From ca59ab59e9fdd239d5e425b4f5a4b3db44e185dc Mon Sep 17 00:00:00 2001 From: Megamouse Date: Sat, 16 Nov 2019 23:30:19 +0100 Subject: [PATCH] HLE: add even more error_code --- rpcs3/Emu/Cell/Modules/cellAdec.cpp | 247 +++++++++++++++++++++- rpcs3/Emu/Cell/Modules/cellAdec.h | 4 +- rpcs3/Emu/Cell/Modules/cellAtrac.cpp | 84 +++++--- rpcs3/Emu/Cell/Modules/cellAtrac.h | 9 +- rpcs3/Emu/Cell/Modules/cellAtracMulti.cpp | 89 +++++--- rpcs3/Emu/Cell/Modules/cellAtracMulti.h | 9 +- rpcs3/Emu/Cell/Modules/cellBgdl.cpp | 14 +- rpcs3/Emu/Cell/Modules/cellBgdl.h | 2 +- 8 files changed, 381 insertions(+), 77 deletions(-) diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.cpp b/rpcs3/Emu/Cell/Modules/cellAdec.cpp index 5090063ee6..b6fbfcbefe 100644 --- a/rpcs3/Emu/Cell/Modules/cellAdec.cpp +++ b/rpcs3/Emu/Cell/Modules/cellAdec.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/IdManager.h" #include "Emu/Cell/PPUModule.h" @@ -23,6 +23,231 @@ extern std::mutex g_mutex_avcodec_open2; LOG_CHANNEL(cellAdec); +template <> +void fmt_class_string::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_ATX_OK); // CELL_ADEC_ERROR_ATX_OFFSET, CELL_ADEC_ERROR_ATX_NONE + STR_CASE(CELL_ADEC_ERROR_ATX_BUSY); + STR_CASE(CELL_ADEC_ERROR_ATX_EMPTY); + STR_CASE(CELL_ADEC_ERROR_ATX_ATSHDR); + STR_CASE(CELL_ADEC_ERROR_ATX_NON_FATAL); + STR_CASE(CELL_ADEC_ERROR_ATX_NOT_IMPLE); + STR_CASE(CELL_ADEC_ERROR_ATX_PACK_CE_OVERFLOW); + STR_CASE(CELL_ADEC_ERROR_ATX_ILLEGAL_NPROCQUS); + STR_CASE(CELL_ADEC_ERROR_ATX_FATAL); + STR_CASE(CELL_ADEC_ERROR_ATX_ENC_OVERFLOW); + STR_CASE(CELL_ADEC_ERROR_ATX_PACK_CE_UNDERFLOW); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDCT); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GAINADJ); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDSF); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_SPECTRA); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GHWAVE); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_SHEADER); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_A); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_B); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_C); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_D); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_E); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_A); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_B); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_C); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDSF_D); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_IDCT_A); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GC_NGC); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_A); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_A); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLEV_B); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_GC_IDLOC_B); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_SN_NWVS); + STR_CASE(CELL_ADEC_ERROR_ATX_FATAL_HANDLE); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_SAMPLING_FREQ); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_CH_CONFIG_INDEX); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_NBYTES); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_NUM); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_BLOCK_ID); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_CHANNELS); + STR_CASE(CELL_ADEC_ERROR_ATX_UNINIT_BLOCK_SPECIFIED); + STR_CASE(CELL_ADEC_ERROR_ATX_POSCFG_PRESENT); + STR_CASE(CELL_ADEC_ERROR_ATX_BUFFER_OVERFLOW); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_BLK_TYPE_ID); + STR_CASE(CELL_ADEC_ERROR_ATX_UNPACK_CHANNEL_BLK_FAILED); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_1); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_BLK_ID_USED_2); + STR_CASE(CELL_ADEC_ERROR_ATX_ILLEGAL_ENC_SETTING); + STR_CASE(CELL_ADEC_ERROR_ATX_ILLEGAL_DEC_SETTING); + STR_CASE(CELL_ADEC_ERROR_ATX_ASSERT_NSAMPLES); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_SYNCWORD); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_SAMPLING_FREQ); + STR_CASE(CELL_ADEC_ERROR_ATX_ILL_CH_CONFIG_INDEX); + STR_CASE(CELL_ADEC_ERROR_ATX_RAW_DATA_FRAME_SIZE_OVER); + STR_CASE(CELL_ADEC_ERROR_ATX_SYNTAX_ENHANCE_LENGTH_OVER); + STR_CASE(CELL_ADEC_ERROR_ATX_SPU_INTERNAL_FAIL); + 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; + }); +} + class AudioDecoder : public ppu_thread { public: @@ -538,7 +763,7 @@ bool adecCheckType(s32 type) return true; } -s32 cellAdecQueryAttr(vm::ptr type, vm::ptr attr) +error_code cellAdecQueryAttr(vm::ptr type, vm::ptr attr) { cellAdec.warning("cellAdecQueryAttr(type=*0x%x, attr=*0x%x)", type, attr); @@ -555,7 +780,7 @@ s32 cellAdecQueryAttr(vm::ptr type, vm::ptr attr) return CELL_OK; } -s32 cellAdecOpen(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) +error_code cellAdecOpen(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) { cellAdec.warning("cellAdecOpen(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle); @@ -567,7 +792,7 @@ s32 cellAdecOpen(vm::ptr type, vm::ptr res, vm:: fmt::throw_exception("cellAdec disabled, use LLE."); } -s32 cellAdecOpenEx(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) +error_code cellAdecOpenEx(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) { cellAdec.warning("cellAdecOpenEx(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle); @@ -579,14 +804,14 @@ s32 cellAdecOpenEx(vm::ptr type, vm::ptr res, fmt::throw_exception("cellAdec disabled, use LLE."); } -s32 cellAdecOpenExt(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) +error_code cellAdecOpenExt(vm::ptr type, vm::ptr res, vm::ptr cb, vm::ptr handle) { cellAdec.warning("cellAdecOpenExt(type=*0x%x, res=*0x%x, cb=*0x%x, handle=*0x%x)", type, res, cb, handle); return cellAdecOpenEx(type, res, cb, handle); } -s32 cellAdecClose(u32 handle) +error_code cellAdecClose(u32 handle) { cellAdec.warning("cellAdecClose(handle=0x%x)", handle); @@ -609,7 +834,7 @@ s32 cellAdecClose(u32 handle) return CELL_OK; } -s32 cellAdecStartSeq(u32 handle, u32 param) +error_code cellAdecStartSeq(u32 handle, u32 param) { cellAdec.warning("cellAdecStartSeq(handle=0x%x, param=*0x%x)", handle, param); @@ -662,7 +887,7 @@ s32 cellAdecStartSeq(u32 handle, u32 param) return CELL_OK; } -s32 cellAdecEndSeq(u32 handle) +error_code cellAdecEndSeq(u32 handle) { cellAdec.warning("cellAdecEndSeq(handle=0x%x)", handle); @@ -677,7 +902,7 @@ s32 cellAdecEndSeq(u32 handle) return CELL_OK; } -s32 cellAdecDecodeAu(u32 handle, vm::ptr auInfo) +error_code cellAdecDecodeAu(u32 handle, vm::ptr auInfo) { cellAdec.trace("cellAdecDecodeAu(handle=0x%x, auInfo=*0x%x)", handle, auInfo); @@ -700,7 +925,7 @@ s32 cellAdecDecodeAu(u32 handle, vm::ptr auInfo) return CELL_OK; } -s32 cellAdecGetPcm(u32 handle, vm::ptr outBuffer) +error_code cellAdecGetPcm(u32 handle, vm::ptr outBuffer) { cellAdec.trace("cellAdecGetPcm(handle=0x%x, outBuffer=*0x%x)", handle, outBuffer); @@ -816,7 +1041,7 @@ s32 cellAdecGetPcm(u32 handle, vm::ptr outBuffer) return CELL_OK; } -s32 cellAdecGetPcmItem(u32 handle, vm::pptr pcmItem) +error_code cellAdecGetPcmItem(u32 handle, vm::pptr pcmItem) { cellAdec.trace("cellAdecGetPcmItem(handle=0x%x, pcmItem=**0x%x)", handle, pcmItem); diff --git a/rpcs3/Emu/Cell/Modules/cellAdec.h b/rpcs3/Emu/Cell/Modules/cellAdec.h index b7dba1223b..1e13568e9e 100644 --- a/rpcs3/Emu/Cell/Modules/cellAdec.h +++ b/rpcs3/Emu/Cell/Modules/cellAdec.h @@ -1,9 +1,9 @@ -#pragma once +#pragma once #include "Emu/Memory/vm_ptr.h" // Error Codes -enum +enum CellAdecError : u32 { CELL_ADEC_ERROR_FATAL = 0x80610001, CELL_ADEC_ERROR_SEQ = 0x80610002, diff --git a/rpcs3/Emu/Cell/Modules/cellAtrac.cpp b/rpcs3/Emu/Cell/Modules/cellAtrac.cpp index 5cdcccfc87..755cae8fc9 100644 --- a/rpcs3/Emu/Cell/Modules/cellAtrac.cpp +++ b/rpcs3/Emu/Cell/Modules/cellAtrac.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" @@ -6,7 +6,41 @@ LOG_CHANNEL(cellAtrac); -s32 cellAtracSetDataAndGetMemSize(vm::ptr pHandle, vm::ptr pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr puiWorkMemByte) +template <> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](CellAtracError value) + { + switch (value) + { + STR_CASE(CELL_ATRAC_ERROR_API_FAIL); + STR_CASE(CELL_ATRAC_ERROR_READSIZE_OVER_BUFFER); + STR_CASE(CELL_ATRAC_ERROR_UNKNOWN_FORMAT); + STR_CASE(CELL_ATRAC_ERROR_READSIZE_IS_TOO_SMALL); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_SAMPLING_RATE); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_DATA); + STR_CASE(CELL_ATRAC_ERROR_NO_DECODER); + STR_CASE(CELL_ATRAC_ERROR_UNSET_DATA); + STR_CASE(CELL_ATRAC_ERROR_DECODER_WAS_CREATED); + STR_CASE(CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED); + STR_CASE(CELL_ATRAC_ERROR_NODATA_IN_BUFFER); + STR_CASE(CELL_ATRAC_ERROR_NOT_ALIGNED_OUT_BUFFER); + STR_CASE(CELL_ATRAC_ERROR_NEED_SECOND_BUFFER); + STR_CASE(CELL_ATRAC_ERROR_ALLDATA_IS_ONMEMORY); + STR_CASE(CELL_ATRAC_ERROR_ADD_DATA_IS_TOO_BIG); + STR_CASE(CELL_ATRAC_ERROR_NONEED_SECOND_BUFFER); + STR_CASE(CELL_ATRAC_ERROR_UNSET_LOOP_NUM); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_SAMPLE); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_RESET_BYTE); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_PPU_THREAD_PRIORITY); + STR_CASE(CELL_ATRAC_ERROR_ILLEGAL_SPU_THREAD_PRIORITY); + } + + return unknown; + }); +} + +error_code cellAtracSetDataAndGetMemSize(vm::ptr pHandle, vm::ptr pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr puiWorkMemByte) { cellAtrac.warning("cellAtracSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte); @@ -14,7 +48,7 @@ s32 cellAtracSetDataAndGetMemSize(vm::ptr pHandle, vm::ptr return CELL_OK; } -s32 cellAtracCreateDecoder(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) +error_code cellAtracCreateDecoder(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) { cellAtrac.warning("cellAtracCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority); @@ -22,7 +56,7 @@ s32 cellAtracCreateDecoder(vm::ptr pHandle, vm::ptr pucWork return CELL_OK; } -s32 cellAtracCreateDecoderExt(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, vm::ptr pExtRes) +error_code cellAtracCreateDecoderExt(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, vm::ptr pExtRes) { cellAtrac.warning("cellAtracCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes); @@ -30,14 +64,14 @@ s32 cellAtracCreateDecoderExt(vm::ptr pHandle, vm::ptr pucW return CELL_OK; } -s32 cellAtracDeleteDecoder(vm::ptr pHandle) +error_code cellAtracDeleteDecoder(vm::ptr pHandle) { cellAtrac.warning("cellAtracDeleteDecoder(pHandle=*0x%x)", pHandle); return CELL_OK; } -s32 cellAtracDecode(vm::ptr pHandle, vm::ptr pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) +error_code cellAtracDecode(vm::ptr pHandle, vm::ptr pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) { cellAtrac.warning("cellAtracDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame); @@ -47,7 +81,7 @@ s32 cellAtracDecode(vm::ptr pHandle, vm::ptr pfOutAddr, return CELL_OK; } -s32 cellAtracGetStreamDataInfo(vm::ptr pHandle, vm::pptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) +error_code cellAtracGetStreamDataInfo(vm::ptr pHandle, vm::pptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) { cellAtrac.warning("cellAtracGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition); @@ -57,14 +91,14 @@ s32 cellAtracGetStreamDataInfo(vm::ptr pHandle, vm::pptr pp return CELL_OK; } -s32 cellAtracAddStreamData(vm::ptr pHandle, u32 uiAddByte) +error_code cellAtracAddStreamData(vm::ptr pHandle, u32 uiAddByte) { cellAtrac.warning("cellAtracAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte); return CELL_OK; } -s32 cellAtracGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) +error_code cellAtracGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) { cellAtrac.warning("cellAtracGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame); @@ -72,7 +106,7 @@ s32 cellAtracGetRemainFrame(vm::ptr pHandle, vm::ptr piRem return CELL_OK; } -s32 cellAtracGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) +error_code cellAtracGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) { cellAtrac.warning("cellAtracGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize); @@ -80,14 +114,14 @@ s32 cellAtracGetVacantSize(vm::ptr pHandle, vm::ptr puiVac return CELL_OK; } -s32 cellAtracIsSecondBufferNeeded(vm::ptr pHandle) +error_code cellAtracIsSecondBufferNeeded(vm::ptr pHandle) { cellAtrac.warning("cellAtracIsSecondBufferNeeded(pHandle=*0x%x)", pHandle); return 0; } -s32 cellAtracGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) +error_code cellAtracGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) { cellAtrac.warning("cellAtracGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte); @@ -96,14 +130,14 @@ s32 cellAtracGetSecondBufferInfo(vm::ptr pHandle, vm::ptr return CELL_OK; } -s32 cellAtracSetSecondBuffer(vm::ptr pHandle, vm::ptr pucSecondBufferAddr, u32 uiSecondBufferByte) +error_code cellAtracSetSecondBuffer(vm::ptr pHandle, vm::ptr pucSecondBufferAddr, u32 uiSecondBufferByte) { cellAtrac.warning("cellAtracSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte); return CELL_OK; } -s32 cellAtracGetChannel(vm::ptr pHandle, vm::ptr puiChannel) +error_code cellAtracGetChannel(vm::ptr pHandle, vm::ptr puiChannel) { cellAtrac.warning("cellAtracGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel); @@ -111,7 +145,7 @@ s32 cellAtracGetChannel(vm::ptr pHandle, vm::ptr puiChanne return CELL_OK; } -s32 cellAtracGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) +error_code cellAtracGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) { cellAtrac.warning("cellAtracGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample); @@ -119,7 +153,7 @@ s32 cellAtracGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxS return CELL_OK; } -s32 cellAtracGetNextSample(vm::ptr pHandle, vm::ptr puiNextSample) +error_code cellAtracGetNextSample(vm::ptr pHandle, vm::ptr puiNextSample) { cellAtrac.warning("cellAtracGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample); @@ -127,7 +161,7 @@ s32 cellAtracGetNextSample(vm::ptr pHandle, vm::ptr puiNex return CELL_OK; } -s32 cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) +error_code cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) { cellAtrac.warning("cellAtracGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample); @@ -137,7 +171,7 @@ s32 cellAtracGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSa return CELL_OK; } -s32 cellAtracGetNextDecodePosition(vm::ptr pHandle, vm::ptr puiSamplePosition) +error_code cellAtracGetNextDecodePosition(vm::ptr pHandle, vm::ptr puiSamplePosition) { cellAtrac.warning("cellAtracGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition); @@ -145,7 +179,7 @@ s32 cellAtracGetNextDecodePosition(vm::ptr pHandle, vm::ptr pHandle, vm::ptr puiBitrate) +error_code cellAtracGetBitrate(vm::ptr pHandle, vm::ptr puiBitrate) { cellAtrac.warning("cellAtracGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate); @@ -153,7 +187,7 @@ s32 cellAtracGetBitrate(vm::ptr pHandle, vm::ptr puiBitrat return CELL_OK; } -s32 cellAtracGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) +error_code cellAtracGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) { cellAtrac.warning("cellAtracGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus); @@ -162,14 +196,14 @@ s32 cellAtracGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNu return CELL_OK; } -s32 cellAtracSetLoopNum(vm::ptr pHandle, s32 iLoopNum) +error_code cellAtracSetLoopNum(vm::ptr pHandle, s32 iLoopNum) { cellAtrac.warning("cellAtracSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum); return CELL_OK; } -s32 cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) +error_code cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) { cellAtrac.warning("cellAtracGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo); @@ -180,14 +214,14 @@ s32 cellAtracGetBufferInfoForResetting(vm::ptr pHandle, u32 uiS return CELL_OK; } -s32 cellAtracResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte) +error_code cellAtracResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte) { cellAtrac.warning("cellAtracResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x)", pHandle, uiSample, uiWriteByte); return CELL_OK; } -s32 cellAtracGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) +error_code cellAtracGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) { cellAtrac.warning("cellAtracGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult); @@ -195,7 +229,7 @@ s32 cellAtracGetInternalErrorInfo(vm::ptr pHandle, vm::ptr return CELL_OK; } -s32 cellAtracGetSamplingRate() +error_code cellAtracGetSamplingRate() { UNIMPLEMENTED_FUNC(cellAtrac); return CELL_OK; diff --git a/rpcs3/Emu/Cell/Modules/cellAtrac.h b/rpcs3/Emu/Cell/Modules/cellAtrac.h index a4b3013759..1c4faf50a1 100644 --- a/rpcs3/Emu/Cell/Modules/cellAtrac.h +++ b/rpcs3/Emu/Cell/Modules/cellAtrac.h @@ -1,9 +1,9 @@ -#pragma once +#pragma once #include "Emu/Memory/vm_ptr.h" // Return Codes -enum +enum CellAtracError : u32 { CELL_ATRAC_ERROR_API_FAIL = 0x80610301, CELL_ATRAC_ERROR_READSIZE_OVER_BUFFER = 0x80610311, @@ -36,6 +36,11 @@ enum : s32 CELL_ATRAC_LOOP_STREAM_DATA_IS_ON_MEMORY = -3, }; +enum +{ + CELL_ATRAC_HANDLE_SIZE = 512 +}; + struct alignas(8) CellAtracHandle { vm::ptr pucWorkMem; diff --git a/rpcs3/Emu/Cell/Modules/cellAtracMulti.cpp b/rpcs3/Emu/Cell/Modules/cellAtracMulti.cpp index c82ba26dee..fc55a1bd59 100644 --- a/rpcs3/Emu/Cell/Modules/cellAtracMulti.cpp +++ b/rpcs3/Emu/Cell/Modules/cellAtracMulti.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" @@ -6,7 +6,42 @@ LOG_CHANNEL(cellAtracMulti); -s32 cellAtracMultiSetDataAndGetMemSize(vm::ptr pHandle, vm::ptr pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, u32 uiOutputChNum, vm::ptr piTrackArray, vm::ptr puiWorkMemByte) +template <> +void fmt_class_string::format(std::string& out, u64 arg) +{ + format_enum(out, arg, [](CellAtracMultiError value) + { + switch (value) + { + STR_CASE(CELL_ATRACMULTI_ERROR_API_FAIL); + STR_CASE(CELL_ATRACMULTI_ERROR_READSIZE_OVER_BUFFER); + STR_CASE(CELL_ATRACMULTI_ERROR_UNKNOWN_FORMAT); + STR_CASE(CELL_ATRACMULTI_ERROR_READSIZE_IS_TOO_SMALL); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLING_RATE); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_DATA); + STR_CASE(CELL_ATRACMULTI_ERROR_NO_DECODER); + STR_CASE(CELL_ATRACMULTI_ERROR_UNSET_DATA); + STR_CASE(CELL_ATRACMULTI_ERROR_DECODER_WAS_CREATED); + STR_CASE(CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED); + STR_CASE(CELL_ATRACMULTI_ERROR_NODATA_IN_BUFFER); + STR_CASE(CELL_ATRACMULTI_ERROR_NOT_ALIGNED_OUT_BUFFER); + STR_CASE(CELL_ATRACMULTI_ERROR_NEED_SECOND_BUFFER); + STR_CASE(CELL_ATRACMULTI_ERROR_ALLDATA_IS_ONMEMORY); + STR_CASE(CELL_ATRACMULTI_ERROR_ADD_DATA_IS_TOO_BIG); + STR_CASE(CELL_ATRACMULTI_ERROR_NONEED_SECOND_BUFFER); + STR_CASE(CELL_ATRACMULTI_ERROR_UNSET_LOOP_NUM); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_SAMPLE); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_RESET_BYTE); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_PPU_THREAD_PRIORITY); + STR_CASE(CELL_ATRACMULTI_ERROR_ILLEGAL_SPU_THREAD_PRIORITY); + STR_CASE(CELL_ATRACMULTI_ERROR_API_PARAMETER); + } + + return unknown; + }); +} + +error_code cellAtracMultiSetDataAndGetMemSize(vm::ptr pHandle, vm::ptr pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, u32 uiOutputChNum, vm::ptr piTrackArray, vm::ptr puiWorkMemByte) { cellAtracMulti.warning("cellAtracMultiSetDataAndGetMemSize(pHandle=*0x%x, pucBufferAddr=*0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, uiOutputChNum=%d, piTrackArray=*0x%x, puiWorkMemByte=*0x%x)", pHandle, pucBufferAddr, uiReadByte, uiBufferByte, uiOutputChNum, piTrackArray, puiWorkMemByte); @@ -15,7 +50,7 @@ s32 cellAtracMultiSetDataAndGetMemSize(vm::ptr pHandle, vm return CELL_OK; } -s32 cellAtracMultiCreateDecoder(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) +error_code cellAtracMultiCreateDecoder(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority) { cellAtracMulti.warning("cellAtracMultiCreateDecoder(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)", pHandle, pucWorkMem, uiPpuThreadPriority, uiSpuThreadPriority); @@ -23,7 +58,7 @@ s32 cellAtracMultiCreateDecoder(vm::ptr pHandle, vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, vm::ptr pExtRes) +error_code cellAtracMultiCreateDecoderExt(vm::ptr pHandle, vm::ptr pucWorkMem, u32 uiPpuThreadPriority, vm::ptr pExtRes) { cellAtracMulti.warning("cellAtracMultiCreateDecoderExt(pHandle=*0x%x, pucWorkMem=*0x%x, uiPpuThreadPriority=%d, pExtRes=*0x%x)", pHandle, pucWorkMem, uiPpuThreadPriority, pExtRes); @@ -31,14 +66,14 @@ s32 cellAtracMultiCreateDecoderExt(vm::ptr pHandle, vm::pt return CELL_OK; } -s32 cellAtracMultiDeleteDecoder(vm::ptr pHandle) +error_code cellAtracMultiDeleteDecoder(vm::ptr pHandle) { cellAtracMulti.warning("cellAtracMultiDeleteDecoder(pHandle=*0x%x)", pHandle); return CELL_OK; } -s32 cellAtracMultiDecode(vm::ptr pHandle, vm::ptr pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) +error_code cellAtracMultiDecode(vm::ptr pHandle, vm::ptr pfOutAddr, vm::ptr puiSamples, vm::ptr puiFinishflag, vm::ptr piRemainFrame) { cellAtracMulti.warning("cellAtracMultiDecode(pHandle=*0x%x, pfOutAddr=*0x%x, puiSamples=*0x%x, puiFinishFlag=*0x%x, piRemainFrame=*0x%x)", pHandle, pfOutAddr, puiSamples, puiFinishflag, piRemainFrame); @@ -48,7 +83,7 @@ s32 cellAtracMultiDecode(vm::ptr pHandle, vm::ptr p return CELL_OK; } -s32 cellAtracMultiGetStreamDataInfo(vm::ptr pHandle, vm::pptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) +error_code cellAtracMultiGetStreamDataInfo(vm::ptr pHandle, vm::pptr ppucWritePointer, vm::ptr puiWritableByte, vm::ptr puiReadPosition) { cellAtracMulti.warning("cellAtracMultiGetStreamDataInfo(pHandle=*0x%x, ppucWritePointer=**0x%x, puiWritableByte=*0x%x, puiReadPosition=*0x%x)", pHandle, ppucWritePointer, puiWritableByte, puiReadPosition); @@ -58,14 +93,14 @@ s32 cellAtracMultiGetStreamDataInfo(vm::ptr pHandle, vm::p return CELL_OK; } -s32 cellAtracMultiAddStreamData(vm::ptr pHandle, u32 uiAddByte) +error_code cellAtracMultiAddStreamData(vm::ptr pHandle, u32 uiAddByte) { cellAtracMulti.warning("cellAtracMultiAddStreamData(pHandle=*0x%x, uiAddByte=0x%x)", pHandle, uiAddByte); return CELL_OK; } -s32 cellAtracMultiGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) +error_code cellAtracMultiGetRemainFrame(vm::ptr pHandle, vm::ptr piRemainFrame) { cellAtracMulti.warning("cellAtracMultiGetRemainFrame(pHandle=*0x%x, piRemainFrame=*0x%x)", pHandle, piRemainFrame); @@ -73,7 +108,7 @@ s32 cellAtracMultiGetRemainFrame(vm::ptr pHandle, vm::ptr< return CELL_OK; } -s32 cellAtracMultiGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) +error_code cellAtracMultiGetVacantSize(vm::ptr pHandle, vm::ptr puiVacantSize) { cellAtracMulti.warning("cellAtracMultiGetVacantSize(pHandle=*0x%x, puiVacantSize=*0x%x)", pHandle, puiVacantSize); @@ -81,14 +116,14 @@ s32 cellAtracMultiGetVacantSize(vm::ptr pHandle, vm::ptr pHandle) +error_code cellAtracMultiIsSecondBufferNeeded(vm::ptr pHandle) { cellAtracMulti.warning("cellAtracMultiIsSecondBufferNeeded(pHandle=*0x%x)", pHandle); - return 0; + return not_an_error(0); } -s32 cellAtracMultiGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) +error_code cellAtracMultiGetSecondBufferInfo(vm::ptr pHandle, vm::ptr puiReadPosition, vm::ptr puiDataByte) { cellAtracMulti.warning("cellAtracMultiGetSecondBufferInfo(pHandle=*0x%x, puiReadPosition=*0x%x, puiDataByte=*0x%x)", pHandle, puiReadPosition, puiDataByte); @@ -97,14 +132,14 @@ s32 cellAtracMultiGetSecondBufferInfo(vm::ptr pHandle, vm: return CELL_OK; } -s32 cellAtracMultiSetSecondBuffer(vm::ptr pHandle, vm::ptr pucSecondBufferAddr, u32 uiSecondBufferByte) +error_code cellAtracMultiSetSecondBuffer(vm::ptr pHandle, vm::ptr pucSecondBufferAddr, u32 uiSecondBufferByte) { cellAtracMulti.warning("cellAtracMultiSetSecondBuffer(pHandle=*0x%x, pucSecondBufferAddr=*0x%x, uiSecondBufferByte=0x%x)", pHandle, pucSecondBufferAddr, uiSecondBufferByte); return CELL_OK; } -s32 cellAtracMultiGetChannel(vm::ptr pHandle, vm::ptr puiChannel) +error_code cellAtracMultiGetChannel(vm::ptr pHandle, vm::ptr puiChannel) { cellAtracMulti.warning("cellAtracMultiGetChannel(pHandle=*0x%x, puiChannel=*0x%x)", pHandle, puiChannel); @@ -112,7 +147,7 @@ s32 cellAtracMultiGetChannel(vm::ptr pHandle, vm::ptr return CELL_OK; } -s32 cellAtracMultiGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) +error_code cellAtracMultiGetMaxSample(vm::ptr pHandle, vm::ptr puiMaxSample) { cellAtracMulti.warning("cellAtracMultiGetMaxSample(pHandle=*0x%x, puiMaxSample=*0x%x)", pHandle, puiMaxSample); @@ -120,7 +155,7 @@ s32 cellAtracMultiGetMaxSample(vm::ptr pHandle, vm::ptr pHandle, vm::ptr puiNextSample) +error_code cellAtracMultiGetNextSample(vm::ptr pHandle, vm::ptr puiNextSample) { cellAtracMulti.warning("cellAtracMultiGetNextSample(pHandle=*0x%x, puiNextSample=*0x%x)", pHandle, puiNextSample); @@ -128,7 +163,7 @@ s32 cellAtracMultiGetNextSample(vm::ptr pHandle, vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) +error_code cellAtracMultiGetSoundInfo(vm::ptr pHandle, vm::ptr piEndSample, vm::ptr piLoopStartSample, vm::ptr piLoopEndSample) { cellAtracMulti.warning("cellAtracMultiGetSoundInfo(pHandle=*0x%x, piEndSample=*0x%x, piLoopStartSample=*0x%x, piLoopEndSample=*0x%x)", pHandle, piEndSample, piLoopStartSample, piLoopEndSample); @@ -138,7 +173,7 @@ s32 cellAtracMultiGetSoundInfo(vm::ptr pHandle, vm::ptr pHandle, vm::ptr puiSamplePosition) +error_code cellAtracMultiGetNextDecodePosition(vm::ptr pHandle, vm::ptr puiSamplePosition) { cellAtracMulti.warning("cellAtracMultiGetNextDecodePosition(pHandle=*0x%x, puiSamplePosition=*0x%x)", pHandle, puiSamplePosition); @@ -146,7 +181,7 @@ s32 cellAtracMultiGetNextDecodePosition(vm::ptr pHandle, v return CELL_ATRACMULTI_ERROR_ALLDATA_WAS_DECODED; } -s32 cellAtracMultiGetBitrate(vm::ptr pHandle, vm::ptr puiBitrate) +error_code cellAtracMultiGetBitrate(vm::ptr pHandle, vm::ptr puiBitrate) { cellAtracMulti.warning("cellAtracMultiGetBitrate(pHandle=*0x%x, puiBitrate=*0x%x)", pHandle, puiBitrate); @@ -154,14 +189,14 @@ s32 cellAtracMultiGetBitrate(vm::ptr pHandle, vm::ptr return CELL_OK; } -s32 cellAtracMultiGetTrackArray(vm::ptr pHandle, vm::ptr piTrackArray) +error_code cellAtracMultiGetTrackArray(vm::ptr pHandle, vm::ptr piTrackArray) { cellAtracMulti.error("cellAtracMultiGetTrackArray(pHandle=*0x%x, piTrackArray=*0x%x)", pHandle, piTrackArray); return CELL_OK; } -s32 cellAtracMultiGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) +error_code cellAtracMultiGetLoopInfo(vm::ptr pHandle, vm::ptr piLoopNum, vm::ptr puiLoopStatus) { cellAtracMulti.warning("cellAtracMultiGetLoopInfo(pHandle=*0x%x, piLoopNum=*0x%x, puiLoopStatus=*0x%x)", pHandle, piLoopNum, puiLoopStatus); @@ -170,14 +205,14 @@ s32 cellAtracMultiGetLoopInfo(vm::ptr pHandle, vm::ptr pHandle, s32 iLoopNum) +error_code cellAtracMultiSetLoopNum(vm::ptr pHandle, s32 iLoopNum) { cellAtracMulti.warning("cellAtracMultiSetLoopNum(pHandle=*0x%x, iLoopNum=%d)", pHandle, iLoopNum); return CELL_OK; } -s32 cellAtracMultiGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) +error_code cellAtracMultiGetBufferInfoForResetting(vm::ptr pHandle, u32 uiSample, vm::ptr pBufferInfo) { cellAtracMulti.warning("cellAtracMultiGetBufferInfoForResetting(pHandle=*0x%x, uiSample=0x%x, pBufferInfo=*0x%x)", pHandle, uiSample, pBufferInfo); @@ -188,14 +223,14 @@ s32 cellAtracMultiGetBufferInfoForResetting(vm::ptr pHandl return CELL_OK; } -s32 cellAtracMultiResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte, vm::ptr piTrackArray) +error_code cellAtracMultiResetPlayPosition(vm::ptr pHandle, u32 uiSample, u32 uiWriteByte, vm::ptr piTrackArray) { cellAtracMulti.warning("cellAtracMultiResetPlayPosition(pHandle=*0x%x, uiSample=0x%x, uiWriteByte=0x%x, piTrackArray=*0x%x)", pHandle, uiSample, uiWriteByte, piTrackArray); return CELL_OK; } -s32 cellAtracMultiGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) +error_code cellAtracMultiGetInternalErrorInfo(vm::ptr pHandle, vm::ptr piResult) { cellAtracMulti.warning("cellAtracMultiGetInternalErrorInfo(pHandle=*0x%x, piResult=*0x%x)", pHandle, piResult); @@ -203,7 +238,7 @@ s32 cellAtracMultiGetInternalErrorInfo(vm::ptr pHandle, vm return CELL_OK; } -s32 cellAtracMultiGetSamplingRate() +error_code cellAtracMultiGetSamplingRate() { UNIMPLEMENTED_FUNC(cellAtracMulti); return CELL_OK; diff --git a/rpcs3/Emu/Cell/Modules/cellAtracMulti.h b/rpcs3/Emu/Cell/Modules/cellAtracMulti.h index f8d2e25172..3a36ecd7f7 100644 --- a/rpcs3/Emu/Cell/Modules/cellAtracMulti.h +++ b/rpcs3/Emu/Cell/Modules/cellAtracMulti.h @@ -1,9 +1,9 @@ -#pragma once +#pragma once #include "Emu/Memory/vm_ptr.h" // Return Codes -enum +enum CellAtracMultiError : u32 { CELL_ATRACMULTI_ERROR_API_FAIL = 0x80610b01, CELL_ATRACMULTI_ERROR_READSIZE_OVER_BUFFER = 0x80610b11, @@ -37,6 +37,11 @@ enum : s32 CELL_ATRACMULTI_LOOP_STREAM_DATA_IS_ON_MEMORY = -3, }; +enum +{ + CELL_ATRACMULTI_HANDLE_SIZE = 512 +}; + struct alignas(8) CellAtracMultiHandle { vm::ptr pucWorkMem; diff --git a/rpcs3/Emu/Cell/Modules/cellBgdl.cpp b/rpcs3/Emu/Cell/Modules/cellBgdl.cpp index 0cc157cecb..0dfcaeed8e 100644 --- a/rpcs3/Emu/Cell/Modules/cellBgdl.cpp +++ b/rpcs3/Emu/Cell/Modules/cellBgdl.cpp @@ -1,4 +1,4 @@ -#include "stdafx.h" +#include "stdafx.h" #include "Emu/System.h" #include "Emu/Cell/PPUModule.h" @@ -8,25 +8,25 @@ LOG_CHANNEL(cellBGDL); -s32 cellBGDLGetInfo(vm::cptr content_id, vm::ptr info, s32 num) +error_code cellBGDLGetInfo(vm::cptr content_id, vm::ptr info, s32 num) { cellBGDL.todo("cellBGDLGetInfo(content_id=%s, info=*0x%x, num=%d)", content_id, info, num); - return 0; + return CELL_OK; } -s32 cellBGDLGetInfo2(vm::cptr service_id, vm::ptr info, s32 num) +error_code cellBGDLGetInfo2(vm::cptr service_id, vm::ptr info, s32 num) { cellBGDL.todo("cellBGDLGetInfo2(service_id=%s, info=*0x%x, num=%d)", service_id, info, num); - return 0; + return CELL_OK; } -s32 cellBGDLSetMode(CellBGDLMode mode) +error_code cellBGDLSetMode(CellBGDLMode mode) { cellBGDL.todo("cellBGDLSetMode(mode=%d)", (s32) mode); return CELL_OK; } -s32 cellBGDLGetMode(vm::ptr mode) +error_code cellBGDLGetMode(vm::ptr mode) { cellBGDL.todo("cellBGDLGetMode(mode=*0x%x)", mode); return CELL_OK; diff --git a/rpcs3/Emu/Cell/Modules/cellBgdl.h b/rpcs3/Emu/Cell/Modules/cellBgdl.h index cf27a2d130..9ca2757ff0 100644 --- a/rpcs3/Emu/Cell/Modules/cellBgdl.h +++ b/rpcs3/Emu/Cell/Modules/cellBgdl.h @@ -1,4 +1,4 @@ -#pragma once +#pragma once #include "Emu/Memory/vm_ptr.h"