diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp index 76a88533ef..5829ac0e29 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp @@ -6,57 +6,59 @@ void cellAdec_init(); Module cellAdec(0x0006, cellAdec_init); -int cellAdecQueryAttr() +int cellAdecQueryAttr(mem_ptr_t type, mem_ptr_t attr) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr()); return CELL_OK; } -int cellAdecOpen() +int cellAdecOpen(mem_ptr_t type, mem_ptr_t res, mem_ptr_t cb, mem32_t handle) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", + type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr()); return CELL_OK; } -int cellAdecOpenEx() +int cellAdecOpenEx(mem_ptr_t type, mem_ptr_t res, mem_ptr_t cb, mem32_t handle) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", + type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr()); return CELL_OK; } -int cellAdecClose() +int cellAdecClose(u32 handle) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecClose(handle=0x%x)", handle); return CELL_OK; } -int cellAdecStartSeq() +int cellAdecStartSeq(u32 handle, u32 param_addr) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecStartSeq(handle=0x%x, param_addr=0x%x)", handle, param_addr); return CELL_OK; } -int cellAdecEndSeq() +int cellAdecEndSeq(u32 handle) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecEndSeq(handle=0x%x)", handle); return CELL_OK; } -int cellAdecDecodeAu() +int cellAdecDecodeAu(u32 handle, mem_ptr_t auInfo) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecDecodeAu(handle=0x%x, auInfo_addr=0x%x)", handle, auInfo.GetAddr()); return CELL_OK; } -int cellAdecGetPcm() +int cellAdecGetPcm(u32 handle, u32 outBuffer_addr) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecGetPcm(handle=0x%x, outBuffer_addr=0x%x)", handle, outBuffer_addr); return CELL_OK; } -int cellAdecGetPcmItem() +int cellAdecGetPcmItem(u32 handle, u32 pcmItem_ptr_addr) { - UNIMPLEMENTED_FUNC(cellAdec); + cellAdec.Error("cellAdecGetPcmItem(handle=0x%x, pcmItem_ptr_addr=0x%x)", handle, pcmItem_ptr_addr); return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.h b/rpcs3/Emu/SysCalls/Modules/cellAdec.h index d5e816291b..d9423c5d85 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAdec.h +++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.h @@ -1,4 +1,5 @@ #pragma once +#include "cellPamf.h" // Error Codes enum @@ -8,4 +9,998 @@ enum CELL_ADEC_ERROR_ARG = 0x80610003, CELL_ADEC_ERROR_BUSY = 0x80610004, CELL_ADEC_ERROR_EMPTY = 0x80610005, + + CELL_ADEC_ERROR_CELP_BUSY = 0x80612e01, + CELL_ADEC_ERROR_CELP_EMPTY = 0x80612e02, + CELL_ADEC_ERROR_CELP_ARG = 0x80612e03, + CELL_ADEC_ERROR_CELP_SEQ = 0x80612e04, + CELL_ADEC_ERROR_CELP_CORE_FATAL = 0x80612e81, + CELL_ADEC_ERROR_CELP_CORE_ARG = 0x80612e82, + CELL_ADEC_ERROR_CELP_CORE_SEQ = 0x80612e83, + + CELL_ADEC_ERROR_CELP8_BUSY = 0x80612ea1, + CELL_ADEC_ERROR_CELP8_EMPTY = 0x80612ea2, + CELL_ADEC_ERROR_CELP8_ARG = 0x80612ea3, + CELL_ADEC_ERROR_CELP8_SEQ = 0x80612ea4, + CELL_ADEC_ERROR_CELP8_CORE_FATAL = 0x80612eb1, + CELL_ADEC_ERROR_CELP8_CORE_ARG = 0x80612eb2, + CELL_ADEC_ERROR_CELP8_CORE_SEQ = 0x80612eb3, + + CELL_ADEC_ERROR_M4AAC_FATAL = 0x80612401, + CELL_ADEC_ERROR_M4AAC_SEQ = 0x80612402, + CELL_ADEC_ERROR_M4AAC_ARG = 0x80612403, + CELL_ADEC_ERROR_M4AAC_BUSY = 0x80612404, + CELL_ADEC_ERROR_M4AAC_EMPTY = 0x80612405, + CELL_ADEC_ERROR_M4AAC_BUFFER_OVERFLOW = 0x80612406, + CELL_ADEC_ERROR_M4AAC_END_OF_BITSTREAM = 0x80612407, + + /* Core */ + CELL_ADEC_ERROR_M4AAC_CH_CONFIG_INCONSISTENCY = 0x80612410, + CELL_ADEC_ERROR_M4AAC_NO_CH_DEFAULT_POS = 0x80612411, + CELL_ADEC_ERROR_M4AAC_INVALID_CH_POS = 0x80612412, + CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_COUPLING_CH = 0x80612413, + CELL_ADEC_ERROR_M4AAC_INVALID_LAYER_ID = 0x80612414, + CELL_ADEC_ERROR_M4AAC_ADTS_SYNCWORD_ERROR = 0x80612415, + CELL_ADEC_ERROR_M4AAC_INVALID_ADTS_ID = 0x80612416, + CELL_ADEC_ERROR_M4AAC_CH_CHANGED = 0x80612417, + CELL_ADEC_ERROR_M4AAC_SAMPLING_FREQ_CHANGED = 0x80612418, + CELL_ADEC_ERROR_M4AAC_WRONG_SBR_CH = 0x80612419, + CELL_ADEC_ERROR_M4AAC_WRONG_SCALE_FACTOR = 0x8061241a, + CELL_ADEC_ERROR_M4AAC_INVALID_BOOKS = 0x8061241b, + CELL_ADEC_ERROR_M4AAC_INVALID_SECTION_DATA = 0x8061241c, + CELL_ADEC_ERROR_M4AAC_PULSE_IS_NOT_LONG = 0x8061241d, + CELL_ADEC_ERROR_M4AAC_GC_IS_NOT_SUPPORTED = 0x8061241e, + CELL_ADEC_ERROR_M4AAC_INVALID_ELEMENT_ID = 0x8061241f, + CELL_ADEC_ERROR_M4AAC_NO_CH_CONFIG = 0x80612420, + CELL_ADEC_ERROR_M4AAC_UNEXPECTED_OVERLAP_CRC = 0x80612421, + CELL_ADEC_ERROR_M4AAC_CRC_BUFFER_EXCEEDED = 0x80612422, + CELL_ADEC_ERROR_M4AAC_INVALID_CRC = 0x80612423, + CELL_ADEC_ERROR_M4AAC_BAD_WINDOW_CODE = 0x80612424, + CELL_ADEC_ERROR_M4AAC_INVALID_ADIF_HEADER_ID = 0x80612425, + CELL_ADEC_ERROR_M4AAC_NOT_SUPPORTED_PROFILE = 0x80612426, + CELL_ADEC_ERROR_M4AAC_PROG_NUMBER_NOT_FOUND = 0x80612427, + CELL_ADEC_ERROR_M4AAC_INVALID_SAMP_RATE_INDEX = 0x80612428, + CELL_ADEC_ERROR_M4AAC_UNANTICIPATED_CH_CONFIG = 0x80612429, + CELL_ADEC_ERROR_M4AAC_PULSE_OVERFLOWED = 0x8061242a, + CELL_ADEC_ERROR_M4AAC_CAN_NOT_UNPACK_INDEX = 0x8061242b, + CELL_ADEC_ERROR_M4AAC_DEINTERLEAVE_FAILED = 0x8061242c, + CELL_ADEC_ERROR_M4AAC_CALC_BAND_OFFSET_FAILED = 0x8061242d, + CELL_ADEC_ERROR_M4AAC_GET_SCALE_FACTOR_FAILED = 0x8061242e, + CELL_ADEC_ERROR_M4AAC_GET_CC_GAIN_FAILED = 0x8061242f, + CELL_ADEC_ERROR_M4AAC_MIX_COUPLING_CH_FAILED = 0x80612430, + CELL_ADEC_ERROR_M4AAC_GROUP_IS_INVALID = 0x80612431, + CELL_ADEC_ERROR_M4AAC_PREDICT_FAILED = 0x80612432, + CELL_ADEC_ERROR_M4AAC_INVALID_PREDICT_RESET_PATTERN = 0x80612433, + CELL_ADEC_ERROR_M4AAC_INVALID_TNS_FRAME_INFO = 0x80612434, + CELL_ADEC_ERROR_M4AAC_GET_MASK_FAILED = 0x80612435, + CELL_ADEC_ERROR_M4AAC_GET_GROUP_FAILED = 0x80612436, + CELL_ADEC_ERROR_M4AAC_GET_LPFLAG_FAILED = 0x80612437, + CELL_ADEC_ERROR_M4AAC_INVERSE_QUANTIZATION_FAILED = 0x80612438, + CELL_ADEC_ERROR_M4AAC_GET_CB_MAP_FAILED = 0x80612439, + CELL_ADEC_ERROR_M4AAC_GET_PULSE_FAILED = 0x8061243a, + CELL_ADEC_ERROR_M4AAC_MONO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED + = 0x8061243b, + CELL_ADEC_ERROR_M4AAC_STEREO_MIXDOWN_ELEMENT_IS_NOT_SUPPORTED + = 0x8061243c, + + /* SBR */ + CELL_ADEC_ERROR_M4AAC_SBR_CH_OVERFLOW = 0x80612480, + CELL_ADEC_ERROR_M4AAC_SBR_NOSYNCH = 0x80612481, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PROGRAM = 0x80612482, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_TAG = 0x80612483, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_CHN_CONFIG = 0x80612484, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SECTION = 0x80612485, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_SCFACTORS = 0x80612486, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PULSE_DATA = 0x80612487, + CELL_ADEC_ERROR_M4AAC_SBR_MAIN_PROFILE_NOT_IMPLEMENTED = 0x80612488, + CELL_ADEC_ERROR_M4AAC_SBR_GC_NOT_IMPLEMENTED = 0x80612489, + CELL_ADEC_ERROR_M4AAC_SBR_ILLEGAL_PLUS_ELE_ID = 0x8061248a, + CELL_ADEC_ERROR_M4AAC_SBR_CREATE_ERROR = 0x8061248b, + CELL_ADEC_ERROR_M4AAC_SBR_NOT_INITIALIZED = 0x8061248c, + CELL_ADEC_ERROR_M4AAC_SBR_INVALID_ENVELOPE = 0x8061248d, + + + CELL_ADEC_ERROR_AC3_BUSY = 0x80612500, + CELL_ADEC_ERROR_AC3_EMPTY = 0x80612501, + CELL_ADEC_ERROR_AC3_PARAM = 0x80612502, + CELL_ADEC_ERROR_AC3_FRAME = 0x80612503, + + + CELL_ADEC_ERROR_AT3_OFFSET = 0x80612100, + CELL_ADEC_ERROR_AT3_OK = 0x80612100, + /* Adapter level error */ + CELL_ADEC_ERROR_AT3_BUSY = 0x80612164, + CELL_ADEC_ERROR_AT3_EMPTY = 0x80612165, + /* Core level error */ + CELL_ADEC_ERROR_AT3_ERROR = 0x80612180, + + + CELL_ADEC_ERROR_ATX_OFFSET = 0x80612200, + CELL_ADEC_ERROR_ATX_NONE = 0x80612200, /* no errors */ + CELL_ADEC_ERROR_ATX_OK = 0x80612200, + /*----- Adapter level error -----*/ + CELL_ADEC_ERROR_ATX_BUSY = 0x80612264, + CELL_ADEC_ERROR_ATX_EMPTY = 0x80612265, + CELL_ADEC_ERROR_ATX_ATSHDR = 0x80612266, + /*----- Core level error -----*/ + /* non fatal errors */ + CELL_ADEC_ERROR_ATX_NON_FATAL = 0x80612281, /* undefined error */ + CELL_ADEC_ERROR_ATX_NOT_IMPLE = 0x80612282, /* not implemented */ + CELL_ADEC_ERROR_ATX_PACK_CE_OVERFLOW = 0x80612283, /* pack_channel_block_at5() in pack_at5.c */ + CELL_ADEC_ERROR_ATX_ILLEGAL_NPROCQUS = 0x80612284, /* unpack_sheader() in pack_at5_sheader.c */ + /* fatal errors(block level) */ + CELL_ADEC_ERROR_ATX_FATAL = 0x8061228c, /* undefined error */ + CELL_ADEC_ERROR_ATX_ENC_OVERFLOW = 0x8061228d, /* at5enc_proc() in at5enc.c */ + CELL_ADEC_ERROR_ATX_PACK_CE_UNDERFLOW = 0x8061228e, /* pack_channel_block_at5() in pack_at5.c */ + /* to check syntax */ + CELL_ADEC_ERROR_ATX_SYNTAX_IDCT = 0x8061228f, /* unpack_idct() in pack_at5_codetbl.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_GAINADJ = 0x80612290, /* unpack_gainadj() in pack_at5_gainadj.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_IDSF = 0x80612291, /* unpack_idsf() in pack_at5_sfactor.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_SPECTRA = 0x80612292, /* unpack_spectra() in pack_at5_spectra.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_IDWL = 0x80612293, /* unpack_idwl() in pack_at5_idwl.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_GHWAVE = 0x80612294, /* unpack_ghwave() in pack_at5_ghwave.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_SHEADER = 0x80612295, /* unpack_sheader() in pack_at5_sheader.c */ + CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_A = 0x80612296, /* idwl[][]{0-7} range error */ + CELL_ADEC_ERROR_ATX_SYNTAX_IDWL_B = 0x80612297, /* idwl restriction error (wlc_encqu<=divqu frame_length */ + CELL_ADEC_ERROR_ATX_SYNTAX_ENHANCE_LENGTH_OVER = 0x806122bf, /* enhance_length {0,2046} range error */ + CELL_ADEC_ERROR_ATX_SPU_INTERNAL_FAIL = 0x806122c8, /* spu-processing failed */ + + + CELL_ADEC_ERROR_LPCM_FATAL = 0x80612001, + CELL_ADEC_ERROR_LPCM_SEQ = 0x80612002, + CELL_ADEC_ERROR_LPCM_ARG = 0x80612003, + CELL_ADEC_ERROR_LPCM_BUSY = 0x80612004, + CELL_ADEC_ERROR_LPCM_EMPTY = 0x80612005, + + + CELL_ADEC_ERROR_MP3_OFFSET = 0x80612700U, + + CELL_ADEC_ERROR_MP3_OK = 0x80612700, + + /* Adapter level error */ + CELL_ADEC_ERROR_MP3_BUSY = 0x80612764, + CELL_ADEC_ERROR_MP3_EMPTY = 0x80612765, + + /* Core level error */ + CELL_ADEC_ERROR_MP3_ERROR = 0x80612781, + CELL_ADEC_ERROR_MP3_LOST_SYNC = 0x80612782, + CELL_ADEC_ERROR_MP3_NOT_L3 = 0x80612783, + CELL_ADEC_ERROR_MP3_BAD_BITRATE = 0x80612784, + CELL_ADEC_ERROR_MP3_BAD_SFREQ = 0x80612785, + CELL_ADEC_ERROR_MP3_BAD_EMPHASIS = 0x80612786, + CELL_ADEC_ERROR_MP3_BAD_BLKTYPE = 0x80612787, + CELL_ADEC_ERROR_MP3_BAD_VERSION = 0x8061278c, + CELL_ADEC_ERROR_MP3_BAD_MODE = 0x8061278d, + CELL_ADEC_ERROR_MP3_BAD_MODE_EXT = 0x8061278e, + CELL_ADEC_ERROR_MP3_HUFFMAN_NUM = 0x80612796, + CELL_ADEC_ERROR_MP3_HUFFMAN_CASE_ID = 0x80612797, + CELL_ADEC_ERROR_MP3_SCALEFAC_COMPRESS = 0x80612798, + CELL_ADEC_ERROR_MP3_HGETBIT = 0x80612799, + CELL_ADEC_ERROR_MP3_FLOATING_EXCEPTION = 0x8061279a, + CELL_ADEC_ERROR_MP3_ARRAY_OVERFLOW = 0x8061279b, + CELL_ADEC_ERROR_MP3_STEREO_PROCESSING = 0x8061279c, + CELL_ADEC_ERROR_MP3_JS_BOUND = 0x8061279d, + CELL_ADEC_ERROR_MP3_PCMOUT = 0x8061279e, + + + CELL_ADEC_ERROR_M2BC_FATAL = 0x80612b01, + CELL_ADEC_ERROR_M2BC_SEQ = 0x80612b02, /* Not Used */ + CELL_ADEC_ERROR_M2BC_ARG = 0x80612b03, + CELL_ADEC_ERROR_M2BC_BUSY = 0x80612b04, + CELL_ADEC_ERROR_M2BC_EMPTY = 0x80612b05, + + /* Common header contents error */ + CELL_ADEC_ERROR_M2BC_SYNCF = 0x80612b11, + CELL_ADEC_ERROR_M2BC_LAYER = 0x80612b12, + CELL_ADEC_ERROR_M2BC_BITRATE = 0x80612b13, + CELL_ADEC_ERROR_M2BC_SAMPLEFREQ = 0x80612b14, + CELL_ADEC_ERROR_M2BC_VERSION = 0x80612b15, + CELL_ADEC_ERROR_M2BC_MODE_EXT = 0x80612b16, /* Not Used */ + CELL_ADEC_ERROR_M2BC_UNSUPPORT = 0x80612b17, /* */ + + /* Extension file header contents error */ + CELL_ADEC_ERROR_M2BC_OPENBS_EX = 0x80612b21, + CELL_ADEC_ERROR_M2BC_SYNCF_EX = 0x80612b22, + CELL_ADEC_ERROR_M2BC_CRCGET_EX = 0x80612b23, + CELL_ADEC_ERROR_M2BC_CRC_EX = 0x80612b24, + + /* Data sampling & CRC error (proper to MPEG I part) */ + CELL_ADEC_ERROR_M2BC_CRCGET = 0x80612b31, + CELL_ADEC_ERROR_M2BC_CRC = 0x80612b32, + CELL_ADEC_ERROR_M2BC_BITALLOC = 0x80612b33, + CELL_ADEC_ERROR_M2BC_SCALE = 0x80612b34, + CELL_ADEC_ERROR_M2BC_SAMPLE = 0x80612b35, + CELL_ADEC_ERROR_M2BC_OPENBS = 0x80612b36, + + /* Data sampling & CRC error (MPEG II muliti codec part) */ + CELL_ADEC_ERROR_M2BC_MC_CRCGET = 0x80612b41, + CELL_ADEC_ERROR_M2BC_MC_CRC = 0x80612b42, + CELL_ADEC_ERROR_M2BC_MC_BITALLOC = 0x80612b43, + CELL_ADEC_ERROR_M2BC_MC_SCALE = 0x80612b44, + CELL_ADEC_ERROR_M2BC_MC_SAMPLE = 0x80612b45, + CELL_ADEC_ERROR_M2BC_MC_HEADER = 0x80612b46, + CELL_ADEC_ERROR_M2BC_MC_STATUS = 0x80612b47, + + /* Data sampling & CRC error (MPEG II extention muliti codec part) */ + CELL_ADEC_ERROR_M2BC_AG_CCRCGET = 0x80612b51, + CELL_ADEC_ERROR_M2BC_AG_CRC = 0x80612b52, + CELL_ADEC_ERROR_M2BC_AG_BITALLOC = 0x80612b53, + CELL_ADEC_ERROR_M2BC_AG_SCALE = 0x80612b54, + CELL_ADEC_ERROR_M2BC_AG_SAMPLE = 0x80612b55, + CELL_ADEC_ERROR_M2BC_AG_STATUS = 0x80612b57, + +}; + +// Audio Codec Type +enum AudioCodecType +{ + CELL_ADEC_TYPE_RESERVED1, + CELL_ADEC_TYPE_LPCM_PAMF, + CELL_ADEC_TYPE_AC3, + CELL_ADEC_TYPE_ATRACX, + CELL_ADEC_TYPE_MP3, + CELL_ADEC_TYPE_ATRAC3, + CELL_ADEC_TYPE_MPEG_L2, + CELL_ADEC_TYPE_RESERVED5, + CELL_ADEC_TYPE_RESERVED6, + CELL_ADEC_TYPE_RESERVED7, + CELL_ADEC_TYPE_RESERVED8, + CELL_ADEC_TYPE_CELP, + CELL_ADEC_TYPE_RESERVED10, + CELL_ADEC_TYPE_ATRACX_2CH, + CELL_ADEC_TYPE_ATRACX_6CH, + CELL_ADEC_TYPE_ATRACX_8CH, + CELL_ADEC_TYPE_M4AAC, + CELL_ADEC_TYPE_RESERVED12, + CELL_ADEC_TYPE_RESERVED13, + CELL_ADEC_TYPE_RESERVED14, + CELL_ADEC_TYPE_RESERVED15, + CELL_ADEC_TYPE_RESERVED16, + CELL_ADEC_TYPE_RESERVED17, + CELL_ADEC_TYPE_RESERVED18, + CELL_ADEC_TYPE_RESERVED19, + CELL_ADEC_TYPE_CELP8, + CELL_ADEC_TYPE_RESERVED20, + CELL_ADEC_TYPE_RESERVED21, + CELL_ADEC_TYPE_RESERVED22, + CELL_ADEC_TYPE_RESERVED23, + CELL_ADEC_TYPE_RESERVED24, + CELL_ADEC_TYPE_RESERVED25, +}; + +// Output Channel Number +enum CellAdecChannel +{ + CELL_ADEC_CH_RESERVED1, + CELL_ADEC_CH_MONO, + CELL_ADEC_CH_RESERVED2, + CELL_ADEC_CH_STEREO, + CELL_ADEC_CH_3_0, + CELL_ADEC_CH_2_1, + CELL_ADEC_CH_3_1, + CELL_ADEC_CH_2_2, + CELL_ADEC_CH_3_2, + CELL_ADEC_CH_3_2_LFE, + CELL_ADEC_CH_3_4, + CELL_ADEC_CH_3_4_LFE, + CELL_ADEC_CH_RESERVED3, +}; + +// Sampling Rate +enum CellAdecSampleRate +{ + CELL_ADEC_FS_RESERVED1 = 0, + CELL_ADEC_FS_48kHz = 1, + CELL_ADEC_FS_16kHz = 2, + CELL_ADEC_FS_8kHz = 5, +}; + +enum CellAdecBitLength +{ + CELL_ADEC_BIT_LENGTH_RESERVED1, + CELL_ADEC_BIT_LENGTH_16, + CELL_ADEC_BIT_LENGTH_20, + CELL_ADEC_BIT_LENGTH_24, +}; + +struct CellAdecType +{ + be_t audioCodecType; +}; + +struct CellAdecAttr +{ + be_t workMemSize; + be_t adecVerUpper; + be_t adecVerLower; +}; + +struct CellAdecResource +{ + be_t totalMemSize; + be_t startAddr; + be_t ppuThreadPriority; + be_t spuThreadPriority; + be_t ppuThreadStackSize; +}; + +// Callback Messages +enum CellAdecMsgType +{ + CELL_ADEC_MSG_TYPE_AUDONE, + CELL_ADEC_MSG_TYPE_PCMOUT, + CELL_ADEC_MSG_TYPE_ERROR, + CELL_ADEC_MSG_TYPE_SEQDONE, +}; + +struct CellAdecCb +{ + be_t> cbFunc; + be_t cbArg_addr; +}; + +typedef CellCodecTimeStamp CellAdecTimeStamp; + +// AU Info +struct CellAdecAuInfo +{ + be_t startAddr; + be_t size; + CellCodecTimeStamp pts; + be_t userData; +}; + +// BSI Info +struct CellAdecPcmAttr +{ + be_t bsiInfo_addr; +}; + +struct CellAdecPcmItem +{ + be_t pcmHandle; + be_t status; + be_t startAddr; + be_t size; + CellAdecPcmAttr pcmAttr; + CellAdecAuInfo auInfo; +}; + +struct CellAdecParamLpcm +{ + be_t channelNumber; + be_t sampleRate; + be_t sizeOfWord; + be_t audioPayloadSize; +}; + +// LPCM BSI +struct CellAdecLpcmInfo +{ + be_t channelNumber; + be_t sampleRate; + be_t outputDataSize; +}; + +struct CellAdecResourceEx +{ + be_t totalMemSize; + be_t startAddr; + be_t ppuThreadPriority; + be_t ppuThreadStackSize; + be_t spurs_addr; + u8 priority[8]; + be_t maxContention; +}; + +// CELP Excitation Mode +enum CELP_ExcitationMode +{ + CELL_ADEC_CELP_EXCITATION_MODE_RPE = 1, +}; + +// CELP RPE Configuration +enum CELP_RPEConfig +{ + CELL_ADEC_CELP_RPE_CONFIG_0, + CELL_ADEC_CELP_RPE_CONFIG_1, + CELL_ADEC_CELP_RPE_CONFIG_2, + CELL_ADEC_CELP_RPE_CONFIG_3, +}; + +// CELP Word Size +enum CELP_WordSize +{ + CELL_ADEC_CELP_WORD_SZ_INT16_LE, + CELL_ADEC_CELP_WORD_SZ_FLOAT, +}; + +// CELP Parameters +struct CellAdecParamCelp +{ + be_t excitationMode; + be_t sampleRate; // CELL_ADEC_FS_16kHz + be_t configuration; + be_t wordSize; +}; + +// CELP BSI (same as CellAdecParamCelp ???) +struct CellAdecCelpInfo +{ + be_t excitationMode; + be_t sampleRate; // CELL_ADEC_FS_16kHz + be_t configuration; + be_t wordSize; +}; + +// CELP8 Excitation Mode +enum CELP8_ExcitationMode +{ + CELL_ADEC_CELP8_EXCITATION_MODE_MPE = 0, +}; + +// CELP8 MPE Configuration +enum CELP8_MPEConfig +{ + CELL_ADEC_CELP8_MPE_CONFIG_0 = 0, + CELL_ADEC_CELP8_MPE_CONFIG_2 = 2, + CELL_ADEC_CELP8_MPE_CONFIG_6 = 6, + CELL_ADEC_CELP8_MPE_CONFIG_9 = 9, + CELL_ADEC_CELP8_MPE_CONFIG_12 = 12, + CELL_ADEC_CELP8_MPE_CONFIG_15 = 15, + CELL_ADEC_CELP8_MPE_CONFIG_18 = 18, + CELL_ADEC_CELP8_MPE_CONFIG_21 = 21, + CELL_ADEC_CELP8_MPE_CONFIG_24 = 24, + CELL_ADEC_CELP8_MPE_CONFIG_26 = 26, +}; + +// CELP8 Word Size +enum CELP8_WordSize +{ + CELL_ADEC_CELP8_WORD_SZ_FLOAT, +}; + +// CELP8 Parameters +struct CellAdecParamCelp8 +{ + be_t excitationMode; + be_t sampleRate; // CELL_ADEC_FS_8kHz + be_t configuration; + be_t wordSize; +}; + +// CELP8 BSI +struct CellAdecCelp8Info +{ + be_t excitationMode; + be_t sampleRate; // CELL_ADEC_FS_8kHz + be_t configuration; + be_t wordSize; +}; + +enum MPEG4AAC_ConfigType +{ + ADIFHeader = 0, + ADTSHeader = 1, + RawDataBlockOnly = 2, +}; + +enum MPEG4AAC_SamplingFreq +{ + SF_96000 = 0, + SF_88200 = 1, + SF_64000 = 2, + SF_48000 = 3, + SF_44100 = 4, + SF_32000 = 5, + SF_24000 = 6, + SF_22050 = 7, + SF_16000 = 8, + SF_12000 = 9, + SF_11025 = 10, + SF_8000 = 11, +}; + +// MPEG4 AAC Parameters +struct CellAdecParamM4Aac +{ + be_t configNumber; + + union { + struct { struct + { + be_t adifProgramNumber; // 0 + } adifConfig; }; + + struct { struct + { + be_t samplingFreqIndex; + be_t profile; // LC profile (1) + } rawDataBlockConfig; }; + } configInfo; + + be_t enableDownmix; // enable downmix to 2.0 (if (enableDownmix)) +}; + +// MPEG4 AAC BSI +struct CellAdecM4AacInfo +{ + be_t samplingFreq; // [Hz] + be_t numberOfChannels; + be_t numberOfFrontChannels; + be_t numberOfFrontMonoChannels; + be_t numberOfSideChannels; + be_t numberOfBackChannels; + be_t numberOfLfeChannels; + be_t enableSBR; + be_t SBRUpsamplingFactor; + be_t isBsiValid; + be_t configNumber; + + be_t pad1; // TODO: check alignment + + union { + struct { struct + { + be_t copyrightIdPresent; + char copyrightId[9]; + be_t originalCopy; + be_t home; + be_t bitstreamType; + be_t bitrate; + be_t numberOfProgramConfigElements; + be_t bufferFullness; + } adif; }; + + struct { struct + { + be_t id; + be_t layer; + be_t protectionAbsent; + be_t profile; + be_t samplingFreqIndex; + be_t privateBit; + be_t channelConfiguration; + be_t originalCopy; + be_t home; + be_t copyrightIdBit; + be_t copyrightIdStart; + be_t frameLength; + be_t bufferFullness; + be_t numberOfRawDataBlocks; + be_t crcCheck; + } adts; }; + } bsi; + + be_t pad2; // TODO: check alignment + + struct + { + be_t matrixMixdownPresent; + be_t mixdownIndex; + be_t pseudoSurroundEnable; + } matrixMixdown; + + be_t reserved; +}; + +enum AC3_WordSize : u8 +{ + CELL_ADEC_AC3_WORD_SZ_INT16 = 0, + CELL_ADEC_AC3_WORD_SZ_FLOAT = 1, +}; + +enum AC3_OutputMode : u8 +{ + CELL_ADEC_AC3_OUTPUT_MODE_RESERVED = 0, + CELL_ADEC_AC3_OUTPUT_MODE_1_0 = 1, + CELL_ADEC_AC3_OUTPUT_MODE_2_0 = 2, + CELL_ADEC_AC3_OUTPUT_MODE_3_0 = 3, + CELL_ADEC_AC3_OUTPUT_MODE_2_1 = 4, + CELL_ADEC_AC3_OUTPUT_MODE_3_1 = 5, + CELL_ADEC_AC3_OUTPUT_MODE_2_2 = 6, + CELL_ADEC_AC3_OUTPUT_MODE_3_2 = 7, +}; + +enum AC3_LFE : u8 +{ + CELL_ADEC_AC3_LFE_NOT_PRESENT = 0, + CELL_ADEC_AC3_LFE_PRESENT = 1, +}; + +enum AC3_CompressionMode : u8 +{ + CELL_ADEC_AC3_COMPRESSION_MODE_CUSTOM_ANALOG = 0, + CELL_ADEC_AC3_COMPRESSION_MODE_CUSTOM_DIGITAL = 1, + CELL_ADEC_AC3_COMPRESSION_MODE_LINE_OUT = 2, + CELL_ADEC_AC3_COMPRESSION_MODE_RF_REMOD = 3, +}; + +enum AC3_StereoMode : u8 +{ + CELL_ADEC_AC3_STEREO_MODE_AUTO_DETECT = 0, + CELL_ADEC_AC3_STEREO_MODE_DOLBY_SURROUND_COMPATIBLE = 1, + CELL_ADEC_AC3_STEREO_MODE_STEREO = 2, +}; + +enum AC3_DualmonoMode : u8 +{ + CELL_ADEC_AC3_DUALMONO_MODE_STEREO = 0, + CELL_ADEC_AC3_DUALMONO_MODE_LEFT_MONO = 1, + CELL_ADEC_AC3_DUALMONO_MODE_RIGHT_MONO = 2, + CELL_ADEC_AC3_DUALMONO_MODE_MIXED_MONO = 3, +}; + +enum AC3_KaraokeCapableMode : u8 +{ + CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_NO_VOCAL = 0, + CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_LEFT_VOCAL = 1, + CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_RIGHT_VOCAL = 2, + CELL_ADEC_AC3_KARAOKE_CAPABLE_MODE_BOTH_VOCAL = 3, +}; + +enum AC3_InputChannel : u8 +{ + CELL_ADEC_AC3_INPUT_CHANNEL_L = 0, + CELL_ADEC_AC3_INPUT_CHANNEL_C = 1, + CELL_ADEC_AC3_INPUT_CHANNEL_R = 2, + CELL_ADEC_AC3_INPUT_CHANNEL_l = 3, + CELL_ADEC_AC3_INPUT_CHANNEL_r = 4, + CELL_ADEC_AC3_INPUT_CHANNEL_s = 5, +}; + +struct CellAdecParamAc3 +{ + AC3_WordSize wordSize; + AC3_OutputMode outputMode; + AC3_LFE outLfeOn; + + be_t drcCutScaleFactor; + be_t drcBoostScaleFactor; + + AC3_CompressionMode compressionMode; + AC3_InputChannel numberOfChannels; + AC3_StereoMode stereoMode; + AC3_DualmonoMode dualmonoMode; + AC3_KaraokeCapableMode karaokeCapableMode; + + be_t pcmScaleFactor; + + be_t channelPointer0; + be_t channelPointer1; + be_t channelPointer2; + be_t channelPointer3; + be_t channelPointer4; + be_t channelPointer5; +}; + +struct CellAdecBsiAc3 +{ + be_t codecType; + be_t versionInfo; + be_t totalCallCarryRun; + be_t totalCallNum; + be_t bitrateValue; + be_t pcmSize; + be_t esSizeBit; + be_t errorCode; + u8 libInfoFlag; + u8 validity; + u8 channelValue; + u8 fsIndex; + u8 outputQuantization; + u8 outputChannel; + u8 monoFlag; + be_t bsi[2]; + be_t frmSizeCod; + u8 acmod; + u8 lfeOn; + u8 karaokeMode; + u8 cmixlev; + u8 surmixlev; + u8 dsurmod; + u8 copyright; + u8 original; + u8 bsmod; + u8 bsid; + u8 xbsi1e; + u8 dmixmod; + u8 xbsi2e; + u8 dsurexmod; + u8 dheadphonmod; + u8 adconvtyp; + u8 crcErrorFlag; + u8 execDmixType; +}; + +enum ATRAC3_WordSize : s32 +{ + CELL_ADEC_ATRAC3_WORD_SZ_16BIT = 0x02, + CELL_ADEC_ATRAC3_WORD_SZ_24BIT = 0x03, + CELL_ADEC_ATRAC3_WORD_SZ_32BIT = 0x04, + CELL_ADEC_ATRAC3_WORD_SZ_FLOAT = 0x84, +}; + +enum ATRAC3_JointType : s32 +{ + ATRAC3_DUAL_STEREO = 0, + ATRAC3_JOINT_STEREO = 1, +}; + +struct CellAdecParamAtrac3 +{ + be_t nch; // channel count + be_t isJoint; + be_t nbytes; // byte count of single AU (???) + be_t bw_pcm; // bit length of output PCM sample +}; + +struct CellAdecAtrac3Info +{ + be_t nch; + be_t isJoint; + be_t nbytes; +}; + +enum ATRACX_WordSize : s32 +{ + CELL_ADEC_ATRACX_WORD_SZ_16BIT = 0x02, + CELL_ADEC_ATRACX_WORD_SZ_24BIT = 0x03, + CELL_ADEC_ATRACX_WORD_SZ_32BIT = 0x04, + CELL_ADEC_ATRACX_WORD_SZ_FLOAT = 0x84, +}; + +enum ATRACX_ATSHeaderInclude : u8 +{ + CELL_ADEC_ATRACX_ATS_HDR_NOTINC = 0, + CELL_ADEC_ATRACX_ATS_HDR_INC = 1, +}; + +enum ATRACX_DownmixFlag : u8 +{ + ATRACX_DOWNMIX_OFF = 0, + ATRACX_DOWNMIX_ON = 1, +}; + +struct CellAdecParamAtracX +{ + be_t sampling_freq; + be_t ch_config_idx; + be_t nch_out; + be_t nbytes; + u8 extra_config_data[4]; // downmix coefficients + be_t bw_pcm; + ATRACX_DownmixFlag downmix_flag; + ATRACX_ATSHeaderInclude au_includes_ats_hdr_flg; +}; + +struct CellAdecAtracXInfo +{ + be_t samplingFreq; // [Hz] + be_t channelConfigIndex; + be_t nbytes; +}; + +enum MP3_WordSize : s32 +{ + CELL_ADEC_MP3_WORD_SZ_16BIT = 3, + CELL_ADEC_MP3_WORD_SZ_FLOAT = 4, +}; + +enum MP3_ChannelMode : u8 +{ + MP3_STEREO = 0, + MP3_JOINT_STEREO = 1, + MP3_DUAL = 2, + MP3_MONO = 3, +}; + +enum MP3_CRCMode : u8 +{ + MP3_CRC = 0, + MP3_NO_CRC = 1, +}; + +struct CellAdecParamMP3 +{ + be_t bw_pcm; +}; + +struct CellAdecMP3Info +{ + be_t ui_header; + be_t ui_main_data_begin; + be_t ui_main_data_remain_size; + be_t ui_main_data_now_size; + MP3_CRCMode uc_crc; + MP3_ChannelMode uc_mode; + u8 uc_mode_extension; + u8 uc_copyright; + u8 uc_original; + u8 uc_emphasis; + u8 uc_crc_error_flag; + be_t i_error_code; +}; + +enum M2BC_SampleFrequency +{ + CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_44 = 0, + CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_48 = 1, + CELL_ADEC_BSI_M2BC_SAMPLE_FREQUENCY_32 = 2, +}; + +enum M2BC_ErrorProtection +{ + CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_NONE = 0, + CELL_ADEC_BSI_M2BC_ERROR_PROTECTION_EXIST = 1, +}; + +enum M2BC_BitrateIndex +{ + CELL_ADEC_BSI_M2BC_BITRATE_32 = 1, + CELL_ADEC_BSI_M2BC_BITRATE_48 = 2, + CELL_ADEC_BSI_M2BC_BITRATE_56 = 3, + CELL_ADEC_BSI_M2BC_BITRATE_64 = 4, + CELL_ADEC_BSI_M2BC_BITRATE_80 = 5, + CELL_ADEC_BSI_M2BC_BITRATE_96 = 6, + CELL_ADEC_BSI_M2BC_BITRATE_112 = 7, + CELL_ADEC_BSI_M2BC_BITRATE_128 = 8, + CELL_ADEC_BSI_M2BC_BITRATE_160 = 9, + CELL_ADEC_BSI_M2BC_BITRATE_192 = 10, + CELL_ADEC_BSI_M2BC_BITRATE_224 = 11, + CELL_ADEC_BSI_M2BC_BITRATE_256 = 12, + CELL_ADEC_BSI_M2BC_BITRATE_320 = 13, + CELL_ADEC_BSI_M2BC_BITRATE_384 = 14, +}; + +enum M2BC_StereoMode +{ + CELL_ADEC_BSI_M2BC_STEREO_MODE_STERO = 0, + CELL_ADEC_BSI_M2BC_STEREO_MODE_JOINTSTERO = 1, + CELL_ADEC_BSI_M2BC_STEREO_MODE_DUAL = 2, + CELL_ADEC_BSI_M2BC_STEREO_MODE_MONO = 3, +}; + +enum M2BC_StereoModeEx +{ + CELL_ADEC_BSI_M2BC_STEREO_EXMODE_0 = 0, + CELL_ADEC_BSI_M2BC_STEREO_EXMODE_1 = 1, + CELL_ADEC_BSI_M2BC_STEREO_EXMODE_2 = 2, + CELL_ADEC_BSI_M2BC_STEREO_EXMODE_3 = 3, +}; + +enum M2BC_Emphasis +{ + CELL_ADEC_BSI_M2BC_EMPHASIS_NONE = 0, + CELL_ADEC_BSI_M2BC_EMPHASIS_50_15 = 1, + CELL_ADEC_BSI_M2BC_EMPHASIS_CCITT = 3, +}; + +enum M2BC_CopyrightBit +{ + CELL_ADEC_BSI_M2BC_COPYRIGHT_NONE = 0, + CELL_ADEC_BSI_M2BC_COPYRIGHT_ON = 1, +}; + +enum M2BC_OriginalBit +{ + CELL_ADEC_BSI_M2BC_ORIGINAL_COPY = 0, + CELL_ADEC_BSI_M2BC_ORIGINAL_ORIGINAL = 1, +}; + +enum M2BC_SurroundMode +{ + CELL_ADEC_BSI_M2BC_SURROUND_NONE = 0, + CELL_ADEC_BSI_M2BC_SURROUND_MONO = 1, + CELL_ADEC_BSI_M2BC_SURROUND_STEREO = 2, + CELL_ADEC_BSI_M2BC_SURROUND_SECOND = 3, +}; + +enum M2BC_CenterMode +{ + CELL_ADEC_BSI_M2BC_CENTER_NONE = 0, + CELL_ADEC_BSI_M2BC_CENTER_EXIST = 1, + CELL_ADEC_BSI_M2BC_CENTER_PHANTOM = 3, +}; + +enum M2BC_LFE +{ + CELL_ADEC_BSI_M2BC_LFE_NONE = 0, + CELL_ADEC_BSI_M2BC_LFE_EXIST = 1, +}; + +enum M2BC_AudioMixMode +{ + CELL_ADEC_BSI_M2BC_AUDIOMIX_LARGE = 0, + CELL_ADEC_BSI_M2BC_AUDIOMIX_SMALLE = 1, +}; + +enum M2BC_MCExtension +{ + CELL_ADEC_BSI_M2BC_MCEXTENSION_2CH = 0, + CELL_ADEC_BSI_M2BC_MCEXTENSION_5CH = 1, + CELL_ADEC_BSI_M2BC_MCEXTENSION_7CH = 2, +}; + +enum M2BC_ChannelConfig +{ + CELL_ADEC_BSI_M2BC_CH_CONFIG_MONO = 0, + CELL_ADEC_BSI_M2BC_CH_CONFIG_DUAL = 1, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R = 2, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_S = 3, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C = 4, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_LS_RS = 5, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_S = 6, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_LS_RS = 7, + CELL_ADEC_BSI_M2BC_CH_CONFIG_LL_RR_CC_LS_RS_LC_RC = 8, + CELL_ADEC_BSI_M2BC_CH_CONFIG_MONO_SECONDSTEREO = 9, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_SECONDSTEREO = 10, + CELL_ADEC_BSI_M2BC_CH_CONFIG_L_R_C_SECONDSTEREO = 11, +}; + +struct CellAdecParamMpmc +{ + be_t channelNumber; + be_t downmix; + be_t lfeUpSample; +}; + +struct CellAdecMpmcInfo +{ + be_t channelNumber; + be_t sampleFreq; + be_t errorPprotection; + be_t bitrateIndex; + be_t stereoMode; + be_t stereoModeEextention; + be_t emphasis; + be_t copyright; + be_t original; + be_t surroundMode; + be_t centerMode; + be_t audioMmix; + be_t outputFramSize; + be_t multiCodecMode; + be_t lfePresent; + be_t channelCoufiguration; }; \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp index d4e3d46d05..0154af54c1 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp @@ -6,33 +6,37 @@ void cellVpost_init(); Module cellVpost(0x0008, cellVpost_init); -int cellVpostQueryAttr() +int cellVpostQueryAttr(const mem_ptr_t cfgParam, mem_ptr_t attr) { - UNIMPLEMENTED_FUNC(cellVpost); + cellVpost.Error("cellVpostQueryAttr(cfgParam_addr=0x%x, attr_addr=0x%x)", cfgParam.GetAddr(), attr.GetAddr()); return CELL_OK; } -int cellVpostOpen() +int cellVpostOpen(const mem_ptr_t cfgParam, const mem_ptr_t resource, mem32_t handle) { - UNIMPLEMENTED_FUNC(cellVpost); + cellVpost.Error("cellVpostOpen(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)", + cfgParam.GetAddr(), resource.GetAddr(), handle.GetAddr()); return CELL_OK; } -int cellVpostOpenEx() +int cellVpostOpenEx(const mem_ptr_t cfgParam, const mem_ptr_t resource, mem32_t handle) { - UNIMPLEMENTED_FUNC(cellVpost); + cellVpost.Error("cellVpostOpenEx(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)", + cfgParam.GetAddr(), resource.GetAddr(), handle.GetAddr()); return CELL_OK; } -int cellVpostClose() +int cellVpostClose(u32 handle) { - UNIMPLEMENTED_FUNC(cellVpost); + cellVpost.Error("cellVpostClose(handle=0x%x)", handle); return CELL_OK; } -int cellVpostExec() +int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t ctrlParam, + u32 outPicBuff_addr, mem_ptr_t picInfo) { - UNIMPLEMENTED_FUNC(cellVpost); + cellVpost.Error("cellVpostExec(handle=0x%x, inPicBuff_addr=0x%x, ctrlParam_addr=0x%x, outPicBuff_addr=0x%x, picInfo_addr=0x%x)", + handle, inPicBuff_addr, ctrlParam.GetAddr(), outPicBuff_addr, picInfo.GetAddr()); return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.h b/rpcs3/Emu/SysCalls/Modules/cellVpost.h index b0eda0951b..3e54a55050 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellVpost.h +++ b/rpcs3/Emu/SysCalls/Modules/cellVpost.h @@ -135,4 +135,183 @@ enum CELL_VPOST_CSC_ERROR_E_FATAL_SNDCMD_FAIL = 0x806184c0, CELL_VPOST_CSC_ERROR_E_FATAL_RCVRES_FAIL = 0x806184c1, CELL_VPOST_CSC_ERROR_E_FATAL_SPUCORE_FAIL = 0x806184c2, -}; \ No newline at end of file +}; + +enum CellVpostPictureDepth +{ + CELL_VPOST_PIC_DEPTH_8, +}; + +enum CellVpostPictureFormatIn +{ + CELL_VPOST_PIC_FMT_IN_YUV420_PLANAR, +}; + +enum CellVpostPictureFormatOut +{ + CELL_VPOST_PIC_FMT_OUT_RGBA_ILV, + CELL_VPOST_PIC_FMT_OUT_YUV420_PLANAR, +}; + +enum CellVpostPictureStructure +{ + CELL_VPOST_PIC_STRUCT_PFRM, + CELL_VPOST_PIC_STRUCT_IFRM, + CELL_VPOST_PIC_STRUCT_ITOP, + CELL_VPOST_PIC_STRUCT_IBTM, +}; + +enum CellVpostExecType +{ + CELL_VPOST_EXEC_TYPE_PFRM_PFRM, + CELL_VPOST_EXEC_TYPE_PTOP_ITOP, + CELL_VPOST_EXEC_TYPE_PBTM_IBTM, + CELL_VPOST_EXEC_TYPE_ITOP_PFRM, + CELL_VPOST_EXEC_TYPE_IBTM_PFRM, + CELL_VPOST_EXEC_TYPE_IFRM_IFRM, + CELL_VPOST_EXEC_TYPE_ITOP_ITOP, + CELL_VPOST_EXEC_TYPE_IBTM_IBTM, +}; + +enum CellVpostChromaPositionType +{ + CELL_VPOST_CHROMA_POS_TYPE_A, + CELL_VPOST_CHROMA_POS_TYPE_B, +}; + +enum CellVpostScanType +{ + CELL_VPOST_SCAN_TYPE_P, + CELL_VPOST_SCAN_TYPE_I, +}; + +enum CellVpostQuantRange +{ + CELL_VPOST_QUANT_RANGE_FULL, + CELL_VPOST_QUANT_RANGE_BROADCAST, +}; + +enum CellVpostColorMatrix +{ + CELL_VPOST_COLOR_MATRIX_BT601, + CELL_VPOST_COLOR_MATRIX_BT709, +}; + +enum CellVpostScalerType +{ + CELL_VPOST_SCALER_TYPE_BILINEAR, + CELL_VPOST_SCALER_TYPE_LINEAR_SHARP, + CELL_VPOST_SCALER_TYPE_2X4TAP, + CELL_VPOST_SCALER_TYPE_8X4TAP, +}; + +enum CellVpostIpcType +{ + CELL_VPOST_IPC_TYPE_DOUBLING, + CELL_VPOST_IPC_TYPE_LINEAR, + CELL_VPOST_IPC_TYPE_MAVG, +}; + +struct CellVpostCfgParam +{ + be_t inMaxWidth; + be_t inMaxHeight; + be_t inDepth; + be_t inPicFmt; + + be_t outMaxWidth; + be_t outMaxHeight; + be_t outDepth; + be_t outPicFmt; + + be_t reserved1; + be_t reserved2; +}; + +struct CellVpostAttr +{ + be_t memSize; + u8 delay; + be_t vpostVerUpper; + be_t vpostVerLower; +}; + +struct CellVpostResource +{ + be_t memAddr; + be_t memSize; + be_t ppuThreadPriority; + be_t ppuThreadStackSize; + be_t spuThreadPriority; + be_t numOfSpus; +}; + +struct CellVpostResourceEx +{ + be_t memAddr; + be_t memSize; + be_t spurs_addr; + u8 priority[8]; + be_t maxContention; +}; + +struct CellVpostWindow +{ + be_t x; + be_t y; + be_t width; + be_t height; +}; + +struct CellVpostCtrlParam +{ + be_t execType; + + be_t scalerType; + be_t ipcType; + + be_t inWidth; + be_t inHeight; + be_t inChromaPosType; + be_t inQuantRange; + be_t inColorMatrix; + CellVpostWindow inWindow; + + be_t outWidth; + be_t outHeight; + CellVpostWindow outWindow; + u8 outAlpha; + + be_t userData; + + be_t reserved1; + be_t reserved2; +}; + +struct CellVpostPictureInfo +{ + be_t inWidth; + be_t inHeight; + be_t inDepth; + be_t inScanType; + be_t inPicFmt; + be_t inChromaPosType; + be_t inPicStruct; + be_t inQuantRange; + be_t inColorMatrix; + + be_t outWidth; + be_t outHeight; + be_t outDepth; + be_t outScanType; + be_t outPicFmt; + be_t outChromaPosType; + be_t outPicStruct; + be_t outQuantRange; + be_t outColorMatrix; + + be_t userData; + + be_t reserved1; + be_t reserved2; +};