diff --git a/CMakeLists.txt b/CMakeLists.txt index 9cfc0d8ef..905ca79ee 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -184,6 +184,9 @@ set(AUDIO_LIB src/core/libraries/audio/audioin.cpp src/core/libraries/audio/audioout.h src/core/libraries/ajm/ajm.cpp src/core/libraries/ajm/ajm.h + src/core/libraries/ajm/ajm_mp3.h + src/core/libraries/ajm/ajm_mp3.cpp + src/core/libraries/ajm/ajm_instance.h src/core/libraries/ngs2/ngs2.cpp src/core/libraries/ngs2/ngs2.h ) diff --git a/src/core/libraries/ajm/ajm.cpp b/src/core/libraries/ajm/ajm.cpp index 441a07f63..73f32e4ab 100644 --- a/src/core/libraries/ajm/ajm.cpp +++ b/src/core/libraries/ajm/ajm.cpp @@ -1,15 +1,54 @@ // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#pragma clang optimize off +#include +#include -#include "ajm.h" -#include "ajm_error.h" - +#include "common/assert.h" #include "common/logging/log.h" +#include "core/libraries/ajm/ajm.h" +#include "core/libraries/ajm/ajm_error.h" +#include "core/libraries/ajm/ajm_instance.h" +#include "core/libraries/ajm/ajm_mp3.h" #include "core/libraries/error_codes.h" #include "core/libraries/libs.h" +extern "C" { +#include +#include +#include +} + namespace Libraries::Ajm { +static constexpr u32 AJM_INSTANCE_STATISTICS = 0x80000; + +static constexpr u32 MaxInstances = 0x2fff; + +struct AjmDevice { + u32 max_prio; + u32 min_prio; + u32 curr_cursor{}; + u32 release_cursor{MaxInstances - 1}; + std::array is_registered{}; + std::array free_instances{}; + std::array, MaxInstances> instances; + + bool IsRegistered(AjmCodecType type) const { + return is_registered[static_cast(type)]; + } + + void Register(AjmCodecType type) { + is_registered[static_cast(type)] = true; + } + + AjmDevice() { + std::iota(free_instances.begin(), free_instances.end(), 1); + } +}; + +static std::unique_ptr dev{}; + int PS4_SYSV_ABI sceAjmBatchCancel() { LOG_ERROR(Lib_Ajm, "(STUBBED) called"); return ORBIS_OK; @@ -20,9 +59,51 @@ int PS4_SYSV_ABI sceAjmBatchErrorDump() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmBatchJobControlBufferRa() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); - return ORBIS_OK; +void* PS4_SYSV_ABI sceAjmBatchJobControlBufferRa(AjmSingleJob* batch_pos, u32 instance, + AjmFlags flags, u8* in_buffer, u32 in_size, + u8* out_buffer, u32 out_size, + const void* ret_addr) { + LOG_INFO(Lib_Ajm, + "called instance = {:#x}, flags = {:#x}, cmd = {}, in_size = {:#x}, out_size = {:#x}, " + "ret_addr = {}", + instance, flags.raw, magic_enum::enum_name(AjmJobControlFlags(flags.command)), in_size, + out_size, fmt::ptr(ret_addr)); + + const u64 mask = instance == AJM_INSTANCE_STATISTICS ? 0xc0018007ULL : 0x60000000e7ffULL; + flags.raw &= mask; + + const bool is_debug = ret_addr != nullptr; + batch_pos->opcode.instance = instance; + batch_pos->opcode.codec_flags = flags.codec; + batch_pos->opcode.command_flags = flags.command; + batch_pos->opcode.sideband_flags = AjmJobSidebandFlags(flags.sideband); + batch_pos->opcode.is_debug = is_debug; + batch_pos->opcode.is_statistic = instance == AJM_INSTANCE_STATISTICS; + batch_pos->opcode.is_control = true; + + AjmInOutJob* job = nullptr; + if (ret_addr == nullptr) { + batch_pos->job_size = sizeof(AjmInOutJob); + job = &batch_pos->job; + } else { + batch_pos->job_size = sizeof(AjmInOutJob) + 16; + batch_pos->ret.unk1 = batch_pos->ret.unk1 & 0xfffffff0 | 6; + batch_pos->ret.unk2 = 0; + batch_pos->ret.ret_addr = ret_addr; + job = &batch_pos->ret.job; + } + + job->input.props &= 0xffffffe0; + job->input.props |= 2; + job->input.buf_size = in_size; + job->input.buffer = in_buffer; + job->unk1 = (job->unk1 & 0xfc000030) + ((flags.raw >> 0x1a) & 0x180000) + 3; + job->flags = u32(flags.raw); + job->output.props &= 0xffffffe0; + job->output.props |= 0x12; + job->output.buf_size = out_size; + job->output.buffer = out_buffer; + return ++job; } int PS4_SYSV_ABI sceAjmBatchJobInlineBuffer() { @@ -35,13 +116,168 @@ int PS4_SYSV_ABI sceAjmBatchJobRunBufferRa() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmBatchJobRunSplitBufferRa() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); - return ORBIS_OK; +void* PS4_SYSV_ABI sceAjmBatchJobRunSplitBufferRa(AjmMultiJob* batch_pos, u32 instance, + AjmFlags flags, const AjmBuffer* in_buffers, + u64 num_in_buffers, const AjmBuffer* out_buffers, + u64 num_out_buffers, void* sideband_output, + u64 sideband_output_size, const void* ret_addr) { + LOG_DEBUG(Lib_Ajm, + "called instance = {}, flags = {:#x}, cmd = {}, sideband_cmd = {} num_input_buffers " + "= {}, num_output_buffers = {}, " + "ret_addr = {}", + instance, flags.raw, magic_enum::enum_name(AjmJobRunFlags(flags.command)), + magic_enum::enum_name(AjmJobSidebandFlags(flags.sideband)), num_in_buffers, + num_out_buffers, fmt::ptr(ret_addr)); + const u32 job_size = (num_in_buffers * 2 + 1 + num_out_buffers * 2) * 8; + const bool is_debug = ret_addr != nullptr; + batch_pos->opcode.instance = instance; + batch_pos->opcode.codec_flags = flags.codec; + batch_pos->opcode.command_flags = flags.command; + batch_pos->opcode.sideband_flags = AjmJobSidebandFlags(flags.sideband); + batch_pos->opcode.is_debug = is_debug; + batch_pos->opcode.is_statistic = false; + batch_pos->opcode.is_control = false; + + u32* job = nullptr; + if (!is_debug) { + batch_pos->job_size = job_size + 16; + job = batch_pos->job; + } else { + batch_pos->job_size = job_size + 32; + batch_pos->ret.unk1 &= 0xfffffff0; + batch_pos->ret.unk1 |= 6; + batch_pos->ret.unk2 = 0; + batch_pos->ret.ret_addr = ret_addr; + job = batch_pos->ret.job; + } + + for (s32 i = 0; i < num_in_buffers; i++) { + AjmJobBuffer* in_buf = reinterpret_cast(job); + in_buf->props &= 0xffffffe0; + in_buf->props |= 1; + in_buf->buf_size = in_buffers[i].size; + in_buf->buffer = in_buffers[i].addr; + job += 4; + } + job[1] = u32(flags.raw & 0xe00000001fffULL); + job[0] &= 0xfc000030; + job[0] = s32((flags.raw & 0xe00000001fffULL) >> 0x1a) + 4; + job += 2; + + for (s32 i = 0; i < num_out_buffers; i++) { + AjmJobBuffer* out_buf = reinterpret_cast(job); + out_buf->props &= 0xffffffe0; + out_buf->props |= 0x11; + out_buf->buf_size = out_buffers[i].size; + out_buf->buffer = out_buffers[i].addr; + job += 4; + } + job[0] = job[0] & 0xffffffe0 | 0x12; + job[1] = sideband_output_size; + memcpy(&job[2], &sideband_output, sizeof(void*)); + return job + 4; } -int PS4_SYSV_ABI sceAjmBatchStartBuffer() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); +int PS4_SYSV_ABI sceAjmBatchStartBuffer(u32 context, const u8* batch, u32 batch_size, + const int priority, AjmBatchError* patch_error, + u32* out_batch_id) { + LOG_DEBUG(Lib_Ajm, "called context = {}, batch_size = {:#x}, priority = {}", context, + batch_size, priority); + + if ((batch_size & 7) != 0) { + return ORBIS_AJM_ERROR_MALFORMED_BATCH; + } + + static constexpr u32 MaxBatches = 1000; + + struct BatchInfo { + u16 instance; + u16 offset_in_qwords; + }; + std::array batches{}; + u32 num_batches = 0; + + const u8* batch_ptr = batch; + const u8* batch_end = batch + batch_size; + while (batch_ptr < batch_end) { + if (num_batches >= MaxBatches) { + LOG_ERROR(Lib_Ajm, "Too many batches in job!"); + return ORBIS_AJM_ERROR_OUT_OF_MEMORY; + } + AjmJobHeader header; + std::memcpy(&header, batch_ptr, sizeof(u64)); + + const auto& opcode = header.opcode; + const u32 instance = opcode.instance; + const u8* job_ptr = batch_ptr + sizeof(AjmJobHeader) + opcode.is_debug * 16; + + if (opcode.is_control) { + ASSERT_MSG(!opcode.is_statistic, "Statistic instance is not handled"); + const auto command = AjmJobControlFlags(opcode.command_flags); + switch (command) { + case AjmJobControlFlags::Reset: { + LOG_INFO(Lib_Ajm, "Resetting instance {}", opcode.instance); + dev->instances[opcode.instance]->Reset(); + break; + } + case (AjmJobControlFlags::Initialize | AjmJobControlFlags::Reset): + LOG_INFO(Lib_Ajm, "Initializing instance {}", opcode.instance); + break; + case AjmJobControlFlags::Resample: + LOG_INFO(Lib_Ajm, "Set resample params of instance {}", opcode.instance); + break; + default: + break; + } + + // Write sideband structures. + const AjmJobBuffer* out_buffer = reinterpret_cast(job_ptr + 24); + auto* result = reinterpret_cast(out_buffer->buffer); + result->result = 0; + result->internal_result = 0; + } else { + const auto command = AjmJobRunFlags(opcode.command_flags); + const auto sideband = AjmJobSidebandFlags(opcode.sideband_flags); + const AjmJobBuffer* in_buffer = reinterpret_cast(job_ptr); + const AjmJobBuffer* out_buffer = reinterpret_cast(job_ptr + 24); + job_ptr += 24; + + LOG_INFO(Lib_Ajm, "Decode job cmd = {}, sideband = {}, in_addr = {}, in_size = {}", + magic_enum::enum_name(command), magic_enum::enum_name(sideband), + fmt::ptr(in_buffer->buffer), in_buffer->buf_size); + + // Decode as much of the input bitstream as possible. + auto* instance = dev->instances[opcode.instance].get(); + const auto [in_remain, out_remain, num_frames] = instance->Decode( + in_buffer->buffer, in_buffer->buf_size, out_buffer->buffer, out_buffer->buf_size); + + // Write sideband structures. + auto* sideband_ptr = *reinterpret_cast(job_ptr + 8); + auto* result = reinterpret_cast(sideband_ptr); + result->result = 0; + result->internal_result = 0; + sideband_ptr += sizeof(AjmSidebandResult); + + // Check sideband flags + if (True(sideband & AjmJobSidebandFlags::Stream)) { + auto* stream = reinterpret_cast(sideband_ptr); + stream->input_consumed = in_buffer->buf_size - in_remain; + stream->output_written = out_buffer->buf_size - out_remain; + stream->total_decoded_samples = instance->decoded_samples; + sideband_ptr += sizeof(AjmSidebandStream); + } + if (True(command & AjmJobRunFlags::MultipleFrames)) { + auto* mframe = reinterpret_cast(sideband_ptr); + mframe->num_frames = num_frames; + sideband_ptr += sizeof(AjmSidebandMFrame); + } + } + + batch_ptr += sizeof(AjmJobHeader) + header.job_size; + } + static int batch_id = 0; + *out_batch_id = ++batch_id; + return ORBIS_OK; } @@ -55,9 +291,16 @@ int PS4_SYSV_ABI sceAjmDecAt9ParseConfigData() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmDecMp3ParseFrame() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); - return ORBIS_OK; +int PS4_SYSV_ABI sceAjmDecMp3ParseFrame(const u8* buf, u32 stream_size, int parse_ofl, + AjmDecMp3ParseFrame* frame) { + LOG_INFO(Lib_Ajm, "called parse_ofl = {}", parse_ofl); + if (buf == nullptr || stream_size < 4 || frame == nullptr) { + return ORBIS_AJM_ERROR_INVALID_PARAMETER; + } + if ((buf[0] & SYNCWORDH) != SYNCWORDH || (buf[1] & SYNCWORDL) != SYNCWORDL) { + return ORBIS_AJM_ERROR_INVALID_PARAMETER; + } + return AjmMp3Decoder::ParseMp3Header(buf, stream_size, parse_ofl, frame); } int PS4_SYSV_ABI sceAjmFinalize() { @@ -65,8 +308,13 @@ int PS4_SYSV_ABI sceAjmFinalize() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmInitialize() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); +int PS4_SYSV_ABI sceAjmInitialize(s64 reserved, u32* out_context) { + LOG_INFO(Lib_Ajm, "called reserved = {}", reserved); + if (out_context == nullptr || reserved != 0) { + return ORBIS_AJM_ERROR_INVALID_PARAMETER; + } + *out_context = 1; + dev = std::make_unique(); return ORBIS_OK; } @@ -75,13 +323,45 @@ int PS4_SYSV_ABI sceAjmInstanceCodecType() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmInstanceCreate() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); +int PS4_SYSV_ABI sceAjmInstanceCreate(u32 context, AjmCodecType codec_type, AjmInstanceFlags flags, + u32* out_instance) { + if (codec_type >= AjmCodecType::Max) { + return ORBIS_AJM_ERROR_INVALID_PARAMETER; + } + if (flags.version == 0) { + return ORBIS_AJM_ERROR_WRONG_REVISION_FLAG; + } + if (!dev->IsRegistered(codec_type)) { + return ORBIS_AJM_ERROR_CODEC_NOT_REGISTERED; + } + if (dev->curr_cursor == dev->release_cursor) { + return ORBIS_AJM_ERROR_OUT_OF_RESOURCES; + } + const u32 index = dev->free_instances[dev->curr_cursor++]; + dev->curr_cursor %= MaxInstances; + auto instance = std::make_unique(); + instance->index = index; + instance->codec_type = codec_type; + instance->num_channels = flags.channels; + dev->instances[index] = std::move(instance); + *out_instance = index; + LOG_INFO(Lib_Ajm, "called codec_type = {}, flags = {:#x}, instance = {}", + magic_enum::enum_name(codec_type), flags.raw, index); + return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmInstanceDestroy() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); +int PS4_SYSV_ABI sceAjmInstanceDestroy(u32 context, u32 instance) { + LOG_INFO(Lib_Ajm, "called context = {}, instance = {}", context, instance); + if ((instance & 0x3fff) > MaxInstances) { + return ORBIS_AJM_ERROR_INVALID_INSTANCE; + } + const u32 next_slot = (dev->release_cursor + 1) % MaxInstances; + if (next_slot != dev->curr_cursor) { + dev->free_instances[dev->release_cursor] = instance; + dev->release_cursor = next_slot; + } + dev->instances[instance].reset(); return ORBIS_OK; } @@ -105,8 +385,16 @@ int PS4_SYSV_ABI sceAjmMemoryUnregister() { return ORBIS_OK; } -int PS4_SYSV_ABI sceAjmModuleRegister() { - LOG_ERROR(Lib_Ajm, "(STUBBED) called"); +int PS4_SYSV_ABI sceAjmModuleRegister(u32 context, AjmCodecType codec_type, s64 reserved) { + LOG_INFO(Lib_Ajm, "called context = {}, codec_type = {}, reserved = {}", context, + u32(codec_type), reserved); + if (codec_type >= AjmCodecType::Max || reserved != 0) { + return ORBIS_AJM_ERROR_INVALID_PARAMETER; + } + if (dev->IsRegistered(codec_type)) { + return ORBIS_AJM_ERROR_CODEC_ALREADY_REGISTERED; + } + dev->Register(codec_type); return ORBIS_OK; } diff --git a/src/core/libraries/ajm/ajm.h b/src/core/libraries/ajm/ajm.h index 8491e519c..3b2853ae0 100644 --- a/src/core/libraries/ajm/ajm.h +++ b/src/core/libraries/ajm/ajm.h @@ -3,6 +3,7 @@ #pragma once +#include "common/enum.h" #include "common/types.h" namespace Core::Loader { @@ -11,26 +12,157 @@ class SymbolsResolver; namespace Libraries::Ajm { +struct AjmBatchInfo { + void* pBuffer; + u64 offset; + u64 size; +}; + +struct AjmBatchError { + int error_code; + const void* job_addr; + u32 cmd_offset; + const void* job_ra; +}; + +struct AjmBuffer { + u8* addr; + u64 size; +}; + +struct AjmJobBuffer { + u32 props; + u32 buf_size; + u8* buffer; +}; + +struct AjmInOutJob { + AjmJobBuffer input; + u32 unk1; + u32 flags; + AjmJobBuffer output; +}; + +enum class AjmJobControlFlags : u32 { + Reset = 1 << 2, + Initialize = 1 << 3, + Resample = 1 << 4, +}; +DECLARE_ENUM_FLAG_OPERATORS(AjmJobControlFlags) + +enum class AjmJobRunFlags : u32 { + GetCodecInfo = 1 << 0, + MultipleFrames = 1 << 1, +}; +DECLARE_ENUM_FLAG_OPERATORS(AjmJobRunFlags) + +enum class AjmJobSidebandFlags : u32 { + GaplessDecode = 1 << 0, + GetInfo = 1 << 1, + Stream = 1 << 2, +}; +DECLARE_ENUM_FLAG_OPERATORS(AjmJobSidebandFlags) + +struct AjmHLEOpcode { + u32 instance : 14; + u32 codec_flags : 8; + u32 command_flags : 4; + AjmJobSidebandFlags sideband_flags : 3; + u32 is_statistic : 1; + u32 is_debug : 1; + u32 is_control : 1; +}; + +struct AjmJobHeader { + AjmHLEOpcode opcode; + u32 job_size; +}; + +struct AjmSingleJob { + AjmHLEOpcode opcode; + u32 job_size; + union { + AjmInOutJob job; + struct { + u32 unk1; + u32 unk2; + const void* ret_addr; + AjmInOutJob job; + } ret; + }; +}; + +struct AjmMultiJob { + AjmHLEOpcode opcode; + u32 job_size; + union { + u32 job[]; + struct { + u32 unk1; + u32 unk2; + const void* ret_addr; + u32 job[]; + } ret; + }; +}; + +union AjmFlags { + u64 raw; + struct { + u64 version : 3; + u64 codec : 8; + u64 command : 4; + u64 reserved : 30; + u64 sideband : 3; + }; +}; + +union AjmInstanceFlags { + u64 raw; + struct { + u64 version : 3; + u64 channels : 4; + u64 format : 3; + u64 pad : 22; + u64 codec : 28; + }; +}; + +struct AjmDecMp3ParseFrame; +enum class AjmCodecType : u32; + int PS4_SYSV_ABI sceAjmBatchCancel(); int PS4_SYSV_ABI sceAjmBatchErrorDump(); -int PS4_SYSV_ABI sceAjmBatchJobControlBufferRa(); +void* PS4_SYSV_ABI sceAjmBatchJobControlBufferRa(AjmSingleJob* batch_pos, u32 instance, + AjmFlags flags, u8* in_buffer, u32 in_size, + u8* out_buffer, u32 out_size, + const void* ret_addr); int PS4_SYSV_ABI sceAjmBatchJobInlineBuffer(); int PS4_SYSV_ABI sceAjmBatchJobRunBufferRa(); -int PS4_SYSV_ABI sceAjmBatchJobRunSplitBufferRa(); -int PS4_SYSV_ABI sceAjmBatchStartBuffer(); +void* PS4_SYSV_ABI sceAjmBatchJobRunSplitBufferRa(AjmMultiJob* batch_pos, u32 instance, + AjmFlags flags, const AjmBuffer* input_buffers, + u64 num_input_buffers, + const AjmBuffer* output_buffers, + u64 num_output_buffers, void* sideband_output, + u64 sideband_output_size, const void* ret_addr); +int PS4_SYSV_ABI sceAjmBatchStartBuffer(u32 context, const u8* batch, u32 batch_size, + const int priority, AjmBatchError* patch_error, + u32* out_batch_id); int PS4_SYSV_ABI sceAjmBatchWait(); int PS4_SYSV_ABI sceAjmDecAt9ParseConfigData(); -int PS4_SYSV_ABI sceAjmDecMp3ParseFrame(); +int PS4_SYSV_ABI sceAjmDecMp3ParseFrame(const u8* stream, u32 stream_size, int parse_ofl, + AjmDecMp3ParseFrame* frame); int PS4_SYSV_ABI sceAjmFinalize(); -int PS4_SYSV_ABI sceAjmInitialize(); +int PS4_SYSV_ABI sceAjmInitialize(s64 reserved, u32* out_context); int PS4_SYSV_ABI sceAjmInstanceCodecType(); -int PS4_SYSV_ABI sceAjmInstanceCreate(); -int PS4_SYSV_ABI sceAjmInstanceDestroy(); +int PS4_SYSV_ABI sceAjmInstanceCreate(u32 context, AjmCodecType codec_type, AjmInstanceFlags flags, + u32* instance); +int PS4_SYSV_ABI sceAjmInstanceDestroy(u32 context, u32 instance); int PS4_SYSV_ABI sceAjmInstanceExtend(); int PS4_SYSV_ABI sceAjmInstanceSwitch(); int PS4_SYSV_ABI sceAjmMemoryRegister(); int PS4_SYSV_ABI sceAjmMemoryUnregister(); -int PS4_SYSV_ABI sceAjmModuleRegister(); +int PS4_SYSV_ABI sceAjmModuleRegister(u32 context, AjmCodecType codec_type, s64 reserved); int PS4_SYSV_ABI sceAjmModuleUnregister(); int PS4_SYSV_ABI sceAjmStrError(); diff --git a/src/core/libraries/ajm/ajm_instance.h b/src/core/libraries/ajm/ajm_instance.h new file mode 100644 index 000000000..4a5e94be4 --- /dev/null +++ b/src/core/libraries/ajm/ajm_instance.h @@ -0,0 +1,70 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/types.h" + +extern "C" { +struct AVCodec; +struct AVCodecContext; +struct AVCodecParserContext; +} + +namespace Libraries::Ajm { + +enum class AjmCodecType : u32 { + Mp3Dec = 0, + At9Dec = 1, + M4aacDec = 2, + Max = 23, +}; +static constexpr u32 NumAjmCodecs = u32(AjmCodecType::Max); + +enum class AjmFormatEncoding : u32 { + S16 = 0, + S32 = 1, + Float = 2, +}; + +struct AjmSidebandResult { + s32 result; + s32 internal_result; +}; + +struct AjmSidebandMFrame { + u32 num_frames; + u32 reserved; +}; + +struct AjmSidebandStream { + s32 input_consumed; + s32 output_written; + u64 total_decoded_samples; +}; + +struct AjmSidebandFormat { + u32 num_channels; + u32 channel_mask; + u32 sampl_freq; + AjmFormatEncoding sample_encoding; + u32 bitrate; + u32 reserved; +}; + +struct AjmInstance { + AjmCodecType codec_type; + u32 decoded_samples{}; + AjmFormatEncoding fmt{}; + u32 num_channels{}; + + explicit AjmInstance() = default; + virtual ~AjmInstance() = default; + + virtual void Reset() = 0; + + virtual std::tuple Decode(const u8* in_buf, u32 in_size, u8* out_buf, + u32 out_size) = 0; +}; + +} // namespace Libraries::Ajm \ No newline at end of file diff --git a/src/core/libraries/ajm/ajm_mp3.cpp b/src/core/libraries/ajm/ajm_mp3.cpp new file mode 100644 index 000000000..9ef138aad --- /dev/null +++ b/src/core/libraries/ajm/ajm_mp3.cpp @@ -0,0 +1,150 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma clang optimize off +#include "common/assert.h" +#include "core/libraries/ajm/ajm_mp3.h" + +extern "C" { +#include +#include +#include +} + +namespace Libraries::Ajm { + +// Following tables have been reversed from AJM library +static constexpr std::array, 3> SamplerateTable = {{ + {0x5622, 0x5DC0, 0x3E80}, + {0xAC44, 0xBB80, 0x7D00}, + {0x2B11, 0x2EE0, 0x1F40}, +}}; + +static constexpr std::array, 2> BitrateTable = {{ + {0, 0x20, 0x28, 0x30, 0x38, 0x40, 0x50, 0x60, 0x70, 0x80, 0xA0, 0xC0, 0xE0, 0x100, 0x140}, + {0, 0x8, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xA0}, +}}; + +static constexpr std::array UnkTable = {0x48, 0x90}; + +SwrContext* swr_context{}; + +AVFrame* ConvertAudioFrame(AVFrame* frame) { + auto pcm16_frame = av_frame_clone(frame); + pcm16_frame->format = AV_SAMPLE_FMT_S16; + + if (swr_context) { + swr_free(&swr_context); + swr_context = nullptr; + } + AVChannelLayout in_ch_layout = frame->ch_layout; + AVChannelLayout out_ch_layout = pcm16_frame->ch_layout; + swr_alloc_set_opts2(&swr_context, &out_ch_layout, AV_SAMPLE_FMT_S16, frame->sample_rate, + &in_ch_layout, AVSampleFormat(frame->format), frame->sample_rate, 0, + nullptr); + swr_init(swr_context); + const auto res = swr_convert_frame(swr_context, pcm16_frame, frame); + if (res < 0) { + LOG_ERROR(Lib_AvPlayer, "Could not convert to S16: {}", av_err2str(res)); + return nullptr; + } + av_frame_free(&frame); + return pcm16_frame; +} + +AjmMp3Decoder::AjmMp3Decoder() { + codec = avcodec_find_decoder(AV_CODEC_ID_MP3); + ASSERT_MSG(codec, "MP3 codec not found"); + parser = av_parser_init(codec->id); + ASSERT_MSG(parser, "Parser not found"); + AjmMp3Decoder::Reset(); +} + +AjmMp3Decoder::~AjmMp3Decoder() { + avcodec_free_context(&c); + av_free(c); +} + +void AjmMp3Decoder::Reset() { + if (c) { + avcodec_free_context(&c); + av_free(c); + } + c = avcodec_alloc_context3(codec); + ASSERT_MSG(c, "Could not allocate audio codec context"); + int ret = avcodec_open2(c, codec, nullptr); + ASSERT_MSG(ret >= 0, "Could not open codec"); + decoded_samples = 0; + static int filename = 0; + file.close(); + file.open(fmt::format("inst{}_{}.raw", index, ++filename), std::ios::out | std::ios::binary); +} + +std::tuple AjmMp3Decoder::Decode(const u8* buf, u32 in_size, u8* out_buf, + u32 out_size) { + u32 num_frames = 0; + AVPacket* pkt = av_packet_alloc(); + while (in_size > 0 && out_size > 0) { + int ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size, buf, in_size, AV_NOPTS_VALUE, + AV_NOPTS_VALUE, 0); + ASSERT_MSG(ret >= 0, "Error while parsing {}", ret); + buf += ret; + in_size -= ret; + + if (pkt->size) { + // Send the packet with the compressed data to the decoder + pkt->pts = parser->pts; + pkt->dts = parser->dts; + pkt->flags = (parser->key_frame == 1) ? AV_PKT_FLAG_KEY : 0; + ret = avcodec_send_packet(c, pkt); + ASSERT_MSG(ret >= 0, "Error submitting the packet to the decoder {}", ret); + + // Read all the output frames (in general there may be any number of them + while (ret >= 0) { + AVFrame* frame = av_frame_alloc(); + ret = avcodec_receive_frame(c, frame); + if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) { + break; + } else if (ret < 0) { + UNREACHABLE_MSG("Error during decoding"); + } + if (frame->format != AV_SAMPLE_FMT_S16) { + frame = ConvertAudioFrame(frame); + } + const auto size = frame->ch_layout.nb_channels * frame->nb_samples * sizeof(u16); + std::memcpy(out_buf, frame->data[0], size); + file.write((const char*)frame->data[0], size); + out_buf += size; + out_size -= size; + decoded_samples += frame->nb_samples; + num_frames++; + av_frame_free(&frame); + } + } + } + av_packet_free(&pkt); + return std::make_tuple(in_size, out_size, num_frames); +} + +int AjmMp3Decoder::ParseMp3Header(const u8* buf, u32 stream_size, int parse_ofl, + AjmDecMp3ParseFrame* frame) { + const u32 unk_idx = buf[1] >> 3 & 1; + const s32 version_idx = (buf[1] >> 3 & 3) ^ 2; + const s32 sr_idx = buf[2] >> 2 & 3; + const s32 br_idx = (buf[2] >> 4) & 0xf; + const s32 padding_bit = (buf[2] >> 1) & 0x1; + + frame->sample_rate = SamplerateTable[version_idx][sr_idx]; + frame->bitrate = BitrateTable[version_idx != 1][br_idx] * 1000; + frame->num_channels = (buf[3] < 0xc0) + 1; + frame->frame_size = (UnkTable[unk_idx] * frame->bitrate) / frame->sample_rate + padding_bit; + frame->samples_per_channel = UnkTable[unk_idx] * 8; + frame->encoder_delay = 0; + if (parse_ofl == 0) { + return 0; + } + + return 0; +} + +} // namespace Libraries::Ajm \ No newline at end of file diff --git a/src/core/libraries/ajm/ajm_mp3.h b/src/core/libraries/ajm/ajm_mp3.h new file mode 100644 index 000000000..0bb1a8b94 --- /dev/null +++ b/src/core/libraries/ajm/ajm_mp3.h @@ -0,0 +1,78 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include +#include "common/types.h" +#include "core/libraries/ajm/ajm_instance.h" + +extern "C" { +struct AVCodec; +struct AVCodecContext; +struct AVCodecParserContext; +} + +namespace Libraries::Ajm { + +enum class AjmDecMp3OflType : u32 { None = 0, Lame = 1, Vbri = 2, Fgh = 3, VbriAndFgh = 4 }; + +// 11-bit syncword if MPEG 2.5 extensions are enabled +static constexpr u8 SYNCWORDH = 0xff; +static constexpr u8 SYNCWORDL = 0xe0; + +struct AjmDecMp3ParseFrame { + u64 frame_size; + u32 num_channels; + u32 samples_per_channel; + u32 bitrate; + u32 sample_rate; + u32 encoder_delay; + u32 num_frames; + u32 total_samples; + AjmDecMp3OflType ofl_type; +}; + +enum class ChannelMode : u8 { + Stereo = 0, + JointStero = 1, + Dual = 2, + Mono = 3, +}; + +struct AjmSidebandDecMp3CodecInfo { + u32 header; + bool has_crc; + ChannelMode channel_mode; + u8 mode_extension; + u8 copyright; + u8 original; + u8 emphasis; + u16 reserved[3]; +}; + +struct AjmDecMp3GetCodecInfoResult { + AjmSidebandResult result; + AjmSidebandDecMp3CodecInfo codec_info; +}; + +struct AjmMp3Decoder : public AjmInstance { + const AVCodec* codec = nullptr; + AVCodecContext* c = nullptr; + AVCodecParserContext* parser = nullptr; + u32 index; + std::ofstream file; + + explicit AjmMp3Decoder(); + ~AjmMp3Decoder() override; + + void Reset() override; + + std::tuple Decode(const u8* in_buf, u32 in_size, u8* out_buf, + u32 out_size) override; + + static int ParseMp3Header(const u8* buf, u32 stream_size, int parse_ofl, + AjmDecMp3ParseFrame* frame); +}; + +} // namespace Libraries::Ajm \ No newline at end of file