fabi/Xenia-Canary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[XMA] Added multiple versions of XMA decoders

Browse Source 
- 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>
This commit is contained in:
Gliniak
2025-12-02 22:33:02 +01:00
committed by Radosław Gliński
parent e588a772d4
commit 4494e40c71
9 changed files with 1498 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/xenia/apu/xma_context.h
View File

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

302
src/xenia/apu/xma_context_fake.cc Normal file
View File

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

66
src/xenia/apu/xma_context_fake.h Normal file
View File

@@ -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_

846
src/xenia/apu/xma_context_master.cc Normal file
View File

@@ -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 <cstring>
#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<xe_mutex> 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<xe_mutex> 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<xe_mutex> 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<xe_mutex> 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<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.
}
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<int>(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<int>(stream.BitsRemaining());
if (split_frame_len_partial_ >= 15) {
split_frame_len_ = static_cast<int>(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<uint8_t>(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<int>(
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<uint32_t>(
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<int, int> 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<int, bool> 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

97
src/xenia/apu/xma_context_master.h Normal file
View File

@@ -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_

24
src/xenia/apu/xma_context_new.h
View File

@@ -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_;

202
src/xenia/apu/xma_context_old.cc
View File

@@ -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};
}
}
}

4
src/xenia/apu/xma_context_old.h
View File

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

27
src/xenia/apu/xma_decoder.cc
View File

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