Experimental C++ version of InputSource and company

Sources/CSFBAudioEngine/Input/BufferInput.cpp

@@ -0,0 +1,47 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#import <algorithm>
+#import <cstdio>
+#import <cstdlib>
+
+#import "BufferInput.hpp"
+
+SFB::BufferInput::BufferInput(const void *buf, int64_t len, BufferAdoption behavior)
+: buf_{const_cast<void *>(buf)}, free_{behavior == BufferAdoption::copy || behavior == BufferAdoption::noCopyAndFree}, len_{len}
+{
+	if(!buf || len < 0) {
+		os_log_error(sLog, "Cannot create BufferInput with null buffer or negative length");
+		throw std::invalid_argument("Null buffer or negative length");
+	}
+
+	if(behavior == BufferAdoption::copy) {
+		buf_ = std::malloc(len_);
+		if(!buf_)
+			throw std::bad_alloc();
+		std::memcpy(buf_, buf, len_);
+	}
+}
+
+SFB::BufferInput::~BufferInput() noexcept
+{
+	if(free_)
+		std::free(buf_);
+}
+
+int64_t SFB::BufferInput::_Read(void *buffer, int64_t count)
+{
+	const auto remaining = len_ - pos_;
+	count = std::min(count, remaining);
+	memcpy(buffer, reinterpret_cast<const void *>(reinterpret_cast<uintptr_t>(buf_) + pos_), count);
+	pos_ += count;
+	return count;
+}
+
+CFStringRef SFB::BufferInput::_CopyDescription() const noexcept
+{
+	return CFStringCreateWithFormat(kCFAllocatorDefault, nullptr, CFSTR("<BufferInput %p: %lld bytes at %p>"), this, len_, buf_);
+}

Sources/CSFBAudioEngine/Input/BufferInput.hpp

@@ -0,0 +1,54 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#pragma once
+
+#import "InputSource.hpp"
+
+namespace SFB {
+
+class BufferInput: public InputSource
+{
+public:
+	/// Buffer adoption behaviors.
+	enum class BufferAdoption { copy, noCopy, noCopyAndFree };
+	BufferInput(const void * _Nonnull buf, int64_t len, BufferAdoption behavior = BufferAdoption::copy);
+	~BufferInput() noexcept;
+
+	// This class is non-copyable.
+	BufferInput(const BufferInput&) = delete;
+	BufferInput(BufferInput&&) = delete;
+
+	// This class is non-assignable.
+	BufferInput& operator=(const BufferInput&) = delete;
+	BufferInput& operator=(BufferInput&&) = delete;
+
+protected:
+	explicit BufferInput() noexcept = default;
+
+	/// The data buffer.
+	void * _Nonnull buf_ {nullptr};
+	/// Whether the buffer should be freed in the destructor.
+	bool free_ {false};
+	/// The length of the buffer in bytes.
+	int64_t len_ {0};
+	/// The current byte position in the buffer.
+	int64_t pos_ {0};
+
+private:
+	void _Open() override 								{ pos_ = 0; }
+	void _Close() override 								{}
+	bool _AtEOF() const noexcept override  				{ return len_ == pos_; }
+	int64_t _Position() const noexcept override 		{ return pos_; }
+	int64_t _Length() const noexcept override 			{ return len_; }
+	bool _SupportsSeeking() const noexcept override 	{ return true; }
+	void _SeekToPosition(int64_t position) override 	{ pos_ = position; }
+
+	int64_t _Read(void * _Nonnull buffer, int64_t count) override;
+	CFStringRef _Nonnull _CopyDescription() const noexcept override;
+};
+
+} /* namespace SFB */

Sources/CSFBAudioEngine/Input/DataInput.cpp

@@ -0,0 +1,43 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#import <algorithm>
+#import <limits>
+
+#import "DataInput.hpp"
+
+SFB::DataInput::DataInput(CFDataRef data)
+{
+	if(!data) {
+		os_log_error(sLog, "Cannot create DataInput with null data");
+		throw std::invalid_argument("Null data");
+	}
+	data_ = static_cast<CFDataRef>(CFRetain(data));
+}
+
+SFB::DataInput::~DataInput() noexcept
+{
+	CFRelease(data_);
+}
+
+int64_t SFB::DataInput::_Read(void *buffer, int64_t count)
+{
+	if(count > std::numeric_limits<CFIndex>::max()) {
+		os_log_error(sLog, "_Read() called on <DataInput: %p> with count greater than maximum allowable value", this);
+		throw std::invalid_argument("Count greater than maximum allowable value");
+	}
+	const int64_t remaining = CFDataGetLength(data_) - pos_;
+	count = std::min(count, remaining);
+	const auto range = CFRangeMake(pos_, count);
+	CFDataGetBytes(data_, range, static_cast<UInt8 *>(buffer));
+	pos_ += count;
+	return count;
+}
+
+CFStringRef SFB::DataInput::_CopyDescription() const noexcept
+{
+	return CFStringCreateWithFormat(kCFAllocatorDefault, nullptr, CFSTR("<DataInput %p: %@>"), this, data_);
+}

Sources/CSFBAudioEngine/Input/DataInput.hpp

@@ -0,0 +1,43 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#pragma once
+
+#import "InputSource.hpp"
+
+namespace SFB {
+
+class DataInput: public InputSource
+{
+public:
+	explicit DataInput(CFDataRef _Nonnull data);
+	~DataInput() noexcept;
+
+	// This class is non-copyable.
+	DataInput(const DataInput&) = delete;
+	DataInput(DataInput&&) = delete;
+
+	// This class is non-assignable.
+	DataInput& operator=(const DataInput&) = delete;
+	DataInput& operator=(DataInput&&) = delete;
+
+private:
+	void _Open() noexcept override 						{ pos_ = 0; }
+	void _Close() noexcept override 					{}
+	bool _AtEOF() const noexcept override 				{ return CFDataGetLength(data_) == pos_; }
+	int64_t _Position() const noexcept override 		{ return pos_; }
+	int64_t _Length() const noexcept override 			{ return CFDataGetLength(data_); }
+	bool _SupportsSeeking() const noexcept override 	{ return true; }
+	void _SeekToPosition(int64_t position) override 	{ pos_ = position; }
+
+	int64_t _Read(void * _Nonnull buffer, int64_t count) override;
+	CFStringRef _Nonnull _CopyDescription() const noexcept override;
+
+	CFDataRef _Nonnull data_ {nullptr};
+	CFIndex pos_ {0};
+};
+
+} /* namespace SFB */

Sources/CSFBAudioEngine/Input/FileContentsInput.cpp

@@ -0,0 +1,69 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#import <algorithm>
+#import <cstdio>
+#import <system_error>
+
+#import <sys/stat.h>
+
+#import "FileContentsInput.hpp"
+#import "scope_exit.hpp"
+
+SFB::FileContentsInput::FileContentsInput(CFURLRef url)
+{
+	if(!url) {
+		os_log_error(sLog, "Cannot create FileContentsInput with null URL");
+		throw std::invalid_argument("Null URL");
+	}
+	url_ = static_cast<CFURLRef>(CFRetain(url));
+	free_ = true;
+}
+
+void SFB::FileContentsInput::_Open()
+{
+	UInt8 path [PATH_MAX];
+	auto success = CFURLGetFileSystemRepresentation(url_, FALSE, path, PATH_MAX);
+	if(!success)
+		throw std::runtime_error("Unable to get URL file system representation");
+
+	auto file = std::fopen(reinterpret_cast<const char *>(path), "r");
+	if(!file)
+		throw std::system_error{errno, std::generic_category()};
+
+	// Ensure the file is closed
+	const auto guard = scope_exit{[&file]() noexcept { std::fclose(file); }};
+
+	auto fd = ::fileno(file);
+
+	struct stat s;
+	if(::fstat(fd, &s))
+		throw std::system_error{errno, std::generic_category()};
+
+	buf_ = std::malloc(s.st_size);
+	if(!buf_)
+		throw std::bad_alloc();
+
+	const auto nitems = std::fread(buf_, 1, s.st_size, file);
+	if(nitems != s.st_size && std::ferror(file))
+		throw std::system_error{errno, std::generic_category()};
+
+	len_ = nitems;
+	pos_ = 0;
+}
+
+void SFB::FileContentsInput::_Close() noexcept
+{
+	std::free(buf_);
+	buf_ = nullptr;
+}
+
+CFStringRef SFB::FileContentsInput::_CopyDescription() const noexcept
+{
+	CFStringRef lastPathComponent = CFURLCopyLastPathComponent(url_);
+	const auto guard = scope_exit{[&lastPathComponent]() noexcept { CFRelease(lastPathComponent); }};
+	return CFStringCreateWithFormat(kCFAllocatorDefault, nullptr, CFSTR("<FileContentsInput %p: %lld bytes copied to %p from \"%@\">"), this, len_, buf_, lastPathComponent);
+}

Sources/CSFBAudioEngine/Input/FileContentsInput.hpp

@@ -0,0 +1,33 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#pragma once
+
+#import "BufferInput.hpp"
+
+namespace SFB {
+
+class FileContentsInput: public BufferInput
+{
+public:
+	explicit FileContentsInput(CFURLRef _Nonnull url);
+	~FileContentsInput() noexcept = default;
+
+	// This class is non-copyable.
+	FileContentsInput(const FileContentsInput&) = delete;
+	FileContentsInput(FileContentsInput&&) = delete;
+
+	// This class is non-assignable.
+	FileContentsInput& operator=(const FileContentsInput&) = delete;
+	FileContentsInput& operator=(FileContentsInput&&) = delete;
+
+private:
+	void _Open() override;
+	void _Close() noexcept override;
+	CFStringRef _Nonnull _CopyDescription() const noexcept override;
+};
+
+} /* namespace SFB */

Sources/CSFBAudioEngine/Input/FileInput.cpp

@@ -0,0 +1,84 @@
+//
+// Copyright (c) 2010-2025 Stephen F. Booth <me@sbooth.org>
+// Part of https://github.com/sbooth/SFBAudioEngine
+// MIT license
+//
+
+#import <sys/stat.h>
+
+#import "FileInput.hpp"
+#import "scope_exit.hpp"
+
+SFB::FileInput::FileInput(CFURLRef url)
+{
+	if(!url) {
+		os_log_error(sLog, "Cannot create FileInput with null URL");
+		throw std::invalid_argument("Null URL");
+	}
+	url_ = static_cast<CFURLRef>(CFRetain(url));
+}
+
+SFB::FileInput::~FileInput() noexcept
+{
+	if(file_)
+		std::fclose(file_);
+}
+
+void SFB::FileInput::_Open()
+{
+	UInt8 path [PATH_MAX];
+	auto success = CFURLGetFileSystemRepresentation(url_, FALSE, path, PATH_MAX);
+	if(!success)
+		throw std::runtime_error("Unable to get URL file system representation");
+
+	file_ = std::fopen(reinterpret_cast<const char *>(path), "r");
+	if(!file_)
+		throw std::system_error{errno, std::generic_category()};
+
+	struct stat s;
+	if(::fstat(::fileno(file_), &s)) {
+		std::fclose(file_);
+		file_ = nullptr;
+		throw std::system_error{errno, std::generic_category()};
+	}
+
+	len_ = s.st_size;
+
+	// Regular files are always seekable
+	if(S_ISREG(s.st_mode))
+		seekable_ = true;
+	else if(const auto offset = ::ftello(file_); offset != -1) {
+		if(::fseeko(file_, offset, SEEK_SET) == 0)
+			seekable_ = true;
+	}
+}
+
+void SFB::FileInput::_Close()
+{
+	const auto defer = scope_exit{[this]() noexcept { file_ = nullptr; }};
+	if(std::fclose(file_))
+		throw std::system_error{errno, std::generic_category()};
+}
+
+int64_t SFB::FileInput::_Read(void *buffer, int64_t count)
+{
+	const auto nitems = std::fread(buffer, 1, count, file_);
+	if(nitems != count && std::ferror(file_))
+		throw std::system_error{errno, std::generic_category()};
+	return nitems;
+}
+
+int64_t SFB::FileInput::_Position() const
+{
+	const auto offset = ::ftello(file_);
+	if(offset == -1)
+		throw std::system_error{errno, std::generic_category()};
+	return offset;
+}
+
+CFStringRef SFB::FileInput::_CopyDescription() const noexcept
+{
+	CFStringRef lastPathComponent = CFURLCopyLastPathComponent(url_);
+	const auto guard = scope_exit{[&lastPathComponent]() noexcept { CFRelease(lastPathComponent); }};
+	return CFStringCreateWithFormat(kCFAllocatorDefault, nullptr, CFSTR("<FileInput %p: \"%@\">"), this, lastPathComponent);
+}