[XMA] Added multiple versions of XMA decoders

- Fake: No decoding
- Master: 1:1 from base version of Xenia
- Old: Master with improvements
- New: Completely new decoder with better stability (but not compability)

Co-authored-by: Herman S. <429230+has207@users.noreply.github.com>

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();

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<xe_mutex> 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<xe_mutex> 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<xe_mutex> 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<xe_mutex> 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<xe_mutex> 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

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 <array>
+#include <atomic>
+#include <mutex>
+#include <queue>
+
+#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<uint8_t, kBytesPerFrameChannel * 2> 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_

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 <array>
+#include <atomic>
+#include <mutex>
+#include <queue>
+
+#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<int, int> 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<int, bool> 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<uint8_t> 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<uint8_t, 1 + 4096> xma_frame_;
+
+  // uint8_t* current_frame_ = nullptr;
+  // conversion buffer for 2 channel frame
+  std::array<uint8_t, kBytesPerFrameChannel * 2> raw_frame_;
+  // std::vector<uint8_t> current_frame_ = std::vector<uint8_t>(0);
+};
+
+}  // namespace apu
+}  // namespace xe
+
+#endif  // XENIA_APU_XMA_CONTEXT_MASTER_H_

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<uint8_t, kBytesPerPacketData * 2> input_buffer_;
   // first byte contains bit offset information
   std::array<uint8_t, 1 + 4096> xma_frame_;

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<xe_mutex> lock(lock_);
-  if (!is_allocated() || !is_enabled()) {
+  if (!is_enabled() || !is_allocated()) {
     return false;
   }
+  {
+    std::lock_guard<xe_mutex> 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<void*>(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<uint8_t>(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<const uint8_t**>(&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<uint32_t>(
           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<int, int> XmaContextOld::GetFrameNumber(uint8_t* block, size_t size,
 
 std::tuple<int, bool> 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<int, bool> 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<int, bool> 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};
+    }
   }
 }
 

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;
 

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);