diff --git a/configure.py b/configure.py index a736a6bcf..a477a1859 100644 --- a/configure.py +++ b/configure.py @@ -707,7 +707,7 @@ config.libs = [ Object(NonMatching, "JSystem/JAudio/JAIConst.cpp"), Object(NonMatching, "JSystem/JAudio/JAIDummyObject.cpp"), Object(NonMatching, "JSystem/JAudio/JAIFx.cpp"), - Object(NonMatching, "JSystem/JAudio/JAIGlobalParameter.cpp"), + Object(Matching, "JSystem/JAudio/JAIGlobalParameter.cpp"), Object(NonMatching, "JSystem/JAudio/JAIInitData.cpp"), Object(NonMatching, "JSystem/JAudio/JAISeMgr.cpp"), Object(NonMatching, "JSystem/JAudio/JAISequenceHeap.cpp"), diff --git a/include/JSystem/JAudio/JAIAnimation.h b/include/JSystem/JAudio/JAIAnimation.h index 2959b46f1..3314fcc5c 100644 --- a/include/JSystem/JAudio/JAIAnimation.h +++ b/include/JSystem/JAudio/JAIAnimation.h @@ -20,17 +20,17 @@ struct JAIAnimeSound__Slot { class JAIAnimeSound { public: /* 0x00 */ JAIAnimeSound__Slot mSlots[8]; - /* 0x60 */ u32 m60; - /* 0x64 */ u32 m64; - /* 0x68 */ u32 m68; - /* 0x6C */ u32 m6C; - /* 0x70 */ void* m70[2]; + /* 0x60 */ u32 field_0x60; + /* 0x64 */ u32 field_0x64; + /* 0x68 */ u32 field_0x68; + /* 0x6C */ u32 field_0x6c; + /* 0x70 */ void* field_0x70[2]; /* 0x78 */ int mDataCounterInc; /* 0x7C */ int mDataCounterLimit; /* 0x80 */ u32 mDataCounter; /* 0x84 */ int mLoopCount; /* 0x88 */ f32 mCurrentTime; - /* 0x8C */ u8 m8C[0x90 - 0x8C]; + /* 0x8C */ u8 field_0x8c[0x90 - 0x8C]; /* 0x90 */ u16* mpData; /* 0x94 */ /* vtable */ diff --git a/include/JSystem/JAudio/JAIBankWave.h b/include/JSystem/JAudio/JAIBankWave.h new file mode 100644 index 000000000..941ec92d5 --- /dev/null +++ b/include/JSystem/JAudio/JAIBankWave.h @@ -0,0 +1,26 @@ +#ifndef JAIBANKWAVE_H +#define JAIBANKWAVE_H + +#include "dolphin/types.h" + +namespace JAInter { + namespace BankWave { + void setWsGroupNumber(s32, s32); + void setWsLoadStatus(s32, s32); + void init(); + void setWaveScene(); + void loadSecondStayWave(); + void setSceneSetFinishCallback(s32, s32); + void finishSceneSet(u32); + void loadSceneWave(s32, s32); + void loadGroupWave(s32, s32); + void getWaveLoadStatus(s32); + void checkAllWaveLoadStatus(); + + extern s32* wsGroupNumber; + extern s32* wsLoadStatus; + extern s32 wsMax; + }; +} + +#endif /* JAIBANKWAVE_H */ diff --git a/include/JSystem/JAudio/JAIBasic.h b/include/JSystem/JAudio/JAIBasic.h new file mode 100644 index 000000000..f7ea36301 --- /dev/null +++ b/include/JSystem/JAudio/JAIBasic.h @@ -0,0 +1,88 @@ +#ifndef JAIBASIC_H +#define JAIBASIC_H + +#include "JSystem/JUtility/JUTAssert.h" +#include "dolphin/mtx/vec.h" + +class JAISound; +class JKRSolidHeap; + +namespace JAInter { + class Actor; +} + +namespace JASystem { + class TTrack; +} + +class JAIBasic { +public: + JAIBasic(); + virtual JAISound* makeSound(u32); + virtual bool getMapInfoFxline(u32); + virtual bool getMapInfoGround(u32); + virtual f32 getMapInfoFxParameter(u32); + virtual void setSeExtParameter(JAISound*); + virtual void setRegisterTrackCallback(); + virtual void initStream(); + void initDriver(JKRSolidHeap*, u32, u8); + void initInterface(u8); + void initInterfaceMain(); + void initHeap(); + void initArchive(); + void initResourcePath(); + void setCameraInfo(Vec*, Vec*, f32(*)[4], u32); + void initAudioThread(JKRSolidHeap*, u32, u8); + void initCamera(); + bool initReadFile(); + void processFrameWork(); + void startSoundVec(u32, JAISound**, Vec*, u32, u32, u8); + void startSoundActor(u32, JAISound**, JAInter::Actor*, u32, u8); + void startSoundDirectID(u32, JAISound**, JAInter::Actor*, u32, u8); + void startSoundBasic(u32, JAISound**, JAInter::Actor*, u32, u8, void*); + void stopSoundHandle(JAISound*, u32); + void stopPlayingCategoryObjectSe(u8, void*); + void stopAllSe(u8, void*); + void stopActorSoundOneBuffer(void*, JAISound*); + void stopIDSoundOneBuffer(u32, JAISound*); + void stopIDActorSoundOneBuffer(u32, void*, JAISound*); + void stopAllSound(void*); + void stopAllSound(u32); + void stopAllSound(u32, void*); + void deleteObject(void*); + void getSoundOffsetNumberFromID(u32); + void setSeCategoryVolume(u8, u8); + static u16 setParameterSeqSync(JASystem::TTrack*, u16); + void allocStreamBuffer(void*, s32); + void deallocStreamBuffer(); + + /* 0x04 */ void* field_0x4; + /* 0x08 */ JKRSolidHeap* field_0x8; + /* 0x0C */ u8 initLoadFileSw; + /* 0x0D */ u8 field_0xd; + /* 0x0E */ struct { + u8 flag1 : 1; + u8 flag2 : 1; + u8 flag3 : 1; + u8 flag4 : 1; + u8 flag5 : 1; + u8 flag6 : 1; + u8 flag7 : 1; + u8 flag8 : 1; + } field_0xe; + /* 0x10 */ int field_0x10; + /* 0x14 */ int field_0x14; + /* 0x18 */ int field_0x18; + /* 0x1C */ int field_0x1c; + + static JAIBasic* getInterface() { return msBasic; } + static JKRSolidHeap* getCurrentJAIHeap() { + JUT_ASSERT_MSG(148, msCurrentHeap, "JAIBasicのカレントヒープがありません（mCurrentHeap==NULL）\n"); + return msCurrentHeap; + } + + static JAIBasic* msBasic; + static JKRSolidHeap* msCurrentHeap; +}; + +#endif /* JAIBASIC_H */ diff --git a/include/JSystem/JAudio/JAIConst.h b/include/JSystem/JAudio/JAIConst.h new file mode 100644 index 000000000..96820d12f --- /dev/null +++ b/include/JSystem/JAudio/JAIConst.h @@ -0,0 +1,19 @@ +#ifndef JAICONST_H +#define JAICONST_H + +#include "JSystem/JMath/random.h" +#include "dolphin/mtx/vec.h" + +namespace JAInter { + u8* transInitDataFile(u8*, u32); + void loadTmpDVDFile(char*, u8**); + void deleteTmpDVDFile(u8**); + u32 routeToTrack(u32); + + namespace Const { + extern Vec dummyZeroVec; + extern JMath::TRandom_fast_ random; + } +} + +#endif /* JAICONST_H */ diff --git a/include/JSystem/JAudio/JAIGlobalParameter.h b/include/JSystem/JAudio/JAIGlobalParameter.h new file mode 100644 index 000000000..8b228992a --- /dev/null +++ b/include/JSystem/JAudio/JAIGlobalParameter.h @@ -0,0 +1,126 @@ +#ifndef JAIGLOBALPARAMETER_H +#define JAIGLOBALPARAMETER_H + +#include "dolphin/types.h" + +namespace JAIGlobalParameter { + void setParamInitDataPointer(void*); + void setParamInterfaceHeapSize(u32); + void setParamSoundSceneMax(u32); + void setParamSeRegistMax(u32); + void setParamSeTrackMax(u32); + void setParamSeqPlayTrackMax(u32); + void setParamSeqControlBufferMax(u32); + void setParamStreamControlBufferMax(u32); + void setParamAutoHeapMax(u32); + void setParamStayHeapMax(u32); + void setParamInputGainDown(f32); + void setParamOutputGainUp(f32); + void setParamDistanceMax(f32); + void setParamMaxVolumeDistance(f32); + void setParamMinDistanceVolume(f32); + void setParamSeDistanceFxParameter(u16); + void setParamStreamDecodedBufferBlocks(u32); + void setParamStreamInsideBufferCut(bool); + void setParamAutoHeapRoomSize(u32); + void setParamStayHeapSize(u32); + void setParamSeDolbyCenterValue(u8); + void setParamSeDolbyFrontDistanceMax(f32); + void setParamSeDolbyBehindDistanceMax(f32); + void setParamInitDataFileName(char*); + void setParamWavePath(char*); + void setParamSequenceArchivesPath(char*); + void setParamStreamPath(char*); + void setParamAudioResPath(char*); + void setParamSequenceArchivesFileName(char*); + void setParamDummyObjectLifeTime(u32); + void setParamDummyObjectMax(u32); + void setParamAudioCameraMax(u32); + void setParamSystemTrackMax(s32); + void setParamSoundOutputMode(u32); + int getParamSeCategoryMax(); + u32 getParamSoundSceneMax(); + u32 getParamSeRegistMax(); + u32 getParamSeTrackMax(); + u32 getParamSeqTrackMax(); + u32 getParamSeqControlBufferMax(); + u32 getParamStreamControlBufferMax(); + u32 getParamStreamParameterBufferMax(); + u32 getParamAutoHeapMax(); + u32 getParamStayHeapMax(); + u32 getParamSeqPlayTrackMax(); + f32 getParamDistanceMax(); + f32 getParamMaxVolumeDistance(); + f32 getParamMinDistanceVolume(); + u32 getParamAutoHeapRoomSize(); + u32 getParamStayHeapSize(); + f32 getParamSeDolbyCenterValue(); + f32 getParamSeDolbyFrontDistanceMax(); + f32 getParamSeDolbyBehindDistanceMax(); + char* getParamInitDataFileName(); + char* getParamWavePath(); + char* getParamSequenceArchivesPath(); + char* getParamStreamPath(); + char* getParamAudioResPath(); + char* getParamSequenceArchivesFileName(); + u32 getParamDopplarMoveTime(); + u8 getParamDistanceParameterMoveTime(); + u32 getParamDummyObjectMax(); + u8 getParamSeqMuteVolumeSePlay(); + u32 getParamSeqMuteMoveSpeedSePlay(); + u32 getParamAudioCameraMax(); + u8 getParamSeqParameterLines(); + u8 getParamStreamParameterLines(); + u16 getParamSeDistanceWaitMax(); + + extern u8 distanceParameterMoveTime; + extern u8 audioSystemThreadPriority; + extern u8 audioDvdThreadPriority; + extern u8 seqMuteVolumeSePlay; + extern u8 seqParameterLines; + extern u8 streamParameterLines; + extern u16 seDistanceFxParameter; + extern u32 soundSceneMax; + extern u32 seRegistMax; + extern u32 seTrackMax; + extern u32 seqTrackMax; + extern u32 seqPlayTrackMax; + extern u32 seqControlBufferMax; + extern u32 streamControlBufferMax; + extern u32 streamParameterBufferMax; + extern u32 autoHeapMax; + extern u32 stayHeapMax; + extern u32 autoHeapRoomSize; + extern u32 stayHeapSize; + extern char* initDataFileName; + extern char* wavePath; + extern char* sequenceArchivesPath; + extern char* streamPath; + extern char* audioResPath; + extern char* sequenceArchivesFileName; + extern f32 inputGainDown; + extern f32 outputGainUp; + extern f32 distanceMax; + extern f32 maxVolumeDistance; + extern f32 seDolbyCenterValue; + extern f32 seDolbyFrontDistanceMax; + extern f32 seDolbyBehindDistanceMax; + extern u32 dopplarMoveTime; + extern u32 dummyObjectLifeTime; + extern u32 dummyObjectMax; + extern u32 seqMuteMoveSpeedSePlay; + extern u32 audioCameraMax; + extern s32 systemTrackMax; + extern f32 panDistanceMax; + extern f32 panDistance2Max; + extern f32 panAngleParameter; + extern f32 panAngleParameter2; + extern f32 dopplarParameter; + extern u16 seDistanceWaitMax; + extern f32 seDistancepitchMax; + extern u16 seDefaultFx; + extern u32 interfaceHeapSize; + extern f32 minDistanceVolume; +} + +#endif /* JAIGLOBALPARAMETER_H */ diff --git a/include/JSystem/JAudio/JAIInitData.h b/include/JSystem/JAudio/JAIInitData.h new file mode 100644 index 000000000..3f5efbc95 --- /dev/null +++ b/include/JSystem/JAudio/JAIInitData.h @@ -0,0 +1,15 @@ +#ifndef JAIINITDATA_H +#define JAIINITDATA_H + +#include "dolphin/types.h" + +namespace JAInter { + namespace InitData { + BOOL checkInitDataFile(); + void checkInitDataOnMemory(); + + extern u32* aafPointer; + }; +} + +#endif /* JAIINITDATA_H */ diff --git a/include/JSystem/JAudio/JAISequenceMgr.h b/include/JSystem/JAudio/JAISequenceMgr.h new file mode 100644 index 000000000..3950f501d --- /dev/null +++ b/include/JSystem/JAudio/JAISequenceMgr.h @@ -0,0 +1,133 @@ +#ifndef JAISEQUENCEMGR_H +#define JAISEQUENCEMGR_H + +#include "JSystem/JAudio/JAISound.h" +#include "JSystem/JAudio/JASCmdStack.h" +#include "JSystem/JAudio/JASTrack.h" + +class JAISound; +class JKRArchive; + +namespace JAInter { + class Actor; + class MoveParaSet; + + class PlayerParameter { + public: + PlayerParameter(); + ~PlayerParameter(); + + /* 0x00 */ int field_0x0; + /* 0x04 */ int field_0x4; + /* 0x08 */ int field_0x8; + /* 0x0C */ int field_0xc; + /* 0x10 */ int field_0x10; + /* 0x14 */ int field_0x14; + /* 0x18 */ int field_0x18; + /* 0x1C */ int field_0x1c; + /* 0x20 */ int field_0x20; + /* 0x24 */ int field_0x24; + /* 0x28 */ int field_0x28; + /* 0x2C */ JASystem::Kernel::TPortCmd field_0x2c; + }; + + class SeqUpdateData { + public: + SeqUpdateData(); + + /* 0x00 */ u8 field_0x0; + /* 0x01 */ u8 field_0x1; + /* 0x02 */ u8 field_0x2; + /* 0x03 */ u8 field_0x3; + /* 0x04 */ int field_0x4; + /* 0x08 */ int field_0x8; + /* 0x0C */ f32 field_0xc; + /* 0x10 */ f32 field_0x10; + /* 0x14 */ f32 field_0x14; + /* 0x18 */ f32 field_0x18; + /* 0x1C */ f32 field_0x1c; + /* 0x20 */ f32 field_0x20; + /* 0x24 */ f32* trackVolume; + /* 0x28 */ f32* trackPitch; + /* 0x2C */ f32* trackFxmix; + /* 0x30 */ f32* trackPan; + /* 0x34 */ f32* trackDolby; + /* 0x38 */ int field_0x38; + /* 0x3C */ int field_0x3c; + /* 0x40 */ int field_0x40; + /* 0x44 */ int* trackupdate; + /* 0x48 */ int field_0x48; + /* 0x4C */ PlayerParameter* systemTrackParameter; + }; + + class MuteBit { + public: + MuteBit(); + + u8 flag1 : 1; + u8 flag2 : 1; + u8 flag3 : 1; + u8 flag4 : 1; + u8 flag5 : 1; + u8 flag6 : 1; + u8 flag7 : 1; + u8 flag8 : 1; + }; + + class SeqParameter { + public: + SeqParameter() {} + int init(); + + /* 0x0000 */ MoveParaSet field_0x0; + /* 0x0010 */ MoveParaSet field_0x10[16]; + /* 0x0110 */ MoveParaSet field_0x110[20]; + /* 0x0250 */ MoveParaSet* seqPan; + /* 0x0254 */ MoveParaSet* seqPitch; + /* 0x0258 */ MoveParaSet* seqFxmix; + /* 0x025C */ MoveParaSet* seqDolby; + /* 0x0260 */ MoveParaSet field_0x260[32]; + /* 0x0460 */ MoveParaSet field_0x460[32]; + /* 0x0660 */ MoveParaSet field_0x660[32]; + /* 0x0860 */ MoveParaSet field_0x860[32]; + /* 0x0A60 */ MoveParaSet field_0xa60[32]; + /* 0x0C60 */ MoveParaSet field_0xc60[32]; + /* 0x0E60 */ u8 field_0xe60[0x1261 - 0xe60]; + /* 0x1261 */ u8 field_0x1261; + /* 0x1262 */ u8 field_0x1262[0x133c - 0x1262]; + /* 0x133C */ MuteBit field_0x133c[32]; + /* 0x135C */ SeqUpdateData* field_0x135c; + /* 0x1360 */ JASystem::TTrack field_0x1360; + /* 0x16EC */ JASystem::TTrack::TOuterParam field_0x16ec; + }; + + namespace SequenceMgr { + void init(); + void getArchiveName(char*); + void setArchivePointer(JKRArchive*); + void processGFrameSequence(); + void checkEntriedSeq(); + void checkFadeoutSeq(); + void checkStoppedSeq(); + void checkPlayingSeq(); + void checkStartedSeq(); + void checkReadSeq(); + void checkSeqWave(); + void checkPlayingSeqUpdateMultiplication(u32, u8, u32, MoveParaSet*, u32*, u8, f32*); + void checkPlayingSeqUpdateAddition(u32, u8, u32, MoveParaSet*, u32*, u8, f32*, f32); + void checkPlayingSeqUpdateTrack(u32, u32, MoveParaSet*, u32*, u8, f32*); + void checkPlayingSeqTrack(u32); + void stopSeq(JAISound*); + void checkDvdLoadArc(u32, u32); + void storeSeqBuffer(JAISound**, Actor*, u32, u32, u8, void*); + void releaseSeqBuffer(JAISound*, u32); + int getPlayTrackInfo(u32); + + extern LinkSound seqControl; + extern SeqUpdateData* seqTrackInfo; + extern int* FixSeqBufPointer; + extern JKRArchive* arcPointer; + } +} + +#endif /* JAISEQUENCEMGR_H */ diff --git a/include/JSystem/JAudio/JAISound.h b/include/JSystem/JAudio/JAISound.h new file mode 100644 index 000000000..ef71c5002 --- /dev/null +++ b/include/JSystem/JAudio/JAISound.h @@ -0,0 +1,137 @@ +#ifndef JAISOUND_H +#define JAISOUND_H + +#include "dolphin/types.h" + +namespace JAInter { + class Actor; + class SeParameter; + class SeqParameter; + class StreamParameter; +} + +class JAISound { +public: + JAISound(); + virtual f32 setPositionDopplarCommon(u32); + virtual f32 setDistanceVolumeCommon(f32, u8); + virtual f32 setDistancePanCommon(); + virtual void setSeDistanceParameters(); + virtual void setSeDistanceVolume(u8); + virtual void setSeDistancePan(u8); + virtual void setSeDistancePitch(u8); + virtual void setSeDistanceFxmix(u8); + virtual void setSeDistanceFir(u8); + virtual void setSeDistanceDolby(u8); + virtual void setSePositionDopplar(); + + int getSeCategoryNumber(); + int getSwBit(); + int checkSwBit(u32); + u8 getInfoPriority(); + void clearMainSoundPPointer(); + void start(u32); + void stop(u32); + void setVolume(f32, u32, u8); + void setPan(f32, u32, u8); + void setPitch(f32, u32, u8); + void setFxmix(f32, u32, u8); + void setDolby(f32, u32, u8); + void setTempoProportion(f32, u32); + void setPortData(u8, u16); + void setPrepareFlag(u8); + void setSeqInterVolume(u8, f32, u32); + void setSeqInterPan(u8, f32, u32); + void setSeqInterPitch(u8, f32, u32); + void setSeqInterFxmix(u8, f32, u32); + void setSeqInterDolby(u8, f32, u32); + void setSeqTempoProportion(f32, u32); + void setSeqPortData(u8, u16, u32); + void setTrackVolume(u8, f32, u32); + void setTrackInterruptSwitch(u8, u8); + void setTrackPortData(u8, u8, u16); + void setSeInterRandomPara(f32*, u32, f32, f32); + void setSeInterVolume(u8, f32, u32, u8); + void setSeInterPan(u8, f32, u32, u8); + void setSeInterPitch(u8, f32, u32, f32); + void setSeInterFxmix(u8, f32, u32, u8); + void setSeInterDolby(u8, f32, u32, u8); + void setSePortData(u8, u16); + void setStreamInterVolume(u8, f32, u32); + void setStreamInterPitch(u8, f32, u32); + void setStreamInterPan(u8, f32, u32); + void setStreamPrepareFlag(u8); + void setPauseMode(u8, u8); + void setSeqPrepareFlag(u8); + f32 getSeqInterVolume(u8); + f32 getStreamInterVolume(u8); + JAInter::SeqParameter* getSeqParameter(); + JAInter::SeParameter* getSeParameter(); + JAInter::StreamParameter* getStreamParameter(); + int getTrackPortRoute(u8, u8); + int checkSoundHandle(u32, void*); + void initParameter(JAISound**, JAInter::Actor*, u32, u32, u8, void*); + + /* 0x04 */ u8 field_0x4; + /* 0x05 */ u8 field_0x5; + /* 0x06 */ u8 field_0x6; + /* 0x07 */ u8 field_0x7; + /* 0x08 */ u8 field_0x8; + /* 0x09 */ u8 field_0x9; + /* 0x0a */ short field_0xa; + /* 0x0c */ int field_0xc; + /* 0x10 */ int field_0x10; + /* 0x14 */ u32 field_0x14; + /* 0x18 */ int field_0x18; + /* 0x1c */ int field_0x1c; + /* 0x20 */ void* field_0x20; + /* 0x24 */ void* field_0x24; + /* 0x28 */ int field_0x28; + /* 0x2C */ int field_0x2c; + /* 0x30 */ JAISound* field_0x30; + /* 0x34 */ JAISound* field_0x34; + /* 0x38 */ JAISound** field_0x38; + /* 0x3C */ void* field_0x3c; + /* 0x40 */ void* field_0x40; +}; + +namespace JAInter { + class MoveParaSet { + public: + MoveParaSet(f32 param_1=1.0f) { + field_0x4 = param_1; + field_0x0 = param_1; + field_0xc = 0; + } + int set(f32 param_1, u32 param_2); + bool move(); + + /* 0x00 */ f32 field_0x0; + /* 0x04 */ f32 field_0x4; + /* 0x08 */ f32 field_0x8; + /* 0x0C */ int field_0xc; + }; + + class MoveParaSetInitHalf : public MoveParaSet { + public: + MoveParaSetInitHalf() : MoveParaSet(0.5f) {} + }; + + class MoveParaSetInitZero : public MoveParaSet { + public: + MoveParaSetInitZero() : MoveParaSet(0.0f) {} + }; + + class LinkSound { + public: + void init(JAISound* param_1, u32 param_2); + JAISound* getSound(); + void releaseSound(JAISound* param_1); + + /* 0x00 */ JAISound* field_0x0; + /* 0x04 */ JAISound* field_0x4; + /* 0x08 */ JAISound* field_0x8; + }; +} + +#endif /* JAISOUND_H */ diff --git a/include/JSystem/JAudio/JAISoundTable.h b/include/JSystem/JAudio/JAISoundTable.h new file mode 100644 index 000000000..cb9dac0d4 --- /dev/null +++ b/include/JSystem/JAudio/JAISoundTable.h @@ -0,0 +1,22 @@ +#ifndef JAISOUNDTABLE_H +#define JAISOUNDTABLE_H + +#include "dolphin/types.h" + +namespace JAInter { + namespace SoundTable { + void init(u8*, u32); + void getInfoPointer(u32); + void getInfoFormat(u32); + u8 getCategotyMax(); + + extern u8 mVersion; + extern u8 mCategotyMax; + extern s16* mSoundMax; + extern u32 mDatasize; + extern int* mPointerCategory; + extern u8* mAddress; + } +} + +#endif /* JAISOUNDTABLE_H */ diff --git a/include/JSystem/JAudio/JAIStreamMgr.h b/include/JSystem/JAudio/JAIStreamMgr.h new file mode 100644 index 000000000..433aebe16 --- /dev/null +++ b/include/JSystem/JAudio/JAIStreamMgr.h @@ -0,0 +1,122 @@ +#ifndef JAISTREAMMGR_H +#define JAISTREAMMGR_H + +#include "dolphin/dvd/dvd.h" +#include "JSystem/JAudio/JAISound.h" +#include "JSystem/JAudio/JASHeapCtrl.h" + +class JAISound; + +namespace JASystem { + class TDSPChannel; + namespace DSPInterface { + class DSPBuffer; + } +} + +namespace JAInter { + class Actor; + namespace StreamMgr { + void init(); + void storeStreamBuffer(JAISound**, Actor*, u32, u32, u8, void*); + void releaseStreamBuffer(JAISound*, u32); + void processGFrameStream(); + void checkEntriedStream(); + void checkWaitStream(); + void checkRequestStream(); + void checkPlayingStream(); + + extern LinkSound streamControl; + extern u8 flags; + extern int streamUpdate; + extern u8* streamList; + extern u8* initOnCodeStrm; + } + + namespace StreamLib { + void Play_DirectPCM(JASystem::TDSPChannel*, s16*, u16, u32, s16, u16); + int Get_DirectPCM_LoopRemain(JASystem::DSPInterface::DSPBuffer*); + int Get_DirectPCM_Remain(JASystem::DSPInterface::DSPBuffer*); + void init(bool); + void allocBuffer(void*, s32); + bool deallocBuffer(); + int getNeedBufferSize(); + void setAllocBufferCallback(void (*)(void)); + void setDeallocBufferCallback(void (*)(void)); + void sync(s32); + void __DecodePCM(); + void __DecodeADPCM(); + void __Decode(); + void __LoadFin(s32, DVDFileInfo*); + void LoadADPCM(); + void setVolume(f32); + void setPitch(f32); + void setPan(f32 param_1); + void stop(); + void setPauseFlag(u8 param_1); + void clearPauseFlag(u8 param_1); + void setPrepareFlag(u8 param_1); + void setOutputMode(u32 param_1); + u8 getPlayingFlag(); + void setDecodedBufferBlocks(u32 param_1); + void LoopInit(); + s32 directPlayWait(void* param_1); + void start(char* param_1, u32 param_2, void* param_3); + void __start(); + s32 callBack(void* param_1); + + extern s16 filter_table[]; + extern s16 table4[]; + extern DVDFileInfo finfo; + extern u32 header[]; + extern char Filename[]; + extern JASystem::Kernel::TSolidHeap streamHeap; + extern u32 LOOP_BLOCKS; + extern int LOOP_SAMPLESIZE; + extern int outputmode; + extern int adpcm_remain; + extern int adpcm_loadpoint; + extern int loadsize; + extern int adpcm_buffer; + extern int loop_buffer; + extern int store_buffer; + extern JASystem::TDSPChannel* assign_ch[2]; + extern int playside; + extern int playback_samples; + extern int loadup_samples; + extern u32 adpcmbuf_state; + extern int movieframe; + extern bool stopflag; + extern bool stopflag2; + extern u8 playflag; + extern u8 playflag2; + extern u8 prepareflag; + extern u8 dspch_deallockflag; + extern f32 outvolume; + extern f32 outpitch; + extern f32 outpan; + extern f32 stackvolume; + extern f32 stackpitch; + extern f32 stackpan; + extern u8 outflag_volume; + extern bool outflag_pan; + extern bool outflag_pitch; + extern int loop_start_flag; + extern int outpause; + extern int playmode; + extern int shift_sample; + extern int extra_sample; + extern int DvdLoadFlag; + extern u32 startInitFlag; + extern int Mode; + extern int sFillBlockSize; + extern void* Head; + extern bool bufferMode; + extern u8 allocFlag; + extern u8 dspFinishFlag; + extern void (*allocCallback)(); + extern void (*deallocCallback)(); + } +} + +#endif /* JAISTREAMMGR_H */ diff --git a/include/JSystem/JAudio/JAISystemInterface.h b/include/JSystem/JAudio/JAISystemInterface.h new file mode 100644 index 000000000..922d72b8b --- /dev/null +++ b/include/JSystem/JAudio/JAISystemInterface.h @@ -0,0 +1,33 @@ +#ifndef JAISYSTEMINTERFACE_H +#define JAISYSTEMINTERFACE_H + +#include "JSystem/JAudio/JASCmdStack.h" + +class JAISound; + +namespace JASystem { + class TTrack; + namespace Kernel { + class TPortArgs; + } +} + +namespace JAInter { + class SeqUpdateData; + namespace SystemInterface { + s32 checkFileExsistence(char*); + int checkSeqActiveFlag(JASystem::TTrack*); + void trackToSeqp(JAISound*, u8); + void setSeqPortargsF32(JAInter::SeqUpdateData*, u32, u8, f32); + void setSeqPortargsU32(JAInter::SeqUpdateData*, u32, u8, u32); + void rootInit(JAInter::SeqUpdateData*); + void trackInit(JAInter::SeqUpdateData*); + void outerInit(JAInter::SeqUpdateData*, void*, u32, u16, u8); + void setPortParameter(JASystem::Kernel::TPortArgs*, JASystem::TTrack*, u32, u32); + void setSePortParameter(JASystem::Kernel::TPortArgs*); + + extern JASystem::Kernel::TPortCmd systemPortCmd; + } +} + +#endif /* JAISYSTEMINTERFACE_H */ diff --git a/include/JSystem/JAudio/JASCmdStack.h b/include/JSystem/JAudio/JASCmdStack.h index c7344d86a..f0ba1cdf9 100644 --- a/include/JSystem/JAudio/JASCmdStack.h +++ b/include/JSystem/JAudio/JASCmdStack.h @@ -16,6 +16,7 @@ namespace JASystem { class TPortCmd { public: TPortCmd(); + ~TPortCmd() {} bool addPortCmdOnce(); bool setPortCmd(void (*)(TPortArgs*), TPortArgs*); bool addPortCmd(TPortHead*); diff --git a/include/JSystem/JAudio/JASDSPInterface.h b/include/JSystem/JAudio/JASDSPInterface.h index 027c40c2c..2cb710539 100644 --- a/include/JSystem/JAudio/JASDSPInterface.h +++ b/include/JSystem/JAudio/JASDSPInterface.h @@ -85,7 +85,7 @@ namespace JASystem { /* 0x64 */ short field_0x64; /* 0x66 */ short field_0x66; /* 0x68 */ int field_0x68; - /* 0x6C */ int field_0x6c; + /* 0x6C */ u32 field_0x6c; /* 0x70 */ u8 field_0x70[0x74 - 0x70]; /* 0x74 */ int field_0x74; /* 0x78 */ short field_0x78[4]; diff --git a/include/JSystem/JUtility/JUTAssert.h b/include/JSystem/JUtility/JUTAssert.h index e54d47440..e03d2e354 100644 --- a/include/JSystem/JUtility/JUTAssert.h +++ b/include/JSystem/JUtility/JUTAssert.h @@ -10,6 +10,16 @@ OSPanic(__FILE__, LINE, "Halt"); \ } +// Favored by JAI (JAudio) +#define JUT_ASSERT_MSG(LINE, COND, MSG) \ + if (!(COND)) { \ + OSReport(MSG); \ + if (!(COND)) { \ + JUTAssertion::showAssert(3, __FILE__, LINE, #COND); \ + OSPanic(__FILE__, LINE, "Halt"); \ + } \ + } + // Some asserts on floats have the wrong codegen with JUT_ASSERT's (COND) == 0 check. // Using !(COND) instead fixes them. #define JUT_ASSERT_FLOAT(LINE, COND) \ diff --git a/src/JSystem/JAudio/JAIAnimation.cpp b/src/JSystem/JAudio/JAIAnimation.cpp index 7f0ed77fd..507a774b7 100644 --- a/src/JSystem/JAudio/JAIAnimation.cpp +++ b/src/JSystem/JAudio/JAIAnimation.cpp @@ -4,44 +4,62 @@ // #include "JSystem/JAudio/JAIAnimation.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JAudio/JAISound.h" /* 8028F08C-8028F110 .text __ct__13JAIAnimeSoundFv */ JAIAnimeSound::JAIAnimeSound() { - /* Nonmatching */ + field_0x60 = 0; + field_0x64 = 0; + field_0x68 = 0; + field_0x6c = 0; + for (u8 i = 0; i < 8; i++) { + mSlots[i].mpSound = NULL; + mSlots[i].mbIsPlaying = false; + } + for (u8 i = 0; i < 2; i++) { + field_0x70[i] = NULL; + } + mDataCounter = 0; + mLoopCount = 0; } /* 8028F110-8028F268 .text initActorAnimSound__13JAIAnimeSoundFPvUlf */ -void JAIAnimeSound::initActorAnimSound(void*, unsigned long, float) { +void JAIAnimeSound::initActorAnimSound(void*, u32, f32) { /* Nonmatching */ } /* 8028F268-8028F2A0 .text setAnimSoundVec__13JAIAnimeSoundFP8JAIBasicP3VecffUlUc */ -void JAIAnimeSound::setAnimSoundVec(JAIBasic*, Vec*, float, float, unsigned long, unsigned char) { +void JAIAnimeSound::setAnimSoundVec(JAIBasic*, Vec*, f32, f32, u32, u8) { /* Nonmatching */ } /* 8028F2A0-8028F7B8 .text setAnimSoundActor__13JAIAnimeSoundFP8JAIBasicPQ27JAInter5ActorffUc */ -void JAIAnimeSound::setAnimSoundActor(JAIBasic*, JAInter::Actor*, float, float, unsigned char) { +void JAIAnimeSound::setAnimSoundActor(JAIBasic*, JAInter::Actor*, f32, f32, u8) { /* Nonmatching */ } /* 8028F7B8-8028FA60 .text playActorAnimSound__13JAIAnimeSoundFP8JAIBasicPQ27JAInter5ActorfUc */ -void JAIAnimeSound::playActorAnimSound(JAIBasic*, JAInter::Actor*, float, unsigned char) { +void JAIAnimeSound::playActorAnimSound(JAIBasic*, JAInter::Actor*, f32, u8) { /* Nonmatching */ } /* 8028FA60-8028FA94 .text startAnimSound__13JAIAnimeSoundFPvUlPP8JAISoundPQ27JAInter5ActorUc */ -void JAIAnimeSound::startAnimSound(void*, unsigned long, JAISound**, JAInter::Actor*, unsigned char) { - /* Nonmatching */ +void JAIAnimeSound::startAnimSound(void* param_1, u32 param_2, JAISound** param_3, JAInter::Actor* param_4, u8 param_5) { + JAIBasic* basic = (JAIBasic*)param_1; + basic->startSoundActor(param_2, param_3, param_4, 0, param_5); } /* 8028FA94-8028FBE0 .text setSpeedModifySound__13JAIAnimeSoundFP8JAISoundP22JAIAnimeFrameSoundDataf */ -void JAIAnimeSound::setSpeedModifySound(JAISound*, JAIAnimeFrameSoundData*, float) { +void JAIAnimeSound::setSpeedModifySound(JAISound*, JAIAnimeFrameSoundData*, f32) { /* Nonmatching */ } /* 8028FBE0-8028FC48 .text stop__13JAIAnimeSoundFv */ void JAIAnimeSound::stop() { - /* Nonmatching */ + for (u8 i = 0; i < 8; i++) { + if (mSlots[i].mpSound) { + mSlots[i].mpSound->stop(0); + } + } } diff --git a/src/JSystem/JAudio/JAIBankWave.cpp b/src/JSystem/JAudio/JAIBankWave.cpp index 0265b4632..a005c8d99 100644 --- a/src/JSystem/JAudio/JAIBankWave.cpp +++ b/src/JSystem/JAudio/JAIBankWave.cpp @@ -4,21 +4,34 @@ // #include "JSystem/JAudio/JAIBankWave.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JAudio/JAIGlobalParameter.h" +#include "JSystem/JAudio/JASWaveArcLoader.h" +#include "JSystem/JAudio/JASWaveBankMgr.h" +#include "JSystem/JKernel/JKRSolidHeap.h" + +s32* JAInter::BankWave::wsGroupNumber; +s32* JAInter::BankWave::wsLoadStatus; +s32 JAInter::BankWave::wsMax; /* 80291220-80291230 .text setWsGroupNumber__Q27JAInter8BankWaveFll */ -void JAInter::BankWave::setWsGroupNumber(long, long) { - /* Nonmatching */ +void JAInter::BankWave::setWsGroupNumber(s32 param_1, s32 param_2) { + wsGroupNumber[param_1] = param_2; } /* 80291230-80291240 .text setWsLoadStatus__Q27JAInter8BankWaveFll */ -void JAInter::BankWave::setWsLoadStatus(long, long) { - /* Nonmatching */ +void JAInter::BankWave::setWsLoadStatus(s32 param_1, s32 param_2) { + wsLoadStatus[param_1] = param_2; } /* 80291240-8029144C .text init__Q27JAInter8BankWaveFv */ void JAInter::BankWave::init() { /* Nonmatching */ + wsGroupNumber = new (JAIBasic::getCurrentJAIHeap(), 32) s32[wsMax]; + wsLoadStatus = new (JAIBasic::getCurrentJAIHeap(), 32) s32[wsMax]; + JASystem::WaveArcLoader::setCurrentDir(JAIGlobalParameter::getParamWavePath()); + JASystem::WaveBankMgr::init(0x100); + JASystem::WaveArcLoader::init(); } /* 8029144C-802914D4 .text setWaveScene__Q27JAInter8BankWaveFv */ @@ -32,27 +45,27 @@ void JAInter::BankWave::loadSecondStayWave() { } /* 80291578-802915C4 .text setSceneSetFinishCallback__Q27JAInter8BankWaveFll */ -void JAInter::BankWave::setSceneSetFinishCallback(long, long) { +void JAInter::BankWave::setSceneSetFinishCallback(s32, s32) { /* Nonmatching */ } /* 802915C4-802915DC .text finishSceneSet__Q27JAInter8BankWaveFUl */ -void JAInter::BankWave::finishSceneSet(unsigned long) { +void JAInter::BankWave::finishSceneSet(u32) { /* Nonmatching */ } /* 802915DC-8029165C .text loadSceneWave__Q27JAInter8BankWaveFll */ -void JAInter::BankWave::loadSceneWave(long, long) { +void JAInter::BankWave::loadSceneWave(s32, s32) { /* Nonmatching */ } /* 8029165C-802916B0 .text loadGroupWave__Q27JAInter8BankWaveFll */ -void JAInter::BankWave::loadGroupWave(long, long) { +void JAInter::BankWave::loadGroupWave(s32, s32) { /* Nonmatching */ } /* 802916B0-802916C0 .text getWaveLoadStatus__Q27JAInter8BankWaveFl */ -void JAInter::BankWave::getWaveLoadStatus(long) { +void JAInter::BankWave::getWaveLoadStatus(s32) { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAIBasic.cpp b/src/JSystem/JAudio/JAIBasic.cpp index 3cdb35529..28ade8cdf 100644 --- a/src/JSystem/JAudio/JAIBasic.cpp +++ b/src/JSystem/JAudio/JAIBasic.cpp @@ -4,21 +4,51 @@ // #include "JSystem/JAudio/JAIBasic.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIGlobalParameter.h" +#include "JSystem/JAudio/JAIInitData.h" +#include "JSystem/JAudio/JAISequenceMgr.h" +#include "JSystem/JAudio/JASAudioThread.h" +#include "JSystem/JAudio/JASDriverIF.h" +#include "JSystem/JAudio/JASSystemHeap.h" +#include "JSystem/JKernel/JKRArchive.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "MSL_C/string.h" + +namespace JAIInitData = JAInter::InitData; +namespace JAISequenceMgr = JAInter::SequenceMgr; + +const int JAI_INIT_MODE_MAX = 5; + +JAIBasic* JAIBasic::msBasic; +JKRSolidHeap* JAIBasic::msCurrentHeap; /* 8028FC48-8028FCC4 .text __ct__8JAIBasicFv */ JAIBasic::JAIBasic() { - /* Nonmatching */ + msBasic = this; + field_0xe.flag1 = 0; + field_0xe.flag2 = 0; + field_0xe.flag3 = 0; + field_0xe.flag4 = 0; + field_0xe.flag5 = 0; + field_0x14 = 0; + field_0x4 = NULL; + field_0x10 = 0; + initLoadFileSw = 2; + field_0x1c = 0; + field_0x8 = NULL; + field_0x18 = 0; + msCurrentHeap = JASDram; } /* 8028FCC4-8028FCE4 .text initDriver__8JAIBasicFP12JKRSolidHeapUlUc */ -void JAIBasic::initDriver(JKRSolidHeap*, unsigned long, unsigned char) { - /* Nonmatching */ +void JAIBasic::initDriver(JKRSolidHeap* param_1, u32 param_2, u8 param_3) { + initAudioThread(param_1, param_2, param_3); } /* 8028FCE4-8028FD04 .text initInterface__8JAIBasicFUc */ -void JAIBasic::initInterface(unsigned char) { - /* Nonmatching */ +void JAIBasic::initInterface(u8) { + initInterfaceMain(); } /* 8028FD04-8028FDC0 .text initInterfaceMain__8JAIBasicFv */ @@ -28,21 +58,42 @@ void JAIBasic::initInterfaceMain() { /* 8028FDC0-8028FE78 .text initHeap__8JAIBasicFv */ void JAIBasic::initHeap() { - /* Nonmatching */ + if (JAIGlobalParameter::interfaceHeapSize) { + field_0x8 = JKRSolidHeap::create(JAIGlobalParameter::interfaceHeapSize, JASDram, false); + msCurrentHeap = field_0x8; + } else { + msCurrentHeap = JASDram; + if (msCurrentHeap) { + return; + } + } + JUT_ASSERT_MSG(186, msCurrentHeap, "JAIBasic::initHeap オーディオヒープが異常（NULL）です。\n"); } /* 8028FE78-8028FF20 .text initArchive__8JAIBasicFv */ void JAIBasic::initArchive() { - /* Nonmatching */ + char buffer[0x60]; + if (!JAISequenceMgr::arcPointer) { + JAISequenceMgr::getArchiveName(buffer); + JAISequenceMgr::arcPointer = JKRArchive::mount(buffer, JKRArchive::MOUNT_DVD, msCurrentHeap, JKRArchive::MOUNT_DIRECTION_HEAD); + JUT_ASSERT_MSG(206, JAISequenceMgr::arcPointer, "JAIBasic::initArchive シーケンスアーカイブのマウントに失敗しました。\n"); + } } /* 8028FF20-8028FFF8 .text initResourcePath__8JAIBasicFv */ void JAIBasic::initResourcePath() { - /* Nonmatching */ + if (JAIGlobalParameter::audioResPath) { + char* wavePath = (char*)JASDram->alloc(strlen(JAIGlobalParameter::audioResPath) + strlen(JAIGlobalParameter::wavePath) + 1, 0); + sprintf(wavePath, "%s%s%c", JAIGlobalParameter::audioResPath, JAIGlobalParameter::wavePath, 0); + JAIGlobalParameter::wavePath = wavePath; + char* streamPath = (char*)JASDram->alloc(strlen(JAIGlobalParameter::audioResPath) + strlen(JAIGlobalParameter::streamPath) + 1, 0); + sprintf(streamPath, "%s%s%c", JAIGlobalParameter::audioResPath, JAIGlobalParameter::streamPath, 0); + JAIGlobalParameter::streamPath = streamPath; + } } /* 8028FFF8-8029002C .text setCameraInfo__8JAIBasicFP3VecP3VecPA4_fUl */ -void JAIBasic::setCameraInfo(Vec*, Vec*, float(*)[4], unsigned long) { +void JAIBasic::setCameraInfo(Vec*, Vec*, f32(*)[4], u32) { /* Nonmatching */ } @@ -53,12 +104,20 @@ void JAIBasic::initStream() { /* 80290068-80290090 .text setRegisterTrackCallback__8JAIBasicFv */ void JAIBasic::setRegisterTrackCallback() { - /* Nonmatching */ + JASystem::TTrack::registerSeqCallback(setParameterSeqSync); } /* 80290090-8029011C .text initAudioThread__8JAIBasicFP12JKRSolidHeapUlUc */ -void JAIBasic::initAudioThread(JKRSolidHeap*, unsigned long, unsigned char) { - /* Nonmatching */ +void JAIBasic::initAudioThread(JKRSolidHeap* param_1, u32 param_2, u8 param_3) { + int r31 = 1; + if (param_3 & 1) { + r31 |= 2; + } + JASystem::TAudioThread::setPriority(JAIGlobalParameter::audioSystemThreadPriority, JAIGlobalParameter::audioDvdThreadPriority); + JASystem::TAudioThread::start(param_1, param_2, r31); + JASystem::TTrack::newMemPool(JAIGlobalParameter::systemTrackMax); + setRegisterTrackCallback(); + JASystem::Driver::setMixerLevel(JAIGlobalParameter::inputGainDown, JAIGlobalParameter::outputGainUp); } /* 8029011C-8029031C .text initCamera__8JAIBasicFv */ @@ -66,14 +125,27 @@ void JAIBasic::initCamera() { /* Nonmatching */ } -/* 8029031C-80290330 .text __defctor__Q27JAInter6CameraFv */ -void JAInter::Camera::__defctor() { - /* Nonmatching */ -} - /* 80290330-8029046C .text initReadFile__8JAIBasicFv */ -void JAIBasic::initReadFile() { +bool JAIBasic::initReadFile() { /* Nonmatching */ + switch (initLoadFileSw) { + case 2: + if (JAIInitData::checkInitDataFile()) { + break; + } + return false; + case 4: + if (JAIInitData::aafPointer) { + JAIInitData::checkInitDataOnMemory(); + break; + } + JUT_ASSERT_MSG(349, JAIInitData::aafPointer, "JAIBasic::initReadFile Init Data Pointer is NULL !!!\n"); + break; + default: + JUT_ASSERT_MSG(353, initLoadFileSw>=JAI_INIT_MODE_MAX, "JAIBasic::initReadFile 初期設定読み込みモードが異常です。\n"); + break; + } + return true; } /* 8029046C-802904B4 .text processFrameWork__8JAIBasicFv */ @@ -82,38 +154,38 @@ void JAIBasic::processFrameWork() { } /* 802904B4-802904EC .text startSoundVec__8JAIBasicFUlPP8JAISoundP3VecUlUlUc */ -void JAIBasic::startSoundVec(unsigned long, JAISound**, Vec*, unsigned long, unsigned long, unsigned char) { +void JAIBasic::startSoundVec(u32, JAISound**, Vec*, u32, u32, u8) { /* Nonmatching */ } /* 802904EC-8029050C .text startSoundActor__8JAIBasicFUlPP8JAISoundPQ27JAInter5ActorUlUc */ -void JAIBasic::startSoundActor(unsigned long, JAISound**, JAInter::Actor*, unsigned long, unsigned char) { - /* Nonmatching */ +void JAIBasic::startSoundActor(u32 param_1, JAISound** param_2, JAInter::Actor* param_3, u32 param_4, u8 param_5) { + startSoundDirectID(param_1, param_2, param_3, param_4, param_5); } /* 8029050C-8029057C .text startSoundDirectID__8JAIBasicFUlPP8JAISoundPQ27JAInter5ActorUlUc */ -void JAIBasic::startSoundDirectID(unsigned long, JAISound**, JAInter::Actor*, unsigned long, unsigned char) { +void JAIBasic::startSoundDirectID(u32, JAISound**, JAInter::Actor*, u32, u8) { /* Nonmatching */ } /* 8029057C-80290708 .text startSoundBasic__8JAIBasicFUlPP8JAISoundPQ27JAInter5ActorUlUcPv */ -void JAIBasic::startSoundBasic(unsigned long, JAISound**, JAInter::Actor*, unsigned long, unsigned char, void*) { +void JAIBasic::startSoundBasic(u32, JAISound**, JAInter::Actor*, u32, u8, void*) { /* Nonmatching */ } /* 80290708-802907E0 .text stopSoundHandle__8JAIBasicFP8JAISoundUl */ -void JAIBasic::stopSoundHandle(JAISound*, unsigned long) { +void JAIBasic::stopSoundHandle(JAISound*, u32) { /* Nonmatching */ } /* 802907E0-80290864 .text stopPlayingCategoryObjectSe__8JAIBasicFUcPv */ -void JAIBasic::stopPlayingCategoryObjectSe(unsigned char, void*) { +void JAIBasic::stopPlayingCategoryObjectSe(u8, void*) { /* Nonmatching */ } /* 80290864-80290884 .text stopAllSe__8JAIBasicFUcPv */ -void JAIBasic::stopAllSe(unsigned char, void*) { - /* Nonmatching */ +void JAIBasic::stopAllSe(u8 param_1, void* param_2) { + stopPlayingCategoryObjectSe(param_1, param_2); } /* 80290884-802908E8 .text stopActorSoundOneBuffer__8JAIBasicFPvP8JAISound */ @@ -122,12 +194,12 @@ void JAIBasic::stopActorSoundOneBuffer(void*, JAISound*) { } /* 802908E8-8029094C .text stopIDSoundOneBuffer__8JAIBasicFUlP8JAISound */ -void JAIBasic::stopIDSoundOneBuffer(unsigned long, JAISound*) { +void JAIBasic::stopIDSoundOneBuffer(u32, JAISound*) { /* Nonmatching */ } /* 8029094C-802909C0 .text stopIDActorSoundOneBuffer__8JAIBasicFUlPvP8JAISound */ -void JAIBasic::stopIDActorSoundOneBuffer(unsigned long, void*, JAISound*) { +void JAIBasic::stopIDActorSoundOneBuffer(u32, void*, JAISound*) { /* Nonmatching */ } @@ -137,12 +209,12 @@ void JAIBasic::stopAllSound(void*) { } /* 80290A5C-80290B64 .text stopAllSound__8JAIBasicFUl */ -void JAIBasic::stopAllSound(unsigned long) { +void JAIBasic::stopAllSound(u32) { /* Nonmatching */ } /* 80290B64-80290C74 .text stopAllSound__8JAIBasicFUlPv */ -void JAIBasic::stopAllSound(unsigned long, void*) { +void JAIBasic::stopAllSound(u32, void*) { /* Nonmatching */ } @@ -152,32 +224,36 @@ void JAIBasic::deleteObject(void*) { } /* 80290D94-80290DA0 .text getMapInfoFxline__8JAIBasicFUl */ -void JAIBasic::getMapInfoFxline(unsigned long) { - /* Nonmatching */ +bool JAIBasic::getMapInfoFxline(u32 param_1) { + return param_1 != 0; } /* 80290DA0-80290DAC .text getMapInfoGround__8JAIBasicFUl */ -void JAIBasic::getMapInfoGround(unsigned long) { - /* Nonmatching */ +bool JAIBasic::getMapInfoGround(u32 param_1) { + return param_1 != 0; } /* 80290DAC-80290DC4 .text getMapInfoFxParameter__8JAIBasicFUl */ -void JAIBasic::getMapInfoFxParameter(unsigned long) { +f32 JAIBasic::getMapInfoFxParameter(u32 param_1) { /* Nonmatching */ + if (param_1 == 0) { + return 0.0f; + } + return 1.0f; } /* 80290DC4-80290E14 .text getSoundOffsetNumberFromID__8JAIBasicFUl */ -void JAIBasic::getSoundOffsetNumberFromID(unsigned long) { +void JAIBasic::getSoundOffsetNumberFromID(u32) { /* Nonmatching */ } /* 80290E14-80290E50 .text setSeCategoryVolume__8JAIBasicFUcUc */ -void JAIBasic::setSeCategoryVolume(unsigned char, unsigned char) { +void JAIBasic::setSeCategoryVolume(u8, u8) { /* Nonmatching */ } /* 80290E50-80291034 .text setParameterSeqSync__8JAIBasicFPQ28JASystem6TTrackUs */ -void JAIBasic::setParameterSeqSync(JASystem::TTrack*, unsigned short) { +u16 JAIBasic::setParameterSeqSync(JASystem::TTrack*, u16) { /* Nonmatching */ } @@ -187,12 +263,12 @@ void JAIBasic::setSeExtParameter(JAISound*) { } /* 80291114-802911A8 .text makeSound__8JAIBasicFUl */ -void JAIBasic::makeSound(unsigned long) { +JAISound* JAIBasic::makeSound(u32) { /* Nonmatching */ } /* 802911A8-80291200 .text allocStreamBuffer__8JAIBasicFPvl */ -void JAIBasic::allocStreamBuffer(void*, long) { +void JAIBasic::allocStreamBuffer(void*, s32) { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAIConst.cpp b/src/JSystem/JAudio/JAIConst.cpp index 22100c3aa..9a874ce0c 100644 --- a/src/JSystem/JAudio/JAIConst.cpp +++ b/src/JSystem/JAudio/JAIConst.cpp @@ -4,24 +4,49 @@ // #include "JSystem/JAudio/JAIConst.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JAudio/JASDvdThread.h" +#include "JSystem/JAudio/JASSystemHeap.h" +#include "JSystem/JKernel/JKRDvdRipper.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "JSystem/JUtility/JUTAssert.h" + +Vec JAInter::Const::dummyZeroVec = {0.0f, 0.0f, 0.0f}; +JMath::TRandom_fast_ JAInter::Const::random(0); /* 80291704-802917D8 .text transInitDataFile__7JAInterFPUcUl */ -void JAInter::transInitDataFile(unsigned char*, unsigned long) { - /* Nonmatching */ +u8* JAInter::transInitDataFile(u8* param_1, u32 param_2) { + u8* var1 = new (JAIBasic::getCurrentJAIHeap(), 0x20) u8[param_2]; + if (var1) { + for (int i = 0; i < param_2; i++) { + var1[i] = param_1[i]; + } + } + return var1; } /* 802917D8-802918CC .text loadTmpDVDFile__7JAInterFPcPPUc */ -void JAInter::loadTmpDVDFile(char*, unsigned char**) { - /* Nonmatching */ +void JAInter::loadTmpDVDFile(char* param_1, u8** tmpPointer) { + u32 size = JASystem::Dvd::checkFile(param_1); + if (size == 0) { + *tmpPointer = NULL; + return; + } + *tmpPointer = (u8*)JASDram->alloc(size, -0x20); + JUT_ASSERT_MSG(113, (*tmpPointer), "JAIBasic::loadTmpDVDFile Cannot Alloc Heap!!\n"); + if (!JKRDvdRipper::loadToMainRAM(param_1, *tmpPointer, EXPAND_SWITCH_UNKNOWN0, 0, NULL, JKRDvdRipper::ALLOC_DIRECTION_FORWARD, 0, NULL)) { + *tmpPointer = NULL; + } } /* 802918CC-802918FC .text deleteTmpDVDFile__7JAInterFPPUc */ -void JAInter::deleteTmpDVDFile(unsigned char**) { - /* Nonmatching */ +void JAInter::deleteTmpDVDFile(u8** tmpPointer) { + if (*tmpPointer) { + JASDram->freeTail(); + } } /* 802918FC-8029193C .text routeToTrack__7JAInterFUl */ -void JAInter::routeToTrack(unsigned long) { +u32 JAInter::routeToTrack(u32) { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAIGlobalParameter.cpp b/src/JSystem/JAudio/JAIGlobalParameter.cpp index 2cf8f38f0..e155ea0ae 100644 --- a/src/JSystem/JAudio/JAIGlobalParameter.cpp +++ b/src/JSystem/JAudio/JAIGlobalParameter.cpp @@ -4,344 +4,425 @@ // #include "JSystem/JAudio/JAIGlobalParameter.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JAudio/JAIInitData.h" +#include "JSystem/JAudio/JAISoundTable.h" +#include "JSystem/JAudio/JAIStreamMgr.h" +#include "JSystem/JAudio/JASDriverIF.h" /* 802920EC-80292100 .text setParamInitDataPointer__18JAIGlobalParameterFPv */ -void JAIGlobalParameter::setParamInitDataPointer(void*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamInitDataPointer(void* value) { + JAInter::InitData::aafPointer = (u32*)value; + JAIBasic::msBasic->initLoadFileSw = 4; } /* 80292100-80292108 .text setParamInterfaceHeapSize__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamInterfaceHeapSize(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamInterfaceHeapSize(u32 value) { + interfaceHeapSize = value; } /* 80292108-80292110 .text setParamSoundSceneMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSoundSceneMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSoundSceneMax(u32 value) { + soundSceneMax = value; } /* 80292110-80292118 .text setParamSeRegistMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSeRegistMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeRegistMax(u32 value) { + seRegistMax = value; } /* 80292118-80292120 .text setParamSeTrackMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSeTrackMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeTrackMax(u32 value) { + seTrackMax = value; } /* 80292120-80292130 .text setParamSeqPlayTrackMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSeqPlayTrackMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeqPlayTrackMax(u32 value) { + seqPlayTrackMax = value; + seqControlBufferMax = value << 1; } /* 80292130-80292138 .text setParamSeqControlBufferMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSeqControlBufferMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeqControlBufferMax(u32 value) { + seqControlBufferMax = value; } /* 80292138-80292140 .text setParamStreamControlBufferMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamStreamControlBufferMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStreamControlBufferMax(u32 value) { + streamControlBufferMax = value; } /* 80292140-80292148 .text setParamAutoHeapMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamAutoHeapMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamAutoHeapMax(u32 value) { + autoHeapMax = value; } /* 80292148-80292150 .text setParamStayHeapMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamStayHeapMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStayHeapMax(u32 value) { + stayHeapMax = value; } /* 80292150-80292158 .text setParamInputGainDown__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamInputGainDown(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamInputGainDown(f32 value) { + inputGainDown = value; } /* 80292158-80292160 .text setParamOutputGainUp__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamOutputGainUp(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamOutputGainUp(f32 value) { + outputGainUp = value; } /* 80292160-80292168 .text setParamDistanceMax__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamDistanceMax(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamDistanceMax(f32 value) { + distanceMax = value; } /* 80292168-80292170 .text setParamMaxVolumeDistance__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamMaxVolumeDistance(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamMaxVolumeDistance(f32 value) { + maxVolumeDistance = value; } /* 80292170-80292178 .text setParamMinDistanceVolume__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamMinDistanceVolume(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamMinDistanceVolume(f32 value) { + minDistanceVolume = value; } /* 80292178-80292180 .text setParamSeDistanceFxParameter__18JAIGlobalParameterFUs */ -void JAIGlobalParameter::setParamSeDistanceFxParameter(unsigned short) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeDistanceFxParameter(u16 value) { + seDistanceFxParameter = value; } /* 80292180-802921A0 .text setParamStreamDecodedBufferBlocks__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamStreamDecodedBufferBlocks(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStreamDecodedBufferBlocks(u32 value) { + JAInter::StreamLib::setDecodedBufferBlocks(value); } /* 802921A0-802921B8 .text setParamStreamInsideBufferCut__18JAIGlobalParameterFb */ -void JAIGlobalParameter::setParamStreamInsideBufferCut(bool) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStreamInsideBufferCut(bool value) { + JAIBasic::msBasic->field_0xe.flag5 = value; } /* 802921B8-802921C0 .text setParamAutoHeapRoomSize__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamAutoHeapRoomSize(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamAutoHeapRoomSize(u32 value) { + autoHeapRoomSize = value; } /* 802921C0-802921C8 .text setParamStayHeapSize__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamStayHeapSize(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStayHeapSize(u32 value) { + stayHeapSize = value; } /* 802921C8-802921F4 .text setParamSeDolbyCenterValue__18JAIGlobalParameterFUc */ -void JAIGlobalParameter::setParamSeDolbyCenterValue(unsigned char) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeDolbyCenterValue(u8 value) { + seDolbyCenterValue = value; } /* 802921F4-802921FC .text setParamSeDolbyFrontDistanceMax__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamSeDolbyFrontDistanceMax(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeDolbyFrontDistanceMax(f32 value) { + seDolbyFrontDistanceMax = value; } /* 802921FC-80292204 .text setParamSeDolbyBehindDistanceMax__18JAIGlobalParameterFf */ -void JAIGlobalParameter::setParamSeDolbyBehindDistanceMax(float) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSeDolbyBehindDistanceMax(f32 value) { + seDolbyBehindDistanceMax = value; } /* 80292204-8029220C .text setParamInitDataFileName__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamInitDataFileName(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamInitDataFileName(char* value) { + initDataFileName = value; } /* 8029220C-80292214 .text setParamWavePath__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamWavePath(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamWavePath(char* value) { + wavePath = value; } /* 80292214-8029221C .text setParamSequenceArchivesPath__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamSequenceArchivesPath(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSequenceArchivesPath(char* value) { + sequenceArchivesPath = value; } /* 8029221C-80292224 .text setParamStreamPath__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamStreamPath(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamStreamPath(char* value) { + streamPath = value; } /* 80292224-8029222C .text setParamAudioResPath__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamAudioResPath(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamAudioResPath(char* value) { + audioResPath = value; } /* 8029222C-80292234 .text setParamSequenceArchivesFileName__18JAIGlobalParameterFPc */ -void JAIGlobalParameter::setParamSequenceArchivesFileName(char*) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSequenceArchivesFileName(char* value) { + sequenceArchivesFileName = value; } /* 80292234-8029223C .text setParamDummyObjectLifeTime__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamDummyObjectLifeTime(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamDummyObjectLifeTime(u32 value) { + dummyObjectLifeTime = value; } /* 8029223C-80292244 .text setParamDummyObjectMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamDummyObjectMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamDummyObjectMax(u32 value) { + dummyObjectMax = value; } /* 80292244-8029224C .text setParamAudioCameraMax__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamAudioCameraMax(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamAudioCameraMax(u32 value) { + audioCameraMax = value; } /* 8029224C-80292254 .text setParamSystemTrackMax__18JAIGlobalParameterFl */ -void JAIGlobalParameter::setParamSystemTrackMax(long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSystemTrackMax(s32 value) { + systemTrackMax = value; } /* 80292254-80292334 .text setParamSoundOutputMode__18JAIGlobalParameterFUl */ -void JAIGlobalParameter::setParamSoundOutputMode(unsigned long) { - /* Nonmatching */ +void JAIGlobalParameter::setParamSoundOutputMode(u32 value) { + int r31 = 1; + int r30 = 0; + switch (value) { + case 0: + r31 = 0; + r30 = 0; + break; + case 1: + r31 = 1; + r30 = 1; + break; + case 2: + r31 = 2; + r30 = 1; + break; + default: + JUT_ASSERT_MSG(345, 0, "JAIGlobalParameter::setParamSoundOutputMode 出力モードが不正です。\n"); + break; + } + JAIBasic::msBasic->field_0xd = value; + JASystem::Driver::setOutputMode(r31); + JAInter::StreamLib::setOutputMode(r30); } /* 80292334-80292358 .text getParamSeCategoryMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeCategoryMax() { - /* Nonmatching */ +int JAIGlobalParameter::getParamSeCategoryMax() { + return JAInter::SoundTable::getCategotyMax(); } /* 80292358-80292360 .text getParamSoundSceneMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSoundSceneMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSoundSceneMax() { + return soundSceneMax; } /* 80292360-80292368 .text getParamSeRegistMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeRegistMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeRegistMax() { + return seRegistMax; } /* 80292368-80292370 .text getParamSeTrackMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeTrackMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeTrackMax() { + return seTrackMax; } /* 80292370-80292378 .text getParamSeqTrackMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqTrackMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeqTrackMax() { + return seqTrackMax; } /* 80292378-80292380 .text getParamSeqControlBufferMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqControlBufferMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeqControlBufferMax() { + return seqControlBufferMax; } /* 80292380-80292388 .text getParamStreamControlBufferMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStreamControlBufferMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamStreamControlBufferMax() { + return streamControlBufferMax; } /* 80292388-80292390 .text getParamStreamParameterBufferMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStreamParameterBufferMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamStreamParameterBufferMax() { + return streamParameterBufferMax; } /* 80292390-80292398 .text getParamAutoHeapMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamAutoHeapMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamAutoHeapMax() { + return autoHeapMax; } /* 80292398-802923A0 .text getParamStayHeapMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStayHeapMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamStayHeapMax() { + return stayHeapMax; } /* 802923A0-802923A8 .text getParamSeqPlayTrackMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqPlayTrackMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeqPlayTrackMax() { + return seqPlayTrackMax; } /* 802923A8-802923B0 .text getParamDistanceMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamDistanceMax() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamDistanceMax() { + return distanceMax; } /* 802923B0-802923B8 .text getParamMaxVolumeDistance__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamMaxVolumeDistance() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamMaxVolumeDistance() { + return maxVolumeDistance; } /* 802923B8-802923C0 .text getParamMinDistanceVolume__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamMinDistanceVolume() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamMinDistanceVolume() { + return minDistanceVolume; } /* 802923C0-802923C8 .text getParamAutoHeapRoomSize__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamAutoHeapRoomSize() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamAutoHeapRoomSize() { + return autoHeapRoomSize; } /* 802923C8-802923D0 .text getParamStayHeapSize__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStayHeapSize() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamStayHeapSize() { + return stayHeapSize; } /* 802923D0-802923D8 .text getParamSeDolbyCenterValue__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeDolbyCenterValue() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamSeDolbyCenterValue() { + return seDolbyCenterValue; } /* 802923D8-802923E0 .text getParamSeDolbyFrontDistanceMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeDolbyFrontDistanceMax() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamSeDolbyFrontDistanceMax() { + return seDolbyFrontDistanceMax; } /* 802923E0-802923E8 .text getParamSeDolbyBehindDistanceMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeDolbyBehindDistanceMax() { - /* Nonmatching */ +f32 JAIGlobalParameter::getParamSeDolbyBehindDistanceMax() { + return seDolbyBehindDistanceMax; } /* 802923E8-802923F0 .text getParamInitDataFileName__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamInitDataFileName() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamInitDataFileName() { + return initDataFileName; } /* 802923F0-802923F8 .text getParamWavePath__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamWavePath() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamWavePath() { + return wavePath; } /* 802923F8-80292400 .text getParamSequenceArchivesPath__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSequenceArchivesPath() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamSequenceArchivesPath() { + return sequenceArchivesPath; } /* 80292400-80292408 .text getParamStreamPath__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStreamPath() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamStreamPath() { + return streamPath; } /* 80292408-80292410 .text getParamAudioResPath__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamAudioResPath() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamAudioResPath() { + return audioResPath; } /* 80292410-80292418 .text getParamSequenceArchivesFileName__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSequenceArchivesFileName() { - /* Nonmatching */ +char* JAIGlobalParameter::getParamSequenceArchivesFileName() { + return sequenceArchivesFileName; } /* 80292418-80292420 .text getParamDopplarMoveTime__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamDopplarMoveTime() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamDopplarMoveTime() { + return dopplarMoveTime; } /* 80292420-80292428 .text getParamDistanceParameterMoveTime__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamDistanceParameterMoveTime() { - /* Nonmatching */ +u8 JAIGlobalParameter::getParamDistanceParameterMoveTime() { + return distanceParameterMoveTime; } /* 80292428-80292430 .text getParamDummyObjectMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamDummyObjectMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamDummyObjectMax() { + return dummyObjectMax; } /* 80292430-80292438 .text getParamSeqMuteVolumeSePlay__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqMuteVolumeSePlay() { - /* Nonmatching */ +u8 JAIGlobalParameter::getParamSeqMuteVolumeSePlay() { + return seqMuteVolumeSePlay; } /* 80292438-80292440 .text getParamSeqMuteMoveSpeedSePlay__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqMuteMoveSpeedSePlay() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamSeqMuteMoveSpeedSePlay() { + return seqMuteMoveSpeedSePlay; } /* 80292440-80292448 .text getParamAudioCameraMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamAudioCameraMax() { - /* Nonmatching */ +u32 JAIGlobalParameter::getParamAudioCameraMax() { + return audioCameraMax; } /* 80292448-80292450 .text getParamSeqParameterLines__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeqParameterLines() { - /* Nonmatching */ +u8 JAIGlobalParameter::getParamSeqParameterLines() { + return seqParameterLines; } /* 80292450-80292458 .text getParamStreamParameterLines__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamStreamParameterLines() { - /* Nonmatching */ +u8 JAIGlobalParameter::getParamStreamParameterLines() { + return streamParameterLines; } /* 80292458-80292460 .text getParamSeDistanceWaitMax__18JAIGlobalParameterFv */ -void JAIGlobalParameter::getParamSeDistanceWaitMax() { - /* Nonmatching */ +u16 JAIGlobalParameter::getParamSeDistanceWaitMax() { + return seDistanceWaitMax; } + +static void dummy() { + OSReport("Seqs/JaiSeInf.bst"); +} + +u8 JAIGlobalParameter::distanceParameterMoveTime = 3; +u8 JAIGlobalParameter::audioSystemThreadPriority = 2; +u8 JAIGlobalParameter::audioDvdThreadPriority = 3; +u8 JAIGlobalParameter::seqMuteVolumeSePlay = 0x28; +u8 JAIGlobalParameter::seqParameterLines = 7; +u8 JAIGlobalParameter::streamParameterLines = 7; +u16 JAIGlobalParameter::seDistanceFxParameter = 0x96; +u32 JAIGlobalParameter::soundSceneMax = 2; +u32 JAIGlobalParameter::seRegistMax = 0x14; +u32 JAIGlobalParameter::seTrackMax = 0x20; +u32 JAIGlobalParameter::seqTrackMax = 0x20; +u32 JAIGlobalParameter::seqPlayTrackMax = 8; +u32 JAIGlobalParameter::seqControlBufferMax = 8; +u32 JAIGlobalParameter::streamControlBufferMax = 2; +u32 JAIGlobalParameter::streamParameterBufferMax = 2; +u32 JAIGlobalParameter::autoHeapMax = 2; +u32 JAIGlobalParameter::stayHeapMax = 2; +u32 JAIGlobalParameter::autoHeapRoomSize = 0xC000; +u32 JAIGlobalParameter::stayHeapSize = 0x00010000; +char* JAIGlobalParameter::initDataFileName = "JaiInit.aaf"; +char* JAIGlobalParameter::wavePath = "Banks/"; +char* JAIGlobalParameter::sequenceArchivesPath = "Seqs/"; +char* JAIGlobalParameter::streamPath = "Stream/"; +char* JAIGlobalParameter::audioResPath = "AudioRes/"; +char* JAIGlobalParameter::sequenceArchivesFileName = "JaiSeqs.arc"; +f32 JAIGlobalParameter::inputGainDown = 0.5f; +f32 JAIGlobalParameter::outputGainUp = 1.2f; +f32 JAIGlobalParameter::distanceMax = 5000.0f; +f32 JAIGlobalParameter::maxVolumeDistance = 1000.0f; +f32 JAIGlobalParameter::seDolbyCenterValue = 30.f; +f32 JAIGlobalParameter::seDolbyFrontDistanceMax = -300.0f; +f32 JAIGlobalParameter::seDolbyBehindDistanceMax = 1000.0f; +u32 JAIGlobalParameter::dopplarMoveTime = 0x0f; +u32 JAIGlobalParameter::dummyObjectLifeTime = 0x0258; +u32 JAIGlobalParameter::dummyObjectMax = 0x0a; +u32 JAIGlobalParameter::seqMuteMoveSpeedSePlay = 3; +u32 JAIGlobalParameter::audioCameraMax = 1; +s32 JAIGlobalParameter::systemTrackMax = 0x0100; +f32 JAIGlobalParameter::panDistanceMax = 500.0f; +f32 JAIGlobalParameter::panDistance2Max = 1000.0f; +f32 JAIGlobalParameter::panAngleParameter = 12.0f; +f32 JAIGlobalParameter::panAngleParameter2 = 2.4f; +f32 JAIGlobalParameter::dopplarParameter = 3200.0f; +u16 JAIGlobalParameter::seDistanceWaitMax = 0xc; +f32 JAIGlobalParameter::seDistancepitchMax = 0.2f; + +u16 JAIGlobalParameter::seDefaultFx; +u32 JAIGlobalParameter::interfaceHeapSize; +f32 JAIGlobalParameter::minDistanceVolume; diff --git a/src/JSystem/JAudio/JAIInitData.cpp b/src/JSystem/JAudio/JAIInitData.cpp index 5f2603000..08618255c 100644 --- a/src/JSystem/JAudio/JAIInitData.cpp +++ b/src/JSystem/JAudio/JAIInitData.cpp @@ -4,11 +4,36 @@ // #include "JSystem/JAudio/JAIInitData.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBankWave.h" +#include "JSystem/JAudio/JAIConst.h" +#include "JSystem/JAudio/JAIGlobalParameter.h" +#include "JSystem/JAudio/JAISoundTable.h" +#include "JSystem/JAudio/JAIStreamMgr.h" +#include "JSystem/JAudio/JAISystemInterface.h" +#include "JSystem/JAudio/JASSystemHeap.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "MSL_C/string.h" + +u32* JAInter::InitData::aafPointer; /* 80292460-80292548 .text checkInitDataFile__Q27JAInter8InitDataFv */ -void JAInter::InitData::checkInitDataFile() { - /* Nonmatching */ +BOOL JAInter::InitData::checkInitDataFile() { + if (!SystemInterface::checkFileExsistence(JAIGlobalParameter::getParamInitDataFileName())) { + char* fileName = (char*)JASDram->alloc(strlen(JAIGlobalParameter::getParamAudioResPath()) + strlen(JAIGlobalParameter::getParamInitDataFileName()) + 1, 0); + sprintf(fileName, "%s%s%c", JAIGlobalParameter::getParamAudioResPath(), JAIGlobalParameter::getParamInitDataFileName(), 0); + JAIGlobalParameter::setParamInitDataFileName(fileName); + if (!SystemInterface::checkFileExsistence(JAIGlobalParameter::getParamInitDataFileName())) { + return false; + } + } + loadTmpDVDFile(JAIGlobalParameter::getParamInitDataFileName(), (u8**)&aafPointer); + if (aafPointer) { + checkInitDataOnMemory(); + deleteTmpDVDFile((u8**)&aafPointer); + return true; + } + return false; } /* 80292548-8029285C .text checkInitDataOnMemory__Q27JAInter8InitDataFv */ diff --git a/src/JSystem/JAudio/JAISequenceMgr.cpp b/src/JSystem/JAudio/JAISequenceMgr.cpp index 316293061..a54633be2 100644 --- a/src/JSystem/JAudio/JAISequenceMgr.cpp +++ b/src/JSystem/JAudio/JAISequenceMgr.cpp @@ -4,41 +4,115 @@ // #include "JSystem/JAudio/JAISequenceMgr.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JAudio/JAIGlobalParameter.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "MSL_C/string.h" + +JAInter::LinkSound JAInter::SequenceMgr::seqControl; +JAInter::SeqUpdateData* JAInter::SequenceMgr::seqTrackInfo; +int* JAInter::SequenceMgr::FixSeqBufPointer; +JKRArchive* JAInter::SequenceMgr::arcPointer; /* 80295684-802960A0 .text init__Q27JAInter11SequenceMgrFv */ void JAInter::SequenceMgr::init() { /* Nonmatching */ + JAIBasic* basic = JAIBasic::getInterface(); + JAISound* soundObjects = basic->makeSound(JAIGlobalParameter::getParamSeqControlBufferMax()); + JUT_ASSERT_MSG(41, soundObjects, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + FixSeqBufPointer = new (JAIBasic::getCurrentJAIHeap(), 0x20) int[JAIGlobalParameter::getParamSeqPlayTrackMax()]; + seqControl.init(soundObjects, JAIGlobalParameter::getParamSeqControlBufferMax()); + for (int i = 0; i < JAIGlobalParameter::getParamSeqControlBufferMax(); i++) { + SeqParameter* _para = new (JAIBasic::getCurrentJAIHeap(), 0x20) SeqParameter(); + JUT_ASSERT_MSG(47, _para, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + seqControl.field_0x8[i].field_0x3c = _para; + _para->seqPan = new (JAIBasic::getCurrentJAIHeap(), 0x20) MoveParaSet[JAIGlobalParameter::getParamSeqParameterLines()]; + JUT_ASSERT_MSG(50, _para->seqPan, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + _para->seqPitch = new (JAIBasic::getCurrentJAIHeap(), 0x20) MoveParaSet[JAIGlobalParameter::getParamSeqParameterLines()]; + JUT_ASSERT_MSG(52, _para->seqPitch, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + _para->seqFxmix = new (JAIBasic::getCurrentJAIHeap(), 0x20) MoveParaSet[JAIGlobalParameter::getParamSeqParameterLines()]; + JUT_ASSERT_MSG(54, _para->seqFxmix, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + _para->seqDolby = new (JAIBasic::getCurrentJAIHeap(), 0x20) MoveParaSet[JAIGlobalParameter::getParamSeqParameterLines()]; + JUT_ASSERT_MSG(56, _para->seqDolby, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + } + FixSeqBufPointer = new (JAIBasic::getCurrentJAIHeap(), 0x20) int[JAIGlobalParameter::getParamSeqPlayTrackMax()]; + JUT_ASSERT_MSG(60, FixSeqBufPointer, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + seqTrackInfo = new (JAIBasic::getCurrentJAIHeap(), 0x20) SeqUpdateData[JAIGlobalParameter::getParamSeqPlayTrackMax()]; + JUT_ASSERT_MSG(62, seqTrackInfo, "JAISequenceMgr::initHeap Cannot Alloc Heap!!\n"); + for (int i = 0; i < JAIGlobalParameter::getParamSeqPlayTrackMax(); i++) { + FixSeqBufPointer[i] = 0; + SeqUpdateData* update = &seqTrackInfo[i]; + update->field_0xc = 1.0f; + update->field_0x18 = 0.5f; + update->field_0x10 = 1.0f; + update->field_0x14 = 0.0f; + update->field_0x1c = 0.0f; + update->field_0x20 = 1.0f; + for (int j = 0; j < JAIGlobalParameter::getParamSeqTrackMax(); j++) { + update->trackVolume[j] = 1.0f; + update->trackPan[j] = 64.0f; + update->trackPitch[j] = 1.0f; + update->trackFxmix[j] = 0.0f; + update->trackDolby[j] = 0.0f; + update->trackupdate[j] = 0; + } + } } /* 802960A0-80296744 .text __ct__Q27JAInter13SeqUpdateDataFv */ JAInter::SeqUpdateData::SeqUpdateData() { - /* Nonmatching */ + field_0x0 = 0; + field_0x1 = 0; + field_0x2 = 0; + field_0x3 = 0; + field_0x8 = 0; + field_0x48 = 0; + systemTrackParameter = new (JAIBasic::getCurrentJAIHeap(), 0x20) PlayerParameter[33]; + JUT_ASSERT_MSG(81, systemTrackParameter, "JAISeqUpdateData Cannot alloc Heap!!\n"); + trackVolume = new (JAIBasic::getCurrentJAIHeap(), 0x20) f32[JAIGlobalParameter::getParamSeqTrackMax()]; + JUT_ASSERT_MSG(83, trackVolume, "JAISeqUpdateData Cannot Alloc Heap!!\n"); + trackPan = new (JAIBasic::getCurrentJAIHeap(), 0x20) f32[JAIGlobalParameter::getParamSeqTrackMax()]; + JUT_ASSERT_MSG(85, trackPan, "JAISeqUpdateData Cannot Alloc Heap!!\n"); + trackPitch = new (JAIBasic::getCurrentJAIHeap(), 0x20) f32[JAIGlobalParameter::getParamSeqTrackMax()]; + JUT_ASSERT_MSG(87, trackPitch, "JAISeqUpdateData Cannot Alloc Heap!!\n"); + trackFxmix = new (JAIBasic::getCurrentJAIHeap(), 0x20) f32[JAIGlobalParameter::getParamSeqTrackMax()]; + JUT_ASSERT_MSG(89, trackFxmix, "JAISeqUpdateData Cannot Alloc Heap!!\n"); + trackDolby = new (JAIBasic::getCurrentJAIHeap(), 0x20) f32[JAIGlobalParameter::getParamSeqTrackMax()]; + JUT_ASSERT_MSG(91, trackDolby, "JAISeqUpdateData Cannot Alloc Heap!!\n"); + trackupdate = new (JAIBasic::getCurrentJAIHeap(), 0x20) int[JAIGlobalParameter::getParamSeqTrackMax() + 1]; + JUT_ASSERT_MSG(99, trackupdate, "JAISeqUpdateData Cannot Alloc Heap!!\n"); } /* 80296744-80296780 .text __dt__Q27JAInter15PlayerParameterFv */ -JAInter::PlayerParameter::~PlayerParameter() { - /* Nonmatching */ -} +JAInter::PlayerParameter::~PlayerParameter() {} /* 80296780-802967B4 .text __ct__Q27JAInter15PlayerParameterFv */ -JAInter::PlayerParameter::PlayerParameter() { - /* Nonmatching */ -} +JAInter::PlayerParameter::PlayerParameter() {} /* 802967B4-80296820 .text getArchiveName__Q27JAInter11SequenceMgrFPc */ -void JAInter::SequenceMgr::getArchiveName(char*) { - /* Nonmatching */ +void JAInter::SequenceMgr::getArchiveName(char* buffer) { + buffer[0] = 0; + if (JAIGlobalParameter::getParamAudioResPath()) { + strcat(buffer, JAIGlobalParameter::getParamAudioResPath()); + } + strcat(buffer, JAIGlobalParameter::getParamSequenceArchivesPath()); + strcat(buffer, JAIGlobalParameter::getParamSequenceArchivesFileName()); } /* 80296820-80296828 .text setArchivePointer__Q27JAInter11SequenceMgrFP10JKRArchive */ -void JAInter::SequenceMgr::setArchivePointer(JKRArchive*) { - /* Nonmatching */ +void JAInter::SequenceMgr::setArchivePointer(JKRArchive* param_1) { + arcPointer = param_1; } /* 80296828-80296860 .text processGFrameSequence__Q27JAInter11SequenceMgrFv */ void JAInter::SequenceMgr::processGFrameSequence() { - /* Nonmatching */ + checkEntriedSeq(); + checkFadeoutSeq(); + checkStoppedSeq(); + checkPlayingSeq(); + checkStartedSeq(); + checkReadSeq(); + checkSeqWave(); } /* 80296860-80296C24 .text checkEntriedSeq__Q27JAInter11SequenceMgrFv */ @@ -77,22 +151,22 @@ void JAInter::SequenceMgr::checkSeqWave() { } /* 80297238-80297378 .text checkPlayingSeqUpdateMultiplication__Q27JAInter11SequenceMgrFUlUcUlPQ27JAInter11MoveParaSetPUlUcPf */ -void JAInter::SequenceMgr::checkPlayingSeqUpdateMultiplication(unsigned long, unsigned char, unsigned long, JAInter::MoveParaSet*, unsigned long*, unsigned char, float*) { +void JAInter::SequenceMgr::checkPlayingSeqUpdateMultiplication(u32, u8, u32, JAInter::MoveParaSet*, u32*, u8, f32*) { /* Nonmatching */ } /* 80297378-802974F8 .text checkPlayingSeqUpdateAddition__Q27JAInter11SequenceMgrFUlUcUlPQ27JAInter11MoveParaSetPUlUcPff */ -void JAInter::SequenceMgr::checkPlayingSeqUpdateAddition(unsigned long, unsigned char, unsigned long, JAInter::MoveParaSet*, unsigned long*, unsigned char, float*, float) { +void JAInter::SequenceMgr::checkPlayingSeqUpdateAddition(u32, u8, u32, JAInter::MoveParaSet*, u32*, u8, f32*, f32) { /* Nonmatching */ } /* 802974F8-80297618 .text checkPlayingSeqUpdateTrack__Q27JAInter11SequenceMgrFUlUlPQ27JAInter11MoveParaSetPUlUcPf */ -void JAInter::SequenceMgr::checkPlayingSeqUpdateTrack(unsigned long, unsigned long, JAInter::MoveParaSet*, unsigned long*, unsigned char, float*) { +void JAInter::SequenceMgr::checkPlayingSeqUpdateTrack(u32, u32, JAInter::MoveParaSet*, u32*, u8, f32*) { /* Nonmatching */ } /* 80297618-80297E18 .text checkPlayingSeqTrack__Q27JAInter11SequenceMgrFUl */ -void JAInter::SequenceMgr::checkPlayingSeqTrack(unsigned long) { +void JAInter::SequenceMgr::checkPlayingSeqTrack(u32) { /* Nonmatching */ } @@ -102,41 +176,32 @@ void JAInter::SequenceMgr::stopSeq(JAISound*) { } /* 80297F14-80297FD0 .text checkDvdLoadArc__Q27JAInter11SequenceMgrFUlUl */ -void JAInter::SequenceMgr::checkDvdLoadArc(unsigned long, unsigned long) { +void JAInter::SequenceMgr::checkDvdLoadArc(u32, u32) { /* Nonmatching */ } /* 80297FD0-80298208 .text storeSeqBuffer__Q27JAInter11SequenceMgrFPP8JAISoundPQ27JAInter5ActorUlUlUcPv */ -void JAInter::SequenceMgr::storeSeqBuffer(JAISound**, JAInter::Actor*, unsigned long, unsigned long, unsigned char, void*) { +void JAInter::SequenceMgr::storeSeqBuffer(JAISound**, JAInter::Actor*, u32, u32, u8, void*) { /* Nonmatching */ } /* 80298208-802982C0 .text releaseSeqBuffer__Q27JAInter11SequenceMgrFP8JAISoundUl */ -void JAInter::SequenceMgr::releaseSeqBuffer(JAISound*, unsigned long) { +void JAInter::SequenceMgr::releaseSeqBuffer(JAISound*, u32) { /* Nonmatching */ } /* 802982C0-802982D0 .text getPlayTrackInfo__Q27JAInter11SequenceMgrFUl */ -void JAInter::SequenceMgr::getPlayTrackInfo(unsigned long) { +int JAInter::SequenceMgr::getPlayTrackInfo(u32) { /* Nonmatching */ } /* 802982D0-802982F0 .text __ct__Q27JAInter7MuteBitFv */ JAInter::MuteBit::MuteBit() { - /* Nonmatching */ -} - -/* 802982F0-8029832C .text __dt__Q38JASystem6Kernel8TPortCmdFv */ -JASystem::Kernel::TPortCmd::~TPortCmd() { - /* Nonmatching */ -} - -/* 8029832C-80298334 .text getInterface__8JAIBasicFv */ -void JAIBasic::getInterface() { - /* Nonmatching */ + flag1 = 0; + flag3 = 0; } /* 80298334-8029859C .text init__Q27JAInter12SeqParameterFv */ -void JAInter::SeqParameter::init() { +int JAInter::SeqParameter::init() { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAISound.cpp b/src/JSystem/JAudio/JAISound.cpp index a8f5ced68..779fa5de9 100644 --- a/src/JSystem/JAudio/JAISound.cpp +++ b/src/JSystem/JAudio/JAISound.cpp @@ -4,185 +4,192 @@ // #include "JSystem/JAudio/JAISound.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" /* 8029859C-802985C4 .text __ct__8JAISoundFv */ JAISound::JAISound() { - /* Nonmatching */ + field_0x3c = NULL; + field_0x5 = 0; + field_0x6 = 10; + field_0x24 = NULL; } /* 802985C4-802985E8 .text getSeCategoryNumber__8JAISoundFv */ -void JAISound::getSeCategoryNumber() { +int JAISound::getSeCategoryNumber() { /* Nonmatching */ } /* 802985E8-802985F4 .text getSwBit__8JAISoundFv */ -void JAISound::getSwBit() { +int JAISound::getSwBit() { /* Nonmatching */ } /* 802985F4-80298624 .text checkSwBit__8JAISoundFUl */ -void JAISound::checkSwBit(unsigned long) { - /* Nonmatching */ +int JAISound::checkSwBit(u32 param_1) { + return param_1 & getSwBit(); } /* 80298624-80298630 .text getInfoPriority__8JAISoundFv */ -void JAISound::getInfoPriority() { +u8 JAISound::getInfoPriority() { /* Nonmatching */ } /* 80298630-80298648 .text clearMainSoundPPointer__8JAISoundFv */ void JAISound::clearMainSoundPPointer() { - /* Nonmatching */ + if (!field_0x38) { + return; + } + field_0x38[0] = NULL; } /* 80298648-80298688 .text start__8JAISoundFUl */ -void JAISound::start(unsigned long) { - /* Nonmatching */ +void JAISound::start(u32 param_1) { + setPrepareFlag(0); + field_0x14 = param_1; } /* 80298688-802986B8 .text stop__8JAISoundFUl */ -void JAISound::stop(unsigned long) { - /* Nonmatching */ +void JAISound::stop(u32 param_1) { + JAIBasic::msBasic->stopSoundHandle(this, param_1); } /* 802986B8-8029878C .text setVolume__8JAISoundFfUlUc */ -void JAISound::setVolume(float, unsigned long, unsigned char) { +void JAISound::setVolume(f32, u32, u8) { /* Nonmatching */ } /* 8029878C-80298864 .text setPan__8JAISoundFfUlUc */ -void JAISound::setPan(float, unsigned long, unsigned char) { +void JAISound::setPan(f32, u32, u8) { /* Nonmatching */ } /* 80298864-8029893C .text setPitch__8JAISoundFfUlUc */ -void JAISound::setPitch(float, unsigned long, unsigned char) { +void JAISound::setPitch(f32, u32, u8) { /* Nonmatching */ } /* 8029893C-80298A04 .text setFxmix__8JAISoundFfUlUc */ -void JAISound::setFxmix(float, unsigned long, unsigned char) { +void JAISound::setFxmix(f32, u32, u8) { /* Nonmatching */ } /* 80298A04-80298ACC .text setDolby__8JAISoundFfUlUc */ -void JAISound::setDolby(float, unsigned long, unsigned char) { +void JAISound::setDolby(f32, u32, u8) { /* Nonmatching */ } /* 80298ACC-80298B74 .text setTempoProportion__8JAISoundFfUl */ -void JAISound::setTempoProportion(float, unsigned long) { +void JAISound::setTempoProportion(f32, u32) { /* Nonmatching */ } /* 80298B74-80298C28 .text setPortData__8JAISoundFUcUs */ -void JAISound::setPortData(unsigned char, unsigned short) { +void JAISound::setPortData(u8, u16) { /* Nonmatching */ } /* 80298C28-80298CD8 .text setPrepareFlag__8JAISoundFUc */ -void JAISound::setPrepareFlag(unsigned char) { +void JAISound::setPrepareFlag(u8) { /* Nonmatching */ } /* 80298CD8-80298E30 .text setDistanceVolumeCommon__8JAISoundFfUc */ -void JAISound::setDistanceVolumeCommon(float, unsigned char) { +f32 JAISound::setDistanceVolumeCommon(f32, u8) { /* Nonmatching */ } /* 80298E30-80298F8C .text setDistancePanCommon__8JAISoundFv */ -void JAISound::setDistancePanCommon() { +f32 JAISound::setDistancePanCommon() { /* Nonmatching */ } /* 80298F8C-80299178 .text setPositionDopplarCommon__8JAISoundFUl */ -void JAISound::setPositionDopplarCommon(unsigned long) { +f32 JAISound::setPositionDopplarCommon(u32) { /* Nonmatching */ } /* 80299178-8029925C .text setSeqInterVolume__8JAISoundFUcfUl */ -void JAISound::setSeqInterVolume(unsigned char, float, unsigned long) { +void JAISound::setSeqInterVolume(u8, f32, u32) { /* Nonmatching */ } /* 8029925C-802993AC .text setSeqInterPan__8JAISoundFUcfUl */ -void JAISound::setSeqInterPan(unsigned char, float, unsigned long) { +void JAISound::setSeqInterPan(u8, f32, u32) { /* Nonmatching */ } /* 802993AC-802994FC .text setSeqInterPitch__8JAISoundFUcfUl */ -void JAISound::setSeqInterPitch(unsigned char, float, unsigned long) { +void JAISound::setSeqInterPitch(u8, f32, u32) { /* Nonmatching */ } /* 802994FC-8029964C .text setSeqInterFxmix__8JAISoundFUcfUl */ -void JAISound::setSeqInterFxmix(unsigned char, float, unsigned long) { +void JAISound::setSeqInterFxmix(u8, f32, u32) { /* Nonmatching */ } /* 8029964C-802997E4 .text setSeqInterDolby__8JAISoundFUcfUl */ -void JAISound::setSeqInterDolby(unsigned char, float, unsigned long) { +void JAISound::setSeqInterDolby(u8, f32, u32) { /* Nonmatching */ } /* 802997E4-80299884 .text setSeqTempoProportion__8JAISoundFfUl */ -void JAISound::setSeqTempoProportion(float, unsigned long) { +void JAISound::setSeqTempoProportion(f32, u32) { /* Nonmatching */ } /* 80299884-802999F4 .text setSeqPortData__8JAISoundFUcUsUl */ -void JAISound::setSeqPortData(unsigned char, unsigned short, unsigned long) { +void JAISound::setSeqPortData(u8, u16, u32) { /* Nonmatching */ } /* 802999F4-80299B14 .text setTrackVolume__8JAISoundFUcfUl */ -void JAISound::setTrackVolume(unsigned char, float, unsigned long) { +void JAISound::setTrackVolume(u8, f32, u32) { /* Nonmatching */ } /* 80299B14-80299BAC .text setTrackInterruptSwitch__8JAISoundFUcUc */ -void JAISound::setTrackInterruptSwitch(unsigned char, unsigned char) { +void JAISound::setTrackInterruptSwitch(u8, u8) { /* Nonmatching */ } /* 80299BAC-80299CD4 .text setTrackPortData__8JAISoundFUcUcUs */ -void JAISound::setTrackPortData(unsigned char, unsigned char, unsigned short) { +void JAISound::setTrackPortData(u8, u8, u16) { /* Nonmatching */ } /* 80299CD4-80299DE8 .text setSeInterRandomPara__8JAISoundFPfUlff */ -void JAISound::setSeInterRandomPara(float*, unsigned long, float, float) { +void JAISound::setSeInterRandomPara(f32*, u32, f32, f32) { /* Nonmatching */ } /* 80299DE8-80299E88 .text setSeInterVolume__8JAISoundFUcfUlUc */ -void JAISound::setSeInterVolume(unsigned char, float, unsigned long, unsigned char) { +void JAISound::setSeInterVolume(u8, f32, u32, u8) { /* Nonmatching */ } /* 80299E88-80299F28 .text setSeInterPan__8JAISoundFUcfUlUc */ -void JAISound::setSeInterPan(unsigned char, float, unsigned long, unsigned char) { +void JAISound::setSeInterPan(u8, f32, u32, u8) { /* Nonmatching */ } /* 80299F28-80299FE0 .text setSeInterPitch__8JAISoundFUcfUlf */ -void JAISound::setSeInterPitch(unsigned char, float, unsigned long, float) { +void JAISound::setSeInterPitch(u8, f32, u32, f32) { /* Nonmatching */ } /* 80299FE0-8029A080 .text setSeInterFxmix__8JAISoundFUcfUlUc */ -void JAISound::setSeInterFxmix(unsigned char, float, unsigned long, unsigned char) { +void JAISound::setSeInterFxmix(u8, f32, u32, u8) { /* Nonmatching */ } /* 8029A080-8029A120 .text setSeInterDolby__8JAISoundFUcfUlUc */ -void JAISound::setSeInterDolby(unsigned char, float, unsigned long, unsigned char) { +void JAISound::setSeInterDolby(u8, f32, u32, u8) { /* Nonmatching */ } /* 8029A120-8029A1C4 .text setSePortData__8JAISoundFUcUs */ -void JAISound::setSePortData(unsigned char, unsigned short) { +void JAISound::setSePortData(u8, u16) { /* Nonmatching */ } @@ -192,17 +199,17 @@ void JAISound::setSeDistanceParameters() { } /* 8029A2E4-8029A364 .text setSeDistanceVolume__8JAISoundFUc */ -void JAISound::setSeDistanceVolume(unsigned char) { +void JAISound::setSeDistanceVolume(u8) { /* Nonmatching */ } /* 8029A364-8029A3BC .text setSeDistancePan__8JAISoundFUc */ -void JAISound::setSeDistancePan(unsigned char) { +void JAISound::setSeDistancePan(u8) { /* Nonmatching */ } /* 8029A3BC-8029A544 .text setSeDistancePitch__8JAISoundFUc */ -void JAISound::setSeDistancePitch(unsigned char) { +void JAISound::setSeDistancePitch(u8) { /* Nonmatching */ } @@ -212,107 +219,107 @@ void JAISound::setSePositionDopplar() { } /* 8029A5CC-8029A6B0 .text setSeDistanceFxmix__8JAISoundFUc */ -void JAISound::setSeDistanceFxmix(unsigned char) { +void JAISound::setSeDistanceFxmix(u8) { /* Nonmatching */ } /* 8029A6B0-8029A6B4 .text setSeDistanceFir__8JAISoundFUc */ -void JAISound::setSeDistanceFir(unsigned char) { +void JAISound::setSeDistanceFir(u8) { /* Nonmatching */ } /* 8029A6B4-8029A788 .text setSeDistanceDolby__8JAISoundFUc */ -void JAISound::setSeDistanceDolby(unsigned char) { +void JAISound::setSeDistanceDolby(u8) { /* Nonmatching */ } /* 8029A788-8029A86C .text setStreamInterVolume__8JAISoundFUcfUl */ -void JAISound::setStreamInterVolume(unsigned char, float, unsigned long) { +void JAISound::setStreamInterVolume(u8, f32, u32) { /* Nonmatching */ } /* 8029A86C-8029A950 .text setStreamInterPitch__8JAISoundFUcfUl */ -void JAISound::setStreamInterPitch(unsigned char, float, unsigned long) { +void JAISound::setStreamInterPitch(u8, f32, u32) { /* Nonmatching */ } /* 8029A950-8029AA34 .text setStreamInterPan__8JAISoundFUcfUl */ -void JAISound::setStreamInterPan(unsigned char, float, unsigned long) { +void JAISound::setStreamInterPan(u8, f32, u32) { /* Nonmatching */ } /* 8029AA34-8029AA84 .text setStreamPrepareFlag__8JAISoundFUc */ -void JAISound::setStreamPrepareFlag(unsigned char) { +void JAISound::setStreamPrepareFlag(u8) { /* Nonmatching */ } /* 8029AA84-8029ACF0 .text setPauseMode__8JAISoundFUcUc */ -void JAISound::setPauseMode(unsigned char, unsigned char) { +void JAISound::setPauseMode(u8, u8) { /* Nonmatching */ } /* 8029ACF0-8029AD54 .text setSeqPrepareFlag__8JAISoundFUc */ -void JAISound::setSeqPrepareFlag(unsigned char) { +void JAISound::setSeqPrepareFlag(u8) { /* Nonmatching */ } /* 8029AD54-8029ADA8 .text getSeqInterVolume__8JAISoundFUc */ -void JAISound::getSeqInterVolume(unsigned char) { +f32 JAISound::getSeqInterVolume(u8) { /* Nonmatching */ } /* 8029ADA8-8029AE34 .text getStreamInterVolume__8JAISoundFUc */ -void JAISound::getStreamInterVolume(unsigned char) { +f32 JAISound::getStreamInterVolume(u8) { /* Nonmatching */ } /* 8029AE34-8029AE3C .text getSeqParameter__8JAISoundFv */ -void JAISound::getSeqParameter() { +JAInter::SeqParameter* JAISound::getSeqParameter() { /* Nonmatching */ } /* 8029AE3C-8029AE44 .text getSeParameter__8JAISoundFv */ -void JAISound::getSeParameter() { +JAInter::SeParameter* JAISound::getSeParameter() { /* Nonmatching */ } /* 8029AE44-8029AE4C .text getStreamParameter__8JAISoundFv */ -void JAISound::getStreamParameter() { +JAInter::StreamParameter* JAISound::getStreamParameter() { /* Nonmatching */ } /* 8029AE4C-8029AE88 .text getTrackPortRoute__8JAISoundFUcUc */ -void JAISound::getTrackPortRoute(unsigned char, unsigned char) { +int JAISound::getTrackPortRoute(u8, u8) { /* Nonmatching */ } /* 8029AE88-8029AEF8 .text checkSoundHandle__8JAISoundFUlPv */ -void JAISound::checkSoundHandle(unsigned long, void*) { +int JAISound::checkSoundHandle(u32, void*) { /* Nonmatching */ } /* 8029AEF8-8029AFCC .text initParameter__8JAISoundFPP8JAISoundPQ27JAInter5ActorUlUlUcPv */ -void JAISound::initParameter(JAISound**, JAInter::Actor*, unsigned long, unsigned long, unsigned char, void*) { +void JAISound::initParameter(JAISound**, JAInter::Actor*, u32, u32, u8, void*) { /* Nonmatching */ } /* 8029AFCC-8029B07C .text set__Q27JAInter11MoveParaSetFfUl */ -void JAInter::MoveParaSet::set(float, unsigned long) { +int JAInter::MoveParaSet::set(f32, u32) { /* Nonmatching */ } /* 8029B07C-8029B0C4 .text move__Q27JAInter11MoveParaSetFv */ -void JAInter::MoveParaSet::move() { +bool JAInter::MoveParaSet::move() { /* Nonmatching */ } /* 8029B0C4-8029B4AC .text init__Q27JAInter9LinkSoundFP8JAISoundUl */ -void JAInter::LinkSound::init(JAISound*, unsigned long) { +void JAInter::LinkSound::init(JAISound*, u32) { /* Nonmatching */ } /* 8029B4AC-8029B500 .text getSound__Q27JAInter9LinkSoundFv */ -void JAInter::LinkSound::getSound() { +JAISound* JAInter::LinkSound::getSound() { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAISoundTable.cpp b/src/JSystem/JAudio/JAISoundTable.cpp index 54d392ae2..b08671bff 100644 --- a/src/JSystem/JAudio/JAISoundTable.cpp +++ b/src/JSystem/JAudio/JAISoundTable.cpp @@ -4,24 +4,40 @@ // #include "JSystem/JAudio/JAISoundTable.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JAIBasic.h" +#include "JSystem/JKernel/JKRSolidHeap.h" + +u8 JAInter::SoundTable::mVersion; +u8 JAInter::SoundTable::mCategotyMax; +s16* JAInter::SoundTable::mSoundMax; +u32 JAInter::SoundTable::mDatasize; +int* JAInter::SoundTable::mPointerCategory; +u8* JAInter::SoundTable::mAddress; /* 8029B570-8029B6FC .text init__Q27JAInter10SoundTableFPUcUl */ -void JAInter::SoundTable::init(unsigned char*, unsigned long) { +void JAInter::SoundTable::init(u8* param_1, u32 param_2) { /* Nonmatching */ + mAddress = param_1; + mDatasize = param_2; + mVersion = param_1[3]; + mSoundMax = new (JAIBasic::getCurrentJAIHeap(), 4) s16[18]; + mPointerCategory = new (JAIBasic::getCurrentJAIHeap(), 4) int[18]; + for (int i = 0; i < 18; i++) { + // TODO + } } /* 8029B6FC-8029B8CC .text getInfoPointer__Q27JAInter10SoundTableFUl */ -void JAInter::SoundTable::getInfoPointer(unsigned long) { +void JAInter::SoundTable::getInfoPointer(u32) { /* Nonmatching */ } /* 8029B8CC-8029B99C .text getInfoFormat__Q27JAInter10SoundTableFUl */ -void JAInter::SoundTable::getInfoFormat(unsigned long) { +void JAInter::SoundTable::getInfoFormat(u32) { /* Nonmatching */ } /* 8029B99C-8029B9A4 .text getCategotyMax__Q27JAInter10SoundTableFv */ -void JAInter::SoundTable::getCategotyMax() { - /* Nonmatching */ +u8 JAInter::SoundTable::getCategotyMax() { + return mCategotyMax; } diff --git a/src/JSystem/JAudio/JAIStreamMgr.cpp b/src/JSystem/JAudio/JAIStreamMgr.cpp index ee2882bc7..000b37a84 100644 --- a/src/JSystem/JAudio/JAIStreamMgr.cpp +++ b/src/JSystem/JAudio/JAIStreamMgr.cpp @@ -4,7 +4,78 @@ // #include "JSystem/JAudio/JAIStreamMgr.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASCallback.h" +#include "JSystem/JAudio/JASDSPInterface.h" +#include "JSystem/JAudio/JASSystemHeap.h" +#include "JSystem/JKernel/JKRSolidHeap.h" +#include "MSL_C/string.h" +#include "dolphin/os/OS.h" + +s16 JAInter::StreamLib::filter_table[32] = { + 0x0000, 0x0000, 0x0800, 0x0000, 0x0000, 0x0800, 0x0400, 0x0400, + 0x1000, -0x800, 0x0E00, -0x600, 0x0C00, -0x400, 0x1200, -0xA00, + 0x1068, -0x8C8, 0x12C0, -0x8FC, 0x1400, -0xC00, 0x0800, -0x800, + 0x0400, -0x400, -0x400, 0x0400, -0x400, 0x0000, -0x800, 0x0000, +}; +s16 JAInter::StreamLib::table4[] = { + 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, + -0x008, -0x007, -0x006, -0x005, -0x004, -0x003, -0x002, -0x001, + +}; +JAInter::LinkSound JAInter::StreamMgr::streamControl; +DVDFileInfo JAInter::StreamLib::finfo; +u32 JAInter::StreamLib::header[8]; +char JAInter::StreamLib::Filename[100]; +JASystem::Kernel::TSolidHeap JAInter::StreamLib::streamHeap; +u32 JAInter::StreamLib::LOOP_BLOCKS = 12; +int JAInter::StreamLib::LOOP_SAMPLESIZE = 0xF000; +int JAInter::StreamLib::outputmode = 1; +u8 JAInter::StreamMgr::flags; +int JAInter::StreamMgr::streamUpdate; +u8* JAInter::StreamMgr::streamList; +u8* JAInter::StreamMgr::initOnCodeStrm; +int JAInter::StreamLib::adpcm_remain; +int JAInter::StreamLib::adpcm_loadpoint; +int JAInter::StreamLib::loadsize; +int JAInter::StreamLib::adpcm_buffer; +int JAInter::StreamLib::loop_buffer; +int JAInter::StreamLib::store_buffer; +JASystem::TDSPChannel* JAInter::StreamLib::assign_ch[2]; +int JAInter::StreamLib::playside; +int JAInter::StreamLib::playback_samples; +int JAInter::StreamLib::loadup_samples; +u32 JAInter::StreamLib::adpcmbuf_state; +int JAInter::StreamLib::movieframe; +bool JAInter::StreamLib::stopflag; +bool JAInter::StreamLib::stopflag2; +u8 JAInter::StreamLib::playflag; +u8 JAInter::StreamLib::playflag2; +u8 JAInter::StreamLib::prepareflag; +u8 JAInter::StreamLib::dspch_deallockflag; +f32 JAInter::StreamLib::outvolume; +f32 JAInter::StreamLib::outpitch; +f32 JAInter::StreamLib::outpan; +f32 JAInter::StreamLib::stackvolume; +f32 JAInter::StreamLib::stackpitch; +f32 JAInter::StreamLib::stackpan; +u8 JAInter::StreamLib::outflag_volume; +bool JAInter::StreamLib::outflag_pan; +bool JAInter::StreamLib::outflag_pitch; +int JAInter::StreamLib::loop_start_flag; +int JAInter::StreamLib::outpause; +int JAInter::StreamLib::playmode; +int JAInter::StreamLib::shift_sample; +int JAInter::StreamLib::extra_sample; +int JAInter::StreamLib::DvdLoadFlag; +u32 JAInter::StreamLib::startInitFlag; +int JAInter::StreamLib::Mode; +int JAInter::StreamLib::sFillBlockSize; +void* JAInter::StreamLib::Head; +bool JAInter::StreamLib::bufferMode; +u8 JAInter::StreamLib::allocFlag; +u8 JAInter::StreamLib::dspFinishFlag; +void (*JAInter::StreamLib::allocCallback)(); +void (*JAInter::StreamLib::deallocCallback)(); /* 8029B9A4-8029BEB4 .text init__Q27JAInter9StreamMgrFv */ void JAInter::StreamMgr::init() { @@ -12,18 +83,24 @@ void JAInter::StreamMgr::init() { } /* 8029BEB4-8029C04C .text storeStreamBuffer__Q27JAInter9StreamMgrFPP8JAISoundPQ27JAInter5ActorUlUlUcPv */ -void JAInter::StreamMgr::storeStreamBuffer(JAISound**, JAInter::Actor*, unsigned long, unsigned long, unsigned char, void*) { +void JAInter::StreamMgr::storeStreamBuffer(JAISound**, JAInter::Actor*, u32, u32, u8, void*) { /* Nonmatching */ } /* 8029C04C-8029C0F0 .text releaseStreamBuffer__Q27JAInter9StreamMgrFP8JAISoundUl */ -void JAInter::StreamMgr::releaseStreamBuffer(JAISound*, unsigned long) { +void JAInter::StreamMgr::releaseStreamBuffer(JAISound*, u32) { /* Nonmatching */ } /* 8029C0F0-8029C128 .text processGFrameStream__Q27JAInter9StreamMgrFv */ void JAInter::StreamMgr::processGFrameStream() { /* Nonmatching */ + if ((flags >> 6 & 1) == 0) { + checkPlayingStream(); + checkRequestStream(); + checkWaitStream(); + checkEntriedStream(); + } } /* 8029C128-8029C1D8 .text checkEntriedStream__Q27JAInter9StreamMgrFv */ @@ -47,53 +124,63 @@ void JAInter::StreamMgr::checkPlayingStream() { } /* 8029C730-8029C858 .text Play_DirectPCM__Q27JAInter9StreamLibFPQ28JASystem11TDSPChannelPsUsUlsUs */ -void JAInter::StreamLib::Play_DirectPCM(JASystem::TDSPChannel*, short*, unsigned short, unsigned long, short, unsigned short) { +void JAInter::StreamLib::Play_DirectPCM(JASystem::TDSPChannel*, s16*, u16, u32, s16, u16) { /* Nonmatching */ } /* 8029C858-8029C864 .text Get_DirectPCM_LoopRemain__Q27JAInter9StreamLibFPQ38JASystem12DSPInterface9DSPBuffer */ -void JAInter::StreamLib::Get_DirectPCM_LoopRemain(JASystem::DSPInterface::DSPBuffer*) { - /* Nonmatching */ +int JAInter::StreamLib::Get_DirectPCM_LoopRemain(JASystem::DSPInterface::DSPBuffer* dspBuffer) { + return dspBuffer->field_0x6c >> 0x10; } /* 8029C864-8029C86C .text Get_DirectPCM_Remain__Q27JAInter9StreamLibFPQ38JASystem12DSPInterface9DSPBuffer */ -void JAInter::StreamLib::Get_DirectPCM_Remain(JASystem::DSPInterface::DSPBuffer*) { - /* Nonmatching */ +int JAInter::StreamLib::Get_DirectPCM_Remain(JASystem::DSPInterface::DSPBuffer* dspBuffer) { + return dspBuffer->field_0x74; } /* 8029C86C-8029C8BC .text init__Q27JAInter9StreamLibFb */ -void JAInter::StreamLib::init(bool) { - /* Nonmatching */ +void JAInter::StreamLib::init(bool param_1) { + bufferMode = param_1; + if (!param_1) { + u32 size = getNeedBufferSize(); + allocBuffer(JASDram->alloc(size, 0), size); + } } /* 8029C8BC-8029CBF0 .text allocBuffer__Q27JAInter9StreamLibFPvl */ -void JAInter::StreamLib::allocBuffer(void*, long) { +void JAInter::StreamLib::allocBuffer(void*, s32) { /* Nonmatching */ } /* 8029CBF0-8029CC50 .text deallocBuffer__Q27JAInter9StreamLibFv */ -void JAInter::StreamLib::deallocBuffer() { - /* Nonmatching */ +bool JAInter::StreamLib::deallocBuffer() { + if (bufferMode && allocFlag && playflag2 != 1) { + streamHeap.freeAll(); + allocFlag = 0; + return true; + } + return false; } /* 8029CC50-8029CCA4 .text getNeedBufferSize__Q27JAInter9StreamLibFv */ -void JAInter::StreamLib::getNeedBufferSize() { +int JAInter::StreamLib::getNeedBufferSize() { /* Nonmatching */ } /* 8029CCA4-8029CCAC .text setAllocBufferCallback__Q27JAInter9StreamLibFPFv_v */ -void JAInter::StreamLib::setAllocBufferCallback(void (*)(void)) { - /* Nonmatching */ +void JAInter::StreamLib::setAllocBufferCallback(void (*param_1)(void)) { + allocCallback = param_1; } /* 8029CCAC-8029CCB4 .text setDeallocBufferCallback__Q27JAInter9StreamLibFPFv_v */ -void JAInter::StreamLib::setDeallocBufferCallback(void (*)(void)) { - /* Nonmatching */ +void JAInter::StreamLib::setDeallocBufferCallback(void (*param_1)(void)) { + deallocCallback = param_1; } /* 8029CCB4-8029CCD0 .text sync__Q27JAInter9StreamLibFl */ -void JAInter::StreamLib::sync(long) { - /* Nonmatching */ +void JAInter::StreamLib::sync(s32 param_1) { + static s32 before = param_1; + before = param_1; } /* 8029CCD0-8029CD8C .text __DecodePCM__Q27JAInter9StreamLibFv */ @@ -112,8 +199,12 @@ void JAInter::StreamLib::__Decode() { } /* 8029D1C8-8029D1E8 .text __LoadFin__Q27JAInter9StreamLibFlP11DVDFileInfo */ -void JAInter::StreamLib::__LoadFin(long, DVDFileInfo*) { - /* Nonmatching */ +void JAInter::StreamLib::__LoadFin(s32, DVDFileInfo*) { + DvdLoadFlag = 0; + if (adpcmbuf_state == 3) { + return; + } + adpcmbuf_state = 2; } /* 8029D1E8-8029D328 .text LoadADPCM__Q27JAInter9StreamLibFv */ @@ -122,53 +213,66 @@ void JAInter::StreamLib::LoadADPCM() { } /* 8029D328-8029D338 .text setVolume__Q27JAInter9StreamLibFf */ -void JAInter::StreamLib::setVolume(float) { - /* Nonmatching */ +void JAInter::StreamLib::setVolume(f32 param_1) { + stackvolume = param_1; + outflag_volume = true; } /* 8029D338-8029D348 .text setPitch__Q27JAInter9StreamLibFf */ -void JAInter::StreamLib::setPitch(float) { - /* Nonmatching */ +void JAInter::StreamLib::setPitch(f32 param_1) { + stackpitch = param_1; + outflag_pitch = true; } /* 8029D348-8029D358 .text setPan__Q27JAInter9StreamLibFf */ -void JAInter::StreamLib::setPan(float) { - /* Nonmatching */ +void JAInter::StreamLib::setPan(f32 param_1) { + stackpan = param_1; + outflag_pan = true; } /* 8029D358-8029D368 .text stop__Q27JAInter9StreamLibFv */ void JAInter::StreamLib::stop() { - /* Nonmatching */ + stopflag = true; + stopflag2 = true; } /* 8029D368-8029D384 .text setPauseFlag__Q27JAInter9StreamLibFUc */ -void JAInter::StreamLib::setPauseFlag(unsigned char) { - /* Nonmatching */ +void JAInter::StreamLib::setPauseFlag(u8 param_1) { + outpause |= param_1; + outpause |= 0x80; } /* 8029D384-8029D3A4 .text clearPauseFlag__Q27JAInter9StreamLibFUc */ -void JAInter::StreamLib::clearPauseFlag(unsigned char) { - /* Nonmatching */ +void JAInter::StreamLib::clearPauseFlag(u8 param_1) { + outpause &= (param_1 ^ 0xff); + outpause |= 0x80; } /* 8029D3A4-8029D3AC .text setPrepareFlag__Q27JAInter9StreamLibFUc */ -void JAInter::StreamLib::setPrepareFlag(unsigned char) { - /* Nonmatching */ +void JAInter::StreamLib::setPrepareFlag(u8 param_1) { + prepareflag = param_1; } /* 8029D3AC-8029D3B4 .text setOutputMode__Q27JAInter9StreamLibFUl */ -void JAInter::StreamLib::setOutputMode(unsigned long) { - /* Nonmatching */ +void JAInter::StreamLib::setOutputMode(u32 param_1) { + outputmode = param_1; } /* 8029D3B4-8029D3BC .text getPlayingFlag__Q27JAInter9StreamLibFv */ -void JAInter::StreamLib::getPlayingFlag() { - /* Nonmatching */ +u8 JAInter::StreamLib::getPlayingFlag() { + return playflag2; } /* 8029D3BC-8029D424 .text setDecodedBufferBlocks__Q27JAInter9StreamLibFUl */ -void JAInter::StreamLib::setDecodedBufferBlocks(unsigned long) { - /* Nonmatching */ +void JAInter::StreamLib::setDecodedBufferBlocks(u32 param_1) { + if (param_1 < 3) { + OSReport("setDecodedBufferBlocks : 3ブロック以上必要ですので、使用ブロックを%dから3に変更します。\n"); + param_1 = 3; + } else if (param_1 > 12) { + OSReport("setDecodedBufferBlocks : 13ブロック以上は設定できませんので、使用ブロックを%dから12に変更しま す。\n"); + param_1 = 12; + } + LOOP_BLOCKS = param_1; } /* 8029D424-8029D464 .text LoopInit__Q27JAInter9StreamLibFv */ @@ -177,13 +281,33 @@ void JAInter::StreamLib::LoopInit() { } /* 8029D464-8029D4C0 .text directPlayWait__Q27JAInter9StreamLibFPv */ -void JAInter::StreamLib::directPlayWait(void*) { - /* Nonmatching */ +s32 JAInter::StreamLib::directPlayWait(void*) { + if (getPlayingFlag() != 1) { + startInitFlag++; + prepareflag = 0; + JASystem::Kernel::registerDspCallback(callBack, NULL); + return -1; + } + return 0; } /* 8029D4C0-8029D560 .text start__Q27JAInter9StreamLibFPcUlPv */ -void JAInter::StreamLib::start(char*, unsigned long, void*) { +void JAInter::StreamLib::start(char* param_1, u32 param_2, void* param_3) { /* Nonmatching */ + if (!startInitFlag) { + strcpy(Filename, param_1); + Mode = param_2; + Head = param_3; + if (!param_3) { + stop(); + JASystem::Kernel::registerDspCallback(directPlayWait, NULL); + } else { + startInitFlag++; + prepareflag = 0; + JASystem::Kernel::registerDspCallback(callBack, NULL); + } + } + } /* 8029D560-8029D7C0 .text __start__Q27JAInter9StreamLibFv */ @@ -192,6 +316,6 @@ void JAInter::StreamLib::__start() { } /* 8029D7C0-8029E14C .text callBack__Q27JAInter9StreamLibFPv */ -void JAInter::StreamLib::callBack(void*) { +s32 JAInter::StreamLib::callBack(void*) { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JAISystemInterface.cpp b/src/JSystem/JAudio/JAISystemInterface.cpp index d440aae8e..578df2fc9 100644 --- a/src/JSystem/JAudio/JAISystemInterface.cpp +++ b/src/JSystem/JAudio/JAISystemInterface.cpp @@ -4,30 +4,43 @@ // #include "JSystem/JAudio/JAISystemInterface.h" -#include "dolphin/types.h" +#include "JSystem/JAudio/JASTrack.h" +#include "dolphin/dvd/dvd.h" + +JASystem::Kernel::TPortCmd JAInter::SystemInterface::systemPortCmd; /* 8029E188-8029E1B4 .text checkFileExsistence__Q27JAInter15SystemInterfaceFPc */ -void JAInter::SystemInterface::checkFileExsistence(char*) { - /* Nonmatching */ +s32 JAInter::SystemInterface::checkFileExsistence(char* param_1) { + return DVDConvertPathToEntrynum(param_1) != -1; } /* 8029E1B4-8029E2A0 .text checkSeqActiveFlag__Q27JAInter15SystemInterfaceFPQ28JASystem6TTrack */ -void JAInter::SystemInterface::checkSeqActiveFlag(JASystem::TTrack*) { - /* Nonmatching */ +int JAInter::SystemInterface::checkSeqActiveFlag(JASystem::TTrack* param_1) { + if (param_1 && param_1->field_0x37e) { + if (param_1->mChildren[0] || param_1->mChildren[1] || param_1->mChildren[2] || param_1->mChildren[3] || + param_1->mChildren[4] || param_1->mChildren[5] || param_1->mChildren[6] || param_1->mChildren[7] || + param_1->mChildren[8] || param_1->mChildren[9] || param_1->mChildren[10] || param_1->mChildren[11] || + param_1->mChildren[12] || param_1->mChildren[13] || param_1->mChildren[14] || param_1->mChildren[15] + ) { + return param_1->field_0x37e; + } + return 0; + } + return 0; } /* 8029E2A0-8029E478 .text trackToSeqp__Q27JAInter15SystemInterfaceFP8JAISoundUc */ -void JAInter::SystemInterface::trackToSeqp(JAISound*, unsigned char) { +void JAInter::SystemInterface::trackToSeqp(JAISound*, u8) { /* Nonmatching */ } /* 8029E478-8029E494 .text setSeqPortargsF32__Q27JAInter15SystemInterfaceFPQ27JAInter13SeqUpdateDataUlUcf */ -void JAInter::SystemInterface::setSeqPortargsF32(JAInter::SeqUpdateData*, unsigned long, unsigned char, float) { +void JAInter::SystemInterface::setSeqPortargsF32(JAInter::SeqUpdateData*, u32, u8, f32) { /* Nonmatching */ } /* 8029E494-8029E4B0 .text setSeqPortargsU32__Q27JAInter15SystemInterfaceFPQ27JAInter13SeqUpdateDataUlUcUl */ -void JAInter::SystemInterface::setSeqPortargsU32(JAInter::SeqUpdateData*, unsigned long, unsigned char, unsigned long) { +void JAInter::SystemInterface::setSeqPortargsU32(JAInter::SeqUpdateData*, u32, u8, u32) { /* Nonmatching */ } @@ -42,12 +55,12 @@ void JAInter::SystemInterface::trackInit(JAInter::SeqUpdateData*) { } /* 8029E5B4-8029E7B8 .text outerInit__Q27JAInter15SystemInterfaceFPQ27JAInter13SeqUpdateDataPvUlUsUc */ -void JAInter::SystemInterface::outerInit(JAInter::SeqUpdateData*, void*, unsigned long, unsigned short, unsigned char) { +void JAInter::SystemInterface::outerInit(JAInter::SeqUpdateData*, void*, u32, u16, u8) { /* Nonmatching */ } /* 8029E7B8-8029E820 .text setPortParameter__Q27JAInter15SystemInterfaceFPQ38JASystem6Kernel9TPortArgsPQ28JASystem6TTrackUlUl */ -void JAInter::SystemInterface::setPortParameter(JASystem::Kernel::TPortArgs*, JASystem::TTrack*, unsigned long, unsigned long) { +void JAInter::SystemInterface::setPortParameter(JASystem::Kernel::TPortArgs*, JASystem::TTrack*, u32, u32) { /* Nonmatching */ } diff --git a/src/JSystem/JAudio/JASHardStream.cpp b/src/JSystem/JAudio/JASHardStream.cpp index fdb1aa4a8..0e7afe4bf 100644 --- a/src/JSystem/JAudio/JASHardStream.cpp +++ b/src/JSystem/JAudio/JASHardStream.cpp @@ -228,7 +228,7 @@ void JASystem::HardStream::getAddrCallback(s32 param_1, DVDCommandBlock* param_2 } } -float dummy1() { +static float dummy1() { return 0.0f; } @@ -278,7 +278,7 @@ u16 JASystem::HardStream::TControl::getLoopNum() { return mpList->getPair()->getLoop(); } -void dummy2() { +static void dummy2() { OSReport(__FILE__); OSReport("playPairs != 0"); OSReport("Halt"); diff --git a/src/f_pc/f_pc_manager.cpp b/src/f_pc/f_pc_manager.cpp index f85976d07..58d65f876 100644 --- a/src/f_pc/f_pc_manager.cpp +++ b/src/f_pc/f_pc_manager.cpp @@ -21,6 +21,7 @@ #include "JSystem/J2DGraph/J2DPicture.h" #include "JSystem/J2DGraph/J2DTextBox.h" #include "JSystem/J3DGraphBase/J3DSys.h" +#include "JSystem/JAudio/JAIStreamMgr.h" #include "JSystem/JUtility/JUTAssert.h" #include "dolphin/dvd/DVD.h" #include "dolphin/gx/GX.h" @@ -170,13 +171,6 @@ void messageSet(u32 status) { delete spane; } -namespace JAInter { - class StreamLib { - public: - static void stop(); - }; -} - /* 8003E9F0-8003EBD4 .text drawDvdCondition__Fl */ void drawDvdCondition(long status) { #if VERSION == VERSION_PAL