kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cog/Frameworks/GME/gme/Vgm_Core.cpp

2272 lines
56 KiB
C++
Raw Blame History

// Game_Music_Emu $vers. http://www.slack.net/~ant/
#include "Vgm_Core.h"
#include "dac_control.h"
#include "blargg_endian.h"
#include <math.h>
// Needed for OKIM6295 system detection
#include "Vgm_Emu.h"
/* Copyright (C) 2003-2008 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module 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 Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this module; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
#include "blargg_source.h"
int const stereo = 2;
int const fm_time_bits = 12;
int const blip_time_bits = 12;
enum {
cmd_gg_stereo = 0x4F,
cmd_gg_stereo_2 = 0x3F,
cmd_psg = 0x50,
cmd_psg_2 = 0x30,
cmd_ym2413 = 0x51,
cmd_ym2413_2 = 0xA1,
cmd_ym2612_port0 = 0x52,
cmd_ym2612_2_port0 = 0xA2,
cmd_ym2612_port1 = 0x53,
cmd_ym2612_2_port1 = 0xA3,
cmd_ym2151 = 0x54,
cmd_ym2151_2 = 0xA4,
cmd_ym2203 = 0x55,
cmd_ym2203_2 = 0xA5,
cmd_ym2608_port0 = 0x56,
cmd_ym2608_2_port0 = 0xA6,
cmd_ym2608_port1 = 0x57,
cmd_ym2608_2_port1 = 0xA7,
cmd_ym2610_port0 = 0x58,
cmd_ym2610_2_port0 = 0xA8,
cmd_ym2610_port1 = 0x59,
cmd_ym2610_2_port1 = 0xA9,
cmd_ym3812 = 0x5A,
cmd_ym3812_2 = 0xAA,
cmd_ymz280b = 0x5D,
cmd_ymf262_port0 = 0x5E,
cmd_ymf262_2_port0 = 0xAE,
cmd_ymf262_port1 = 0x5F,
cmd_ymf262_2_port1 = 0xAF,
cmd_delay = 0x61,
cmd_delay_735 = 0x62,
cmd_delay_882 = 0x63,
cmd_byte_delay = 0x64,
cmd_end = 0x66,
cmd_data_block = 0x67,
cmd_ram_block = 0x68,
cmd_short_delay = 0x70,
cmd_pcm_delay = 0x80,
cmd_dacctl_setup = 0x90,
cmd_dacctl_data = 0x91,
cmd_dacctl_freq = 0x92,
cmd_dacctl_play = 0x93,
cmd_dacctl_stop = 0x94,
cmd_dacctl_playblock= 0x95,
cmd_ay8910 = 0xA0,
cmd_rf5c68 = 0xB0,
cmd_rf5c164 = 0xB1,
cmd_pwm = 0xB2,
cmd_okim6258_write = 0xB7,
cmd_okim6295_write = 0xB8,
cmd_huc6280_write = 0xB9,
cmd_k053260_write = 0xBA,
cmd_segapcm_write = 0xC0,
cmd_rf5c68_mem = 0xC1,
cmd_rf5c164_mem = 0xC2,
cmd_qsound_write = 0xC4,
cmd_k051649_write = 0xD2,
cmd_k054539_write = 0xD3,
cmd_c140 = 0xD4,
cmd_pcm_seek = 0xE0,
rf5c68_ram_block = 0x01,
rf5c164_ram_block = 0x02,
pcm_block_type = 0x00,
pcm_aux_block_type = 0x40,
rom_block_type = 0x80,
ram_block_type = 0xC0,
rom_segapcm = 0x80,
rom_ym2608_deltat = 0x81,
rom_ym2610_adpcm = 0x82,
rom_ym2610_deltat = 0x83,
rom_ymz280b = 0x86,
rom_okim6295 = 0x8B,
rom_k054539 = 0x8C,
rom_c140 = 0x8D,
rom_k053260 = 0x8E,
rom_qsound = 0x8F,
ram_rf5c68 = 0xC0,
ram_rf5c164 = 0xC1,
ram_nesapu = 0xC2,
ym2612_dac_port = 0x2A,
ym2612_dac_pan_port = 0xB6
};
inline int command_len( int command )
{
static byte const lens [0x10] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
1,1,1,2,2,3,1,1,1,1,3,3,4,4,5,5
};
int len = lens [command >> 4];
check( len != 1 );
return len;
}
int Vgm_Core::run_ym2151( int chip, int time )
{
return ym2151[!!chip].run_until( time );
}
int Vgm_Core::run_ym2203( int chip, int time )
{
return ym2203[!!chip].run_until( time );
}
int Vgm_Core::run_ym2413( int chip, int time )
{
return ym2413[!!chip].run_until( time );
}
int Vgm_Core::run_ym2612( int chip, int time )
{
return ym2612[!!chip].run_until( time );
}
int Vgm_Core::run_ym2610( int chip, int time )
{
return ym2610[!!chip].run_until( time );
}
int Vgm_Core::run_ym2608( int chip, int time )
{
return ym2608[!!chip].run_until( time );
}
int Vgm_Core::run_ym3812( int chip, int time )
{
return ym3812[!!chip].run_until( time );
}
int Vgm_Core::run_ymf262( int chip, int time )
{
return ymf262[!!chip].run_until( time );
}
int Vgm_Core::run_ymz280b( int time )
{
return ymz280b.run_until( time );
}
int Vgm_Core::run_c140( int time )
{
return c140.run_until( time );
}
int Vgm_Core::run_segapcm( int time )
{
return segapcm.run_until( time );
}
int Vgm_Core::run_rf5c68( int time )
{
return rf5c68.run_until( time );
}
int Vgm_Core::run_rf5c164( int time )
{
return rf5c164.run_until( time );
}
int Vgm_Core::run_pwm( int time )
{
return pwm.run_until( time );
}
int Vgm_Core::run_okim6258( int chip, int time )
{
chip = !!chip;
if ( okim6258[chip].enabled() )
{
int current_clock = okim6258[chip].get_clock();
if ( okim6258_hz[chip] != current_clock )
{
okim6258_hz[chip] = current_clock;
okim6258[chip].setup( (double)okim6258_hz[chip] / vgm_rate, 0.85, 1.0 );
}
}
return okim6258[chip].run_until( time );
}
int Vgm_Core::run_okim6295( int chip, int time )
{
return okim6295[!!chip].run_until( time );
}
int Vgm_Core::run_k051649( int time )
{
return k051649.run_until( time );
}
int Vgm_Core::run_k053260( int time )
{
return k053260.run_until( time );
}
int Vgm_Core::run_k054539( int time )
{
return k054539.run_until( time );
}
int Vgm_Core::run_qsound( int chip, int time )
{
return qsound[!!chip].run_until( time );
}
/* Recursive fun starts here! */
int Vgm_Core::run_dac_control( int time )
{
if (dac_control_recursion) return 1;
++dac_control_recursion;
for ( unsigned i = 0; i < DacCtrlUsed; i++ )
{
int time_start = DacCtrlTime[DacCtrlMap[i]];
if ( time > time_start )
{
DacCtrlTime[DacCtrlMap[i]] = time;
daccontrol_update( dac_control [i], time_start, time - time_start );
}
}
--dac_control_recursion;
return 1;
}
Vgm_Core::Vgm_Core()
{
blip_buf[0] = stereo_buf[0].center();
blip_buf[1] = blip_buf[0];
has_looped = false;
DacCtrlUsed = 0;
dac_control = NULL;
memset( PCMBank, 0, sizeof( PCMBank ) );
memset( &PCMTbl, 0, sizeof( PCMTbl ) );
memset( DacCtrl, 0, sizeof( DacCtrl ) );
memset( DacCtrlTime, 0, sizeof( DacCtrlTime ) );
}
Vgm_Core::~Vgm_Core()
{
for (unsigned i = 0; i < DacCtrlUsed; i++) device_stop_daccontrol( dac_control [i] );
if ( dac_control ) free( dac_control );
for (unsigned i = 0; i < PCM_BANK_COUNT; i++)
{
if ( PCMBank [i].Bank ) free( PCMBank [i].Bank );
if ( PCMBank [i].Data ) free( PCMBank [i].Data );
}
if ( PCMTbl.Entries ) free( PCMTbl.Entries );
}
typedef unsigned int FUINT8;
typedef unsigned int FUINT16;
void Vgm_Core::ReadPCMTable(unsigned DataSize, const byte* Data)
{
byte ValSize;
unsigned TblSize;
PCMTbl.ComprType = Data[0x00];
PCMTbl.CmpSubType = Data[0x01];
PCMTbl.BitDec = Data[0x02];
PCMTbl.BitCmp = Data[0x03];
PCMTbl.EntryCount = get_le16( Data + 0x04 );
ValSize = (PCMTbl.BitDec + 7) / 8;
TblSize = PCMTbl.EntryCount * ValSize;
PCMTbl.Entries = realloc(PCMTbl.Entries, TblSize);
memcpy(PCMTbl.Entries, Data + 0x06, TblSize);
}
bool Vgm_Core::DecompressDataBlk(VGM_PCM_DATA* Bank, unsigned DataSize, const byte* Data)
{
UINT8 ComprType;
UINT8 BitDec;
FUINT8 BitCmp;
UINT8 CmpSubType;
UINT16 AddVal;
const UINT8* InPos;
const UINT8* InDataEnd;
UINT8* OutPos;
const UINT8* OutDataEnd;
FUINT16 InVal;
FUINT16 OutVal = 0;
FUINT8 ValSize;
FUINT8 InShift;
FUINT8 OutShift;
UINT8* Ent1B;
UINT16* Ent2B;
// ReadBits Variables
FUINT8 BitsToRead;
FUINT8 BitReadVal;
FUINT8 InValB;
FUINT8 BitMask;
FUINT8 OutBit;
// Variables for DPCM
UINT16 OutMask;
ComprType = Data[0x00];
Bank->DataSize = get_le32( Data + 0x01 );
switch(ComprType)
{
case 0x00: // n-Bit compression
BitDec = Data[0x05];
BitCmp = Data[0x06];
CmpSubType = Data[0x07];
AddVal = get_le16( Data + 0x08 );
if (CmpSubType == 0x02)
{
Ent1B = (UINT8*)PCMTbl.Entries;
Ent2B = (UINT16*)PCMTbl.Entries;
if (! PCMTbl.EntryCount)
{
Bank->DataSize = 0x00;
return false;
}
else if (BitDec != PCMTbl.BitDec || BitCmp != PCMTbl.BitCmp)
{
Bank->DataSize = 0x00;
return false;
}
}
ValSize = (BitDec + 7) / 8;
InPos = Data + 0x0A;
InDataEnd = Data + DataSize;
InShift = 0;
OutShift = BitDec - BitCmp;
OutDataEnd = Bank->Data + Bank->DataSize;
for (OutPos = Bank->Data; OutPos < OutDataEnd && InPos < InDataEnd; OutPos += ValSize)
{
//InVal = ReadBits(Data, InPos, &InShift, BitCmp);
// inlined - is 30% faster
OutBit = 0x00;
InVal = 0x0000;
BitsToRead = BitCmp;
while(BitsToRead)
{
BitReadVal = (BitsToRead >= 8) ? 8 : BitsToRead;
BitsToRead -= BitReadVal;
BitMask = (1 << BitReadVal) - 1;
InShift += BitReadVal;
InValB = (*InPos << InShift >> 8) & BitMask;
if (InShift >= 8)
{
InShift -= 8;
InPos ++;
if (InShift)
InValB |= (*InPos << InShift >> 8) & BitMask;
}
InVal |= InValB << OutBit;
OutBit += BitReadVal;
}
switch(CmpSubType)
{
case 0x00: // Copy
OutVal = InVal + AddVal;
break;
case 0x01: // Shift Left
OutVal = (InVal << OutShift) + AddVal;
break;
case 0x02: // Table
switch(ValSize)
{
case 0x01:
OutVal = Ent1B[InVal];
break;
case 0x02:
OutVal = Ent2B[InVal];
break;
}
break;
}
//memcpy(OutPos, &OutVal, ValSize);
if (ValSize == 0x01)
*((UINT8*)OutPos) = (UINT8)OutVal;
else //if (ValSize == 0x02)
*((UINT16*)OutPos) = (UINT16)OutVal;
}
break;
case 0x01: // Delta-PCM
BitDec = Data[0x05];
BitCmp = Data[0x06];
OutVal = get_le16( Data + 0x08 );
Ent1B = (UINT8*)PCMTbl.Entries;
Ent2B = (UINT16*)PCMTbl.Entries;
if (! PCMTbl.EntryCount)
{
Bank->DataSize = 0x00;
return false;
}
else if (BitDec != PCMTbl.BitDec || BitCmp != PCMTbl.BitCmp)
{
Bank->DataSize = 0x00;
return false;
}
ValSize = (BitDec + 7) / 8;
OutMask = (1 << BitDec) - 1;
InPos = Data + 0x0A;
InDataEnd = Data + DataSize;
InShift = 0;
OutShift = BitDec - BitCmp;
OutDataEnd = Bank->Data + Bank->DataSize;
AddVal = 0x0000;
for (OutPos = Bank->Data; OutPos < OutDataEnd && InPos < InDataEnd; OutPos += ValSize)
{
//InVal = ReadBits(Data, InPos, &InShift, BitCmp);
// inlined - is 30% faster
OutBit = 0x00;
InVal = 0x0000;
BitsToRead = BitCmp;
while(BitsToRead)
{
BitReadVal = (BitsToRead >= 8) ? 8 : BitsToRead;
BitsToRead -= BitReadVal;
BitMask = (1 << BitReadVal) - 1;
InShift += BitReadVal;
InValB = (*InPos << InShift >> 8) & BitMask;
if (InShift >= 8)
{
InShift -= 8;
InPos ++;
if (InShift)
InValB |= (*InPos << InShift >> 8) & BitMask;
}
InVal |= InValB << OutBit;
OutBit += BitReadVal;
}
switch(ValSize)
{
case 0x01:
AddVal = Ent1B[InVal];
OutVal += AddVal;
OutVal &= OutMask;
*((UINT8*)OutPos) = (UINT8)OutVal;
break;
case 0x02:
AddVal = Ent2B[InVal];
OutVal += AddVal;
OutVal &= OutMask;
*((UINT16*)OutPos) = (UINT16)OutVal;
break;
}
}
break;
default:
return false;
}
return true;
}
void Vgm_Core::AddPCMData(byte Type, unsigned DataSize, const byte* Data)
{
unsigned CurBnk;
VGM_PCM_BANK* TempPCM;
VGM_PCM_DATA* TempBnk;
unsigned BankSize;
bool RetVal;
if ((Type & 0x3F) >= PCM_BANK_COUNT || has_looped)
return;
if (Type == 0x7F)
{
ReadPCMTable( DataSize, Data );
return;
}
TempPCM = &PCMBank[Type & 0x3F];
CurBnk = TempPCM->BankCount;
TempPCM->BankCount ++;
TempPCM->BnkPos ++;
if (TempPCM->BnkPos < TempPCM->BankCount)
return; // Speed hack (for restarting playback)
TempPCM->Bank = (VGM_PCM_DATA*)realloc(TempPCM->Bank,
sizeof(VGM_PCM_DATA) * TempPCM->BankCount);
if (! (Type & 0x40))
BankSize = DataSize;
else
BankSize = get_le32( Data + 1 );
TempPCM->Data = ( byte * ) realloc(TempPCM->Data, TempPCM->DataSize + BankSize);
TempBnk = &TempPCM->Bank[CurBnk];
TempBnk->DataStart = TempPCM->DataSize;
if (! (Type & 0x40))
{
TempBnk->DataSize = DataSize;
TempBnk->Data = TempPCM->Data + TempBnk->DataStart;
memcpy(TempBnk->Data, Data, DataSize);
}
else
{
TempBnk->Data = TempPCM->Data + TempBnk->DataStart;
RetVal = DecompressDataBlk(TempBnk, DataSize, Data);
if (! RetVal)
{
TempBnk->Data = NULL;
TempBnk->DataSize = 0x00;
return;
}
}
TempPCM->DataSize += BankSize;
}
const byte* Vgm_Core::GetPointerFromPCMBank(byte Type, unsigned DataPos)
{
if (Type >= PCM_BANK_COUNT)
return NULL;
if (DataPos >= PCMBank[Type].DataSize)
return NULL;
return &PCMBank[Type].Data[DataPos];
}
void Vgm_Core::dac_control_grow(byte chip_id)
{
for ( unsigned i = 0; i < DacCtrlUsed; i++ )
{
if ( DacCtrlUsg [i] == chip_id )
{
device_reset_daccontrol( dac_control [i] );
return;
}
}
unsigned chip_mapped = DacCtrlUsed;
DacCtrlUsg [DacCtrlUsed++] = chip_id;
DacCtrlMap [chip_id] = chip_mapped;
dac_control = (void**) realloc( dac_control, DacCtrlUsed * sizeof(void*) );
dac_control [chip_mapped] = device_start_daccontrol( vgm_rate, this );
device_reset_daccontrol( dac_control [chip_mapped] );
}
extern "C" void chip_reg_write(void * context, UINT32 Sample, UINT8 ChipType, UINT8 ChipID, UINT8 Port, UINT8 Offset, UINT8 Data)
{
Vgm_Core * core = (Vgm_Core *) context;
core->chip_reg_write(Sample, ChipType, ChipID, Port, Offset, Data);
}
void Vgm_Core::chip_reg_write(unsigned Sample, byte ChipType, byte ChipID, byte Port, byte Offset, byte Data)
{
run_dac_control( Sample ); /* Let's get recursive! */
ChipID = !!ChipID;
switch (ChipType)
{
case 0x02:
switch (Port)
{
case 0:
if ( Offset == ym2612_dac_port )
{
write_pcm( Sample, ChipID, Data );
}
else if ( run_ym2612( ChipID, to_fm_time( Sample ) ) )
{
if ( Offset == 0x2B )
{
dac_disabled[ChipID] = (Data >> 7 & 1) - 1;
dac_amp[ChipID] |= dac_disabled[ChipID];
}
ym2612[ChipID].write0( Offset, Data );
}
break;
case 1:
if ( run_ym2612( ChipID, to_fm_time( Sample ) ) )
{
if ( Offset == ym2612_dac_pan_port )
{
Blip_Buffer * blip_buf = NULL;
switch ( Data >> 6 )
{
case 0: blip_buf = NULL; break;
case 1: blip_buf = stereo_buf[0].right(); break;
case 2: blip_buf = stereo_buf[0].left(); break;
case 3: blip_buf = stereo_buf[0].center(); break;
}
/*if ( this->blip_buf != blip_buf )
{
blip_time_t blip_time = to_psg_time( vgm_time );
if ( this->blip_buf ) pcm.offset_inline( blip_time, -dac_amp, this->blip_buf );
if ( blip_buf ) pcm.offset_inline( blip_time, dac_amp, blip_buf );
}*/
this->blip_buf[ChipID] = blip_buf;
}
ym2612[ChipID].write1( Offset, Data );
}
break;
}
break;
case 0x11:
if ( run_pwm( to_fm_time( Sample ) ) )
pwm.write( Port, ( ( Offset ) << 8 ) + Data );
break;
case 0x00:
psg[ChipID].write_data( to_psg_time( Sample ), Data );
break;
case 0x01:
if ( run_ym2413( ChipID, to_fm_time( Sample ) ) )
ym2413[ChipID].write( Offset, Data );
break;
case 0x03:
if ( run_ym2151( ChipID, to_fm_time( Sample ) ) )
ym2151[ChipID].write( Offset, Data );
break;
case 0x06:
if ( run_ym2203( ChipID, to_fm_time( Sample ) ) )
ym2203[ChipID].write( Offset, Data );
break;
case 0x07:
if ( run_ym2608( ChipID, to_fm_time( Sample ) ) )
{
switch (Port)
{
case 0: ym2608[ChipID].write0( Offset, Data ); break;
case 1: ym2608[ChipID].write1( Offset, Data ); break;
}
}
break;
case 0x08:
if ( run_ym2610( ChipID, to_fm_time( Sample ) ) )
{
switch (Port)
{
case 0: ym2610[ChipID].write0( Offset, Data ); break;
case 1: ym2610[ChipID].write1( Offset, Data ); break;
}
}
break;
case 0x09:
if ( run_ym3812( ChipID, to_fm_time( Sample ) ) )
ym3812[ChipID].write( Offset, Data );
break;
case 0x0C:
if ( run_ymf262( ChipID, to_fm_time( Sample ) ) )
{
switch (Port)
{
case 0: ymf262[ChipID].write0( Offset, Data ); break;
case 1: ymf262[ChipID].write1( Offset, Data ); break;
}
}
break;
case 0x0F:
if ( run_ymz280b( to_fm_time( Sample ) ) )
ymz280b.write( Offset, Data );
break;
case 0x12:
ay[ChipID].write_addr( Offset );
ay[ChipID].write_data( to_ay_time( Sample ), Data );
break;
case 0x17:
if ( run_okim6258( ChipID, to_fm_time( Sample ) ) )
okim6258[ChipID].write( Offset, Data );
break;
case 0x18:
if ( run_okim6295( ChipID, to_fm_time( Sample ) ) )
okim6295[ChipID].write( Offset, Data );
break;
case 0x19:
if ( run_k051649( to_fm_time( Sample ) ) )
k051649.write( Port, Offset, Data );
break;
case 0x1A:
if ( run_k054539( to_fm_time( Sample ) ) )
k054539.write( ( Port << 8 ) | Offset, Data );
break;
case 0x1B:
huc6280[ChipID].write_data( to_huc6280_time( Sample ), 0x800 + Offset, Data );
break;
case 0x1D:
if ( run_k053260( to_fm_time( Sample ) ) )
k053260.write( Offset, Data );
break;
case 0x1F:
if ( run_qsound( ChipID, Sample ) )
qsound[ ChipID ].write( Data, ( Port << 8 ) + Offset );
break;
}
}
void Vgm_Core::set_tempo( double t )
{
if ( file_begin() )
{
vgm_rate = (int) (44100 * t + 0.5);
blip_time_factor = (int) ((double)
(1 << blip_time_bits) / vgm_rate * stereo_buf[0].center()->clock_rate() + 0.5);
blip_ay_time_factor = (int) ((double)
(1 << blip_time_bits) / vgm_rate * stereo_buf[1].center()->clock_rate() + 0.5);
blip_huc6280_time_factor = (int) ((double)
(1 << blip_time_bits) / vgm_rate * stereo_buf[2].center()->clock_rate() + 0.5);
//dprintf( "blip_time_factor: %ld\n", blip_time_factor );
//dprintf( "vgm_rate: %ld\n", vgm_rate );
// TODO: remove? calculates vgm_rate more accurately (above differs at most by one Hz only)
//blip_time_factor = (int) floor( double (1 << blip_time_bits) * psg_rate_ / 44100 / t + 0.5 );
//vgm_rate = (int) floor( double (1 << blip_time_bits) * psg_rate_ / blip_time_factor + 0.5 );
fm_time_factor = 2 + (int) (fm_rate * (1 << fm_time_bits) / vgm_rate + 0.5);
}
}
bool Vgm_Core::header_t::valid_tag() const
{
return !memcmp( tag, "Vgm ", 4 );
}
int Vgm_Core::header_t::size() const
{
unsigned int version = get_le32( this->version );
unsigned int data_offset;
if ( version >= 0x150 )
{
data_offset = get_le32( this->data_offset );
if ( data_offset ) data_offset += offsetof( header_t, data_offset );
}
else data_offset = 0x40;
unsigned expected_size = ( version > 0x150 ) ? ( ( version > 0x160 ) ? unsigned(size_max) : unsigned(size_151) ) : unsigned(size_min);
if ( expected_size > data_offset ) expected_size = data_offset ? (data_offset > unsigned(size_max) ? unsigned(size_max) : data_offset) : unsigned(size_min);
return expected_size;
}
void Vgm_Core::header_t::cleanup()
{
unsigned int version = get_le32( this->version );
if ( size() < size_max ) memset( ((byte*)this) + size(), 0, size_max - size() );
if ( version < 0x161 )
{
memset( this->gbdmg_rate, 0, size_max - offsetof(header_t, gbdmg_rate) );
}
if ( version < 0x160 )
{
volume_modifier = 0;
reserved = 0;
loop_base = 0;
}
if ( version < 0x151 ) memset( this->rf5c68_rate, 0, size_max - size_min );
if ( version < 0x150 )
{
set_le32( data_offset, size_min - offsetof(header_t, data_offset) );
sn76489_flags = 0;
set_le32( segapcm_rate, 0 );
set_le32( segapcm_reg, 0 );
}
if ( version < 0x110 )
{
set_le16( noise_feedback, 0 );
noise_width = 0;
unsigned int rate = get_le32( ym2413_rate );
set_le32( ym2612_rate, rate );
set_le32( ym2151_rate, rate );
}
if ( version < 0x101 )
{
set_le32( frame_rate, 0 );
}
}
blargg_err_t Vgm_Core::load_mem_( byte const data [], int size )
{
assert( offsetof (header_t, rf5c68_rate) == header_t::size_min );
assert( offsetof (header_t, extra_offset[4]) == header_t::size_max );
if ( size <= header_t::size_min )
return blargg_err_file_type;
memcpy( &_header, data, header_t::size_min );
header_t const& h = header();
if ( !h.valid_tag() )
return blargg_err_file_type;
int version = get_le32( h.version );
check( version < 0x100 );
if ( version > 0x150 )
{
if ( size < header().size() )
return "Invalid header";
memcpy( &_header.rf5c68_rate, data + offsetof (header_t, rf5c68_rate), header().size() - header_t::size_min );
}
_header.cleanup();
// Get loop
loop_begin = file_end();
if ( get_le32( h.loop_offset ) )
loop_begin = &data [get_le32( h.loop_offset ) + offsetof (header_t,loop_offset)];
// PSG rate
int psg_rate = get_le32( h.psg_rate ) & 0x3FFFFFFF;
if ( !psg_rate )
psg_rate = 3579545;
stereo_buf[0].clock_rate( psg_rate );
int ay_rate = get_le32( h.ay8910_rate ) & 0xBFFFFFFF;
if ( !ay_rate )
ay_rate = 2000000;
stereo_buf[1].clock_rate( ay_rate * 2 );
ay[0].set_type( (Ay_Apu::Ay_Apu_Type) header().ay8910_type );
ay[1].set_type( (Ay_Apu::Ay_Apu_Type) header().ay8910_type );
int huc6280_rate = get_le32( h.huc6280_rate ) & 0xBFFFFFFF;
if ( !huc6280_rate )
huc6280_rate = 3579545;
stereo_buf[2].clock_rate( huc6280_rate * 2 );
// Disable FM
fm_rate = 0;
ymz280b.enable( false );
ymf262[0].enable( false );
ymf262[1].enable( false );
ym3812[0].enable( false );
ym3812[1].enable( false );
ym2612[0].enable( false );
ym2612[1].enable( false );
ym2610[0].enable( false );
ym2610[1].enable( false );
ym2608[0].enable( false );
ym2608[1].enable( false );
ym2413[0].enable( false );
ym2413[1].enable( false );
ym2203[0].enable( false );
ym2203[1].enable( false );
ym2151[0].enable( false );
ym2151[1].enable( false );
c140.enable( false );
segapcm.enable( false );
rf5c68.enable( false );
rf5c164.enable( false );
pwm.enable( false );
okim6258[0].enable( false );
okim6258[1].enable( false );
okim6295[0].enable( false );
okim6295[1].enable( false );
k051649.enable( false );
k053260.enable( false );
k054539.enable( false );
qsound[0].enable( false );
qsound[1].enable( false );
set_tempo( 1 );
return blargg_ok;
}
// Update pre-1.10 header FM rates by scanning commands
void Vgm_Core::update_fm_rates( int* ym2151_rate, int* ym2413_rate, int* ym2612_rate ) const
{
byte const* p = file_begin() + header().size();
int data_offset = get_le32( header().data_offset );
check( data_offset );
if ( data_offset )
p += data_offset + offsetof( header_t, data_offset ) - header().size();
while ( p < file_end() )
{
switch ( *p )
{
case cmd_end:
return;
case cmd_psg:
case cmd_byte_delay:
p += 2;
break;
case cmd_delay:
p += 3;
break;
case cmd_data_block:
p += 7 + get_le32( p + 3 );
break;
case cmd_ram_block:
p += 12;
break;
case cmd_ym2413:
*ym2151_rate = 0;
*ym2612_rate = 0;
return;
case cmd_ym2612_port0:
case cmd_ym2612_port1:
*ym2612_rate = *ym2413_rate;
*ym2413_rate = 0;
*ym2151_rate = 0;
return;
case cmd_ym2151:
*ym2151_rate = *ym2413_rate;
*ym2413_rate = 0;
*ym2612_rate = 0;
return;
default:
p += command_len( *p );
}
}
}
blargg_err_t Vgm_Core::init_chips( double* rate, bool reinit )
{
int ymz280b_rate = get_le32( header().ymz280b_rate ) & 0xBFFFFFFF;
int ymf262_rate = get_le32( header().ymf262_rate ) & 0xBFFFFFFF;
int ym3812_rate = get_le32( header().ym3812_rate ) & 0xBFFFFFFF;
int ym2612_rate = get_le32( header().ym2612_rate ) & 0xBFFFFFFF;
int ym2610_rate = get_le32( header().ym2610_rate ) & 0x3FFFFFFF;
int ym2608_rate = get_le32( header().ym2608_rate ) & 0x3FFFFFFF;
int ym2413_rate = get_le32( header().ym2413_rate ) & 0xBFFFFFFF;
int ym2203_rate = get_le32( header().ym2203_rate ) & 0xBFFFFFFF;
int ym2151_rate = get_le32( header().ym2151_rate ) & 0xBFFFFFFF;
int c140_rate = get_le32( header().c140_rate ) & 0xBFFFFFFF;
int segapcm_rate = get_le32( header().segapcm_rate ) & 0xBFFFFFFF;
int rf5c68_rate = get_le32( header().rf5c68_rate ) & 0xBFFFFFFF;
int rf5c164_rate = get_le32( header().rf5c164_rate ) & 0xBFFFFFFF;
int pwm_rate = get_le32( header().pwm_rate ) & 0xBFFFFFFF;
int okim6258_rate = get_le32( header().okim6258_rate ) & 0xBFFFFFFF;
int okim6295_rate = get_le32( header().okim6295_rate ) & 0xBFFFFFFF;
int k051649_rate = get_le32( header().k051649_rate ) & 0xBFFFFFFF;
int k053260_rate = get_le32( header().k053260_rate ) & 0xBFFFFFFF;
int k054539_rate = get_le32( header().k054539_rate ) & 0xBFFFFFFF;
int qsound_rate = get_le32( header().qsound_rate ) & 0xBFFFFFFF;
if ( ym2413_rate && get_le32( header().version ) < 0x110 )
update_fm_rates( &ym2151_rate, &ym2413_rate, &ym2612_rate );
*rate = vgm_rate;
if ( ymf262_rate )
{
bool dual_chip = !!(header().ymf262_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ymf262_rate / 288.0;
int result;
if ( !reinit )
{
result = ymf262[0].set_rate( fm_rate, ymf262_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ymf262[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ymf262[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ymf262[1].set_rate( fm_rate, ymf262_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ymf262[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ymf262[1].enable();
}
}
if ( ym3812_rate )
{
bool dual_chip = !!(header().ym3812_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym3812_rate / 72.0;
int result;
if ( !reinit )
{
result = ym3812[0].set_rate( fm_rate, ym3812_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym3812[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym3812[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym3812[1].set_rate( fm_rate, ym3812_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym3812[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym3812[1].enable();
}
}
if ( ym2612_rate )
{
bool dual_chip = !!(header().ym2612_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym2612_rate / 144.0;
if ( !reinit )
{
RETURN_ERR( ym2612[0].set_rate( fm_rate, ym2612_rate ) );
}
RETURN_ERR( ym2612[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2612[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
RETURN_ERR( ym2612[1].set_rate( fm_rate, ym2612_rate ) );
}
RETURN_ERR( ym2612[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2612[1].enable();
}
}
if ( ym2610_rate )
{
bool dual_chip = !!(header().ym2610_rate[3] & 0x40);
bool is_2610b = !!(header().ym2610_rate[3] & 0x80);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym2610_rate / 72.0;
int result;
if ( !reinit )
{
result = ym2610[0].set_rate( fm_rate, ym2610_rate, is_2610b );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2610[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2610[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym2610[1].set_rate( fm_rate, ym2610_rate, is_2610b );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2610[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2610[1].enable();
}
}
if ( ym2608_rate )
{
bool dual_chip = !!(header().ym2610_rate[3] & 0x40);
double gain = dual_chip ? 1.0 : 2.0;
double fm_rate = ym2608_rate / 72.0;
int result;
if ( !reinit )
{
result = ym2608[0].set_rate( fm_rate, ym2608_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2608[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2608[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym2608[1].set_rate( fm_rate, ym2608_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2608[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2608[1].enable();
}
}
if ( ym2413_rate )
{
bool dual_chip = !!(header().ym2413_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym2413_rate / 72.0;
int result;
if ( !reinit )
{
result = ym2413[0].set_rate( fm_rate, ym2413_rate );
if ( result == 2 )
return "YM2413 FM sound not supported";
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2413[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2413[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym2413[1].set_rate( fm_rate, ym2413_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2413[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2413[1].enable();
}
}
if ( ym2151_rate )
{
bool dual_chip = !!(header().ym2151_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym2151_rate / 64.0;
int result;
if ( !reinit )
{
result = ym2151[0].set_rate( fm_rate, ym2151_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2151[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2151[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym2151[1].set_rate( fm_rate, ym2151_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( ym2151[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2151[1].enable();
}
}
if ( ym2203_rate )
{
bool dual_chip = !!(header().ym2203_rate[3] & 0x40);
double gain = dual_chip ? 0.5 : 1.0;
double fm_rate = ym2203_rate / 72.0;
int result;
if ( !reinit )
{
result = ym2203[0].set_rate( fm_rate, ym2203_rate );
CHECK_ALLOC ( !result );
}
RETURN_ERR( ym2203[0].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2203[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
result = ym2203[1].set_rate( fm_rate, ym2203_rate );
CHECK_ALLOC ( !result );
}
RETURN_ERR( ym2203[1].setup( fm_rate / vgm_rate, 0.85, gain ) );
ym2203[1].enable();
}
}
if ( segapcm_rate )
{
double pcm_rate = segapcm_rate / 128.0;
if ( !reinit )
{
int result = segapcm.set_rate( get_le32( header().segapcm_reg ) );
CHECK_ALLOC( !result );
}
RETURN_ERR( segapcm.setup( pcm_rate / vgm_rate, 0.85, 1.5 ) );
segapcm.enable();
}
if ( rf5c68_rate )
{
double pcm_rate = rf5c68_rate / 384.0;
if ( !reinit )
{
int result = rf5c68.set_rate();
CHECK_ALLOC( !result );
}
RETURN_ERR( rf5c68.setup( pcm_rate / vgm_rate, 0.85, 0.6875 ) );
rf5c68.enable();
}
if ( rf5c164_rate )
{
double pcm_rate = rf5c164_rate / 384.0;
if ( !reinit )
{
int result = rf5c164.set_rate( rf5c164_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( rf5c164.setup( pcm_rate / vgm_rate, 0.85, 0.5 ) );
rf5c164.enable();
}
if ( pwm_rate )
{
double pcm_rate = 22020.0;
if ( !reinit )
{
int result = pwm.set_rate( pwm_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( pwm.setup( pcm_rate / vgm_rate, 0.85, 0.875 ) );
pwm.enable();
}
if ( okim6258_rate )
{
bool dual_chip = !!( header().okim6258_rate[3] & 0x40 );
if ( !reinit )
{
okim6258_hz[0] = okim6258[0].set_rate( okim6258_rate, header().okim6258_flags & 0x03, ( header().okim6258_flags & 0x04 ) >> 2, ( header().okim6258_flags & 0x08 ) >> 3 );
CHECK_ALLOC( okim6258_hz[0] );
}
RETURN_ERR( okim6258[0].setup( (double)okim6258_hz[0] / vgm_rate, 0.85, 1.0 ) );
okim6258[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
okim6258_hz[1] = okim6258[1].set_rate( okim6258_rate, header().okim6258_flags & 0x03, ( header().okim6258_flags & 0x04 ) >> 2, ( header().okim6258_flags & 0x08 ) >> 3 );
CHECK_ALLOC( okim6258_hz[1] );
}
RETURN_ERR( okim6258[1].setup( (double)okim6258_hz[1] / vgm_rate, 0.85, 1.0 ) );
okim6258[1].enable();
}
}
if ( okim6295_rate )
{
// moo
Mem_File_Reader rdr( file_begin(), file_size() );
Music_Emu * vgm = gme_vgm_type->new_info();
track_info_t info;
vgm->load( rdr );
vgm->track_info( &info, 0 );
delete vgm;
bool is_cp_system = strncmp( info.system, "CP", 2 ) == 0;
bool dual_chip = !!( header().okim6295_rate[3] & 0x40 );
double gain = is_cp_system ? 0.4296875 : 1.0;
if ( dual_chip ) gain *= 0.5;
if ( !reinit )
{
okim6295_hz = okim6295[0].set_rate( okim6295_rate );
CHECK_ALLOC( okim6295_hz );
}
RETURN_ERR( okim6295[0].setup( (double)okim6295_hz / vgm_rate, 0.85, gain ) );
okim6295[0].enable();
if ( dual_chip )
{
if ( !reinit )
{
int result = okim6295[1].set_rate( okim6295_rate );
CHECK_ALLOC( result );
}
RETURN_ERR( okim6295[1].setup( (double)okim6295_hz / vgm_rate, 0.85, gain ) );
okim6295[1].enable();
}
}
if ( c140_rate )
{
double pcm_rate = c140_rate;
if ( !reinit )
{
int result = c140.set_rate( header().c140_type, c140_rate, c140_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( c140.setup( pcm_rate / vgm_rate, 0.85, 1.0 ) );
c140.enable();
}
if ( k051649_rate )
{
double pcm_rate = k051649_rate / 16.0;
if ( !reinit )
{
int result = k051649.set_rate( k051649_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( k051649.setup( pcm_rate / vgm_rate, 0.85, 1.0 ) );
k051649.enable();
}
if ( k053260_rate )
{
double pcm_rate = k053260_rate / 32.0;
if ( !reinit )
{
int result = k053260.set_rate( k053260_rate );
CHECK_ALLOC( !result );
}
RETURN_ERR( k053260.setup( pcm_rate / vgm_rate, 0.85, 1.0 ) );
k053260.enable();
}
if ( k054539_rate )
{
double pcm_rate = k054539_rate;
if ( !reinit )
{
int result = k054539.set_rate( k054539_rate, header().k054539_flags );
CHECK_ALLOC( !result );
}
RETURN_ERR( k054539.setup( pcm_rate / vgm_rate, 0.85, 1.0 ) );
k054539.enable();
}
if ( ymz280b_rate )
{
if ( !reinit )
{
ymz280b_hz = ymz280b.set_rate( ymz280b_rate );
CHECK_ALLOC( ymz280b_hz );
}
RETURN_ERR( ymz280b.setup( (double)ymz280b_hz / vgm_rate, 0.85, 0.59375 ) );
ymz280b.enable();
}
if ( qsound_rate )
{
/*double pcm_rate = (double)qsound_rate / 166.0;*/
if ( !reinit )
{
int result = qsound[0].set_rate( qsound_rate );
CHECK_ALLOC( result );
}
qsound[0].set_sample_rate( vgm_rate );
RETURN_ERR( qsound[0].setup( 1.0, 0.85, 1.0 ) );
qsound[0].enable();
}
fm_rate = *rate;
return blargg_ok;
}
void Vgm_Core::start_track()
{
psg[0].reset( get_le16( header().noise_feedback ), header().noise_width );
psg[1].reset( get_le16( header().noise_feedback ), header().noise_width );
ay[0].reset();
ay[1].reset();
huc6280[0].reset();
huc6280[1].reset();
blip_buf[0] = stereo_buf[0].center();
blip_buf[1] = blip_buf[0];
dac_disabled[0] = -1;
dac_disabled[1] = -1;
pos = file_begin() + header().size();
dac_amp[0] = -1;
dac_amp[1] = -1;
vgm_time = 0;
int data_offset = get_le32( header().data_offset );
check( data_offset );
if ( data_offset )
pos += data_offset + offsetof (header_t,data_offset) - header().size();
pcm_pos = pos;
if ( uses_fm() )
{
if ( rf5c68.enabled() )
rf5c68.reset();
if ( rf5c164.enabled() )
rf5c164.reset();
if ( segapcm.enabled() )
segapcm.reset();
if ( pwm.enabled() )
pwm.reset();
if ( okim6258[0].enabled() )
okim6258[0].reset();
if ( okim6258[1].enabled() )
okim6258[1].reset();
if ( okim6295[0].enabled() )
okim6295[0].reset();
if ( okim6295[1].enabled() )
okim6295[1].reset();
if ( k051649.enabled() )
k051649.reset();
if ( k053260.enabled() )
k053260.reset();
if ( k054539.enabled() )
k054539.reset();
if ( c140.enabled() )
c140.reset();
if ( ym2151[0].enabled() )
ym2151[0].reset();
if ( ym2151[1].enabled() )
ym2151[1].reset();
if ( ym2203[0].enabled() )
ym2203[0].reset();
if ( ym2203[1].enabled() )
ym2203[1].reset();
if ( ym2413[0].enabled() )
ym2413[0].reset();
if ( ym2413[1].enabled() )
ym2413[1].reset();
if ( ym2612[0].enabled() )
ym2612[0].reset();
if ( ym2612[1].enabled() )
ym2612[1].reset();
if ( ym2610[0].enabled() )
ym2610[0].reset();
if ( ym2610[1].enabled() )
ym2610[1].reset();
if ( ym2608[0].enabled() )
ym2608[0].reset();
if ( ym2608[1].enabled() )
ym2608[0].reset();
if ( ym3812[0].enabled() )
ym3812[0].reset();
if ( ym3812[1].enabled() )
ym3812[1].reset();
if ( ymf262[0].enabled() )
ymf262[0].reset();
if ( ymf262[1].enabled() )
ymf262[1].reset();
if ( ymz280b.enabled() )
ymz280b.reset();
if ( qsound[0].enabled() )
qsound[0].reset();
if ( qsound[1].enabled() )
qsound[1].reset();
stereo_buf[0].clear();
stereo_buf[1].clear();
stereo_buf[2].clear();
}
for ( unsigned i = 0; i < DacCtrlUsed; i++ )
{
device_reset_daccontrol( dac_control [i] );
DacCtrlTime[DacCtrlMap[i]] = 0;
}
for ( unsigned i = 0; i < PCM_BANK_COUNT; i++)
{
// reset PCM Bank, but not the data
// (this way I don't need to decompress the data again when restarting)
PCMBank [i].DataPos = 0;
PCMBank [i].BnkPos = 0;
}
PCMTbl.EntryCount = 0;
fm_time_offset = 0;
ay_time_offset = 0;
huc6280_time_offset = 0;
dac_control_recursion = 0;
}
inline Vgm_Core::fm_time_t Vgm_Core::to_fm_time( vgm_time_t t ) const
{
return (t * fm_time_factor + fm_time_offset) >> fm_time_bits;
}
inline blip_time_t Vgm_Core::to_psg_time( vgm_time_t t ) const
{
return (t * blip_time_factor) >> blip_time_bits;
}
inline blip_time_t Vgm_Core::to_ay_time( vgm_time_t t ) const
{
return (t * blip_ay_time_factor) >> blip_time_bits;
}
inline blip_time_t Vgm_Core::to_huc6280_time( vgm_time_t t ) const
{
return (t * blip_huc6280_time_factor) >> blip_time_bits;
}
void Vgm_Core::write_pcm( vgm_time_t vgm_time, int chip, int amp )
{
chip = !!chip;
if ( blip_buf[chip] )
{
check( amp >= 0 );
blip_time_t blip_time = to_psg_time( vgm_time );
int old = dac_amp[chip];
int delta = amp - old;
dac_amp[chip] = amp;
blip_buf[chip]->set_modified();
if ( old >= 0 ) // first write is ignored, to avoid click
pcm.offset_inline( blip_time, delta, blip_buf[chip] );
else
dac_amp[chip] |= dac_disabled[chip];
}
}
blip_time_t Vgm_Core::run( vgm_time_t end_time )
{
vgm_time_t vgm_time = this->vgm_time;
vgm_time_t vgm_loop_time = ~0;
int ChipID;
byte const* pos = this->pos;
if ( pos > file_end() )
set_warning( "Stream lacked end event" );
while ( vgm_time < end_time && pos < file_end() )
{
// TODO: be sure there are enough bytes left in stream for particular command
// so we don't read past end
switch ( *pos++ )
{
case cmd_end:
if ( vgm_loop_time == ~0 ) vgm_loop_time = vgm_time;
else if ( vgm_loop_time == vgm_time ) loop_begin = file_end(); // XXX some files may loop forever on a region without any delay commands
pos = loop_begin; // if not looped, loop_begin == file_end()
if ( pos != file_end() ) has_looped = true;
break;
case cmd_delay_735:
vgm_time += 735;
break;
case cmd_delay_882:
vgm_time += 882;
break;
case cmd_gg_stereo:
psg[0].write_ggstereo( to_psg_time( vgm_time ), *pos++ );
break;
case cmd_gg_stereo_2:
psg[1].write_ggstereo( to_psg_time( vgm_time ), *pos++ );
break;
case cmd_psg:
psg[0].write_data( to_psg_time( vgm_time ), *pos++ );
break;
case cmd_psg_2:
psg[1].write_data( to_psg_time( vgm_time ), *pos++ );
break;
case cmd_ay8910:
ChipID = !!(pos [0] & 0x80);
chip_reg_write( vgm_time, 0x12, ChipID, 0x00, pos [0] & 0x7F, pos [1] );
pos += 2;
break;
case cmd_delay:
vgm_time += pos [1] * 0x100 + pos [0];
pos += 2;
break;
case cmd_byte_delay:
vgm_time += *pos++;
break;
case cmd_segapcm_write:
if ( get_le32( header().segapcm_rate ) > 0 )
if ( run_segapcm( to_fm_time( vgm_time ) ) )
segapcm.write( get_le16( pos ), pos [2] );
pos += 3;
break;
case cmd_rf5c68:
if ( run_rf5c68( to_fm_time( vgm_time ) ) )
rf5c68.write( pos [0], pos [1] );
pos += 2;
break;
case cmd_rf5c68_mem:
if ( run_rf5c68( to_fm_time( vgm_time ) ) )
rf5c68.write_mem( get_le16( pos ), pos [2] );
pos += 3;
break;
case cmd_rf5c164:
if ( run_rf5c164( to_fm_time( vgm_time ) ) )
rf5c164.write( pos [0], pos [1] );
pos += 2;
break;
case cmd_rf5c164_mem:
if ( run_rf5c164( to_fm_time( vgm_time ) ) )
rf5c164.write_mem( get_le16( pos ), pos [2] );
pos += 3;
break;
case cmd_pwm:
chip_reg_write( vgm_time, 0x11, 0x00, pos [0] >> 4, pos [0] & 0x0F, pos [1] );
pos += 2;
break;
case cmd_c140:
if ( get_le32( header().c140_rate ) > 0 )
if ( run_c140( to_fm_time( vgm_time ) ) )
c140.write( get_be16( pos ), pos [2] );
pos += 3;
break;
case cmd_ym2151:
chip_reg_write( vgm_time, 0x03, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2151_2:
chip_reg_write( vgm_time, 0x03, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2203:
chip_reg_write( vgm_time, 0x06, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2203_2:
chip_reg_write( vgm_time, 0x06, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2413:
chip_reg_write( vgm_time, 0x01, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2413_2:
chip_reg_write( vgm_time, 0x01, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym3812:
chip_reg_write( vgm_time, 0x09, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym3812_2:
chip_reg_write( vgm_time, 0x09, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ymf262_port0:
chip_reg_write( vgm_time, 0x0C, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ymf262_2_port0:
chip_reg_write( vgm_time, 0x0C, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ymf262_port1:
chip_reg_write( vgm_time, 0x0C, 0x00, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ymf262_2_port1:
chip_reg_write( vgm_time, 0x0C, 0x01, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ymz280b:
chip_reg_write( vgm_time, 0x0F, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2612_port0:
chip_reg_write( vgm_time, 0x02, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2612_2_port0:
chip_reg_write( vgm_time, 0x02, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2612_port1:
chip_reg_write( vgm_time, 0x02, 0x00, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2612_2_port1:
chip_reg_write( vgm_time, 0x02, 0x01, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2610_port0:
chip_reg_write( vgm_time, 0x08, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2610_2_port0:
chip_reg_write( vgm_time, 0x08, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2610_port1:
chip_reg_write( vgm_time, 0x08, 0x00, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2610_2_port1:
chip_reg_write( vgm_time, 0x08, 0x01, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2608_port0:
chip_reg_write( vgm_time, 0x07, 0x00, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2608_2_port0:
chip_reg_write( vgm_time, 0x07, 0x01, 0x00, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2608_port1:
chip_reg_write( vgm_time, 0x07, 0x00, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2608_2_port1:
chip_reg_write( vgm_time, 0x07, 0x01, 0x01, pos [0], pos [1] );
pos += 2;
break;
case cmd_okim6258_write:
chip_reg_write( vgm_time, 0x17, ChipID, 0x00, pos [0] & 0x7F, pos [1] );
pos += 2;
break;
case cmd_okim6295_write:
ChipID = (pos [0] & 0x80) ? 1 : 0;
chip_reg_write( vgm_time, 0x18, ChipID, 0x00, pos [0] & 0x7F, pos [1] );
pos += 2;
break;
case cmd_huc6280_write:
ChipID = (pos [0] & 0x80) ? 1 : 0;
chip_reg_write( vgm_time, 0x1B, ChipID, 0x00, pos [0] & 0x7F, pos [1] );
pos += 2;
break;
case cmd_k051649_write:
chip_reg_write( vgm_time, 0x19, 0x00, pos [0] & 0x7F, pos [1], pos [2] );
pos += 3;
break;
case cmd_k053260_write:
chip_reg_write( vgm_time, 0x1D, 0x00, 0x00, pos [0] & 0x7F, pos [1] );
pos += 2;
break;
case cmd_k054539_write:
chip_reg_write( vgm_time, 0x1A, 0x00, pos [0] & 0x7F, pos [1], pos [2] );
pos += 3;
break;
case cmd_qsound_write:
chip_reg_write( vgm_time, 0x1F, 0x00, pos [0], pos [1], pos [2] );
pos += 3;
break;
case cmd_dacctl_setup:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF )
{
if ( ! DacCtrl [chip].Enable )
{
dac_control_grow( chip );
DacCtrl [chip].Enable = true;
}
daccontrol_setup_chip( dac_control [DacCtrlMap [chip]], pos [1] & 0x7F, ( pos [1] & 0x80 ) >> 7, get_be16( pos + 2 ) );
}
}
pos += 4;
break;
case cmd_dacctl_data:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF && DacCtrl [chip].Enable )
{
DacCtrl [chip].Bank = pos [1];
if ( DacCtrl [chip].Bank >= 0x40 )
DacCtrl [chip].Bank = 0x00;
VGM_PCM_BANK * TempPCM = &PCMBank [DacCtrl [chip].Bank];
daccontrol_set_data( dac_control [DacCtrlMap [chip]], TempPCM->Data, TempPCM->DataSize, pos [2], pos [3] );
}
}
pos += 4;
break;
case cmd_dacctl_freq:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF && DacCtrl [chip].Enable )
{
daccontrol_set_frequency( dac_control [DacCtrlMap [chip]], get_le32( pos + 1 ) );
}
}
pos += 5;
break;
case cmd_dacctl_play:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF && DacCtrl [chip].Enable && PCMBank [DacCtrl [chip].Bank].BankCount )
{
daccontrol_start( dac_control [DacCtrlMap [chip]], get_le32( pos + 1 ), pos [5], get_le32( pos + 6 ) );
}
}
pos += 10;
break;
case cmd_dacctl_stop:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF && DacCtrl [chip].Enable )
{
daccontrol_stop( dac_control [DacCtrlMap [chip]] );
}
else if ( chip == 0xFF )
{
for ( unsigned i = 0; i < DacCtrlUsed; i++ )
{
daccontrol_stop( dac_control [i] );
}
}
}
pos++;
break;
case cmd_dacctl_playblock:
if ( run_dac_control( vgm_time ) )
{
unsigned chip = pos [0];
if ( chip < 0xFF && DacCtrl [chip].Enable && PCMBank [DacCtrl [chip].Bank].BankCount )
{
VGM_PCM_BANK * TempPCM = &PCMBank [DacCtrl [chip].Bank];
unsigned block_number = get_le16( pos + 1 );
if ( block_number >= TempPCM->BankCount )
block_number = 0;
VGM_PCM_DATA * TempBnk = &TempPCM->Bank [block_number];
unsigned flags = DCTRL_LMODE_BYTES | ((pos [4] & 1) << 7);
daccontrol_start( dac_control [DacCtrlMap [chip]], TempBnk->DataStart, flags, TempBnk->DataSize );
}
}
pos += 4;
break;
case cmd_data_block: {
check( *pos == cmd_end );
int type = pos [1];
int size = get_le32( pos + 2 );
int chipid = 0;
if ( size & 0x80000000 )
{
size &= 0x7FFFFFFF;
chipid = 1;
}
pos += 6;
switch ( type & 0xC0 )
{
case pcm_block_type:
case pcm_aux_block_type:
AddPCMData( type, size, pos );
break;
case rom_block_type:
if ( size >= 8 )
{
int rom_size = get_le32( pos );
int data_start = get_le32( pos + 4 );
int data_size = size - 8;
void * rom_data = ( void * ) ( pos + 8 );
switch ( type )
{
case rom_segapcm:
if ( segapcm.enabled() )
segapcm.write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_ym2608_deltat:
if ( ym2608[chipid].enabled() )
{
ym2608[chipid].write_rom( 0x02, rom_size, data_start, data_size, rom_data );
}
break;
case rom_ym2610_adpcm:
case rom_ym2610_deltat:
if ( ym2610[chipid].enabled() )
{
int rom_id = 0x01 + ( type - rom_ym2610_adpcm );
ym2610[chipid].write_rom( rom_id, rom_size, data_start, data_size, rom_data );
}
break;
case rom_ymz280b:
if ( ymz280b.enabled() )
ymz280b.write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_okim6295:
if ( okim6295[chipid].enabled() )
okim6295[chipid].write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_k054539:
if ( k054539.enabled() )
k054539.write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_c140:
if ( c140.enabled() )
c140.write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_k053260:
if ( k053260.enabled() )
k053260.write_rom( rom_size, data_start, data_size, rom_data );
break;
case rom_qsound:
if ( qsound[chipid].enabled() )
qsound[chipid].write_rom( rom_size, data_start, data_size, rom_data );
break;
}
}
break;
case ram_block_type:
if ( size >= 2 )
{
int data_start = get_le16( pos );
int data_size = size - 2;
void * ram_data = ( void * ) ( pos + 2 );
switch ( type )
{
case ram_rf5c68:
if ( rf5c68.enabled() )
rf5c68.write_ram( data_start, data_size, ram_data );
break;
case ram_rf5c164:
if ( rf5c164.enabled() )
rf5c164.write_ram( data_start, data_size, ram_data );
break;
}
}
break;
}
pos += size;
break;
}
case cmd_ram_block: {
check( *pos == cmd_end );
int type = pos[ 1 ];
int data_start = get_le24( pos + 2 );
int data_addr = get_le24( pos + 5 );
int data_size = get_le24( pos + 8 );
if ( !data_size ) data_size += 0x01000000;
void * data_ptr = (void *) GetPointerFromPCMBank( type, data_start );
switch ( type )
{
case rf5c68_ram_block:
if ( rf5c68.enabled() )
rf5c68.write_ram( data_addr, data_size, data_ptr );
break;
case rf5c164_ram_block:
if ( rf5c164.enabled() )
rf5c164.write_ram( data_addr, data_size, data_ptr );
break;
}
pos += 11;
break;
}
case cmd_pcm_seek:
pcm_pos = GetPointerFromPCMBank( 0, get_le32( pos ) );
pos += 4;
break;
default:
int cmd = pos [-1];
switch ( cmd & 0xF0 )
{
case cmd_pcm_delay:
chip_reg_write( vgm_time, 0x02, 0x00, 0x00, ym2612_dac_port, *pcm_pos++ );
vgm_time += cmd & 0x0F;
break;
case cmd_short_delay:
vgm_time += (cmd & 0x0F) + 1;
break;
case 0x50:
pos += 2;
break;
default:
pos += command_len( cmd ) - 1;
set_warning( "Unknown stream event" );
}
}
}
vgm_time -= end_time;
this->pos = pos;
this->vgm_time = vgm_time;
return to_psg_time( end_time );
}
blip_time_t Vgm_Core::run_psg( int msec )
{
blip_time_t t = run( msec * vgm_rate / 1000 );
psg[0].end_frame( t );
psg[1].end_frame( t );
return t;
}
int Vgm_Core::play_frame( blip_time_t blip_time, int sample_count, blip_sample_t out [] )
{
// to do: timing is working mostly by luck
int min_pairs = (unsigned) sample_count / 2;
int vgm_time = (min_pairs << fm_time_bits) / fm_time_factor - 1;
assert( to_fm_time( vgm_time ) <= min_pairs );
int pairs;
while ( (pairs = to_fm_time( vgm_time )) < min_pairs )
vgm_time++;
//dprintf( "pairs: %d, min_pairs: %d\n", pairs, min_pairs );
memset( out, 0, pairs * stereo * sizeof *out );
if ( ymf262[0].enabled() )
{
ymf262[0].begin_frame( out );
if ( ymf262[1].enabled() )
{
ymf262[1].begin_frame( out );
}
}
if ( ym3812[0].enabled() )
{
ym3812[0].begin_frame( out );
if ( ym3812[1].enabled() )
{
ym3812[1].begin_frame( out );
}
}
if ( ym2612[0].enabled() )
{
ym2612[0].begin_frame( out );
if ( ym2612[1].enabled() )
{
ym2612[1].begin_frame( out );
}
}
if ( ym2610[0].enabled() )
{
ym2610[0].begin_frame( out );
if ( ym2610[1].enabled() )
{
ym2610[1].begin_frame( out );
}
}
if ( ym2608[0].enabled() )
{
ym2608[0].begin_frame( out );
if ( ym2608[1].enabled() )
{
ym2608[1].begin_frame( out );
}
}
if ( ym2413[0].enabled() )
{
ym2413[0].begin_frame( out );
if ( ym2413[1].enabled() )
{
ym2413[1].begin_frame( out );
}
}
if ( ym2203[0].enabled() )
{
ym2203[0].begin_frame( out );
if ( ym2203[1].enabled() )
{
ym2203[1].begin_frame( out );
}
}
if ( ym2151[0].enabled() )
{
ym2151[0].begin_frame( out );
if ( ym2151[1].enabled() )
{
ym2151[1].begin_frame( out );
}
}
if ( c140.enabled() )
{
c140.begin_frame( out );
}
if ( segapcm.enabled() )
{
segapcm.begin_frame( out );
}
if ( rf5c68.enabled() )
{
rf5c68.begin_frame( out );
}
if ( rf5c164.enabled() )
{
rf5c164.begin_frame( out );
}
if ( pwm.enabled() )
{
pwm.begin_frame( out );
}
if ( okim6258[0].enabled() )
{
okim6258[0].begin_frame( out );
if ( okim6258[1].enabled() )
{
okim6258[1].begin_frame( out );
}
}
if ( okim6295[0].enabled() )
{
okim6295[0].begin_frame( out );
if ( okim6295[1].enabled() )
{
okim6295[1].begin_frame( out );
}
}
if ( k051649.enabled() )
{
k051649.begin_frame( out );
}
if ( k053260.enabled() )
{
k053260.begin_frame( out );
}
if ( k054539.enabled() )
{
k054539.begin_frame( out );
}
if ( ymz280b.enabled() )
{
ymz280b.begin_frame( out );
}
if ( qsound[0].enabled() )
{
qsound[0].begin_frame( out );
if ( qsound[1].enabled() )
{
qsound[1].begin_frame( out );
}
}
run( vgm_time );
run_dac_control( vgm_time );
run_ymf262( 0, pairs ); run_ymf262( 1, pairs );
run_ym3812( 0, pairs ); run_ym3812( 1, pairs );
run_ym2612( 0, pairs ); run_ym2612( 1, pairs );
run_ym2610( 0, pairs ); run_ym2610( 1, pairs );
run_ym2608( 0, pairs ); run_ym2608( 1, pairs );
run_ym2413( 0, pairs ); run_ym2413( 1, pairs );
run_ym2203( 0, pairs ); run_ym2203( 1, pairs );
run_ym2151( 0, pairs ); run_ym2151( 1, pairs );
run_c140( pairs );
run_segapcm( pairs );
run_rf5c68( pairs );
run_rf5c164( pairs );
run_pwm( pairs );
run_okim6258( 0, pairs ); run_okim6258( 1, pairs );
run_okim6295( 0, pairs ); run_okim6295( 1, pairs );
run_k051649( pairs );
run_k053260( pairs );
run_k054539( pairs );
run_ymz280b( pairs );
run_qsound( 0, pairs ); run_qsound( 1, pairs );
fm_time_offset = (vgm_time * fm_time_factor + fm_time_offset) - (pairs << fm_time_bits);
psg[0].end_frame( blip_time );
psg[1].end_frame( blip_time );
ay_time_offset = (vgm_time * blip_ay_time_factor + ay_time_offset) - (pairs << blip_time_bits);
blip_time_t ay_end_time = to_ay_time( vgm_time );
ay[0].end_frame( ay_end_time );
ay[1].end_frame( ay_end_time );
huc6280_time_offset = (vgm_time * blip_huc6280_time_factor + huc6280_time_offset) - (pairs << blip_time_bits);
blip_time_t huc6280_end_time = to_huc6280_time( vgm_time );
huc6280[0].end_frame( huc6280_end_time );
huc6280[1].end_frame( huc6280_end_time );
memset( DacCtrlTime, 0, sizeof(DacCtrlTime) );
return pairs * stereo;
}
Reference in New Issue View Git Blame Copy Permalink