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

xb format --all (we are now format clean). Buildbot will yell at you.

Browse Source
This commit is contained in:
Ben Vanik
2015-06-22 22:26:51 -07:00
parent f902f8b78a
commit fb1f4906d9
87 changed files with 3542 additions and 2938 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/xenia/apu/audio_system.cc
View File

@@ -38,15 +38,14 @@ namespace apu {
using namespace xe::cpu;
AudioSystem::AudioSystem(Emulator* emulator)
: emulator_(emulator),
memory_(emulator->memory()),
worker_running_(false) {
: emulator_(emulator), memory_(emulator->memory()), worker_running_(false) {
std::memset(clients_, 0, sizeof(clients_));
for (size_t i = 0; i < kMaximumClientCount; ++i) {
unused_clients_.push(i);
}
for (size_t i = 0; i < kMaximumClientCount; ++i) {
client_semaphores_[i] = CreateSemaphore(NULL, 0, kMaximumQueuedFrames, NULL);
client_semaphores_[i] =
CreateSemaphore(NULL, 0, kMaximumQueuedFrames, NULL);
wait_handles_[i] = client_semaphores_[i];
}
shutdown_event_ = CreateEvent(NULL, TRUE, FALSE, NULL);

5
src/xenia/apu/audio_system.h
View File

@@ -48,7 +48,8 @@ class AudioSystem {
AudioDriver** out_driver) = 0;
virtual void DestroyDriver(AudioDriver* driver) = 0;
// TODO(gibbed): respect XAUDIO2_MAX_QUEUED_BUFFERS somehow (ie min(64, XAUDIO2_MAX_QUEUED_BUFFERS))
// TODO(gibbed): respect XAUDIO2_MAX_QUEUED_BUFFERS somehow (ie min(64,
// XAUDIO2_MAX_QUEUED_BUFFERS))
static const size_t kMaximumQueuedFrames = 64;
protected:
@@ -79,7 +80,7 @@ class AudioSystem {
} clients_[kMaximumClientCount];
HANDLE client_semaphores_[kMaximumClientCount];
HANDLE shutdown_event_; // Event is always there in case we have no clients.
HANDLE shutdown_event_; // Event is always there in case we have no clients.
HANDLE wait_handles_[kMaximumClientCount + 1];
std::queue<size_t> unused_clients_;
};

73
src/xenia/apu/xma_context.cc
View File

@@ -27,15 +27,15 @@ namespace xe {
namespace apu {
XmaContext::XmaContext()
: id_(0)
, guest_ptr_(0)
, is_allocated_(false)
, is_enabled_(false)
, decoding_packet_(false)
, codec_(nullptr)
, context_(nullptr)
, decoded_frame_(nullptr)
, packet_(nullptr) {}
: id_(0),
guest_ptr_(0),
is_allocated_(false),
is_enabled_(false),
decoding_packet_(false),
codec_(nullptr),
context_(nullptr),
decoded_frame_(nullptr),
packet_(nullptr) {}
XmaContext::~XmaContext() {
if (context_) {
@@ -48,11 +48,11 @@ XmaContext::~XmaContext() {
av_frame_free(&decoded_frame_);
}
if (current_frame_) {
delete [] current_frame_;
delete[] current_frame_;
}
}
int XmaContext::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) {
int XmaContext::Setup(uint32_t id, Memory *memory, uint32_t guest_ptr) {
id_ = id;
memory_ = memory;
guest_ptr_ = guest_ptr;
@@ -94,7 +94,7 @@ int XmaContext::Setup(uint32_t id, Memory* memory, uint32_t guest_ptr) {
extra_data_.decode_flags = 0x10D6;
context_->extradata_size = sizeof(extra_data_);
context_->extradata = (uint8_t*)&extra_data_;
context_->extradata = (uint8_t *)&extra_data_;
// Current frame stuff whatever
// samples per frame * 2 max channels * output bytes
@@ -126,10 +126,11 @@ void XmaContext::Enable() {
auto context_ptr = memory()->TranslateVirtual(guest_ptr());
XMA_CONTEXT_DATA data(context_ptr);
XELOGAPU("XmaContext: kicking context %d (%d/%d bytes)", id(),
XELOGAPU(
"XmaContext: kicking context %d (%d/%d bytes)", id(),
(data.input_buffer_read_offset & ~0x7FF) / 8,
(data.input_buffer_0_packet_count + data.input_buffer_1_packet_count)
* kBytesPerPacket);
(data.input_buffer_0_packet_count + data.input_buffer_1_packet_count) *
kBytesPerPacket);
// Reset valid flags so our audio decoder knows to process this one.
data.input_buffer_0_valid = data.input_buffer_0_ptr != 0;
@@ -190,16 +191,20 @@ void XmaContext::Release() {
int XmaContext::GetSampleRate(int id) {
switch (id) {
case 0: return 24000;
case 1: return 32000;
case 2: return 44100;
case 3: return 48000;
case 0:
return 24000;
case 1:
return 32000;
case 2:
return 44100;
case 3:
return 48000;
}
assert_always();
return 0;
}
void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
void XmaContext::DecodePackets(XMA_CONTEXT_DATA &data) {
SCOPE_profile_cpu_f("apu");
// What I see:
@@ -231,10 +236,12 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
// 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);
uint8_t *output_buffer = memory()->TranslatePhysical(data.output_buffer_ptr);
uint32_t output_capacity = data.output_buffer_block_count * kBytesPerSubframe;
uint32_t output_read_offset = data.output_buffer_read_offset * kBytesPerSubframe;
uint32_t output_write_offset = data.output_buffer_write_offset * kBytesPerSubframe;
uint32_t output_read_offset =
data.output_buffer_read_offset * kBytesPerSubframe;
uint32_t output_write_offset =
data.output_buffer_write_offset * kBytesPerSubframe;
RingBuffer output_rb(output_buffer, output_capacity);
output_rb.set_read_offset(output_read_offset);
@@ -254,7 +261,7 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
while (decode_attempts_remaining) {
read_bytes = DecodePacket(work_buffer, 0, output_remaining_bytes);
if (read_bytes >= 0) {
//assert_true((read_bytes % 256) == 0);
// assert_true((read_bytes % 256) == 0);
auto written_bytes = output_rb.Write(work_buffer, read_bytes);
assert_true(read_bytes == written_bytes);
@@ -269,7 +276,8 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
}
if (!decode_attempts_remaining) {
XELOGAPU("XmaContext: libav failed to decode packet (returned %.8X)", -read_bytes);
XELOGAPU("XmaContext: libav failed to decode packet (returned %.8X)",
-read_bytes);
// Failed out.
if (data.input_buffer_0_valid || data.input_buffer_1_valid) {
@@ -309,10 +317,10 @@ void XmaContext::DecodePackets(XMA_CONTEXT_DATA& data) {
int XmaContext::StartPacket(XMA_CONTEXT_DATA &data) {
// Translate pointers for future use.
uint8_t* in0 = data.input_buffer_0_valid
uint8_t *in0 = data.input_buffer_0_valid
? memory()->TranslatePhysical(data.input_buffer_0_ptr)
: nullptr;
uint8_t* in1 = data.input_buffer_1_valid
uint8_t *in1 = data.input_buffer_1_valid
? memory()->TranslatePhysical(data.input_buffer_1_ptr)
: nullptr;
@@ -348,9 +356,8 @@ int XmaContext::StartPacket(XMA_CONTEXT_DATA &data) {
// Still have data to read.
auto packet = input_buffer + input_offset_bytes;
assert_true(input_offset_bytes % 2048 == 0);
PreparePacket(packet, seq_offset_bytes,
kBytesPerPacket,
sample_rate, channels);
PreparePacket(packet, seq_offset_bytes, kBytesPerPacket, sample_rate,
channels);
data.input_buffer_read_offset += kBytesPerPacket * 8;
input_remaining_bytes -= kBytesPerPacket;
@@ -395,7 +402,8 @@ int XmaContext::PreparePacket(uint8_t *input, size_t seq_offset, size_t size,
context_->sample_rate = sample_rate;
context_->channels = channels;
extra_data_.channel_mask = channels == 2 ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
extra_data_.channel_mask =
channels == 2 ? AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_MONO;
if (avcodec_open2(context_, codec_, NULL) < 0) {
XELOGE("XmaContext: Failed to reopen libav context");
@@ -487,8 +495,7 @@ int XmaContext::DecodePacket(uint8_t *output, size_t output_offset,
// Total size of the frame's samples
// Magic number 2 is sizeof an output sample
frame_samples_size_ =
context_->channels * decoded_frame_->nb_samples * 2;
frame_samples_size_ = context_->channels * decoded_frame_->nb_samples * 2;
to_copy = std::min(output_size, (size_t)(frame_samples_size_));
std::memcpy(output + output_offset, current_frame_, to_copy);

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

@@ -45,25 +45,25 @@ namespace apu {
struct XMA_CONTEXT_DATA {
// DWORD 0
uint32_t input_buffer_0_packet_count : 12; // XMASetInputBuffer0, number of
// 2KB packets. Max 4095 packets.
// These packets form a block.
uint32_t loop_count : 8; // +12bit, XMASetLoopData NumLoops
uint32_t input_buffer_0_valid : 1; // +20bit, XMAIsInputBuffer0Valid
uint32_t input_buffer_1_valid : 1; // +21bit, XMAIsInputBuffer1Valid
uint32_t output_buffer_block_count : 5; // +22bit SizeWrite 256byte blocks
uint32_t output_buffer_write_offset : 5; // +27bit
// XMAGetOutputBufferWriteOffset
// AKA OffsetWrite
uint32_t input_buffer_0_packet_count : 12; // XMASetInputBuffer0, number of
// 2KB packets. Max 4095 packets.
// These packets form a block.
uint32_t loop_count : 8; // +12bit, XMASetLoopData NumLoops
uint32_t input_buffer_0_valid : 1; // +20bit, XMAIsInputBuffer0Valid
uint32_t input_buffer_1_valid : 1; // +21bit, XMAIsInputBuffer1Valid
uint32_t output_buffer_block_count : 5; // +22bit SizeWrite 256byte blocks
uint32_t output_buffer_write_offset : 5; // +27bit
// XMAGetOutputBufferWriteOffset
// AKA OffsetWrite
// DWORD 1
uint32_t input_buffer_1_packet_count : 12; // XMASetInputBuffer1, number of
// 2KB packets. Max 4095 packets.
// These packets form a block.
uint32_t loop_subframe_end : 2; // +12bit, XMASetLoopData
uint32_t unk_dword_1_a : 3; // ? might be loop_subframe_skip
uint32_t loop_subframe_skip : 3; // +17bit, XMASetLoopData might be
// subframe_decode_count
uint32_t input_buffer_1_packet_count : 12; // XMASetInputBuffer1, number of
// 2KB packets. Max 4095 packets.
// These packets form a block.
uint32_t loop_subframe_end : 2; // +12bit, XMASetLoopData
uint32_t unk_dword_1_a : 3; // ? might be loop_subframe_skip
uint32_t loop_subframe_skip : 3; // +17bit, XMASetLoopData might be
// subframe_decode_count
uint32_t subframe_decode_count : 4; // +20bit might be subframe_skip_count
uint32_t unk_dword_1_b : 3; // ? NumSubframesToSkip/NumChannels(?)
uint32_t sample_rate : 2; // +27bit enum of sample rates
@@ -99,7 +99,7 @@ struct XMA_CONTEXT_DATA {
uint32_t unk_dword_9 : 27; // StopWhenDone/InterruptWhenDone(?)
// DWORD 10-15
uint32_t unk_dwords_10_15[6]; // reserved?
uint32_t unk_dwords_10_15[6]; // reserved?
XMA_CONTEXT_DATA(const void* ptr) {
xe::copy_and_swap(reinterpret_cast<uint32_t*>(this),
@@ -117,86 +117,87 @@ static_assert_size(XMA_CONTEXT_DATA, 64);
#pragma pack(push, 1)
struct WmaProExtraData {
uint16_t bits_per_sample;
uint32_t channel_mask;
uint8_t unk06[8];
uint16_t decode_flags;
uint8_t unk10[2];
uint16_t bits_per_sample;
uint32_t channel_mask;
uint8_t unk06[8];
uint16_t decode_flags;
uint8_t unk10[2];
};
static_assert_size(WmaProExtraData, 18);
#pragma pack(pop)
class XmaContext {
public:
static const uint32_t kBytesPerPacket = 2048;
public:
static const uint32_t kBytesPerPacket = 2048;
static const uint32_t kBytesPerSample = 2;
static const uint32_t kSamplesPerFrame = 512;
static const uint32_t kSamplesPerSubframe = 128;
static const uint32_t kBytesPerSubframe = kSamplesPerSubframe * kBytesPerSample;
static const uint32_t kBytesPerSample = 2;
static const uint32_t kSamplesPerFrame = 512;
static const uint32_t kSamplesPerSubframe = 128;
static const uint32_t kBytesPerSubframe =
kSamplesPerSubframe * kBytesPerSample;
static const uint32_t kOutputBytesPerBlock = 256;
static const uint32_t kOutputMaxSizeBytes = 31 * kOutputBytesPerBlock;
static const uint32_t kOutputBytesPerBlock = 256;
static const uint32_t kOutputMaxSizeBytes = 31 * kOutputBytesPerBlock;
XmaContext();
~XmaContext();
XmaContext();
~XmaContext();
int Setup(uint32_t id, Memory* memory, uint32_t guest_ptr);
void Work();
int Setup(uint32_t id, Memory* memory, uint32_t guest_ptr);
void Work();
void Enable();
bool Block(bool poll);
void Clear();
void Disable();
void Release();
void Enable();
bool Block(bool poll);
void Clear();
void Disable();
void Release();
Memory* memory() const { return memory_; }
Memory* memory() const { return memory_; }
uint32_t id() { return id_; }
uint32_t guest_ptr() { return guest_ptr_; }
bool is_allocated() { return is_allocated_; }
bool is_enabled() { return is_enabled_; }
uint32_t id() { return id_; }
uint32_t guest_ptr() { return guest_ptr_; }
bool is_allocated() { return is_allocated_; }
bool is_enabled() { return is_enabled_; }
void set_is_allocated(bool is_allocated) { is_allocated_ = is_allocated; }
void set_is_enabled(bool is_enabled) { is_enabled_ = is_enabled; }
void set_is_allocated(bool is_allocated) { is_allocated_ = is_allocated; }
void set_is_enabled(bool is_enabled) { is_enabled_ = is_enabled; }
private:
static int GetSampleRate(int id);
private:
static int GetSampleRate(int id);
void DecodePackets(XMA_CONTEXT_DATA& data);
int StartPacket(XMA_CONTEXT_DATA &data);
void DecodePackets(XMA_CONTEXT_DATA& data);
int StartPacket(XMA_CONTEXT_DATA& data);
int PreparePacket(uint8_t* input, size_t seq_offset, size_t size,
int sample_rate, int channels);
void DiscardPacket();
int PreparePacket(uint8_t* input, size_t seq_offset, size_t size,
int sample_rate, int channels);
void DiscardPacket();
int DecodePacket(uint8_t* output, size_t offset, size_t size);
int DecodePacket(uint8_t* output, size_t offset, size_t size);
Memory* memory_;
Memory* memory_;
uint32_t id_;
uint32_t guest_ptr_;
xe::mutex lock_;
bool is_allocated_;
bool is_enabled_;
uint32_t id_;
uint32_t guest_ptr_;
xe::mutex lock_;
bool is_allocated_;
bool is_enabled_;
bool decoding_packet_;
bool decoding_packet_;
// libav structures
AVCodec* codec_;
AVCodecContext* context_;
AVFrame* decoded_frame_;
AVPacket* packet_;
WmaProExtraData extra_data_;
// libav structures
AVCodec* codec_;
AVCodecContext* context_;
AVFrame* decoded_frame_;
AVPacket* packet_;
WmaProExtraData extra_data_;
size_t current_frame_pos_;
uint8_t* current_frame_;
uint32_t frame_samples_size_;
size_t current_frame_pos_;
uint8_t* current_frame_;
uint32_t frame_samples_size_;
uint8_t packet_data_[kBytesPerPacket];
uint8_t packet_data_[kBytesPerPacket];
};
} // namespace apu
} // namespace xe
} // namespace apu
} // namespace xe
#endif // XENIA_APU_XMA_CONTEXT_H_

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

@@ -53,17 +53,16 @@ namespace apu {
using namespace xe::cpu;
XmaDecoder::XmaDecoder(Emulator* emulator)
: emulator_(emulator)
, memory_(emulator->memory())
, processor_(emulator->processor())
, worker_running_(false)
, context_data_first_ptr_(0)
, context_data_last_ptr_(0) {
}
: emulator_(emulator),
memory_(emulator->memory()),
processor_(emulator->processor()),
worker_running_(false),
context_data_first_ptr_(0),
context_data_last_ptr_(0) {}
XmaDecoder::~XmaDecoder() {}
void av_log_callback(void *avcl, int level, const char *fmt, va_list va) {
void av_log_callback(void* avcl, int level, const char* fmt, va_list va) {
StringBuffer buff;
buff.AppendVarargs(fmt, va);
xe::log_line('i', "libav: %s", buff.GetString());
@@ -82,12 +81,14 @@ X_STATUS XmaDecoder::Setup() {
// Setup XMA context data.
context_data_first_ptr_ = memory()->SystemHeapAlloc(
sizeof(XMA_CONTEXT_DATA) * kContextCount, 256, kSystemHeapPhysical);
context_data_last_ptr_ = context_data_first_ptr_ + (sizeof(XMA_CONTEXT_DATA) * kContextCount - 1);
context_data_last_ptr_ =
context_data_first_ptr_ + (sizeof(XMA_CONTEXT_DATA) * kContextCount - 1);
registers_.context_array_ptr = context_data_first_ptr_;
// Setup XMA contexts.
for (int i = 0; i < kContextCount; ++i) {
uint32_t guest_ptr = registers_.context_array_ptr + i * sizeof(XMA_CONTEXT_DATA);
uint32_t guest_ptr =
registers_.context_array_ptr + i * sizeof(XMA_CONTEXT_DATA);
XmaContext& context = contexts_[i];
if (context.Setup(i, memory(), guest_ptr)) {
assert_always();

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

@@ -41,9 +41,7 @@ class XmaDecoder {
virtual X_STATUS Setup();
virtual void Shutdown();
uint32_t context_array_ptr() const {
return registers_.context_array_ptr;
}
uint32_t context_array_ptr() const { return registers_.context_array_ptr; }
uint32_t AllocateContext();
void ReleaseContext(uint32_t guest_ptr);