RPCSX/rpcsx
1
0
Fork 0
mirror of https://github.com/RPCSX/rpcsx.git synced 2025-12-06 07:12:14 +01:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
rpcsx/ps3fw/cellAdec.cpp

2292 lines
85 KiB
C++
Raw Blame History

#include "stdafx.h"
#include "Emu/perf_meter.hpp"
#include "Emu/Cell/PPUModule.h"
#include "cellos/sys_sync.h"
#include "cellos/sys_ppu_thread.h"
#include "Emu/savestate_utils.hpp"
#include "sysPrxForUser.h"
#include "cellAdec.h"
#include "util/simd.hpp"
#include "util/asm.hpp"
LOG_CHANNEL(cellAdec);
// These need to be defined somewhere to access the LLE functions
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_ac3;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_atrac3;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_atrac3multi;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Celp8;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Celp;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Ddp;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_DtsCore;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_DtsHd_Core;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_DtsHd;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_DtsLbr;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Aac;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_mpmc;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_M4Aac;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_M4Aac2ch;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_M4Aac2chmod;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Mp3;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_Mp3s;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_mpmcl1;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_truehd;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_wma;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_WmaLsl;
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_WmaPro;
error_code _SceAdecCorrectPtsValue_Celp8(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_Celp(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_Ddp(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_DtsCore(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_DtsHd_Core(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_DtsHd(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_DtsLbr(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_Aac(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_mpmc(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_M4Aac(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_M4Aac2ch(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_M4Aac2chmod(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_Mp3s(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_mpmcl1(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_truehd(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_wma(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_WmaLsl(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
error_code _SceAdecCorrectPtsValue_WmaPro(ppu_thread&, vm::ptr<void>, vm::ptr<CellCodecTimeStamp>)
{
UNIMPLEMENTED_FUNC(cellAdec);
return CELL_OK;
}
template <>
void fmt_class_string<CellAdecError>::format(std::string& out, u64 arg)
{
format_enum(out, arg, [](CellAdecError value)
{
switch (value)
{
STR_CASE(CELL_ADEC_ERROR_FATAL);
STR_CASE(CELL_ADEC_ERROR_SEQ);
STR_CASE(CELL_ADEC_ERROR_ARG);
STR_CASE(CELL_ADEC_ERROR_BUSY);
STR_CASE(CELL_ADEC_ERROR_EMPTY);
STR_CASE(CELL_ADEC_ERROR_CELP_BUSY);
STR_CASE(CELL_ADEC_ERROR_CELP_EMPTY);
STR_CASE(CELL_ADEC_ERROR_CELP_ARG);
STR_CASE(CELL_ADEC_ERROR_CELP_SEQ);
STR_CASE(CELL_ADEC_ERROR_CELP_CORE_FATAL);
STR_CASE(CELL_ADEC_ERROR_CELP_CORE_ARG);
STR_CASE(CELL_ADEC_ERROR_CELP_CORE_SEQ);
STR_CASE(CELL_ADEC_ERROR_CELP8_BUSY);
STR_CASE(CELL_ADEC_ERROR_CELP8_EMPTY);
STR_CASE(CELL_ADEC_ERROR_CELP8_ARG);
STR_CASE(CELL_ADEC_ERROR_CELP8_SEQ);
STR_CASE(CELL_ADEC_ERROR_CELP8_CORE_FATAL);
STR_CASE(CELL_ADEC_ERROR_CELP8_CORE_ARG);
STR_CASE(CELL_ADEC_ERROR_CELP8_CORE_SEQ);
STR_CASE(CELL_ADEC_ERROR_M4AAC_FATAL);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SEQ);
STR_CASE(CELL_ADEC_ERROR_M4AAC_ARG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_BUSY);
STR_CASE(CELL_ADEC_ERROR_M4AAC_EMPTY);
STR_CASE(CELL_ADEC_ERROR_M4AAC_BUFFER_OVERFLOW);
STR_CASE(CELL_ADEC_ERROR_M4AAC_END_OF_BITSTREAM);
STR_CASE(CELL_ADEC_ERROR_M4AAC_CH_CONFIG_INCONSISTENCY);
STR_CASE(CELL_ADEC_ERROR_M4AAC_NO_CH_DEFAULT_POS);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_CH_POS);
STR_CASE(CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_COUPLING_CH);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_LAYER_ID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_ADTS_SYNCWORD_ERROR);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_ADTS_ID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_CH_CHANGED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SAMPLING_FREQ_CHANGED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_WRONG_SBR_CH);
STR_CASE(CELL_ADEC_ERROR_M4AAC_WRONG_SCALE_FACTOR);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_BOOKS);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_SECTION_DATA);
STR_CASE(CELL_ADEC_ERROR_M4AAC_PULSE_IS_NOT_LONG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GC_IS_NOT_SUPPORTED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_ELEMENT_ID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_NO_CH_CONFIG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_UNEXPECTED_OVERLAP_CRC);
STR_CASE(CELL_ADEC_ERROR_M4AAC_CRC_BUFFER_EXCEEDED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_CRC);
STR_CASE(CELL_ADEC_ERROR_M4AAC_BAD_WINDOW_CODE);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_ADIF_HEADER_ID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_NOT_SUPPORTED_PROFILE);
STR_CASE(CELL_ADEC_ERROR_M4AAC_PROG_NUMBER_NOT_FOUND);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_SAMP_RATE_INDEX);
STR_CASE(CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_CH_CONFIG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_PULSE_OVERFLOWED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_CAN_NOT_UNPACK_INDEX);
STR_CASE(CELL_ADEC_ERROR_M4AAC_DEINTERLEAVE_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_CALC_BAND_OFFSET_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_SCALE_FACTOR_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_CC_GAIN_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_MIX_COUPLING_CH_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GROUP_IS_INVALID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_PREDICT_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_PREDICT_RESET_PATTERN);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVALID_TNS_FRAME_INFO);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_MASK_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_GROUP_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_LPFLAG_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_INVERSE_QUANTIZATION_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_CB_MAP_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_GET_PULSE_FAILED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_MONO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_STEREO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_CH_OVERFLOW);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_NOSYNCH);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PROGRAM);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_TAG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_CHN_CONFIG);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SECTION);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SCFACTORS);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PULSE_DATA);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_MAIN_PROFILE_NOT_IMPLEMENTED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_GC_NOT_IMPLEMENTED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PLUS_ELE_ID);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_CREATE_ERROR);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_NOT_INITIALIZED);
STR_CASE(CELL_ADEC_ERROR_M4AAC_SBR_INVALID_ENVELOPE);
STR_CASE(CELL_ADEC_ERROR_AC3_BUSY);
STR_CASE(CELL_ADEC_ERROR_AC3_EMPTY);
STR_CASE(CELL_ADEC_ERROR_AC3_PARAM);
STR_CASE(CELL_ADEC_ERROR_AC3_FRAME);
STR_CASE(CELL_ADEC_ERROR_AT3_OK); // CELL_ADEC_ERROR_AT3_OFFSET
STR_CASE(CELL_ADEC_ERROR_AT3_BUSY);
STR_CASE(CELL_ADEC_ERROR_AT3_EMPTY);
STR_CASE(CELL_ADEC_ERROR_AT3_ERROR);
STR_CASE(CELL_ADEC_ERROR_LPCM_FATAL);
STR_CASE(CELL_ADEC_ERROR_LPCM_SEQ);
STR_CASE(CELL_ADEC_ERROR_LPCM_ARG);
STR_CASE(CELL_ADEC_ERROR_LPCM_BUSY);
STR_CASE(CELL_ADEC_ERROR_LPCM_EMPTY);
STR_CASE(CELL_ADEC_ERROR_MP3_OK); // CELL_ADEC_ERROR_MP3_OFFSET
STR_CASE(CELL_ADEC_ERROR_MP3_BUSY);
STR_CASE(CELL_ADEC_ERROR_MP3_EMPTY);
STR_CASE(CELL_ADEC_ERROR_MP3_ERROR);
STR_CASE(CELL_ADEC_ERROR_MP3_LOST_SYNC);
STR_CASE(CELL_ADEC_ERROR_MP3_NOT_L3);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_BITRATE);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_SFREQ);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_EMPHASIS);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_BLKTYPE);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_VERSION);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_MODE);
STR_CASE(CELL_ADEC_ERROR_MP3_BAD_MODE_EXT);
STR_CASE(CELL_ADEC_ERROR_MP3_HUFFMAN_NUM);
STR_CASE(CELL_ADEC_ERROR_MP3_HUFFMAN_CASE_ID);
STR_CASE(CELL_ADEC_ERROR_MP3_SCALEFAC_COMPRESS);
STR_CASE(CELL_ADEC_ERROR_MP3_HGETBIT);
STR_CASE(CELL_ADEC_ERROR_MP3_FLOATING_EXCEPTION);
STR_CASE(CELL_ADEC_ERROR_MP3_ARRAY_OVERFLOW);
STR_CASE(CELL_ADEC_ERROR_MP3_STEREO_PROCESSING);
STR_CASE(CELL_ADEC_ERROR_MP3_JS_BOUND);
STR_CASE(CELL_ADEC_ERROR_MP3_PCMOUT);
STR_CASE(CELL_ADEC_ERROR_M2BC_FATAL);
STR_CASE(CELL_ADEC_ERROR_M2BC_SEQ);
STR_CASE(CELL_ADEC_ERROR_M2BC_ARG);
STR_CASE(CELL_ADEC_ERROR_M2BC_BUSY);
STR_CASE(CELL_ADEC_ERROR_M2BC_EMPTY);
STR_CASE(CELL_ADEC_ERROR_M2BC_SYNCF);
STR_CASE(CELL_ADEC_ERROR_M2BC_LAYER);
STR_CASE(CELL_ADEC_ERROR_M2BC_BITRATE);
STR_CASE(CELL_ADEC_ERROR_M2BC_SAMPLEFREQ);
STR_CASE(CELL_ADEC_ERROR_M2BC_VERSION);
STR_CASE(CELL_ADEC_ERROR_M2BC_MODE_EXT);
STR_CASE(CELL_ADEC_ERROR_M2BC_UNSUPPORT);
STR_CASE(CELL_ADEC_ERROR_M2BC_OPENBS_EX);
STR_CASE(CELL_ADEC_ERROR_M2BC_SYNCF_EX);
STR_CASE(CELL_ADEC_ERROR_M2BC_CRCGET_EX);
STR_CASE(CELL_ADEC_ERROR_M2BC_CRC_EX);
STR_CASE(CELL_ADEC_ERROR_M2BC_CRCGET);
STR_CASE(CELL_ADEC_ERROR_M2BC_CRC);
STR_CASE(CELL_ADEC_ERROR_M2BC_BITALLOC);
STR_CASE(CELL_ADEC_ERROR_M2BC_SCALE);
STR_CASE(CELL_ADEC_ERROR_M2BC_SAMPLE);
STR_CASE(CELL_ADEC_ERROR_M2BC_OPENBS);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_CRCGET);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_CRC);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_BITALLOC);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_SCALE);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_SAMPLE);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_HEADER);
STR_CASE(CELL_ADEC_ERROR_M2BC_MC_STATUS);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_CCRCGET);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_CRC);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_BITALLOC);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_SCALE);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_SAMPLE);
STR_CASE(CELL_ADEC_ERROR_M2BC_AG_STATUS);
}
return unknown;
});
}
// LPCM decoder (included in cellAdec/libadec.sprx)
vm::gvar<CellAdecCoreOps> g_cell_adec_core_ops_lpcm;
void LpcmDecContext::exec(ppu_thread& ppu)
{
perf_meter<"LPCMDEC"_u64> perf0;
switch (savestate)
{
case lpcm_dec_state::waiting_for_cmd_mutex_lock: break;
case lpcm_dec_state::waiting_for_cmd_cond_wait: break;
case lpcm_dec_state::waiting_for_output_mutex_lock: goto output_mutex_lock;
case lpcm_dec_state::waiting_for_output_cond_wait: goto output_cond_wait;
case lpcm_dec_state::queue_mutex_lock: goto queue_mutex_lock;
case lpcm_dec_state::executing_cmd: goto execute_cmd;
}
for (; run_thread; cmd_counter++)
{
cellAdec.trace("Command counter: %llu, waiting for next command...", cmd_counter);
// Wait for a command to become available
error_occurred |= static_cast<u32>(cmd_available.acquire(ppu, savestate) != CELL_OK);
if (ppu.state & cpu_flag::again)
{
return;
}
cellAdec.trace("Command available, waiting for output to be consumed...");
// Wait for the output to be consumed.
// The output has to be consumed even if the next command is not a decode command
savestate = lpcm_dec_state::waiting_for_output_mutex_lock;
output_mutex_lock:
error_occurred |= static_cast<u32>(sys_mutex_lock(ppu, output_mutex, 0) != CELL_OK);
if (ppu.state & cpu_flag::again)
{
return;
}
while (output_locked)
{
savestate = lpcm_dec_state::waiting_for_output_cond_wait;
output_cond_wait:
ensure(sys_cond_wait(ppu, output_consumed, 0) == CELL_OK); // Error code isn't checked on LLE
if (ppu.state & cpu_flag::again)
{
return;
}
}
cellAdec.trace("Output consumed");
// Pop command from queue
savestate = lpcm_dec_state::queue_mutex_lock;
queue_mutex_lock:
ensure(sys_mutex_lock(ppu, queue_mutex, 0) == CELL_OK); // Error code isn't checked on LLE
if (ppu.state & cpu_flag::again)
{
return;
}
cmd_queue.pop(cmd);
ensure(sys_mutex_unlock(ppu, queue_mutex) == CELL_OK); // Error code isn't checked on LLE
cellAdec.trace("Command type: %d", static_cast<u32>(cmd.type.get()));
savestate = lpcm_dec_state::executing_cmd;
execute_cmd:
switch (cmd.type)
{
case LpcmDecCmdType::start_seq:
// LLE sends a command to the SPU thread. The SPU thread consumes the command without doing anything, however
error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
break;
case LpcmDecCmdType::end_seq:
{
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return;
}
// Doesn't do anything else
notify_seq_done.cbFunc(ppu, notify_seq_done.cbArg);
error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
break;
}
case LpcmDecCmdType::close:
ensure(sys_mutex_unlock(ppu, output_mutex) == CELL_OK); // Error code isn't checked on LLE
return;
case LpcmDecCmdType::decode_au:
{
// For 20 and 24-bit samples
const u8* const input_u8 = static_cast<const u8*>(cmd.au_start_addr.get_ptr());
const s64 au_size_u8 = cmd.au_size;
// For 16-bit samples
const be_t<s16, 1>* const input_s16 = static_cast<const be_t<s16, 1>*>(cmd.au_start_addr.get_ptr());
const s64 au_size_s16 = static_cast<s64>(au_size_u8 / sizeof(s16));
be_t<f32>* const _output = std::assume_aligned<0x80>(output.get_ptr());
s64 output_size = cmd.au_size;
s32 sample_num = static_cast<s32>(utils::align(+lpcm_param->audioPayloadSize, 0x10));
s32 channel_num = 0;
if (!dvd_packing)
{
switch (lpcm_param->sizeOfWord)
{
case CELL_ADEC_BIT_LENGTH_16:
output_size = output_size * 32 / 16;
sample_num /= 2;
break;
case CELL_ADEC_BIT_LENGTH_20: // Same as below
case CELL_ADEC_BIT_LENGTH_24:
output_size = output_size * 32 / 24;
sample_num /= 3;
break;
default:; // LLE skips decoding entirely, the output buffer isn't written to, and it outputs whatever was there before
}
// LPCM streams with an odd number of channels contain an empty dummy channel
switch (lpcm_param->channelNumber)
{
case CELL_ADEC_CH_MONO:
channel_num = 1;
output_size = output_size * 1 / 2;
break;
case CELL_ADEC_CH_STEREO: channel_num = 2; break;
case CELL_ADEC_CH_3_0: // Same as below
case CELL_ADEC_CH_2_1:
channel_num = 3;
output_size = output_size * 3 / 4;
break;
case CELL_ADEC_CH_3_1: // Same as below
case CELL_ADEC_CH_2_2: channel_num = 4; break;
case CELL_ADEC_CH_3_2:
channel_num = 5;
output_size = output_size * 5 / 6;
break;
case CELL_ADEC_CH_3_2_LFE: channel_num = 6; break;
case CELL_ADEC_CH_3_4:
channel_num = 7;
output_size = output_size * 7 / 8;
break;
case CELL_ADEC_CH_3_4_LFE: channel_num = 8; break;
default:; // Don't do anything, LLE simply skips reordering channels
}
// LLE doesn't check the output size
ensure(output_size <= LPCM_DEC_OUTPUT_BUFFER_SIZE);
ensure(sample_num * sizeof(f32) <= LPCM_DEC_OUTPUT_BUFFER_SIZE);
// Convert to float
if (lpcm_param->sizeOfWord == CELL_ADEC_BIT_LENGTH_16)
{
s64 i = 0;
for (; i <= au_size_s16 - 8; i += 8)
{
const v128 s16be = v128::loadu(&input_s16[i]);
// Convert endianess if necessary and shift left by 16
#if defined(ARCH_X64) && !defined(__SSSE3__)
const v128 s16le = gv_rol16<8>(s16be);
const v128 s32_1 = gv_unpacklo16(gv_bcst16(0), s16le);
const v128 s32_2 = gv_unpackhi16(gv_bcst16(0), s16le);
#else
const v128 s32_1 = std::endian::native == std::endian::little ? gv_shuffle8(s16be, v128::normal_array_t<s8>{-1, -1, 1, 0, -1, -1, 3, 2, -1, -1, 5, 4, -1, -1, 7, 6}) : gv_unpacklo16(s16be, gv_bcst16(0));
const v128 s32_2 = std::endian::native == std::endian::little ? gv_shuffle8(s16be, v128::normal_array_t<s8>{-1, -1, 9, 8, -1, -1, 11, 10, -1, -1, 13, 12, -1, -1, 15, 14}) : gv_unpackhi16(s16be, gv_bcst16(0));
#endif
// Convert to float and divide by INT32_MAX + 1
const v128 f32_1 = gv_mulfs(gv_cvts32_tofs(s32_1), 1.f / static_cast<f32>(0x80000000u));
const v128 f32_2 = gv_mulfs(gv_cvts32_tofs(s32_2), 1.f / static_cast<f32>(0x80000000u));
v128::storeu(gv_to_be32(f32_1), &_output[i]);
v128::storeu(gv_to_be32(f32_2), &_output[i + 4]);
}
for (; i < au_size_s16; i++)
{
_output[i] = static_cast<f32>(input_s16[i]) / 0x8000u;
}
}
else if (lpcm_param->sizeOfWord == CELL_ADEC_BIT_LENGTH_20 || lpcm_param->sizeOfWord == CELL_ADEC_BIT_LENGTH_24)
{
s64 i = 0;
for (; i * 3 <= au_size_u8 - static_cast<s64>(sizeof(v128)); i += 4)
{
// Load four samples, convert endianness if necessary and shift left by 8
const v128 _s32 = std::endian::native == std::endian::little ? gv_shuffle8(v128::loadu(&input_u8[i * 3]), v128::normal_array_t<s8>{-1, 2, 1, 0, -1, 5, 4, 3, -1, 8, 7, 6, -1, 11, 10, 9}) : gv_shuffle8(v128::loadu(&input_u8[i * 3]), v128::normal_array_t<s8>{0, 1, 2, -1, 3, 4, 5, -1, 6, 7, 8, -1, 9, 10, 11, -1});
// Convert to float and divide by INT32_MAX + 1
const v128 _f32 = gv_mulfs(gv_cvts32_tofs(_s32), 1.f / static_cast<f32>(0x80000000u));
v128::storeu(gv_to_be32(_f32), &_output[i]);
}
for (; i * 3 <= au_size_u8 - 3; i++)
{
alignas(alignof(s32)) const u8 s32le[4] = {0, input_u8[i * 3 + 2], input_u8[i * 3 + 1], input_u8[i * 3]};
_output[i] = static_cast<f32>(std::bit_cast<le_t<s32>>(s32le)) / static_cast<f32>(0x80000000u);
}
}
// Reorder channels and remove the dummy channel
// Input channel order:
// Front Left, Front Right, Center, Side Left, Rear Left, Rear Right, Side Right, LFE
// Output channel order:
// - up to 3_4: Front Left, Center, Front Right, Side Left, Side Right, Rear Left, Rear Right, LFE
// - 3_4_LFE: Front Left, Front Right, Center, LFE, Side Left, Side Right, Rear Left, Rear Right
// The following loops can access sample_num % channel_num * sizeof(f32) bytes more than LPCM_DEC_OUTPUT_BUFFER_SIZE (up to 28 bytes).
// This is intended, LLE does something similar. The buffer is much larger than LPCM_DEC_OUTPUT_BUFFER_SIZE (see _CellAdecCoreOpGetMemSize_lpcm())
switch (lpcm_param->channelNumber)
{
case CELL_ADEC_CH_MONO:
for (s32 i = 0; i < sample_num / 2; i += 4)
{
const v128 tmp1 = v128::loadu(&_output[i * 2]);
const v128 tmp2 = v128::loadu(&_output[i * 2 + 4]);
v128::storeu(gv_shufflefs<0, 2, 0, 2>(tmp1, tmp2), &_output[i]); // Remove every other sample
}
break;
case CELL_ADEC_CH_STEREO:
case CELL_ADEC_CH_2_2:
// Input order == output order, no need to do anything
break;
case CELL_ADEC_CH_3_0:
for (s32 i_in = 0, i_out = 0; i_in < sample_num; i_in += 4, i_out += 3)
{
const v128 tmp = gv_shuffle32<0, 2, 1, 3>(v128::loadu(&_output[i_in])); // Swap Front Right and Center
v128::storeu(tmp, &_output[i_out]);
}
break;
case CELL_ADEC_CH_2_1:
for (s32 i_in = 0, i_out = 0; i_in < sample_num; i_in += 4, i_out += 3)
{
v128::storeu(v128::loadu(&_output[i_in]), &_output[i_out]);
}
break;
case CELL_ADEC_CH_3_1:
case CELL_ADEC_CH_3_2_LFE:
for (s32 i = 0; i < sample_num; i += channel_num)
{
const u64 tmp = std::rotl(read_from_ptr<u64>(&_output[i + 1]), 0x20); // Swap Front Right and Center
std::memcpy(&_output[i + 1], &tmp, sizeof(u64));
}
break;
case CELL_ADEC_CH_3_2:
for (s32 i_in = 0, i_out = 0; i_in < sample_num; i_in += 6, i_out += 5)
{
const v128 tmp = gv_shuffle32<0, 2, 1, 3>(v128::loadu(&_output[i_in])); // Swap Front Right and Center
v128::storeu(tmp, &_output[i_out]);
_output[i_out + 4] = _output[i_in + 4];
}
break;
case CELL_ADEC_CH_3_4:
for (s32 i_in = 0, i_out = 0; i_in < sample_num; i_in += 8, i_out += 7)
{
const v128 tmp1 = gv_shuffle32<0, 2, 1, 3>(v128::loadu(&_output[i_in])); // Swap Front Right and Center
const v128 tmp2 = gv_shuffle32<2, 0, 1, 3>(v128::loadu(&_output[i_in + 4])); // Reorder Rear Left, Rear Right, Side Right -> Side Right, Rear Left, Rear Right
v128::storeu(tmp1, &_output[i_out]);
v128::storeu(tmp2, &_output[i_out + 4]);
}
break;
case CELL_ADEC_CH_3_4_LFE:
for (s32 i = 0; i < sample_num; i += 8)
{
const v128 tmp1 = gv_shuffle32<3, 2, 0, 1>(v128::loadu(&_output[i + 4])); // Reorder Rear Left, Rear Right, Side Right, LFE -> LFE, Side Right, Rear Left, Rear Right
v128::storeu(tmp1, &_output[i + 4]);
const u64 tmp2 = std::rotl(read_from_ptr<u64>(&_output[i + 3]), 0x20); // Swap Side Left and LFE
std::memcpy(&_output[i + 3], &tmp2, sizeof(u64));
}
break;
default:; // Don't do anything
}
}
else
{
switch (lpcm_param->sizeOfWord)
{
case CELL_ADEC_BIT_LENGTH_16: output_size = output_size * 32 / 16; break;
case CELL_ADEC_BIT_LENGTH_20: output_size = output_size * 32 / 20; break;
case CELL_ADEC_BIT_LENGTH_24: output_size = output_size * 32 / 24; break;
default: fmt::throw_exception("Unreachable"); // Parameters get verified in adecSetLpcmDvdParams()
}
// Only the front left and right channels are decoded, all other channels are ignored
switch (lpcm_param->channelNumber)
{
case CELL_ADEC_LPCM_DVD_CH_MONO: // Set channel_num to two for mono as well
case CELL_ADEC_LPCM_DVD_CH_STEREO: channel_num = 2; break;
case 4:
channel_num = 3;
output_size = output_size * 2 / 3;
break;
case 5:
channel_num = 4;
output_size = output_size * 2 / 4;
break;
case CELL_ADEC_LPCM_DVD_CH_3_2:
channel_num = 5;
output_size = output_size * 2 / 5;
break;
case CELL_ADEC_LPCM_DVD_CH_3_2_LFE:
channel_num = 6;
output_size = output_size * 2 / 6;
break;
case CELL_ADEC_LPCM_DVD_CH_3_4:
channel_num = 7;
output_size = output_size * 2 / 7;
break;
case CELL_ADEC_LPCM_DVD_CH_3_4_LFE:
channel_num = 8;
output_size = output_size * 2 / 8;
break;
default: fmt::throw_exception("Unreachable"); // Parameters get verified in adecSetLpcmDvdParams()
}
// LLE doesn't check the output size
ensure(output_size <= LPCM_DEC_OUTPUT_BUFFER_SIZE);
// Convert to float
switch (lpcm_param->sizeOfWord)
{
case CELL_ADEC_BIT_LENGTH_16:
{
s64 i_in = 0;
s64 i_out = 0;
for (; i_in <= au_size_s16 - channel_num - 2; i_in += channel_num * 2, i_out += 4)
{
// Load four samples
const v128 tmp1 = gv_loadu32(&input_s16[i_in]);
const v128 tmp2 = gv_loadu32(&input_s16[i_in + channel_num]);
const v128 s16be = gv_unpacklo32(tmp1, tmp2);
// Convert endianess if necessary and shift left by 16
const v128 _s32 = std::endian::native == std::endian::little ? gv_shuffle8(s16be, v128::normal_array_t<s8>{-1, -1, 1, 0, -1, -1, 3, 2, -1, -1, 5, 4, -1, -1, 7, 6}) : gv_unpacklo16(s16be, gv_bcst16(0));
// Convert to float and divide by INT32_MAX + 1
const v128 _f32 = gv_mulfs(gv_cvts32_tofs(_s32), 1.f / static_cast<f32>(0x80000000u));
v128::storeu(gv_to_be32(_f32), &_output[i_out]);
}
for (; i_in <= au_size_s16 - 2; i_in += channel_num, i_out += 2)
{
const v128 s16be = gv_loadu32(&input_s16[i_in]);
const v128 _s32 = std::endian::native == std::endian::little ? gv_shuffle8(s16be, v128::normal_array_t<s8>{-1, -1, 1, 0, -1, -1, 3, 2, -1, -1, 5, 4, -1, -1, 7, 6}) : gv_unpacklo16(s16be, gv_bcst16(0));
const v128 _f32 = gv_mulfs(gv_cvts32_tofs(_s32), 1.f / static_cast<f32>(0x80000000u));
std::memcpy(&_output[i_out], &gv_to_be32(_f32)._u64[0], sizeof(u64));
}
break;
}
case CELL_ADEC_BIT_LENGTH_20:
{
const s64 high_bytes_3_4_offset = lpcm_param->channelNumber == CELL_ADEC_LPCM_DVD_CH_MONO ? 5 : channel_num * 2;
const s64 low_bits_1_2_offset = lpcm_param->channelNumber == CELL_ADEC_LPCM_DVD_CH_MONO ? 4 : channel_num * 4;
const s64 low_bits_3_4_offset = channel_num * 4 + channel_num / 2 - !(channel_num & 1);
const s64 next_samples_offset = channel_num * 5;
// If channel_num is odd, the low bits of samples three and four are in different bytes
alignas(alignof(v128)) static constexpr auto shuffle_ctrl_same_offset = std::endian::native == std::endian::little ? v128::normal_array_t<s8>{-1, 8, 1, 0, -1, 8, 3, 2, -1, 11, 5, 4, -1, 11, 7, 6} : v128::normal_array_t<s8>{0, 1, 8, -1, 2, 3, 8, -1, 4, 5, 11, -1, 6, 7, 11, -1};
alignas(alignof(v128)) static constexpr auto shuffle_ctrl_different_offset = std::endian::native == std::endian::little ? v128::normal_array_t<s8>{-1, 8, 1, 0, -1, 8, 3, 2, -1, 10, 5, 4, -1, 11, 7, 6} : v128::normal_array_t<s8>{0, 1, 8, -1, 2, 3, 8, -1, 4, 5, 10, -1, 6, 7, 11, -1};
const v128 shuffle_ctrl = channel_num & 1 ? v128::loadu(&shuffle_ctrl_different_offset) : v128::loadu(&shuffle_ctrl_same_offset);
alignas(alignof(v128)) static constexpr auto low_bits_mask_same_offset = std::endian::native == std::endian::little ? v128::normal_array_t<u8>{0x00, 0xf0, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00, 0xf0, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff} : v128::normal_array_t<u8>{0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0x0f, 0x00};
alignas(alignof(v128)) static constexpr auto low_bits_mask_different_offset = std::endian::native == std::endian::little ? v128::normal_array_t<u8>{0x00, 0xf0, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00, 0xf0, 0xff, 0xff} : v128::normal_array_t<u8>{0xff, 0xff, 0xf0, 0x00, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0x0f, 0x00, 0xff, 0xff, 0xf0, 0x00};
const v128 low_bits_mask = channel_num & 1 ? v128::loadu(&low_bits_mask_different_offset) : v128::loadu(&low_bits_mask_same_offset);
for (s64 i_in = 0, i_out = 0; i_in <= au_size_u8 - low_bits_3_4_offset - (channel_num & 1); i_in += next_samples_offset, i_out += 4)
{
// Load all the high and low bits of four samples
const v128 tmp1 = gv_loadu32(&input_u8[i_in]);
const v128 tmp2 = gv_loadu32(&input_u8[i_in + high_bytes_3_4_offset]);
v128 s20be = gv_unpacklo32(tmp1, tmp2);
s20be = gv_insert16<4>(s20be, read_from_ptr<u16>(&input_u8[i_in + low_bits_1_2_offset]));
s20be = gv_insert16<5>(s20be, read_from_ptr<u16>(&input_u8[i_in + low_bits_3_4_offset]));
// Reorder bytes to form four 32-bit integer samples
v128 _s32 = gv_shuffle8(s20be, shuffle_ctrl);
// Set low 12 bits to zero for each sample
_s32 = _s32 & low_bits_mask;
// LLE is missing a step: each byte that was ANDed with 0x0f would still need to be shifted left by 4
// Convert to float and divide by INT32_MAX + 1
const v128 _f32 = gv_mulfs(gv_cvts32_tofs(_s32), 1.f / static_cast<f32>(0x80000000u));
v128::storeu(gv_to_be32(_f32), &_output[i_out]);
}
break;
}
case CELL_ADEC_BIT_LENGTH_24:
{
const s64 high_bytes_3_4_offset = lpcm_param->channelNumber == CELL_ADEC_LPCM_DVD_CH_MONO ? 6 : channel_num * 2;
const s64 low_bytes_1_2_offset = lpcm_param->channelNumber == CELL_ADEC_LPCM_DVD_CH_MONO ? 4 : channel_num * 4;
const s64 low_bytes_3_4_offset = channel_num * 5;
const s64 next_samples_offset = channel_num * 6;
for (s64 i_in = 0, i_out = 0; i_in <= au_size_u8 - low_bytes_3_4_offset - 2; i_in += next_samples_offset, i_out += 4)
{
// Load all the high and low bytes of four samples
const v128 tmp1 = gv_loadu32(&input_u8[i_in]);
const v128 tmp2 = gv_loadu32(&input_u8[i_in + high_bytes_3_4_offset]);
v128 s24be = gv_unpacklo32(tmp1, tmp2);
s24be = gv_insert16<4>(s24be, read_from_ptr<u16>(&input_u8[i_in + low_bytes_1_2_offset]));
s24be = gv_insert16<5>(s24be, read_from_ptr<u16>(&input_u8[i_in + low_bytes_3_4_offset]));
// Reorder bytes to form four 32-bit integer samples
const v128 _s32 = std::endian::native == std::endian::little ? gv_shuffle8(s24be, v128::normal_array_t<s8>{-1, 8, 1, 0, -1, 9, 3, 2, -1, 10, 5, 4, -1, 11, 7, 6}) : gv_shuffle8(s24be, v128::normal_array_t<s8>{0, 1, 8, -1, 2, 3, 9, -1, 4, 5, 10, -1, 6, 7, 11, -1});
// Convert to float and divide by INT32_MAX + 1
const v128 _f32 = gv_mulfs(gv_cvts32_tofs(_s32), 1.f / static_cast<f32>(0x80000000u));
v128::storeu(gv_to_be32(_f32), &_output[i_out]);
}
}
}
}
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return;
}
if (error_occurred)
{
notify_error.cbFunc(ppu, CELL_ADEC_ERROR_FATAL, notify_error.cbArg);
}
notify_au_done.cbFunc(ppu, cmd.pcm_handle, notify_au_done.cbArg);
output_locked = true;
error_occurred |= static_cast<u32>(sys_mutex_unlock(ppu, output_mutex) != CELL_OK);
const vm::var<CellAdecLpcmInfo> bsi_info{{lpcm_param->channelNumber, lpcm_param->sampleRate, static_cast<u32>(output_size)}};
notify_pcm_out.cbFunc(ppu, cmd.pcm_handle, output, static_cast<u32>(output_size), notify_pcm_out.cbArg, vm::make_var<vm::bcptr<void>>(bsi_info), ADEC_CORRECT_PTS_VALUE_TYPE_LPCM_HDMV, error_occurred ? static_cast<s32>(CELL_ADEC_ERROR_FATAL) : CELL_OK);
break;
}
default:
fmt::throw_exception("Invalid command");
}
}
}
template <LpcmDecCmdType type>
error_code LpcmDecContext::send_command(ppu_thread& ppu, auto&&... args)
{
ppu.state += cpu_flag::wait;
if (error_code ret = sys_mutex_lock(ppu, queue_size_mutex, 0); ret != CELL_OK)
{
return ret;
}
if (cmd_queue.full())
{
ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_BUSY;
}
// LLE copies the parameters directly into the context
if constexpr (type == LpcmDecCmdType::start_seq)
{
*lpcm_param = {args...};
}
if (error_code ret = sys_mutex_lock(ppu, queue_mutex, 0); ret != CELL_OK)
{
ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
return ret;
}
cmd_queue.emplace(type, std::forward<decltype(args)>(args)...);
if (error_code ret = sys_mutex_unlock(ppu, queue_mutex); ret != CELL_OK || (ret = cmd_available.release(ppu)) != CELL_OK)
{
ensure(sys_mutex_unlock(ppu, queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
return ret;
}
return sys_mutex_unlock(ppu, queue_size_mutex);
}
inline error_code LpcmDecContext::release_output(ppu_thread& ppu)
{
if (error_code ret = sys_mutex_lock(ppu, output_mutex, 0); ret != CELL_OK)
{
return ret;
}
output_locked = false;
if (error_code ret = sys_cond_signal(ppu, output_consumed); ret != CELL_OK)
{
return ret; // LLE doesn't unlock the mutex
}
return sys_mutex_unlock(ppu, output_mutex);
}
void lpcmDecEntry(ppu_thread& ppu, vm::ptr<LpcmDecContext> lpcm_dec)
{
lpcm_dec->exec(ppu);
if (ppu.state & cpu_flag::again)
{
// For savestates, save argument
ppu.syscall_args[0] = lpcm_dec.addr();
return;
}
ppu_execute<&sys_ppu_thread_exit>(ppu, CELL_OK);
}
error_code _CellAdecCoreOpGetMemSize_lpcm(vm::ptr<CellAdecAttr> attr)
{
cellAdec.notice("_CellAdecCoreOpGetMemSize_lpcm(attr=*0x%x)", attr);
constexpr u32 mem_size =
utils::align(static_cast<u32>(sizeof(LpcmDecContext)), 0x80) + utils::align(static_cast<u32>(sizeof(CellAdecParamLpcm)), 0x80) + 0x100 // Command data for Spurs task
+ LPCM_DEC_OUTPUT_BUFFER_SIZE + 0x2900 // sizeof(CellSpurs) + sizeof(CellSpursTaskset)
+ 0x3b400 // Spurs context
+ 0x300 // (sizeof(CellSpursQueue) + 0x80 + queue buffer) * 2
+ 0x855; // Unused
static_assert(mem_size == 0x7ebd5);
attr->workMemSize = mem_size;
return CELL_OK;
}
error_code _CellAdecCoreOpOpenExt_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle, vm::ptr<AdecNotifyAuDone> notifyAuDone, vm::ptr<void> notifyAuDoneArg, vm::ptr<AdecNotifyPcmOut> notifyPcmOut, vm::ptr<void> notifyPcmOutArg,
vm::ptr<AdecNotifyError> notifyError, vm::ptr<void> notifyErrorArg, vm::ptr<AdecNotifySeqDone> notifySeqDone, vm::ptr<void> notifySeqDoneArg, vm::cptr<CellAdecResource> res, vm::cptr<CellAdecResourceSpurs> spursRes)
{
cellAdec.notice("_CellAdecCoreOpOpenExt_lpcm(handle=*0x%x, notifyAuDone=*0x%x, notifyAuDoneArg=0x%x, notifyPcmOut=*0x%x, notifyPcmOutArg=0x%x, notifyError=*0x%x, notifyErrorArg=0x%x, notifySeqDone=*0x%x, notifySeqDoneArg=0x%x, res=*0x%x, spursRes=*0x%x)",
handle, notifyAuDone, notifyAuDoneArg, notifyPcmOut, notifyPcmOutArg, notifyError, notifyErrorArg, notifySeqDone, notifySeqDoneArg, res, spursRes);
ensure(!!handle && !!res); // Not checked on LLE
ensure(handle.aligned(0x80)); // LLE doesn't check the alignment or aligns the address itself
ensure(!!notifyAuDone && !!notifyAuDoneArg && !!notifyPcmOut && !!notifyPcmOutArg && !!notifyError && !!notifyErrorArg && !!notifySeqDone && !!notifySeqDoneArg); // These should always be set
const u32 end_of_context_addr = handle.addr() + utils::align(static_cast<u32>(sizeof(LpcmDecContext)), 0x80);
handle->cmd_queue.front = 0;
handle->cmd_queue.back = 0;
handle->cmd_queue.size = 0;
handle->run_thread = true;
handle->notify_au_done = {notifyAuDone, notifyAuDoneArg};
handle->notify_pcm_out = {notifyPcmOut, notifyPcmOutArg};
handle->notify_error = {notifyError, notifyErrorArg};
handle->notify_seq_done = {notifySeqDone, notifySeqDoneArg};
handle->output = vm::bptr<f32>::make(end_of_context_addr + 0x180);
handle->lpcm_param.set(end_of_context_addr);
handle->error_occurred = false;
const vm::var<sys_mutex_attribute_t> mutex_attr{{SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, {"_adem04"_u64}}};
const vm::var<sys_mutex_attribute_t> output_mutex_attr{{SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, {"_adem05"_u64}}};
const vm::var<sys_mutex_attribute_t> queue_mutex_attr{{SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, {"_adem06"_u64}}};
const vm::var<sys_cond_attribute_t> cond_attr{{SYS_SYNC_NOT_PROCESS_SHARED, 0, 0, {"_adec03"_u64}}};
error_code ret = sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::queue_size_mutex), mutex_attr);
ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::queue_size_cond), handle->queue_size_mutex, cond_attr);
ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::unk_mutex), mutex_attr);
ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::unk_cond), handle->unk_mutex, cond_attr);
ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::output_mutex), output_mutex_attr);
ret = ret ? ret : sys_cond_create(ppu, handle.ptr(&LpcmDecContext::output_consumed), handle->output_mutex, cond_attr);
ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::queue_mutex), queue_mutex_attr);
ret = ret ? ret : handle->release_output(ppu);
ret = ret ? ret : handle->cmd_available.init(ppu, handle.ptr(&LpcmDecContext::cmd_available), 0);
ret = ret ? ret : handle->reserved2.init(ppu, handle.ptr(&LpcmDecContext::reserved2), 0);
if (ret != CELL_OK)
{
return ret;
}
// HLE exclusive
handle->savestate = lpcm_dec_state::waiting_for_cmd_mutex_lock;
handle->cmd_counter = 0;
const vm::var<char[]> _name = vm::make_str("HLE LPCM decoder");
const auto entry = g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(lpcmDecEntry));
ret = ppu_execute<&sys_ppu_thread_create>(ppu, handle.ptr(&LpcmDecContext::thread_id), entry, handle.addr(), +res->ppuThreadPriority, +res->ppuThreadStackSize, SYS_PPU_THREAD_CREATE_JOINABLE, +_name);
ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::spurs_queue_pop_mutex), mutex_attr);
ret = ret ? ret : sys_mutex_create(ppu, handle.ptr(&LpcmDecContext::spurs_queue_push_mutex), mutex_attr);
return ret;
}
error_code _CellAdecCoreOpOpen_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle, vm::ptr<AdecNotifyAuDone> notifyAuDone, vm::ptr<void> notifyAuDoneArg, vm::ptr<AdecNotifyPcmOut> notifyPcmOut, vm::ptr<void> notifyPcmOutArg,
vm::ptr<AdecNotifyError> notifyError, vm::ptr<void> notifyErrorArg, vm::ptr<AdecNotifySeqDone> notifySeqDone, vm::ptr<void> notifySeqDoneArg, vm::cptr<CellAdecResource> res)
{
cellAdec.notice("_CellAdecCoreOpOpen_lpcm(handle=*0x%x, notifyAuDone=*0x%x, notifyAuDoneArg=*0x%x, notifyPcmOut=*0x%x, notifyPcmOutArg=*0x%x, notifyError=*0x%x, notifyErrorArg=*0x%x, notifySeqDone=*0x%x, notifySeqDoneArg=*0x%x, res=*0x%x)",
handle, notifyAuDone, notifyAuDoneArg, notifyPcmOut, notifyPcmOutArg, notifyError, notifyErrorArg, notifySeqDone, notifySeqDoneArg, res);
return _CellAdecCoreOpOpenExt_lpcm(ppu, handle, notifyAuDone, notifyAuDoneArg, notifyPcmOut, notifyPcmOutArg, notifyError, notifyErrorArg, notifySeqDone, notifySeqDoneArg, res, vm::null);
}
error_code _CellAdecCoreOpClose_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle)
{
ppu.state += cpu_flag::wait;
cellAdec.notice("_CellAdecCoreOpClose_lpcm(handle=*0x%x)", handle);
if (error_code ret = sys_mutex_lock(ppu, handle->queue_size_mutex, 0); ret != CELL_OK || (ret = sys_mutex_lock(ppu, handle->queue_mutex, 0)) != CELL_OK)
{
return ret;
}
if (handle->cmd_queue.empty())
{
handle->cmd_queue.emplace(LpcmDecCmdType::close);
if (error_code ret = sys_mutex_unlock(ppu, handle->queue_mutex); ret != CELL_OK)
{
return ret; // LLE doesn't unlock the queue size mutex
}
if (error_code ret = handle->cmd_available.release(ppu); ret != CELL_OK)
{
ensure(sys_mutex_unlock(ppu, handle->queue_size_mutex) == CELL_OK); // Error code isn't checked on LLE
return ret;
}
}
else
{
for (auto& cmd : handle->cmd_queue.elements)
{
cmd.type = LpcmDecCmdType::close;
}
if (error_code ret = sys_mutex_unlock(ppu, handle->queue_mutex); ret != CELL_OK)
{
return ret; // LLE doesn't unlock the queue size mutex
}
}
error_code ret = sys_mutex_unlock(ppu, handle->queue_size_mutex);
ret = ret ? ret : handle->release_output(ppu);
vm::var<u64> thread_ret;
ret = ret ? ret : sys_ppu_thread_join(ppu, static_cast<u32>(handle->thread_id), +thread_ret);
ret = ret ? ret : sys_cond_destroy(ppu, handle->queue_size_cond);
ret = ret ? ret : sys_cond_destroy(ppu, handle->unk_cond);
ret = ret ? ret : sys_cond_destroy(ppu, handle->output_consumed);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->queue_mutex);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->queue_size_mutex);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->unk_mutex);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->output_mutex);
ret = ret ? ret : handle->cmd_available.finalize(ppu);
ret = ret ? ret : handle->reserved2.finalize(ppu);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->spurs_queue_pop_mutex);
ret = ret ? ret : sys_mutex_destroy(ppu, handle->spurs_queue_push_mutex);
return ret;
}
error_code _CellAdecCoreOpStartSeq_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle, vm::ptr<CellAdecParamLpcm> lpcmParam)
{
cellAdec.notice("_CellAdecCoreOpStartSeq_lpcm(handle=*0x%x, lpcmParam=*0x%x)", handle, lpcmParam);
ensure(!!handle && !!lpcmParam); // Not checked on LLE
cellAdec.notice("_CellAdecCoreOpStartSeq_lpcm(): channelNumber=%d, sampleRate=%d, sizeOfWord=%d, audioPayloadSize=0x%x", lpcmParam->channelNumber, lpcmParam->sampleRate, lpcmParam->sizeOfWord, lpcmParam->audioPayloadSize);
if (lpcmParam->channelNumber >= 0x20u || lpcmParam->sampleRate >= 0x20u || lpcmParam->sizeOfWord >= 0x20u || lpcmParam->audioPayloadSize == 0u)
{
return CELL_ADEC_ERROR_LPCM_ARG;
}
return handle->send_command<LpcmDecCmdType::start_seq>(ppu, *lpcmParam);
}
error_code _CellAdecCoreOpEndSeq_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle)
{
cellAdec.notice("_CellAdecCoreOpEndSeq_lpcm(handle=*0x%x)", handle);
ensure(!!handle); // Not checked on LLE
return handle->send_command<LpcmDecCmdType::end_seq>(ppu);
}
error_code _CellAdecCoreOpDecodeAu_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle, s32 pcmHandle, vm::ptr<CellAdecAuInfo> auInfo)
{
cellAdec.trace("_CellAdecCoreOpDecodeAu_lpcm(handle=*0x%x, pcmHandle=%d, auInfo=*0x%x)", handle, pcmHandle, auInfo);
ensure(!!handle && !!auInfo); // Not checked on LLE
cellAdec.trace("_CellAdecCoreOpDecodeAu_lpcm(): startAddr=*0x%x, size=0x%x, pts=0x%x, userData=0x%016x", auInfo->startAddr, auInfo->size, std::bit_cast<be_t<u64>>(auInfo->pts), auInfo->userData);
return handle->send_command<LpcmDecCmdType::decode_au>(ppu, pcmHandle, *auInfo);
}
void _CellAdecCoreOpGetVersion_lpcm(vm::ptr<be_t<u32, 1>> version)
{
cellAdec.notice("_CellAdecCoreOpGetVersion_lpcm(version=*0x%x)", version);
*version = 0x20070323;
}
error_code _CellAdecCoreOpRealign_lpcm(vm::ptr<LpcmDecContext> handle, vm::ptr<void> outBuffer, vm::cptr<void> pcmStartAddr)
{
cellAdec.trace("_CellAdecCoreOpRealign_lpcm(handle=*0x%x, outBuffer=*0x%x, pcmStartAddr=*0x%x)", handle, outBuffer, pcmStartAddr);
if (!pcmStartAddr)
{
return CELL_ADEC_ERROR_LPCM_ARG;
}
if (outBuffer)
{
ensure(!!handle); // Not checked on LLE
ensure(vm::check_addr(outBuffer.addr(), vm::page_info_t::page_writable, handle->output_size));
std::memcpy(outBuffer.get_ptr(), pcmStartAddr.get_ptr(), handle->output_size);
}
return CELL_OK;
}
error_code _CellAdecCoreOpReleasePcm_lpcm(ppu_thread& ppu, vm::ptr<LpcmDecContext> handle, s32 pcmHandle, vm::ptr<void> outBuffer)
{
ppu.state += cpu_flag::wait;
cellAdec.trace("_CellAdecCoreOpReleasePcm_lpcm(handle=*0x%x, pcmHandle=%d, outBuffer=*0x%x)", handle, pcmHandle, outBuffer);
ensure(!!handle); // Not checked on LLE
return handle->release_output(ppu);
}
s32 _CellAdecCoreOpGetPcmHandleNum_lpcm()
{
cellAdec.notice("_CellAdecCoreOpGetPcmHandleNum_lpcm()");
return 8;
}
u32 _CellAdecCoreOpGetBsiInfoSize_lpcm()
{
cellAdec.notice("_CellAdecCoreOpGetBsiInfoSize_lpcm()");
return sizeof(CellAdecLpcmInfo);
}
// cellAdec abstraction layer, operates the individual decoders
error_code AdecContext::get_new_pcm_handle(vm::ptr<CellAdecAuInfo> au_info) const
{
for (s32 i = 0; i < frames_num; i++)
{
if (!frames[i].in_use)
{
frames[i].in_use = true;
frames[i].au_info = *au_info;
return not_an_error(i);
}
}
return CELL_ADEC_ERROR_BUSY;
}
error_code AdecContext::verify_pcm_handle(s32 pcm_handle) const
{
ensure(pcm_handle >= 0 && pcm_handle < frames_num); // Not properly checked on LLE, see below
if ((pcm_handle < 0 && /* LLE uses && instead of || */ pcm_handle >= frames_num) || !frames[pcm_handle].in_use)
{
return CELL_ADEC_ERROR_FATAL;
}
return CELL_OK;
}
vm::ptr<CellAdecAuInfo> AdecContext::get_au_info(s32 pcm_handle) const
{
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return vm::null;
}
return (frames + pcm_handle).ptr(&AdecFrame::au_info);
}
void AdecContext::set_state(s32 pcm_handle, u32 state) const
{
if (state == 1u << 9)
{
frames[pcm_handle].au_done = true;
}
else if (state == 1u << 11)
{
frames[pcm_handle].pcm_out = true;
}
}
error_code AdecContext::get_pcm_item(s32 pcm_handle, vm::ptr<CellAdecPcmItem>& pcm_item) const
{
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
pcm_item = (frames + pcm_handle).ptr(&AdecFrame::pcm_item);
return CELL_OK;
}
error_code AdecContext::set_pcm_item(s32 pcm_handle, vm::ptr<void> pcm_addr, u32 pcm_size, vm::cpptr<void> bitstream_info) const
{
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
frames[pcm_handle].pcm_item.pcmHandle = pcm_handle;
frames[pcm_handle].pcm_item.status = CELL_OK;
frames[pcm_handle].pcm_item.startAddr = pcm_addr;
frames[pcm_handle].pcm_item.size = pcm_size;
frames[pcm_handle].pcm_item.auInfo = frames[pcm_handle].au_info;
std::memcpy(frames[pcm_handle].pcm_item.pcmAttr.bsiInfo.get_ptr(), bitstream_info->get_ptr(), bitstream_info_size);
return CELL_OK;
}
error_code AdecContext::link_frame(ppu_thread& ppu, s32 pcm_handle)
{
ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_FATAL;
}
if (frames_tail == -1 && frames_head == -1)
{
frames[pcm_handle].next = pcm_handle;
frames[pcm_handle].prev = pcm_handle;
frames_head = pcm_handle;
frames_tail = pcm_handle;
}
else if (frames_tail != -1 && frames_head != -1)
{
frames[pcm_handle].next = pcm_handle;
frames[pcm_handle].prev = frames_tail;
frames[frames_tail].next = pcm_handle;
frames_tail = pcm_handle;
}
else
{
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_FATAL;
}
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_OK;
}
error_code AdecContext::unlink_frame(ppu_thread& ppu, s32 pcm_handle)
{
ensure(sys_mutex_lock(ppu, mutex, 0) == CELL_OK); // Error code isn't checked on LLE
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_FATAL;
}
if (frames_head == -1 || frames_tail == -1)
{
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_FATAL;
}
const s32 next = frames[pcm_handle].next;
const s32 prev = frames[pcm_handle].prev;
if (frames_head == frames_tail)
{
if (pcm_handle != frames_tail)
{
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_ADEC_ERROR_FATAL;
}
frames_head = -1;
frames_tail = -1;
frames[pcm_handle].next = -1;
frames[pcm_handle].prev = -1;
}
else if (pcm_handle == frames_head)
{
frames_head = next;
frames[prev].next = next;
}
else if (pcm_handle == frames_tail)
{
frames_tail = prev;
frames[next].prev = prev;
}
else
{
frames[next].prev = prev;
frames[prev].next = next;
}
ensure(sys_mutex_unlock(ppu, mutex) == CELL_OK); // Error code isn't checked on LLE
return CELL_OK;
}
void AdecContext::reset_frame(s32 pcm_handle) const
{
frames[pcm_handle].in_use = false;
frames[pcm_handle].au_done = false;
frames[pcm_handle].pcm_out = false;
frames[pcm_handle].next = -1;
frames[pcm_handle].prev = -1;
}
error_code AdecContext::correct_pts_value(ppu_thread& ppu, s32 pcm_handle, s8 correct_pts_type)
{
if (verify_pcm_handle(pcm_handle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
const vm::ptr<CellCodecTimeStamp> au_pts = (frames + pcm_handle).ptr(&AdecFrame::au_info).ptr(&CellAdecAuInfo::pts);
switch (correct_pts_type)
{
case ADEC_CORRECT_PTS_VALUE_TYPE_EAC3: return ppu_execute<&_SceAdecCorrectPtsValue_Ddp>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_DTSHD: return ppu_execute<&_SceAdecCorrectPtsValue_DtsHd>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_CELP: return ppu_execute<&_SceAdecCorrectPtsValue_Celp>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_M2AAC: return ppu_execute<&_SceAdecCorrectPtsValue_Aac>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_MPEG_L2: return ppu_execute<&_SceAdecCorrectPtsValue_mpmc>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_TRUEHD: return ppu_execute<&_SceAdecCorrectPtsValue_truehd>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_DTS: return ppu_execute<&_SceAdecCorrectPtsValue_DtsCore>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_M4AAC:
switch (type.audioCodecType)
{
case CELL_ADEC_TYPE_M4AAC: return ppu_execute<&_SceAdecCorrectPtsValue_M4Aac>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case CELL_ADEC_TYPE_M4AAC_2CH: return ppu_execute<&_SceAdecCorrectPtsValue_M4Aac2ch>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case CELL_ADEC_TYPE_M4AAC_2CH_MOD: return ppu_execute<&_SceAdecCorrectPtsValue_M4Aac2chmod>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
default: return CELL_OK;
}
case ADEC_CORRECT_PTS_VALUE_TYPE_WMA: return ppu_execute<&_SceAdecCorrectPtsValue_wma>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_DTSLBR: return ppu_execute<&_SceAdecCorrectPtsValue_DtsLbr>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_MPEG_L1: return ppu_execute<&_SceAdecCorrectPtsValue_mpmcl1>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_MP3S: return ppu_execute<&_SceAdecCorrectPtsValue_Mp3s>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_CELP8: return ppu_execute<&_SceAdecCorrectPtsValue_Celp8>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_WMAPRO: return ppu_execute<&_SceAdecCorrectPtsValue_WmaPro>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_WMALSL: return ppu_execute<&_SceAdecCorrectPtsValue_WmaLsl>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
case ADEC_CORRECT_PTS_VALUE_TYPE_DTSHDCORE_UNK1: // Same as below
case ADEC_CORRECT_PTS_VALUE_TYPE_DTSHDCORE_UNK2: return ppu_execute<&_SceAdecCorrectPtsValue_DtsHd_Core>(ppu, +core_handle, au_pts) != CELL_OK ? static_cast<error_code>(CELL_ADEC_ERROR_FATAL) : static_cast<error_code>(CELL_OK);
}
// If the user didn't set a PTS, we need to interpolate from the previous PTS
if (au_pts->upper == CODEC_TS_INVALID)
{
if (au_pts->lower != CODEC_TS_INVALID)
{
return CELL_ADEC_ERROR_FATAL;
}
if (previous_pts.upper == CODEC_TS_INVALID && previous_pts.lower == CODEC_TS_INVALID)
{
return CELL_OK;
}
const u32 pts_adjust = [&]
{
switch (correct_pts_type)
{
case ADEC_CORRECT_PTS_VALUE_TYPE_LPCM_HDMV: return 450;
case ADEC_CORRECT_PTS_VALUE_TYPE_LPCM_DVD: return 150;
case ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_48000Hz: return 3840;
case ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_44100Hz: return 4180;
case ADEC_CORRECT_PTS_VALUE_TYPE_ATRACX_32000Hz: return 5760;
case ADEC_CORRECT_PTS_VALUE_TYPE_AC3: return 2880;
case ADEC_CORRECT_PTS_VALUE_TYPE_ATRAC3: return 4180;
case ADEC_CORRECT_PTS_VALUE_TYPE_MP3_48000Hz: return 2160;
case ADEC_CORRECT_PTS_VALUE_TYPE_MP3_44100Hz: return 2351;
case ADEC_CORRECT_PTS_VALUE_TYPE_MP3_32000Hz: return 3240;
case ADEC_CORRECT_PTS_VALUE_TYPE_ATRAC3MULTI: return 3840;
default: return 0;
}
}();
au_pts->upper = previous_pts.upper;
au_pts->lower = previous_pts.lower + pts_adjust;
if (au_pts->lower < previous_pts.lower) // overflow
{
au_pts->upper = (au_pts->upper + 1) & 1;
}
if (au_pts->upper == CODEC_TS_INVALID)
{
return CELL_ADEC_ERROR_FATAL;
}
}
if (au_pts->lower == CODEC_TS_INVALID)
{
return CELL_ADEC_ERROR_FATAL;
}
previous_pts = *au_pts;
return CELL_OK;
}
static vm::cptr<CellAdecCoreOps> get_core_ops(s32 type)
{
switch (type)
{
case CELL_ADEC_TYPE_INVALID1: fmt::throw_exception("Invalid audio codec: CELL_ADEC_TYPE_INVALID1");
case CELL_ADEC_TYPE_LPCM_PAMF: return g_cell_adec_core_ops_lpcm;
case CELL_ADEC_TYPE_AC3: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cell_libac3dec.variables.find(0xc58bb170)->second.export_addr);
case CELL_ADEC_TYPE_ATRACX: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtracXdec.variables.find(0x4944af9a)->second.export_addr);
case CELL_ADEC_TYPE_MP3: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellMP3dec.variables.find(0x84276a23)->second.export_addr);
case CELL_ADEC_TYPE_ATRAC3: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtrac3dec.variables.find(0x60487d65)->second.export_addr);
case CELL_ADEC_TYPE_MPEG_L2: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellM2BCdec.variables.find(0x300afe4d)->second.export_addr);
case CELL_ADEC_TYPE_M2AAC: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellM2AACdec.variables.find(0xac2f0831)->second.export_addr);
case CELL_ADEC_TYPE_EAC3: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellDDPdec.variables.find(0xf5e9c15c)->second.export_addr);
case CELL_ADEC_TYPE_TRUEHD: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellTRHDdec.variables.find(0xe88e381b)->second.export_addr);
case CELL_ADEC_TYPE_DTS: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellDTSdec.variables.find(0x15248ec5)->second.export_addr);
case CELL_ADEC_TYPE_CELP: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellCelpDec.variables.find(0xffe42c22)->second.export_addr);
case CELL_ADEC_TYPE_LPCM_BLURAY: return g_cell_adec_core_ops_lpcm;
case CELL_ADEC_TYPE_ATRACX_2CH: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtracXdec.variables.find(0x076b33ab)->second.export_addr);
case CELL_ADEC_TYPE_ATRACX_6CH: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtracXdec.variables.find(0x1d210eaa)->second.export_addr);
case CELL_ADEC_TYPE_ATRACX_8CH: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtracXdec.variables.find(0xe9a86e54)->second.export_addr);
case CELL_ADEC_TYPE_M4AAC: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellM4AacDec.variables.find(0xab61278d)->second.export_addr);
case CELL_ADEC_TYPE_LPCM_DVD: return g_cell_adec_core_ops_lpcm;
case CELL_ADEC_TYPE_WMA: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellWMAdec.variables.find(0x88320b10)->second.export_addr);
case CELL_ADEC_TYPE_DTSLBR: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellDTSLBRdec.variables.find(0x8c50af52)->second.export_addr);
case CELL_ADEC_TYPE_M4AAC_2CH: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellM4AacDec2ch.variables.find(0xe996c664)->second.export_addr);
case CELL_ADEC_TYPE_DTSHD: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellDTSHDdec.variables.find(0x51ac2b6c)->second.export_addr);
case CELL_ADEC_TYPE_MPEG_L1: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellMPL1dec.variables.find(0xbbc70551)->second.export_addr);
case CELL_ADEC_TYPE_MP3S: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellMP3Sdec.variables.find(0x292cdf0a)->second.export_addr);
case CELL_ADEC_TYPE_M4AAC_2CH_MOD: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellM4AacDec2chmod.variables.find(0xdbd26836)->second.export_addr);
case CELL_ADEC_TYPE_CELP8: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellCelp8Dec.variables.find(0xf0190c6c)->second.export_addr);
case CELL_ADEC_TYPE_INVALID2: fmt::throw_exception("Invalid audio codec: CELL_ADEC_TYPE_INVALID2");
case CELL_ADEC_TYPE_INVALID3: fmt::throw_exception("Invalid audio codec: CELL_ADEC_TYPE_INVALID3");
case CELL_ADEC_TYPE_RESERVED22: fmt::throw_exception("Invalid audio codec: CELL_ADEC_TYPE_RESERVED22");
case CELL_ADEC_TYPE_RESERVED23: fmt::throw_exception("Invalid audio codec: CELL_ADEC_TYPE_RESERVED23");
case CELL_ADEC_TYPE_DTSHDCORE: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellDTSHDCOREdec.variables.find(0x6c8f4f1c)->second.export_addr);
case CELL_ADEC_TYPE_ATRAC3MULTI: return vm::cptr<CellAdecCoreOps>::make(*ppu_module_manager::cellAtrac3multidec.variables.find(0xc20c6bd7)->second.export_addr);
default: fmt::throw_exception("Invalid audio codec: %d", type);
}
}
error_code adecNotifyAuDone(ppu_thread& ppu, s32 pcmHandle, vm::ptr<AdecContext> handle)
{
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.trace("adecNotifyAuDone(pcmHandle=%d, handle=*0x%x)", pcmHandle, handle);
ensure(!!handle); // Not checked on LLE
const auto au_info = handle->get_au_info(pcmHandle);
if (!au_info)
{
return CELL_ADEC_ERROR_FATAL;
}
handle->set_state(pcmHandle, 1u << 9);
handle->callback.cbFunc(ppu, handle, CELL_ADEC_MSG_TYPE_AUDONE, static_cast<s32>(au_info.addr()), handle->callback.cbArg);
return CELL_OK;
}
error_code adecNotifyPcmOut(ppu_thread& ppu, s32 pcmHandle, vm::ptr<void> pcmAddr, u32 pcmSize, vm::ptr<AdecContext> handle, vm::cpptr<void> bsiInfo, s8 correctPtsValueType, s32 errorCode)
{
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.trace("adecNotifyPcmOut(pcmHandle=%d, pcmAddr=*0x%x, pcmSize=0x%x, handle=*0x%x, bsiInfo=**0x%x, correctPtsValueType=%d, errorCode=0x%x)", pcmHandle, pcmAddr, pcmSize, handle, bsiInfo, correctPtsValueType, errorCode);
ensure(!!handle && !!bsiInfo && !!*bsiInfo); // Not checked on LLE
if (!handle->get_au_info(pcmHandle))
{
return CELL_ADEC_ERROR_FATAL;
}
if (error_code ret = handle->correct_pts_value(ppu, pcmHandle, correctPtsValueType); ret != CELL_OK)
{
return ret;
}
if (handle->link_frame(ppu, pcmHandle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
handle->set_state(pcmHandle, 1u << 11);
if (handle->set_pcm_item(pcmHandle, pcmAddr, pcmSize, bsiInfo) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
vm::ptr<CellAdecPcmItem> pcm_item{};
if (handle->get_pcm_item(pcmHandle, pcm_item) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
if (handle->pcm_queue.push(ppu, pcm_item, pcmHandle) != CELL_OK)
{
return CELL_ADEC_ERROR_FATAL;
}
if (handle->pcm_item_queue.push(ppu, pcm_item, pcmHandle) != CELL_OK)
{
return CELL_ADEC_ERROR_FATAL;
}
handle->callback.cbFunc(ppu, handle, CELL_ADEC_MSG_TYPE_PCMOUT, errorCode, handle->callback.cbArg);
return CELL_OK;
}
error_code adecNotifyError(ppu_thread& ppu, s32 errorCode, vm::ptr<AdecContext> handle)
{
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.error("adecNotifyError(errorCode=0x%x, handle=*0x%x)", errorCode, handle);
ensure(!!handle); // Not checked on LLE
handle->callback.cbFunc(ppu, handle, CELL_ADEC_MSG_TYPE_ERROR, errorCode, handle->callback.cbArg);
return CELL_OK;
}
error_code adecNotifySeqDone(ppu_thread& ppu, vm::ptr<AdecContext> handle)
{
// Block savestate creation during callbacks
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.notice("adecNotifySeqDone(handle=*0x%x)", handle);
ensure(!!handle); // Not checked on LLE
handle->callback.cbFunc(ppu, handle, CELL_ADEC_MSG_TYPE_SEQDONE, CELL_OK, handle->callback.cbArg);
return CELL_OK;
}
error_code cellAdecQueryAttr(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::ptr<CellAdecAttr> attr)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.notice("cellAdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr);
if (!type || type->audioCodecType >= 32 || type->audioCodecType == CELL_ADEC_TYPE_INVALID1 || type->audioCodecType == CELL_ADEC_TYPE_INVALID2 || type->audioCodecType == CELL_ADEC_TYPE_INVALID3 || !attr)
{
return CELL_ADEC_ERROR_ARG;
}
const auto core_ops = get_core_ops(type->audioCodecType);
core_ops->getMemSize(ppu, attr);
const s32 pcm_handle_num = core_ops->getPcmHandleNum(ppu);
const u32 bitstream_info_size = core_ops->getBsiInfoSize(ppu);
attr->workMemSize += static_cast<u32>((bitstream_info_size + sizeof(AdecFrame)) * pcm_handle_num + sizeof(AdecContext) + 0x7f);
const vm::var<be_t<u32, 1>> ver_lower;
core_ops->getVersion(ppu, ver_lower);
attr->adecVerUpper = 0x491000;
attr->adecVerLower = *ver_lower;
return CELL_OK;
}
error_code adecOpen(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::cptr<CellAdecResource> res, vm::cptr<CellAdecCb> cb, vm::pptr<AdecContext> handle, vm::cptr<CellAdecResourceSpurs> spursRes)
{
if (!type || type->audioCodecType >= 32 || !res || !res->startAddr || res->ppuThreadPriority >= 0xa00 || res->spuThreadPriority >= 0x100 || res->ppuThreadStackSize < 0x1000 || !cb || !cb->cbFunc || !handle)
{
return CELL_ADEC_ERROR_ARG;
}
if (vm::var<CellAdecAttr> attr; cellAdecQueryAttr(ppu, type, attr), res->totalMemSize < attr->workMemSize)
{
return CELL_ADEC_ERROR_FATAL;
}
const auto core_ops = get_core_ops(type->audioCodecType);
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
const s32 pcm_handle_num = core_ops->getPcmHandleNum(ppu);
const u32 bitstream_info_size = core_ops->getBsiInfoSize(ppu);
const auto _this = vm::ptr<AdecContext>::make(utils::align(+res->startAddr, 0x80));
const auto frames = vm::ptr<AdecFrame>::make(_this.addr() + sizeof(AdecContext));
const u32 bitstream_infos_addr = frames.addr() + pcm_handle_num * sizeof(AdecFrame);
const auto core_handle = vm::ptr<void>::make(utils::align(bitstream_infos_addr + bitstream_info_size * pcm_handle_num, 0x80));
if (type->audioCodecType == CELL_ADEC_TYPE_LPCM_DVD)
{
vm::static_ptr_cast<LpcmDecContext>(core_handle)->dvd_packing = true;
}
else if (type->audioCodecType == CELL_ADEC_TYPE_LPCM_PAMF || type->audioCodecType == CELL_ADEC_TYPE_LPCM_BLURAY)
{
vm::static_ptr_cast<LpcmDecContext>(core_handle)->dvd_packing = false;
}
_this->_this = _this;
_this->this_size = sizeof(AdecContext) + (bitstream_info_size + sizeof(AdecFrame)) * pcm_handle_num;
_this->unk = 0;
_this->sequence_state = AdecSequenceState::dormant;
_this->type = *type;
_this->res = *res;
_this->callback = *cb;
_this->core_handle = core_handle;
_this->core_ops = core_ops;
_this->previous_pts = {CODEC_TS_INVALID, CODEC_TS_INVALID};
_this->frames_num = pcm_handle_num;
_this->reserved1 = 0;
_this->frames_head = -1;
_this->frames_tail = -1;
_this->frames = frames;
_this->bitstream_info_size = bitstream_info_size;
_this->mutex_attribute = {SYS_SYNC_PRIORITY, SYS_SYNC_NOT_RECURSIVE, SYS_SYNC_NOT_PROCESS_SHARED, SYS_SYNC_NOT_ADAPTIVE, 0, 0, 0, {"_adem03"_u64}};
_this->pcm_queue.init(ppu, _this.ptr(&AdecContext::pcm_queue));
_this->pcm_item_queue.init(ppu, _this.ptr(&AdecContext::pcm_item_queue));
for (s32 i = 0; i < pcm_handle_num; i++)
{
frames[i].in_use = false;
frames[i].this_index = i;
frames[i].au_done = false;
frames[i].unk1 = false;
frames[i].pcm_out = false;
frames[i].unk2 = false;
frames[i].pcm_item.pcmAttr.bsiInfo.set(bitstream_infos_addr + bitstream_info_size * i);
frames[i].reserved1 = 0;
frames[i].reserved2 = 0;
frames[i].next = 0;
frames[i].prev = 0;
}
ensure(sys_mutex_create(ppu, _this.ptr(&AdecContext::mutex), _this.ptr(&AdecContext::mutex_attribute)) == CELL_OK); // Error code isn't checked on LLE
*handle = _this;
const auto notifyAuDone = vm::ptr<AdecNotifyAuDone>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(adecNotifyAuDone)));
const auto notifyPcmOut = vm::ptr<AdecNotifyPcmOut>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(adecNotifyPcmOut)));
const auto notifyError = vm::ptr<AdecNotifyError>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(adecNotifyError)));
const auto notifySeqDone = vm::ptr<AdecNotifySeqDone>::make(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(adecNotifySeqDone)));
if (spursRes)
{
return core_ops->openExt(ppu, _this->core_handle, notifyAuDone, _this, notifyPcmOut, _this, notifyError, _this, notifySeqDone, _this, res, spursRes);
}
return core_ops->open(ppu, _this->core_handle, notifyAuDone, _this, notifyPcmOut, _this, notifyError, _this, notifySeqDone, _this, res);
}
error_code cellAdecOpen(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::ptr<CellAdecResource> res, vm::ptr<CellAdecCb> cb, vm::pptr<AdecContext> handle)
{
cellAdec.notice("cellAdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
return adecOpen(ppu, type, res, cb, handle, vm::null);
}
error_code cellAdecOpenExt(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res, vm::ptr<CellAdecCb> cb, vm::pptr<AdecContext> handle)
{
cellAdec.notice("cellAdecOpenExt(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
if (!res)
{
return CELL_ADEC_ERROR_ARG;
}
const vm::var<CellAdecResource> _res{{res->totalMemSize, res->startAddr, res->ppuThreadPriority, 0, res->ppuThreadStackSize}};
const vm::var<CellAdecResourceSpurs> spursRes{{res->spurs_addr, res->priority, res->maxContention}};
return adecOpen(ppu, type, _res, cb, handle, spursRes);
}
error_code cellAdecOpenEx(ppu_thread& ppu, vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res, vm::ptr<CellAdecCb> cb, vm::pptr<AdecContext> handle)
{
cellAdec.notice("cellAdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle);
return cellAdecOpenExt(ppu, type, res, cb, handle);
}
error_code cellAdecClose(ppu_thread& ppu, vm::ptr<AdecContext> handle)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.notice("cellAdecClose(handle=*0x%x)", handle);
if (!handle || handle->_this != handle)
{
return CELL_ADEC_ERROR_ARG;
}
if (error_code ret = handle->core_ops->close(ppu, handle->core_handle); ret != CELL_OK)
{
return ret;
}
if (error_code ret = sys_mutex_destroy(ppu, handle->mutex); ret != CELL_OK)
{
return ret;
}
if (error_code ret = handle->pcm_queue.finalize(ppu); ret != CELL_OK)
{
return ret;
}
if (error_code ret = handle->pcm_item_queue.finalize(ppu); ret != CELL_OK)
{
return ret;
}
handle->_this = vm::null;
handle->sequence_state = AdecSequenceState::closed;
return CELL_OK;
}
error_code cellAdecStartSeq(ppu_thread& ppu, vm::ptr<AdecContext> handle, vm::ptr<void> param)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.notice("cellAdecStartSeq(handle=*0x%x, param=*0x%x)", handle, param);
if (!handle || !param)
{
return CELL_ADEC_ERROR_ARG;
}
if (handle->sequence_state != AdecSequenceState::dormant && handle->sequence_state != AdecSequenceState::ready)
{
return CELL_ADEC_ERROR_SEQ;
}
if (error_code ret = handle->core_ops->startSeq(ppu, handle->core_handle, param); ret != CELL_OK)
{
return ret;
}
handle->sequence_state = AdecSequenceState::ready;
return CELL_OK;
}
error_code cellAdecEndSeq(ppu_thread& ppu, vm::ptr<AdecContext> handle)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.notice("cellAdecEndSeq(handle=*0x%x)", handle);
if (!handle || handle->_this != handle)
{
return CELL_ADEC_ERROR_ARG;
}
if (handle->sequence_state != AdecSequenceState::ready)
{
return CELL_ADEC_ERROR_SEQ;
}
// LLE does not set the sequence state to dormant
return handle->core_ops->endSeq(ppu, handle->core_handle);
}
error_code adecSetLpcmBlurayParams(vm::ptr<LpcmDecContext> handle, u64 userData)
{
const u8 channel_number = static_cast<u8>(userData >> 32);
const u8 sample_rate = static_cast<u8>(userData >> 40);
const u8 size_of_word = static_cast<u8>(userData >> 48);
const u8 unk = static_cast<u8>(userData >> 56);
handle->lpcm_param->channelNumber = channel_number;
handle->lpcm_param->sampleRate = sample_rate;
handle->lpcm_param->sizeOfWord = size_of_word;
u32 allocated_channels;
switch (channel_number)
{
case CELL_ADEC_CH_MONO:
case CELL_ADEC_CH_STEREO:
allocated_channels = 2;
break;
case CELL_ADEC_CH_3_0:
case CELL_ADEC_CH_2_1:
case CELL_ADEC_CH_3_1:
case CELL_ADEC_CH_2_2:
allocated_channels = 4;
break;
case CELL_ADEC_CH_3_2:
case CELL_ADEC_CH_3_2_LFE:
allocated_channels = 6;
break;
case CELL_ADEC_CH_3_4:
case CELL_ADEC_CH_3_4_LFE:
allocated_channels = 8;
break;
default:
return CELL_ADEC_ERROR_FATAL;
}
u32 samples_per_frame;
switch (sample_rate)
{
case CELL_ADEC_FS_48kHz: samples_per_frame = 48000 / 200; break;
case CELL_ADEC_FS_96kHz: samples_per_frame = 96000 / 200; break;
case CELL_ADEC_FS_192kHz: samples_per_frame = 192000 / 200; break;
default: return CELL_ADEC_ERROR_FATAL;
}
u32 allocated_bytes_per_sample;
switch (size_of_word)
{
case CELL_ADEC_BIT_LENGTH_16: allocated_bytes_per_sample = 2; break;
case CELL_ADEC_BIT_LENGTH_20: // Same as below
case CELL_ADEC_BIT_LENGTH_24: allocated_bytes_per_sample = 3; break;
default: return CELL_ADEC_ERROR_FATAL;
}
handle->lpcm_param->audioPayloadSize = allocated_bytes_per_sample * allocated_channels * samples_per_frame * unk;
return CELL_OK;
}
error_code adecSetLpcmDvdParams(vm::ptr<LpcmDecContext> handle, u64 userData)
{
const u8 channel_layout = static_cast<u8>(userData >> 32);
const u8 sample_rate = static_cast<u8>(userData >> 40);
const u8 size_of_word = static_cast<u8>(userData >> 48);
const u8 unk = static_cast<u8>(userData >> 56);
handle->lpcm_param->channelNumber = channel_layout;
handle->lpcm_param->sampleRate = sample_rate;
handle->lpcm_param->sizeOfWord = size_of_word;
u32 samples_per_frame;
switch (sample_rate)
{
case CELL_ADEC_FS_48kHz: samples_per_frame = 48000 / 600; break;
case CELL_ADEC_FS_96kHz: samples_per_frame = 96000 / 600; break;
default: return CELL_ADEC_ERROR_FATAL;
}
u32 bits_per_sample;
switch (size_of_word)
{
case CELL_ADEC_BIT_LENGTH_16: bits_per_sample = 16; break;
case CELL_ADEC_BIT_LENGTH_20: bits_per_sample = 20; break;
case CELL_ADEC_BIT_LENGTH_24: bits_per_sample = 24; break;
default: return CELL_ADEC_ERROR_FATAL;
}
u32 channel_number;
switch (channel_layout)
{
case CELL_ADEC_LPCM_DVD_CH_MONO:
channel_number = 1;
break;
case CELL_ADEC_LPCM_DVD_CH_STEREO:
channel_number = 2;
break;
case 4:
if (sample_rate == CELL_ADEC_FS_96kHz && size_of_word == CELL_ADEC_BIT_LENGTH_24)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 3;
break;
case 5:
if (sample_rate == CELL_ADEC_FS_96kHz && size_of_word != CELL_ADEC_BIT_LENGTH_16)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 4;
break;
case CELL_ADEC_LPCM_DVD_CH_3_2:
if (sample_rate == CELL_ADEC_FS_96kHz)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 5;
break;
case CELL_ADEC_LPCM_DVD_CH_3_2_LFE:
if (sample_rate == CELL_ADEC_FS_96kHz || size_of_word == CELL_ADEC_BIT_LENGTH_24)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 6;
break;
case CELL_ADEC_LPCM_DVD_CH_3_4:
if (sample_rate == CELL_ADEC_FS_96kHz || size_of_word != CELL_ADEC_BIT_LENGTH_16)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 7;
break;
case CELL_ADEC_LPCM_DVD_CH_3_4_LFE:
if (sample_rate == CELL_ADEC_FS_96kHz || size_of_word != CELL_ADEC_BIT_LENGTH_16)
{
return CELL_ADEC_ERROR_FATAL;
}
channel_number = 8;
break;
default:
return CELL_ADEC_ERROR_FATAL;
}
handle->lpcm_param->audioPayloadSize = bits_per_sample * channel_number * samples_per_frame / 8 * unk;
return CELL_OK;
}
error_code cellAdecDecodeAu(ppu_thread& ppu, vm::ptr<AdecContext> handle, vm::ptr<CellAdecAuInfo> auInfo)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
cellAdec.trace("cellAdecDecodeAu(handle=*0x%x, auInfo=*0x%x)", handle, auInfo);
if (!handle || !auInfo || !auInfo->size)
{
return CELL_ADEC_ERROR_ARG;
}
cellAdec.trace("cellAdecDecodeAu(): startAddr=*0x%x, size=0x%x, pts=0x%llx, userData=0x%llx", auInfo->startAddr, auInfo->size, std::bit_cast<be_t<u64>>(auInfo->pts), auInfo->userData);
if (handle->sequence_state != AdecSequenceState::ready)
{
return CELL_ADEC_ERROR_SEQ;
}
if (!auInfo->startAddr)
{
return CELL_ADEC_ERROR_ARG;
}
const error_code pcmHandle = handle->get_new_pcm_handle(auInfo);
if (pcmHandle == static_cast<s32>(CELL_ADEC_ERROR_BUSY))
{
return CELL_ADEC_ERROR_BUSY;
}
if (handle->type.audioCodecType == CELL_ADEC_TYPE_LPCM_BLURAY)
{
if (adecSetLpcmBlurayParams(vm::static_ptr_cast<LpcmDecContext>(handle->core_handle), auInfo->userData) != CELL_OK)
{
return CELL_ADEC_ERROR_FATAL;
}
}
else if (handle->type.audioCodecType == CELL_ADEC_TYPE_LPCM_DVD)
{
if (adecSetLpcmDvdParams(vm::static_ptr_cast<LpcmDecContext>(handle->core_handle), auInfo->userData) != CELL_OK)
{
return CELL_ADEC_ERROR_FATAL;
}
}
return handle->core_ops->decodeAu(ppu, handle->core_handle, pcmHandle, auInfo);
}
error_code cellAdecGetPcm(ppu_thread& ppu, vm::ptr<AdecContext> handle, vm::ptr<float> outBuffer)
{
// Block savestate creation during ppu_thread::fast_call()
std::unique_lock savestate_lock{g_fxo->get<hle_locks_t>(), std::try_to_lock};
if (!savestate_lock.owns_lock())
{
ppu.state += cpu_flag::again;
return {};
}
ppu.state += cpu_flag::wait;
cellAdec.trace("cellAdecGetPcm(handle=0x%x, outBuffer=*0x%x)", handle, outBuffer);
if (!handle)
{
return CELL_ADEC_ERROR_ARG;
}
// If the pcm_handles are equal, then cellAdecGetPcmItem() was not called before cellAdecGetPcm(). We need to pop pcm_item_queue as well
if (handle->pcm_item_queue.peek(ppu).pcm_handle == handle->pcm_queue.peek(ppu).pcm_handle)
{
handle->pcm_item_queue.pop(ppu);
}
const auto pcm_queue_entry = handle->pcm_queue.pop(ppu);
if (!pcm_queue_entry)
{
return CELL_ADEC_ERROR_EMPTY;
}
const auto pcm_item = pcm_queue_entry->pcm_item;
if (handle->verify_pcm_handle(pcm_item->pcmHandle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
if (handle->type.audioCodecType == CELL_ADEC_TYPE_LPCM_PAMF || handle->type.audioCodecType == CELL_ADEC_TYPE_LPCM_BLURAY || handle->type.audioCodecType == CELL_ADEC_TYPE_LPCM_DVD)
{
vm::static_ptr_cast<LpcmDecContext>(handle->core_handle)->output_size = pcm_item->size;
}
if (error_code ret = handle->core_ops->realign(ppu, handle->core_handle, outBuffer, pcm_queue_entry->pcm_item->startAddr); ret != CELL_OK)
{
return ret;
}
if (error_code ret = handle->core_ops->releasePcm(ppu, handle->core_handle, pcm_item->pcmHandle, outBuffer); ret != CELL_OK)
{
return ret;
}
if (handle->unlink_frame(ppu, pcm_item->pcmHandle) == static_cast<s32>(CELL_ADEC_ERROR_FATAL))
{
return CELL_ADEC_ERROR_FATAL;
}
handle->reset_frame(pcm_item->pcmHandle);
return CELL_OK;
}
error_code cellAdecGetPcmItem(ppu_thread& ppu, vm::ptr<AdecContext> handle, vm::pptr<CellAdecPcmItem> pcmItem)
{
cellAdec.trace("cellAdecGetPcmItem(handle=*0x%x, pcmItem=**0x%x)", handle, pcmItem);
if (!handle)
{
return CELL_ADEC_ERROR_ARG;
}
if (!pcmItem)
{
return CELL_ADEC_ERROR_FATAL;
}
const auto pcm_item_entry = handle->pcm_item_queue.pop(ppu);
if (ppu.state & cpu_flag::again) // Savestate was created while waiting on the queue mutex
{
return {};
}
if (!pcm_item_entry)
{
return CELL_ADEC_ERROR_EMPTY;
}
*pcmItem = pcm_item_entry->pcm_item;
return CELL_OK;
}
DECLARE(ppu_module_manager::cellAdec)("cellAdec", []()
{
REG_FUNC(cellAdec, cellAdecQueryAttr);
REG_FUNC(cellAdec, cellAdecOpen);
REG_FUNC(cellAdec, cellAdecOpenEx);
REG_FUNC(cellAdec, cellAdecOpenExt); // 0xdf982d2c
REG_FUNC(cellAdec, cellAdecClose);
REG_FUNC(cellAdec, cellAdecStartSeq);
REG_FUNC(cellAdec, cellAdecEndSeq);
REG_FUNC(cellAdec, cellAdecDecodeAu);
REG_FUNC(cellAdec, cellAdecGetPcm);
REG_FUNC(cellAdec, cellAdecGetPcmItem);
REG_HIDDEN_FUNC(adecNotifyAuDone);
REG_HIDDEN_FUNC(adecNotifyPcmOut);
REG_HIDDEN_FUNC(adecNotifyError);
REG_HIDDEN_FUNC(adecNotifySeqDone);
ppu_static_variable& lpcm_gvar = REG_VAR(cellAdec, g_cell_adec_core_ops_lpcm);
lpcm_gvar.flags = MFF_HIDDEN;
lpcm_gvar.init = []
{
g_cell_adec_core_ops_lpcm->getMemSize.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpGetMemSize_lpcm)));
g_cell_adec_core_ops_lpcm->open.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpOpen_lpcm)));
g_cell_adec_core_ops_lpcm->close.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpClose_lpcm)));
g_cell_adec_core_ops_lpcm->startSeq.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpStartSeq_lpcm)));
g_cell_adec_core_ops_lpcm->endSeq.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpEndSeq_lpcm)));
g_cell_adec_core_ops_lpcm->decodeAu.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpDecodeAu_lpcm)));
g_cell_adec_core_ops_lpcm->getVersion.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpGetVersion_lpcm)));
g_cell_adec_core_ops_lpcm->realign.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpRealign_lpcm)));
g_cell_adec_core_ops_lpcm->releasePcm.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpReleasePcm_lpcm)));
g_cell_adec_core_ops_lpcm->getPcmHandleNum.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpGetPcmHandleNum_lpcm)));
g_cell_adec_core_ops_lpcm->getBsiInfoSize.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpGetBsiInfoSize_lpcm)));
g_cell_adec_core_ops_lpcm->openExt.set(g_fxo->get<ppu_function_manager>().func_addr(FIND_FUNC(_CellAdecCoreOpOpenExt_lpcm)));
};
REG_HIDDEN_FUNC(_CellAdecCoreOpGetMemSize_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpOpen_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpClose_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpStartSeq_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpEndSeq_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpDecodeAu_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpGetVersion_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpRealign_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpReleasePcm_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpGetPcmHandleNum_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpGetBsiInfoSize_lpcm);
REG_HIDDEN_FUNC(_CellAdecCoreOpOpenExt_lpcm);
REG_HIDDEN_FUNC(lpcmDecEntry);
});
DECLARE(ppu_module_manager::cell_libac3dec)("cell_libac3dec", []
{
REG_VNID(cell_libac3dec, 0xc58bb170, g_cell_adec_core_ops_ac3);
});
DECLARE(ppu_module_manager::cellAtrac3dec)("cellAtrac3dec", []
{
REG_VNID(cellAtrac3dec, 0x60487d65, g_cell_adec_core_ops_atrac3);
});
DECLARE(ppu_module_manager::cellAtrac3multidec)("cellAtrac3multidec", []
{
REG_VNID(cellAtrac3multidec, 0xc20c6bd7, g_cell_adec_core_ops_atrac3multi);
});
DECLARE(ppu_module_manager::cellCelp8Dec)("cellCelp8Dec", []
{
REG_VNID(cellCelp8Dec, 0xf0190c6c, g_cell_adec_core_ops_Celp8);
REG_FUNC(cellCelp8Dec, _SceAdecCorrectPtsValue_Celp8);
});
DECLARE(ppu_module_manager::cellCelpDec)("cellCelpDec", []
{
REG_VNID(cellCelpDec, 0xffe42c22, g_cell_adec_core_ops_Celp);
REG_FUNC(cellCelpDec, _SceAdecCorrectPtsValue_Celp);
});
DECLARE(ppu_module_manager::cellDDPdec)("cellDDPdec", []
{
REG_VNID(cellDDPdec, 0xf5e9c15c, g_cell_adec_core_ops_Ddp);
REG_FUNC(cellDDPdec, _SceAdecCorrectPtsValue_Ddp);
});
DECLARE(ppu_module_manager::cellDTSdec)("cellDTSdec", []
{
REG_VNID(cellDTSdec, 0x15248ec5, g_cell_adec_core_ops_DtsCore);
REG_FUNC(cellDTSdec, _SceAdecCorrectPtsValue_DtsCore);
});
DECLARE(ppu_module_manager::cellDTSHDCOREdec)("cellDTSHDCOREdec", []
{
REG_VNID(cellDTSHDCOREdec, 0x6c8f4f1c, g_cell_adec_core_ops_DtsHd_Core);
REG_FUNC(cellDTSHDCOREdec, _SceAdecCorrectPtsValue_DtsHd_Core);
});
DECLARE(ppu_module_manager::cellDTSHDdec)("cellDTSHDdec", []
{
REG_VNID(cellDTSHDdec, 0x51ac2b6c, g_cell_adec_core_ops_DtsHd);
REG_FUNC(cellDTSHDdec, _SceAdecCorrectPtsValue_DtsHd);
});
DECLARE(ppu_module_manager::cellDTSLBRdec)("cellDTSLBRdec", []
{
REG_VNID(cellDTSLBRdec, 0x8c50af52, g_cell_adec_core_ops_DtsLbr);
REG_FUNC(cellDTSLBRdec, _SceAdecCorrectPtsValue_DtsLbr);
});
DECLARE(ppu_module_manager::cellM2AACdec)("cellM2AACdec", []
{
REG_VNID(cellM2AACdec, 0xac2f0831, g_cell_adec_core_ops_Aac);
REG_FUNC(cellM2AACdec, _SceAdecCorrectPtsValue_Aac);
});
DECLARE(ppu_module_manager::cellM2BCdec)("cellM2BCdec", []
{
REG_VNID(cellM2BCdec, 0x300afe4d, g_cell_adec_core_ops_mpmc);
REG_FUNC(cellM2BCdec, _SceAdecCorrectPtsValue_mpmc);
});
DECLARE(ppu_module_manager::cellM4AacDec)("cellM4AacDec", []
{
REG_VNID(cellM4AacDec, 0xab61278d, g_cell_adec_core_ops_M4Aac);
REG_FUNC(cellM4AacDec, _SceAdecCorrectPtsValue_M4Aac);
});
DECLARE(ppu_module_manager::cellM4AacDec2ch)("cellM4AacDec2ch", []
{
REG_VNID(cellM4AacDec2ch, 0xe996c664, g_cell_adec_core_ops_M4Aac2ch);
REG_FUNC(cellM4AacDec2ch, _SceAdecCorrectPtsValue_M4Aac2ch);
});
DECLARE(ppu_module_manager::cellM4AacDec2chmod)("cellM4AacDec2chmod", []
{
REG_VNID(cellM4AacDec2chmod, 0xdbd26836, g_cell_adec_core_ops_M4Aac2chmod);
REG_FUNC(cellM4AacDec2chmod, _SceAdecCorrectPtsValue_M4Aac2chmod);
});
DECLARE(ppu_module_manager::cellMP3dec)("cellMP3dec", []
{
REG_VNID(cellMP3dec, 0x84276a23, g_cell_adec_core_ops_Mp3);
});
DECLARE(ppu_module_manager::cellMP3Sdec)("cellMP3Sdec", []
{
REG_VNID(cellMP3Sdec, 0x292cdf0a, g_cell_adec_core_ops_Mp3s);
REG_FUNC(cellMP3Sdec, _SceAdecCorrectPtsValue_Mp3s);
});
DECLARE(ppu_module_manager::cellMPL1dec)("cellMPL1dec", []
{
REG_VNID(cellMPL1dec, 0xbbc70551, g_cell_adec_core_ops_mpmcl1);
REG_FUNC(cellMPL1dec, _SceAdecCorrectPtsValue_mpmcl1);
});
DECLARE(ppu_module_manager::cellTRHDdec)("cellTRHDdec", []
{
REG_VNID(cellTRHDdec, 0xe88e381b, g_cell_adec_core_ops_truehd);
REG_FUNC(cellTRHDdec, _SceAdecCorrectPtsValue_truehd);
});
DECLARE(ppu_module_manager::cellWMAdec)("cellWMAdec", []
{
REG_VNID(cellWMAdec, 0x88320b10, g_cell_adec_core_ops_wma);
REG_FUNC(cellWMAdec, _SceAdecCorrectPtsValue_wma);
});
DECLARE(ppu_module_manager::cellWMALSLdec)("cellWMALSLdec", []
{
REG_VNID(cellWMALSLdec, 0x602aab16, g_cell_adec_core_ops_WmaLsl);
REG_FUNC(cellWMALSLdec, _SceAdecCorrectPtsValue_WmaLsl);
});
DECLARE(ppu_module_manager::cellWMAPROdec)("cellWMAPROdec", []
{
REG_VNID(cellWMAPROdec, 0xa8bac670, g_cell_adec_core_ops_WmaPro);
REG_FUNC(cellWMAPROdec, _SceAdecCorrectPtsValue_WmaPro);
});
Reference in a new issue View git blame Copy permalink