mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-08-08 02:00:17 -04:00
JAudio field name/comment pass
HUGE thanks to XAYRGA for their work documenting JAudio file formats
This commit is contained in:
@@ -43,7 +43,7 @@ void JASAramStream::initSystem(u32 block_size, u32 channel_max) {
|
||||
}
|
||||
|
||||
JASAramStream::JASAramStream() {
|
||||
field_0x0a8 = NULL;
|
||||
mInitialChannel = NULL;
|
||||
field_0x0ac = false;
|
||||
field_0x0ad = false;
|
||||
field_0x0ae = 0;
|
||||
@@ -60,15 +60,15 @@ JASAramStream::JASAramStream() {
|
||||
field_0x114 = 0;
|
||||
field_0x118 = 0;
|
||||
field_0x12c = 0;
|
||||
field_0x148 = 0;
|
||||
mAramAddress = 0;
|
||||
field_0x14c = 0;
|
||||
mCallback = NULL;
|
||||
mCallbackData = NULL;
|
||||
field_0x158 = 0;
|
||||
mFormat = 0;
|
||||
mChannelNum = 0;
|
||||
mBufCount = 0;
|
||||
field_0x160 = 0;
|
||||
field_0x164 = 0;
|
||||
mBlocksPerChannel = 0;
|
||||
mSampleRate = 0;
|
||||
mLoop = false;
|
||||
mLoopStart = 0;
|
||||
mLoopEnd = 0;
|
||||
@@ -76,21 +76,21 @@ JASAramStream::JASAramStream() {
|
||||
mPitch = 1.0f;
|
||||
for (int i = 0; i < 6; i++) {
|
||||
mChannels[i] = NULL;
|
||||
field_0x130[i] = 0;
|
||||
field_0x13c[i] = 0;
|
||||
mpLasts[i] = 0;
|
||||
mpPenults[i] = 0;
|
||||
mChannelVolume[i] = 1.0f;
|
||||
mChannelPan[i] = 0.5f;
|
||||
mChannelFxMix[i] = 0.0f;
|
||||
mChannelDolby[i] = 0.0f;
|
||||
}
|
||||
for (int i = 0; i < 6; i++) {
|
||||
field_0x1dc[i] = 0;
|
||||
mMixConfig[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, void* i_callbackData) {
|
||||
void JASAramStream::init(u32 aramAddress, u32 param_1, StreamCallback i_callback, void* i_callbackData) {
|
||||
JUT_ASSERT(153, sReadBuffer != NULL);
|
||||
field_0x148 = param_0;
|
||||
mAramAddress = aramAddress;
|
||||
field_0x14c = param_1;
|
||||
field_0x0c8 = 0.0f;
|
||||
field_0x0ae = 0;
|
||||
@@ -106,7 +106,7 @@ void JASAramStream::init(u32 param_0, u32 param_1, StreamCallback i_callback, vo
|
||||
}
|
||||
mVolume = 1.0f;
|
||||
mPitch = 1.0f;
|
||||
field_0x1dc[0] = 0xffff;
|
||||
mMixConfig[0] = 0xffff;
|
||||
mCallback = i_callback;
|
||||
mCallbackData = i_callbackData;
|
||||
OSInitMessageQueue(&field_0x000, field_0x040, 0x10);
|
||||
@@ -169,7 +169,7 @@ bool JASAramStream::cancel() {
|
||||
}
|
||||
|
||||
u32 JASAramStream::getBlockSamples() const {
|
||||
return field_0x158 == 0 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
|
||||
return mFormat == 0 ? (sBlockSize << 4) / 9 : sBlockSize >> 1;
|
||||
}
|
||||
|
||||
void JASAramStream::headerLoadTask(void* i_data) {
|
||||
@@ -245,18 +245,18 @@ bool JASAramStream::headerLoad(u32 param_0, int param_1) {
|
||||
JUT_ASSERT(428, header->bits == 16);
|
||||
JUT_ASSERT(429, header->channels <= sChannelMax);
|
||||
JUT_ASSERT(430, header->block_size == sBlockSize);
|
||||
field_0x158 = header->format;
|
||||
mFormat = header->format;
|
||||
mChannelNum = header->channels;
|
||||
field_0x164 = header->field_0x10;
|
||||
mSampleRate = header->mSampleRate;
|
||||
mLoop = header->loop != 0;
|
||||
mLoopStart = header->loop_start;
|
||||
mLoopEnd = header->loop_end;
|
||||
mVolume = header->field_0x28 / 127.0f;
|
||||
mVolume = header->mVolume / 127.0f;
|
||||
field_0x118 = 0;
|
||||
mBlock = 0;
|
||||
field_0x10c = 0;
|
||||
field_0x160 = (param_0 / sBlockSize) / header->channels;
|
||||
mBufCount = field_0x160;
|
||||
mBlocksPerChannel = (param_0 / sBlockSize) / header->channels;
|
||||
mBufCount = mBlocksPerChannel;
|
||||
JUT_ASSERT(445, mBufCount > 0);
|
||||
mBufCount--;
|
||||
if (mBufCount < 3) {
|
||||
@@ -319,14 +319,14 @@ bool JASAramStream::load() {
|
||||
if (field_0x114 != 0) {
|
||||
return false;
|
||||
}
|
||||
u32 sp08 = field_0x148 + field_0x10c * sBlockSize;
|
||||
u32 sp08 = mAramAddress + field_0x10c * sBlockSize;
|
||||
for (int i = 0; i < mChannelNum; i++) {
|
||||
(void)i;
|
||||
// Fakematch? It seems the only way to get the bhead->field_0x4 load in the right order is
|
||||
// with a pointer cast on its address in one of the two places it is read, but not both.
|
||||
if (!JKRMainRamToAram(sReadBuffer + *(u32*)&bhead->field_0x4 * i + sizeof(BlockHeader),
|
||||
sp08 + sBlockSize * field_0x160 * i,
|
||||
bhead->field_0x4, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
|
||||
if (!JKRMainRamToAram(sReadBuffer + *(u32*)&bhead->mSize * i + sizeof(BlockHeader),
|
||||
sp08 + sBlockSize * mBlocksPerChannel * i,
|
||||
bhead->mSize, EXPAND_SWITCH_UNKNOWN0, 0, NULL, -1, NULL)) {
|
||||
JUT_WARN(522, "%s", "JKRMainRamToAram Failed");
|
||||
struct_80451261 = 1;
|
||||
return false;
|
||||
@@ -344,14 +344,14 @@ bool JASAramStream::load() {
|
||||
}
|
||||
}
|
||||
if (r28 == loop_end_block || r28 + 2 == loop_end_block) {
|
||||
field_0x108 = field_0x160;
|
||||
field_0x108 = mBlocksPerChannel;
|
||||
OSSendMessage(&field_0x020, (OSMessage)5, OS_MESSAGE_BLOCK);
|
||||
} else {
|
||||
field_0x108 = field_0x160 - 1;
|
||||
field_0x108 = mBlocksPerChannel - 1;
|
||||
}
|
||||
for (int i = 0; i < mChannelNum; i++) {
|
||||
field_0x130[i] = (s16)bhead->field_0x8[i].field_0x0;
|
||||
field_0x13c[i] = (s16)bhead->field_0x8[i].field_0x2;
|
||||
mpLasts[i] = (s16)bhead->mAdpcmContinuationData[i].mpLast;
|
||||
mpPenults[i] = (s16)bhead->mAdpcmContinuationData[i].mpPenult;
|
||||
}
|
||||
field_0x10c = 0;
|
||||
}
|
||||
@@ -402,8 +402,8 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
u32 block_samples = getBlockSamples();
|
||||
switch (i_callbackType) {
|
||||
case JASChannel::CB_START:
|
||||
if (field_0x0a8 == NULL) {
|
||||
field_0x0a8 = i_channel;
|
||||
if (mInitialChannel == NULL) {
|
||||
mInitialChannel = i_channel;
|
||||
field_0x0b4 = block_samples * mBufCount;
|
||||
field_0x0b8 = 0;
|
||||
field_0x0b0 = 0;
|
||||
@@ -415,9 +415,9 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
break;
|
||||
case JASChannel::CB_PLAY:
|
||||
if (i_dspChannel->field_0x008 == 0) {
|
||||
if (i_channel == field_0x0a8) {
|
||||
if (i_channel == mInitialChannel) {
|
||||
field_0x12c = 0;
|
||||
u32 sp28 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
|
||||
u32 sp28 = i_dspChannel->field_0x074 + i_dspChannel->mSamplesPerBlock;
|
||||
if (sp28 <= field_0x0b4) {
|
||||
field_0x0b8 += field_0x0b4 - sp28;
|
||||
} else {
|
||||
@@ -427,10 +427,10 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
} else {
|
||||
field_0x0b8 += field_0x0b4;
|
||||
field_0x0b8 += block_samples * mBufCount - sp28
|
||||
- i_dspChannel->field_0x110;
|
||||
- i_dspChannel->mLoopStartSample;
|
||||
field_0x0b8 -= mLoopEnd;
|
||||
field_0x0b8 += mLoopStart;
|
||||
i_dspChannel->field_0x110 = 0;
|
||||
i_dspChannel->mLoopStartSample = 0;
|
||||
field_0x120 = 0;
|
||||
field_0x12c |= 2;
|
||||
if (field_0x0c4 < 0xffffffff) {
|
||||
@@ -448,7 +448,7 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
if (field_0x0c4 < 0xffffffff) {
|
||||
fvar1 += field_0x0b8;
|
||||
}
|
||||
fvar1 /= field_0x164;
|
||||
fvar1 /= mSampleRate;
|
||||
field_0x0c8 = fvar1;
|
||||
if (field_0x0b8 + 400 >= mLoopEnd && !field_0x0c0) {
|
||||
if (mLoop) {
|
||||
@@ -456,9 +456,9 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
if (uvar5 >= mBufCount) {
|
||||
uvar5 = 0;
|
||||
}
|
||||
i_dspChannel->field_0x110 = mLoopStart % block_samples
|
||||
i_dspChannel->mLoopStartSample = mLoopStart % block_samples
|
||||
+ uvar5 * block_samples;
|
||||
field_0x120 = i_dspChannel->field_0x110;
|
||||
field_0x120 = i_dspChannel->mLoopStartSample;
|
||||
field_0x12c |= 2;
|
||||
} else {
|
||||
i_dspChannel->field_0x102 = 0;
|
||||
@@ -472,17 +472,17 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
field_0x0bc += (mLoopEnd - 1) / block_samples - mLoopStart / block_samples + 1;
|
||||
field_0x0c0 = true;
|
||||
}
|
||||
u32 uvar4 = i_dspChannel->field_0x070 - i_channel->field_0x104;
|
||||
u32 uvar4 = i_dspChannel->mAramStreamPosition - i_channel->mWaveAramAddress;
|
||||
if (uvar4 != 0) {
|
||||
uvar4--;
|
||||
}
|
||||
u32 sp18 = uvar4 / sBlockSize;
|
||||
u32 blockCount = uvar4 / sBlockSize;
|
||||
u32 sp14 = (mLoopEnd - 1) / getBlockSamples();
|
||||
if (sp18 != field_0x0b0) {
|
||||
bool cmp = sp18 < field_0x0b0;
|
||||
while (sp18 != field_0x0b0) {
|
||||
if (blockCount != field_0x0b0) {
|
||||
bool cmp = blockCount < field_0x0b0;
|
||||
while (blockCount != field_0x0b0) {
|
||||
if (!sLoadThread->sendCmdMsg(loadToAramTask, this)) {
|
||||
JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->field_0x070, i_channel->field_0x104, sp18, field_0x0b0);
|
||||
JUT_WARN(741, "sendCmdMsg Failed %d %d (%d %d)", i_dspChannel->mAramStreamPosition, i_channel->mWaveAramAddress, blockCount, field_0x0b0);
|
||||
struct_80451261 = true;
|
||||
break;
|
||||
}
|
||||
@@ -503,16 +503,16 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
field_0x11c = i_dspChannel->field_0x074;
|
||||
field_0x12c |= 1;
|
||||
}
|
||||
i_dspChannel->field_0x114 += block_samples;
|
||||
field_0x124 = i_dspChannel->field_0x114;
|
||||
i_dspChannel->mEndSample += block_samples;
|
||||
field_0x124 = i_dspChannel->mEndSample;
|
||||
field_0x12c |= 4;
|
||||
mBufCount = field_0x160;
|
||||
mBufCount = mBlocksPerChannel;
|
||||
field_0x0ad = false;
|
||||
} else {
|
||||
if (mBufCount != field_0x160 - 1) {
|
||||
mBufCount = field_0x160 - 1;
|
||||
i_dspChannel->field_0x114 -= block_samples;
|
||||
field_0x124 = i_dspChannel->field_0x114;
|
||||
if (mBufCount != mBlocksPerChannel - 1) {
|
||||
mBufCount = mBlocksPerChannel - 1;
|
||||
i_dspChannel->mEndSample -= block_samples;
|
||||
field_0x124 = i_dspChannel->mEndSample;
|
||||
field_0x12c |= 4;
|
||||
if (!field_0x0c0) {
|
||||
i_dspChannel->field_0x074 -= block_samples;
|
||||
@@ -528,8 +528,8 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
field_0x0ae &= ~4;
|
||||
}
|
||||
}
|
||||
field_0x0b4 = i_dspChannel->field_0x074 + i_dspChannel->field_0x064;
|
||||
if (field_0x118 >= field_0x160 - 2) {
|
||||
field_0x0b4 = i_dspChannel->field_0x074 + i_dspChannel->mSamplesPerBlock;
|
||||
if (field_0x118 >= mBlocksPerChannel - 2) {
|
||||
JUT_WARN_DEVICE(810, 1, "%s", "buffer under error");
|
||||
field_0x0ae |= (u8)4;
|
||||
}
|
||||
@@ -538,10 +538,10 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
i_dspChannel->field_0x074 = field_0x11c;
|
||||
}
|
||||
if (field_0x12c & 2) {
|
||||
i_dspChannel->field_0x110 = field_0x120;
|
||||
i_dspChannel->mLoopStartSample = field_0x120;
|
||||
}
|
||||
if (field_0x12c & 4) {
|
||||
i_dspChannel->field_0x114 = field_0x124;
|
||||
i_dspChannel->mEndSample = field_0x124;
|
||||
}
|
||||
if (field_0x12c & 8) {
|
||||
i_dspChannel->field_0x102 = field_0x128;
|
||||
@@ -554,8 +554,8 @@ void JASAramStream::updateChannel(u32 i_callbackType, JASChannel* i_channel,
|
||||
}
|
||||
}
|
||||
JUT_ASSERT(834, ch < CHANNEL_MAX);
|
||||
i_dspChannel->field_0x104 = (s16)field_0x130[ch];
|
||||
i_dspChannel->field_0x106 = (s16)field_0x13c[ch];
|
||||
i_dspChannel->mpLast = (s16)mpLasts[ch];
|
||||
i_dspChannel->mpPenult = (s16)mpPenults[ch];
|
||||
}
|
||||
break;
|
||||
case JASChannel::CB_STOP:
|
||||
@@ -646,44 +646,44 @@ static JASOscillator::Point const OSC_RELEASE_TABLE[2] = {
|
||||
static JASOscillator::Data const OSC_ENV = {0, 1.0f, NULL, OSC_RELEASE_TABLE, 1.0f, 0.0f};
|
||||
|
||||
void JASAramStream::channelStart() {
|
||||
u8 r31;
|
||||
switch (field_0x158) {
|
||||
u8 format;
|
||||
switch (mFormat) {
|
||||
case 0:
|
||||
r31 = 0;
|
||||
format = WAVE_FORMAT_ADPCM4;
|
||||
break;
|
||||
case 1:
|
||||
r31 = 3;
|
||||
format = WAVE_FORMAT_PCM16;
|
||||
break;
|
||||
}
|
||||
for (int i = 0; i < mChannelNum; i++) {
|
||||
JASWaveInfo wave_info;
|
||||
wave_info.field_0x00 = r31;
|
||||
wave_info.field_0x02 = 0xff;
|
||||
wave_info.field_0x10 = 0;
|
||||
wave_info.field_0x14 = mBufCount * getBlockSamples();
|
||||
wave_info.field_0x18 = wave_info.field_0x14;
|
||||
wave_info.field_0x1c = 0;
|
||||
wave_info.field_0x1e = 0;
|
||||
wave_info.mWaveFormat = format;
|
||||
wave_info.mLoopFlag = 0xff;
|
||||
wave_info.mLoopStartSample = 0;
|
||||
wave_info.mLoopEndSample = mBufCount * getBlockSamples();
|
||||
wave_info.mSampleCount = wave_info.mLoopEndSample;
|
||||
wave_info.mpLast = 0;
|
||||
wave_info.mpPenult = 0;
|
||||
// probably a fake match, this should be set in the JASWaveInfo constructor
|
||||
static u32 const one = 1;
|
||||
wave_info.field_0x20 = &one;
|
||||
JASChannel* jc = JKR_NEW JASChannel(channelCallback, this);
|
||||
JUT_ASSERT(963, jc);
|
||||
jc->setPriority(0x7f7f);
|
||||
for (u32 j = 0; j < 6; j++) {
|
||||
jc->setMixConfig(j, field_0x1dc[j]);
|
||||
for (u32 j = 0; j < DSP_OUTPUT_CHANNELS; j++) {
|
||||
jc->setMixConfig(j, mMixConfig[j]);
|
||||
}
|
||||
jc->setInitPitch(field_0x164 / JASDriver::getDacRate());
|
||||
jc->setInitPitch(mSampleRate / JASDriver::getDacRate());
|
||||
jc->setOscInit(0, &OSC_ENV);
|
||||
jc->field_0xdc.field_0x4 = wave_info;
|
||||
jc->field_0x104 = field_0x148 + sBlockSize * field_0x160 * i;
|
||||
jc->field_0xdc.field_0x0 = 0;
|
||||
jc->field_0xdc.mWaveInfo = wave_info;
|
||||
jc->mWaveAramAddress = mAramAddress + sBlockSize * mBlocksPerChannel * i;
|
||||
jc->field_0xdc.mChannelType = 0;
|
||||
int ret = jc->playForce();
|
||||
JUT_ASSERT(977, ret);
|
||||
JUT_ASSERT_MSG(979, mChannels[i] == NULL, "channelStart for already playing channel");
|
||||
mChannels[i] = jc;
|
||||
}
|
||||
field_0x0a8 = NULL;
|
||||
mInitialChannel = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -47,7 +47,7 @@ s32 JASAudioReseter::checkDone() const {
|
||||
|
||||
s32 JASAudioReseter::calc() {
|
||||
if (field_0x0==0) {
|
||||
for (size_t i = 0; i<64; i++) {
|
||||
for (size_t i = 0; i<DSP_CHANNELS; i++) {
|
||||
JASDSPChannel* handle = JASDSPChannel::getHandle(i);
|
||||
if (handle->getStatus() == 0) {
|
||||
handle->drop();
|
||||
|
||||
@@ -23,7 +23,7 @@ JASBasicBank* JASBNKParser::createBasicBank(void const* stream, JKRHeap* heap) {
|
||||
u32 free_size = heap->getFreeSize();
|
||||
|
||||
TFileHeader* filep = (TFileHeader*)stream;
|
||||
JUT_ASSERT(59, filep->id == 'IBNK');
|
||||
JUT_ASSERT(59, filep->mMagic == 'IBNK');
|
||||
JASBasicBank* bank = NULL;
|
||||
switch (filep->mVersion) {
|
||||
case 0:
|
||||
@@ -79,11 +79,11 @@ JASBasicBank* JASBNKParser::Ver1::createBasicBank(void const* stream, JKRHeap* h
|
||||
JUT_ASSERT(155, op->id == 'Osci');
|
||||
JASOscillator::Data* data = &osc_data[i];
|
||||
data->mTarget = op->mTarget;
|
||||
data->_04 = op->_08;
|
||||
data->mRate = op->mRate;
|
||||
data->mScale = op->mScale;
|
||||
data->_14 = op->_18;
|
||||
data->mTable = (JASOscillator::Point*)(envt + op->mTableOffset);
|
||||
data->rel_table = (JASOscillator::Point*)(envt + op->_10);
|
||||
data->mVertex = op->mVertex;
|
||||
data->mTable = (JASOscillator::Point*)(envt + op->mAttackEnvelopeOffset);
|
||||
data->rel_table = (JASOscillator::Point*)(envt + op->mReleaseEnvelopeOffset);
|
||||
}
|
||||
TListChunk* list = list_chunk;
|
||||
JUT_ASSERT(172, list->count <= JASBank::PRG_OSC);
|
||||
@@ -203,7 +203,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
|
||||
osc = JKR_NEW_ARGS (heap, 0) JASOscillator::Data;
|
||||
JUT_ASSERT(386, osc != NULL);
|
||||
osc->mTarget = tosc->mTarget;
|
||||
osc->_04 = tosc->field_0x4;
|
||||
osc->mRate = tosc->field_0x4;
|
||||
|
||||
JASOscillator::Point* points = tosc->mPointOffset.ptr(header);
|
||||
if (points != NULL) {
|
||||
@@ -230,7 +230,7 @@ JASBasicBank* JASBNKParser::Ver0::createBasicBank(void const* stream, JKRHeap* h
|
||||
}
|
||||
|
||||
osc->mScale = tosc->mScale;
|
||||
osc->_14 = tosc->field_0x14;
|
||||
osc->mVertex = tosc->field_0x14;
|
||||
instp->setOsc(osc_idx, osc);
|
||||
}
|
||||
|
||||
@@ -312,7 +312,7 @@ JASOscillator::Data* JASBNKParser::Ver0::findOscPtr(JASBasicBank* bank, THeader
|
||||
JASOscillator::Point const* JASBNKParser::Ver0::getOscTableEndPtr(JASOscillator::Point const* points) {
|
||||
const JASOscillator::Point* ptr = points;
|
||||
while(true) {
|
||||
s16 tmp = ptr->_0;
|
||||
s16 tmp = ptr->mEnvelopeMode;
|
||||
ptr++;
|
||||
if (tmp > 10) {
|
||||
break;
|
||||
|
||||
@@ -42,13 +42,13 @@ JASChannel* JASBank::noteOn(JASBank const* param_0, int param_1, u8 param_2, u8
|
||||
return NULL;
|
||||
}
|
||||
channel->setPriority(param_4);
|
||||
channel->field_0xdc.field_0x4 = *waveInfo;
|
||||
channel->field_0x104 = wavePtr;
|
||||
channel->field_0xdc.field_0x0 = stack_60.field_0x1c;
|
||||
channel->field_0xdc.mWaveInfo = *waveInfo;
|
||||
channel->mWaveAramAddress = wavePtr;
|
||||
channel->field_0xdc.mChannelType = stack_60.field_0x1c;
|
||||
channel->setBankDisposeID(param_0);
|
||||
channel->setInitPitch(stack_60.mPitch * (waveInfo->field_0x04 / JASDriver::getDacRate()));
|
||||
channel->setInitPitch(stack_60.mPitch * (waveInfo->mSampleRate / JASDriver::getDacRate()));
|
||||
if (stack_60.field_0x1e == 0) {
|
||||
channel->setKey(param_2 - waveInfo->field_0x01);
|
||||
channel->setKey(param_2 - waveInfo->mBaseKey);
|
||||
}
|
||||
channel->setInitVolume(stack_60.mVolume);
|
||||
channel->setVelocity(param_3);
|
||||
@@ -79,10 +79,10 @@ JASChannel* JASBank::noteOnOsc(int param_0, u8 param_1, u8 param_2, u16 param_3,
|
||||
return NULL;
|
||||
}
|
||||
channel->setPriority(param_3);
|
||||
channel->field_0x104 = param_0;
|
||||
channel->field_0xdc.field_0x0 = 2;
|
||||
channel->mOscillatorSomething = param_0;
|
||||
channel->field_0xdc.mChannelType = 2;
|
||||
channel->setInitPitch(16736.016f / JASDriver::getDacRate());
|
||||
channel->setKey(param_1 - channel->field_0xdc.field_0x4.field_0x01);
|
||||
channel->setKey(param_1 - channel->field_0xdc.mWaveInfo.mBaseKey);
|
||||
channel->setVelocity(param_2);
|
||||
channel->setOscInit(0, &OSC_ENV);
|
||||
if (!channel->play()) {
|
||||
|
||||
@@ -50,7 +50,7 @@ void JASBasicWaveBank::incWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
|
||||
if (!handle->mHeap) {
|
||||
handle->mHeap = ¶m_0->mHeap;
|
||||
handle->field_0x4.field_0x20 = ¶m_0->_48;
|
||||
handle->field_0x4.field_0x08 = param_0->mCtrlWaveArray[i].field_0x4;
|
||||
handle->field_0x4.mOffsetStart = param_0->mCtrlWaveArray[i].field_0x4;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,7 +64,7 @@ void JASBasicWaveBank::decWaveTable(JASBasicWaveBank::TWaveGroup const* param_0)
|
||||
if (handle->mHeap == ¶m_0->mHeap) {
|
||||
handle->mHeap = NULL;
|
||||
handle->field_0x4.field_0x20 = &mNoLoad;
|
||||
handle->field_0x4.field_0x08 = -1;
|
||||
handle->field_0x4.mOffsetStart = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -86,9 +86,9 @@ void JASBasicWaveBank::setWaveInfo(JASBasicWaveBank::TWaveGroup* wgrp, int index
|
||||
JUT_ASSERT(206, index >= 0);
|
||||
mWaveTable[param_2].field_0x4 = param_3;
|
||||
mWaveTable[param_2].field_0x4.field_0x20 = &mNoLoad;
|
||||
mWaveTable[param_2].field_0x4.field_0x08 = -1;
|
||||
mWaveTable[param_2].field_0x4.mOffsetStart = -1;
|
||||
wgrp->mCtrlWaveArray[index].field_0x0 = param_2;
|
||||
wgrp->mCtrlWaveArray[index].field_0x4 = param_3.field_0x08;
|
||||
wgrp->mCtrlWaveArray[index].field_0x4 = param_3.mOffsetStart;
|
||||
}
|
||||
|
||||
JASBasicWaveBank::TWaveGroup::TWaveGroup() {
|
||||
@@ -131,5 +131,5 @@ intptr_t JASBasicWaveBank::TWaveHandle::getWavePtr() const {
|
||||
if (base == 0) {
|
||||
return 0;
|
||||
}
|
||||
return (intptr_t)base + field_0x4.field_0x08;
|
||||
return (intptr_t)base + field_0x4.mOffsetStart;
|
||||
}
|
||||
|
||||
@@ -31,7 +31,7 @@ JASChannel::JASChannel(Callback i_callback, void* i_callbackData) :
|
||||
mKeySweepCount(0),
|
||||
mSkipSamples(0)
|
||||
{
|
||||
field_0xdc.field_0x0 = 0;
|
||||
field_0xdc.mChannelType = 0;
|
||||
field_0x104 = 0;
|
||||
mMixConfig[0].whole = 0x150;
|
||||
mMixConfig[1].whole = 0x210;
|
||||
@@ -171,12 +171,12 @@ void JASChannel::updateEffectorParam(JASDsp::TChannel* i_channel, u16* i_mixerVo
|
||||
f32 pan = 0.5f;
|
||||
f32 dolby = 0.0f;
|
||||
switch (JASDriver::getOutputMode()) {
|
||||
case 0:
|
||||
case JAS_OUTPUT_MONO:
|
||||
break;
|
||||
case 1:
|
||||
case JAS_OUTPUT_STEREO:
|
||||
pan = calcPan(&pan_vector);
|
||||
break;
|
||||
case 2:
|
||||
case JAS_OUTPUT_SURROUND:
|
||||
pan = calcPan(&pan_vector);
|
||||
dolby = calcEffect(&dolby_vector);
|
||||
break;
|
||||
@@ -229,7 +229,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
mCallback(CB_START, this, i_channel, mCallbackData);
|
||||
}
|
||||
|
||||
if (field_0xdc.field_0x4.field_0x20[0] == 0) {
|
||||
if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
|
||||
JUT_WARN_DEVICE(346, 2, "%s", "Lost wave data while playing");
|
||||
mDspCh->free();
|
||||
mDspCh = NULL;
|
||||
@@ -245,19 +245,19 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
switch (field_0xdc.field_0x0) {
|
||||
switch (field_0xdc.mChannelType) {
|
||||
case 0:
|
||||
i_channel->setWaveInfo(field_0xdc.field_0x4, field_0x104, mSkipSamples);
|
||||
i_channel->setWaveInfo(field_0xdc.mWaveInfo, mWaveAramAddress, mSkipSamples);
|
||||
break;
|
||||
case 2:
|
||||
i_channel->setOscInfo(field_0x104);
|
||||
i_channel->setOscInfo(mOscillatorSomething);
|
||||
break;
|
||||
}
|
||||
|
||||
for (u8 i = 0; i < 6; i++) {
|
||||
for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
|
||||
MixConfig mix_config = mMixConfig[i];
|
||||
u32 output_mode = JASDriver::getOutputMode();
|
||||
if (output_mode == 0) {
|
||||
if (output_mode == JAS_OUTPUT_MONO) {
|
||||
switch (mix_config.parts.upper) {
|
||||
case 8:
|
||||
mix_config.parts.upper = 11;
|
||||
@@ -266,7 +266,7 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
mix_config.parts.upper = 2;
|
||||
break;
|
||||
}
|
||||
} else if (output_mode == 1 && mix_config.parts.upper == 8) {
|
||||
} else if (output_mode == JAS_OUTPUT_STEREO && mix_config.parts.upper == 8) {
|
||||
mix_config.parts.upper = 11;
|
||||
}
|
||||
i_channel->setBusConnect(i, mix_config.parts.upper);
|
||||
@@ -281,9 +281,9 @@ s32 JASChannel::initialUpdateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
}
|
||||
mVibrate.resetCounter();
|
||||
mTremolo.resetCounter();
|
||||
u16 mixer_volume[6];
|
||||
u16 mixer_volume[DSP_OUTPUT_CHANNELS];
|
||||
updateEffectorParam(i_channel, mixer_volume, effect_params);
|
||||
for (u8 i = 0; i < 6; i++) {
|
||||
for (u8 i = 0; i < DSP_OUTPUT_CHANNELS; i++) {
|
||||
i_channel->setMixerInitVolume(i, mixer_volume[i]);
|
||||
}
|
||||
|
||||
@@ -307,7 +307,7 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
mCallback(CB_PLAY, this, i_channel, mCallbackData);
|
||||
}
|
||||
|
||||
if (field_0xdc.field_0x4.field_0x20[0] == 0) {
|
||||
if (field_0xdc.mWaveInfo.field_0x20[0] == 0) {
|
||||
JUT_WARN_DEVICE(456, 2, "%s","Lost wave data while playing");
|
||||
mDspCh->free();
|
||||
mDspCh = NULL;
|
||||
@@ -378,18 +378,18 @@ s32 JASChannel::updateDSPChannel(JASDsp::TChannel* i_channel) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 param_1, f32 param_2,
|
||||
f32 param_3, f32 param_4) {
|
||||
if (JASDriver::getOutputMode() == 0) {
|
||||
param_1 *= 0.707f;
|
||||
void JASChannel::updateAutoMixer(JASDsp::TChannel* i_channel, f32 volume, f32 pan,
|
||||
f32 fxmix, f32 dolby) {
|
||||
if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
|
||||
volume *= 0.707f;
|
||||
}
|
||||
param_1 = JASCalc::clamp01(param_1);
|
||||
volume = JASCalc::clamp01(volume);
|
||||
|
||||
u16 r31 = param_1 * JASDriver::getChannelLevel_dsp();
|
||||
u8 r30 = param_2 * 127.5f;
|
||||
u8 r29 = param_4 * 127.5f;
|
||||
u8 r28 = param_3 * 127.5f;
|
||||
i_channel->setAutoMixer(r31, r30, r29, r28, 0);
|
||||
u16 dspVolume = volume * JASDriver::getChannelLevel_dsp();
|
||||
u8 dspPan = pan * 127.5f;
|
||||
u8 dspDolby = dolby * 127.5f;
|
||||
u8 dspFxMix = fxmix * 127.5f;
|
||||
i_channel->setAutoMixer(dspVolume, dspPan, dspDolby, dspFxMix, 0);
|
||||
}
|
||||
|
||||
void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby, u16* i_volumeOut) {
|
||||
@@ -429,7 +429,7 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
|
||||
volume *= scale;
|
||||
break;
|
||||
default:
|
||||
if (JASDriver::getOutputMode() == 0) {
|
||||
if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
|
||||
volume *= scale;
|
||||
} else {
|
||||
volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);
|
||||
@@ -471,7 +471,7 @@ void JASChannel::updateMixer(f32 i_volume, f32 i_pan, f32 i_fxmix, f32 i_dolby,
|
||||
volume *= scale;
|
||||
break;
|
||||
default:
|
||||
if (JASDriver::getOutputMode() == 0) {
|
||||
if (JASDriver::getOutputMode() == JAS_OUTPUT_MONO) {
|
||||
volume *= scale;
|
||||
} else {
|
||||
volume *= JMASinRadian(scale * JGeometry::TUtil<f32>::PI() * 0.5f);
|
||||
|
||||
@@ -10,7 +10,7 @@ JASDSPChannel::JASDSPChannel() :
|
||||
mStatus(STATUS_INACTIVE),
|
||||
mPriority(-1),
|
||||
mFlags(0),
|
||||
field_0xc(0),
|
||||
mUpdateCounter(0),
|
||||
mCallback(NULL),
|
||||
mCallbackData(NULL),
|
||||
mChannel(NULL)
|
||||
@@ -42,9 +42,9 @@ void JASDSPChannel::drop() {
|
||||
}
|
||||
|
||||
void JASDSPChannel::initAll() {
|
||||
sDspChannels = JKR_NEW_ARRAY_ARGS(JASDSPChannel, 0x40, JASDram, 0x20);
|
||||
sDspChannels = JKR_NEW_ARRAY_ARGS(JASDSPChannel, DSP_CHANNELS, JASDram, 0x20);
|
||||
JUT_ASSERT(102, sDspChannels);
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
sDspChannels[i].mChannel = JASDsp::getDSPHandle(i);
|
||||
}
|
||||
}
|
||||
@@ -56,7 +56,7 @@ JASDSPChannel* JASDSPChannel::alloc(u8 i_priority, Callback i_callback, void* i_
|
||||
}
|
||||
channel->drop();
|
||||
channel->mPriority = i_priority;
|
||||
channel->field_0xc = 0;
|
||||
channel->mUpdateCounter = 0;
|
||||
channel->mCallback = i_callback;
|
||||
channel->mCallbackData = i_callbackData;
|
||||
return channel;
|
||||
@@ -70,7 +70,7 @@ JASDSPChannel* JASDSPChannel::allocForce(u8 i_priority, Callback i_callback, voi
|
||||
channel->mStatus = STATUS_INACTIVE;
|
||||
channel->drop();
|
||||
channel->mPriority = i_priority;
|
||||
channel->field_0xc = 0;
|
||||
channel->mUpdateCounter = 0;
|
||||
channel->mCallback = i_callback;
|
||||
channel->mCallbackData = i_callbackData;
|
||||
return channel;
|
||||
@@ -83,16 +83,16 @@ void JASDSPChannel::setPriority(u8 i_priority) {
|
||||
JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
|
||||
s16 best_priority = 0xff;
|
||||
int best_index = -1;
|
||||
int best_unknown = 0;
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
int best_updateCounter = 0;
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
JASDSPChannel* channel = &sDspChannels[i];
|
||||
s16 priority = channel->mPriority;
|
||||
if (priority < 0) {
|
||||
return &sDspChannels[i];
|
||||
}
|
||||
if (priority <= i_priority && priority <= best_priority) {
|
||||
if (priority != best_priority || channel->field_0xc > best_unknown) {
|
||||
best_unknown = channel->field_0xc;
|
||||
if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
|
||||
best_updateCounter = channel->mUpdateCounter;
|
||||
best_index = i;
|
||||
best_priority = priority;
|
||||
}
|
||||
@@ -107,14 +107,14 @@ JASDSPChannel* JASDSPChannel::getLowestChannel(int i_priority) {
|
||||
JASDSPChannel* JASDSPChannel::getLowestActiveChannel() {
|
||||
s16 best_priority = 0xff;
|
||||
int best_index = -1;
|
||||
int best_unknown = 0;
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
int best_updateCounter = 0;
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
JASDSPChannel* channel = &sDspChannels[i];
|
||||
if (channel->mStatus == STATUS_ACTIVE) {
|
||||
s16 priority = channel->mPriority;
|
||||
if (priority < 0x7f && priority <= best_priority) {
|
||||
if (priority != best_priority || channel->field_0xc > best_unknown) {
|
||||
best_unknown = channel->field_0xc;
|
||||
if (priority != best_priority || channel->mUpdateCounter > best_updateCounter) {
|
||||
best_updateCounter = channel->mUpdateCounter;
|
||||
best_index = i;
|
||||
best_priority = priority;
|
||||
}
|
||||
@@ -195,7 +195,7 @@ void JASDSPChannel::updateProc() {
|
||||
mChannel->playStop();
|
||||
mChannel->flush();
|
||||
} else {
|
||||
field_0xc++;
|
||||
mUpdateCounter++;
|
||||
if (flush) {
|
||||
mChannel->flush();
|
||||
}
|
||||
@@ -205,7 +205,7 @@ void JASDSPChannel::updateProc() {
|
||||
}
|
||||
|
||||
void JASDSPChannel::updateAll() {
|
||||
for (u32 i = 0; i < 0x40; i++) {
|
||||
for (u32 i = 0; i < DSP_CHANNELS; i++) {
|
||||
if ((i & 0xf) == 0 && i != 0) {
|
||||
JASDsp::releaseHalt((i - 1) >> 4);
|
||||
}
|
||||
@@ -230,8 +230,8 @@ JASDSPChannel* JASDSPChannel::getHandle(u32 i_index) {
|
||||
|
||||
u32 JASDSPChannel::getNumUse() {
|
||||
u32 count = 0;
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
if (sDspChannels[i].mStatus == 0) {
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
if (sDspChannels[i].mStatus == STATUS_ACTIVE) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
@@ -240,8 +240,8 @@ u32 JASDSPChannel::getNumUse() {
|
||||
|
||||
u32 JASDSPChannel::getNumFree() {
|
||||
u32 count = 0;
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
if (sDspChannels[i].mStatus == 1) {
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
if (sDspChannels[i].mStatus == STATUS_INACTIVE) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
@@ -250,8 +250,8 @@ u32 JASDSPChannel::getNumFree() {
|
||||
|
||||
u32 JASDSPChannel::getNumBreak() {
|
||||
u32 count = 0;
|
||||
for (int i = 0; i < 0x40; i++) {
|
||||
if (sDspChannels[i].mStatus == 2) {
|
||||
for (int i = 0; i < DSP_CHANNELS; i++) {
|
||||
if (sDspChannels[i].mStatus == STATUS_DROP) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -72,8 +72,8 @@ f32 JASDsp::getDSPMixerLevel() {
|
||||
return sDSPVolume;
|
||||
}
|
||||
|
||||
JASDsp::TChannel* JASDsp::getDSPHandle(int param_0) {
|
||||
return CH_BUF + param_0;
|
||||
JASDsp::TChannel* JASDsp::getDSPHandle(int index) {
|
||||
return CH_BUF + index;
|
||||
}
|
||||
|
||||
JASDsp::TChannel* JASDsp::getDSPHandleNc(int param_0) {
|
||||
@@ -87,12 +87,12 @@ void JASDsp::setFilterTable(s16* param_0, s16* param_1, u32 param_2) {
|
||||
}
|
||||
|
||||
void JASDsp::flushBuffer() {
|
||||
DCFlushRange(CH_BUF, sizeof(TChannel) * 64);
|
||||
DCFlushRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
|
||||
DCFlushRange(FX_BUF, sizeof(FxBuf) * 4);
|
||||
}
|
||||
|
||||
void JASDsp::invalChannelAll() {
|
||||
DCInvalidateRange(CH_BUF, sizeof(TChannel) * 64);
|
||||
DCInvalidateRange(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
|
||||
}
|
||||
|
||||
u8 const ATTRIBUTE_ALIGN(32) JASDsp::DSPADPCM_FILTER[64] = {
|
||||
@@ -426,16 +426,16 @@ u32 const ATTRIBUTE_ALIGN(32) JASDsp::DSPRES_FILTER[320] = {
|
||||
};
|
||||
|
||||
void JASDsp::initBuffer() {
|
||||
CH_BUF = JKR_NEW_ARRAY_ARGS(TChannel, 64, JASDram, 0x20);
|
||||
CH_BUF = JKR_NEW_ARRAY_ARGS(TChannel, DSP_CHANNELS, JASDram, 0x20);
|
||||
JUT_ASSERT(354, CH_BUF);
|
||||
FX_BUF = JKR_NEW_ARRAY_ARGS(FxBuf, 4, JASDram, 0x20);
|
||||
JUT_ASSERT(356, FX_BUF);
|
||||
JASCalc::bzero(CH_BUF, 0x6000);
|
||||
JASCalc::bzero(CH_BUF, sizeof(TChannel) * DSP_CHANNELS);
|
||||
JASCalc::bzero(FX_BUF, sizeof(FxBuf) * 4);
|
||||
for (u8 i = 0; i < 4; i++) {
|
||||
setFXLine(i, NULL, NULL);
|
||||
}
|
||||
DsetupTable(0x40, uintptr_t(CH_BUF), uintptr_t(&DSPRES_FILTER), uintptr_t(&DSPADPCM_FILTER), uintptr_t(FX_BUF));
|
||||
DsetupTable(DSP_CHANNELS, uintptr_t(CH_BUF), uintptr_t(&DSPRES_FILTER), uintptr_t(&DSPADPCM_FILTER), uintptr_t(FX_BUF));
|
||||
|
||||
flushBuffer();
|
||||
}
|
||||
@@ -501,8 +501,8 @@ void JASDsp::TChannel::init() {
|
||||
mIsFinished = 0;
|
||||
mForcedStop = 0;
|
||||
mIsActive = 0;
|
||||
field_0x058 = 0;
|
||||
field_0x068 = 0;
|
||||
mAutoMixerBeenSet = 0;
|
||||
mSamplePosition = 0;
|
||||
initFilter();
|
||||
}
|
||||
|
||||
@@ -549,41 +549,41 @@ bool JASDsp::TChannel::isFinish() const {
|
||||
return mIsFinished != 0;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32 param_2) {
|
||||
void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& waveInfo, u32 aramAddress, u32 skipSamples) {
|
||||
int i;
|
||||
JUT_ASSERT(610, dspMutex);
|
||||
field_0x118 = param_1;
|
||||
mWaveAramAddress = aramAddress;
|
||||
static const u8 COMP_BLOCKSAMPLES[8] = {0x10, 0x10, 0x01, 0x01, 0x01, 0x10, 0x10, 0x01};
|
||||
field_0x064 = COMP_BLOCKSAMPLES[param_0.field_0x00];
|
||||
mSamplesPerBlock = COMP_BLOCKSAMPLES[waveInfo.mWaveFormat];
|
||||
static const u8 COMP_BLOCKBYTES[8] = {0x09, 0x05, 0x08, 0x10, 0x01, 0x01, 0x01, 0x01};
|
||||
field_0x100 = COMP_BLOCKBYTES[param_0.field_0x00];
|
||||
field_0x068 = 0;
|
||||
if (field_0x100 >= 4) {
|
||||
field_0x11c = param_0.field_0x18;
|
||||
field_0x102 = param_0.field_0x02;
|
||||
mBytesPerBlock = COMP_BLOCKBYTES[waveInfo.mWaveFormat];
|
||||
mSamplePosition = 0;
|
||||
if (mBytesPerBlock >= 4) {
|
||||
mSampleCount = waveInfo.mSampleCount;
|
||||
field_0x102 = waveInfo.mLoopFlag;
|
||||
if (field_0x102) {
|
||||
if (param_2 == 1) {
|
||||
param_2 = param_0.field_0x10;
|
||||
if (skipSamples == 1) {
|
||||
skipSamples = waveInfo.mLoopStartSample;
|
||||
}
|
||||
field_0x110 = param_0.field_0x10;
|
||||
field_0x114 = param_0.field_0x14;
|
||||
field_0x104 = param_0.field_0x1c;
|
||||
field_0x106 = param_0.field_0x1e;
|
||||
mLoopStartSample = waveInfo.mLoopStartSample;
|
||||
mEndSample = waveInfo.mLoopEndSample;
|
||||
mpLast = waveInfo.mpLast;
|
||||
mpPenult = waveInfo.mpPenult;
|
||||
} else {
|
||||
field_0x114 = field_0x11c;
|
||||
mEndSample = mSampleCount;
|
||||
}
|
||||
if (param_2 && field_0x114 > param_2) {
|
||||
switch (param_0.field_0x00) {
|
||||
case 0:
|
||||
case 1:
|
||||
field_0x068 = param_2;
|
||||
field_0x118 += param_2 * field_0x100 >> 4;
|
||||
field_0x110 -= param_2;
|
||||
field_0x114 -= param_2;
|
||||
if (skipSamples && mEndSample > skipSamples) {
|
||||
switch (waveInfo.mWaveFormat) {
|
||||
case WAVE_FORMAT_ADPCM4:
|
||||
case WAVE_FORMAT_ADPCM2:
|
||||
mSamplePosition = skipSamples;
|
||||
mWaveAramAddress += skipSamples * mBytesPerBlock >> 4;
|
||||
mLoopStartSample -= skipSamples;
|
||||
mEndSample -= skipSamples;
|
||||
break;
|
||||
case 2:
|
||||
case 3:
|
||||
field_0x068 = param_2;
|
||||
case WAVE_FORMAT_PCM8:
|
||||
case WAVE_FORMAT_PCM16:
|
||||
mSamplePosition = skipSamples;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -595,28 +595,27 @@ void JASDsp::TChannel::setWaveInfo(JASWaveInfo const& param_0, u32 param_1, u32
|
||||
|
||||
void JASDsp::TChannel::setOscInfo(u32 param_0) {
|
||||
JUT_ASSERT(671, dspMutex);
|
||||
field_0x118 = 0;
|
||||
field_0x064 = 16;
|
||||
field_0x100 = param_0;
|
||||
mWaveAramAddress = 0;
|
||||
mSamplesPerBlock = 16;
|
||||
mBytesPerBlock = param_0;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::initAutoMixer() {
|
||||
JUT_ASSERT(688, dspMutex);
|
||||
if (field_0x058) {
|
||||
field_0x054 = field_0x056;
|
||||
if (mAutoMixerBeenSet) {
|
||||
mAutoMixerInitVolume = mAutoMixerVolume;
|
||||
} else {
|
||||
field_0x054 = 0;
|
||||
field_0x058 = 1;
|
||||
mAutoMixerInitVolume = 0;
|
||||
mAutoMixerBeenSet = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setAutoMixer(u16 param_0, u8 param_1, u8 param_2, u8 param_3,
|
||||
u8 param_4) {
|
||||
void JASDsp::TChannel::setAutoMixer(u16 volume, u8 pan, u8 dolby, u8 fxMix, u8) {
|
||||
JUT_ASSERT(709, dspMutex);
|
||||
field_0x050 = (param_1 << 8) | param_2;
|
||||
field_0x052 = param_3 << 8 | param_3 << 1;
|
||||
field_0x056 = param_0;
|
||||
field_0x058 = 1;
|
||||
mAutoMixerPanDolby = (pan << 8) | dolby;
|
||||
mAutoMixerFxMix = fxMix << 8 | fxMix << 1;
|
||||
mAutoMixerVolume = volume;
|
||||
mAutoMixerBeenSet = 1;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setPitch(u16 param_0) {
|
||||
@@ -627,21 +626,20 @@ void JASDsp::TChannel::setPitch(u16 param_0) {
|
||||
mPitch = param_0;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setMixerInitVolume(u8 param_0, s16 param_1) {
|
||||
void JASDsp::TChannel::setMixerInitVolume(u8 outputChannel, s16 volume) {
|
||||
JUT_ASSERT(798, dspMutex);
|
||||
u16* tmp = field_0x010[param_0];
|
||||
tmp[2] = param_1;
|
||||
tmp[1] = param_1;
|
||||
tmp[3] = 0;
|
||||
OutputChannelConfig& cfg = mOutputChannels[outputChannel];
|
||||
cfg.mCurrentVolume = volume;
|
||||
cfg.mTargetVolume = volume;
|
||||
cfg.mVolumeProgress = 0;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setMixerVolume(u8 param_0, s16 param_1) {
|
||||
u16* tmp;
|
||||
void JASDsp::TChannel::setMixerVolume(u8 outputChannel, s16 volume) {
|
||||
JUT_ASSERT(841, dspMutex);
|
||||
if (mForcedStop == 0) {
|
||||
tmp = field_0x010[param_0];
|
||||
tmp[1] = param_1;
|
||||
tmp[3] &= 0xff;
|
||||
OutputChannelConfig& cfg = mOutputChannels[outputChannel];
|
||||
cfg.mTargetVolume = volume;
|
||||
cfg.mVolumeProgress &= 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -699,16 +697,16 @@ void JASDsp::TChannel::setDistFilter(s16 param_0) {
|
||||
iir_filter_params[4] = param_0;
|
||||
}
|
||||
|
||||
void JASDsp::TChannel::setBusConnect(u8 param_0, u8 param_1) {
|
||||
void JASDsp::TChannel::setBusConnect(u8 outputChannel, u8 param_1) {
|
||||
JUT_ASSERT(973, dspMutex);
|
||||
u16* tmp = field_0x010[param_0];
|
||||
OutputChannelConfig& tmp = mOutputChannels[outputChannel];
|
||||
static u16 const connect_table[12] = {
|
||||
0x0000, 0x0D00, 0x0D60, 0x0DC0, 0x0E20, 0x0E80,
|
||||
0x0EE0, 0x0CA0, 0x0F40, 0x0FA0, 0x0B00, 0x09A0,
|
||||
};
|
||||
u16 r30 = 0;
|
||||
r30 = connect_table[param_1];
|
||||
tmp[0] = r30;
|
||||
tmp.mBusConnect = r30;
|
||||
}
|
||||
|
||||
u16 DSP_CreateMap2(u32 param_0) {
|
||||
|
||||
@@ -23,10 +23,10 @@ f32 JASDriver::getDSPLevel() {
|
||||
return JASDsp::getDSPMixerLevel();
|
||||
}
|
||||
|
||||
u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = 0x00000001;
|
||||
u32 JASDriver::JAS_SYSTEM_OUTPUT_MODE = JAS_OUTPUT_STEREO;
|
||||
|
||||
void JASDriver::setOutputMode(u32 param_0) {
|
||||
JAS_SYSTEM_OUTPUT_MODE = param_0;
|
||||
void JASDriver::setOutputMode(u32 mode) {
|
||||
JAS_SYSTEM_OUTPUT_MODE = mode;
|
||||
}
|
||||
|
||||
u32 JASDriver::getOutputMode() {
|
||||
|
||||
@@ -49,11 +49,11 @@ bool JASDrumSet::getParam(int key, int param_1, JASInstParam* param_2) const {
|
||||
static JASOscillator::Data osc;
|
||||
|
||||
osc.mTarget = 0;
|
||||
osc._04 = 1.0f;
|
||||
osc.mRate = 1.0f;
|
||||
osc.mTable = NULL;
|
||||
osc.rel_table = NULL;
|
||||
osc.mScale = 1.0f;
|
||||
osc._14 = 0.0f;
|
||||
osc.mVertex = 0.0f;
|
||||
|
||||
static JASOscillator::Data* oscp = &osc;
|
||||
|
||||
|
||||
@@ -4,9 +4,9 @@
|
||||
|
||||
JASOscillator::JASOscillator() {
|
||||
mData = NULL;
|
||||
_14 = 0;
|
||||
mCurPoint = 0;
|
||||
mDirectRelease = 0;
|
||||
_18 = 0;
|
||||
mEnvelopeMode = 0;
|
||||
_1C = 0;
|
||||
_04 = _08 = _10 = _0C = 0.0f;
|
||||
}
|
||||
@@ -17,7 +17,7 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
|
||||
_04 = 0.0f;
|
||||
_08 = 0.0f;
|
||||
_0C = 0.0f;
|
||||
_14 = 0;
|
||||
mCurPoint = 0;
|
||||
mDirectRelease = 0;
|
||||
if (!data) {
|
||||
_1C = 0;
|
||||
@@ -30,8 +30,8 @@ void JASOscillator::initStart(JASOscillator::Data const* data) {
|
||||
return;
|
||||
}
|
||||
|
||||
_10 = mData->mTable[0]._4 / 32768.0f;
|
||||
_18 = mData->mTable[0]._0;
|
||||
_10 = mData->mTable[0].mValue / 32768.0f;
|
||||
mEnvelopeMode = mData->mTable[0].mEnvelopeMode;
|
||||
_1C = 1;
|
||||
}
|
||||
|
||||
@@ -44,13 +44,13 @@ void JASOscillator::incCounter(f32 param_0) {
|
||||
case 1:
|
||||
break;
|
||||
}
|
||||
_04 += param_0 * mData->_04;
|
||||
_04 += param_0 * mData->mRate;
|
||||
update();
|
||||
}
|
||||
|
||||
f32 JASOscillator::getValue() const {
|
||||
JUT_ASSERT(120, mData);
|
||||
return _08 * mData->mScale + mData->_14;
|
||||
return _08 * mData->mScale + mData->mVertex;
|
||||
}
|
||||
|
||||
void JASOscillator::release() {
|
||||
@@ -63,8 +63,8 @@ void JASOscillator::release() {
|
||||
_04 = 0.0f;
|
||||
_0C = _08;
|
||||
_10 = 0.0f;
|
||||
_14 = 0;
|
||||
_18 = (mDirectRelease >> 14) & 3;
|
||||
mCurPoint = 0;
|
||||
mEnvelopeMode = (mDirectRelease >> 14) & 3;
|
||||
_1C = 4;
|
||||
update();
|
||||
return;
|
||||
@@ -74,9 +74,9 @@ void JASOscillator::release() {
|
||||
JUT_ASSERT(157, mData->rel_table != NULL);
|
||||
_04 = 0.0f;
|
||||
_0C = _08;
|
||||
_10 = mData->rel_table[0]._4 / 32768.0f;
|
||||
_14 = 0;
|
||||
_18 = mData->rel_table[0]._0;
|
||||
_10 = mData->rel_table[0].mValue / 32768.0f;
|
||||
mCurPoint = 0;
|
||||
mEnvelopeMode = mData->rel_table[0].mEnvelopeMode;
|
||||
}
|
||||
|
||||
_1C = 3;
|
||||
@@ -104,31 +104,31 @@ void JASOscillator::update() {
|
||||
return;
|
||||
}
|
||||
|
||||
while (_04 >= psVar1[_14]._2) {
|
||||
_04 -= psVar1[_14]._2;
|
||||
while (_04 >= psVar1[mCurPoint].mTime) {
|
||||
_04 -= psVar1[mCurPoint].mTime;
|
||||
_08 = _10;
|
||||
_14++;
|
||||
mCurPoint++;
|
||||
_0C = _08;
|
||||
const BE(s16)* ps = &psVar1[_14]._0;
|
||||
s16 r26 = ps[0];
|
||||
switch(r26) {
|
||||
case 0xf:
|
||||
const Point* ps = &psVar1[mCurPoint];
|
||||
s16 mode = ps->mEnvelopeMode;
|
||||
switch(mode) {
|
||||
case ENVELOPE_STOP:
|
||||
_1C = 0;
|
||||
return;
|
||||
case 0xe:
|
||||
case ENVELOPE_HOLD:
|
||||
_1C = 2;
|
||||
return;
|
||||
case 0xd:
|
||||
_14 = ps[2];
|
||||
case ENVELOPE_LOOP:
|
||||
mCurPoint = ps->mValue;
|
||||
break;
|
||||
default:
|
||||
_18 = r26;
|
||||
_10 = ps[2] / 32768.0f;
|
||||
mEnvelopeMode = mode;
|
||||
_10 = ps->mValue / 32768.0f;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
updateCurrentValue(psVar1[_14]._2);
|
||||
updateCurrentValue(psVar1[mCurPoint].mTime);
|
||||
}
|
||||
|
||||
f32 const JASOscillator::sCurveTableLinear[17] = {
|
||||
@@ -163,7 +163,7 @@ static f32* table_list[4] = {
|
||||
};
|
||||
|
||||
void JASOscillator::updateCurrentValue(f32 param_0) {
|
||||
f32* table = table_list[_18];
|
||||
f32* table = table_list[mEnvelopeMode];
|
||||
f32 fVar1 = 16.0f * (_04 / param_0);
|
||||
u32 index = (u32) fVar1;
|
||||
f32 fVar3 = (fVar1 - index);
|
||||
|
||||
@@ -44,7 +44,7 @@ intptr_t JASSimpleWaveBank::TWaveHandle::getWavePtr() const {
|
||||
if (base == NULL) {
|
||||
return 0;
|
||||
}
|
||||
return (intptr_t)base + mWaveInfo.field_0x08;
|
||||
return (intptr_t)base + mWaveInfo.mOffsetStart;
|
||||
}
|
||||
|
||||
JASSimpleWaveBank::TWaveHandle::TWaveHandle() {
|
||||
|
||||
@@ -356,7 +356,7 @@ int JASTrack::gateOn(u32 param_0, u32 i_velocity, f32 i_time, u32 i_flags) {
|
||||
} else {
|
||||
JASChannel* channel = channel_mgr->mChannels[0];
|
||||
if (channel != NULL) {
|
||||
channel->setKey(uvar7 - channel->field_0xdc.field_0x4.field_0x01);
|
||||
channel->setKey(uvar7 - channel->field_0xdc.mWaveInfo.mBaseKey);
|
||||
channel->setVelocity(i_velocity);
|
||||
channel->setUpdateTimer(update_timer);
|
||||
}
|
||||
@@ -545,10 +545,10 @@ void JASTrack::setOscTable(u32 osc_no, JASOscillator::Point const* i_table) {
|
||||
void JASTrack::setOscAdsr(s16 param_0, s16 param_1, s16 param_2, s16 param_3, u16 i_directRelease) {
|
||||
mOscParam[0] = sEnvOsc;
|
||||
mOscParam[0].mTable = mOscPoint;
|
||||
mOscPoint[0]._2 = param_0;
|
||||
mOscPoint[1]._2 = param_1;
|
||||
mOscPoint[2]._2 = param_2;
|
||||
mOscPoint[2]._4 = param_3;
|
||||
mOscPoint[0].mTime = param_0;
|
||||
mOscPoint[1].mTime = param_1;
|
||||
mOscPoint[2].mTime = param_2;
|
||||
mOscPoint[2].mValue = param_3;
|
||||
mDirectRelease = i_directRelease;
|
||||
}
|
||||
|
||||
|
||||
@@ -48,17 +48,17 @@ JASBasicWaveBank* JASWSParser::createBasicWaveBank(void const* stream, JKRHeap*
|
||||
for (int j = 0; j < ctrl->mWaveCount; j++) {
|
||||
TWave* wave = archive->mWaveOffsets[j].ptr(header);
|
||||
JASWaveInfo wave_info;
|
||||
wave_info.field_0x00 = wave->_01;
|
||||
wave_info.field_0x01 = wave->_02;
|
||||
wave_info.field_0x04 = wave->_04;
|
||||
wave_info.field_0x08 = wave->mOffset;
|
||||
wave_info.field_0x0c = wave->_0C;
|
||||
wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
|
||||
wave_info.field_0x10 = wave->_14;
|
||||
wave_info.field_0x14 = wave->_18;
|
||||
wave_info.field_0x18 = wave->_1C;
|
||||
wave_info.field_0x1c = wave->_20;
|
||||
wave_info.field_0x1e = wave->_22;
|
||||
wave_info.mWaveFormat = wave->mWaveFormat;
|
||||
wave_info.mBaseKey = wave->mBaseKey;
|
||||
wave_info.mSampleRate = wave->mSampleRate;
|
||||
wave_info.mOffsetStart = wave->mAWOffsetStart;
|
||||
wave_info.mOffsetLength = wave->mAWOffsetEnd;
|
||||
wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
|
||||
wave_info.mLoopStartSample = wave->mLoopStartSample;
|
||||
wave_info.mLoopEndSample = wave->mLoopEndSample;
|
||||
wave_info.mSampleCount = wave->mSampleCount;
|
||||
wave_info.mpLast = wave->mpLast;
|
||||
wave_info.mpPenult = wave->mpPenult;
|
||||
TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[j].ptr(header);
|
||||
u16 local_74 = JSULoHalf(ctrl_wave->_00);
|
||||
wave_bank->setWaveInfo(wave_group, j, local_74, wave_info);
|
||||
@@ -104,17 +104,17 @@ JASSimpleWaveBank* JASWSParser::createSimpleWaveBank(void const* stream, JKRHeap
|
||||
for (int i = 0; i < ctrl->mWaveCount; i++) {
|
||||
TWave* wave = archive->mWaveOffsets[i].ptr(header);
|
||||
JASWaveInfo wave_info;
|
||||
wave_info.field_0x00 = wave->_01;
|
||||
wave_info.field_0x01 = wave->_02;
|
||||
wave_info.field_0x04 = wave->_04;
|
||||
wave_info.field_0x08 = wave->mOffset;
|
||||
wave_info.field_0x0c = wave->_0C;
|
||||
wave_info.field_0x02 = wave->_10 == 0 ? 0 : 0xff;
|
||||
wave_info.field_0x10 = wave->_14;
|
||||
wave_info.field_0x14 = wave->_18;
|
||||
wave_info.field_0x18 = wave->_1C;
|
||||
wave_info.field_0x1c = wave->_20;
|
||||
wave_info.field_0x1e = wave->_22;
|
||||
wave_info.mWaveFormat = wave->mWaveFormat;
|
||||
wave_info.mBaseKey = wave->mBaseKey;
|
||||
wave_info.mSampleRate = wave->mSampleRate;
|
||||
wave_info.mOffsetStart = wave->mAWOffsetStart;
|
||||
wave_info.mOffsetLength = wave->mAWOffsetEnd;
|
||||
wave_info.mLoopFlag = wave->mLoopFlags == 0 ? 0 : 0xff;
|
||||
wave_info.mLoopStartSample = wave->mLoopStartSample;
|
||||
wave_info.mLoopEndSample = wave->mLoopEndSample;
|
||||
wave_info.mSampleCount = wave->mSampleCount;
|
||||
wave_info.mpLast = wave->mpLast;
|
||||
wave_info.mpPenult = wave->mpPenult;
|
||||
TCtrlWave* ctrl_wave = ctrl->mCtrlWaveOffsets[i].ptr(header);
|
||||
u32 tmp = JSULoHalf(ctrl_wave->_00);
|
||||
wave_bank->setWaveInfo(tmp, wave_info);
|
||||
|
||||
@@ -27,7 +27,7 @@ JAU_JASInitializer::JAU_JASInitializer() {
|
||||
#endif
|
||||
dvdThreadPriority_ = 3;
|
||||
audioThreadPriority_ = 2;
|
||||
field_0x1c = 0x80;
|
||||
mJasTrackPoolSize = 0x80;
|
||||
dspLevel_ = 1.0f;
|
||||
aramBlockSize_ = 0x2760;
|
||||
aramChannelNum_ = 2;
|
||||
@@ -54,7 +54,7 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {
|
||||
|
||||
JASKernel::setupAramHeap(audioMemory_, audioMemSize_);
|
||||
|
||||
JASTrack::newMemPool(field_0x1c);
|
||||
JASTrack::newMemPool(mJasTrackPoolSize);
|
||||
if (field_0x20 > 0) {
|
||||
JASTrack::TChannelMgr::newMemPool(field_0x20);
|
||||
}
|
||||
@@ -80,33 +80,33 @@ void JAU_JASInitializer::initJASystem(JKRSolidHeap* heap) {
|
||||
}
|
||||
|
||||
#if PLATFORM_SHIELD
|
||||
JASDriver::setOutputMode(1);
|
||||
JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
|
||||
#else
|
||||
switch (OSGetSoundMode()) {
|
||||
case 0:
|
||||
JASDriver::setOutputMode(0);
|
||||
case OS_SOUND_MODE_MONO:
|
||||
JASDriver::setOutputMode(JAS_OUTPUT_MONO);
|
||||
break;
|
||||
case 1:
|
||||
JASDriver::setOutputMode(1);
|
||||
case OS_SOUND_MODE_STEREO:
|
||||
JASDriver::setOutputMode(JAS_OUTPUT_STEREO);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
JAU_JAIInitializer::JAU_JAIInitializer() {
|
||||
field_0x0 = 100;
|
||||
field_0x4 = 4;
|
||||
field_0x8 = 2;
|
||||
field_0xc = 16;
|
||||
mJaiSePoolSize = 100;
|
||||
mJaiSeqPoolSize = 4;
|
||||
mJaiStreamPoolSize = 2;
|
||||
mJaiSoundChildPoolSize = 16;
|
||||
}
|
||||
|
||||
// NONMATCHING JASPoolAllocObject<_> locations
|
||||
void JAU_JAIInitializer::initJAInterface() {
|
||||
s32 r30 = JASDram->getFreeSize();
|
||||
JAIStream::newMemPool(field_0x8);
|
||||
JAISeq::newMemPool(field_0x4);
|
||||
JAISe::newMemPool(field_0x0);
|
||||
JAISoundChild::newMemPool(field_0xc);
|
||||
JAIStream::newMemPool(mJaiStreamPoolSize);
|
||||
JAISeq::newMemPool(mJaiSeqPoolSize);
|
||||
JAISe::newMemPool(mJaiSePoolSize);
|
||||
JAISoundChild::newMemPool(mJaiSoundChildPoolSize);
|
||||
s32 r29 = JASDram->getFreeSize();
|
||||
OS_REPORT("JAU_JAIInitializer uses %d bytes\n", r30 - r29);
|
||||
}
|
||||
|
||||
@@ -245,11 +245,11 @@ u8* JAUSection::newStaticSeqDataBlock_(JAISoundID param_0, u32 size) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 param_2) {
|
||||
bool JAUSection::newStaticSeqData(JAISoundID param_0, void const* param_1, u32 size) {
|
||||
{
|
||||
u8* r30 = newStaticSeqDataBlock_(param_0, param_2);
|
||||
u8* r30 = newStaticSeqDataBlock_(param_0, size);
|
||||
if (r30) {
|
||||
memcpy(r30, param_1, param_2);
|
||||
memcpy(r30, param_1, size);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -20,10 +20,10 @@ static void setup_callback(u16 param_0) {
|
||||
flag = FALSE;
|
||||
}
|
||||
|
||||
void DsetupTable(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
|
||||
void DsetupTable(u32 channelCount, u32 channelBufferAddress, u32 param_2, u32 param_3, u32 param_4) {
|
||||
u32 table[5];
|
||||
table[0] = (param_0 & 0xFFFF) | 0x81000000;
|
||||
table[1] = param_1;
|
||||
table[0] = (channelCount & 0xFFFF) | 0x81000000;
|
||||
table[1] = channelBufferAddress;
|
||||
table[2] = param_2;
|
||||
table[3] = param_3;
|
||||
table[4] = param_4;
|
||||
|
||||
@@ -527,7 +527,7 @@ static DSPTaskInfo audio_task ATTRIBUTE_ALIGN(32);
|
||||
|
||||
static u8 AUDIO_YIELD_BUFFER[8192] ATTRIBUTE_ALIGN(32);
|
||||
|
||||
void DspBoot(void (*param_0)(void*)) {
|
||||
void DspBoot(void (*requestCallback)(void*)) {
|
||||
DspInitWork();
|
||||
OS_REPORT("Dsp をブートします\n");
|
||||
audio_task.priority = 0xf0;
|
||||
@@ -542,7 +542,7 @@ void DspBoot(void (*param_0)(void*)) {
|
||||
audio_task.init_cb = DspHandShake;
|
||||
audio_task.res_cb = NULL;
|
||||
audio_task.done_cb = NULL;
|
||||
audio_task.req_cb = param_0;
|
||||
audio_task.req_cb = requestCallback;
|
||||
DSPInit();
|
||||
DSPAddPriorTask(&audio_task);
|
||||
OS_REPORT("Dspブートしました\n");
|
||||
|
||||
@@ -12,7 +12,7 @@ extern "C" void __DSP_remove_task(DSPTaskInfo* task);
|
||||
|
||||
static void Dsp_Update_Request();
|
||||
|
||||
static vu8 struct_80451308;
|
||||
static vu8 DspRunningStatus;
|
||||
static u8 struct_80451309;
|
||||
|
||||
DSPTaskInfo* DSP_prior_task;
|
||||
@@ -23,7 +23,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
OSClearContext(&funcContext);
|
||||
OSSetCurrentContext(&funcContext);
|
||||
|
||||
if (struct_80451308 == 1 || struct_80451308 == 0) {
|
||||
if (DspRunningStatus == 1 || DspRunningStatus == 0) {
|
||||
__DSP_curr_task = DSP_prior_task;
|
||||
}
|
||||
|
||||
@@ -38,7 +38,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
case 0xDCD10000:
|
||||
__DSP_curr_task->state = 1;
|
||||
if (__DSP_curr_task == DSP_prior_task) {
|
||||
struct_80451308 = 1;
|
||||
DspRunningStatus = 1;
|
||||
}
|
||||
if (__DSP_curr_task->init_cb != NULL) {
|
||||
__DSP_curr_task->init_cb(__DSP_curr_task);
|
||||
@@ -47,7 +47,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
case 0xDCD10001:
|
||||
__DSP_curr_task->state = 1;
|
||||
if (__DSP_curr_task == DSP_prior_task) {
|
||||
struct_80451308 = 1;
|
||||
DspRunningStatus = 1;
|
||||
Dsp_Update_Request();
|
||||
}
|
||||
if (__DSP_curr_task->res_cb != NULL) {
|
||||
@@ -97,7 +97,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
__DSP_curr_task = DSP_prior_task;
|
||||
Dsp_Update_Request();
|
||||
} else {
|
||||
struct_80451308 = 3;
|
||||
DspRunningStatus = 3;
|
||||
DSPSendMailToDSP(0xCDD10001);
|
||||
while (DSPCheckMailToDSP() != 0);
|
||||
__DSP_exec_task(DSP_prior_task, __DSP_first_task);
|
||||
@@ -113,7 +113,7 @@ extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
static u32 sync_stack[5];
|
||||
|
||||
void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
|
||||
if (struct_80451308 != 1) {
|
||||
if (DspRunningStatus != 1) {
|
||||
sync_stack[0] = param_0;
|
||||
struct_80451309 = 1;
|
||||
sync_stack[1] = param_1;
|
||||
@@ -125,7 +125,7 @@ void DsyncFrame2(u32 param_0, u32 param_1, u32 param_2) {
|
||||
}
|
||||
|
||||
static void DsyncFrame3(u32 param_0, u32 param_1, u32 param_2, u32 param_3, u32 param_4) {
|
||||
if (struct_80451308 != 1) {
|
||||
if (DspRunningStatus != 1) {
|
||||
sync_stack[0] = param_0;
|
||||
struct_80451309 = 2;
|
||||
sync_stack[1] = param_1;
|
||||
@@ -152,9 +152,9 @@ static void Dsp_Update_Request() {
|
||||
}
|
||||
|
||||
int Dsp_Running_Check() {
|
||||
return struct_80451308 == 1 ? TRUE : FALSE;
|
||||
return DspRunningStatus == 1 ? TRUE : FALSE;
|
||||
}
|
||||
|
||||
void Dsp_Running_Start() {
|
||||
struct_80451308 = 1;
|
||||
DspRunningStatus = 1;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user