From 784fc571b3d5d7b4a59e52b27c2abba866e6f225 Mon Sep 17 00:00:00 2001 From: O1L Date: Fri, 27 Sep 2013 14:05:29 +0400 Subject: [PATCH 1/4] Created new dummy module for cellAudio. --- rpcs3/Emu/SysCalls/Modules/cellAudio.cpp | 950 +++++++++++++++++++++++ rpcs3/rpcs3.vcxproj | 3 +- rpcs3/rpcs3.vcxproj.filters | 5 +- 3 files changed, 956 insertions(+), 2 deletions(-) create mode 100644 rpcs3/Emu/SysCalls/Modules/cellAudio.cpp diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp new file mode 100644 index 0000000000..0b740b7b11 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp @@ -0,0 +1,950 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + + +// Initialization and Termination Functions; + +void cellAudio_init (); +Module cellAudio (0x0011, cellAudio_init); + +enum +{ +//libaudio ERROR_CODES +CELL_AUDIO_ERROR_ALREADY_INIT = 0x80310701, +CELL_AUDIO_ERROR_AUDIOSYSTEM = 0x80310702, +CELL_AUDIO_ERROR_NOT_INIT = 0x80310703, +CELL_AUDIO_ERROR_PARAM = 0x80310704, +CELL_AUDIO_ERROR_PORT_FULL = 0x80310705, +CELL_AUDIO_ERROR_PORT_ALREADY_RUN = 0x80310706, +CELL_AUDIO_ERROR_PORT_NOT_OPEN = 0x80310707, +CELL_AUDIO_ERROR_PORT_NOT_RUN = 0x80310708, +CELL_AUDIO_ERROR_TRANS_EVENT = 0x80310709, +CELL_AUDIO_ERROR_PORT_OPEN = 0x8031070a, +CELL_AUDIO_ERROR_SHAREDMEMORY = 0x8031070b, +CELL_AUDIO_ERROR_MUTEX = 0x8031070c, +CELL_AUDIO_ERROR_EVENT_QUEUE = 0x8031070d, +CELL_AUDIO_ERROR_AUDIOSYSTEM_NOT_FOUND = 0x8031070e, +CELL_AUDIO_ERROR_TAG_NOT_FOUND = 0x8031070f, + +//libmixer ERROR_CODES +CELL_LIBMIXER_ERROR_NOT_INITIALIZED = 0x80310002, +CELL_LIBMIXER_ERROR_INVALID_PARAMATER = 0x80310003, +CELL_LIBMIXER_ERROR_NO_MEMORY = 0x80310005, +CELL_LIBMIXER_ERROR_ALREADY_EXIST = 0x80310006, +CELL_LIBMIXER_ERROR_FULL = 0x80310007, +CELL_LIBMIXER_ERROR_NOT_EXIST = 0x80310008, +CELL_LIBMIXER_ERROR_TYPE_MISMATCH = 0x80310009, +CELL_LIBMIXER_ERROR_NOT_FOUND = 0x8031000a, + +//libsnd3 ERROR_CODES +CELL_SND3_ERROR_PARAM = 0x80310301, +CELL_SND3_ERROR_CREATE_MUTEX = 0x80310302, +CELL_SND3_ERROR_SYNTH = 0x80310303, +CELL_SND3_ERROR_ALREADY = 0x80310304, +CELL_SND3_ERROR_NOTINIT = 0x80310305, +CELL_SND3_ERROR_SMFFULL = 0x80310306, +CELL_SND3_ERROR_HD3ID = 0x80310307, +CELL_SND3_ERROR_SMF = 0x80310308, +CELL_SND3_ERROR_SMFCTX = 0x80310309, +CELL_SND3_ERROR_FORMAT = 0x8031030a, +CELL_SND3_ERROR_SMFID = 0x8031030b, +CELL_SND3_ERROR_SOUNDDATAFULL = 0x8031030c, +CELL_SND3_ERROR_VOICENUM = 0x8031030d, +CELL_SND3_ERROR_RESERVEDVOICE = 0x8031030e, +CELL_SND3_ERROR_REQUESTQUEFULL = 0x8031030f, +CELL_SND3_ERROR_OUTPUTMODE = 0x80310310, + +//libsynt2 EROR_CODES +CELL_SOUND_SYNTH2_ERROR_FATAL = 0x80310201, +CELL_SOUND_SYNTH2_ERROR_INVALID_PARAMETER = 0x80310202, +CELL_SOUND_SYNTH2_ERROR_ALREADY_INITIALIZED = 0x80310203, +}; + +#define __CSTD +typedef __CSTD uint32_t sys_timer_t; +typedef __CSTD int64_t system_time_t; +typedef __CSTD uint64_t usecond_t; +typedef __CSTD uint32_t second_t; +typedef __CSTD uint32_t sys_event_queue_t; +typedef __CSTD uint32_t sys_event_port_t; +typedef __CSTD uint32_t sys_event_type_t; +typedef __CSTD uint64_t sys_ipc_key_t; +typedef __CSTD uintptr_t lparaddr_t; +typedef __CSTD uintptr_t sys_addr_t; +typedef __CSTD uint32_t sys_memory_t; +typedef __CSTD uint32_t sys_memory_container_t; +#undef __CSTD + +//libaudio datatyps +struct CellAudioPortParam +{ +uint64_t nChannel; +uint64_t nBlock; +uint64_t attr; +float level; +}; + +struct CellAudioPortConfig +{ +sys_addr_t readIndexAddr; +uint32_t status; +uint64_t nChannel; +uint64_t nBlock; +uint32_t portSize; +sys_addr_t portAddr; +}; + +//libmixer datatypes + +typedef void * CellAANHandle; + + +struct CellSSPlayerConfig +{ +uint32_t channels; +uint32_t outputMode; +}; + +struct CellSSPlayerWaveParam +{ +void *addr; +int format; +uint32_t samples; +uint32_t loopStartOffset; +uint32_t startOffset; +}; + +struct CellSSPlayerCommonParam +{ +uint32_t loopMode; +uint32_t attackMode; +}; + +struct CellSurMixerPosition +{ +float x; +float y; +float z; +}; + +struct CellSSPlayerRuntimeInfo +{ +float level; +float speed; +CellSurMixerPosition position; +}; + +struct CellSurMixerConfig +{ +int32_t priority; +uint32_t chStrips1; +uint32_t chStrips2; +uint32_t chStrips6; +uint32_t chStrips8; +}; + +struct CellSurMixerChStripParam +{ +uint32_t param; +void *attribute; +int dBSwitch; +float floatVal; +int intVal; +}; + + +//libsnd3 datatypes + +struct CellSnd3DataCtx +{ +int8_t system; //[CELL_SND3_DATA_CTX_SIZE], unknown identifier +}; + +struct CellSnd3SmfCtx +{ +int8_t system; //[CELL_SND3_SMF_CTX_SIZE], unknown identifier +}; + +struct CellSnd3KeyOnParam +{ +uint8_t vel; +uint8_t pan; +uint8_t panEx; +int32_t addPitch; +}; + +struct CellSnd3VoiceBitCtx +{ +uint32_t core; //[CELL_SND3_MAX_CORE], unknown identifier +}; + +struct CellSnd3RequestQueueCtx +{ +void *frontQueue; +uint32_t frontQueueSize; +void *rearQueue; +uint32_t rearQueueSize; +}; + +//libsynt2 datatypes +struct CellSoundSynth2EffectAttr +{ +uint16_t core; +uint16_t mode; +int16_t depth_L; +int16_t depth_R; +uint16_t delay; +uint16_t feedback; +}; + + + //*libaudio functions*// + +int cellAudioInit (void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellAudioQuit(void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +// Audio Ports Setting/Operation Functions +int cellAudioPortOpen () //CellAudioPortParam *audioParam, uint32_t *portNum +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioPortStart (uint32_t portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioPortClose (uint32_t portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioPortStop (uint32_t portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioGetPortConfig () //uint32_t portNum, CellAudioPortConfig *portConfig +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioGetPortBlockTag () //uint32_t portNum, uint64_t blockNo, uint64_t *tag +{ + UNIMPLEMENTED_FUNC (cellAudio); + return CELL_OK; +} + +int cellAudioGetPortTimestamp () //uint32_t portNum, uint64_t tag, usecond_t *stamp +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioSetPortLevel (uint32_t portNum, float level) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + + +// Utility Functions +int cellAudioCreateNotifyEventQueue () //sys_event_queue_t *id, sys_ipc_key_t *key +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioCreateNotifyEventQueueEx (sys_event_queue_t *id, sys_ipc_key_t *key, uint32_t iFlags) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioSetNotifyEventQueue (sys_ipc_key_t key) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioSetNotifyEventQueueEx (sys_ipc_key_t key, uint32_t iFlags) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioRemoveNotifyEventQueue (sys_ipc_key_t key) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioRemoveNotifyEventQueueEx (sys_ipc_key_t key, uint32_t iFlags) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioAddData () //uint32_t portNum, float *src, unsigned int samples, float volume +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioAdd2chData () //uint32_t portNum, float *src, unsigned int samples, float volume +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioMiscSetAccessoryVolume (uint32_t devNum, float volume) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioSendAck (uint64_t data3) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioSetPersonalDevice (int iPersonalStream, int iDevice) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioUnsetPersonalDevice (int iPersonalStream) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int cellAudioAdd6chData (uint32_t portNum, float *src, float volume) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +//Callback Functions +typedef int (*CellSurMixerNotifyCallbackFunction)(void *arg, uint32_t counter, uint32_t samples); //Currently unused. + + + //*libmixer Functions, NON active in this moment*// + + +int cellAANConnect (CellAANHandle receive, uint32_t receivePortNo, CellAANHandle source, uint32_t sourcePortNo) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellAANDisconnect (CellAANHandle receive, uint32_t receivePortNo, CellAANHandle source, uint32_t sourcePortNo) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellAANAddData (CellAANHandle handle, uint32_t port, uint32_t offset, float *addr, uint32_t samples) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerCreate (CellAANHandle *handle, CellSSPlayerConfig *config) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerRemove (CellAANHandle handle) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerSetWave (CellAANHandle handle, CellSSPlayerWaveParam *waveInfo, CellSSPlayerCommonParam *commonInfo) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerPlay (CellAANHandle handle, CellSSPlayerRuntimeInfo *info) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerStop (CellAANHandle handle, uint32_t mode) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSSPlayerSetParam (CellAANHandle handle, CellSSPlayerRuntimeInfo *info) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int32_t cellSSPlayerGetState (CellAANHandle handle) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerCreate (const CellSurMixerConfig *config) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerGetAANHandle (CellAANHandle *handle) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerChStripGetAANPortNo (uint32_t *port, uint32_t type, uint32_t index) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerSetNotifyCallback (CellSurMixerNotifyCallbackFunction callback, void *arg) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerRemoveNotifyCallback (CellSurMixerNotifyCallbackFunction callback) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerStart(void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerSurBusAddData (uint32_t busNo, uint32_t offset, float *addr, uint32_t samples) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerSetParameter (uint32_t param, float value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerChStripSetParameter (uint32_t type, uint32_t index, CellSurMixerChStripParam *param) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerPause() //uint32_t switch +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerGetCurrentBlockTag (uint64_t *tag) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int cellSurMixerGetTimestamp (uint64_t tag, usecond_t *stamp) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +void cellSurMixerBeep (void *arg); + +float cellSurMixerUtilGetLevelFromDB () //float dB +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO; +} + +float cellSurMixerUtilGetLevelFromDBIndex () //int index +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO; +} + +float cellSurMixerUtilNoteToRatio () //unsigned char refNote, unsigned char note +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int cellSurMixerFinalize(void); //Currently unused. Returns 0 (in the current release). + + + //*libsnd3 Functions, NON active in this moment*// + +int32_t cellSnd3Init (uint32_t maxVoice, uint32_t samples, CellSnd3RequestQueueCtx *queue) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3Exit (void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SetOutputMode (uint32_t mode) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3Synthesis (float *pOutL, float *pOutR) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SynthesisEx (float *pOutL, float *pOutR, float *pOutRL, float *pOutRR) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetReserveMode (uint32_t voiceNum, uint32_t reserveMode) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3BindSoundData (CellSnd3DataCtx *snd3Ctx, void *hd3, uint32_t synthMemOffset) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3UnbindSoundData (uint32_t hd3ID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3NoteOnByTone () //uint32_t hd3ID, uint32_t toneIndex, uint32_t note, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3KeyOnByTone () //uint32_t hd3ID, uint32_t toneIndex, uint32_t pitch,uint32_t keyOnID,CellSnd3KeyOnParam *keyOnParam +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3VoiceNoteOnByTone () //uint32_t hd3ID, uint32_t voiceNum, uint32_t toneIndex, uint32_t note, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3VoiceKeyOnByTone () //uint32_t hd3ID, uint32_t voiceNum, uint32_t toneIndex, uint32_t pitch, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3VoiceSetSustainHold (uint32_t voiceNum, uint32_t sustainHold) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceKeyOff (uint32_t voiceNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetPitch(uint32_t voiceNum, int32_t addPitch) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetVelocity (uint32_t voiceNum, uint32_t velocity) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetPanpot (uint32_t voiceNum, uint32_t panpot) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetPanpotEx (uint32_t voiceNum, uint32_t panpotEx) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceSetPitchBend (uint32_t voiceNum, uint32_t bendValue) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceAllKeyOff (void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceGetEnvelope (uint32_t voiceNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3VoiceGetStatus () //uint32_t voiceNum +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +uint32_t cellSnd3KeyOffByID (uint32_t keyOnID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3GetVoice (uint32_t midiChannel, uint32_t keyOnID, CellSnd3VoiceBitCtx *voiceBit) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3GetVoiceByID (uint32_t keyOnID, CellSnd3VoiceBitCtx *voiceBit) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3NoteOn (uint32_t hd3ID, uint32_t midiChannel, uint32_t midiProgram, uint32_t midiNote, uint32_t sustain,CellSnd3KeyOnParam *keyOnParam, uint32_t keyOnID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3NoteOff (uint32_t midiChannel, uint32_t midiNote, uint32_t keyOnID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SetSustainHold (uint32_t midiChannel, uint32_t sustainHold, uint32_t ID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SetEffectType (uint16_t effectType, int16_t returnVol, uint16_t delay, uint16_t feedback) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +uint16_t cellSnd3Note2Pitch () //uint16_t center_note, uint16_t center_fine, uint16_t note, int16_t fine +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +uint16_t cellSnd3Pitch2Note () //uint16_t center_note, uint16_t center_fine, uint16_t pitch +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFBind () //CellSnd3SmfCtx *smfCtx, void *smf, uint32_t hd3ID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFUnbind () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFPlay (uint32_t smfID, uint32_t playVelocity, uint32_t playPan, uint32_t playCount) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFPlayEx (uint32_t smfID, uint32_t playVelocity, uint32_t playPan, uint32_t playPanEx, uint32_t playCount) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFPause (uint32_t smfID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFResume (uint32_t smfID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFStop (uint32_t smfID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFAddTempo (uint32_t smfID, int32_t addTempo) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFGetTempo () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFSetPlayVelocity (uint32_t smfID, uint32_t playVelocity) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFGetPlayVelocity () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFSetPlayPanpot (uint32_t smfID, uint32_t playPanpot) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFSetPlayPanpotEx (uint32_t smfID, uint32_t playPanpotEx) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFGetPlayPanpot () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFGetPlayPanpotEx () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFGetPlayStatus () //uint32_t smfID +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSnd3SMFSetPlayChannel (uint32_t smfID, uint32_t playChannelBit) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFGetPlayChannel (uint32_t smfID, uint32_t *playChannelBit) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + +int32_t cellSnd3SMFGetKeyOnID (uint32_t smfID, uint32_t midiChannel, uint32_t *keyOnID) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; +} + + //*libsynth2 Functions, NON active in this moment*// + +int32_t cellSoundSynth2Config (int16_t param, int32_t value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int32_t cellSoundSynth2Init( int16_t flag) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int32_t cellSoundSynth2Exit(void) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +void cellSoundSynth2SetParam (uint16_t register, uint16_t value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + //TODO +} + +uint16_t cellSoundSynth2GetParam () //uint16_t register +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +void cellSoundSynth2SetSwitch (uint16_t register, uint32_t value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + //TODO +} + +uint32_t cellSoundSynth2GetSwitch () //uint16_t register +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +uint32_t cellSoundSynth2SetAddr (uint16_t register, uint32_t value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +uint32_t cellSoundSynth2GetAddr () //uint16_t register +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +int32_t cellSoundSynth2SetEffectAttr (int16_t bus, CellSoundSynth2EffectAttr *attr) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int32_t cellSoundSynth2SetEffectMode (int16_t bus, CellSoundSynth2EffectAttr *attr) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +void cellSoundSynth2SetCoreAttr (uint16_t entry, uint16_t value) +{ + UNIMPLEMENTED_FUNC(cellAudio); + //TODO +} + +int32_t cellSoundSynth2Generate (uint16_t samples, float *left_buffer, float *right_buffer, float *left_rear, float *right_rear) +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +int32_t cellSoundSynth2VoiceTrans () //int16_t channel, uint16_t mode, uint8_t *m_addr, uint32_t s_addr, uint32_t size +{ + UNIMPLEMENTED_FUNC(cellAudio); + return 0; +} + +uint16_t cellSoundSynth2Note2Pitch () //uint16_t center_note, uint16_t center_fine, uint16_t note, int16_t fine +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + +uint16_t cellSoundSynth2Pitch2Note () //uint16_t center_note, uint16_t center_fine, uint16_t pitch +{ + UNIMPLEMENTED_FUNC(cellAudio); + return CELL_OK; //it's NOT real value + //TODO +} + + + +void cellAudio_init () +{ +cellAudio.AddFunc (0x0b168f92, cellAudioInit); +cellAudio.AddFunc (0x4129fe2d, cellAudioPortClose); +cellAudio.AddFunc (0x5b1e2c73, cellAudioPortStop); +cellAudio.AddFunc (0x74a66af0, cellAudioGetPortConfig); +cellAudio.AddFunc (0x89be28f2, cellAudioPortStart); +cellAudio.AddFunc (0xca5ac370, cellAudioQuit); +cellAudio.AddFunc (0xcd7bc431, cellAudioPortOpen); +cellAudio.AddFunc (0x56dfe179, cellAudioSetPortLevel); +cellAudio.AddFunc (0x04af134e, cellAudioCreateNotifyEventQueue); +cellAudio.AddFunc (0x31211f6b, cellAudioMiscSetAccessoryVolume); +cellAudio.AddFunc (0x377e0cd9, cellAudioSetNotifyEventQueue); +cellAudio.AddFunc (0x4109d08c, cellAudioGetPortTimestamp); +cellAudio.AddFunc (0x9e4b1db8, cellAudioAdd2chData); +cellAudio.AddFunc (0xdab029aa, cellAudioAddData); +cellAudio.AddFunc (0xe4046afe, cellAudioGetPortBlockTag); +cellAudio.AddFunc (0xff3626fd, cellAudioRemoveNotifyEventQueue); +//TODO: Find addresses for libmixer, libsnd3 and libsynth2 functions +} diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index 893c671409..3b04e70d4f 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -1,4 +1,4 @@ - + @@ -248,6 +248,7 @@ + diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters index 1606f87a8a..57664c5e67 100644 --- a/rpcs3/rpcs3.vcxproj.filters +++ b/rpcs3/rpcs3.vcxproj.filters @@ -1,4 +1,4 @@ - + @@ -307,6 +307,9 @@ Emu\SysCalls\lv2 + + Emu\SysCalls\Modules + From 23ece01a0b6381cbbf70f87d6fa5d8d38094a1d3 Mon Sep 17 00:00:00 2001 From: O1L Date: Mon, 30 Sep 2013 20:35:28 +0400 Subject: [PATCH 2/4] Minor improved cellAudio module. More dummy modules created. Some modules are not included to the project. If you want to implement a function of any of these modules, add the corresponding file to the project first. --- rpcs3/Emu/SysCalls/Modules/cellAudio.cpp | 366 +++++++-------- .../SysCalls/Modules/cellPhotoDecodeUtil.cpp | 72 +++ .../SysCalls/Modules/cellPhotoImportUtil.cpp | 68 +++ .../Emu/SysCalls/Modules/cellPhotoUtility.cpp | 90 ++++ rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp | 430 ++++++++++++++++++ .../Modules/cellScreenShotUtility.cpp | 59 +++ 6 files changed, 905 insertions(+), 180 deletions(-) create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoDecodeUtil.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoImportUtil.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellPhotoUtility.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp create mode 100644 rpcs3/Emu/SysCalls/Modules/cellScreenShotUtility.cpp diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp index 0b740b7b11..4ec55211a8 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp @@ -61,40 +61,29 @@ CELL_SOUND_SYNTH2_ERROR_INVALID_PARAMETER = 0x80310202, CELL_SOUND_SYNTH2_ERROR_ALREADY_INITIALIZED = 0x80310203, }; -#define __CSTD -typedef __CSTD uint32_t sys_timer_t; -typedef __CSTD int64_t system_time_t; -typedef __CSTD uint64_t usecond_t; -typedef __CSTD uint32_t second_t; -typedef __CSTD uint32_t sys_event_queue_t; -typedef __CSTD uint32_t sys_event_port_t; -typedef __CSTD uint32_t sys_event_type_t; -typedef __CSTD uint64_t sys_ipc_key_t; -typedef __CSTD uintptr_t lparaddr_t; -typedef __CSTD uintptr_t sys_addr_t; -typedef __CSTD uint32_t sys_memory_t; -typedef __CSTD uint32_t sys_memory_container_t; -#undef __CSTD //libaudio datatyps struct CellAudioPortParam { -uint64_t nChannel; -uint64_t nBlock; -uint64_t attr; +u64 nChannel; +u64 nBlock; +u64 attr; float level; }; struct CellAudioPortConfig { -sys_addr_t readIndexAddr; -uint32_t status; -uint64_t nChannel; -uint64_t nBlock; -uint32_t portSize; -sys_addr_t portAddr; +u32 readIndexAddr; +u32 status; +u64 nChannel; +u64 nBlock; +u32 portSize; +u32 portAddr; }; +CellAudioPortParam current_AudioPortParam; +CellAudioPortConfig current_AudioPortConfig; + //libmixer datatypes typedef void * CellAANHandle; @@ -102,23 +91,25 @@ typedef void * CellAANHandle; struct CellSSPlayerConfig { -uint32_t channels; -uint32_t outputMode; +u32 channels; +u32 outputMode; }; struct CellSSPlayerWaveParam { void *addr; int format; -uint32_t samples; -uint32_t loopStartOffset; -uint32_t startOffset; +u32 samples; +u32 loopStartOffset; +u32 startOffset; }; +CellSSPlayerWaveParam current_SSPlayerWaveParam; + struct CellSSPlayerCommonParam { -uint32_t loopMode; -uint32_t attackMode; +u32 loopMode; +u32 attackMode; }; struct CellSurMixerPosition @@ -137,16 +128,16 @@ CellSurMixerPosition position; struct CellSurMixerConfig { -int32_t priority; -uint32_t chStrips1; -uint32_t chStrips2; -uint32_t chStrips6; -uint32_t chStrips8; +s32 priority; +u32 chStrips1; +u32 chStrips2; +u32 chStrips6; +u32 chStrips8; }; struct CellSurMixerChStripParam { -uint32_t param; +u32 param; void *attribute; int dBSwitch; float floatVal; @@ -158,105 +149,120 @@ int intVal; struct CellSnd3DataCtx { -int8_t system; //[CELL_SND3_DATA_CTX_SIZE], unknown identifier +s8 system; //[CELL_SND3_DATA_CTX_SIZE], unknown identifier }; struct CellSnd3SmfCtx { -int8_t system; //[CELL_SND3_SMF_CTX_SIZE], unknown identifier +s8 system; //[CELL_SND3_SMF_CTX_SIZE], unknown identifier }; struct CellSnd3KeyOnParam { -uint8_t vel; -uint8_t pan; -uint8_t panEx; -int32_t addPitch; +u8 vel; +u8 pan; +u8 panEx; +s32 addPitch; }; struct CellSnd3VoiceBitCtx { -uint32_t core; //[CELL_SND3_MAX_CORE], unknown identifier +u32 core; //[CELL_SND3_MAX_CORE], unknown identifier }; struct CellSnd3RequestQueueCtx { void *frontQueue; -uint32_t frontQueueSize; +u32 frontQueueSize; void *rearQueue; -uint32_t rearQueueSize; +u32 rearQueueSize; }; //libsynt2 datatypes struct CellSoundSynth2EffectAttr { -uint16_t core; -uint16_t mode; -int16_t depth_L; -int16_t depth_R; -uint16_t delay; -uint16_t feedback; +u16 core; +u16 mode; +s16 depth_L; +s16 depth_R; +u16 delay; +u16 feedback; }; - //*libaudio functions*// +bool g_is_audio_initialized = false; int cellAudioInit (void) { UNIMPLEMENTED_FUNC(cellAudio); + if(g_is_audio_initialized) return CELL_AUDIO_ERROR_ALREADY_INIT; + g_is_audio_initialized = true; return CELL_OK; } -int32_t cellAudioQuit(void) +s32 cellAudioQuit(void) { UNIMPLEMENTED_FUNC(cellAudio); + if (g_is_audio_initialized) return CELL_AUDIO_ERROR_NOT_INIT; + g_is_audio_initialized = false; return CELL_OK; } // Audio Ports Setting/Operation Functions -int cellAudioPortOpen () //CellAudioPortParam *audioParam, uint32_t *portNum + +bool g_is_audio_port_open = false; +int cellAudioPortOpen () //CellAudioPortParam *audioParam, u32 *portNum +{ + UNIMPLEMENTED_FUNC(cellAudio); + if(g_is_audio_port_open) return CELL_AUDIO_ERROR_PORT_OPEN; + g_is_audio_port_open = true; + return CELL_OK; +} + +int cellAudioPortClose (u32 portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + if(g_is_audio_port_open) return CELL_AUDIO_ERROR_PORT_NOT_OPEN; + g_is_audio_port_open = false; + return CELL_OK; +} + +bool g_is_audio_port_start = false; +int cellAudioPortStart (u32 portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + if(g_is_audio_port_start) return CELL_AUDIO_ERROR_PORT_ALREADY_RUN; + g_is_audio_port_start = true; + return CELL_OK; +} + +int cellAudioPortStop (u32 portNum) +{ + UNIMPLEMENTED_FUNC(cellAudio); + if(g_is_audio_port_start) return CELL_AUDIO_ERROR_PORT_NOT_RUN; + g_is_audio_port_start = false; + return CELL_OK; +} + +int cellAudioGetPortTimestamp () //u32 portNum, u64 tag, u64 *stamp { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioPortStart (uint32_t portNum) +int cellAudioGetPortConfig () //u32 portNum, CellAudioPortConfig *portConfig { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioPortClose (uint32_t portNum) -{ - UNIMPLEMENTED_FUNC(cellAudio); - return CELL_OK; -} - -int cellAudioPortStop (uint32_t portNum) -{ - UNIMPLEMENTED_FUNC(cellAudio); - return CELL_OK; -} - -int cellAudioGetPortConfig () //uint32_t portNum, CellAudioPortConfig *portConfig -{ - UNIMPLEMENTED_FUNC(cellAudio); - return CELL_OK; -} - -int cellAudioGetPortBlockTag () //uint32_t portNum, uint64_t blockNo, uint64_t *tag +int cellAudioGetPortBlockTag () //u32 portNum, u64 blockNo, u64 *tag { UNIMPLEMENTED_FUNC (cellAudio); return CELL_OK; } -int cellAudioGetPortTimestamp () //uint32_t portNum, uint64_t tag, usecond_t *stamp -{ - UNIMPLEMENTED_FUNC(cellAudio); - return CELL_OK; -} - -int cellAudioSetPortLevel (uint32_t portNum, float level) +int cellAudioSetPortLevel (u32 portNum, float level) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -264,61 +270,61 @@ int cellAudioSetPortLevel (uint32_t portNum, float level) // Utility Functions -int cellAudioCreateNotifyEventQueue () //sys_event_queue_t *id, sys_ipc_key_t *key +int cellAudioCreateNotifyEventQueue () //u32 *id, u64 *key { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioCreateNotifyEventQueueEx (sys_event_queue_t *id, sys_ipc_key_t *key, uint32_t iFlags) +int cellAudioCreateNotifyEventQueueEx (u32 *id, u64 *key, u32 iFlags) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioSetNotifyEventQueue (sys_ipc_key_t key) +int cellAudioSetNotifyEventQueue (u64 key) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioSetNotifyEventQueueEx (sys_ipc_key_t key, uint32_t iFlags) +int cellAudioSetNotifyEventQueueEx (u64 key, u32 iFlags) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioRemoveNotifyEventQueue (sys_ipc_key_t key) +int cellAudioRemoveNotifyEventQueue (u64 key) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioRemoveNotifyEventQueueEx (sys_ipc_key_t key, uint32_t iFlags) +int cellAudioRemoveNotifyEventQueueEx (u64 key, u32 iFlags) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioAddData () //uint32_t portNum, float *src, unsigned int samples, float volume +int cellAudioAddData () //u32 portNum, float *src, unsigned int samples, float volume { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioAdd2chData () //uint32_t portNum, float *src, unsigned int samples, float volume +int cellAudioAdd2chData () //u32 portNum, float *src, unsigned int samples, float volume { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioMiscSetAccessoryVolume (uint32_t devNum, float volume) +int cellAudioMiscSetAccessoryVolume (u32 devNum, float volume) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int cellAudioSendAck (uint64_t data3) +int cellAudioSendAck (u64 data3) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -336,32 +342,33 @@ int cellAudioUnsetPersonalDevice (int iPersonalStream) return CELL_OK; } -int cellAudioAdd6chData (uint32_t portNum, float *src, float volume) +int cellAudioAdd6chData (u32 portNum, float *src, float volume) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } //Callback Functions -typedef int (*CellSurMixerNotifyCallbackFunction)(void *arg, uint32_t counter, uint32_t samples); //Currently unused. +typedef int (*CellSurMixerNotifyCallbackFunction)(void *arg, u32 counter, u32 samples); //Currently unused. + //*libmixer Functions, NON active in this moment*// -int cellAANConnect (CellAANHandle receive, uint32_t receivePortNo, CellAANHandle source, uint32_t sourcePortNo) +int cellAANConnect (CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellAANDisconnect (CellAANHandle receive, uint32_t receivePortNo, CellAANHandle source, uint32_t sourcePortNo) +int cellAANDisconnect (CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellAANAddData (CellAANHandle handle, uint32_t port, uint32_t offset, float *addr, uint32_t samples) +int cellAANAddData (CellAANHandle handle, u32 port, u32 offset, float *addr, u32 samples) { UNIMPLEMENTED_FUNC(cellAudio); return 0; @@ -379,61 +386,61 @@ int cellSSPlayerRemove (CellAANHandle handle) return 0; } -int cellSSPlayerSetWave (CellAANHandle handle, CellSSPlayerWaveParam *waveInfo, CellSSPlayerCommonParam *commonInfo) +int cellSSPlayerSetWave () //CellAANHandle handle, CellSSPlayerWaveParam *waveInfo, CellSSPlayerCommonParam *commonInfo //mem_class_t waveInfo { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSSPlayerPlay (CellAANHandle handle, CellSSPlayerRuntimeInfo *info) +int cellSSPlayerPlay () //CellAANHandle handle, CellSSPlayerRuntimeInfo *info { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSSPlayerStop (CellAANHandle handle, uint32_t mode) +int cellSSPlayerStop () //CellAANHandle handle, u32 mode { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSSPlayerSetParam (CellAANHandle handle, CellSSPlayerRuntimeInfo *info) +int cellSSPlayerSetParam () //CellAANHandle handle, CellSSPlayerRuntimeInfo *info { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int32_t cellSSPlayerGetState (CellAANHandle handle) +s32 cellSSPlayerGetState () //CellAANHandle handle { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerCreate (const CellSurMixerConfig *config) +int cellSurMixerCreate () //const CellSurMixerConfig *config { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerGetAANHandle (CellAANHandle *handle) +int cellSurMixerGetAANHandle () //CellAANHandle *handle { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerChStripGetAANPortNo (uint32_t *port, uint32_t type, uint32_t index) +int cellSurMixerChStripGetAANPortNo () //u32 *port, u32 type, u32 index { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerSetNotifyCallback (CellSurMixerNotifyCallbackFunction callback, void *arg) +int cellSurMixerSetNotifyCallback () //CellSurMixerNotifyCallbackFunction callback, void *arg { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerRemoveNotifyCallback (CellSurMixerNotifyCallbackFunction callback) +int cellSurMixerRemoveNotifyCallback () //CellSurMixerNotifyCallbackFunction callback { UNIMPLEMENTED_FUNC(cellAudio); return 0; @@ -445,43 +452,43 @@ int cellSurMixerStart(void) return 0; } -int cellSurMixerSurBusAddData (uint32_t busNo, uint32_t offset, float *addr, uint32_t samples) +int cellSurMixerSurBusAddData () //u32 busNo, u32 offset, float *addr, u32 samples { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerSetParameter (uint32_t param, float value) +int cellSurMixerSetParameter () //u32 param, float value { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerChStripSetParameter (uint32_t type, uint32_t index, CellSurMixerChStripParam *param) +int cellSurMixerChStripSetParameter () //u32 type, u32 index, CellSurMixerChStripParam *param { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerPause() //uint32_t switch +int cellSurMixerPause() //u32 switch { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerGetCurrentBlockTag (uint64_t *tag) +int cellSurMixerGetCurrentBlockTag () //u64 *tag { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int cellSurMixerGetTimestamp (uint64_t tag, usecond_t *stamp) +int cellSurMixerGetTimestamp () //u64 tag, u64 *stamp { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -void cellSurMixerBeep (void *arg); +void cellSurMixerBeep (); //void *arg float cellSurMixerUtilGetLevelFromDB () //float dB { @@ -509,315 +516,315 @@ int cellSurMixerFinalize(void); //Currently unused. Returns 0 (in the current re //*libsnd3 Functions, NON active in this moment*// -int32_t cellSnd3Init (uint32_t maxVoice, uint32_t samples, CellSnd3RequestQueueCtx *queue) +s32 cellSnd3Init () //u32 maxVoice, u32 samples, CellSnd3RequestQueueCtx *queue { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3Exit (void) +s32 cellSnd3Exit (void) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SetOutputMode (uint32_t mode) +s32 cellSnd3SetOutputMode () //u32 mode { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3Synthesis (float *pOutL, float *pOutR) +s32 cellSnd3Synthesis () //float *pOutL, float *pOutR { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SynthesisEx (float *pOutL, float *pOutR, float *pOutRL, float *pOutRR) +s32 cellSnd3SynthesisEx () //float *pOutL, float *pOutR, float *pOutRL, float *pOutRR { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetReserveMode (uint32_t voiceNum, uint32_t reserveMode) +s32 cellSnd3VoiceSetReserveMode () //u32 voiceNum, u32 reserveMode { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3BindSoundData (CellSnd3DataCtx *snd3Ctx, void *hd3, uint32_t synthMemOffset) +s32 cellSnd3BindSoundData () //CellSnd3DataCtx *snd3Ctx, void *hd3, u32 synthMemOffset { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3UnbindSoundData (uint32_t hd3ID) +s32 cellSnd3UnbindSoundData (u32 hd3ID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3NoteOnByTone () //uint32_t hd3ID, uint32_t toneIndex, uint32_t note, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +s32 cellSnd3NoteOnByTone () //u32 hd3ID, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3KeyOnByTone () //uint32_t hd3ID, uint32_t toneIndex, uint32_t pitch,uint32_t keyOnID,CellSnd3KeyOnParam *keyOnParam +s32 cellSnd3KeyOnByTone () //u32 hd3ID, u32 toneIndex, u32 pitch,u32 keyOnID,CellSnd3KeyOnParam *keyOnParam { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3VoiceNoteOnByTone () //uint32_t hd3ID, uint32_t voiceNum, uint32_t toneIndex, uint32_t note, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +s32 cellSnd3VoiceNoteOnByTone () //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3VoiceKeyOnByTone () //uint32_t hd3ID, uint32_t voiceNum, uint32_t toneIndex, uint32_t pitch, uint32_t keyOnID, CellSnd3KeyOnParam *keyOnParam +s32 cellSnd3VoiceKeyOnByTone () //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 pitch, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3VoiceSetSustainHold (uint32_t voiceNum, uint32_t sustainHold) +s32 cellSnd3VoiceSetSustainHold (u32 voiceNum, u32 sustainHold) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceKeyOff (uint32_t voiceNum) +s32 cellSnd3VoiceKeyOff (u32 voiceNum) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetPitch(uint32_t voiceNum, int32_t addPitch) +s32 cellSnd3VoiceSetPitch(u32 voiceNum, s32 addPitch) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetVelocity (uint32_t voiceNum, uint32_t velocity) +s32 cellSnd3VoiceSetVelocity (u32 voiceNum, u32 velocity) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetPanpot (uint32_t voiceNum, uint32_t panpot) +s32 cellSnd3VoiceSetPanpot (u32 voiceNum, u32 panpot) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetPanpotEx (uint32_t voiceNum, uint32_t panpotEx) +s32 cellSnd3VoiceSetPanpotEx (u32 voiceNum, u32 panpotEx) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceSetPitchBend (uint32_t voiceNum, uint32_t bendValue) +s32 cellSnd3VoiceSetPitchBend (u32 voiceNum, u32 bendValue) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceAllKeyOff (void) +s32 cellSnd3VoiceAllKeyOff (void) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceGetEnvelope (uint32_t voiceNum) +s32 cellSnd3VoiceGetEnvelope (u32 voiceNum) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3VoiceGetStatus () //uint32_t voiceNum +s32 cellSnd3VoiceGetStatus () //u32 voiceNum { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -uint32_t cellSnd3KeyOffByID (uint32_t keyOnID) +u32 cellSnd3KeyOffByID (u32 keyOnID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3GetVoice (uint32_t midiChannel, uint32_t keyOnID, CellSnd3VoiceBitCtx *voiceBit) +s32 cellSnd3GetVoice () //u32 midiChannel, u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3GetVoiceByID (uint32_t keyOnID, CellSnd3VoiceBitCtx *voiceBit) +s32 cellSnd3GetVoiceByID () //u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3NoteOn (uint32_t hd3ID, uint32_t midiChannel, uint32_t midiProgram, uint32_t midiNote, uint32_t sustain,CellSnd3KeyOnParam *keyOnParam, uint32_t keyOnID) +s32 cellSnd3NoteOn () //u32 hd3ID, u32 midiChannel, u32 midiProgram, u32 midiNote, u32 sustain,CellSnd3KeyOnParam *keyOnParam, u32 keyOnID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3NoteOff (uint32_t midiChannel, uint32_t midiNote, uint32_t keyOnID) +s32 cellSnd3NoteOff (u32 midiChannel, u32 midiNote, u32 keyOnID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SetSustainHold (uint32_t midiChannel, uint32_t sustainHold, uint32_t ID) +s32 cellSnd3SetSustainHold (u32 midiChannel, u32 sustainHold, u32 ID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SetEffectType (uint16_t effectType, int16_t returnVol, uint16_t delay, uint16_t feedback) +s32 cellSnd3SetEffectType (u16 effectType, s16 returnVol, u16 delay, u16 feedback) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -uint16_t cellSnd3Note2Pitch () //uint16_t center_note, uint16_t center_fine, uint16_t note, int16_t fine +u16 cellSnd3Note2Pitch () //u16 center_note, u16 center_fine, u16 note, s16 fine { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -uint16_t cellSnd3Pitch2Note () //uint16_t center_note, uint16_t center_fine, uint16_t pitch +u16 cellSnd3Pitch2Note () //u16 center_note, u16 center_fine, u16 pitch { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFBind () //CellSnd3SmfCtx *smfCtx, void *smf, uint32_t hd3ID +s32 cellSnd3SMFBind () //CellSnd3SmfCtx *smfCtx, void *smf, u32 hd3ID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFUnbind () //uint32_t smfID +s32 cellSnd3SMFUnbind () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFPlay (uint32_t smfID, uint32_t playVelocity, uint32_t playPan, uint32_t playCount) +s32 cellSnd3SMFPlay (u32 smfID, u32 playVelocity, u32 playPan, u32 playCount) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFPlayEx (uint32_t smfID, uint32_t playVelocity, uint32_t playPan, uint32_t playPanEx, uint32_t playCount) +s32 cellSnd3SMFPlayEx (u32 smfID, u32 playVelocity, u32 playPan, u32 playPanEx, u32 playCount) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFPause (uint32_t smfID) +s32 cellSnd3SMFPause (u32 smfID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFResume (uint32_t smfID) +s32 cellSnd3SMFResume (u32 smfID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFStop (uint32_t smfID) +s32 cellSnd3SMFStop (u32 smfID) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFAddTempo (uint32_t smfID, int32_t addTempo) +s32 cellSnd3SMFAddTempo (u32 smfID, s32 addTempo) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFGetTempo () //uint32_t smfID +s32 cellSnd3SMFGetTempo () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFSetPlayVelocity (uint32_t smfID, uint32_t playVelocity) +s32 cellSnd3SMFSetPlayVelocity (u32 smfID, u32 playVelocity) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFGetPlayVelocity () //uint32_t smfID +s32 cellSnd3SMFGetPlayVelocity () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFSetPlayPanpot (uint32_t smfID, uint32_t playPanpot) +s32 cellSnd3SMFSetPlayPanpot (u32 smfID, u32 playPanpot) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFSetPlayPanpotEx (uint32_t smfID, uint32_t playPanpotEx) +s32 cellSnd3SMFSetPlayPanpotEx (u32 smfID, u32 playPanpotEx) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFGetPlayPanpot () //uint32_t smfID +s32 cellSnd3SMFGetPlayPanpot () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFGetPlayPanpotEx () //uint32_t smfID +s32 cellSnd3SMFGetPlayPanpotEx () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFGetPlayStatus () //uint32_t smfID +s32 cellSnd3SMFGetPlayStatus () //u32 smfID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSnd3SMFSetPlayChannel (uint32_t smfID, uint32_t playChannelBit) +s32 cellSnd3SMFSetPlayChannel (u32 smfID, u32 playChannelBit) { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFGetPlayChannel (uint32_t smfID, uint32_t *playChannelBit) +s32 cellSnd3SMFGetPlayChannel () //u32 smfID, u32 *playChannelBit { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -int32_t cellSnd3SMFGetKeyOnID (uint32_t smfID, uint32_t midiChannel, uint32_t *keyOnID) +s32 cellSnd3SMFGetKeyOnID () //u32 smfID, u32 midiChannel, u32 *keyOnID { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -825,101 +832,101 @@ int32_t cellSnd3SMFGetKeyOnID (uint32_t smfID, uint32_t midiChannel, uint32_t *k //*libsynth2 Functions, NON active in this moment*// -int32_t cellSoundSynth2Config (int16_t param, int32_t value) +s32 cellSoundSynth2Config (s16 param, s32 value) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int32_t cellSoundSynth2Init( int16_t flag) +s32 cellSoundSynth2Init( s16 flag) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int32_t cellSoundSynth2Exit(void) +s32 cellSoundSynth2Exit(void) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -void cellSoundSynth2SetParam (uint16_t register, uint16_t value) +void cellSoundSynth2SetParam (u16 register, u16 value) { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -uint16_t cellSoundSynth2GetParam () //uint16_t register +u16 cellSoundSynth2GetParam () //u16 register { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -void cellSoundSynth2SetSwitch (uint16_t register, uint32_t value) +void cellSoundSynth2SetSwitch (u16 register, u32 value) { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -uint32_t cellSoundSynth2GetSwitch () //uint16_t register +u32 cellSoundSynth2GetSwitch () //u16 register { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -uint32_t cellSoundSynth2SetAddr (uint16_t register, uint32_t value) +u32 cellSoundSynth2SetAddr (u16 register, u32 value) { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -uint32_t cellSoundSynth2GetAddr () //uint16_t register +u32 cellSoundSynth2GetAddr () //u16 register { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -int32_t cellSoundSynth2SetEffectAttr (int16_t bus, CellSoundSynth2EffectAttr *attr) +s32 cellSoundSynth2SetEffectAttr () //s16 bus, CellSoundSynth2EffectAttr *attr { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int32_t cellSoundSynth2SetEffectMode (int16_t bus, CellSoundSynth2EffectAttr *attr) +s32 cellSoundSynth2SetEffectMode () //s16 bus, CellSoundSynth2EffectAttr *attr { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -void cellSoundSynth2SetCoreAttr (uint16_t entry, uint16_t value) +void cellSoundSynth2SetCoreAttr (u16 entry, u16 value) { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -int32_t cellSoundSynth2Generate (uint16_t samples, float *left_buffer, float *right_buffer, float *left_rear, float *right_rear) +s32 cellSoundSynth2Generate () //u16 samples, float *left_buffer, float *right_buffer, float *left_rear, float *right_rear { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -int32_t cellSoundSynth2VoiceTrans () //int16_t channel, uint16_t mode, uint8_t *m_addr, uint32_t s_addr, uint32_t size +s32 cellSoundSynth2VoiceTrans () //s16 channel, u16 mode, u8 *m_addr, u32 s_addr, u32 size { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -uint16_t cellSoundSynth2Note2Pitch () //uint16_t center_note, uint16_t center_fine, uint16_t note, int16_t fine +u16 cellSoundSynth2Note2Pitch () //u16 center_note, u16 center_fine, u16 note, s16 fine { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -uint16_t cellSoundSynth2Pitch2Note () //uint16_t center_note, uint16_t center_fine, uint16_t pitch +u16 cellSoundSynth2Pitch2Note () //u16 center_note, u16 center_fine, u16 pitch { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value @@ -927,7 +934,6 @@ uint16_t cellSoundSynth2Pitch2Note () //uint16_t center_note, uint16_t center_fi } - void cellAudio_init () { cellAudio.AddFunc (0x0b168f92, cellAudioInit); diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoDecodeUtil.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoDecodeUtil.cpp new file mode 100644 index 0000000000..f2ad31c05f --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellPhotoDecodeUtil.cpp @@ -0,0 +1,72 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellPhotoDecodeUtil_init (); +Module cellPhotoDecodeUtil ("cellPhotoDecodeUtil", cellPhotoDecodeUtil_init); + +//Error codes +enum +{ + CELL_PHOTO_DECODE_RET_OK = 0, + CELL_PHOTO_DECODE_RET_CANCEL = 1, + CELL_PHOTO_DECODE_ERROR_BUSY = 0x8002c901, + CELL_PHOTO_DECODE_ERROR_INTERNAL = 0x8002c902, + CELL_PHOTO_DECODE_ERROR_PARAM = 0x8002c903, + CELL_PHOTO_DECODE_ERROR_ACCESS_ERROR = 0x8002c904, + CELL_PHOTO_DECODE_ERROR_INITIALIZE = 0x8002c905, + CELL_PHOTO_DECODE_ERROR_DECODE = 0x8002c906, +}; + +//datatypes +struct CellPhotoDecodeSetParam +{ + void *dstBuffer; + u16 width; + u16 height; + void *reserved1; + void *reserved2; +}; + +struct CellPhotoDecodeReturnParam +{ + u16 width; + u16 height; + void *reserved1; + void *reserved2; +}; + + +int cellPhotoDecodeInitialize () //unsigned int version, sys_memory_container_t container1, sys_memory_container_t container2, CellPhotoDecodeFinishCallback funcFinish, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoDecodeUtil); + return CELL_PHOTO_DECODE_RET_OK; +} + +int cellPhotoDecodeInitialize2 () //unsigned int version, sys_memory_container_t container2, CellPhotoDecodeFinishCallback funcFinish, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoDecodeUtil); + return CELL_PHOTO_DECODE_RET_OK; +} + +int cellPhotoDecodeFinalize () //CellPhotoDecodeFinishCallback funcFinish, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoDecodeUtil); + return CELL_PHOTO_DECODE_RET_OK; +} + +int cellPhotoDecodeFromFile () //const char *srcHddDir, const char *srcHddFile, CellPhotoDecodeSetParam *set_param, CellPhotoDecodeReturnParam *return_param +{ + UNIMPLEMENTED_FUNC(cellPhotoDecodeUtil); + return CELL_PHOTO_DECODE_RET_OK; +} + +void ( *CellPhotoDecodeFinishCallback) (); //int result, void *userdata + +void cellPhotoDecodeUtil_init () +{ + cellPhotoDecodeUtil.AddFunc (0x0f424ecb, cellPhotoDecodeInitialize2); + cellPhotoDecodeUtil.AddFunc (0x28b22e44, cellPhotoDecodeFromFile); + cellPhotoDecodeUtil.AddFunc (0x596f0a56, cellPhotoDecodeInitialize); + cellPhotoDecodeUtil.AddFunc (0xad7d8f38, cellPhotoDecodeFinalize); +} diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoImportUtil.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoImportUtil.cpp new file mode 100644 index 0000000000..669824bb17 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellPhotoImportUtil.cpp @@ -0,0 +1,68 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellPhotoImportUtil_init (); +Module cellPhotoImportUtil ("cellPhotoImportUtil", cellPhotoImportUtil_init); + +//Error codes +enum +{ + CELL_PHOTO_IMPORT_RET_OK = 0, + CELL_PHOTO_IMPORT_RET_CANCEL = 1, + CELL_PHOTO_IMPORT_ERROR_BUSY = 0x8002c701, + CELL_PHOTO_IMPORT_ERROR_INTERNAL = 0x8002c702, + CELL_PHOTO_IMPORT_ERROR_PARAM = 0x8002c703, + CELL_PHOTO_IMPORT_ERROR_ACCESS_ERROR = 0x8002c704, + CELL_PHOTO_IMPORT_ERROR_COPY = 0x8002c705, + CELL_PHOTO_IMPORT_ERROR_INITIALIZE = 0x8002c706, + +}; + +//datatyps + +struct CellPhotoImportFileDataSub +{ +int width; +int height; +//CellPhotoImportFormatType format; +//CellPhotoImportTexRot rotate; +}; + +struct CellPhotoImportFileData +{ +char dstFileName; //[CELL_FS_MAX_FS_FILE_NAME_LENGTH]; +char photo_title; //[CELL_PHOTO_IMPORT_PHOTO_TITLE_MAX_LENGTH*3]; +char game_title; //[CELL_PHOTO_IMPORT_GAME_TITLE_MAX_SIZE]; +char game_comment; //[CELL_PHOTO_IMPORT_GAME_COMMENT_MAX_SIZE]; +CellPhotoImportFileDataSub* data_sub; +void *reserved; +}; + +struct CellPhotoImportSetParam +{ + unsigned int fileSizeMax; + void *reserved1; + void *reserved2; +}; + +//import API + +int cellPhotoImport () //unsigned int version, const char *dstHddPath, CellPhotoImportSetParam *param, sys_memory_container_t container, CellPhotoImportFinishCallback funcFinish, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoImportUtil); + return CELL_PHOTO_IMPORT_RET_OK; +} + +int cellPhotoImport2 () //unsigned int version, const char *dstHddPath, CellPhotoImportSetParam *param, CellPhotoImportFinishCallback funcFinish, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoImportUtil); + return CELL_PHOTO_IMPORT_RET_OK; +} + + +void cellPhotoImportUtil_init () +{ + cellPhotoImportUtil.AddFunc (0x0783bce0, cellPhotoImport); + cellPhotoImportUtil.AddFunc (0x1ab8df55, cellPhotoImport2); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellPhotoUtility.cpp b/rpcs3/Emu/SysCalls/Modules/cellPhotoUtility.cpp new file mode 100644 index 0000000000..44e7e1fe3f --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellPhotoUtility.cpp @@ -0,0 +1,90 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellPhotoUtility_init (); +Module cellPhotoUtility ("cellPhotoUtility", cellPhotoUtility_init); + +//Error codes +enum +{ + CELL_PHOTO_EXPORT_UTIL_RET_OK = 0, + CELL_PHOTO_EXPORT_UTIL_RET_CANCEL = 1, + CELL_PHOTO_EXPORT_UTIL_ERROR_BUSY = 0x8002c201, + CELL_PHOTO_EXPORT_UTIL_ERROR_INTERNAL = 0x8002c202, + CELL_PHOTO_EXPORT_UTIL_ERROR_PARAM = 0x8002c203, + CELL_PHOTO_EXPORT_UTIL_ERROR_ACCESS_ERROR = 0x8002c204, + CELL_PHOTO_EXPORT_UTIL_ERROR_DB_INTERNAL = 0x8002c205, + CELL_PHOTO_EXPORT_UTIL_ERROR_DB_REGIST = 0x8002c206, + CELL_PHOTO_EXPORT_UTIL_ERROR_SET_META = 0x8002c207, + CELL_PHOTO_EXPORT_UTIL_ERROR_FLUSH_META = 0x8002c208, + CELL_PHOTO_EXPORT_UTIL_ERROR_MOVE = 0x8002c209, + CELL_PHOTO_EXPORT_UTIL_ERROR_INITIALIZE = 0x8002c20a, +}; + +//datatyps + +struct CellPhotoExportSetParam +{ + char *photo_title; + char *game_title; + char *game_comment; + void *reserved; +}; + + +//export API +int cellPhotoExportInitialize () +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +int cellPhotoExportInitialize2() //unsigned int version, CellPhotoExportUtilFinishCallback func, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +int cellPhotoExportFinalize () //CellPhotoExportUtilFinishCallback func, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +int cellPhotoExportFromFile () //const char *srcHddDir, const char *srcHddFile, CellPhotoExportSetParam *param, CellPhotoExportUtilFinishCallback func,void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +int cellPhotoExportFromFileWithCopy () //const char *srcHddDir, const char *srcHddFile, CellPhotoExportSetParam *param, CellPhotoExportUtilFinishCallback func, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +int cellPhotoExportProgress () //CellPhotoExportUtilFinishCallback func, void *userdata +{ + UNIMPLEMENTED_FUNC(cellPhotoUtility); + return CELL_PHOTO_EXPORT_UTIL_RET_OK; +} + +void ( * CellPhotoExportUtilFinishCallback ) (); //int result, void *userdata + + + +void ( * CellPhotoImportFinishCallback ) (); //int result, CellPhotoImportFileData *filedata, void *userdata + + +void cellPhotoUtility_init () +{ + cellPhotoUtility.AddFunc (0x08cbd8e1, cellPhotoExportInitialize2); + cellPhotoUtility.AddFunc (0x09ce84ac, cellPhotoExportFromFile); + //cellPhotoUtility.AddFunc (0x3f7fc0af, cellPhotoFinalize); //TODO + //cellPhotoUtility.AddFunc (0x42a32983, cellPhotoRegistFromFile); //TODO + cellPhotoUtility.AddFunc (0x4357c77f, cellPhotoExportInitialize); //TODO + //cellPhotoUtility.AddFunc (0x55c70783, cellPhotoInitialize); //TODO + cellPhotoUtility.AddFunc (0xde509ead, cellPhotoExportProgress); + cellPhotoUtility.AddFunc (0xed4a0148, cellPhotoExportFinalize); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp new file mode 100644 index 0000000000..f9a2e81092 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp @@ -0,0 +1,430 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellSaveData_init (); +Module cellSaveData ("cellSaveData", cellSaveData_init); + +//Error codes + +enum +{ + CELL_SAVEDATA_RET_OK = 0, + CELL_SAVEDATA_RET_CANCEL = 1, + CELL_SAVEDATA_ERROR_CBRESULT, + CELL_SAVEDATA_ERROR_ACCESS_ERROR, + CELL_SAVEDATA_ERROR_INTERNAL, + CELL_SAVEDATA_ERROR_PARAM, + CELL_SAVEDATA_ERROR_NOSPACE, + CELL_SAVEDATA_ERROR_BROKEN, + CELL_SAVEDATA_ERROR_FAILURE, + CELL_SAVEDATA_ERROR_BUSY, + CELL_SAVEDATA_ERROR_NOUSER, +}; + +//datatyps + +struct CellSaveDataSetList +{ +unsigned int sortType; +unsigned int sortOrder; +char *dirNamePrefix; +void *reserved; +}; + +struct CellSaveDataSetBuf +{ +unsigned int dirListMax; +unsigned int fileListMax; +unsigned int reserved[6]; +unsigned int bufSize; +void *buf; +}; + +struct CellSaveDataNewDataIcon +{ +char *title; +unsigned int iconBufSize; +void *iconBuf; +void *reserved; +}; + +struct CellSaveDataListNewData +{ +unsigned int iconPosition; +char *dirName; +CellSaveDataNewDataIcon *icon; +void *reserved; +}; + +struct CellSaveDataDirList +{ +char dirName; //[CELL_SAVEDATA_DIRNAME_SIZE]; +char listParam; //[CELL_SAVEDATA_SYSP_LPARAM_SIZE]; +char reserved[8]; +}; + +struct CellSaveDataListGet +{ +unsigned int dirNum; +unsigned int dirListNum; +CellSaveDataDirList *dirList; +char reserved[64]; +}; + +struct CellSaveDataListSet +{ +unsigned int focusPosition; +char *focusDirName; +unsigned int fixedListNum; +CellSaveDataDirList *fixedList; +CellSaveDataListNewData *newData; +void *reserved; +}; + +struct CellSaveDataFixedSet +{ +char *dirName; +CellSaveDataNewDataIcon *newIcon; +unsigned int option; +}; + +struct CellSaveDataSystemFileParam +{ +char title; //[CELL_SAVEDATA_SYSP_TITLE_SIZE]; +char subTitle; //[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE]; +char detail; //[CELL_SAVEDATA_SYSP_DETAIL_SIZE]; +unsigned int attribute; +char reserved2[4]; +char listParam; //[CELL_SAVEDATA_SYSP_LPARAM_SIZE]; +char reserved[256]; +}; + +struct CellSaveDataDirStat +{ +s64 st_atime; +s64 st_mtime; +s64 st_ctime; +char dirName; //[CELL_SAVEDATA_DIRNAME_SIZE]; +}; + +struct CellSaveDataFileStat +{ +unsigned int fileType; +char reserved1[4]; +u64 st_size; +s64 st_atime; +s64 st_mtime; +s64 st_ctime; +char fileName; //[CELL_SAVEDATA_FILENAME_SIZE]; +char reserved2[3]; +}; + +struct CellSaveDataStatGet +{ +int hddFreeSizeKB; +unsigned int isNewData; +CellSaveDataDirStat dir; +CellSaveDataSystemFileParam getParam; +unsigned int bind; +int sizeKB; +int sysSizeKB; +unsigned int fileNum; +unsigned int fileListNum; +CellSaveDataFileStat *fileList; +char reserved[64]; +}; + +struct CellSaveDataAutoIndicator +{ +unsigned int dispPosition; +unsigned int dispMode; +char *dispMsg; +unsigned int picBufSize; +void *picBuf; +void *reserved; +}; + +struct CellSaveDataStatSet +{ +CellSaveDataSystemFileParam *setParam; +unsigned int reCreateMode; +CellSaveDataAutoIndicator *indicator; +}; + +struct CellSaveDataFileGet +{ +unsigned int excSize; +char reserved[64]; +}; + +struct CellSaveDataFileSet +{ +unsigned int fileOperation; +void *reserved; +unsigned int fileType; +unsigned char secureFileId; //[CELL_SAVEDATA_SECUREFILEID_SIZE]; +char *fileName; +unsigned int fileOffset; +unsigned int fileSize; +unsigned int fileBufSize; +void *fileBuf; +}; + +struct CellSaveDataCBResult +{ +int result; +unsigned int progressBarInc; +int errNeedSizeKB; +char *invalidMsg; +void *userdata; +}; + +struct CellSaveDataDoneGet +{ +int excResult; +char dirName; //[CELL_SAVEDATA_DIRNAME_SIZE]; +int sizeKB; +int hddFreeSizeKB; +char reserved[64]; +}; + +//functions + +int cellSaveDataListSave2 () //unsigned int version, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataListLoad2 () //unsigned int version, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataFixedSave2 () //unsigned int version, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile,sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataFixedLoad2 () //unsigned int version, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataAutoSave2 () //unsigned int version, const char *dirName, unsigned int errDialog, CellSaveDataSetBuf *setBuf, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataAutoLoad2 () //unsigned int version, const char *dirName, unsigned int errDialog, CellSaveDataSetBuf *setBuf, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataListAutoSave () //unsigned int version, unsigned int errDialog, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile,sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataListAutoLoad () //unsigned int version, unsigned int errDialog, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataDelete2 () //sys_memory_container_t container +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_CANCEL; +} + +int cellSaveDataFixedDelete () //CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListSave () //unsigned int version, CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListLoad () //unsigned int version, CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserFixedSave () //unsigned int version, CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserFixedLoad () //unsigned int version, CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserAutoSave () //unsigned int version, CellSysutilUserId userId, const char *dirName, unsigned int errDialog, CellSaveDataSetBuf *setBuf, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserAutoLoad () //unsigned int version, CellSysutilUserId userId, const char *dirName, unsigned int errDialog, CellSaveDataSetBuf *setBuf, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListAutoSave () //unsigned int version, CellSysutilUserId userId, unsigned int errDialog, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListAutoLoad () //unsigned int version, CellSysutilUserId userId, unsigned int errDialog, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataStatCallback funcStat, CellSaveDataFileCallback funcFile, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserFixedDelete () //CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataFixedCallback funcFixed, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +//void cellSaveDataEnableOverlay (); //int enable + + +//Functions (Extensions) + +int cellSaveDataListDelete () //CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataListImport () //CellSaveDataSetList *setList, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataListExport () //CellSaveDataSetList *setList, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataFixedImport () //const char *dirName, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataFixedExport () //const char *dirName, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataGetListItem () //const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, unsigned int *bind, int *sizeKB +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListDelete () //CellSysutilUserId userId, CellSaveDataSetList *setList, CellSaveDataSetBuf *setBuf, CellSaveDataListCallback funcList, CellSaveDataDoneCallback funcDone,sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListImport () //CellSysutilUserId userId, CellSaveDataSetList *setList, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserListExport () //CellSysutilUserId userId, CellSaveDataSetList *setList, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserFixedImport () //CellSysutilUserId userId, const char *dirName, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserFixedExport () //CellSysutilUserId userId, const char *dirName, unsigned int maxSizeKB, CellSaveDataDoneCallback funcDone, sys_memory_container_t container, void *userdata +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + +int cellSaveDataUserGetListItem () //CellSysutilUserId userId, const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, unsigned int *bind, int *sizeKB +{ + UNIMPLEMENTED_FUNC(cellSaveData); + return CELL_SAVEDATA_RET_OK; +} + + +//Callback Functions + +void (*CellSaveDataFixedCallback) (); //CellSaveDataCBResult *cbResult, CellSaveDataListGet *get, CellSaveDataFixedSet *set + +void (*CellSaveDataListCallback) (); //CellSaveDataCBResult *cbResult, CellSaveDataListGet *get, CellSaveDataListSet *set + +void (*CellSaveDataStatCallback) (); //CellSaveDataCBResult *cbResult, CellSaveDataStatGet *get, CellSaveDataStatSet *set + +void (*CellSaveDataFileCallback) (); //CellSaveDataCBResult *cbResult, CellSaveDataFileGet *get, CellSaveDataFileSet *set + +void (*CellSaveDataDoneCallback) (); //CellSaveDataCBResult *cbResult, CellSaveDataDoneGet *get + + +void cellSaveData_init () +{ + cellSaveData.AddFunc (0x04c06fc2, cellSaveDataGetListItem); + cellSaveData.AddFunc (0x273d116a, cellSaveDataUserListExport); + cellSaveData.AddFunc (0x27cb8bc2, cellSaveDataListDelete); + cellSaveData.AddFunc (0x39d6ee43, cellSaveDataUserListImport); + cellSaveData.AddFunc (0x46a2d878, cellSaveDataFixedExport); + cellSaveData.AddFunc (0x491cc554, cellSaveDataListExport); + cellSaveData.AddFunc (0x52541151, cellSaveDataFixedImport); + cellSaveData.AddFunc (0x529231b0, cellSaveDataUserFixedImport); + cellSaveData.AddFunc (0x6b4e0de6, cellSaveDataListImport); + cellSaveData.AddFunc (0x7048a9ba, cellSaveDataUserListDelete); + cellSaveData.AddFunc (0x95ae2cde, cellSaveDataUserFixedExport); + cellSaveData.AddFunc (0xf6482036, cellSaveDataUserGetListItem); + cellSaveData.AddFunc (0x2de0d663, cellSaveDataListSave2); + cellSaveData.AddFunc (0x1dfbfdd6, cellSaveDataListLoad2); + cellSaveData.AddFunc (0x2aae9ef5, cellSaveDataFixedSave2); + cellSaveData.AddFunc (0x2a8eada2, cellSaveDataFixedLoad2); + cellSaveData.AddFunc (0x8b7ed64b, cellSaveDataAutoSave2); + cellSaveData.AddFunc (0xfbd5c856, cellSaveDataAutoLoad2); + cellSaveData.AddFunc (0x4dd03a4e, cellSaveDataListAutoSave); + cellSaveData.AddFunc (0x21425307, cellSaveDataListAutoLoad); + cellSaveData.AddFunc (0xedadd797, cellSaveDataDelete2); + cellSaveData.AddFunc (0x0f03cfb0, cellSaveDataUserListSave); + cellSaveData.AddFunc (0x39dd8425, cellSaveDataUserListLoad); + cellSaveData.AddFunc (0x40b34847, cellSaveDataUserFixedSave); + cellSaveData.AddFunc (0x6e7264ed, cellSaveDataUserFixedLoad); + cellSaveData.AddFunc (0x52aac4fa, cellSaveDataUserAutoSave); + cellSaveData.AddFunc (0xcdc6aefd, cellSaveDataUserAutoLoad); + cellSaveData.AddFunc (0x0e091c36, cellSaveDataUserListAutoSave); + //cellSaveData.AddFunc (0xe7fa820b, cellSaveDataEnableOverlay); +} \ No newline at end of file diff --git a/rpcs3/Emu/SysCalls/Modules/cellScreenShotUtility.cpp b/rpcs3/Emu/SysCalls/Modules/cellScreenShotUtility.cpp new file mode 100644 index 0000000000..eac19fab33 --- /dev/null +++ b/rpcs3/Emu/SysCalls/Modules/cellScreenShotUtility.cpp @@ -0,0 +1,59 @@ +#include "stdafx.h" +#include "Emu/SysCalls/SysCalls.h" +#include "Emu/SysCalls/SC_FUNC.h" + +void cellScreenShotUtility_init (); +Module cellScreenShotUtility ("cellScreenShotUtility", cellScreenShotUtility_init); + +//Error codes +enum +{ + CELL_SCREENSHOT_OK = 0x0, + CELL_SCREENSHOT_ERROR_INTERNAL = 0x8002d101, + CELL_SCREENSHOT_ERROR_PARAM = 0x8002d102, + CELL_SCREENSHOT_ERROR_DECODE = 0x8002d103, + CELL_SCREENSHOT_ERROR_NOSPACE = 0x8002d104, + CELL_SCREENSHOT_ERROR_UNSUPPORTED_COLOR_FORMAT = 0x8002d105, +}; + +//datatyps +struct CellScreenShotSetParam +{ + const char *photo_title; + const char *game_title; + const char *game_comment; + void* reserved; +}; + +int cellScreenShotSetParameter () //const CellScreenShotSetParam *param +{ + UNIMPLEMENTED_FUNC(cellScreenShotUtility); + return CELL_SCREENSHOT_OK; +} + +int cellScreenShotSetOverlayImage() //const char *srcDir, const char *srcFile, s32 offset_x, s32 offset_y +{ + UNIMPLEMENTED_FUNC(cellScreenShotUtility); + return CELL_SCREENSHOT_OK; +} + +int cellScreenShotEnable (void) +{ + UNIMPLEMENTED_FUNC(cellScreenShotUtility); + return CELL_SCREENSHOT_OK; +} + +int cellScreenShotDisable (void) +{ + UNIMPLEMENTED_FUNC(cellScreenShotUtility); + return CELL_SCREENSHOT_OK; +} + + +void cellScreenShotUtility_init () +{ +cellScreenShotUtility.AddFunc (0x9e33ab8f, cellScreenShotEnable); +cellScreenShotUtility.AddFunc (0xd3ad63e4, cellScreenShotSetParameter); +cellScreenShotUtility.AddFunc (0xfc6f4e74, cellScreenShotDisable); +cellScreenShotUtility.AddFunc (0x7a9c2243, cellScreenShotSetOverlayImage); +} From 6d56f1ae86451e75cbbe0dfcc76122c0f24846e6 Mon Sep 17 00:00:00 2001 From: O1L Date: Wed, 13 Nov 2013 22:35:25 +0400 Subject: [PATCH 3/4] Implemented PKG Installer, improved Boot game. --- rpcs3.sln | 8 + rpcs3/Gui/AboutDialog.cpp | 3 +- rpcs3/Gui/MainFrame.cpp | 51 ++++- rpcs3/Gui/MainFrame.h | 1 + unpkg/oddkeys.h | 20 ++ unpkg/ps3_common.h | 106 ++++++++++ unpkg/unpkg.c | 406 ++++++++++++++++++++++++++++++++++++++ unpkg/unpkg.h | 176 +++++++++++++++++ 8 files changed, 768 insertions(+), 3 deletions(-) create mode 100644 unpkg/oddkeys.h create mode 100644 unpkg/ps3_common.h create mode 100644 unpkg/unpkg.c create mode 100644 unpkg/unpkg.h diff --git a/rpcs3.sln b/rpcs3.sln index 819265aa30..3d5647a6ea 100644 --- a/rpcs3.sln +++ b/rpcs3.sln @@ -95,6 +95,14 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "scetool", "scetool", "{AB33 scetool\zlib.h = scetool\zlib.h EndProjectSection EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "unpkg", "unpkg", "{9F2D2094-BA46-4456-8C45-FD9EC108F1EE}" + ProjectSection(SolutionItems) = preProject + unpkg\oddkeys.h = unpkg\oddkeys.h + unpkg\ps3_common.h = unpkg\ps3_common.h + unpkg\unpkg.c = unpkg\unpkg.c + unpkg\unpkg.h = unpkg\unpkg.h + EndProjectSection +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Win32 = Debug|Win32 diff --git a/rpcs3/Gui/AboutDialog.cpp b/rpcs3/Gui/AboutDialog.cpp index 38ce2abcc7..76a78a3f23 100644 --- a/rpcs3/Gui/AboutDialog.cpp +++ b/rpcs3/Gui/AboutDialog.cpp @@ -47,7 +47,8 @@ AboutDialog::AboutDialog(wxWindow *parent) wxBoxSizer* s_panel_credits(new wxBoxSizer(wxHORIZONTAL)); wxStaticText* t_section1 = new wxStaticText(this, wxID_ANY, "\nDevelopers:\n\nDH\nAlexAltea", wxDefaultPosition, wxSize(156,160)); wxStaticText* t_section2 = new wxStaticText(this, wxID_ANY, "\nThanks:\n\nBlackDaemon", wxDefaultPosition, wxSize(156,160)); - wxStaticText* t_section3 = new wxStaticText(this, wxID_ANY, "\nExternal code:\n\n - SELF Decrypter based on scetool (C) 2011-2013 by naehrwert", wxDefaultPosition, wxSize(156,160)); + wxStaticText* t_section3 = new wxStaticText(this, wxID_ANY, "\nExternal code:\n\n - SELF Decrypter based on scetool (C) 2011-2013 by naehrwert\n\ - PKG Installer based on ps3pkgtool (C) 2011-2013 by avtolstoy and PKG Finalize (C) by geohot", wxDefaultPosition, wxSize(156,160)); + s_panel_credits->AddSpacer(12); s_panel_credits->Add(t_section1); s_panel_credits->AddSpacer(8); diff --git a/rpcs3/Gui/MainFrame.cpp b/rpcs3/Gui/MainFrame.cpp index d46089ac4a..551501fc3c 100644 --- a/rpcs3/Gui/MainFrame.cpp +++ b/rpcs3/Gui/MainFrame.cpp @@ -12,6 +12,7 @@ #include #include "scetool/scetool.cpp" +#include "unpkg/unpkg.c" BEGIN_EVENT_TABLE(MainFrame, FrameBase) EVT_CLOSE(MainFrame::OnQuit) @@ -22,6 +23,7 @@ enum IDs id_boot_elf = 0x555, id_boot_self, id_boot_game, + id_boot_pkg, id_sys_pause, id_sys_stop, id_sys_send_open_menu, @@ -65,6 +67,7 @@ MainFrame::MainFrame() menubar.Append(&menu_help, "Help"); menu_boot.Append(id_boot_game, "Boot game"); + menu_boot.Append(id_boot_pkg, "Install PKG"); menu_boot.AppendSeparator(); menu_boot.Append(id_boot_elf, "Boot ELF"); menu_boot.Append(id_boot_self, "Boot SELF"); @@ -88,6 +91,7 @@ MainFrame::MainFrame() AddPane(m_game_viewer, "Game List", wxAUI_DOCK_BOTTOM); Connect( id_boot_game, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrame::BootGame) ); + Connect( id_boot_pkg, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrame::BootPkg) ); Connect( id_boot_elf, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrame::BootElf) ); Connect( id_boot_self, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(MainFrame::BootSelf) ); @@ -167,9 +171,19 @@ void MainFrame::BootGame(wxCommandEvent& WXUNUSED(event)) { if(wxFile::Access(ctrl.GetPath() + elf[i], wxFile::read)) { - Emu.SetPath(ctrl.GetPath() + elf[i]); - ConLog.Write("Elf: booting..."); + ConLog.Write("SELF: booting..."); + + Emu.Stop(); + + wxString fileIn = ctrl.GetPath()+elf[i]; + wxString fileOut = (ctrl.GetPath()+elf[i])+".elf"; + scetool_decrypt((scetool::s8 *)fileIn.mb_str(), (scetool::s8 *)fileOut.mb_str()); + + Emu.SetPath((ctrl.GetPath()+elf[i])+".elf"); Emu.Load(); + if (!wxRemoveFile((ctrl.GetPath()+elf[i])+".elf")) + ConLog.Warning("Could not delete the decrypted ELF file"); + ConLog.Write("Game: boot done."); return; } @@ -179,6 +193,39 @@ void MainFrame::BootGame(wxCommandEvent& WXUNUSED(event)) return; } + +void MainFrame::BootPkg(wxCommandEvent& WXUNUSED(event)) +{ + bool stopped = false; + + if(Emu.IsRunning()) + { + Emu.Pause(); + stopped = true; + } + + wxFileDialog ctrl (this, L"Select PKG", wxEmptyString, wxEmptyString, "*.*", + wxFD_OPEN | wxFD_FILE_MUST_EXIST); + + if(ctrl.ShowModal() == wxID_CANCEL) + { + if(stopped) Emu.Resume(); + return; + } + + ConLog.Write("PKG: extracting..."); + + Emu.Stop(); + + wxString fileName = ctrl.GetPath(); + pkg_unpack((const char *)fileName.mb_str()); + + if (!wxRemoveFile(ctrl.GetPath()+".dec")) + ConLog.Warning("Could not delete the decoded DEC file"); + + ConLog.Write("PKG: extract done."); +} + void MainFrame::BootElf(wxCommandEvent& WXUNUSED(event)) { bool stopped = false; diff --git a/rpcs3/Gui/MainFrame.h b/rpcs3/Gui/MainFrame.h index 94fdf0e9f2..a8d0bc89a6 100644 --- a/rpcs3/Gui/MainFrame.h +++ b/rpcs3/Gui/MainFrame.h @@ -20,6 +20,7 @@ private: void OnQuit(wxCloseEvent& event); void BootGame(wxCommandEvent& event); + void BootPkg(wxCommandEvent& event); void BootElf(wxCommandEvent& event); void BootSelf(wxCommandEvent& event); void Pause(wxCommandEvent& event); diff --git a/unpkg/oddkeys.h b/unpkg/oddkeys.h new file mode 100644 index 0000000000..9c53edab34 --- /dev/null +++ b/unpkg/oddkeys.h @@ -0,0 +1,20 @@ +#pragma once +#include "stdafx.h" + +u8 retail_pkg_aes_key[] = {0x2E,0x7B,0x71,0xD7,0xC9,0xC9,0xA1,0x4E,0xA3,0x22,0x1F,0x18,0x88,0x28,0xB8,0xF8}; + +u8 npdrm_keypair_e[] = { +0xA1,0xC0,0x13,0xAB,0xCE,0x98,0xA7,0xE3,0xDC,0x69,0x92,0x3B,0x07,0xC0,0x28,0x5F, +0x75,0x54,0xC5,0x12,0xB0,0xB0,0xA9,0x6F,0x24,0x52,0x40,0xF2,0xFD,0x43,0x3A,0xF2, +0x3F,0x4E,0xFE,0xC6,0xC1,0x83,0xEA,0x37,0x8D,0x1B,0xEC,0xB0,0x9D,0x88,0xDB,0x32, +0x8F,0x2C,0x86,0x37,0xB7,0xAC,0x72,0x05,0x9B,0x15,0x56,0xB0,0xD9,0x5B,0x5B,0xE0}; + +u8 npdrm_keypair_d[] = { +0x87,0xC7,0x4F,0xFE,0x66,0x93,0x0B,0xAA,0xA1,0x6F,0x86,0x40,0x91,0xC5,0x66,0xFB, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, +0x08,0x28,0xB5,0x8F,0xAC,0xF9,0xDE,0xC8,0xD7,0x0D,0xFE,0xF0,0xF3,0x76,0x63,0xAE, +0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; + +u8 npdrm_omac_key1[] = {0x72,0xF9,0x90,0x78,0x8F,0x9C,0xFF,0x74,0x57,0x25,0xF0,0x8E,0x4C,0x12,0x83,0x87}; +u8 npdrm_omac_key2[] = {0x6B,0xA5,0x29,0x76,0xEF,0xDA,0x16,0xEF,0x3C,0x33,0x9F,0xB2,0x97,0x1E,0x25,0x6B}; +u8 npdrm_omac_key3[] = {0x9B,0x51,0x5F,0xEA,0xCF,0x75,0x06,0x49,0x81,0xAA,0x60,0x4D,0x91,0xA5,0x4E,0x97}; diff --git a/unpkg/ps3_common.h b/unpkg/ps3_common.h new file mode 100644 index 0000000000..73d8e2185d --- /dev/null +++ b/unpkg/ps3_common.h @@ -0,0 +1,106 @@ +#pragma once +#include "stdafx.h" + +typedef struct { + u32 magic; + u32 debugFlag; + u32 infoOffset; + u32 unknown1; + u32 headSize; + u32 itemCount; + u64 packageSize; + u64 dataOffset; + u64 dataSize; +} pkg_header2; + +u64 get_u64(void* vd) { + u8 *d = (u8*)vd; + return ((u64)d[0]<<56) | ((u64)d[1]<<48) | ((u64)d[2]<<40) | ((u64)d[3]<<32) | (d[4]<<24) | (d[5]<<16) | (d[6]<<8) | d[7]; +} + +void set_u64(void* vd, u64 v) { + u8 *d = (u8*)vd; + d[0] = v>>56; + d[1] = v>>48; + d[2] = v>>40; + d[3] = v>>32; + d[4] = v>>24; + d[5] = v>>16; + d[6] = v>>8; + d[7] = v>>0; +} + +void set_u32(void* vd, u32 v) { + u8 *d = (u8*)vd; + d[0] = v>>24; + d[1] = v>>16; + d[2] = v>>8; + d[3] = v>>0; +} + +void set_u16(void* vd, u16 v) { + u8 *d = (u8*)vd; + d[0] = v>>8; + d[1] = v>>0; +} + +u32 get_u32(void* vd) { + u8 *d = (u8*)vd; + return (d[0]<<24) | (d[1]<<16) | (d[2]<<8) | d[3]; +} + +float get_float(u8* d) { + float ret; + u32 inter = (d[0]<<24) | (d[1]<<16) | (d[2]<<8) | d[3]; + memcpy(&ret, &inter, 4); + return ret; +} + +u32 get_u16(void* vd) { + u8 *d = (u8*)vd; + return (d[0]<<8) | d[1]; +} + +void hexdump(u8* d, int l) { + int i; + for(i=0;i + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + +#include "unpkg.h" +#include "ps3_common.h" +#include "oddkeys.h" + +static void hash_tostring(char *str, u8 *hash, u32 len) +{ + u8 *p; + memset(str, 0, 2*len+1); + for (p = hash; p-hash < len; p++) + { + str += 2; + } +} + +static void *pkg_open(const char *fname) +{ + FILE *f; + + f = fopen(fname, "rb"); + if (f == NULL) + { + ConLog.Error ("UnPkg: Could not open package file!"); + return NULL; + } + + return f; +} + +static int pkg_sanity_check(FILE *f, FILE *g, pkg_header **h_ptr, const char *fname) +{ + pkg_header *header = (pkg_header*)malloc(sizeof(pkg_header)); + u64 tmp; + + if (!fread(header, sizeof(pkg_header), 1, f)) + { + ConLog.Error("UnPkg: Package file is too short!"); + return 1; + } + + // some sanity checks + + if (ntohl(header->magic) != PKG_MAGIC) + { + ConLog.Error("UnPkg: Not a package file!"); + return 1; + } + + switch (ntohl(header->rel_type) >> 16 & (0xffff)) + { + case PKG_RELEASE_TYPE_DEBUG: + { + ConLog.Warning ("UnPkg: Debug PKG detected."); + u8* data; + u8 sha_key[0x40]; + int i; + f= fopen(fname, "rb"); + fseek(f, 0, SEEK_END); + int nlen = ftell(f); + fseek(f, 0, SEEK_SET); + data = (u8*)malloc(nlen); + fread(data, 1, nlen, f); + fclose(f); + + pkg_header2 *header = (pkg_header2 *)data; + int data_offset = get_u64(&(header->dataOffset)); + int data_size = get_u64(&(header->dataSize)); + + // decrypt debug + u8 sha_crap[0x40]; + memset(sha_crap, 0, 0x40); + memcpy(sha_crap, &data[0x60], 8); + memcpy(sha_crap+0x8, &data[0x60], 8); + memcpy(sha_crap+0x10, &data[0x68], 8); + memcpy(sha_crap+0x18, &data[0x68], 8); + + int dptr; + for(dptr = data_offset; dptr < (data_offset+data_size); dptr+=0x10) { + u8 hash[0x14]; + sha1(sha_crap, 0x40, hash); + for(i=0;i<0x10;i++) data[dptr+i] ^= hash[i]; + set_u64(sha_crap+0x38, get_u64(sha_crap+0x38)+1); + } + + // recrypt retail + u8 pkg_key[0x10]; + memcpy(pkg_key, &data[0x70], 0x10); + + //AES_KEY aes_key; + aes_context aes_key; + aes_setkey_enc(&aes_key, retail_pkg_aes_key, 128); + + size_t num=0; u8 ecount_buf[0x10]; memset(ecount_buf, 0, 0x10); + aes_crypt_ctr(&aes_key, data_size, &num, pkg_key, ecount_buf, &data[data_offset], &data[data_offset]); + + // write back + g = fopen(fname, "wb"); + data[4] = 0x80; // set finalize flag + memset(&data[(data_offset+data_size)], 0, 0x60); + + // add hash + sha1(data, nlen-0x20, &data[nlen-0x20]); + fwrite(data, 1, nlen, g); + //fclose(g); // not close the file for continuing + + fseek(g, 0, SEEK_END); + tmp = ftell(g); + } + break; + + + case PKG_RELEASE_TYPE_RELEASE: + { + ConLog.Warning ("UnPkg: Retail PKG detected."); + fseek(f, 0, SEEK_END); + tmp = ftell(f); + } + break; + + default: + ConLog.Error("UnPkg: Unknown release type."); + return 1; + + + } + switch (ntohl(header->rel_type) & (0xffff)) + { + case PKG_PLATFORM_TYPE_PS3: + case PKG_PLATFORM_TYPE_PSP: + break; + + default: + ConLog.Error("UnPkg: Unknown platform type."); + return 1; + } + + if (ntohl(header->header_size) != PKG_HEADER_SIZE) + { + ConLog.Error("UnPkg: Wrong header size: "); + return 1; + } + + //fseek(g, 0, SEEK_END); + //tmp = ftell(g); + if (ntohll(header->pkg_size) != tmp) + { + ConLog.Error("UnPkg: File size mismatch."); + return 1; + } + + tmp -= ntohll(header->data_offset) + 0x60; + if (ntohll(header->data_size) != tmp) + { + ConLog.Error("UnPkg: Data size mismatch."); + return 1; + } + + if (h_ptr != NULL) + { + (*h_ptr) = (pkg_header*) malloc(sizeof(pkg_header)); + memcpy(h_ptr, &header, sizeof(pkg_header*)); + } + + return 0; +} + +static void print_pkg_header(pkg_header *header) +{ + char qa[33], kl[33]; + + if (header == NULL) + return; + + hash_tostring(qa, header->qa_digest, sizeof(header->qa_digest)); + hash_tostring(kl, header->klicensee, sizeof(header->klicensee)); + + ConLog.Write("Magic: %x\n", ntohl(header->magic)); + ConLog.Write("Release Type: %x\n", ntohl(header->rel_type) >> 16 & (0xffff)); + ConLog.Write("Platform Type: %x\n", ntohl(header->rel_type) & (0xffff)); + ConLog.Write("Header size: %x\n", ntohl(header->header_size)); + ConLog.Write("Unk1: %x\n", ntohl(header->unk1)); + ConLog.Write("Metadata size: %x\n", ntohl(header->meta_size)); + ConLog.Write("File count: %u\n", ntohl(header->file_count)); + ConLog.Write("Pkg size: %llu\n", ntohll(header->pkg_size)); + ConLog.Write("Data offset: %llx\n", ntohll(header->data_offset)); + ConLog.Write("Data size: %llu\n", ntohll(header->data_size)); + ConLog.Write("TitleID: %s\n", header->title_id); + ConLog.Write("QA Digest: %s\n", qa); + ConLog.Write( "KLicensee: %s\n", kl); +} + +static void *pkg_info(const char *fname, pkg_header **h_ptr) +{ + FILE *f; + FILE *g; + pkg_header *header; + + f = (FILE*) pkg_open(fname); + if (f == NULL) + return NULL; + + if (pkg_sanity_check(f, g, &header, fname)) + return NULL; + + print_pkg_header(header); + + if (h_ptr != NULL) + { + (*h_ptr) = header; + } + else + { + free(header); + } + + + return f; +} + + +static void pkg_crypt(const u8 *key, const u8 *kl, FILE *f, + u64 len, FILE *out) +{ + aes_context c; + u32 parts, bits; + u32 i, j; + u8 iv[HASH_LEN]; + u8 buf[BUF_SIZE]; + u8 ctr[BUF_SIZE]; + u8 out_buf[BUF_SIZE]; + u32 l; + u64 hi, lo; + + parts = len / BUF_SIZE; + if (len % BUF_SIZE != 0) + parts++; + + memcpy(iv, kl, sizeof(iv)); + aes_setkey_enc(&c, key, 128); + + for (i = 0; iname_offset, SEEK_SET); + + memset(buf, 0, sizeof(buf)); + fread(buf, fentry->name_size, 1, dec); + + switch (fentry->type & (0xffff)) + { + case PKG_FILE_ENTRY_NPDRM: + case PKG_FILE_ENTRY_NPDRMEDAT: + case PKG_FILE_ENTRY_SDAT: + case PKG_FILE_ENTRY_REGULAR: + out = fopen((char *)buf, "wb"); + fseek(dec, fentry->file_offset, SEEK_SET); + for (size = 0; size < fentry->file_size; ) + { + size += fread(buf, sizeof(u8), BUF_SIZE, dec); + if (size > fentry->file_size) + tmp = size - fentry->file_size; + else + tmp = 0; + + fwrite(buf, sizeof(u8), BUF_SIZE - tmp, out); + } + + fclose(out); + break; + + case PKG_FILE_ENTRY_FOLDER: + mkdir ((char *)buf); + break; + } +} + +static void pkg_unpack_data(u32 file_count, FILE *dec) +{ + u32 i; + pkg_file_entry *file_table = NULL; + + fseek(dec, 0, SEEK_SET); + + file_table = (pkg_file_entry *)malloc(sizeof(pkg_file_entry)*file_count); + i = fread(file_table, sizeof(pkg_file_entry), file_count, dec); + + if (ntohl(file_table->name_offset) / sizeof(pkg_file_entry) != file_count) + { + ConLog.Error("UnPkg: ERROR. Impossiburu!"); + return; + } + + for (i = 0; iname_offset = ntohl((file_table+i)->name_offset); + (file_table+i)->name_size = ntohl((file_table+i)->name_size); + (file_table+i)->file_offset = ntohll((file_table+i)->file_offset); + (file_table+i)->file_size = ntohll((file_table+i)->file_size); + (file_table+i)->type = ntohl((file_table+i)->type); + + pkg_unpack_file(file_table+i, dec); + + } + + free(file_table); +} + +static void pkg_unpack(const char *fname) +{ + FILE *f, *dec; + char *dec_fname; + pkg_header *header; + int ret; + struct stat sb; + + f = (FILE*) pkg_info(fname, &header); + + if (f == NULL) + return; + + fseek(f, ntohll(header->data_offset), SEEK_SET); + + dec_fname = (char*)malloc(strlen(fname)+4); + memset(dec_fname, 0, strlen(fname)+4); + sprintf(dec_fname, "%s.dec", fname); + + dec = fopen(dec_fname, "wb+"); + if (dec == NULL) + { + ConLog.Error("UnPkg: Could not create temp file for decrypted data."); + free(header); + return; + } + unlink(dec_fname); + + pkg_crypt(PKG_AES_KEY, header->klicensee, f, ntohll(header->data_size), + dec); + fseek(dec, 0, SEEK_SET); + + fclose(f); + + if (stat(header->title_id, &sb) != 0) + { + ret = mkdir(header->title_id); + if (ret < 0) + { + ConLog.Error("UnPkg: Could not mkdir."); + free(header); + return; + } + } + + chdir(header->title_id); + + pkg_unpack_data(ntohl(header->file_count), dec); + fclose(dec); +} \ No newline at end of file diff --git a/unpkg/unpkg.h b/unpkg/unpkg.h new file mode 100644 index 0000000000..0eb214f1b4 --- /dev/null +++ b/unpkg/unpkg.h @@ -0,0 +1,176 @@ +/* + * Copyright 2011 Andrey Tolstoy + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + */ + + +#ifndef UNPKG_H_ +#define UNPKG_H_ + +#include "stdafx.h" +#include "scetool/aes.h" +#include "scetool/sha1.h" + +#define ntohll(x) (((u64) ntohl (x) << 32) | (u64) ntohl (x >> 32) ) +#define htonll(x) (((u64) htonl (x) << 32) | (u64) htonl (x >> 32) ) +#define conv_ntohl(x) { x = ntohl(x); } +#define conv_ntohll(x) { x = ntohll(x); } +#define conv_htonl(x) { x = htonl(x); } +#define conv_htonll(x) { x = htonll(x); } + +#define unpack32(x) ((u32) ((u32)*(x) << 24 | \ + (u32)*(x+1) << 16 | \ + (u32)*(x+2) << 8 | \ + (u32)*(x+3) << 0)) + +#define unpack64(x) ((u64)unpack32(x) << 32 | (u64)unpack32(x+4)) + +#define pack32(x, p) \ + { \ + *(x) = (u8)(p >> 24); \ + *((x)+1) = (u8)(p >> 16); \ + *((x)+2) = (u8)(p >> 8); \ + *((x)+3) = (u8)(p >> 0); \ + } + +#define pack64(x, p) { pack32((x + 4), p); pack32((x), p >> 32); } + +#define HASH_LEN 16 +#define BUF_SIZE 4096 + +typedef struct { + u32 magic; // magic 0x7f504b47 + u32 rel_type; // release type + u32 header_size; // 0xc0 + u32 unk1; //some pkg version maybe + u32 meta_size; //size of metadata (block after header & hashes) + u32 file_count; // number of files + u64 pkg_size; // pkg size in bytes + u64 data_offset; // encrypted data offset + u64 data_size; // encrypted data size in bytes + char title_id[48]; // title id + u8 qa_digest[16]; // this should be the hash of "files + attribs" + u8 klicensee[16]; // nonce +} pkg_header; + +typedef struct { + u8 hash1[16]; + u8 hash2[16]; + u8 hash3[16]; + u8 hash4[16]; +} pkg_unk_checksum; + +/* + is it in meta or sfo? + # CATEGORY : HG + # BOOTABLE : YES + # VERSION : 01.00 + # APP_VER : 01.00 + # PS3_SYSTEM_VER : 03.0000 + */ + +/* meta hell structure */ +typedef struct { + u32 unk1; + u32 unk2; + u32 drm_type; + u32 unk3; + + u32 unk4; + u32 unk5; + u32 unk6; + u32 unk7; + + u32 unk8; + u32 unk9; + u32 unk10; + u32 unk11; + + u32 data_size; + u32 unk12; + u32 unk13; + u32 packager; + + u8 unk14[64]; +} pkg_meta; + +typedef struct { + u32 name_offset; // file name offset + u32 name_size; // file name size + u64 file_offset; // file offset + u64 file_size; // file size + u32 type; // file type + /* + 0x80000003 - regular file + 0x80000001 - npdrm + 0x80000004 - folder + 0x80000009 - sdat ? + 0x80000002 - npdrm.edat ? + */ + u32 pad; // padding (zeros) +} pkg_file_entry; + +typedef struct { + pkg_file_entry fe; + char *name; + char *path; +} file_table_tr; + +#define PKG_MAGIC 0x7f504b47 // \x7fPKG +#define PKG_HEADER_SIZE sizeof(pkg_header) + sizeof(pkg_unk_checksum) +#define PKG_RELEASE_TYPE_RELEASE 0x8000 +#define PKG_RELEASE_TYPE_DEBUG 0x0000 +#define PKG_PLATFORM_TYPE_PS3 0x0001 +#define PKG_PLATFORM_TYPE_PSP 0x0002 + +#define PKG_FILE_ENTRY_OVERWRITE 0x80000000 +#define PKG_FILE_ENTRY_NPDRM 0x0001 +#define PKG_FILE_ENTRY_NPDRMEDAT 0x0002 // npdrm.edat +#define PKG_FILE_ENTRY_REGULAR 0x0003 +#define PKG_FILE_ENTRY_FOLDER 0x0004 +#define PKG_FILE_ENTRY_SDAT 0x0009 // .sdat ? + +static const u8 PKG_AES_KEY[16] = { + 0x2e, 0x7b, 0x71, 0xd7, + 0xc9, 0xc9, 0xa1, 0x4e, + 0xa3, 0x22, 0x1f, 0x18, + 0x88, 0x28, 0xb8, 0xf8 +}; + +static void hash_tostring(char *str, u8 *hash, u32 len); + +static void *pkg_open(const char *fname); + +static int pkg_sanity_check(FILE *f, FILE *g, pkg_header **h_ptr, const char *fname); + +static void print_pkg_header(pkg_header *header); + +static void *pkg_info(const char *fname, pkg_header **h_ptr); + +static void pkg_crypt(const u8 *key, const u8 *kl, FILE *f, + u64 len, FILE *out); + +static void pkg_unpack(const char *fname); + +static void pkg_unpack_data(u32 file_count, FILE *dec); + +static void pkg_unpack_file(pkg_file_entry *fentry, FILE *dec);; + +static int pkg_pack_data(file_table_tr *ftr, pkg_file_entry *table, + int file_count, sha1_context *ctx, FILE *out); + + +static void *pkg_pack_create_filetable(file_table_tr *tr, int file_count, + char **n_table, u32 *n_table_len); + +#endif From b1caa5f9c403af4f59243c15177bf5586dc0f8a9 Mon Sep 17 00:00:00 2001 From: O1L Date: Wed, 13 Nov 2013 23:43:44 +0400 Subject: [PATCH 4/4] Fixed errors from previous commit. Sorry. --- rpcs3/Emu/SysCalls/Modules/cellAudio.cpp | 658 ----------------------- rpcs3/rpcs3.vcxproj | 354 ------------ rpcs3/rpcs3.vcxproj.filters | 483 ----------------- unpkg/unpkg.c | 5 +- 4 files changed, 2 insertions(+), 1498 deletions(-) diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp index 1787456e3a..1c72cbcae2 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp @@ -2,75 +2,6 @@ #include "Emu/SysCalls/SysCalls.h" #include "Emu/SysCalls/SC_FUNC.h" -<<<<<<< HEAD - -// Initialization and Termination Functions; - -void cellAudio_init (); -Module cellAudio (0x0011, cellAudio_init); - -enum -{ -//libaudio ERROR_CODES -CELL_AUDIO_ERROR_ALREADY_INIT = 0x80310701, -CELL_AUDIO_ERROR_AUDIOSYSTEM = 0x80310702, -CELL_AUDIO_ERROR_NOT_INIT = 0x80310703, -CELL_AUDIO_ERROR_PARAM = 0x80310704, -CELL_AUDIO_ERROR_PORT_FULL = 0x80310705, -CELL_AUDIO_ERROR_PORT_ALREADY_RUN = 0x80310706, -CELL_AUDIO_ERROR_PORT_NOT_OPEN = 0x80310707, -CELL_AUDIO_ERROR_PORT_NOT_RUN = 0x80310708, -CELL_AUDIO_ERROR_TRANS_EVENT = 0x80310709, -CELL_AUDIO_ERROR_PORT_OPEN = 0x8031070a, -CELL_AUDIO_ERROR_SHAREDMEMORY = 0x8031070b, -CELL_AUDIO_ERROR_MUTEX = 0x8031070c, -CELL_AUDIO_ERROR_EVENT_QUEUE = 0x8031070d, -CELL_AUDIO_ERROR_AUDIOSYSTEM_NOT_FOUND = 0x8031070e, -CELL_AUDIO_ERROR_TAG_NOT_FOUND = 0x8031070f, - -//libmixer ERROR_CODES -CELL_LIBMIXER_ERROR_NOT_INITIALIZED = 0x80310002, -CELL_LIBMIXER_ERROR_INVALID_PARAMATER = 0x80310003, -CELL_LIBMIXER_ERROR_NO_MEMORY = 0x80310005, -CELL_LIBMIXER_ERROR_ALREADY_EXIST = 0x80310006, -CELL_LIBMIXER_ERROR_FULL = 0x80310007, -CELL_LIBMIXER_ERROR_NOT_EXIST = 0x80310008, -CELL_LIBMIXER_ERROR_TYPE_MISMATCH = 0x80310009, -CELL_LIBMIXER_ERROR_NOT_FOUND = 0x8031000a, - -//libsnd3 ERROR_CODES -CELL_SND3_ERROR_PARAM = 0x80310301, -CELL_SND3_ERROR_CREATE_MUTEX = 0x80310302, -CELL_SND3_ERROR_SYNTH = 0x80310303, -CELL_SND3_ERROR_ALREADY = 0x80310304, -CELL_SND3_ERROR_NOTINIT = 0x80310305, -CELL_SND3_ERROR_SMFFULL = 0x80310306, -CELL_SND3_ERROR_HD3ID = 0x80310307, -CELL_SND3_ERROR_SMF = 0x80310308, -CELL_SND3_ERROR_SMFCTX = 0x80310309, -CELL_SND3_ERROR_FORMAT = 0x8031030a, -CELL_SND3_ERROR_SMFID = 0x8031030b, -CELL_SND3_ERROR_SOUNDDATAFULL = 0x8031030c, -CELL_SND3_ERROR_VOICENUM = 0x8031030d, -CELL_SND3_ERROR_RESERVEDVOICE = 0x8031030e, -CELL_SND3_ERROR_REQUESTQUEFULL = 0x8031030f, -CELL_SND3_ERROR_OUTPUTMODE = 0x80310310, - -//libsynt2 EROR_CODES -CELL_SOUND_SYNTH2_ERROR_FATAL = 0x80310201, -CELL_SOUND_SYNTH2_ERROR_INVALID_PARAMETER = 0x80310202, -CELL_SOUND_SYNTH2_ERROR_ALREADY_INITIALIZED = 0x80310203, -}; - - -//libaudio datatyps -struct CellAudioPortParam -{ -u64 nChannel; -u64 nBlock; -u64 attr; -float level; -======= void cellAudio_init(); Module cellAudio(0x0011, cellAudio_init); @@ -135,68 +66,32 @@ struct CellAudioPortParam u64 nBlock; u64 attr; float level; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellAudioPortConfig { -<<<<<<< HEAD -u32 readIndexAddr; -u32 status; -u64 nChannel; -u64 nBlock; -u32 portSize; -u32 portAddr; -======= u32 readIndexAddr; u32 status; u64 nChannel; u64 nBlock; u32 portSize; u32 portAddr; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; CellAudioPortParam current_AudioPortParam; CellAudioPortConfig current_AudioPortConfig; //libmixer datatypes -<<<<<<< HEAD - -typedef void * CellAANHandle; - - -struct CellSSPlayerConfig -{ -u32 channels; -u32 outputMode; -======= typedef void * CellAANHandle; struct CellSSPlayerConfig { u32 channels; u32 outputMode; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSSPlayerWaveParam { -<<<<<<< HEAD -void *addr; -int format; -u32 samples; -u32 loopStartOffset; -u32 startOffset; -}; - -CellSSPlayerWaveParam current_SSPlayerWaveParam; - -struct CellSSPlayerCommonParam -{ -u32 loopMode; -u32 attackMode; -======= void *addr; int format; u32 samples; @@ -208,69 +103,33 @@ struct CellSSPlayerCommonParam { u32 loopMode; u32 attackMode; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSurMixerPosition { -<<<<<<< HEAD -float x; -float y; -float z; -======= float x; float y; float z; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSSPlayerRuntimeInfo { -<<<<<<< HEAD -float level; -float speed; -CellSurMixerPosition position; -======= float level; float speed; CellSurMixerPosition position; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSurMixerConfig { -<<<<<<< HEAD -s32 priority; -u32 chStrips1; -u32 chStrips2; -u32 chStrips6; -u32 chStrips8; -======= s32 priority; u32 chStrips1; u32 chStrips2; u32 chStrips6; u32 chStrips8; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSurMixerChStripParam { -<<<<<<< HEAD -u32 param; -void *attribute; -int dBSwitch; -float floatVal; -int intVal; -}; - - -//libsnd3 datatypes - -struct CellSnd3DataCtx -{ -s8 system; //[CELL_SND3_DATA_CTX_SIZE], unknown identifier -======= u32 param; void *attribute; int dBSwitch; @@ -284,74 +143,37 @@ CellSSPlayerWaveParam current_SSPlayerWaveParam; struct CellSnd3DataCtx { s8 system; //[CELL_SND3_DATA_CTX_SIZE], unknown identifier ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSnd3SmfCtx { -<<<<<<< HEAD -s8 system; //[CELL_SND3_SMF_CTX_SIZE], unknown identifier -======= s8 system; //[CELL_SND3_SMF_CTX_SIZE], unknown identifier ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSnd3KeyOnParam { -<<<<<<< HEAD -u8 vel; -u8 pan; -u8 panEx; -s32 addPitch; -======= u8 vel; u8 pan; u8 panEx; s32 addPitch; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSnd3VoiceBitCtx { -<<<<<<< HEAD -u32 core; //[CELL_SND3_MAX_CORE], unknown identifier -======= u32 core; //[CELL_SND3_MAX_CORE], unknown identifier ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; struct CellSnd3RequestQueueCtx { -<<<<<<< HEAD -void *frontQueue; -u32 frontQueueSize; -void *rearQueue; -u32 rearQueueSize; -======= void *frontQueue; u32 frontQueueSize; void *rearQueue; u32 rearQueueSize; ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa }; //libsynt2 datatypes struct CellSoundSynth2EffectAttr { -<<<<<<< HEAD -u16 core; -u16 mode; -s16 depth_L; -s16 depth_R; -u16 delay; -u16 feedback; -}; - - //*libaudio functions*// - -bool g_is_audio_initialized = false; -int cellAudioInit (void) -======= u16 core; u16 mode; s16 depth_L; @@ -364,7 +186,6 @@ int cellAudioInit (void) bool g_is_audio_initialized = false; int cellAudioInit() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if(g_is_audio_initialized) return CELL_AUDIO_ERROR_ALREADY_INIT; @@ -372,11 +193,7 @@ int cellAudioInit() return CELL_OK; } -<<<<<<< HEAD -s32 cellAudioQuit(void) -======= int cellAudioQuit() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if (g_is_audio_initialized) return CELL_AUDIO_ERROR_NOT_INIT; @@ -385,16 +202,10 @@ int cellAudioQuit() } // Audio Ports Setting/Operation Functions -<<<<<<< HEAD - -bool g_is_audio_port_open = false; -int cellAudioPortOpen () //CellAudioPortParam *audioParam, u32 *portNum -======= bool g_is_audio_port_open = false; bool g_is_audio_port_start = false; int cellAudioPortOpen() //CellAudioPortParam *audioParam, u32 *portNum ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if(g_is_audio_port_open) return CELL_AUDIO_ERROR_PORT_OPEN; @@ -402,11 +213,7 @@ int cellAudioPortOpen() //CellAudioPortParam *audioParam, u32 *portNum return CELL_OK; } -<<<<<<< HEAD -int cellAudioPortClose (u32 portNum) -======= int cellAudioPortClose(u32 portNum) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if(g_is_audio_port_open) return CELL_AUDIO_ERROR_PORT_NOT_OPEN; @@ -414,12 +221,7 @@ int cellAudioPortClose(u32 portNum) return CELL_OK; } -<<<<<<< HEAD -bool g_is_audio_port_start = false; -int cellAudioPortStart (u32 portNum) -======= int cellAudioPortStart(u32 portNum) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if(g_is_audio_port_start) return CELL_AUDIO_ERROR_PORT_ALREADY_RUN; @@ -427,11 +229,7 @@ int cellAudioPortStart(u32 portNum) return CELL_OK; } -<<<<<<< HEAD -int cellAudioPortStop (u32 portNum) -======= int cellAudioPortStop(u32 portNum) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); if(g_is_audio_port_start) return CELL_AUDIO_ERROR_PORT_NOT_RUN; @@ -439,174 +237,104 @@ int cellAudioPortStop(u32 portNum) return CELL_OK; } -<<<<<<< HEAD -int cellAudioGetPortTimestamp () //u32 portNum, u64 tag, u64 *stamp -======= int cellAudioGetPortTimestamp() //u32 portNum, u64 tag, u64 *stamp ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioGetPortConfig () //u32 portNum, CellAudioPortConfig *portConfig -======= int cellAudioGetPortConfig() //u32 portNum, CellAudioPortConfig *portConfig ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioGetPortBlockTag () //u32 portNum, u64 blockNo, u64 *tag -======= int cellAudioGetPortBlockTag() //u32 portNum, u64 blockNo, u64 *tag ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC (cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioSetPortLevel (u32 portNum, float level) -======= int cellAudioSetPortLevel(u32 portNum, float level) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD - -// Utility Functions -int cellAudioCreateNotifyEventQueue () //u32 *id, u64 *key -======= // Utility Functions int cellAudioCreateNotifyEventQueue() //u32 *id, u64 *key ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioCreateNotifyEventQueueEx (u32 *id, u64 *key, u32 iFlags) -======= int cellAudioCreateNotifyEventQueueEx(u32 *id, u64 *key, u32 iFlags) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioSetNotifyEventQueue (u64 key) -======= int cellAudioSetNotifyEventQueue(u64 key) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioSetNotifyEventQueueEx (u64 key, u32 iFlags) -======= int cellAudioSetNotifyEventQueueEx(u64 key, u32 iFlags) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioRemoveNotifyEventQueue (u64 key) -======= int cellAudioRemoveNotifyEventQueue(u64 key) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioRemoveNotifyEventQueueEx (u64 key, u32 iFlags) -======= int cellAudioRemoveNotifyEventQueueEx(u64 key, u32 iFlags) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioAddData () //u32 portNum, float *src, unsigned int samples, float volume -======= int cellAudioAddData() //u32 portNum, float *src, unsigned int samples, float volume ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioAdd2chData () //u32 portNum, float *src, unsigned int samples, float volume -======= int cellAudioAdd2chData() //u32 portNum, float *src, unsigned int samples, float volume ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioMiscSetAccessoryVolume (u32 devNum, float volume) -======= int cellAudioMiscSetAccessoryVolume(u32 devNum, float volume) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioSendAck (u64 data3) -======= int cellAudioSendAck(u64 data3) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioSetPersonalDevice (int iPersonalStream, int iDevice) -======= int cellAudioSetPersonalDevice(int iPersonalStream, int iDevice) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioUnsetPersonalDevice (int iPersonalStream) -======= int cellAudioUnsetPersonalDevice(int iPersonalStream) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -int cellAudioAdd6chData (u32 portNum, float *src, float volume) -======= int cellAudioAdd6chData(u32 portNum, float *src, float volume) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -615,197 +343,116 @@ int cellAudioAdd6chData(u32 portNum, float *src, float volume) //Callback Functions typedef int (*CellSurMixerNotifyCallbackFunction)(void *arg, u32 counter, u32 samples); //Currently unused. -<<<<<<< HEAD - - - //*libmixer Functions, NON active in this moment*// - - -int cellAANConnect (CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) -======= // libmixer Functions, NOT active in this moment int cellAANConnect(CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellAANDisconnect (CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) -======= int cellAANDisconnect(CellAANHandle receive, u32 receivePortNo, CellAANHandle source, u32 sourcePortNo) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellAANAddData (CellAANHandle handle, u32 port, u32 offset, float *addr, u32 samples) -======= int cellAANAddData(CellAANHandle handle, u32 port, u32 offset, float *addr, u32 samples) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerCreate (CellAANHandle *handle, CellSSPlayerConfig *config) -======= int cellSSPlayerCreate(CellAANHandle *handle, CellSSPlayerConfig *config) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerRemove (CellAANHandle handle) -======= int cellSSPlayerRemove(CellAANHandle handle) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerSetWave () //CellAANHandle handle, CellSSPlayerWaveParam *waveInfo, CellSSPlayerCommonParam *commonInfo //mem_class_t waveInfo -======= int cellSSPlayerSetWave() //CellAANHandle handle, CellSSPlayerWaveParam *waveInfo, CellSSPlayerCommonParam *commonInfo //mem_class_t waveInfo ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerPlay () //CellAANHandle handle, CellSSPlayerRuntimeInfo *info -======= int cellSSPlayerPlay() //CellAANHandle handle, CellSSPlayerRuntimeInfo *info ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerStop () //CellAANHandle handle, u32 mode -======= int cellSSPlayerStop() //CellAANHandle handle, u32 mode ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSSPlayerSetParam () //CellAANHandle handle, CellSSPlayerRuntimeInfo *info -======= int cellSSPlayerSetParam() //CellAANHandle handle, CellSSPlayerRuntimeInfo *info ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -s32 cellSSPlayerGetState () //CellAANHandle handle -======= s32 cellSSPlayerGetState() //CellAANHandle handle ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerCreate () //const CellSurMixerConfig *config -======= int cellSurMixerCreate() //const CellSurMixerConfig *config ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerGetAANHandle () //CellAANHandle *handle -======= int cellSurMixerGetAANHandle() //CellAANHandle *handle ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerChStripGetAANPortNo () //u32 *port, u32 type, u32 index -======= int cellSurMixerChStripGetAANPortNo() //u32 *port, u32 type, u32 index ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerSetNotifyCallback () //CellSurMixerNotifyCallbackFunction callback, void *arg -======= int cellSurMixerSetNotifyCallback() //CellSurMixerNotifyCallbackFunction callback, void *arg ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerRemoveNotifyCallback () //CellSurMixerNotifyCallbackFunction callback -======= int cellSurMixerRemoveNotifyCallback() //CellSurMixerNotifyCallbackFunction callback ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerStart(void) -======= int cellSurMixerStart() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerSurBusAddData () //u32 busNo, u32 offset, float *addr, u32 samples -======= int cellSurMixerSurBusAddData() //u32 busNo, u32 offset, float *addr, u32 samples ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerSetParameter () //u32 param, float value -======= int cellSurMixerSetParameter() //u32 param, float value ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerChStripSetParameter () //u32 type, u32 index, CellSurMixerChStripParam *param -======= int cellSurMixerChStripSetParameter() //u32 type, u32 index, CellSurMixerChStripParam *param ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; @@ -817,210 +464,127 @@ int cellSurMixerPause() //u32 switch return 0; } -<<<<<<< HEAD -int cellSurMixerGetCurrentBlockTag () //u64 *tag -======= int cellSurMixerGetCurrentBlockTag() //u64 *tag ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -int cellSurMixerGetTimestamp () //u64 tag, u64 *stamp -======= int cellSurMixerGetTimestamp() //u64 tag, u64 *stamp ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -void cellSurMixerBeep (); //void *arg - -float cellSurMixerUtilGetLevelFromDB () //float dB -======= void cellSurMixerBeep(); //void *arg float cellSurMixerUtilGetLevelFromDB() //float dB ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO; } -<<<<<<< HEAD -float cellSurMixerUtilGetLevelFromDBIndex () //int index -======= float cellSurMixerUtilGetLevelFromDBIndex() //int index ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO; } -<<<<<<< HEAD -float cellSurMixerUtilNoteToRatio () //unsigned char refNote, unsigned char note -======= float cellSurMixerUtilNoteToRatio() //unsigned char refNote, unsigned char note ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -int cellSurMixerFinalize(void); //Currently unused. Returns 0 (in the current release). - - - //*libsnd3 Functions, NON active in this moment*// - -s32 cellSnd3Init () //u32 maxVoice, u32 samples, CellSnd3RequestQueueCtx *queue -======= int cellSurMixerFinalize(); //Currently unused. Returns 0 (in the current release). //*libsnd3 Functions, NOT active in this moment s32 cellSnd3Init() //u32 maxVoice, u32 samples, CellSnd3RequestQueueCtx *queue ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3Exit (void) -======= s32 cellSnd3Exit() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SetOutputMode () //u32 mode -======= s32 cellSnd3SetOutputMode() //u32 mode ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3Synthesis () //float *pOutL, float *pOutR -======= s32 cellSnd3Synthesis() //float *pOutL, float *pOutR ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SynthesisEx () //float *pOutL, float *pOutR, float *pOutRL, float *pOutRR -======= s32 cellSnd3SynthesisEx() //float *pOutL, float *pOutR, float *pOutRL, float *pOutRR ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceSetReserveMode () //u32 voiceNum, u32 reserveMode -======= s32 cellSnd3VoiceSetReserveMode() //u32 voiceNum, u32 reserveMode ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3BindSoundData () //CellSnd3DataCtx *snd3Ctx, void *hd3, u32 synthMemOffset -======= s32 cellSnd3BindSoundData() //CellSnd3DataCtx *snd3Ctx, void *hd3, u32 synthMemOffset ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3UnbindSoundData (u32 hd3ID) -======= s32 cellSnd3UnbindSoundData(u32 hd3ID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3NoteOnByTone () //u32 hd3ID, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam -======= s32 cellSnd3NoteOnByTone() //u32 hd3ID, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3KeyOnByTone () //u32 hd3ID, u32 toneIndex, u32 pitch,u32 keyOnID,CellSnd3KeyOnParam *keyOnParam -======= s32 cellSnd3KeyOnByTone() //u32 hd3ID, u32 toneIndex, u32 pitch,u32 keyOnID,CellSnd3KeyOnParam *keyOnParam ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3VoiceNoteOnByTone () //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam -======= s32 cellSnd3VoiceNoteOnByTone() //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 note, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3VoiceKeyOnByTone () //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 pitch, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam -======= s32 cellSnd3VoiceKeyOnByTone() //u32 hd3ID, u32 voiceNum, u32 toneIndex, u32 pitch, u32 keyOnID, CellSnd3KeyOnParam *keyOnParam ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3VoiceSetSustainHold (u32 voiceNum, u32 sustainHold) -======= s32 cellSnd3VoiceSetSustainHold(u32 voiceNum, u32 sustainHold) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceKeyOff (u32 voiceNum) -======= s32 cellSnd3VoiceKeyOff(u32 voiceNum) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -1032,361 +596,221 @@ s32 cellSnd3VoiceSetPitch(u32 voiceNum, s32 addPitch) return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceSetVelocity (u32 voiceNum, u32 velocity) -======= s32 cellSnd3VoiceSetVelocity(u32 voiceNum, u32 velocity) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceSetPanpot (u32 voiceNum, u32 panpot) -======= s32 cellSnd3VoiceSetPanpot(u32 voiceNum, u32 panpot) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceSetPanpotEx (u32 voiceNum, u32 panpotEx) -======= s32 cellSnd3VoiceSetPanpotEx(u32 voiceNum, u32 panpotEx) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceSetPitchBend (u32 voiceNum, u32 bendValue) -======= s32 cellSnd3VoiceSetPitchBend(u32 voiceNum, u32 bendValue) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceAllKeyOff (void) -======= s32 cellSnd3VoiceAllKeyOff() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceGetEnvelope (u32 voiceNum) -======= s32 cellSnd3VoiceGetEnvelope(u32 voiceNum) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3VoiceGetStatus () //u32 voiceNum -======= s32 cellSnd3VoiceGetStatus() //u32 voiceNum ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -u32 cellSnd3KeyOffByID (u32 keyOnID) -======= u32 cellSnd3KeyOffByID(u32 keyOnID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3GetVoice () //u32 midiChannel, u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit -======= s32 cellSnd3GetVoice() //u32 midiChannel, u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3GetVoiceByID () //u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit -======= s32 cellSnd3GetVoiceByID() //u32 keyOnID, CellSnd3VoiceBitCtx *voiceBit ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3NoteOn () //u32 hd3ID, u32 midiChannel, u32 midiProgram, u32 midiNote, u32 sustain,CellSnd3KeyOnParam *keyOnParam, u32 keyOnID -======= s32 cellSnd3NoteOn() //u32 hd3ID, u32 midiChannel, u32 midiProgram, u32 midiNote, u32 sustain,CellSnd3KeyOnParam *keyOnParam, u32 keyOnID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3NoteOff (u32 midiChannel, u32 midiNote, u32 keyOnID) -======= s32 cellSnd3NoteOff(u32 midiChannel, u32 midiNote, u32 keyOnID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SetSustainHold (u32 midiChannel, u32 sustainHold, u32 ID) -======= s32 cellSnd3SetSustainHold(u32 midiChannel, u32 sustainHold, u32 ID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SetEffectType (u16 effectType, s16 returnVol, u16 delay, u16 feedback) -======= s32 cellSnd3SetEffectType(u16 effectType, s16 returnVol, u16 delay, u16 feedback) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -u16 cellSnd3Note2Pitch () //u16 center_note, u16 center_fine, u16 note, s16 fine -======= u16 cellSnd3Note2Pitch() //u16 center_note, u16 center_fine, u16 note, s16 fine ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -u16 cellSnd3Pitch2Note () //u16 center_note, u16 center_fine, u16 pitch -======= u16 cellSnd3Pitch2Note() //u16 center_note, u16 center_fine, u16 pitch ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFBind () //CellSnd3SmfCtx *smfCtx, void *smf, u32 hd3ID -======= s32 cellSnd3SMFBind() //CellSnd3SmfCtx *smfCtx, void *smf, u32 hd3ID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFUnbind () //u32 smfID -======= s32 cellSnd3SMFUnbind() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFPlay (u32 smfID, u32 playVelocity, u32 playPan, u32 playCount) -======= s32 cellSnd3SMFPlay(u32 smfID, u32 playVelocity, u32 playPan, u32 playCount) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFPlayEx (u32 smfID, u32 playVelocity, u32 playPan, u32 playPanEx, u32 playCount) -======= s32 cellSnd3SMFPlayEx(u32 smfID, u32 playVelocity, u32 playPan, u32 playPanEx, u32 playCount) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFPause (u32 smfID) -======= s32 cellSnd3SMFPause(u32 smfID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFResume (u32 smfID) -======= s32 cellSnd3SMFResume(u32 smfID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFStop (u32 smfID) -======= s32 cellSnd3SMFStop(u32 smfID) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFAddTempo (u32 smfID, s32 addTempo) -======= s32 cellSnd3SMFAddTempo(u32 smfID, s32 addTempo) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFGetTempo () //u32 smfID -======= s32 cellSnd3SMFGetTempo() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFSetPlayVelocity (u32 smfID, u32 playVelocity) -======= s32 cellSnd3SMFSetPlayVelocity(u32 smfID, u32 playVelocity) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFGetPlayVelocity () //u32 smfID -======= s32 cellSnd3SMFGetPlayVelocity() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFSetPlayPanpot (u32 smfID, u32 playPanpot) -======= s32 cellSnd3SMFSetPlayPanpot(u32 smfID, u32 playPanpot) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFSetPlayPanpotEx (u32 smfID, u32 playPanpotEx) -======= s32 cellSnd3SMFSetPlayPanpotEx(u32 smfID, u32 playPanpotEx) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFGetPlayPanpot () //u32 smfID -======= s32 cellSnd3SMFGetPlayPanpot() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFGetPlayPanpotEx () //u32 smfID -======= s32 cellSnd3SMFGetPlayPanpotEx() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFGetPlayStatus () //u32 smfID -======= s32 cellSnd3SMFGetPlayStatus() //u32 smfID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSnd3SMFSetPlayChannel (u32 smfID, u32 playChannelBit) -======= s32 cellSnd3SMFSetPlayChannel(u32 smfID, u32 playChannelBit) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFGetPlayChannel () //u32 smfID, u32 *playChannelBit -======= s32 cellSnd3SMFGetPlayChannel() //u32 smfID, u32 *playChannelBit ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; } -<<<<<<< HEAD -s32 cellSnd3SMFGetKeyOnID () //u32 smfID, u32 midiChannel, u32 *keyOnID -======= s32 cellSnd3SMFGetKeyOnID() //u32 smfID, u32 midiChannel, u32 *keyOnID ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; @@ -1394,11 +818,7 @@ s32 cellSnd3SMFGetKeyOnID() //u32 smfID, u32 midiChannel, u32 *keyOnID //*libsynth2 Functions, NON active in this moment*// -<<<<<<< HEAD -s32 cellSoundSynth2Config (s16 param, s32 value) -======= s32 cellSoundSynth2Config(s16 param, s32 value) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; @@ -1410,145 +830,89 @@ s32 cellSoundSynth2Init( s16 flag) return 0; } -<<<<<<< HEAD -s32 cellSoundSynth2Exit(void) -======= s32 cellSoundSynth2Exit() ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -void cellSoundSynth2SetParam (u16 register, u16 value) -======= void cellSoundSynth2SetParam(u16 register, u16 value) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -<<<<<<< HEAD -u16 cellSoundSynth2GetParam () //u16 register -======= u16 cellSoundSynth2GetParam() //u16 register ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -void cellSoundSynth2SetSwitch (u16 register, u32 value) -======= void cellSoundSynth2SetSwitch(u16 register, u32 value) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -<<<<<<< HEAD -u32 cellSoundSynth2GetSwitch () //u16 register -======= u32 cellSoundSynth2GetSwitch() //u16 register ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -u32 cellSoundSynth2SetAddr (u16 register, u32 value) -======= u32 cellSoundSynth2SetAddr(u16 register, u32 value) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -u32 cellSoundSynth2GetAddr () //u16 register -======= u32 cellSoundSynth2GetAddr() //u16 register ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -s32 cellSoundSynth2SetEffectAttr () //s16 bus, CellSoundSynth2EffectAttr *attr -======= s32 cellSoundSynth2SetEffectAttr() //s16 bus, CellSoundSynth2EffectAttr *attr ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -s32 cellSoundSynth2SetEffectMode () //s16 bus, CellSoundSynth2EffectAttr *attr -======= s32 cellSoundSynth2SetEffectMode() //s16 bus, CellSoundSynth2EffectAttr *attr ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -void cellSoundSynth2SetCoreAttr (u16 entry, u16 value) -======= void cellSoundSynth2SetCoreAttr(u16 entry, u16 value) ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); //TODO } -<<<<<<< HEAD -s32 cellSoundSynth2Generate () //u16 samples, float *left_buffer, float *right_buffer, float *left_rear, float *right_rear -======= s32 cellSoundSynth2Generate() //u16 samples, float *left_buffer, float *right_buffer, float *left_rear, float *right_rear ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -s32 cellSoundSynth2VoiceTrans () //s16 channel, u16 mode, u8 *m_addr, u32 s_addr, u32 size -======= s32 cellSoundSynth2VoiceTrans() //s16 channel, u16 mode, u8 *m_addr, u32 s_addr, u32 size ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return 0; } -<<<<<<< HEAD -u16 cellSoundSynth2Note2Pitch () //u16 center_note, u16 center_fine, u16 note, s16 fine -======= u16 cellSoundSynth2Note2Pitch() //u16 center_note, u16 center_fine, u16 note, s16 fine ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value //TODO } -<<<<<<< HEAD -u16 cellSoundSynth2Pitch2Note () //u16 center_note, u16 center_fine, u16 pitch -======= u16 cellSoundSynth2Pitch2Note() //u16 center_note, u16 center_fine, u16 pitch ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa { UNIMPLEMENTED_FUNC(cellAudio); return CELL_OK; //it's NOT real value @@ -1556,27 +920,6 @@ u16 cellSoundSynth2Pitch2Note() //u16 center_note, u16 center_fine, u16 pitch } -<<<<<<< HEAD -void cellAudio_init () -{ -cellAudio.AddFunc (0x0b168f92, cellAudioInit); -cellAudio.AddFunc (0x4129fe2d, cellAudioPortClose); -cellAudio.AddFunc (0x5b1e2c73, cellAudioPortStop); -cellAudio.AddFunc (0x74a66af0, cellAudioGetPortConfig); -cellAudio.AddFunc (0x89be28f2, cellAudioPortStart); -cellAudio.AddFunc (0xca5ac370, cellAudioQuit); -cellAudio.AddFunc (0xcd7bc431, cellAudioPortOpen); -cellAudio.AddFunc (0x56dfe179, cellAudioSetPortLevel); -cellAudio.AddFunc (0x04af134e, cellAudioCreateNotifyEventQueue); -cellAudio.AddFunc (0x31211f6b, cellAudioMiscSetAccessoryVolume); -cellAudio.AddFunc (0x377e0cd9, cellAudioSetNotifyEventQueue); -cellAudio.AddFunc (0x4109d08c, cellAudioGetPortTimestamp); -cellAudio.AddFunc (0x9e4b1db8, cellAudioAdd2chData); -cellAudio.AddFunc (0xdab029aa, cellAudioAddData); -cellAudio.AddFunc (0xe4046afe, cellAudioGetPortBlockTag); -cellAudio.AddFunc (0xff3626fd, cellAudioRemoveNotifyEventQueue); -//TODO: Find addresses for libmixer, libsnd3 and libsynth2 functions -======= void cellAudio_init() { cellAudio.AddFunc(0x0b168f92, cellAudioInit); @@ -1597,5 +940,4 @@ void cellAudio_init() cellAudio.AddFunc(0xff3626fd, cellAudioRemoveNotifyEventQueue); //TODO: Find addresses for libmixer, libsnd3 and libsynth2 functions ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa } diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj index 6e49bcdbd9..69f59aa20c 100644 --- a/rpcs3/rpcs3.vcxproj +++ b/rpcs3/rpcs3.vcxproj @@ -1,356 +1,3 @@ -<<<<<<< HEAD - - - - - Debug - Win32 - - - Debug - x64 - - - Release - Win32 - - - Release - x64 - - - - {70CD65B0-91D6-4FAE-9A7B-4AF55D0D1B12} - Win32Proj - rpcs3 - - - - Application - true - MultiByte - v110 - - - Application - true - MultiByte - v110 - - - Application - false - true - MultiByte - v110 - false - - - Application - false - true - MultiByte - v110 - false - - - - - - - - - - - - - - - - - - - .\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;$(IncludePath) - $(SolutionDir)bin\ - ..\libs\$(Configuration)\;$(LibraryPath) - $(ProjectName)-$(PlatformShortName)-dbg - - - .\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;$(IncludePath) - $(SolutionDir)bin\ - ..\libs\$(Configuration)\;$(LibraryPath) - $(ProjectName)-$(PlatformShortName)-dbg - - - false - .\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;$(IncludePath) - $(SolutionDir)bin\ - ..\libs\$(Configuration)\;$(LibraryPath) - false - false - $(ProjectName)-$(PlatformShortName) - - - false - .\;..\wxWidgets\include;..\SDL-1.3.0-5538\include;..\SDL_image-1.2.10;..\pthreads-2.8.0;..\;$(IncludePath) - $(SolutionDir)bin\ - ..\libs\$(Configuration)\;$(LibraryPath) - false - false - $(ProjectName)-$(PlatformShortName) - - - - Level3 - Disabled - EditAndContinue - Use - - - true - adv.lib;base.lib;core.lib;aui.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;%(AdditionalDependencies) - %(IgnoreSpecificDefaultLibraries) - - - - - - - - - Level3 - Disabled - ProgramDatabase - Use - - - true - adv.lib;base.lib;core.lib;aui.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;%(AdditionalDependencies) - %(IgnoreSpecificDefaultLibraries) - - - $(SolutionDir)\Utilities\git-version-gen.cmd - - - - - Level3 - Full - true - true - - - MultiThreadedDLL - WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) - false - Use - Speed - Sync - false - - - Windows - true - true - true - adv.lib;base.lib;core.lib;aui.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;wxregex.lib;wxexpat.lib;wsock32.lib;wininet.lib;%(AdditionalDependencies) - - - %(IgnoreSpecificDefaultLibraries) - - - - - - - - - Level3 - Full - true - true - - - MultiThreadedDLL - WIN32;NDEBUG;_WINDOWS;%(PreprocessorDefinitions) - false - Use - Speed - Sync - false - - - Windows - true - true - true - adv.lib;base.lib;core.lib;aui.lib;odbc32.lib;odbccp32.lib;comctl32.lib;ws2_32.lib;shlwapi.lib;winmm.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;rpcrt4.lib;wxtiff.lib;wxjpeg.lib;wxpng.lib;wxzlib.lib;wxregex.lib;wxexpat.lib;wsock32.lib;wininet.lib;%(AdditionalDependencies) - - - %(IgnoreSpecificDefaultLibraries) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Create - Create - Create - Create - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -=======  @@ -717,5 +364,4 @@ ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa \ No newline at end of file diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters index fa4931e3ea..c4eeb689ac 100644 --- a/rpcs3/rpcs3.vcxproj.filters +++ b/rpcs3/rpcs3.vcxproj.filters @@ -1,485 +1,3 @@ -<<<<<<< HEAD - - - - - {29c70b04-59a5-4d5b-98f9-3584df137ed1} - - - {98fb6fa5-9a9a-48a6-a6b4-be4b9a69b76e} - - - {47155d25-741d-42c0-8850-f22aafca082a} - - - {f306c137-6d2c-4e21-ba79-ac87d0ded22c} - - - {adfec460-d940-4482-9fdb-18cb0814c3d5} - true - - - {f66e37f9-5e58-443b-bcff-2e9e002ac89e} - - - {6c36f15e-07fd-45d6-a81c-1ab43ee1b58b} - - - {57263311-75a4-4309-81aa-b86fd212794b} - - - {461eddb5-b8a8-46be-918c-98cc7eaf995b} - - - {6fb03753-064a-456d-bb6f-9ceaed3776c7} - - - {e79e49c8-6967-4776-8f50-5479c3821b51} - - - {9bd88f78-8528-48f3-b9e0-78e06476b04d} - - - {fd7cea02-e77f-41b1-8b61-f78e7d280e04} - - - {dfd581c4-aed0-4229-bb30-7ee5816049e1} - - - {718bc358-b7ef-4988-8547-2148d14bb08b} - - - - - rpcs3 - - - rpcs3 - - - Gui - - - Gui - - - Emu - - - Gui - - - Gui - - - Emu - - - rpcs3 - - - Gui - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Gui - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Gui - - - Loader - - - Loader - - - Loader - - - Loader - - - Loader - - - Loader - - - Emu\CPU - - - Emu\CPU - - - Emu\CPU - - - Emu\SysCalls - - - Emu\SysCalls\lv2 - - - Emu\Io - - - Emu - - - Emu\GS - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\GS\GL - - - Emu\GS\GL - - - Emu\GS\GL - - - Emu\GS\GL - - - Emu\GS\GL - - - Emu\GS\GL - - - Emu\GS - - - Emu\GS\GL - - - Emu\SysCalls\lv2 - - - Emu\GS - - - Emu\CPU - - - Emu\SysCalls\lv2 - - - Utilities - - - Emu\SysCalls - - - Emu\SysCalls\lv2 - - - Emu\SysCalls - - - Emu\FS - - - Emu\FS - - - Emu\FS - - - Emu\FS - - - Emu\FS - - - Emu\SysCalls\lv2 - - - Emu\FS - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Gui - - - rpcs3 - - - Emu\CPU - - - Emu\SysCalls\lv2 - - - Emu\SysCalls - - - Emu\SysCalls\Modules - - - Emu\CPU - - - Emu\CPU - - - Emu\HDD - - - Gui - - - Gui - - - Gui - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\SysCalls\Modules - - - Emu\Io - - - Emu\SysCalls\lv2 - - - Emu\Io - - - Emu\SysCalls\lv2 - - - Emu\SysCalls\Modules - - - - - - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Include - - - Utilities - - - Utilities - - - Utilities - - - Utilities - - - Utilities - - - Include - - - Include - - - Include - - - Include - - - Include - - -=======  @@ -996,5 +514,4 @@ Utilities ->>>>>>> 3dd9683b472b89358a697210798c89df5b0e5baa \ No newline at end of file diff --git a/unpkg/unpkg.c b/unpkg/unpkg.c index a707ee0d34..f406f1c026 100644 --- a/unpkg/unpkg.c +++ b/unpkg/unpkg.c @@ -203,17 +203,16 @@ static void print_pkg_header(pkg_header *header) ConLog.Write( "KLicensee: %s\n", kl); } -static void *pkg_info(const char *fname, pkg_header **h_ptr) +static void *pkg_info(const char *fname, pkg_header **h_ptr) { FILE *f; - FILE *g; pkg_header *header; f = (FILE*) pkg_open(fname); if (f == NULL) return NULL; - if (pkg_sanity_check(f, g, &header, fname)) + if (pkg_sanity_check(f, NULL, &header, fname)) return NULL; print_pkg_header(header);