858 lines
38 KiB
C++
858 lines
38 KiB
C++
#include "joc_decode.h"
|
|
|
|
#include <windows.h>
|
|
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
#include <vector>
|
|
|
|
// The kernel copy that is compiled into this component; see kernel/.
|
|
#include "../kernel/include/joc_core.h"
|
|
#include "../kernel/include/joc_stream.h"
|
|
|
|
#include "eac3_scan.h"
|
|
#include "log.h"
|
|
|
|
namespace joc_decode {
|
|
namespace {
|
|
|
|
constexpr std::size_t kEac3Chunk = 96u * 1024u; // bytes read per push
|
|
constexpr std::size_t kBedFramesChunk = 8192u; // staging capacity, in frames
|
|
constexpr std::size_t kBedChannels = 6; // ffmpeg -ac 6
|
|
// A read on an anonymous pipe only completes once the whole request is available,
|
|
// so each read asks for a slice ffmpeg can always fill, and the pipe buffer is
|
|
// sized well above that slice. Requesting the whole staging buffer deadlocks:
|
|
// ffmpeg fills the pipe and blocks, while the reader waits for more than the pipe
|
|
// can ever hold.
|
|
constexpr std::size_t kBedReadBytes = 48u * 1024u;
|
|
constexpr std::size_t kBedPipeBytes = 1u << 20;
|
|
constexpr std::size_t kFrameSamples = JOC_FRAME_SAMPLES;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Kernel entry points.
|
|
//
|
|
// The kernel's own C++ sources are part of this component (see kernel/, a copy of
|
|
// the project's source tree), so the public C ABI is linked in directly. There is
|
|
// nothing to load at run time, and no way for the component and the renderer to
|
|
// disagree about which ABI they were built against.
|
|
// ---------------------------------------------------------------------------
|
|
struct CoreApi {
|
|
joc_error(JOC_CALL* create)(const joc_stream_config*, joc_stream**) = joc_stream_create;
|
|
joc_error(JOC_CALL* push)(joc_stream*, const joc_stream_buffer*, std::uint32_t*,
|
|
std::uint32_t*) = joc_stream_push;
|
|
joc_error(JOC_CALL* pull)(joc_stream*, joc_stream_buffer*, std::uint32_t*) = joc_stream_pull;
|
|
joc_error(JOC_CALL* flush)(joc_stream*) = joc_stream_flush;
|
|
joc_error(JOC_CALL* status)(const joc_stream*, joc_stream_status_info*) = joc_stream_status;
|
|
joc_error(JOC_CALL* destroy)(joc_stream*) = joc_stream_destroy;
|
|
std::uint32_t(JOC_CALL* abi_version)() = joc_abi_version;
|
|
const char*(JOC_CALL* version_string)() = joc_version_string;
|
|
const char*(JOC_CALL* error_name)(joc_error) = joc_error_name;
|
|
};
|
|
|
|
std::wstring utf8_to_wide(const std::string& text) {
|
|
if (text.empty()) return {};
|
|
const int needed = MultiByteToWideChar(CP_UTF8, 0, text.c_str(),
|
|
static_cast<int>(text.size()), nullptr, 0);
|
|
std::wstring out(static_cast<std::size_t>(needed), L'\0');
|
|
MultiByteToWideChar(CP_UTF8, 0, text.c_str(), static_cast<int>(text.size()), out.data(),
|
|
needed);
|
|
return out;
|
|
}
|
|
|
|
bool file_exists(const std::string& path) {
|
|
const std::wstring wide = utf8_to_wide(path);
|
|
if (wide.empty()) return false;
|
|
const DWORD attributes = GetFileAttributesW(wide.c_str());
|
|
return attributes != INVALID_FILE_ATTRIBUTES &&
|
|
(attributes & FILE_ATTRIBUTE_DIRECTORY) == 0;
|
|
}
|
|
|
|
// The renderer is inside this binary, so "loading" it is just an ABI check.
|
|
bool load_api(const std::string& explicit_path, CoreApi* api, std::string* error) {
|
|
(void)explicit_path;
|
|
if (api->abi_version() != JOC_ABI_VERSION) {
|
|
if (error != nullptr) *error = "the bundled renderer has an unexpected ABI";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
const char* error_text(const CoreApi& api, joc_error code) {
|
|
if (api.error_name != nullptr) {
|
|
const char* name = api.error_name(code);
|
|
if (name != nullptr) return name;
|
|
}
|
|
return "unknown core error";
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ffmpeg child process producing the 5.1 core PCM on a pipe.
|
|
// ---------------------------------------------------------------------------
|
|
class FfmpegPipe {
|
|
public:
|
|
~FfmpegPipe() { stop(); }
|
|
|
|
// ffmpeg_path, the input file and whatever should follow "-i <input>" are
|
|
// separate: the 5.1 bed and the E-AC-3 metadata stream of a container file are
|
|
// both ffmpeg output, they only differ in those arguments. input_arguments come
|
|
// before -i and carry the decoder options the bed needs.
|
|
bool start(const std::string& ffmpeg_path, const std::string& input_path,
|
|
const std::wstring& input_arguments, const std::wstring& output_arguments,
|
|
const char* label, const std::wstring& stderr_path, std::string* error,
|
|
std::size_t pipe_bytes = kBedPipeBytes) {
|
|
SECURITY_ATTRIBUTES attributes{};
|
|
attributes.nLength = sizeof(attributes);
|
|
attributes.bInheritHandle = TRUE;
|
|
HANDLE read_end = nullptr;
|
|
HANDLE write_end = nullptr;
|
|
if (CreatePipe(&read_end, &write_end, &attributes, static_cast<DWORD>(pipe_bytes)) == FALSE) {
|
|
if (error != nullptr) *error = std::string("cannot create the ") + label + " pipe";
|
|
return false;
|
|
}
|
|
// Only the child's end is inheritable.
|
|
SetHandleInformation(read_end, HANDLE_FLAG_INHERIT, 0);
|
|
|
|
HANDLE null_input = CreateFileW(L"NUL", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
&attributes, OPEN_EXISTING, 0, nullptr);
|
|
HANDLE error_file = CreateFileW(stderr_path.c_str(), GENERIC_WRITE,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, &attributes,
|
|
CREATE_ALWAYS, 0, nullptr);
|
|
|
|
std::wstring command = L"\"" + utf8_to_wide(ffmpeg_path) + L"\"";
|
|
command += L" -hide_banner -loglevel error -nostdin -y ";
|
|
command += input_arguments; // input options must precede -i
|
|
command += L" -i \"";
|
|
command += utf8_to_wide(input_path);
|
|
command += L"\" ";
|
|
command += output_arguments;
|
|
|
|
STARTUPINFOW startup{};
|
|
startup.cb = sizeof(startup);
|
|
startup.dwFlags = STARTF_USESTDHANDLES;
|
|
startup.hStdInput = null_input;
|
|
startup.hStdOutput = write_end;
|
|
startup.hStdError = (error_file != INVALID_HANDLE_VALUE) ? error_file : null_input;
|
|
|
|
PROCESS_INFORMATION process{};
|
|
std::vector<wchar_t> mutable_command(command.begin(), command.end());
|
|
mutable_command.push_back(L'\0');
|
|
const BOOL created = CreateProcessW(nullptr, mutable_command.data(), nullptr, nullptr,
|
|
TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &startup,
|
|
&process);
|
|
CloseHandle(write_end);
|
|
if (null_input != INVALID_HANDLE_VALUE) CloseHandle(null_input);
|
|
if (error_file != INVALID_HANDLE_VALUE) CloseHandle(error_file);
|
|
if (created == FALSE) {
|
|
CloseHandle(read_end);
|
|
if (error != nullptr) *error = std::string("cannot start ffmpeg for the ") + label;
|
|
return false;
|
|
}
|
|
CloseHandle(process.hThread);
|
|
pipe_ = read_end;
|
|
process_ = process.hProcess;
|
|
joc_log::line("core %s: ffmpeg started (pid %lu)", label, process.dwProcessId);
|
|
return true;
|
|
}
|
|
|
|
// Returns bytes read; 0 means end of stream.
|
|
std::size_t read(void* destination, std::size_t bytes) {
|
|
if (pipe_ == nullptr) return 0;
|
|
DWORD got = 0;
|
|
if (ReadFile(pipe_, destination, static_cast<DWORD>(bytes), &got, nullptr) == FALSE) {
|
|
return 0;
|
|
}
|
|
return got;
|
|
}
|
|
|
|
void stop() {
|
|
if (pipe_ != nullptr) {
|
|
CloseHandle(pipe_);
|
|
pipe_ = nullptr;
|
|
}
|
|
if (process_ != nullptr) {
|
|
// ffmpeg is normally gone by now (its stdout was drained); ask it to
|
|
// finish rather than killing it, and only then let go.
|
|
if (WaitForSingleObject(process_, 5000) == WAIT_TIMEOUT) {
|
|
TerminateProcess(process_, 1);
|
|
}
|
|
CloseHandle(process_);
|
|
process_ = nullptr;
|
|
}
|
|
}
|
|
|
|
bool finished() const { return pipe_ == nullptr; }
|
|
|
|
private:
|
|
HANDLE pipe_ = nullptr;
|
|
HANDLE process_ = nullptr;
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Small file reader (wide paths, no CRT locale involved).
|
|
// ---------------------------------------------------------------------------
|
|
class InputFile {
|
|
public:
|
|
~InputFile() { close(); }
|
|
bool open(const std::string& path) {
|
|
handle_ = CreateFileW(utf8_to_wide(path).c_str(), GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
|
|
return handle_ != INVALID_HANDLE_VALUE;
|
|
}
|
|
std::size_t read(void* destination, std::size_t bytes) {
|
|
if (handle_ == INVALID_HANDLE_VALUE) return 0;
|
|
DWORD got = 0;
|
|
if (ReadFile(handle_, destination, static_cast<DWORD>(bytes), &got, nullptr) == FALSE) {
|
|
return 0;
|
|
}
|
|
return got;
|
|
}
|
|
std::uint64_t size() const {
|
|
LARGE_INTEGER value{};
|
|
if (handle_ == INVALID_HANDLE_VALUE || GetFileSizeEx(handle_, &value) == FALSE) return 0;
|
|
return static_cast<std::uint64_t>(value.QuadPart);
|
|
}
|
|
void close() {
|
|
if (handle_ != INVALID_HANDLE_VALUE) {
|
|
CloseHandle(handle_);
|
|
handle_ = INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
private:
|
|
HANDLE handle_ = INVALID_HANDLE_VALUE;
|
|
};
|
|
|
|
const char* const kLayouts[] = {"2.0", "3.0", "3.1", "4.0", "5.0", "5.1", "5.1.2",
|
|
"5.1.4", "6.1", "7.0", "7.1", "7.1.2", "7.1.4", "9.1.4",
|
|
"9.1.6", "22.2"};
|
|
const unsigned kLayoutChannels[] = {2, 3, 4, 4, 5, 6, 8, 10, 7, 7, 8, 10, 12, 14, 16, 24};
|
|
|
|
} // namespace
|
|
|
|
const char* const* speaker_layouts(std::size_t* count) {
|
|
if (count != nullptr) *count = sizeof(kLayouts) / sizeof(kLayouts[0]);
|
|
return kLayouts;
|
|
}
|
|
|
|
unsigned speaker_channels(const std::string& layout) {
|
|
for (std::size_t i = 0; i < sizeof(kLayouts) / sizeof(kLayouts[0]); ++i) {
|
|
if (layout == kLayouts[i]) return kLayoutChannels[i];
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
std::string component_directory() {
|
|
HMODULE self = nullptr;
|
|
if (GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
|
|
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
|
|
reinterpret_cast<LPCWSTR>(&component_directory), &self) == FALSE) {
|
|
return {};
|
|
}
|
|
wchar_t path[4096] = {};
|
|
const DWORD length = GetModuleFileNameW(self, path, 4096);
|
|
if (length == 0) return {};
|
|
const std::wstring text(path, length);
|
|
const std::wstring::size_type slash = text.find_last_of(L"\\/");
|
|
if (slash == std::wstring::npos) return {};
|
|
const std::wstring directory = text.substr(0, slash);
|
|
const int needed = WideCharToMultiByte(CP_UTF8, 0, directory.c_str(),
|
|
static_cast<int>(directory.size()), nullptr, 0,
|
|
nullptr, nullptr);
|
|
std::string out(static_cast<std::size_t>(needed), '\0');
|
|
WideCharToMultiByte(CP_UTF8, 0, directory.c_str(), static_cast<int>(directory.size()),
|
|
out.data(), needed, nullptr, nullptr);
|
|
return out;
|
|
}
|
|
|
|
std::string resolve_hrtf_file(const Settings& settings) {
|
|
if (!settings.hrtf_file.empty()) return settings.hrtf_file;
|
|
const std::string directory = component_directory();
|
|
if (directory.empty()) return {};
|
|
// Same convention as the reference CLI next to its executable:
|
|
// <base>\HRTF\binaural.sofa or <base>\HRTF\binaural.personalized_headphone.
|
|
const char* name = (settings.hrtf_source == HrtfSource::kRosella)
|
|
? "binaural.personalized_headphone"
|
|
: "binaural.sofa";
|
|
return directory + "\\HRTF\\" + name;
|
|
}
|
|
|
|
FileProbe probe_file(const std::string& path, std::size_t max_scan_bytes) {
|
|
FileProbe probe;
|
|
InputFile file;
|
|
if (!file.open(path)) {
|
|
probe.detail = "cannot open";
|
|
return probe;
|
|
}
|
|
const std::uint64_t size = file.size();
|
|
|
|
// A Media Library scan calls this for every file, so the whole stream is
|
|
// walked only when that is cheap; otherwise the first window is enough,
|
|
// because E-AC-3 syncframes in a stream like this are all the same size.
|
|
const std::uint64_t kFullWalkLimit = 16u * 1024u * 1024u;
|
|
const std::size_t window =
|
|
(max_scan_bytes != 0) ? max_scan_bytes : 256u * 1024u;
|
|
std::vector<std::uint8_t> buffer(static_cast<std::size_t>(
|
|
(size < kFullWalkLimit && size > 0) ? size : window));
|
|
const std::size_t got = file.read(buffer.data(), buffer.size());
|
|
if (got < 8) {
|
|
probe.detail = "file too small to be E-AC-3";
|
|
return probe;
|
|
}
|
|
|
|
const joc_eac3::ScanResult scan = joc_eac3::scan(buffer.data(), got, 8);
|
|
probe.readable = true;
|
|
probe.joc = (scan.joc == joc_eac3::JocState::kYes);
|
|
probe.detail = scan.detail;
|
|
if (scan.frames_examined == 0 || scan.first_frame_bytes == 0) {
|
|
probe.detail = "not a bare E-AC-3 stream";
|
|
return probe;
|
|
}
|
|
|
|
std::uint64_t frames = 0;
|
|
if (buffer.size() == size) {
|
|
std::size_t offset = 0;
|
|
while (true) {
|
|
const std::size_t bytes = joc_eac3::frame_bytes_at(buffer.data(), got, offset);
|
|
if (bytes == 0 || offset + bytes > got) break;
|
|
offset += bytes;
|
|
++frames;
|
|
}
|
|
probe.detail = "frame count walked over the whole file";
|
|
} else if (scan.all_frames_same_size) {
|
|
frames = size / scan.first_frame_bytes;
|
|
probe.detail = "frame count extrapolated from a constant frame size";
|
|
} else {
|
|
// Variable frame size: count in the window and scale by the byte ratio.
|
|
std::size_t offset = 0;
|
|
std::uint64_t seen = 0;
|
|
while (true) {
|
|
const std::size_t bytes = joc_eac3::frame_bytes_at(buffer.data(), got, offset);
|
|
if (bytes == 0 || offset + bytes > got) break;
|
|
offset += bytes;
|
|
++seen;
|
|
}
|
|
frames = (offset != 0) ? static_cast<std::uint64_t>(
|
|
(static_cast<double>(size) / static_cast<double>(offset)) *
|
|
static_cast<double>(seen))
|
|
: 0;
|
|
probe.detail = "frame count estimated from a variable frame size";
|
|
}
|
|
|
|
probe.frames = frames;
|
|
probe.sample_rate = 48000;
|
|
probe.channels = 6; // the core audio of an E-AC-3 JOC stream
|
|
probe.duration_seconds =
|
|
static_cast<double>(frames) * static_cast<double>(kFrameSamples) / 48000.0;
|
|
return probe;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// JOC verdict for a container file, without rendering anything.
|
|
// ---------------------------------------------------------------------------
|
|
bool probe_container_joc(const std::string& ffmpeg_path, const std::string& path,
|
|
unsigned audio_index, bool* joc, std::string* detail) {
|
|
struct Entry {
|
|
std::string path;
|
|
unsigned audio_index = 0;
|
|
std::uint64_t size = 0;
|
|
std::uint64_t modified = 0;
|
|
bool joc = false;
|
|
std::string detail;
|
|
};
|
|
static std::vector<Entry> cache;
|
|
|
|
std::uint64_t size = 0;
|
|
std::uint64_t modified = 0;
|
|
{
|
|
WIN32_FILE_ATTRIBUTE_DATA data{};
|
|
if (GetFileAttributesExW(utf8_to_wide(path).c_str(), GetFileExInfoStandard, &data) !=
|
|
FALSE) {
|
|
size = (static_cast<std::uint64_t>(data.nFileSizeHigh) << 32) | data.nFileSizeLow;
|
|
modified = (static_cast<std::uint64_t>(data.ftLastWriteTime.dwHighDateTime) << 32) |
|
|
data.ftLastWriteTime.dwLowDateTime;
|
|
}
|
|
}
|
|
for (const Entry& entry : cache) {
|
|
if (entry.path == path && entry.audio_index == audio_index && entry.size == size &&
|
|
entry.modified == modified) {
|
|
if (joc != nullptr) *joc = entry.joc;
|
|
if (detail != nullptr) *detail = entry.detail;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (ffmpeg_path.empty()) {
|
|
if (detail != nullptr) *detail = "no ffmpeg configured";
|
|
return false;
|
|
}
|
|
|
|
FfmpegPipe pipe;
|
|
std::string error;
|
|
std::wstring arguments = L"-map 0:a:";
|
|
arguments += std::to_wstring(audio_index);
|
|
arguments += L" -vn -t 3 -c:a copy -f eac3 -";
|
|
const std::wstring stderr_path = [] {
|
|
wchar_t temp[MAX_PATH + 1] = {};
|
|
const DWORD length = GetTempPathW(MAX_PATH, temp);
|
|
return length == 0 ? std::wstring(L"NUL")
|
|
: std::wstring(temp) + L"joc_container_probe.log";
|
|
}();
|
|
if (!pipe.start(ffmpeg_path, path, L"", arguments, "probe", stderr_path, &error, 1u << 20)) {
|
|
if (detail != nullptr) *detail = error;
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::uint8_t> prefix(512u * 1024u);
|
|
std::size_t filled = 0;
|
|
while (filled < prefix.size()) {
|
|
const std::size_t got = pipe.read(prefix.data() + filled, prefix.size() - filled);
|
|
if (got == 0) break;
|
|
filled += got;
|
|
}
|
|
pipe.stop();
|
|
|
|
const joc_eac3::ScanResult scan = joc_eac3::scan(prefix.data(), filled, 8);
|
|
const bool carries_joc = (scan.joc == joc_eac3::JocState::kYes);
|
|
|
|
Entry entry;
|
|
entry.path = path;
|
|
entry.audio_index = audio_index;
|
|
entry.size = size;
|
|
entry.modified = modified;
|
|
entry.joc = carries_joc;
|
|
entry.detail = scan.detail;
|
|
if (cache.size() >= 8) cache.erase(cache.begin());
|
|
cache.push_back(entry);
|
|
|
|
joc_log::line("container: %s track %u -> %s (%s)", path.c_str(), audio_index,
|
|
carries_joc ? "JOC" : "not JOC", scan.detail);
|
|
if (joc != nullptr) *joc = carries_joc;
|
|
if (detail != nullptr) *detail = scan.detail;
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Engine
|
|
// ---------------------------------------------------------------------------
|
|
struct Engine::Impl {
|
|
CoreApi api;
|
|
joc_stream* stream = nullptr;
|
|
InputFile eac3; // bare E-AC-3 input: read straight from the file
|
|
FfmpegPipe eac3_pipe; // E-AC-3 inside a container: ffmpeg extracts the stream
|
|
bool eac3_from_pipe = false;
|
|
FfmpegPipe bed;
|
|
Settings settings;
|
|
|
|
// The metadata stream comes either from the file itself or from ffmpeg.
|
|
std::size_t read_eac3(void* destination, std::size_t bytes) {
|
|
return eac3_from_pipe ? eac3_pipe.read(destination, bytes)
|
|
: eac3.read(destination, bytes);
|
|
}
|
|
|
|
unsigned channels = 0;
|
|
std::uint64_t frames_queued = 0; // E-AC-3 frames handed to the core
|
|
std::uint64_t bed_frames_pushed = 0;
|
|
bool eac3_eof = false;
|
|
bool bed_eof = false;
|
|
bool flushed = false;
|
|
unsigned trace_count = 0;
|
|
unsigned read_calls = 0;
|
|
std::size_t eac3_carry = 0; // trailing partial syncframe, for exact counting
|
|
std::uint64_t bed_bytes_read = 0;
|
|
std::vector<std::uint8_t> eac3_buffer;
|
|
std::vector<float> bed_buffer;
|
|
std::size_t bed_staged_bytes = 0; // bytes staged at the front of bed_buffer
|
|
std::vector<float> pull_buffer;
|
|
};
|
|
|
|
Engine::Engine() : impl_(new Impl()) {}
|
|
|
|
Engine::~Engine() {
|
|
stop();
|
|
delete impl_;
|
|
}
|
|
|
|
unsigned Engine::channels() const { return impl_->channels; }
|
|
|
|
void Engine::stop() {
|
|
Impl& impl = *impl_;
|
|
if (impl.stream != nullptr && impl.api.destroy != nullptr) {
|
|
impl.api.destroy(impl.stream);
|
|
impl.stream = nullptr;
|
|
}
|
|
impl.bed.stop();
|
|
impl.eac3_pipe.stop();
|
|
impl.eac3.close();
|
|
impl.eac3_from_pipe = false;
|
|
}
|
|
|
|
bool Engine::start(const std::string& input_path, const Settings& settings, std::string* error) {
|
|
Impl& impl = *impl_;
|
|
impl.settings = settings;
|
|
impl.eac3_buffer.resize(kEac3Chunk);
|
|
impl.bed_buffer.resize(kBedFramesChunk * kBedChannels);
|
|
|
|
if (!load_api(std::string(), &impl.api, error)) return false;
|
|
const std::uint32_t abi = impl.api.abi_version();
|
|
const char* version = impl.api.version_string != nullptr ? impl.api.version_string() : "?";
|
|
joc_log::line("core: in-process renderer %s (abi %u), component built against abi %u",
|
|
version, abi, static_cast<unsigned>(JOC_ABI_VERSION));
|
|
if (abi != JOC_ABI_VERSION) {
|
|
joc_log::line("core: ABI mismatch; refusing to continue");
|
|
if (error != nullptr) *error = "the bundled renderer ABI does not match the component";
|
|
return false;
|
|
}
|
|
|
|
// Metadata stream: a bare E-AC-3 file is read directly, while the E-AC-3 track
|
|
// of a container is extracted by ffmpeg (stream copy, so the syncframes reach
|
|
// the renderer exactly as stored).
|
|
impl.eac3_from_pipe = (settings.input_kind == InputKind::kContainer);
|
|
if (!impl.eac3_from_pipe) {
|
|
if (!impl.eac3.open(input_path)) {
|
|
if (error != nullptr) *error = "cannot open the input file";
|
|
return false;
|
|
}
|
|
}
|
|
|
|
joc_stream_config config{};
|
|
config.struct_size = sizeof(config);
|
|
config.struct_version = 1;
|
|
config.input = JOC_STREAM_IN_EAC3;
|
|
config.output = (settings.output == Output::kBinaural) ? JOC_STREAM_OUT_BINAURAL
|
|
: JOC_STREAM_OUT_SPEAKER;
|
|
config.speaker_layout_name = settings.speaker_layout.c_str();
|
|
config.speaker_metadata_offset = 0;
|
|
config.binaural_mode = settings.binaural_mode;
|
|
// The filter bank tables live in the library (hrtf::builtin_kernels in
|
|
// kernel_tables.cpp), so there is no table path to configure and none is
|
|
// passed: the field stays null. The same goes for the compiled-HRTF cache:
|
|
// it is the renderer's internal business, not a user choice.
|
|
config.kernels_path = nullptr;
|
|
config.hrtf_path = nullptr;
|
|
// Only binaural output reads an HRTF at all: a speaker layout must not be
|
|
// blocked by a missing HRTF file, and must not have to name one.
|
|
std::string hrtf_in_use;
|
|
if (settings.output == Output::kBinaural) {
|
|
hrtf_in_use = resolve_hrtf_file(settings);
|
|
const std::string& hrtf_file = hrtf_in_use;
|
|
if (hrtf_file.empty()) {
|
|
if (error != nullptr) {
|
|
*error = "双耳渲染需要 HRTF 文件，但组件目录无法确定；请在设置页里显式指定路径";
|
|
}
|
|
return false;
|
|
}
|
|
if (!file_exists(hrtf_file)) {
|
|
if (error != nullptr) {
|
|
*error = std::string("找不到 HRTF 文件：") + hrtf_file +
|
|
(settings.hrtf_file.empty() ? "（默认位置，可在设置页里指定其它路径）"
|
|
: "");
|
|
}
|
|
return false;
|
|
}
|
|
if (settings.hrtf_source == HrtfSource::kRosella) {
|
|
config.personalized_headphone_path = hrtf_file.c_str();
|
|
} else {
|
|
config.hrtf_sofa_path = hrtf_file.c_str();
|
|
}
|
|
}
|
|
config.hrtf_cache_policy = settings.hrtf_cache_policy;
|
|
config.hrtf_cache_dir =
|
|
settings.hrtf_cache_dir.empty() ? nullptr : settings.hrtf_cache_dir.c_str();
|
|
config.hrtf_radius_m = settings.hrtf_radius_m;
|
|
config.binaural_tail_seconds = settings.tail_seconds;
|
|
config.object_delay_samples = settings.object_delay_samples;
|
|
config.gain_db = settings.gain_db;
|
|
config.native_threads = settings.native_threads;
|
|
|
|
const joc_error created = impl.api.create(&config, &impl.stream);
|
|
if (created != JOC_OK) {
|
|
if (error != nullptr) {
|
|
*error = std::string("cannot create the render stream: ") +
|
|
error_text(impl.api, created);
|
|
}
|
|
return false;
|
|
}
|
|
joc_stream_status_info status{};
|
|
status.struct_size = sizeof(status);
|
|
status.struct_version = 1;
|
|
if (impl.api.status(impl.stream, &status) == JOC_OK && status.output_channels != 0u) {
|
|
impl.channels = status.output_channels;
|
|
} else {
|
|
impl.channels = (settings.output == Output::kBinaural)
|
|
? 2u
|
|
: speaker_channels(settings.speaker_layout);
|
|
}
|
|
joc_log::line("core: stream created, %u output channel(s), layout=%s, hrtf=%s", impl.channels,
|
|
settings.speaker_layout.c_str(),
|
|
hrtf_in_use.empty() ? "(none)" : hrtf_in_use.c_str());
|
|
|
|
// ffmpeg's stderr lands next to the component rather than in whatever working
|
|
// directory the host process happens to have. The two children write separate
|
|
// files so neither can truncate the other's diagnostics.
|
|
const auto stderr_path_for = [](const wchar_t* name) {
|
|
HMODULE self = nullptr;
|
|
GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
|
|
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
|
|
reinterpret_cast<LPCWSTR>(&speaker_channels), &self);
|
|
wchar_t path[4096] = {};
|
|
const DWORD length = GetModuleFileNameW(self, path, 4096);
|
|
if (length == 0) return std::wstring(name);
|
|
const std::wstring text(path, length);
|
|
const std::wstring::size_type slash = text.find_last_of(L"\\/");
|
|
return slash == std::wstring::npos ? std::wstring(name)
|
|
: text.substr(0, slash) + L"\\" + name;
|
|
};
|
|
|
|
// The 5.1 core PCM, exactly as the reference renderer's own core decode does it:
|
|
// 5.1 interleaved float32 at 48 kHz, the layout the renderer expects
|
|
// (L R C LFE Ls Rs).
|
|
// -drc_scale 0 -target_level 0: the bed is taken as stored, without the stream's
|
|
// dynrng or target-level metadata being applied by the decoder.
|
|
std::wstring bed_arguments = L"-map 0:a:";
|
|
bed_arguments += std::to_wstring(settings.audio_index);
|
|
bed_arguments += L" -vn -ac 6 -ar 48000 -c:a pcm_f32le -f f32le -";
|
|
if (!impl.bed.start(settings.ffmpeg_path, input_path, L"-drc_scale 0 -target_level 0", bed_arguments, "bed",
|
|
stderr_path_for(L"joc_ffmpeg_bed.log"), error)) {
|
|
return false;
|
|
}
|
|
|
|
if (impl.eac3_from_pipe) {
|
|
// Stream copy: the syncframes arrive byte for byte as they are stored, which
|
|
// is what the JOC metadata needs.
|
|
std::wstring stream_arguments = L"-map 0:a:";
|
|
stream_arguments += std::to_wstring(settings.audio_index);
|
|
stream_arguments += L" -vn -c:a copy -f eac3 -";
|
|
if (!impl.eac3_pipe.start(settings.ffmpeg_path, input_path, L"", stream_arguments, "metadata",
|
|
stderr_path_for(L"joc_ffmpeg_stream.log"), error,
|
|
1u << 20)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::size_t Engine::read(float* destination, std::size_t frames, std::string* error) {
|
|
Impl& impl = *impl_;
|
|
if (impl.stream == nullptr || frames == 0) return 0;
|
|
const bool trace = impl.trace_count < 6;
|
|
++impl.read_calls;
|
|
if ((impl.read_calls % 50u) == 0u) {
|
|
joc_log::line("engine: call %u queued=%llu bed=%llu staged_bytes=%llu eac3_eof=%d bed_eof=%d flushed=%d",
|
|
impl.read_calls, static_cast<unsigned long long>(impl.frames_queued),
|
|
static_cast<unsigned long long>(impl.bed_frames_pushed),
|
|
static_cast<unsigned long long>(impl.bed_staged_bytes), impl.eac3_eof ? 1 : 0,
|
|
impl.bed_eof ? 1 : 0, impl.flushed ? 1 : 0);
|
|
}
|
|
|
|
for (;;) {
|
|
if (trace) {
|
|
joc_log::line("engine: loop eac3_eof=%d bed_eof=%d queued=%llu bed=%llu staged_bytes=%llu",
|
|
impl.eac3_eof ? 1 : 0, impl.bed_eof ? 1 : 0,
|
|
static_cast<unsigned long long>(impl.frames_queued),
|
|
static_cast<unsigned long long>(impl.bed_frames_pushed),
|
|
static_cast<unsigned long long>(impl.bed_staged_bytes));
|
|
}
|
|
// Feed the metadata stream, keeping it only a little ahead of the bed so
|
|
// the core's pairing queue stays small.
|
|
// A test-side input limit has to look like end of file, or the loop below
|
|
// never reaches its terminal state.
|
|
if (impl.settings.input_frame_limit != 0 &&
|
|
impl.frames_queued >= impl.settings.input_frame_limit) {
|
|
impl.eac3_eof = true;
|
|
}
|
|
|
|
if (!impl.eac3_eof && impl.frames_queued <= impl.bed_frames_pushed + 2u &&
|
|
(impl.settings.input_frame_limit == 0 ||
|
|
impl.frames_queued < impl.settings.input_frame_limit)) {
|
|
// The tail of a chunk is usually the head of the next syncframe. It
|
|
// stays at the front of the buffer so the frame count stays exact
|
|
// across chunk boundaries: counting each chunk on its own loses one
|
|
// frame at the end, which leaves the bed a frame short and the last
|
|
// frame of the file unrendered.
|
|
const std::size_t got = impl.read_eac3(impl.eac3_buffer.data() + impl.eac3_carry,
|
|
impl.eac3_buffer.size() - impl.eac3_carry);
|
|
const std::size_t total = impl.eac3_carry + got;
|
|
if (total == 0) {
|
|
impl.eac3_eof = true;
|
|
} else {
|
|
std::size_t offset = 0;
|
|
std::uint64_t complete = 0;
|
|
while (true) {
|
|
const std::size_t bytes =
|
|
joc_eac3::frame_bytes_at(impl.eac3_buffer.data(), total, offset);
|
|
if (bytes == 0 || offset + bytes > total) break;
|
|
offset += bytes;
|
|
++complete;
|
|
}
|
|
// With an input limit the chunk is cut at a frame boundary: the
|
|
// renderer's output depends on how many frames it was given, so a
|
|
// limit that overshoots to the end of the read buffer would not
|
|
// reproduce a run that stopped earlier.
|
|
std::size_t push_bytes = offset;
|
|
std::uint64_t pushed_frames = complete;
|
|
if (impl.settings.input_frame_limit != 0) {
|
|
const std::uint64_t room =
|
|
impl.settings.input_frame_limit - impl.frames_queued;
|
|
if (complete > room) {
|
|
pushed_frames = room;
|
|
std::size_t walk = 0;
|
|
for (std::uint64_t index = 0; index < pushed_frames; ++index) {
|
|
const std::size_t bytes = joc_eac3::frame_bytes_at(
|
|
impl.eac3_buffer.data(), total, walk);
|
|
if (bytes == 0 || walk + bytes > total) break;
|
|
walk += bytes;
|
|
}
|
|
push_bytes = walk;
|
|
}
|
|
}
|
|
joc_stream_buffer input{};
|
|
input.struct_size = sizeof(input);
|
|
input.struct_version = 1;
|
|
input.kind = JOC_STREAM_IN_EAC3;
|
|
input.bytes = impl.eac3_buffer.data();
|
|
input.byte_count = static_cast<std::uint32_t>(push_bytes);
|
|
const joc_error pushed = impl.api.push(impl.stream, &input, nullptr, nullptr);
|
|
if (pushed != JOC_OK) {
|
|
if (error != nullptr) {
|
|
*error = std::string("E-AC-3 push failed: ") +
|
|
error_text(impl.api, pushed);
|
|
}
|
|
return 0;
|
|
}
|
|
impl.frames_queued += pushed_frames;
|
|
impl.eac3_carry = total - push_bytes;
|
|
if (impl.eac3_carry != 0 && push_bytes != 0) {
|
|
std::memmove(impl.eac3_buffer.data(), impl.eac3_buffer.data() + push_bytes,
|
|
impl.eac3_carry);
|
|
}
|
|
if (got == 0) impl.eac3_eof = true;
|
|
}
|
|
}
|
|
|
|
// Feed the core PCM until the bed has caught up with the metadata. The
|
|
// core pairs one syncframe with exactly 1536 bed samples, so only whole
|
|
// frames are pushed; whatever is left over stays at the front of the
|
|
// staging buffer. Staging counted in bytes, not samples: a pipe read may
|
|
// return any number of bytes, and rounding a read down to whole samples
|
|
// quietly drops the rest of the stream's alignment.
|
|
while (!impl.bed_eof && impl.bed_frames_pushed < impl.frames_queued) {
|
|
constexpr std::size_t kFrameBytes = kFrameSamples * kBedChannels * sizeof(float);
|
|
const std::size_t whole_frames = impl.bed_staged_bytes / kFrameBytes;
|
|
if (whole_frames != 0) {
|
|
joc_stream_buffer input{};
|
|
input.struct_size = sizeof(input);
|
|
input.struct_version = 1;
|
|
input.kind = JOC_STREAM_IN_CORE_PCM;
|
|
input.pcm = impl.bed_buffer.data();
|
|
input.channels = static_cast<std::uint32_t>(kBedChannels);
|
|
input.sample_rate = 48000;
|
|
input.sample_count = static_cast<std::uint32_t>(whole_frames * kFrameSamples);
|
|
const joc_error pushed = impl.api.push(impl.stream, &input, nullptr, nullptr);
|
|
if (pushed != JOC_OK) {
|
|
if (error != nullptr) {
|
|
*error = std::string("core PCM push failed: ") +
|
|
error_text(impl.api, pushed);
|
|
}
|
|
return 0;
|
|
}
|
|
impl.bed_frames_pushed += whole_frames;
|
|
const std::size_t pushed_bytes = whole_frames * kFrameBytes;
|
|
impl.bed_staged_bytes -= pushed_bytes;
|
|
if (impl.bed_staged_bytes != 0) {
|
|
std::memmove(impl.bed_buffer.data(),
|
|
reinterpret_cast<const std::uint8_t*>(impl.bed_buffer.data()) +
|
|
pushed_bytes,
|
|
impl.bed_staged_bytes);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Less than one whole frame staged: read more.
|
|
const std::size_t capacity_bytes = impl.bed_buffer.size() * sizeof(float);
|
|
const std::size_t room = capacity_bytes - impl.bed_staged_bytes;
|
|
const std::size_t want =
|
|
(room < kBedReadBytes) ? room : kBedReadBytes;
|
|
if (want == 0) break; // cannot happen while capacity exceeds a frame
|
|
const std::size_t bytes = impl.bed.read(
|
|
reinterpret_cast<std::uint8_t*>(impl.bed_buffer.data()) + impl.bed_staged_bytes,
|
|
want);
|
|
if (bytes == 0) {
|
|
impl.bed_eof = true;
|
|
break;
|
|
}
|
|
impl.bed_bytes_read += bytes;
|
|
impl.bed_staged_bytes += bytes;
|
|
}
|
|
|
|
// Take whatever the renderer has.
|
|
joc_stream_buffer output{};
|
|
output.struct_size = sizeof(output);
|
|
output.struct_version = 1;
|
|
output.kind = (impl.settings.output == Output::kBinaural) ? JOC_STREAM_OUT_BINAURAL
|
|
: JOC_STREAM_OUT_SPEAKER;
|
|
output.channels = impl.channels;
|
|
output.sample_rate = 48000;
|
|
output.sample_count = static_cast<std::uint32_t>(frames);
|
|
output.out_pcm = destination;
|
|
std::uint32_t produced = 0;
|
|
const joc_error pulled = impl.api.pull(impl.stream, &output, &produced);
|
|
if (pulled != JOC_OK) {
|
|
if (error != nullptr) {
|
|
*error = std::string("pull failed: ") + error_text(impl.api, pulled);
|
|
}
|
|
return 0;
|
|
}
|
|
if (produced != 0u) {
|
|
if (trace) {
|
|
++impl.trace_count;
|
|
joc_log::line("engine: pulled %u frame(s) on the %u%s attempt", produced,
|
|
impl.trace_count, impl.trace_count == 1 ? "st" : "th");
|
|
}
|
|
return produced;
|
|
}
|
|
|
|
// Nothing more can arrive once the metadata stream is drained and the bed
|
|
// has caught up with it. The bed process is normally stopped as a
|
|
// consequence of that catch-up rather than by reaching its own end, so
|
|
// waiting for bed_eof here would spin forever.
|
|
const bool no_more_input =
|
|
impl.eac3_eof &&
|
|
(impl.bed_eof || impl.bed_frames_pushed >= impl.frames_queued);
|
|
if (no_more_input) {
|
|
if (!impl.flushed) {
|
|
const joc_error flushed = impl.api.flush(impl.stream);
|
|
if (flushed != JOC_OK) {
|
|
if (error != nullptr) {
|
|
*error = std::string("flush failed: ") + error_text(impl.api, flushed);
|
|
}
|
|
return 0;
|
|
}
|
|
impl.flushed = true;
|
|
joc_stream_status_info status{};
|
|
status.struct_size = sizeof(status);
|
|
status.struct_version = 1;
|
|
if (impl.api.status(impl.stream, &status) == JOC_OK) {
|
|
joc_log::line(
|
|
"core: exhausted (eac3 frames queued=%llu, bed frames pushed=%llu); "
|
|
"core counters frames_in=%llu frames_out=%llu samples_out=%llu "
|
|
"buffered=%llu",
|
|
static_cast<unsigned long long>(impl.frames_queued),
|
|
static_cast<unsigned long long>(impl.bed_frames_pushed),
|
|
static_cast<unsigned long long>(status.frames_in),
|
|
static_cast<unsigned long long>(status.frames_out),
|
|
static_cast<unsigned long long>(status.samples_out),
|
|
static_cast<unsigned long long>(status.buffered_samples));
|
|
joc_log::line("core: bed bytes read=%llu, staged samples left=%llu",
|
|
static_cast<unsigned long long>(impl.bed_bytes_read),
|
|
static_cast<unsigned long long>(impl.bed_staged_bytes));
|
|
}
|
|
continue; // drain the tail
|
|
}
|
|
return 0; // genuinely done
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace joc_decode
|