mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-14 21:37:52 -07:00
Core/DSPHLE: Remove global System access in UCodes.
This commit is contained in:
Admiral H. Curtiss
parent
a9bf93cf2a
commit
e9ab33b871
@ -95,7 +95,7 @@ void AESndUCode::Update()
|
||||
// This is dubious in general, since we set the interrupt parameter on m_mail_handler.PushMail
|
||||
if (m_mail_handler.HasPending())
|
||||
{
|
||||
Core::System::GetInstance().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
m_dsphle->GetSystem().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
}
|
||||
}
|
||||
|
||||
@ -154,14 +154,18 @@ void AESndUCode::HandleMail(u32 mail)
|
||||
// No mail is sent in response
|
||||
break;
|
||||
case MAIL_SEND_SAMPLES:
|
||||
{
|
||||
DEBUG_LOG_FMT(DSPHLE, "AESndUCode - MAIL_SEND_SAMPLES");
|
||||
// send_samples
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < NUM_OUTPUT_SAMPLES * 2; i++)
|
||||
{
|
||||
HLEMemory_Write_U16(m_parameter_block.out_buf + i * sizeof(u16), m_output_buffer[i]);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block.out_buf + i * sizeof(u16),
|
||||
m_output_buffer[i]);
|
||||
}
|
||||
m_mail_handler.PushMail(DSP_SYNC, true);
|
||||
break;
|
||||
}
|
||||
case MAIL_TERMINATE:
|
||||
INFO_LOG_FMT(DSPHLE, "AESndUCode - MAIL_TERMINATE: {:08x}", mail);
|
||||
if (m_crc != HASH_2022_PAD && m_crc != HASH_2023)
|
||||
@ -197,40 +201,42 @@ void AESndUCode::HandleMail(u32 mail)
|
||||
|
||||
void AESndUCode::DMAInParameterBlock()
|
||||
{
|
||||
m_parameter_block.out_buf = HLEMemory_Read_U32(m_parameter_block_addr + 0);
|
||||
m_parameter_block.buf_start = HLEMemory_Read_U32(m_parameter_block_addr + 4);
|
||||
m_parameter_block.buf_end = HLEMemory_Read_U32(m_parameter_block_addr + 8);
|
||||
m_parameter_block.buf_curr = HLEMemory_Read_U32(m_parameter_block_addr + 12);
|
||||
m_parameter_block.yn1 = HLEMemory_Read_U16(m_parameter_block_addr + 16);
|
||||
m_parameter_block.yn2 = HLEMemory_Read_U16(m_parameter_block_addr + 18);
|
||||
m_parameter_block.pds = HLEMemory_Read_U16(m_parameter_block_addr + 20);
|
||||
m_parameter_block.freq = HLEMemory_Read_U32(m_parameter_block_addr + 22);
|
||||
m_parameter_block.counter = HLEMemory_Read_U16(m_parameter_block_addr + 26);
|
||||
m_parameter_block.left = HLEMemory_Read_U16(m_parameter_block_addr + 28);
|
||||
m_parameter_block.right = HLEMemory_Read_U16(m_parameter_block_addr + 30);
|
||||
m_parameter_block.volume_l = HLEMemory_Read_U16(m_parameter_block_addr + 32);
|
||||
m_parameter_block.volume_r = HLEMemory_Read_U16(m_parameter_block_addr + 34);
|
||||
m_parameter_block.delay = HLEMemory_Read_U32(m_parameter_block_addr + 36);
|
||||
m_parameter_block.flags = HLEMemory_Read_U32(m_parameter_block_addr + 40);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
m_parameter_block.out_buf = HLEMemory_Read_U32(memory, m_parameter_block_addr + 0);
|
||||
m_parameter_block.buf_start = HLEMemory_Read_U32(memory, m_parameter_block_addr + 4);
|
||||
m_parameter_block.buf_end = HLEMemory_Read_U32(memory, m_parameter_block_addr + 8);
|
||||
m_parameter_block.buf_curr = HLEMemory_Read_U32(memory, m_parameter_block_addr + 12);
|
||||
m_parameter_block.yn1 = HLEMemory_Read_U16(memory, m_parameter_block_addr + 16);
|
||||
m_parameter_block.yn2 = HLEMemory_Read_U16(memory, m_parameter_block_addr + 18);
|
||||
m_parameter_block.pds = HLEMemory_Read_U16(memory, m_parameter_block_addr + 20);
|
||||
m_parameter_block.freq = HLEMemory_Read_U32(memory, m_parameter_block_addr + 22);
|
||||
m_parameter_block.counter = HLEMemory_Read_U16(memory, m_parameter_block_addr + 26);
|
||||
m_parameter_block.left = HLEMemory_Read_U16(memory, m_parameter_block_addr + 28);
|
||||
m_parameter_block.right = HLEMemory_Read_U16(memory, m_parameter_block_addr + 30);
|
||||
m_parameter_block.volume_l = HLEMemory_Read_U16(memory, m_parameter_block_addr + 32);
|
||||
m_parameter_block.volume_r = HLEMemory_Read_U16(memory, m_parameter_block_addr + 34);
|
||||
m_parameter_block.delay = HLEMemory_Read_U32(memory, m_parameter_block_addr + 36);
|
||||
m_parameter_block.flags = HLEMemory_Read_U32(memory, m_parameter_block_addr + 40);
|
||||
}
|
||||
|
||||
void AESndUCode::DMAOutParameterBlock()
|
||||
{
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 0, m_parameter_block.out_buf);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 4, m_parameter_block.buf_start);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 8, m_parameter_block.buf_end);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 12, m_parameter_block.buf_curr);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 16, m_parameter_block.yn1);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 18, m_parameter_block.yn2);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 20, m_parameter_block.pds);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 22, m_parameter_block.freq);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 26, m_parameter_block.counter);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 28, m_parameter_block.left);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 30, m_parameter_block.right);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 32, m_parameter_block.volume_l);
|
||||
HLEMemory_Write_U16(m_parameter_block_addr + 34, m_parameter_block.volume_r);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 36, m_parameter_block.delay);
|
||||
HLEMemory_Write_U32(m_parameter_block_addr + 40, m_parameter_block.flags);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 0, m_parameter_block.out_buf);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 4, m_parameter_block.buf_start);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 8, m_parameter_block.buf_end);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 12, m_parameter_block.buf_curr);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 16, m_parameter_block.yn1);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 18, m_parameter_block.yn2);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 20, m_parameter_block.pds);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 22, m_parameter_block.freq);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 26, m_parameter_block.counter);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 28, m_parameter_block.left);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 30, m_parameter_block.right);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 32, m_parameter_block.volume_l);
|
||||
HLEMemory_Write_U16(memory, m_parameter_block_addr + 34, m_parameter_block.volume_r);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 36, m_parameter_block.delay);
|
||||
HLEMemory_Write_U32(memory, m_parameter_block_addr + 40, m_parameter_block.flags);
|
||||
}
|
||||
|
||||
void AESndAccelerator::OnEndException()
|
||||
|
||||
@ -80,7 +80,7 @@ void ASndUCode::Update()
|
||||
// This is dubious in general, since we set the interrupt parameter on m_mail_handler.PushMail
|
||||
if (m_mail_handler.HasPending())
|
||||
{
|
||||
Core::System::GetInstance().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
m_dsphle->GetSystem().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
}
|
||||
}
|
||||
|
||||
@ -128,17 +128,20 @@ void ASndUCode::HandleMail(u32 mail)
|
||||
// Mail is handled by DoMixing()
|
||||
break;
|
||||
case MAIL_INPUT_SAMPLES_2:
|
||||
{
|
||||
WARN_LOG_FMT(DSPHLE, "ASndUCode - MAIL_INPUT_SAMPLES_2: {:08x} - not normally used", mail);
|
||||
// input_samples2
|
||||
DMAInVoiceData(); // first do_dma call
|
||||
// second do_dma call
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < NUM_OUTPUT_SAMPLES * 2; i++)
|
||||
{
|
||||
m_output_buffer[i] = HLEMemory_Read_U16(m_current_voice.out_buf + i * sizeof(u16));
|
||||
m_output_buffer[i] = HLEMemory_Read_U16(memory, m_current_voice.out_buf + i * sizeof(u16));
|
||||
}
|
||||
DoMixing(DSP_SYNC);
|
||||
// Mail is handled by DoMixing()
|
||||
break;
|
||||
}
|
||||
case MAIL_SET_VOICE_DATA_BUFFER:
|
||||
DEBUG_LOG_FMT(DSPHLE, "ASndUCode - MAIL_SET_VOICE_DATA_BUFFER: {:08x}", mail);
|
||||
m_next_mail_is_voice_addr = true;
|
||||
@ -153,13 +156,16 @@ void ASndUCode::HandleMail(u32 mail)
|
||||
// Mail is handled by DoMixing()
|
||||
break;
|
||||
case MAIN_SEND_SAMPLES:
|
||||
{
|
||||
DEBUG_LOG_FMT(DSPHLE, "ASndUCode - MAIN_SEND_SAMPLES: {:08x}", mail);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < NUM_OUTPUT_SAMPLES * 2; i++)
|
||||
{
|
||||
HLEMemory_Write_U16(m_current_voice.out_buf + i * sizeof(u16), m_output_buffer[i]);
|
||||
HLEMemory_Write_U16(memory, m_current_voice.out_buf + i * sizeof(u16), m_output_buffer[i]);
|
||||
}
|
||||
m_mail_handler.PushMail(DSP_SYNC, true);
|
||||
break;
|
||||
}
|
||||
case MAIL_ROM_DUMP_WORD:
|
||||
WARN_LOG_FMT(DSPHLE, "ASndUCode - MAIL_ROM_DUMP_WORD: {:08x} - not normally used", mail);
|
||||
// Reads instruction at 0x8000 | (mail >> 16), and sends it back in DMBL. DMBH is 0.
|
||||
@ -196,51 +202,53 @@ void ASndUCode::HandleMail(u32 mail)
|
||||
|
||||
void ASndUCode::DMAInVoiceData()
|
||||
{
|
||||
m_current_voice.out_buf = HLEMemory_Read_U32(m_voice_addr);
|
||||
m_current_voice.delay_samples = HLEMemory_Read_U32(m_voice_addr + 4);
|
||||
u32 new_flags = HLEMemory_Read_U32(m_voice_addr + 8);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
m_current_voice.out_buf = HLEMemory_Read_U32(memory, m_voice_addr);
|
||||
m_current_voice.delay_samples = HLEMemory_Read_U32(memory, m_voice_addr + 4);
|
||||
u32 new_flags = HLEMemory_Read_U32(memory, m_voice_addr + 8);
|
||||
if (m_current_voice.flags != new_flags)
|
||||
DEBUG_LOG_FMT(DSPHLE, "ASndUCode - flags: {:08x}", new_flags);
|
||||
m_current_voice.flags = new_flags;
|
||||
m_current_voice.start_addr = HLEMemory_Read_U32(m_voice_addr + 12);
|
||||
m_current_voice.end_addr = HLEMemory_Read_U32(m_voice_addr + 16);
|
||||
m_current_voice.freq = HLEMemory_Read_U32(m_voice_addr + 20);
|
||||
m_current_voice.left = HLEMemory_Read_U16(m_voice_addr + 24);
|
||||
m_current_voice.right = HLEMemory_Read_U16(m_voice_addr + 26);
|
||||
m_current_voice.counter = HLEMemory_Read_U32(m_voice_addr + 28);
|
||||
m_current_voice.volume_l = HLEMemory_Read_U16(m_voice_addr + 32);
|
||||
m_current_voice.volume_r = HLEMemory_Read_U16(m_voice_addr + 34);
|
||||
m_current_voice.start_addr2 = HLEMemory_Read_U32(m_voice_addr + 36);
|
||||
m_current_voice.end_addr2 = HLEMemory_Read_U32(m_voice_addr + 40);
|
||||
m_current_voice.volume2_l = HLEMemory_Read_U16(m_voice_addr + 44);
|
||||
m_current_voice.volume2_r = HLEMemory_Read_U16(m_voice_addr + 46);
|
||||
m_current_voice.backup_addr = HLEMemory_Read_U32(m_voice_addr + 48);
|
||||
m_current_voice.tick_counter = HLEMemory_Read_U32(m_voice_addr + 52);
|
||||
m_current_voice.cb = HLEMemory_Read_U32(m_voice_addr + 56);
|
||||
m_current_voice._pad = HLEMemory_Read_U32(m_voice_addr + 60);
|
||||
m_current_voice.start_addr = HLEMemory_Read_U32(memory, m_voice_addr + 12);
|
||||
m_current_voice.end_addr = HLEMemory_Read_U32(memory, m_voice_addr + 16);
|
||||
m_current_voice.freq = HLEMemory_Read_U32(memory, m_voice_addr + 20);
|
||||
m_current_voice.left = HLEMemory_Read_U16(memory, m_voice_addr + 24);
|
||||
m_current_voice.right = HLEMemory_Read_U16(memory, m_voice_addr + 26);
|
||||
m_current_voice.counter = HLEMemory_Read_U32(memory, m_voice_addr + 28);
|
||||
m_current_voice.volume_l = HLEMemory_Read_U16(memory, m_voice_addr + 32);
|
||||
m_current_voice.volume_r = HLEMemory_Read_U16(memory, m_voice_addr + 34);
|
||||
m_current_voice.start_addr2 = HLEMemory_Read_U32(memory, m_voice_addr + 36);
|
||||
m_current_voice.end_addr2 = HLEMemory_Read_U32(memory, m_voice_addr + 40);
|
||||
m_current_voice.volume2_l = HLEMemory_Read_U16(memory, m_voice_addr + 44);
|
||||
m_current_voice.volume2_r = HLEMemory_Read_U16(memory, m_voice_addr + 46);
|
||||
m_current_voice.backup_addr = HLEMemory_Read_U32(memory, m_voice_addr + 48);
|
||||
m_current_voice.tick_counter = HLEMemory_Read_U32(memory, m_voice_addr + 52);
|
||||
m_current_voice.cb = HLEMemory_Read_U32(memory, m_voice_addr + 56);
|
||||
m_current_voice._pad = HLEMemory_Read_U32(memory, m_voice_addr + 60);
|
||||
}
|
||||
|
||||
void ASndUCode::DMAOutVoiceData()
|
||||
{
|
||||
HLEMemory_Write_U32(m_voice_addr, m_current_voice.out_buf);
|
||||
HLEMemory_Write_U32(m_voice_addr + 4, m_current_voice.delay_samples);
|
||||
HLEMemory_Write_U32(m_voice_addr + 8, m_current_voice.flags);
|
||||
HLEMemory_Write_U32(m_voice_addr + 12, m_current_voice.start_addr);
|
||||
HLEMemory_Write_U32(m_voice_addr + 16, m_current_voice.end_addr);
|
||||
HLEMemory_Write_U32(m_voice_addr + 20, m_current_voice.freq);
|
||||
HLEMemory_Write_U16(m_voice_addr + 24, m_current_voice.left);
|
||||
HLEMemory_Write_U16(m_voice_addr + 26, m_current_voice.right);
|
||||
HLEMemory_Write_U32(m_voice_addr + 28, m_current_voice.counter);
|
||||
HLEMemory_Write_U16(m_voice_addr + 32, m_current_voice.volume_l);
|
||||
HLEMemory_Write_U16(m_voice_addr + 34, m_current_voice.volume_r);
|
||||
HLEMemory_Write_U32(m_voice_addr + 36, m_current_voice.start_addr2);
|
||||
HLEMemory_Write_U32(m_voice_addr + 40, m_current_voice.end_addr2);
|
||||
HLEMemory_Write_U16(m_voice_addr + 44, m_current_voice.volume2_l);
|
||||
HLEMemory_Write_U16(m_voice_addr + 46, m_current_voice.volume2_r);
|
||||
HLEMemory_Write_U32(m_voice_addr + 48, m_current_voice.backup_addr);
|
||||
HLEMemory_Write_U32(m_voice_addr + 52, m_current_voice.tick_counter);
|
||||
HLEMemory_Write_U32(m_voice_addr + 56, m_current_voice.cb);
|
||||
HLEMemory_Write_U32(m_voice_addr + 60, m_current_voice._pad);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
HLEMemory_Write_U32(memory, m_voice_addr, m_current_voice.out_buf);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 4, m_current_voice.delay_samples);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 8, m_current_voice.flags);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 12, m_current_voice.start_addr);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 16, m_current_voice.end_addr);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 20, m_current_voice.freq);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 24, m_current_voice.left);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 26, m_current_voice.right);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 28, m_current_voice.counter);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 32, m_current_voice.volume_l);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 34, m_current_voice.volume_r);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 36, m_current_voice.start_addr2);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 40, m_current_voice.end_addr2);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 44, m_current_voice.volume2_l);
|
||||
HLEMemory_Write_U16(memory, m_voice_addr + 46, m_current_voice.volume2_r);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 48, m_current_voice.backup_addr);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 52, m_current_voice.tick_counter);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 56, m_current_voice.cb);
|
||||
HLEMemory_Write_U32(memory, m_voice_addr + 60, m_current_voice._pad);
|
||||
}
|
||||
|
||||
void ASndUCode::DoMixing(u32 return_mail)
|
||||
@ -449,9 +457,10 @@ void ASndUCode::DMAInSampleData()
|
||||
// The only difference is that this one forces the address to be aligned, while when
|
||||
// jump_load_smp_dma is used, the address is expected to already be aligned.
|
||||
const u32 addr = m_current_voice.start_addr & ~INPUT_SAMPLE_BUFFER_BYTE_MASK;
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u16 i = 0; i < INPUT_SAMPLE_BUFFER_SIZE_WORDS; i++)
|
||||
{
|
||||
m_input_sample_buffer[i] = HLEMemory_Read_U16(addr + i * sizeof(u16));
|
||||
m_input_sample_buffer[i] = HLEMemory_Read_U16(memory, addr + i * sizeof(u16));
|
||||
}
|
||||
}
|
||||
|
||||
@ -461,9 +470,10 @@ void ASndUCode::DMAInSampleDataAssumeAligned()
|
||||
// This is technically not a function, but instead is directly jumped to and then jumps to $ar3
|
||||
// (which is set to an address from sample_selector). We can just treat it as a function though.
|
||||
const u32 addr = m_current_voice.start_addr;
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u16 i = 0; i < INPUT_SAMPLE_BUFFER_SIZE_WORDS; i++)
|
||||
{
|
||||
m_input_sample_buffer[i] = HLEMemory_Read_U16(addr + i * sizeof(u16));
|
||||
m_input_sample_buffer[i] = HLEMemory_Read_U16(memory, addr + i * sizeof(u16));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -390,9 +390,10 @@ void AXUCode::DownloadAndMixWithVolume(u32 addr, u16 vol_main, u16 vol_auxa, u16
|
||||
int** buffers[3] = {buffers_main, buffers_auxa, buffers_auxb};
|
||||
u16 volumes[3] = {vol_main, vol_auxa, vol_auxb};
|
||||
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < 3; ++i)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(addr);
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, addr);
|
||||
u16 volume = volumes[i];
|
||||
for (u32 j = 0; j < 3; ++j)
|
||||
{
|
||||
@ -415,16 +416,17 @@ void AXUCode::ProcessPBList(u32 pb_addr)
|
||||
|
||||
AXPB pb;
|
||||
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
while (pb_addr)
|
||||
{
|
||||
AXBuffers buffers = {{m_samples_main_left, m_samples_main_right, m_samples_main_surround,
|
||||
m_samples_auxA_left, m_samples_auxA_right, m_samples_auxA_surround,
|
||||
m_samples_auxB_left, m_samples_auxB_right, m_samples_auxB_surround}};
|
||||
|
||||
ReadPB(pb_addr, pb, m_crc);
|
||||
ReadPB(memory, pb_addr, pb, m_crc);
|
||||
|
||||
u32 updates_addr = HILO_TO_32(pb.updates.data);
|
||||
u16* updates = (u16*)HLEMemory_Get_Pointer(updates_addr);
|
||||
u16* updates = (u16*)HLEMemory_Get_Pointer(memory, updates_addr);
|
||||
|
||||
for (int curr_ms = 0; curr_ms < 5; ++curr_ms)
|
||||
{
|
||||
@ -439,7 +441,7 @@ void AXUCode::ProcessPBList(u32 pb_addr)
|
||||
ptr += spms;
|
||||
}
|
||||
|
||||
WritePB(pb_addr, pb, m_crc);
|
||||
WritePB(memory, pb_addr, pb, m_crc);
|
||||
pb_addr = HILO_TO_32(pb.next_pb);
|
||||
}
|
||||
}
|
||||
@ -464,9 +466,10 @@ void AXUCode::MixAUXSamples(int aux_id, u32 write_addr, u32 read_addr)
|
||||
}
|
||||
|
||||
// First, we need to send the contents of our AUX buffers to the CPU.
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
if (write_addr)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(write_addr);
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, write_addr);
|
||||
for (auto& buffer : buffers)
|
||||
for (u32 j = 0; j < 5 * 32; ++j)
|
||||
*ptr++ = Common::swap32(buffer[j]);
|
||||
@ -474,7 +477,7 @@ void AXUCode::MixAUXSamples(int aux_id, u32 write_addr, u32 read_addr)
|
||||
|
||||
// Then, we read the new temp from the CPU and add to our current
|
||||
// temp.
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(read_addr);
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, read_addr);
|
||||
for (auto& sample : m_samples_main_left)
|
||||
sample += (int)Common::swap32(*ptr++);
|
||||
for (auto& sample : m_samples_main_right)
|
||||
@ -493,12 +496,13 @@ void AXUCode::UploadLRS(u32 dst_addr)
|
||||
buffers[1][i] = Common::swap32(m_samples_main_right[i]);
|
||||
buffers[2][i] = Common::swap32(m_samples_main_surround[i]);
|
||||
}
|
||||
memcpy(HLEMemory_Get_Pointer(dst_addr), buffers, sizeof(buffers));
|
||||
memcpy(HLEMemory_Get_Pointer(m_dsphle->GetSystem().GetMemory(), dst_addr), buffers,
|
||||
sizeof(buffers));
|
||||
}
|
||||
|
||||
void AXUCode::SetMainLR(u32 src_addr)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(src_addr);
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(m_dsphle->GetSystem().GetMemory(), src_addr);
|
||||
for (u32 i = 0; i < 5 * 32; ++i)
|
||||
{
|
||||
int samp = (int)Common::swap32(*ptr++);
|
||||
@ -545,7 +549,8 @@ void AXUCode::RunCompressor(u16 threshold, u16 release_frames, u32 table_addr, u
|
||||
}
|
||||
|
||||
// apply the selected ramp
|
||||
u16* ramp = (u16*)HLEMemory_Get_Pointer(table_addr + table_offset);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
u16* ramp = (u16*)HLEMemory_Get_Pointer(memory, table_addr + table_offset);
|
||||
for (u32 i = 0; i < 32 * millis; ++i)
|
||||
{
|
||||
u16 coef = Common::swap16(*ramp++);
|
||||
@ -560,7 +565,8 @@ void AXUCode::OutputSamples(u32 lr_addr, u32 surround_addr)
|
||||
|
||||
for (u32 i = 0; i < 5 * 32; ++i)
|
||||
surround_buffer[i] = Common::swap32(m_samples_main_surround[i]);
|
||||
memcpy(HLEMemory_Get_Pointer(surround_addr), surround_buffer, sizeof(surround_buffer));
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
memcpy(HLEMemory_Get_Pointer(memory, surround_addr), surround_buffer, sizeof(surround_buffer));
|
||||
|
||||
// 32 samples per ms, 5 ms, 2 channels
|
||||
short buffer[5 * 32 * 2];
|
||||
@ -575,20 +581,21 @@ void AXUCode::OutputSamples(u32 lr_addr, u32 surround_addr)
|
||||
buffer[2 * i + 1] = Common::swap16(left);
|
||||
}
|
||||
|
||||
memcpy(HLEMemory_Get_Pointer(lr_addr), buffer, sizeof(buffer));
|
||||
memcpy(HLEMemory_Get_Pointer(memory, lr_addr), buffer, sizeof(buffer));
|
||||
}
|
||||
|
||||
void AXUCode::MixAUXBLR(u32 ul_addr, u32 dl_addr)
|
||||
{
|
||||
// Upload AUXB L/R
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(ul_addr);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, ul_addr);
|
||||
for (auto& sample : m_samples_auxB_left)
|
||||
*ptr++ = Common::swap32(sample);
|
||||
for (auto& sample : m_samples_auxB_right)
|
||||
*ptr++ = Common::swap32(sample);
|
||||
|
||||
// Mix AUXB L/R to MAIN L/R, and replace AUXB L/R
|
||||
ptr = (int*)HLEMemory_Get_Pointer(dl_addr);
|
||||
ptr = (int*)HLEMemory_Get_Pointer(memory, dl_addr);
|
||||
for (u32 i = 0; i < 5 * 32; ++i)
|
||||
{
|
||||
int samp = Common::swap32(*ptr++);
|
||||
@ -605,7 +612,8 @@ void AXUCode::MixAUXBLR(u32 ul_addr, u32 dl_addr)
|
||||
|
||||
void AXUCode::SetOppositeLR(u32 src_addr)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(src_addr);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, src_addr);
|
||||
for (u32 i = 0; i < 5 * 32; ++i)
|
||||
{
|
||||
int inp = Common::swap32(*ptr++);
|
||||
@ -626,7 +634,8 @@ void AXUCode::SendAUXAndMix(u32 auxa_lrs_up, u32 auxb_s_up, u32 main_l_dl, u32 m
|
||||
};
|
||||
|
||||
// Upload AUXA LRS
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(auxa_lrs_up);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, auxa_lrs_up);
|
||||
for (const auto& up_buffer : up_buffers)
|
||||
{
|
||||
for (u32 j = 0; j < 32 * 5; ++j)
|
||||
@ -634,7 +643,7 @@ void AXUCode::SendAUXAndMix(u32 auxa_lrs_up, u32 auxb_s_up, u32 main_l_dl, u32 m
|
||||
}
|
||||
|
||||
// Upload AUXB S
|
||||
ptr = (int*)HLEMemory_Get_Pointer(auxb_s_up);
|
||||
ptr = (int*)HLEMemory_Get_Pointer(memory, auxb_s_up);
|
||||
for (auto& sample : m_samples_auxB_surround)
|
||||
*ptr++ = Common::swap32(sample);
|
||||
|
||||
@ -655,7 +664,7 @@ void AXUCode::SendAUXAndMix(u32 auxa_lrs_up, u32 auxb_s_up, u32 main_l_dl, u32 m
|
||||
// Download and mix
|
||||
for (size_t i = 0; i < dl_buffers.size(); ++i)
|
||||
{
|
||||
const int* dl_src = (int*)HLEMemory_Get_Pointer(dl_addrs[i]);
|
||||
const int* dl_src = (int*)HLEMemory_Get_Pointer(memory, dl_addrs[i]);
|
||||
for (size_t j = 0; j < 32 * 5; ++j)
|
||||
dl_buffers[i][j] += (int)Common::swap32(*dl_src++);
|
||||
}
|
||||
@ -743,8 +752,9 @@ void AXUCode::CopyCmdList(u32 addr, u16 size)
|
||||
return;
|
||||
}
|
||||
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < size; ++i, addr += 2)
|
||||
m_cmdlist[i] = HLEMemory_Read_U16(addr);
|
||||
m_cmdlist[i] = HLEMemory_Read_U16(memory, addr);
|
||||
}
|
||||
|
||||
void AXUCode::Update()
|
||||
|
||||
@ -18,6 +18,7 @@
|
||||
#include "Common/BitUtils.h"
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Common/Swap.h"
|
||||
#include "Core/HW/DSPHLE/DSPHLE.h"
|
||||
#include "Core/HW/DSPHLE/UCodes/UCodes.h"
|
||||
#include "Core/HW/Memmap.h"
|
||||
#include "Core/System.h"
|
||||
@ -154,7 +155,7 @@ protected:
|
||||
template <int Millis, size_t BufCount>
|
||||
void InitMixingBuffers(u32 init_addr, const std::array<BufferDesc, BufCount>& buffers)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& system = m_dsphle->GetSystem();
|
||||
auto& memory = system.GetMemory();
|
||||
std::array<u16, 3 * BufCount> init_array;
|
||||
memory.CopyFromEmuSwapped(init_array.data(), init_addr, sizeof(init_array));
|
||||
|
||||
@ -100,11 +100,8 @@ bool HasLpf(u32 crc)
|
||||
}
|
||||
|
||||
// Read a PB from MRAM/ARAM
|
||||
void ReadPB(u32 addr, PB_TYPE& pb, u32 crc)
|
||||
void ReadPB(Memory::MemoryManager& memory, u32 addr, PB_TYPE& pb, u32 crc)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (HasLpf(crc))
|
||||
{
|
||||
u16* dst = (u16*)&pb;
|
||||
@ -127,11 +124,8 @@ void ReadPB(u32 addr, PB_TYPE& pb, u32 crc)
|
||||
}
|
||||
|
||||
// Write a PB back to MRAM/ARAM
|
||||
void WritePB(u32 addr, const PB_TYPE& pb, u32 crc)
|
||||
void WritePB(Memory::MemoryManager& memory, u32 addr, const PB_TYPE& pb, u32 crc)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (HasLpf(crc))
|
||||
{
|
||||
const u16* src = (const u16*)&pb;
|
||||
|
||||
@ -271,7 +271,8 @@ void AXWiiUCode::SetupProcessing(u32 init_addr)
|
||||
|
||||
void AXWiiUCode::AddToLR(u32 val_addr, bool neg)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(val_addr);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, val_addr);
|
||||
for (int i = 0; i < 32 * 3; ++i)
|
||||
{
|
||||
int val = (int)Common::swap32(*ptr++);
|
||||
@ -285,7 +286,8 @@ void AXWiiUCode::AddToLR(u32 val_addr, bool neg)
|
||||
|
||||
void AXWiiUCode::AddSubToLR(u32 val_addr)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(val_addr);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, val_addr);
|
||||
for (int i = 0; i < 32 * 3; ++i)
|
||||
{
|
||||
int val = (int)Common::swap32(*ptr++);
|
||||
@ -371,7 +373,8 @@ bool AXWiiUCode::ExtractUpdatesFields(AXPBWii& pb, u16* num_updates, u16* update
|
||||
u16 addr_hi = pb_mem[44];
|
||||
u16 addr_lo = pb_mem[45];
|
||||
u32 addr = HILO_TO_32(addr);
|
||||
u16* ptr = (u16*)HLEMemory_Get_Pointer(addr);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
u16* ptr = (u16*)HLEMemory_Get_Pointer(memory, addr);
|
||||
|
||||
*updates_addr = addr;
|
||||
|
||||
@ -423,6 +426,7 @@ void AXWiiUCode::ProcessPBList(u32 pb_addr)
|
||||
|
||||
AXPBWii pb;
|
||||
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
while (pb_addr)
|
||||
{
|
||||
AXBuffers buffers = {{m_samples_main_left, m_samples_main_right, m_samples_main_surround,
|
||||
@ -433,7 +437,7 @@ void AXWiiUCode::ProcessPBList(u32 pb_addr)
|
||||
m_samples_aux1, m_samples_wm2, m_samples_aux2,
|
||||
m_samples_wm3, m_samples_aux3}};
|
||||
|
||||
ReadPB(pb_addr, pb, m_crc);
|
||||
ReadPB(memory, pb_addr, pb, m_crc);
|
||||
|
||||
u16 num_updates[3];
|
||||
u16 updates[1024];
|
||||
@ -460,7 +464,7 @@ void AXWiiUCode::ProcessPBList(u32 pb_addr)
|
||||
m_coeffs_checksum ? m_coeffs.data() : nullptr);
|
||||
}
|
||||
|
||||
WritePB(pb_addr, pb, m_crc);
|
||||
WritePB(memory, pb_addr, pb, m_crc);
|
||||
pb_addr = HILO_TO_32(pb.next_pb);
|
||||
}
|
||||
}
|
||||
@ -506,9 +510,10 @@ void AXWiiUCode::MixAUXSamples(int aux_id, u32 write_addr, u32 read_addr, u16 vo
|
||||
}
|
||||
|
||||
// Send the content of AUX buffers to the CPU
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
if (write_addr)
|
||||
{
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(write_addr);
|
||||
int* ptr = (int*)HLEMemory_Get_Pointer(memory, write_addr);
|
||||
for (const auto& buffer : buffers)
|
||||
{
|
||||
for (u32 j = 0; j < 3 * 32; ++j)
|
||||
@ -517,7 +522,7 @@ void AXWiiUCode::MixAUXSamples(int aux_id, u32 write_addr, u32 read_addr, u16 vo
|
||||
}
|
||||
|
||||
// Then read the buffers from the CPU and add to our main buffers.
|
||||
const int* ptr = (int*)HLEMemory_Get_Pointer(read_addr);
|
||||
const int* ptr = (int*)HLEMemory_Get_Pointer(memory, read_addr);
|
||||
for (auto& main_buffer : main_buffers)
|
||||
{
|
||||
for (u32 j = 0; j < 3 * 32; ++j)
|
||||
@ -536,7 +541,8 @@ void AXWiiUCode::UploadAUXMixLRSC(int aux_id, u32* addresses, u16 volume)
|
||||
int* aux_surround = aux_id ? m_samples_auxB_surround : m_samples_auxA_surround;
|
||||
int* auxc_buffer = aux_id ? m_samples_auxC_surround : m_samples_auxC_right;
|
||||
|
||||
int* upload_ptr = (int*)HLEMemory_Get_Pointer(addresses[0]);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
int* upload_ptr = (int*)HLEMemory_Get_Pointer(memory, addresses[0]);
|
||||
for (u32 i = 0; i < 96; ++i)
|
||||
*upload_ptr++ = Common::swap32(aux_left[i]);
|
||||
for (u32 i = 0; i < 96; ++i)
|
||||
@ -544,7 +550,7 @@ void AXWiiUCode::UploadAUXMixLRSC(int aux_id, u32* addresses, u16 volume)
|
||||
for (u32 i = 0; i < 96; ++i)
|
||||
*upload_ptr++ = Common::swap32(aux_surround[i]);
|
||||
|
||||
upload_ptr = (int*)HLEMemory_Get_Pointer(addresses[1]);
|
||||
upload_ptr = (int*)HLEMemory_Get_Pointer(memory, addresses[1]);
|
||||
for (u32 i = 0; i < 96; ++i)
|
||||
*upload_ptr++ = Common::swap32(auxc_buffer[i]);
|
||||
|
||||
@ -556,7 +562,7 @@ void AXWiiUCode::UploadAUXMixLRSC(int aux_id, u32* addresses, u16 volume)
|
||||
m_samples_auxC_left};
|
||||
for (u32 mix_i = 0; mix_i < 4; ++mix_i)
|
||||
{
|
||||
int* dl_ptr = (int*)HLEMemory_Get_Pointer(addresses[2 + mix_i]);
|
||||
int* dl_ptr = (int*)HLEMemory_Get_Pointer(memory, addresses[2 + mix_i]);
|
||||
for (u32 i = 0; i < 96; ++i)
|
||||
aux_left[i] = Common::swap32(dl_ptr[i]);
|
||||
|
||||
@ -579,14 +585,16 @@ void AXWiiUCode::OutputSamples(u32 lr_addr, u32 surround_addr, u16 volume, bool
|
||||
|
||||
for (size_t i = 0; i < upload_buffer.size(); ++i)
|
||||
upload_buffer[i] = Common::swap32(m_samples_main_surround[i]);
|
||||
memcpy(HLEMemory_Get_Pointer(surround_addr), upload_buffer.data(), sizeof(upload_buffer));
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
memcpy(HLEMemory_Get_Pointer(memory, surround_addr), upload_buffer.data(), sizeof(upload_buffer));
|
||||
|
||||
if (upload_auxc)
|
||||
{
|
||||
surround_addr += sizeof(upload_buffer);
|
||||
for (size_t i = 0; i < upload_buffer.size(); ++i)
|
||||
upload_buffer[i] = Common::swap32(m_samples_auxC_left[i]);
|
||||
memcpy(HLEMemory_Get_Pointer(surround_addr), upload_buffer.data(), sizeof(upload_buffer));
|
||||
memcpy(HLEMemory_Get_Pointer(memory, surround_addr), upload_buffer.data(),
|
||||
sizeof(upload_buffer));
|
||||
}
|
||||
|
||||
// Clamp internal buffers to 16 bits.
|
||||
@ -610,7 +618,7 @@ void AXWiiUCode::OutputSamples(u32 lr_addr, u32 surround_addr, u16 volume, bool
|
||||
buffer[2 * i + 1] = Common::swap16(m_samples_main_left[i]);
|
||||
}
|
||||
|
||||
memcpy(HLEMemory_Get_Pointer(lr_addr), buffer.data(), sizeof(buffer));
|
||||
memcpy(HLEMemory_Get_Pointer(memory, lr_addr), buffer.data(), sizeof(buffer));
|
||||
m_mail_handler.PushMail(DSP_SYNC, true);
|
||||
}
|
||||
|
||||
@ -618,10 +626,11 @@ void AXWiiUCode::OutputWMSamples(u32* addresses)
|
||||
{
|
||||
int* buffers[] = {m_samples_wm0, m_samples_wm1, m_samples_wm2, m_samples_wm3};
|
||||
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
for (u32 i = 0; i < 4; ++i)
|
||||
{
|
||||
int* in = buffers[i];
|
||||
u16* out = (u16*)HLEMemory_Get_Pointer(addresses[i]);
|
||||
u16* out = (u16*)HLEMemory_Get_Pointer(memory, addresses[i]);
|
||||
for (u32 j = 0; j < 3 * 6; ++j)
|
||||
{
|
||||
int sample = std::clamp(in[j], -32767, 32767);
|
||||
|
||||
@ -28,7 +28,7 @@ void CARDUCode::Update()
|
||||
// check if we have something to send
|
||||
if (m_mail_handler.HasPending())
|
||||
{
|
||||
Core::System::GetInstance().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
m_dsphle->GetSystem().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -15,26 +15,26 @@
|
||||
|
||||
namespace DSP::HLE
|
||||
{
|
||||
void ProcessGBACrypto(u32 address)
|
||||
void ProcessGBACrypto(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
// Nonce challenge (first read from GBA, hence already little-endian)
|
||||
const u32 challenge = HLEMemory_Read_U32LE(address);
|
||||
const u32 challenge = HLEMemory_Read_U32LE(memory, address);
|
||||
|
||||
// Palette of pulsing logo on GBA during transmission [0,6]
|
||||
const u32 logo_palette = HLEMemory_Read_U32(address + 4);
|
||||
const u32 logo_palette = HLEMemory_Read_U32(memory, address + 4);
|
||||
|
||||
// Speed and direction of palette interpolation [-4,4]
|
||||
const u32 logo_speed_32 = HLEMemory_Read_U32(address + 8);
|
||||
const u32 logo_speed_32 = HLEMemory_Read_U32(memory, address + 8);
|
||||
|
||||
// Length of JoyBoot program to upload
|
||||
const u32 length = HLEMemory_Read_U32(address + 12);
|
||||
const u32 length = HLEMemory_Read_U32(memory, address + 12);
|
||||
|
||||
// Address to return results to game
|
||||
const u32 dest_addr = HLEMemory_Read_U32(address + 16);
|
||||
const u32 dest_addr = HLEMemory_Read_U32(memory, address + 16);
|
||||
|
||||
// Unwrap key from challenge using 'sedo' magic number (to encrypt JoyBoot program)
|
||||
const u32 key = challenge ^ 0x6f646573;
|
||||
HLEMemory_Write_U32(dest_addr, key);
|
||||
HLEMemory_Write_U32(memory, dest_addr, key);
|
||||
|
||||
// Pack palette parameters
|
||||
u16 palette_speed_coded;
|
||||
@ -62,7 +62,7 @@ void ProcessGBACrypto(u32 address)
|
||||
|
||||
// Wrap with 'Kawa' or 'sedo' (Kawasedo is the author of the BIOS cipher)
|
||||
t3 ^= ((t3 & 0x200) != 0 ? 0x6f646573 : 0x6177614b);
|
||||
HLEMemory_Write_U32(dest_addr + 4, t3);
|
||||
HLEMemory_Write_U32(memory, dest_addr + 4, t3);
|
||||
|
||||
// Done!
|
||||
DEBUG_LOG_FMT(DSPHLE,
|
||||
@ -85,7 +85,7 @@ void GBAUCode::Update()
|
||||
// check if we have something to send
|
||||
if (m_mail_handler.HasPending())
|
||||
{
|
||||
Core::System::GetInstance().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
m_dsphle->GetSystem().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
}
|
||||
}
|
||||
|
||||
@ -119,7 +119,7 @@ void GBAUCode::HandleMail(u32 mail)
|
||||
{
|
||||
const u32 address = mail & 0x0fff'ffff;
|
||||
|
||||
ProcessGBACrypto(address);
|
||||
ProcessGBACrypto(m_dsphle->GetSystem().GetMemory(), address);
|
||||
|
||||
m_mail_handler.PushMail(DSP_DONE);
|
||||
m_mail_state = MailState::WaitingForNextTask;
|
||||
|
||||
@ -6,6 +6,11 @@
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Core/HW/DSPHLE/UCodes/UCodes.h"
|
||||
|
||||
namespace Memory
|
||||
{
|
||||
class MemoryManager;
|
||||
}
|
||||
|
||||
namespace DSP::HLE
|
||||
{
|
||||
class DSPHLE;
|
||||
@ -13,7 +18,7 @@ class DSPHLE;
|
||||
// Computes two 32 bit integers to be returned to the game, based on the
|
||||
// provided crypto parameters at the provided MRAM address. The integers are
|
||||
// written back to RAM at the dest address provided in the crypto parameters.
|
||||
void ProcessGBACrypto(u32 address);
|
||||
void ProcessGBACrypto(Memory::MemoryManager& memory, u32 address);
|
||||
|
||||
class GBAUCode final : public UCodeInterface
|
||||
{
|
||||
|
||||
@ -19,6 +19,7 @@
|
||||
#include "Core/HW/DSPHLE/DSPHLE.h"
|
||||
#include "Core/HW/DSPHLE/MailHandler.h"
|
||||
#include "Core/HW/DSPHLE/UCodes/UCodes.h"
|
||||
#include "Core/System.h"
|
||||
|
||||
namespace DSP::HLE
|
||||
{
|
||||
@ -94,13 +95,14 @@ void ROMUCode::HandleMail(u32 mail)
|
||||
|
||||
void ROMUCode::BootUCode()
|
||||
{
|
||||
const u32 ector_crc =
|
||||
Common::HashEctor(static_cast<u8*>(HLEMemory_Get_Pointer(m_current_ucode.m_ram_address)),
|
||||
m_current_ucode.m_length);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
const u32 ector_crc = Common::HashEctor(
|
||||
static_cast<u8*>(HLEMemory_Get_Pointer(memory, m_current_ucode.m_ram_address)),
|
||||
m_current_ucode.m_length);
|
||||
|
||||
if (Config::Get(Config::MAIN_DUMP_UCODE))
|
||||
{
|
||||
DSP::DumpDSPCode(static_cast<u8*>(HLEMemory_Get_Pointer(m_current_ucode.m_ram_address)),
|
||||
DSP::DumpDSPCode(static_cast<u8*>(HLEMemory_Get_Pointer(memory, m_current_ucode.m_ram_address)),
|
||||
m_current_ucode.m_length, ector_crc);
|
||||
}
|
||||
|
||||
|
||||
@ -39,33 +39,24 @@ constexpr bool ExramRead(u32 address)
|
||||
return (address & 0x10000000) != 0;
|
||||
}
|
||||
|
||||
u8 HLEMemory_Read_U8(u32 address)
|
||||
u8 HLEMemory_Read_U8(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (ExramRead(address))
|
||||
return memory.GetEXRAM()[address & memory.GetExRamMask()];
|
||||
|
||||
return memory.GetRAM()[address & memory.GetRamMask()];
|
||||
}
|
||||
|
||||
void HLEMemory_Write_U8(u32 address, u8 value)
|
||||
void HLEMemory_Write_U8(Memory::MemoryManager& memory, u32 address, u8 value)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (ExramRead(address))
|
||||
memory.GetEXRAM()[address & memory.GetExRamMask()] = value;
|
||||
else
|
||||
memory.GetRAM()[address & memory.GetRamMask()] = value;
|
||||
}
|
||||
|
||||
u16 HLEMemory_Read_U16LE(u32 address)
|
||||
u16 HLEMemory_Read_U16LE(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
u16 value;
|
||||
|
||||
if (ExramRead(address))
|
||||
@ -76,32 +67,26 @@ u16 HLEMemory_Read_U16LE(u32 address)
|
||||
return value;
|
||||
}
|
||||
|
||||
u16 HLEMemory_Read_U16(u32 address)
|
||||
u16 HLEMemory_Read_U16(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
return Common::swap16(HLEMemory_Read_U16LE(address));
|
||||
return Common::swap16(HLEMemory_Read_U16LE(memory, address));
|
||||
}
|
||||
|
||||
void HLEMemory_Write_U16LE(u32 address, u16 value)
|
||||
void HLEMemory_Write_U16LE(Memory::MemoryManager& memory, u32 address, u16 value)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (ExramRead(address))
|
||||
std::memcpy(&memory.GetEXRAM()[address & memory.GetExRamMask()], &value, sizeof(u16));
|
||||
else
|
||||
std::memcpy(&memory.GetRAM()[address & memory.GetRamMask()], &value, sizeof(u16));
|
||||
}
|
||||
|
||||
void HLEMemory_Write_U16(u32 address, u16 value)
|
||||
void HLEMemory_Write_U16(Memory::MemoryManager& memory, u32 address, u16 value)
|
||||
{
|
||||
HLEMemory_Write_U16LE(address, Common::swap16(value));
|
||||
HLEMemory_Write_U16LE(memory, address, Common::swap16(value));
|
||||
}
|
||||
|
||||
u32 HLEMemory_Read_U32LE(u32 address)
|
||||
u32 HLEMemory_Read_U32LE(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
u32 value;
|
||||
|
||||
if (ExramRead(address))
|
||||
@ -112,32 +97,26 @@ u32 HLEMemory_Read_U32LE(u32 address)
|
||||
return value;
|
||||
}
|
||||
|
||||
u32 HLEMemory_Read_U32(u32 address)
|
||||
u32 HLEMemory_Read_U32(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
return Common::swap32(HLEMemory_Read_U32LE(address));
|
||||
return Common::swap32(HLEMemory_Read_U32LE(memory, address));
|
||||
}
|
||||
|
||||
void HLEMemory_Write_U32LE(u32 address, u32 value)
|
||||
void HLEMemory_Write_U32LE(Memory::MemoryManager& memory, u32 address, u32 value)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (ExramRead(address))
|
||||
std::memcpy(&memory.GetEXRAM()[address & memory.GetExRamMask()], &value, sizeof(u32));
|
||||
else
|
||||
std::memcpy(&memory.GetRAM()[address & memory.GetRamMask()], &value, sizeof(u32));
|
||||
}
|
||||
|
||||
void HLEMemory_Write_U32(u32 address, u32 value)
|
||||
void HLEMemory_Write_U32(Memory::MemoryManager& memory, u32 address, u32 value)
|
||||
{
|
||||
HLEMemory_Write_U32LE(address, Common::swap32(value));
|
||||
HLEMemory_Write_U32LE(memory, address, Common::swap32(value));
|
||||
}
|
||||
|
||||
void* HLEMemory_Get_Pointer(u32 address)
|
||||
void* HLEMemory_Get_Pointer(Memory::MemoryManager& memory, u32 address)
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
|
||||
if (ExramRead(address))
|
||||
return &memory.GetEXRAM()[address & memory.GetExRamMask()];
|
||||
|
||||
@ -204,14 +183,13 @@ void UCodeInterface::PrepareBootUCode(u32 mail)
|
||||
m_needs_resume_mail = true;
|
||||
m_upload_setup_in_progress = false;
|
||||
|
||||
const u32 ector_crc =
|
||||
Common::HashEctor(static_cast<u8*>(HLEMemory_Get_Pointer(m_next_ucode.iram_mram_addr)),
|
||||
m_next_ucode.iram_size);
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
const u32 ector_crc = Common::HashEctor(
|
||||
static_cast<u8*>(HLEMemory_Get_Pointer(memory, m_next_ucode.iram_mram_addr)),
|
||||
m_next_ucode.iram_size);
|
||||
|
||||
if (Config::Get(Config::MAIN_DUMP_UCODE))
|
||||
{
|
||||
auto& system = Core::System::GetInstance();
|
||||
auto& memory = system.GetMemory();
|
||||
DSP::DumpDSPCode(memory.GetPointer(m_next_ucode.iram_mram_addr), m_next_ucode.iram_size,
|
||||
ector_crc);
|
||||
}
|
||||
|
||||
@ -8,6 +8,10 @@
|
||||
|
||||
#include "Common/CommonTypes.h"
|
||||
|
||||
namespace Memory
|
||||
{
|
||||
class MemoryManager;
|
||||
}
|
||||
class PointerWrap;
|
||||
|
||||
namespace DSP::HLE
|
||||
@ -19,22 +23,22 @@ class DSPHLE;
|
||||
#define UCODE_INIT_AUDIO_SYSTEM 0x00000001
|
||||
#define UCODE_NULL 0xFFFFFFFF
|
||||
|
||||
u8 HLEMemory_Read_U8(u32 address);
|
||||
void HLEMemory_Write_U8(u32 address, u8 value);
|
||||
u8 HLEMemory_Read_U8(Memory::MemoryManager& memory, u32 address);
|
||||
void HLEMemory_Write_U8(Memory::MemoryManager& memory, u32 address, u8 value);
|
||||
|
||||
u16 HLEMemory_Read_U16LE(u32 address);
|
||||
u16 HLEMemory_Read_U16(u32 address);
|
||||
u16 HLEMemory_Read_U16LE(Memory::MemoryManager& memory, u32 address);
|
||||
u16 HLEMemory_Read_U16(Memory::MemoryManager& memory, u32 address);
|
||||
|
||||
void HLEMemory_Write_U16LE(u32 address, u16 value);
|
||||
void HLEMemory_Write_U16(u32 address, u16 value);
|
||||
void HLEMemory_Write_U16LE(Memory::MemoryManager& memory, u32 address, u16 value);
|
||||
void HLEMemory_Write_U16(Memory::MemoryManager& memory, u32 address, u16 value);
|
||||
|
||||
u32 HLEMemory_Read_U32LE(u32 address);
|
||||
u32 HLEMemory_Read_U32(u32 address);
|
||||
u32 HLEMemory_Read_U32LE(Memory::MemoryManager& memory, u32 address);
|
||||
u32 HLEMemory_Read_U32(Memory::MemoryManager& memory, u32 address);
|
||||
|
||||
void HLEMemory_Write_U32LE(u32 address, u32 value);
|
||||
void HLEMemory_Write_U32(u32 address, u32 value);
|
||||
void HLEMemory_Write_U32LE(Memory::MemoryManager& memory, u32 address, u32 value);
|
||||
void HLEMemory_Write_U32(Memory::MemoryManager& memory, u32 address, u32 value);
|
||||
|
||||
void* HLEMemory_Get_Pointer(u32 address);
|
||||
void* HLEMemory_Get_Pointer(Memory::MemoryManager& memory, u32 address);
|
||||
|
||||
class UCodeInterface
|
||||
{
|
||||
|
||||
@ -118,7 +118,8 @@ static const std::map<u32, u32> UCODE_FLAGS = {
|
||||
// * The Legend of Zelda: Twilight Princess / Wii (type ????, CRC ????)
|
||||
};
|
||||
|
||||
ZeldaUCode::ZeldaUCode(DSPHLE* dsphle, u32 crc) : UCodeInterface(dsphle, crc)
|
||||
ZeldaUCode::ZeldaUCode(DSPHLE* dsphle, u32 crc)
|
||||
: UCodeInterface(dsphle, crc), m_renderer(dsphle->GetSystem())
|
||||
{
|
||||
auto it = UCODE_FLAGS.find(crc);
|
||||
if (it == UCODE_FLAGS.end())
|
||||
@ -369,7 +370,7 @@ void ZeldaUCode::HandleMailLight(u32 mail)
|
||||
m_sync_max_voice_id = 0xFFFFFFFF;
|
||||
m_sync_voice_skip_flags.fill(0xFFFF);
|
||||
RenderAudio();
|
||||
Core::System::GetInstance().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
m_dsphle->GetSystem().GetDSP().GenerateDSPInterruptFromDSPEmu(DSP::INT_DSP);
|
||||
break;
|
||||
|
||||
case MailState::HALTED:
|
||||
@ -470,7 +471,8 @@ void ZeldaUCode::RunPendingCommands()
|
||||
|
||||
m_renderer.SetVPBBaseAddress(Read32());
|
||||
|
||||
u16* data_ptr = (u16*)HLEMemory_Get_Pointer(Read32());
|
||||
auto& memory = m_dsphle->GetSystem().GetMemory();
|
||||
u16* data_ptr = (u16*)HLEMemory_Get_Pointer(memory, Read32());
|
||||
|
||||
std::array<s16, 0x100> resampling_coeffs;
|
||||
for (size_t i = 0; i < 0x100; ++i)
|
||||
@ -492,7 +494,7 @@ void ZeldaUCode::RunPendingCommands()
|
||||
m_renderer.SetSineTable(std::move(sine_table));
|
||||
}
|
||||
|
||||
u16* afc_coeffs_ptr = (u16*)HLEMemory_Get_Pointer(Read32());
|
||||
u16* afc_coeffs_ptr = (u16*)HLEMemory_Get_Pointer(memory, Read32());
|
||||
std::array<s16, 0x20> afc_coeffs;
|
||||
for (size_t i = 0; i < 0x20; ++i)
|
||||
afc_coeffs[i] = Common::swap16(afc_coeffs_ptr[i]);
|
||||
@ -542,7 +544,7 @@ void ZeldaUCode::RunPendingCommands()
|
||||
case 0x0C:
|
||||
if (m_flags & SUPPORTS_GBA_CRYPTO)
|
||||
{
|
||||
ProcessGBACrypto(Read32());
|
||||
ProcessGBACrypto(m_dsphle->GetSystem().GetMemory(), Read32());
|
||||
}
|
||||
else if (m_flags & WEIRD_CMD_0C)
|
||||
{
|
||||
@ -965,6 +967,12 @@ struct ReverbPB
|
||||
};
|
||||
#pragma pack(pop)
|
||||
|
||||
ZeldaAudioRenderer::ZeldaAudioRenderer(Core::System& system) : m_system(system)
|
||||
{
|
||||
}
|
||||
|
||||
ZeldaAudioRenderer::~ZeldaAudioRenderer() = default;
|
||||
|
||||
void ZeldaAudioRenderer::PrepareFrame()
|
||||
{
|
||||
if (m_prepared)
|
||||
@ -1047,7 +1055,8 @@ void ZeldaAudioRenderer::ApplyReverb(bool post_rendering)
|
||||
&m_buf_front_right_reverb_last8,
|
||||
};
|
||||
|
||||
u16* rpb_base_ptr = (u16*)HLEMemory_Get_Pointer(m_reverb_pb_base_addr);
|
||||
auto& memory = m_system.GetMemory();
|
||||
u16* rpb_base_ptr = (u16*)HLEMemory_Get_Pointer(memory, m_reverb_pb_base_addr);
|
||||
for (u16 rpb_idx = 0; rpb_idx < 4; ++rpb_idx)
|
||||
{
|
||||
ReverbPB rpb;
|
||||
@ -1061,7 +1070,7 @@ void ZeldaAudioRenderer::ApplyReverb(bool post_rendering)
|
||||
u16 mram_buffer_idx = m_reverb_pb_frames_count[rpb_idx];
|
||||
|
||||
u32 mram_addr = rpb.GetCircularBufferBase() + mram_buffer_idx * 0x50 * sizeof(s16);
|
||||
s16* mram_ptr = (s16*)HLEMemory_Get_Pointer(mram_addr);
|
||||
s16* mram_ptr = (s16*)HLEMemory_Get_Pointer(memory, mram_addr);
|
||||
|
||||
if (!post_rendering)
|
||||
{
|
||||
@ -1316,8 +1325,9 @@ void ZeldaAudioRenderer::FinalizeFrame()
|
||||
ApplyVolumeInPlace_4_12(&m_buf_front_left, m_output_volume);
|
||||
ApplyVolumeInPlace_4_12(&m_buf_front_right, m_output_volume);
|
||||
|
||||
u16* ram_left_buffer = (u16*)HLEMemory_Get_Pointer(m_output_lbuf_addr);
|
||||
u16* ram_right_buffer = (u16*)HLEMemory_Get_Pointer(m_output_rbuf_addr);
|
||||
auto& memory = m_system.GetMemory();
|
||||
u16* ram_left_buffer = (u16*)HLEMemory_Get_Pointer(memory, m_output_lbuf_addr);
|
||||
u16* ram_right_buffer = (u16*)HLEMemory_Get_Pointer(memory, m_output_rbuf_addr);
|
||||
for (size_t i = 0; i < m_buf_front_left.size(); ++i)
|
||||
{
|
||||
ram_left_buffer[i] = Common::swap16(m_buf_front_left[i]);
|
||||
@ -1335,8 +1345,9 @@ void ZeldaAudioRenderer::FinalizeFrame()
|
||||
|
||||
void ZeldaAudioRenderer::FetchVPB(u16 voice_id, VPB* vpb)
|
||||
{
|
||||
auto& memory = m_system.GetMemory();
|
||||
u16* vpb_words = (u16*)vpb;
|
||||
u16* ram_vpbs = (u16*)HLEMemory_Get_Pointer(m_vpb_base_addr);
|
||||
u16* ram_vpbs = (u16*)HLEMemory_Get_Pointer(memory, m_vpb_base_addr);
|
||||
|
||||
// A few versions of the UCode have VPB of size 0x80 (vs. the standard
|
||||
// 0xC0). The whole 0x40-0x80 part is gone. Handle that by moving things
|
||||
@ -1353,8 +1364,9 @@ void ZeldaAudioRenderer::FetchVPB(u16 voice_id, VPB* vpb)
|
||||
|
||||
void ZeldaAudioRenderer::StoreVPB(u16 voice_id, VPB* vpb)
|
||||
{
|
||||
auto& memory = m_system.GetMemory();
|
||||
u16* vpb_words = (u16*)vpb;
|
||||
u16* ram_vpbs = (u16*)HLEMemory_Get_Pointer(m_vpb_base_addr);
|
||||
u16* ram_vpbs = (u16*)HLEMemory_Get_Pointer(memory, m_vpb_base_addr);
|
||||
|
||||
size_t vpb_size = (m_flags & TINY_VPB) ? 0x80 : 0xC0;
|
||||
size_t base_idx = voice_id * vpb_size;
|
||||
@ -1538,9 +1550,9 @@ void ZeldaAudioRenderer::Resample(VPB* vpb, const s16* src, MixingBuffer* dst)
|
||||
void* ZeldaAudioRenderer::GetARAMPtr(u32 offset) const
|
||||
{
|
||||
if (SConfig::GetInstance().bWii)
|
||||
return HLEMemory_Get_Pointer(m_aram_base_addr + offset);
|
||||
return HLEMemory_Get_Pointer(m_system.GetMemory(), m_aram_base_addr + offset);
|
||||
else
|
||||
return reinterpret_cast<u8*>(Core::System::GetInstance().GetDSP().GetARAMPtr()) + offset;
|
||||
return reinterpret_cast<u8*>(m_system.GetDSP().GetARAMPtr()) + offset;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
@ -1773,8 +1785,9 @@ void ZeldaAudioRenderer::DecodeAFC(VPB* vpb, s16* dst, size_t block_count)
|
||||
|
||||
void ZeldaAudioRenderer::DownloadRawSamplesFromMRAM(s16* dst, VPB* vpb, u16 requested_samples_count)
|
||||
{
|
||||
auto& memory = m_system.GetMemory();
|
||||
u32 addr = vpb->GetBaseAddress() + vpb->current_position_h * sizeof(u16);
|
||||
s16* src_ptr = (s16*)HLEMemory_Get_Pointer(addr);
|
||||
s16* src_ptr = (s16*)HLEMemory_Get_Pointer(memory, addr);
|
||||
|
||||
if (requested_samples_count > vpb->GetRemainingLength())
|
||||
{
|
||||
@ -1803,7 +1816,7 @@ void ZeldaAudioRenderer::DownloadRawSamplesFromMRAM(s16* dst, VPB* vpb, u16 requ
|
||||
for (u16 i = 0; i < vpb->samples_before_loop; ++i)
|
||||
*dst++ = Common::swap16(*src_ptr++);
|
||||
vpb->SetBaseAddress(vpb->GetLoopAddress());
|
||||
src_ptr = (s16*)HLEMemory_Get_Pointer(vpb->GetLoopAddress());
|
||||
src_ptr = (s16*)HLEMemory_Get_Pointer(memory, vpb->GetLoopAddress());
|
||||
for (u16 i = vpb->samples_before_loop; i < requested_samples_count; ++i)
|
||||
*dst++ = Common::swap16(*src_ptr++);
|
||||
vpb->current_position_h = requested_samples_count - vpb->samples_before_loop;
|
||||
|
||||
@ -9,6 +9,11 @@
|
||||
#include "Common/CommonTypes.h"
|
||||
#include "Core/HW/DSPHLE/UCodes/UCodes.h"
|
||||
|
||||
namespace Core
|
||||
{
|
||||
class System;
|
||||
}
|
||||
|
||||
namespace DSP::HLE
|
||||
{
|
||||
class DSPHLE;
|
||||
@ -16,6 +21,13 @@ class DSPHLE;
|
||||
class ZeldaAudioRenderer
|
||||
{
|
||||
public:
|
||||
explicit ZeldaAudioRenderer(Core::System& system);
|
||||
ZeldaAudioRenderer(const ZeldaAudioRenderer&) = delete;
|
||||
ZeldaAudioRenderer(ZeldaAudioRenderer&&) = delete;
|
||||
ZeldaAudioRenderer& operator=(const ZeldaAudioRenderer&) = delete;
|
||||
ZeldaAudioRenderer& operator=(ZeldaAudioRenderer&&) = delete;
|
||||
~ZeldaAudioRenderer();
|
||||
|
||||
void PrepareFrame();
|
||||
void AddVoice(u16 voice_id);
|
||||
void FinalizeFrame();
|
||||
@ -183,6 +195,8 @@ private:
|
||||
std::array<s16, 8> m_buf_front_left_reverb_last8{};
|
||||
std::array<s16, 8> m_buf_front_right_reverb_last8{};
|
||||
u32 m_reverb_pb_base_addr = 0;
|
||||
|
||||
Core::System& m_system;
|
||||
};
|
||||
|
||||
class ZeldaUCode final : public UCodeInterface
|
||||
|
||||
Loading…
Reference in New Issue
Block a user