484 lines
12 KiB
C++
484 lines
12 KiB
C++
// Copyright (C) 2003-2008 Dolphin Project.
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, version 2.0.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
// Games that uses this UCode:
|
|
// Zelda: The Windwaker, Mario Sunshine, Mario Kart, Twilight Princess
|
|
|
|
#include "../Globals.h"
|
|
#include "FileUtil.h"
|
|
#include "UCodes.h"
|
|
#include "UCode_Zelda.h"
|
|
#include "../MailHandler.h"
|
|
|
|
#include "../main.h"
|
|
#include "Mixer.h"
|
|
|
|
|
|
namespace {
|
|
CompileTimeAssert<sizeof(ZPB) == 0x180> dummy_name;
|
|
}
|
|
|
|
// TODO: replace with table from RAM.
|
|
unsigned short afccoef[16][2] =
|
|
{{0,0},
|
|
{0x0800,0},
|
|
{0,0x0800},
|
|
{0x0400,0x0400},
|
|
{0x1000,0xf800},
|
|
{0x0e00,0xfa00},
|
|
{0x0c00,0xfc00},
|
|
{0x1200,0xf600},
|
|
{0x1068,0xf738},
|
|
{0x12c0,0xf704},
|
|
{0x1400,0xf400},
|
|
{0x0800,0xf800},
|
|
{0x0400,0xfc00},
|
|
{0xfc00,0x0400},
|
|
{0xfc00,0},
|
|
{0xf800,0}};
|
|
|
|
|
|
// Decoder from in_cube by hcs/destop/etc. Haven't yet found a valid use for it.
|
|
|
|
// Looking at in_cube, it seems to be 9 bytes of input = 16 samples of output.
|
|
// Different from AX ADPCM which is 8 bytes of input = 14 samples of output.
|
|
void AFCdecodebuffer
|
|
(
|
|
u8 *input, // location of encoded source samples
|
|
s16 *out, // location of destination buffer (16 bits / sample)
|
|
short *histp,
|
|
short *hist2p
|
|
)
|
|
{
|
|
int sample;
|
|
short nibbles[16];
|
|
u8 *src, *dst;
|
|
short idx;
|
|
short delta;
|
|
short hist=*histp;
|
|
short hist2=*hist2p;
|
|
|
|
dst = (u8 *)out;
|
|
|
|
src = input;
|
|
delta = 1 << (((*src) >> 4)&0xf);
|
|
idx = (*src) & 0xf;
|
|
|
|
src++;
|
|
|
|
for (int i = 0; i < 16; i = i + 2)
|
|
{
|
|
int j = ( *src & 255) >> 4;
|
|
nibbles[i] = j;
|
|
j = *src & 255 & 15;
|
|
nibbles[i + 1] = j;
|
|
src++;
|
|
}
|
|
|
|
for (int i = 0; i < 16; i = i + 1)
|
|
{
|
|
if (nibbles[i] >= 8)
|
|
nibbles[i] = nibbles[i] - 16;
|
|
}
|
|
|
|
for (int i = 0; i < 16; i = i + 1)
|
|
{
|
|
sample = (delta * nibbles[i]) << 11;
|
|
sample += ((long)hist * afccoef[idx][0]) + ((long)hist2 * afccoef[idx][1]);
|
|
sample = sample >> 11;
|
|
|
|
if(sample > 32767) {
|
|
sample = 32767;
|
|
}
|
|
if(sample < -32768) {
|
|
sample = -32768;
|
|
}
|
|
|
|
*(short*)dst = (short)sample;
|
|
dst = dst + 2;
|
|
|
|
hist2 = hist;
|
|
hist = (short)sample;
|
|
}
|
|
|
|
*histp=hist;
|
|
*hist2p=hist2;
|
|
}
|
|
|
|
|
|
|
|
CUCode_Zelda::CUCode_Zelda(CMailHandler& _rMailHandler)
|
|
: IUCode(_rMailHandler)
|
|
, m_bSyncInProgress(false)
|
|
, m_SyncIndex(0)
|
|
, m_SyncStep(0)
|
|
, m_SyncMaxStep(0)
|
|
, m_bSyncCmdPending(false)
|
|
, m_SyncEndSync(0)
|
|
, m_SyncCurStep(0)
|
|
, m_SyncCount(0)
|
|
, m_SyncMax(0)
|
|
, m_numSteps(0)
|
|
, m_bListInProgress(false)
|
|
, m_step(0)
|
|
, m_readOffset(0)
|
|
{
|
|
DEBUG_LOG(DSPHLE, "UCode_Zelda - add boot mails for handshake");
|
|
|
|
m_rMailHandler.PushMail(DSP_INIT);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
m_rMailHandler.PushMail(0xF3551111); // handshake
|
|
memset(m_Buffer, 0, sizeof(m_Buffer));
|
|
memset(m_SyncValues, 0, sizeof(m_SyncValues));
|
|
}
|
|
|
|
|
|
CUCode_Zelda::~CUCode_Zelda()
|
|
{
|
|
m_rMailHandler.Clear();
|
|
}
|
|
|
|
|
|
void CUCode_Zelda::Update(int cycles)
|
|
{
|
|
// check if we have to sent something
|
|
//if (!m_rMailHandler.IsEmpty())
|
|
// g_dspInitialize.pGenerateDSPInterrupt();
|
|
}
|
|
|
|
|
|
void CUCode_Zelda::HandleMail(u32 _uMail)
|
|
{
|
|
// XK: Sync mails spam the logs
|
|
/*
|
|
DEBUG_LOG(DSPHLE, "Zelda mail 0x%08X, list in progress? %s, sync in progress? %s", _uMail,
|
|
m_bListInProgress ? "Yes" : "No", m_bSyncInProgress ? "Yes" : "No");
|
|
*/
|
|
// SetupTable
|
|
// in WW we get SetDolbyDelay
|
|
// SyncFrame
|
|
// The last mails we get before the audio goes bye-bye
|
|
// 0
|
|
// 0x00000
|
|
// 0
|
|
// 0x10000
|
|
// 0
|
|
// 0x20000
|
|
// 0
|
|
// 0x30000
|
|
// And then silence...
|
|
|
|
if (m_bSyncInProgress)
|
|
{
|
|
if (m_bSyncCmdPending)
|
|
{
|
|
u32 n = (_uMail >> 16) & 0xF;
|
|
m_SyncStep = (n + 1) << 4;
|
|
m_SyncValues[n] = _uMail & 0xFFFF;
|
|
m_bSyncInProgress = false;
|
|
|
|
m_SyncCurStep = m_SyncStep;
|
|
if (m_SyncCurStep == m_SyncMaxStep)
|
|
{
|
|
m_SyncCount++;
|
|
|
|
m_rMailHandler.PushMail(DSP_SYNC);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
m_rMailHandler.PushMail(0xF355FF00 | m_SyncCount);
|
|
|
|
m_SyncCurStep = 0;
|
|
|
|
if (m_SyncCount == (m_SyncMax + 1))
|
|
{
|
|
m_rMailHandler.PushMail(DSP_UNKN);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
|
|
soundStream->GetMixer()->SetHLEReady(true);
|
|
DEBUG_LOG(DSPHLE, "Update the SoundThread to be in sync");
|
|
soundStream->Update(); //do it in this thread to avoid sync problems
|
|
|
|
m_bSyncCmdPending = false;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_bSyncInProgress = false;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if(_uMail != 0) {
|
|
DEBUG_LOG(DSPHLE, "Zelda mail 0x%08X, list in progress? %s", _uMail,
|
|
m_bListInProgress ? "Yes" : "No");
|
|
}
|
|
|
|
if (m_bListInProgress)
|
|
{
|
|
if (m_step < 0 || m_step >= sizeof(m_Buffer)/4)
|
|
PanicAlert("m_step out of range");
|
|
|
|
((u32*)m_Buffer)[m_step] = _uMail;
|
|
m_step++;
|
|
|
|
if (m_step >= m_numSteps)
|
|
{
|
|
DEBUG_LOG(DSPHLE, "Executing %i-step list.", m_numSteps);
|
|
ExecuteList();
|
|
m_bListInProgress = false;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (_uMail == 0)
|
|
{
|
|
m_bSyncInProgress = true;
|
|
}
|
|
else if ((_uMail >> 16) == 0)
|
|
{
|
|
m_bListInProgress = true;
|
|
m_numSteps = _uMail;
|
|
m_step = 0;
|
|
|
|
// make sure we never read outside the buffer by mistake.
|
|
// Before deleting extra reads in ExecuteList, we were getting these
|
|
// values.
|
|
memset(m_Buffer, 0xcc, sizeof(m_Buffer));
|
|
}
|
|
else
|
|
{
|
|
WARN_LOG(DSPHLE, "Zelda uCode: unknown mail %08X", _uMail);
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::ExecuteList()
|
|
{
|
|
// begin with the list
|
|
m_readOffset = 0;
|
|
|
|
// First figure out what command we're dealing with.
|
|
u32 CmdMail = Read32();
|
|
u32 Command = (CmdMail >> 24) & 0x7f;
|
|
u32 Sync = CmdMail >> 16;
|
|
u16 ExtraData = CmdMail & 0xFFFF; // not yet used
|
|
|
|
DEBUG_LOG(DSPHLE, "==============================================================================");
|
|
DEBUG_LOG(DSPHLE, "Zelda UCode - execute dlist (cmd: 0x%04x : sync: 0x%04x)", Command, Sync);
|
|
|
|
switch (Command)
|
|
{
|
|
// DsetupTable ... zelda ww jumps to 0x0095
|
|
case 0x01:
|
|
{
|
|
num_param_blocks = ExtraData;
|
|
u32 tmp[4];
|
|
param_blocks_ptr = tmp[0] = Read32();
|
|
tmp[1] = Read32();
|
|
tmp[2] = Read32();
|
|
param_blocks2_ptr = tmp[3] = Read32();
|
|
|
|
m_SyncMaxStep = CmdMail & 0xFFFF;
|
|
|
|
DEBUG_LOG(DSPHLE, "DsetupTable");
|
|
DEBUG_LOG(DSPHLE, "Num param blocks: %i", num_param_blocks);
|
|
DEBUG_LOG(DSPHLE, "Param blocks 1: 0x%08x", tmp[0]);
|
|
|
|
// This points to some strange data table.
|
|
DEBUG_LOG(DSPHLE, "DSPRES_FILTER (size: 0x40): 0x%08x", tmp[1]);
|
|
|
|
// Zelda WW: This points to a 64-byte array of coefficients, which are EXACTLY the same
|
|
// as the AFC ADPCM coef array in decode.c of the in_cube winamp plugin,
|
|
// which can play Zelda audio.
|
|
// There's also a lot more table-looking data immediately after - maybe alternative
|
|
// tables? I wonder where the parameter blocks are?
|
|
DEBUG_LOG(DSPHLE, "DSPADPCM_FILTER (size: 0x500): 0x%08x", tmp[2]);
|
|
DEBUG_LOG(DSPHLE, "Param blocks 2: 0x%08x", tmp[3]);
|
|
}
|
|
break;
|
|
|
|
// SyncFrame ... zelda ww jumps to 0x0243
|
|
case 0x02:
|
|
{
|
|
u32 tmp[3];
|
|
tmp[0] = Read32();
|
|
tmp[1] = Read32();
|
|
|
|
// We're ready to mix
|
|
// soundStream->GetMixer()->SetHLEReady(true);
|
|
// DEBUG_LOG(DSPHLE, "Update the SoundThread to be in sync");
|
|
soundStream->Update(); //do it in this thread to avoid sync problems
|
|
|
|
m_bSyncCmdPending = true;
|
|
m_SyncEndSync = Sync;
|
|
m_SyncCount = 0;
|
|
m_SyncMax = (CmdMail >> 16) & 0xFF;
|
|
|
|
DEBUG_LOG(DSPHLE, "DsyncFrame");
|
|
|
|
// These alternate between three sets of mixing buffers. They are all three fairly near,
|
|
// but not at, the ADMA read addresses.
|
|
DEBUG_LOG(DSPHLE, "Left mixing buffer? 0x%08x", tmp[0]);
|
|
DEBUG_LOG(DSPHLE, "Right mixing buffer? 0x%08x", tmp[1]);
|
|
|
|
// Let's log the parameter blocks.
|
|
// Copy and byteswap the parameter blocks.
|
|
|
|
// For some reason, in Z:WW we get no param blocks until in-game,
|
|
// while Zelda Four Swords happily sets param blocks as soon as the title screen comes up.
|
|
// Looks like it's playing midi music.
|
|
DEBUG_LOG(DSPHLE, "Param block at %08x:", param_blocks_ptr);
|
|
CopyPBsFromRAM();
|
|
for (int i = 0; i < num_param_blocks; i++)
|
|
{
|
|
// The only thing that consistently looks like a pointer in the param blocks.
|
|
u32 addr = (zpbs[i].addr_high << 16) | zpbs[i].addr_low;
|
|
if (addr)
|
|
{
|
|
DEBUG_LOG(DSPHLE, "Param block: ==== %i ( %08x ) ====", i, GetParamBlockAddr(i));
|
|
DEBUG_LOG(DSPHLE, "Addr: %08x", addr);
|
|
|
|
// Got one! Read from ARAM, dump to file.
|
|
// I can't get the below to produce anything resembling sane audio :(
|
|
//addr *= 2;
|
|
/*
|
|
int size = 0x10000;
|
|
u8 *temp = new u8[size];
|
|
for (int i = 0; i < size; i++) {
|
|
temp[i] = g_dspInitialize.pARAM_Read_U8(addr + i);
|
|
}
|
|
s16 *audio = new s16[size * 4];
|
|
int aoff = 0;
|
|
short hist1 = 0, hist2 = 0;
|
|
for (int i = 0; i < size; i+=9)
|
|
{
|
|
AFCdecodebuffer(temp + i, audio + aoff, &hist1, &hist2);
|
|
aoff += 16;
|
|
}
|
|
char fname[256];
|
|
sprintf(fname, "%08x.bin", addr);
|
|
if (File::Exists(fname))
|
|
continue;
|
|
|
|
FILE *f = fopen(fname, "wb");
|
|
fwrite(audio, 1, size*4, f);
|
|
fclose(f);
|
|
|
|
sprintf(fname, "%08x_raw.bin", addr);
|
|
|
|
f = fopen(fname, "wb");
|
|
fwrite(temp, 1, size, f);
|
|
fclose(f);
|
|
*/
|
|
}
|
|
}
|
|
CopyPBsToRAM();
|
|
}
|
|
return;
|
|
break;
|
|
|
|
/*
|
|
case 0x03: break; // dunno ... zelda ww jmps to 0x0073
|
|
case 0x04: break; // dunno ... zelda ww jmps to 0x0580
|
|
case 0x05: break; // dunno ... zelda ww jmps to 0x0592
|
|
case 0x06: break; // dunno ... zelda ww jmps to 0x0469
|
|
|
|
case 0x07: break; // dunno ... zelda ww jmps to 0x044d
|
|
case 0x08: break; // Mixer ... zelda ww jmps to 0x0485
|
|
case 0x09: break; // dunno ... zelda ww jmps to 0x044d
|
|
*/
|
|
|
|
// DsetDolbyDelay ... zelda ww jumps to 0x00b2
|
|
case 0x0d:
|
|
{
|
|
u32 tmp[2];
|
|
tmp[0] = Read32();
|
|
|
|
DEBUG_LOG(DSPHLE, "DSetDolbyDelay");
|
|
DEBUG_LOG(DSPHLE, "DOLBY2_DELAY_BUF (size 0x960): 0x%08x", tmp[0]);
|
|
}
|
|
break;
|
|
|
|
// Set VARAM
|
|
// Luigi__: in the real Zelda ucode, this opcode is dummy
|
|
// however, in the ucode used by SMG it isn't
|
|
case 0x0e:
|
|
{
|
|
/*
|
|
00b0 0080 037d lri $AR0, #0x037d
|
|
00b2 0e01 lris $AC0.M, #0x01
|
|
00b3 02bf 0065 call 0x0065
|
|
00b5 00de 037d lr $AC0.M, @0x037d
|
|
00b7 0240 7fff andi $AC0.M, #0x7fff
|
|
00b9 00fe 037d sr @0x037d, $AC0.M
|
|
00bb 029f 0041 jmp 0x0041
|
|
*/
|
|
//
|
|
}
|
|
break;
|
|
|
|
// default ... zelda ww jumps to 0x0043
|
|
default:
|
|
PanicAlert("Zelda UCode - unknown cmd: %x (size %i)", Command, m_numSteps);
|
|
break;
|
|
}
|
|
|
|
// sync, we are ready
|
|
m_rMailHandler.PushMail(DSP_SYNC);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
m_rMailHandler.PushMail(0xF3550000 | Sync);
|
|
}
|
|
|
|
|
|
void CUCode_Zelda::CopyPBsFromRAM()
|
|
{
|
|
for (int i = 0; i < num_param_blocks; i++)
|
|
{
|
|
u32 addr = param_blocks_ptr + i * sizeof(ZPB);
|
|
const u16 *src_ptr = (u16 *)g_dspInitialize.pGetMemoryPointer(addr);
|
|
u16 *dst_ptr = (u16 *)&zpbs[i];
|
|
for (size_t p = 0; p < sizeof(ZPB) / 2; p++)
|
|
{
|
|
dst_ptr[p] = Common::swap16(src_ptr[p]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::CopyPBsToRAM()
|
|
{
|
|
for (int i = 0; i < num_param_blocks; i++)
|
|
{
|
|
u32 addr = param_blocks_ptr + i * sizeof(ZPB);
|
|
const u16 *src_ptr = (u16 *)&zpbs[i];
|
|
u16 *dst_ptr = (u16 *)g_dspInitialize.pGetMemoryPointer(addr);
|
|
for (size_t p = 0; p < sizeof(ZPB) / 2; p++)
|
|
{
|
|
dst_ptr[p] = Common::swap16(src_ptr[p]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::MixAdd(short* buffer, int size)
|
|
{
|
|
//TODO(XK): Zelda UCode MixAdd?
|
|
// for (int i = 0; i < size; i++) {
|
|
// buffer[i] = rand();
|
|
// }
|
|
}
|
|
|