667 lines
20 KiB
C++
667 lines
20 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 "UCodes.h"
|
|
#include "UCode_Zelda.h"
|
|
#include "UCode_Zelda_ADPCM.h"
|
|
#include "../MailHandler.h"
|
|
|
|
#include "../main.h"
|
|
#include "Mixer.h"
|
|
|
|
#include "WaveFile.h"
|
|
|
|
class CResampler
|
|
{
|
|
public:
|
|
CResampler(short* samples, int num_stereo_samples, int core_sample_rate)
|
|
: m_mode(1)
|
|
, m_queueSize(0)
|
|
{
|
|
int PV1l=0,PV2l=0,PV3l=0,PV4l=0;
|
|
int acc=0;
|
|
|
|
while (num_stereo_samples)
|
|
{
|
|
acc += core_sample_rate;
|
|
while (num_stereo_samples && (acc >= 48000))
|
|
{
|
|
PV4l=PV3l;
|
|
PV3l=PV2l;
|
|
PV2l=PV1l;
|
|
PV1l=*(samples++); //32bit processing
|
|
num_stereo_samples--;
|
|
acc-=48000;
|
|
}
|
|
|
|
// defaults to nearest
|
|
s32 DataL = PV1l;
|
|
|
|
if (m_mode == 1) { //linear
|
|
DataL = PV1l + ((PV2l - PV1l)*acc)/48000;
|
|
}
|
|
else if (m_mode == 2) {//cubic
|
|
s32 a0l = PV1l - PV2l - PV4l + PV3l;
|
|
s32 a1l = PV4l - PV3l - a0l;
|
|
s32 a2l = PV1l - PV4l;
|
|
s32 a3l = PV2l;
|
|
|
|
s32 t0l = ((a0l )*acc)/48000;
|
|
s32 t1l = ((t0l+a1l)*acc)/48000;
|
|
s32 t2l = ((t1l+a2l)*acc)/48000;
|
|
s32 t3l = ((t2l+a3l));
|
|
|
|
DataL = t3l;
|
|
}
|
|
|
|
int l = DataL;
|
|
if (l < -32767) l = -32767;
|
|
if (l > 32767) l = 32767;
|
|
sample_queue.push(l);
|
|
m_queueSize += 1;
|
|
}
|
|
}
|
|
|
|
FixedSizeQueue<s16, queue_maxlength> sample_queue;
|
|
int m_queueSize;
|
|
int m_mode;
|
|
};
|
|
|
|
CUCode_Zelda::CUCode_Zelda(CMailHandler& _rMailHandler)
|
|
: IUCode(_rMailHandler)
|
|
, m_numSteps(0)
|
|
, m_step(0)
|
|
, m_readOffset(0)
|
|
, m_NumberOfFramesToRender(0)
|
|
, m_CurrentFrameToRender(0)
|
|
, m_MaxSyncedPB(0)
|
|
, m_MailState(WaitForMail)
|
|
{
|
|
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));
|
|
|
|
for (int i = 0; i < 0x10; i++)
|
|
m_PBMask[i] = false;
|
|
|
|
templbuffer = new int[1024 * 1024];
|
|
temprbuffer = new int[1024 * 1024];
|
|
}
|
|
|
|
CUCode_Zelda::~CUCode_Zelda()
|
|
{
|
|
m_rMailHandler.Clear();
|
|
|
|
delete [] templbuffer;
|
|
delete [] temprbuffer;
|
|
}
|
|
|
|
void CUCode_Zelda::UpdatePB(ZPB& _rPB, int *templbuffer, int *temprbuffer, u32 _Size)
|
|
{
|
|
u16* pTest = (u16*)&_rPB;
|
|
|
|
if (pTest[0x00] == 0)
|
|
return;
|
|
|
|
if (pTest[0x01] != 0)
|
|
return;
|
|
|
|
if (pTest[0x06] != 0x00)
|
|
{
|
|
// probably pTest[0x06] == 0 -> AFC (and variants)
|
|
}
|
|
else
|
|
{
|
|
switch(_rPB.type) // or Bytes per Sample
|
|
{
|
|
case 0x05:
|
|
case 0x09:
|
|
{
|
|
// initialize "decoder" if the sample is played the first time
|
|
if (pTest[0x04] != 0)
|
|
{
|
|
// zelda:
|
|
// perhaps init or "has played before"
|
|
pTest[0x32] = 0x00;
|
|
pTest[0x66] = 0x00; // history1
|
|
pTest[0x67] = 0x00; // history2
|
|
|
|
// samplerate? length? num of samples? i dunno...
|
|
// Likely length...
|
|
pTest[0x3a] = pTest[0x8a];
|
|
pTest[0x3b] = pTest[0x8b];
|
|
|
|
// copy ARAM addr from r to rw area
|
|
pTest[0x38] = pTest[0x8c];
|
|
pTest[0x39] = pTest[0x8d];
|
|
}
|
|
|
|
if (pTest[0x01] != 0) // 0747 early out... i dunno if this can happen because we filter it above
|
|
return;
|
|
|
|
u32 ARAMAddr = (pTest[0x38] << 16) | pTest[0x39];
|
|
u32 NumberOfSamples = (pTest[0x3a] << 16) | pTest[0x3b];
|
|
|
|
// round upwards how many samples we need to copy, 0759
|
|
NumberOfSamples = (NumberOfSamples + 0xf) >> 4; // i think the lower 4 are the fraction
|
|
u32 frac = NumberOfSamples & 0xF;
|
|
|
|
u8 inBuffer[9];
|
|
short outbuf[16];
|
|
u32 sampleCount = 0;
|
|
|
|
// It must be something like this:
|
|
|
|
// The PB contains a small sample buffer of 0x4D decoded samples.
|
|
// If it's empty or "used", decode to it.
|
|
// Then, resample from this buffer to the output as you go. When it needs
|
|
// wrapping, decode more.
|
|
|
|
#define USE_RESAMPLE 1
|
|
#if USE_RESAMPLE != 1
|
|
for (int s=0; s<(_Size/16);s++)
|
|
{
|
|
for (int i=0; i<9; i++)
|
|
{
|
|
inBuffer[i] = g_dspInitialize.pARAM_Read_U8(ARAMAddr);
|
|
ARAMAddr++;
|
|
}
|
|
|
|
|
|
AFCdecodebuffer((char*)inBuffer, outbuf, (short*)&pTest[0x66], (short*)&pTest[0x67]);
|
|
|
|
for (int i=0; i<16; i++)
|
|
{
|
|
templbuffer[sampleCount] += outbuf[i];
|
|
temprbuffer[sampleCount] += outbuf[i];
|
|
sampleCount++;
|
|
}
|
|
|
|
NumberOfSamples--;
|
|
|
|
if (NumberOfSamples<=0)
|
|
break;
|
|
}
|
|
#else
|
|
while (NumberOfSamples > 0)
|
|
{
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
inBuffer[i] = g_dspInitialize.pARAM_Read_U8(ARAMAddr);
|
|
ARAMAddr++;
|
|
}
|
|
|
|
AFCdecodebuffer(m_AFCCoefTable, (char*)inBuffer, outbuf, (short*)&pTest[0x66], (short*)&pTest[0x67], 9);
|
|
CResampler Sampler(outbuf, 16, 48000);
|
|
|
|
while (Sampler.m_queueSize > 0)
|
|
{
|
|
int sample = Sampler.sample_queue.front();
|
|
Sampler.sample_queue.pop();
|
|
Sampler.m_queueSize-=1;
|
|
|
|
templbuffer[sampleCount] += sample;
|
|
temprbuffer[sampleCount] += sample;
|
|
sampleCount++;
|
|
|
|
if (sampleCount > _Size)
|
|
break;
|
|
}
|
|
|
|
if (sampleCount > _Size)
|
|
break;
|
|
|
|
NumberOfSamples--;
|
|
}
|
|
#endif
|
|
if (NumberOfSamples == 0)
|
|
{
|
|
pTest[0x01] = 1; // we are done ??
|
|
}
|
|
|
|
// write back
|
|
NumberOfSamples = (NumberOfSamples << 4); // missing fraction
|
|
|
|
pTest[0x38] = ARAMAddr >> 16;
|
|
pTest[0x39] = ARAMAddr & 0xFFFF;
|
|
pTest[0x3a] = NumberOfSamples >> 16;
|
|
pTest[0x3b] = NumberOfSamples & 0xFFFF;
|
|
|
|
|
|
#if 0
|
|
NumberOfSamples = (NumberOfSamples + 0xf) >> 4;
|
|
|
|
static u8 Buffer[500000];
|
|
for (int i =0; i<NumberOfSamples*9; i++)
|
|
{
|
|
Buffer[i] = g_dspInitialize.pARAM_Read_U8(ARAMAddr+i);
|
|
}
|
|
|
|
// yes, the dumps are really zelda sound ;)
|
|
DumpAFC(Buffer, NumberOfSamples*9, 0x3d00);
|
|
|
|
DumpPB(_rPB);
|
|
|
|
// exit(1);
|
|
#endif
|
|
|
|
// i think pTest[0x3a] and pTest[0x3b] got an update after you have decoded some samples...
|
|
// just decrement them with the number of samples you have played
|
|
// and incrrease the ARAM Offset in pTest[0x38], pTest[0x39]
|
|
|
|
|
|
// end of block (Zelda 03b2)
|
|
if (pTest[0x06] == 0)
|
|
{
|
|
pTest[0x04] = 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::Update(int cycles)
|
|
{
|
|
// This is called at arbitrary intervals from the core emu.
|
|
// We don't need it.
|
|
}
|
|
|
|
void CUCode_Zelda::HandleMail(u32 _uMail)
|
|
{
|
|
switch (m_MailState)
|
|
{
|
|
case WaitForMail:
|
|
{
|
|
if (_uMail == 0x00000000)
|
|
{
|
|
m_MailState = ReadingFrameSync;
|
|
}
|
|
else if (_uMail < 0x255)
|
|
{
|
|
m_numSteps = _uMail;
|
|
m_MailState = ReadingMessage;
|
|
}
|
|
else
|
|
{
|
|
PanicAlert("Unknown Mail: 0x%08x", _uMail);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ReadingFrameSync:
|
|
{
|
|
int Slot = (_uMail >> 16) & 0x000F;
|
|
m_PBMask[Slot] = _uMail & 0xFFFF;
|
|
m_MailState = WaitForMail;
|
|
|
|
// Zelda UC 05db
|
|
m_MaxSyncedPB = (Slot+1) << 4;
|
|
}
|
|
break;
|
|
|
|
case ReadingMessage:
|
|
{
|
|
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)
|
|
{
|
|
ExecuteList();
|
|
m_MailState = WaitForMail;
|
|
m_step = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ReadingSystemMsg:
|
|
{
|
|
_dbg_assert_msg_(DSPHLE, (_uMail & 0xFFFF0000) == 0xCDD10000, "This is not a system msg", _uMail);
|
|
m_MailState = WaitForMail;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::MixAdd(short* _pBuffer, int _iSize)
|
|
{
|
|
if (m_NumberOfFramesToRender > 0)
|
|
{
|
|
if (m_NumPBs <= m_MaxSyncedPB) // we just render if all PBs are synced...Zelda does it in steps of 0x10 PBs but hey this is HLE
|
|
{
|
|
if (_iSize > 1024 * 1024)
|
|
_iSize = 1024 * 1024;
|
|
|
|
memset(templbuffer, 0, _iSize * sizeof(int));
|
|
memset(temprbuffer, 0, _iSize * sizeof(int));
|
|
|
|
CopyPBsFromRAM();
|
|
|
|
// render frame...
|
|
for (u32 i = 0; i < m_NumPBs; i++)
|
|
{
|
|
// masking of PBs is done in zelda 0272... skip it for the moment
|
|
/* int Slot = i >> 4;
|
|
int Mask = i & 0x0F;
|
|
if (m_PBMask[Slot] & Mask)) */
|
|
{
|
|
UpdatePB(m_PBs[i], templbuffer, temprbuffer, _iSize);
|
|
}
|
|
}
|
|
CopyPBsToRAM();
|
|
m_MaxSyncedPB = 0;
|
|
|
|
if (_pBuffer) {
|
|
for (int i = 0; i < _iSize; i++)
|
|
{
|
|
// Clamp into 16-bit. Maybe we should add a volume compressor here.
|
|
int left = templbuffer[i] + _pBuffer[0];
|
|
int right = temprbuffer[i] + _pBuffer[1];
|
|
if (left < -32767) left = -32767;
|
|
if (left > 32767) left = 32767;
|
|
if (right < -32767) right = -32767;
|
|
if (right > 32767) right = 32767;
|
|
*_pBuffer++ = left;
|
|
*_pBuffer++ = right;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_CurrentFrameToRender++;
|
|
|
|
// sync, we are ready
|
|
m_rMailHandler.PushMail(DSP_SYNC);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
m_rMailHandler.PushMail(0xF3550000 | m_CurrentFrameToRender | 0xFF00);
|
|
|
|
if (m_CurrentFrameToRender == m_NumberOfFramesToRender)
|
|
{
|
|
/*
|
|
afaik zelda hasnt registered a handler to FRAME_END... so skip it
|
|
m_rMailHandler.PushMail(DSP_FRAME_END);
|
|
g_dspInitialize.pGenerateDSPInterrupt();
|
|
m_MailState = ReadingSystemMsg;
|
|
*/
|
|
m_NumberOfFramesToRender = 0;
|
|
m_CurrentFrameToRender = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// zelda debug ..803F6418
|
|
void CUCode_Zelda::ExecuteList()
|
|
{
|
|
// begin with the list
|
|
m_readOffset = 0;
|
|
|
|
u32 CmdMail = Read32();
|
|
u32 Command = (CmdMail >> 24) & 0x7f;
|
|
u32 Sync = CmdMail >> 16;
|
|
|
|
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:
|
|
{
|
|
m_NumPBs = (CmdMail & 0xFFFF);
|
|
if (m_NumPBs > 0x40)
|
|
{
|
|
PanicAlert("(m_NumPBs > 0x40) to much PBs");
|
|
m_NumPBs = 0x40;
|
|
}
|
|
|
|
m_PBAddress = Read32();
|
|
u32 DSPADPCM_FILTER = Read32();
|
|
u32 DSPRES_FILTER = Read32();
|
|
m_PBAddress2 = Read32();
|
|
|
|
// What is this stuff?
|
|
u16 Buffer[0x280];
|
|
for (int i = 0; i < 0x280; i++)
|
|
{
|
|
Buffer[i] = Memory_Read_U16(DSPADPCM_FILTER + (i*2));
|
|
}
|
|
|
|
u16* pTmp = (u16*)m_AFCCoefTable;
|
|
for (int i = 0; i < 0x20; i++)
|
|
{
|
|
pTmp[i] = Memory_Read_U16(DSPRES_FILTER + (i*2));
|
|
}
|
|
|
|
DEBUG_LOG(DSPHLE, "DsetupTable");
|
|
DEBUG_LOG(DSPHLE, "Param Blocks 1: 0x%08x", m_PBAddress);
|
|
DEBUG_LOG(DSPHLE, "DSPADPCM_FILTER (size: 0x500): 0x%08x", DSPADPCM_FILTER);
|
|
DEBUG_LOG(DSPHLE, "DSPRES_FILTER (size: 0x40): 0x%08x", DSPRES_FILTER);
|
|
DEBUG_LOG(DSPHLE, "Param Blocks 2: 0x%08x", m_PBAddress2);
|
|
}
|
|
break;
|
|
|
|
// SyncFrame ... zelda ww jumps to 0x0243
|
|
// SyncFrame doesn't send a 0xDCD10004 SYNC at all ... just the 0xDCD10005 for "frame end"
|
|
case 0x02:
|
|
{
|
|
m_MixingBufferLeft = Read32();
|
|
m_MixingBufferRight = Read32();
|
|
|
|
m_NumberOfFramesToRender = (CmdMail >> 16) & 0xFF;
|
|
m_MaxSyncedPB = 0;
|
|
|
|
DEBUG_LOG(DSPHLE, "DsyncFrame");
|
|
DEBUG_LOG(DSPHLE, "Left Mixing Buffer: 0x%08x", m_MixingBufferLeft);
|
|
DEBUG_LOG(DSPHLE, "Right Mixing Buffer: 0x%08x", m_MixingBufferRight);
|
|
|
|
// This is where we should render.
|
|
soundStream->GetMixer()->SetHLEReady(true);
|
|
}
|
|
return;
|
|
|
|
/*
|
|
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[1];
|
|
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:
|
|
{
|
|
DEBUG_LOG(DSPHLE, "Set VARAM - ???");
|
|
/*
|
|
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 (u32 i = 0; i < m_NumPBs; i++)
|
|
{
|
|
u32 addr = m_PBAddress + i * sizeof(ZPB);
|
|
const u16 *src_ptr = (u16 *)g_dspInitialize.pGetMemoryPointer(addr);
|
|
u16 *dst_ptr = (u16 *)&m_PBs[i];
|
|
|
|
for (size_t p = 0; p < 0xC0; p++)
|
|
{
|
|
dst_ptr[p] = Common::swap16(src_ptr[p]);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CUCode_Zelda::CopyPBsToRAM()
|
|
{
|
|
for (u32 i = 0; i < m_NumPBs; i++)
|
|
{
|
|
u32 addr = m_PBAddress + i * sizeof(ZPB);
|
|
const u16 *src_ptr = (u16 *)&m_PBs[i];
|
|
u16 *dst_ptr = (u16 *)g_dspInitialize.pGetMemoryPointer(addr);
|
|
for (size_t p = 0; p < 0x80; p++) // we write the first 0x80 shorts back only
|
|
{
|
|
dst_ptr[p] = Common::swap16(src_ptr[p]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 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.
|
|
// input = location of encoded source samples
|
|
// out = location of destination buffer (16 bits / sample)
|
|
|
|
// I am sure that there are 5 bytes of input for 16 samples output too... just check the UCode
|
|
// if (type == 5) -> 5 input bytes
|
|
// if (type == 9) -> 9 input bytes
|
|
//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// --- Debug Helper
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void CUCode_Zelda::DumpPB(const ZPB& _rPB)
|
|
{
|
|
u16* pTmp = (u16*)&_rPB;
|
|
FILE* pF = fopen("d:\\dump\\PB.txt", "a");
|
|
if (pF)
|
|
{
|
|
if (_rPB.addr_high)
|
|
{
|
|
for (int i = 0; i < 0xc0; i += 4)
|
|
{
|
|
fprintf(pF, "[0x%02x] %04x %04x %04x %04x\n", i, pTmp[i], pTmp[i + 1], pTmp[i + 2], pTmp[i + 3]);
|
|
}
|
|
fprintf(pF, "\n");
|
|
fclose(pF);
|
|
}
|
|
}
|
|
}
|
|
|
|
void write32le(int in, unsigned char * buf) {
|
|
buf[0]=in&0xff;
|
|
buf[1]=(in>>8)&0xff;
|
|
buf[2]=(in>>16)&0xff;
|
|
buf[3]=(in>>24)&0xff;
|
|
}
|
|
|
|
int CUCode_Zelda::DumpAFC(u8* pIn, const int size, const int srate)
|
|
{
|
|
unsigned char inbuf[9];
|
|
short outbuf[16];
|
|
FILE * outfile;
|
|
int sizeleft;
|
|
int outsize,outsizetotal;
|
|
short hist=0,hist2=0;
|
|
|
|
unsigned char wavhead[44] = {
|
|
0x52, 0x49, 0x46, 0x46, 0x00, 0x00, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6D, 0x74, 0x20,
|
|
0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x02, 0x00, 0x10, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
outfile = fopen("d:/supa.wav","wb");
|
|
if (!outfile) return 1;
|
|
|
|
outsize = size/9*16*2;
|
|
outsizetotal = outsize+8;
|
|
write32le(outsizetotal,wavhead+4);
|
|
write32le(outsize,wavhead+40);
|
|
write32le(srate,wavhead+24);
|
|
write32le(srate*2,wavhead+28);
|
|
if (fwrite(wavhead,1,44,outfile)!=44) return 1;
|
|
|
|
for (sizeleft=size;sizeleft>=9;sizeleft-=9) {
|
|
memcpy(inbuf, pIn, 9);
|
|
pIn += 9;
|
|
|
|
AFCdecodebuffer(m_AFCCoefTable, (char*)inbuf,outbuf,&hist,&hist2,9);
|
|
|
|
if (fwrite(outbuf,1,16*2,outfile) != 16*2)
|
|
return 1;
|
|
}
|
|
|
|
if (fclose(outfile)==EOF) return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void CUCode_Zelda::DoState(PointerWrap &p) {
|
|
p.Do(m_MailState);
|
|
p.Do(m_PBMask);
|
|
p.Do(m_NumPBs);
|
|
p.Do(m_PBAddress);
|
|
p.Do(m_MaxSyncedPB);
|
|
p.Do(m_PBs);
|
|
p.Do(m_readOffset);
|
|
p.Do(m_NumberOfFramesToRender);
|
|
p.Do(m_CurrentFrameToRender);
|
|
p.Do(m_numSteps);
|
|
p.Do(m_step);
|
|
p.Do(m_Buffer);
|
|
}
|