diff --git a/src/xenia/apu/xma_context.h b/src/xenia/apu/xma_context.h index d7dfa39c8..3be7062eb 100644 --- a/src/xenia/apu/xma_context.h +++ b/src/xenia/apu/xma_context.h @@ -166,8 +166,13 @@ static_assert_size(Xma2ExtraData, 34); class XmaContext { public: static constexpr uint32_t kBytesPerPacket = 2048; + static constexpr uint32_t kBytesPerPacketHeader = 4; + static constexpr uint32_t kBytesPerPacketData = + kBytesPerPacket - kBytesPerPacketHeader; + static constexpr uint32_t kBitsPerPacket = kBytesPerPacket * 8; static constexpr uint32_t kBitsPerHeader = 32; + static constexpr uint32_t kBitsPerFrameHeader = 15; static constexpr uint32_t kBytesPerSample = 2; static constexpr uint32_t kSamplesPerFrame = 512; @@ -177,8 +182,10 @@ class XmaContext { static constexpr uint32_t kBytesPerSubframeChannel = kSamplesPerSubframe * kBytesPerSample; - // static const uint32_t kOutputBytesPerBlock = 256; - // static const uint32_t kOutputMaxSizeBytes = 31 * kOutputBytesPerBlock; + static constexpr uint32_t kOutputBytesPerBlock = 256; + static constexpr uint32_t kOutputMaxSizeBytes = 31 * kOutputBytesPerBlock; + + static constexpr uint32_t kLastFrameMarker = 0x7FFF; explicit XmaContext(); virtual ~XmaContext(); diff --git a/src/xenia/apu/xma_context_fake.cc b/src/xenia/apu/xma_context_fake.cc new file mode 100644 index 000000000..c77f471d0 --- /dev/null +++ b/src/xenia/apu/xma_context_fake.cc @@ -0,0 +1,302 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2025 Xenia Canary. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#include "xenia/apu/xma_context_fake.h" +#include "xenia/apu/xma_helpers.h" + +#include "xenia/base/logging.h" +#include "xenia/base/platform.h" +#include "xenia/base/profiling.h" + +namespace xe { +namespace apu { + +static constexpr int kIdToSampleRate[4] = {24000, 32000, 44100, 48000}; + +XmaContextFake::XmaContextFake() = default; + +XmaContextFake::~XmaContextFake() = default; + +int XmaContextFake::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) { + id_ = id; + memory_ = memory; + guest_ptr_ = guest_ptr; + + // Initialize fake frame to silence + fake_frame_.fill(0); + + XELOGI("XmaContextFake {}: Setup complete", id); + return 0; +} + +RingBuffer XmaContextFake::PrepareOutputRingBuffer(XMA_CONTEXT_DATA* data) { + const uint32_t output_capacity = + data->output_buffer_block_count * kOutputBytesPerBlock; + const uint32_t output_read_offset = + data->output_buffer_read_offset * kOutputBytesPerBlock; + const uint32_t output_write_offset = + data->output_buffer_write_offset * kOutputBytesPerBlock; + + if (output_capacity > kOutputMaxSizeBytes) { + XELOGW( + "XmaContextFake {}: Output buffer uses more space than expected! " + "(Actual: {} Max: {})", + id(), output_capacity, kOutputMaxSizeBytes); + } + + uint8_t* output_buffer = memory()->TranslatePhysical(data->output_buffer_ptr); + + // Output buffers are in raw PCM samples, 256 bytes per block. + // Output buffer is a ring buffer. We need to write from the write offset + // to the read offset. + RingBuffer output_rb(output_buffer, output_capacity); + output_rb.set_read_offset(output_read_offset); + output_rb.set_write_offset(output_write_offset); + remaining_subframe_blocks_in_output_buffer_ = + (int32_t)output_rb.write_count() / kOutputBytesPerBlock; + + return output_rb; +} + +bool XmaContextFake::Work() { + if (!is_enabled() || !is_allocated()) { + return false; + } + + std::lock_guard lock(lock_); + set_is_enabled(false); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + + if (!data.output_buffer_valid) { + return true; + } + + RingBuffer output_rb = PrepareOutputRingBuffer(&data); + + const int32_t minimum_subframe_decode_count = + (data.subframe_decode_count * 2) - 1; + + // We don't have enough space to even make one pass + if (minimum_subframe_decode_count > + remaining_subframe_blocks_in_output_buffer_) { + XELOGD("XmaContextFake {}: No space for subframe decoding {}/{}!", id(), + minimum_subframe_decode_count, + remaining_subframe_blocks_in_output_buffer_); + data.Store(context_ptr); + return true; + } + + while (remaining_subframe_blocks_in_output_buffer_ >= + minimum_subframe_decode_count) { + XELOGAPU("XmaContextFake {}: Processing context (buffer {} {}/{} bits)", + id(), data.current_buffer, data.input_buffer_read_offset, + data.GetCurrentInputBufferPacketCount() * kBitsPerPacket); + + ProcessPacket(&data); + Consume(&output_rb, &data); + + if (!data.IsAnyInputBufferValid() || data.error_status == 4) { + break; + } + } + + data.output_buffer_write_offset = + output_rb.write_offset() / kOutputBytesPerBlock; + + XELOGAPU("XmaContextFake {}: Read Output: {} Write Output: {}", id(), + data.output_buffer_read_offset, data.output_buffer_write_offset); + + // That's a bit misleading due to nature of ringbuffer + // when write and read offset matches it might mean that we wrote nothing + // or we fully saturated allocated space. + if (output_rb.empty()) { + data.output_buffer_valid = 0; + } + + data.Store(context_ptr); + return true; +} + +void XmaContextFake::Enable() { + std::lock_guard lock(lock_); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + + XELOGAPU("XmaContextFake: kicking context {} (buffer {} {}/{} bits)", id(), + data.current_buffer, data.input_buffer_read_offset, + data.GetCurrentInputBufferPacketCount() * kBitsPerPacket); + + data.Store(context_ptr); + set_is_enabled(true); +} + +bool XmaContextFake::Block(bool poll) { + if (!lock_.try_lock()) { + if (poll) { + return false; + } + lock_.lock(); + } + lock_.unlock(); + return true; +} + +void XmaContextFake::Clear() { + std::lock_guard lock(lock_); + XELOGAPU("XmaContextFake: reset context {}", id()); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + + data.input_buffer_0_valid = 0; + data.input_buffer_1_valid = 0; + data.output_buffer_valid = 0; + + data.input_buffer_read_offset = 0; + data.output_buffer_read_offset = 0; + data.output_buffer_write_offset = 0; + data.input_buffer_read_offset = kBitsPerPacketHeader; + + current_frame_remaining_subframes_ = 0; + data.Store(context_ptr); +} + +void XmaContextFake::Disable() { + std::lock_guard lock(lock_); + XELOGAPU("XmaContextFake: disabling context {}", id()); + set_is_enabled(false); +} + +void XmaContextFake::Release() { + // Lock it in case the decoder thread is working on it now. + std::lock_guard lock(lock_); + assert_true(is_allocated_ == true); + + set_is_allocated(false); + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + std::memset(context_ptr, 0, sizeof(XMA_CONTEXT_DATA)); // Zero it. +} + +int XmaContextFake::GetSampleRate(int id) { + return kIdToSampleRate[std::min(id, 3)]; +} + +void XmaContextFake::SwapInputBuffer(XMA_CONTEXT_DATA* data) { + // No more frames. + if (data->current_buffer == 0) { + data->input_buffer_0_valid = 0; + } else { + data->input_buffer_1_valid = 0; + } + data->current_buffer ^= 1; + data->input_buffer_read_offset = kBitsPerPacketHeader; +} + +void XmaContextFake::Consume(RingBuffer* output_rb, XMA_CONTEXT_DATA* data) { + if (!current_frame_remaining_subframes_) { + return; + } + + const int8_t subframes_to_write = + std::min((int8_t)current_frame_remaining_subframes_, + (int8_t)data->subframe_decode_count); + + const int8_t raw_frame_read_offset = + ((kBytesPerFrameChannel / kOutputBytesPerBlock) << data->is_stereo) - + current_frame_remaining_subframes_; + + output_rb->Write( + fake_frame_.data() + (kOutputBytesPerBlock * raw_frame_read_offset), + subframes_to_write * kOutputBytesPerBlock); + remaining_subframe_blocks_in_output_buffer_ -= subframes_to_write; + current_frame_remaining_subframes_ -= subframes_to_write; + + XELOGAPU("XmaContextFake {}: Consume: {} - {} - {} - {} - {}", id(), + remaining_subframe_blocks_in_output_buffer_, + data->output_buffer_write_offset, data->output_buffer_read_offset, + output_rb->write_offset(), current_frame_remaining_subframes_); +} + +void XmaContextFake::ProcessPacket(XMA_CONTEXT_DATA* data) { + // No available data. + if (!data->IsAnyInputBufferValid()) { + return; + } + + if (current_frame_remaining_subframes_ > 0) { + return; + } + + UpdateLoopStatus(data); + + const uint32_t current_input_size = GetCurrentInputBufferSize(data); + const uint32_t current_packet_index = + data->input_buffer_read_offset / kBitsPerPacket; + + // if we've processed all packets in current buffer, switch to next + if (current_packet_index >= current_input_size / kBytesPerPacket) { + SwapInputBuffer(data); + return; + } + + // just move to next packet + const uint32_t next_packet_index = current_packet_index + 1; + if (next_packet_index >= current_input_size / kBytesPerPacket) { + SwapInputBuffer(data); + } else { + // Advance to next packet in current buffer + data->input_buffer_read_offset = + next_packet_index * kBitsPerPacket + kBitsPerPacketHeader; + } + + // fixed subframe count + current_frame_remaining_subframes_ = 4 << data->is_stereo; + + XELOGAPU( + "XmaContextFake {}: Processed packet {}, set up {} subframes for " + "consumption", + id(), current_packet_index, current_frame_remaining_subframes_); +} + +void XmaContextFake::UpdateLoopStatus(XMA_CONTEXT_DATA* data) { + if (data->loop_count == 0) { + return; + } + + const uint32_t loop_start = std::max(kBitsPerPacketHeader, data->loop_start); + const uint32_t loop_end = std::max(kBitsPerPacketHeader, data->loop_end); + + XELOGAPU("XmaContextFake {}: Looped Data: {} < {} (Start: {}) Remaining: {}", + id(), data->input_buffer_read_offset, data->loop_end, + data->loop_start, data->loop_count); + + if (data->input_buffer_read_offset != loop_end) { + return; + } + + data->input_buffer_read_offset = loop_start; + + if (data->loop_count != 255) { + data->loop_count--; + } +} + +uint32_t XmaContextFake::GetCurrentInputBufferSize(XMA_CONTEXT_DATA* data) { + return data->GetCurrentInputBufferPacketCount() * kBytesPerPacket; +} + +uint8_t* XmaContextFake::GetCurrentInputBuffer(XMA_CONTEXT_DATA* data) { + return memory()->TranslatePhysical(data->GetCurrentInputBufferAddress()); +} + +} // namespace apu +} // namespace xe diff --git a/src/xenia/apu/xma_context_fake.h b/src/xenia/apu/xma_context_fake.h new file mode 100644 index 000000000..edf167e6e --- /dev/null +++ b/src/xenia/apu/xma_context_fake.h @@ -0,0 +1,66 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2025 Xenia Canary. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#ifndef XENIA_APU_XMA_CONTEXT_FAKE_H_ +#define XENIA_APU_XMA_CONTEXT_FAKE_H_ + +#include +#include +#include +#include + +#include "xenia/apu/xma_context.h" +#include "xenia/base/bit_stream.h" +#include "xenia/base/ring_buffer.h" +#include "xenia/memory.h" +#include "xenia/xbox.h" + +namespace xe { +namespace apu { + +class XmaContextFake : public XmaContext { + public: + static constexpr uint32_t kBitsPerPacketHeader = 32; + static constexpr uint32_t kMaxFrameSizeinBits = 0x4000 - kBitsPerPacketHeader; + + explicit XmaContextFake(); + ~XmaContextFake() override; + + int Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) override; + bool Work() override; + + void Enable() override; + bool Block(bool poll) override; + void Clear() override; + void Disable() override; + void Release() override; + + private: + void ProcessPacket(XMA_CONTEXT_DATA* data); + void Consume(RingBuffer* output_rb, XMA_CONTEXT_DATA* data); + void UpdateLoopStatus(XMA_CONTEXT_DATA* data); + RingBuffer PrepareOutputRingBuffer(XMA_CONTEXT_DATA* data); + + static void SwapInputBuffer(XMA_CONTEXT_DATA* data); + static int GetSampleRate(int id); + uint8_t* GetCurrentInputBuffer(XMA_CONTEXT_DATA* data); + static uint32_t GetCurrentInputBufferSize(XMA_CONTEXT_DATA* data); + + // Fake frame data - generate silence + std::array fake_frame_; + + // Minimal state tracking + int32_t remaining_subframe_blocks_in_output_buffer_ = 0; + uint8_t current_frame_remaining_subframes_ = 0; +}; + +} // namespace apu +} // namespace xe + +#endif // XENIA_APU_XMA_CONTEXT_FAKE_H_ diff --git a/src/xenia/apu/xma_context_master.cc b/src/xenia/apu/xma_context_master.cc new file mode 100644 index 000000000..f6e179100 --- /dev/null +++ b/src/xenia/apu/xma_context_master.cc @@ -0,0 +1,846 @@ +/** +****************************************************************************** +* Xenia : Xbox 360 Emulator Research Project * +****************************************************************************** +* Copyright 2024 Ben Vanik. All rights reserved. * +* Released under the BSD license - see LICENSE in the root for more details. * +****************************************************************************** +*/ + +#include "xenia/apu/xma_context_master.h" + +#include + +#include "xenia/apu/xma_decoder.h" +#include "xenia/apu/xma_helpers.h" +#include "xenia/base/bit_stream.h" +#include "xenia/base/logging.h" +#include "xenia/base/platform.h" +#include "xenia/base/profiling.h" +#include "xenia/base/ring_buffer.h" + +extern "C" { +#if XE_COMPILER_MSVC +#pragma warning(push) +#pragma warning(disable : 4101 4244 5033) +#endif +#include "third_party/FFmpeg/libavcodec/avcodec.h" +#if XE_COMPILER_MSVC +#pragma warning(pop) +#endif +} // extern "C" + +// Credits for most of this code goes to: +// https://github.com/koolkdev/libertyv/blob/master/libav_wrapper/xma2dec.c + +namespace xe { +namespace apu { + +XmaContextMaster::XmaContextMaster() = default; + +XmaContextMaster::~XmaContextMaster() { + if (av_context_) { + if (avcodec_is_open(av_context_)) { + avcodec_close(av_context_); + } + av_free(av_context_); + } + if (av_frame_) { + av_frame_free(&av_frame_); + } + // if (current_frame_) { + // delete[] current_frame_; + // } +} + +int XmaContextMaster::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) { + id_ = id; + memory_ = memory; + guest_ptr_ = guest_ptr; + + // Allocate ffmpeg stuff: + av_packet_ = av_packet_alloc(); + assert_not_null(av_packet_); + // chrispy: preallocate this buffer so that ffmpeg isn't reallocating it for + // every packet, these allocations were causing RtlSubsegmentInitialize + av_packet_->buf = av_buffer_alloc(128 * 1024); + // find the XMA2 audio decoder + av_codec_ = avcodec_find_decoder(AV_CODEC_ID_XMAFRAMES); + if (!av_codec_) { + XELOGE("XmaContext {}: Codec not found", id); + return 1; + } + + av_context_ = avcodec_alloc_context3(av_codec_); + if (!av_context_) { + XELOGE("XmaContext {}: Couldn't allocate context", id); + return 1; + } + + // Initialize these to 0. They'll actually be set later. + av_context_->channels = 0; + av_context_->sample_rate = 0; + + av_frame_ = av_frame_alloc(); + if (!av_frame_) { + XELOGE("XmaContext {}: Couldn't allocate frame", id); + return 1; + } + + // FYI: We're purposely not opening the codec here. That is done later. + return 0; +} + +bool XmaContextMaster::Work() { + std::lock_guard lock(lock_); + if (!is_allocated() || !is_enabled()) { + return false; + } + + set_is_enabled(false); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + Decode(&data); + data.Store(context_ptr); + return true; +} + +void XmaContextMaster::Enable() { + std::lock_guard lock(lock_); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + + XELOGAPU("XmaContext: kicking context {} (buffer {} {}/{} bits)", id(), + data.current_buffer, data.input_buffer_read_offset, + (data.current_buffer == 0 ? data.input_buffer_0_packet_count + : data.input_buffer_1_packet_count) * + kBitsPerPacket); + + data.Store(context_ptr); + + set_is_enabled(true); +} + +bool XmaContextMaster::Block(bool poll) { + if (!lock_.try_lock()) { + if (poll) { + return false; + } + lock_.lock(); + } + lock_.unlock(); + return true; +} + +void XmaContextMaster::Clear() { + std::lock_guard lock(lock_); + XELOGAPU("XmaContext: reset context {}", id()); + + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + + data.input_buffer_0_valid = 0; + data.input_buffer_1_valid = 0; + data.output_buffer_valid = 0; + + data.output_buffer_read_offset = 0; + data.output_buffer_write_offset = 0; + + data.Store(context_ptr); +} + +void XmaContextMaster::Disable() { + std::lock_guard lock(lock_); + XELOGAPU("XmaContext: disabling context {}", id()); + set_is_enabled(false); +} + +void XmaContextMaster::Release() { + // Lock it in case the decoder thread is working on it now. + std::lock_guard lock(lock_); + assert_true(is_allocated_ == true); + + set_is_allocated(false); + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + std::memset(context_ptr, 0, sizeof(XMA_CONTEXT_DATA)); // Zero it. +} + +void XmaContextMaster::SwapInputBuffer(XMA_CONTEXT_DATA* data) { + // No more frames. + if (data->current_buffer == 0) { + data->input_buffer_0_valid = 0; + } else { + data->input_buffer_1_valid = 0; + } + data->current_buffer ^= 1; + data->input_buffer_read_offset = 0; +} + +bool XmaContextMaster::TrySetupNextLoop(XMA_CONTEXT_DATA* data, + bool ignore_input_buffer_offset) { + // Setup the input buffer offset if next loop exists. + // TODO(Pseudo-Kernel): Need to handle loop in the following cases. + // 1. loop_start == loop_end == 0 + // 2. loop_start > loop_end && loop_count > 0 + if (data->loop_count > 0 && data->loop_start < data->loop_end && + (ignore_input_buffer_offset || + data->input_buffer_read_offset >= data->loop_end)) { + // Loop back to the beginning. + data->input_buffer_read_offset = data->loop_start; + if (data->loop_count < 255) { + data->loop_count--; + } + return true; + } + return false; +} + +/* +void XmaContext::NextPacket( + uint8_t* input_buffer, + uint32_t input_size, + uint32_t input_buffer_read_offset) { +*/ +void XmaContextMaster::NextPacket(XMA_CONTEXT_DATA* data) { + // auto packet_idx = GetFramePacketNumber(input_buffer, input_size, + // input_buffer_read_offset); + + // packet_idx++; + // if (packet_idx++ >= input_size) +} + +int XmaContextMaster::GetSampleRate(int id) { + switch (id) { + case 0: + return 24000; + case 1: + return 32000; + case 2: + return 44100; + case 3: + return 48000; + } + assert_always(); + return 0; +} + +bool XmaContextMaster::ValidFrameOffset(uint8_t* block, size_t size_bytes, + size_t frame_offset_bits) { + uint32_t packet_num = + GetFramePacketNumber(block, size_bytes, frame_offset_bits); + if (packet_num == -1) { + // Invalid packet number + return false; + } + + uint8_t* packet = block + (packet_num * kBytesPerPacket); + size_t relative_offset_bits = frame_offset_bits % kBitsPerPacket; + + uint32_t first_frame_offset = xma::GetPacketFrameOffset(packet); + if (first_frame_offset == -1 || first_frame_offset > kBitsPerPacket) { + // Packet only contains a partial frame, so no frames can start here. + return false; + } + + BitStream stream(packet, kBitsPerPacket); + stream.SetOffset(first_frame_offset); + while (true) { + if (stream.offset_bits() == relative_offset_bits) { + return true; + } + + if (stream.BitsRemaining() < 15) { + // Not enough room for another frame header. + return false; + } + + uint64_t size = stream.Read(15); + if ((size - 15) > stream.BitsRemaining()) { + // Last frame. + return false; + } else if (size == 0x7FFF) { + // Invalid frame (and last of this packet) + return false; + } + + stream.Advance(size - 16); + + // Read the trailing bit to see if frames follow + if (stream.Read(1) == 0) { + break; + } + } + + return false; +} + +void XmaContextMaster::Decode(XMA_CONTEXT_DATA* data) { + SCOPE_profile_cpu_f("apu"); + + // What I see: + // XMA outputs 2 bytes per sample + // 512 samples per frame (128 per subframe) + // Max output size is data.output_buffer_block_count * 256 + + // This decoder is fed packets (max 4095 per buffer) + // Packets contain "some" frames + // 32bit header (big endian) + + // Frames are the smallest thing the SPUs can decode. + // They can and usually will span packets. + + // Sample rates (data.sample_rate): + // 0 - 24 kHz + // 1 - 32 kHz + // 2 - 44.1 kHz + // 3 - 48 kHz + + // SPUs also support stereo decoding. (data.is_stereo) + + // Check the output buffer - we cannot decode anything else if it's + // unavailable. + if (!data->output_buffer_valid) { + return; + } + + // No available data. + if (!data->input_buffer_0_valid && !data->input_buffer_1_valid) { + data->output_buffer_valid = 0; + return; + } + + // XAudio Loops + // loop_count: + // - XAUDIO2_MAX_LOOP_COUNT = 254 + // - XAUDIO2_LOOP_INFINITE = 255 + // loop_start/loop_end are bit offsets to a specific frame + + // Translate pointers for future use. + // Sometimes the game will use rolling input buffers. If they do, we cannot + // assume they form a complete block! In addition, the buffers DO NOT have + // to be contiguous! + uint8_t* in0 = data->input_buffer_0_valid + ? memory()->TranslatePhysical(data->input_buffer_0_ptr) + : nullptr; + uint8_t* in1 = data->input_buffer_1_valid + ? memory()->TranslatePhysical(data->input_buffer_1_ptr) + : nullptr; + uint8_t* current_input_buffer = data->current_buffer ? in1 : in0; + + // XELOGAPU("Processing context {} (offset {}, buffer {}, ptr {:p})", id(), + // data->input_buffer_read_offset, data->current_buffer, + // current_input_buffer); + + size_t input_buffer_0_size = + data->input_buffer_0_packet_count * kBytesPerPacket; + size_t input_buffer_1_size = + data->input_buffer_1_packet_count * kBytesPerPacket; + size_t input_total_size = input_buffer_0_size + input_buffer_1_size; + + size_t current_input_size = + data->current_buffer ? input_buffer_1_size : input_buffer_0_size; + size_t current_input_packet_count = current_input_size / kBytesPerPacket; + + // Output buffers are in raw PCM samples, 256 bytes per block. + // Output buffer is a ring buffer. We need to write from the write offset + // to the read offset. + uint8_t* output_buffer = memory()->TranslatePhysical(data->output_buffer_ptr); + uint32_t output_capacity = + data->output_buffer_block_count * kBytesPerSubframeChannel; + uint32_t output_read_offset = + data->output_buffer_read_offset * kBytesPerSubframeChannel; + uint32_t output_write_offset = + data->output_buffer_write_offset * kBytesPerSubframeChannel; + + RingBuffer output_rb(output_buffer, output_capacity); + output_rb.set_read_offset(output_read_offset); + output_rb.set_write_offset(output_write_offset); + + // We can only decode an entire frame and write it out at a time, so + // don't save any samples. + // TODO(JoelLinn): subframes when looping + size_t output_remaining_bytes = output_rb.write_count(); + output_remaining_bytes -= + output_remaining_bytes % (kBytesPerFrameChannel << data->is_stereo); + + // is_dirty_ = true; // TODO + // is_dirty_ = false; // TODO + assert_false(data->stop_when_done); + assert_false(data->interrupt_when_done); + static int total_samples = 0; + bool reuse_input_buffer = false; + // Decode until we can't write any more data. + while (output_remaining_bytes > 0) { + if (!data->input_buffer_0_valid && !data->input_buffer_1_valid) { + // Out of data. + break; + } + + // Setup the input buffer if we are at loop_end. + // The input buffer must not be swapped out until all loops are processed. + reuse_input_buffer = TrySetupNextLoop(data, false); + + // assert_true(packets_skip_ == 0); + // assert_true(split_frame_len_ == 0); + // assert_true(split_frame_len_partial_ == 0); + + // Where are we in the buffer (in XMA jargon) + int packet_idx, frame_idx, frame_count; + uint8_t* packet; + bool frame_last_split; + + BitStream stream(current_input_buffer, current_input_size * 8); + stream.SetOffset(data->input_buffer_read_offset); + + // if we had a buffer swap try to skip packets first + if (packets_skip_ > 0) { + packet_idx = + GetFramePacketNumber(current_input_buffer, current_input_size, + data->input_buffer_read_offset); + while (packets_skip_ > 0) { + packets_skip_--; + packet_idx++; + if (packet_idx >= current_input_packet_count) { + if (!reuse_input_buffer) { + // Last packet. Try setup once more. + reuse_input_buffer = TrySetupNextLoop(data, true); + } + if (!reuse_input_buffer) { + SwapInputBuffer(data); + } + return; + } + } + // invalid frame pointer but needed for us + data->input_buffer_read_offset = packet_idx * kBitsPerPacket; + // continue; + } + + if (split_frame_len_) { + // handle a frame that was split over two packages + packet_idx = + GetFramePacketNumber(current_input_buffer, current_input_size, + data->input_buffer_read_offset); + packet = current_input_buffer + packet_idx * kBytesPerPacket; + std::tie(frame_count, frame_last_split) = GetPacketFrameCount(packet); + frame_idx = -1; + + stream = + BitStream(current_input_buffer, (packet_idx + 1) * kBitsPerPacket); + stream.SetOffset(packet_idx * kBitsPerPacket + 32); + + if (split_frame_len_ > xma::kMaxFrameLength) { + // TODO write CopyPeekMethod + auto offset = stream.offset_bits(); + stream.Copy( + xma_frame_.data() + 1 + + ((split_frame_len_partial_ + split_frame_padding_start_) / 8), + 15 - split_frame_len_partial_); + stream.SetOffset(offset); + BitStream slen(xma_frame_.data() + 1, 15 + split_frame_padding_start_); + slen.Advance(split_frame_padding_start_); + split_frame_len_ = static_cast(slen.Read(15)); + } + + if (frame_count > 0) { + assert_true(xma::GetPacketFrameOffset(packet) - 32 == + split_frame_len_ - split_frame_len_partial_); + } + + auto offset = stream.Copy( + xma_frame_.data() + 1 + + ((split_frame_len_partial_ + split_frame_padding_start_) / 8), + split_frame_len_ - split_frame_len_partial_); + assert_true(offset == + (split_frame_padding_start_ + split_frame_len_partial_) % 8); + } else { + if (data->input_buffer_read_offset % kBitsPerPacket == 0) { + // Invalid offset. Go ahead and set it. + int packet_number = + GetFramePacketNumber(current_input_buffer, current_input_size, + data->input_buffer_read_offset); + + if (packet_number == -1) { + return; + } + + auto offset = + xma::GetPacketFrameOffset(current_input_buffer + + kBytesPerPacket * packet_number) + + data->input_buffer_read_offset; + if (offset == -1) { + // No more frames. + SwapInputBuffer(data); + // TODO partial frames? end? + XELOGE("XmaContext {}: TODO partial frames? end?", id()); + assert_always("TODO"); + return; + } else { + data->input_buffer_read_offset = offset; + } + } + + if (!ValidFrameOffset(current_input_buffer, current_input_size, + data->input_buffer_read_offset)) { + XELOGAPU("XmaContext {}: Invalid read offset {}!", id(), + data->input_buffer_read_offset); + SwapInputBuffer(data); + return; + } + + // Where are we in the buffer (in XMA jargon) + std::tie(packet_idx, frame_idx) = + GetFrameNumber(current_input_buffer, current_input_size, + data->input_buffer_read_offset); + // TODO handle + assert_true(packet_idx >= 0); + assert_true(frame_idx >= 0); + packet = current_input_buffer + packet_idx * kBytesPerPacket; + // frames that belong to this packet + std::tie(frame_count, frame_last_split) = GetPacketFrameCount(packet); + assert_true(frame_count >= 0); // TODO end + + PrepareDecoder(packet, data->sample_rate, bool(data->is_stereo)); + + // Current frame is split to next packet: + bool frame_is_split = frame_last_split && (frame_idx >= frame_count - 1); + + stream = + BitStream(current_input_buffer, (packet_idx + 1) * kBitsPerPacket); + stream.SetOffset(data->input_buffer_read_offset); + // int frame_len; + // int frame_len_partial + split_frame_len_partial_ = static_cast(stream.BitsRemaining()); + if (split_frame_len_partial_ >= 15) { + split_frame_len_ = static_cast(stream.Peek(15)); + } else { + // assert_always(); + split_frame_len_ = xma::kMaxFrameLength + 1; + } + assert_true(frame_is_split == + (split_frame_len_ > split_frame_len_partial_)); + + // TODO fix bitstream copy + std::memset(xma_frame_.data(), 0, xma_frame_.size()); + + { + auto offset = + stream.Copy(xma_frame_.data() + 1, + std::min(split_frame_len_, split_frame_len_partial_)); + assert_true(offset < 8); + split_frame_padding_start_ = static_cast(offset); + } + + if (frame_is_split) { + // go to next xma packet of this stream + packets_skip_ = xma::GetPacketSkipCount(packet) + 1; + while (packets_skip_ > 0) { + packets_skip_--; + packet += kBytesPerPacket; + packet_idx++; + if (packet_idx >= current_input_packet_count) { + if (!reuse_input_buffer) { + // Last packet. Try setup once more. + reuse_input_buffer = TrySetupNextLoop(data, true); + } + if (!reuse_input_buffer) { + SwapInputBuffer(data); + } + return; + } + } + // TODO guest might read this: + data->input_buffer_read_offset = packet_idx * kBitsPerPacket; + continue; + } + } + + av_packet_->data = xma_frame_.data(); + av_packet_->size = static_cast( + 1 + ((split_frame_padding_start_ + split_frame_len_) / 8) + + (((split_frame_padding_start_ + split_frame_len_) % 8) ? 1 : 0)); + + auto padding_end = av_packet_->size * 8 - + (8 + split_frame_padding_start_ + split_frame_len_); + assert_true(padding_end < 8); + xma_frame_[0] = + ((split_frame_padding_start_ & 7) << 5) | ((padding_end & 7) << 2); + + split_frame_len_ = 0; + split_frame_len_partial_ = 0; + split_frame_padding_start_ = 0; + + auto ret = avcodec_send_packet(av_context_, av_packet_); + if (ret < 0) { + XELOGE("XmaContext {}: Error sending packet for decoding", id()); + // TODO bail out + assert_always(); + } + ret = avcodec_receive_frame(av_context_, av_frame_); + /* + if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) + // TODO AVERROR_EOF??? + break; + else + */ + if (ret < 0) { + XELOGE("XmaContext {}: Error during decoding", id()); + assert_always(); + return; // TODO bail out + } + assert_true(ret == 0); + + { + // copy over 1 frame + // update input buffer read offset + + // assert(decoded_consumed_samples_ + kSamplesPerFrame <= + // current_frame_.size()); + assert_true(av_context_->sample_fmt == AV_SAMPLE_FMT_FLTP); + // assert_true(frame_is_split == (frame_idx == -1)); + + // dump_raw(av_frame_, id()); + ConvertFrame((const uint8_t**)av_frame_->data, bool(data->is_stereo), + raw_frame_.data()); + // decoded_consumed_samples_ += kSamplesPerFrame; + + auto byte_count = kBytesPerFrameChannel << data->is_stereo; + assert_true(output_remaining_bytes >= byte_count); + output_rb.Write(raw_frame_.data(), byte_count); + output_remaining_bytes -= byte_count; + data->output_buffer_write_offset = output_rb.write_offset() / 256; + + total_samples += id_ == 0 ? kSamplesPerFrame : 0; + + uint32_t offset = data->input_buffer_read_offset; + // if (offset % (kBytesPerSample * 8) == 0) { + // offset = xma::GetPacketFrameOffset(packet); + //} + offset = static_cast( + GetNextFrame(current_input_buffer, current_input_size, offset)); + // assert_true((offset == 0) == + // (frame_is_split || (frame_idx + 1 >= frame_count))); + if (frame_idx + 1 >= frame_count) { + // Skip to next packet (no split frame) + packets_skip_ = xma::GetPacketSkipCount(packet) + 1; + while (packets_skip_ > 0) { + packets_skip_--; + packet_idx++; + if (packet_idx >= current_input_packet_count) { + if (!reuse_input_buffer) { + // Last packet. Try setup once more. + reuse_input_buffer = TrySetupNextLoop(data, true); + } + if (!reuse_input_buffer) { + SwapInputBuffer(data); + } + return; + } + } + packet = current_input_buffer + packet_idx * kBytesPerPacket; + offset = + xma::GetPacketFrameOffset(packet) + packet_idx * kBitsPerPacket; + } + if (offset == 0 || frame_idx == -1) { + // Next packet but we already skipped to it + if (packet_idx >= current_input_packet_count) { + // Buffer is fully used + if (!reuse_input_buffer) { + // Last packet. Try setup once more. + reuse_input_buffer = TrySetupNextLoop(data, true); + } + if (!reuse_input_buffer) { + SwapInputBuffer(data); + } + break; + } + offset = + xma::GetPacketFrameOffset(packet) + packet_idx * kBitsPerPacket; + } + // TODO buffer bounds check + assert_true(data->input_buffer_read_offset < offset); + data->input_buffer_read_offset = offset; + } + } + + // assert_true((split_frame_len_ != 0) == (data->input_buffer_read_offset == + // 0)); + + // The game will kick us again with a new output buffer later. + // It's important that we only invalidate this if we actually wrote to it!! + if (output_rb.write_offset() == output_rb.read_offset()) { + data->output_buffer_valid = 0; + } +} + +size_t XmaContextMaster::GetNextFrame(uint8_t* block, size_t size, + size_t bit_offset) { + // offset = xma::GetPacketFrameOffset(packet); + // TODO meh + // auto next_packet = bit_offset - bit_offset % kBitsPerPacket + + // kBitsPerPacket; + auto packet_idx = GetFramePacketNumber(block, size, bit_offset); + + BitStream stream(block, size * 8); + stream.SetOffset(bit_offset); + + if (stream.BitsRemaining() < 15) { + return 0; + } + + uint64_t len = stream.Read(15); + if ((len - 15) > stream.BitsRemaining()) { + // assert_always("TODO"); + // *bit_offset = next_packet; + // return false; + // return next_packet; + return 0; + } else if (len >= xma::kMaxFrameLength) { + // assert_always("TODO"); + // *bit_offset = next_packet; + // return false; + return 0; + // return next_packet; + } + + stream.Advance(len - (15 + 1)); + // Read the trailing bit to see if frames follow + if (stream.Read(1) == 0) { + return 0; + } + + bit_offset += len; + if (packet_idx < GetFramePacketNumber(block, size, bit_offset)) { + return 0; + } + return bit_offset; +} + +int XmaContextMaster::GetFramePacketNumber(uint8_t* block, size_t size, + size_t bit_offset) { + size *= 8; + if (bit_offset >= size) { + // Not good :( + assert_always(); + return -1; + } + + size_t byte_offset = bit_offset >> 3; + size_t packet_number = byte_offset / kBytesPerPacket; + + return (uint32_t)packet_number; +} + +std::tuple XmaContextMaster::GetFrameNumber(uint8_t* block, + size_t size, + size_t bit_offset) { + auto packet_idx = GetFramePacketNumber(block, size, bit_offset); + + if (packet_idx < 0 || (packet_idx + 1) * kBytesPerPacket > size) { + assert_always(); + return {packet_idx, -2}; + } + + if (bit_offset == 0) { + return {packet_idx, -1}; + } + + uint8_t* packet = block + (packet_idx * kBytesPerPacket); + auto first_frame_offset = xma::GetPacketFrameOffset(packet); + BitStream stream(block, size * 8); + stream.SetOffset(packet_idx * kBitsPerPacket + first_frame_offset); + + int frame_idx = 0; + while (true) { + if (stream.BitsRemaining() < 15) { + break; + } + + if (stream.offset_bits() == bit_offset) { + break; + } + + uint64_t size = stream.Read(15); + if ((size - 15) > stream.BitsRemaining()) { + // Last frame. + break; + } else if (size == 0x7FFF) { + // Invalid frame (and last of this packet) + break; + } + + stream.Advance(size - (15 + 1)); + + // Read the trailing bit to see if frames follow + if (stream.Read(1) == 0) { + break; + } + frame_idx++; + } + return {packet_idx, frame_idx}; +} + +std::tuple XmaContextMaster::GetPacketFrameCount(uint8_t* packet) { + auto first_frame_offset = xma::GetPacketFrameOffset(packet); + if (first_frame_offset > kBitsPerPacket - 33) { + // frame offset is beyond packet end + return {0, false}; + } + + BitStream stream(packet, kBitsPerPacket); + stream.SetOffset(first_frame_offset); + int frame_count = 0; + + while (true) { + frame_count++; + if (stream.BitsRemaining() < 15) { + return {frame_count, true}; + } + + uint64_t size = stream.Read(15); + if ((size - 15) > stream.BitsRemaining()) { + return {frame_count, true}; + } else if (size == 0x7FFF) { + assert_always(); + return {frame_count, true}; + } + + stream.Advance(size - (15 + 1)); + + if (stream.Read(1) == 0) { + return {frame_count, false}; + } + } +} + +int XmaContextMaster::PrepareDecoder(uint8_t* packet, int sample_rate, + bool is_two_channel) { + // Sanity check: Packet metadata is always 1 for XMA2/0 for XMA + assert_true((packet[2] & 0x7) == 1 || (packet[2] & 0x7) == 0); + + sample_rate = GetSampleRate(sample_rate); + + // Re-initialize the context with new sample rate and channels. + uint32_t channels = is_two_channel ? 2 : 1; + if (av_context_->sample_rate != sample_rate || + av_context_->channels != channels) { + // We have to reopen the codec so it'll realloc whatever data it needs. + // TODO(DrChat): Find a better way. + avcodec_close(av_context_); + + av_context_->sample_rate = sample_rate; + av_context_->channels = channels; + + if (avcodec_open2(av_context_, av_codec_, NULL) < 0) { + XELOGE("XmaContext: Failed to reopen FFmpeg context"); + return -1; + } + return 1; + } + return 0; +} + +} // namespace apu +} // namespace xe diff --git a/src/xenia/apu/xma_context_master.h b/src/xenia/apu/xma_context_master.h new file mode 100644 index 000000000..b1b5724da --- /dev/null +++ b/src/xenia/apu/xma_context_master.h @@ -0,0 +1,97 @@ +/** + ****************************************************************************** + * Xenia : Xbox 360 Emulator Research Project * + ****************************************************************************** + * Copyright 2024 Ben Vanik. All rights reserved. * + * Released under the BSD license - see LICENSE in the root for more details. * + ****************************************************************************** + */ + +#ifndef XENIA_APU_XMA_CONTEXT_MASTER_H_ +#define XENIA_APU_XMA_CONTEXT_MASTER_H_ + +#include +#include +#include +#include + +#include "xenia/apu/xma_context.h" +#include "xenia/memory.h" +#include "xenia/xbox.h" + +// Forward declarations +struct AVCodec; +struct AVCodecParserContext; +struct AVCodecContext; +struct AVFrame; +struct AVPacket; + +namespace xe { +namespace apu { + +class XmaContextMaster : public XmaContext { + public: + explicit XmaContextMaster(); + ~XmaContextMaster(); + + int Setup(uint32_t id, Memory* memory, uint32_t guest_ptr); + bool Work(); + + void Enable(); + bool Block(bool poll); + void Clear(); + void Disable(); + void Release(); + + private: + static void SwapInputBuffer(XMA_CONTEXT_DATA* data); + static bool TrySetupNextLoop(XMA_CONTEXT_DATA* data, + bool ignore_input_buffer_offset); + static void NextPacket(XMA_CONTEXT_DATA* data); + static int GetSampleRate(int id); + // Get the offset of the next frame. Does not traverse packets. + static size_t GetNextFrame(uint8_t* block, size_t size, size_t bit_offset); + // Get the containing packet number of the frame pointed to by the offset. + static int GetFramePacketNumber(uint8_t* block, size_t size, + size_t bit_offset); + // Get the packet number and the index of the frame inside that packet + static std::tuple GetFrameNumber(uint8_t* block, size_t size, + size_t bit_offset); + // Get the number of frames contained in the packet (including truncated) and + // if the last frame is split. + static std::tuple GetPacketFrameCount(uint8_t* packet); + + bool ValidFrameOffset(uint8_t* block, size_t size_bytes, + size_t frame_offset_bits); + void Decode(XMA_CONTEXT_DATA* data); + int PrepareDecoder(uint8_t* packet, int sample_rate, bool is_two_channel); + + // uint32_t decoded_consumed_samples_ = 0; // TODO do this dynamically + // int decoded_idx_ = -1; + + // bool partial_frame_saved_ = false; + // bool partial_frame_size_known_ = false; + // size_t partial_frame_total_size_bits_ = 0; + // size_t partial_frame_start_offset_bits_ = 0; + // size_t partial_frame_offset_bits_ = 0; // blah internal don't use this + // std::vector partial_frame_buffer_; + uint32_t packets_skip_ = 0; + + bool is_stream_done_ = false; + // bool split_frame_pending_ = false; + uint32_t split_frame_len_ = 0; + uint32_t split_frame_len_partial_ = 0; + uint8_t split_frame_padding_start_ = 0; + // first byte contains bit offset information + std::array xma_frame_; + + // uint8_t* current_frame_ = nullptr; + // conversion buffer for 2 channel frame + std::array raw_frame_; + // std::vector current_frame_ = std::vector(0); +}; + +} // namespace apu +} // namespace xe + +#endif // XENIA_APU_XMA_CONTEXT_MASTER_H_ diff --git a/src/xenia/apu/xma_context_new.h b/src/xenia/apu/xma_context_new.h index 985b2ca9a..7b0a426ab 100644 --- a/src/xenia/apu/xma_context_new.h +++ b/src/xenia/apu/xma_context_new.h @@ -45,27 +45,7 @@ static constexpr int kIdToSampleRate[4] = {24000, 32000, 44100, 48000}; class XmaContextNew : public XmaContext { public: - static constexpr uint32_t kBytesPerPacket = 2048; - static constexpr uint32_t kBytesPerPacketHeader = 4; - static constexpr uint32_t kBytesPerPacketData = - kBytesPerPacket - kBytesPerPacketHeader; - - static constexpr uint32_t kBitsPerPacket = kBytesPerPacket * 8; static constexpr uint32_t kBitsPerPacketHeader = 32; - static constexpr uint32_t kBitsPerFrameHeader = 15; - - static constexpr uint32_t kBytesPerSample = 2; - static constexpr uint32_t kSamplesPerFrame = 512; - static constexpr uint32_t kSamplesPerSubframe = 128; - static constexpr uint32_t kBytesPerFrameChannel = - kSamplesPerFrame * kBytesPerSample; - static constexpr uint32_t kBytesPerSubframeChannel = - kSamplesPerSubframe * kBytesPerSample; - - static constexpr uint32_t kOutputBytesPerBlock = 256; - static constexpr uint32_t kOutputMaxSizeBytes = 31 * kOutputBytesPerBlock; - - static constexpr uint32_t kLastFrameMarker = 0x7FFF; static constexpr uint32_t kMaxFrameSizeinBits = 0x4000 - kBitsPerPacketHeader; explicit XmaContextNew(); @@ -118,10 +98,6 @@ class XmaContextNew : public XmaContext { bool DecodePacket(AVCodecContext* av_context, const AVPacket* av_packet, AVFrame* av_frame); - // This method should be used ONLY when we're at the last packet of the stream - // and we want to find offset in next buffer - uint32_t GetPacketFirstFrameOffset(const XMA_CONTEXT_DATA* data); - std::array input_buffer_; // first byte contains bit offset information std::array xma_frame_; diff --git a/src/xenia/apu/xma_context_old.cc b/src/xenia/apu/xma_context_old.cc index fc2978e1c..ed6b3c4f1 100644 --- a/src/xenia/apu/xma_context_old.cc +++ b/src/xenia/apu/xma_context_old.cc @@ -92,18 +92,19 @@ int XmaContextOld::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) { } bool XmaContextOld::Work() { - std::lock_guard lock(lock_); - if (!is_allocated() || !is_enabled()) { + if (!is_enabled() || !is_allocated()) { return false; } + { + std::lock_guard lock(lock_); + set_is_enabled(false); - set_is_enabled(false); - - auto context_ptr = memory()->TranslateVirtual(guest_ptr()); - XMA_CONTEXT_DATA data(context_ptr); - Decode(&data); - data.Store(context_ptr); - return true; + auto context_ptr = memory()->TranslateVirtual(guest_ptr()); + XMA_CONTEXT_DATA data(context_ptr); + Decode(&data); + data.Store(context_ptr); + return true; + } } void XmaContextOld::Enable() { @@ -145,9 +146,15 @@ void XmaContextOld::Clear() { data.input_buffer_1_valid = 0; data.output_buffer_valid = 0; + data.input_buffer_read_offset = 0; data.output_buffer_read_offset = 0; data.output_buffer_write_offset = 0; + xma_frame_.fill(0); + split_frame_len_ = 0; + split_frame_len_partial_ = 0; + split_frame_padding_start_ = 0; + data.Store(context_ptr); } @@ -175,7 +182,7 @@ void XmaContextOld::SwapInputBuffer(XMA_CONTEXT_DATA* data) { data->input_buffer_1_valid = 0; } data->current_buffer ^= 1; - data->input_buffer_read_offset = 0; + data->input_buffer_read_offset = kBitsPerHeader; } bool XmaContextOld::TrySetupNextLoop(XMA_CONTEXT_DATA* data, @@ -232,6 +239,7 @@ bool XmaContextOld::ValidFrameOffset(uint8_t* block, size_t size_bytes, GetFramePacketNumber(block, size_bytes, frame_offset_bits); if (packet_num == -1) { // Invalid packet number + XELOGAPU("ValidFrameOffset: Invalid packet number"); return false; } @@ -240,6 +248,7 @@ bool XmaContextOld::ValidFrameOffset(uint8_t* block, size_t size_bytes, uint32_t first_frame_offset = xma::GetPacketFrameOffset(packet); if (first_frame_offset == -1 || first_frame_offset > kBitsPerPacket) { + XELOGAPU("ValidFrameOffset: Invalid frame offset {}", first_frame_offset); // Packet only contains a partial frame, so no frames can start here. return false; } @@ -252,12 +261,16 @@ bool XmaContextOld::ValidFrameOffset(uint8_t* block, size_t size_bytes, } if (stream.BitsRemaining() < 15) { + XELOGAPU("ValidFrameOffset: No room for next frame header {}", + first_frame_offset); // Not enough room for another frame header. return false; } uint64_t size = stream.Read(15); if ((size - 15) > stream.BitsRemaining()) { + XELOGAPU("ValidFrameOffset: Last frame {} - {}", first_frame_offset, + size); // Last frame. return false; } else if (size == 0x7FFF) { @@ -307,7 +320,6 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { // No available data. if (!data->input_buffer_0_valid && !data->input_buffer_1_valid) { - data->output_buffer_valid = 0; return; } @@ -329,19 +341,41 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { : nullptr; uint8_t* current_input_buffer = data->current_buffer ? in1 : in0; - // XELOGAPU("Processing context {} (offset {}, buffer {}, ptr {:p})", id(), - // data->input_buffer_read_offset, data->current_buffer, - // current_input_buffer); + if (!current_input_buffer) { + XELOGE("XmaContext {}: Error - input buffer pointer is invalid!", id()); + return; + } + + if (!data->output_buffer_block_count) { + XELOGE("XmaContext {}: Error - Received 0 for output_buffer_block_count!", + id()); + return; + } + + XELOGAPU( + "Processing context {} (offset {}, buffer {}, ptr {:p}, output buffer " + "{:08X}, output buffer count {})", + id(), data->input_buffer_read_offset, data->current_buffer, + static_cast(current_input_buffer), data->output_buffer_ptr, + data->output_buffer_block_count); + + if (is_stream_done_) { + is_stream_done_ = false; + packets_skip_ = 0; + SwapInputBuffer(data); + return; + } size_t input_buffer_0_size = data->input_buffer_0_packet_count * kBytesPerPacket; size_t input_buffer_1_size = data->input_buffer_1_packet_count * kBytesPerPacket; - size_t input_total_size = input_buffer_0_size + input_buffer_1_size; size_t current_input_size = data->current_buffer ? input_buffer_1_size : input_buffer_0_size; size_t current_input_packet_count = current_input_size / kBytesPerPacket; + bool is_streaming = data->input_buffer_0_packet_count == 1 && + data->input_buffer_1_packet_count == 1; // Output buffers are in raw PCM samples, 256 bytes per block. // Output buffer is a ring buffer. We need to write from the write offset @@ -370,17 +404,15 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { assert_false(data->stop_when_done); assert_false(data->interrupt_when_done); static int total_samples = 0; - bool reuse_input_buffer = false; // Decode until we can't write any more data. while (output_remaining_bytes > 0) { if (!data->input_buffer_0_valid && !data->input_buffer_1_valid) { // Out of data. break; } - // Setup the input buffer if we are at loop_end. // The input buffer must not be swapped out until all loops are processed. - reuse_input_buffer = TrySetupNextLoop(data, false); + bool reuse_input_buffer = TrySetupNextLoop(data, false); // assert_true(packets_skip_ == 0); // assert_true(split_frame_len_ == 0); @@ -394,6 +426,14 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { BitStream stream(current_input_buffer, current_input_size * 8); stream.SetOffset(data->input_buffer_read_offset); + if (data->input_buffer_read_offset > current_input_size * 8) { + XELOGE( + "XmaContext {}: Error - Provided input offset exceed input buffer " + "size! ({} > {})", + id(), data->input_buffer_read_offset, current_input_size * 8); + SwapInputBuffer(data); + return; + } // if we had a buffer swap try to skip packets first if (packets_skip_ > 0) { packet_idx = @@ -402,13 +442,17 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { while (packets_skip_ > 0) { packets_skip_--; packet_idx++; - if (packet_idx >= current_input_packet_count) { + if (packet_idx > current_input_packet_count) { if (!reuse_input_buffer) { // Last packet. Try setup once more. reuse_input_buffer = TrySetupNextLoop(data, true); } if (!reuse_input_buffer) { - SwapInputBuffer(data); + if (is_streaming) { + SwapInputBuffer(data); + } else { + is_stream_done_ = true; + } } return; } @@ -429,7 +473,7 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { stream = BitStream(current_input_buffer, (packet_idx + 1) * kBitsPerPacket); - stream.SetOffset(packet_idx * kBitsPerPacket + 32); + stream.SetOffset(packet_idx * kBitsPerPacket + kBitsPerHeader); if (split_frame_len_ > xma::kMaxFrameLength) { // TODO write CopyPeekMethod @@ -445,8 +489,8 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { } if (frame_count > 0) { - assert_true(xma::GetPacketFrameOffset(packet) - 32 == - split_frame_len_ - split_frame_len_partial_); + // assert_true(xma::GetPacketFrameOffset(packet) - 32 == + // split_frame_len_ - split_frame_len_partial_); } auto offset = stream.Copy( @@ -484,7 +528,7 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { if (!ValidFrameOffset(current_input_buffer, current_input_size, data->input_buffer_read_offset)) { - XELOGAPU("XmaContext {}: Invalid read offset {}!", id(), + XELOGAPU("XmaContext {}: Error - Invalid read offset {}!", id(), data->input_buffer_read_offset); SwapInputBuffer(data); return; @@ -526,9 +570,19 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { std::memset(xma_frame_.data(), 0, xma_frame_.size()); { - auto offset = - stream.Copy(xma_frame_.data() + 1, - std::min(split_frame_len_, split_frame_len_partial_)); + int32_t bits_to_copy = + std::min(split_frame_len_, split_frame_len_partial_); + + if (!stream.IsOffsetValid(bits_to_copy)) { + XELOGAPU( + "XmaContext {}: Error - Invalid amount of bits to copy! " + "split_frame_len: {}, split_partial: {}, offset_bits: {}", + id(), split_frame_len_, split_frame_len_partial_, + stream.offset_bits()); + SwapInputBuffer(data); + return; + } + auto offset = stream.Copy(xma_frame_.data() + 1, bits_to_copy); assert_true(offset < 8); split_frame_padding_start_ = static_cast(offset); } @@ -546,7 +600,11 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { reuse_input_buffer = TrySetupNextLoop(data, true); } if (!reuse_input_buffer) { - SwapInputBuffer(data); + if (is_streaming) { + SwapInputBuffer(data); + } else { + is_stream_done_ = true; + } } return; } @@ -574,7 +632,7 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { auto ret = avcodec_send_packet(av_context_, av_packet_); if (ret < 0) { - XELOGE("XmaContext {}: Error sending packet for decoding", id()); + XELOGE("XmaContext {}: Error - Sending packet for decoding failed", id()); // TODO bail out assert_always(); } @@ -586,7 +644,10 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { else */ if (ret < 0) { - XELOGE("XmaContext {}: Error during decoding", id()); + XELOGE("XmaContext {}: Error - Decoding failed", id()); + data->parser_error_status = 4; // TODO(Gliniak): Find all parsing errors + // and create enumerator from them + SwapInputBuffer(data); assert_always(); return; // TODO bail out } @@ -602,8 +663,8 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { // assert_true(frame_is_split == (frame_idx == -1)); // dump_raw(av_frame_, id()); - ConvertFrame((const uint8_t**)av_frame_->data, bool(data->is_stereo), - raw_frame_.data()); + ConvertFrame(reinterpret_cast(&av_frame_->data), + bool(av_frame_->channels > 1), raw_frame_.data()); // decoded_consumed_samples_ += kSamplesPerFrame; auto byte_count = kBytesPerFrameChannel << data->is_stereo; @@ -614,14 +675,17 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { total_samples += id_ == 0 ? kSamplesPerFrame : 0; - uint32_t offset = data->input_buffer_read_offset; - // if (offset % (kBytesPerSample * 8) == 0) { - // offset = xma::GetPacketFrameOffset(packet); - //} + uint32_t offset = + std::max(kBitsPerHeader, data->input_buffer_read_offset); offset = static_cast( GetNextFrame(current_input_buffer, current_input_size, offset)); - // assert_true((offset == 0) == - // (frame_is_split || (frame_idx + 1 >= frame_count))); + + XELOGAPU( + "XmaContext {}: Next Offset: {} (Frame: {}/{} Packet: {}/{} Packet " + "Skip: {} - {})", + id(), offset, frame_idx, frame_count - 1, packet_idx, + current_input_packet_count, xma::GetPacketSkipCount(packet), + data->input_buffer_read_offset); if (frame_idx + 1 >= frame_count) { // Skip to next packet (no split frame) packets_skip_ = xma::GetPacketSkipCount(packet) + 1; @@ -634,12 +698,24 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { reuse_input_buffer = TrySetupNextLoop(data, true); } if (!reuse_input_buffer) { - SwapInputBuffer(data); + if (is_streaming) { + SwapInputBuffer(data); + data->input_buffer_read_offset = + GetPacketFirstFrameOffset(data); + } else { + is_stream_done_ = true; + } + if (output_rb.write_offset() == output_rb.read_offset()) { + data->output_buffer_valid = 0; + } } return; } } packet = current_input_buffer + packet_idx * kBytesPerPacket; + // TODO(Gliniak): There might be an edge-case when we're in packet 26/27 + // and GetPacketFrameOffset returns that there is no data in this packet + // aka. FrameOffset is set to more than 0x7FFF-0x20 offset = xma::GetPacketFrameOffset(packet) + packet_idx * kBitsPerPacket; } @@ -652,7 +728,11 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { reuse_input_buffer = TrySetupNextLoop(data, true); } if (!reuse_input_buffer) { - SwapInputBuffer(data); + if (is_streaming) { + SwapInputBuffer(data); + } else { + is_stream_done_ = true; + } } break; } @@ -675,6 +755,24 @@ void XmaContextOld::Decode(XMA_CONTEXT_DATA* data) { } } +uint32_t XmaContextOld::GetPacketFirstFrameOffset( + const XMA_CONTEXT_DATA* data) { + uint32_t first_frame_offset = kBitsPerHeader; + + uint8_t* in0 = data->input_buffer_0_valid + ? memory()->TranslatePhysical(data->input_buffer_0_ptr) + : nullptr; + uint8_t* in1 = data->input_buffer_1_valid + ? memory()->TranslatePhysical(data->input_buffer_1_ptr) + : nullptr; + uint8_t* current_input_buffer = data->current_buffer ? in1 : in0; + + if (current_input_buffer) { + first_frame_offset = xma::GetPacketFrameOffset(current_input_buffer); + } + return first_frame_offset; +} + size_t XmaContextOld::GetNextFrame(uint8_t* block, size_t size, size_t bit_offset) { // offset = xma::GetPacketFrameOffset(packet); @@ -693,14 +791,14 @@ size_t XmaContextOld::GetNextFrame(uint8_t* block, size_t size, uint64_t len = stream.Read(15); if ((len - 15) > stream.BitsRemaining()) { // assert_always("TODO"); - // *bit_offset = next_packet; - // return false; - // return next_packet; + // *bit_offset = next_packet; + // return false; + // return next_packet; return 0; } else if (len >= xma::kMaxFrameLength) { - // assert_always("TODO"); - // *bit_offset = next_packet; - // return false; + assert_always("TODO"); + // *bit_offset = next_packet; + // return false; return 0; // return next_packet; } @@ -783,7 +881,7 @@ std::tuple XmaContextOld::GetFrameNumber(uint8_t* block, size_t size, std::tuple XmaContextOld::GetPacketFrameCount(uint8_t* packet) { auto first_frame_offset = xma::GetPacketFrameOffset(packet); - if (first_frame_offset > kBitsPerPacket - 33) { + if (first_frame_offset > kBitsPerPacket - kBitsPerHeader) { // frame offset is beyond packet end return {0, false}; } @@ -793,11 +891,11 @@ std::tuple XmaContextOld::GetPacketFrameCount(uint8_t* packet) { int frame_count = 0; while (true) { - frame_count++; if (stream.BitsRemaining() < 15) { - return {frame_count, true}; + return {frame_count, false}; } + frame_count++; uint64_t size = stream.Read(15); if ((size - 15) > stream.BitsRemaining()) { return {frame_count, true}; @@ -811,6 +909,12 @@ std::tuple XmaContextOld::GetPacketFrameCount(uint8_t* packet) { if (stream.Read(1) == 0) { return {frame_count, false}; } + // There is a case when frame ends EXACTLY at the end of packet. + // In such case we shouldn't increase frame count by additional not existing + // frame and don't mark it as splitted, but as a normal frame + if (!stream.BitsRemaining()) { + return {frame_count, false}; + } } } diff --git a/src/xenia/apu/xma_context_old.h b/src/xenia/apu/xma_context_old.h index de2d3e1bd..736b961a0 100644 --- a/src/xenia/apu/xma_context_old.h +++ b/src/xenia/apu/xma_context_old.h @@ -66,6 +66,10 @@ class XmaContextOld : public XmaContext { void Decode(XMA_CONTEXT_DATA* data); int PrepareDecoder(uint8_t* packet, int sample_rate, bool is_two_channel); + // This method should be used ONLY when we're at the last packet of the stream + // and we want to find offset in next buffer + uint32_t GetPacketFirstFrameOffset(const XMA_CONTEXT_DATA* data); + // uint32_t decoded_consumed_samples_ = 0; // TODO do this dynamically // int decoded_idx_ = -1; diff --git a/src/xenia/apu/xma_decoder.cc b/src/xenia/apu/xma_decoder.cc index 114885edd..8662a6ea3 100644 --- a/src/xenia/apu/xma_decoder.cc +++ b/src/xenia/apu/xma_decoder.cc @@ -10,6 +10,8 @@ #include "xenia/apu/xma_decoder.h" #include "xenia/apu/xma_context.h" +#include "xenia/apu/xma_context_fake.h" +#include "xenia/apu/xma_context_master.h" #include "xenia/apu/xma_context_new.h" #include "xenia/apu/xma_context_old.h" @@ -54,15 +56,22 @@ extern "C" { DEFINE_bool(ffmpeg_verbose, false, "Verbose FFmpeg output (debug and above)", "APU"); -DEFINE_bool(use_new_decoder, true, - "Enables usage of new experimental XMA audio decoder.", "APU"); - DEFINE_bool(use_dedicated_xma_thread, true, "Enables XMA decoding on separate thread. Disabled should produce " "better results, but decrease performance a bit.", "APU"); -UPDATE_from_bool(use_new_decoder, 2025, 12, 01, 23, false); +DEFINE_string( + xma_decoder, "new", + "Decoder version used to process XMA audio.\n" + "Use: [fake, master, old, new]\n" + " fake: \n No audio will be decoded.\n" + " master: \n Version of decoder exactly like on base version of Xenia.\n" + " old: \n Decoder based on master version of decoder with few " + "improvements.\n" + " new: \n New version of decoder. Provides highest stability, but isn't " + "yet finished.\n", + "APU"); namespace xe { namespace apu { @@ -141,10 +150,16 @@ X_STATUS XmaDecoder::Setup(kernel::KernelState* kernel_state) { // Setup XMA contexts. for (int i = 0; i < kContextCount; ++i) { - if (cvars::use_new_decoder) { + if (cvars::xma_decoder == "fake") { + contexts_[i] = new XmaContextFake(); + } else if (cvars::xma_decoder == "master") { + contexts_[i] = new XmaContextMaster(); + } else if (cvars::xma_decoder == "old") { + contexts_[i] = new XmaContextOld(); + } else if (cvars::xma_decoder == "new") { contexts_[i] = new XmaContextNew(); } else { - contexts_[i] = new XmaContextOld(); + contexts_[i] = new XmaContextNew(); } uint32_t guest_ptr = context_data_first_ptr_ + i * sizeof(XMA_CONTEXT_DATA);