Page MenuHomePhabricator (Chris)
Files F134457

No OneTemporary
Actions

Authored By
Unknown
Size
781 KB
Referenced Files
None
Subscribers
None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
This document is not UTF8. It was detected as JIS and converted to UTF8 for display.
diff --git a/src/libs/gme/Ay_Apu.cpp b/src/libs/gme/Ay_Apu.cpp
index 8204abf2..d132c42f 100644
--- a/src/libs/gme/Ay_Apu.cpp
+++ b/src/libs/gme/Ay_Apu.cpp
@@ -1,395 +1,395 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Ay_Apu.h"
/* Copyright (C) 2006 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"
// Emulation inaccuracies:
// * Noise isn't run when not in use
// * Changes to envelope and noise periods are delayed until next reload
// * Super-sonic tone should attenuate output to about 60%, not 50%
// Tones above this frequency are treated as disabled tone at half volume.
// Power of two is more efficient (avoids division).
unsigned const inaudible_freq = 16384;
int const period_factor = 16;
static byte const amp_table [16] =
{
#define ENTRY( n ) byte (n * Ay_Apu::amp_range + 0.5)
// With channels tied together and 1K resistor to ground (as datasheet recommends),
// output nearly matches logarithmic curve as claimed. Approx. 1.5 dB per step.
ENTRY(0.000000),ENTRY(0.007813),ENTRY(0.011049),ENTRY(0.015625),
ENTRY(0.022097),ENTRY(0.031250),ENTRY(0.044194),ENTRY(0.062500),
ENTRY(0.088388),ENTRY(0.125000),ENTRY(0.176777),ENTRY(0.250000),
ENTRY(0.353553),ENTRY(0.500000),ENTRY(0.707107),ENTRY(1.000000),
/*
// Measured from an AY-3-8910A chip with date code 8611.
// Direct voltages without any load (very linear)
ENTRY(0.000000),ENTRY(0.046237),ENTRY(0.064516),ENTRY(0.089785),
ENTRY(0.124731),ENTRY(0.173118),ENTRY(0.225806),ENTRY(0.329032),
ENTRY(0.360215),ENTRY(0.494624),ENTRY(0.594624),ENTRY(0.672043),
ENTRY(0.766129),ENTRY(0.841935),ENTRY(0.926882),ENTRY(1.000000),
// With only some load
ENTRY(0.000000),ENTRY(0.011940),ENTRY(0.017413),ENTRY(0.024876),
ENTRY(0.036318),ENTRY(0.054229),ENTRY(0.072637),ENTRY(0.122388),
ENTRY(0.174129),ENTRY(0.239303),ENTRY(0.323881),ENTRY(0.410945),
ENTRY(0.527363),ENTRY(0.651741),ENTRY(0.832338),ENTRY(1.000000),
*/
#undef ENTRY
};
static byte const modes [8] =
{
#define MODE( a0,a1, b0,b1, c0,c1 ) \
(a0 | a1<<1 | b0<<2 | b1<<3 | c0<<4 | c1<<5)
MODE( 1,0, 1,0, 1,0 ),
MODE( 1,0, 0,0, 0,0 ),
MODE( 1,0, 0,1, 1,0 ),
MODE( 1,0, 1,1, 1,1 ),
MODE( 0,1, 0,1, 0,1 ),
MODE( 0,1, 1,1, 1,1 ),
MODE( 0,1, 1,0, 0,1 ),
MODE( 0,1, 0,0, 0,0 ),
};
Ay_Apu::Ay_Apu()
{
// build full table of the upper 8 envelope waveforms
for ( int m = 8; m--; )
{
byte* out = env.modes [m];
int flags = modes [m];
for ( int x = 3; --x >= 0; )
{
int amp = flags & 1;
int end = flags >> 1 & 1;
int step = end - amp;
amp *= 15;
for ( int y = 16; --y >= 0; )
{
*out++ = amp_table [amp];
amp += step;
}
flags >>= 2;
}
}
output( 0 );
volume( 1.0 );
reset();
}
void Ay_Apu::reset()
{
last_time = 0;
noise.delay = 0;
noise.lfsr = 1;
osc_t* osc = &oscs [osc_count];
do
{
osc--;
osc->period = period_factor;
osc->delay = 0;
osc->last_amp = 0;
osc->phase = 0;
}
while ( osc != oscs );
for ( int i = sizeof regs; --i >= 0; )
regs [i] = 0;
regs [7] = 0xFF;
write_data_( 13, 0 );
}
void Ay_Apu::write_data_( int addr, int data )
{
assert( (unsigned) addr < reg_count );
if ( (unsigned) addr >= 14 )
{
#ifdef debug_printf
debug_printf( "Wrote to I/O port %02X\n", (int) addr );
#endif
}
// envelope mode
if ( addr == 13 )
{
if ( !(data & 8) ) // convert modes 0-7 to proper equivalents
data = (data & 4) ? 15 : 9;
env.wave = env.modes [data - 7];
env.pos = -48;
env.delay = 0; // will get set to envelope period in run_until()
}
regs [addr] = data;
// handle period changes accurately
int i = addr >> 1;
if ( i < osc_count )
{
blip_time_t period = (regs [i * 2 + 1] & 0x0F) * (0x100L * period_factor) +
regs [i * 2] * period_factor;
if ( !period )
period = period_factor;
// adjust time of next timer expiration based on change in period
osc_t& osc = oscs [i];
if ( (osc.delay += period - osc.period) < 0 )
osc.delay = 0;
osc.period = period;
}
// TODO: same as above for envelope timer, and it also has a divide by two after it
}
int const noise_off = 0x08;
int const tone_off = 0x01;
void Ay_Apu::run_until( blip_time_t final_end_time )
{
require( final_end_time >= last_time );
// noise period and initial values
blip_time_t const noise_period_factor = period_factor * 2; // verified
blip_time_t noise_period = (regs [6] & 0x1F) * noise_period_factor;
if ( !noise_period )
noise_period = noise_period_factor;
blip_time_t const old_noise_delay = noise.delay;
blargg_ulong const old_noise_lfsr = noise.lfsr;
// envelope period
blip_time_t const env_period_factor = period_factor * 2; // verified
blip_time_t env_period = (regs [12] * 0x100L + regs [11]) * env_period_factor;
if ( !env_period )
env_period = env_period_factor; // same as period 1 on my AY chip
if ( !env.delay )
env.delay = env_period;
// run each osc separately
for ( int index = 0; index < osc_count; index++ )
{
osc_t* const osc = &oscs [index];
int osc_mode = regs [7] >> index;
// output
Blip_Buffer* const osc_output = osc->output;
if ( !osc_output )
continue;
osc_output->set_modified();
// period
int half_vol = 0;
blip_time_t inaudible_period = (blargg_ulong) (osc_output->clock_rate() +
inaudible_freq) / (inaudible_freq * 2);
if ( osc->period <= inaudible_period && !(osc_mode & tone_off) )
{
half_vol = 1; // Actually around 60%, but 50% is close enough
osc_mode |= tone_off;
}
// envelope
blip_time_t start_time = last_time;
blip_time_t end_time = final_end_time;
int const vol_mode = regs [0x08 + index];
int volume = amp_table [vol_mode & 0x0F] >> half_vol;
int osc_env_pos = env.pos;
if ( vol_mode & 0x10 )
{
volume = env.wave [osc_env_pos] >> half_vol;
// use envelope only if it's a repeating wave or a ramp that hasn't finished
if ( !(regs [13] & 1) || osc_env_pos < -32 )
{
end_time = start_time + env.delay;
if ( end_time >= final_end_time )
end_time = final_end_time;
//if ( !(regs [12] | regs [11]) )
// debug_printf( "Used envelope period 0\n" );
}
else if ( !volume )
{
osc_mode = noise_off | tone_off;
}
}
else if ( !volume )
{
osc_mode = noise_off | tone_off;
}
// tone time
blip_time_t const period = osc->period;
blip_time_t time = start_time + osc->delay;
if ( osc_mode & tone_off ) // maintain tone's phase when off
{
blargg_long count = (final_end_time - time + period - 1) / period;
time += count * period;
osc->phase ^= count & 1;
}
// noise time
blip_time_t ntime = final_end_time;
blargg_ulong noise_lfsr = 1;
if ( !(osc_mode & noise_off) )
{
ntime = start_time + old_noise_delay;
noise_lfsr = old_noise_lfsr;
//if ( (regs [6] & 0x1F) == 0 )
// debug_printf( "Used noise period 0\n" );
}
// The following efficiently handles several cases (least demanding first):
// * Tone, noise, and envelope disabled, where channel acts as 4-bit DAC
// * Just tone or just noise, envelope disabled
// * Envelope controlling tone and/or noise
// * Tone and noise disabled, envelope enabled with high frequency
// * Tone and noise together
// * Tone and noise together with envelope
// This loop only runs one iteration if envelope is disabled. If envelope
// is being used as a waveform (tone and noise disabled), this loop will
// still be reasonably efficient since the bulk of it will be skipped.
while ( 1 )
{
// current amplitude
int amp = 0;
if ( (osc_mode | osc->phase) & 1 & (osc_mode >> 3 | noise_lfsr) )
amp = volume;
{
int delta = amp - osc->last_amp;
if ( delta )
{
osc->last_amp = amp;
synth_.offset( start_time, delta, osc_output );
}
}
// Run wave and noise interleved with each catching up to the other.
// If one or both are disabled, their "current time" will be past end time,
// so there will be no significant performance hit.
if ( ntime < end_time || time < end_time )
{
// Since amplitude was updated above, delta will always be +/- volume,
// so we can avoid using last_amp every time to calculate the delta.
int delta = amp * 2 - volume;
int delta_non_zero = delta != 0;
int phase = osc->phase | (osc_mode & tone_off); assert( tone_off == 0x01 );
do
{
// run noise
blip_time_t end = end_time;
if ( end_time > time ) end = time;
if ( phase & delta_non_zero )
{
while ( ntime <= end ) // must advance *past* time to avoid hang
{
int changed = noise_lfsr + 1;
noise_lfsr = (-(noise_lfsr & 1) & 0x12000) ^ (noise_lfsr >> 1);
if ( changed & 2 )
{
delta = -delta;
synth_.offset( ntime, delta, osc_output );
}
ntime += noise_period;
}
}
else
{
// 20 or more noise periods on average for some music
blargg_long remain = end - ntime;
blargg_long count = remain / noise_period;
if ( remain >= 0 )
ntime += noise_period + count * noise_period;
}
// run tone
end = end_time;
if ( end_time > ntime ) end = ntime;
if ( noise_lfsr & delta_non_zero )
{
while ( time < end )
{
delta = -delta;
synth_.offset( time, delta, osc_output );
time += period;
//phase ^= 1;
}
//assert( phase == (delta > 0) );
phase = unsigned (-delta) >> (CHAR_BIT * sizeof (unsigned) - 1);
// (delta > 0)
}
else
{
// loop usually runs less than once
//SUB_CASE_COUNTER( (time < end) * (end - time + period - 1) / period );
while ( time < end )
{
time += period;
phase ^= 1;
}
}
}
while ( time < end_time || ntime < end_time );
osc->last_amp = (delta + volume) >> 1;
if ( !(osc_mode & tone_off) )
osc->phase = phase;
}
if ( end_time >= final_end_time )
break; // breaks first time when envelope is disabled
// next envelope step
if ( ++osc_env_pos >= 0 )
osc_env_pos -= 32;
volume = env.wave [osc_env_pos] >> half_vol;
start_time = end_time;
end_time += env_period;
if ( end_time > final_end_time )
end_time = final_end_time;
}
osc->delay = time - final_end_time;
if ( !(osc_mode & noise_off) )
{
noise.delay = ntime - final_end_time;
noise.lfsr = noise_lfsr;
}
}
// TODO: optimized saw wave envelope?
// maintain envelope phase
blip_time_t remain = final_end_time - last_time - env.delay;
if ( remain >= 0 )
{
blargg_long count = (remain + env_period) / env_period;
env.pos += count;
if ( env.pos >= 0 )
env.pos = (env.pos & 31) - 32;
remain -= count * env_period;
assert( -remain <= env_period );
}
env.delay = -remain;
assert( env.delay > 0 );
assert( env.pos < 0 );
last_time = final_end_time;
}
diff --git a/src/libs/gme/Ay_Apu.h b/src/libs/gme/Ay_Apu.h
index 42395e37..ad2d8369 100644
--- a/src/libs/gme/Ay_Apu.h
+++ b/src/libs/gme/Ay_Apu.h
@@ -1,107 +1,106 @@
// AY-3-8910 sound chip emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef AY_APU_H
#define AY_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
class Ay_Apu {
public:
// Set buffer to generate all sound into, or disable sound if NULL
void output( Blip_Buffer* );
// Reset sound chip
void reset();
// Write to register at specified time
enum { reg_count = 16 };
void write( blip_time_t time, int addr, int data );
// Run sound to specified time, end current time frame, then start a new
// time frame at time 0. Time frames have no effect on emulation and each
// can be whatever length is convenient.
void end_frame( blip_time_t length );
// Additional features
// Set sound output of specific oscillator to buffer, where index is
// 0, 1, or 2. If buffer is NULL, the specified oscillator is muted.
enum { osc_count = 3 };
void osc_output( int index, Blip_Buffer* );
// Set overall volume (default is 1.0)
void volume( double );
// Set treble equalization (see documentation)
void treble_eq( blip_eq_t const& );
public:
Ay_Apu();
typedef unsigned char byte;
private:
struct osc_t
{
blip_time_t period;
blip_time_t delay;
short last_amp;
short phase;
Blip_Buffer* output;
} oscs [osc_count];
blip_time_t last_time;
- byte latch;
byte regs [reg_count];
struct {
blip_time_t delay;
blargg_ulong lfsr;
} noise;
struct {
blip_time_t delay;
byte const* wave;
int pos;
byte modes [8] [48]; // values already passed through volume table
} env;
void run_until( blip_time_t );
void write_data_( int addr, int data );
public:
enum { amp_range = 255 };
Blip_Synth<blip_good_quality,1> synth_;
};
inline void Ay_Apu::volume( double v ) { synth_.volume( 0.7 / osc_count / amp_range * v ); }
inline void Ay_Apu::treble_eq( blip_eq_t const& eq ) { synth_.treble_eq( eq ); }
inline void Ay_Apu::write( blip_time_t time, int addr, int data )
{
run_until( time );
write_data_( addr, data );
}
inline void Ay_Apu::osc_output( int i, Blip_Buffer* buf )
{
assert( (unsigned) i < osc_count );
oscs [i].output = buf;
}
inline void Ay_Apu::output( Blip_Buffer* buf )
{
osc_output( 0, buf );
osc_output( 1, buf );
osc_output( 2, buf );
}
inline void Ay_Apu::end_frame( blip_time_t time )
{
if ( time > last_time )
run_until( time );
assert( last_time >= time );
last_time -= time;
}
#endif
diff --git a/src/libs/gme/Ay_Cpu.cpp b/src/libs/gme/Ay_Cpu.cpp
index c11dd437..31c91256 100644
--- a/src/libs/gme/Ay_Cpu.cpp
+++ b/src/libs/gme/Ay_Cpu.cpp
@@ -1,1666 +1,1659 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
/*
Last validated with zexall 2006.11.21 5:26 PM
* Doesn't implement the R register or immediate interrupt after EI.
* Address wrap-around isn't completely correct, but is prevented from crashing emulator.
*/
#include "Ay_Cpu.h"
#include "blargg_endian.h"
#include <string.h>
//#include "z80_cpu_log.h"
/* Copyright (C) 2006 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 */
#define SYNC_TIME() (void) (s.time = s_time)
#define RELOAD_TIME() (void) (s_time = s.time)
// Callbacks to emulator
#define CPU_OUT( cpu, addr, data, TIME )\
ay_cpu_out( cpu, TIME, addr, data )
#define CPU_IN( cpu, addr, TIME )\
ay_cpu_in( cpu, addr )
#include "blargg_source.h"
// flags, named with hex value for clarity
int const S80 = 0x80;
int const Z40 = 0x40;
int const F20 = 0x20;
int const H10 = 0x10;
int const F08 = 0x08;
int const V04 = 0x04;
int const P04 = 0x04;
int const N02 = 0x02;
int const C01 = 0x01;
#define SZ28P( n ) szpc [n]
#define SZ28PC( n ) szpc [n]
#define SZ28C( n ) (szpc [n] & ~P04)
#define SZ28( n ) SZ28C( n )
#define SET_R( n ) (void) (r.r = n)
#define GET_R() (r.r)
Ay_Cpu::Ay_Cpu()
{
state = &state_;
for ( int i = 0x100; --i >= 0; )
{
int even = 1;
for ( int p = i; p; p >>= 1 )
even ^= p;
int n = (i & (S80 | F20 | F08)) | ((even & 1) * P04);
szpc [i] = n;
szpc [i + 0x100] = n | C01;
}
szpc [0x000] |= Z40;
szpc [0x100] |= Z40;
}
void Ay_Cpu::reset( void* m )
{
mem = (uint8_t*) m;
check( state == &state_ );
state = &state_;
state_.time = 0;
state_.base = 0;
end_time_ = 0;
memset( &r, 0, sizeof r );
}
#define TIME (s_time + s.base)
#define READ_PROG( addr ) (mem [addr])
#define INSTR( offset ) READ_PROG( pc + (offset) )
#define GET_ADDR() GET_LE16( &READ_PROG( pc ) )
#define READ( addr ) READ_PROG( addr )
#define WRITE( addr, data ) (void) (READ_PROG( addr ) = data)
#define READ_WORD( addr ) GET_LE16( &READ_PROG( addr ) )
#define WRITE_WORD( addr, data ) SET_LE16( &READ_PROG( addr ), data )
#define IN( addr ) CPU_IN( this, addr, TIME )
#define OUT( addr, data ) CPU_OUT( this, addr, data, TIME )
#if BLARGG_BIG_ENDIAN
#define R8( n, offset ) ((r8_ - offset) [n])
#elif BLARGG_LITTLE_ENDIAN
#define R8( n, offset ) ((r8_ - offset) [(n) ^ 1])
#else
#error "Byte order of CPU must be known"
#endif
//#define R16( n, shift, offset ) (r16_ [((n) >> shift) - (offset >> shift)])
// help compiler see that it can just adjust stack offset, saving an extra instruction
#define R16( n, shift, offset )\
(*(uint16_t*) ((char*) r16_ - (offset >> (shift - 1)) + ((n) >> (shift - 1))))
#define CASE5( a, b, c, d, e ) case 0x##a:case 0x##b:case 0x##c:case 0x##d:case 0x##e
#define CASE6( a, b, c, d, e, f ) CASE5( a, b, c, d, e ): case 0x##f
#define CASE7( a, b, c, d, e, f, g ) CASE6( a, b, c, d, e, f ): case 0x##g
#define CASE8( a, b, c, d, e, f, g, h ) CASE7( a, b, c, d, e, f, g ): case 0x##h
// high four bits are $ED time - 8, low four bits are $DD/$FD time - 8
static byte const ed_dd_timing [0x100] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x06,0x0C,0x02,0x00,0x00,0x03,0x00,0x00,0x07,0x0C,0x02,0x00,0x00,0x03,0x00,
0x00,0x00,0x00,0x00,0x0F,0x0F,0x0B,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0xA0,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0xA0,
0x4B,0x4B,0x7B,0xCB,0x0B,0x6B,0x00,0x0B,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,
0x80,0x80,0x80,0x80,0x00,0x00,0x0B,0x00,0x80,0x80,0x80,0x80,0x00,0x00,0x0B,0x00,
0xD0,0xD0,0xD0,0xD0,0x00,0x00,0x0B,0x00,0xD0,0xD0,0xD0,0xD0,0x00,0x00,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x06,0x00,0x0F,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,
};
-// even on x86, using short and unsigned char was slower
-typedef int fint16;
-typedef unsigned fuint16;
-typedef unsigned fuint8;
-
bool Ay_Cpu::run( cpu_time_t end_time )
{
set_end_time( end_time );
state_t s = this->state_;
this->state = &s;
bool warning = false;
- typedef BOOST::int8_t int8_t;
-
union {
regs_t rg;
pairs_t rp;
uint8_t r8_ [8]; // indexed
uint16_t r16_ [4];
};
rg = this->r.b;
cpu_time_t s_time = s.time;
uint8_t* const mem = this->mem; // cache
- fuint16 pc = r.pc;
- fuint16 sp = r.sp;
- fuint16 ix = r.ix; // TODO: keep in memory for direct access?
- fuint16 iy = r.iy;
+ uint16_t pc = r.pc;
+ uint16_t sp = r.sp;
+ uint16_t ix = r.ix; // TODO: keep in memory for direct access?
+ uint16_t iy = r.iy;
int flags = r.b.flags;
goto loop;
jr_not_taken:
s_time -= 5;
goto loop;
call_not_taken:
s_time -= 7;
jp_not_taken:
pc += 2;
loop:
check( (unsigned long) pc < 0x10000 );
check( (unsigned long) sp < 0x10000 );
check( (unsigned) flags < 0x100 );
check( (unsigned) ix < 0x10000 );
check( (unsigned) iy < 0x10000 );
- fuint8 opcode;
+ uint8_t opcode;
opcode = READ_PROG( pc );
pc++;
static byte const base_timing [0x100] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
4,10, 7, 6, 4, 4, 7, 4, 4,11, 7, 6, 4, 4, 7, 4, // 0
13,10, 7, 6, 4, 4, 7, 4,12,11, 7, 6, 4, 4, 7, 4, // 1
12,10,16, 6, 4, 4, 7, 4,12,11,16, 6, 4, 4, 7, 4, // 2
12,10,13, 6,11,11,10, 4,12,11,13, 6, 4, 4, 7, 4, // 3
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 4
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 5
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 6
7, 7, 7, 7, 7, 7, 4, 7, 4, 4, 4, 4, 4, 4, 7, 4, // 7
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 8
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 9
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // A
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // B
11,10,10,10,17,11, 7,11,11,10,10, 8,17,17, 7,11, // C
11,10,10,11,17,11, 7,11,11, 4,10,11,17, 8, 7,11, // D
11,10,10,19,17,11, 7,11,11, 4,10, 4,17, 8, 7,11, // E
11,10,10, 4,17,11, 7,11,11, 6,10, 4,17, 8, 7,11, // F
};
- fuint16 data;
+ uint16_t data;
data = base_timing [opcode];
if ( (s_time += data) >= 0 )
goto possibly_out_of_time;
almost_out_of_time:
data = READ_PROG( pc );
#ifdef Z80_CPU_LOG_H
//log_opcode( opcode, READ_PROG( pc ) );
z80_log_regs( rg.a, rp.bc, rp.de, rp.hl, sp, ix, iy );
z80_cpu_log( "new", pc - 1, opcode, READ_PROG( pc ),
READ_PROG( pc + 1 ), READ_PROG( pc + 2 ) );
#endif
switch ( opcode )
{
possibly_out_of_time:
if ( s_time < (int) data )
goto almost_out_of_time;
s_time -= data;
goto out_of_time;
// Common
case 0x00: // NOP
CASE7( 40, 49, 52, 5B, 64, 6D, 7F ): // LD B,B etc.
goto loop;
case 0x08:{// EX AF,AF'
int temp = r.alt.b.a;
r.alt.b.a = rg.a;
rg.a = temp;
temp = r.alt.b.flags;
r.alt.b.flags = flags;
flags = temp;
goto loop;
}
case 0xD3: // OUT (imm),A
pc++;
OUT( data + rg.a * 0x100, rg.a );
goto loop;
case 0x2E: // LD L,imm
pc++;
rg.l = data;
goto loop;
case 0x3E: // LD A,imm
pc++;
rg.a = data;
goto loop;
case 0x3A:{// LD A,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
rg.a = READ( addr );
goto loop;
}
// Conditional
#define ZERO (flags & Z40)
#define CARRY (flags & C01)
#define EVEN (flags & P04)
#define MINUS (flags & S80)
// JR
#define JR( cond ) {\
- int disp = (BOOST::int8_t) data;\
+ int disp = (int8_t) data;\
pc++;\
if ( !(cond) )\
goto jr_not_taken;\
pc += disp;\
goto loop;\
}
case 0x20: JR( !ZERO ) // JR NZ,disp
case 0x28: JR( ZERO ) // JR Z,disp
case 0x30: JR( !CARRY ) // JR NC,disp
case 0x38: JR( CARRY ) // JR C,disp
case 0x18: JR( true ) // JR disp
case 0x10:{// DJNZ disp
int temp = rg.b - 1;
rg.b = temp;
JR( temp )
}
// JP
#define JP( cond ) if ( !(cond) ) goto jp_not_taken; pc = GET_ADDR(); goto loop;
case 0xC2: JP( !ZERO ) // JP NZ,addr
case 0xCA: JP( ZERO ) // JP Z,addr
case 0xD2: JP( !CARRY ) // JP NC,addr
case 0xDA: JP( CARRY ) // JP C,addr
case 0xE2: JP( !EVEN ) // JP PO,addr
case 0xEA: JP( EVEN ) // JP PE,addr
case 0xF2: JP( !MINUS ) // JP P,addr
case 0xFA: JP( MINUS ) // JP M,addr
case 0xC3: // JP addr
pc = GET_ADDR();
goto loop;
case 0xE9: // JP HL
pc = rp.hl;
goto loop;
// RET
#define RET( cond ) if ( cond ) goto ret_taken; s_time -= 6; goto loop;
case 0xC0: RET( !ZERO ) // RET NZ
case 0xC8: RET( ZERO ) // RET Z
case 0xD0: RET( !CARRY ) // RET NC
case 0xD8: RET( CARRY ) // RET C
case 0xE0: RET( !EVEN ) // RET PO
case 0xE8: RET( EVEN ) // RET PE
case 0xF0: RET( !MINUS ) // RET P
case 0xF8: RET( MINUS ) // RET M
case 0xC9: // RET
ret_taken:
pc = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto loop;
// CALL
#define CALL( cond ) if ( cond ) goto call_taken; goto call_not_taken;
case 0xC4: CALL( !ZERO ) // CALL NZ,addr
case 0xCC: CALL( ZERO ) // CALL Z,addr
case 0xD4: CALL( !CARRY ) // CALL NC,addr
case 0xDC: CALL( CARRY ) // CALL C,addr
case 0xE4: CALL( !EVEN ) // CALL PO,addr
case 0xEC: CALL( EVEN ) // CALL PE,addr
case 0xF4: CALL( !MINUS ) // CALL P,addr
case 0xFC: CALL( MINUS ) // CALL M,addr
case 0xCD:{// CALL addr
call_taken:
- fuint16 addr = pc + 2;
+ uint16_t addr = pc + 2;
pc = GET_ADDR();
sp = uint16_t (sp - 2);
WRITE_WORD( sp, addr );
goto loop;
}
case 0xFF: // RST
if ( (pc - 1) > 0xFFFF )
{
pc = uint16_t (pc - 1);
s_time -= 11;
goto loop;
}
CASE7( C7, CF, D7, DF, E7, EF, F7 ):
data = pc;
pc = opcode & 0x38;
goto push_data;
// PUSH/POP
case 0xF5: // PUSH AF
data = rg.a * 0x100u + flags;
goto push_data;
case 0xC5: // PUSH BC
case 0xD5: // PUSH DE
case 0xE5: // PUSH HL
data = R16( opcode, 4, 0xC5 );
push_data:
sp = uint16_t (sp - 2);
WRITE_WORD( sp, data );
goto loop;
case 0xF1: // POP AF
flags = READ( sp );
rg.a = READ( sp + 1 );
sp = uint16_t (sp + 2);
goto loop;
case 0xC1: // POP BC
case 0xD1: // POP DE
case 0xE1: // POP HL
R16( opcode, 4, 0xC1 ) = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto loop;
// ADC/ADD/SBC/SUB
case 0x96: // SUB (HL)
case 0x86: // ADD (HL)
flags &= ~C01;
case 0x9E: // SBC (HL)
case 0x8E: // ADC (HL)
data = READ( rp.hl );
goto adc_data;
case 0xD6: // SUB A,imm
case 0xC6: // ADD imm
flags &= ~C01;
case 0xDE: // SBC A,imm
case 0xCE: // ADC imm
pc++;
goto adc_data;
CASE7( 90, 91, 92, 93, 94, 95, 97 ): // SUB r
CASE7( 80, 81, 82, 83, 84, 85, 87 ): // ADD r
flags &= ~C01;
CASE7( 98, 99, 9A, 9B, 9C, 9D, 9F ): // SBC r
CASE7( 88, 89, 8A, 8B, 8C, 8D, 8F ): // ADC r
data = R8( opcode & 7, 0 );
adc_data: {
int result = data + (flags & C01);
data ^= rg.a;
flags = opcode >> 3 & N02; // bit 4 is set in subtract opcodes
if ( flags )
result = -result;
result += rg.a;
data ^= result;
flags |=(data & H10) |
((data - -0x80) >> 6 & V04) |
SZ28C( result & 0x1FF );
rg.a = result;
goto loop;
}
// CP
case 0xBE: // CP (HL)
data = READ( rp.hl );
goto cp_data;
case 0xFE: // CP imm
pc++;
goto cp_data;
CASE7( B8, B9, BA, BB, BC, BD, BF ): // CP r
data = R8( opcode, 0xB8 );
cp_data: {
int result = rg.a - data;
flags = N02 | (data & (F20 | F08)) | (result >> 8 & C01);
data ^= rg.a;
flags |=(((result ^ rg.a) & data) >> 5 & V04) |
(((data & H10) ^ result) & (S80 | H10));
if ( (uint8_t) result )
goto loop;
flags |= Z40;
goto loop;
}
// ADD HL,rp
case 0x39: // ADD HL,SP
data = sp;
goto add_hl_data;
case 0x09: // ADD HL,BC
case 0x19: // ADD HL,DE
case 0x29: // ADD HL,HL
data = R16( opcode, 4, 0x09 );
add_hl_data: {
blargg_ulong sum = rp.hl + data;
data ^= rp.hl;
rp.hl = sum;
flags = (flags & (S80 | Z40 | V04)) |
(sum >> 16) |
(sum >> 8 & (F20 | F08)) |
((data ^ sum) >> 8 & H10);
goto loop;
}
case 0x27:{// DAA
int a = rg.a;
if ( a > 0x99 )
flags |= C01;
int adjust = 0x60 & -(flags & C01);
if ( flags & H10 || (a & 0x0F) > 9 )
adjust |= 0x06;
if ( flags & N02 )
adjust = -adjust;
a += adjust;
flags = (flags & (C01 | N02)) |
((rg.a ^ a) & H10) |
SZ28P( (uint8_t) a );
rg.a = a;
goto loop;
}
/*
case 0x27:{// DAA
// more optimized, but probably not worth the obscurity
int f = (rg.a + (0xFF - 0x99)) >> 8 | flags; // (a > 0x99 ? C01 : 0) | flags
int adjust = 0x60 & -(f & C01); // f & C01 ? 0x60 : 0
if ( (((rg.a + (0x0F - 9)) ^ rg.a) | f) & H10 ) // flags & H10 || (rg.a & 0x0F) > 9
adjust |= 0x06;
if ( f & N02 )
adjust = -adjust;
int a = rg.a + adjust;
flags = (f & (N02 | C01)) | ((rg.a ^ a) & H10) | SZ28P( (uint8_t) a );
rg.a = a;
goto loop;
}
*/
// INC/DEC
case 0x34: // INC (HL)
data = READ( rp.hl ) + 1;
WRITE( rp.hl, data );
goto inc_set_flags;
CASE7( 04, 0C, 14, 1C, 24, 2C, 3C ): // INC r
data = ++R8( opcode >> 3, 0 );
inc_set_flags:
flags = (flags & C01) |
(((data & 0x0F) - 1) & H10) |
SZ28( (uint8_t) data );
if ( data != 0x80 )
goto loop;
flags |= V04;
goto loop;
case 0x35: // DEC (HL)
data = READ( rp.hl ) - 1;
WRITE( rp.hl, data );
goto dec_set_flags;
CASE7( 05, 0D, 15, 1D, 25, 2D, 3D ): // DEC r
data = --R8( opcode >> 3, 0 );
dec_set_flags:
flags = (flags & C01) | N02 |
(((data & 0x0F) + 1) & H10) |
SZ28( (uint8_t) data );
if ( data != 0x7F )
goto loop;
flags |= V04;
goto loop;
case 0x03: // INC BC
case 0x13: // INC DE
case 0x23: // INC HL
R16( opcode, 4, 0x03 )++;
goto loop;
case 0x33: // INC SP
sp = uint16_t (sp + 1);
goto loop;
case 0x0B: // DEC BC
case 0x1B: // DEC DE
case 0x2B: // DEC HL
R16( opcode, 4, 0x0B )--;
goto loop;
case 0x3B: // DEC SP
sp = uint16_t (sp - 1);
goto loop;
// AND
case 0xA6: // AND (HL)
data = READ( rp.hl );
goto and_data;
case 0xE6: // AND imm
pc++;
goto and_data;
CASE7( A0, A1, A2, A3, A4, A5, A7 ): // AND r
data = R8( opcode, 0xA0 );
and_data:
rg.a &= data;
flags = SZ28P( rg.a ) | H10;
goto loop;
// OR
case 0xB6: // OR (HL)
data = READ( rp.hl );
goto or_data;
case 0xF6: // OR imm
pc++;
goto or_data;
CASE7( B0, B1, B2, B3, B4, B5, B7 ): // OR r
data = R8( opcode, 0xB0 );
or_data:
rg.a |= data;
flags = SZ28P( rg.a );
goto loop;
// XOR
case 0xAE: // XOR (HL)
data = READ( rp.hl );
goto xor_data;
case 0xEE: // XOR imm
pc++;
goto xor_data;
CASE7( A8, A9, AA, AB, AC, AD, AF ): // XOR r
data = R8( opcode, 0xA8 );
xor_data:
rg.a ^= data;
flags = SZ28P( rg.a );
goto loop;
// LD
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // LD (HL),r
WRITE( rp.hl, R8( opcode, 0x70 ) );
goto loop;
CASE6( 41, 42, 43, 44, 45, 47 ): // LD B,r
CASE6( 48, 4A, 4B, 4C, 4D, 4F ): // LD C,r
CASE6( 50, 51, 53, 54, 55, 57 ): // LD D,r
CASE6( 58, 59, 5A, 5C, 5D, 5F ): // LD E,r
CASE6( 60, 61, 62, 63, 65, 67 ): // LD H,r
CASE6( 68, 69, 6A, 6B, 6C, 6F ): // LD L,r
CASE6( 78, 79, 7A, 7B, 7C, 7D ): // LD A,r
R8( opcode >> 3 & 7, 0 ) = R8( opcode & 7, 0 );
goto loop;
CASE5( 06, 0E, 16, 1E, 26 ): // LD r,imm
R8( opcode >> 3, 0 ) = data;
pc++;
goto loop;
case 0x36: // LD (HL),imm
pc++;
WRITE( rp.hl, data );
goto loop;
CASE7( 46, 4E, 56, 5E, 66, 6E, 7E ): // LD r,(HL)
R8( opcode >> 3, 8 ) = READ( rp.hl );
goto loop;
case 0x01: // LD rp,imm
case 0x11:
case 0x21:
R16( opcode, 4, 0x01 ) = GET_ADDR();
pc += 2;
goto loop;
case 0x31: // LD sp,imm
sp = GET_ADDR();
pc += 2;
goto loop;
case 0x2A:{// LD HL,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
rp.hl = READ_WORD( addr );
goto loop;
}
case 0x32:{// LD (addr),A
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE( addr, rg.a );
goto loop;
}
case 0x22:{// LD (addr),HL
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, rp.hl );
goto loop;
}
case 0x02: // LD (BC),A
case 0x12: // LD (DE),A
WRITE( R16( opcode, 4, 0x02 ), rg.a );
goto loop;
case 0x0A: // LD A,(BC)
case 0x1A: // LD A,(DE)
rg.a = READ( R16( opcode, 4, 0x0A ) );
goto loop;
case 0xF9: // LD SP,HL
sp = rp.hl;
goto loop;
// Rotate
case 0x07:{// RLCA
- fuint16 temp = rg.a;
+ uint16_t temp = rg.a;
temp = (temp << 1) | (temp >> 7);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08 | C01));
rg.a = temp;
goto loop;
}
case 0x0F:{// RRCA
- fuint16 temp = rg.a;
+ uint16_t temp = rg.a;
flags = (flags & (S80 | Z40 | P04)) |
(temp & C01);
temp = (temp << 7) | (temp >> 1);
flags |= temp & (F20 | F08);
rg.a = temp;
goto loop;
}
case 0x17:{// RLA
blargg_ulong temp = (rg.a << 1) | (flags & C01);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08)) |
(temp >> 8);
rg.a = temp;
goto loop;
}
case 0x1F:{// RRA
- fuint16 temp = (flags << 7) | (rg.a >> 1);
+ uint16_t temp = (flags << 7) | (rg.a >> 1);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08)) |
(rg.a & C01);
rg.a = temp;
goto loop;
}
// Misc
case 0x2F:{// CPL
- fuint16 temp = ~rg.a;
+ uint16_t temp = ~rg.a;
flags = (flags & (S80 | Z40 | P04 | C01)) |
(temp & (F20 | F08)) |
(H10 | N02);
rg.a = temp;
goto loop;
}
case 0x3F:{// CCF
flags = ((flags & (S80 | Z40 | P04 | C01)) ^ C01) |
(flags << 4 & H10) |
(rg.a & (F20 | F08));
goto loop;
}
case 0x37: // SCF
flags = (flags & (S80 | Z40 | P04)) | C01 |
(rg.a & (F20 | F08));
goto loop;
case 0xDB: // IN A,(imm)
pc++;
rg.a = IN( data + rg.a * 0x100 );
goto loop;
case 0xE3:{// EX (SP),HL
- fuint16 temp = READ_WORD( sp );
+ uint16_t temp = READ_WORD( sp );
WRITE_WORD( sp, rp.hl );
rp.hl = temp;
goto loop;
}
case 0xEB:{// EX DE,HL
- fuint16 temp = rp.hl;
+ uint16_t temp = rp.hl;
rp.hl = rp.de;
rp.de = temp;
goto loop;
}
case 0xD9:{// EXX DE,HL
- fuint16 temp = r.alt.w.bc;
+ uint16_t temp = r.alt.w.bc;
r.alt.w.bc = rp.bc;
rp.bc = temp;
temp = r.alt.w.de;
r.alt.w.de = rp.de;
rp.de = temp;
temp = r.alt.w.hl;
r.alt.w.hl = rp.hl;
rp.hl = temp;
goto loop;
}
case 0xF3: // DI
r.iff1 = 0;
r.iff2 = 0;
goto loop;
case 0xFB: // EI
r.iff1 = 1;
r.iff2 = 1;
// TODO: delayed effect
goto loop;
case 0x76: // HALT
goto halt;
//////////////////////////////////////// CB prefix
{
case 0xCB:
unsigned data2;
data2 = INSTR( 1 );
- data2 = data2;
+ (void) data2; // TODO is this the same as data in all cases?
pc++;
switch ( data )
{
// Rotate left
#define RLC( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
result = uint8_t (result << 1) | (result >> 7);\
flags = SZ28P( result ) | (result & C01);\
write;\
goto loop;\
}
case 0x06: // RLC (HL)
s_time += 7;
data = rp.hl;
rlc_data_addr:
RLC( READ( data ), WRITE( data, result ) )
CASE7( 00, 01, 02, 03, 04, 05, 07 ):{// RLC r
uint8_t& reg = R8( data, 0 );
RLC( reg, reg = result )
}
#define RL( read, write ) {\
- fuint16 result = (read << 1) | (flags & C01);\
+ uint16_t result = (read << 1) | (flags & C01);\
flags = SZ28PC( result );\
write;\
goto loop;\
}
case 0x16: // RL (HL)
s_time += 7;
data = rp.hl;
rl_data_addr:
RL( READ( data ), WRITE( data, result ) )
CASE7( 10, 11, 12, 13, 14, 15, 17 ):{// RL r
uint8_t& reg = R8( data, 0x10 );
RL( reg, reg = result )
}
#define SLA( read, add, write ) {\
- fuint16 result = (read << 1) | add;\
+ uint16_t result = (read << 1) | add;\
flags = SZ28PC( result );\
write;\
goto loop;\
}
case 0x26: // SLA (HL)
s_time += 7;
data = rp.hl;
sla_data_addr:
SLA( READ( data ), 0, WRITE( data, result ) )
CASE7( 20, 21, 22, 23, 24, 25, 27 ):{// SLA r
uint8_t& reg = R8( data, 0x20 );
SLA( reg, 0, reg = result )
}
case 0x36: // SLL (HL)
s_time += 7;
data = rp.hl;
sll_data_addr:
SLA( READ( data ), 1, WRITE( data, result ) )
CASE7( 30, 31, 32, 33, 34, 35, 37 ):{// SLL r
uint8_t& reg = R8( data, 0x30 );
SLA( reg, 1, reg = result )
}
// Rotate right
#define RRC( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result = uint8_t (result << 7) | (result >> 1);\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x0E: // RRC (HL)
s_time += 7;
data = rp.hl;
rrc_data_addr:
RRC( READ( data ), WRITE( data, result ) )
CASE7( 08, 09, 0A, 0B, 0C, 0D, 0F ):{// RRC r
uint8_t& reg = R8( data, 0x08 );
RRC( reg, reg = result )
}
#define RR( read, write ) {\
- fuint8 result = read;\
- fuint8 temp = result & C01;\
+ uint8_t result = read;\
+ uint8_t temp = result & C01;\
result = uint8_t (flags << 7) | (result >> 1);\
flags = SZ28P( result ) | temp;\
write;\
goto loop;\
}
case 0x1E: // RR (HL)
s_time += 7;
data = rp.hl;
rr_data_addr:
RR( READ( data ), WRITE( data, result ) )
CASE7( 18, 19, 1A, 1B, 1C, 1D, 1F ):{// RR r
uint8_t& reg = R8( data, 0x18 );
RR( reg, reg = result )
}
#define SRA( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result = (result & 0x80) | (result >> 1);\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x2E: // SRA (HL)
data = rp.hl;
s_time += 7;
sra_data_addr:
SRA( READ( data ), WRITE( data, result ) )
CASE7( 28, 29, 2A, 2B, 2C, 2D, 2F ):{// SRA r
uint8_t& reg = R8( data, 0x28 );
SRA( reg, reg = result )
}
#define SRL( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result >>= 1;\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x3E: // SRL (HL)
s_time += 7;
data = rp.hl;
srl_data_addr:
SRL( READ( data ), WRITE( data, result ) )
CASE7( 38, 39, 3A, 3B, 3C, 3D, 3F ):{// SRL r
uint8_t& reg = R8( data, 0x38 );
SRL( reg, reg = result )
}
// BIT
{
unsigned temp;
CASE8( 46, 4E, 56, 5E, 66, 6E, 76, 7E ): // BIT b,(HL)
s_time += 4;
temp = READ( rp.hl );
flags &= C01;
goto bit_temp;
CASE7( 40, 41, 42, 43, 44, 45, 47 ): // BIT 0,r
CASE7( 48, 49, 4A, 4B, 4C, 4D, 4F ): // BIT 1,r
CASE7( 50, 51, 52, 53, 54, 55, 57 ): // BIT 2,r
CASE7( 58, 59, 5A, 5B, 5C, 5D, 5F ): // BIT 3,r
CASE7( 60, 61, 62, 63, 64, 65, 67 ): // BIT 4,r
CASE7( 68, 69, 6A, 6B, 6C, 6D, 6F ): // BIT 5,r
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // BIT 6,r
CASE7( 78, 79, 7A, 7B, 7C, 7D, 7F ): // BIT 7,r
temp = R8( data & 7, 0 );
flags = (flags & C01) | (temp & (F20 | F08));
bit_temp:
int masked = temp & 1 << (data >> 3 & 7);
flags |=(masked & S80) | H10 |
((masked - 1) >> 8 & (Z40 | P04));
goto loop;
}
// SET/RES
CASE8( 86, 8E, 96, 9E, A6, AE, B6, BE ): // RES b,(HL)
CASE8( C6, CE, D6, DE, E6, EE, F6, FE ):{// SET b,(HL)
s_time += 7;
int temp = READ( rp.hl );
int bit = 1 << (data >> 3 & 7);
temp |= bit; // SET
if ( !(data & 0x40) )
temp ^= bit; // RES
WRITE( rp.hl, temp );
goto loop;
}
CASE7( C0, C1, C2, C3, C4, C5, C7 ): // SET 0,r
CASE7( C8, C9, CA, CB, CC, CD, CF ): // SET 1,r
CASE7( D0, D1, D2, D3, D4, D5, D7 ): // SET 2,r
CASE7( D8, D9, DA, DB, DC, DD, DF ): // SET 3,r
CASE7( E0, E1, E2, E3, E4, E5, E7 ): // SET 4,r
CASE7( E8, E9, EA, EB, EC, ED, EF ): // SET 5,r
CASE7( F0, F1, F2, F3, F4, F5, F7 ): // SET 6,r
CASE7( F8, F9, FA, FB, FC, FD, FF ): // SET 7,r
R8( data & 7, 0 ) |= 1 << (data >> 3 & 7);
goto loop;
CASE7( 80, 81, 82, 83, 84, 85, 87 ): // RES 0,r
CASE7( 88, 89, 8A, 8B, 8C, 8D, 8F ): // RES 1,r
CASE7( 90, 91, 92, 93, 94, 95, 97 ): // RES 2,r
CASE7( 98, 99, 9A, 9B, 9C, 9D, 9F ): // RES 3,r
CASE7( A0, A1, A2, A3, A4, A5, A7 ): // RES 4,r
CASE7( A8, A9, AA, AB, AC, AD, AF ): // RES 5,r
CASE7( B0, B1, B2, B3, B4, B5, B7 ): // RES 6,r
CASE7( B8, B9, BA, BB, BC, BD, BF ): // RES 7,r
R8( data & 7, 0 ) &= ~(1 << (data >> 3 & 7));
goto loop;
}
assert( false );
}
//////////////////////////////////////// ED prefix
{
case 0xED:
pc++;
s_time += ed_dd_timing [data] >> 4;
switch ( data )
{
{
blargg_ulong temp;
case 0x72: // SBC HL,SP
case 0x7A: // ADC HL,SP
temp = sp;
if ( 0 )
case 0x42: // SBC HL,BC
case 0x52: // SBC HL,DE
case 0x62: // SBC HL,HL
case 0x4A: // ADC HL,BC
case 0x5A: // ADC HL,DE
case 0x6A: // ADC HL,HL
temp = R16( data >> 3 & 6, 1, 0 );
blargg_ulong sum = temp + (flags & C01);
flags = ~data >> 2 & N02;
if ( flags )
sum = -sum;
sum += rp.hl;
temp ^= rp.hl;
temp ^= sum;
flags |=(sum >> 16 & C01) |
(temp >> 8 & H10) |
(sum >> 8 & (S80 | F20 | F08)) |
((temp - -0x8000) >> 14 & V04);
rp.hl = sum;
if ( (uint16_t) sum )
goto loop;
flags |= Z40;
goto loop;
}
CASE8( 40, 48, 50, 58, 60, 68, 70, 78 ):{// IN r,(C)
int temp = IN( rp.bc );
R8( data >> 3, 8 ) = temp;
flags = (flags & C01) | SZ28P( temp );
goto loop;
}
case 0x71: // OUT (C),0
rg.flags = 0;
CASE7( 41, 49, 51, 59, 61, 69, 79 ): // OUT (C),r
OUT( rp.bc, R8( data >> 3, 8 ) );
goto loop;
{
unsigned temp;
case 0x73: // LD (ADDR),SP
temp = sp;
if ( 0 )
case 0x43: // LD (ADDR),BC
case 0x53: // LD (ADDR),DE
temp = R16( data, 4, 0x43 );
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, temp );
goto loop;
}
case 0x4B: // LD BC,(ADDR)
case 0x5B:{// LD DE,(ADDR)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
R16( data, 4, 0x4B ) = READ_WORD( addr );
goto loop;
}
case 0x7B:{// LD SP,(ADDR)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
sp = READ_WORD( addr );
goto loop;
}
case 0x67:{// RRD
- fuint8 temp = READ( rp.hl );
+ uint8_t temp = READ( rp.hl );
WRITE( rp.hl, (rg.a << 4) | (temp >> 4) );
temp = (rg.a & 0xF0) | (temp & 0x0F);
flags = (flags & C01) | SZ28P( temp );
rg.a = temp;
goto loop;
}
case 0x6F:{// RLD
- fuint8 temp = READ( rp.hl );
+ uint8_t temp = READ( rp.hl );
WRITE( rp.hl, (temp << 4) | (rg.a & 0x0F) );
temp = (rg.a & 0xF0) | (temp >> 4);
flags = (flags & C01) | SZ28P( temp );
rg.a = temp;
goto loop;
}
CASE8( 44, 4C, 54, 5C, 64, 6C, 74, 7C ): // NEG
opcode = 0x10; // flag to do SBC instead of ADC
flags &= ~C01;
data = rg.a;
rg.a = 0;
goto adc_data;
{
int inc;
case 0xA9: // CPD
case 0xB9: // CPDR
inc = -1;
if ( 0 )
case 0xA1: // CPI
case 0xB1: // CPIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
int result = rg.a - temp;
flags = (flags & C01) | N02 |
((((temp ^ rg.a) & H10) ^ result) & (S80 | H10));
if ( !(uint8_t) result ) flags |= Z40;
result -= (flags & H10) >> 4;
flags |= result & F08;
flags |= result << 4 & F20;
if ( !--rp.bc )
goto loop;
flags |= V04;
if ( flags & Z40 || data < 0xB0 )
goto loop;
pc -= 2;
s_time += 5;
goto loop;
}
{
int inc;
case 0xA8: // LDD
case 0xB8: // LDDR
inc = -1;
if ( 0 )
case 0xA0: // LDI
case 0xB0: // LDIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
addr = rp.de;
rp.de = addr + inc;
WRITE( addr, temp );
temp += rg.a;
flags = (flags & (S80 | Z40 | C01)) |
(temp & F08) | (temp << 4 & F20);
if ( !--rp.bc )
goto loop;
flags |= V04;
if ( data < 0xB0 )
goto loop;
pc -= 2;
s_time += 5;
goto loop;
}
{
int inc;
case 0xAB: // OUTD
case 0xBB: // OTDR
inc = -1;
if ( 0 )
case 0xA3: // OUTI
case 0xB3: // OTIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
int b = --rg.b;
flags = (temp >> 6 & N02) | SZ28( b );
if ( b && data >= 0xB0 )
{
pc -= 2;
s_time += 5;
}
OUT( rp.bc, temp );
goto loop;
}
{
int inc;
case 0xAA: // IND
case 0xBA: // INDR
inc = -1;
if ( 0 )
case 0xA2: // INI
case 0xB2: // INIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = IN( rp.bc );
int b = --rg.b;
flags = (temp >> 6 & N02) | SZ28( b );
if ( b && data >= 0xB0 )
{
pc -= 2;
s_time += 5;
}
WRITE( addr, temp );
goto loop;
}
case 0x47: // LD I,A
r.i = rg.a;
goto loop;
case 0x4F: // LD R,A
SET_R( rg.a );
debug_printf( "LD R,A not supported\n" );
warning = true;
goto loop;
case 0x57: // LD A,I
rg.a = r.i;
goto ld_ai_common;
case 0x5F: // LD A,R
rg.a = GET_R();
debug_printf( "LD A,R not supported\n" );
warning = true;
ld_ai_common:
flags = (flags & C01) | SZ28( rg.a ) | (r.iff2 << 2 & V04);
goto loop;
CASE8( 45, 4D, 55, 5D, 65, 6D, 75, 7D ): // RETI/RETN
r.iff1 = r.iff2;
goto ret_taken;
case 0x46: case 0x4E: case 0x66: case 0x6E: // IM 0
r.im = 0;
goto loop;
case 0x56: case 0x76: // IM 1
r.im = 1;
goto loop;
case 0x5E: case 0x7E: // IM 2
r.im = 2;
goto loop;
default:
debug_printf( "Opcode $ED $%02X not supported\n", data );
warning = true;
goto loop;
}
assert( false );
}
//////////////////////////////////////// DD/FD prefix
{
- fuint16 ixy;
+ uint16_t ixy;
case 0xDD:
ixy = ix;
goto ix_prefix;
case 0xFD:
ixy = iy;
ix_prefix:
pc++;
unsigned data2 = READ_PROG( pc );
s_time += ed_dd_timing [data] & 0x0F;
switch ( data )
{
// TODO: more efficient way of avoid negative address
#define IXY_DISP( ixy, disp ) uint16_t ((ixy) + (disp))
#define SET_IXY( in ) if ( opcode == 0xDD ) ix = in; else iy = in;
// ADD/ADC/SUB/SBC
case 0x96: // SUB (IXY+disp)
case 0x86: // ADD (IXY+disp)
flags &= ~C01;
case 0x9E: // SBC (IXY+disp)
case 0x8E: // ADC (IXY+disp)
pc++;
opcode = data;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto adc_data;
case 0x94: // SUB HXY
case 0x84: // ADD HXY
flags &= ~C01;
case 0x9C: // SBC HXY
case 0x8C: // ADC HXY
opcode = data;
data = ixy >> 8;
goto adc_data;
case 0x95: // SUB LXY
case 0x85: // ADD LXY
flags &= ~C01;
case 0x9D: // SBC LXY
case 0x8D: // ADC LXY
opcode = data;
data = (uint8_t) ixy;
goto adc_data;
{
unsigned temp;
case 0x39: // ADD IXY,SP
temp = sp;
goto add_ixy_data;
case 0x29: // ADD IXY,HL
temp = ixy;
goto add_ixy_data;
case 0x09: // ADD IXY,BC
case 0x19: // ADD IXY,DE
temp = R16( data, 4, 0x09 );
add_ixy_data: {
blargg_ulong sum = ixy + temp;
temp ^= ixy;
ixy = (uint16_t) sum;
flags = (flags & (S80 | Z40 | V04)) |
(sum >> 16) |
(sum >> 8 & (F20 | F08)) |
((temp ^ sum) >> 8 & H10);
goto set_ixy;
}
}
// AND
case 0xA6: // AND (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto and_data;
case 0xA4: // AND HXY
data = ixy >> 8;
goto and_data;
case 0xA5: // AND LXY
data = (uint8_t) ixy;
goto and_data;
// OR
case 0xB6: // OR (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto or_data;
case 0xB4: // OR HXY
data = ixy >> 8;
goto or_data;
case 0xB5: // OR LXY
data = (uint8_t) ixy;
goto or_data;
// XOR
case 0xAE: // XOR (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto xor_data;
case 0xAC: // XOR HXY
data = ixy >> 8;
goto xor_data;
case 0xAD: // XOR LXY
data = (uint8_t) ixy;
goto xor_data;
// CP
case 0xBE: // CP (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto cp_data;
case 0xBC: // CP HXY
data = ixy >> 8;
goto cp_data;
case 0xBD: // CP LXY
data = (uint8_t) ixy;
goto cp_data;
// LD
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // LD (IXY+disp),r
data = R8( data, 0x70 );
if ( 0 )
case 0x36: // LD (IXY+disp),imm
pc++, data = READ_PROG( pc );
pc++;
WRITE( IXY_DISP( ixy, (int8_t) data2 ), data );
goto loop;
CASE5( 44, 4C, 54, 5C, 7C ): // LD r,HXY
R8( data >> 3, 8 ) = ixy >> 8;
goto loop;
case 0x64: // LD HXY,HXY
case 0x6D: // LD LXY,LXY
goto loop;
CASE5( 45, 4D, 55, 5D, 7D ): // LD r,LXY
R8( data >> 3, 8 ) = ixy;
goto loop;
CASE7( 46, 4E, 56, 5E, 66, 6E, 7E ): // LD r,(IXY+disp)
pc++;
R8( data >> 3, 8 ) = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto loop;
case 0x26: // LD HXY,imm
pc++;
goto ld_hxy_data;
case 0x65: // LD HXY,LXY
data2 = (uint8_t) ixy;
goto ld_hxy_data;
CASE5( 60, 61, 62, 63, 67 ): // LD HXY,r
data2 = R8( data, 0x60 );
ld_hxy_data:
ixy = (uint8_t) ixy | (data2 << 8);
goto set_ixy;
case 0x2E: // LD LXY,imm
pc++;
goto ld_lxy_data;
case 0x6C: // LD LXY,HXY
data2 = ixy >> 8;
goto ld_lxy_data;
CASE5( 68, 69, 6A, 6B, 6F ): // LD LXY,r
data2 = R8( data, 0x68 );
ld_lxy_data:
ixy = (ixy & 0xFF00) | data2;
set_ixy:
if ( opcode == 0xDD )
{
ix = ixy;
goto loop;
}
iy = ixy;
goto loop;
case 0xF9: // LD SP,IXY
sp = ixy;
goto loop;
case 0x22:{// LD (ADDR),IXY
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, ixy );
goto loop;
}
case 0x21: // LD IXY,imm
ixy = GET_ADDR();
pc += 2;
goto set_ixy;
case 0x2A:{// LD IXY,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
ixy = READ_WORD( addr );
pc += 2;
goto set_ixy;
}
// DD/FD CB prefix
case 0xCB: {
data = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data2 = READ_PROG( pc );
pc++;
switch ( data2 )
{
case 0x06: goto rlc_data_addr; // RLC (IXY)
case 0x16: goto rl_data_addr; // RL (IXY)
case 0x26: goto sla_data_addr; // SLA (IXY)
case 0x36: goto sll_data_addr; // SLL (IXY)
case 0x0E: goto rrc_data_addr; // RRC (IXY)
case 0x1E: goto rr_data_addr; // RR (IXY)
case 0x2E: goto sra_data_addr; // SRA (IXY)
case 0x3E: goto srl_data_addr; // SRL (IXY)
CASE8( 46, 4E, 56, 5E, 66, 6E, 76, 7E ):{// BIT b,(IXY+disp)
- fuint8 temp = READ( data );
+ uint8_t temp = READ( data );
int masked = temp & 1 << (data2 >> 3 & 7);
flags = (flags & C01) | H10 |
(masked & S80) |
((masked - 1) >> 8 & (Z40 | P04));
goto loop;
}
CASE8( 86, 8E, 96, 9E, A6, AE, B6, BE ): // RES b,(IXY+disp)
CASE8( C6, CE, D6, DE, E6, EE, F6, FE ):{// SET b,(IXY+disp)
int temp = READ( data );
int bit = 1 << (data2 >> 3 & 7);
temp |= bit; // SET
if ( !(data2 & 0x40) )
temp ^= bit; // RES
WRITE( data, temp );
goto loop;
}
default:
debug_printf( "Opcode $%02X $CB $%02X not supported\n", opcode, data2 );
warning = true;
goto loop;
}
assert( false );
}
// INC/DEC
case 0x23: // INC IXY
ixy = uint16_t (ixy + 1);
goto set_ixy;
case 0x2B: // DEC IXY
ixy = uint16_t (ixy - 1);
goto set_ixy;
case 0x34: // INC (IXY+disp)
ixy = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data = READ( ixy ) + 1;
WRITE( ixy, data );
goto inc_set_flags;
case 0x35: // DEC (IXY+disp)
ixy = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data = READ( ixy ) - 1;
WRITE( ixy, data );
goto dec_set_flags;
case 0x24: // INC HXY
ixy = uint16_t (ixy + 0x100);
data = ixy >> 8;
goto inc_xy_common;
case 0x2C: // INC LXY
data = uint8_t (ixy + 1);
ixy = (ixy & 0xFF00) | data;
inc_xy_common:
if ( opcode == 0xDD )
{
ix = ixy;
goto inc_set_flags;
}
iy = ixy;
goto inc_set_flags;
case 0x25: // DEC HXY
ixy = uint16_t (ixy - 0x100);
data = ixy >> 8;
goto dec_xy_common;
case 0x2D: // DEC LXY
data = uint8_t (ixy - 1);
ixy = (ixy & 0xFF00) | data;
dec_xy_common:
if ( opcode == 0xDD )
{
ix = ixy;
goto dec_set_flags;
}
iy = ixy;
goto dec_set_flags;
// PUSH/POP
case 0xE5: // PUSH IXY
data = ixy;
goto push_data;
case 0xE1:{// POP IXY
ixy = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto set_ixy;
}
// Misc
case 0xE9: // JP (IXY)
pc = ixy;
goto loop;
case 0xE3:{// EX (SP),IXY
- fuint16 temp = READ_WORD( sp );
+ uint16_t temp = READ_WORD( sp );
WRITE_WORD( sp, ixy );
ixy = temp;
goto set_ixy;
}
default:
debug_printf( "Unnecessary DD/FD prefix encountered\n" );
warning = true;
pc--;
goto loop;
}
assert( false );
}
}
debug_printf( "Unhandled main opcode: $%02X\n", opcode );
assert( false );
halt:
s_time &= 3; // increment by multiple of 4
out_of_time:
pc--;
s.time = s_time;
rg.flags = flags;
r.ix = ix;
r.iy = iy;
r.sp = sp;
r.pc = pc;
this->r.b = rg;
this->state_ = s;
this->state = &this->state_;
return warning;
}
diff --git a/src/libs/gme/Ay_Cpu.h b/src/libs/gme/Ay_Cpu.h
index 2f4d351e..6984b42d 100644
--- a/src/libs/gme/Ay_Cpu.h
+++ b/src/libs/gme/Ay_Cpu.h
@@ -1,92 +1,89 @@
// Z80 CPU emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef AY_CPU_H
#define AY_CPU_H
#include "blargg_endian.h"
typedef blargg_long cpu_time_t;
// must be defined by caller
void ay_cpu_out( class Ay_Cpu*, cpu_time_t, unsigned addr, int data );
int ay_cpu_in( class Ay_Cpu*, unsigned addr );
class Ay_Cpu {
public:
// Clear all registers and keep pointer to 64K memory passed in
void reset( void* mem_64k );
// Run until specified time is reached. Returns true if suspicious/unsupported
// instruction was encountered at any point during run.
bool run( cpu_time_t end_time );
// Time of beginning of next instruction
cpu_time_t time() const { return state->time + state->base; }
// Alter current time. Not supported during run() call.
void set_time( cpu_time_t t ) { state->time = t - state->base; }
void adjust_time( int delta ) { state->time += delta; }
- typedef BOOST::uint8_t uint8_t;
- typedef BOOST::uint16_t uint16_t;
-
#if BLARGG_BIG_ENDIAN
struct regs_t { uint8_t b, c, d, e, h, l, flags, a; };
#else
struct regs_t { uint8_t c, b, e, d, l, h, a, flags; };
#endif
BOOST_STATIC_ASSERT( sizeof (regs_t) == 8 );
struct pairs_t { uint16_t bc, de, hl, fa; };
// Registers are not updated until run() returns
struct registers_t {
uint16_t pc;
uint16_t sp;
uint16_t ix;
uint16_t iy;
union {
regs_t b; // b.b, b.c, b.d, b.e, b.h, b.l, b.flags, b.a
pairs_t w; // w.bc, w.de, w.hl. w.fa
};
union {
regs_t b;
pairs_t w;
} alt;
uint8_t iff1;
uint8_t iff2;
uint8_t r;
uint8_t i;
uint8_t im;
};
//registers_t r; (below for efficiency)
// can read this far past end of memory
enum { cpu_padding = 0x100 };
public:
Ay_Cpu();
private:
uint8_t szpc [0x200];
uint8_t* mem;
cpu_time_t end_time_;
struct state_t {
cpu_time_t base;
cpu_time_t time;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
void set_end_time( cpu_time_t t );
public:
registers_t r;
};
inline void Ay_Cpu::set_end_time( cpu_time_t t )
{
cpu_time_t delta = state->base - t;
state->base = t;
state->time += delta;
}
#endif
diff --git a/src/libs/gme/Ay_Emu.cpp b/src/libs/gme/Ay_Emu.cpp
index 0ee592e3..a973ba0f 100644
--- a/src/libs/gme/Ay_Emu.cpp
+++ b/src/libs/gme/Ay_Emu.cpp
@@ -1,405 +1,405 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Ay_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2006 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"
long const spectrum_clock = 3546900;
long const cpc_clock = 2000000;
unsigned const ram_start = 0x4000;
int const osc_count = Ay_Apu::osc_count + 1;
Ay_Emu::Ay_Emu()
{
beeper_output = 0;
set_type( gme_ay_type );
static const char* const names [osc_count] = {
"Wave 1", "Wave 2", "Wave 3", "Beeper"
};
set_voice_names( names );
static int const types [osc_count] = {
wave_type | 0, wave_type | 1, wave_type | 2, mixed_type | 0
};
set_voice_types( types );
set_silence_lookahead( 6 );
}
Ay_Emu::~Ay_Emu() { }
// Track info
static byte const* get_data( Ay_Emu::file_t const& file, byte const* ptr, int min_size )
{
long pos = ptr - (byte const*) file.header;
long file_size = file.end - (byte const*) file.header;
assert( (unsigned long) pos <= (unsigned long) file_size - 2 );
- int offset = (BOOST::int16_t) get_be16( ptr );
+ int offset = (int16_t) get_be16( ptr );
if ( !offset || blargg_ulong (pos + offset) > blargg_ulong (file_size - min_size) )
return 0;
return ptr + offset;
}
static blargg_err_t parse_header( byte const* in, long size, Ay_Emu::file_t* out )
{
typedef Ay_Emu::header_t header_t;
out->header = (header_t const*) in;
out->end = in + size;
if ( size < Ay_Emu::header_size )
return gme_wrong_file_type;
header_t const& h = *(header_t const*) in;
if ( memcmp( h.tag, "ZXAYEMUL", 8 ) )
return gme_wrong_file_type;
out->tracks = get_data( *out, h.track_info, (h.max_track + 1) * 4 );
if ( !out->tracks )
return "Missing track data";
return 0;
}
static void copy_ay_fields( Ay_Emu::file_t const& file, track_info_t* out, int track )
{
Gme_File::copy_field_( out->song, (char const*) get_data( file, file.tracks + track * 4, 1 ) );
byte const* track_info = get_data( file, file.tracks + track * 4 + 2, 6 );
if ( track_info )
out->length = get_be16( track_info + 4 ) * (1000L / 50); // frames to msec
Gme_File::copy_field_( out->author, (char const*) get_data( file, file.header->author, 1 ) );
Gme_File::copy_field_( out->comment, (char const*) get_data( file, file.header->comment, 1 ) );
}
blargg_err_t Ay_Emu::track_info_( track_info_t* out, int track ) const
{
copy_ay_fields( file, out, track );
return 0;
}
struct Ay_File : Gme_Info_
{
Ay_Emu::file_t file;
Ay_File() { set_type( gme_ay_type ); }
blargg_err_t load_mem_( byte const* begin, long size )
{
RETURN_ERR( parse_header( begin, size, &file ) );
set_track_count( file.header->max_track + 1 );
return 0;
}
blargg_err_t track_info_( track_info_t* out, int track ) const
{
copy_ay_fields( file, out, track );
return 0;
}
};
static Music_Emu* new_ay_emu () { return BLARGG_NEW Ay_Emu ; }
static Music_Emu* new_ay_file() { return BLARGG_NEW Ay_File; }
static gme_type_t_ const gme_ay_type_ = { "ZX Spectrum", 0, &new_ay_emu, &new_ay_file, "AY", 1 };
-gme_type_t const gme_ay_type = &gme_ay_type_;
+BLARGG_EXPORT extern gme_type_t const gme_ay_type = &gme_ay_type_;
// Setup
blargg_err_t Ay_Emu::load_mem_( byte const* in, long size )
{
assert( offsetof (header_t,track_info [2]) == header_size );
RETURN_ERR( parse_header( in, size, &file ) );
set_track_count( file.header->max_track + 1 );
if ( file.header->vers > 2 )
set_warning( "Unknown file version" );
set_voice_count( osc_count );
apu.volume( gain() );
return setup_buffer( spectrum_clock );
}
void Ay_Emu::update_eq( blip_eq_t const& eq )
{
apu.treble_eq( eq );
}
void Ay_Emu::set_voice( int i, Blip_Buffer* center, Blip_Buffer*, Blip_Buffer* )
{
if ( i >= Ay_Apu::osc_count )
beeper_output = center;
else
apu.osc_output( i, center );
}
// Emulation
void Ay_Emu::set_tempo_( double t )
{
play_period = blip_time_t (clock_rate() / 50 / t);
}
blargg_err_t Ay_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( mem.ram + 0x0000, 0xC9, 0x100 ); // fill RST vectors with RET
memset( mem.ram + 0x0100, 0xFF, 0x4000 - 0x100 );
memset( mem.ram + ram_start, 0x00, sizeof mem.ram - ram_start );
memset( mem.padding1, 0xFF, sizeof mem.padding1 );
memset( mem.ram + 0x10000, 0xFF, sizeof mem.ram - 0x10000 );
// locate data blocks
byte const* const data = get_data( file, file.tracks + track * 4 + 2, 14 );
if ( !data ) return "File data missing";
byte const* const more_data = get_data( file, data + 10, 6 );
if ( !more_data ) return "File data missing";
byte const* blocks = get_data( file, data + 12, 8 );
if ( !blocks ) return "File data missing";
// initial addresses
cpu::reset( mem.ram );
r.sp = get_be16( more_data );
r.b.a = r.b.b = r.b.d = r.b.h = data [8];
r.b.flags = r.b.c = r.b.e = r.b.l = data [9];
r.alt.w = r.w;
r.ix = r.iy = r.w.hl;
unsigned addr = get_be16( blocks );
if ( !addr ) return "File data missing";
unsigned init = get_be16( more_data + 2 );
if ( !init )
init = addr;
// copy blocks into memory
do
{
blocks += 2;
unsigned len = get_be16( blocks ); blocks += 2;
if ( addr + len > 0x10000 )
{
set_warning( "Bad data block size" );
len = 0x10000 - addr;
}
check( len );
byte const* in = get_data( file, blocks, 0 ); blocks += 2;
if ( len > blargg_ulong (file.end - in) )
{
set_warning( "Missing file data" );
len = file.end - in;
}
//debug_printf( "addr: $%04X, len: $%04X\n", addr, len );
if ( addr < ram_start && addr >= 0x400 ) // several tracks use low data
debug_printf( "Block addr in ROM\n" );
memcpy( mem.ram + addr, in, len );
if ( file.end - blocks < 8 )
{
set_warning( "Missing file data" );
break;
}
}
while ( (addr = get_be16( blocks )) != 0 );
// copy and configure driver
static byte const passive [] = {
0xF3, // DI
0xCD, 0, 0, // CALL init
0xED, 0x5E, // LOOP: IM 2
0xFB, // EI
0x76, // HALT
0x18, 0xFA // JR LOOP
};
static byte const active [] = {
0xF3, // DI
0xCD, 0, 0, // CALL init
0xED, 0x56, // LOOP: IM 1
0xFB, // EI
0x76, // HALT
0xCD, 0, 0, // CALL play
0x18, 0xF7 // JR LOOP
};
memcpy( mem.ram, passive, sizeof passive );
unsigned play_addr = get_be16( more_data + 4 );
//debug_printf( "Play: $%04X\n", play_addr );
if ( play_addr )
{
memcpy( mem.ram, active, sizeof active );
mem.ram [ 9] = play_addr;
mem.ram [10] = play_addr >> 8;
}
mem.ram [2] = init;
mem.ram [3] = init >> 8;
mem.ram [0x38] = 0xFB; // Put EI at interrupt vector (followed by RET)
memcpy( mem.ram + 0x10000, mem.ram, 0x80 ); // some code wraps around (ugh)
beeper_delta = int (apu.amp_range * 0.65);
last_beeper = 0;
apu.reset();
next_play = play_period;
// start at spectrum speed
change_clock_rate( spectrum_clock );
set_tempo( tempo() );
spectrum_mode = false;
cpc_mode = false;
cpc_latch = 0;
return 0;
}
// Emulation
void Ay_Emu::cpu_out_misc( cpu_time_t time, unsigned addr, int data )
{
if ( !cpc_mode )
{
switch ( addr & 0xFEFF )
{
case 0xFEFD:
spectrum_mode = true;
apu_addr = data & 0x0F;
return;
case 0xBEFD:
spectrum_mode = true;
apu.write( time, apu_addr, data );
return;
}
}
if ( !spectrum_mode )
{
switch ( addr >> 8 )
{
case 0xF6:
switch ( data & 0xC0 )
{
case 0xC0:
apu_addr = cpc_latch & 0x0F;
goto enable_cpc;
case 0x80:
apu.write( time, apu_addr, cpc_latch );
goto enable_cpc;
}
break;
case 0xF4:
cpc_latch = data;
goto enable_cpc;
}
}
debug_printf( "Unmapped OUT: $%04X <- $%02X\n", addr, data );
return;
enable_cpc:
if ( !cpc_mode )
{
cpc_mode = true;
change_clock_rate( cpc_clock );
set_tempo( tempo() );
}
}
void ay_cpu_out( Ay_Cpu* cpu, cpu_time_t time, unsigned addr, int data )
{
Ay_Emu& emu = STATIC_CAST(Ay_Emu&,*cpu);
if ( (addr & 0xFF) == 0xFE && !emu.cpc_mode )
{
int delta = emu.beeper_delta;
data &= 0x10;
if ( emu.last_beeper != data )
{
emu.last_beeper = data;
emu.beeper_delta = -delta;
emu.spectrum_mode = true;
if ( emu.beeper_output )
emu.apu.synth_.offset( time, delta, emu.beeper_output );
}
}
else
{
emu.cpu_out_misc( time, addr, data );
}
}
int ay_cpu_in( Ay_Cpu*, unsigned addr )
{
// keyboard read and other things
if ( (addr & 0xFF) == 0xFE )
return 0xFF; // other values break some beeper tunes
debug_printf( "Unmapped IN : $%04X\n", addr );
return 0xFF;
}
blargg_err_t Ay_Emu::run_clocks( blip_time_t& duration, int )
{
set_time( 0 );
if ( !(spectrum_mode | cpc_mode) )
duration /= 2; // until mode is set, leave room for halved clock rate
while ( time() < duration )
{
cpu::run( min( duration, (blip_time_t) next_play ) );
if ( time() >= next_play )
{
next_play += play_period;
if ( r.iff1 )
{
if ( mem.ram [r.pc] == 0x76 )
r.pc++;
r.iff1 = r.iff2 = 0;
mem.ram [--r.sp] = uint8_t (r.pc >> 8);
mem.ram [--r.sp] = uint8_t (r.pc);
r.pc = 0x38;
cpu::adjust_time( 12 );
if ( r.im == 2 )
{
cpu::adjust_time( 6 );
unsigned addr = r.i * 0x100u + 0xFF;
r.pc = mem.ram [(addr + 1) & 0xFFFF] * 0x100u + mem.ram [addr];
}
}
}
}
duration = time();
next_play -= duration;
check( next_play >= 0 );
adjust_time( -duration );
apu.end_frame( duration );
return 0;
}
diff --git a/src/libs/gme/Ay_Emu.h b/src/libs/gme/Ay_Emu.h
index 8cd2231d..6726f015 100644
--- a/src/libs/gme/Ay_Emu.h
+++ b/src/libs/gme/Ay_Emu.h
@@ -1,70 +1,69 @@
// Sinclair Spectrum AY music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef AY_EMU_H
#define AY_EMU_H
#include "Classic_Emu.h"
#include "Ay_Apu.h"
#include "Ay_Cpu.h"
class Ay_Emu : private Ay_Cpu, public Classic_Emu {
typedef Ay_Cpu cpu;
public:
// AY file header
enum { header_size = 0x14 };
struct header_t
{
byte tag [8];
byte vers;
byte player;
byte unused [2];
byte author [2];
byte comment [2];
byte max_track;
byte first_track;
byte track_info [2];
};
static gme_type_t static_type() { return gme_ay_type; }
public:
Ay_Emu();
~Ay_Emu();
struct file_t {
header_t const* header;
byte const* end;
byte const* tracks;
};
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_mem_( byte const*, long );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
private:
file_t file;
- unsigned play_addr;
cpu_time_t play_period;
cpu_time_t next_play;
Blip_Buffer* beeper_output;
int beeper_delta;
int last_beeper;
int apu_addr;
int cpc_latch;
bool spectrum_mode;
bool cpc_mode;
// large items
struct {
byte padding1 [0x100];
byte ram [0x10000 + 0x100];
} mem;
Ay_Apu apu;
friend void ay_cpu_out( Ay_Cpu*, cpu_time_t, unsigned addr, int data );
void cpu_out_misc( cpu_time_t, unsigned addr, int data );
};
#endif
diff --git a/src/libs/gme/Blip_Buffer.cpp b/src/libs/gme/Blip_Buffer.cpp
index 9dc89ea8..2b88cd4f 100644
--- a/src/libs/gme/Blip_Buffer.cpp
+++ b/src/libs/gme/Blip_Buffer.cpp
@@ -1,446 +1,460 @@
// Blip_Buffer 0.4.1. http://www.slack.net/~ant/
#include "Blip_Buffer.h"
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
/* Copyright (C) 2003-2006 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 */
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
int const silent_buf_size = 1; // size used for Silent_Blip_Buffer
Blip_Buffer::Blip_Buffer()
{
factor_ = (blip_ulong)-1 / 2;
offset_ = 0;
buffer_ = 0;
buffer_size_ = 0;
sample_rate_ = 0;
reader_accum_ = 0;
bass_shift_ = 0;
clock_rate_ = 0;
bass_freq_ = 16;
length_ = 0;
// assumptions code makes about implementation-defined features
#ifndef NDEBUG
// right shift of negative value preserves sign
buf_t_ i = -0x7FFFFFFE;
assert( (i >> 1) == -0x3FFFFFFF );
// casting to short truncates to 16 bits and sign-extends
i = 0x18000;
assert( (short) i == -0x8000 );
#endif
}
Blip_Buffer::~Blip_Buffer()
{
if ( buffer_size_ != silent_buf_size )
free( buffer_ );
}
Silent_Blip_Buffer::Silent_Blip_Buffer()
{
factor_ = 0;
buffer_ = buf;
buffer_size_ = silent_buf_size;
memset( buf, 0, sizeof buf ); // in case machine takes exception for signed overflow
}
void Blip_Buffer::clear( int entire_buffer )
{
offset_ = 0;
reader_accum_ = 0;
modified_ = 0;
if ( buffer_ )
{
long count = (entire_buffer ? buffer_size_ : samples_avail());
memset( buffer_, 0, (count + blip_buffer_extra_) * sizeof (buf_t_) );
}
}
Blip_Buffer::blargg_err_t Blip_Buffer::set_sample_rate( long new_rate, int msec )
{
if ( buffer_size_ == silent_buf_size )
{
assert( 0 );
return "Internal (tried to resize Silent_Blip_Buffer)";
}
// start with maximum length that resampled time can represent
long new_size = (UINT_MAX >> BLIP_BUFFER_ACCURACY) - blip_buffer_extra_ - 64;
if ( msec != blip_max_length )
{
long s = (new_rate * (msec + 1) + 999) / 1000;
if ( s < new_size )
new_size = s;
else
assert( 0 ); // fails if requested buffer length exceeds limit
}
if ( buffer_size_ != new_size )
{
void* p = realloc( buffer_, (new_size + blip_buffer_extra_) * sizeof *buffer_ );
if ( !p )
return "Out of memory";
buffer_ = (buf_t_*) p;
}
buffer_size_ = new_size;
assert( buffer_size_ != silent_buf_size );
// update things based on the sample rate
sample_rate_ = new_rate;
length_ = new_size * 1000 / new_rate - 1;
if ( msec )
assert( length_ == msec ); // ensure length is same as that passed in
if ( clock_rate_ )
clock_rate( clock_rate_ );
bass_freq( bass_freq_ );
clear();
return 0; // success
}
blip_resampled_time_t Blip_Buffer::clock_rate_factor( long rate ) const
{
double ratio = (double) sample_rate_ / rate;
blip_long factor = (blip_long) floor( ratio * (1L << BLIP_BUFFER_ACCURACY) + 0.5 );
assert( factor > 0 || !sample_rate_ ); // fails if clock/output ratio is too large
return (blip_resampled_time_t) factor;
}
void Blip_Buffer::bass_freq( int freq )
{
bass_freq_ = freq;
int shift = 31;
if ( freq > 0 )
{
shift = 13;
long f = (freq << 16) / sample_rate_;
while ( (f >>= 1) && --shift ) { }
}
bass_shift_ = shift;
}
void Blip_Buffer::end_frame( blip_time_t t )
{
offset_ += t * factor_;
assert( samples_avail() <= (long) buffer_size_ ); // time outside buffer length
}
void Blip_Buffer::remove_silence( long count )
{
assert( count <= samples_avail() ); // tried to remove more samples than available
offset_ -= (blip_resampled_time_t) count << BLIP_BUFFER_ACCURACY;
}
long Blip_Buffer::count_samples( blip_time_t t ) const
{
unsigned long last_sample = resampled_time( t ) >> BLIP_BUFFER_ACCURACY;
unsigned long first_sample = offset_ >> BLIP_BUFFER_ACCURACY;
return (long) (last_sample - first_sample);
}
blip_time_t Blip_Buffer::count_clocks( long count ) const
{
if ( !factor_ )
{
assert( 0 ); // sample rate and clock rates must be set first
return 0;
}
if ( count > buffer_size_ )
count = buffer_size_;
blip_resampled_time_t time = (blip_resampled_time_t) count << BLIP_BUFFER_ACCURACY;
return (blip_time_t) ((time - offset_ + factor_ - 1) / factor_);
}
void Blip_Buffer::remove_samples( long count )
{
if ( count )
{
remove_silence( count );
// copy remaining samples to beginning and clear old samples
long remain = samples_avail() + blip_buffer_extra_;
memmove( buffer_, buffer_ + count, remain * sizeof *buffer_ );
memset( buffer_ + remain, 0, count * sizeof *buffer_ );
}
}
// Blip_Synth_
Blip_Synth_Fast_::Blip_Synth_Fast_()
{
buf = 0;
last_amp = 0;
delta_factor = 0;
}
void Blip_Synth_Fast_::volume_unit( double new_unit )
{
delta_factor = int (new_unit * (1L << blip_sample_bits) + 0.5);
}
#if !BLIP_BUFFER_FAST
Blip_Synth_::Blip_Synth_( short* p, int w ) :
impulses( p ),
width( w )
{
volume_unit_ = 0.0;
kernel_unit = 0;
buf = 0;
last_amp = 0;
delta_factor = 0;
}
#undef PI
#define PI 3.1415926535897932384626433832795029
static void gen_sinc( float* out, int count, double oversample, double treble, double cutoff )
{
if ( cutoff >= 0.999 )
cutoff = 0.999;
if ( treble < -300.0 )
treble = -300.0;
if ( treble > 5.0 )
treble = 5.0;
double const maxh = 4096.0;
double const rolloff = pow( 10.0, 1.0 / (maxh * 20.0) * treble / (1.0 - cutoff) );
double const pow_a_n = pow( rolloff, maxh - maxh * cutoff );
double const to_angle = PI / 2 / maxh / oversample;
for ( int i = 0; i < count; i++ )
{
- double angle = ((i - count) * 2 + 1) * to_angle;
- double c = rolloff * cos( (maxh - 1.0) * angle ) - cos( maxh * angle );
- double cos_nc_angle = cos( maxh * cutoff * angle );
- double cos_nc1_angle = cos( (maxh * cutoff - 1.0) * angle );
- double cos_angle = cos( angle );
+ double angle = ((i - count) * 2 + 1) * to_angle;
+ double angle_maxh = angle * maxh;
+ double angle_maxh_mid = angle_maxh * cutoff;
- c = c * pow_a_n - rolloff * cos_nc1_angle + cos_nc_angle;
- double d = 1.0 + rolloff * (rolloff - cos_angle - cos_angle);
- double b = 2.0 - cos_angle - cos_angle;
- double a = 1.0 - cos_angle - cos_nc_angle + cos_nc1_angle;
+ double y = maxh;
- out [i] = (float) ((a * d + c * b) / (b * d)); // a / b + c / d
+ // 0 to Fs/2*cutoff, flat
+ if ( angle_maxh_mid ) // unstable at t=0
+ y *= sin( angle_maxh_mid ) / angle_maxh_mid;
+
+ // Fs/2*cutoff to Fs/2, logarithmic rolloff
+ double cosa = cos( angle );
+ double den = 1 + rolloff * (rolloff - cosa - cosa);
+
+ // Becomes unstable when rolloff is near 1.0 and t is near 0,
+ // which is the only time den becomes small
+ if ( den > 1e-13 )
+ {
+ double num =
+ (cos( angle_maxh - angle ) * rolloff - cos( angle_maxh )) * pow_a_n -
+ cos( angle_maxh_mid - angle ) * rolloff + cos( angle_maxh_mid );
+
+ y = y * cutoff + num / den;
+ }
+
+ out [i] = (float) y;
}
}
void blip_eq_t::generate( float* out, int count ) const
{
// lower cutoff freq for narrow kernels with their wider transition band
// (8 points->1.49, 16 points->1.15)
double oversample = blip_res * 2.25 / count + 0.85;
double half_rate = sample_rate * 0.5;
if ( cutoff_freq )
oversample = half_rate / cutoff_freq;
double cutoff = rolloff_freq * oversample / half_rate;
gen_sinc( out, count, blip_res * oversample, treble, cutoff );
// apply (half of) hamming window
double to_fraction = PI / (count - 1);
for ( int i = count; i--; )
out [i] *= 0.54f - 0.46f * (float) cos( i * to_fraction );
}
void Blip_Synth_::adjust_impulse()
{
// sum pairs for each phase and add error correction to end of first half
int const size = impulses_size();
for ( int p = blip_res; p-- >= blip_res / 2; )
{
int p2 = blip_res - 2 - p;
long error = kernel_unit;
for ( int i = 1; i < size; i += blip_res )
{
error -= impulses [i + p ];
error -= impulses [i + p2];
}
if ( p == p2 )
error /= 2; // phase = 0.5 impulse uses same half for both sides
impulses [size - blip_res + p] += (short) error;
//printf( "error: %ld\n", error );
}
//for ( int i = blip_res; i--; printf( "\n" ) )
// for ( int j = 0; j < width / 2; j++ )
// printf( "%5ld,", impulses [j * blip_res + i + 1] );
}
void Blip_Synth_::treble_eq( blip_eq_t const& eq )
{
float fimpulse [blip_res / 2 * (blip_widest_impulse_ - 1) + blip_res * 2];
int const half_size = blip_res / 2 * (width - 1);
eq.generate( &fimpulse [blip_res], half_size );
int i;
// need mirror slightly past center for calculation
for ( i = blip_res; i--; )
fimpulse [blip_res + half_size + i] = fimpulse [blip_res + half_size - 1 - i];
// starts at 0
for ( i = 0; i < blip_res; i++ )
fimpulse [i] = 0.0f;
// find rescale factor
double total = 0.0;
for ( i = 0; i < half_size; i++ )
total += fimpulse [blip_res + i];
//double const base_unit = 44800.0 - 128 * 18; // allows treble up to +0 dB
//double const base_unit = 37888.0; // allows treble to +5 dB
double const base_unit = 32768.0; // necessary for blip_unscaled to work
double rescale = base_unit / 2 / total;
kernel_unit = (long) base_unit;
// integrate, first difference, rescale, convert to int
double sum = 0.0;
double next = 0.0;
int const impulses_size = this->impulses_size();
for ( i = 0; i < impulses_size; i++ )
{
impulses [i] = (short) floor( (next - sum) * rescale + 0.5 );
sum += fimpulse [i];
next += fimpulse [i + blip_res];
}
adjust_impulse();
// volume might require rescaling
double vol = volume_unit_;
if ( vol )
{
volume_unit_ = 0.0;
volume_unit( vol );
}
}
void Blip_Synth_::volume_unit( double new_unit )
{
if ( new_unit != volume_unit_ )
{
// use default eq if it hasn't been set yet
if ( !kernel_unit )
treble_eq( -8.0 );
volume_unit_ = new_unit;
double factor = new_unit * (1L << blip_sample_bits) / kernel_unit;
if ( factor > 0.0 )
{
int shift = 0;
// if unit is really small, might need to attenuate kernel
while ( factor < 2.0 )
{
shift++;
factor *= 2.0;
}
if ( shift )
{
kernel_unit >>= shift;
assert( kernel_unit > 0 ); // fails if volume unit is too low
// keep values positive to avoid round-towards-zero of sign-preserving
// right shift for negative values
long offset = 0x8000 + (1 << (shift - 1));
long offset2 = 0x8000 >> shift;
for ( int i = impulses_size(); i--; )
impulses [i] = (short) (((impulses [i] + offset) >> shift) - offset2);
adjust_impulse();
}
}
delta_factor = (int) floor( factor + 0.5 );
//printf( "delta_factor: %d, kernel_unit: %d\n", delta_factor, kernel_unit );
}
}
#endif
long Blip_Buffer::read_samples( blip_sample_t* BLIP_RESTRICT out, long max_samples, int stereo )
{
long count = samples_avail();
if ( count > max_samples )
count = max_samples;
if ( count )
{
int const bass = BLIP_READER_BASS( *this );
BLIP_READER_BEGIN( reader, *this );
if ( !stereo )
{
for ( blip_long n = count; n; --n )
{
blip_long s = BLIP_READER_READ( reader );
if ( (blip_sample_t) s != s )
s = 0x7FFF - (s >> 24);
*out++ = (blip_sample_t) s;
BLIP_READER_NEXT( reader, bass );
}
}
else
{
for ( blip_long n = count; n; --n )
{
blip_long s = BLIP_READER_READ( reader );
if ( (blip_sample_t) s != s )
s = 0x7FFF - (s >> 24);
*out = (blip_sample_t) s;
out += 2;
BLIP_READER_NEXT( reader, bass );
}
}
BLIP_READER_END( reader, *this );
remove_samples( count );
}
return count;
}
void Blip_Buffer::mix_samples( blip_sample_t const* in, long count )
{
if ( buffer_size_ == silent_buf_size )
{
assert( 0 );
return;
}
buf_t_* out = buffer_ + (offset_ >> BLIP_BUFFER_ACCURACY) + blip_widest_impulse_ / 2;
int const sample_shift = blip_sample_bits - 16;
int prev = 0;
while ( count-- )
{
blip_long s = (blip_long) *in++ << sample_shift;
*out += s - prev;
prev = s;
++out;
}
*out -= prev;
}
diff --git a/src/libs/gme/Blip_Buffer.h b/src/libs/gme/Blip_Buffer.h
index 4cc526d2..e6facc82 100644
--- a/src/libs/gme/Blip_Buffer.h
+++ b/src/libs/gme/Blip_Buffer.h
@@ -1,488 +1,490 @@
// Band-limited sound synthesis buffer
// Blip_Buffer 0.4.1
#ifndef BLIP_BUFFER_H
#define BLIP_BUFFER_H
// internal
#include <limits.h>
#if INT_MAX < 0x7FFFFFFF
#error "int must be at least 32 bits"
#endif
typedef int blip_long;
typedef unsigned blip_ulong;
// Time unit at source clock rate
typedef blip_long blip_time_t;
// Output samples are 16-bit signed, with a range of -32768 to 32767
typedef short blip_sample_t;
enum { blip_sample_max = 32767 };
class Blip_Buffer {
public:
typedef const char* blargg_err_t;
// Set output sample rate and buffer length in milliseconds (1/1000 sec, defaults
// to 1/4 second), then clear buffer. Returns NULL on success, otherwise if there
// isn't enough memory, returns error without affecting current buffer setup.
blargg_err_t set_sample_rate( long samples_per_sec, int msec_length = 1000 / 4 );
// Set number of source time units per second
void clock_rate( long );
// End current time frame of specified duration and make its samples available
// (along with any still-unread samples) for reading with read_samples(). Begins
// a new time frame at the end of the current frame.
void end_frame( blip_time_t time );
// Read at most 'max_samples' out of buffer into 'dest', removing them from from
// the buffer. Returns number of samples actually read and removed. If stereo is
// true, increments 'dest' one extra time after writing each sample, to allow
// easy interleving of two channels into a stereo output buffer.
long read_samples( blip_sample_t* dest, long max_samples, int stereo = 0 );
// Additional optional features
// Current output sample rate
long sample_rate() const;
// Length of buffer, in milliseconds
int length() const;
// Number of source time units per second
long clock_rate() const;
// Set frequency high-pass filter frequency, where higher values reduce bass more
void bass_freq( int frequency );
// Number of samples delay from synthesis to samples read out
int output_latency() const;
// Remove all available samples and clear buffer to silence. If 'entire_buffer' is
// false, just clears out any samples waiting rather than the entire buffer.
void clear( int entire_buffer = 1 );
// Number of samples available for reading with read_samples()
long samples_avail() const;
// Remove 'count' samples from those waiting to be read
void remove_samples( long count );
// Experimental features
// Count number of clocks needed until 'count' samples will be available.
// If buffer can't even hold 'count' samples, returns number of clocks until
// buffer becomes full.
blip_time_t count_clocks( long count ) const;
// Number of raw samples that can be mixed within frame of specified duration.
long count_samples( blip_time_t duration ) const;
// Mix 'count' samples from 'buf' into buffer.
void mix_samples( blip_sample_t const* buf, long count );
// not documented yet
void set_modified() { modified_ = 1; }
int clear_modified() { int b = modified_; modified_ = 0; return b; }
typedef blip_ulong blip_resampled_time_t;
void remove_silence( long count );
blip_resampled_time_t resampled_duration( int t ) const { return t * factor_; }
blip_resampled_time_t resampled_time( blip_time_t t ) const { return t * factor_ + offset_; }
blip_resampled_time_t clock_rate_factor( long clock_rate ) const;
public:
Blip_Buffer();
~Blip_Buffer();
+ Blip_Buffer(Blip_Buffer &&) = default;
+
// Deprecated
typedef blip_resampled_time_t resampled_time_t;
blargg_err_t sample_rate( long r ) { return set_sample_rate( r ); }
blargg_err_t sample_rate( long r, int msec ) { return set_sample_rate( r, msec ); }
private:
// noncopyable
Blip_Buffer( const Blip_Buffer& );
Blip_Buffer& operator = ( const Blip_Buffer& );
public:
typedef blip_time_t buf_t_;
blip_ulong factor_;
blip_resampled_time_t offset_;
buf_t_* buffer_;
blip_long buffer_size_;
blip_long reader_accum_;
int bass_shift_;
private:
long sample_rate_;
long clock_rate_;
int bass_freq_;
int length_;
int modified_;
friend class Blip_Reader;
};
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
// Number of bits in resample ratio fraction. Higher values give a more accurate ratio
// but reduce maximum buffer size.
#ifndef BLIP_BUFFER_ACCURACY
#define BLIP_BUFFER_ACCURACY 16
#endif
// Number bits in phase offset. Fewer than 6 bits (64 phase offsets) results in
// noticeable broadband noise when synthesizing high frequency square waves.
// Affects size of Blip_Synth objects since they store the waveform directly.
#ifndef BLIP_PHASE_BITS
#if BLIP_BUFFER_FAST
#define BLIP_PHASE_BITS 8
#else
#define BLIP_PHASE_BITS 6
#endif
#endif
// Internal
typedef blip_ulong blip_resampled_time_t;
int const blip_widest_impulse_ = 16;
int const blip_buffer_extra_ = blip_widest_impulse_ + 2;
int const blip_res = 1 << BLIP_PHASE_BITS;
class blip_eq_t;
class Blip_Synth_Fast_ {
public:
Blip_Buffer* buf;
int last_amp;
int delta_factor;
void volume_unit( double );
Blip_Synth_Fast_();
void treble_eq( blip_eq_t const& ) { }
};
class Blip_Synth_ {
public:
Blip_Buffer* buf;
int last_amp;
int delta_factor;
void volume_unit( double );
Blip_Synth_( short* impulses, int width );
void treble_eq( blip_eq_t const& );
private:
double volume_unit_;
short* const impulses;
int const width;
blip_long kernel_unit;
int impulses_size() const { return blip_res / 2 * width + 1; }
void adjust_impulse();
};
// Quality level. Start with blip_good_quality.
const int blip_med_quality = 8;
const int blip_good_quality = 12;
const int blip_high_quality = 16;
// Range specifies the greatest expected change in amplitude. Calculate it
// by finding the difference between the maximum and minimum expected
// amplitudes (max - min).
template<int quality,int range>
class Blip_Synth {
public:
// Set overall volume of waveform
void volume( double v ) { impl.volume_unit( v * (1.0 / (range < 0 ? -range : range)) ); }
// Configure low-pass filter (see blip_buffer.txt)
void treble_eq( blip_eq_t const& eq ) { impl.treble_eq( eq ); }
// Get/set Blip_Buffer used for output
Blip_Buffer* output() const { return impl.buf; }
void output( Blip_Buffer* b ) { impl.buf = b; impl.last_amp = 0; }
// Update amplitude of waveform at given time. Using this requires a separate
// Blip_Synth for each waveform.
void update( blip_time_t time, int amplitude );
// Low-level interface
// Add an amplitude transition of specified delta, optionally into specified buffer
// rather than the one set with output(). Delta can be positive or negative.
// The actual change in amplitude is delta * (volume / range)
void offset( blip_time_t, int delta, Blip_Buffer* ) const;
void offset( blip_time_t t, int delta ) const { offset( t, delta, impl.buf ); }
// Works directly in terms of fractional output samples. Contact author for more info.
void offset_resampled( blip_resampled_time_t, int delta, Blip_Buffer* ) const;
// Same as offset(), except code is inlined for higher performance
void offset_inline( blip_time_t t, int delta, Blip_Buffer* buf ) const {
offset_resampled( t * buf->factor_ + buf->offset_, delta, buf );
}
void offset_inline( blip_time_t t, int delta ) const {
offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf );
}
private:
#if BLIP_BUFFER_FAST
Blip_Synth_Fast_ impl;
#else
Blip_Synth_ impl;
typedef short imp_t;
imp_t impulses [blip_res * (quality / 2) + 1];
public:
Blip_Synth() : impl( impulses, quality ) { }
#endif
};
// Low-pass equalization parameters
class blip_eq_t {
public:
// Logarithmic rolloff to treble dB at half sampling rate. Negative values reduce
// treble, small positive values (0 to 5.0) increase treble.
blip_eq_t( double treble_db = 0 );
// See blip_buffer.txt
blip_eq_t( double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0 );
private:
double treble;
long rolloff_freq;
long sample_rate;
long cutoff_freq;
void generate( float* out, int count ) const;
friend class Blip_Synth_;
};
int const blip_sample_bits = 30;
// Dummy Blip_Buffer to direct sound output to, for easy muting without
// having to stop sound code.
class Silent_Blip_Buffer : public Blip_Buffer {
buf_t_ buf [blip_buffer_extra_ + 1];
public:
// The following cannot be used (an assertion will fail if attempted):
blargg_err_t set_sample_rate( long samples_per_sec, int msec_length );
blip_time_t count_clocks( long count ) const;
void mix_samples( blip_sample_t const* buf, long count );
Silent_Blip_Buffer();
};
#if defined (__GNUC__) || _MSC_VER >= 1100
#define BLIP_RESTRICT __restrict
#else
#define BLIP_RESTRICT
#endif
// Optimized reading from Blip_Buffer, for use in custom sample output
// Begin reading from buffer. Name should be unique to the current block.
#define BLIP_READER_BEGIN( name, blip_buffer ) \
const Blip_Buffer::buf_t_* BLIP_RESTRICT name##_reader_buf = (blip_buffer).buffer_;\
blip_long name##_reader_accum = (blip_buffer).reader_accum_
// Get value to pass to BLIP_READER_NEXT()
#define BLIP_READER_BASS( blip_buffer ) ((blip_buffer).bass_shift_)
// Constant value to use instead of BLIP_READER_BASS(), for slightly more optimal
// code at the cost of having no bass control
int const blip_reader_default_bass = 9;
// Current sample
#define BLIP_READER_READ( name ) (name##_reader_accum >> (blip_sample_bits - 16))
// Current raw sample in full internal resolution
#define BLIP_READER_READ_RAW( name ) (name##_reader_accum)
// Advance to next sample
#define BLIP_READER_NEXT( name, bass ) \
(void) (name##_reader_accum += *name##_reader_buf++ - (name##_reader_accum >> (bass)))
// End reading samples from buffer. The number of samples read must now be removed
// using Blip_Buffer::remove_samples().
#define BLIP_READER_END( name, blip_buffer ) \
(void) ((blip_buffer).reader_accum_ = name##_reader_accum)
// Compatibility with older version
const long blip_unscaled = 65535;
const int blip_low_quality = blip_med_quality;
const int blip_best_quality = blip_high_quality;
// Deprecated; use BLIP_READER macros as follows:
// Blip_Reader r; r.begin( buf ); -> BLIP_READER_BEGIN( r, buf );
// int bass = r.begin( buf ) -> BLIP_READER_BEGIN( r, buf ); int bass = BLIP_READER_BASS( buf );
// r.read() -> BLIP_READER_READ( r )
// r.read_raw() -> BLIP_READER_READ_RAW( r )
// r.next( bass ) -> BLIP_READER_NEXT( r, bass )
// r.next() -> BLIP_READER_NEXT( r, blip_reader_default_bass )
// r.end( buf ) -> BLIP_READER_END( r, buf )
class Blip_Reader {
public:
int begin( Blip_Buffer& );
blip_long read() const { return accum >> (blip_sample_bits - 16); }
blip_long read_raw() const { return accum; }
void next( int bass_shift = 9 ) { accum += *buf++ - (accum >> bass_shift); }
void end( Blip_Buffer& b ) { b.reader_accum_ = accum; }
private:
const Blip_Buffer::buf_t_* buf;
blip_long accum;
};
// End of public interface
#include <assert.h>
template<int quality,int range>
inline void Blip_Synth<quality,range>::offset_resampled( blip_resampled_time_t time,
int delta, Blip_Buffer* blip_buf ) const
{
// Fails if time is beyond end of Blip_Buffer, due to a bug in caller code or the
// need for a longer buffer as set by set_sample_rate().
assert( (blip_long) (time >> BLIP_BUFFER_ACCURACY) < blip_buf->buffer_size_ );
delta *= impl.delta_factor;
blip_long* BLIP_RESTRICT buf = blip_buf->buffer_ + (time >> BLIP_BUFFER_ACCURACY);
int phase = (int) (time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS) & (blip_res - 1));
#if BLIP_BUFFER_FAST
blip_long left = buf [0] + delta;
// Kind of crappy, but doing shift after multiply results in overflow.
// Alternate way of delaying multiply by delta_factor results in worse
// sub-sample resolution.
blip_long right = (delta >> BLIP_PHASE_BITS) * phase;
left -= right;
right += buf [1];
buf [0] = left;
buf [1] = right;
#else
int const fwd = (blip_widest_impulse_ - quality) / 2;
int const rev = fwd + quality - 2;
int const mid = quality / 2 - 1;
imp_t const* BLIP_RESTRICT imp = impulses + blip_res - phase;
#if defined (_M_IX86) || defined (_M_IA64) || defined (__i486__) || \
defined (__x86_64__) || defined (__ia64__) || defined (__i386__)
// straight forward implementation resulted in better code on GCC for x86
#define ADD_IMP( out, in ) \
buf [out] += (blip_long) imp [blip_res * (in)] * delta
#define BLIP_FWD( i ) {\
ADD_IMP( fwd + i, i );\
ADD_IMP( fwd + 1 + i, i + 1 );\
}
#define BLIP_REV( r ) {\
ADD_IMP( rev - r, r + 1 );\
ADD_IMP( rev + 1 - r, r );\
}
BLIP_FWD( 0 )
if ( quality > 8 ) BLIP_FWD( 2 )
if ( quality > 12 ) BLIP_FWD( 4 )
{
ADD_IMP( fwd + mid - 1, mid - 1 );
ADD_IMP( fwd + mid , mid );
imp = impulses + phase;
}
if ( quality > 12 ) BLIP_REV( 6 )
if ( quality > 8 ) BLIP_REV( 4 )
BLIP_REV( 2 )
ADD_IMP( rev , 1 );
ADD_IMP( rev + 1, 0 );
#else
// for RISC processors, help compiler by reading ahead of writes
#define BLIP_FWD( i ) {\
blip_long t0 = i0 * delta + buf [fwd + i];\
blip_long t1 = imp [blip_res * (i + 1)] * delta + buf [fwd + 1 + i];\
i0 = imp [blip_res * (i + 2)];\
buf [fwd + i] = t0;\
buf [fwd + 1 + i] = t1;\
}
#define BLIP_REV( r ) {\
blip_long t0 = i0 * delta + buf [rev - r];\
blip_long t1 = imp [blip_res * r] * delta + buf [rev + 1 - r];\
i0 = imp [blip_res * (r - 1)];\
buf [rev - r] = t0;\
buf [rev + 1 - r] = t1;\
}
blip_long i0 = *imp;
BLIP_FWD( 0 )
if ( quality > 8 ) BLIP_FWD( 2 )
if ( quality > 12 ) BLIP_FWD( 4 )
{
blip_long t0 = i0 * delta + buf [fwd + mid - 1];
blip_long t1 = imp [blip_res * mid] * delta + buf [fwd + mid ];
imp = impulses + phase;
i0 = imp [blip_res * mid];
buf [fwd + mid - 1] = t0;
buf [fwd + mid ] = t1;
}
if ( quality > 12 ) BLIP_REV( 6 )
if ( quality > 8 ) BLIP_REV( 4 )
BLIP_REV( 2 )
blip_long t0 = i0 * delta + buf [rev ];
blip_long t1 = *imp * delta + buf [rev + 1];
buf [rev ] = t0;
buf [rev + 1] = t1;
#endif
#endif
}
#undef BLIP_FWD
#undef BLIP_REV
template<int quality,int range>
#if BLIP_BUFFER_FAST
inline
#endif
void Blip_Synth<quality,range>::offset( blip_time_t t, int delta, Blip_Buffer* buf ) const
{
offset_resampled( t * buf->factor_ + buf->offset_, delta, buf );
}
template<int quality,int range>
#if BLIP_BUFFER_FAST
inline
#endif
void Blip_Synth<quality,range>::update( blip_time_t t, int amp )
{
int delta = amp - impl.last_amp;
impl.last_amp = amp;
offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf );
}
inline blip_eq_t::blip_eq_t( double t ) :
treble( t ), rolloff_freq( 0 ), sample_rate( 44100 ), cutoff_freq( 0 ) { }
inline blip_eq_t::blip_eq_t( double t, long rf, long sr, long cf ) :
treble( t ), rolloff_freq( rf ), sample_rate( sr ), cutoff_freq( cf ) { }
inline int Blip_Buffer::length() const { return length_; }
inline long Blip_Buffer::samples_avail() const { return (long) (offset_ >> BLIP_BUFFER_ACCURACY); }
inline long Blip_Buffer::sample_rate() const { return sample_rate_; }
inline int Blip_Buffer::output_latency() const { return blip_widest_impulse_ / 2; }
inline long Blip_Buffer::clock_rate() const { return clock_rate_; }
inline void Blip_Buffer::clock_rate( long cps ) { factor_ = clock_rate_factor( clock_rate_ = cps ); }
inline int Blip_Reader::begin( Blip_Buffer& blip_buf )
{
buf = blip_buf.buffer_;
accum = blip_buf.reader_accum_;
return blip_buf.bass_shift_;
}
int const blip_max_length = 0;
int const blip_default_length = 250;
#endif
diff --git a/src/libs/gme/Classic_Emu.cpp b/src/libs/gme/Classic_Emu.cpp
index 9b68a445..c572d9b5 100644
--- a/src/libs/gme/Classic_Emu.cpp
+++ b/src/libs/gme/Classic_Emu.cpp
@@ -1,184 +1,190 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Classic_Emu.h"
#include "Multi_Buffer.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
Classic_Emu::Classic_Emu()
{
buf = 0;
stereo_buffer = 0;
voice_types = 0;
// avoid inconsistency in our duplicated constants
assert( (int) wave_type == (int) Multi_Buffer::wave_type );
assert( (int) noise_type == (int) Multi_Buffer::noise_type );
assert( (int) mixed_type == (int) Multi_Buffer::mixed_type );
}
Classic_Emu::~Classic_Emu()
{
delete stereo_buffer;
}
void Classic_Emu::set_equalizer_( equalizer_t const& eq )
{
Music_Emu::set_equalizer_( eq );
update_eq( eq.treble );
if ( buf )
buf->bass_freq( (int) equalizer().bass );
}
blargg_err_t Classic_Emu::set_sample_rate_( long rate )
{
if ( !buf )
{
if ( !stereo_buffer )
CHECK_ALLOC( stereo_buffer = BLARGG_NEW Stereo_Buffer );
buf = stereo_buffer;
}
return buf->set_sample_rate( rate, 1000 / 20 );
}
+blargg_err_t Classic_Emu::set_multi_channel ( bool is_enabled )
+{
+ RETURN_ERR( Music_Emu::set_multi_channel_( is_enabled ) );
+ return 0;
+}
+
void Classic_Emu::mute_voices_( int mask )
{
Music_Emu::mute_voices_( mask );
for ( int i = voice_count(); i--; )
{
if ( mask & (1 << i) )
{
set_voice( i, 0, 0, 0 );
}
else
{
Multi_Buffer::channel_t ch = buf->channel( i, (voice_types ? voice_types [i] : 0) );
assert( (ch.center && ch.left && ch.right) ||
(!ch.center && !ch.left && !ch.right) ); // all or nothing
set_voice( i, ch.center, ch.left, ch.right );
}
}
}
void Classic_Emu::change_clock_rate( long rate )
{
clock_rate_ = rate;
buf->clock_rate( rate );
}
blargg_err_t Classic_Emu::setup_buffer( long rate )
{
change_clock_rate( rate );
RETURN_ERR( buf->set_channel_count( voice_count() ) );
set_equalizer( equalizer() );
buf_changed_count = buf->channels_changed_count();
return 0;
}
blargg_err_t Classic_Emu::start_track_( int track )
{
RETURN_ERR( Music_Emu::start_track_( track ) );
buf->clear();
return 0;
}
blargg_err_t Classic_Emu::play_( long count, sample_t* out )
{
long remain = count;
while ( remain )
{
remain -= buf->read_samples( &out [count - remain], remain );
if ( remain )
{
if ( buf_changed_count != buf->channels_changed_count() )
{
buf_changed_count = buf->channels_changed_count();
remute_voices();
}
int msec = buf->length();
blip_time_t clocks_emulated = (blargg_long) msec * clock_rate_ / 1000;
RETURN_ERR( run_clocks( clocks_emulated, msec ) );
assert( clocks_emulated );
buf->end_frame( clocks_emulated );
}
}
return 0;
}
// Rom_Data
blargg_err_t Rom_Data_::load_rom_data_( Data_Reader& in,
int header_size, void* header_out, int fill, long pad_size )
{
long file_offset = pad_size - header_size;
rom_addr = 0;
mask = 0;
size_ = 0;
rom.clear();
file_size_ = in.remain();
if ( file_size_ <= header_size ) // <= because there must be data after header
return gme_wrong_file_type;
blargg_err_t err = rom.resize( file_offset + file_size_ + pad_size );
if ( !err )
err = in.read( rom.begin() + file_offset, file_size_ );
if ( err )
{
rom.clear();
return err;
}
file_size_ -= header_size;
memcpy( header_out, &rom [file_offset], header_size );
memset( rom.begin() , fill, pad_size );
memset( rom.end() - pad_size, fill, pad_size );
return 0;
}
void Rom_Data_::set_addr_( long addr, int unit )
{
rom_addr = addr - unit - pad_extra;
long rounded = (addr + file_size_ + unit - 1) / unit * unit;
if ( rounded <= 0 )
{
rounded = 0;
}
else
{
int shift = 0;
unsigned long max_addr = (unsigned long) (rounded - 1);
while ( max_addr >> shift )
shift++;
mask = (1L << shift) - 1;
}
if ( addr < 0 )
addr = 0;
size_ = rounded;
if ( rom.resize( rounded - rom_addr + pad_extra ) ) { } // OK if shrink fails
if ( 0 )
{
debug_printf( "addr: %X\n", addr );
debug_printf( "file_size: %d\n", file_size_ );
debug_printf( "rounded: %d\n", rounded );
debug_printf( "mask: $%X\n", mask );
}
}
diff --git a/src/libs/gme/Classic_Emu.h b/src/libs/gme/Classic_Emu.h
index d0cfda25..57cdd5c3 100644
--- a/src/libs/gme/Classic_Emu.h
+++ b/src/libs/gme/Classic_Emu.h
@@ -1,127 +1,128 @@
// Common aspects of emulators which use Blip_Buffer for sound output
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef CLASSIC_EMU_H
#define CLASSIC_EMU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
#include "Music_Emu.h"
class Classic_Emu : public Music_Emu {
public:
Classic_Emu();
~Classic_Emu();
void set_buffer( Multi_Buffer* );
+ blargg_err_t set_multi_channel( bool is_enabled ) override;
protected:
// Services
enum { wave_type = 0x100, noise_type = 0x200, mixed_type = wave_type | noise_type };
void set_voice_types( int const* t ) { voice_types = t; }
blargg_err_t setup_buffer( long clock_rate );
long clock_rate() const { return clock_rate_; }
void change_clock_rate( long ); // experimental
// Overridable
virtual void set_voice( int index, Blip_Buffer* center,
Blip_Buffer* left, Blip_Buffer* right ) = 0;
virtual void update_eq( blip_eq_t const& ) = 0;
virtual blargg_err_t start_track_( int track ) = 0;
virtual blargg_err_t run_clocks( blip_time_t& time_io, int msec ) = 0;
protected:
blargg_err_t set_sample_rate_( long sample_rate );
void mute_voices_( int );
void set_equalizer_( equalizer_t const& );
blargg_err_t play_( long, sample_t* );
private:
Multi_Buffer* buf;
Multi_Buffer* stereo_buffer; // NULL if using custom buffer
long clock_rate_;
unsigned buf_changed_count;
int const* voice_types;
};
inline void Classic_Emu::set_buffer( Multi_Buffer* new_buf )
{
assert( !buf && new_buf );
buf = new_buf;
}
// ROM data handler, used by several Classic_Emu derivitives. Loads file data
// with padding on both sides, allowing direct use in bank mapping. The main purpose
// is to allow all file data to be loaded with only one read() call (for efficiency).
class Rom_Data_ {
public:
typedef unsigned char byte;
protected:
enum { pad_extra = 8 };
blargg_vector<byte> rom;
long file_size_;
blargg_long rom_addr;
blargg_long mask;
blargg_long size_; // TODO: eliminate
blargg_err_t load_rom_data_( Data_Reader& in, int header_size, void* header_out,
int fill, long pad_size );
void set_addr_( long addr, int unit );
};
template<int unit>
class Rom_Data : public Rom_Data_ {
enum { pad_size = unit + pad_extra };
public:
// Load file data, using already-loaded header 'h' if not NULL. Copy header
// from loaded file data into *out and fill unmapped bytes with 'fill'.
blargg_err_t load( Data_Reader& in, int header_size, void* header_out, int fill )
{
return load_rom_data_( in, header_size, header_out, fill, pad_size );
}
// Size of file data read in (excluding header)
long file_size() const { return file_size_; }
// Pointer to beginning of file data
byte* begin() const { return rom.begin() + pad_size; }
// Set address that file data should start at
void set_addr( long addr ) { set_addr_( addr, unit ); }
// Free data
void clear() { rom.clear(); }
// Size of data + start addr, rounded to a multiple of unit
long size() const { return size_; }
// Pointer to unmapped page filled with same value
byte* unmapped() { return rom.begin(); }
// Mask address to nearest power of two greater than size()
blargg_long mask_addr( blargg_long addr ) const
{
#ifdef check
check( addr <= mask );
#endif
return addr & mask;
}
// Pointer to page starting at addr. Returns unmapped() if outside data.
byte* at_addr( blargg_long addr )
{
blargg_ulong offset = mask_addr( addr ) - rom_addr;
if ( offset > blargg_ulong (rom.size() - pad_size) )
offset = 0; // unmapped
return &rom [offset];
}
};
#ifndef GME_APU_HOOK
#define GME_APU_HOOK( emu, addr, data ) ((void) 0)
#endif
#ifndef GME_FRAME_HOOK
#define GME_FRAME_HOOK( emu ) ((void) 0)
#else
#define GME_FRAME_HOOK_DEFINED 1
#endif
#endif
diff --git a/src/libs/gme/Data_Reader.h b/src/libs/gme/Data_Reader.h
index acf571f6..6c22b678 100644
--- a/src/libs/gme/Data_Reader.h
+++ b/src/libs/gme/Data_Reader.h
@@ -1,151 +1,153 @@
// Data reader interface for uniform access
// File_Extractor 0.4.0
#ifndef DATA_READER_H
#define DATA_READER_H
#include "blargg_common.h"
// Supports reading and finding out how many bytes are remaining
class Data_Reader {
public:
virtual ~Data_Reader() { }
static const char eof_error []; // returned by read() when request goes beyond end
// Read at most count bytes and return number actually read, or <= 0 if error
virtual long read_avail( void*, long n ) = 0;
// Read exactly count bytes and return error if they couldn't be read
virtual blargg_err_t read( void*, long count );
// Number of bytes remaining until end of file
virtual long remain() const = 0;
// Read and discard count bytes
virtual blargg_err_t skip( long count );
public:
Data_Reader() { }
typedef blargg_err_t error_t; // deprecated
private:
// noncopyable
Data_Reader( const Data_Reader& );
Data_Reader& operator = ( const Data_Reader& );
};
// Supports seeking in addition to Data_Reader operations
class File_Reader : public Data_Reader {
public:
// Size of file
virtual long size() const = 0;
// Current position in file
virtual long tell() const = 0;
// Go to new position
virtual blargg_err_t seek( long ) = 0;
long remain() const;
blargg_err_t skip( long n );
};
// Disk file reader
class Std_File_Reader : public File_Reader {
public:
blargg_err_t open( const char* path );
void close();
public:
Std_File_Reader();
~Std_File_Reader();
long size() const;
blargg_err_t read( void*, long );
long read_avail( void*, long );
long tell() const;
blargg_err_t seek( long );
private:
void* file_;
};
// Treats range of memory as a file
class Mem_File_Reader : public File_Reader {
public:
Mem_File_Reader( const void*, long size );
public:
long size() const;
long read_avail( void*, long );
long tell() const;
blargg_err_t seek( long );
private:
const char* const begin;
const long size_;
long pos;
};
// Makes it look like there are only count bytes remaining
class Subset_Reader : public Data_Reader {
public:
Subset_Reader( Data_Reader*, long count );
public:
long remain() const;
long read_avail( void*, long );
private:
Data_Reader* in;
long remain_;
};
// Joins already-read header and remaining data into original file (to avoid seeking)
class Remaining_Reader : public Data_Reader {
public:
Remaining_Reader( void const* header, long size, Data_Reader* );
public:
long remain() const;
long read_avail( void*, long );
blargg_err_t read( void*, long );
private:
char const* header;
char const* header_end;
Data_Reader* in;
long read_first( void* out, long count );
};
// Invokes callback function to read data. Size of data must be specified in advance.
class Callback_Reader : public Data_Reader {
public:
typedef const char* (*callback_t)( void* data, void* out, int count );
Callback_Reader( callback_t, long size, void* data = 0 );
public:
long read_avail( void*, long );
blargg_err_t read( void*, long );
long remain() const;
private:
callback_t const callback;
void* const data;
long remain_;
};
#ifdef HAVE_ZLIB_H
+#include <zlib.h>
+
// Gzip compressed file reader
class Gzip_File_Reader : public File_Reader {
public:
blargg_err_t open( const char* path );
void close();
public:
Gzip_File_Reader();
~Gzip_File_Reader();
long size() const;
long read_avail( void*, long );
long tell() const;
blargg_err_t seek( long );
private:
- void* file_;
+ gzFile file_;
long size_;
};
#endif
#endif
diff --git a/src/libs/gme/Dual_Resampler.cpp b/src/libs/gme/Dual_Resampler.cpp
index 6af295fc..9ca70cc7 100644
--- a/src/libs/gme/Dual_Resampler.cpp
+++ b/src/libs/gme/Dual_Resampler.cpp
@@ -1,133 +1,137 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Dual_Resampler.h"
#include <stdlib.h>
#include <string.h>
/* Copyright (C) 2003-2006 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"
unsigned const resampler_extra = 256;
-Dual_Resampler::Dual_Resampler():
-sample_buf_size(0){
+Dual_Resampler::Dual_Resampler() :
+ sample_buf_size(0),
+ oversamples_per_frame(-1),
+ buf_pos(-1),
+ resampler_size(0)
+{
}
Dual_Resampler::~Dual_Resampler() { }
blargg_err_t Dual_Resampler::reset( int pairs )
{
// expand allocations a bit
RETURN_ERR( sample_buf.resize( (pairs + (pairs >> 2)) * 2 ) );
resize( pairs );
resampler_size = oversamples_per_frame + (oversamples_per_frame >> 2);
return resampler.buffer_size( resampler_size );
}
void Dual_Resampler::resize( int pairs )
{
int new_sample_buf_size = pairs * 2;
if ( sample_buf_size != new_sample_buf_size )
{
if ( (unsigned) new_sample_buf_size > sample_buf.size() )
{
check( false );
return;
}
sample_buf_size = new_sample_buf_size;
oversamples_per_frame = int (pairs * resampler.ratio()) * 2 + 2;
clear();
}
}
void Dual_Resampler::play_frame_( Blip_Buffer& blip_buf, dsample_t* out )
{
long pair_count = sample_buf_size >> 1;
blip_time_t blip_time = blip_buf.count_clocks( pair_count );
int sample_count = oversamples_per_frame - resampler.written();
int new_count = play_frame( blip_time, sample_count, resampler.buffer() );
assert( new_count < resampler_size );
blip_buf.end_frame( blip_time );
assert( blip_buf.samples_avail() == pair_count );
resampler.write( new_count );
long count = resampler.read( sample_buf.begin(), sample_buf_size );
assert( count == (long) sample_buf_size );
mix_samples( blip_buf, out );
blip_buf.remove_samples( pair_count );
}
void Dual_Resampler::dual_play( long count, dsample_t* out, Blip_Buffer& blip_buf )
{
// empty extra buffer
long remain = sample_buf_size - buf_pos;
if ( remain )
{
if ( remain > count )
remain = count;
count -= remain;
memcpy( out, &sample_buf [buf_pos], remain * sizeof *out );
out += remain;
buf_pos += remain;
}
// entire frames
while ( count >= (long) sample_buf_size )
{
play_frame_( blip_buf, out );
out += sample_buf_size;
count -= sample_buf_size;
}
// extra
if ( count )
{
play_frame_( blip_buf, sample_buf.begin() );
buf_pos = count;
memcpy( out, sample_buf.begin(), count * sizeof *out );
out += count;
}
}
void Dual_Resampler::mix_samples( Blip_Buffer& blip_buf, dsample_t* out )
{
Blip_Reader sn;
int bass = sn.begin( blip_buf );
const dsample_t* in = sample_buf.begin();
for ( int n = sample_buf_size >> 1; n--; )
{
int s = sn.read();
blargg_long l = (blargg_long) in [0] * 2 + s;
- if ( (BOOST::int16_t) l != l )
+ if ( (int16_t) l != l )
l = 0x7FFF - (l >> 24);
sn.next( bass );
blargg_long r = (blargg_long) in [1] * 2 + s;
- if ( (BOOST::int16_t) r != r )
+ if ( (int16_t) r != r )
r = 0x7FFF - (r >> 24);
in += 2;
out [0] = l;
out [1] = r;
out += 2;
}
sn.end( blip_buf );
}
diff --git a/src/libs/gme/Dual_Resampler.h b/src/libs/gme/Dual_Resampler.h
index e3194fe7..512fd97d 100644
--- a/src/libs/gme/Dual_Resampler.h
+++ b/src/libs/gme/Dual_Resampler.h
@@ -1,50 +1,50 @@
// Combination of Fir_Resampler and Blip_Buffer mixing. Used by Sega FM emulators.
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef DUAL_RESAMPLER_H
#define DUAL_RESAMPLER_H
#include "Fir_Resampler.h"
#include "Blip_Buffer.h"
class Dual_Resampler {
public:
Dual_Resampler();
virtual ~Dual_Resampler();
typedef short dsample_t;
double setup( double oversample, double rolloff, double gain );
blargg_err_t reset( int max_pairs );
void resize( int pairs_per_frame );
void clear();
void dual_play( long count, dsample_t* out, Blip_Buffer& );
protected:
virtual int play_frame( blip_time_t, int pcm_count, dsample_t* pcm_out ) = 0;
private:
blargg_vector<dsample_t> sample_buf;
int sample_buf_size;
int oversamples_per_frame;
int buf_pos;
int resampler_size;
Fir_Resampler<12> resampler;
void mix_samples( Blip_Buffer&, dsample_t* );
void play_frame_( Blip_Buffer&, dsample_t* );
};
inline double Dual_Resampler::setup( double oversample, double rolloff, double gain )
{
return resampler.time_ratio( oversample, rolloff, gain * 0.5 );
}
inline void Dual_Resampler::clear()
{
buf_pos = sample_buf_size;
resampler.clear();
}
#endif
diff --git a/src/libs/gme/Effects_Buffer.cpp b/src/libs/gme/Effects_Buffer.cpp
index 181b11e9..56b0c5b5 100644
--- a/src/libs/gme/Effects_Buffer.cpp
+++ b/src/libs/gme/Effects_Buffer.cpp
@@ -1,529 +1,595 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Effects_Buffer.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
typedef blargg_long fixed_t;
#define TO_FIXED( f ) fixed_t ((f) * (1L << 15) + 0.5)
#define FMUL( x, y ) (((x) * (y)) >> 15)
const unsigned echo_size = 4096;
const unsigned echo_mask = echo_size - 1;
BOOST_STATIC_ASSERT( (echo_size & echo_mask) == 0 ); // must be power of 2
const unsigned reverb_size = 8192 * 2;
const unsigned reverb_mask = reverb_size - 1;
BOOST_STATIC_ASSERT( (reverb_size & reverb_mask) == 0 ); // must be power of 2
Effects_Buffer::config_t::config_t()
{
pan_1 = -0.15f;
pan_2 = 0.15f;
reverb_delay = 88.0f;
reverb_level = 0.12f;
echo_delay = 61.0f;
echo_level = 0.10f;
delay_variance = 18.0f;
effects_enabled = false;
}
void Effects_Buffer::set_depth( double d )
{
float f = (float) d;
config_t c;
c.pan_1 = -0.6f * f;
c.pan_2 = 0.6f * f;
c.reverb_delay = 880 * 0.1f;
c.echo_delay = 610 * 0.1f;
if ( f > 0.5 )
f = 0.5; // TODO: more linear reduction of extreme reverb/echo
c.reverb_level = 0.5f * f;
c.echo_level = 0.30f * f;
c.delay_variance = 180 * 0.1f;
c.effects_enabled = (d > 0.0f);
config( c );
}
-Effects_Buffer::Effects_Buffer( bool center_only ) : Multi_Buffer( 2 )
+Effects_Buffer::Effects_Buffer( int num_voices, bool center_only )
+ : Multi_Buffer( 2*num_voices )
+ , max_voices(num_voices)
+ , bufs(max_voices * (center_only ? (max_buf_count - 4) : max_buf_count))
+ , chan_types(max_voices * chan_types_count)
+ , stereo_remain(0)
+ , effect_remain(0)
+ // TODO: Reorder buf_count to be initialized before bufs to factor out channel sizing
+ , buf_count(max_voices * (center_only ? (max_buf_count - 4) : max_buf_count))
+ , effects_enabled(false)
+ , reverb_buf(max_voices, std::vector<blip_sample_t>(reverb_size))
+ , echo_buf(max_voices, std::vector<blip_sample_t>(echo_size))
+ , reverb_pos(max_voices)
+ , echo_pos(max_voices)
{
- buf_count = center_only ? max_buf_count - 4 : max_buf_count;
-
- echo_pos = 0;
- reverb_pos = 0;
-
- stereo_remain = 0;
- effect_remain = 0;
- effects_enabled = false;
set_depth( 0 );
}
-Effects_Buffer::~Effects_Buffer() { }
+Effects_Buffer::~Effects_Buffer()
+{}
blargg_err_t Effects_Buffer::set_sample_rate( long rate, int msec )
{
- if ( !echo_buf.size() )
- RETURN_ERR( echo_buf.resize( echo_size ) );
-
- if ( !reverb_buf.size() )
- RETURN_ERR( reverb_buf.resize( reverb_size ) );
-
+ try
+ {
+ for(int i=0; i<max_voices; i++)
+ {
+ if ( !echo_buf[i].size() )
+ {
+ echo_buf[i].resize( echo_size );
+ }
+
+ if ( !reverb_buf[i].size() )
+ {
+ reverb_buf[i].resize( reverb_size );
+ }
+ }
+ }
+ catch(std::bad_alloc& ba)
+ {
+ return "Out of memory";
+ }
+
for ( int i = 0; i < buf_count; i++ )
RETURN_ERR( bufs [i].set_sample_rate( rate, msec ) );
config( config_ );
clear();
return Multi_Buffer::set_sample_rate( bufs [0].sample_rate(), bufs [0].length() );
}
void Effects_Buffer::clock_rate( long rate )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].clock_rate( rate );
}
void Effects_Buffer::bass_freq( int freq )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].bass_freq( freq );
}
void Effects_Buffer::clear()
{
stereo_remain = 0;
effect_remain = 0;
- if ( echo_buf.size() )
- memset( &echo_buf [0], 0, echo_size * sizeof echo_buf [0] );
-
- if ( reverb_buf.size() )
- memset( &reverb_buf [0], 0, reverb_size * sizeof reverb_buf [0] );
-
+
+ for(int i=0; i<max_voices; i++)
+ {
+ if ( echo_buf[i].size() )
+ memset( &echo_buf[i][0], 0, echo_size * sizeof echo_buf[i][0] );
+
+ if ( reverb_buf[i].size() )
+ memset( &reverb_buf[i][0], 0, reverb_size * sizeof reverb_buf[i][0] );
+ }
+
for ( int i = 0; i < buf_count; i++ )
bufs [i].clear();
}
inline int pin_range( int n, int max, int min = 0 )
{
if ( n < min )
return min;
if ( n > max )
return max;
return n;
}
void Effects_Buffer::config( const config_t& cfg )
{
channels_changed();
// clear echo and reverb buffers
- if ( !config_.effects_enabled && cfg.effects_enabled && echo_buf.size() )
+ // ensure the echo/reverb buffers have already been allocated, so this method can be
+ // called before set_sample_rate is called
+ if ( !config_.effects_enabled && cfg.effects_enabled && echo_buf[0].size() )
{
- memset( &echo_buf [0], 0, echo_size * sizeof echo_buf [0] );
- memset( &reverb_buf [0], 0, reverb_size * sizeof reverb_buf [0] );
+ for(int i=0; i<max_voices; i++)
+ {
+ memset( &echo_buf[i][0], 0, echo_size * sizeof echo_buf[i][0] );
+ memset( &reverb_buf[i][0], 0, reverb_size * sizeof reverb_buf[i][0] );
+ }
}
-
+
config_ = cfg;
if ( config_.effects_enabled )
{
// convert to internal format
chans.pan_1_levels [0] = TO_FIXED( 1 ) - TO_FIXED( config_.pan_1 );
chans.pan_1_levels [1] = TO_FIXED( 2 ) - chans.pan_1_levels [0];
chans.pan_2_levels [0] = TO_FIXED( 1 ) - TO_FIXED( config_.pan_2 );
chans.pan_2_levels [1] = TO_FIXED( 2 ) - chans.pan_2_levels [0];
chans.reverb_level = TO_FIXED( config_.reverb_level );
chans.echo_level = TO_FIXED( config_.echo_level );
int delay_offset = int (1.0 / 2000 * config_.delay_variance * sample_rate());
int reverb_sample_delay = int (1.0 / 1000 * config_.reverb_delay * sample_rate());
chans.reverb_delay_l = pin_range( reverb_size -
(reverb_sample_delay - delay_offset) * 2, reverb_size - 2, 0 );
chans.reverb_delay_r = pin_range( reverb_size + 1 -
(reverb_sample_delay + delay_offset) * 2, reverb_size - 1, 1 );
int echo_sample_delay = int (1.0 / 1000 * config_.echo_delay * sample_rate());
chans.echo_delay_l = pin_range( echo_size - 1 - (echo_sample_delay - delay_offset),
echo_size - 1 );
chans.echo_delay_r = pin_range( echo_size - 1 - (echo_sample_delay + delay_offset),
echo_size - 1 );
- chan_types [0].center = &bufs [0];
- chan_types [0].left = &bufs [3];
- chan_types [0].right = &bufs [4];
-
- chan_types [1].center = &bufs [1];
- chan_types [1].left = &bufs [3];
- chan_types [1].right = &bufs [4];
-
- chan_types [2].center = &bufs [2];
- chan_types [2].left = &bufs [5];
- chan_types [2].right = &bufs [6];
+ for(int i=0; i<max_voices; i++)
+ {
+ chan_types [i*chan_types_count+0].center = &bufs [i*max_buf_count+0];
+ chan_types [i*chan_types_count+0].left = &bufs [i*max_buf_count+3];
+ chan_types [i*chan_types_count+0].right = &bufs [i*max_buf_count+4];
+
+ chan_types [i*chan_types_count+1].center = &bufs [i*max_buf_count+1];
+ chan_types [i*chan_types_count+1].left = &bufs [i*max_buf_count+3];
+ chan_types [i*chan_types_count+1].right = &bufs [i*max_buf_count+4];
+
+ chan_types [i*chan_types_count+2].center = &bufs [i*max_buf_count+2];
+ chan_types [i*chan_types_count+2].left = &bufs [i*max_buf_count+5];
+ chan_types [i*chan_types_count+2].right = &bufs [i*max_buf_count+6];
+ }
assert( 2 < chan_types_count );
}
else
{
- // set up outputs
- for ( unsigned i = 0; i < chan_types_count; i++ )
+ for(int i=0; i<max_voices; i++)
{
- channel_t& c = chan_types [i];
- c.center = &bufs [0];
- c.left = &bufs [1];
- c.right = &bufs [2];
+ // set up outputs
+ for ( int j = 0; j < chan_types_count; j++ )
+ {
+ channel_t& c = chan_types [i*chan_types_count+j];
+ c.center = &bufs [i*max_buf_count+0];
+ c.left = &bufs [i*max_buf_count+1];
+ c.right = &bufs [i*max_buf_count+2];
+ }
}
}
- if ( buf_count < max_buf_count )
+ if ( buf_count < max_buf_count ) // if center_only
{
- for ( int i = 0; i < chan_types_count; i++ )
+ for(int i=0; i<max_voices; i++)
{
- channel_t& c = chan_types [i];
- c.left = c.center;
- c.right = c.center;
+ for ( int j = 0; j < chan_types_count; j++ )
+ {
+ channel_t& c = chan_types [i*chan_types_count+j];
+ c.left = c.center;
+ c.right = c.center;
+ }
}
}
}
Effects_Buffer::channel_t Effects_Buffer::channel( int i, int type )
{
- int out = 2;
+ int out = chan_types_count-1;
if ( !type )
{
out = i % 5;
- if ( out > 2 )
- out = 2;
+ if ( out > chan_types_count-1 )
+ out = chan_types_count-1;
}
else if ( !(type & noise_type) && (type & type_index_mask) % 3 != 0 )
{
out = type & 1;
}
- return chan_types [out];
+ return chan_types [(i%max_voices)*chan_types_count+out];
}
void Effects_Buffer::end_frame( blip_time_t clock_count )
{
int bufs_used = 0;
- for ( int i = 0; i < buf_count; i++ )
+ int stereo_mask = (config_.effects_enabled ? 0x78 : 0x06);
+
+ const int buf_count_per_voice = buf_count/max_voices;
+ for ( int v = 0; v < max_voices; v++ ) // foreach voice
{
- bufs_used |= bufs [i].clear_modified() << i;
- bufs [i].end_frame( clock_count );
+ for ( int i = 0; i < buf_count_per_voice; i++) // foreach buffer of that voice
+ {
+ bufs_used |= bufs [v*buf_count_per_voice + i].clear_modified() << i;
+ bufs [v*buf_count_per_voice + i].end_frame( clock_count );
+
+ if ( (bufs_used & stereo_mask) && buf_count == max_voices*max_buf_count )
+ stereo_remain = max(stereo_remain, bufs [v*buf_count_per_voice + i].samples_avail() + bufs [v*buf_count_per_voice + i].output_latency());
+ if ( effects_enabled || config_.effects_enabled )
+ effect_remain = max(effect_remain, bufs [v*buf_count_per_voice + i].samples_avail() + bufs [v*buf_count_per_voice + i].output_latency());
+ }
+ bufs_used = 0;
}
- int stereo_mask = (config_.effects_enabled ? 0x78 : 0x06);
- if ( (bufs_used & stereo_mask) && buf_count == max_buf_count )
- stereo_remain = bufs [0].samples_avail() + bufs [0].output_latency();
-
- if ( effects_enabled || config_.effects_enabled )
- effect_remain = bufs [0].samples_avail() + bufs [0].output_latency();
-
effects_enabled = config_.effects_enabled;
}
long Effects_Buffer::samples_avail() const
{
return bufs [0].samples_avail() * 2;
}
long Effects_Buffer::read_samples( blip_sample_t* out, long total_samples )
{
- require( total_samples % 2 == 0 ); // count must be even
-
+ const int n_channels = max_voices * 2;
+ const int buf_count_per_voice = buf_count/max_voices;
+
+ require( total_samples % n_channels == 0 ); // as many items needed to fill at least one frame
+
long remain = bufs [0].samples_avail();
- if ( remain > (total_samples >> 1) )
- remain = (total_samples >> 1);
- total_samples = remain;
+ total_samples = remain = min( remain, total_samples/n_channels );
+
while ( remain )
{
- int active_bufs = buf_count;
+ int active_bufs = buf_count_per_voice;
long count = remain;
// optimizing mixing to skip any channels which had nothing added
if ( effect_remain )
{
if ( count > effect_remain )
count = effect_remain;
if ( stereo_remain )
{
mix_enhanced( out, count );
}
else
{
mix_mono_enhanced( out, count );
active_bufs = 3;
}
}
else if ( stereo_remain )
{
mix_stereo( out, count );
active_bufs = 3;
}
else
{
mix_mono( out, count );
active_bufs = 1;
}
- out += count * 2;
+ out += count * n_channels;
remain -= count;
stereo_remain -= count;
if ( stereo_remain < 0 )
stereo_remain = 0;
effect_remain -= count;
if ( effect_remain < 0 )
effect_remain = 0;
- for ( int i = 0; i < buf_count; i++ )
+ // skip the output from any buffers that didn't contribute to the sound output
+ // during this frame (e.g. if we only render mono then only the very first buf
+ // is 'active')
+ for ( int v = 0; v < max_voices; v++ ) // foreach voice
{
- if ( i < active_bufs )
- bufs [i].remove_samples( count );
- else
- bufs [i].remove_silence( count ); // keep time synchronized
+ for ( int i = 0; i < buf_count_per_voice; i++) // foreach buffer of that voice
+ {
+ if ( i < active_bufs )
+ bufs [v*buf_count_per_voice + i].remove_samples( count );
+ else // keep time synchronized
+ bufs [v*buf_count_per_voice + i].remove_silence( count );
+ }
}
}
- return total_samples * 2;
+ return total_samples * n_channels;
}
void Effects_Buffer::mix_mono( blip_sample_t* out_, blargg_long count )
{
+ for(int i=0; i<max_voices; i++)
+ {
blip_sample_t* BLIP_RESTRICT out = out_;
- int const bass = BLIP_READER_BASS( bufs [0] );
- BLIP_READER_BEGIN( c, bufs [0] );
+ int const bass = BLIP_READER_BASS( bufs [i*max_buf_count+0] );
+ BLIP_READER_BEGIN( c, bufs [i*max_buf_count+0] );
// unrolled loop
for ( blargg_long n = count >> 1; n; --n )
{
blargg_long cs0 = BLIP_READER_READ( c );
BLIP_READER_NEXT( c, bass );
blargg_long cs1 = BLIP_READER_READ( c );
BLIP_READER_NEXT( c, bass );
- if ( (BOOST::int16_t) cs0 != cs0 )
+ if ( (int16_t) cs0 != cs0 )
cs0 = 0x7FFF - (cs0 >> 24);
- ((BOOST::uint32_t*) out) [0] = ((BOOST::uint16_t) cs0) | (cs0 << 16);
+ ((uint32_t*) out) [i*2+0] = ((uint16_t) cs0) | (uint16_t(cs0) << 16);
- if ( (BOOST::int16_t) cs1 != cs1 )
+ if ( (int16_t) cs1 != cs1 )
cs1 = 0x7FFF - (cs1 >> 24);
- ((BOOST::uint32_t*) out) [1] = ((BOOST::uint16_t) cs1) | (cs1 << 16);
- out += 4;
+ ((uint32_t*) out) [i*2+1] = ((uint16_t) cs1) | (uint16_t(cs1) << 16);
+ out += max_voices*4;
}
if ( count & 1 )
{
int s = BLIP_READER_READ( c );
BLIP_READER_NEXT( c, bass );
- out [0] = s;
- out [1] = s;
- if ( (BOOST::int16_t) s != s )
+ out [i*2+0] = s;
+ out [i*2+1] = s;
+ if ( (int16_t) s != s )
{
s = 0x7FFF - (s >> 24);
- out [0] = s;
- out [1] = s;
+ out [i*2+0] = s;
+ out [i*2+1] = s;
}
}
- BLIP_READER_END( c, bufs [0] );
+ BLIP_READER_END( c, bufs [i*max_buf_count+0] );
+ }
}
-void Effects_Buffer::mix_stereo( blip_sample_t* out_, blargg_long count )
+void Effects_Buffer::mix_stereo( blip_sample_t* out_, blargg_long frames )
{
+ for(int i=0; i<max_voices; i++)
+ {
blip_sample_t* BLIP_RESTRICT out = out_;
- int const bass = BLIP_READER_BASS( bufs [0] );
- BLIP_READER_BEGIN( c, bufs [0] );
- BLIP_READER_BEGIN( l, bufs [1] );
- BLIP_READER_BEGIN( r, bufs [2] );
-
+ int const bass = BLIP_READER_BASS( bufs [i*max_buf_count+0] );
+ BLIP_READER_BEGIN( c, bufs [i*max_buf_count+0] );
+ BLIP_READER_BEGIN( l, bufs [i*max_buf_count+1] );
+ BLIP_READER_BEGIN( r, bufs [i*max_buf_count+2] );
+
+ int count = frames;
while ( count-- )
{
int cs = BLIP_READER_READ( c );
BLIP_READER_NEXT( c, bass );
int left = cs + BLIP_READER_READ( l );
int right = cs + BLIP_READER_READ( r );
BLIP_READER_NEXT( l, bass );
BLIP_READER_NEXT( r, bass );
- if ( (BOOST::int16_t) left != left )
+ if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
- out [0] = left;
- out [1] = right;
+ if ( (int16_t) right != right )
+ right = 0x7FFF - (right >> 24);
+
+ out [i*2+0] = left;
+ out [i*2+1] = right;
- out += 2;
+ out += max_voices*2;
- if ( (BOOST::int16_t) right != right )
- out [-1] = 0x7FFF - (right >> 24);
}
- BLIP_READER_END( r, bufs [2] );
- BLIP_READER_END( l, bufs [1] );
- BLIP_READER_END( c, bufs [0] );
+ BLIP_READER_END( r, bufs [i*max_buf_count+2] );
+ BLIP_READER_END( l, bufs [i*max_buf_count+1] );
+ BLIP_READER_END( c, bufs [i*max_buf_count+0] );
+ }
}
-void Effects_Buffer::mix_mono_enhanced( blip_sample_t* out_, blargg_long count )
+void Effects_Buffer::mix_mono_enhanced( blip_sample_t* out_, blargg_long frames )
{
+ for(int i=0; i<max_voices; i++)
+ {
blip_sample_t* BLIP_RESTRICT out = out_;
- int const bass = BLIP_READER_BASS( bufs [2] );
- BLIP_READER_BEGIN( center, bufs [2] );
- BLIP_READER_BEGIN( sq1, bufs [0] );
- BLIP_READER_BEGIN( sq2, bufs [1] );
+ int const bass = BLIP_READER_BASS( bufs [i*max_buf_count+2] );
+ BLIP_READER_BEGIN( center, bufs [i*max_buf_count+2] );
+ BLIP_READER_BEGIN( sq1, bufs [i*max_buf_count+0] );
+ BLIP_READER_BEGIN( sq2, bufs [i*max_buf_count+1] );
- blip_sample_t* const reverb_buf = this->reverb_buf.begin();
- blip_sample_t* const echo_buf = this->echo_buf.begin();
- int echo_pos = this->echo_pos;
- int reverb_pos = this->reverb_pos;
+ blip_sample_t* const reverb_buf = &this->reverb_buf[i][0];
+ blip_sample_t* const echo_buf = &this->echo_buf[i][0];
+ int echo_pos = this->echo_pos[i];
+ int reverb_pos = this->reverb_pos[i];
+ int count = frames;
while ( count-- )
{
int sum1_s = BLIP_READER_READ( sq1 );
int sum2_s = BLIP_READER_READ( sq2 );
BLIP_READER_NEXT( sq1, bass );
BLIP_READER_NEXT( sq2, bass );
int new_reverb_l = FMUL( sum1_s, chans.pan_1_levels [0] ) +
FMUL( sum2_s, chans.pan_2_levels [0] ) +
reverb_buf [(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL( sum1_s, chans.pan_1_levels [1] ) +
FMUL( sum2_s, chans.pan_2_levels [1] ) +
reverb_buf [(reverb_pos + chans.reverb_delay_r) & reverb_mask];
fixed_t reverb_level = chans.reverb_level;
reverb_buf [reverb_pos] = (blip_sample_t) FMUL( new_reverb_l, reverb_level );
reverb_buf [reverb_pos + 1] = (blip_sample_t) FMUL( new_reverb_r, reverb_level );
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = BLIP_READER_READ( center );
BLIP_READER_NEXT( center, bass );
int left = new_reverb_l + sum3_s + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_l) & echo_mask] );
int right = new_reverb_r + sum3_s + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_r) & echo_mask] );
echo_buf [echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
- if ( (BOOST::int16_t) left != left )
+ if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
- out [0] = left;
- out [1] = right;
-
- out += 2;
-
- if ( (BOOST::int16_t) right != right )
- out [-1] = 0x7FFF - (right >> 24);
+ if ( (int16_t) right != right )
+ right = 0x7FFF - (right >> 24);
+
+ out [i*2+0] = left;
+ out [i*2+1] = right;
+ out += max_voices*2;
}
- this->reverb_pos = reverb_pos;
- this->echo_pos = echo_pos;
+ this->reverb_pos[i] = reverb_pos;
+ this->echo_pos[i] = echo_pos;
- BLIP_READER_END( sq1, bufs [0] );
- BLIP_READER_END( sq2, bufs [1] );
- BLIP_READER_END( center, bufs [2] );
+ BLIP_READER_END( sq1, bufs [i*max_buf_count+0] );
+ BLIP_READER_END( sq2, bufs [i*max_buf_count+1] );
+ BLIP_READER_END( center, bufs [i*max_buf_count+2] );
+ }
}
-void Effects_Buffer::mix_enhanced( blip_sample_t* out_, blargg_long count )
+void Effects_Buffer::mix_enhanced( blip_sample_t* out_, blargg_long frames )
{
+ for(int i=0; i<max_voices; i++)
+ {
blip_sample_t* BLIP_RESTRICT out = out_;
- int const bass = BLIP_READER_BASS( bufs [2] );
- BLIP_READER_BEGIN( center, bufs [2] );
- BLIP_READER_BEGIN( l1, bufs [3] );
- BLIP_READER_BEGIN( r1, bufs [4] );
- BLIP_READER_BEGIN( l2, bufs [5] );
- BLIP_READER_BEGIN( r2, bufs [6] );
- BLIP_READER_BEGIN( sq1, bufs [0] );
- BLIP_READER_BEGIN( sq2, bufs [1] );
+ int const bass = BLIP_READER_BASS( bufs [i*max_buf_count+2] );
+ BLIP_READER_BEGIN( center, bufs [i*max_buf_count+2] );
+ BLIP_READER_BEGIN( l1, bufs [i*max_buf_count+3] );
+ BLIP_READER_BEGIN( r1, bufs [i*max_buf_count+4] );
+ BLIP_READER_BEGIN( l2, bufs [i*max_buf_count+5] );
+ BLIP_READER_BEGIN( r2, bufs [i*max_buf_count+6] );
+ BLIP_READER_BEGIN( sq1, bufs [i*max_buf_count+0] );
+ BLIP_READER_BEGIN( sq2, bufs [i*max_buf_count+1] );
- blip_sample_t* const reverb_buf = this->reverb_buf.begin();
- blip_sample_t* const echo_buf = this->echo_buf.begin();
- int echo_pos = this->echo_pos;
- int reverb_pos = this->reverb_pos;
+ blip_sample_t* const reverb_buf = &this->reverb_buf[i][0];
+ blip_sample_t* const echo_buf = &this->echo_buf[i][0];
+ int echo_pos = this->echo_pos[i];
+ int reverb_pos = this->reverb_pos[i];
+ int count = frames;
while ( count-- )
{
int sum1_s = BLIP_READER_READ( sq1 );
int sum2_s = BLIP_READER_READ( sq2 );
BLIP_READER_NEXT( sq1, bass );
BLIP_READER_NEXT( sq2, bass );
int new_reverb_l = FMUL( sum1_s, chans.pan_1_levels [0] ) +
FMUL( sum2_s, chans.pan_2_levels [0] ) + BLIP_READER_READ( l1 ) +
reverb_buf [(reverb_pos + chans.reverb_delay_l) & reverb_mask];
int new_reverb_r = FMUL( sum1_s, chans.pan_1_levels [1] ) +
FMUL( sum2_s, chans.pan_2_levels [1] ) + BLIP_READER_READ( r1 ) +
reverb_buf [(reverb_pos + chans.reverb_delay_r) & reverb_mask];
BLIP_READER_NEXT( l1, bass );
BLIP_READER_NEXT( r1, bass );
fixed_t reverb_level = chans.reverb_level;
reverb_buf [reverb_pos] = (blip_sample_t) FMUL( new_reverb_l, reverb_level );
reverb_buf [reverb_pos + 1] = (blip_sample_t) FMUL( new_reverb_r, reverb_level );
reverb_pos = (reverb_pos + 2) & reverb_mask;
int sum3_s = BLIP_READER_READ( center );
BLIP_READER_NEXT( center, bass );
int left = new_reverb_l + sum3_s + BLIP_READER_READ( l2 ) + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_l) & echo_mask] );
int right = new_reverb_r + sum3_s + BLIP_READER_READ( r2 ) + FMUL( chans.echo_level,
echo_buf [(echo_pos + chans.echo_delay_r) & echo_mask] );
BLIP_READER_NEXT( l2, bass );
BLIP_READER_NEXT( r2, bass );
echo_buf [echo_pos] = sum3_s;
echo_pos = (echo_pos + 1) & echo_mask;
- if ( (BOOST::int16_t) left != left )
+ if ( (int16_t) left != left )
left = 0x7FFF - (left >> 24);
- out [0] = left;
- out [1] = right;
-
- out += 2;
-
- if ( (BOOST::int16_t) right != right )
- out [-1] = 0x7FFF - (right >> 24);
+ if ( (int16_t) right != right )
+ right = 0x7FFF - (right >> 24);
+
+ out [i*2+0] = left;
+ out [i*2+1] = right;
+
+ out += max_voices*2;
}
- this->reverb_pos = reverb_pos;
- this->echo_pos = echo_pos;
+ this->reverb_pos[i] = reverb_pos;
+ this->echo_pos[i] = echo_pos;
- BLIP_READER_END( l1, bufs [3] );
- BLIP_READER_END( r1, bufs [4] );
- BLIP_READER_END( l2, bufs [5] );
- BLIP_READER_END( r2, bufs [6] );
- BLIP_READER_END( sq1, bufs [0] );
- BLIP_READER_END( sq2, bufs [1] );
- BLIP_READER_END( center, bufs [2] );
+ BLIP_READER_END( l1, bufs [i*max_buf_count+3] );
+ BLIP_READER_END( r1, bufs [i*max_buf_count+4] );
+ BLIP_READER_END( l2, bufs [i*max_buf_count+5] );
+ BLIP_READER_END( r2, bufs [i*max_buf_count+6] );
+ BLIP_READER_END( sq1, bufs [i*max_buf_count+0] );
+ BLIP_READER_END( sq2, bufs [i*max_buf_count+1] );
+ BLIP_READER_END( center, bufs [i*max_buf_count+2] );
+ }
}
diff --git a/src/libs/gme/Effects_Buffer.h b/src/libs/gme/Effects_Buffer.h
index 061f74ab..ec634d62 100644
--- a/src/libs/gme/Effects_Buffer.h
+++ b/src/libs/gme/Effects_Buffer.h
@@ -1,86 +1,90 @@
// Multi-channel effects buffer with panning, echo and reverb
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef EFFECTS_BUFFER_H
#define EFFECTS_BUFFER_H
#include "Multi_Buffer.h"
+#include <vector>
+
// Effects_Buffer uses several buffers and outputs stereo sample pairs.
class Effects_Buffer : public Multi_Buffer {
public:
+ // nVoices indicates the number of voices for which buffers will be allocated
+ // to make Effects_Buffer work as "mix everything to one", nVoices will be 1
// If center_only is true, only center buffers are created and
// less memory is used.
- Effects_Buffer( bool center_only = false );
+ Effects_Buffer( int nVoices = 1, bool center_only = false );
// Channel Effect Center Pan
// ---------------------------------
// 0,5 reverb pan_1
// 1,6 reverb pan_2
// 2,7 echo -
// 3 echo -
// 4 echo -
// Channel configuration
struct config_t {
double pan_1; // -1.0 = left, 0.0 = center, 1.0 = right
double pan_2;
double echo_delay; // msec
double echo_level; // 0.0 to 1.0
double reverb_delay; // msec
double delay_variance; // difference between left/right delays (msec)
double reverb_level; // 0.0 to 1.0
bool effects_enabled; // if false, use optimized simple mixer
config_t();
};
// Set configuration of buffer
virtual void config( const config_t& );
void set_depth( double );
public:
~Effects_Buffer();
blargg_err_t set_sample_rate( long samples_per_sec, int msec = blip_default_length );
void clock_rate( long );
void bass_freq( int );
void clear();
channel_t channel( int, int );
void end_frame( blip_time_t );
long read_samples( blip_sample_t*, long );
long samples_avail() const;
private:
typedef long fixed_t;
-
+ int max_voices;
enum { max_buf_count = 7 };
- Blip_Buffer bufs [max_buf_count];
+ std::vector<Blip_Buffer> bufs;
enum { chan_types_count = 3 };
- channel_t chan_types [3];
+ std::vector<channel_t> chan_types;
config_t config_;
long stereo_remain;
long effect_remain;
int buf_count;
bool effects_enabled;
- blargg_vector<blip_sample_t> reverb_buf;
- blargg_vector<blip_sample_t> echo_buf;
- int reverb_pos;
- int echo_pos;
+ std::vector<std::vector<blip_sample_t> > reverb_buf;
+ std::vector<std::vector<blip_sample_t> > echo_buf;
+ std::vector<int> reverb_pos;
+ std::vector<int> echo_pos;
struct {
fixed_t pan_1_levels [2];
fixed_t pan_2_levels [2];
int echo_delay_l;
int echo_delay_r;
fixed_t echo_level;
int reverb_delay_l;
int reverb_delay_r;
fixed_t reverb_level;
} chans;
void mix_mono( blip_sample_t*, blargg_long );
void mix_stereo( blip_sample_t*, blargg_long );
void mix_enhanced( blip_sample_t*, blargg_long );
void mix_mono_enhanced( blip_sample_t*, blargg_long );
};
#endif
diff --git a/src/libs/gme/Fir_Resampler.cpp b/src/libs/gme/Fir_Resampler.cpp
index f2c905a9..d8dd6837 100644
--- a/src/libs/gme/Fir_Resampler.cpp
+++ b/src/libs/gme/Fir_Resampler.cpp
@@ -1,199 +1,199 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Fir_Resampler.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
/* Copyright (C) 2004-2006 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"
#undef PI
#define PI 3.1415926535897932384626433832795029
static void gen_sinc( double rolloff, int width, double offset, double spacing, double scale,
int count, short* out )
{
double const maxh = 256;
double const step = PI / maxh * spacing;
double const to_w = maxh * 2 / width;
double const pow_a_n = pow( rolloff, maxh );
scale /= maxh * 2;
double angle = (count / 2 - 1 + offset) * -step;
while ( count-- )
{
*out++ = 0;
double w = angle * to_w;
if ( fabs( w ) < PI )
{
double rolloff_cos_a = rolloff * cos( angle );
double num = 1 - rolloff_cos_a -
pow_a_n * cos( maxh * angle ) +
pow_a_n * rolloff * cos( (maxh - 1) * angle );
double den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff;
double sinc = scale * num / den - scale;
out [-1] = (short) (cos( w ) * sinc + sinc);
}
angle += step;
}
}
Fir_Resampler_::Fir_Resampler_( int width, sample_t* impulses_ ) :
width_( width ),
write_offset( width * stereo - stereo ),
impulses( impulses_ )
{
write_pos = 0;
res = 1;
imp_phase = 0;
skip_bits = 0;
step = stereo;
ratio_ = 1.0;
}
Fir_Resampler_::~Fir_Resampler_() { }
void Fir_Resampler_::clear()
{
imp_phase = 0;
if ( buf.size() )
{
write_pos = &buf [write_offset];
memset( buf.begin(), 0, write_offset * sizeof buf [0] );
}
}
blargg_err_t Fir_Resampler_::buffer_size( int new_size )
{
RETURN_ERR( buf.resize( new_size + write_offset ) );
clear();
return 0;
}
double Fir_Resampler_::time_ratio( double new_factor, double rolloff, double gain )
{
ratio_ = new_factor;
double fstep = 0.0;
{
double least_error = 2;
double pos = 0;
res = -1;
for ( int r = 1; r <= max_res; r++ )
{
pos += ratio_;
double nearest = floor( pos + 0.5 );
double error = fabs( pos - nearest );
if ( error < least_error )
{
res = r;
fstep = nearest / res;
least_error = error;
}
}
}
skip_bits = 0;
step = stereo * (int) floor( fstep );
ratio_ = fstep;
fstep = fmod( fstep, 1.0 );
double filter = (ratio_ < 1.0) ? 1.0 : 1.0 / ratio_;
double pos = 0.0;
input_per_cycle = 0;
for ( int i = 0; i < res; i++ )
{
gen_sinc( rolloff, int (width_ * filter + 1) & ~1, pos, filter,
double (0x7FFF * gain * filter),
(int) width_, impulses + i * width_ );
pos += fstep;
input_per_cycle += step;
if ( pos >= 0.9999999 )
{
pos -= 1.0;
skip_bits |= 1 << i;
input_per_cycle++;
}
}
clear();
return ratio_;
}
int Fir_Resampler_::input_needed( blargg_long output_count ) const
{
blargg_long input_count = 0;
unsigned long skip = skip_bits >> imp_phase;
int remain = res - imp_phase;
while ( (output_count -= 2) > 0 )
{
input_count += step + (skip & 1) * stereo;
skip >>= 1;
if ( !--remain )
{
skip = skip_bits;
remain = res;
}
output_count -= 2;
}
long input_extra = input_count - (write_pos - &buf [(width_ - 1) * stereo]);
if ( input_extra < 0 )
input_extra = 0;
return input_extra;
}
int Fir_Resampler_::avail_( blargg_long input_count ) const
{
int cycle_count = input_count / input_per_cycle;
int output_count = cycle_count * res * stereo;
input_count -= cycle_count * input_per_cycle;
blargg_ulong skip = skip_bits >> imp_phase;
int remain = res - imp_phase;
while ( input_count >= 0 )
{
input_count -= step + (skip & 1) * stereo;
skip >>= 1;
if ( !--remain )
{
skip = skip_bits;
remain = res;
}
output_count += 2;
}
return output_count;
}
int Fir_Resampler_::skip_input( long count )
{
int remain = write_pos - buf.begin();
int max_count = remain - width_ * stereo;
if ( count > max_count )
count = max_count;
remain -= count;
write_pos = &buf [remain];
memmove( buf.begin(), &buf [count], remain * sizeof buf [0] );
return count;
}
diff --git a/src/libs/gme/Fir_Resampler.h b/src/libs/gme/Fir_Resampler.h
index aed87492..d637ec41 100644
--- a/src/libs/gme/Fir_Resampler.h
+++ b/src/libs/gme/Fir_Resampler.h
@@ -1,171 +1,171 @@
// Finite impulse response (FIR) resampler with adjustable FIR size
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef FIR_RESAMPLER_H
#define FIR_RESAMPLER_H
#include "blargg_common.h"
#include <string.h>
class Fir_Resampler_ {
public:
// Use Fir_Resampler<width> (below)
// Set input/output resampling ratio and optionally low-pass rolloff and gain.
// Returns actual ratio used (rounded to internal precision).
double time_ratio( double factor, double rolloff = 0.999, double gain = 1.0 );
// Current input/output ratio
double ratio() const { return ratio_; }
// Input
typedef short sample_t;
// Resize and clear input buffer
blargg_err_t buffer_size( int );
// Clear input buffer. At least two output samples will be available after
// two input samples are written.
void clear();
// Number of input samples that can be written
int max_write() const { return buf.end() - write_pos; }
// Pointer to place to write input samples
sample_t* buffer() { return write_pos; }
// Notify resampler that 'count' input samples have been written
void write( long count );
// Number of input samples in buffer
int written() const { return write_pos - &buf [write_offset]; }
// Skip 'count' input samples. Returns number of samples actually skipped.
int skip_input( long count );
// Output
// Number of extra input samples needed until 'count' output samples are available
int input_needed( blargg_long count ) const;
// Number of output samples available
int avail() const { return avail_( write_pos - &buf [width_ * stereo] ); }
public:
~Fir_Resampler_();
protected:
enum { stereo = 2 };
enum { max_res = 32 };
blargg_vector<sample_t> buf;
sample_t* write_pos;
int res;
int imp_phase;
int const width_;
int const write_offset;
blargg_ulong skip_bits;
int step;
int input_per_cycle;
double ratio_;
sample_t* impulses;
Fir_Resampler_( int width, sample_t* );
int avail_( blargg_long input_count ) const;
};
// Width is number of points in FIR. Must be even and 4 or more. More points give
// better quality and rolloff effectiveness, and take longer to calculate.
template<int width>
class Fir_Resampler : public Fir_Resampler_ {
BOOST_STATIC_ASSERT( width >= 4 && width % 2 == 0 );
short impulses [max_res] [width];
public:
Fir_Resampler() : Fir_Resampler_( width, impulses [0] ) { }
// Read at most 'count' samples. Returns number of samples actually read.
typedef short sample_t;
int read( sample_t* out, blargg_long count );
};
// End of public interface
inline void Fir_Resampler_::write( long count )
{
write_pos += count;
assert( write_pos <= buf.end() );
}
template<int width>
int Fir_Resampler<width>::read( sample_t* out_begin, blargg_long count )
{
sample_t* out = out_begin;
const sample_t* in = buf.begin();
sample_t* end_pos = write_pos;
blargg_ulong skip = skip_bits >> imp_phase;
sample_t const* imp = impulses [imp_phase];
int remain = res - imp_phase;
int const step = this->step;
count >>= 1;
if ( end_pos - in >= width * stereo )
{
end_pos -= width * stereo;
do
{
count--;
// accumulate in extended precision
blargg_long l = 0;
blargg_long r = 0;
const sample_t* i = in;
if ( count < 0 )
break;
for ( int n = width / 2; n; --n )
{
int pt0 = imp [0];
l += pt0 * i [0];
r += pt0 * i [1];
int pt1 = imp [1];
imp += 2;
l += pt1 * i [2];
r += pt1 * i [3];
i += 4;
}
remain--;
l >>= 15;
r >>= 15;
in += (skip * stereo) & stereo;
skip >>= 1;
in += step;
if ( !remain )
{
imp = impulses [0];
skip = skip_bits;
remain = res;
}
out [0] = (sample_t) l;
out [1] = (sample_t) r;
out += 2;
}
while ( in <= end_pos );
}
imp_phase = res - remain;
int left = write_pos - in;
write_pos = &buf [left];
memmove( buf.begin(), in, left * sizeof *in );
return out - out_begin;
}
#endif
diff --git a/src/libs/gme/Gb_Apu.cpp b/src/libs/gme/Gb_Apu.cpp
index 866594dd..82a9cc1b 100644
--- a/src/libs/gme/Gb_Apu.cpp
+++ b/src/libs/gme/Gb_Apu.cpp
@@ -1,306 +1,306 @@
// Gb_Snd_Emu 0.1.5. http://www.slack.net/~ant/
#include "Gb_Apu.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
unsigned const vol_reg = 0xFF24;
unsigned const status_reg = 0xFF26;
Gb_Apu::Gb_Apu()
{
square1.synth = &square_synth;
square2.synth = &square_synth;
wave.synth = &other_synth;
noise.synth = &other_synth;
oscs [0] = &square1;
oscs [1] = &square2;
oscs [2] = &wave;
oscs [3] = &noise;
for ( int i = 0; i < osc_count; i++ )
{
Gb_Osc& osc = *oscs [i];
osc.regs = &regs [i * 5];
osc.output = 0;
osc.outputs [0] = 0;
osc.outputs [1] = 0;
osc.outputs [2] = 0;
osc.outputs [3] = 0;
}
set_tempo( 1.0 );
volume( 1.0 );
reset();
}
void Gb_Apu::treble_eq( const blip_eq_t& eq )
{
square_synth.treble_eq( eq );
other_synth.treble_eq( eq );
}
void Gb_Apu::osc_output( int index, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
require( (unsigned) index < osc_count );
require( (center && left && right) || (!center && !left && !right) );
Gb_Osc& osc = *oscs [index];
osc.outputs [1] = right;
osc.outputs [2] = left;
osc.outputs [3] = center;
osc.output = osc.outputs [osc.output_select];
}
void Gb_Apu::output( Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, center, left, right );
}
void Gb_Apu::update_volume()
{
// TODO: doesn't handle differing left/right global volume (support would
// require modification to all oscillator code)
int data = regs [vol_reg - start_addr];
double vol = (max( data & 7, data >> 4 & 7 ) + 1) * volume_unit;
square_synth.volume( vol );
other_synth.volume( vol );
}
static unsigned char const powerup_regs [0x20] = {
0x80,0x3F,0x00,0xFF,0xBF, // square 1
0xFF,0x3F,0x00,0xFF,0xBF, // square 2
0x7F,0xFF,0x9F,0xFF,0xBF, // wave
0xFF,0xFF,0x00,0x00,0xBF, // noise
0x00, // left/right enables
0x77, // master volume
0x80, // power
0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
};
void Gb_Apu::set_tempo( double t )
{
frame_period = 4194304 / 256; // 256 Hz
if ( t != 1.0 )
frame_period = blip_time_t (frame_period / t);
}
void Gb_Apu::reset()
{
next_frame_time = 0;
last_time = 0;
frame_count = 0;
square1.reset();
square2.reset();
wave.reset();
noise.reset();
noise.bits = 1;
wave.wave_pos = 0;
// avoid click at beginning
regs [vol_reg - start_addr] = 0x77;
update_volume();
regs [status_reg - start_addr] = 0x01; // force power
write_register( 0, status_reg, 0x00 );
static unsigned char const initial_wave [] = {
0x84,0x40,0x43,0xAA,0x2D,0x78,0x92,0x3C, // wave table
0x60,0x59,0x59,0xB0,0x34,0xB8,0x2E,0xDA
};
- memcpy( wave.wave, initial_wave, sizeof wave.wave );
+ memcpy( wave.wave, initial_wave, sizeof initial_wave );
}
void Gb_Apu::run_until( blip_time_t end_time )
{
require( end_time >= last_time ); // end_time must not be before previous time
if ( end_time == last_time )
return;
while ( true )
{
blip_time_t time = next_frame_time;
if ( time > end_time )
time = end_time;
// run oscillators
for ( int i = 0; i < osc_count; ++i )
{
Gb_Osc& osc = *oscs [i];
if ( osc.output )
{
osc.output->set_modified(); // TODO: misses optimization opportunities?
int playing = false;
if ( osc.enabled && osc.volume &&
(!(osc.regs [4] & osc.len_enabled_mask) || osc.length) )
playing = -1;
switch ( i )
{
case 0: square1.run( last_time, time, playing ); break;
case 1: square2.run( last_time, time, playing ); break;
case 2: wave .run( last_time, time, playing ); break;
case 3: noise .run( last_time, time, playing ); break;
}
}
}
last_time = time;
if ( time == end_time )
break;
next_frame_time += frame_period;
// 256 Hz actions
square1.clock_length();
square2.clock_length();
wave.clock_length();
noise.clock_length();
frame_count = (frame_count + 1) & 3;
if ( frame_count == 0 )
{
// 64 Hz actions
square1.clock_envelope();
square2.clock_envelope();
noise.clock_envelope();
}
if ( frame_count & 1 )
square1.clock_sweep(); // 128 Hz action
}
}
void Gb_Apu::end_frame( blip_time_t end_time )
{
if ( end_time > last_time )
run_until( end_time );
assert( next_frame_time >= end_time );
next_frame_time -= end_time;
assert( last_time >= end_time );
last_time -= end_time;
}
void Gb_Apu::write_register( blip_time_t time, unsigned addr, int data )
{
require( (unsigned) data < 0x100 );
int reg = addr - start_addr;
if ( (unsigned) reg >= register_count )
return;
run_until( time );
int old_reg = regs [reg];
regs [reg] = data;
if ( addr < vol_reg )
{
write_osc( reg / 5, reg, data );
}
else if ( addr == vol_reg && data != old_reg ) // global volume
{
// return all oscs to 0
for ( int i = 0; i < osc_count; i++ )
{
Gb_Osc& osc = *oscs [i];
int amp = osc.last_amp;
osc.last_amp = 0;
if ( amp && osc.enabled && osc.output )
other_synth.offset( time, -amp, osc.output );
}
if ( wave.outputs [3] )
other_synth.offset( time, 30, wave.outputs [3] );
update_volume();
if ( wave.outputs [3] )
other_synth.offset( time, -30, wave.outputs [3] );
// oscs will update with new amplitude when next run
}
else if ( addr == 0xFF25 || addr == status_reg )
{
int mask = (regs [status_reg - start_addr] & 0x80) ? ~0 : 0;
int flags = regs [0xFF25 - start_addr] & mask;
// left/right assignments
for ( int i = 0; i < osc_count; i++ )
{
Gb_Osc& osc = *oscs [i];
osc.enabled &= mask;
int bits = flags >> i;
Blip_Buffer* old_output = osc.output;
osc.output_select = (bits >> 3 & 2) | (bits & 1);
osc.output = osc.outputs [osc.output_select];
if ( osc.output != old_output )
{
int amp = osc.last_amp;
osc.last_amp = 0;
if ( amp && old_output )
other_synth.offset( time, -amp, old_output );
}
}
if ( addr == status_reg && data != old_reg )
{
if ( !(data & 0x80) )
{
for ( unsigned i = 0; i < sizeof powerup_regs; i++ )
{
if ( i != status_reg - start_addr )
write_register( time, i + start_addr, powerup_regs [i] );
}
}
else
{
//debug_printf( "APU powered on\n" );
}
}
}
else if ( addr >= 0xFF30 )
{
int index = (addr & 0x0F) * 2;
wave.wave [index] = data >> 4;
wave.wave [index + 1] = data & 0x0F;
}
}
int Gb_Apu::read_register( blip_time_t time, unsigned addr )
{
run_until( time );
int index = addr - start_addr;
require( (unsigned) index < register_count );
int data = regs [index];
if ( addr == status_reg )
{
data = (data & 0x80) | 0x70;
for ( int i = 0; i < osc_count; i++ )
{
const Gb_Osc& osc = *oscs [i];
if ( osc.enabled && (osc.length || !(osc.regs [4] & osc.len_enabled_mask)) )
data |= 1 << i;
}
}
return data;
}
diff --git a/src/libs/gme/Gb_Apu.h b/src/libs/gme/Gb_Apu.h
index e74ebc55..9b251262 100644
--- a/src/libs/gme/Gb_Apu.h
+++ b/src/libs/gme/Gb_Apu.h
@@ -1,90 +1,90 @@
// Nintendo Game Boy PAPU sound chip emulator
// Gb_Snd_Emu 0.1.5
#ifndef GB_APU_H
#define GB_APU_H
#include "Gb_Oscs.h"
class Gb_Apu {
public:
// Set overall volume of all oscillators, where 1.0 is full volume
void volume( double );
// Set treble equalization
void treble_eq( const blip_eq_t& );
// Outputs can be assigned to a single buffer for mono output, or to three
// buffers for stereo output (using Stereo_Buffer to do the mixing).
// Assign all oscillator outputs to specified buffer(s). If buffer
// is NULL, silences all oscillators.
void output( Blip_Buffer* mono );
void output( Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right );
// Assign single oscillator output to buffer(s). Valid indicies are 0 to 3,
// which refer to Square 1, Square 2, Wave, and Noise. If buffer is NULL,
// silences oscillator.
enum { osc_count = 4 };
void osc_output( int index, Blip_Buffer* mono );
void osc_output( int index, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right );
// Reset oscillators and internal state
void reset();
// Reads and writes at addr must satisfy start_addr <= addr <= end_addr
enum { start_addr = 0xFF10 };
enum { end_addr = 0xFF3F };
enum { register_count = end_addr - start_addr + 1 };
// Write 'data' to address at specified time
void write_register( blip_time_t, unsigned addr, int data );
// Read from address at specified time
int read_register( blip_time_t, unsigned addr );
// Run all oscillators up to specified time, end current time frame, then
// start a new frame at time 0.
void end_frame( blip_time_t );
void set_tempo( double );
public:
Gb_Apu();
private:
// noncopyable
Gb_Apu( const Gb_Apu& );
Gb_Apu& operator = ( const Gb_Apu& );
Gb_Osc* oscs [osc_count];
blip_time_t next_frame_time;
blip_time_t last_time;
blip_time_t frame_period;
double volume_unit;
int frame_count;
Gb_Square square1;
Gb_Square square2;
Gb_Wave wave;
Gb_Noise noise;
- BOOST::uint8_t regs [register_count];
+ uint8_t regs [register_count];
Gb_Square::Synth square_synth; // used by squares
Gb_Wave::Synth other_synth; // used by wave and noise
void update_volume();
void run_until( blip_time_t );
void write_osc( int index, int reg, int data );
};
inline void Gb_Apu::output( Blip_Buffer* b ) { output( b, b, b ); }
inline void Gb_Apu::osc_output( int i, Blip_Buffer* b ) { osc_output( i, b, b, b ); }
inline void Gb_Apu::volume( double vol )
{
volume_unit = 0.60 / osc_count / 15 /*steps*/ / 2 /*?*/ / 8 /*master vol range*/ * vol;
update_volume();
}
#endif
diff --git a/src/libs/gme/Gb_Cpu.cpp b/src/libs/gme/Gb_Cpu.cpp
index 6980aafe..db1abee5 100644
--- a/src/libs/gme/Gb_Cpu.cpp
+++ b/src/libs/gme/Gb_Cpu.cpp
@@ -1,1056 +1,1054 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Gb_Cpu.h"
#include <string.h>
//#include "gb_cpu_log.h"
/* Copyright (C) 2003-2006 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 "gb_cpu_io.h"
#include "blargg_source.h"
// Common instructions:
//
// 365880 FA LD A,IND16
// 355863 20 JR NZ
// 313655 21 LD HL,IMM
// 274580 28 JR Z
// 252878 FE CMP IMM
// 230541 7E LD A,(HL)
// 226209 2A LD A,(HL+)
// 217467 CD CALL
// 212034 C9 RET
// 208376 CB CB prefix
//
// 27486 CB 7E BIT 7,(HL)
// 15925 CB 76 BIT 6,(HL)
// 13035 CB 19 RR C
// 11557 CB 7F BIT 7,A
// 10898 CB 37 SWAP A
// 10208 CB 66 BIT 4,(HL)
#if BLARGG_NONPORTABLE
#define PAGE_OFFSET( addr ) (addr)
#else
#define PAGE_OFFSET( addr ) ((addr) & (page_size - 1))
#endif
inline void Gb_Cpu::set_code_page( int i, uint8_t* p )
{
state->code_map [i] = p - PAGE_OFFSET( i * (blargg_long) page_size );
}
void Gb_Cpu::reset( void* unmapped )
{
check( state == &state_ );
state = &state_;
state_.remain = 0;
for ( int i = 0; i < page_count + 1; i++ )
set_code_page( i, (uint8_t*) unmapped );
memset( &r, 0, sizeof r );
//interrupts_enabled = false;
blargg_verify_byte_order();
}
void Gb_Cpu::map_code( gb_addr_t start, unsigned size, void* data )
{
// address range must begin and end on page boundaries
require( start % page_size == 0 );
require( size % page_size == 0 );
unsigned first_page = start / page_size;
for ( unsigned i = size / page_size; i--; )
set_code_page( first_page + i, (uint8_t*) data + i * page_size );
}
#define READ( addr ) CPU_READ( this, (addr), s.remain )
#define WRITE( addr, data ) {CPU_WRITE( this, (addr), (data), s.remain );}
#define READ_FAST( addr, out ) CPU_READ_FAST( this, (addr), s.remain, out )
#define READ_PROG( addr ) (s.code_map [(addr) >> page_shift] [PAGE_OFFSET( addr )])
unsigned const z_flag = 0x80;
unsigned const n_flag = 0x40;
unsigned const h_flag = 0x20;
unsigned const c_flag = 0x10;
bool Gb_Cpu::run( blargg_long cycle_count )
{
state_.remain = blargg_ulong (cycle_count + clocks_per_instr) / clocks_per_instr;
state_t s;
this->state = &s;
memcpy( &s, &this->state_, sizeof s );
- typedef BOOST::uint16_t uint16_t;
-
#if BLARGG_BIG_ENDIAN
#define R8( n ) (r8_ [n])
#elif BLARGG_LITTLE_ENDIAN
#define R8( n ) (r8_ [(n) ^ 1])
#else
#error "Byte order of CPU must be known"
#endif
union {
core_regs_t rg; // individual registers
struct {
- BOOST::uint16_t bc, de, hl, unused; // pairs
+ uint16_t bc, de, hl, unused; // pairs
} rp;
uint8_t r8_ [8]; // indexed registers (use R8 macro due to endian dependence)
- BOOST::uint16_t r16 [4]; // indexed pairs
+ uint16_t r16 [4]; // indexed pairs
};
BOOST_STATIC_ASSERT( sizeof rg == 8 && sizeof rp == 8 );
rg = r;
unsigned pc = r.pc;
unsigned sp = r.sp;
unsigned flags = r.flags;
loop:
check( (unsigned long) pc < 0x10000 );
check( (unsigned long) sp < 0x10000 );
check( (flags & ~0xF0) == 0 );
uint8_t const* instr = s.code_map [pc >> page_shift];
unsigned op;
// TODO: eliminate this special case
#if BLARGG_NONPORTABLE
op = instr [pc];
pc++;
instr += pc;
#else
instr += PAGE_OFFSET( pc );
op = *instr++;
pc++;
#endif
#define GET_ADDR() GET_LE16( instr )
if ( !--s.remain )
goto stop;
unsigned data;
data = *instr;
#ifdef GB_CPU_LOG_H
gb_cpu_log( "new", pc - 1, op, data, instr [1] );
#endif
switch ( op )
{
// TODO: more efficient way to handle negative branch that wraps PC around
#define BRANCH( cond )\
{\
pc++;\
- int offset = (BOOST::int8_t) data;\
+ int offset = (int8_t) data;\
if ( !(cond) ) goto loop;\
pc = uint16_t (pc + offset);\
goto loop;\
}
// Most Common
case 0x20: // JR NZ
BRANCH( !(flags & z_flag) )
case 0x21: // LD HL,IMM (common)
rp.hl = GET_ADDR();
pc += 2;
goto loop;
case 0x28: // JR Z
BRANCH( flags & z_flag )
{
unsigned temp;
case 0xF0: // LD A,(0xFF00+imm)
temp = data | 0xFF00;
pc++;
goto ld_a_ind_comm;
case 0xF2: // LD A,(0xFF00+C)
temp = rg.c | 0xFF00;
goto ld_a_ind_comm;
case 0x0A: // LD A,(BC)
temp = rp.bc;
goto ld_a_ind_comm;
case 0x3A: // LD A,(HL-)
temp = rp.hl;
rp.hl = temp - 1;
goto ld_a_ind_comm;
case 0x1A: // LD A,(DE)
temp = rp.de;
goto ld_a_ind_comm;
case 0x2A: // LD A,(HL+) (common)
temp = rp.hl;
rp.hl = temp + 1;
goto ld_a_ind_comm;
case 0xFA: // LD A,IND16 (common)
temp = GET_ADDR();
pc += 2;
ld_a_ind_comm:
READ_FAST( temp, rg.a );
goto loop;
}
case 0xBE: // CMP (HL)
data = READ( rp.hl );
goto cmp_comm;
case 0xB8: // CMP B
case 0xB9: // CMP C
case 0xBA: // CMP D
case 0xBB: // CMP E
case 0xBC: // CMP H
case 0xBD: // CMP L
data = R8( op & 7 );
goto cmp_comm;
case 0xFE: // CMP IMM
pc++;
cmp_comm:
op = rg.a;
data = op - data;
sub_set_flags:
flags = ((op & 15) - (data & 15)) & h_flag;
flags |= (data >> 4) & c_flag;
flags |= n_flag;
if ( data & 0xFF )
goto loop;
flags |= z_flag;
goto loop;
case 0x46: // LD B,(HL)
case 0x4E: // LD C,(HL)
case 0x56: // LD D,(HL)
case 0x5E: // LD E,(HL)
case 0x66: // LD H,(HL)
case 0x6E: // LD L,(HL)
case 0x7E:{// LD A,(HL)
unsigned addr = rp.hl;
READ_FAST( addr, R8( (op >> 3) & 7 ) );
goto loop;
}
case 0xC4: // CNZ (next-most-common)
pc += 2;
if ( flags & z_flag )
goto loop;
call:
pc -= 2;
case 0xCD: // CALL (most-common)
data = pc + 2;
pc = GET_ADDR();
push:
sp = (sp - 1) & 0xFFFF;
WRITE( sp, data >> 8 );
sp = (sp - 1) & 0xFFFF;
WRITE( sp, data & 0xFF );
goto loop;
case 0xC8: // RNZ (next-most-common)
if ( !(flags & z_flag) )
goto loop;
case 0xC9: // RET (most common)
ret:
pc = READ( sp );
pc += 0x100 * READ( sp + 1 );
sp = (sp + 2) & 0xFFFF;
goto loop;
case 0x00: // NOP
case 0x40: // LD B,B
case 0x49: // LD C,C
case 0x52: // LD D,D
case 0x5B: // LD E,E
case 0x64: // LD H,H
case 0x6D: // LD L,L
case 0x7F: // LD A,A
goto loop;
// CB Instructions
case 0xCB:
pc++;
// now data is the opcode
switch ( data ) {
{
int temp;
case 0x46: // BIT b,(HL)
case 0x4E:
case 0x56:
case 0x5E:
case 0x66:
case 0x6E:
case 0x76:
case 0x7E:
{
unsigned addr = rp.hl;
READ_FAST( addr, temp );
goto bit_comm;
}
case 0x40: case 0x41: case 0x42: case 0x43: // BIT b,r
case 0x44: case 0x45: case 0x47: case 0x48:
case 0x49: case 0x4A: case 0x4B: case 0x4C:
case 0x4D: case 0x4F: case 0x50: case 0x51:
case 0x52: case 0x53: case 0x54: case 0x55:
case 0x57: case 0x58: case 0x59: case 0x5A:
case 0x5B: case 0x5C: case 0x5D: case 0x5F:
case 0x60: case 0x61: case 0x62: case 0x63:
case 0x64: case 0x65: case 0x67: case 0x68:
case 0x69: case 0x6A: case 0x6B: case 0x6C:
case 0x6D: case 0x6F: case 0x70: case 0x71:
case 0x72: case 0x73: case 0x74: case 0x75:
case 0x77: case 0x78: case 0x79: case 0x7A:
case 0x7B: case 0x7C: case 0x7D: case 0x7F:
temp = R8( data & 7 );
bit_comm:
int bit = (~data >> 3) & 7;
flags &= ~n_flag;
flags |= h_flag | z_flag;
flags ^= (temp << bit) & z_flag;
goto loop;
}
case 0x86: // RES b,(HL)
case 0x8E:
case 0x96:
case 0x9E:
case 0xA6:
case 0xAE:
case 0xB6:
case 0xBE:
case 0xC6: // SET b,(HL)
case 0xCE:
case 0xD6:
case 0xDE:
case 0xE6:
case 0xEE:
case 0xF6:
case 0xFE: {
int temp = READ( rp.hl );
int bit = 1 << ((data >> 3) & 7);
temp &= ~bit;
if ( !(data & 0x40) )
bit = 0;
WRITE( rp.hl, temp | bit );
goto loop;
}
case 0xC0: case 0xC1: case 0xC2: case 0xC3: // SET b,r
case 0xC4: case 0xC5: case 0xC7: case 0xC8:
case 0xC9: case 0xCA: case 0xCB: case 0xCC:
case 0xCD: case 0xCF: case 0xD0: case 0xD1:
case 0xD2: case 0xD3: case 0xD4: case 0xD5:
case 0xD7: case 0xD8: case 0xD9: case 0xDA:
case 0xDB: case 0xDC: case 0xDD: case 0xDF:
case 0xE0: case 0xE1: case 0xE2: case 0xE3:
case 0xE4: case 0xE5: case 0xE7: case 0xE8:
case 0xE9: case 0xEA: case 0xEB: case 0xEC:
case 0xED: case 0xEF: case 0xF0: case 0xF1:
case 0xF2: case 0xF3: case 0xF4: case 0xF5:
case 0xF7: case 0xF8: case 0xF9: case 0xFA:
case 0xFB: case 0xFC: case 0xFD: case 0xFF:
R8( data & 7 ) |= 1 << ((data >> 3) & 7);
goto loop;
case 0x80: case 0x81: case 0x82: case 0x83: // RES b,r
case 0x84: case 0x85: case 0x87: case 0x88:
case 0x89: case 0x8A: case 0x8B: case 0x8C:
case 0x8D: case 0x8F: case 0x90: case 0x91:
case 0x92: case 0x93: case 0x94: case 0x95:
case 0x97: case 0x98: case 0x99: case 0x9A:
case 0x9B: case 0x9C: case 0x9D: case 0x9F:
case 0xA0: case 0xA1: case 0xA2: case 0xA3:
case 0xA4: case 0xA5: case 0xA7: case 0xA8:
case 0xA9: case 0xAA: case 0xAB: case 0xAC:
case 0xAD: case 0xAF: case 0xB0: case 0xB1:
case 0xB2: case 0xB3: case 0xB4: case 0xB5:
case 0xB7: case 0xB8: case 0xB9: case 0xBA:
case 0xBB: case 0xBC: case 0xBD: case 0xBF:
R8( data & 7 ) &= ~(1 << ((data >> 3) & 7));
goto loop;
{
int temp;
case 0x36: // SWAP (HL)
temp = READ( rp.hl );
goto swap_comm;
case 0x30: // SWAP B
case 0x31: // SWAP C
case 0x32: // SWAP D
case 0x33: // SWAP E
case 0x34: // SWAP H
case 0x35: // SWAP L
case 0x37: // SWAP A
temp = R8( data & 7 );
swap_comm:
op = (temp >> 4) | (temp << 4);
flags = 0;
goto shift_comm;
}
// Shift/Rotate
case 0x06: // RLC (HL)
case 0x16: // RL (HL)
case 0x26: // SLA (HL)
op = READ( rp.hl );
goto rl_comm;
case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x27: // SLA A
case 0x00: case 0x01: case 0x02: case 0x03: case 0x04: case 0x05: case 0x07: // RLC A
case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x17: // RL A
op = R8( data & 7 );
goto rl_comm;
case 0x3E: // SRL (HL)
data += 0x10; // bump up to 0x4n to avoid preserving sign bit
case 0x1E: // RR (HL)
case 0x0E: // RRC (HL)
case 0x2E: // SRA (HL)
op = READ( rp.hl );
goto rr_comm;
case 0x38: case 0x39: case 0x3A: case 0x3B: case 0x3C: case 0x3D: case 0x3F: // SRL A
data += 0x10; // bump up to 0x4n
case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1F: // RR A
case 0x08: case 0x09: case 0x0A: case 0x0B: case 0x0C: case 0x0D: case 0x0F: // RRC A
case 0x28: case 0x29: case 0x2A: case 0x2B: case 0x2C: case 0x2D: case 0x2F: // SRA A
op = R8( data & 7 );
goto rr_comm;
} // CB op
assert( false ); // unhandled CB op
case 0x07: // RLCA
case 0x17: // RLA
data = op;
op = rg.a;
rl_comm:
op <<= 1;
op |= ((data & flags) >> 4) & 1; // RL and carry is set
flags = (op >> 4) & c_flag; // C = bit shifted out
if ( data < 0x10 ) // RLC
op |= op >> 8;
// SLA doesn't fill lower bit
goto shift_comm;
case 0x0F: // RRCA
case 0x1F: // RRA
data = op;
op = rg.a;
rr_comm:
op |= (data & flags) << 4; // RR and carry is set
flags = (op << 4) & c_flag; // C = bit shifted out
if ( data < 0x10 ) // RRC
op |= op << 8;
op >>= 1;
if ( data & 0x20 ) // SRA propagates sign bit
op |= (op << 1) & 0x80;
shift_comm:
data &= 7;
if ( !(op & 0xFF) )
flags |= z_flag;
if ( data == 6 )
goto write_hl_op_ff;
R8( data ) = op;
goto loop;
// Load
case 0x70: // LD (HL),B
case 0x71: // LD (HL),C
case 0x72: // LD (HL),D
case 0x73: // LD (HL),E
case 0x74: // LD (HL),H
case 0x75: // LD (HL),L
case 0x77: // LD (HL),A
op = R8( op & 7 );
write_hl_op_ff:
WRITE( rp.hl, op & 0xFF );
goto loop;
case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x47: // LD r,r
case 0x48: case 0x4A: case 0x4B: case 0x4C: case 0x4D: case 0x4F:
case 0x50: case 0x51: case 0x53: case 0x54: case 0x55: case 0x57:
case 0x58: case 0x59: case 0x5A: case 0x5C: case 0x5D: case 0x5F:
case 0x60: case 0x61: case 0x62: case 0x63: case 0x65: case 0x67:
case 0x68: case 0x69: case 0x6A: case 0x6B: case 0x6C: case 0x6F:
case 0x78: case 0x79: case 0x7A: case 0x7B: case 0x7C: case 0x7D:
R8( (op >> 3) & 7 ) = R8( op & 7 );
goto loop;
case 0x08: // LD IND16,SP
data = GET_ADDR();
pc += 2;
WRITE( data, sp&0xFF );
data++;
WRITE( data, sp >> 8 );
goto loop;
case 0xF9: // LD SP,HL
sp = rp.hl;
goto loop;
case 0x31: // LD SP,IMM
sp = GET_ADDR();
pc += 2;
goto loop;
case 0x01: // LD BC,IMM
case 0x11: // LD DE,IMM
r16 [op >> 4] = GET_ADDR();
pc += 2;
goto loop;
{
unsigned temp;
case 0xE0: // LD (0xFF00+imm),A
temp = data | 0xFF00;
pc++;
goto write_data_rg_a;
case 0xE2: // LD (0xFF00+C),A
temp = rg.c | 0xFF00;
goto write_data_rg_a;
case 0x32: // LD (HL-),A
temp = rp.hl;
rp.hl = temp - 1;
goto write_data_rg_a;
case 0x02: // LD (BC),A
temp = rp.bc;
goto write_data_rg_a;
case 0x12: // LD (DE),A
temp = rp.de;
goto write_data_rg_a;
case 0x22: // LD (HL+),A
temp = rp.hl;
rp.hl = temp + 1;
goto write_data_rg_a;
case 0xEA: // LD IND16,A (common)
temp = GET_ADDR();
pc += 2;
write_data_rg_a:
WRITE( temp, rg.a );
goto loop;
}
case 0x06: // LD B,IMM
rg.b = data;
pc++;
goto loop;
case 0x0E: // LD C,IMM
rg.c = data;
pc++;
goto loop;
case 0x16: // LD D,IMM
rg.d = data;
pc++;
goto loop;
case 0x1E: // LD E,IMM
rg.e = data;
pc++;
goto loop;
case 0x26: // LD H,IMM
rg.h = data;
pc++;
goto loop;
case 0x2E: // LD L,IMM
rg.l = data;
pc++;
goto loop;
case 0x36: // LD (HL),IMM
WRITE( rp.hl, data );
pc++;
goto loop;
case 0x3E: // LD A,IMM
rg.a = data;
pc++;
goto loop;
// Increment/Decrement
case 0x03: // INC BC
case 0x13: // INC DE
case 0x23: // INC HL
r16 [op >> 4]++;
goto loop;
case 0x33: // INC SP
sp = (sp + 1) & 0xFFFF;
goto loop;
case 0x0B: // DEC BC
case 0x1B: // DEC DE
case 0x2B: // DEC HL
r16 [op >> 4]--;
goto loop;
case 0x3B: // DEC SP
sp = (sp - 1) & 0xFFFF;
goto loop;
case 0x34: // INC (HL)
op = rp.hl;
data = READ( op );
data++;
WRITE( op, data & 0xFF );
goto inc_comm;
case 0x04: // INC B
case 0x0C: // INC C (common)
case 0x14: // INC D
case 0x1C: // INC E
case 0x24: // INC H
case 0x2C: // INC L
case 0x3C: // INC A
op = (op >> 3) & 7;
R8( op ) = data = R8( op ) + 1;
inc_comm:
flags = (flags & c_flag) | (((data & 15) - 1) & h_flag) | ((data >> 1) & z_flag);
goto loop;
case 0x35: // DEC (HL)
op = rp.hl;
data = READ( op );
data--;
WRITE( op, data & 0xFF );
goto dec_comm;
case 0x05: // DEC B
case 0x0D: // DEC C
case 0x15: // DEC D
case 0x1D: // DEC E
case 0x25: // DEC H
case 0x2D: // DEC L
case 0x3D: // DEC A
op = (op >> 3) & 7;
data = R8( op ) - 1;
R8( op ) = data;
dec_comm:
flags = (flags & c_flag) | n_flag | (((data & 15) + 0x31) & h_flag);
if ( data & 0xFF )
goto loop;
flags |= z_flag;
goto loop;
// Add 16-bit
{
blargg_ulong temp; // need more than 16 bits for carry
unsigned prev;
case 0xF8: // LD HL,SP+imm
- temp = BOOST::int8_t (data); // sign-extend to 16 bits
+ temp = int8_t (data); // sign-extend to 16 bits
pc++;
flags = 0;
temp += sp;
prev = sp;
goto add_16_hl;
case 0xE8: // ADD SP,IMM
- temp = BOOST::int8_t (data); // sign-extend to 16 bits
+ temp = int8_t (data); // sign-extend to 16 bits
pc++;
flags = 0;
temp += sp;
prev = sp;
sp = temp & 0xFFFF;
goto add_16_comm;
case 0x39: // ADD HL,SP
temp = sp;
goto add_hl_comm;
case 0x09: // ADD HL,BC
case 0x19: // ADD HL,DE
case 0x29: // ADD HL,HL
temp = r16 [op >> 4];
add_hl_comm:
prev = rp.hl;
temp += prev;
flags &= z_flag;
add_16_hl:
rp.hl = temp;
add_16_comm:
flags |= (temp >> 12) & c_flag;
flags |= (((temp & 0x0FFF) - (prev & 0x0FFF)) >> 7) & h_flag;
goto loop;
}
case 0x86: // ADD (HL)
data = READ( rp.hl );
goto add_comm;
case 0x80: // ADD B
case 0x81: // ADD C
case 0x82: // ADD D
case 0x83: // ADD E
case 0x84: // ADD H
case 0x85: // ADD L
case 0x87: // ADD A
data = R8( op & 7 );
goto add_comm;
case 0xC6: // ADD IMM
pc++;
add_comm:
flags = rg.a;
data += flags;
flags = ((data & 15) - (flags & 15)) & h_flag;
flags |= (data >> 4) & c_flag;
rg.a = data;
if ( data & 0xFF )
goto loop;
flags |= z_flag;
goto loop;
// Add/Subtract
case 0x8E: // ADC (HL)
data = READ( rp.hl );
goto adc_comm;
case 0x88: // ADC B
case 0x89: // ADC C
case 0x8A: // ADC D
case 0x8B: // ADC E
case 0x8C: // ADC H
case 0x8D: // ADC L
case 0x8F: // ADC A
data = R8( op & 7 );
goto adc_comm;
case 0xCE: // ADC IMM
pc++;
adc_comm:
data += (flags >> 4) & 1;
data &= 0xFF; // to do: does carry get set when sum + carry = 0x100?
goto add_comm;
case 0x96: // SUB (HL)
data = READ( rp.hl );
goto sub_comm;
case 0x90: // SUB B
case 0x91: // SUB C
case 0x92: // SUB D
case 0x93: // SUB E
case 0x94: // SUB H
case 0x95: // SUB L
case 0x97: // SUB A
data = R8( op & 7 );
goto sub_comm;
case 0xD6: // SUB IMM
pc++;
sub_comm:
op = rg.a;
data = op - data;
rg.a = data;
goto sub_set_flags;
case 0x9E: // SBC (HL)
data = READ( rp.hl );
goto sbc_comm;
case 0x98: // SBC B
case 0x99: // SBC C
case 0x9A: // SBC D
case 0x9B: // SBC E
case 0x9C: // SBC H
case 0x9D: // SBC L
case 0x9F: // SBC A
data = R8( op & 7 );
goto sbc_comm;
case 0xDE: // SBC IMM
pc++;
sbc_comm:
data += (flags >> 4) & 1;
data &= 0xFF; // to do: does carry get set when sum + carry = 0x100?
goto sub_comm;
// Logical
case 0xA0: // AND B
case 0xA1: // AND C
case 0xA2: // AND D
case 0xA3: // AND E
case 0xA4: // AND H
case 0xA5: // AND L
data = R8( op & 7 );
goto and_comm;
case 0xA6: // AND (HL)
data = READ( rp.hl );
pc--;
case 0xE6: // AND IMM
pc++;
and_comm:
rg.a &= data;
case 0xA7: // AND A
flags = h_flag | (((rg.a - 1) >> 1) & z_flag);
goto loop;
case 0xB0: // OR B
case 0xB1: // OR C
case 0xB2: // OR D
case 0xB3: // OR E
case 0xB4: // OR H
case 0xB5: // OR L
data = R8( op & 7 );
goto or_comm;
case 0xB6: // OR (HL)
data = READ( rp.hl );
pc--;
case 0xF6: // OR IMM
pc++;
or_comm:
rg.a |= data;
case 0xB7: // OR A
flags = ((rg.a - 1) >> 1) & z_flag;
goto loop;
case 0xA8: // XOR B
case 0xA9: // XOR C
case 0xAA: // XOR D
case 0xAB: // XOR E
case 0xAC: // XOR H
case 0xAD: // XOR L
data = R8( op & 7 );
goto xor_comm;
case 0xAE: // XOR (HL)
data = READ( rp.hl );
pc--;
case 0xEE: // XOR IMM
pc++;
xor_comm:
data ^= rg.a;
rg.a = data;
data--;
flags = (data >> 1) & z_flag;
goto loop;
case 0xAF: // XOR A
rg.a = 0;
flags = z_flag;
goto loop;
// Stack
case 0xF1: // POP FA
case 0xC1: // POP BC
case 0xD1: // POP DE
case 0xE1: // POP HL (common)
data = READ( sp );
r16 [(op >> 4) & 3] = data + 0x100 * READ( sp + 1 );
sp = (sp + 2) & 0xFFFF;
if ( op != 0xF1 )
goto loop;
flags = rg.flags & 0xF0;
goto loop;
case 0xC5: // PUSH BC
data = rp.bc;
goto push;
case 0xD5: // PUSH DE
data = rp.de;
goto push;
case 0xE5: // PUSH HL
data = rp.hl;
goto push;
case 0xF5: // PUSH FA
data = (flags << 8) | rg.a;
goto push;
// Flow control
case 0xFF:
if ( pc == idle_addr + 1 )
goto stop;
case 0xC7: case 0xCF: case 0xD7: case 0xDF: // RST
case 0xE7: case 0xEF: case 0xF7:
data = pc;
pc = (op & 0x38) + rst_base;
goto push;
case 0xCC: // CZ
pc += 2;
if ( flags & z_flag )
goto call;
goto loop;
case 0xD4: // CNC
pc += 2;
if ( !(flags & c_flag) )
goto call;
goto loop;
case 0xDC: // CC
pc += 2;
if ( flags & c_flag )
goto call;
goto loop;
case 0xD9: // RETI
//interrupts_enabled = 1;
goto ret;
case 0xC0: // RZ
if ( !(flags & z_flag) )
goto ret;
goto loop;
case 0xD0: // RNC
if ( !(flags & c_flag) )
goto ret;
goto loop;
case 0xD8: // RC
if ( flags & c_flag )
goto ret;
goto loop;
case 0x18: // JR
BRANCH( true )
case 0x30: // JR NC
BRANCH( !(flags & c_flag) )
case 0x38: // JR C
BRANCH( flags & c_flag )
case 0xE9: // JP_HL
pc = rp.hl;
goto loop;
case 0xC3: // JP (next-most-common)
pc = GET_ADDR();
goto loop;
case 0xC2: // JP NZ
pc += 2;
if ( !(flags & z_flag) )
goto jp_taken;
goto loop;
case 0xCA: // JP Z (most common)
pc += 2;
if ( !(flags & z_flag) )
goto loop;
jp_taken:
pc -= 2;
pc = GET_ADDR();
goto loop;
case 0xD2: // JP NC
pc += 2;
if ( !(flags & c_flag) )
goto jp_taken;
goto loop;
case 0xDA: // JP C
pc += 2;
if ( flags & c_flag )
goto jp_taken;
goto loop;
// Flags
case 0x2F: // CPL
rg.a = ~rg.a;
flags |= n_flag | h_flag;
goto loop;
case 0x3F: // CCF
flags = (flags ^ c_flag) & ~(n_flag | h_flag);
goto loop;
case 0x37: // SCF
flags = (flags | c_flag) & ~(n_flag | h_flag);
goto loop;
case 0xF3: // DI
//interrupts_enabled = 0;
goto loop;
case 0xFB: // EI
//interrupts_enabled = 1;
goto loop;
// Special
case 0xDD: case 0xD3: case 0xDB: case 0xE3: case 0xE4: // ?
case 0xEB: case 0xEC: case 0xF4: case 0xFD: case 0xFC:
case 0x10: // STOP
case 0x27: // DAA (I'll have to implement this eventually...)
case 0xBF:
case 0xED: // Z80 prefix
case 0x76: // HALT
s.remain++;
goto stop;
}
// If this fails then the case above is missing an opcode
assert( false );
stop:
pc--;
// copy state back
STATIC_CAST(core_regs_t&,r) = rg;
r.pc = pc;
r.sp = sp;
r.flags = flags;
this->state = &state_;
memcpy( &this->state_, &s, sizeof this->state_ );
return s.remain > 0;
}
diff --git a/src/libs/gme/Gb_Cpu.h b/src/libs/gme/Gb_Cpu.h
index 9d623e04..d3df30ca 100644
--- a/src/libs/gme/Gb_Cpu.h
+++ b/src/libs/gme/Gb_Cpu.h
@@ -1,93 +1,91 @@
// Nintendo Game Boy CPU emulator
// Treats every instruction as taking 4 cycles
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef GB_CPU_H
#define GB_CPU_H
#include "blargg_common.h"
#include "blargg_endian.h"
typedef unsigned gb_addr_t; // 16-bit CPU address
class Gb_Cpu {
enum { clocks_per_instr = 4 };
public:
- typedef BOOST::uint8_t uint8_t;
-
// Clear registers and map all pages to unmapped
void reset( void* unmapped = 0 );
// Map code memory (memory accessed via the program counter). Start and size
// must be multiple of page_size.
enum { page_size = 0x2000 };
void map_code( gb_addr_t start, unsigned size, void* code );
uint8_t* get_code( gb_addr_t );
// Push a byte on the stack
void push_byte( int );
// Game Boy Z80 registers. *Not* kept updated during a call to run().
struct core_regs_t {
#if BLARGG_BIG_ENDIAN
uint8_t b, c, d, e, h, l, flags, a;
#else
uint8_t c, b, e, d, l, h, a, flags;
#endif
};
struct registers_t : core_regs_t {
long pc; // more than 16 bits to allow overflow detection
- BOOST::uint16_t sp;
+ uint16_t sp;
};
registers_t r;
// Interrupt enable flag set by EI and cleared by DI
//bool interrupts_enabled; // unused
// Base address for RST vectors (normally 0)
gb_addr_t rst_base;
// If CPU executes opcode 0xFF at this address, it treats as illegal instruction
enum { idle_addr = 0xF00D };
// Run CPU for at least 'count' cycles and return false, or return true if
// illegal instruction is encountered.
bool run( blargg_long count );
// Number of clock cycles remaining for most recent run() call
blargg_long remain() const { return state->remain * clocks_per_instr; }
// Can read this many bytes past end of a page
enum { cpu_padding = 8 };
public:
Gb_Cpu() : rst_base( 0 ) { state = &state_; }
enum { page_shift = 13 };
enum { page_count = 0x10000 >> page_shift };
private:
// noncopyable
Gb_Cpu( const Gb_Cpu& );
Gb_Cpu& operator = ( const Gb_Cpu& );
struct state_t {
uint8_t* code_map [page_count + 1];
blargg_long remain;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
void set_code_page( int, uint8_t* );
};
-inline BOOST::uint8_t* Gb_Cpu::get_code( gb_addr_t addr )
+inline uint8_t* Gb_Cpu::get_code( gb_addr_t addr )
{
return state->code_map [addr >> page_shift] + addr
#if !BLARGG_NONPORTABLE
% (unsigned) page_size
#endif
;
}
#endif
diff --git a/src/libs/gme/Gb_Oscs.h b/src/libs/gme/Gb_Oscs.h
index d7f88ea1..8cb026c3 100644
--- a/src/libs/gme/Gb_Oscs.h
+++ b/src/libs/gme/Gb_Oscs.h
@@ -1,83 +1,83 @@
// Private oscillators used by Gb_Apu
// Gb_Snd_Emu 0.1.5
#ifndef GB_OSCS_H
#define GB_OSCS_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
struct Gb_Osc
{
enum { trigger = 0x80 };
enum { len_enabled_mask = 0x40 };
Blip_Buffer* outputs [4]; // NULL, right, left, center
Blip_Buffer* output;
int output_select;
- BOOST::uint8_t* regs; // osc's 5 registers
+ uint8_t* regs; // osc's 5 registers
int delay;
int last_amp;
int volume;
int length;
int enabled;
void reset();
void clock_length();
int frequency() const { return (regs [4] & 7) * 0x100 + regs [3]; }
};
struct Gb_Env : Gb_Osc
{
int env_delay;
void reset();
void clock_envelope();
bool write_register( int, int );
};
struct Gb_Square : Gb_Env
{
enum { period_mask = 0x70 };
enum { shift_mask = 0x07 };
typedef Blip_Synth<blip_good_quality,1> Synth;
Synth const* synth;
int sweep_delay;
int sweep_freq;
int phase;
void reset();
void clock_sweep();
void run( blip_time_t, blip_time_t, int playing );
};
struct Gb_Noise : Gb_Env
{
typedef Blip_Synth<blip_med_quality,1> Synth;
Synth const* synth;
unsigned bits;
void run( blip_time_t, blip_time_t, int playing );
};
struct Gb_Wave : Gb_Osc
{
typedef Blip_Synth<blip_med_quality,1> Synth;
Synth const* synth;
int wave_pos;
enum { wave_size = 32 };
- BOOST::uint8_t wave [wave_size];
+ uint8_t wave [wave_size];
void write_register( int, int );
void run( blip_time_t, blip_time_t, int playing );
};
inline void Gb_Env::reset()
{
env_delay = 0;
Gb_Osc::reset();
}
#endif
diff --git a/src/libs/gme/Gbs_Emu.cpp b/src/libs/gme/Gbs_Emu.cpp
index ceb526e5..6c5def33 100644
--- a/src/libs/gme/Gbs_Emu.cpp
+++ b/src/libs/gme/Gbs_Emu.cpp
@@ -1,289 +1,290 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Gbs_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
-Gbs_Emu::equalizer_t const Gbs_Emu::handheld_eq = { -47.0, 2000 };
-Gbs_Emu::equalizer_t const Gbs_Emu::headphones_eq = { 0.0, 300 };
+Gbs_Emu::equalizer_t const Gbs_Emu::handheld_eq =
+ Music_Emu::make_equalizer( -47.0, 2000 );
+Gbs_Emu::equalizer_t const Gbs_Emu::headphones_eq =
+ Music_Emu::make_equalizer( 0.0, 300 );
Gbs_Emu::Gbs_Emu()
{
set_type( gme_gbs_type );
static const char* const names [Gb_Apu::osc_count] = {
"Square 1", "Square 2", "Wave", "Noise"
};
set_voice_names( names );
static int const types [Gb_Apu::osc_count] = {
wave_type | 1, wave_type | 2, wave_type | 0, mixed_type | 0
};
set_voice_types( types );
set_silence_lookahead( 6 );
set_max_initial_silence( 21 );
set_gain( 1.2 );
- static equalizer_t const eq = { -1.0, 120 };
- set_equalizer( eq );
+ set_equalizer( make_equalizer( -1.0, 120 ) );
}
Gbs_Emu::~Gbs_Emu() { }
void Gbs_Emu::unload()
{
rom.clear();
Music_Emu::unload();
}
// Track info
static void copy_gbs_fields( Gbs_Emu::header_t const& h, track_info_t* out )
{
GME_COPY_FIELD( h, out, game );
GME_COPY_FIELD( h, out, author );
GME_COPY_FIELD( h, out, copyright );
}
blargg_err_t Gbs_Emu::track_info_( track_info_t* out, int ) const
{
copy_gbs_fields( header_, out );
return 0;
}
static blargg_err_t check_gbs_header( void const* header )
{
if ( memcmp( header, "GBS", 3 ) )
return gme_wrong_file_type;
return 0;
}
struct Gbs_File : Gme_Info_
{
Gbs_Emu::header_t h;
Gbs_File() { set_type( gme_gbs_type ); }
blargg_err_t load_( Data_Reader& in )
{
blargg_err_t err = in.read( &h, Gbs_Emu::header_size );
if ( err )
return (err == in.eof_error ? gme_wrong_file_type : err);
set_track_count( h.track_count );
return check_gbs_header( &h );
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
copy_gbs_fields( h, out );
return 0;
}
};
static Music_Emu* new_gbs_emu () { return BLARGG_NEW Gbs_Emu ; }
static Music_Emu* new_gbs_file() { return BLARGG_NEW Gbs_File; }
static gme_type_t_ const gme_gbs_type_ = { "Game Boy", 0, &new_gbs_emu, &new_gbs_file, "GBS", 1 };
-gme_type_t const gme_gbs_type = &gme_gbs_type_;
+BLARGG_EXPORT extern gme_type_t const gme_gbs_type = &gme_gbs_type_;
// Setup
blargg_err_t Gbs_Emu::load_( Data_Reader& in )
{
assert( offsetof (header_t,copyright [32]) == header_size );
RETURN_ERR( rom.load( in, header_size, &header_, 0 ) );
set_track_count( header_.track_count );
RETURN_ERR( check_gbs_header( &header_ ) );
if ( header_.vers != 1 )
set_warning( "Unknown file version" );
if ( header_.timer_mode & 0x78 )
set_warning( "Invalid timer mode" );
unsigned load_addr = get_le16( header_.load_addr );
if ( (header_.load_addr [1] | header_.init_addr [1] | header_.play_addr [1]) > 0x7F ||
load_addr < 0x400 )
set_warning( "Invalid load/init/play address" );
set_voice_count( Gb_Apu::osc_count );
apu.volume( gain() );
return setup_buffer( 4194304 );
}
void Gbs_Emu::update_eq( blip_eq_t const& eq )
{
apu.treble_eq( eq );
}
void Gbs_Emu::set_voice( int i, Blip_Buffer* c, Blip_Buffer* l, Blip_Buffer* r )
{
apu.osc_output( i, c, l, r );
}
// Emulation
// see gb_cpu_io.h for read/write functions
void Gbs_Emu::set_bank( int n )
{
blargg_long addr = rom.mask_addr( n * (blargg_long) bank_size );
if ( addr == 0 && rom.size() > bank_size )
{
// TODO: what is the correct behavior? Current Game & Watch Gallery
// rip requires that this have no effect or set to bank 1.
//debug_printf( "Selected ROM bank 0\n" );
return;
//n = 1;
}
cpu::map_code( bank_size, bank_size, rom.at_addr( addr ) );
}
void Gbs_Emu::update_timer()
{
if ( header_.timer_mode & 0x04 )
{
static byte const rates [4] = { 10, 4, 6, 8 };
int shift = rates [ram [hi_page + 7] & 3] - (header_.timer_mode >> 7);
play_period = (256L - ram [hi_page + 6]) << shift;
}
else
{
play_period = 70224; // 59.73 Hz
}
if ( tempo() != 1.0 )
play_period = blip_time_t (play_period / tempo());
}
-static BOOST::uint8_t const sound_data [Gb_Apu::register_count] = {
+static uint8_t const sound_data [Gb_Apu::register_count] = {
0x80, 0xBF, 0x00, 0x00, 0xBF, // square 1
0x00, 0x3F, 0x00, 0x00, 0xBF, // square 2
0x7F, 0xFF, 0x9F, 0x00, 0xBF, // wave
0x00, 0xFF, 0x00, 0x00, 0xBF, // noise
0x77, 0xF3, 0xF1, // vin/volume, status, power mode
0, 0, 0, 0, 0, 0, 0, 0, 0, // unused
0xAC, 0xDD, 0xDA, 0x48, 0x36, 0x02, 0xCF, 0x16, // waveform data
0x2C, 0x04, 0xE5, 0x2C, 0xAC, 0xDD, 0xDA, 0x48
};
void Gbs_Emu::cpu_jsr( gb_addr_t addr )
{
check( cpu::r.sp == get_le16( header_.stack_ptr ) );
cpu::r.pc = addr;
cpu_write( --cpu::r.sp, idle_addr >> 8 );
cpu_write( --cpu::r.sp, idle_addr&0xFF );
}
void Gbs_Emu::set_tempo_( double t )
{
apu.set_tempo( t );
update_timer();
}
blargg_err_t Gbs_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( ram, 0, 0x4000 );
memset( ram + 0x4000, 0xFF, 0x1F80 );
memset( ram + 0x5F80, 0, sizeof ram - 0x5F80 );
ram [hi_page] = 0; // joypad reads back as 0
apu.reset();
for ( int i = 0; i < (int) sizeof sound_data; i++ )
apu.write_register( 0, i + apu.start_addr, sound_data [i] );
- cpu::reset( rom.unmapped() );
-
unsigned load_addr = get_le16( header_.load_addr );
- cpu::rst_base = load_addr;
rom.set_addr( load_addr );
+ cpu::rst_base = load_addr;
+
+ cpu::reset( rom.unmapped() );
cpu::map_code( ram_addr, 0x10000 - ram_addr, ram );
cpu::map_code( 0, bank_size, rom.at_addr( 0 ) );
set_bank( rom.size() > bank_size );
ram [hi_page + 6] = header_.timer_modulo;
ram [hi_page + 7] = header_.timer_mode;
update_timer();
next_play = play_period;
cpu::r.a = track;
cpu::r.pc = idle_addr;
cpu::r.sp = get_le16( header_.stack_ptr );
cpu_time = 0;
cpu_jsr( get_le16( header_.init_addr ) );
return 0;
}
blargg_err_t Gbs_Emu::run_clocks( blip_time_t& duration, int )
{
cpu_time = 0;
while ( cpu_time < duration )
{
long count = duration - cpu_time;
cpu_time = duration;
bool result = cpu::run( count );
cpu_time -= cpu::remain();
if ( result )
{
if ( cpu::r.pc == idle_addr )
{
if ( next_play > duration )
{
cpu_time = duration;
break;
}
if ( cpu_time < next_play )
cpu_time = next_play;
next_play += play_period;
cpu_jsr( get_le16( header_.play_addr ) );
GME_FRAME_HOOK( this );
// TODO: handle timer rates different than 60 Hz
}
else if ( cpu::r.pc > 0xFFFF )
{
debug_printf( "PC wrapped around\n" );
cpu::r.pc &= 0xFFFF;
}
else
{
set_warning( "Emulation error (illegal/unsupported instruction)" );
debug_printf( "Bad opcode $%.2x at $%.4x\n",
(int) *cpu::get_code( cpu::r.pc ), (int) cpu::r.pc );
cpu::r.pc = (cpu::r.pc + 1) & 0xFFFF;
cpu_time += 6;
}
}
}
duration = cpu_time;
next_play -= cpu_time;
if ( next_play < 0 ) // could go negative if routine is taking too long to return
next_play = 0;
apu.end_frame( cpu_time );
return 0;
}
diff --git a/src/libs/gme/Gbs_Emu.h b/src/libs/gme/Gbs_Emu.h
index 30a66047..580f395c 100644
--- a/src/libs/gme/Gbs_Emu.h
+++ b/src/libs/gme/Gbs_Emu.h
@@ -1,88 +1,88 @@
// Nintendo Game Boy GBS music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef GBS_EMU_H
#define GBS_EMU_H
#include "Classic_Emu.h"
#include "Gb_Apu.h"
#include "Gb_Cpu.h"
class Gbs_Emu : private Gb_Cpu, public Classic_Emu {
typedef Gb_Cpu cpu;
public:
// Equalizer profiles for Game Boy Color speaker and headphones
static equalizer_t const handheld_eq;
static equalizer_t const headphones_eq;
// GBS file header
enum { header_size = 112 };
struct header_t
{
char tag [3];
byte vers;
byte track_count;
byte first_track;
byte load_addr [2];
byte init_addr [2];
byte play_addr [2];
byte stack_ptr [2];
byte timer_modulo;
byte timer_mode;
char game [32];
char author [32];
char copyright [32];
};
// Header for currently loaded file
header_t const& header() const { return header_; }
static gme_type_t static_type() { return gme_gbs_type; }
public:
// deprecated
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
public:
Gbs_Emu();
~Gbs_Emu();
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_( Data_Reader& );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
void unload();
private:
// rom
enum { bank_size = 0x4000 };
Rom_Data<bank_size> rom;
void set_bank( int );
// timer
blip_time_t cpu_time;
blip_time_t play_period;
blip_time_t next_play;
void update_timer();
header_t header_;
void cpu_jsr( gb_addr_t );
public: private: friend class Gb_Cpu;
blip_time_t clock() const { return cpu_time - cpu::remain(); }
enum { joypad_addr = 0xFF00 };
enum { ram_addr = 0xA000 };
enum { hi_page = 0xFF00 - ram_addr };
byte ram [0x4000 + 0x2000 + Gb_Cpu::cpu_padding];
Gb_Apu apu;
int cpu_read( gb_addr_t );
void cpu_write( gb_addr_t, int );
};
#endif
diff --git a/src/libs/gme/Gme_File.cpp b/src/libs/gme/Gme_File.cpp
index 17edc9f8..a5e4516d 100644
--- a/src/libs/gme/Gme_File.cpp
+++ b/src/libs/gme/Gme_File.cpp
@@ -1,216 +1,216 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Gme_File.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
const char* const gme_wrong_file_type = "Wrong file type for this emulator";
void Gme_File::clear_playlist()
{
playlist.clear();
clear_playlist_();
track_count_ = raw_track_count_;
}
void Gme_File::unload()
{
clear_playlist(); // *before* clearing track count
track_count_ = 0;
raw_track_count_ = 0;
file_data.clear();
}
Gme_File::Gme_File()
{
type_ = 0;
user_data_ = 0;
user_cleanup_ = 0;
unload(); // clears fields
blargg_verify_byte_order(); // used by most emulator types, so save them the trouble
}
Gme_File::~Gme_File()
{
if ( user_cleanup_ )
user_cleanup_( user_data_ );
}
blargg_err_t Gme_File::load_mem_( byte const* data, long size )
{
require( data != file_data.begin() ); // load_mem_() or load_() must be overridden
Mem_File_Reader in( data, size );
return load_( in );
}
blargg_err_t Gme_File::load_( Data_Reader& in )
{
RETURN_ERR( file_data.resize( in.remain() ) );
RETURN_ERR( in.read( file_data.begin(), file_data.size() ) );
return load_mem_( file_data.begin(), file_data.size() );
}
// public load functions call this at beginning
void Gme_File::pre_load() { unload(); }
void Gme_File::post_load_() { }
// public load functions call this at end
blargg_err_t Gme_File::post_load( blargg_err_t err )
{
if ( !track_count() )
set_track_count( type()->track_count );
if ( !err )
post_load_();
else
unload();
return err;
}
// Public load functions
blargg_err_t Gme_File::load_mem( void const* in, long size )
{
pre_load();
return post_load( load_mem_( (byte const*) in, size ) );
}
blargg_err_t Gme_File::load( Data_Reader& in )
{
pre_load();
return post_load( load_( in ) );
}
blargg_err_t Gme_File::load_file( const char* path )
{
pre_load();
GME_FILE_READER in;
RETURN_ERR( in.open( path ) );
return post_load( load_( in ) );
}
blargg_err_t Gme_File::load_remaining_( void const* h, long s, Data_Reader& in )
{
Remaining_Reader rem( h, s, &in );
return load( rem );
}
// Track info
void Gme_File::copy_field_( char* out, const char* in, int in_size )
{
if ( !in || !*in )
return;
// remove spaces/junk from beginning
while ( in_size && unsigned (*in - 1) <= ' ' - 1 )
{
in++;
in_size--;
}
// truncate
if ( in_size > max_field_ )
in_size = max_field_;
// find terminator
int len = 0;
while ( len < in_size && in [len] )
len++;
// remove spaces/junk from end
while ( len && unsigned (in [len - 1]) <= ' ' )
len--;
// copy
out [len] = 0;
memcpy( out, in, len );
// strip out stupid fields that should have been left blank
if ( !strcmp( out, "?" ) || !strcmp( out, "<?>" ) || !strcmp( out, "< ? >" ) )
out [0] = 0;
}
void Gme_File::copy_field_( char* out, const char* in )
{
copy_field_( out, in, max_field_ );
}
blargg_err_t Gme_File::remap_track_( int* track_io ) const
{
if ( (unsigned) *track_io >= (unsigned) track_count() )
return "Invalid track";
if ( (unsigned) *track_io < (unsigned) playlist.size() )
{
M3u_Playlist::entry_t const& e = playlist [*track_io];
*track_io = 0;
if ( e.track >= 0 )
{
*track_io = e.track;
if ( !(type_->flags_ & 0x02) )
*track_io -= e.decimal_track;
}
if ( *track_io >= raw_track_count_ )
return "Invalid track in m3u playlist";
}
else
{
check( !playlist.size() );
}
return 0;
}
blargg_err_t Gme_File::track_info( track_info_t* out, int track ) const
{
out->track_count = track_count();
out->length = -1;
out->loop_length = -1;
out->intro_length = -1;
out->song [0] = 0;
out->game [0] = 0;
out->author [0] = 0;
out->copyright [0] = 0;
out->comment [0] = 0;
out->dumper [0] = 0;
out->system [0] = 0;
copy_field_( out->system, type()->system );
int remapped = track;
RETURN_ERR( remap_track_( &remapped ) );
RETURN_ERR( track_info_( out, remapped ) );
// override with m3u info
if ( playlist.size() )
{
M3u_Playlist::info_t const& i = playlist.info();
copy_field_( out->game , i.title );
copy_field_( out->author, i.engineer );
copy_field_( out->author, i.composer );
copy_field_( out->dumper, i.ripping );
M3u_Playlist::entry_t const& e = playlist [track];
copy_field_( out->song, e.name );
if ( e.length >= 0 ) out->length = e.length * 1000L;
if ( e.intro >= 0 ) out->intro_length = e.intro * 1000L;
if ( e.loop >= 0 ) out->loop_length = e.loop * 1000L;
}
return 0;
}
diff --git a/src/libs/gme/Gme_File.h b/src/libs/gme/Gme_File.h
index a327ceb6..111a71d9 100644
--- a/src/libs/gme/Gme_File.h
+++ b/src/libs/gme/Gme_File.h
@@ -1,177 +1,177 @@
// Common interface to game music file loading and information
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef GME_FILE_H
#define GME_FILE_H
#include "gme.h"
#include "blargg_common.h"
#include "Data_Reader.h"
#include "M3u_Playlist.h"
// Error returned if file is wrong type
//extern const char gme_wrong_file_type []; // declared in gme.h
struct gme_type_t_
{
const char* system; /* name of system this music file type is generally for */
int track_count; /* non-zero for formats with a fixed number of tracks */
Music_Emu* (*new_emu)(); /* Create new emulator for this type (useful in C++ only) */
Music_Emu* (*new_info)(); /* Create new info reader for this type */
/* internal */
const char* extension_;
int flags_;
};
struct track_info_t
{
long track_count;
/* times in milliseconds; -1 if unknown */
long length;
long intro_length;
long loop_length;
/* empty string if not available */
char system [256];
char game [256];
char song [256];
char author [256];
char copyright [256];
char comment [256];
char dumper [256];
};
enum { gme_max_field = 255 };
struct Gme_File {
public:
// File loading
// Each loads game music data from a file and returns an error if
// file is wrong type or is seriously corrupt. They also set warning
// string for minor problems.
// Load from file on disk
blargg_err_t load_file( const char* path );
// Load from custom data source (see Data_Reader.h)
blargg_err_t load( Data_Reader& );
// Load from file already read into memory. Keeps pointer to data, so you
// must not free it until you're done with the file.
blargg_err_t load_mem( void const* data, long size );
// Load an m3u playlist. Must be done after loading main music file.
blargg_err_t load_m3u( const char* path );
blargg_err_t load_m3u( Data_Reader& in );
// Clears any loaded m3u playlist and any internal playlist that the music
// format supports (NSFE for example).
void clear_playlist();
// Informational
// Type of emulator. For example if this returns gme_nsfe_type, this object
// is an NSFE emulator, and you can cast to an Nsfe_Emu* if necessary.
gme_type_t type() const;
// Most recent warning string, or NULL if none. Clears current warning after
// returning.
const char* warning();
// Number of tracks or 0 if no file has been loaded
int track_count() const;
// Get information for a track (length, name, author, etc.)
// See gme.h for definition of struct track_info_t.
blargg_err_t track_info( track_info_t* out, int track ) const;
// User data/cleanup
// Set/get pointer to data you want to associate with this emulator.
// You can use this for whatever you want.
void set_user_data( void* p ) { user_data_ = p; }
void* user_data() const { return user_data_; }
// Register cleanup function to be called when deleting emulator, or NULL to
// clear it. Passes user_data to cleanup function.
void set_user_cleanup( gme_user_cleanup_t func ) { user_cleanup_ = func; }
public:
// deprecated
int error_count() const; // use warning()
public:
Gme_File();
virtual ~Gme_File();
BLARGG_DISABLE_NOTHROW
- typedef BOOST::uint8_t byte;
+ typedef uint8_t byte;
protected:
// Services
void set_track_count( int n ) { track_count_ = raw_track_count_ = n; }
void set_warning( const char* s ) { warning_ = s; }
void set_type( gme_type_t t ) { type_ = t; }
blargg_err_t load_remaining_( void const* header, long header_size, Data_Reader& remaining );
// Overridable
virtual void unload(); // called before loading file and if loading fails
virtual blargg_err_t load_( Data_Reader& ); // default loads then calls load_mem_()
virtual blargg_err_t load_mem_( byte const* data, long size ); // use data in memory
virtual blargg_err_t track_info_( track_info_t* out, int track ) const = 0;
virtual void pre_load();
virtual void post_load_();
virtual void clear_playlist_() { }
public:
blargg_err_t remap_track_( int* track_io ) const; // need by Music_Emu
private:
// noncopyable
Gme_File( const Gme_File& );
Gme_File& operator = ( const Gme_File& );
gme_type_t type_;
int track_count_;
int raw_track_count_;
const char* warning_;
void* user_data_;
gme_user_cleanup_t user_cleanup_;
M3u_Playlist playlist;
char playlist_warning [64];
blargg_vector<byte> file_data; // only if loaded into memory using default load
blargg_err_t load_m3u_( blargg_err_t );
blargg_err_t post_load( blargg_err_t err );
public:
// track_info field copying
enum { max_field_ = 255 };
static void copy_field_( char* out, const char* in );
static void copy_field_( char* out, const char* in, int len );
};
Music_Emu* gme_new_( Music_Emu*, long sample_rate );
#define GME_COPY_FIELD( in, out, name ) \
{ Gme_File::copy_field_( out->name, in.name, sizeof in.name ); }
#ifndef GME_FILE_READER
#ifdef HAVE_ZLIB_H
#define GME_FILE_READER Gzip_File_Reader
#else
#define GME_FILE_READER Std_File_Reader
#endif
#elif defined (GME_FILE_READER_INCLUDE)
#include GME_FILE_READER_INCLUDE
#endif
inline gme_type_t Gme_File::type() const { return type_; }
inline int Gme_File::error_count() const { return warning_ != 0; }
inline int Gme_File::track_count() const { return track_count_; }
inline const char* Gme_File::warning()
{
const char* s = warning_;
warning_ = 0;
return s;
}
#endif
diff --git a/src/libs/gme/Gym_Emu.cpp b/src/libs/gme/Gym_Emu.cpp
index eb547f7f..bb99ff03 100644
--- a/src/libs/gme/Gym_Emu.cpp
+++ b/src/libs/gme/Gym_Emu.cpp
@@ -1,380 +1,380 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Gym_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
-static double const min_tempo = 0.25;
-static double const oversample_factor = 5 / 3.0;
-static double const fm_gain = 3.0;
+double const min_tempo = 0.25;
+double const oversample_factor = 5 / 3.0;
+double const fm_gain = 3.0;
-static const long base_clock = 53700300;
-static const long clock_rate = base_clock / 15;
+const long base_clock = 53700300;
+const long clock_rate = base_clock / 15;
Gym_Emu::Gym_Emu()
{
data = 0;
pos = 0;
set_type( gme_gym_type );
static const char* const names [] = {
"FM 1", "FM 2", "FM 3", "FM 4", "FM 5", "FM 6", "PCM", "PSG"
};
set_voice_names( names );
set_silence_lookahead( 1 ); // tracks should already be trimmed
}
Gym_Emu::~Gym_Emu() { }
// Track info
static void get_gym_info( Gym_Emu::header_t const& h, long length, track_info_t* out )
{
if ( !memcmp( h.tag, "GYMX", 4 ) )
{
length = length * 50 / 3; // 1000 / 60
long loop = get_le32( h.loop_start );
if ( loop )
{
out->intro_length = loop * 50 / 3;
out->loop_length = length - out->intro_length;
}
else
{
out->length = length;
out->intro_length = length; // make it clear that track is no longer than length
out->loop_length = 0;
}
// more stupidity where the field should have been left
if ( strcmp( h.song, "Unknown Song" ) )
GME_COPY_FIELD( h, out, song );
if ( strcmp( h.game, "Unknown Game" ) )
GME_COPY_FIELD( h, out, game );
if ( strcmp( h.copyright, "Unknown Publisher" ) )
GME_COPY_FIELD( h, out, copyright );
if ( strcmp( h.dumper, "Unknown Person" ) )
GME_COPY_FIELD( h, out, dumper );
if ( strcmp( h.comment, "Header added by YMAMP" ) )
GME_COPY_FIELD( h, out, comment );
}
}
blargg_err_t Gym_Emu::track_info_( track_info_t* out, int ) const
{
get_gym_info( header_, track_length(), out );
return 0;
}
static long gym_track_length( byte const* p, byte const* end )
{
long time = 0;
while ( p < end )
{
switch ( *p++ )
{
case 0:
time++;
break;
case 1:
case 2:
p += 2;
break;
case 3:
p += 1;
break;
}
}
return time;
}
long Gym_Emu::track_length() const { return gym_track_length( data, data_end ); }
static blargg_err_t check_header( byte const* in, long size, int* data_offset = 0 )
{
if ( size < 4 )
return gme_wrong_file_type;
if ( memcmp( in, "GYMX", 4 ) == 0 )
{
if ( size < Gym_Emu::header_size + 1 )
return gme_wrong_file_type;
if ( memcmp( ((Gym_Emu::header_t const*) in)->packed, "\0\0\0\0", 4 ) != 0 )
return "Packed GYM file not supported";
if ( data_offset )
*data_offset = Gym_Emu::header_size;
}
else if ( *in > 3 )
{
return gme_wrong_file_type;
}
return 0;
}
struct Gym_File : Gme_Info_
{
byte const* file_begin;
byte const* file_end;
int data_offset;
Gym_File() { set_type( gme_gym_type ); }
blargg_err_t load_mem_( byte const* in, long size )
{
file_begin = in;
file_end = in + size;
data_offset = 0;
return check_header( in, size, &data_offset );
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
long length = gym_track_length( &file_begin [data_offset], file_end );
get_gym_info( *(Gym_Emu::header_t const*) file_begin, length, out );
return 0;
}
};
static Music_Emu* new_gym_emu () { return BLARGG_NEW Gym_Emu ; }
static Music_Emu* new_gym_file() { return BLARGG_NEW Gym_File; }
static gme_type_t_ const gme_gym_type_ = { "Sega Genesis", 1, &new_gym_emu, &new_gym_file, "GYM", 0 };
-gme_type_t const gme_gym_type = &gme_gym_type_;
+BLARGG_EXPORT extern gme_type_t const gme_gym_type = &gme_gym_type_;
// Setup
blargg_err_t Gym_Emu::set_sample_rate_( long sample_rate )
{
blip_eq_t eq( -32, 8000, sample_rate );
apu.treble_eq( eq );
dac_synth.treble_eq( eq );
apu.volume( 0.135 * fm_gain * gain() );
dac_synth.volume( 0.125 / 256 * fm_gain * gain() );
double factor = Dual_Resampler::setup( oversample_factor, 0.990, fm_gain * gain() );
fm_sample_rate = sample_rate * factor;
RETURN_ERR( blip_buf.set_sample_rate( sample_rate, int (1000 / 60.0 / min_tempo) ) );
blip_buf.clock_rate( clock_rate );
RETURN_ERR( fm.set_rate( fm_sample_rate, base_clock / 7.0 ) );
RETURN_ERR( Dual_Resampler::reset( long (1.0 / 60 / min_tempo * sample_rate) ) );
return 0;
}
void Gym_Emu::set_tempo_( double t )
{
if ( t < min_tempo )
{
set_tempo( min_tempo );
return;
}
if ( blip_buf.sample_rate() )
{
clocks_per_frame = long (clock_rate / 60 / tempo());
Dual_Resampler::resize( long (sample_rate() / (60.0 * tempo())) );
}
}
void Gym_Emu::mute_voices_( int mask )
{
Music_Emu::mute_voices_( mask );
fm.mute_voices( mask );
dac_muted = (mask & 0x40) != 0;
apu.output( (mask & 0x80) ? 0 : &blip_buf );
}
blargg_err_t Gym_Emu::load_mem_( byte const* in, long size )
{
assert( offsetof (header_t,packed [4]) == header_size );
int offset = 0;
RETURN_ERR( check_header( in, size, &offset ) );
set_voice_count( 8 );
data = in + offset;
data_end = in + size;
loop_begin = 0;
if ( offset )
header_ = *(header_t const*) in;
else
memset( &header_, 0, sizeof header_ );
return 0;
}
// Emulation
blargg_err_t Gym_Emu::start_track_( int track )
{
RETURN_ERR( Music_Emu::start_track_( track ) );
pos = data;
loop_remain = get_le32( header_.loop_start );
prev_dac_count = 0;
dac_enabled = false;
dac_amp = -1;
fm.reset();
apu.reset();
blip_buf.clear();
Dual_Resampler::clear();
return 0;
}
void Gym_Emu::run_dac( int dac_count )
{
// Guess beginning and end of sample and adjust rate and buffer position accordingly.
// count dac samples in next frame
int next_dac_count = 0;
const byte* p = this->pos;
int cmd;
while ( (cmd = *p++) != 0 )
{
int data = *p++;
if ( cmd <= 2 )
++p;
if ( cmd == 1 && data == 0x2A )
next_dac_count++;
}
// detect beginning and end of sample
int rate_count = dac_count;
int start = 0;
if ( !prev_dac_count && next_dac_count && dac_count < next_dac_count )
{
rate_count = next_dac_count;
start = next_dac_count - dac_count;
}
else if ( prev_dac_count && !next_dac_count && dac_count < prev_dac_count )
{
rate_count = prev_dac_count;
}
// Evenly space samples within buffer section being used
blip_resampled_time_t period = blip_buf.resampled_duration( clocks_per_frame ) / rate_count;
blip_resampled_time_t time = blip_buf.resampled_time( 0 ) +
period * start + (period >> 1);
int dac_amp = this->dac_amp;
if ( dac_amp < 0 )
dac_amp = dac_buf [0];
for ( int i = 0; i < dac_count; i++ )
{
int delta = dac_buf [i] - dac_amp;
dac_amp += delta;
dac_synth.offset_resampled( time, delta, &blip_buf );
time += period;
}
this->dac_amp = dac_amp;
}
void Gym_Emu::parse_frame()
{
int dac_count = 0;
const byte* pos = this->pos;
if ( loop_remain && !--loop_remain )
loop_begin = pos; // find loop on first time through sequence
int cmd;
while ( (cmd = *pos++) != 0 )
{
int data = *pos++;
if ( cmd == 1 )
{
int data2 = *pos++;
if ( data != 0x2A )
{
if ( data == 0x2B )
dac_enabled = (data2 & 0x80) != 0;
fm.write0( data, data2 );
}
else if ( dac_count < (int) sizeof dac_buf )
{
dac_buf [dac_count] = data2;
dac_count += dac_enabled;
}
}
else if ( cmd == 2 )
{
fm.write1( data, *pos++ );
}
else if ( cmd == 3 )
{
apu.write_data( 0, data );
}
else
{
// to do: many GYM streams are full of errors, and error count should
// reflect cases where music is really having problems
//log_error();
--pos; // put data back
}
}
// loop
if ( pos >= data_end )
{
check( pos == data_end );
if ( loop_begin )
pos = loop_begin;
else
set_track_ended();
}
this->pos = pos;
// dac
if ( dac_count && !dac_muted )
run_dac( dac_count );
prev_dac_count = dac_count;
}
int Gym_Emu::play_frame( blip_time_t blip_time, int sample_count, sample_t* buf )
{
if ( !track_ended() )
parse_frame();
apu.end_frame( blip_time );
memset( buf, 0, sample_count * sizeof *buf );
fm.run( sample_count >> 1, buf );
return sample_count;
}
blargg_err_t Gym_Emu::play_( long count, sample_t* out )
{
Dual_Resampler::dual_play( count, out, blip_buf );
return 0;
}
diff --git a/src/libs/gme/Gym_Emu.h b/src/libs/gme/Gym_Emu.h
index c9dcd160..290f57f5 100644
--- a/src/libs/gme/Gym_Emu.h
+++ b/src/libs/gme/Gym_Emu.h
@@ -1,82 +1,82 @@
// Sega Genesis/Mega Drive GYM music file emulator
// Includes with PCM timing recovery to improve sample quality.
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef GYM_EMU_H
#define GYM_EMU_H
#include "Dual_Resampler.h"
#include "Ym2612_Emu.h"
#include "Music_Emu.h"
#include "Sms_Apu.h"
class Gym_Emu : public Music_Emu, private Dual_Resampler {
public:
// GYM file header
enum { header_size = 428 };
struct header_t
{
char tag [4];
char song [32];
char game [32];
char copyright [32];
char emulator [32];
char dumper [32];
char comment [256];
byte loop_start [4]; // in 1/60 seconds, 0 if not looped
byte packed [4];
};
// Header for currently loaded file
header_t const& header() const { return header_; }
static gme_type_t static_type() { return gme_gym_type; }
public:
// deprecated
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
enum { gym_rate = 60 };
long track_length() const; // use track_info()
public:
Gym_Emu();
~Gym_Emu();
protected:
blargg_err_t load_mem_( byte const*, long );
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t set_sample_rate_( long sample_rate );
blargg_err_t start_track_( int );
blargg_err_t play_( long count, sample_t* );
void mute_voices_( int );
void set_tempo_( double );
int play_frame( blip_time_t blip_time, int sample_count, sample_t* buf );
private:
// sequence data begin, loop begin, current position, end
const byte* data;
const byte* loop_begin;
const byte* pos;
const byte* data_end;
blargg_long loop_remain; // frames remaining until loop beginning has been located
header_t header_;
double fm_sample_rate;
blargg_long clocks_per_frame;
void parse_frame();
// dac (pcm)
int dac_amp;
int prev_dac_count;
bool dac_enabled;
bool dac_muted;
void run_dac( int );
// sound
Blip_Buffer blip_buf;
Ym2612_Emu fm;
Blip_Synth<blip_med_quality,1> dac_synth;
Sms_Apu apu;
byte dac_buf [1024];
};
#endif
diff --git a/src/libs/gme/Hes_Apu.cpp b/src/libs/gme/Hes_Apu.cpp
index 63c2b707..1df81159 100644
--- a/src/libs/gme/Hes_Apu.cpp
+++ b/src/libs/gme/Hes_Apu.cpp
@@ -1,315 +1,315 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Hes_Apu.h"
#include <string.h>
/* Copyright (C) 2006 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"
bool const center_waves = true; // reduces asymmetry and clamping when starting notes
Hes_Apu::Hes_Apu()
{
Hes_Osc* osc = &oscs [osc_count];
do
{
osc--;
osc->outputs [0] = 0;
osc->outputs [1] = 0;
osc->chans [0] = 0;
osc->chans [1] = 0;
osc->chans [2] = 0;
}
while ( osc != oscs );
reset();
}
void Hes_Apu::reset()
{
latch = 0;
balance = 0xFF;
Hes_Osc* osc = &oscs [osc_count];
do
{
osc--;
memset( osc, 0, offsetof (Hes_Osc,outputs) );
osc->noise_lfsr = 1;
osc->control = 0x40;
osc->balance = 0xFF;
}
while ( osc != oscs );
}
void Hes_Apu::osc_output( int index, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
require( (unsigned) index < osc_count );
oscs [index].chans [0] = center;
oscs [index].chans [1] = left;
oscs [index].chans [2] = right;
Hes_Osc* osc = &oscs [osc_count];
do
{
osc--;
balance_changed( *osc );
}
while ( osc != oscs );
}
void Hes_Osc::run_until( synth_t& synth_, blip_time_t end_time )
{
Blip_Buffer* const osc_outputs_0 = outputs [0]; // cache often-used values
if ( osc_outputs_0 && control & 0x80 )
{
int dac = this->dac;
int const volume_0 = volume [0];
{
int delta = dac * volume_0 - last_amp [0];
if ( delta )
synth_.offset( last_time, delta, osc_outputs_0 );
osc_outputs_0->set_modified();
}
Blip_Buffer* const osc_outputs_1 = outputs [1];
int const volume_1 = volume [1];
if ( osc_outputs_1 )
{
int delta = dac * volume_1 - last_amp [1];
if ( delta )
synth_.offset( last_time, delta, osc_outputs_1 );
osc_outputs_1->set_modified();
}
blip_time_t time = last_time + delay;
if ( time < end_time )
{
if ( noise & 0x80 )
{
if ( volume_0 | volume_1 )
{
// noise
int const period = (32 - (noise & 0x1F)) * 64; // TODO: correct?
unsigned noise_lfsr = this->noise_lfsr;
do
{
int new_dac = 0x1F & -(noise_lfsr >> 1 & 1);
// Implemented using "Galios configuration"
// TODO: find correct LFSR algorithm
noise_lfsr = (noise_lfsr >> 1) ^ (0xE008 & -(noise_lfsr & 1));
//noise_lfsr = (noise_lfsr >> 1) ^ (0x6000 & -(noise_lfsr & 1));
int delta = new_dac - dac;
if ( delta )
{
dac = new_dac;
synth_.offset( time, delta * volume_0, osc_outputs_0 );
if ( osc_outputs_1 )
synth_.offset( time, delta * volume_1, osc_outputs_1 );
}
time += period;
}
while ( time < end_time );
this->noise_lfsr = noise_lfsr;
assert( noise_lfsr );
}
}
else if ( !(control & 0x40) )
{
// wave
int phase = (this->phase + 1) & 0x1F; // pre-advance for optimal inner loop
int period = this->period * 2;
if ( period >= 14 && (volume_0 | volume_1) )
{
do
{
int new_dac = wave [phase];
phase = (phase + 1) & 0x1F;
int delta = new_dac - dac;
if ( delta )
{
dac = new_dac;
synth_.offset( time, delta * volume_0, osc_outputs_0 );
if ( osc_outputs_1 )
synth_.offset( time, delta * volume_1, osc_outputs_1 );
}
time += period;
}
while ( time < end_time );
}
else
{
if ( !period )
{
// TODO: Gekisha Boy assumes that period = 0 silences wave
//period = 0x1000 * 2;
period = 1;
//if ( !(volume_0 | volume_1) )
// debug_printf( "Used period 0\n" );
}
// maintain phase when silent
blargg_long count = (end_time - time + period - 1) / period;
phase += count; // phase will be masked below
time += count * period;
}
this->phase = (phase - 1) & 0x1F; // undo pre-advance
}
}
time -= end_time;
if ( time < 0 )
time = 0;
delay = time;
this->dac = dac;
last_amp [0] = dac * volume_0;
last_amp [1] = dac * volume_1;
}
last_time = end_time;
}
void Hes_Apu::balance_changed( Hes_Osc& osc )
{
static short const log_table [32] = { // ~1.5 db per step
#define ENTRY( factor ) short (factor * Hes_Osc::amp_range / 31.0 + 0.5)
ENTRY( 0.000000 ),ENTRY( 0.005524 ),ENTRY( 0.006570 ),ENTRY( 0.007813 ),
ENTRY( 0.009291 ),ENTRY( 0.011049 ),ENTRY( 0.013139 ),ENTRY( 0.015625 ),
ENTRY( 0.018581 ),ENTRY( 0.022097 ),ENTRY( 0.026278 ),ENTRY( 0.031250 ),
ENTRY( 0.037163 ),ENTRY( 0.044194 ),ENTRY( 0.052556 ),ENTRY( 0.062500 ),
ENTRY( 0.074325 ),ENTRY( 0.088388 ),ENTRY( 0.105112 ),ENTRY( 0.125000 ),
ENTRY( 0.148651 ),ENTRY( 0.176777 ),ENTRY( 0.210224 ),ENTRY( 0.250000 ),
ENTRY( 0.297302 ),ENTRY( 0.353553 ),ENTRY( 0.420448 ),ENTRY( 0.500000 ),
ENTRY( 0.594604 ),ENTRY( 0.707107 ),ENTRY( 0.840896 ),ENTRY( 1.000000 ),
#undef ENTRY
};
int vol = (osc.control & 0x1F) - 0x1E * 2;
int left = vol + (osc.balance >> 3 & 0x1E) + (balance >> 3 & 0x1E);
if ( left < 0 ) left = 0;
int right = vol + (osc.balance << 1 & 0x1E) + (balance << 1 & 0x1E);
if ( right < 0 ) right = 0;
left = log_table [left ];
right = log_table [right];
// optimizing for the common case of being centered also allows easy
// panning using Effects_Buffer
osc.outputs [0] = osc.chans [0]; // center
osc.outputs [1] = 0;
if ( left != right )
{
osc.outputs [0] = osc.chans [1]; // left
osc.outputs [1] = osc.chans [2]; // right
}
if ( center_waves )
{
osc.last_amp [0] += (left - osc.volume [0]) * 16;
osc.last_amp [1] += (right - osc.volume [1]) * 16;
}
osc.volume [0] = left;
osc.volume [1] = right;
}
void Hes_Apu::write_data( blip_time_t time, int addr, int data )
{
if ( addr == 0x800 )
{
latch = data & 7;
}
else if ( addr == 0x801 )
{
if ( balance != data )
{
balance = data;
Hes_Osc* osc = &oscs [osc_count];
do
{
osc--;
osc->run_until( synth, time );
balance_changed( *oscs );
}
while ( osc != oscs );
}
}
else if ( latch < osc_count )
{
Hes_Osc& osc = oscs [latch];
osc.run_until( synth, time );
switch ( addr )
{
case 0x802:
osc.period = (osc.period & 0xF00) | data;
break;
case 0x803:
osc.period = (osc.period & 0x0FF) | ((data & 0x0F) << 8);
break;
case 0x804:
if ( osc.control & 0x40 & ~data )
osc.phase = 0;
osc.control = data;
balance_changed( osc );
break;
case 0x805:
osc.balance = data;
balance_changed( osc );
break;
case 0x806:
data &= 0x1F;
if ( !(osc.control & 0x40) )
{
osc.wave [osc.phase] = data;
osc.phase = (osc.phase + 1) & 0x1F;
}
else if ( osc.control & 0x80 )
{
osc.dac = data;
}
break;
case 0x807:
if ( &osc >= &oscs [4] )
osc.noise = data;
break;
case 0x809:
if ( !(data & 0x80) && (data & 0x03) != 0 )
debug_printf( "HES LFO not supported\n" );
}
}
}
void Hes_Apu::end_frame( blip_time_t end_time )
{
Hes_Osc* osc = &oscs [osc_count];
do
{
osc--;
if ( end_time > osc->last_time )
osc->run_until( synth, end_time );
assert( osc->last_time >= end_time );
osc->last_time -= end_time;
}
while ( osc != oscs );
}
diff --git a/src/libs/gme/Hes_Apu.h b/src/libs/gme/Hes_Apu.h
index 1e546053..1efc0a06 100644
--- a/src/libs/gme/Hes_Apu.h
+++ b/src/libs/gme/Hes_Apu.h
@@ -1,66 +1,66 @@
// Turbo Grafx 16 (PC Engine) PSG sound chip emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef HES_APU_H
#define HES_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
struct Hes_Osc
{
unsigned char wave [32];
short volume [2];
int last_amp [2];
int delay;
int period;
unsigned char noise;
unsigned char phase;
unsigned char balance;
unsigned char dac;
blip_time_t last_time;
Blip_Buffer* outputs [2];
Blip_Buffer* chans [3];
unsigned noise_lfsr;
unsigned char control;
enum { amp_range = 0x8000 };
typedef Blip_Synth<blip_med_quality,1> synth_t;
void run_until( synth_t& synth, blip_time_t );
};
class Hes_Apu {
public:
void treble_eq( blip_eq_t const& );
void volume( double );
enum { osc_count = 6 };
void osc_output( int index, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right );
void reset();
enum { start_addr = 0x0800 };
enum { end_addr = 0x0809 };
void write_data( blip_time_t, int addr, int data );
void end_frame( blip_time_t );
public:
Hes_Apu();
private:
Hes_Osc oscs [osc_count];
int latch;
int balance;
Hes_Osc::synth_t synth;
void balance_changed( Hes_Osc& );
void recalc_chans();
};
inline void Hes_Apu::volume( double v ) { synth.volume( 1.8 / osc_count / Hes_Osc::amp_range * v ); }
inline void Hes_Apu::treble_eq( blip_eq_t const& eq ) { synth.treble_eq( eq ); }
#endif
diff --git a/src/libs/gme/Hes_Cpu.cpp b/src/libs/gme/Hes_Cpu.cpp
index 8acdd94f..d1514596 100644
--- a/src/libs/gme/Hes_Cpu.cpp
+++ b/src/libs/gme/Hes_Cpu.cpp
@@ -1,1303 +1,1296 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Hes_Cpu.h"
#include "blargg_endian.h"
//#include "hes_cpu_log.h"
/* Copyright (C) 2003-2006 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 */
// TODO: support T flag, including clearing it at appropriate times?
// all zero-page should really use whatever is at page 1, but that would
// reduce efficiency quite a bit
int const ram_addr = 0x2000;
#define FLUSH_TIME() (void) (s.time = s_time)
#define CACHE_TIME() (void) (s_time = s.time)
#include "hes_cpu_io.h"
#include "blargg_source.h"
#if BLARGG_NONPORTABLE
#define PAGE_OFFSET( addr ) (addr)
#else
#define PAGE_OFFSET( addr ) ((addr) & (page_size - 1))
#endif
// status flags
int const st_n = 0x80;
int const st_v = 0x40;
int const st_t = 0x20;
int const st_b = 0x10;
int const st_d = 0x08;
int const st_i = 0x04;
int const st_z = 0x02;
int const st_c = 0x01;
void Hes_Cpu::reset()
{
check( state == &state_ );
state = &state_;
state_.time = 0;
state_.base = 0;
irq_time_ = future_hes_time;
end_time_ = future_hes_time;
r.status = st_i;
r.sp = 0;
r.pc = 0;
r.a = 0;
r.x = 0;
r.y = 0;
blargg_verify_byte_order();
}
void Hes_Cpu::set_mmr( int reg, int bank )
{
assert( (unsigned) reg <= page_count ); // allow page past end to be set
assert( (unsigned) bank < 0x100 );
mmr [reg] = bank;
uint8_t const* code = CPU_SET_MMR( this, reg, bank );
state->code_map [reg] = code - PAGE_OFFSET( reg << page_shift );
}
#define TIME (s_time + s.base)
#define READ( addr ) CPU_READ( this, (addr), TIME )
#define WRITE( addr, data ) {CPU_WRITE( this, (addr), (data), TIME );}
#define READ_LOW( addr ) (ram [int (addr)])
#define WRITE_LOW( addr, data ) (void) (READ_LOW( addr ) = (data))
#define READ_PROG( addr ) (s.code_map [(addr) >> page_shift] [PAGE_OFFSET( addr )])
#define SET_SP( v ) (sp = ((v) + 1) | 0x100)
#define GET_SP() ((sp - 1) & 0xFF)
#define PUSH( v ) ((sp = (sp - 1) | 0x100), WRITE_LOW( sp, v ))
-// even on x86, using short and unsigned char was slower
-typedef int fint16;
-typedef unsigned fuint16;
-typedef unsigned fuint8;
-typedef blargg_long fint32;
-
bool Hes_Cpu::run( hes_time_t end_time )
{
bool illegal_encountered = false;
set_end_time( end_time );
state_t s = this->state_;
this->state = &s;
// even on x86, using s.time in place of s_time was slower
- fint16 s_time = s.time;
+ int16_t s_time = s.time;
// registers
- fuint16 pc = r.pc;
- fuint8 a = r.a;
- fuint8 x = r.x;
- fuint8 y = r.y;
- fuint16 sp;
+ uint16_t pc = r.pc;
+ uint8_t a = r.a;
+ uint8_t x = r.x;
+ uint8_t y = r.y;
+ uint16_t sp;
SET_SP( r.sp );
#define IS_NEG (nz & 0x8080)
#define CALC_STATUS( out ) do {\
out = status & (st_v | st_d | st_i);\
out |= ((nz >> 8) | nz) & st_n;\
out |= c >> 8 & st_c;\
if ( !(nz & 0xFF) ) out |= st_z;\
} while ( 0 )
#define SET_STATUS( in ) do {\
status = in & (st_v | st_d | st_i);\
nz = in << 8;\
c = nz;\
nz |= ~in & st_z;\
} while ( 0 )
- fuint8 status;
- fuint16 c; // carry set if (c & 0x100) != 0
- fuint16 nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
+ uint8_t status;
+ uint16_t c; // carry set if (c & 0x100) != 0
+ uint16_t nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
{
- fuint8 temp = r.status;
+ uint8_t temp = r.status;
SET_STATUS( temp );
}
goto loop;
branch_not_taken:
s_time -= 2;
loop:
#ifndef NDEBUG
{
hes_time_t correct = end_time_;
if ( !(status & st_i) && correct > irq_time_ )
correct = irq_time_;
check( s.base == correct );
/*
static long count;
if ( count == 1844 ) Debugger();
if ( s.base != correct ) debug_printf( "%ld\n", count );
count++;
*/
}
#endif
check( (unsigned) GET_SP() < 0x100 );
check( (unsigned) a < 0x100 );
check( (unsigned) x < 0x100 );
uint8_t const* instr = s.code_map [pc >> page_shift];
- fuint8 opcode;
+ uint8_t opcode;
// TODO: eliminate this special case
#if BLARGG_NONPORTABLE
opcode = instr [pc];
pc++;
instr += pc;
#else
instr += PAGE_OFFSET( pc );
opcode = *instr++;
pc++;
#endif
// TODO: each reference lists slightly different timing values, ugh
static uint8_t const clock_table [256] =
{// 0 1 2 3 4 5 6 7 8 9 A B C D E F
1,7,3, 4,6,4,6,7,3,2,2,2,7,5,7,6,// 0
4,7,7, 4,6,4,6,7,2,5,2,2,7,5,7,6,// 1
7,7,3, 4,4,4,6,7,4,2,2,2,5,5,7,6,// 2
4,7,7, 2,4,4,6,7,2,5,2,2,5,5,7,6,// 3
7,7,3, 4,8,4,6,7,3,2,2,2,4,5,7,6,// 4
4,7,7, 5,2,4,6,7,2,5,3,2,2,5,7,6,// 5
7,7,2, 2,4,4,6,7,4,2,2,2,7,5,7,6,// 6
4,7,7,17,4,4,6,7,2,5,4,2,7,5,7,6,// 7
4,7,2, 7,4,4,4,7,2,2,2,2,5,5,5,6,// 8
4,7,7, 8,4,4,4,7,2,5,2,2,5,5,5,6,// 9
2,7,2, 7,4,4,4,7,2,2,2,2,5,5,5,6,// A
4,7,7, 8,4,4,4,7,2,5,2,2,5,5,5,6,// B
2,7,2,17,4,4,6,7,2,2,2,2,5,5,7,6,// C
4,7,7,17,2,4,6,7,2,5,3,2,2,5,7,6,// D
2,7,2,17,4,4,6,7,2,2,2,2,5,5,7,6,// E
4,7,7,17,2,4,6,7,2,5,4,2,2,5,7,6 // F
}; // 0x00 was 8
- fuint16 data;
+ uint16_t data;
data = clock_table [opcode];
if ( (s_time += data) >= 0 )
goto possibly_out_of_time;
almost_out_of_time:
data = *instr;
#ifdef HES_CPU_LOG_H
log_cpu( "new", pc - 1, opcode, instr [0], instr [1], instr [2],
instr [3], instr [4], instr [5] );
//log_opcode( opcode );
#endif
switch ( opcode )
{
possibly_out_of_time:
if ( s_time < (int) data )
goto almost_out_of_time;
s_time -= data;
goto out_of_time;
// Macros
#define GET_MSB() (instr [1])
#define ADD_PAGE( out ) (pc++, out = data + 0x100 * GET_MSB());
#define GET_ADDR() GET_LE16( instr )
// TODO: is the penalty really always added? the original 6502 was much better
//#define PAGE_CROSS_PENALTY( lsb ) (void) (s_time += (lsb) >> 8)
#define PAGE_CROSS_PENALTY( lsb )
// Branch
// TODO: more efficient way to handle negative branch that wraps PC around
#define BRANCH( cond )\
{\
- fint16 offset = (BOOST::int8_t) data;\
+ int16_t offset = (int8_t) data;\
pc++;\
if ( !(cond) ) goto branch_not_taken;\
- pc = BOOST::uint16_t (pc + offset);\
+ pc = uint16_t (pc + offset);\
goto loop;\
}
case 0xF0: // BEQ
BRANCH( !((uint8_t) nz) );
case 0xD0: // BNE
BRANCH( (uint8_t) nz );
case 0x10: // BPL
BRANCH( !IS_NEG );
case 0x90: // BCC
BRANCH( !(c & 0x100) )
case 0x30: // BMI
BRANCH( IS_NEG )
case 0x50: // BVC
BRANCH( !(status & st_v) )
case 0x70: // BVS
BRANCH( status & st_v )
case 0xB0: // BCS
BRANCH( c & 0x100 )
case 0x80: // BRA
branch_taken:
BRANCH( true );
case 0xFF:
if ( pc == idle_addr + 1 )
goto idle_done;
case 0x0F: // BBRn
case 0x1F:
case 0x2F:
case 0x3F:
case 0x4F:
case 0x5F:
case 0x6F:
case 0x7F:
case 0x8F: // BBSn
case 0x9F:
case 0xAF:
case 0xBF:
case 0xCF:
case 0xDF:
case 0xEF: {
- fuint16 t = 0x101 * READ_LOW( data );
+ uint16_t t = 0x101 * READ_LOW( data );
t ^= 0xFF;
pc++;
data = GET_MSB();
BRANCH( t & (1 << (opcode >> 4)) )
}
case 0x4C: // JMP abs
pc = GET_ADDR();
goto loop;
case 0x7C: // JMP (ind+X)
data += x;
case 0x6C:{// JMP (ind)
data += 0x100 * GET_MSB();
pc = GET_LE16( &READ_PROG( data ) );
goto loop;
}
// Subroutine
case 0x44: // BSR
WRITE_LOW( 0x100 | (sp - 1), pc >> 8 );
sp = (sp - 2) | 0x100;
WRITE_LOW( sp, pc );
goto branch_taken;
case 0x20: { // JSR
- fuint16 temp = pc + 1;
+ uint16_t temp = pc + 1;
pc = GET_ADDR();
WRITE_LOW( 0x100 | (sp - 1), temp >> 8 );
sp = (sp - 2) | 0x100;
WRITE_LOW( sp, temp );
goto loop;
}
case 0x60: // RTS
pc = 0x100 * READ_LOW( 0x100 | (sp - 0xFF) );
pc += 1 + READ_LOW( sp );
sp = (sp - 0xFE) | 0x100;
goto loop;
case 0x00: // BRK
goto handle_brk;
// Common
case 0xBD:{// LDA abs,X
PAGE_CROSS_PENALTY( data + x );
- fuint16 addr = GET_ADDR() + x;
+ uint16_t addr = GET_ADDR() + x;
pc += 2;
CPU_READ_FAST( this, addr, TIME, nz );
a = nz;
goto loop;
}
case 0x9D:{// STA abs,X
- fuint16 addr = GET_ADDR() + x;
+ uint16_t addr = GET_ADDR() + x;
pc += 2;
CPU_WRITE_FAST( this, addr, a, TIME );
goto loop;
}
case 0x95: // STA zp,x
data = uint8_t (data + x);
case 0x85: // STA zp
pc++;
WRITE_LOW( data, a );
goto loop;
case 0xAE:{// LDX abs
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
CPU_READ_FAST( this, addr, TIME, nz );
x = nz;
goto loop;
}
case 0xA5: // LDA zp
a = nz = READ_LOW( data );
pc++;
goto loop;
// Load/store
{
- fuint16 addr;
+ uint16_t addr;
case 0x91: // STA (ind),Y
addr = 0x100 * READ_LOW( uint8_t (data + 1) );
addr += READ_LOW( data ) + y;
pc++;
goto sta_ptr;
case 0x81: // STA (ind,X)
data = uint8_t (data + x);
case 0x92: // STA (ind)
addr = 0x100 * READ_LOW( uint8_t (data + 1) );
addr += READ_LOW( data );
pc++;
goto sta_ptr;
case 0x99: // STA abs,Y
data += y;
case 0x8D: // STA abs
addr = data + 0x100 * GET_MSB();
pc += 2;
sta_ptr:
CPU_WRITE_FAST( this, addr, a, TIME );
goto loop;
}
{
- fuint16 addr;
+ uint16_t addr;
case 0xA1: // LDA (ind,X)
data = uint8_t (data + x);
case 0xB2: // LDA (ind)
addr = 0x100 * READ_LOW( uint8_t (data + 1) );
addr += READ_LOW( data );
pc++;
goto a_nz_read_addr;
case 0xB1:// LDA (ind),Y
addr = READ_LOW( data ) + y;
PAGE_CROSS_PENALTY( addr );
addr += 0x100 * READ_LOW( (uint8_t) (data + 1) );
pc++;
goto a_nz_read_addr;
case 0xB9: // LDA abs,Y
data += y;
PAGE_CROSS_PENALTY( data );
case 0xAD: // LDA abs
addr = data + 0x100 * GET_MSB();
pc += 2;
a_nz_read_addr:
CPU_READ_FAST( this, addr, TIME, nz );
a = nz;
goto loop;
}
case 0xBE:{// LDX abs,y
PAGE_CROSS_PENALTY( data + y );
- fuint16 addr = GET_ADDR() + y;
+ uint16_t addr = GET_ADDR() + y;
pc += 2;
FLUSH_TIME();
x = nz = READ( addr );
CACHE_TIME();
goto loop;
}
case 0xB5: // LDA zp,x
a = nz = READ_LOW( uint8_t (data + x) );
pc++;
goto loop;
case 0xA9: // LDA #imm
pc++;
a = data;
nz = data;
goto loop;
// Bit operations
case 0x3C: // BIT abs,x
data += x;
case 0x2C:{// BIT abs
- fuint16 addr;
+ uint16_t addr;
ADD_PAGE( addr );
FLUSH_TIME();
nz = READ( addr );
CACHE_TIME();
goto bit_common;
}
case 0x34: // BIT zp,x
data = uint8_t (data + x);
case 0x24: // BIT zp
data = READ_LOW( data );
case 0x89: // BIT imm
nz = data;
bit_common:
pc++;
status &= ~st_v;
status |= nz & st_v;
if ( nz & a )
goto loop; // Z should be clear, and nz must be non-zero if nz & a is
nz <<= 8; // set Z flag without affecting N flag
goto loop;
{
- fuint16 addr;
+ uint16_t addr;
case 0xB3: // TST abs,x
addr = GET_MSB() + x;
goto tst_abs;
case 0x93: // TST abs
addr = GET_MSB();
tst_abs:
addr += 0x100 * instr [2];
pc++;
FLUSH_TIME();
nz = READ( addr );
CACHE_TIME();
goto tst_common;
}
case 0xA3: // TST zp,x
nz = READ_LOW( uint8_t (GET_MSB() + x) );
goto tst_common;
case 0x83: // TST zp
nz = READ_LOW( GET_MSB() );
tst_common:
pc += 2;
status &= ~st_v;
status |= nz & st_v;
if ( nz & data )
goto loop; // Z should be clear, and nz must be non-zero if nz & data is
nz <<= 8; // set Z flag without affecting N flag
goto loop;
{
- fuint16 addr;
+ uint16_t addr;
case 0x0C: // TSB abs
case 0x1C: // TRB abs
addr = GET_ADDR();
pc++;
goto txb_addr;
// TODO: everyone lists different behaviors for the status flags, ugh
case 0x04: // TSB zp
case 0x14: // TRB zp
addr = data + ram_addr;
txb_addr:
FLUSH_TIME();
nz = a | READ( addr );
if ( opcode & 0x10 )
nz ^= a; // bits from a will already be set, so this clears them
status &= ~st_v;
status |= nz & st_v;
pc++;
WRITE( addr, nz );
CACHE_TIME();
goto loop;
}
case 0x07: // RMBn
case 0x17:
case 0x27:
case 0x37:
case 0x47:
case 0x57:
case 0x67:
case 0x77:
pc++;
READ_LOW( data ) &= ~(1 << (opcode >> 4));
goto loop;
case 0x87: // SMBn
case 0x97:
case 0xA7:
case 0xB7:
case 0xC7:
case 0xD7:
case 0xE7:
case 0xF7:
pc++;
READ_LOW( data ) |= 1 << ((opcode >> 4) - 8);
goto loop;
// Load/store
case 0x9E: // STZ abs,x
data += x;
case 0x9C: // STZ abs
ADD_PAGE( data );
pc++;
FLUSH_TIME();
WRITE( data, 0 );
CACHE_TIME();
goto loop;
case 0x74: // STZ zp,x
data = uint8_t (data + x);
case 0x64: // STZ zp
pc++;
WRITE_LOW( data, 0 );
goto loop;
case 0x94: // STY zp,x
data = uint8_t (data + x);
case 0x84: // STY zp
pc++;
WRITE_LOW( data, y );
goto loop;
case 0x96: // STX zp,y
data = uint8_t (data + y);
case 0x86: // STX zp
pc++;
WRITE_LOW( data, x );
goto loop;
case 0xB6: // LDX zp,y
data = uint8_t (data + y);
case 0xA6: // LDX zp
data = READ_LOW( data );
case 0xA2: // LDX #imm
pc++;
x = data;
nz = data;
goto loop;
case 0xB4: // LDY zp,x
data = uint8_t (data + x);
case 0xA4: // LDY zp
data = READ_LOW( data );
case 0xA0: // LDY #imm
pc++;
y = data;
nz = data;
goto loop;
case 0xBC: // LDY abs,X
data += x;
PAGE_CROSS_PENALTY( data );
case 0xAC:{// LDY abs
- fuint16 addr = data + 0x100 * GET_MSB();
+ uint16_t addr = data + 0x100 * GET_MSB();
pc += 2;
FLUSH_TIME();
y = nz = READ( addr );
CACHE_TIME();
goto loop;
}
{
- fuint8 temp;
+ uint8_t temp;
case 0x8C: // STY abs
temp = y;
goto store_abs;
case 0x8E: // STX abs
temp = x;
store_abs:
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
FLUSH_TIME();
WRITE( addr, temp );
CACHE_TIME();
goto loop;
}
// Compare
case 0xEC:{// CPX abs
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpx_data;
}
case 0xE4: // CPX zp
data = READ_LOW( data );
case 0xE0: // CPX #imm
cpx_data:
nz = x - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
case 0xCC:{// CPY abs
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpy_data;
}
case 0xC4: // CPY zp
data = READ_LOW( data );
case 0xC0: // CPY #imm
cpy_data:
nz = y - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
// Logical
#define ARITH_ADDR_MODES( op )\
case op - 0x04: /* (ind,x) */\
data = uint8_t (data + x);\
case op + 0x0D: /* (ind) */\
data = 0x100 * READ_LOW( uint8_t (data + 1) ) + READ_LOW( data );\
goto ptr##op;\
case op + 0x0C:{/* (ind),y */\
- fuint16 temp = READ_LOW( data ) + y;\
+ uint16_t temp = READ_LOW( data ) + y;\
PAGE_CROSS_PENALTY( temp );\
data = temp + 0x100 * READ_LOW( uint8_t (data + 1) );\
goto ptr##op;\
}\
case op + 0x10: /* zp,X */\
data = uint8_t (data + x);\
case op + 0x00: /* zp */\
data = READ_LOW( data );\
goto imm##op;\
case op + 0x14: /* abs,Y */\
data += y;\
goto ind##op;\
case op + 0x18: /* abs,X */\
data += x;\
ind##op:\
PAGE_CROSS_PENALTY( data );\
case op + 0x08: /* abs */\
ADD_PAGE( data );\
ptr##op:\
FLUSH_TIME();\
data = READ( data );\
CACHE_TIME();\
case op + 0x04: /* imm */\
imm##op:
ARITH_ADDR_MODES( 0xC5 ) // CMP
nz = a - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
ARITH_ADDR_MODES( 0x25 ) // AND
nz = (a &= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x45 ) // EOR
nz = (a ^= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x05 ) // ORA
nz = (a |= data);
pc++;
goto loop;
// Add/subtract
ARITH_ADDR_MODES( 0xE5 ) // SBC
data ^= 0xFF;
goto adc_imm;
ARITH_ADDR_MODES( 0x65 ) // ADC
adc_imm: {
if ( status & st_d )
debug_printf( "Decimal mode not supported\n" );
- fint16 carry = c >> 8 & 1;
- fint16 ov = (a ^ 0x80) + carry + (BOOST::int8_t) data; // sign-extend
+ int16_t carry = c >> 8 & 1;
+ int16_t ov = (a ^ 0x80) + carry + (int8_t) data; // sign-extend
status &= ~st_v;
status |= ov >> 2 & 0x40;
c = nz = a + data + carry;
pc++;
a = (uint8_t) nz;
goto loop;
}
// Shift/rotate
case 0x4A: // LSR A
c = 0;
case 0x6A: // ROR A
nz = c >> 1 & 0x80;
c = a << 8;
nz |= a >> 1;
a = nz;
goto loop;
case 0x0A: // ASL A
nz = a << 1;
c = nz;
a = (uint8_t) nz;
goto loop;
case 0x2A: { // ROL A
nz = a << 1;
- fint16 temp = c >> 8 & 1;
+ int16_t temp = c >> 8 & 1;
c = nz;
nz |= temp;
a = (uint8_t) nz;
goto loop;
}
case 0x5E: // LSR abs,X
data += x;
case 0x4E: // LSR abs
c = 0;
case 0x6E: // ROR abs
ror_abs: {
ADD_PAGE( data );
FLUSH_TIME();
int temp = READ( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto rotate_common;
}
case 0x3E: // ROL abs,X
data += x;
goto rol_abs;
case 0x1E: // ASL abs,X
data += x;
case 0x0E: // ASL abs
c = 0;
case 0x2E: // ROL abs
rol_abs:
ADD_PAGE( data );
nz = c >> 8 & 1;
FLUSH_TIME();
nz |= (c = READ( data ) << 1);
rotate_common:
pc++;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
case 0x7E: // ROR abs,X
data += x;
goto ror_abs;
case 0x76: // ROR zp,x
data = uint8_t (data + x);
goto ror_zp;
case 0x56: // LSR zp,x
data = uint8_t (data + x);
case 0x46: // LSR zp
c = 0;
case 0x66: // ROR zp
ror_zp: {
int temp = READ_LOW( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto write_nz_zp;
}
case 0x36: // ROL zp,x
data = uint8_t (data + x);
goto rol_zp;
case 0x16: // ASL zp,x
data = uint8_t (data + x);
case 0x06: // ASL zp
c = 0;
case 0x26: // ROL zp
rol_zp:
nz = c >> 8 & 1;
nz |= (c = READ_LOW( data ) << 1);
goto write_nz_zp;
// Increment/decrement
#define INC_DEC_AXY( reg, n ) reg = uint8_t (nz = reg + n); goto loop;
case 0x1A: // INA
INC_DEC_AXY( a, +1 )
case 0xE8: // INX
INC_DEC_AXY( x, +1 )
case 0xC8: // INY
INC_DEC_AXY( y, +1 )
case 0x3A: // DEA
INC_DEC_AXY( a, -1 )
case 0xCA: // DEX
INC_DEC_AXY( x, -1 )
case 0x88: // DEY
INC_DEC_AXY( y, -1 )
case 0xF6: // INC zp,x
data = uint8_t (data + x);
case 0xE6: // INC zp
nz = 1;
goto add_nz_zp;
case 0xD6: // DEC zp,x
data = uint8_t (data + x);
case 0xC6: // DEC zp
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
add_nz_zp:
nz += READ_LOW( data );
write_nz_zp:
pc++;
WRITE_LOW( data, nz );
goto loop;
case 0xFE: // INC abs,x
data = x + GET_ADDR();
goto inc_ptr;
case 0xEE: // INC abs
data = GET_ADDR();
inc_ptr:
nz = 1;
goto inc_common;
case 0xDE: // DEC abs,x
data = x + GET_ADDR();
goto dec_ptr;
case 0xCE: // DEC abs
data = GET_ADDR();
dec_ptr:
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
inc_common:
FLUSH_TIME();
nz += READ( data );
pc += 2;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
// Transfer
case 0xA8: // TAY
y = a;
nz = a;
goto loop;
case 0x98: // TYA
a = y;
nz = y;
goto loop;
case 0xAA: // TAX
x = a;
nz = a;
goto loop;
case 0x8A: // TXA
a = x;
nz = x;
goto loop;
case 0x9A: // TXS
SET_SP( x ); // verified (no flag change)
goto loop;
case 0xBA: // TSX
x = nz = GET_SP();
goto loop;
#define SWAP_REGS( r1, r2 ) {\
- fuint8 t = r1;\
+ uint8_t t = r1;\
r1 = r2;\
r2 = t;\
goto loop;\
}
case 0x02: // SXY
SWAP_REGS( x, y );
case 0x22: // SAX
SWAP_REGS( a, x );
case 0x42: // SAY
SWAP_REGS( a, y );
case 0x62: // CLA
a = 0;
goto loop;
case 0x82: // CLX
x = 0;
goto loop;
case 0xC2: // CLY
y = 0;
goto loop;
// Stack
case 0x48: // PHA
PUSH( a );
goto loop;
case 0xDA: // PHX
PUSH( x );
goto loop;
case 0x5A: // PHY
PUSH( y );
goto loop;
case 0x40:{// RTI
- fuint8 temp = READ_LOW( sp );
+ uint8_t temp = READ_LOW( sp );
pc = READ_LOW( 0x100 | (sp - 0xFF) );
pc |= READ_LOW( 0x100 | (sp - 0xFE) ) * 0x100;
sp = (sp - 0xFD) | 0x100;
data = status;
SET_STATUS( temp );
this->r.status = status; // update externally-visible I flag
if ( (data ^ status) & st_i )
{
hes_time_t new_time = end_time_;
if ( !(status & st_i) && new_time > irq_time_ )
new_time = irq_time_;
blargg_long delta = s.base - new_time;
s.base = new_time;
s_time += delta;
}
goto loop;
}
#define POP() READ_LOW( sp ); sp = (sp - 0xFF) | 0x100
case 0x68: // PLA
a = nz = POP();
goto loop;
case 0xFA: // PLX
x = nz = POP();
goto loop;
case 0x7A: // PLY
y = nz = POP();
goto loop;
case 0x28:{// PLP
- fuint8 temp = POP();
- fuint8 changed = status ^ temp;
+ uint8_t temp = POP();
+ uint8_t changed = status ^ temp;
SET_STATUS( temp );
if ( !(changed & st_i) )
goto loop; // I flag didn't change
if ( status & st_i )
goto handle_sei;
goto handle_cli;
}
#undef POP
case 0x08: { // PHP
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
PUSH( temp | st_b );
goto loop;
}
// Flags
case 0x38: // SEC
- c = (unsigned) ~0;
+ c = (uint16_t) ~0;
goto loop;
case 0x18: // CLC
c = 0;
goto loop;
case 0xB8: // CLV
status &= ~st_v;
goto loop;
case 0xD8: // CLD
status &= ~st_d;
goto loop;
case 0xF8: // SED
status |= st_d;
goto loop;
case 0x58: // CLI
if ( !(status & st_i) )
goto loop;
status &= ~st_i;
handle_cli: {
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - irq_time_;
if ( delta <= 0 )
{
if ( TIME < irq_time_ )
goto loop;
goto delayed_cli;
}
s.base = irq_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
if ( delta >= s_time + 1 )
{
// delayed irq until after next instruction
s.base += s_time + 1;
s_time = -1;
irq_time_ = s.base; // TODO: remove, as only to satisfy debug check in loop
goto loop;
}
delayed_cli:
debug_printf( "Delayed CLI not supported\n" ); // TODO: implement
goto loop;
}
case 0x78: // SEI
if ( status & st_i )
goto loop;
status |= st_i;
handle_sei: {
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - end_time_;
s.base = end_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
debug_printf( "Delayed SEI not supported\n" ); // TODO: implement
goto loop;
}
// Special
case 0x53:{// TAM
- fuint8 const bits = data; // avoid using data across function call
+ uint8_t const bits = data; // avoid using data across function call
pc++;
for ( int i = 0; i < 8; i++ )
if ( bits & (1 << i) )
set_mmr( i, a );
goto loop;
}
case 0x43:{// TMA
pc++;
byte const* in = mmr;
do
{
if ( data & 1 )
a = *in;
in++;
}
while ( (data >>= 1) != 0 );
goto loop;
}
case 0x03: // ST0
case 0x13: // ST1
case 0x23:{// ST2
- fuint16 addr = opcode >> 4;
+ uint16_t addr = opcode >> 4;
if ( addr )
addr++;
pc++;
FLUSH_TIME();
CPU_WRITE_VDP( this, addr, data, TIME );
CACHE_TIME();
goto loop;
}
case 0xEA: // NOP
goto loop;
case 0x54: // CSL
debug_printf( "CSL not supported\n" );
illegal_encountered = true;
goto loop;
case 0xD4: // CSH
goto loop;
case 0xF4: { // SET
- //fuint16 operand = GET_MSB();
+ //uint16_t operand = GET_MSB();
debug_printf( "SET not handled\n" );
//switch ( data )
//{
//}
illegal_encountered = true;
goto loop;
}
// Block transfer
{
- fuint16 in_alt;
- fint16 in_inc;
- fuint16 out_alt;
- fint16 out_inc;
+ uint16_t in_alt;
+ int16_t in_inc;
+ uint16_t out_alt;
+ int16_t out_inc;
case 0xE3: // TIA
in_alt = 0;
goto bxfer_alt;
case 0xF3: // TAI
in_alt = 1;
bxfer_alt:
in_inc = in_alt ^ 1;
out_alt = in_inc;
out_inc = in_alt;
goto bxfer;
case 0xD3: // TIN
in_inc = 1;
out_inc = 0;
goto bxfer_no_alt;
case 0xC3: // TDD
in_inc = -1;
out_inc = -1;
goto bxfer_no_alt;
case 0x73: // TII
in_inc = 1;
out_inc = 1;
bxfer_no_alt:
in_alt = 0;
out_alt = 0;
bxfer:
- fuint16 in = GET_LE16( instr + 0 );
- fuint16 out = GET_LE16( instr + 2 );
+ uint16_t in = GET_LE16( instr + 0 );
+ uint16_t out = GET_LE16( instr + 2 );
int count = GET_LE16( instr + 4 );
if ( !count )
count = 0x10000;
pc += 6;
WRITE_LOW( 0x100 | (sp - 1), y );
WRITE_LOW( 0x100 | (sp - 2), a );
WRITE_LOW( 0x100 | (sp - 3), x );
FLUSH_TIME();
do
{
// TODO: reads from $0800-$1400 in I/O page return 0 and don't access I/O
- fuint8 t = READ( in );
+ uint8_t t = READ( in );
in += in_inc;
in &= 0xFFFF;
s.time += 6;
if ( in_alt )
in_inc = -in_inc;
WRITE( out, t );
out += out_inc;
out &= 0xFFFF;
if ( out_alt )
out_inc = -out_inc;
}
while ( --count );
CACHE_TIME();
goto loop;
}
// Illegal
default:
- assert( (unsigned) opcode <= 0xFF );
debug_printf( "Illegal opcode $%02X at $%04X\n", (int) opcode, (int) pc - 1 );
illegal_encountered = true;
goto loop;
}
assert( false );
int result_;
handle_brk:
pc++;
result_ = 6;
interrupt:
{
s_time += 7;
WRITE_LOW( 0x100 | (sp - 1), pc >> 8 );
WRITE_LOW( 0x100 | (sp - 2), pc );
pc = GET_LE16( &READ_PROG( 0xFFF0 ) + result_ );
sp = (sp - 3) | 0x100;
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
if ( result_ == 6 )
temp |= st_b;
WRITE_LOW( sp, temp );
status &= ~st_d;
status |= st_i;
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - end_time_;
s.base = end_time_;
s_time += delta;
goto loop;
}
idle_done:
s_time = 0;
out_of_time:
pc--;
FLUSH_TIME();
CPU_DONE( this, TIME, result_ );
CACHE_TIME();
if ( result_ > 0 )
goto interrupt;
if ( s_time < 0 )
goto loop;
s.time = s_time;
r.pc = pc;
r.sp = GET_SP();
r.a = a;
r.x = x;
r.y = y;
{
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
r.status = temp;
}
this->state_ = s;
this->state = &this->state_;
return illegal_encountered;
}
diff --git a/src/libs/gme/Hes_Cpu.h b/src/libs/gme/Hes_Cpu.h
index cf3af87d..cec46fa9 100644
--- a/src/libs/gme/Hes_Cpu.h
+++ b/src/libs/gme/Hes_Cpu.h
@@ -1,124 +1,122 @@
// PC Engine CPU emulator for use with HES music files
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef HES_CPU_H
#define HES_CPU_H
#include "blargg_common.h"
typedef blargg_long hes_time_t; // clock cycle count
typedef unsigned hes_addr_t; // 16-bit address
enum { future_hes_time = INT_MAX / 2 + 1 };
class Hes_Cpu {
public:
- typedef BOOST::uint8_t uint8_t;
-
void reset();
enum { page_size = 0x2000 };
enum { page_shift = 13 };
enum { page_count = 8 };
void set_mmr( int reg, int bank );
uint8_t const* get_code( hes_addr_t );
uint8_t ram [page_size];
// not kept updated during a call to run()
struct registers_t {
- BOOST::uint16_t pc;
+ uint16_t pc;
uint8_t a;
uint8_t x;
uint8_t y;
uint8_t status;
uint8_t sp;
};
registers_t r;
// page mapping registers
uint8_t mmr [page_count + 1];
// Set end_time and run CPU from current time. Returns true if any illegal
// instructions were encountered.
bool run( hes_time_t end_time );
// Time of beginning of next instruction to be executed
hes_time_t time() const { return state->time + state->base; }
void set_time( hes_time_t t ) { state->time = t - state->base; }
void adjust_time( int delta ) { state->time += delta; }
hes_time_t irq_time() const { return irq_time_; }
void set_irq_time( hes_time_t );
hes_time_t end_time() const { return end_time_; }
void set_end_time( hes_time_t );
void end_frame( hes_time_t );
// Attempt to execute instruction here results in CPU advancing time to
// lesser of irq_time() and end_time() (or end_time() if IRQs are
// disabled)
enum { idle_addr = 0x1FFF };
// Can read this many bytes past end of a page
enum { cpu_padding = 8 };
public:
Hes_Cpu() { state = &state_; }
enum { irq_inhibit = 0x04 };
private:
// noncopyable
Hes_Cpu( const Hes_Cpu& );
Hes_Cpu& operator = ( const Hes_Cpu& );
struct state_t {
uint8_t const* code_map [page_count + 1];
hes_time_t base;
blargg_long time;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
hes_time_t irq_time_;
hes_time_t end_time_;
void set_code_page( int, void const* );
inline int update_end_time( hes_time_t end, hes_time_t irq );
};
-inline BOOST::uint8_t const* Hes_Cpu::get_code( hes_addr_t addr )
+inline uint8_t const* Hes_Cpu::get_code( hes_addr_t addr )
{
return state->code_map [addr >> page_shift] + addr
#if !BLARGG_NONPORTABLE
% (unsigned) page_size
#endif
;
}
inline int Hes_Cpu::update_end_time( hes_time_t t, hes_time_t irq )
{
if ( irq < t && !(r.status & irq_inhibit) ) t = irq;
int delta = state->base - t;
state->base = t;
return delta;
}
inline void Hes_Cpu::set_irq_time( hes_time_t t )
{
state->time += update_end_time( end_time_, (irq_time_ = t) );
}
inline void Hes_Cpu::set_end_time( hes_time_t t )
{
state->time += update_end_time( (end_time_ = t), irq_time_ );
}
inline void Hes_Cpu::end_frame( hes_time_t t )
{
assert( state == &state_ );
state_.base -= t;
if ( irq_time_ < future_hes_time ) irq_time_ -= t;
if ( end_time_ < future_hes_time ) end_time_ -= t;
}
#endif
diff --git a/src/libs/gme/Hes_Emu.cpp b/src/libs/gme/Hes_Emu.cpp
index 9a32b688..818691fd 100644
--- a/src/libs/gme/Hes_Emu.cpp
+++ b/src/libs/gme/Hes_Emu.cpp
@@ -1,531 +1,531 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Hes_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2006 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 timer_mask = 0x04;
int const vdp_mask = 0x02;
int const i_flag_mask = 0x04;
int const unmapped = 0xFF;
long const period_60hz = 262 * 455L; // scanlines * clocks per scanline
Hes_Emu::Hes_Emu()
{
timer.raw_load = 0;
set_type( gme_hes_type );
static const char* const names [Hes_Apu::osc_count] = {
"Wave 1", "Wave 2", "Wave 3", "Wave 4", "Multi 1", "Multi 2"
};
set_voice_names( names );
static int const types [Hes_Apu::osc_count] = {
wave_type | 0, wave_type | 1, wave_type | 2, wave_type | 3,
mixed_type | 0, mixed_type | 1
};
set_voice_types( types );
set_silence_lookahead( 6 );
set_gain( 1.11 );
}
Hes_Emu::~Hes_Emu() { }
void Hes_Emu::unload()
{
rom.clear();
Music_Emu::unload();
}
// Track info
static byte const* copy_field( byte const* in, char* out )
{
if ( in )
{
int len = 0x20;
if ( in [0x1F] && !in [0x2F] )
len = 0x30; // fields are sometimes 16 bytes longer (ugh)
// since text fields are where any data could be, detect non-text
// and fields with data after zero byte terminator
int i = 0;
for ( i = 0; i < len && in [i]; i++ )
if ( ((in [i] + 1) & 0xFF) < ' ' + 1 ) // also treat 0xFF as non-text
return 0; // non-ASCII found
for ( ; i < len; i++ )
if ( in [i] )
return 0; // data after terminator
Gme_File::copy_field_( out, (char const*) in, len );
in += len;
}
return in;
}
static void copy_hes_fields( byte const* in, track_info_t* out )
{
if ( *in >= ' ' )
{
in = copy_field( in, out->game );
in = copy_field( in, out->author );
in = copy_field( in, out->copyright );
}
}
blargg_err_t Hes_Emu::track_info_( track_info_t* out, int ) const
{
copy_hes_fields( rom.begin() + 0x20, out );
return 0;
}
static blargg_err_t check_hes_header( void const* header )
{
if ( memcmp( header, "HESM", 4 ) )
return gme_wrong_file_type;
return 0;
}
struct Hes_File : Gme_Info_
{
struct header_t {
char header [Hes_Emu::header_size];
char unused [0x20];
byte fields [0x30 * 3];
} h;
Hes_File() { set_type( gme_hes_type ); }
blargg_err_t load_( Data_Reader& in )
{
assert( offsetof (header_t,fields) == Hes_Emu::header_size + 0x20 );
blargg_err_t err = in.read( &h, sizeof h );
if ( err )
return (err == in.eof_error ? gme_wrong_file_type : err);
return check_hes_header( &h );
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
copy_hes_fields( h.fields, out );
return 0;
}
};
static Music_Emu* new_hes_emu () { return BLARGG_NEW Hes_Emu ; }
static Music_Emu* new_hes_file() { return BLARGG_NEW Hes_File; }
static gme_type_t_ const gme_hes_type_ = { "PC Engine", 256, &new_hes_emu, &new_hes_file, "HES", 1 };
-gme_type_t const gme_hes_type = &gme_hes_type_;
+BLARGG_EXPORT extern gme_type_t const gme_hes_type = &gme_hes_type_;
// Setup
blargg_err_t Hes_Emu::load_( Data_Reader& in )
{
assert( offsetof (header_t,unused [4]) == header_size );
RETURN_ERR( rom.load( in, header_size, &header_, unmapped ) );
RETURN_ERR( check_hes_header( header_.tag ) );
if ( header_.vers != 0 )
set_warning( "Unknown file version" );
if ( memcmp( header_.data_tag, "DATA", 4 ) )
set_warning( "Data header missing" );
if ( memcmp( header_.unused, "\0\0\0\0", 4 ) )
set_warning( "Unknown header data" );
// File spec supports multiple blocks, but I haven't found any, and
// many files have bad sizes in the only block, so it's simpler to
// just try to load the damn data as best as possible.
long addr = get_le32( header_.addr );
long size = get_le32( header_.size );
long const rom_max = 0x100000;
if ( addr & ~(rom_max - 1) )
{
set_warning( "Invalid address" );
addr &= rom_max - 1;
}
if ( (unsigned long) (addr + size) > (unsigned long) rom_max )
set_warning( "Invalid size" );
if ( size != rom.file_size() )
{
if ( size <= rom.file_size() - 4 && !memcmp( rom.begin() + size, "DATA", 4 ) )
set_warning( "Multiple DATA not supported" );
else if ( size < rom.file_size() )
set_warning( "Extra file data" );
else
set_warning( "Missing file data" );
}
rom.set_addr( addr );
set_voice_count( apu.osc_count );
apu.volume( gain() );
return setup_buffer( 7159091 );
}
void Hes_Emu::update_eq( blip_eq_t const& eq )
{
apu.treble_eq( eq );
}
void Hes_Emu::set_voice( int i, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
apu.osc_output( i, center, left, right );
}
// Emulation
void Hes_Emu::recalc_timer_load()
{
timer.load = timer.raw_load * timer_base + 1;
}
void Hes_Emu::set_tempo_( double t )
{
play_period = hes_time_t (period_60hz / t);
timer_base = int (1024 / t);
recalc_timer_load();
}
blargg_err_t Hes_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( ram, 0, sizeof ram ); // some HES music relies on zero fill
memset( sgx, 0, sizeof sgx );
apu.reset();
cpu::reset();
for ( unsigned i = 0; i < sizeof header_.banks; i++ )
set_mmr( i, header_.banks [i] );
set_mmr( page_count, 0xFF ); // unmapped beyond end of address space
irq.disables = timer_mask | vdp_mask;
irq.timer = future_hes_time;
irq.vdp = future_hes_time;
timer.enabled = false;
timer.raw_load= 0x80;
timer.count = timer.load;
timer.fired = false;
timer.last_time = 0;
vdp.latch = 0;
vdp.control = 0;
vdp.next_vbl = 0;
ram [0x1FF] = (idle_addr - 1) >> 8;
ram [0x1FE] = (idle_addr - 1) & 0xFF;
r.sp = 0xFD;
r.pc = get_le16( header_.init_addr );
r.a = track;
recalc_timer_load();
last_frame_hook = 0;
return 0;
}
// Hardware
void Hes_Emu::cpu_write_vdp( int addr, int data )
{
switch ( addr )
{
case 0:
vdp.latch = data & 0x1F;
break;
case 2:
if ( vdp.latch == 5 )
{
if ( data & 0x04 )
set_warning( "Scanline interrupt unsupported" );
run_until( time() );
vdp.control = data;
irq_changed();
}
else
{
debug_printf( "VDP not supported: $%02X <- $%02X\n", vdp.latch, data );
}
break;
case 3:
debug_printf( "VDP MSB not supported: $%02X <- $%02X\n", vdp.latch, data );
break;
}
}
void Hes_Emu::cpu_write_( hes_addr_t addr, int data )
{
if ( unsigned (addr - apu.start_addr) <= apu.end_addr - apu.start_addr )
{
GME_APU_HOOK( this, addr - apu.start_addr, data );
// avoid going way past end when a long block xfer is writing to I/O space
hes_time_t t = min( time(), end_time() + 8 );
apu.write_data( t, addr, data );
return;
}
hes_time_t time = this->time();
switch ( addr )
{
case 0x0000:
case 0x0002:
case 0x0003:
cpu_write_vdp( addr, data );
return;
case 0x0C00: {
run_until( time );
timer.raw_load = (data & 0x7F) + 1;
recalc_timer_load();
timer.count = timer.load;
break;
}
case 0x0C01:
data &= 1;
if ( timer.enabled == data )
return;
run_until( time );
timer.enabled = data;
if ( data )
timer.count = timer.load;
break;
case 0x1402:
run_until( time );
irq.disables = data;
if ( (data & 0xF8) && (data & 0xF8) != 0xF8 ) // flag questionable values
debug_printf( "Int mask: $%02X\n", data );
break;
case 0x1403:
run_until( time );
if ( timer.enabled )
timer.count = timer.load;
timer.fired = false;
break;
#ifndef NDEBUG
case 0x1000: // I/O port
case 0x0402: // palette
case 0x0403:
case 0x0404:
case 0x0405:
return;
default:
debug_printf( "unmapped write $%04X <- $%02X\n", addr, data );
return;
#endif
}
irq_changed();
}
int Hes_Emu::cpu_read_( hes_addr_t addr )
{
hes_time_t time = this->time();
addr &= page_size - 1;
switch ( addr )
{
case 0x0000:
if ( irq.vdp > time )
return 0;
irq.vdp = future_hes_time;
run_until( time );
irq_changed();
return 0x20;
case 0x0002:
case 0x0003:
debug_printf( "VDP read not supported: %d\n", addr );
return 0;
case 0x0C01:
//return timer.enabled; // TODO: remove?
case 0x0C00:
run_until( time );
debug_printf( "Timer count read\n" );
return (unsigned) (timer.count - 1) / timer_base;
case 0x1402:
return irq.disables;
case 0x1403:
{
int status = 0;
if ( irq.timer <= time ) status |= timer_mask;
if ( irq.vdp <= time ) status |= vdp_mask;
return status;
}
#ifndef NDEBUG
case 0x1000: // I/O port
case 0x180C: // CD-ROM
case 0x180D:
break;
default:
debug_printf( "unmapped read $%04X\n", addr );
#endif
}
return unmapped;
}
// see hes_cpu_io.h for core read/write functions
// Emulation
void Hes_Emu::run_until( hes_time_t present )
{
while ( vdp.next_vbl < present )
vdp.next_vbl += play_period;
hes_time_t elapsed = present - timer.last_time;
if ( elapsed > 0 )
{
if ( timer.enabled )
{
timer.count -= elapsed;
if ( timer.count <= 0 )
timer.count += timer.load;
}
timer.last_time = present;
}
}
void Hes_Emu::irq_changed()
{
hes_time_t present = time();
if ( irq.timer > present )
{
irq.timer = future_hes_time;
if ( timer.enabled && !timer.fired )
irq.timer = present + timer.count;
}
if ( irq.vdp > present )
{
irq.vdp = future_hes_time;
if ( vdp.control & 0x08 )
irq.vdp = vdp.next_vbl;
}
hes_time_t time = future_hes_time;
if ( !(irq.disables & timer_mask) ) time = irq.timer;
if ( !(irq.disables & vdp_mask) ) time = min( time, irq.vdp );
set_irq_time( time );
}
int Hes_Emu::cpu_done()
{
check( time() >= end_time() ||
(!(r.status & i_flag_mask) && time() >= irq_time()) );
if ( !(r.status & i_flag_mask) )
{
hes_time_t present = time();
if ( irq.timer <= present && !(irq.disables & timer_mask) )
{
timer.fired = true;
irq.timer = future_hes_time;
irq_changed(); // overkill, but not worth writing custom code
#if GME_FRAME_HOOK_DEFINED
{
unsigned const threshold = period_60hz / 30;
unsigned long elapsed = present - last_frame_hook;
if ( elapsed - period_60hz + threshold / 2 < threshold )
{
last_frame_hook = present;
GME_FRAME_HOOK( this );
}
}
#endif
return 0x0A;
}
if ( irq.vdp <= present && !(irq.disables & vdp_mask) )
{
// work around for bugs with music not acknowledging VDP
//run_until( present );
//irq.vdp = future_hes_time;
//irq_changed();
#if GME_FRAME_HOOK_DEFINED
last_frame_hook = present;
GME_FRAME_HOOK( this );
#endif
return 0x08;
}
}
return 0;
}
static void adjust_time( blargg_long& time, hes_time_t delta )
{
if ( time < future_hes_time )
{
time -= delta;
if ( time < 0 )
time = 0;
}
}
blargg_err_t Hes_Emu::run_clocks( blip_time_t& duration_, int )
{
blip_time_t const duration = duration_; // cache
if ( cpu::run( duration ) )
set_warning( "Emulation error (illegal instruction)" );
check( time() >= duration );
//check( time() - duration < 20 ); // Txx instruction could cause going way over
run_until( duration );
// end time frame
timer.last_time -= duration;
vdp.next_vbl -= duration;
#if GME_FRAME_HOOK_DEFINED
last_frame_hook -= duration;
#endif
cpu::end_frame( duration );
::adjust_time( irq.timer, duration );
::adjust_time( irq.vdp, duration );
apu.end_frame( duration );
return 0;
}
diff --git a/src/libs/gme/Hes_Emu.h b/src/libs/gme/Hes_Emu.h
index d17983c5..08c1370d 100644
--- a/src/libs/gme/Hes_Emu.h
+++ b/src/libs/gme/Hes_Emu.h
@@ -1,94 +1,94 @@
// TurboGrafx-16/PC Engine HES music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef HES_EMU_H
#define HES_EMU_H
#include "Classic_Emu.h"
#include "Hes_Apu.h"
#include "Hes_Cpu.h"
class Hes_Emu : private Hes_Cpu, public Classic_Emu {
typedef Hes_Cpu cpu;
public:
// HES file header
enum { header_size = 0x20 };
struct header_t
{
byte tag [4];
byte vers;
byte first_track;
byte init_addr [2];
byte banks [8];
byte data_tag [4];
byte size [4];
byte addr [4];
byte unused [4];
};
// Header for currently loaded file
header_t const& header() const { return header_; }
static gme_type_t static_type() { return gme_hes_type; }
public:
Hes_Emu();
~Hes_Emu();
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_( Data_Reader& );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
void unload();
public: private: friend class Hes_Cpu;
byte* write_pages [page_count + 1]; // 0 if unmapped or I/O space
int cpu_read_( hes_addr_t );
int cpu_read( hes_addr_t );
void cpu_write_( hes_addr_t, int data );
void cpu_write( hes_addr_t, int );
void cpu_write_vdp( int addr, int data );
byte const* cpu_set_mmr( int page, int bank );
int cpu_done();
private:
Rom_Data<page_size> rom;
header_t header_;
hes_time_t play_period;
hes_time_t last_frame_hook;
int timer_base;
struct {
hes_time_t last_time;
blargg_long count;
blargg_long load;
int raw_load;
byte enabled;
byte fired;
} timer;
struct {
hes_time_t next_vbl;
byte latch;
byte control;
} vdp;
struct {
hes_time_t timer;
hes_time_t vdp;
byte disables;
} irq;
void recalc_timer_load();
// large items
Hes_Apu apu;
byte sgx [3 * page_size + cpu_padding];
void irq_changed();
void run_until( hes_time_t );
};
#endif
diff --git a/src/libs/gme/Kss_Cpu.cpp b/src/libs/gme/Kss_Cpu.cpp
index 3654da2f..10eec4fc 100644
--- a/src/libs/gme/Kss_Cpu.cpp
+++ b/src/libs/gme/Kss_Cpu.cpp
@@ -1,1707 +1,1700 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
/*
Last validated with zexall 2006.11.14 2:19 PM
* Doesn't implement the R register or immediate interrupt after EI.
* Address wrap-around isn't completely correct, but is prevented from crashing emulator.
*/
#include "Kss_Cpu.h"
#include "blargg_endian.h"
#include <string.h>
//#include "z80_cpu_log.h"
/* Copyright (C) 2006 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 */
#define SYNC_TIME() (void) (s.time = s_time)
#define RELOAD_TIME() (void) (s_time = s.time)
// Callbacks to emulator
#define CPU_OUT( cpu, addr, data, time )\
kss_cpu_out( this, time, addr, data )
#define CPU_IN( cpu, addr, time )\
kss_cpu_in( this, time, addr )
#define CPU_WRITE( cpu, addr, data, time )\
(SYNC_TIME(), kss_cpu_write( this, addr, data ))
#include "blargg_source.h"
// flags, named with hex value for clarity
int const S80 = 0x80;
int const Z40 = 0x40;
int const F20 = 0x20;
int const H10 = 0x10;
int const F08 = 0x08;
int const V04 = 0x04;
int const P04 = 0x04;
int const N02 = 0x02;
int const C01 = 0x01;
#define SZ28P( n ) szpc [n]
#define SZ28PC( n ) szpc [n]
#define SZ28C( n ) (szpc [n] & ~P04)
#define SZ28( n ) SZ28C( n )
#define SET_R( n ) (void) (r.r = n)
#define GET_R() (r.r)
Kss_Cpu::Kss_Cpu()
{
state = &state_;
for ( int i = 0x100; --i >= 0; )
{
int even = 1;
for ( int p = i; p; p >>= 1 )
even ^= p;
int n = (i & (S80 | F20 | F08)) | ((even & 1) * P04);
szpc [i] = n;
szpc [i + 0x100] = n | C01;
}
szpc [0x000] |= Z40;
szpc [0x100] |= Z40;
}
inline void Kss_Cpu::set_page( int i, void* write, void const* read )
{
blargg_long offset = KSS_CPU_PAGE_OFFSET( i * (blargg_long) page_size );
state->write [i] = (byte *) write - offset;
state->read [i] = (byte const*) read - offset;
}
void Kss_Cpu::reset( void* unmapped_write, void const* unmapped_read )
{
check( state == &state_ );
state = &state_;
state_.time = 0;
state_.base = 0;
end_time_ = 0;
for ( int i = 0; i < page_count + 1; i++ )
set_page( i, unmapped_write, unmapped_read );
memset( &r, 0, sizeof r );
}
void Kss_Cpu::map_mem( unsigned addr, blargg_ulong size, void* write, void const* read )
{
// address range must begin and end on page boundaries
require( addr % page_size == 0 );
require( size % page_size == 0 );
unsigned first_page = addr / page_size;
for ( unsigned i = size / page_size; i--; )
{
blargg_long offset = i * (blargg_long) page_size;
set_page( first_page + i, (byte*) write + offset, (byte const*) read + offset );
}
}
#define TIME (s_time + s.base)
#define RW_MEM( addr, rw ) (s.rw [(addr) >> page_shift] [KSS_CPU_PAGE_OFFSET( addr )])
#define READ_PROG( addr ) RW_MEM( addr, read )
#define READ( addr ) READ_PROG( addr )
//#define WRITE( addr, data ) (void) (RW_MEM( addr, write ) = data)
#define WRITE( addr, data ) CPU_WRITE( this, addr, data, TIME )
#define READ_WORD( addr ) GET_LE16( &READ( addr ) )
#define WRITE_WORD( addr, data ) SET_LE16( &RW_MEM( addr, write ), data )
#define IN( addr ) CPU_IN( this, addr, TIME )
#define OUT( addr, data ) CPU_OUT( this, addr, data, TIME )
#if BLARGG_BIG_ENDIAN
#define R8( n, offset ) ((r8_ - offset) [n])
#elif BLARGG_LITTLE_ENDIAN
#define R8( n, offset ) ((r8_ - offset) [(n) ^ 1])
#else
#error "Byte order of CPU must be known"
#endif
//#define R16( n, shift, offset ) (r16_ [((n) >> shift) - (offset >> shift)])
// help compiler see that it can just adjust stack offset, saving an extra instruction
#define R16( n, shift, offset )\
(*(uint16_t*) ((char*) r16_ - (offset >> (shift - 1)) + ((n) >> (shift - 1))))
#define CASE5( a, b, c, d, e ) case 0x##a:case 0x##b:case 0x##c:case 0x##d:case 0x##e
#define CASE6( a, b, c, d, e, f ) CASE5( a, b, c, d, e ): case 0x##f
#define CASE7( a, b, c, d, e, f, g ) CASE6( a, b, c, d, e, f ): case 0x##g
#define CASE8( a, b, c, d, e, f, g, h ) CASE7( a, b, c, d, e, f, g ): case 0x##h
// high four bits are $ED time - 8, low four bits are $DD/$FD time - 8
static byte const ed_dd_timing [0x100] = {
//0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x06,0x0C,0x02,0x00,0x00,0x03,0x00,0x00,0x07,0x0C,0x02,0x00,0x00,0x03,0x00,
0x00,0x00,0x00,0x00,0x0F,0x0F,0x0B,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x10,
0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0xA0,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0xA0,
0x4B,0x4B,0x7B,0xCB,0x0B,0x6B,0x00,0x0B,0x40,0x40,0x70,0xC0,0x00,0x60,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,
0x80,0x80,0x80,0x80,0x00,0x00,0x0B,0x00,0x80,0x80,0x80,0x80,0x00,0x00,0x0B,0x00,
0xD0,0xD0,0xD0,0xD0,0x00,0x00,0x0B,0x00,0xD0,0xD0,0xD0,0xD0,0x00,0x00,0x0B,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x06,0x00,0x0F,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,
};
-// even on x86, using short and unsigned char was slower
-typedef int fint16;
-typedef unsigned fuint16;
-typedef unsigned fuint8;
-
bool Kss_Cpu::run( cpu_time_t end_time )
{
set_end_time( end_time );
state_t s = this->state_;
this->state = &s;
bool warning = false;
- typedef BOOST::int8_t int8_t;
-
union {
regs_t rg;
pairs_t rp;
uint8_t r8_ [8]; // indexed
uint16_t r16_ [4];
};
rg = this->r.b;
cpu_time_t s_time = s.time;
- fuint16 pc = r.pc;
- fuint16 sp = r.sp;
- fuint16 ix = r.ix; // TODO: keep in memory for direct access?
- fuint16 iy = r.iy;
+ uint16_t pc = r.pc;
+ uint16_t sp = r.sp;
+ uint16_t ix = r.ix; // TODO: keep in memory for direct access?
+ uint16_t iy = r.iy;
int flags = r.b.flags;
goto loop;
jr_not_taken:
s_time -= 5;
goto loop;
call_not_taken:
s_time -= 7;
jp_not_taken:
pc += 2;
loop:
check( (unsigned long) pc < 0x10000 );
check( (unsigned long) sp < 0x10000 );
check( (unsigned) flags < 0x100 );
check( (unsigned) ix < 0x10000 );
check( (unsigned) iy < 0x10000 );
uint8_t const* instr = s.read [pc >> page_shift];
#define GET_ADDR() GET_LE16( instr )
- fuint8 opcode;
+ uint8_t opcode;
// TODO: eliminate this special case
#if BLARGG_NONPORTABLE
opcode = instr [pc];
pc++;
instr += pc;
#else
instr += KSS_CPU_PAGE_OFFSET( pc );
opcode = *instr++;
pc++;
#endif
static byte const base_timing [0x100] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
4,10, 7, 6, 4, 4, 7, 4, 4,11, 7, 6, 4, 4, 7, 4, // 0
13,10, 7, 6, 4, 4, 7, 4,12,11, 7, 6, 4, 4, 7, 4, // 1
12,10,16, 6, 4, 4, 7, 4,12,11,16, 6, 4, 4, 7, 4, // 2
12,10,13, 6,11,11,10, 4,12,11,13, 6, 4, 4, 7, 4, // 3
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 4
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 5
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 6
7, 7, 7, 7, 7, 7, 4, 7, 4, 4, 4, 4, 4, 4, 7, 4, // 7
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 8
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // 9
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // A
4, 4, 4, 4, 4, 4, 7, 4, 4, 4, 4, 4, 4, 4, 7, 4, // B
11,10,10,10,17,11, 7,11,11,10,10, 8,17,17, 7,11, // C
11,10,10,11,17,11, 7,11,11, 4,10,11,17, 8, 7,11, // D
11,10,10,19,17,11, 7,11,11, 4,10, 4,17, 8, 7,11, // E
11,10,10, 4,17,11, 7,11,11, 6,10, 4,17, 8, 7,11, // F
};
- fuint16 data;
+ uint16_t data;
data = base_timing [opcode];
if ( (s_time += data) >= 0 )
goto possibly_out_of_time;
almost_out_of_time:
data = READ_PROG( pc );
#ifdef Z80_CPU_LOG_H
//log_opcode( opcode, READ_PROG( pc ) );
z80_log_regs( rg.a, rp.bc, rp.de, rp.hl, sp, ix, iy );
z80_cpu_log( "new", pc - 1, opcode, READ_PROG( pc ),
READ_PROG( pc + 1 ), READ_PROG( pc + 2 ) );
#endif
switch ( opcode )
{
possibly_out_of_time:
if ( s_time < (int) data )
goto almost_out_of_time;
s_time -= data;
goto out_of_time;
// Common
case 0x00: // NOP
CASE7( 40, 49, 52, 5B, 64, 6D, 7F ): // LD B,B etc.
goto loop;
case 0x08:{// EX AF,AF'
int temp = r.alt.b.a;
r.alt.b.a = rg.a;
rg.a = temp;
temp = r.alt.b.flags;
r.alt.b.flags = flags;
flags = temp;
goto loop;
}
case 0xD3: // OUT (imm),A
pc++;
OUT( data + rg.a * 0x100, rg.a );
goto loop;
case 0x2E: // LD L,imm
pc++;
rg.l = data;
goto loop;
case 0x3E: // LD A,imm
pc++;
rg.a = data;
goto loop;
case 0x3A:{// LD A,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
rg.a = READ( addr );
goto loop;
}
// Conditional
#define ZERO (flags & Z40)
#define CARRY (flags & C01)
#define EVEN (flags & P04)
#define MINUS (flags & S80)
// JR
// TODO: more efficient way to handle negative branch that wraps PC around
#define JR( cond ) {\
- int offset = (BOOST::int8_t) data;\
+ int offset = (int8_t) data;\
pc++;\
if ( !(cond) )\
goto jr_not_taken;\
pc = uint16_t (pc + offset);\
goto loop;\
}
case 0x20: JR( !ZERO ) // JR NZ,disp
case 0x28: JR( ZERO ) // JR Z,disp
case 0x30: JR( !CARRY ) // JR NC,disp
case 0x38: JR( CARRY ) // JR C,disp
case 0x18: JR( true ) // JR disp
case 0x10:{// DJNZ disp
int temp = rg.b - 1;
rg.b = temp;
JR( temp )
}
// JP
#define JP( cond ) if ( !(cond) ) goto jp_not_taken; pc = GET_ADDR(); goto loop;
case 0xC2: JP( !ZERO ) // JP NZ,addr
case 0xCA: JP( ZERO ) // JP Z,addr
case 0xD2: JP( !CARRY ) // JP NC,addr
case 0xDA: JP( CARRY ) // JP C,addr
case 0xE2: JP( !EVEN ) // JP PO,addr
case 0xEA: JP( EVEN ) // JP PE,addr
case 0xF2: JP( !MINUS ) // JP P,addr
case 0xFA: JP( MINUS ) // JP M,addr
case 0xC3: // JP addr
pc = GET_ADDR();
goto loop;
case 0xE9: // JP HL
pc = rp.hl;
goto loop;
// RET
#define RET( cond ) if ( cond ) goto ret_taken; s_time -= 6; goto loop;
case 0xC0: RET( !ZERO ) // RET NZ
case 0xC8: RET( ZERO ) // RET Z
case 0xD0: RET( !CARRY ) // RET NC
case 0xD8: RET( CARRY ) // RET C
case 0xE0: RET( !EVEN ) // RET PO
case 0xE8: RET( EVEN ) // RET PE
case 0xF0: RET( !MINUS ) // RET P
case 0xF8: RET( MINUS ) // RET M
case 0xC9: // RET
ret_taken:
pc = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto loop;
// CALL
#define CALL( cond ) if ( cond ) goto call_taken; goto call_not_taken;
case 0xC4: CALL( !ZERO ) // CALL NZ,addr
case 0xCC: CALL( ZERO ) // CALL Z,addr
case 0xD4: CALL( !CARRY ) // CALL NC,addr
case 0xDC: CALL( CARRY ) // CALL C,addr
case 0xE4: CALL( !EVEN ) // CALL PO,addr
case 0xEC: CALL( EVEN ) // CALL PE,addr
case 0xF4: CALL( !MINUS ) // CALL P,addr
case 0xFC: CALL( MINUS ) // CALL M,addr
case 0xCD:{// CALL addr
call_taken:
- fuint16 addr = pc + 2;
+ uint16_t addr = pc + 2;
pc = GET_ADDR();
sp = uint16_t (sp - 2);
WRITE_WORD( sp, addr );
goto loop;
}
case 0xFF: // RST
- if ( pc > idle_addr )
+ if ( pc >= idle_addr )
goto hit_idle_addr;
CASE7( C7, CF, D7, DF, E7, EF, F7 ):
data = pc;
pc = opcode & 0x38;
goto push_data;
// PUSH/POP
case 0xF5: // PUSH AF
data = rg.a * 0x100u + flags;
goto push_data;
case 0xC5: // PUSH BC
case 0xD5: // PUSH DE
case 0xE5: // PUSH HL
data = R16( opcode, 4, 0xC5 );
push_data:
sp = uint16_t (sp - 2);
WRITE_WORD( sp, data );
goto loop;
case 0xF1: // POP AF
flags = READ( sp );
rg.a = READ( sp + 1 );
sp = uint16_t (sp + 2);
goto loop;
case 0xC1: // POP BC
case 0xD1: // POP DE
case 0xE1: // POP HL
R16( opcode, 4, 0xC1 ) = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto loop;
// ADC/ADD/SBC/SUB
case 0x96: // SUB (HL)
case 0x86: // ADD (HL)
flags &= ~C01;
case 0x9E: // SBC (HL)
case 0x8E: // ADC (HL)
data = READ( rp.hl );
goto adc_data;
case 0xD6: // SUB A,imm
case 0xC6: // ADD imm
flags &= ~C01;
case 0xDE: // SBC A,imm
case 0xCE: // ADC imm
pc++;
goto adc_data;
CASE7( 90, 91, 92, 93, 94, 95, 97 ): // SUB r
CASE7( 80, 81, 82, 83, 84, 85, 87 ): // ADD r
flags &= ~C01;
CASE7( 98, 99, 9A, 9B, 9C, 9D, 9F ): // SBC r
CASE7( 88, 89, 8A, 8B, 8C, 8D, 8F ): // ADC r
data = R8( opcode & 7, 0 );
adc_data: {
int result = data + (flags & C01);
data ^= rg.a;
flags = opcode >> 3 & N02; // bit 4 is set in subtract opcodes
if ( flags )
result = -result;
result += rg.a;
data ^= result;
flags |=(data & H10) |
((data - -0x80) >> 6 & V04) |
SZ28C( result & 0x1FF );
rg.a = result;
goto loop;
}
// CP
case 0xBE: // CP (HL)
data = READ( rp.hl );
goto cp_data;
case 0xFE: // CP imm
pc++;
goto cp_data;
CASE7( B8, B9, BA, BB, BC, BD, BF ): // CP r
data = R8( opcode, 0xB8 );
cp_data: {
int result = rg.a - data;
flags = N02 | (data & (F20 | F08)) | (result >> 8 & C01);
data ^= rg.a;
flags |=(((result ^ rg.a) & data) >> 5 & V04) |
(((data & H10) ^ result) & (S80 | H10));
if ( (uint8_t) result )
goto loop;
flags |= Z40;
goto loop;
}
// ADD HL,rp
case 0x39: // ADD HL,SP
data = sp;
goto add_hl_data;
case 0x09: // ADD HL,BC
case 0x19: // ADD HL,DE
case 0x29: // ADD HL,HL
data = R16( opcode, 4, 0x09 );
add_hl_data: {
blargg_ulong sum = rp.hl + data;
data ^= rp.hl;
rp.hl = sum;
flags = (flags & (S80 | Z40 | V04)) |
(sum >> 16) |
(sum >> 8 & (F20 | F08)) |
((data ^ sum) >> 8 & H10);
goto loop;
}
case 0x27:{// DAA
int a = rg.a;
if ( a > 0x99 )
flags |= C01;
int adjust = 0x60 & -(flags & C01);
if ( flags & H10 || (a & 0x0F) > 9 )
adjust |= 0x06;
if ( flags & N02 )
adjust = -adjust;
a += adjust;
flags = (flags & (C01 | N02)) |
((rg.a ^ a) & H10) |
SZ28P( (uint8_t) a );
rg.a = a;
goto loop;
}
/*
case 0x27:{// DAA
// more optimized, but probably not worth the obscurity
int f = (rg.a + (0xFF - 0x99)) >> 8 | flags; // (a > 0x99 ? C01 : 0) | flags
int adjust = 0x60 & -(f & C01); // f & C01 ? 0x60 : 0
if ( (((rg.a + (0x0F - 9)) ^ rg.a) | f) & H10 ) // flags & H10 || (rg.a & 0x0F) > 9
adjust |= 0x06;
if ( f & N02 )
adjust = -adjust;
int a = rg.a + adjust;
flags = (f & (N02 | C01)) | ((rg.a ^ a) & H10) | SZ28P( (uint8_t) a );
rg.a = a;
goto loop;
}
*/
// INC/DEC
case 0x34: // INC (HL)
data = READ( rp.hl ) + 1;
WRITE( rp.hl, data );
goto inc_set_flags;
CASE7( 04, 0C, 14, 1C, 24, 2C, 3C ): // INC r
data = ++R8( opcode >> 3, 0 );
inc_set_flags:
flags = (flags & C01) |
(((data & 0x0F) - 1) & H10) |
SZ28( (uint8_t) data );
if ( data != 0x80 )
goto loop;
flags |= V04;
goto loop;
case 0x35: // DEC (HL)
data = READ( rp.hl ) - 1;
WRITE( rp.hl, data );
goto dec_set_flags;
CASE7( 05, 0D, 15, 1D, 25, 2D, 3D ): // DEC r
data = --R8( opcode >> 3, 0 );
dec_set_flags:
flags = (flags & C01) | N02 |
(((data & 0x0F) + 1) & H10) |
SZ28( (uint8_t) data );
if ( data != 0x7F )
goto loop;
flags |= V04;
goto loop;
case 0x03: // INC BC
case 0x13: // INC DE
case 0x23: // INC HL
R16( opcode, 4, 0x03 )++;
goto loop;
case 0x33: // INC SP
sp = uint16_t (sp + 1);
goto loop;
case 0x0B: // DEC BC
case 0x1B: // DEC DE
case 0x2B: // DEC HL
R16( opcode, 4, 0x0B )--;
goto loop;
case 0x3B: // DEC SP
sp = uint16_t (sp - 1);
goto loop;
// AND
case 0xA6: // AND (HL)
data = READ( rp.hl );
goto and_data;
case 0xE6: // AND imm
pc++;
goto and_data;
CASE7( A0, A1, A2, A3, A4, A5, A7 ): // AND r
data = R8( opcode, 0xA0 );
and_data:
rg.a &= data;
flags = SZ28P( rg.a ) | H10;
goto loop;
// OR
case 0xB6: // OR (HL)
data = READ( rp.hl );
goto or_data;
case 0xF6: // OR imm
pc++;
goto or_data;
CASE7( B0, B1, B2, B3, B4, B5, B7 ): // OR r
data = R8( opcode, 0xB0 );
or_data:
rg.a |= data;
flags = SZ28P( rg.a );
goto loop;
// XOR
case 0xAE: // XOR (HL)
data = READ( rp.hl );
goto xor_data;
case 0xEE: // XOR imm
pc++;
goto xor_data;
CASE7( A8, A9, AA, AB, AC, AD, AF ): // XOR r
data = R8( opcode, 0xA8 );
xor_data:
rg.a ^= data;
flags = SZ28P( rg.a );
goto loop;
// LD
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // LD (HL),r
WRITE( rp.hl, R8( opcode, 0x70 ) );
goto loop;
CASE6( 41, 42, 43, 44, 45, 47 ): // LD B,r
CASE6( 48, 4A, 4B, 4C, 4D, 4F ): // LD C,r
CASE6( 50, 51, 53, 54, 55, 57 ): // LD D,r
CASE6( 58, 59, 5A, 5C, 5D, 5F ): // LD E,r
CASE6( 60, 61, 62, 63, 65, 67 ): // LD H,r
CASE6( 68, 69, 6A, 6B, 6C, 6F ): // LD L,r
CASE6( 78, 79, 7A, 7B, 7C, 7D ): // LD A,r
R8( opcode >> 3 & 7, 0 ) = R8( opcode & 7, 0 );
goto loop;
CASE5( 06, 0E, 16, 1E, 26 ): // LD r,imm
R8( opcode >> 3, 0 ) = data;
pc++;
goto loop;
case 0x36: // LD (HL),imm
pc++;
WRITE( rp.hl, data );
goto loop;
CASE7( 46, 4E, 56, 5E, 66, 6E, 7E ): // LD r,(HL)
R8( opcode >> 3, 8 ) = READ( rp.hl );
goto loop;
case 0x01: // LD rp,imm
case 0x11:
case 0x21:
R16( opcode, 4, 0x01 ) = GET_ADDR();
pc += 2;
goto loop;
case 0x31: // LD sp,imm
sp = GET_ADDR();
pc += 2;
goto loop;
case 0x2A:{// LD HL,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
rp.hl = READ_WORD( addr );
goto loop;
}
case 0x32:{// LD (addr),A
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE( addr, rg.a );
goto loop;
}
case 0x22:{// LD (addr),HL
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, rp.hl );
goto loop;
}
case 0x02: // LD (BC),A
case 0x12: // LD (DE),A
WRITE( R16( opcode, 4, 0x02 ), rg.a );
goto loop;
case 0x0A: // LD A,(BC)
case 0x1A: // LD A,(DE)
rg.a = READ( R16( opcode, 4, 0x0A ) );
goto loop;
case 0xF9: // LD SP,HL
sp = rp.hl;
goto loop;
// Rotate
case 0x07:{// RLCA
- fuint16 temp = rg.a;
+ uint16_t temp = rg.a;
temp = (temp << 1) | (temp >> 7);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08 | C01));
rg.a = temp;
goto loop;
}
case 0x0F:{// RRCA
- fuint16 temp = rg.a;
+ uint16_t temp = rg.a;
flags = (flags & (S80 | Z40 | P04)) |
(temp & C01);
temp = (temp << 7) | (temp >> 1);
flags |= temp & (F20 | F08);
rg.a = temp;
goto loop;
}
case 0x17:{// RLA
blargg_ulong temp = (rg.a << 1) | (flags & C01);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08)) |
(temp >> 8);
rg.a = temp;
goto loop;
}
case 0x1F:{// RRA
- fuint16 temp = (flags << 7) | (rg.a >> 1);
+ uint16_t temp = (flags << 7) | (rg.a >> 1);
flags = (flags & (S80 | Z40 | P04)) |
(temp & (F20 | F08)) |
(rg.a & C01);
rg.a = temp;
goto loop;
}
// Misc
case 0x2F:{// CPL
- fuint16 temp = ~rg.a;
+ uint16_t temp = ~rg.a;
flags = (flags & (S80 | Z40 | P04 | C01)) |
(temp & (F20 | F08)) |
(H10 | N02);
rg.a = temp;
goto loop;
}
case 0x3F:{// CCF
flags = ((flags & (S80 | Z40 | P04 | C01)) ^ C01) |
(flags << 4 & H10) |
(rg.a & (F20 | F08));
goto loop;
}
case 0x37: // SCF
flags = (flags & (S80 | Z40 | P04)) | C01 |
(rg.a & (F20 | F08));
goto loop;
case 0xDB: // IN A,(imm)
pc++;
rg.a = IN( data + rg.a * 0x100 );
goto loop;
case 0xE3:{// EX (SP),HL
- fuint16 temp = READ_WORD( sp );
+ uint16_t temp = READ_WORD( sp );
WRITE_WORD( sp, rp.hl );
rp.hl = temp;
goto loop;
}
case 0xEB:{// EX DE,HL
- fuint16 temp = rp.hl;
+ uint16_t temp = rp.hl;
rp.hl = rp.de;
rp.de = temp;
goto loop;
}
case 0xD9:{// EXX DE,HL
- fuint16 temp = r.alt.w.bc;
+ uint16_t temp = r.alt.w.bc;
r.alt.w.bc = rp.bc;
rp.bc = temp;
temp = r.alt.w.de;
r.alt.w.de = rp.de;
rp.de = temp;
temp = r.alt.w.hl;
r.alt.w.hl = rp.hl;
rp.hl = temp;
goto loop;
}
case 0xF3: // DI
r.iff1 = 0;
r.iff2 = 0;
goto loop;
case 0xFB: // EI
r.iff1 = 1;
r.iff2 = 1;
// TODO: delayed effect
goto loop;
case 0x76: // HALT
goto halt;
//////////////////////////////////////// CB prefix
{
case 0xCB:
unsigned data2;
data2 = instr [1];
- data2 = data2;
+ (void) data2; // TODO is this the same as data in all cases?
pc++;
switch ( data )
{
// Rotate left
#define RLC( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
result = uint8_t (result << 1) | (result >> 7);\
flags = SZ28P( result ) | (result & C01);\
write;\
goto loop;\
}
case 0x06: // RLC (HL)
s_time += 7;
data = rp.hl;
rlc_data_addr:
RLC( READ( data ), WRITE( data, result ) )
CASE7( 00, 01, 02, 03, 04, 05, 07 ):{// RLC r
uint8_t& reg = R8( data, 0 );
RLC( reg, reg = result )
}
#define RL( read, write ) {\
- fuint16 result = (read << 1) | (flags & C01);\
+ uint16_t result = (read << 1) | (flags & C01);\
flags = SZ28PC( result );\
write;\
goto loop;\
}
case 0x16: // RL (HL)
s_time += 7;
data = rp.hl;
rl_data_addr:
RL( READ( data ), WRITE( data, result ) )
CASE7( 10, 11, 12, 13, 14, 15, 17 ):{// RL r
uint8_t& reg = R8( data, 0x10 );
RL( reg, reg = result )
}
#define SLA( read, add, write ) {\
- fuint16 result = (read << 1) | add;\
+ uint16_t result = (read << 1) | add;\
flags = SZ28PC( result );\
write;\
goto loop;\
}
case 0x26: // SLA (HL)
s_time += 7;
data = rp.hl;
sla_data_addr:
SLA( READ( data ), 0, WRITE( data, result ) )
CASE7( 20, 21, 22, 23, 24, 25, 27 ):{// SLA r
uint8_t& reg = R8( data, 0x20 );
SLA( reg, 0, reg = result )
}
case 0x36: // SLL (HL)
s_time += 7;
data = rp.hl;
sll_data_addr:
SLA( READ( data ), 1, WRITE( data, result ) )
CASE7( 30, 31, 32, 33, 34, 35, 37 ):{// SLL r
uint8_t& reg = R8( data, 0x30 );
SLA( reg, 1, reg = result )
}
// Rotate right
#define RRC( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result = uint8_t (result << 7) | (result >> 1);\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x0E: // RRC (HL)
s_time += 7;
data = rp.hl;
rrc_data_addr:
RRC( READ( data ), WRITE( data, result ) )
CASE7( 08, 09, 0A, 0B, 0C, 0D, 0F ):{// RRC r
uint8_t& reg = R8( data, 0x08 );
RRC( reg, reg = result )
}
#define RR( read, write ) {\
- fuint8 result = read;\
- fuint8 temp = result & C01;\
+ uint8_t result = read;\
+ uint8_t temp = result & C01;\
result = uint8_t (flags << 7) | (result >> 1);\
flags = SZ28P( result ) | temp;\
write;\
goto loop;\
}
case 0x1E: // RR (HL)
s_time += 7;
data = rp.hl;
rr_data_addr:
RR( READ( data ), WRITE( data, result ) )
CASE7( 18, 19, 1A, 1B, 1C, 1D, 1F ):{// RR r
uint8_t& reg = R8( data, 0x18 );
RR( reg, reg = result )
}
#define SRA( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result = (result & 0x80) | (result >> 1);\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x2E: // SRA (HL)
data = rp.hl;
s_time += 7;
sra_data_addr:
SRA( READ( data ), WRITE( data, result ) )
CASE7( 28, 29, 2A, 2B, 2C, 2D, 2F ):{// SRA r
uint8_t& reg = R8( data, 0x28 );
SRA( reg, reg = result )
}
#define SRL( read, write ) {\
- fuint8 result = read;\
+ uint8_t result = read;\
flags = result & C01;\
result >>= 1;\
flags |= SZ28P( result );\
write;\
goto loop;\
}
case 0x3E: // SRL (HL)
s_time += 7;
data = rp.hl;
srl_data_addr:
SRL( READ( data ), WRITE( data, result ) )
CASE7( 38, 39, 3A, 3B, 3C, 3D, 3F ):{// SRL r
uint8_t& reg = R8( data, 0x38 );
SRL( reg, reg = result )
}
// BIT
{
unsigned temp;
CASE8( 46, 4E, 56, 5E, 66, 6E, 76, 7E ): // BIT b,(HL)
s_time += 4;
temp = READ( rp.hl );
flags &= C01;
goto bit_temp;
CASE7( 40, 41, 42, 43, 44, 45, 47 ): // BIT 0,r
CASE7( 48, 49, 4A, 4B, 4C, 4D, 4F ): // BIT 1,r
CASE7( 50, 51, 52, 53, 54, 55, 57 ): // BIT 2,r
CASE7( 58, 59, 5A, 5B, 5C, 5D, 5F ): // BIT 3,r
CASE7( 60, 61, 62, 63, 64, 65, 67 ): // BIT 4,r
CASE7( 68, 69, 6A, 6B, 6C, 6D, 6F ): // BIT 5,r
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // BIT 6,r
CASE7( 78, 79, 7A, 7B, 7C, 7D, 7F ): // BIT 7,r
temp = R8( data & 7, 0 );
flags = (flags & C01) | (temp & (F20 | F08));
bit_temp:
int masked = temp & 1 << (data >> 3 & 7);
flags |=(masked & S80) | H10 |
((masked - 1) >> 8 & (Z40 | P04));
goto loop;
}
// SET/RES
CASE8( 86, 8E, 96, 9E, A6, AE, B6, BE ): // RES b,(HL)
CASE8( C6, CE, D6, DE, E6, EE, F6, FE ):{// SET b,(HL)
s_time += 7;
int temp = READ( rp.hl );
int bit = 1 << (data >> 3 & 7);
temp |= bit; // SET
if ( !(data & 0x40) )
temp ^= bit; // RES
WRITE( rp.hl, temp );
goto loop;
}
CASE7( C0, C1, C2, C3, C4, C5, C7 ): // SET 0,r
CASE7( C8, C9, CA, CB, CC, CD, CF ): // SET 1,r
CASE7( D0, D1, D2, D3, D4, D5, D7 ): // SET 2,r
CASE7( D8, D9, DA, DB, DC, DD, DF ): // SET 3,r
CASE7( E0, E1, E2, E3, E4, E5, E7 ): // SET 4,r
CASE7( E8, E9, EA, EB, EC, ED, EF ): // SET 5,r
CASE7( F0, F1, F2, F3, F4, F5, F7 ): // SET 6,r
CASE7( F8, F9, FA, FB, FC, FD, FF ): // SET 7,r
R8( data & 7, 0 ) |= 1 << (data >> 3 & 7);
goto loop;
CASE7( 80, 81, 82, 83, 84, 85, 87 ): // RES 0,r
CASE7( 88, 89, 8A, 8B, 8C, 8D, 8F ): // RES 1,r
CASE7( 90, 91, 92, 93, 94, 95, 97 ): // RES 2,r
CASE7( 98, 99, 9A, 9B, 9C, 9D, 9F ): // RES 3,r
CASE7( A0, A1, A2, A3, A4, A5, A7 ): // RES 4,r
CASE7( A8, A9, AA, AB, AC, AD, AF ): // RES 5,r
CASE7( B0, B1, B2, B3, B4, B5, B7 ): // RES 6,r
CASE7( B8, B9, BA, BB, BC, BD, BF ): // RES 7,r
R8( data & 7, 0 ) &= ~(1 << (data >> 3 & 7));
goto loop;
}
assert( false );
}
#undef GET_ADDR
#define GET_ADDR() GET_LE16( instr + 1 )
//////////////////////////////////////// ED prefix
{
case 0xED:
pc++;
s_time += ed_dd_timing [data] >> 4;
switch ( data )
{
{
blargg_ulong temp;
case 0x72: // SBC HL,SP
case 0x7A: // ADC HL,SP
temp = sp;
if ( 0 )
case 0x42: // SBC HL,BC
case 0x52: // SBC HL,DE
case 0x62: // SBC HL,HL
case 0x4A: // ADC HL,BC
case 0x5A: // ADC HL,DE
case 0x6A: // ADC HL,HL
temp = R16( data >> 3 & 6, 1, 0 );
blargg_ulong sum = temp + (flags & C01);
flags = ~data >> 2 & N02;
if ( flags )
sum = -sum;
sum += rp.hl;
temp ^= rp.hl;
temp ^= sum;
flags |=(sum >> 16 & C01) |
(temp >> 8 & H10) |
(sum >> 8 & (S80 | F20 | F08)) |
((temp - -0x8000) >> 14 & V04);
rp.hl = sum;
if ( (uint16_t) sum )
goto loop;
flags |= Z40;
goto loop;
}
CASE8( 40, 48, 50, 58, 60, 68, 70, 78 ):{// IN r,(C)
int temp = IN( rp.bc );
R8( data >> 3, 8 ) = temp;
flags = (flags & C01) | SZ28P( temp );
goto loop;
}
case 0x71: // OUT (C),0
rg.flags = 0;
CASE7( 41, 49, 51, 59, 61, 69, 79 ): // OUT (C),r
OUT( rp.bc, R8( data >> 3, 8 ) );
goto loop;
{
unsigned temp;
case 0x73: // LD (ADDR),SP
temp = sp;
if ( 0 )
case 0x43: // LD (ADDR),BC
case 0x53: // LD (ADDR),DE
temp = R16( data, 4, 0x43 );
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, temp );
goto loop;
}
case 0x4B: // LD BC,(ADDR)
case 0x5B:{// LD DE,(ADDR)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
R16( data, 4, 0x4B ) = READ_WORD( addr );
goto loop;
}
case 0x7B:{// LD SP,(ADDR)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
sp = READ_WORD( addr );
goto loop;
}
case 0x67:{// RRD
- fuint8 temp = READ( rp.hl );
+ uint8_t temp = READ( rp.hl );
WRITE( rp.hl, (rg.a << 4) | (temp >> 4) );
temp = (rg.a & 0xF0) | (temp & 0x0F);
flags = (flags & C01) | SZ28P( temp );
rg.a = temp;
goto loop;
}
case 0x6F:{// RLD
- fuint8 temp = READ( rp.hl );
+ uint8_t temp = READ( rp.hl );
WRITE( rp.hl, (temp << 4) | (rg.a & 0x0F) );
temp = (rg.a & 0xF0) | (temp >> 4);
flags = (flags & C01) | SZ28P( temp );
rg.a = temp;
goto loop;
}
CASE8( 44, 4C, 54, 5C, 64, 6C, 74, 7C ): // NEG
opcode = 0x10; // flag to do SBC instead of ADC
flags &= ~C01;
data = rg.a;
rg.a = 0;
goto adc_data;
{
int inc;
case 0xA9: // CPD
case 0xB9: // CPDR
inc = -1;
if ( 0 )
case 0xA1: // CPI
case 0xB1: // CPIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
int result = rg.a - temp;
flags = (flags & C01) | N02 |
((((temp ^ rg.a) & H10) ^ result) & (S80 | H10));
if ( !(uint8_t) result ) flags |= Z40;
result -= (flags & H10) >> 4;
flags |= result & F08;
flags |= result << 4 & F20;
if ( !--rp.bc )
goto loop;
flags |= V04;
if ( flags & Z40 || data < 0xB0 )
goto loop;
pc -= 2;
s_time += 5;
goto loop;
}
{
int inc;
case 0xA8: // LDD
case 0xB8: // LDDR
inc = -1;
if ( 0 )
case 0xA0: // LDI
case 0xB0: // LDIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
addr = rp.de;
rp.de = addr + inc;
WRITE( addr, temp );
temp += rg.a;
flags = (flags & (S80 | Z40 | C01)) |
(temp & F08) | (temp << 4 & F20);
if ( !--rp.bc )
goto loop;
flags |= V04;
if ( data < 0xB0 )
goto loop;
pc -= 2;
s_time += 5;
goto loop;
}
{
int inc;
case 0xAB: // OUTD
case 0xBB: // OTDR
inc = -1;
if ( 0 )
case 0xA3: // OUTI
case 0xB3: // OTIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = READ( addr );
int b = --rg.b;
flags = (temp >> 6 & N02) | SZ28( b );
if ( b && data >= 0xB0 )
{
pc -= 2;
s_time += 5;
}
OUT( rp.bc, temp );
goto loop;
}
{
int inc;
case 0xAA: // IND
case 0xBA: // INDR
inc = -1;
if ( 0 )
case 0xA2: // INI
case 0xB2: // INIR
inc = +1;
- fuint16 addr = rp.hl;
+ uint16_t addr = rp.hl;
rp.hl = addr + inc;
int temp = IN( rp.bc );
int b = --rg.b;
flags = (temp >> 6 & N02) | SZ28( b );
if ( b && data >= 0xB0 )
{
pc -= 2;
s_time += 5;
}
WRITE( addr, temp );
goto loop;
}
case 0x47: // LD I,A
r.i = rg.a;
goto loop;
case 0x4F: // LD R,A
SET_R( rg.a );
debug_printf( "LD R,A not supported\n" );
warning = true;
goto loop;
case 0x57: // LD A,I
rg.a = r.i;
goto ld_ai_common;
case 0x5F: // LD A,R
rg.a = GET_R();
debug_printf( "LD A,R not supported\n" );
warning = true;
ld_ai_common:
flags = (flags & C01) | SZ28( rg.a ) | (r.iff2 << 2 & V04);
goto loop;
CASE8( 45, 4D, 55, 5D, 65, 6D, 75, 7D ): // RETI/RETN
r.iff1 = r.iff2;
goto ret_taken;
case 0x46: case 0x4E: case 0x66: case 0x6E: // IM 0
r.im = 0;
goto loop;
case 0x56: case 0x76: // IM 1
r.im = 1;
goto loop;
case 0x5E: case 0x7E: // IM 2
r.im = 2;
goto loop;
default:
debug_printf( "Opcode $ED $%02X not supported\n", data );
warning = true;
goto loop;
}
assert( false );
}
//////////////////////////////////////// DD/FD prefix
{
- fuint16 ixy;
+ uint16_t ixy;
case 0xDD:
ixy = ix;
goto ix_prefix;
case 0xFD:
ixy = iy;
ix_prefix:
pc++;
unsigned data2 = READ_PROG( pc );
s_time += ed_dd_timing [data] & 0x0F;
switch ( data )
{
// TODO: more efficient way of avoid negative address
// TODO: avoid using this as argument to READ() since it is evaluated twice
#define IXY_DISP( ixy, disp ) uint16_t ((ixy) + (disp))
#define SET_IXY( in ) if ( opcode == 0xDD ) ix = in; else iy = in;
// ADD/ADC/SUB/SBC
case 0x96: // SUB (IXY+disp)
case 0x86: // ADD (IXY+disp)
flags &= ~C01;
case 0x9E: // SBC (IXY+disp)
case 0x8E: // ADC (IXY+disp)
pc++;
opcode = data;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto adc_data;
case 0x94: // SUB HXY
case 0x84: // ADD HXY
flags &= ~C01;
case 0x9C: // SBC HXY
case 0x8C: // ADC HXY
opcode = data;
data = ixy >> 8;
goto adc_data;
case 0x95: // SUB LXY
case 0x85: // ADD LXY
flags &= ~C01;
case 0x9D: // SBC LXY
case 0x8D: // ADC LXY
opcode = data;
data = (uint8_t) ixy;
goto adc_data;
{
unsigned temp;
case 0x39: // ADD IXY,SP
temp = sp;
goto add_ixy_data;
case 0x29: // ADD IXY,HL
temp = ixy;
goto add_ixy_data;
case 0x09: // ADD IXY,BC
case 0x19: // ADD IXY,DE
temp = R16( data, 4, 0x09 );
add_ixy_data: {
blargg_ulong sum = ixy + temp;
temp ^= ixy;
ixy = (uint16_t) sum;
flags = (flags & (S80 | Z40 | V04)) |
(sum >> 16) |
(sum >> 8 & (F20 | F08)) |
((temp ^ sum) >> 8 & H10);
goto set_ixy;
}
}
// AND
case 0xA6: // AND (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto and_data;
case 0xA4: // AND HXY
data = ixy >> 8;
goto and_data;
case 0xA5: // AND LXY
data = (uint8_t) ixy;
goto and_data;
// OR
case 0xB6: // OR (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto or_data;
case 0xB4: // OR HXY
data = ixy >> 8;
goto or_data;
case 0xB5: // OR LXY
data = (uint8_t) ixy;
goto or_data;
// XOR
case 0xAE: // XOR (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto xor_data;
case 0xAC: // XOR HXY
data = ixy >> 8;
goto xor_data;
case 0xAD: // XOR LXY
data = (uint8_t) ixy;
goto xor_data;
// CP
case 0xBE: // CP (IXY+disp)
pc++;
data = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto cp_data;
case 0xBC: // CP HXY
data = ixy >> 8;
goto cp_data;
case 0xBD: // CP LXY
data = (uint8_t) ixy;
goto cp_data;
// LD
CASE7( 70, 71, 72, 73, 74, 75, 77 ): // LD (IXY+disp),r
data = R8( data, 0x70 );
if ( 0 )
case 0x36: // LD (IXY+disp),imm
pc++, data = READ_PROG( pc );
pc++;
WRITE( IXY_DISP( ixy, (int8_t) data2 ), data );
goto loop;
CASE5( 44, 4C, 54, 5C, 7C ): // LD r,HXY
R8( data >> 3, 8 ) = ixy >> 8;
goto loop;
case 0x64: // LD HXY,HXY
case 0x6D: // LD LXY,LXY
goto loop;
CASE5( 45, 4D, 55, 5D, 7D ): // LD r,LXY
R8( data >> 3, 8 ) = ixy;
goto loop;
CASE7( 46, 4E, 56, 5E, 66, 6E, 7E ): // LD r,(IXY+disp)
pc++;
R8( data >> 3, 8 ) = READ( IXY_DISP( ixy, (int8_t) data2 ) );
goto loop;
case 0x26: // LD HXY,imm
pc++;
goto ld_hxy_data;
case 0x65: // LD HXY,LXY
data2 = (uint8_t) ixy;
goto ld_hxy_data;
CASE5( 60, 61, 62, 63, 67 ): // LD HXY,r
data2 = R8( data, 0x60 );
ld_hxy_data:
ixy = (uint8_t) ixy | (data2 << 8);
goto set_ixy;
case 0x2E: // LD LXY,imm
pc++;
goto ld_lxy_data;
case 0x6C: // LD LXY,HXY
data2 = ixy >> 8;
goto ld_lxy_data;
CASE5( 68, 69, 6A, 6B, 6F ): // LD LXY,r
data2 = R8( data, 0x68 );
ld_lxy_data:
ixy = (ixy & 0xFF00) | data2;
set_ixy:
if ( opcode == 0xDD )
{
ix = ixy;
goto loop;
}
iy = ixy;
goto loop;
case 0xF9: // LD SP,IXY
sp = ixy;
goto loop;
case 0x22:{// LD (ADDR),IXY
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
pc += 2;
WRITE_WORD( addr, ixy );
goto loop;
}
case 0x21: // LD IXY,imm
ixy = GET_ADDR();
pc += 2;
goto set_ixy;
case 0x2A:{// LD IXY,(addr)
- fuint16 addr = GET_ADDR();
+ uint16_t addr = GET_ADDR();
ixy = READ_WORD( addr );
pc += 2;
goto set_ixy;
}
// DD/FD CB prefix
case 0xCB: {
data = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data2 = READ_PROG( pc );
pc++;
switch ( data2 )
{
case 0x06: goto rlc_data_addr; // RLC (IXY)
case 0x16: goto rl_data_addr; // RL (IXY)
case 0x26: goto sla_data_addr; // SLA (IXY)
case 0x36: goto sll_data_addr; // SLL (IXY)
case 0x0E: goto rrc_data_addr; // RRC (IXY)
case 0x1E: goto rr_data_addr; // RR (IXY)
case 0x2E: goto sra_data_addr; // SRA (IXY)
case 0x3E: goto srl_data_addr; // SRL (IXY)
CASE8( 46, 4E, 56, 5E, 66, 6E, 76, 7E ):{// BIT b,(IXY+disp)
- fuint8 temp = READ( data );
+ uint8_t temp = READ( data );
int masked = temp & 1 << (data2 >> 3 & 7);
flags = (flags & C01) | H10 |
(masked & S80) |
((masked - 1) >> 8 & (Z40 | P04));
goto loop;
}
CASE8( 86, 8E, 96, 9E, A6, AE, B6, BE ): // RES b,(IXY+disp)
CASE8( C6, CE, D6, DE, E6, EE, F6, FE ):{// SET b,(IXY+disp)
int temp = READ( data );
int bit = 1 << (data2 >> 3 & 7);
temp |= bit; // SET
if ( !(data2 & 0x40) )
temp ^= bit; // RES
WRITE( data, temp );
goto loop;
}
default:
debug_printf( "Opcode $%02X $CB $%02X not supported\n", opcode, data2 );
warning = true;
goto loop;
}
assert( false );
}
// INC/DEC
case 0x23: // INC IXY
ixy = uint16_t (ixy + 1);
goto set_ixy;
case 0x2B: // DEC IXY
ixy = uint16_t (ixy - 1);
goto set_ixy;
case 0x34: // INC (IXY+disp)
ixy = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data = READ( ixy ) + 1;
WRITE( ixy, data );
goto inc_set_flags;
case 0x35: // DEC (IXY+disp)
ixy = IXY_DISP( ixy, (int8_t) data2 );
pc++;
data = READ( ixy ) - 1;
WRITE( ixy, data );
goto dec_set_flags;
case 0x24: // INC HXY
ixy = uint16_t (ixy + 0x100);
data = ixy >> 8;
goto inc_xy_common;
case 0x2C: // INC LXY
data = uint8_t (ixy + 1);
ixy = (ixy & 0xFF00) | data;
inc_xy_common:
if ( opcode == 0xDD )
{
ix = ixy;
goto inc_set_flags;
}
iy = ixy;
goto inc_set_flags;
case 0x25: // DEC HXY
ixy = uint16_t (ixy - 0x100);
data = ixy >> 8;
goto dec_xy_common;
case 0x2D: // DEC LXY
data = uint8_t (ixy - 1);
ixy = (ixy & 0xFF00) | data;
dec_xy_common:
if ( opcode == 0xDD )
{
ix = ixy;
goto dec_set_flags;
}
iy = ixy;
goto dec_set_flags;
// PUSH/POP
case 0xE5: // PUSH IXY
data = ixy;
goto push_data;
case 0xE1:{// POP IXY
ixy = READ_WORD( sp );
sp = uint16_t (sp + 2);
goto set_ixy;
}
// Misc
case 0xE9: // JP (IXY)
pc = ixy;
goto loop;
case 0xE3:{// EX (SP),IXY
- fuint16 temp = READ_WORD( sp );
+ uint16_t temp = READ_WORD( sp );
WRITE_WORD( sp, ixy );
ixy = temp;
goto set_ixy;
}
default:
debug_printf( "Unnecessary DD/FD prefix encountered\n" );
warning = true;
pc--;
goto loop;
}
assert( false );
}
}
debug_printf( "Unhandled main opcode: $%02X\n", opcode );
assert( false );
hit_idle_addr:
s_time -= 11;
goto out_of_time;
halt:
s_time &= 3; // increment by multiple of 4
out_of_time:
pc--;
s.time = s_time;
rg.flags = flags;
r.ix = ix;
r.iy = iy;
r.sp = sp;
r.pc = pc;
this->r.b = rg;
this->state_ = s;
this->state = &this->state_;
return warning;
}
diff --git a/src/libs/gme/Kss_Cpu.h b/src/libs/gme/Kss_Cpu.h
index 28a2fc0f..d31864cd 100644
--- a/src/libs/gme/Kss_Cpu.h
+++ b/src/libs/gme/Kss_Cpu.h
@@ -1,124 +1,120 @@
// Z80 CPU emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef KSS_CPU_H
#define KSS_CPU_H
#include "blargg_endian.h"
typedef blargg_long cpu_time_t;
// must be defined by caller
void kss_cpu_out( class Kss_Cpu*, cpu_time_t, unsigned addr, int data );
int kss_cpu_in( class Kss_Cpu*, cpu_time_t, unsigned addr );
void kss_cpu_write( class Kss_Cpu*, unsigned addr, int data );
class Kss_Cpu {
public:
- typedef BOOST::uint8_t uint8_t;
-
// Clear registers and map all pages to unmapped
void reset( void* unmapped_write, void const* unmapped_read );
// Map memory. Start and size must be multiple of page_size.
enum { page_size = 0x2000 };
void map_mem( unsigned addr, blargg_ulong size, void* write, void const* read );
// Map address to page
uint8_t* write( unsigned addr );
uint8_t const* read( unsigned addr );
// Run until specified time is reached. Returns true if suspicious/unsupported
// instruction was encountered at any point during run.
bool run( cpu_time_t end_time );
// Time of beginning of next instruction
cpu_time_t time() const { return state->time + state->base; }
// Alter current time. Not supported during run() call.
void set_time( cpu_time_t t ) { state->time = t - state->base; }
void adjust_time( int delta ) { state->time += delta; }
- typedef BOOST::uint16_t uint16_t;
-
#if BLARGG_BIG_ENDIAN
struct regs_t { uint8_t b, c, d, e, h, l, flags, a; };
#else
struct regs_t { uint8_t c, b, e, d, l, h, a, flags; };
#endif
BOOST_STATIC_ASSERT( sizeof (regs_t) == 8 );
struct pairs_t { uint16_t bc, de, hl, fa; };
// Registers are not updated until run() returns
struct registers_t {
uint16_t pc;
uint16_t sp;
uint16_t ix;
uint16_t iy;
union {
regs_t b; // b.b, b.c, b.d, b.e, b.h, b.l, b.flags, b.a
pairs_t w; // w.bc, w.de, w.hl. w.fa
};
union {
regs_t b;
pairs_t w;
} alt;
uint8_t iff1;
uint8_t iff2;
uint8_t r;
uint8_t i;
uint8_t im;
};
//registers_t r; (below for efficiency)
enum { idle_addr = 0xFFFF };
// can read this far past end of a page
enum { cpu_padding = 0x100 };
public:
Kss_Cpu();
enum { page_shift = 13 };
enum { page_count = 0x10000 >> page_shift };
private:
uint8_t szpc [0x200];
cpu_time_t end_time_;
struct state_t {
uint8_t const* read [page_count + 1];
uint8_t * write [page_count + 1];
cpu_time_t base;
cpu_time_t time;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
void set_end_time( cpu_time_t t );
void set_page( int i, void* write, void const* read );
public:
registers_t r;
};
#if BLARGG_NONPORTABLE
#define KSS_CPU_PAGE_OFFSET( addr ) (addr)
#else
#define KSS_CPU_PAGE_OFFSET( addr ) ((addr) & (page_size - 1))
#endif
-inline BOOST::uint8_t* Kss_Cpu::write( unsigned addr )
+inline uint8_t* Kss_Cpu::write( unsigned addr )
{
return state->write [addr >> page_shift] + KSS_CPU_PAGE_OFFSET( addr );
}
-inline BOOST::uint8_t const* Kss_Cpu::read( unsigned addr )
+inline uint8_t const* Kss_Cpu::read( unsigned addr )
{
return state->read [addr >> page_shift] + KSS_CPU_PAGE_OFFSET( addr );
}
inline void Kss_Cpu::set_end_time( cpu_time_t t )
{
cpu_time_t delta = state->base - t;
state->base = t;
state->time += delta;
}
#endif
diff --git a/src/libs/gme/Kss_Emu.cpp b/src/libs/gme/Kss_Emu.cpp
index 3b84509c..fd4905ce 100644
--- a/src/libs/gme/Kss_Emu.cpp
+++ b/src/libs/gme/Kss_Emu.cpp
@@ -1,416 +1,416 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Kss_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2006 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"
long const clock_rate = 3579545;
int const osc_count = Ay_Apu::osc_count + Scc_Apu::osc_count;
Kss_Emu::Kss_Emu()
{
sn = 0;
set_type( gme_kss_type );
set_silence_lookahead( 6 );
static const char* const names [osc_count] = {
"Square 1", "Square 2", "Square 3",
"Wave 1", "Wave 2", "Wave 3", "Wave 4", "Wave 5"
};
set_voice_names( names );
static int const types [osc_count] = {
wave_type | 0, wave_type | 1, wave_type | 2,
wave_type | 3, wave_type | 4, wave_type | 5, wave_type | 6, wave_type | 7
};
set_voice_types( types );
memset( unmapped_read, 0xFF, sizeof unmapped_read );
}
Kss_Emu::~Kss_Emu() { unload(); }
void Kss_Emu::unload()
{
delete sn;
sn = 0;
Classic_Emu::unload();
}
// Track info
static void copy_kss_fields( Kss_Emu::header_t const& h, track_info_t* out )
{
const char* system = "MSX";
if ( h.device_flags & 0x02 )
{
system = "Sega Master System";
if ( h.device_flags & 0x04 )
system = "Game Gear";
}
Gme_File::copy_field_( out->system, system );
}
blargg_err_t Kss_Emu::track_info_( track_info_t* out, int ) const
{
copy_kss_fields( header_, out );
return 0;
}
static blargg_err_t check_kss_header( void const* header )
{
if ( memcmp( header, "KSCC", 4 ) && memcmp( header, "KSSX", 4 ) )
return gme_wrong_file_type;
return 0;
}
struct Kss_File : Gme_Info_
{
Kss_Emu::header_t header_;
Kss_File() { set_type( gme_kss_type ); }
blargg_err_t load_( Data_Reader& in )
{
blargg_err_t err = in.read( &header_, Kss_Emu::header_size );
if ( err )
return (err == in.eof_error ? gme_wrong_file_type : err);
return check_kss_header( &header_ );
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
copy_kss_fields( header_, out );
return 0;
}
};
static Music_Emu* new_kss_emu () { return BLARGG_NEW Kss_Emu ; }
static Music_Emu* new_kss_file() { return BLARGG_NEW Kss_File; }
static gme_type_t_ const gme_kss_type_ = { "MSX", 256, &new_kss_emu, &new_kss_file, "KSS", 0x03 };
-gme_type_t const gme_kss_type = &gme_kss_type_;
+BLARGG_EXPORT extern gme_type_t const gme_kss_type = &gme_kss_type_;
// Setup
void Kss_Emu::update_gain()
{
double g = gain() * 1.4;
if ( scc_accessed )
g *= 1.5;
ay.volume( g );
scc.volume( g );
if ( sn )
sn->volume( g );
}
blargg_err_t Kss_Emu::load_( Data_Reader& in )
{
memset( &header_, 0, sizeof header_ );
assert( offsetof (header_t,device_flags) == header_size - 1 );
assert( offsetof (ext_header_t,msx_audio_vol) == ext_header_size - 1 );
RETURN_ERR( rom.load( in, header_size, STATIC_CAST(header_t*,&header_), 0 ) );
RETURN_ERR( check_kss_header( header_.tag ) );
if ( header_.tag [3] == 'C' )
{
if ( header_.extra_header )
{
header_.extra_header = 0;
set_warning( "Unknown data in header" );
}
if ( header_.device_flags & ~0x0F )
{
header_.device_flags &= 0x0F;
set_warning( "Unknown data in header" );
}
}
else
{
ext_header_t& ext = header_;
memcpy( &ext, rom.begin(), min( (int) ext_header_size, (int) header_.extra_header ) );
if ( header_.extra_header > 0x10 )
set_warning( "Unknown data in header" );
}
if ( header_.device_flags & 0x09 )
set_warning( "FM sound not supported" );
scc_enabled = 0xC000;
if ( header_.device_flags & 0x04 )
scc_enabled = 0;
if ( header_.device_flags & 0x02 && !sn )
CHECK_ALLOC( sn = BLARGG_NEW( Sms_Apu ) );
set_voice_count( osc_count );
return setup_buffer( ::clock_rate );
}
void Kss_Emu::update_eq( blip_eq_t const& eq )
{
ay.treble_eq( eq );
scc.treble_eq( eq );
if ( sn )
sn->treble_eq( eq );
}
void Kss_Emu::set_voice( int i, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
int i2 = i - ay.osc_count;
if ( i2 >= 0 )
scc.osc_output( i2, center );
else
ay.osc_output( i, center );
if ( sn && i < sn->osc_count )
sn->osc_output( i, center, left, right );
}
// Emulation
void Kss_Emu::set_tempo_( double t )
{
blip_time_t period =
(header_.device_flags & 0x40 ? ::clock_rate / 50 : ::clock_rate / 60);
play_period = blip_time_t (period / t);
}
blargg_err_t Kss_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( ram, 0xC9, 0x4000 );
memset( ram + 0x4000, 0, sizeof ram - 0x4000 );
// copy driver code to lo RAM
static byte const bios [] = {
0xD3, 0xA0, 0xF5, 0x7B, 0xD3, 0xA1, 0xF1, 0xC9, // $0001: WRTPSG
0xD3, 0xA0, 0xDB, 0xA2, 0xC9 // $0009: RDPSG
};
static byte const vectors [] = {
0xC3, 0x01, 0x00, // $0093: WRTPSG vector
0xC3, 0x09, 0x00, // $0096: RDPSG vector
};
memcpy( ram + 0x01, bios, sizeof bios );
memcpy( ram + 0x93, vectors, sizeof vectors );
// copy non-banked data into RAM
unsigned load_addr = get_le16( header_.load_addr );
long orig_load_size = get_le16( header_.load_size );
long load_size = min( orig_load_size, rom.file_size() );
load_size = min( load_size, long (mem_size - load_addr) );
if ( load_size != orig_load_size )
set_warning( "Excessive data size" );
memcpy( ram + load_addr, rom.begin() + header_.extra_header, load_size );
rom.set_addr( -load_size - header_.extra_header );
// check available bank data
blargg_long const bank_size = this->bank_size();
int max_banks = (rom.file_size() - load_size + bank_size - 1) / bank_size;
bank_count = header_.bank_mode & 0x7F;
if ( bank_count > max_banks )
{
bank_count = max_banks;
set_warning( "Bank data missing" );
}
//debug_printf( "load_size : $%X\n", load_size );
//debug_printf( "bank_size : $%X\n", bank_size );
//debug_printf( "bank_count: %d (%d claimed)\n", bank_count, header_.bank_mode & 0x7F );
ram [idle_addr] = 0xFF;
cpu::reset( unmapped_write, unmapped_read );
cpu::map_mem( 0, mem_size, ram, ram );
ay.reset();
scc.reset();
if ( sn )
sn->reset();
r.sp = 0xF380;
ram [--r.sp] = idle_addr >> 8;
ram [--r.sp] = idle_addr & 0xFF;
r.b.a = track;
r.pc = get_le16( header_.init_addr );
next_play = play_period;
scc_accessed = false;
gain_updated = false;
update_gain();
ay_latch = 0;
return 0;
}
void Kss_Emu::set_bank( int logical, int physical )
{
unsigned const bank_size = this->bank_size();
unsigned addr = 0x8000;
if ( logical && bank_size == 8 * 1024 )
addr = 0xA000;
physical -= header_.first_bank;
if ( (unsigned) physical >= (unsigned) bank_count )
{
byte* data = ram + addr;
cpu::map_mem( addr, bank_size, data, data );
}
else
{
long phys = physical * (blargg_long) bank_size;
for ( unsigned offset = 0; offset < bank_size; offset += page_size )
cpu::map_mem( addr + offset, page_size,
unmapped_write, rom.at_addr( phys + offset ) );
}
}
void Kss_Emu::cpu_write( unsigned addr, int data )
{
data &= 0xFF;
switch ( addr )
{
case 0x9000:
set_bank( 0, data );
return;
case 0xB000:
set_bank( 1, data );
return;
}
int scc_addr = (addr & 0xDFFF) ^ 0x9800;
if ( scc_addr < scc.reg_count )
{
scc_accessed = true;
scc.write( time(), scc_addr, data );
return;
}
debug_printf( "LD ($%04X),$%02X\n", addr, data );
}
void kss_cpu_write( Kss_Cpu* cpu, unsigned addr, int data )
{
*cpu->write( addr ) = data;
if ( (addr & STATIC_CAST(Kss_Emu&,*cpu).scc_enabled) == 0x8000 )
STATIC_CAST(Kss_Emu&,*cpu).cpu_write( addr, data );
}
void kss_cpu_out( Kss_Cpu* cpu, cpu_time_t time, unsigned addr, int data )
{
data &= 0xFF;
Kss_Emu& emu = STATIC_CAST(Kss_Emu&,*cpu);
switch ( addr & 0xFF )
{
case 0xA0:
emu.ay_latch = data & 0x0F;
return;
case 0xA1:
GME_APU_HOOK( &emu, emu.ay_latch, data );
emu.ay.write( time, emu.ay_latch, data );
return;
case 0x06:
if ( emu.sn && (emu.header_.device_flags & 0x04) )
{
emu.sn->write_ggstereo( time, data );
return;
}
break;
case 0x7E:
case 0x7F:
if ( emu.sn )
{
GME_APU_HOOK( &emu, 16, data );
emu.sn->write_data( time, data );
return;
}
break;
case 0xFE:
emu.set_bank( 0, data );
return;
#ifndef NDEBUG
case 0xF1: // FM data
if ( data )
break; // trap non-zero data
case 0xF0: // FM addr
case 0xA8: // PPI
return;
#endif
}
debug_printf( "OUT $%04X,$%02X\n", addr, data );
}
int kss_cpu_in( Kss_Cpu*, cpu_time_t, unsigned addr )
{
//Kss_Emu& emu = STATIC_CAST(Kss_Emu&,*cpu);
//switch ( addr & 0xFF )
//{
//}
debug_printf( "IN $%04X\n", addr );
return 0;
}
// Emulation
blargg_err_t Kss_Emu::run_clocks( blip_time_t& duration, int )
{
while ( time() < duration )
{
blip_time_t end = min( duration, next_play );
cpu::run( min( duration, next_play ) );
if ( r.pc == idle_addr )
set_time( end );
if ( time() >= next_play )
{
next_play += play_period;
if ( r.pc == idle_addr )
{
if ( !gain_updated )
{
gain_updated = true;
if ( scc_accessed )
update_gain();
}
ram [--r.sp] = idle_addr >> 8;
ram [--r.sp] = idle_addr & 0xFF;
r.pc = get_le16( header_.play_addr );
GME_FRAME_HOOK( this );
}
}
}
duration = time();
next_play -= duration;
check( next_play >= 0 );
adjust_time( -duration );
ay.end_frame( duration );
scc.end_frame( duration );
if ( sn )
sn->end_frame( duration );
return 0;
}
diff --git a/src/libs/gme/Kss_Emu.h b/src/libs/gme/Kss_Emu.h
index 1d6ae475..467b28ab 100644
--- a/src/libs/gme/Kss_Emu.h
+++ b/src/libs/gme/Kss_Emu.h
@@ -1,96 +1,95 @@
// MSX computer KSS music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef KSS_EMU_H
#define KSS_EMU_H
#include "Classic_Emu.h"
#include "Kss_Scc_Apu.h"
#include "Kss_Cpu.h"
#include "Sms_Apu.h"
#include "Ay_Apu.h"
class Kss_Emu : private Kss_Cpu, public Classic_Emu {
typedef Kss_Cpu cpu;
public:
// KSS file header
enum { header_size = 0x10 };
struct header_t
{
byte tag [4];
byte load_addr [2];
byte load_size [2];
byte init_addr [2];
byte play_addr [2];
byte first_bank;
byte bank_mode;
byte extra_header;
byte device_flags;
};
enum { ext_header_size = 0x10 };
struct ext_header_t
{
byte data_size [4];
byte unused [4];
byte first_track [2];
byte last_tack [2];
byte psg_vol;
byte scc_vol;
byte msx_music_vol;
byte msx_audio_vol;
};
struct composite_header_t : header_t, ext_header_t { };
// Header for currently loaded file
composite_header_t const& header() const { return header_; }
static gme_type_t static_type() { return gme_kss_type; }
public:
Kss_Emu();
~Kss_Emu();
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_( Data_Reader& );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
void unload();
private:
Rom_Data<page_size> rom;
composite_header_t header_;
bool scc_accessed;
bool gain_updated;
void update_gain();
unsigned scc_enabled; // 0 or 0xC000
- byte const* bank_data;
int bank_count;
void set_bank( int logical, int physical );
blargg_long bank_size() const { return (16 * 1024L) >> (header_.bank_mode >> 7 & 1); }
blip_time_t play_period;
blip_time_t next_play;
int ay_latch;
friend void kss_cpu_out( class Kss_Cpu*, cpu_time_t, unsigned addr, int data );
friend int kss_cpu_in( class Kss_Cpu*, cpu_time_t, unsigned addr );
void cpu_write( unsigned addr, int data );
friend void kss_cpu_write( class Kss_Cpu*, unsigned addr, int data );
// large items
enum { mem_size = 0x10000 };
byte ram [mem_size + cpu_padding];
Ay_Apu ay;
Scc_Apu scc;
Sms_Apu* sn;
byte unmapped_read [0x100];
byte unmapped_write [page_size];
};
#endif
diff --git a/src/libs/gme/Kss_Scc_Apu.cpp b/src/libs/gme/Kss_Scc_Apu.cpp
index cfccce64..bb84b325 100644
--- a/src/libs/gme/Kss_Scc_Apu.cpp
+++ b/src/libs/gme/Kss_Scc_Apu.cpp
@@ -1,97 +1,97 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Kss_Scc_Apu.h"
/* Copyright (C) 2006 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"
// Tones above this frequency are treated as disabled tone at half volume.
// Power of two is more efficient (avoids division).
unsigned const inaudible_freq = 16384;
int const wave_size = 0x20;
void Scc_Apu::run_until( blip_time_t end_time )
{
for ( int index = 0; index < osc_count; index++ )
{
osc_t& osc = oscs [index];
Blip_Buffer* const output = osc.output;
if ( !output )
continue;
output->set_modified();
blip_time_t period = (regs [0x80 + index * 2 + 1] & 0x0F) * 0x100 +
regs [0x80 + index * 2] + 1;
int volume = 0;
if ( regs [0x8F] & (1 << index) )
{
blip_time_t inaudible_period = (blargg_ulong) (output->clock_rate() +
inaudible_freq * 32) / (inaudible_freq * 16);
if ( period > inaudible_period )
volume = (regs [0x8A + index] & 0x0F) * (amp_range / 256 / 15);
}
- BOOST::int8_t const* wave = (BOOST::int8_t*) regs + index * wave_size;
+ int8_t const* wave = (int8_t*) regs + index * wave_size;
if ( index == osc_count - 1 )
wave -= wave_size; // last two oscs share wave
{
int amp = wave [osc.phase] * volume;
int delta = amp - osc.last_amp;
if ( delta )
{
osc.last_amp = amp;
synth.offset( last_time, delta, output );
}
}
blip_time_t time = last_time + osc.delay;
if ( time < end_time )
{
if ( !volume )
{
// maintain phase
blargg_long count = (end_time - time + period - 1) / period;
osc.phase = (osc.phase + count) & (wave_size - 1);
time += count * period;
}
else
{
int phase = osc.phase;
int last_wave = wave [phase];
phase = (phase + 1) & (wave_size - 1); // pre-advance for optimal inner loop
do
{
int amp = wave [phase];
phase = (phase + 1) & (wave_size - 1);
int delta = amp - last_wave;
if ( delta )
{
last_wave = amp;
synth.offset( time, delta * volume, output );
}
time += period;
}
while ( time < end_time );
osc.phase = phase = (phase - 1) & (wave_size - 1); // undo pre-advance
osc.last_amp = wave [phase] * volume;
}
}
osc.delay = time - end_time;
}
last_time = end_time;
}
diff --git a/src/libs/gme/Kss_Scc_Apu.h b/src/libs/gme/Kss_Scc_Apu.h
index 5c65461c..eda5747f 100644
--- a/src/libs/gme/Kss_Scc_Apu.h
+++ b/src/libs/gme/Kss_Scc_Apu.h
@@ -1,106 +1,106 @@
// Konami SCC sound chip emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef KSS_SCC_APU_H
#define KSS_SCC_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
#include <string.h>
class Scc_Apu {
public:
// Set buffer to generate all sound into, or disable sound if NULL
void output( Blip_Buffer* );
// Reset sound chip
void reset();
// Write to register at specified time
enum { reg_count = 0x90 };
void write( blip_time_t time, int reg, int data );
// Run sound to specified time, end current time frame, then start a new
// time frame at time 0. Time frames have no effect on emulation and each
// can be whatever length is convenient.
void end_frame( blip_time_t length );
// Additional features
// Set sound output of specific oscillator to buffer, where index is
// 0 to 4. If buffer is NULL, the specified oscillator is muted.
enum { osc_count = 5 };
void osc_output( int index, Blip_Buffer* );
// Set overall volume (default is 1.0)
void volume( double );
// Set treble equalization (see documentation)
void treble_eq( blip_eq_t const& );
public:
Scc_Apu();
private:
enum { amp_range = 0x8000 };
struct osc_t
{
int delay;
int phase;
int last_amp;
Blip_Buffer* output;
};
osc_t oscs [osc_count];
blip_time_t last_time;
unsigned char regs [reg_count];
Blip_Synth<blip_med_quality,1> synth;
void run_until( blip_time_t );
};
inline void Scc_Apu::volume( double v ) { synth.volume( 0.43 / osc_count / amp_range * v ); }
inline void Scc_Apu::treble_eq( blip_eq_t const& eq ) { synth.treble_eq( eq ); }
inline void Scc_Apu::osc_output( int index, Blip_Buffer* b )
{
assert( (unsigned) index < osc_count );
oscs [index].output = b;
}
inline void Scc_Apu::write( blip_time_t time, int addr, int data )
{
assert( (unsigned) addr < reg_count );
run_until( time );
regs [addr] = data;
}
inline void Scc_Apu::end_frame( blip_time_t end_time )
{
if ( end_time > last_time )
run_until( end_time );
last_time -= end_time;
assert( last_time >= 0 );
}
inline void Scc_Apu::output( Blip_Buffer* buf )
{
for ( int i = 0; i < osc_count; i++ )
oscs [i].output = buf;
}
inline Scc_Apu::Scc_Apu()
{
output( 0 );
}
inline void Scc_Apu::reset()
{
last_time = 0;
for ( int i = 0; i < osc_count; i++ )
memset( &oscs [i], 0, offsetof (osc_t,output) );
memset( regs, 0, sizeof regs );
}
#endif
diff --git a/src/libs/gme/M3u_Playlist.cpp b/src/libs/gme/M3u_Playlist.cpp
index 75d0fcb2..e751d4cc 100644
--- a/src/libs/gme/M3u_Playlist.cpp
+++ b/src/libs/gme/M3u_Playlist.cpp
@@ -1,426 +1,426 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "M3u_Playlist.h"
#include "Music_Emu.h"
#include <string.h>
/* Copyright (C) 2006 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"
// gme functions defined here to avoid linking in m3u code unless it's used
blargg_err_t Gme_File::load_m3u_( blargg_err_t err )
{
require( raw_track_count_ ); // file must be loaded first
if ( !err )
{
if ( playlist.size() )
track_count_ = playlist.size();
int line = playlist.first_error();
if ( line )
{
// avoid using bloated printf()
char* out = &playlist_warning [sizeof playlist_warning];
*--out = 0;
do {
*--out = line % 10 + '0';
} while ( (line /= 10) > 0 );
static const char str [] = "Problem in m3u at line ";
out -= sizeof str - 1;
memcpy( out, str, sizeof str - 1 );
set_warning( out );
}
}
return err;
}
blargg_err_t Gme_File::load_m3u( const char* path ) { return load_m3u_( playlist.load( path ) ); }
blargg_err_t Gme_File::load_m3u( Data_Reader& in ) { return load_m3u_( playlist.load( in ) ); }
-gme_err_t gme_load_m3u( Music_Emu* me, const char* path ) { return me->load_m3u( path ); }
+BLARGG_EXPORT gme_err_t gme_load_m3u( Music_Emu* me, const char* path ) { return me->load_m3u( path ); }
-gme_err_t gme_load_m3u_data( Music_Emu* me, const void* data, long size )
+BLARGG_EXPORT gme_err_t gme_load_m3u_data( Music_Emu* me, const void* data, long size )
{
Mem_File_Reader in( data, size );
return me->load_m3u( in );
}
static char* skip_white( char* in )
{
while ( *in == ' ' )
in++;
return in;
}
inline unsigned from_dec( unsigned n ) { return n - '0'; }
static char* parse_filename( char* in, M3u_Playlist::entry_t& entry )
{
entry.file = in;
entry.type = "";
char* out = in;
while ( 1 )
{
int c = *in;
if ( !c ) break;
in++;
if ( c == ',' ) // commas in filename
{
char* p = skip_white( in );
if ( *p == '$' || from_dec( *p ) <= 9 )
{
in = p;
break;
}
}
if ( c == ':' && in [0] == ':' && in [1] && in [2] != ',' ) // ::type suffix
{
entry.type = ++in;
while ( (c = *in) != 0 && c != ',' )
in++;
if ( c == ',' )
{
*in++ = 0; // terminate type
in = skip_white( in );
}
break;
}
if ( c == '\\' ) // \ prefix for special characters
{
c = *in;
if ( !c ) break;
in++;
}
*out++ = (char) c;
}
*out = 0; // terminate string
return in;
}
static char* next_field( char* in, int* result )
{
while ( 1 )
{
in = skip_white( in );
if ( !*in )
break;
if ( *in == ',' )
{
in++;
break;
}
*result = 1;
in++;
}
return skip_white( in );
}
static char* parse_int_( char* in, int* out )
{
int n = 0;
while ( 1 )
{
unsigned d = from_dec( *in );
if ( d > 9 )
break;
in++;
n = n * 10 + d;
*out = n;
}
return in;
}
static char* parse_int( char* in, int* out, int* result )
{
return next_field( parse_int_( in, out ), result );
}
// Returns 16 or greater if not hex
inline int from_hex_char( int h )
{
h -= 0x30;
if ( (unsigned) h > 9 )
h = ((h - 0x11) & 0xDF) + 10;
return h;
}
static char* parse_track( char* in, M3u_Playlist::entry_t& entry, int* result )
{
if ( *in == '$' )
{
in++;
int n = 0;
while ( 1 )
{
int h = from_hex_char( *in );
if ( h > 15 )
break;
in++;
n = n * 16 + h;
entry.track = n;
}
}
else
{
in = parse_int_( in, &entry.track );
if ( entry.track >= 0 )
entry.decimal_track = 1;
}
return next_field( in, result );
}
static char* parse_time_( char* in, int* out )
{
*out = -1;
int n = -1;
in = parse_int_( in, &n );
if ( n >= 0 )
{
*out = n;
if ( *in == ':' )
{
n = -1;
in = parse_int_( in + 1, &n );
if ( n >= 0 )
*out = *out * 60 + n;
}
}
return in;
}
static char* parse_time( char* in, int* out, int* result )
{
return next_field( parse_time_( in, out ), result );
}
static char* parse_name( char* in )
{
char* out = in;
while ( 1 )
{
int c = *in;
if ( !c ) break;
in++;
if ( c == ',' ) // commas in string
{
char* p = skip_white( in );
if ( *p == ',' || *p == '-' || from_dec( *p ) <= 9 )
{
in = p;
break;
}
}
if ( c == '\\' ) // \ prefix for special characters
{
c = *in;
if ( !c ) break;
in++;
}
*out++ = (char) c;
}
*out = 0; // terminate string
return in;
}
static int parse_line( char* in, M3u_Playlist::entry_t& entry )
{
int result = 0;
// file
entry.file = in;
entry.type = "";
in = parse_filename( in, entry );
// track
entry.track = -1;
entry.decimal_track = 0;
in = parse_track( in, entry, &result );
// name
entry.name = in;
in = parse_name( in );
// time
entry.length = -1;
in = parse_time( in, &entry.length, &result );
// loop
entry.intro = -1;
entry.loop = -1;
if ( *in == '-' )
{
entry.loop = entry.length;
in++;
}
else
{
in = parse_time_( in, &entry.loop );
if ( entry.loop >= 0 )
{
entry.intro = 0;
if ( *in == '-' ) // trailing '-' means that intro length was specified
{
in++;
entry.intro = entry.loop;
entry.loop = entry.length - entry.intro;
}
}
}
in = next_field( in, &result );
// fade
entry.fade = -1;
in = parse_time( in, &entry.fade, &result );
// repeat
entry.repeat = -1;
in = parse_int( in, &entry.repeat, &result );
return result;
}
static void parse_comment( char* in, M3u_Playlist::info_t& info, bool first )
{
in = skip_white( in + 1 );
const char* field = in;
while ( *in && *in != ':' )
in++;
if ( *in == ':' )
{
const char* text = skip_white( in + 1 );
if ( *text )
{
*in = 0;
if ( !strcmp( "Composer", field ) ) info.composer = text;
else if ( !strcmp( "Engineer", field ) ) info.engineer = text;
else if ( !strcmp( "Ripping" , field ) ) info.ripping = text;
else if ( !strcmp( "Tagging" , field ) ) info.tagging = text;
else
text = 0;
if ( text )
return;
*in = ':';
}
}
if ( first )
info.title = field;
}
blargg_err_t M3u_Playlist::parse_()
{
info_.title = "";
info_.composer = "";
info_.engineer = "";
info_.ripping = "";
info_.tagging = "";
int const CR = 13;
int const LF = 10;
data.end() [-1] = LF; // terminate input
first_error_ = 0;
bool first_comment = true;
int line = 0;
int count = 0;
char* in = data.begin();
while ( in < data.end() )
{
// find end of line and terminate it
line++;
char* begin = in;
while ( *in != CR && *in != LF )
{
if ( !*in )
return "Not an m3u playlist";
in++;
}
if ( in [0] == CR && in [1] == LF ) // treat CR,LF as a single line
*in++ = 0;
*in++ = 0;
// parse line
if ( *begin == '#' )
{
parse_comment( begin, info_, first_comment );
first_comment = false;
}
else if ( *begin )
{
if ( (int) entries.size() <= count )
RETURN_ERR( entries.resize( count * 2 + 64 ) );
if ( !parse_line( begin, entries [count] ) )
count++;
else if ( !first_error_ )
first_error_ = line;
first_comment = false;
}
}
if ( count <= 0 )
return "Not an m3u playlist";
if ( !(info_.composer [0] | info_.engineer [0] | info_.ripping [0] | info_.tagging [0]) )
info_.title = "";
return entries.resize( count );
}
blargg_err_t M3u_Playlist::parse()
{
blargg_err_t err = parse_();
if ( err )
{
entries.clear();
data.clear();
}
return err;
}
blargg_err_t M3u_Playlist::load( Data_Reader& in )
{
RETURN_ERR( data.resize( in.remain() + 1 ) );
RETURN_ERR( in.read( data.begin(), data.size() - 1 ) );
return parse();
}
blargg_err_t M3u_Playlist::load( const char* path )
{
GME_FILE_READER in;
RETURN_ERR( in.open( path ) );
return load( in );
}
blargg_err_t M3u_Playlist::load( void const* in, long size )
{
RETURN_ERR( data.resize( size + 1 ) );
memcpy( data.begin(), in, size );
return parse();
}
diff --git a/src/libs/gme/M3u_Playlist.h b/src/libs/gme/M3u_Playlist.h
index 266a0653..6757b7cf 100644
--- a/src/libs/gme/M3u_Playlist.h
+++ b/src/libs/gme/M3u_Playlist.h
@@ -1,67 +1,67 @@
// M3U playlist file parser, with support for subtrack information
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef M3U_PLAYLIST_H
#define M3U_PLAYLIST_H
#include "blargg_common.h"
#include "Data_Reader.h"
class M3u_Playlist {
public:
// Load playlist data
blargg_err_t load( const char* path );
blargg_err_t load( Data_Reader& in );
blargg_err_t load( void const* data, long size );
// Line number of first parse error, 0 if no error. Any lines with parse
// errors are ignored.
int first_error() const { return first_error_; }
struct info_t
{
const char* title;
const char* composer;
const char* engineer;
const char* ripping;
const char* tagging;
};
info_t const& info() const { return info_; }
struct entry_t
{
const char* file; // filename without stupid ::TYPE suffix
const char* type; // if filename has ::TYPE suffix, this will be "TYPE". "" if none.
const char* name;
bool decimal_track; // true if track was specified in hex
// integers are -1 if not present
int track; // 1-based
int length; // seconds
int intro;
int loop;
int fade;
int repeat; // count
};
entry_t const& operator [] ( int i ) const { return entries [i]; }
int size() const { return entries.size(); }
void clear();
private:
blargg_vector<entry_t> entries;
blargg_vector<char> data;
int first_error_;
info_t info_;
blargg_err_t parse();
blargg_err_t parse_();
};
inline void M3u_Playlist::clear()
{
first_error_ = 0;
entries.clear();
data.clear();
}
#endif
diff --git a/src/libs/gme/Multi_Buffer.cpp b/src/libs/gme/Multi_Buffer.cpp
index 57f93b31..5f000cee 100644
--- a/src/libs/gme/Multi_Buffer.cpp
+++ b/src/libs/gme/Multi_Buffer.cpp
@@ -1,232 +1,232 @@
// Blip_Buffer 0.4.1. http://www.slack.net/~ant/
#include "Multi_Buffer.h"
/* Copyright (C) 2003-2006 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"
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
Multi_Buffer::Multi_Buffer( int spf ) : samples_per_frame_( spf )
{
length_ = 0;
sample_rate_ = 0;
channels_changed_count_ = 1;
}
blargg_err_t Multi_Buffer::set_channel_count( int ) { return 0; }
// Silent_Buffer
Silent_Buffer::Silent_Buffer() : Multi_Buffer( 1 ) // 0 channels would probably confuse
{
// TODO: better to use empty Blip_Buffer so caller never has to check for NULL?
chan.left = 0;
chan.center = 0;
chan.right = 0;
}
// Mono_Buffer
Mono_Buffer::Mono_Buffer() : Multi_Buffer( 1 )
{
chan.center = &buf;
chan.left = &buf;
chan.right = &buf;
}
Mono_Buffer::~Mono_Buffer() { }
blargg_err_t Mono_Buffer::set_sample_rate( long rate, int msec )
{
RETURN_ERR( buf.set_sample_rate( rate, msec ) );
return Multi_Buffer::set_sample_rate( buf.sample_rate(), buf.length() );
}
// Stereo_Buffer
Stereo_Buffer::Stereo_Buffer() : Multi_Buffer( 2 )
{
chan.center = &bufs [0];
chan.left = &bufs [1];
chan.right = &bufs [2];
}
Stereo_Buffer::~Stereo_Buffer() { }
blargg_err_t Stereo_Buffer::set_sample_rate( long rate, int msec )
{
for ( int i = 0; i < buf_count; i++ )
RETURN_ERR( bufs [i].set_sample_rate( rate, msec ) );
return Multi_Buffer::set_sample_rate( bufs [0].sample_rate(), bufs [0].length() );
}
void Stereo_Buffer::clock_rate( long rate )
{
for ( int i = 0; i < buf_count; i++ )
bufs [i].clock_rate( rate );
}
void Stereo_Buffer::bass_freq( int bass )
{
- for ( unsigned i = 0; i < buf_count; i++ )
+ for ( int i = 0; i < buf_count; i++ )
bufs [i].bass_freq( bass );
}
void Stereo_Buffer::clear()
{
stereo_added = 0;
was_stereo = false;
for ( int i = 0; i < buf_count; i++ )
bufs [i].clear();
}
void Stereo_Buffer::end_frame( blip_time_t clock_count )
{
stereo_added = 0;
- for ( unsigned i = 0; i < buf_count; i++ )
+ for ( int i = 0; i < buf_count; i++ )
{
stereo_added |= bufs [i].clear_modified() << i;
bufs [i].end_frame( clock_count );
}
}
long Stereo_Buffer::read_samples( blip_sample_t* out, long count )
{
require( !(count & 1) ); // count must be even
count = (unsigned) count / 2;
long avail = bufs [0].samples_avail();
if ( count > avail )
count = avail;
if ( count )
{
int bufs_used = stereo_added | was_stereo;
//debug_printf( "%X\n", bufs_used );
if ( bufs_used <= 1 )
{
mix_mono( out, count );
bufs [0].remove_samples( count );
bufs [1].remove_silence( count );
bufs [2].remove_silence( count );
}
else if ( bufs_used & 1 )
{
mix_stereo( out, count );
bufs [0].remove_samples( count );
bufs [1].remove_samples( count );
bufs [2].remove_samples( count );
}
else
{
mix_stereo_no_center( out, count );
bufs [0].remove_silence( count );
bufs [1].remove_samples( count );
bufs [2].remove_samples( count );
}
// to do: this might miss opportunities for optimization
if ( !bufs [0].samples_avail() )
{
was_stereo = stereo_added;
stereo_added = 0;
}
}
return count * 2;
}
void Stereo_Buffer::mix_stereo( blip_sample_t* out_, blargg_long count )
{
blip_sample_t* BLIP_RESTRICT out = out_;
int const bass = BLIP_READER_BASS( bufs [1] );
BLIP_READER_BEGIN( left, bufs [1] );
BLIP_READER_BEGIN( right, bufs [2] );
BLIP_READER_BEGIN( center, bufs [0] );
for ( ; count; --count )
{
int c = BLIP_READER_READ( center );
blargg_long l = c + BLIP_READER_READ( left );
blargg_long r = c + BLIP_READER_READ( right );
- if ( (BOOST::int16_t) l != l )
+ if ( (int16_t) l != l )
l = 0x7FFF - (l >> 24);
BLIP_READER_NEXT( center, bass );
- if ( (BOOST::int16_t) r != r )
+ if ( (int16_t) r != r )
r = 0x7FFF - (r >> 24);
BLIP_READER_NEXT( left, bass );
BLIP_READER_NEXT( right, bass );
out [0] = l;
out [1] = r;
out += 2;
}
BLIP_READER_END( center, bufs [0] );
BLIP_READER_END( right, bufs [2] );
BLIP_READER_END( left, bufs [1] );
}
void Stereo_Buffer::mix_stereo_no_center( blip_sample_t* out_, blargg_long count )
{
blip_sample_t* BLIP_RESTRICT out = out_;
int const bass = BLIP_READER_BASS( bufs [1] );
BLIP_READER_BEGIN( left, bufs [1] );
BLIP_READER_BEGIN( right, bufs [2] );
for ( ; count; --count )
{
blargg_long l = BLIP_READER_READ( left );
- if ( (BOOST::int16_t) l != l )
+ if ( (int16_t) l != l )
l = 0x7FFF - (l >> 24);
blargg_long r = BLIP_READER_READ( right );
- if ( (BOOST::int16_t) r != r )
+ if ( (int16_t) r != r )
r = 0x7FFF - (r >> 24);
BLIP_READER_NEXT( left, bass );
BLIP_READER_NEXT( right, bass );
out [0] = l;
out [1] = r;
out += 2;
}
BLIP_READER_END( right, bufs [2] );
BLIP_READER_END( left, bufs [1] );
}
void Stereo_Buffer::mix_mono( blip_sample_t* out_, blargg_long count )
{
blip_sample_t* BLIP_RESTRICT out = out_;
int const bass = BLIP_READER_BASS( bufs [0] );
BLIP_READER_BEGIN( center, bufs [0] );
for ( ; count; --count )
{
blargg_long s = BLIP_READER_READ( center );
- if ( (BOOST::int16_t) s != s )
+ if ( (int16_t) s != s )
s = 0x7FFF - (s >> 24);
BLIP_READER_NEXT( center, bass );
out [0] = s;
out [1] = s;
out += 2;
}
BLIP_READER_END( center, bufs [0] );
}
diff --git a/src/libs/gme/Music_Emu.cpp b/src/libs/gme/Music_Emu.cpp
index 5db66fb9..66ffa2d9 100644
--- a/src/libs/gme/Music_Emu.cpp
+++ b/src/libs/gme/Music_Emu.cpp
@@ -1,410 +1,439 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Music_Emu.h"
#include "Multi_Buffer.h"
#include <string.h>
/* Copyright (C) 2003-2006 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; // number of channels for stereo
int const silence_max = 6; // seconds
int const silence_threshold = 0x10;
long const fade_block_size = 512;
int const fade_shift = 8; // fade ends with gain at 1.0 / (1 << fade_shift)
-Music_Emu::equalizer_t const Music_Emu::tv_eq = { -8.0, 180 };
+Music_Emu::equalizer_t const Music_Emu::tv_eq =
+ Music_Emu::make_equalizer( -8.0, 180 );
void Music_Emu::clear_track_vars()
{
current_track_ = -1;
out_time = 0;
emu_time = 0;
emu_track_ended_ = true;
track_ended_ = true;
fade_start = INT_MAX / 2 + 1;
fade_step = 1;
silence_time = 0;
silence_count = 0;
buf_remain = 0;
warning(); // clear warning
}
void Music_Emu::unload()
{
voice_count_ = 0;
clear_track_vars();
Gme_File::unload();
}
Music_Emu::Music_Emu()
{
effects_buffer = 0;
-
+ multi_channel_ = false;
sample_rate_ = 0;
mute_mask_ = 0;
tempo_ = 1.0;
gain_ = 1.0;
// defaults
max_initial_silence = 2;
silence_lookahead = 3;
ignore_silence_ = false;
equalizer_.treble = -1.0;
equalizer_.bass = 60;
static const char* const names [] = {
"Voice 1", "Voice 2", "Voice 3", "Voice 4",
"Voice 5", "Voice 6", "Voice 7", "Voice 8"
};
set_voice_names( names );
Music_Emu::unload(); // non-virtual
}
Music_Emu::~Music_Emu() { delete effects_buffer; }
blargg_err_t Music_Emu::set_sample_rate( long rate )
{
require( !sample_rate() ); // sample rate can't be changed once set
RETURN_ERR( set_sample_rate_( rate ) );
RETURN_ERR( buf.resize( buf_size ) );
sample_rate_ = rate;
return 0;
}
void Music_Emu::pre_load()
{
require( sample_rate() ); // set_sample_rate() must be called before loading a file
Gme_File::pre_load();
}
void Music_Emu::set_equalizer( equalizer_t const& eq )
{
equalizer_ = eq;
set_equalizer_( eq );
}
+bool Music_Emu::multi_channel() const
+{
+ return this->multi_channel_;
+}
+
+blargg_err_t Music_Emu::set_multi_channel( bool )
+{
+ // by default not supported, derived may override this
+ return "unsupported for this emulator type";
+}
+
+blargg_err_t Music_Emu::set_multi_channel_( bool isEnabled )
+{
+ // multi channel support must be set at the very beginning
+ require( !sample_rate() );
+ multi_channel_ = isEnabled;
+ return 0;
+}
+
void Music_Emu::mute_voice( int index, bool mute )
{
require( (unsigned) index < (unsigned) voice_count() );
int bit = 1 << index;
int mask = mute_mask_ | bit;
if ( !mute )
mask ^= bit;
mute_voices( mask );
}
void Music_Emu::mute_voices( int mask )
{
require( sample_rate() ); // sample rate must be set first
mute_mask_ = mask;
mute_voices_( mask );
}
void Music_Emu::set_tempo( double t )
{
require( sample_rate() ); // sample rate must be set first
double const min = 0.02;
double const max = 4.00;
if ( t < min ) t = min;
if ( t > max ) t = max;
tempo_ = t;
set_tempo_( t );
}
void Music_Emu::post_load_()
{
set_tempo( tempo_ );
remute_voices();
}
blargg_err_t Music_Emu::start_track( int track )
{
clear_track_vars();
int remapped = track;
RETURN_ERR( remap_track_( &remapped ) );
current_track_ = track;
RETURN_ERR( start_track_( remapped ) );
emu_track_ended_ = false;
track_ended_ = false;
if ( !ignore_silence_ )
{
// play until non-silence or end of track
- for ( long end = max_initial_silence * stereo * sample_rate(); emu_time < end; )
+ for ( long end = max_initial_silence * out_channels() * sample_rate(); emu_time < end; )
{
fill_buf();
if ( buf_remain | (int) emu_track_ended_ )
break;
}
emu_time = buf_remain;
out_time = 0;
silence_time = 0;
silence_count = 0;
}
return track_ended() ? warning() : 0;
}
void Music_Emu::end_track_if_error( blargg_err_t err )
{
if ( err )
{
emu_track_ended_ = true;
set_warning( err );
}
}
// Tell/Seek
blargg_long Music_Emu::msec_to_samples( blargg_long msec ) const
{
blargg_long sec = msec / 1000;
msec -= sec * 1000;
- return (sec * sample_rate() + msec * sample_rate() / 1000) * stereo;
+ return (sec * sample_rate() + msec * sample_rate() / 1000) * out_channels();
+}
+
+long Music_Emu::tell_samples() const
+{
+ return out_time;
}
long Music_Emu::tell() const
{
- blargg_long rate = sample_rate() * stereo;
+ blargg_long rate = sample_rate() * out_channels();
blargg_long sec = out_time / rate;
return sec * 1000 + (out_time - sec * rate) * 1000 / rate;
}
-blargg_err_t Music_Emu::seek( long msec )
+blargg_err_t Music_Emu::seek_samples( long time )
{
- blargg_long time = msec_to_samples( msec );
if ( time < out_time )
RETURN_ERR( start_track( current_track_ ) );
return skip( time - out_time );
}
+blargg_err_t Music_Emu::seek( long msec )
+{
+ return seek_samples( msec_to_samples( msec ) );
+}
+
blargg_err_t Music_Emu::skip( long count )
{
require( current_track() >= 0 ); // start_track() must have been called already
out_time += count;
// remove from silence and buf first
{
long n = min( count, silence_count );
silence_count -= n;
count -= n;
n = min( count, buf_remain );
buf_remain -= n;
count -= n;
}
if ( count && !emu_track_ended_ )
{
emu_time += count;
end_track_if_error( skip_( count ) );
}
if ( !(silence_count | buf_remain) ) // caught up to emulator, so update track ended
track_ended_ |= emu_track_ended_;
return 0;
}
blargg_err_t Music_Emu::skip_( long count )
{
// for long skip, mute sound
const long threshold = 30000;
if ( count > threshold )
{
int saved_mute = mute_mask_;
mute_voices( ~0 );
while ( count > threshold / 2 && !emu_track_ended_ )
{
RETURN_ERR( play_( buf_size, buf.begin() ) );
count -= buf_size;
}
mute_voices( saved_mute );
}
while ( count && !emu_track_ended_ )
{
long n = buf_size;
if ( n > count )
n = count;
count -= n;
RETURN_ERR( play_( n, buf.begin() ) );
}
return 0;
}
// Fading
void Music_Emu::set_fade( long start_msec, long length_msec )
{
- fade_step = sample_rate() * length_msec / (fade_block_size * fade_shift * 1000 / stereo);
+ fade_step = sample_rate() * length_msec / (fade_block_size * fade_shift * 1000 / out_channels());
fade_start = msec_to_samples( start_msec );
}
// unit / pow( 2.0, (double) x / step )
static int int_log( blargg_long x, int step, int unit )
{
int shift = x / step;
int fraction = (x - shift * step) * unit / step;
return ((unit - fraction) + (fraction >> 1)) >> shift;
}
void Music_Emu::handle_fade( long out_count, sample_t* out )
{
for ( int i = 0; i < out_count; i += fade_block_size )
{
int const shift = 14;
int const unit = 1 << shift;
int gain = int_log( (out_time + i - fade_start) / fade_block_size,
fade_step, unit );
if ( gain < (unit >> fade_shift) )
track_ended_ = emu_track_ended_ = true;
sample_t* io = &out [i];
for ( int count = min( fade_block_size, out_count - i ); count; --count )
{
*io = sample_t ((*io * gain) >> shift);
++io;
}
}
}
// Silence detection
void Music_Emu::emu_play( long count, sample_t* out )
{
check( current_track_ >= 0 );
emu_time += count;
if ( current_track_ >= 0 && !emu_track_ended_ )
end_track_if_error( play_( count, out ) );
else
memset( out, 0, count * sizeof *out );
}
// number of consecutive silent samples at end
static long count_silence( Music_Emu::sample_t* begin, long size )
{
Music_Emu::sample_t first = *begin;
*begin = silence_threshold; // sentinel
Music_Emu::sample_t* p = begin + size;
while ( (unsigned) (*--p + silence_threshold / 2) <= (unsigned) silence_threshold ) { }
*begin = first;
return size - (p - begin);
}
// fill internal buffer and check it for silence
void Music_Emu::fill_buf()
{
assert( !buf_remain );
if ( !emu_track_ended_ )
{
emu_play( buf_size, buf.begin() );
long silence = count_silence( buf.begin(), buf_size );
if ( silence < buf_size )
{
silence_time = emu_time - silence;
buf_remain = buf_size;
return;
}
}
silence_count += buf_size;
}
blargg_err_t Music_Emu::play( long out_count, sample_t* out )
{
if ( track_ended_ )
{
memset( out, 0, out_count * sizeof *out );
}
else
{
require( current_track() >= 0 );
- require( out_count % stereo == 0 );
+ require( out_count % out_channels() == 0 );
assert( emu_time >= out_time );
// prints nifty graph of how far ahead we are when searching for silence
//debug_printf( "%*s \n", int ((emu_time - out_time) * 7 / sample_rate()), "*" );
long pos = 0;
if ( silence_count )
{
// during a run of silence, run emulator at >=2x speed so it gets ahead
long ahead_time = silence_lookahead * (out_time + out_count - silence_time) + silence_time;
while ( emu_time < ahead_time && !(buf_remain | emu_track_ended_) )
fill_buf();
// fill with silence
pos = min( silence_count, out_count );
memset( out, 0, pos * sizeof *out );
silence_count -= pos;
- if ( emu_time - silence_time > silence_max * stereo * sample_rate() )
+ if ( emu_time - silence_time > silence_max * out_channels() * sample_rate() )
{
track_ended_ = emu_track_ended_ = true;
silence_count = 0;
buf_remain = 0;
}
}
if ( buf_remain )
{
// empty silence buf
long n = min( buf_remain, out_count - pos );
memcpy( &out [pos], buf.begin() + (buf_size - buf_remain), n * sizeof *out );
buf_remain -= n;
pos += n;
}
// generate remaining samples normally
long remain = out_count - pos;
if ( remain )
{
emu_play( remain, out + pos );
track_ended_ |= emu_track_ended_;
if ( !ignore_silence_ || out_time > fade_start )
{
// check end for a new run of silence
long silence = count_silence( out + pos, remain );
if ( silence < remain )
silence_time = emu_time - silence;
if ( emu_time - silence_time >= buf_size )
fill_buf(); // cause silence detection on next play()
}
}
- if ( out_time > fade_start )
+ if ( fade_start >= 0 && out_time > fade_start )
handle_fade( out_count, out );
}
out_time += out_count;
return 0;
}
// Gme_Info_
blargg_err_t Gme_Info_::set_sample_rate_( long ) { return 0; }
void Gme_Info_::pre_load() { Gme_File::pre_load(); } // skip Music_Emu
void Gme_Info_::post_load_() { Gme_File::post_load_(); } // skip Music_Emu
void Gme_Info_::set_equalizer_( equalizer_t const& ){ check( false ); }
+void Gme_Info_::enable_accuracy_( bool ) { check( false ); }
void Gme_Info_::mute_voices_( int ) { check( false ); }
void Gme_Info_::set_tempo_( double ) { }
blargg_err_t Gme_Info_::start_track_( int ) { return "Use full emulator for playback"; }
blargg_err_t Gme_Info_::play_( long, sample_t* ) { return "Use full emulator for playback"; }
diff --git a/src/libs/gme/Music_Emu.h b/src/libs/gme/Music_Emu.h
index c3d4d8db..ee0f8379 100644
--- a/src/libs/gme/Music_Emu.h
+++ b/src/libs/gme/Music_Emu.h
@@ -1,211 +1,244 @@
// Common interface to game music file emulators
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef MUSIC_EMU_H
#define MUSIC_EMU_H
#include "Gme_File.h"
class Multi_Buffer;
-class Music_Emu : public Gme_File {
+struct Music_Emu : public Gme_File {
public:
// Basic functionality (see Gme_File.h for file loading/track info functions)
// Set output sample rate. Must be called only once before loading file.
blargg_err_t set_sample_rate( long sample_rate );
+
+ // specifies if all 8 voices get rendered to their own stereo channel
+ // default implementation of Music_Emu always returns not supported error (i.e. no multichannel support by default)
+ // derived emus must override this if they support multichannel rendering
+ virtual blargg_err_t set_multi_channel( bool is_enabled );
// Start a track, where 0 is the first track. Also clears warning string.
blargg_err_t start_track( int );
// Generate 'count' samples info 'buf'. Output is in stereo. Any emulation
// errors set warning string, and major errors also end track.
typedef short sample_t;
blargg_err_t play( long count, sample_t* buf );
// Informational
// Sample rate sound is generated at
long sample_rate() const;
// Index of current track or -1 if one hasn't been started
int current_track() const;
// Number of voices used by currently loaded file
int voice_count() const;
// Names of voices
const char** voice_names() const;
+
+ bool multi_channel() const;
// Track status/control
// Number of milliseconds (1000 msec = 1 second) played since beginning of track
long tell() const;
+ // Number of samples generated since beginning of track
+ long tell_samples() const;
+
// Seek to new time in track. Seeking backwards or far forward can take a while.
blargg_err_t seek( long msec );
+ // Equivalent to restarting track then skipping n samples
+ blargg_err_t seek_samples( long n );
+
// Skip n samples
blargg_err_t skip( long n );
// True if a track has reached its end
bool track_ended() const;
// Set start time and length of track fade out. Once fade ends track_ended() returns
// true. Fade time can be changed while track is playing.
void set_fade( long start_msec, long length_msec = 8000 );
// Disable automatic end-of-track detection and skipping of silence at beginning
void ignore_silence( bool disable = true );
// Info for current track
using Gme_File::track_info;
blargg_err_t track_info( track_info_t* out ) const;
// Sound customization
// Adjust song tempo, where 1.0 = normal, 0.5 = half speed, 2.0 = double speed.
// Track length as returned by track_info() assumes a tempo of 1.0.
void set_tempo( double );
// Mute/unmute voice i, where voice 0 is first voice
void mute_voice( int index, bool mute = true );
// Set muting state of all voices at once using a bit mask, where -1 mutes them all,
// 0 unmutes them all, 0x01 mutes just the first voice, etc.
void mute_voices( int mask );
// Change overall output amplitude, where 1.0 results in minimal clamping.
// Must be called before set_sample_rate().
void set_gain( double );
// Request use of custom multichannel buffer. Only supported by "classic" emulators;
// on others this has no effect. Should be called only once *before* set_sample_rate().
virtual void set_buffer( Multi_Buffer* ) { }
+ // Enables/disables accurate emulation options, if any are supported. Might change
+ // equalizer settings.
+ void enable_accuracy( bool enable = true );
+
// Sound equalization (treble/bass)
// Frequency equalizer parameters (see gme.txt)
// See gme.h for definition of struct gme_equalizer_t.
typedef gme_equalizer_t equalizer_t;
// Current frequency equalizater parameters
equalizer_t const& equalizer() const;
// Set frequency equalizer parameters
void set_equalizer( equalizer_t const& );
+
+ // Construct equalizer of given treble/bass settings
+ static const equalizer_t make_equalizer( double treble, double bass )
+ {
+ const Music_Emu::equalizer_t e = { treble, bass,
+ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
+ return e;
+ }
// Equalizer settings for TV speaker
static equalizer_t const tv_eq;
public:
Music_Emu();
~Music_Emu();
protected:
void set_max_initial_silence( int n ) { max_initial_silence = n; }
void set_silence_lookahead( int n ) { silence_lookahead = n; }
void set_voice_count( int n ) { voice_count_ = n; }
void set_voice_names( const char* const* names );
void set_track_ended() { emu_track_ended_ = true; }
double gain() const { return gain_; }
double tempo() const { return tempo_; }
void remute_voices();
+ blargg_err_t set_multi_channel_( bool is_enabled );
virtual blargg_err_t set_sample_rate_( long sample_rate ) = 0;
- virtual void set_equalizer_( equalizer_t const& ) { };
+ virtual void set_equalizer_( equalizer_t const& ) { }
+ virtual void enable_accuracy_( bool /* enable */ ) { }
virtual void mute_voices_( int mask ) = 0;
virtual void set_tempo_( double ) = 0;
virtual blargg_err_t start_track_( int ) = 0; // tempo is set before this
virtual blargg_err_t play_( long count, sample_t* out ) = 0;
virtual blargg_err_t skip_( long count );
protected:
virtual void unload();
virtual void pre_load();
virtual void post_load_();
private:
// general
equalizer_t equalizer_;
int max_initial_silence;
const char** voice_names_;
int voice_count_;
int mute_mask_;
double tempo_;
double gain_;
-
+ bool multi_channel_;
+
+ // returns the number of output channels, i.e. usually 2 for stereo, unlesss multi_channel_ == true
+ int out_channels() const { return this->multi_channel() ? 2*8 : 2; }
+
long sample_rate_;
blargg_long msec_to_samples( blargg_long msec ) const;
// track-specific
int current_track_;
blargg_long out_time; // number of samples played since start of track
blargg_long emu_time; // number of samples emulator has generated since start of track
bool emu_track_ended_; // emulator has reached end of track
volatile bool track_ended_;
void clear_track_vars();
void end_track_if_error( blargg_err_t );
// fading
blargg_long fade_start;
int fade_step;
void handle_fade( long count, sample_t* out );
// silence detection
int silence_lookahead; // speed to run emulator when looking ahead for silence
bool ignore_silence_;
long silence_time; // number of samples where most recent silence began
long silence_count; // number of samples of silence to play before using buf
long buf_remain; // number of samples left in silence buffer
enum { buf_size = 2048 };
blargg_vector<sample_t> buf;
void fill_buf();
void emu_play( long count, sample_t* out );
Multi_Buffer* effects_buffer;
- friend Music_Emu* gme_new_emu( gme_type_t, int );
+ friend Music_Emu* gme_internal_new_emu_( gme_type_t, int, bool );
friend void gme_set_stereo_depth( Music_Emu*, double );
};
// base class for info-only derivations
struct Gme_Info_ : Music_Emu
{
virtual blargg_err_t set_sample_rate_( long sample_rate );
virtual void set_equalizer_( equalizer_t const& );
+ virtual void enable_accuracy_( bool );
virtual void mute_voices_( int mask );
virtual void set_tempo_( double );
virtual blargg_err_t start_track_( int );
virtual blargg_err_t play_( long count, sample_t* out );
virtual void pre_load();
virtual void post_load_();
};
inline blargg_err_t Music_Emu::track_info( track_info_t* out ) const
{
return track_info( out, current_track_ );
}
inline long Music_Emu::sample_rate() const { return sample_rate_; }
inline const char** Music_Emu::voice_names() const { return voice_names_; }
inline int Music_Emu::voice_count() const { return voice_count_; }
inline int Music_Emu::current_track() const { return current_track_; }
inline bool Music_Emu::track_ended() const { return track_ended_; }
inline const Music_Emu::equalizer_t& Music_Emu::equalizer() const { return equalizer_; }
+inline void Music_Emu::enable_accuracy( bool b ) { enable_accuracy_( b ); }
inline void Music_Emu::set_tempo_( double t ) { tempo_ = t; }
inline void Music_Emu::remute_voices() { mute_voices( mute_mask_ ); }
inline void Music_Emu::ignore_silence( bool b ) { ignore_silence_ = b; }
inline blargg_err_t Music_Emu::start_track_( int ) { return 0; }
inline void Music_Emu::set_voice_names( const char* const* names )
{
// Intentional removal of const, so users don't have to remember obscure const in middle
voice_names_ = const_cast<const char**> (names);
}
inline void Music_Emu::mute_voices_( int ) { }
inline void Music_Emu::set_gain( double g )
{
assert( !sample_rate() ); // you must set gain before setting sample rate
gain_ = g;
}
#endif
diff --git a/src/libs/gme/Nes_Apu.h b/src/libs/gme/Nes_Apu.h
index dbef4c73..5e722248 100644
--- a/src/libs/gme/Nes_Apu.h
+++ b/src/libs/gme/Nes_Apu.h
@@ -1,325 +1,179 @@
// NES 2A03 APU sound chip emulator
// Nes_Snd_Emu 0.1.8
#ifndef NES_APU_H
#define NES_APU_H
#include "blargg_common.h"
typedef blargg_long nes_time_t; // CPU clock cycle count
typedef unsigned nes_addr_t; // 16-bit memory address
-// Private oscillators used by Nes_Apu
-
-// Nes_Snd_Emu 0.1.8
-#ifndef NES_OSCS_H
-#define NES_OSCS_H
-
-#include "blargg_common.h"
-#include "Blip_Buffer.h"
-
-class Nes_Apu;
-
-struct Nes_Osc
-{
- unsigned char regs [4];
- bool reg_written [4];
- Blip_Buffer* output;
- int length_counter;// length counter (0 if unused by oscillator)
- int delay; // delay until next (potential) transition
- int last_amp; // last amplitude oscillator was outputting
-
- void clock_length( int halt_mask );
- int period() const {
- return (regs [3] & 7) * 0x100 + (regs [2] & 0xFF);
- }
- void reset() {
- delay = 0;
- last_amp = 0;
- }
- int update_amp( int amp ) {
- int delta = amp - last_amp;
- last_amp = amp;
- return delta;
- }
-};
-
-struct Nes_Envelope : Nes_Osc
-{
- int envelope;
- int env_delay;
-
- void clock_envelope();
- int volume() const;
- void reset() {
- envelope = 0;
- env_delay = 0;
- Nes_Osc::reset();
- }
-};
-
-// Nes_Square
-struct Nes_Square : Nes_Envelope
-{
- enum { negate_flag = 0x08 };
- enum { shift_mask = 0x07 };
- enum { phase_range = 8 };
- int phase;
- int sweep_delay;
-
- typedef Blip_Synth<blip_good_quality,1> Synth;
- Synth const& synth; // shared between squares
-
- Nes_Square( Synth const* s ) : synth( *s ) { }
-
- void clock_sweep( int adjust );
- void run( nes_time_t, nes_time_t );
- void reset() {
- sweep_delay = 0;
- Nes_Envelope::reset();
- }
- nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
- nes_time_t timer_period );
-};
-
-// Nes_Triangle
-struct Nes_Triangle : Nes_Osc
-{
- enum { phase_range = 16 };
- int phase;
- int linear_counter;
- Blip_Synth<blip_med_quality,1> synth;
-
- int calc_amp() const;
- void run( nes_time_t, nes_time_t );
- void clock_linear_counter();
- void reset() {
- linear_counter = 0;
- phase = 1;
- Nes_Osc::reset();
- }
- nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
- nes_time_t timer_period );
-};
-
-// Nes_Noise
-struct Nes_Noise : Nes_Envelope
-{
- int noise;
- Blip_Synth<blip_med_quality,1> synth;
-
- void run( nes_time_t, nes_time_t );
- void reset() {
- noise = 1 << 14;
- Nes_Envelope::reset();
- }
-};
-
-// Nes_Dmc
-struct Nes_Dmc : Nes_Osc
-{
- int address; // address of next byte to read
- int period;
- //int length_counter; // bytes remaining to play (already defined in Nes_Osc)
- int buf;
- int bits_remain;
- int bits;
- bool buf_full;
- bool silence;
-
- enum { loop_flag = 0x40 };
-
- int dac;
-
- nes_time_t next_irq;
- bool irq_enabled;
- bool irq_flag;
- bool pal_mode;
- bool nonlinear;
-
- int (*prg_reader)( void*, nes_addr_t ); // needs to be initialized to prg read function
- void* prg_reader_data;
-
- Nes_Apu* apu;
-
- Blip_Synth<blip_med_quality,1> synth;
-
- void start();
- void write_register( int, int );
- void run( nes_time_t, nes_time_t );
- void recalc_irq();
- void fill_buffer();
- void reload_sample();
- void reset();
- int count_reads( nes_time_t, nes_time_t* ) const;
- nes_time_t next_read_time() const;
-};
-
-#endif
+#include "Nes_Oscs.h"
struct apu_state_t;
class Nes_Buffer;
class Nes_Apu {
public:
// Set buffer to generate all sound into, or disable sound if NULL
void output( Blip_Buffer* );
// Set memory reader callback used by DMC oscillator to fetch samples.
// When callback is invoked, 'user_data' is passed unchanged as the
// first parameter.
void dmc_reader( int (*callback)( void* user_data, nes_addr_t ), void* user_data = NULL );
// All time values are the number of CPU clock cycles relative to the
// beginning of the current time frame. Before resetting the CPU clock
// count, call end_frame( last_cpu_time ).
// Write to register (0x4000-0x4017, except 0x4014 and 0x4016)
enum { start_addr = 0x4000 };
enum { end_addr = 0x4017 };
void write_register( nes_time_t, nes_addr_t, int data );
// Read from status register at 0x4015
enum { status_addr = 0x4015 };
int read_status( nes_time_t );
// Run all oscillators up to specified time, end current time frame, then
// start a new time frame at time 0. Time frames have no effect on emulation
// and each can be whatever length is convenient.
void end_frame( nes_time_t );
// Additional optional features (can be ignored without any problem)
// Reset internal frame counter, registers, and all oscillators.
// Use PAL timing if pal_timing is true, otherwise use NTSC timing.
// Set the DMC oscillator's initial DAC value to initial_dmc_dac without
// any audible click.
void reset( bool pal_mode = false, int initial_dmc_dac = 0 );
// Adjust frame period
void set_tempo( double );
// Save/load exact emulation state
void save_state( apu_state_t* out ) const;
void load_state( apu_state_t const& );
// Set overall volume (default is 1.0)
void volume( double );
// Set treble equalization (see notes.txt)
void treble_eq( const blip_eq_t& );
// Set sound output of specific oscillator to buffer. If buffer is NULL,
// the specified oscillator is muted and emulation accuracy is reduced.
// The oscillators are indexed as follows: 0) Square 1, 1) Square 2,
// 2) Triangle, 3) Noise, 4) DMC.
enum { osc_count = 5 };
void osc_output( int index, Blip_Buffer* buffer );
// Set IRQ time callback that is invoked when the time of earliest IRQ
// may have changed, or NULL to disable. When callback is invoked,
// 'user_data' is passed unchanged as the first parameter.
void irq_notifier( void (*callback)( void* user_data ), void* user_data = NULL );
// Get time that APU-generated IRQ will occur if no further register reads
// or writes occur. If IRQ is already pending, returns irq_waiting. If no
// IRQ will occur, returns no_irq.
enum { no_irq = INT_MAX / 2 + 1 };
enum { irq_waiting = 0 };
nes_time_t earliest_irq( nes_time_t ) const;
// Count number of DMC reads that would occur if 'run_until( t )' were executed.
// If last_read is not NULL, set *last_read to the earliest time that
// 'count_dmc_reads( time )' would result in the same result.
int count_dmc_reads( nes_time_t t, nes_time_t* last_read = NULL ) const;
// Time when next DMC memory read will occur
nes_time_t next_dmc_read_time() const;
// Run DMC until specified time, so that any DMC memory reads can be
// accounted for (i.e. inserting CPU wait states).
void run_until( nes_time_t );
public:
Nes_Apu();
BLARGG_DISABLE_NOTHROW
private:
friend class Nes_Nonlinearizer;
void enable_nonlinear( double volume );
static double nonlinear_tnd_gain() { return 0.75; }
private:
friend struct Nes_Dmc;
// noncopyable
Nes_Apu( const Nes_Apu& );
Nes_Apu& operator = ( const Nes_Apu& );
Nes_Osc* oscs [osc_count];
Nes_Square square1;
Nes_Square square2;
Nes_Noise noise;
Nes_Triangle triangle;
Nes_Dmc dmc;
double tempo_;
nes_time_t last_time; // has been run until this time in current frame
nes_time_t last_dmc_time;
nes_time_t earliest_irq_;
nes_time_t next_irq;
int frame_period;
int frame_delay; // cycles until frame counter runs next
int frame; // current frame (0-3)
int osc_enables;
int frame_mode;
bool irq_flag;
void (*irq_notifier_)( void* user_data );
void* irq_data;
Nes_Square::Synth square_synth; // shared by squares
void irq_changed();
void state_restored();
void run_until_( nes_time_t );
// TODO: remove
friend class Nes_Core;
};
inline void Nes_Apu::osc_output( int osc, Blip_Buffer* buf )
{
assert( (unsigned) osc < osc_count );
oscs [osc]->output = buf;
}
inline nes_time_t Nes_Apu::earliest_irq( nes_time_t ) const
{
return earliest_irq_;
}
inline void Nes_Apu::dmc_reader( int (*func)( void*, nes_addr_t ), void* user_data )
{
dmc.prg_reader_data = user_data;
dmc.prg_reader = func;
}
inline void Nes_Apu::irq_notifier( void (*func)( void* user_data ), void* user_data )
{
irq_notifier_ = func;
irq_data = user_data;
}
inline int Nes_Apu::count_dmc_reads( nes_time_t time, nes_time_t* last_read ) const
{
return dmc.count_reads( time, last_read );
}
inline nes_time_t Nes_Dmc::next_read_time() const
{
if ( length_counter == 0 )
return Nes_Apu::no_irq; // not reading
return apu->last_dmc_time + delay + long (bits_remain - 1) * period;
}
inline nes_time_t Nes_Apu::next_dmc_read_time() const { return dmc.next_read_time(); }
#endif
diff --git a/src/libs/gme/Nes_Cpu.cpp b/src/libs/gme/Nes_Cpu.cpp
index 864e0dde..5eb0862a 100644
--- a/src/libs/gme/Nes_Cpu.cpp
+++ b/src/libs/gme/Nes_Cpu.cpp
@@ -1,1084 +1,1073 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Nes_Cpu.h"
#include "blargg_endian.h"
#include <limits.h>
#define BLARGG_CPU_X86 1
/* Copyright (C) 2003-2006 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 */
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
#define FLUSH_TIME() (void) (s.time = s_time)
#define CACHE_TIME() (void) (s_time = s.time)
#include "nes_cpu_io.h"
#include "blargg_source.h"
#ifndef CPU_DONE
#define CPU_DONE( cpu, time, result_out ) { result_out = -1; }
#endif
#ifndef CPU_READ_PPU
#define CPU_READ_PPU( cpu, addr, out, time )\
{\
FLUSH_TIME();\
out = CPU_READ( cpu, addr, time );\
CACHE_TIME();\
}
#endif
#if BLARGG_NONPORTABLE
#define PAGE_OFFSET( addr ) (addr)
#else
#define PAGE_OFFSET( addr ) ((addr) & (page_size - 1))
#endif
inline void Nes_Cpu::set_code_page( int i, void const* p )
{
state->code_map [i] = (uint8_t const*) p - PAGE_OFFSET( i * page_size );
}
int const st_n = 0x80;
int const st_v = 0x40;
int const st_r = 0x20;
int const st_b = 0x10;
int const st_d = 0x08;
int const st_i = 0x04;
int const st_z = 0x02;
int const st_c = 0x01;
void Nes_Cpu::reset( void const* unmapped_page )
{
check( state == &state_ );
state = &state_;
r.status = st_i;
r.sp = 0xFF;
r.pc = 0;
r.a = 0;
r.x = 0;
r.y = 0;
state_.time = 0;
state_.base = 0;
irq_time_ = future_nes_time;
end_time_ = future_nes_time;
error_count_ = 0;
assert( page_size == 0x800 ); // assumes this
set_code_page( page_count, unmapped_page );
map_code( 0x2000, 0xE000, unmapped_page, true );
map_code( 0x0000, 0x2000, low_mem, true );
blargg_verify_byte_order();
}
void Nes_Cpu::map_code( nes_addr_t start, unsigned size, void const* data, bool mirror )
{
// address range must begin and end on page boundaries
require( start % page_size == 0 );
require( size % page_size == 0 );
require( start + size <= 0x10000 );
unsigned page = start / page_size;
for ( unsigned n = size / page_size; n; --n )
{
set_code_page( page++, data );
if ( !mirror )
data = (char const*) data + page_size;
}
}
#define TIME (s_time + s.base)
#define READ_LIKELY_PPU( addr, out ) {CPU_READ_PPU( this, (addr), out, TIME );}
#define READ( addr ) CPU_READ( this, (addr), TIME )
#define WRITE( addr, data ) {CPU_WRITE( this, (addr), (data), TIME );}
#define READ_LOW( addr ) (low_mem [int (addr)])
#define WRITE_LOW( addr, data ) (void) (READ_LOW( addr ) = (data))
#define READ_PROG( addr ) (s.code_map [(addr) >> page_bits] [PAGE_OFFSET( addr )])
#define SET_SP( v ) (sp = ((v) + 1) | 0x100)
#define GET_SP() ((sp - 1) & 0xFF)
#define PUSH( v ) ((sp = (sp - 1) | 0x100), WRITE_LOW( sp, v ))
-// even on x86, using short and unsigned char was slower
-typedef int fint16;
-typedef unsigned fuint16;
-typedef unsigned fuint8;
-
bool Nes_Cpu::run( nes_time_t end_time )
{
set_end_time( end_time );
state_t s = this->state_;
this->state = &s;
// even on x86, using s.time in place of s_time was slower
- fint16 s_time = s.time;
+ int16_t s_time = s.time;
// registers
- fuint16 pc = r.pc;
- fuint8 a = r.a;
- fuint8 x = r.x;
- fuint8 y = r.y;
- fuint16 sp;
+ uint16_t pc = r.pc;
+ uint8_t a = r.a;
+ uint8_t x = r.x;
+ uint8_t y = r.y;
+ uint16_t sp;
SET_SP( r.sp );
// status flags
#define IS_NEG (nz & 0x8080)
#define CALC_STATUS( out ) do {\
out = status & (st_v | st_d | st_i);\
out |= ((nz >> 8) | nz) & st_n;\
out |= c >> 8 & st_c;\
if ( !(nz & 0xFF) ) out |= st_z;\
} while ( 0 )
#define SET_STATUS( in ) do {\
status = in & (st_v | st_d | st_i);\
nz = in << 8;\
c = nz;\
nz |= ~in & st_z;\
} while ( 0 )
- fuint8 status;
- fuint16 c; // carry set if (c & 0x100) != 0
- fuint16 nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
+ uint8_t status;
+ uint16_t c; // carry set if (c & 0x100) != 0
+ uint16_t nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
{
- fuint8 temp = r.status;
+ uint8_t temp = r.status;
SET_STATUS( temp );
}
goto loop;
dec_clock_loop:
s_time--;
loop:
check( (unsigned) GET_SP() < 0x100 );
check( (unsigned) pc < 0x10000 );
check( (unsigned) a < 0x100 );
check( (unsigned) x < 0x100 );
check( (unsigned) y < 0x100 );
check( -32768 <= s_time && s_time < 32767 );
uint8_t const* instr = s.code_map [pc >> page_bits];
- fuint8 opcode;
+ uint8_t opcode;
// TODO: eliminate this special case
#if BLARGG_NONPORTABLE
opcode = instr [pc];
pc++;
instr += pc;
#else
instr += PAGE_OFFSET( pc );
opcode = *instr++;
pc++;
#endif
static uint8_t const clock_table [256] =
{// 0 1 2 3 4 5 6 7 8 9 A B C D E F
0,6,2,8,3,3,5,5,3,2,2,2,4,4,6,6,// 0
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 1
6,6,2,8,3,3,5,5,4,2,2,2,4,4,6,6,// 2
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 3
6,6,2,8,3,3,5,5,3,2,2,2,3,4,6,6,// 4
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 5
6,6,2,8,3,3,5,5,4,2,2,2,5,4,6,6,// 6
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 7
2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,// 8
3,6,2,6,4,4,4,4,2,5,2,5,5,5,5,5,// 9
2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,// A
3,5,2,5,4,4,4,4,2,4,2,4,4,4,4,4,// B
2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,// C
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// D
2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,// E
3,5,0,8,4,4,6,6,2,4,2,7,4,4,7,7 // F
}; // 0x00 was 7 and 0xF2 was 2
- fuint16 data;
+ uint16_t data;
#if !BLARGG_CPU_X86
if ( s_time >= 0 )
goto out_of_time;
s_time += clock_table [opcode];
data = *instr;
switch ( opcode )
{
#else
data = clock_table [opcode];
if ( (s_time += data) >= 0 )
goto possibly_out_of_time;
almost_out_of_time:
data = *instr;
switch ( opcode )
{
possibly_out_of_time:
if ( s_time < (int) data )
goto almost_out_of_time;
s_time -= data;
goto out_of_time;
#endif
// Macros
#define GET_MSB() (instr [1])
#define ADD_PAGE() (pc++, data += 0x100 * GET_MSB())
#define GET_ADDR() GET_LE16( instr )
#define NO_PAGE_CROSSING( lsb )
#define HANDLE_PAGE_CROSSING( lsb ) s_time += (lsb) >> 8;
#define INC_DEC_XY( reg, n ) reg = uint8_t (nz = reg + n); goto loop;
#define IND_Y( cross, out ) {\
- fuint16 temp = READ_LOW( data ) + y;\
+ uint16_t temp = READ_LOW( data ) + y;\
out = temp + 0x100 * READ_LOW( uint8_t (data + 1) );\
cross( temp );\
}
#define IND_X( out ) {\
- fuint16 temp = data + x;\
+ uint16_t temp = data + x;\
out = 0x100 * READ_LOW( uint8_t (temp + 1) ) + READ_LOW( uint8_t (temp) );\
}
#define ARITH_ADDR_MODES( op )\
case op - 0x04: /* (ind,x) */\
IND_X( data )\
goto ptr##op;\
case op + 0x0C: /* (ind),y */\
IND_Y( HANDLE_PAGE_CROSSING, data )\
goto ptr##op;\
case op + 0x10: /* zp,X */\
data = uint8_t (data + x);\
case op + 0x00: /* zp */\
data = READ_LOW( data );\
goto imm##op;\
case op + 0x14: /* abs,Y */\
data += y;\
goto ind##op;\
case op + 0x18: /* abs,X */\
data += x;\
ind##op:\
HANDLE_PAGE_CROSSING( data );\
case op + 0x08: /* abs */\
ADD_PAGE();\
ptr##op:\
FLUSH_TIME();\
data = READ( data );\
CACHE_TIME();\
case op + 0x04: /* imm */\
imm##op:
// TODO: more efficient way to handle negative branch that wraps PC around
#define BRANCH( cond )\
{\
- fint16 offset = (BOOST::int8_t) data;\
- fuint16 extra_clock = (++pc & 0xFF) + offset;\
+ int16_t offset = (int8_t) data;\
+ uint16_t extra_clock = (++pc & 0xFF) + offset;\
if ( !(cond) ) goto dec_clock_loop;\
- pc = BOOST::uint16_t (pc + offset);\
+ pc = uint16_t (pc + offset);\
s_time += extra_clock >> 8 & 1;\
goto loop;\
}
// Often-Used
case 0xB5: // LDA zp,x
a = nz = READ_LOW( uint8_t (data + x) );
pc++;
goto loop;
case 0xA5: // LDA zp
a = nz = READ_LOW( data );
pc++;
goto loop;
case 0xD0: // BNE
BRANCH( (uint8_t) nz );
case 0x20: { // JSR
- fuint16 temp = pc + 1;
+ uint16_t temp = pc + 1;
pc = GET_ADDR();
WRITE_LOW( 0x100 | (sp - 1), temp >> 8 );
sp = (sp - 2) | 0x100;
WRITE_LOW( sp, temp );
goto loop;
}
case 0x4C: // JMP abs
pc = GET_ADDR();
goto loop;
case 0xE8: // INX
INC_DEC_XY( x, 1 )
case 0x10: // BPL
BRANCH( !IS_NEG )
ARITH_ADDR_MODES( 0xC5 ) // CMP
nz = a - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
case 0x30: // BMI
BRANCH( IS_NEG )
case 0xF0: // BEQ
BRANCH( !(uint8_t) nz );
case 0x95: // STA zp,x
data = uint8_t (data + x);
case 0x85: // STA zp
pc++;
WRITE_LOW( data, a );
goto loop;
case 0xC8: // INY
INC_DEC_XY( y, 1 )
case 0xA8: // TAY
y = a;
nz = a;
goto loop;
case 0x98: // TYA
a = y;
nz = y;
goto loop;
case 0xAD:{// LDA abs
unsigned addr = GET_ADDR();
pc += 2;
READ_LIKELY_PPU( addr, nz );
a = nz;
goto loop;
}
case 0x60: // RTS
pc = 1 + READ_LOW( sp );
pc += 0x100 * READ_LOW( 0x100 | (sp - 0xFF) );
sp = (sp - 0xFE) | 0x100;
goto loop;
{
- fuint16 addr;
+ uint16_t addr;
case 0x99: // STA abs,Y
addr = y + GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
goto sta_ptr;
case 0x8D: // STA abs
addr = GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
goto sta_ptr;
case 0x9D: // STA abs,X (slightly more common than STA abs)
addr = x + GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
sta_ptr:
FLUSH_TIME();
WRITE( addr, a );
CACHE_TIME();
goto loop;
case 0x91: // STA (ind),Y
IND_Y( NO_PAGE_CROSSING, addr )
pc++;
goto sta_ptr;
case 0x81: // STA (ind,X)
IND_X( addr )
pc++;
goto sta_ptr;
}
case 0xA9: // LDA #imm
pc++;
a = data;
nz = data;
goto loop;
// common read instructions
{
- fuint16 addr;
+ uint16_t addr;
case 0xA1: // LDA (ind,X)
IND_X( addr )
pc++;
goto a_nz_read_addr;
case 0xB1:// LDA (ind),Y
addr = READ_LOW( data ) + y;
HANDLE_PAGE_CROSSING( addr );
addr += 0x100 * READ_LOW( (uint8_t) (data + 1) );
pc++;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
goto a_nz_read_addr;
case 0xB9: // LDA abs,Y
HANDLE_PAGE_CROSSING( data + y );
addr = GET_ADDR() + y;
pc += 2;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
goto a_nz_read_addr;
case 0xBD: // LDA abs,X
HANDLE_PAGE_CROSSING( data + x );
addr = GET_ADDR() + x;
pc += 2;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
a_nz_read_addr:
FLUSH_TIME();
a = nz = READ( addr );
CACHE_TIME();
goto loop;
}
// Branch
case 0x50: // BVC
BRANCH( !(status & st_v) )
case 0x70: // BVS
BRANCH( status & st_v )
case 0xB0: // BCS
BRANCH( c & 0x100 )
case 0x90: // BCC
BRANCH( !(c & 0x100) )
// Load/store
case 0x94: // STY zp,x
data = uint8_t (data + x);
case 0x84: // STY zp
pc++;
WRITE_LOW( data, y );
goto loop;
case 0x96: // STX zp,y
data = uint8_t (data + y);
case 0x86: // STX zp
pc++;
WRITE_LOW( data, x );
goto loop;
case 0xB6: // LDX zp,y
data = uint8_t (data + y);
case 0xA6: // LDX zp
data = READ_LOW( data );
case 0xA2: // LDX #imm
pc++;
x = data;
nz = data;
goto loop;
case 0xB4: // LDY zp,x
data = uint8_t (data + x);
case 0xA4: // LDY zp
data = READ_LOW( data );
case 0xA0: // LDY #imm
pc++;
y = data;
nz = data;
goto loop;
case 0xBC: // LDY abs,X
data += x;
HANDLE_PAGE_CROSSING( data );
case 0xAC:{// LDY abs
unsigned addr = data + 0x100 * GET_MSB();
pc += 2;
FLUSH_TIME();
y = nz = READ( addr );
CACHE_TIME();
goto loop;
}
case 0xBE: // LDX abs,y
data += y;
HANDLE_PAGE_CROSSING( data );
case 0xAE:{// LDX abs
unsigned addr = data + 0x100 * GET_MSB();
pc += 2;
FLUSH_TIME();
x = nz = READ( addr );
CACHE_TIME();
goto loop;
}
{
- fuint8 temp;
+ uint8_t temp;
case 0x8C: // STY abs
temp = y;
goto store_abs;
case 0x8E: // STX abs
temp = x;
store_abs:
unsigned addr = GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, temp );
goto loop;
}
FLUSH_TIME();
WRITE( addr, temp );
CACHE_TIME();
goto loop;
}
// Compare
case 0xEC:{// CPX abs
unsigned addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpx_data;
}
case 0xE4: // CPX zp
data = READ_LOW( data );
case 0xE0: // CPX #imm
cpx_data:
nz = x - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
case 0xCC:{// CPY abs
unsigned addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpy_data;
}
case 0xC4: // CPY zp
data = READ_LOW( data );
case 0xC0: // CPY #imm
cpy_data:
nz = y - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
// Logical
ARITH_ADDR_MODES( 0x25 ) // AND
nz = (a &= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x45 ) // EOR
nz = (a ^= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x05 ) // ORA
nz = (a |= data);
pc++;
goto loop;
case 0x2C:{// BIT abs
unsigned addr = GET_ADDR();
pc += 2;
status &= ~st_v;
READ_LIKELY_PPU( addr, nz );
status |= nz & st_v;
if ( a & nz )
goto loop;
nz <<= 8; // result must be zero, even if N bit is set
goto loop;
}
case 0x24: // BIT zp
nz = READ_LOW( data );
pc++;
status &= ~st_v;
status |= nz & st_v;
if ( a & nz )
goto loop;
nz <<= 8; // result must be zero, even if N bit is set
goto loop;
// Add/subtract
ARITH_ADDR_MODES( 0xE5 ) // SBC
case 0xEB: // unofficial equivalent
data ^= 0xFF;
goto adc_imm;
ARITH_ADDR_MODES( 0x65 ) // ADC
adc_imm: {
- fint16 carry = c >> 8 & 1;
- fint16 ov = (a ^ 0x80) + carry + (BOOST::int8_t) data; // sign-extend
+ int16_t carry = c >> 8 & 1;
+ int16_t ov = (a ^ 0x80) + carry + (int8_t) data; // sign-extend
status &= ~st_v;
status |= ov >> 2 & 0x40;
c = nz = a + data + carry;
pc++;
a = (uint8_t) nz;
goto loop;
}
// Shift/rotate
case 0x4A: // LSR A
c = 0;
case 0x6A: // ROR A
nz = c >> 1 & 0x80;
c = a << 8;
nz |= a >> 1;
a = nz;
goto loop;
case 0x0A: // ASL A
nz = a << 1;
c = nz;
a = (uint8_t) nz;
goto loop;
case 0x2A: { // ROL A
nz = a << 1;
- fint16 temp = c >> 8 & 1;
+ int16_t temp = c >> 8 & 1;
c = nz;
nz |= temp;
a = (uint8_t) nz;
goto loop;
}
case 0x5E: // LSR abs,X
data += x;
case 0x4E: // LSR abs
c = 0;
case 0x6E: // ROR abs
ror_abs: {
ADD_PAGE();
FLUSH_TIME();
int temp = READ( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto rotate_common;
}
case 0x3E: // ROL abs,X
data += x;
goto rol_abs;
case 0x1E: // ASL abs,X
data += x;
case 0x0E: // ASL abs
c = 0;
case 0x2E: // ROL abs
rol_abs:
ADD_PAGE();
nz = c >> 8 & 1;
FLUSH_TIME();
nz |= (c = READ( data ) << 1);
rotate_common:
pc++;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
case 0x7E: // ROR abs,X
data += x;
goto ror_abs;
case 0x76: // ROR zp,x
data = uint8_t (data + x);
goto ror_zp;
case 0x56: // LSR zp,x
data = uint8_t (data + x);
case 0x46: // LSR zp
c = 0;
case 0x66: // ROR zp
ror_zp: {
int temp = READ_LOW( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto write_nz_zp;
}
case 0x36: // ROL zp,x
data = uint8_t (data + x);
goto rol_zp;
case 0x16: // ASL zp,x
data = uint8_t (data + x);
case 0x06: // ASL zp
c = 0;
case 0x26: // ROL zp
rol_zp:
nz = c >> 8 & 1;
nz |= (c = READ_LOW( data ) << 1);
goto write_nz_zp;
// Increment/decrement
case 0xCA: // DEX
INC_DEC_XY( x, -1 )
case 0x88: // DEY
INC_DEC_XY( y, -1 )
case 0xF6: // INC zp,x
data = uint8_t (data + x);
case 0xE6: // INC zp
nz = 1;
goto add_nz_zp;
case 0xD6: // DEC zp,x
data = uint8_t (data + x);
case 0xC6: // DEC zp
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
add_nz_zp:
nz += READ_LOW( data );
write_nz_zp:
pc++;
WRITE_LOW( data, nz );
goto loop;
case 0xFE: // INC abs,x
data = x + GET_ADDR();
goto inc_ptr;
case 0xEE: // INC abs
data = GET_ADDR();
inc_ptr:
nz = 1;
goto inc_common;
case 0xDE: // DEC abs,x
data = x + GET_ADDR();
goto dec_ptr;
case 0xCE: // DEC abs
data = GET_ADDR();
dec_ptr:
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
inc_common:
FLUSH_TIME();
nz += READ( data );
pc += 2;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
// Transfer
case 0xAA: // TAX
x = a;
nz = a;
goto loop;
case 0x8A: // TXA
a = x;
nz = x;
goto loop;
case 0x9A: // TXS
SET_SP( x ); // verified (no flag change)
goto loop;
case 0xBA: // TSX
x = nz = GET_SP();
goto loop;
// Stack
case 0x48: // PHA
PUSH( a ); // verified
goto loop;
case 0x68: // PLA
a = nz = READ_LOW( sp );
sp = (sp - 0xFF) | 0x100;
goto loop;
case 0x40:{// RTI
- fuint8 temp = READ_LOW( sp );
+ uint8_t temp = READ_LOW( sp );
pc = READ_LOW( 0x100 | (sp - 0xFF) );
pc |= READ_LOW( 0x100 | (sp - 0xFE) ) * 0x100;
sp = (sp - 0xFD) | 0x100;
data = status;
SET_STATUS( temp );
if ( !((data ^ status) & st_i) ) goto loop; // I flag didn't change
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - irq_time_;
if ( delta <= 0 ) goto loop;
if ( status & st_i ) goto loop;
s_time += delta;
s.base = irq_time_;
goto loop;
}
case 0x28:{// PLP
- fuint8 temp = READ_LOW( sp );
+ uint8_t temp = READ_LOW( sp );
sp = (sp - 0xFF) | 0x100;
- fuint8 changed = status ^ temp;
+ uint8_t changed = status ^ temp;
SET_STATUS( temp );
if ( !(changed & st_i) )
goto loop; // I flag didn't change
if ( status & st_i )
goto handle_sei;
goto handle_cli;
}
case 0x08: { // PHP
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
PUSH( temp | (st_b | st_r) );
goto loop;
}
case 0x6C:{// JMP (ind)
data = GET_ADDR();
check( unsigned (data - 0x2000) >= 0x4000 ); // ensure it's outside I/O space
uint8_t const* page = s.code_map [data >> page_bits];
pc = page [PAGE_OFFSET( data )];
data = (data & 0xFF00) | ((data + 1) & 0xFF);
pc |= page [PAGE_OFFSET( data )] << 8;
goto loop;
}
case 0x00: // BRK
goto handle_brk;
// Flags
case 0x38: // SEC
- c = (unsigned) ~0;
+ c = (uint16_t) ~0;
goto loop;
case 0x18: // CLC
c = 0;
goto loop;
case 0xB8: // CLV
status &= ~st_v;
goto loop;
case 0xD8: // CLD
status &= ~st_d;
goto loop;
case 0xF8: // SED
status |= st_d;
goto loop;
case 0x58: // CLI
if ( !(status & st_i) )
goto loop;
status &= ~st_i;
handle_cli: {
//debug_printf( "CLI at %d\n", TIME );
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - irq_time_;
if ( delta <= 0 )
{
if ( TIME < irq_time_ )
goto loop;
goto delayed_cli;
}
s.base = irq_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
if ( delta >= s_time + 1 )
{
s.base += s_time + 1;
s_time = -1;
goto loop;
}
// TODO: implement
delayed_cli:
debug_printf( "Delayed CLI not emulated\n" );
goto loop;
}
case 0x78: // SEI
if ( status & st_i )
goto loop;
status |= st_i;
handle_sei: {
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - end_time_;
s.base = end_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
debug_printf( "Delayed SEI not emulated\n" );
goto loop;
}
// Unofficial
// SKW - Skip word
case 0x1C: case 0x3C: case 0x5C: case 0x7C: case 0xDC: case 0xFC:
HANDLE_PAGE_CROSSING( data + x );
case 0x0C:
pc++;
// SKB - Skip byte
case 0x74: case 0x04: case 0x14: case 0x34: case 0x44: case 0x54: case 0x64:
case 0x80: case 0x82: case 0x89: case 0xC2: case 0xD4: case 0xE2: case 0xF4:
pc++;
goto loop;
// NOP
case 0xEA: case 0x1A: case 0x3A: case 0x5A: case 0x7A: case 0xDA: case 0xFA:
goto loop;
case bad_opcode: // HLT
pc--;
- if ( pc > 0xFFFF )
- {
- // handle wrap-around (assumes caller has put page of HLT at 0x10000)
- pc &= 0xFFFF;
- goto loop;
- }
case 0x02: case 0x12: case 0x22: case 0x32: case 0x42: case 0x52:
case 0x62: case 0x72: case 0x92: case 0xB2: case 0xD2:
goto stop;
// Unimplemented
case 0xFF: // force 256-entry jump table for optimization purposes
c |= 1;
default:
check( (unsigned) opcode <= 0xFF );
// skip over proper number of bytes
static unsigned char const illop_lens [8] = {
0x40, 0x40, 0x40, 0x80, 0x40, 0x40, 0x80, 0xA0
};
- fuint8 opcode = instr [-1];
- fint16 len = illop_lens [opcode >> 2 & 7] >> (opcode << 1 & 6) & 3;
+ uint8_t opcode = instr [-1];
+ int16_t len = illop_lens [opcode >> 2 & 7] >> (opcode << 1 & 6) & 3;
if ( opcode == 0x9C )
len = 2;
pc += len;
error_count_++;
if ( (opcode >> 4) == 0x0B )
{
if ( opcode == 0xB3 )
data = READ_LOW( data );
if ( opcode != 0xB7 )
HANDLE_PAGE_CROSSING( data + y );
}
goto loop;
}
assert( false );
int result_;
handle_brk:
pc++;
result_ = 4;
interrupt:
{
s_time += 7;
WRITE_LOW( 0x100 | (sp - 1), pc >> 8 );
WRITE_LOW( 0x100 | (sp - 2), pc );
pc = GET_LE16( &READ_PROG( 0xFFFA ) + result_ );
sp = (sp - 3) | 0x100;
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
temp |= st_r;
if ( result_ )
temp |= st_b; // TODO: incorrectly sets B flag for IRQ
WRITE_LOW( sp, temp );
this->r.status = status |= st_i;
blargg_long delta = s.base - end_time_;
if ( delta >= 0 ) goto loop;
s_time += delta;
s.base = end_time_;
goto loop;
}
out_of_time:
pc--;
FLUSH_TIME();
CPU_DONE( this, TIME, result_ );
CACHE_TIME();
if ( result_ >= 0 )
goto interrupt;
if ( s_time < 0 )
goto loop;
stop:
s.time = s_time;
r.pc = pc;
r.sp = GET_SP();
r.a = a;
r.x = x;
r.y = y;
{
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
r.status = temp;
}
this->state_ = s;
this->state = &this->state_;
return s_time < 0;
}
diff --git a/src/libs/gme/Nes_Cpu.h b/src/libs/gme/Nes_Cpu.h
index 694296f7..878b5ba5 100644
--- a/src/libs/gme/Nes_Cpu.h
+++ b/src/libs/gme/Nes_Cpu.h
@@ -1,114 +1,112 @@
// NES 6502 CPU emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef NES_CPU_H
#define NES_CPU_H
#include "blargg_common.h"
typedef blargg_long nes_time_t; // clock cycle count
typedef unsigned nes_addr_t; // 16-bit address
enum { future_nes_time = INT_MAX / 2 + 1 };
class Nes_Cpu {
public:
- typedef BOOST::uint8_t uint8_t;
-
// Clear registers, map low memory and its three mirrors to address 0,
// and mirror unmapped_page in remaining memory
void reset( void const* unmapped_page = 0 );
// Map code memory (memory accessed via the program counter). Start and size
// must be multiple of page_size. If mirror is true, repeats code page
// throughout address range.
enum { page_size = 0x800 };
void map_code( nes_addr_t start, unsigned size, void const* code, bool mirror = false );
// Access emulated memory as CPU does
uint8_t const* get_code( nes_addr_t );
// 2KB of RAM at address 0
uint8_t low_mem [0x800];
// NES 6502 registers. Not kept updated during a call to run().
struct registers_t {
- BOOST::uint16_t pc;
- BOOST::uint8_t a;
- BOOST::uint8_t x;
- BOOST::uint8_t y;
- BOOST::uint8_t status;
- BOOST::uint8_t sp;
+ uint16_t pc;
+ uint8_t a;
+ uint8_t x;
+ uint8_t y;
+ uint8_t status;
+ uint8_t sp;
};
registers_t r;
// Set end_time and run CPU from current time. Returns true if execution
// stopped due to encountering bad_opcode.
bool run( nes_time_t end_time );
// Time of beginning of next instruction to be executed
nes_time_t time() const { return state->time + state->base; }
void set_time( nes_time_t t ) { state->time = t - state->base; }
void adjust_time( int delta ) { state->time += delta; }
nes_time_t irq_time() const { return irq_time_; }
void set_irq_time( nes_time_t );
nes_time_t end_time() const { return end_time_; }
void set_end_time( nes_time_t );
// Number of undefined instructions encountered and skipped
void clear_error_count() { error_count_ = 0; }
unsigned long error_count() const { return error_count_; }
// CPU invokes bad opcode handler if it encounters this
enum { bad_opcode = 0xF2 };
public:
Nes_Cpu() { state = &state_; }
enum { page_bits = 11 };
enum { page_count = 0x10000 >> page_bits };
enum { irq_inhibit = 0x04 };
private:
struct state_t {
uint8_t const* code_map [page_count + 1];
nes_time_t base;
int time;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
nes_time_t irq_time_;
nes_time_t end_time_;
unsigned long error_count_;
void set_code_page( int, void const* );
inline int update_end_time( nes_time_t end, nes_time_t irq );
};
-inline BOOST::uint8_t const* Nes_Cpu::get_code( nes_addr_t addr )
+inline uint8_t const* Nes_Cpu::get_code( nes_addr_t addr )
{
return state->code_map [addr >> page_bits] + addr
#if !BLARGG_NONPORTABLE
% (unsigned) page_size
#endif
;
}
inline int Nes_Cpu::update_end_time( nes_time_t t, nes_time_t irq )
{
if ( irq < t && !(r.status & irq_inhibit) ) t = irq;
int delta = state->base - t;
state->base = t;
return delta;
}
inline void Nes_Cpu::set_irq_time( nes_time_t t )
{
state->time += update_end_time( end_time_, (irq_time_ = t) );
}
inline void Nes_Cpu::set_end_time( nes_time_t t )
{
state->time += update_end_time( (end_time_ = t), irq_time_ );
}
#endif
diff --git a/src/libs/gme/Nes_Fme7_Apu.cpp b/src/libs/gme/Nes_Fme7_Apu.cpp
index 62594fc2..93973e40 100644
--- a/src/libs/gme/Nes_Fme7_Apu.cpp
+++ b/src/libs/gme/Nes_Fme7_Apu.cpp
@@ -1,121 +1,121 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Nes_Fme7_Apu.h"
#include <string.h>
/* Copyright (C) 2003-2006 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"
void Nes_Fme7_Apu::reset()
{
last_time = 0;
for ( int i = 0; i < osc_count; i++ )
oscs [i].last_amp = 0;
fme7_apu_state_t* state = this;
memset( state, 0, sizeof *state );
}
unsigned char const Nes_Fme7_Apu::amp_table [16] =
{
#define ENTRY( n ) (unsigned char) (n * amp_range + 0.5)
ENTRY(0.0000), ENTRY(0.0078), ENTRY(0.0110), ENTRY(0.0156),
ENTRY(0.0221), ENTRY(0.0312), ENTRY(0.0441), ENTRY(0.0624),
ENTRY(0.0883), ENTRY(0.1249), ENTRY(0.1766), ENTRY(0.2498),
ENTRY(0.3534), ENTRY(0.4998), ENTRY(0.7070), ENTRY(1.0000)
#undef ENTRY
};
void Nes_Fme7_Apu::run_until( blip_time_t end_time )
{
require( end_time >= last_time );
for ( int index = 0; index < osc_count; index++ )
{
int mode = regs [7] >> index;
int vol_mode = regs [010 + index];
int volume = amp_table [vol_mode & 0x0F];
Blip_Buffer* const osc_output = oscs [index].output;
if ( !osc_output )
continue;
osc_output->set_modified();
// check for unsupported mode
#ifndef NDEBUG
if ( (mode & 011) <= 001 && vol_mode & 0x1F )
debug_printf( "FME7 used unimplemented sound mode: %02X, vol_mode: %02X\n",
mode, vol_mode & 0x1F );
#endif
if ( (mode & 001) | (vol_mode & 0x10) )
volume = 0; // noise and envelope aren't supported
// period
int const period_factor = 16;
unsigned period = (regs [index * 2 + 1] & 0x0F) * 0x100 * period_factor +
regs [index * 2] * period_factor;
if ( period < 50 ) // around 22 kHz
{
volume = 0;
if ( !period ) // on my AY-3-8910A, period doesn't have extra one added
period = period_factor;
}
// current amplitude
int amp = volume;
if ( !phases [index] )
amp = 0;
{
int delta = amp - oscs [index].last_amp;
if ( delta )
{
oscs [index].last_amp = amp;
synth.offset( last_time, delta, osc_output );
}
}
blip_time_t time = last_time + delays [index];
if ( time < end_time )
{
int delta = amp * 2 - volume;
if ( volume )
{
do
{
delta = -delta;
synth.offset_inline( time, delta, osc_output );
time += period;
}
while ( time < end_time );
oscs [index].last_amp = (delta + volume) >> 1;
phases [index] = (delta > 0);
}
else
{
// maintain phase when silent
int count = (end_time - time + period - 1) / period;
phases [index] ^= count & 1;
time += (blargg_long) count * period;
}
}
delays [index] = time - end_time;
}
last_time = end_time;
}
diff --git a/src/libs/gme/Nes_Fme7_Apu.h b/src/libs/gme/Nes_Fme7_Apu.h
index 97094897..b79ed6f5 100644
--- a/src/libs/gme/Nes_Fme7_Apu.h
+++ b/src/libs/gme/Nes_Fme7_Apu.h
@@ -1,131 +1,131 @@
// Sunsoft FME-7 sound emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef NES_FME7_APU_H
#define NES_FME7_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
struct fme7_apu_state_t
{
enum { reg_count = 14 };
- BOOST::uint8_t regs [reg_count];
- BOOST::uint8_t phases [3]; // 0 or 1
- BOOST::uint8_t latch;
- BOOST::uint16_t delays [3]; // a, b, c
+ uint8_t regs [reg_count];
+ uint8_t phases [3]; // 0 or 1
+ uint8_t latch;
+ uint16_t delays [3]; // a, b, c
};
class Nes_Fme7_Apu : private fme7_apu_state_t {
public:
// See Nes_Apu.h for reference
void reset();
void volume( double );
void treble_eq( blip_eq_t const& );
void output( Blip_Buffer* );
enum { osc_count = 3 };
void osc_output( int index, Blip_Buffer* );
void end_frame( blip_time_t );
void save_state( fme7_apu_state_t* ) const;
void load_state( fme7_apu_state_t const& );
// Mask and addresses of registers
enum { addr_mask = 0xE000 };
enum { data_addr = 0xE000 };
enum { latch_addr = 0xC000 };
// (addr & addr_mask) == latch_addr
void write_latch( int );
// (addr & addr_mask) == data_addr
void write_data( blip_time_t, int data );
public:
Nes_Fme7_Apu();
BLARGG_DISABLE_NOTHROW
private:
// noncopyable
Nes_Fme7_Apu( const Nes_Fme7_Apu& );
Nes_Fme7_Apu& operator = ( const Nes_Fme7_Apu& );
static unsigned char const amp_table [16];
struct {
Blip_Buffer* output;
int last_amp;
} oscs [osc_count];
blip_time_t last_time;
enum { amp_range = 192 }; // can be any value; this gives best error/quality tradeoff
Blip_Synth<blip_good_quality,1> synth;
void run_until( blip_time_t );
};
inline void Nes_Fme7_Apu::volume( double v )
{
synth.volume( 0.38 / amp_range * v ); // to do: fine-tune
}
inline void Nes_Fme7_Apu::treble_eq( blip_eq_t const& eq )
{
synth.treble_eq( eq );
}
inline void Nes_Fme7_Apu::osc_output( int i, Blip_Buffer* buf )
{
assert( (unsigned) i < osc_count );
oscs [i].output = buf;
}
inline void Nes_Fme7_Apu::output( Blip_Buffer* buf )
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
}
inline Nes_Fme7_Apu::Nes_Fme7_Apu()
{
output( NULL );
volume( 1.0 );
reset();
}
inline void Nes_Fme7_Apu::write_latch( int data ) { latch = data; }
inline void Nes_Fme7_Apu::write_data( blip_time_t time, int data )
{
if ( (unsigned) latch >= reg_count )
{
#ifdef debug_printf
debug_printf( "FME7 write to %02X (past end of sound registers)\n", (int) latch );
#endif
return;
}
run_until( time );
regs [latch] = data;
}
inline void Nes_Fme7_Apu::end_frame( blip_time_t time )
{
if ( time > last_time )
run_until( time );
assert( last_time >= time );
last_time -= time;
}
inline void Nes_Fme7_Apu::save_state( fme7_apu_state_t* out ) const
{
*out = *this;
}
inline void Nes_Fme7_Apu::load_state( fme7_apu_state_t const& in )
{
reset();
fme7_apu_state_t* state = this;
*state = in;
}
#endif
diff --git a/src/libs/gme/Nes_Namco_Apu.cpp b/src/libs/gme/Nes_Namco_Apu.cpp
index f3235b38..3e5fc149 100644
--- a/src/libs/gme/Nes_Namco_Apu.cpp
+++ b/src/libs/gme/Nes_Namco_Apu.cpp
@@ -1,145 +1,145 @@
// Nes_Snd_Emu 0.1.8. http://www.slack.net/~ant/
#include "Nes_Namco_Apu.h"
/* Copyright (C) 2003-2006 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"
Nes_Namco_Apu::Nes_Namco_Apu()
{
output( NULL );
volume( 1.0 );
reset();
}
void Nes_Namco_Apu::reset()
{
last_time = 0;
addr_reg = 0;
int i;
for ( i = 0; i < reg_count; i++ )
reg [i] = 0;
for ( i = 0; i < osc_count; i++ )
{
Namco_Osc& osc = oscs [i];
osc.delay = 0;
osc.last_amp = 0;
osc.wave_pos = 0;
}
}
void Nes_Namco_Apu::output( Blip_Buffer* buf )
{
for ( int i = 0; i < osc_count; i++ )
osc_output( i, buf );
}
/*
void Nes_Namco_Apu::reflect_state( Tagged_Data& data )
{
reflect_int16( data, BLARGG_4CHAR('A','D','D','R'), &addr_reg );
static const char hex [17] = "0123456789ABCDEF";
int i;
for ( i = 0; i < reg_count; i++ )
reflect_int16( data, 'RG\0\0' + hex [i >> 4] * 0x100 + hex [i & 15], &reg [i] );
for ( i = 0; i < osc_count; i++ )
{
reflect_int32( data, BLARGG_4CHAR('D','L','Y','0') + i, &oscs [i].delay );
reflect_int16( data, BLARGG_4CHAR('P','O','S','0') + i, &oscs [i].wave_pos );
}
}
*/
void Nes_Namco_Apu::end_frame( blip_time_t time )
{
if ( time > last_time )
run_until( time );
assert( last_time >= time );
last_time -= time;
}
void Nes_Namco_Apu::run_until( blip_time_t nes_end_time )
{
int active_oscs = (reg [0x7F] >> 4 & 7) + 1;
for ( int i = osc_count - active_oscs; i < osc_count; i++ )
{
Namco_Osc& osc = oscs [i];
Blip_Buffer* output = osc.output;
if ( !output )
continue;
output->set_modified();
blip_resampled_time_t time =
output->resampled_time( last_time ) + osc.delay;
blip_resampled_time_t end_time = output->resampled_time( nes_end_time );
osc.delay = 0;
if ( time < end_time )
{
- const BOOST::uint8_t* osc_reg = &reg [i * 8 + 0x40];
+ const uint8_t* osc_reg = &reg [i * 8 + 0x40];
if ( !(osc_reg [4] & 0xE0) )
continue;
int volume = osc_reg [7] & 15;
if ( !volume )
continue;
blargg_long freq = (osc_reg [4] & 3) * 0x10000 + osc_reg [2] * 0x100L + osc_reg [0];
if ( freq < 64 * active_oscs )
continue; // prevent low frequencies from excessively delaying freq changes
blip_resampled_time_t period =
output->resampled_duration( 983040 ) / freq * active_oscs;
int wave_size = 32 - (osc_reg [4] >> 2 & 7) * 4;
if ( !wave_size )
continue;
int last_amp = osc.last_amp;
int wave_pos = osc.wave_pos;
do
{
// read wave sample
int addr = wave_pos + osc_reg [6];
int sample = reg [addr >> 1] >> (addr << 2 & 4);
wave_pos++;
sample = (sample & 15) * volume;
// output impulse if amplitude changed
int delta = sample - last_amp;
if ( delta )
{
last_amp = sample;
synth.offset_resampled( time, delta, output );
}
// next sample
time += period;
if ( wave_pos >= wave_size )
wave_pos = 0;
}
while ( time < end_time );
osc.wave_pos = wave_pos;
osc.last_amp = last_amp;
}
osc.delay = time - end_time;
}
last_time = nes_end_time;
}
diff --git a/src/libs/gme/Nes_Namco_Apu.h b/src/libs/gme/Nes_Namco_Apu.h
index db5fea4b..876d85e0 100644
--- a/src/libs/gme/Nes_Namco_Apu.h
+++ b/src/libs/gme/Nes_Namco_Apu.h
@@ -1,102 +1,102 @@
// Namco 106 sound chip emulator
// Nes_Snd_Emu 0.1.8
#ifndef NES_NAMCO_APU_H
#define NES_NAMCO_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
struct namco_state_t;
class Nes_Namco_Apu {
public:
// See Nes_Apu.h for reference.
void volume( double );
void treble_eq( const blip_eq_t& );
void output( Blip_Buffer* );
enum { osc_count = 8 };
void osc_output( int index, Blip_Buffer* );
void reset();
void end_frame( blip_time_t );
// Read/write data register is at 0x4800
enum { data_reg_addr = 0x4800 };
void write_data( blip_time_t, int );
int read_data();
// Write-only address register is at 0xF800
enum { addr_reg_addr = 0xF800 };
void write_addr( int );
// to do: implement save/restore
void save_state( namco_state_t* out ) const;
void load_state( namco_state_t const& );
public:
Nes_Namco_Apu();
BLARGG_DISABLE_NOTHROW
private:
// noncopyable
Nes_Namco_Apu( const Nes_Namco_Apu& );
Nes_Namco_Apu& operator = ( const Nes_Namco_Apu& );
struct Namco_Osc {
blargg_long delay;
Blip_Buffer* output;
short last_amp;
short wave_pos;
};
Namco_Osc oscs [osc_count];
blip_time_t last_time;
int addr_reg;
enum { reg_count = 0x80 };
- BOOST::uint8_t reg [reg_count];
+ uint8_t reg [reg_count];
Blip_Synth<blip_good_quality,15> synth;
- BOOST::uint8_t& access();
+ uint8_t& access();
void run_until( blip_time_t );
};
/*
struct namco_state_t
{
- BOOST::uint8_t regs [0x80];
- BOOST::uint8_t addr;
- BOOST::uint8_t unused;
- BOOST::uint8_t positions [8];
- BOOST::uint32_t delays [8];
+ uint8_t regs [0x80];
+ uint8_t addr;
+ uint8_t unused;
+ uint8_t positions [8];
+ uint32_t delays [8];
};
*/
-inline BOOST::uint8_t& Nes_Namco_Apu::access()
+inline uint8_t& Nes_Namco_Apu::access()
{
int addr = addr_reg & 0x7F;
if ( addr_reg & 0x80 )
addr_reg = (addr + 1) | 0x80;
return reg [addr];
}
inline void Nes_Namco_Apu::volume( double v ) { synth.volume( 0.10 / osc_count * v ); }
inline void Nes_Namco_Apu::treble_eq( const blip_eq_t& eq ) { synth.treble_eq( eq ); }
inline void Nes_Namco_Apu::write_addr( int v ) { addr_reg = v; }
inline int Nes_Namco_Apu::read_data() { return access(); }
inline void Nes_Namco_Apu::osc_output( int i, Blip_Buffer* buf )
{
assert( (unsigned) i < osc_count );
oscs [i].output = buf;
}
inline void Nes_Namco_Apu::write_data( blip_time_t time, int data )
{
run_until( time );
access() = data;
}
#endif
diff --git a/src/libs/gme/Nes_Oscs.h b/src/libs/gme/Nes_Oscs.h
new file mode 100644
index 00000000..b675bfb4
--- /dev/null
+++ b/src/libs/gme/Nes_Oscs.h
@@ -0,0 +1,147 @@
+// Private oscillators used by Nes_Apu
+
+// Nes_Snd_Emu 0.1.8
+#ifndef NES_OSCS_H
+#define NES_OSCS_H
+
+#include "blargg_common.h"
+#include "Blip_Buffer.h"
+
+class Nes_Apu;
+
+struct Nes_Osc
+{
+ unsigned char regs [4];
+ bool reg_written [4];
+ Blip_Buffer* output;
+ int length_counter;// length counter (0 if unused by oscillator)
+ int delay; // delay until next (potential) transition
+ int last_amp; // last amplitude oscillator was outputting
+
+ void clock_length( int halt_mask );
+ int period() const {
+ return (regs [3] & 7) * 0x100 + (regs [2] & 0xFF);
+ }
+ void reset() {
+ delay = 0;
+ last_amp = 0;
+ }
+ int update_amp( int amp ) {
+ int delta = amp - last_amp;
+ last_amp = amp;
+ return delta;
+ }
+};
+
+struct Nes_Envelope : Nes_Osc
+{
+ int envelope;
+ int env_delay;
+
+ void clock_envelope();
+ int volume() const;
+ void reset() {
+ envelope = 0;
+ env_delay = 0;
+ Nes_Osc::reset();
+ }
+};
+
+// Nes_Square
+struct Nes_Square : Nes_Envelope
+{
+ enum { negate_flag = 0x08 };
+ enum { shift_mask = 0x07 };
+ enum { phase_range = 8 };
+ int phase;
+ int sweep_delay;
+
+ typedef Blip_Synth<blip_good_quality,1> Synth;
+ Synth const& synth; // shared between squares
+
+ Nes_Square( Synth const* s ) : synth( *s ) { }
+
+ void clock_sweep( int adjust );
+ void run( nes_time_t, nes_time_t );
+ void reset() {
+ sweep_delay = 0;
+ Nes_Envelope::reset();
+ }
+ nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
+ nes_time_t timer_period );
+};
+
+// Nes_Triangle
+struct Nes_Triangle : Nes_Osc
+{
+ enum { phase_range = 16 };
+ int phase;
+ int linear_counter;
+ Blip_Synth<blip_med_quality,1> synth;
+
+ int calc_amp() const;
+ void run( nes_time_t, nes_time_t );
+ void clock_linear_counter();
+ void reset() {
+ linear_counter = 0;
+ phase = 1;
+ Nes_Osc::reset();
+ }
+ nes_time_t maintain_phase( nes_time_t time, nes_time_t end_time,
+ nes_time_t timer_period );
+};
+
+// Nes_Noise
+struct Nes_Noise : Nes_Envelope
+{
+ int noise;
+ Blip_Synth<blip_med_quality,1> synth;
+
+ void run( nes_time_t, nes_time_t );
+ void reset() {
+ noise = 1 << 14;
+ Nes_Envelope::reset();
+ }
+};
+
+// Nes_Dmc
+struct Nes_Dmc : Nes_Osc
+{
+ int address; // address of next byte to read
+ int period;
+ //int length_counter; // bytes remaining to play (already defined in Nes_Osc)
+ int buf;
+ int bits_remain;
+ int bits;
+ bool buf_full;
+ bool silence;
+
+ enum { loop_flag = 0x40 };
+
+ int dac;
+
+ nes_time_t next_irq;
+ bool irq_enabled;
+ bool irq_flag;
+ bool pal_mode;
+ bool nonlinear;
+
+ int (*prg_reader)( void*, nes_addr_t ); // needs to be initialized to prg read function
+ void* prg_reader_data;
+
+ Nes_Apu* apu;
+
+ Blip_Synth<blip_med_quality,1> synth;
+
+ void start();
+ void write_register( int, int );
+ void run( nes_time_t, nes_time_t );
+ void recalc_irq();
+ void fill_buffer();
+ void reload_sample();
+ void reset();
+ int count_reads( nes_time_t, nes_time_t* ) const;
+ nes_time_t next_read_time() const;
+};
+
+#endif
diff --git a/src/libs/gme/Nes_Vrc6_Apu.h b/src/libs/gme/Nes_Vrc6_Apu.h
index 18722233..23a6519f 100644
--- a/src/libs/gme/Nes_Vrc6_Apu.h
+++ b/src/libs/gme/Nes_Vrc6_Apu.h
@@ -1,95 +1,95 @@
// Konami VRC6 sound chip emulator
// Nes_Snd_Emu 0.1.8
#ifndef NES_VRC6_APU_H
#define NES_VRC6_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
struct vrc6_apu_state_t;
class Nes_Vrc6_Apu {
public:
// See Nes_Apu.h for reference
void reset();
void volume( double );
void treble_eq( blip_eq_t const& );
void output( Blip_Buffer* );
enum { osc_count = 3 };
void osc_output( int index, Blip_Buffer* );
void end_frame( blip_time_t );
void save_state( vrc6_apu_state_t* ) const;
void load_state( vrc6_apu_state_t const& );
// Oscillator 0 write-only registers are at $9000-$9002
// Oscillator 1 write-only registers are at $A000-$A002
// Oscillator 2 write-only registers are at $B000-$B002
enum { reg_count = 3 };
enum { base_addr = 0x9000 };
enum { addr_step = 0x1000 };
void write_osc( blip_time_t, int osc, int reg, int data );
public:
Nes_Vrc6_Apu();
BLARGG_DISABLE_NOTHROW
private:
// noncopyable
Nes_Vrc6_Apu( const Nes_Vrc6_Apu& );
Nes_Vrc6_Apu& operator = ( const Nes_Vrc6_Apu& );
struct Vrc6_Osc
{
- BOOST::uint8_t regs [3];
+ uint8_t regs [3];
Blip_Buffer* output;
int delay;
int last_amp;
int phase;
int amp; // only used by saw
int period() const
{
return (regs [2] & 0x0F) * 0x100L + regs [1] + 1;
}
};
Vrc6_Osc oscs [osc_count];
blip_time_t last_time;
Blip_Synth<blip_med_quality,1> saw_synth;
Blip_Synth<blip_good_quality,1> square_synth;
void run_until( blip_time_t );
void run_square( Vrc6_Osc& osc, blip_time_t );
void run_saw( blip_time_t );
};
struct vrc6_apu_state_t
{
- BOOST::uint8_t regs [3] [3];
- BOOST::uint8_t saw_amp;
- BOOST::uint16_t delays [3];
- BOOST::uint8_t phases [3];
- BOOST::uint8_t unused;
+ uint8_t regs [3] [3];
+ uint8_t saw_amp;
+ uint16_t delays [3];
+ uint8_t phases [3];
+ uint8_t unused;
};
inline void Nes_Vrc6_Apu::osc_output( int i, Blip_Buffer* buf )
{
assert( (unsigned) i < osc_count );
oscs [i].output = buf;
}
inline void Nes_Vrc6_Apu::volume( double v )
{
double const factor = 0.0967 * 2;
saw_synth.volume( factor / 31 * v );
square_synth.volume( factor * 0.5 / 15 * v );
}
inline void Nes_Vrc6_Apu::treble_eq( blip_eq_t const& eq )
{
saw_synth.treble_eq( eq );
square_synth.treble_eq( eq );
}
#endif
diff --git a/src/libs/gme/Nsf_Emu.cpp b/src/libs/gme/Nsf_Emu.cpp
index 6e58164c..74d76850 100644
--- a/src/libs/gme/Nsf_Emu.cpp
+++ b/src/libs/gme/Nsf_Emu.cpp
@@ -1,559 +1,561 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Nsf_Emu.h"
#include "blargg_endian.h"
#include <string.h>
#include <stdio.h>
#if !NSF_EMU_APU_ONLY
#include "Nes_Namco_Apu.h"
#include "Nes_Vrc6_Apu.h"
#include "Nes_Fme7_Apu.h"
#endif
/* Copyright (C) 2003-2006 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 vrc6_flag = 0x01;
int const namco_flag = 0x10;
int const fme7_flag = 0x20;
long const clock_divisor = 12;
-Nsf_Emu::equalizer_t const Nsf_Emu::nes_eq = { -1.0, 80 };
-Nsf_Emu::equalizer_t const Nsf_Emu::famicom_eq = { -15.0, 80 };
+Nsf_Emu::equalizer_t const Nsf_Emu::nes_eq =
+ Music_Emu::make_equalizer( -1.0, 80 );
+Nsf_Emu::equalizer_t const Nsf_Emu::famicom_eq =
+ Music_Emu::make_equalizer( -15.0, 80 );
int Nsf_Emu::pcm_read( void* emu, nes_addr_t addr )
{
return *((Nsf_Emu*) emu)->cpu::get_code( addr );
}
Nsf_Emu::Nsf_Emu()
{
vrc6 = 0;
namco = 0;
fme7 = 0;
set_type( gme_nsf_type );
set_silence_lookahead( 6 );
apu.dmc_reader( pcm_read, this );
Music_Emu::set_equalizer( nes_eq );
set_gain( 1.4 );
memset( unmapped_code, Nes_Cpu::bad_opcode, sizeof unmapped_code );
}
Nsf_Emu::~Nsf_Emu() { unload(); }
void Nsf_Emu::unload()
{
#if !NSF_EMU_APU_ONLY
{
delete vrc6;
vrc6 = 0;
delete namco;
namco = 0;
delete fme7;
fme7 = 0;
}
#endif
rom.clear();
Music_Emu::unload();
}
// Track info
static void copy_nsf_fields( Nsf_Emu::header_t const& h, track_info_t* out )
{
GME_COPY_FIELD( h, out, game );
GME_COPY_FIELD( h, out, author );
GME_COPY_FIELD( h, out, copyright );
if ( h.chip_flags )
Gme_File::copy_field_( out->system, "Famicom" );
}
blargg_err_t Nsf_Emu::track_info_( track_info_t* out, int ) const
{
copy_nsf_fields( header_, out );
return 0;
}
static blargg_err_t check_nsf_header( void const* header )
{
if ( memcmp( header, "NESM\x1A", 5 ) )
return gme_wrong_file_type;
return 0;
}
struct Nsf_File : Gme_Info_
{
Nsf_Emu::header_t h;
Nsf_File() { set_type( gme_nsf_type ); }
blargg_err_t load_( Data_Reader& in )
{
blargg_err_t err = in.read( &h, Nsf_Emu::header_size );
if ( err )
return (err == in.eof_error ? gme_wrong_file_type : err);
if ( h.chip_flags & ~(namco_flag | vrc6_flag | fme7_flag) )
set_warning( "Uses unsupported audio expansion hardware" );
set_track_count( h.track_count );
return check_nsf_header( &h );
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
copy_nsf_fields( h, out );
return 0;
}
};
static Music_Emu* new_nsf_emu () { return BLARGG_NEW Nsf_Emu ; }
static Music_Emu* new_nsf_file() { return BLARGG_NEW Nsf_File; }
static gme_type_t_ const gme_nsf_type_ = { "Nintendo NES", 0, &new_nsf_emu, &new_nsf_file, "NSF", 1 };
-gme_type_t const gme_nsf_type = &gme_nsf_type_;
+BLARGG_EXPORT extern gme_type_t const gme_nsf_type = &gme_nsf_type_;
// Setup
void Nsf_Emu::set_tempo_( double t )
{
unsigned playback_rate = get_le16( header_.ntsc_speed );
unsigned standard_rate = 0x411A;
clock_rate_ = 1789772.72727;
play_period = 262 * 341L * 4 - 2; // two fewer PPU clocks every four frames
if ( pal_only )
{
play_period = 33247 * clock_divisor;
clock_rate_ = 1662607.125;
standard_rate = 0x4E20;
playback_rate = get_le16( header_.pal_speed );
}
if ( !playback_rate )
playback_rate = standard_rate;
if ( playback_rate != standard_rate || t != 1.0 )
play_period = long (playback_rate * clock_rate_ / (1000000.0 / clock_divisor * t));
apu.set_tempo( t );
}
blargg_err_t Nsf_Emu::init_sound()
{
if ( header_.chip_flags & ~(namco_flag | vrc6_flag | fme7_flag) )
set_warning( "Uses unsupported audio expansion hardware" );
{
#define APU_NAMES "Square 1", "Square 2", "Triangle", "Noise", "DMC"
int const count = Nes_Apu::osc_count;
static const char* const apu_names [count] = { APU_NAMES };
set_voice_count( count );
set_voice_names( apu_names );
}
static int const types [] = {
wave_type | 1, wave_type | 2, wave_type | 0,
noise_type | 0, mixed_type | 1,
wave_type | 3, wave_type | 4, wave_type | 5,
wave_type | 6, wave_type | 7, wave_type | 8, wave_type | 9,
wave_type |10, wave_type |11, wave_type |12, wave_type |13
};
set_voice_types( types ); // common to all sound chip configurations
double adjusted_gain = gain();
#if NSF_EMU_APU_ONLY
{
if ( header_.chip_flags )
set_warning( "Uses unsupported audio expansion hardware" );
}
#else
{
if ( header_.chip_flags & (namco_flag | vrc6_flag | fme7_flag) )
set_voice_count( Nes_Apu::osc_count + 3 );
if ( header_.chip_flags & namco_flag )
{
namco = BLARGG_NEW Nes_Namco_Apu;
CHECK_ALLOC( namco );
adjusted_gain *= 0.75;
int const count = Nes_Apu::osc_count + Nes_Namco_Apu::osc_count;
static const char* const names [count] = {
APU_NAMES,
"Wave 1", "Wave 2", "Wave 3", "Wave 4",
"Wave 5", "Wave 6", "Wave 7", "Wave 8"
};
set_voice_count( count );
set_voice_names( names );
}
if ( header_.chip_flags & vrc6_flag )
{
vrc6 = BLARGG_NEW Nes_Vrc6_Apu;
CHECK_ALLOC( vrc6 );
adjusted_gain *= 0.75;
{
int const count = Nes_Apu::osc_count + Nes_Vrc6_Apu::osc_count;
static const char* const names [count] = {
APU_NAMES,
"Saw Wave", "Square 3", "Square 4"
};
set_voice_count( count );
set_voice_names( names );
}
if ( header_.chip_flags & namco_flag )
{
int const count = Nes_Apu::osc_count + Nes_Vrc6_Apu::osc_count +
Nes_Namco_Apu::osc_count;
static const char* const names [count] = {
APU_NAMES,
"Saw Wave", "Square 3", "Square 4",
"Wave 1", "Wave 2", "Wave 3", "Wave 4",
"Wave 5", "Wave 6", "Wave 7", "Wave 8"
};
set_voice_count( count );
set_voice_names( names );
}
}
if ( header_.chip_flags & fme7_flag )
{
fme7 = BLARGG_NEW Nes_Fme7_Apu;
CHECK_ALLOC( fme7 );
adjusted_gain *= 0.75;
int const count = Nes_Apu::osc_count + Nes_Fme7_Apu::osc_count;
static const char* const names [count] = {
APU_NAMES,
"Square 3", "Square 4", "Square 5"
};
set_voice_count( count );
set_voice_names( names );
}
if ( namco ) namco->volume( adjusted_gain );
if ( vrc6 ) vrc6 ->volume( adjusted_gain );
if ( fme7 ) fme7 ->volume( adjusted_gain );
}
#endif
apu.volume( adjusted_gain );
return 0;
}
blargg_err_t Nsf_Emu::load_( Data_Reader& in )
{
assert( offsetof (header_t,unused [4]) == header_size );
RETURN_ERR( rom.load( in, header_size, &header_, 0 ) );
set_track_count( header_.track_count );
RETURN_ERR( check_nsf_header( &header_ ) );
if ( header_.vers != 1 )
set_warning( "Unknown file version" );
// sound and memory
blargg_err_t err = init_sound();
if ( err )
return err;
// set up data
nes_addr_t load_addr = get_le16( header_.load_addr );
init_addr = get_le16( header_.init_addr );
play_addr = get_le16( header_.play_addr );
if ( !load_addr ) load_addr = rom_begin;
if ( !init_addr ) init_addr = rom_begin;
if ( !play_addr ) play_addr = rom_begin;
if ( load_addr < rom_begin || init_addr < rom_begin )
{
const char* w = warning();
if ( !w )
w = "Corrupt file (invalid load/init/play address)";
return w;
}
rom.set_addr( load_addr % bank_size );
int total_banks = rom.size() / bank_size;
// bank switching
int first_bank = (load_addr - rom_begin) / bank_size;
for ( int i = 0; i < bank_count; i++ )
{
unsigned bank = i - first_bank;
if ( bank >= (unsigned) total_banks )
bank = 0;
initial_banks [i] = bank;
if ( header_.banks [i] )
{
// bank-switched
memcpy( initial_banks, header_.banks, sizeof initial_banks );
break;
}
}
pal_only = (header_.speed_flags & 3) == 1;
#if !NSF_EMU_EXTRA_FLAGS
header_.speed_flags = 0;
#endif
set_tempo( tempo() );
return setup_buffer( (long) (clock_rate_ + 0.5) );
}
void Nsf_Emu::update_eq( blip_eq_t const& eq )
{
apu.treble_eq( eq );
#if !NSF_EMU_APU_ONLY
{
if ( namco ) namco->treble_eq( eq );
if ( vrc6 ) vrc6 ->treble_eq( eq );
if ( fme7 ) fme7 ->treble_eq( eq );
}
#endif
}
void Nsf_Emu::set_voice( int i, Blip_Buffer* buf, Blip_Buffer*, Blip_Buffer* )
{
if ( i < Nes_Apu::osc_count )
{
apu.osc_output( i, buf );
return;
}
i -= Nes_Apu::osc_count;
#if !NSF_EMU_APU_ONLY
{
if ( fme7 && i < Nes_Fme7_Apu::osc_count )
{
fme7->osc_output( i, buf );
return;
}
if ( vrc6 )
{
if ( i < Nes_Vrc6_Apu::osc_count )
{
// put saw first
if ( --i < 0 )
i = 2;
vrc6->osc_output( i, buf );
return;
}
i -= Nes_Vrc6_Apu::osc_count;
}
if ( namco && i < Nes_Namco_Apu::osc_count )
{
namco->osc_output( i, buf );
return;
}
}
#endif
}
// Emulation
// see nes_cpu_io.h for read/write functions
void Nsf_Emu::cpu_write_misc( nes_addr_t addr, int data )
{
#if !NSF_EMU_APU_ONLY
{
if ( namco )
{
switch ( addr )
{
case Nes_Namco_Apu::data_reg_addr:
namco->write_data( time(), data );
return;
case Nes_Namco_Apu::addr_reg_addr:
namco->write_addr( data );
return;
}
}
if ( addr >= Nes_Fme7_Apu::latch_addr && fme7 )
{
switch ( addr & Nes_Fme7_Apu::addr_mask )
{
case Nes_Fme7_Apu::latch_addr:
fme7->write_latch( data );
return;
case Nes_Fme7_Apu::data_addr:
fme7->write_data( time(), data );
return;
}
}
if ( vrc6 )
{
unsigned reg = addr & (Nes_Vrc6_Apu::addr_step - 1);
unsigned osc = unsigned (addr - Nes_Vrc6_Apu::base_addr) / Nes_Vrc6_Apu::addr_step;
if ( osc < Nes_Vrc6_Apu::osc_count && reg < Nes_Vrc6_Apu::reg_count )
{
vrc6->write_osc( time(), osc, reg, data );
return;
}
}
}
#endif
// unmapped write
#ifndef NDEBUG
{
// some games write to $8000 and $8001 repeatedly
if ( addr == 0x8000 || addr == 0x8001 ) return;
// probably namco sound mistakenly turned on in mck
if ( addr == 0x4800 || addr == 0xF800 ) return;
// memory mapper?
if ( addr == 0xFFF8 ) return;
debug_printf( "write_unmapped( 0x%04X, 0x%02X )\n", (unsigned) addr, (unsigned) data );
}
#endif
}
blargg_err_t Nsf_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( low_mem, 0, sizeof low_mem );
memset( sram, 0, sizeof sram );
cpu::reset( unmapped_code ); // also maps low_mem
cpu::map_code( sram_addr, sizeof sram, sram );
for ( int i = 0; i < bank_count; ++i )
cpu_write( bank_select_addr + i, initial_banks [i] );
apu.reset( pal_only, (header_.speed_flags & 0x20) ? 0x3F : 0 );
apu.write_register( 0, 0x4015, 0x0F );
apu.write_register( 0, 0x4017, (header_.speed_flags & 0x10) ? 0x80 : 0 );
#if !NSF_EMU_APU_ONLY
{
if ( namco ) namco->reset();
if ( vrc6 ) vrc6 ->reset();
if ( fme7 ) fme7 ->reset();
}
#endif
play_ready = 4;
play_extra = 0;
next_play = play_period / clock_divisor;
saved_state.pc = badop_addr;
low_mem [0x1FF] = (badop_addr - 1) >> 8;
low_mem [0x1FE] = (badop_addr - 1) & 0xFF;
r.sp = 0xFD;
r.pc = init_addr;
r.a = track;
r.x = pal_only;
return 0;
}
blargg_err_t Nsf_Emu::run_clocks( blip_time_t& duration, int )
{
set_time( 0 );
while ( time() < duration )
{
nes_time_t end = min( (blip_time_t) next_play, duration );
end = min( end, time() + 32767 ); // allows CPU to use 16-bit time delta
if ( cpu::run( end ) )
{
if ( r.pc != badop_addr )
{
set_warning( "Emulation error (illegal instruction)" );
r.pc++;
}
else
{
play_ready = 1;
if ( saved_state.pc != badop_addr )
{
cpu::r = saved_state;
saved_state.pc = badop_addr;
}
else
{
set_time( end );
}
}
}
if ( time() >= next_play )
{
nes_time_t period = (play_period + play_extra) / clock_divisor;
play_extra = play_period - period * clock_divisor;
next_play += period;
if ( play_ready && !--play_ready )
{
check( saved_state.pc == badop_addr );
if ( r.pc != badop_addr )
saved_state = cpu::r;
r.pc = play_addr;
low_mem [0x100 + r.sp--] = (badop_addr - 1) >> 8;
low_mem [0x100 + r.sp--] = (badop_addr - 1) & 0xFF;
GME_FRAME_HOOK( this );
}
}
}
if ( cpu::error_count() )
{
cpu::clear_error_count();
set_warning( "Emulation error (illegal instruction)" );
}
duration = time();
next_play -= duration;
check( next_play >= 0 );
if ( next_play < 0 )
next_play = 0;
apu.end_frame( duration );
#if !NSF_EMU_APU_ONLY
{
if ( namco ) namco->end_frame( duration );
if ( vrc6 ) vrc6 ->end_frame( duration );
if ( fme7 ) fme7 ->end_frame( duration );
}
#endif
return 0;
}
diff --git a/src/libs/gme/Nsf_Emu.h b/src/libs/gme/Nsf_Emu.h
index 72452a6b..e538b1b3 100644
--- a/src/libs/gme/Nsf_Emu.h
+++ b/src/libs/gme/Nsf_Emu.h
@@ -1,106 +1,106 @@
// Nintendo NES/Famicom NSF music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef NSF_EMU_H
#define NSF_EMU_H
#include "Classic_Emu.h"
#include "Nes_Apu.h"
#include "Nes_Cpu.h"
class Nsf_Emu : private Nes_Cpu, public Classic_Emu {
typedef Nes_Cpu cpu;
public:
// Equalizer profiles for US NES and Japanese Famicom
static equalizer_t const nes_eq;
static equalizer_t const famicom_eq;
// NSF file header
enum { header_size = 0x80 };
struct header_t
{
char tag [5];
byte vers;
byte track_count;
byte first_track;
byte load_addr [2];
byte init_addr [2];
byte play_addr [2];
char game [32];
char author [32];
char copyright [32];
byte ntsc_speed [2];
byte banks [8];
byte pal_speed [2];
byte speed_flags;
byte chip_flags;
byte unused [4];
};
// Header for currently loaded file
header_t const& header() const { return header_; }
static gme_type_t static_type() { return gme_nsf_type; }
public:
// deprecated
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
public:
Nsf_Emu();
~Nsf_Emu();
Nes_Apu* apu_() { return &apu; }
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_( Data_Reader& );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
void unload();
protected:
enum { bank_count = 8 };
byte initial_banks [bank_count];
nes_addr_t init_addr;
nes_addr_t play_addr;
double clock_rate_;
bool pal_only;
// timing
Nes_Cpu::registers_t saved_state;
nes_time_t next_play;
nes_time_t play_period;
int play_extra;
int play_ready;
enum { rom_begin = 0x8000 };
enum { bank_select_addr = 0x5FF8 };
enum { bank_size = 0x1000 };
Rom_Data<bank_size> rom;
public: private: friend class Nes_Cpu;
void cpu_jsr( nes_addr_t );
int cpu_read( nes_addr_t );
void cpu_write( nes_addr_t, int );
void cpu_write_misc( nes_addr_t, int );
enum { badop_addr = bank_select_addr };
private:
class Nes_Namco_Apu* namco;
class Nes_Vrc6_Apu* vrc6;
class Nes_Fme7_Apu* fme7;
Nes_Apu apu;
static int pcm_read( void*, nes_addr_t );
blargg_err_t init_sound();
header_t header_;
enum { sram_addr = 0x6000 };
byte sram [0x2000];
byte unmapped_code [Nes_Cpu::page_size + 8];
};
#endif
diff --git a/src/libs/gme/Nsfe_Emu.cpp b/src/libs/gme/Nsfe_Emu.cpp
index eb8cdadf..1b405345 100644
--- a/src/libs/gme/Nsfe_Emu.cpp
+++ b/src/libs/gme/Nsfe_Emu.cpp
@@ -1,332 +1,332 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Nsfe_Emu.h"
#include "blargg_endian.h"
#include <string.h>
#include <ctype.h>
/* Copyright (C) 2005-2006 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"
Nsfe_Info::Nsfe_Info() { playlist_disabled = false; }
Nsfe_Info::~Nsfe_Info() { }
inline void Nsfe_Info::unload()
{
track_name_data.clear();
track_names.clear();
playlist.clear();
track_times.clear();
}
// TODO: if no playlist, treat as if there is a playlist that is just 1,2,3,4,5... ?
void Nsfe_Info::disable_playlist( bool b )
{
playlist_disabled = b;
info.track_count = playlist.size();
if ( !info.track_count || playlist_disabled )
info.track_count = actual_track_count_;
}
int Nsfe_Info::remap_track( int track ) const
{
if ( !playlist_disabled && (unsigned) track < playlist.size() )
track = playlist [track];
return track;
}
// Read multiple strings and separate into individual strings
static blargg_err_t read_strs( Data_Reader& in, long size, blargg_vector<char>& chars,
blargg_vector<const char*>& strs )
{
RETURN_ERR( chars.resize( size + 1 ) );
chars [size] = 0; // in case last string doesn't have terminator
RETURN_ERR( in.read( &chars [0], size ) );
RETURN_ERR( strs.resize( 128 ) );
int count = 0;
for ( int i = 0; i < size; i++ )
{
if ( (int) strs.size() <= count )
RETURN_ERR( strs.resize( count * 2 ) );
strs [count++] = &chars [i];
while ( i < size && chars [i] )
i++;
}
return strs.resize( count );
}
// Copy in to out, where out has out_max characters allocated. Truncate to
// out_max - 1 characters.
static void copy_str( const char* in, char* out, int out_max )
{
out [out_max - 1] = 0;
strncpy( out, in, out_max - 1 );
}
struct nsfe_info_t
{
byte load_addr [2];
byte init_addr [2];
byte play_addr [2];
byte speed_flags;
byte chip_flags;
byte track_count;
byte first_track;
byte unused [6];
};
blargg_err_t Nsfe_Info::load( Data_Reader& in, Nsf_Emu* nsf_emu )
{
int const nsfe_info_size = 16;
assert( offsetof (nsfe_info_t,unused [6]) == nsfe_info_size );
// check header
byte signature [4];
blargg_err_t err = in.read( signature, sizeof signature );
if ( err )
return (err == in.eof_error ? gme_wrong_file_type : err);
if ( memcmp( signature, "NSFE", 4 ) )
return gme_wrong_file_type;
// free previous info
track_name_data.clear();
track_names.clear();
playlist.clear();
track_times.clear();
// default nsf header
static const Nsf_Emu::header_t base_header =
{
{'N','E','S','M','\x1A'},// tag
1, // version
1, 1, // track count, first track
{0,0},{0,0},{0,0}, // addresses
"","","", // strings
{0x1A, 0x41}, // NTSC rate
{0,0,0,0,0,0,0,0}, // banks
{0x20, 0x4E}, // PAL rate
0, 0, // flags
{0,0,0,0} // unused
};
Nsf_Emu::header_t& header = info;
header = base_header;
// parse tags
int phase = 0;
while ( phase != 3 )
{
// read size and tag
byte block_header [2] [4];
RETURN_ERR( in.read( block_header, sizeof block_header ) );
blargg_long size = get_le32( block_header [0] );
blargg_long tag = get_le32( block_header [1] );
//debug_printf( "tag: %c%c%c%c\n", char(tag), char(tag>>8), char(tag>>16), char(tag>>24) );
switch ( tag )
{
case BLARGG_4CHAR('O','F','N','I'): {
check( phase == 0 );
if ( size < 8 )
return "Corrupt file";
nsfe_info_t finfo;
finfo.track_count = 1;
finfo.first_track = 0;
RETURN_ERR( in.read( &finfo, min( size, (blargg_long) nsfe_info_size ) ) );
if ( size > nsfe_info_size )
RETURN_ERR( in.skip( size - nsfe_info_size ) );
phase = 1;
info.speed_flags = finfo.speed_flags;
info.chip_flags = finfo.chip_flags;
info.track_count = finfo.track_count;
this->actual_track_count_ = finfo.track_count;
info.first_track = finfo.first_track;
memcpy( info.load_addr, finfo.load_addr, 2 * 3 );
break;
}
case BLARGG_4CHAR('K','N','A','B'):
if ( size > (int) sizeof info.banks )
return "Corrupt file";
RETURN_ERR( in.read( info.banks, size ) );
break;
case BLARGG_4CHAR('h','t','u','a'): {
blargg_vector<char> chars;
blargg_vector<const char*> strs;
RETURN_ERR( read_strs( in, size, chars, strs ) );
int n = strs.size();
if ( n > 3 )
copy_str( strs [3], info.dumper, sizeof info.dumper );
if ( n > 2 )
copy_str( strs [2], info.copyright, sizeof info.copyright );
if ( n > 1 )
copy_str( strs [1], info.author, sizeof info.author );
if ( n > 0 )
copy_str( strs [0], info.game, sizeof info.game );
break;
}
case BLARGG_4CHAR('e','m','i','t'):
RETURN_ERR( track_times.resize( size / 4 ) );
RETURN_ERR( in.read( track_times.begin(), track_times.size() * 4 ) );
break;
case BLARGG_4CHAR('l','b','l','t'):
RETURN_ERR( read_strs( in, size, track_name_data, track_names ) );
break;
case BLARGG_4CHAR('t','s','l','p'):
RETURN_ERR( playlist.resize( size ) );
RETURN_ERR( in.read( &playlist [0], size ) );
break;
case BLARGG_4CHAR('A','T','A','D'): {
check( phase == 1 );
phase = 2;
if ( !nsf_emu )
{
RETURN_ERR( in.skip( size ) );
}
else
{
Subset_Reader sub( &in, size ); // limit emu to nsf data
Remaining_Reader rem( &header, Nsf_Emu::header_size, &sub );
RETURN_ERR( nsf_emu->load( rem ) );
check( rem.remain() == 0 );
}
break;
}
case BLARGG_4CHAR('D','N','E','N'):
check( phase == 2 );
phase = 3;
break;
default:
// tags that can be skipped start with a lowercase character
check( islower( (tag >> 24) & 0xFF ) );
RETURN_ERR( in.skip( size ) );
break;
}
}
return 0;
}
blargg_err_t Nsfe_Info::track_info_( track_info_t* out, int track ) const
{
int remapped = remap_track( track );
if ( (unsigned) remapped < track_times.size() )
{
- long length = (BOOST::int32_t) get_le32( track_times [remapped] );
+ long length = (int32_t) get_le32( track_times [remapped] );
if ( length > 0 )
out->length = length;
}
if ( (unsigned) remapped < track_names.size() )
Gme_File::copy_field_( out->song, track_names [remapped] );
GME_COPY_FIELD( info, out, game );
GME_COPY_FIELD( info, out, author );
GME_COPY_FIELD( info, out, copyright );
GME_COPY_FIELD( info, out, dumper );
return 0;
}
Nsfe_Emu::Nsfe_Emu()
{
loading = false;
set_type( gme_nsfe_type );
}
Nsfe_Emu::~Nsfe_Emu() { }
void Nsfe_Emu::unload()
{
if ( !loading )
info.unload(); // TODO: extremely hacky!
Nsf_Emu::unload();
}
blargg_err_t Nsfe_Emu::track_info_( track_info_t* out, int track ) const
{
return info.track_info_( out, track );
}
struct Nsfe_File : Gme_Info_
{
Nsfe_Info info;
Nsfe_File() { set_type( gme_nsfe_type ); }
blargg_err_t load_( Data_Reader& in )
{
RETURN_ERR( info.load( in, 0 ) );
info.disable_playlist( false );
set_track_count( info.info.track_count );
return 0;
}
blargg_err_t track_info_( track_info_t* out, int track ) const
{
return info.track_info_( out, track );
}
};
static Music_Emu* new_nsfe_emu () { return BLARGG_NEW Nsfe_Emu ; }
static Music_Emu* new_nsfe_file() { return BLARGG_NEW Nsfe_File; }
static gme_type_t_ const gme_nsfe_type_ = { "Nintendo NES", 0, &new_nsfe_emu, &new_nsfe_file, "NSFE", 1 };
-gme_type_t const gme_nsfe_type = &gme_nsfe_type_;
+BLARGG_EXPORT extern gme_type_t const gme_nsfe_type = &gme_nsfe_type_;
blargg_err_t Nsfe_Emu::load_( Data_Reader& in )
{
if ( loading )
return Nsf_Emu::load_( in );
// TODO: this hacky recursion-avoidance could have subtle problems
loading = true;
blargg_err_t err = info.load( in, this );
loading = false;
disable_playlist( false );
return err;
}
void Nsfe_Emu::disable_playlist( bool b )
{
info.disable_playlist( b );
set_track_count( info.info.track_count );
}
void Nsfe_Emu::clear_playlist_()
{
disable_playlist();
Nsf_Emu::clear_playlist_();
}
blargg_err_t Nsfe_Emu::start_track_( int track )
{
return Nsf_Emu::start_track_( info.remap_track( track ) );
}
diff --git a/src/libs/gme/Nsfe_Emu.h b/src/libs/gme/Nsfe_Emu.h
index 9a00f146..fd65f0af 100644
--- a/src/libs/gme/Nsfe_Emu.h
+++ b/src/libs/gme/Nsfe_Emu.h
@@ -1,68 +1,68 @@
// Nintendo NES/Famicom NSFE music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef NSFE_EMU_H
#define NSFE_EMU_H
#include "blargg_common.h"
#include "Nsf_Emu.h"
// Allows reading info from NSFE file without creating emulator
class Nsfe_Info {
public:
blargg_err_t load( Data_Reader&, Nsf_Emu* );
struct info_t : Nsf_Emu::header_t
{
char game [256];
char author [256];
char copyright [256];
char dumper [256];
} info;
void disable_playlist( bool = true );
blargg_err_t track_info_( track_info_t* out, int track ) const;
int remap_track( int i ) const;
void unload();
Nsfe_Info();
~Nsfe_Info();
private:
blargg_vector<char> track_name_data;
blargg_vector<const char*> track_names;
blargg_vector<unsigned char> playlist;
blargg_vector<char [4]> track_times;
int actual_track_count_;
bool playlist_disabled;
};
class Nsfe_Emu : public Nsf_Emu {
public:
static gme_type_t static_type() { return gme_nsfe_type; }
public:
// deprecated
struct header_t { char tag [4]; };
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
void disable_playlist( bool = true ); // use clear_playlist()
public:
Nsfe_Emu();
~Nsfe_Emu();
protected:
blargg_err_t load_( Data_Reader& );
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t start_track_( int );
void unload();
void clear_playlist_();
private:
Nsfe_Info info;
bool loading;
};
#endif
diff --git a/src/libs/gme/SConscript b/src/libs/gme/SConscript
index 0618fde9..7daa140b 100644
--- a/src/libs/gme/SConscript
+++ b/src/libs/gme/SConscript
@@ -1,26 +1,26 @@
Import('use')
gmeEnv = use.Clone()
# These things are defined by gme_types.h
if False:
gmeEnv.Append(CPPDEFINES = Split("""USE_GME_NSF USE_GME_NSFE USE_GME_KSS
USE_GME_AY USE_GME_GBS USE_GME_GYM USE_GME_HES USE_GME_SAP USE_GME_SPC USE_GME_VGM
"""))
source = Split("""Ay_Apu.cpp Ay_Cpu.cpp Ay_Emu.cpp Blip_Buffer.cpp
Classic_Emu.cpp Data_Reader.cpp Dual_Resampler.cpp Effects_Buffer.cpp
Fir_Resampler.cpp Gb_Apu.cpp Gb_Cpu.cpp Gb_Oscs.cpp Gbs_Emu.cpp gme.cpp
Gme_File.cpp Gym_Emu.cpp Hes_Apu.cpp Hes_Cpu.cpp Hes_Emu.cpp Kss_Cpu.cpp
Kss_Emu.cpp Kss_Scc_Apu.cpp M3u_Playlist.cpp Multi_Buffer.cpp Music_Emu.cpp
Nes_Apu.cpp Nes_Cpu.cpp Nes_Fme7_Apu.cpp Nes_Namco_Apu.cpp Nes_Oscs.cpp
Nes_Vrc6_Apu.cpp Nsfe_Emu.cpp Nsf_Emu.cpp Sap_Apu.cpp Sap_Cpu.cpp Sap_Emu.cpp
-Sms_Apu.cpp Snes_Spc.cpp Spc_Cpu.cpp Spc_Dsp.cpp Spc_Emu.cpp Vgm_Emu.cpp
+Sms_Apu.cpp Snes_Spc.cpp Spc_Cpu.cpp Spc_Dsp.cpp Spc_Emu.cpp Spc_Filter.cpp Vgm_Emu.cpp
Vgm_Emu_Impl.cpp Ym2413_Emu.cpp Ym2612_Emu.cpp""")
library = []
for s in source:
library.append(gmeEnv.Object(s))
Return('library')
diff --git a/src/libs/gme/Sap_Apu.cpp b/src/libs/gme/Sap_Apu.cpp
index fa9bc4b1..26fa2d13 100644
--- a/src/libs/gme/Sap_Apu.cpp
+++ b/src/libs/gme/Sap_Apu.cpp
@@ -1,334 +1,334 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Sap_Apu.h"
#include <string.h>
/* Copyright (C) 2006 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 max_frequency = 12000; // pure waves above this frequency are silenced
static void gen_poly( blargg_ulong mask, int count, byte* out )
{
blargg_ulong n = 1;
do
{
int bits = 0;
int b = 0;
do
{
// implemented using "Galios configuration"
bits |= (n & 1) << b;
n = (n >> 1) ^ (mask & -(n & 1));
}
while ( b++ < 7 );
*out++ = bits;
}
while ( --count );
}
// poly5
int const poly5_len = (1 << 5) - 1;
blargg_ulong const poly5_mask = (1UL << poly5_len) - 1;
blargg_ulong const poly5 = 0x167C6EA1;
inline blargg_ulong run_poly5( blargg_ulong in, int shift )
{
return (in << shift & poly5_mask) | (in >> (poly5_len - shift));
}
#define POLY_MASK( width, tap1, tap2 ) \
((1UL << (width - 1 - tap1)) | (1UL << (width - 1 - tap2)))
Sap_Apu_Impl::Sap_Apu_Impl()
{
gen_poly( POLY_MASK( 4, 1, 0 ), sizeof poly4, poly4 );
gen_poly( POLY_MASK( 9, 5, 0 ), sizeof poly9, poly9 );
gen_poly( POLY_MASK( 17, 5, 0 ), sizeof poly17, poly17 );
if ( 0 ) // comment out to recauculate poly5 constant
{
byte poly5 [4];
gen_poly( POLY_MASK( 5, 2, 0 ), sizeof poly5, poly5 );
blargg_ulong n = poly5 [3] * 0x1000000L + poly5 [2] * 0x10000L +
poly5 [1] * 0x100L + poly5 [0];
blargg_ulong rev = n & 1;
for ( int i = 1; i < poly5_len; i++ )
rev |= (n >> i & 1) << (poly5_len - i);
debug_printf( "poly5: 0x%08lX\n", rev );
}
}
Sap_Apu::Sap_Apu()
{
impl = 0;
for ( int i = 0; i < osc_count; i++ )
osc_output( i, 0 );
}
void Sap_Apu::reset( Sap_Apu_Impl* new_impl )
{
impl = new_impl;
last_time = 0;
poly5_pos = 0;
poly4_pos = 0;
polym_pos = 0;
control = 0;
for ( int i = 0; i < osc_count; i++ )
memset( &oscs [i], 0, offsetof (osc_t,output) );
}
inline void Sap_Apu::calc_periods()
{
// 15/64 kHz clock
int divider = 28;
if ( this->control & 1 )
divider = 114;
for ( int i = 0; i < osc_count; i++ )
{
osc_t* const osc = &oscs [i];
int const osc_reload = osc->regs [0]; // cache
blargg_long period = (osc_reload + 1) * divider;
static byte const fast_bits [osc_count] = { 1 << 6, 1 << 4, 1 << 5, 1 << 3 };
if ( this->control & fast_bits [i] )
{
period = osc_reload + 4;
if ( i & 1 )
{
period = osc_reload * 0x100L + osc [-1].regs [0] + 7;
if ( !(this->control & fast_bits [i - 1]) )
period = (period - 6) * divider;
if ( (osc [-1].regs [1] & 0x1F) > 0x10 )
debug_printf( "Use of slave channel in 16-bit mode not supported\n" );
}
}
osc->period = period;
}
}
void Sap_Apu::run_until( blip_time_t end_time )
{
calc_periods();
Sap_Apu_Impl* const impl = this->impl; // cache
// 17/9-bit poly selection
byte const* polym = impl->poly17;
int polym_len = poly17_len;
if ( this->control & 0x80 )
{
polym_len = poly9_len;
polym = impl->poly9;
}
polym_pos %= polym_len;
for ( int i = 0; i < osc_count; i++ )
{
osc_t* const osc = &oscs [i];
blip_time_t time = last_time + osc->delay;
blip_time_t const period = osc->period;
// output
Blip_Buffer* output = osc->output;
if ( output )
{
output->set_modified();
int const osc_control = osc->regs [1]; // cache
int volume = (osc_control & 0x0F) * 2;
if ( !volume || osc_control & 0x10 || // silent, DAC mode, or inaudible frequency
((osc_control & 0xA0) == 0xA0 && period < 1789773 / 2 / max_frequency) )
{
if ( !(osc_control & 0x10) )
volume >>= 1; // inaudible frequency = half volume
int delta = volume - osc->last_amp;
if ( delta )
{
osc->last_amp = volume;
impl->synth.offset( last_time, delta, output );
}
// TODO: doesn't maintain high pass flip-flop (very minor issue)
}
else
{
// high pass
static byte const hipass_bits [osc_count] = { 1 << 2, 1 << 1, 0, 0 };
blip_time_t period2 = 0; // unused if no high pass
blip_time_t time2 = end_time;
if ( this->control & hipass_bits [i] )
{
period2 = osc [2].period;
time2 = last_time + osc [2].delay;
if ( osc->invert )
{
// trick inner wave loop into inverting output
osc->last_amp -= volume;
volume = -volume;
}
}
if ( time < end_time || time2 < end_time )
{
// poly source
static byte const poly1 [] = { 0x55, 0x55 }; // square wave
byte const* poly = poly1;
int poly_len = 8 * sizeof poly1; // can be just 2 bits, but this is faster
int poly_pos = osc->phase & 1;
int poly_inc = 1;
if ( !(osc_control & 0x20) )
{
poly = polym;
poly_len = polym_len;
poly_pos = polym_pos;
if ( osc_control & 0x40 )
{
poly = impl->poly4;
poly_len = poly4_len;
poly_pos = poly4_pos;
}
poly_inc = period % poly_len;
poly_pos = (poly_pos + osc->delay) % poly_len;
}
poly_inc -= poly_len; // allows more optimized inner loop below
// square/poly5 wave
blargg_ulong wave = poly5;
check( poly5 & 1 ); // low bit is set for pure wave
int poly5_inc = 0;
if ( !(osc_control & 0x80) )
{
wave = run_poly5( wave, (osc->delay + poly5_pos) % poly5_len );
poly5_inc = period % poly5_len;
}
// Run wave and high pass interleved with each catching up to the other.
// Disabled high pass has no performance effect since inner wave loop
// makes no compromise for high pass, and only runs once in that case.
int osc_last_amp = osc->last_amp;
do
{
// run high pass
if ( time2 < time )
{
int delta = -osc_last_amp;
if ( volume < 0 )
delta += volume;
if ( delta )
{
osc_last_amp += delta - volume;
volume = -volume;
impl->synth.offset( time2, delta, output );
}
}
while ( time2 <= time ) // must advance *past* time to avoid hang
time2 += period2;
// run wave
blip_time_t end = end_time;
if ( end > time2 )
end = time2;
while ( time < end )
{
if ( wave & 1 )
{
int amp = volume & -(poly [poly_pos >> 3] >> (poly_pos & 7) & 1);
if ( (poly_pos += poly_inc) < 0 )
poly_pos += poly_len;
int delta = amp - osc_last_amp;
if ( delta )
{
osc_last_amp = amp;
impl->synth.offset( time, delta, output );
}
}
wave = run_poly5( wave, poly5_inc );
time += period;
}
}
while ( time < end_time || time2 < end_time );
osc->phase = poly_pos;
osc->last_amp = osc_last_amp;
}
osc->invert = 0;
if ( volume < 0 )
{
// undo inversion trickery
osc->last_amp -= volume;
osc->invert = 1;
}
}
}
// maintain divider
blip_time_t remain = end_time - time;
if ( remain > 0 )
{
blargg_long count = (remain + period - 1) / period;
osc->phase ^= count;
time += count * period;
}
osc->delay = time - end_time;
}
// advance polies
blip_time_t duration = end_time - last_time;
last_time = end_time;
poly4_pos = (poly4_pos + duration) % poly4_len;
poly5_pos = (poly5_pos + duration) % poly5_len;
polym_pos += duration; // will get %'d on next call
}
void Sap_Apu::write_data( blip_time_t time, unsigned addr, int data )
{
run_until( time );
int i = (addr ^ 0xD200) >> 1;
if ( i < osc_count )
{
oscs [i].regs [addr & 1] = data;
}
else if ( addr == 0xD208 )
{
control = data;
}
else if ( addr == 0xD209 )
{
oscs [0].delay = 0;
oscs [1].delay = 0;
oscs [2].delay = 0;
oscs [3].delay = 0;
}
/*
// TODO: are polynomials reset in this case?
else if ( addr == 0xD20F )
{
if ( (data & 3) == 0 )
polym_pos = 0;
}
*/
}
void Sap_Apu::end_frame( blip_time_t end_time )
{
if ( end_time > last_time )
run_until( end_time );
last_time -= end_time;
}
diff --git a/src/libs/gme/Sap_Apu.h b/src/libs/gme/Sap_Apu.h
index a573499c..1b67571b 100644
--- a/src/libs/gme/Sap_Apu.h
+++ b/src/libs/gme/Sap_Apu.h
@@ -1,77 +1,77 @@
// Atari POKEY sound chip emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SAP_APU_H
#define SAP_APU_H
#include "blargg_common.h"
#include "Blip_Buffer.h"
class Sap_Apu_Impl;
class Sap_Apu {
public:
enum { osc_count = 4 };
void osc_output( int index, Blip_Buffer* );
void reset( Sap_Apu_Impl* );
enum { start_addr = 0xD200 };
enum { end_addr = 0xD209 };
void write_data( blip_time_t, unsigned addr, int data );
void end_frame( blip_time_t );
public:
Sap_Apu();
private:
struct osc_t
{
unsigned char regs [2];
unsigned char phase;
unsigned char invert;
int last_amp;
blip_time_t delay;
blip_time_t period; // always recalculated before use; here for convenience
Blip_Buffer* output;
};
osc_t oscs [osc_count];
Sap_Apu_Impl* impl;
blip_time_t last_time;
int poly5_pos;
int poly4_pos;
int polym_pos;
int control;
void calc_periods();
void run_until( blip_time_t );
enum { poly4_len = (1L << 4) - 1 };
enum { poly9_len = (1L << 9) - 1 };
enum { poly17_len = (1L << 17) - 1 };
friend class Sap_Apu_Impl;
};
// Common tables and Blip_Synth that can be shared among multiple Sap_Apu objects
class Sap_Apu_Impl {
public:
Blip_Synth<blip_good_quality,1> synth;
Sap_Apu_Impl();
void volume( double d ) { synth.volume( 1.0 / Sap_Apu::osc_count / 30 * d ); }
private:
typedef unsigned char byte;
byte poly4 [Sap_Apu::poly4_len / 8 + 1];
byte poly9 [Sap_Apu::poly9_len / 8 + 1];
byte poly17 [Sap_Apu::poly17_len / 8 + 1];
friend class Sap_Apu;
};
inline void Sap_Apu::osc_output( int i, Blip_Buffer* b )
{
assert( (unsigned) i < osc_count );
oscs [i].output = b;
}
#endif
diff --git a/src/libs/gme/Sap_Cpu.cpp b/src/libs/gme/Sap_Cpu.cpp
index 35e1b511..76ae277a 100644
--- a/src/libs/gme/Sap_Cpu.cpp
+++ b/src/libs/gme/Sap_Cpu.cpp
@@ -1,1011 +1,1004 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Sap_Cpu.h"
#include <limits.h>
#include "blargg_endian.h"
//#include "nes_cpu_log.h"
/* Copyright (C) 2003-2006 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 */
#define FLUSH_TIME() (void) (s.time = s_time)
#define CACHE_TIME() (void) (s_time = s.time)
#include "sap_cpu_io.h"
#ifndef CPU_DONE
#define CPU_DONE( cpu, time, result_out ) { result_out = -1; }
#endif
#include "blargg_source.h"
int const st_n = 0x80;
int const st_v = 0x40;
int const st_r = 0x20;
int const st_b = 0x10;
int const st_d = 0x08;
int const st_i = 0x04;
int const st_z = 0x02;
int const st_c = 0x01;
void Sap_Cpu::reset( void* new_mem )
{
check( state == &state_ );
state = &state_;
mem = (uint8_t*) new_mem;
r.status = st_i;
r.sp = 0xFF;
r.pc = 0;
r.a = 0;
r.x = 0;
r.y = 0;
state_.time = 0;
state_.base = 0;
irq_time_ = future_sap_time;
end_time_ = future_sap_time;
blargg_verify_byte_order();
}
#define TIME (s_time + s.base)
#define READ( addr ) CPU_READ( this, (addr), TIME )
#define WRITE( addr, data ) {CPU_WRITE( this, (addr), (data), TIME );}
#define READ_LOW( addr ) (mem [int (addr)])
#define WRITE_LOW( addr, data ) (void) (READ_LOW( addr ) = (data))
#define READ_PROG( addr ) (READ_LOW( addr ))
#define SET_SP( v ) (sp = ((v) + 1) | 0x100)
#define GET_SP() ((sp - 1) & 0xFF)
#define PUSH( v ) ((sp = (sp - 1) | 0x100), WRITE_LOW( sp, v ))
-// even on x86, using short and unsigned char was slower
-typedef int fint16;
-typedef unsigned fuint16;
-typedef unsigned fuint8;
-typedef blargg_long fint32;
-
bool Sap_Cpu::run( sap_time_t end_time )
{
bool illegal_encountered = false;
set_end_time( end_time );
state_t s = this->state_;
this->state = &s;
- fint32 s_time = s.time;
+ int32_t s_time = s.time;
uint8_t* const mem = this->mem; // cache
// registers
- fuint16 pc = r.pc;
- fuint8 a = r.a;
- fuint8 x = r.x;
- fuint8 y = r.y;
- fuint16 sp;
+ uint16_t pc = r.pc;
+ uint8_t a = r.a;
+ uint8_t x = r.x;
+ uint8_t y = r.y;
+ uint16_t sp;
SET_SP( r.sp );
// status flags
#define IS_NEG (nz & 0x8080)
#define CALC_STATUS( out ) do {\
out = status & (st_v | st_d | st_i);\
out |= ((nz >> 8) | nz) & st_n;\
out |= c >> 8 & st_c;\
if ( !(nz & 0xFF) ) out |= st_z;\
} while ( 0 )
#define SET_STATUS( in ) do {\
status = in & (st_v | st_d | st_i);\
nz = in << 8;\
c = nz;\
nz |= ~in & st_z;\
} while ( 0 )
- fuint8 status;
- fuint16 c; // carry set if (c & 0x100) != 0
- fuint16 nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
+ uint8_t status;
+ uint16_t c; // carry set if (c & 0x100) != 0
+ uint16_t nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x8080) != 0
{
- fuint8 temp = r.status;
+ uint8_t temp = r.status;
SET_STATUS( temp );
}
goto loop;
dec_clock_loop:
s_time--;
loop:
#ifndef NDEBUG
{
sap_time_t correct = end_time_;
if ( !(status & st_i) && correct > irq_time_ )
correct = irq_time_;
check( s.base == correct );
}
#endif
check( (unsigned) GET_SP() < 0x100 );
check( (unsigned) a < 0x100 );
check( (unsigned) x < 0x100 );
check( (unsigned) y < 0x100 );
- fuint8 opcode = mem [pc];
+ uint8_t opcode = mem [pc];
pc++;
uint8_t const* instr = mem + pc;
static uint8_t const clock_table [256] =
{// 0 1 2 3 4 5 6 7 8 9 A B C D E F
0,6,2,8,3,3,5,5,3,2,2,2,4,4,6,6,// 0
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 1
6,6,2,8,3,3,5,5,4,2,2,2,4,4,6,6,// 2
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 3
6,6,2,8,3,3,5,5,3,2,2,2,3,4,6,6,// 4
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 5
6,6,2,8,3,3,5,5,4,2,2,2,5,4,6,6,// 6
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// 7
2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,// 8
3,6,2,6,4,4,4,4,2,5,2,5,5,5,5,5,// 9
2,6,2,6,3,3,3,3,2,2,2,2,4,4,4,4,// A
3,5,2,5,4,4,4,4,2,4,2,4,4,4,4,4,// B
2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,// C
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7,// D
2,6,2,8,3,3,5,5,2,2,2,2,4,4,6,6,// E
3,5,2,8,4,4,6,6,2,4,2,7,4,4,7,7 // F
}; // 0x00 was 7
- fuint16 data;
+ uint16_t data;
data = clock_table [opcode];
if ( (s_time += data) >= 0 )
goto possibly_out_of_time;
almost_out_of_time:
data = *instr;
#ifdef NES_CPU_LOG_H
nes_cpu_log( "cpu_log", pc - 1, opcode, instr [0], instr [1] );
#endif
switch ( opcode )
{
possibly_out_of_time:
if ( s_time < (int) data )
goto almost_out_of_time;
s_time -= data;
goto out_of_time;
// Macros
#define GET_MSB() (instr [1])
#define ADD_PAGE() (pc++, data += 0x100 * GET_MSB())
#define GET_ADDR() GET_LE16( instr )
#define NO_PAGE_CROSSING( lsb )
#define HANDLE_PAGE_CROSSING( lsb ) s_time += (lsb) >> 8;
#define INC_DEC_XY( reg, n ) reg = uint8_t (nz = reg + n); goto loop;
#define IND_Y( cross, out ) {\
- fuint16 temp = READ_LOW( data ) + y;\
+ uint16_t temp = READ_LOW( data ) + y;\
out = temp + 0x100 * READ_LOW( uint8_t (data + 1) );\
cross( temp );\
}
#define IND_X( out ) {\
- fuint16 temp = data + x;\
+ uint16_t temp = data + x;\
out = 0x100 * READ_LOW( uint8_t (temp + 1) ) + READ_LOW( uint8_t (temp) );\
}
#define ARITH_ADDR_MODES( op )\
case op - 0x04: /* (ind,x) */\
IND_X( data )\
goto ptr##op;\
case op + 0x0C: /* (ind),y */\
IND_Y( HANDLE_PAGE_CROSSING, data )\
goto ptr##op;\
case op + 0x10: /* zp,X */\
data = uint8_t (data + x);\
case op + 0x00: /* zp */\
data = READ_LOW( data );\
goto imm##op;\
case op + 0x14: /* abs,Y */\
data += y;\
goto ind##op;\
case op + 0x18: /* abs,X */\
data += x;\
ind##op:\
HANDLE_PAGE_CROSSING( data );\
case op + 0x08: /* abs */\
ADD_PAGE();\
ptr##op:\
FLUSH_TIME();\
data = READ( data );\
CACHE_TIME();\
case op + 0x04: /* imm */\
imm##op:
// TODO: more efficient way to handle negative branch that wraps PC around
#define BRANCH( cond )\
{\
- fint16 offset = (BOOST::int8_t) data;\
- fuint16 extra_clock = (++pc & 0xFF) + offset;\
+ int16_t offset = (int8_t) data;\
+ uint16_t extra_clock = (++pc & 0xFF) + offset;\
if ( !(cond) ) goto dec_clock_loop;\
pc += offset;\
s_time += extra_clock >> 8 & 1;\
goto loop;\
}
// Often-Used
case 0xB5: // LDA zp,x
a = nz = READ_LOW( uint8_t (data + x) );
pc++;
goto loop;
case 0xA5: // LDA zp
a = nz = READ_LOW( data );
pc++;
goto loop;
case 0xD0: // BNE
BRANCH( (uint8_t) nz );
case 0x20: { // JSR
- fuint16 temp = pc + 1;
+ uint16_t temp = pc + 1;
pc = GET_ADDR();
WRITE_LOW( 0x100 | (sp - 1), temp >> 8 );
sp = (sp - 2) | 0x100;
WRITE_LOW( sp, temp );
goto loop;
}
case 0x4C: // JMP abs
pc = GET_ADDR();
goto loop;
case 0xE8: // INX
INC_DEC_XY( x, 1 )
case 0x10: // BPL
BRANCH( !IS_NEG )
ARITH_ADDR_MODES( 0xC5 ) // CMP
nz = a - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
case 0x30: // BMI
BRANCH( IS_NEG )
case 0xF0: // BEQ
BRANCH( !(uint8_t) nz );
case 0x95: // STA zp,x
data = uint8_t (data + x);
case 0x85: // STA zp
pc++;
WRITE_LOW( data, a );
goto loop;
case 0xC8: // INY
INC_DEC_XY( y, 1 )
case 0xA8: // TAY
y = a;
nz = a;
goto loop;
case 0x98: // TYA
a = y;
nz = y;
goto loop;
case 0xAD:{// LDA abs
unsigned addr = GET_ADDR();
pc += 2;
nz = READ( addr );
a = nz;
goto loop;
}
case 0x60: // RTS
pc = 1 + READ_LOW( sp );
pc += 0x100 * READ_LOW( 0x100 | (sp - 0xFF) );
sp = (sp - 0xFE) | 0x100;
goto loop;
{
- fuint16 addr;
+ uint16_t addr;
case 0x99: // STA abs,Y
addr = y + GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
goto sta_ptr;
case 0x8D: // STA abs
addr = GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
goto sta_ptr;
case 0x9D: // STA abs,X (slightly more common than STA abs)
addr = x + GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, a );
goto loop;
}
sta_ptr:
FLUSH_TIME();
WRITE( addr, a );
CACHE_TIME();
goto loop;
case 0x91: // STA (ind),Y
IND_Y( NO_PAGE_CROSSING, addr )
pc++;
goto sta_ptr;
case 0x81: // STA (ind,X)
IND_X( addr )
pc++;
goto sta_ptr;
}
case 0xA9: // LDA #imm
pc++;
a = data;
nz = data;
goto loop;
// common read instructions
{
- fuint16 addr;
+ uint16_t addr;
case 0xA1: // LDA (ind,X)
IND_X( addr )
pc++;
goto a_nz_read_addr;
case 0xB1:// LDA (ind),Y
addr = READ_LOW( data ) + y;
HANDLE_PAGE_CROSSING( addr );
addr += 0x100 * READ_LOW( (uint8_t) (data + 1) );
pc++;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
goto a_nz_read_addr;
case 0xB9: // LDA abs,Y
HANDLE_PAGE_CROSSING( data + y );
addr = GET_ADDR() + y;
pc += 2;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
goto a_nz_read_addr;
case 0xBD: // LDA abs,X
HANDLE_PAGE_CROSSING( data + x );
addr = GET_ADDR() + x;
pc += 2;
a = nz = READ_PROG( addr );
if ( (addr ^ 0x8000) <= 0x9FFF )
goto loop;
a_nz_read_addr:
FLUSH_TIME();
a = nz = READ( addr );
CACHE_TIME();
goto loop;
}
// Branch
case 0x50: // BVC
BRANCH( !(status & st_v) )
case 0x70: // BVS
BRANCH( status & st_v )
case 0xB0: // BCS
BRANCH( c & 0x100 )
case 0x90: // BCC
BRANCH( !(c & 0x100) )
// Load/store
case 0x94: // STY zp,x
data = uint8_t (data + x);
case 0x84: // STY zp
pc++;
WRITE_LOW( data, y );
goto loop;
case 0x96: // STX zp,y
data = uint8_t (data + y);
case 0x86: // STX zp
pc++;
WRITE_LOW( data, x );
goto loop;
case 0xB6: // LDX zp,y
data = uint8_t (data + y);
case 0xA6: // LDX zp
data = READ_LOW( data );
case 0xA2: // LDX #imm
pc++;
x = data;
nz = data;
goto loop;
case 0xB4: // LDY zp,x
data = uint8_t (data + x);
case 0xA4: // LDY zp
data = READ_LOW( data );
case 0xA0: // LDY #imm
pc++;
y = data;
nz = data;
goto loop;
case 0xBC: // LDY abs,X
data += x;
HANDLE_PAGE_CROSSING( data );
case 0xAC:{// LDY abs
unsigned addr = data + 0x100 * GET_MSB();
pc += 2;
FLUSH_TIME();
y = nz = READ( addr );
CACHE_TIME();
goto loop;
}
case 0xBE: // LDX abs,y
data += y;
HANDLE_PAGE_CROSSING( data );
case 0xAE:{// LDX abs
unsigned addr = data + 0x100 * GET_MSB();
pc += 2;
FLUSH_TIME();
x = nz = READ( addr );
CACHE_TIME();
goto loop;
}
{
- fuint8 temp;
+ uint8_t temp;
case 0x8C: // STY abs
temp = y;
goto store_abs;
case 0x8E: // STX abs
temp = x;
store_abs:
unsigned addr = GET_ADDR();
pc += 2;
if ( addr <= 0x7FF )
{
WRITE_LOW( addr, temp );
goto loop;
}
FLUSH_TIME();
WRITE( addr, temp );
CACHE_TIME();
goto loop;
}
// Compare
case 0xEC:{// CPX abs
unsigned addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpx_data;
}
case 0xE4: // CPX zp
data = READ_LOW( data );
case 0xE0: // CPX #imm
cpx_data:
nz = x - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
case 0xCC:{// CPY abs
unsigned addr = GET_ADDR();
pc++;
FLUSH_TIME();
data = READ( addr );
CACHE_TIME();
goto cpy_data;
}
case 0xC4: // CPY zp
data = READ_LOW( data );
case 0xC0: // CPY #imm
cpy_data:
nz = y - data;
pc++;
c = ~nz;
nz &= 0xFF;
goto loop;
// Logical
ARITH_ADDR_MODES( 0x25 ) // AND
nz = (a &= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x45 ) // EOR
nz = (a ^= data);
pc++;
goto loop;
ARITH_ADDR_MODES( 0x05 ) // ORA
nz = (a |= data);
pc++;
goto loop;
case 0x2C:{// BIT abs
unsigned addr = GET_ADDR();
pc += 2;
status &= ~st_v;
nz = READ( addr );
status |= nz & st_v;
if ( a & nz )
goto loop;
nz <<= 8; // result must be zero, even if N bit is set
goto loop;
}
case 0x24: // BIT zp
nz = READ_LOW( data );
pc++;
status &= ~st_v;
status |= nz & st_v;
if ( a & nz )
goto loop;
nz <<= 8; // result must be zero, even if N bit is set
goto loop;
// Add/subtract
ARITH_ADDR_MODES( 0xE5 ) // SBC
case 0xEB: // unofficial equivalent
data ^= 0xFF;
goto adc_imm;
ARITH_ADDR_MODES( 0x65 ) // ADC
adc_imm: {
check( !(status & st_d) );
- fint16 carry = c >> 8 & 1;
- fint16 ov = (a ^ 0x80) + carry + (BOOST::int8_t) data; // sign-extend
+ int16_t carry = c >> 8 & 1;
+ int16_t ov = (a ^ 0x80) + carry + (int8_t) data; // sign-extend
status &= ~st_v;
status |= ov >> 2 & 0x40;
c = nz = a + data + carry;
pc++;
a = (uint8_t) nz;
goto loop;
}
// Shift/rotate
case 0x4A: // LSR A
c = 0;
case 0x6A: // ROR A
nz = c >> 1 & 0x80;
c = a << 8;
nz |= a >> 1;
a = nz;
goto loop;
case 0x0A: // ASL A
nz = a << 1;
c = nz;
a = (uint8_t) nz;
goto loop;
case 0x2A: { // ROL A
nz = a << 1;
- fint16 temp = c >> 8 & 1;
+ int16_t temp = c >> 8 & 1;
c = nz;
nz |= temp;
a = (uint8_t) nz;
goto loop;
}
case 0x5E: // LSR abs,X
data += x;
case 0x4E: // LSR abs
c = 0;
case 0x6E: // ROR abs
ror_abs: {
ADD_PAGE();
FLUSH_TIME();
int temp = READ( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto rotate_common;
}
case 0x3E: // ROL abs,X
data += x;
goto rol_abs;
case 0x1E: // ASL abs,X
data += x;
case 0x0E: // ASL abs
c = 0;
case 0x2E: // ROL abs
rol_abs:
ADD_PAGE();
nz = c >> 8 & 1;
FLUSH_TIME();
nz |= (c = READ( data ) << 1);
rotate_common:
pc++;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
case 0x7E: // ROR abs,X
data += x;
goto ror_abs;
case 0x76: // ROR zp,x
data = uint8_t (data + x);
goto ror_zp;
case 0x56: // LSR zp,x
data = uint8_t (data + x);
case 0x46: // LSR zp
c = 0;
case 0x66: // ROR zp
ror_zp: {
int temp = READ_LOW( data );
nz = (c >> 1 & 0x80) | (temp >> 1);
c = temp << 8;
goto write_nz_zp;
}
case 0x36: // ROL zp,x
data = uint8_t (data + x);
goto rol_zp;
case 0x16: // ASL zp,x
data = uint8_t (data + x);
case 0x06: // ASL zp
c = 0;
case 0x26: // ROL zp
rol_zp:
nz = c >> 8 & 1;
nz |= (c = READ_LOW( data ) << 1);
goto write_nz_zp;
// Increment/decrement
case 0xCA: // DEX
INC_DEC_XY( x, -1 )
case 0x88: // DEY
INC_DEC_XY( y, -1 )
case 0xF6: // INC zp,x
data = uint8_t (data + x);
case 0xE6: // INC zp
nz = 1;
goto add_nz_zp;
case 0xD6: // DEC zp,x
data = uint8_t (data + x);
case 0xC6: // DEC zp
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
add_nz_zp:
nz += READ_LOW( data );
write_nz_zp:
pc++;
WRITE_LOW( data, nz );
goto loop;
case 0xFE: // INC abs,x
data = x + GET_ADDR();
goto inc_ptr;
case 0xEE: // INC abs
data = GET_ADDR();
inc_ptr:
nz = 1;
goto inc_common;
case 0xDE: // DEC abs,x
data = x + GET_ADDR();
goto dec_ptr;
case 0xCE: // DEC abs
data = GET_ADDR();
dec_ptr:
- nz = (unsigned) -1;
+ nz = (uint16_t) -1;
inc_common:
FLUSH_TIME();
nz += READ( data );
pc += 2;
WRITE( data, (uint8_t) nz );
CACHE_TIME();
goto loop;
// Transfer
case 0xAA: // TAX
x = a;
nz = a;
goto loop;
case 0x8A: // TXA
a = x;
nz = x;
goto loop;
case 0x9A: // TXS
SET_SP( x ); // verified (no flag change)
goto loop;
case 0xBA: // TSX
x = nz = GET_SP();
goto loop;
// Stack
case 0x48: // PHA
PUSH( a ); // verified
goto loop;
case 0x68: // PLA
a = nz = READ_LOW( sp );
sp = (sp - 0xFF) | 0x100;
goto loop;
case 0x40:{// RTI
- fuint8 temp = READ_LOW( sp );
+ uint8_t temp = READ_LOW( sp );
pc = READ_LOW( 0x100 | (sp - 0xFF) );
pc |= READ_LOW( 0x100 | (sp - 0xFE) ) * 0x100;
sp = (sp - 0xFD) | 0x100;
data = status;
SET_STATUS( temp );
this->r.status = status; // update externally-visible I flag
if ( (data ^ status) & st_i )
{
sap_time_t new_time = end_time_;
if ( !(status & st_i) && new_time > irq_time_ )
new_time = irq_time_;
blargg_long delta = s.base - new_time;
s.base = new_time;
s_time += delta;
}
goto loop;
}
case 0x28:{// PLP
- fuint8 temp = READ_LOW( sp );
+ uint8_t temp = READ_LOW( sp );
sp = (sp - 0xFF) | 0x100;
- fuint8 changed = status ^ temp;
+ uint8_t changed = status ^ temp;
SET_STATUS( temp );
if ( !(changed & st_i) )
goto loop; // I flag didn't change
if ( status & st_i )
goto handle_sei;
goto handle_cli;
}
case 0x08: { // PHP
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
PUSH( temp | (st_b | st_r) );
goto loop;
}
case 0x6C:{// JMP (ind)
data = GET_ADDR();
pc = READ_PROG( data );
data = (data & 0xFF00) | ((data + 1) & 0xFF);
pc |= 0x100 * READ_PROG( data );
goto loop;
}
case 0x00: // BRK
goto handle_brk;
// Flags
case 0x38: // SEC
- c = (unsigned) ~0;
+ c = (uint16_t) ~0;
goto loop;
case 0x18: // CLC
c = 0;
goto loop;
case 0xB8: // CLV
status &= ~st_v;
goto loop;
case 0xD8: // CLD
status &= ~st_d;
goto loop;
case 0xF8: // SED
status |= st_d;
goto loop;
case 0x58: // CLI
if ( !(status & st_i) )
goto loop;
status &= ~st_i;
handle_cli: {
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - irq_time_;
if ( delta <= 0 )
{
if ( TIME < irq_time_ )
goto loop;
goto delayed_cli;
}
s.base = irq_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
if ( delta >= s_time + 1 )
{
// delayed irq until after next instruction
s.base += s_time + 1;
s_time = -1;
irq_time_ = s.base; // TODO: remove, as only to satisfy debug check in loop
goto loop;
}
delayed_cli:
debug_printf( "Delayed CLI not emulated\n" );
goto loop;
}
case 0x78: // SEI
if ( status & st_i )
goto loop;
status |= st_i;
handle_sei: {
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - end_time_;
s.base = end_time_;
s_time += delta;
if ( s_time < 0 )
goto loop;
debug_printf( "Delayed SEI not emulated\n" );
goto loop;
}
// Unofficial
// SKW - Skip word
case 0x1C: case 0x3C: case 0x5C: case 0x7C: case 0xDC: case 0xFC:
HANDLE_PAGE_CROSSING( data + x );
case 0x0C:
pc++;
// SKB - Skip byte
case 0x74: case 0x04: case 0x14: case 0x34: case 0x44: case 0x54: case 0x64:
case 0x80: case 0x82: case 0x89: case 0xC2: case 0xD4: case 0xE2: case 0xF4:
pc++;
goto loop;
// NOP
case 0xEA: case 0x1A: case 0x3A: case 0x5A: case 0x7A: case 0xDA: case 0xFA:
goto loop;
// Unimplemented
// halt
//case 0x02: case 0x12: case 0x22: case 0x32: case 0x42: case 0x52:
//case 0x62: case 0x72: case 0x92: case 0xB2: case 0xD2: case 0xF2:
default:
- assert( (unsigned) opcode <= 0xFF );
illegal_encountered = true;
pc--;
goto stop;
}
assert( false );
int result_;
handle_brk:
if ( (pc - 1) >= idle_addr )
goto idle_done;
pc++;
result_ = 4;
debug_printf( "BRK executed\n" );
interrupt:
{
s_time += 7;
WRITE_LOW( 0x100 | (sp - 1), pc >> 8 );
WRITE_LOW( 0x100 | (sp - 2), pc );
pc = GET_LE16( &READ_PROG( 0xFFFA ) + result_ );
sp = (sp - 3) | 0x100;
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
temp |= st_r;
if ( result_ )
temp |= st_b; // TODO: incorrectly sets B flag for IRQ
WRITE_LOW( sp, temp );
status &= ~st_d;
status |= st_i;
this->r.status = status; // update externally-visible I flag
blargg_long delta = s.base - end_time_;
s.base = end_time_;
s_time += delta;
goto loop;
}
idle_done:
//s_time = 0;
pc--;
goto stop;
out_of_time:
pc--;
FLUSH_TIME();
CPU_DONE( this, TIME, result_ );
CACHE_TIME();
if ( result_ >= 0 )
goto interrupt;
if ( s_time < 0 )
goto loop;
stop:
s.time = s_time;
r.pc = pc;
r.sp = GET_SP();
r.a = a;
r.x = x;
r.y = y;
{
- fuint8 temp;
+ uint8_t temp;
CALC_STATUS( temp );
r.status = temp;
}
this->state_ = s;
this->state = &this->state_;
return illegal_encountered;
}
diff --git a/src/libs/gme/Sap_Cpu.h b/src/libs/gme/Sap_Cpu.h
index bde219f6..fdfb9a31 100644
--- a/src/libs/gme/Sap_Cpu.h
+++ b/src/libs/gme/Sap_Cpu.h
@@ -1,83 +1,81 @@
// Atari 6502 CPU emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SAP_CPU_H
#define SAP_CPU_H
#include "blargg_common.h"
typedef blargg_long sap_time_t; // clock cycle count
typedef unsigned sap_addr_t; // 16-bit address
enum { future_sap_time = INT_MAX / 2 + 1 };
class Sap_Cpu {
public:
- typedef BOOST::uint8_t uint8_t;
-
// Clear all registers and keep pointer to 64K memory passed in
void reset( void* mem_64k );
// Run until specified time is reached. Returns true if suspicious/unsupported
// instruction was encountered at any point during run.
bool run( sap_time_t end_time );
// Registers are not updated until run() returns (except I flag in status)
struct registers_t {
- BOOST::uint16_t pc;
- BOOST::uint8_t a;
- BOOST::uint8_t x;
- BOOST::uint8_t y;
- BOOST::uint8_t status;
- BOOST::uint8_t sp;
+ uint16_t pc;
+ uint8_t a;
+ uint8_t x;
+ uint8_t y;
+ uint8_t status;
+ uint8_t sp;
};
registers_t r;
enum { idle_addr = 0xFEFF };
// Time of beginning of next instruction to be executed
sap_time_t time() const { return state->time + state->base; }
void set_time( sap_time_t t ) { state->time = t - state->base; }
void adjust_time( int delta ) { state->time += delta; }
sap_time_t irq_time() const { return irq_time_; }
void set_irq_time( sap_time_t );
sap_time_t end_time() const { return end_time_; }
void set_end_time( sap_time_t );
public:
Sap_Cpu() { state = &state_; }
enum { irq_inhibit = 0x04 };
private:
struct state_t {
sap_time_t base;
sap_time_t time;
};
state_t* state; // points to state_ or a local copy within run()
state_t state_;
sap_time_t irq_time_;
sap_time_t end_time_;
uint8_t* mem;
inline sap_time_t update_end_time( sap_time_t end, sap_time_t irq );
};
inline sap_time_t Sap_Cpu::update_end_time( sap_time_t t, sap_time_t irq )
{
if ( irq < t && !(r.status & irq_inhibit) ) t = irq;
sap_time_t delta = state->base - t;
state->base = t;
return delta;
}
inline void Sap_Cpu::set_irq_time( sap_time_t t )
{
state->time += update_end_time( end_time_, (irq_time_ = t) );
}
inline void Sap_Cpu::set_end_time( sap_time_t t )
{
state->time += update_end_time( (end_time_ = t), irq_time_ );
}
#endif
diff --git a/src/libs/gme/Sap_Emu.cpp b/src/libs/gme/Sap_Emu.cpp
index aa4ce948..dc5d666d 100644
--- a/src/libs/gme/Sap_Emu.cpp
+++ b/src/libs/gme/Sap_Emu.cpp
@@ -1,444 +1,443 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Sap_Emu.h"
#include "blargg_endian.h"
#include <string.h>
/* Copyright (C) 2006 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"
long const base_scanline_period = 114;
Sap_Emu::Sap_Emu()
{
set_type( gme_sap_type );
static const char* const names [Sap_Apu::osc_count * 2] = {
"Wave 1", "Wave 2", "Wave 3", "Wave 4",
"Wave 5", "Wave 6", "Wave 7", "Wave 8",
};
set_voice_names( names );
static int const types [Sap_Apu::osc_count * 2] = {
wave_type | 1, wave_type | 2, wave_type | 3, wave_type | 0,
wave_type | 5, wave_type | 6, wave_type | 7, wave_type | 4,
};
set_voice_types( types );
set_silence_lookahead( 6 );
}
Sap_Emu::~Sap_Emu() { }
// Track info
// Returns 16 or greater if not hex
inline int from_hex_char( int h )
{
h -= 0x30;
if ( (unsigned) h > 9 )
h = ((h - 0x11) & 0xDF) + 10;
return h;
}
static long from_hex( byte const* in )
{
unsigned result = 0;
for ( int n = 4; n--; )
{
int h = from_hex_char( *in++ );
if ( h > 15 )
return -1;
result = result * 0x10 + h;
}
return result;
}
static int from_dec( byte const* in, byte const* end )
{
if ( in >= end )
return -1;
int n = 0;
while ( in < end )
{
int dig = *in++ - '0';
if ( (unsigned) dig > 9 )
return -1;
n = n * 10 + dig;
}
return n;
}
static void parse_string( byte const* in, byte const* end, int len, char* out )
{
byte const* start = in;
if ( *in++ == '\"' )
{
start++;
while ( in < end && *in != '\"' )
in++;
}
else
{
in = end;
}
len = min( len - 1, int (in - start) );
out [len] = 0;
memcpy( out, start, len );
}
static blargg_err_t parse_info( byte const* in, long size, Sap_Emu::info_t* out )
{
out->track_count = 1;
out->author [0] = 0;
out->name [0] = 0;
out->copyright [0] = 0;
if ( size < 16 || memcmp( in, "SAP\x0D\x0A", 5 ) )
return gme_wrong_file_type;
byte const* file_end = in + size - 5;
in += 5;
while ( in < file_end && (in [0] != 0xFF || in [1] != 0xFF) )
{
byte const* line_end = in;
while ( line_end < file_end && *line_end != 0x0D )
line_end++;
char const* tag = (char const*) in;
while ( in < line_end && *in > ' ' )
in++;
int tag_len = (char const*) in - tag;
while ( in < line_end && *in <= ' ' ) in++;
if ( tag_len <= 0 )
{
// skip line
}
else if ( !strncmp( "INIT", tag, tag_len ) )
{
out->init_addr = from_hex( in );
if ( (unsigned long) out->init_addr > 0xFFFF )
return "Invalid init address";
}
else if ( !strncmp( "PLAYER", tag, tag_len ) )
{
out->play_addr = from_hex( in );
if ( (unsigned long) out->play_addr > 0xFFFF )
return "Invalid play address";
}
else if ( !strncmp( "MUSIC", tag, tag_len ) )
{
out->music_addr = from_hex( in );
if ( (unsigned long) out->music_addr > 0xFFFF )
return "Invalid music address";
}
else if ( !strncmp( "SONGS", tag, tag_len ) )
{
out->track_count = from_dec( in, line_end );
if ( out->track_count <= 0 )
return "Invalid track count";
}
else if ( !strncmp( "TYPE", tag, tag_len ) )
{
switch ( out->type = *in )
{
case 'C':
case 'B':
break;
case 'D':
return "Digimusic not supported";
default:
return "Unsupported player type";
}
}
else if ( !strncmp( "STEREO", tag, tag_len ) )
{
out->stereo = true;
}
else if ( !strncmp( "FASTPLAY", tag, tag_len ) )
{
out->fastplay = from_dec( in, line_end );
if ( out->fastplay <= 0 )
return "Invalid fastplay value";
}
else if ( !strncmp( "AUTHOR", tag, tag_len ) )
{
parse_string( in, line_end, sizeof out->author, out->author );
}
else if ( !strncmp( "NAME", tag, tag_len ) )
{
parse_string( in, line_end, sizeof out->name, out->name );
}
else if ( !strncmp( "DATE", tag, tag_len ) )
{
parse_string( in, line_end, sizeof out->copyright, out->copyright );
}
in = line_end + 2;
}
if ( in [0] != 0xFF || in [1] != 0xFF )
return "ROM data missing";
out->rom_data = in + 2;
return 0;
}
static void copy_sap_fields( Sap_Emu::info_t const& in, track_info_t* out )
{
Gme_File::copy_field_( out->game, in.name );
Gme_File::copy_field_( out->author, in.author );
Gme_File::copy_field_( out->copyright, in.copyright );
}
blargg_err_t Sap_Emu::track_info_( track_info_t* out, int ) const
{
copy_sap_fields( info, out );
return 0;
}
struct Sap_File : Gme_Info_
{
Sap_Emu::info_t info;
Sap_File() { set_type( gme_sap_type ); }
blargg_err_t load_mem_( byte const* begin, long size )
{
RETURN_ERR( parse_info( begin, size, &info ) );
set_track_count( info.track_count );
return 0;
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
copy_sap_fields( info, out );
return 0;
}
};
static Music_Emu* new_sap_emu () { return BLARGG_NEW Sap_Emu ; }
static Music_Emu* new_sap_file() { return BLARGG_NEW Sap_File; }
static gme_type_t_ const gme_sap_type_ = { "Atari XL", 0, &new_sap_emu, &new_sap_file, "SAP", 1 };
-gme_type_t const gme_sap_type = &gme_sap_type_;
-
+BLARGG_EXPORT extern gme_type_t const gme_sap_type = &gme_sap_type_;
// Setup
blargg_err_t Sap_Emu::load_mem_( byte const* in, long size )
{
file_end = in + size;
info.warning = 0;
info.type = 'B';
info.stereo = false;
info.init_addr = -1;
info.play_addr = -1;
info.music_addr = -1;
info.fastplay = 312;
RETURN_ERR( parse_info( in, size, &info ) );
set_warning( info.warning );
set_track_count( info.track_count );
set_voice_count( Sap_Apu::osc_count << info.stereo );
apu_impl.volume( gain() );
return setup_buffer( 1773447 );
}
void Sap_Emu::update_eq( blip_eq_t const& eq )
{
apu_impl.synth.treble_eq( eq );
}
void Sap_Emu::set_voice( int i, Blip_Buffer* center, Blip_Buffer* left, Blip_Buffer* right )
{
int i2 = i - Sap_Apu::osc_count;
if ( i2 >= 0 )
apu2.osc_output( i2, right );
else
apu.osc_output( i, (info.stereo ? left : center) );
}
// Emulation
void Sap_Emu::set_tempo_( double t )
{
scanline_period = sap_time_t (base_scanline_period / t);
}
inline sap_time_t Sap_Emu::play_period() const { return info.fastplay * scanline_period; }
void Sap_Emu::cpu_jsr( sap_addr_t addr )
{
check( r.sp >= 0xFE ); // catch anything trying to leave data on stack
r.pc = addr;
int high_byte = (idle_addr - 1) >> 8;
if ( r.sp == 0xFE && mem.ram [0x1FF] == high_byte )
r.sp = 0xFF; // pop extra byte off
mem.ram [0x100 + r.sp--] = high_byte; // some routines use RTI to return
mem.ram [0x100 + r.sp--] = high_byte;
mem.ram [0x100 + r.sp--] = (idle_addr - 1) & 0xFF;
}
void Sap_Emu::run_routine( sap_addr_t addr )
{
cpu_jsr( addr );
cpu::run( 312 * base_scanline_period * 60 );
check( r.pc == idle_addr );
}
inline void Sap_Emu::call_init( int track )
{
switch ( info.type )
{
case 'B':
r.a = track;
run_routine( info.init_addr );
break;
case 'C':
r.a = 0x70;
r.x = info.music_addr&0xFF;
r.y = info.music_addr >> 8;
run_routine( info.play_addr + 3 );
r.a = 0;
r.x = track;
run_routine( info.play_addr + 3 );
break;
}
}
blargg_err_t Sap_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
memset( &mem, 0, sizeof mem );
byte const* in = info.rom_data;
while ( file_end - in >= 5 )
{
unsigned start = get_le16( in );
unsigned end = get_le16( in + 2 );
//debug_printf( "Block $%04X-$%04X\n", start, end );
in += 4;
if ( end < start )
{
set_warning( "Invalid file data block" );
break;
}
long len = end - start + 1;
if ( len > file_end - in )
{
set_warning( "Invalid file data block" );
break;
}
memcpy( mem.ram + start, in, len );
in += len;
if ( file_end - in >= 2 && in [0] == 0xFF && in [1] == 0xFF )
in += 2;
}
apu.reset( &apu_impl );
apu2.reset( &apu_impl );
cpu::reset( mem.ram );
time_mask = 0; // disables sound during init
call_init( track );
time_mask = -1;
next_play = play_period();
return 0;
}
// Emulation
// see sap_cpu_io.h for read/write functions
void Sap_Emu::cpu_write_( sap_addr_t addr, int data )
{
if ( (addr ^ Sap_Apu::start_addr) <= (Sap_Apu::end_addr - Sap_Apu::start_addr) )
{
GME_APU_HOOK( this, addr - Sap_Apu::start_addr, data );
apu.write_data( time() & time_mask, addr, data );
return;
}
if ( (addr ^ (Sap_Apu::start_addr + 0x10)) <= (Sap_Apu::end_addr - Sap_Apu::start_addr) &&
info.stereo )
{
GME_APU_HOOK( this, addr - 0x10 - Sap_Apu::start_addr + 10, data );
apu2.write_data( time() & time_mask, addr ^ 0x10, data );
return;
}
if ( (addr & ~0x0010) != 0xD20F || data != 0x03 )
debug_printf( "Unmapped write $%04X <- $%02X\n", addr, data );
}
inline void Sap_Emu::call_play()
{
switch ( info.type )
{
case 'B':
cpu_jsr( info.play_addr );
break;
case 'C':
cpu_jsr( info.play_addr + 6 );
break;
}
}
blargg_err_t Sap_Emu::run_clocks( blip_time_t& duration, int )
{
set_time( 0 );
while ( time() < duration )
{
if ( cpu::run( duration ) || r.pc > idle_addr )
return "Emulation error (illegal instruction)";
if ( r.pc == idle_addr )
{
if ( next_play <= duration )
{
set_time( next_play );
next_play += play_period();
call_play();
GME_FRAME_HOOK( this );
}
else
{
set_time( duration );
}
}
}
duration = time();
next_play -= duration;
check( next_play >= 0 );
if ( next_play < 0 )
next_play = 0;
apu.end_frame( duration );
if ( info.stereo )
apu2.end_frame( duration );
return 0;
}
diff --git a/src/libs/gme/Sap_Emu.h b/src/libs/gme/Sap_Emu.h
index 21879447..1dd5d865 100644
--- a/src/libs/gme/Sap_Emu.h
+++ b/src/libs/gme/Sap_Emu.h
@@ -1,69 +1,69 @@
// Atari XL/XE SAP music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SAP_EMU_H
#define SAP_EMU_H
#include "Classic_Emu.h"
#include "Sap_Apu.h"
#include "Sap_Cpu.h"
class Sap_Emu : private Sap_Cpu, public Classic_Emu {
typedef Sap_Cpu cpu;
public:
static gme_type_t static_type() { return gme_sap_type; }
public:
Sap_Emu();
~Sap_Emu();
struct info_t {
byte const* rom_data;
const char* warning;
long init_addr;
long play_addr;
long music_addr;
int type;
int track_count;
int fastplay;
bool stereo;
char author [256];
char name [256];
char copyright [ 32];
};
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_mem_( byte const*, long );
blargg_err_t start_track_( int );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
public: private: friend class Sap_Cpu;
int cpu_read( sap_addr_t );
void cpu_write( sap_addr_t, int );
void cpu_write_( sap_addr_t, int );
private:
info_t info;
byte const* file_end;
sap_time_t scanline_period;
sap_time_t next_play;
sap_time_t time_mask;
Sap_Apu apu;
Sap_Apu apu2;
// large items
struct {
byte padding1 [0x100];
byte ram [0x10000];
byte padding2 [0x100];
} mem;
Sap_Apu_Impl apu_impl;
sap_time_t play_period() const;
void call_play();
void cpu_jsr( sap_addr_t );
void call_init( int track );
void run_routine( sap_addr_t );
};
#endif
diff --git a/src/libs/gme/Snes_Spc.cpp b/src/libs/gme/Snes_Spc.cpp
index 697ee052..da40d8f3 100644
--- a/src/libs/gme/Snes_Spc.cpp
+++ b/src/libs/gme/Snes_Spc.cpp
@@ -1,492 +1,380 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// SPC emulation support: init, sample buffering, reset, SPC loading
+
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Snes_Spc.h"
#include <string.h>
-/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
+/* Copyright (C) 2004-2007 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"
-// always in the future (CPU time can go over 0, but not by this much)
-int const timer_disabled_time = 127;
-
-Snes_Spc::Snes_Spc() : dsp( mem.ram ), cpu( this, mem.ram )
-{
- set_tempo( 1.0 );
-
- // Put STOP instruction around memory to catch PC underflow/overflow.
- memset( mem.padding1, 0xFF, sizeof mem.padding1 );
- memset( mem.padding2, 0xFF, sizeof mem.padding2 );
-
- // A few tracks read from the last four bytes of IPL ROM
- boot_rom [sizeof boot_rom - 2] = 0xC0;
- boot_rom [sizeof boot_rom - 1] = 0xFF;
- memset( boot_rom, 0, sizeof boot_rom - 2 );
-}
+#define RAM (m.ram.ram)
+#define REGS (m.smp_regs [0])
+#define REGS_IN (m.smp_regs [1])
-void Snes_Spc::set_tempo( double t )
-{
- int unit = (int) (16.0 / t + 0.5);
-
- timer [0].divisor = unit * 8; // 8 kHz
- timer [1].divisor = unit * 8; // 8 kHz
- timer [2].divisor = unit; // 64 kHz
-}
+// (n ? n : 256)
+#define IF_0_THEN_256( n ) ((uint8_t) ((n) - 1) + 1)
-// Load
-void Snes_Spc::set_ipl_rom( void const* in )
-{
- memcpy( boot_rom, in, sizeof boot_rom );
-}
+//// Init
-blargg_err_t Snes_Spc::load_spc( const void* data, long size )
+blargg_err_t Snes_Spc::init()
{
- struct spc_file_t {
- char signature [27];
- char unused [10];
- uint8_t pc [2];
- uint8_t a;
- uint8_t x;
- uint8_t y;
- uint8_t status;
- uint8_t sp;
- char unused2 [212];
- uint8_t ram [0x10000];
- uint8_t dsp [128];
- uint8_t ipl_rom [128];
- };
- assert( offsetof (spc_file_t,ipl_rom) == spc_file_size );
+ memset( &m, 0, sizeof m );
+ dsp.init( RAM );
- const spc_file_t* spc = (spc_file_t const*) data;
-
- if ( size < spc_file_size )
- return "Not an SPC file";
-
- if ( strncmp( spc->signature, "SNES-SPC700 Sound File Data", 27 ) != 0 )
- return "Not an SPC file";
+ m.tempo = tempo_unit;
- registers_t regs;
- regs.pc = spc->pc [1] * 0x100 + spc->pc [0];
- regs.a = spc->a;
- regs.x = spc->x;
- regs.y = spc->y;
- regs.status = spc->status;
- regs.sp = spc->sp;
+ // Most SPC music doesn't need ROM, and almost all the rest only rely
+ // on these two bytes
+ m.rom [0x3E] = 0xFF;
+ m.rom [0x3F] = 0xC0;
- if ( (unsigned long) size >= sizeof *spc )
- set_ipl_rom( spc->ipl_rom );
+ static unsigned char const cycle_table [128] =
+ {// 01 23 45 67 89 AB CD EF
+ 0x28,0x47,0x34,0x36,0x26,0x54,0x54,0x68, // 0
+ 0x48,0x47,0x45,0x56,0x55,0x65,0x22,0x46, // 1
+ 0x28,0x47,0x34,0x36,0x26,0x54,0x54,0x74, // 2
+ 0x48,0x47,0x45,0x56,0x55,0x65,0x22,0x38, // 3
+ 0x28,0x47,0x34,0x36,0x26,0x44,0x54,0x66, // 4
+ 0x48,0x47,0x45,0x56,0x55,0x45,0x22,0x43, // 5
+ 0x28,0x47,0x34,0x36,0x26,0x44,0x54,0x75, // 6
+ 0x48,0x47,0x45,0x56,0x55,0x55,0x22,0x36, // 7
+ 0x28,0x47,0x34,0x36,0x26,0x54,0x52,0x45, // 8
+ 0x48,0x47,0x45,0x56,0x55,0x55,0x22,0xC5, // 9
+ 0x38,0x47,0x34,0x36,0x26,0x44,0x52,0x44, // A
+ 0x48,0x47,0x45,0x56,0x55,0x55,0x22,0x34, // B
+ 0x38,0x47,0x45,0x47,0x25,0x64,0x52,0x49, // C
+ 0x48,0x47,0x56,0x67,0x45,0x55,0x22,0x83, // D
+ 0x28,0x47,0x34,0x36,0x24,0x53,0x43,0x40, // E
+ 0x48,0x47,0x45,0x56,0x34,0x54,0x22,0x60, // F
+ };
- const char* error = load_state( regs, spc->ram, spc->dsp );
+ // unpack cycle table
+ for ( int i = 0; i < 128; i++ )
+ {
+ int n = cycle_table [i];
+ m.cycle_table [i * 2 + 0] = n >> 4;
+ m.cycle_table [i * 2 + 1] = n & 0x0F;
+ }
- echo_accessed = false;
+ #if SPC_LESS_ACCURATE
+ memcpy( reg_times, reg_times_, sizeof reg_times );
+ #endif
- return error;
+ reset();
+ return 0;
}
-void Snes_Spc::clear_echo()
+void Snes_Spc::init_rom( uint8_t const in [rom_size] )
{
- if ( !(dsp.read( 0x6C ) & 0x20) )
- {
- unsigned addr = 0x100 * dsp.read( 0x6D );
- size_t size = 0x800 * dsp.read( 0x7D );
- memset( mem.ram + addr, 0xFF, min( size, sizeof mem.ram - addr ) );
- }
+ memcpy( m.rom, in, sizeof m.rom );
}
-// Handle other file formats (emulator save states) in user code, not here.
-
-blargg_err_t Snes_Spc::load_state( const registers_t& cpu_state, const void* new_ram,
- const void* dsp_state )
+void Snes_Spc::set_tempo( int t )
{
- // cpu
- cpu.r = cpu_state;
+ m.tempo = t;
+ int const timer2_shift = 4; // 64 kHz
+ int const other_shift = 3; // 8 kHz
- // Allow DSP to generate one sample before code starts
- // (Tengai Makyo Zero, Tenjin's Table Toss first notes are lost since it
- // clears KON 31 cycles from starting execution. It works on the SNES
- // since the SPC player adds a few extra cycles delay after restoring
- // KON from the DSP registers at the end of an SPC file).
- extra_cycles = 32;
-
- // ram
- memcpy( mem.ram, new_ram, sizeof mem.ram );
- memcpy( extra_ram, mem.ram + rom_addr, sizeof extra_ram );
-
- // boot rom (have to force enable_rom() to update it)
- rom_enabled = !(mem.ram [0xF1] & 0x80);
- enable_rom( !rom_enabled );
-
- // dsp
- dsp.reset();
+ #if SPC_DISABLE_TEMPO
+ m.timers [2].prescaler = timer2_shift;
+ m.timers [1].prescaler = timer2_shift + other_shift;
+ m.timers [0].prescaler = timer2_shift + other_shift;
+ #else
+ if ( !t )
+ t = 1;
+ int const timer2_rate = 1 << timer2_shift;
+ int rate = (timer2_rate * tempo_unit + (t >> 1)) / t;
+ if ( rate < timer2_rate / 4 )
+ rate = timer2_rate / 4; // max 4x tempo
+ m.timers [2].prescaler = rate;
+ m.timers [1].prescaler = rate << other_shift;
+ m.timers [0].prescaler = rate << other_shift;
+ #endif
+}
+
+// Timer registers have been loaded. Applies these to the timers. Does not
+// reset timer prescalers or dividers.
+void Snes_Spc::timers_loaded()
+{
int i;
- for ( i = 0; i < Spc_Dsp::register_count; i++ )
- dsp.write( i, ((uint8_t const*) dsp_state) [i] );
-
- // timers
for ( i = 0; i < timer_count; i++ )
{
- Timer& t = timer [i];
-
- t.next_tick = 0;
- t.enabled = (mem.ram [0xF1] >> i) & 1;
- if ( !t.enabled )
- t.next_tick = timer_disabled_time;
- t.count = 0;
- t.counter = mem.ram [0xFD + i] & 15;
-
- int p = mem.ram [0xFA + i];
- t.period = p ? p : 0x100;
+ Timer* t = &m.timers [i];
+ t->period = IF_0_THEN_256( REGS [r_t0target + i] );
+ t->enabled = REGS [r_control] >> i & 1;
+ t->counter = REGS_IN [r_t0out + i] & 0x0F;
}
- // Handle registers which already give 0 when read by setting RAM and not changing it.
- // Put STOP instruction in registers which can be read, to catch attempted CPU execution.
- mem.ram [0xF0] = 0;
- mem.ram [0xF1] = 0;
- mem.ram [0xF3] = 0xFF;
- mem.ram [0xFA] = 0;
- mem.ram [0xFB] = 0;
- mem.ram [0xFC] = 0;
- mem.ram [0xFD] = 0xFF;
- mem.ram [0xFE] = 0xFF;
- mem.ram [0xFF] = 0xFF;
-
- return 0; // success
+ set_tempo( m.tempo );
}
-// Hardware
-
-// Current time starts negative and ends at 0
-inline spc_time_t Snes_Spc::time() const
+// Loads registers from unified 16-byte format
+void Snes_Spc::load_regs( uint8_t const in [reg_count] )
{
- return -cpu.remain();
+ memcpy( REGS, in, reg_count );
+ memcpy( REGS_IN, REGS, reg_count );
+
+ // These always read back as 0
+ REGS_IN [r_test ] = 0;
+ REGS_IN [r_control ] = 0;
+ REGS_IN [r_t0target] = 0;
+ REGS_IN [r_t1target] = 0;
+ REGS_IN [r_t2target] = 0;
}
-// Keep track of next time to run and avoid a function call if it hasn't been reached.
+// RAM was just loaded from SPC, with $F0-$FF containing SMP registers
+// and timer counts. Copies these to proper registers.
+void Snes_Spc::ram_loaded()
+{
+ m.rom_enabled = 0;
+ load_regs( &RAM [0xF0] );
+
+ // Put STOP instruction around memory to catch PC underflow/overflow
+ memset( m.ram.padding1, cpu_pad_fill, sizeof m.ram.padding1 );
+ memset( m.ram.padding2, cpu_pad_fill, sizeof m.ram.padding2 );
+}
-// Timers
+// Registers were just loaded. Applies these new values.
+void Snes_Spc::regs_loaded()
+{
+ enable_rom( REGS [r_control] & 0x80 );
+ timers_loaded();
+}
-void Snes_Spc::Timer::run_until_( spc_time_t time )
+void Snes_Spc::reset_time_regs()
{
- if ( !enabled )
- debug_printf( "next_tick: %ld, time: %ld", (long) next_tick, (long) time );
- assert( enabled ); // when disabled, next_tick should always be in the future
-
- int elapsed = ((time - next_tick) / divisor) + 1;
- next_tick += elapsed * divisor;
+ m.cpu_error = 0;
+ m.echo_accessed = 0;
+ m.spc_time = 0;
+ m.dsp_time = 0;
+ #if SPC_LESS_ACCURATE
+ m.dsp_time = clocks_per_sample + 1;
+ #endif
- elapsed += count;
- if ( elapsed >= period ) // avoid unnecessary division
+ for ( int i = 0; i < timer_count; i++ )
{
- int n = elapsed / period;
- elapsed -= n * period;
- counter = (counter + n) & 15;
+ Timer* t = &m.timers [i];
+ t->next_time = 1;
+ t->divider = 0;
}
- count = elapsed;
+
+ regs_loaded();
+
+ m.extra_clocks = 0;
+ reset_buf();
}
-// DSP
-
-const int clocks_per_sample = 32; // 1.024 MHz CPU clock / 32000 samples per second
-
-void Snes_Spc::run_dsp_( spc_time_t time )
+void Snes_Spc::reset_common( int timer_counter_init )
{
- int count = ((time - next_dsp) >> 5) + 1; // divide by clocks_per_sample
- sample_t* buf = sample_buf;
- if ( buf ) {
- sample_buf = buf + count * 2; // stereo
- assert( sample_buf <= buf_end );
- }
- next_dsp += count * clocks_per_sample;
- dsp.run( count, buf );
+ int i;
+ for ( i = 0; i < timer_count; i++ )
+ REGS_IN [r_t0out + i] = timer_counter_init;
+
+ // Run IPL ROM
+ memset( &m.cpu_regs, 0, sizeof m.cpu_regs );
+ m.cpu_regs.pc = rom_addr;
+
+ REGS [r_test ] = 0x0A;
+ REGS [r_control] = 0xB0; // ROM enabled, clear ports
+ for ( i = 0; i < port_count; i++ )
+ REGS_IN [r_cpuio0 + i] = 0;
+
+ reset_time_regs();
}
-inline void Snes_Spc::run_dsp( spc_time_t time )
+void Snes_Spc::soft_reset()
{
- if ( time >= next_dsp )
- run_dsp_( time );
+ reset_common( 0 );
+ dsp.soft_reset();
}
-// Debug-only check for read/write within echo buffer, since this might result in
-// inaccurate emulation due to the DSP not being caught up to the present.
-inline void Snes_Spc::check_for_echo_access( spc_addr_t addr )
+void Snes_Spc::reset()
{
- if ( !echo_accessed && !(dsp.read( 0x6C ) & 0x20) )
- {
- // ** If echo accesses are found that require running the DSP, cache
- // the start and end address on DSP writes to speed up checking.
-
- unsigned start = 0x100 * dsp.read( 0x6D );
- unsigned end = start + 0x800 * dsp.read( 0x7D );
- if ( start <= addr && addr < end ) {
- echo_accessed = true;
- debug_printf( "Read/write at $%04X within echo buffer\n", (unsigned) addr );
- }
- }
+ memset( RAM, 0xFF, 0x10000 );
+ ram_loaded();
+ reset_common( 0x0F );
+ dsp.reset();
}
-// Read
+char const Snes_Spc::signature [signature_size + 1] =
+ "SNES-SPC700 Sound File Data v0.30\x1A\x1A";
-int Snes_Spc::read( spc_addr_t addr )
+blargg_err_t Snes_Spc::load_spc( void const* data, long size )
{
- int result = mem.ram [addr];
+ spc_file_t const* const spc = (spc_file_t const*) data;
+
+ // be sure compiler didn't insert any padding into fle_t
+ assert( sizeof (spc_file_t) == spc_min_file_size + 0x80 );
+
+ // Check signature and file size
+ if ( size < signature_size || memcmp( spc, signature, 27 ) )
+ return "Not an SPC file";
+
+ if ( size < spc_min_file_size )
+ return "Corrupt SPC file";
+
+ // CPU registers
+ m.cpu_regs.pc = spc->pch * 0x100 + spc->pcl;
+ m.cpu_regs.a = spc->a;
+ m.cpu_regs.x = spc->x;
+ m.cpu_regs.y = spc->y;
+ m.cpu_regs.psw = spc->psw;
+ m.cpu_regs.sp = spc->sp;
+
+ // RAM and registers
+ memcpy( RAM, spc->ram, 0x10000 );
+ ram_loaded();
- /* 4/28/2010: Jon added () around the && expression, but I'm not 100%
- * thats right.
- */
- if ( ((rom_addr <= addr && addr < 0xFFFC) || addr >= 0xFFFE) && rom_enabled )
- debug_printf( "Read from ROM: %04X -> %02X\n", addr, result );
+ // DSP registers
+ dsp.load( spc->dsp );
- if ( unsigned (addr - 0xF0) < 0x10 )
+ reset_time_regs();
+
+ return 0;
+}
+
+void Snes_Spc::clear_echo()
+{
+ if ( !(dsp.read( Spc_Dsp::r_flg ) & 0x20) )
{
- assert( 0xF0 <= addr && addr <= 0xFF );
-
- // counters
- int i = addr - 0xFD;
- if ( i >= 0 )
- {
- Timer& t = timer [i];
- t.run_until( time() );
- int old = t.counter;
- t.counter = 0;
- return old;
- }
-
- // dsp
- if ( addr == 0xF3 )
- {
- run_dsp( time() );
- if ( mem.ram [0xF2] >= Spc_Dsp::register_count )
- debug_printf( "DSP read from $%02X\n", (int) mem.ram [0xF2] );
- return dsp.read( mem.ram [0xF2] & 0x7F );
- }
-
- if ( addr == 0xF0 || addr == 0xF1 || addr == 0xF8 ||
- addr == 0xF9 || addr == 0xFA )
- debug_printf( "Read from register $%02X\n", (int) addr );
-
- // Registers which always read as 0 are handled by setting mem.ram [reg] to 0
- // at startup then never changing that value.
-
- check(( check_for_echo_access( addr ), true ));
+ int addr = 0x100 * dsp.read( Spc_Dsp::r_esa );
+ int end = addr + 0x800 * (dsp.read( Spc_Dsp::r_edl ) & 0x0F);
+ if ( end > 0x10000 )
+ end = 0x10000;
+ memset( &RAM [addr], 0xFF, end - addr );
}
-
- return result;
}
-// Write
+//// Sample output
-void Snes_Spc::enable_rom( bool enable )
+void Snes_Spc::reset_buf()
{
- if ( rom_enabled != enable )
- {
- rom_enabled = enable;
- memcpy( mem.ram + rom_addr, (enable ? boot_rom : extra_ram), rom_size );
- // TODO: ROM can still get overwritten when DSP writes to echo buffer
- }
+ // Start with half extra buffer of silence
+ sample_t* out = m.extra_buf;
+ while ( out < &m.extra_buf [extra_size / 2] )
+ *out++ = 0;
+
+ m.extra_pos = out;
+ m.buf_begin = 0;
+
+ dsp.set_output( 0, 0 );
}
-void Snes_Spc::write( spc_addr_t addr, int data )
+void Snes_Spc::set_output( sample_t* out, int size )
{
- // first page is very common
- if ( addr < 0xF0 ) {
- mem.ram [addr] = (uint8_t) data;
- }
- else switch ( addr )
+ require( (size & 1) == 0 ); // size must be even
+
+ m.extra_clocks &= clocks_per_sample - 1;
+ if ( out )
{
- // RAM
- default:
- check(( check_for_echo_access( addr ), true ));
- if ( addr < rom_addr ) {
- mem.ram [addr] = (uint8_t) data;
- }
- else {
- extra_ram [addr - rom_addr] = (uint8_t) data;
- if ( !rom_enabled )
- mem.ram [addr] = (uint8_t) data;
- }
- break;
-
- // DSP
- //case 0xF2: // mapped to RAM
- case 0xF3: {
- run_dsp( time() );
- int reg = mem.ram [0xF2];
- if ( next_dsp > 0 ) {
- // skip mode
-
- // key press
- if ( reg == 0x4C )
- keys_pressed |= data & ~dsp.read( 0x5C );
-
- // key release
- if ( reg == 0x5C ) {
- keys_released |= data;
- keys_pressed &= ~data;
- }
- }
- if ( reg < Spc_Dsp::register_count ) {
- dsp.write( reg, data );
- }
- else {
- debug_printf( "DSP write to $%02X\n", (int) reg );
- }
- break;
- }
+ sample_t const* out_end = out + size;
+ m.buf_begin = out;
+ m.buf_end = out_end;
- case 0xF0: // Test register
- debug_printf( "Wrote $%02X to $F0\n", (int) data );
- break;
+ // Copy extra to output
+ sample_t const* in = m.extra_buf;
+ while ( in < m.extra_pos && out < out_end )
+ *out++ = *in++;
- // Config
- case 0xF1:
+ // Handle output being full already
+ if ( out >= out_end )
{
- // timers
- for ( int i = 0; i < timer_count; i++ )
- {
- Timer& t = timer [i];
- if ( !(data & (1 << i)) ) {
- t.enabled = 0;
- t.next_tick = timer_disabled_time;
- }
- else if ( !t.enabled ) {
- // just enabled
- t.enabled = 1;
- t.counter = 0;
- t.count = 0;
- t.next_tick = time();
- }
- }
+ // Have DSP write to remaining extra space
+ out = dsp.extra();
+ out_end = &dsp.extra() [extra_size];
- // port clears
- if ( data & 0x10 ) {
- mem.ram [0xF4] = 0;
- mem.ram [0xF5] = 0;
- }
- if ( data & 0x20 ) {
- mem.ram [0xF6] = 0;
- mem.ram [0xF7] = 0;
- }
-
- enable_rom( (data & 0x80) != 0 );
-
- break;
+ // Copy any remaining extra samples as if DSP wrote them
+ while ( in < m.extra_pos )
+ *out++ = *in++;
+ assert( out <= out_end );
}
- // Ports
- case 0xF4:
- case 0xF5:
- case 0xF6:
- case 0xF7:
- // to do: handle output ports
- break;
-
- //case 0xF8: // verified on SNES that these are read/write (RAM)
- //case 0xF9:
-
- // Timers
- case 0xFA:
- case 0xFB:
- case 0xFC: {
- Timer& t = timer [addr - 0xFA];
- if ( (t.period & 0xFF) != data ) {
- t.run_until( time() );
- t.period = data ? data : 0x100;
- }
- break;
- }
-
- // Counters (cleared on write)
- case 0xFD:
- case 0xFE:
- case 0xFF:
- debug_printf( "Wrote to counter $%02X\n", (int) addr );
- timer [addr - 0xFD].counter = 0;
- break;
+ dsp.set_output( out, out_end - out );
+ }
+ else
+ {
+ reset_buf();
}
}
-// Play
-
-blargg_err_t Snes_Spc::skip( long count )
+void Snes_Spc::save_extra()
{
- if ( count > 4 * 32000L )
+ // Get end pointers
+ sample_t const* main_end = m.buf_end; // end of data written to buf
+ sample_t const* dsp_end = dsp.out_pos(); // end of data written to dsp.extra()
+ if ( m.buf_begin <= dsp_end && dsp_end <= main_end )
{
- // don't run DSP for long durations (2-3 times faster)
-
- const long sync_count = 32000L * 2;
-
- // keep track of any keys pressed/released (and not subsequently released)
- keys_pressed = 0;
- keys_released = 0;
- // sentinel tells play to ignore DSP
- RETURN_ERR( play( count - sync_count, skip_sentinel ) );
-
- // press/release keys now
- dsp.write( 0x5C, keys_released & ~keys_pressed );
- dsp.write( 0x4C, keys_pressed );
-
- clear_echo();
-
- // play the last few seconds normally to help synchronize DSP
- count = sync_count;
+ main_end = dsp_end;
+ dsp_end = dsp.extra(); // nothing in DSP's extra
}
- return play( count );
+ // Copy any extra samples at these ends into extra_buf
+ sample_t* out = m.extra_buf;
+ sample_t const* in;
+ for ( in = m.buf_begin + sample_count(); in < main_end; in++ )
+ *out++ = *in;
+ for ( in = dsp.extra(); in < dsp_end ; in++ )
+ *out++ = *in;
+
+ m.extra_pos = out;
+ assert( out <= &m.extra_buf [extra_size] );
}
-blargg_err_t Snes_Spc::play( long count, sample_t* out )
+blargg_err_t Snes_Spc::play( int count, sample_t* out )
{
- require( count % 2 == 0 ); // output is always in pairs of samples
-
- // CPU time() runs from -duration to 0
- spc_time_t duration = (count / 2) * clocks_per_sample;
-
- // DSP output is made on-the-fly when the CPU reads/writes DSP registers
- sample_buf = out;
- buf_end = out + (out && out != skip_sentinel ? count : 0);
- next_dsp = (out == skip_sentinel) ? clocks_per_sample : -duration + clocks_per_sample;
-
- // Localize timer next_tick times and run them to the present to prevent a running
- // but ignored timer's next_tick from getting too far behind and overflowing.
- for ( int i = 0; i < timer_count; i++ )
+ require( (count & 1) == 0 ); // must be even
+ if ( count )
{
- Timer& t = timer [i];
- if ( t.enabled )
- {
- t.next_tick -= duration;
- t.run_until( -duration );
- }
+ set_output( out, count );
+ end_frame( count * (clocks_per_sample / 2) );
}
- // Run CPU for duration, reduced by any extra cycles from previous run
- int elapsed = cpu.run( duration - extra_cycles );
- if ( elapsed > 0 )
+ const char* err = m.cpu_error;
+ m.cpu_error = 0;
+ return err;
+}
+
+blargg_err_t Snes_Spc::skip( int count )
+{
+ #if SPC_LESS_ACCURATE
+ if ( count > 2 * sample_rate * 2 )
{
- debug_printf( "Unhandled instruction $%02X, pc = $%04X\n",
- (int) cpu.read( cpu.r.pc ), (unsigned) cpu.r.pc );
- return "Emulation error (illegal/unsupported instruction)";
- }
- extra_cycles = -elapsed;
-
- // Catch DSP up to present.
- run_dsp( 0 );
- if ( out ) {
- assert( next_dsp == clocks_per_sample );
- assert( out == skip_sentinel || sample_buf - out == count );
+ set_output( 0, 0 );
+
+ // Skip a multiple of 4 samples
+ time_t end = count;
+ count = (count & 3) + 1 * sample_rate * 2;
+ end = (end - count) * (clocks_per_sample / 2);
+
+ m.skipped_kon = 0;
+ m.skipped_koff = 0;
+
+ // Preserve DSP and timer synchronization
+ // TODO: verify that this really preserves it
+ int old_dsp_time = m.dsp_time + m.spc_time;
+ m.dsp_time = end - m.spc_time + skipping_time;
+ end_frame( end );
+ m.dsp_time = m.dsp_time - skipping_time + old_dsp_time;
+
+ dsp.write( Spc_Dsp::r_koff, m.skipped_koff & ~m.skipped_kon );
+ dsp.write( Spc_Dsp::r_kon , m.skipped_kon );
+ clear_echo();
}
- buf_end = 0;
+ #endif
- return 0;
+ return play( count, 0 );
}
diff --git a/src/libs/gme/Snes_Spc.h b/src/libs/gme/Snes_Spc.h
index 1df51613..4448e855 100644
--- a/src/libs/gme/Snes_Spc.h
+++ b/src/libs/gme/Snes_Spc.h
@@ -1,121 +1,285 @@
-// Super Nintendo (SNES) SPC-700 APU Emulator
+// SNES SPC-700 APU emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SNES_SPC_H
#define SNES_SPC_H
-#include "blargg_common.h"
-#include "Spc_Cpu.h"
#include "Spc_Dsp.h"
+#include "blargg_endian.h"
-class Snes_Spc {
+#include <stdint.h>
+
+struct Snes_Spc {
public:
+ // Must be called once before using
+ blargg_err_t init();
+
+ // Sample pairs generated per second
+ enum { sample_rate = 32000 };
- // Load copy of SPC data into emulator. Clear echo buffer if 'clear_echo' is true.
- enum { spc_file_size = 0x10180 };
- blargg_err_t load_spc( const void* spc, long spc_size );
+// Emulator use
- // Generate 'count' samples and optionally write to 'buf'. Count must be even.
- // Sample output is 16-bit 32kHz, signed stereo pairs with the left channel first.
+ // Sets IPL ROM data. Library does not include ROM data. Most SPC music files
+ // don't need ROM, but a full emulator must provide this.
+ enum { rom_size = 0x40 };
+ void init_rom( uint8_t const rom [rom_size] );
+
+ // Sets destination for output samples
typedef short sample_t;
- blargg_err_t play( long count, sample_t* buf = NULL );
+ void set_output( sample_t* out, int out_size );
+
+ // Number of samples written to output since last set
+ int sample_count() const;
+
+ // Resets SPC to power-on state. This resets your output buffer, so you must
+ // call set_output() after this.
+ void reset();
+
+ // Emulates pressing reset switch on SNES. This resets your output buffer, so
+ // you must call set_output() after this.
+ void soft_reset();
+
+ // 1024000 SPC clocks per second, sample pair every 32 clocks
+ typedef int time_t;
+ enum { clock_rate = 1024000 };
+ enum { clocks_per_sample = 32 };
-// Optional functionality
+ // Emulated port read/write at specified time
+ enum { port_count = 4 };
+ int read_port ( time_t, int port );
+ void write_port( time_t, int port, int data );
+
+ // Runs SPC to end_time and starts a new time frame at 0
+ void end_frame( time_t end_time );
- // Load copy of state into emulator.
- typedef Spc_Cpu::registers_t registers_t;
- blargg_err_t load_state( const registers_t& cpu_state, const void* ram_64k,
- const void* dsp_regs_128 );
+// Sound control
- // Clear echo buffer, useful because many tracks have junk in the buffer.
- void clear_echo();
-
- // Mute voice n if bit n (1 << n) of mask is set
- enum { voice_count = Spc_Dsp::voice_count };
+ // Mutes voices corresponding to non-zero bits in mask (issues repeated KOFF events).
+ // Reduces emulation accuracy.
+ enum { voice_count = 8 };
void mute_voices( int mask );
- // Skip forward by the specified number of samples (64000 samples = 1 second)
- blargg_err_t skip( long count );
+ // If true, prevents channels and global volumes from being phase-negated.
+ // Only supported by fast DSP.
+ void disable_surround( bool disable = true );
+
+ // Sets tempo, where tempo_unit = normal, tempo_unit / 2 = half speed, etc.
+ enum { tempo_unit = 0x100 };
+ void set_tempo( int );
+
+// SPC music files
+
+ // Loads SPC data into emulator
+ enum { spc_min_file_size = 0x10180 };
+ enum { spc_file_size = 0x10200 };
+ blargg_err_t load_spc( void const* in, long size );
- // Set gain, where 1.0 is normal. When greater than 1.0, output is clamped the
- // 16-bit sample range.
- void set_gain( double );
+ // Clears echo region. Useful after loading an SPC as many have garbage in echo.
+ void clear_echo();
+
+ // Plays for count samples and write samples to out. Discards samples if out
+ // is NULL. Count must be a multiple of 2 since output is stereo.
+ blargg_err_t play( int count, sample_t* out );
- // If true, prevent channels and global volumes from being phase-negated
- void disable_surround( bool disable = true );
+ // Skips count samples. Several times faster than play() when using fast DSP.
+ blargg_err_t skip( int count );
- // Set 128 bytes to use for IPL boot ROM. Makes copy. Default is zero filled,
- // to avoid including copyrighted code from the SPC-700.
- void set_ipl_rom( const void* );
+// State save/load (only available with accurate DSP)
+
+#if !SPC_NO_COPY_STATE_FUNCS
+ // Saves/loads state
+ enum { state_size = 67 * 1024L }; // maximum space needed when saving
+ typedef Spc_Dsp::copy_func_t copy_func_t;
+ void copy_state( unsigned char** io, copy_func_t );
+
+ // Writes minimal header to spc_out
+ static void init_header( void* spc_out );
+
+ // Saves emulator state as SPC file data. Writes spc_file_size bytes to spc_out.
+ // Does not set up SPC header; use init_header() for that.
+ void save_spc( void* spc_out );
+
+ // Returns true if new key-on events occurred since last check. Useful for
+ // trimming silence while saving an SPC.
+ bool check_kon();
+#endif
+
+public:
+ // TODO: document
+ struct regs_t
+ {
+ uint16_t pc;
+ uint8_t a;
+ uint8_t x;
+ uint8_t y;
+ uint8_t psw;
+ uint8_t sp;
+ };
+ regs_t& smp_regs() { return m.cpu_regs; }
- void set_tempo( double );
+ uint8_t* smp_ram() { return m.ram.ram; }
+ void run_until( time_t t ) { run_until_( t ); }
public:
- Snes_Spc();
- typedef BOOST::uint8_t uint8_t;
-private:
- // timers
+ BLARGG_DISABLE_NOTHROW
+
+ // Time relative to m_spc_time. Speeds up code a bit by eliminating need to
+ // constantly add m_spc_time to time from CPU. CPU uses time that ends at
+ // 0 to eliminate reloading end time every instruction. It pays off.
+ typedef int rel_time_t;
+
struct Timer
{
- spc_time_t next_tick;
+ rel_time_t next_time; // time of next event
+ int prescaler;
int period;
- int count;
- int divisor;
+ int divider;
int enabled;
int counter;
-
- void run_until_( spc_time_t );
- void run_until( spc_time_t time )
- {
- if ( time >= next_tick )
- run_until_( time );
- }
};
+ enum { reg_count = 0x10 };
enum { timer_count = 3 };
- Timer timer [timer_count];
-
- // hardware
- int extra_cycles;
- spc_time_t time() const;
- int read( spc_addr_t );
- void write( spc_addr_t, int );
- friend class Spc_Cpu;
-
- // dsp
- sample_t* sample_buf;
- sample_t* buf_end; // to do: remove this once possible bug resolved
- spc_time_t next_dsp;
+ enum { extra_size = Spc_Dsp::extra_size };
+
+ enum { signature_size = 35 };
+
+private:
Spc_Dsp dsp;
- int keys_pressed;
- int keys_released;
- sample_t skip_sentinel [1]; // special value for play() passed by skip()
- void run_dsp( spc_time_t );
- void run_dsp_( spc_time_t );
- bool echo_accessed;
- void check_for_echo_access( spc_addr_t );
-
- // boot rom
- enum { rom_size = 64 };
+
+ #if SPC_LESS_ACCURATE
+ static signed char const reg_times_ [256];
+ signed char reg_times [256];
+ #endif
+
+ struct state_t
+ {
+ Timer timers [timer_count];
+
+ uint8_t smp_regs [2] [reg_count];
+
+ regs_t cpu_regs;
+
+ rel_time_t dsp_time;
+ time_t spc_time;
+ bool echo_accessed;
+
+ int tempo;
+ int skipped_kon;
+ int skipped_koff;
+ const char* cpu_error;
+
+ int extra_clocks;
+ sample_t* buf_begin;
+ sample_t const* buf_end;
+ sample_t* extra_pos;
+ sample_t extra_buf [extra_size];
+
+ int rom_enabled;
+ uint8_t rom [rom_size];
+ uint8_t hi_ram [rom_size];
+
+ unsigned char cycle_table [256];
+
+ struct
+ {
+ // padding to neutralize address overflow
+ union {
+ uint8_t padding1 [0x100];
+ uint16_t align; // makes compiler align data for 16-bit access
+ } padding1 [1];
+ uint8_t ram [0x10000];
+ uint8_t padding2 [0x100];
+ } ram;
+ };
+ state_t m;
+
enum { rom_addr = 0xFFC0 };
- bool rom_enabled;
- void enable_rom( bool );
-
- // CPU and RAM (at end because it's large)
- Spc_Cpu cpu;
- uint8_t extra_ram [rom_size];
- struct {
- // padding to catch jumps before beginning or past end
- uint8_t padding1 [0x100];
+
+ enum { skipping_time = 127 };
+
+ // Value that padding should be filled with
+ enum { cpu_pad_fill = 0xFF };
+
+ enum {
+ r_test = 0x0, r_control = 0x1,
+ r_dspaddr = 0x2, r_dspdata = 0x3,
+ r_cpuio0 = 0x4, r_cpuio1 = 0x5,
+ r_cpuio2 = 0x6, r_cpuio3 = 0x7,
+ r_f8 = 0x8, r_f9 = 0x9,
+ r_t0target = 0xA, r_t1target = 0xB, r_t2target = 0xC,
+ r_t0out = 0xD, r_t1out = 0xE, r_t2out = 0xF
+ };
+
+ void timers_loaded();
+ void enable_rom( int enable );
+ void reset_buf();
+ void save_extra();
+ void load_regs( uint8_t const in [reg_count] );
+ void ram_loaded();
+ void regs_loaded();
+ void reset_time_regs();
+ void reset_common( int timer_counter_init );
+
+ Timer* run_timer_ ( Timer* t, rel_time_t );
+ Timer* run_timer ( Timer* t, rel_time_t );
+ int dsp_read ( rel_time_t );
+ void dsp_write ( int data, rel_time_t );
+ void cpu_write_smp_reg_( int data, rel_time_t, uint16_t addr );
+ void cpu_write_smp_reg ( int data, rel_time_t, uint16_t addr );
+ void cpu_write_high ( int data, uint8_t i );
+ void cpu_write ( int data, uint16_t addr, rel_time_t );
+ int cpu_read_smp_reg ( int i, rel_time_t );
+ int cpu_read ( uint16_t addr, rel_time_t );
+ unsigned CPU_mem_bit ( uint16_t pc, rel_time_t );
+
+ bool check_echo_access ( int addr );
+ uint8_t* run_until_( time_t end_time );
+
+ struct spc_file_t
+ {
+ char signature [signature_size];
+ uint8_t has_id666;
+ uint8_t version;
+ uint8_t pcl, pch;
+ uint8_t a;
+ uint8_t x;
+ uint8_t y;
+ uint8_t psw;
+ uint8_t sp;
+ char text [212];
uint8_t ram [0x10000];
- uint8_t padding2 [0x100];
- } mem;
- uint8_t boot_rom [rom_size];
+ uint8_t dsp [128];
+ uint8_t unused [0x40];
+ uint8_t ipl_rom [0x40];
+ };
+
+ static char const signature [signature_size + 1];
+
+ void save_regs( uint8_t out [reg_count] );
};
-inline void Snes_Spc::disable_surround( bool disable ) { dsp.disable_surround( disable ); }
+#include <assert.h>
+
+inline int Snes_Spc::sample_count() const { return (m.extra_clocks >> 5) * 2; }
+
+inline int Snes_Spc::read_port( time_t t, int port )
+{
+ assert( (unsigned) port < port_count );
+ return run_until_( t ) [port];
+}
+
+inline void Snes_Spc::write_port( time_t t, int port, int data )
+{
+ assert( (unsigned) port < port_count );
+ run_until_( t ) [0x10 + port] = data;
+}
inline void Snes_Spc::mute_voices( int mask ) { dsp.mute_voices( mask ); }
+
+inline void Snes_Spc::disable_surround( bool disable ) { dsp.disable_surround( disable ); }
-inline void Snes_Spc::set_gain( double v ) { dsp.set_gain( v ); }
+#if !SPC_NO_COPY_STATE_FUNCS
+inline bool Snes_Spc::check_kon() { return dsp.check_kon(); }
+#endif
#endif
diff --git a/src/libs/gme/Spc_Cpu.cpp b/src/libs/gme/Spc_Cpu.cpp
index 8b61a455..998fe121 100644
--- a/src/libs/gme/Spc_Cpu.cpp
+++ b/src/libs/gme/Spc_Cpu.cpp
@@ -1,1062 +1,549 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Core SPC emulation: CPU, timers, SMP registers, memory
-#include "Spc_Cpu.h"
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
-#include "blargg_endian.h"
#include "Snes_Spc.h"
-/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
+#include <string.h>
+
+/* Copyright (C) 2004-2007 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"
-// Several instructions are commented out (or not even implemented). These aren't
-// used by the SPC files tested.
+#define RAM (m.ram.ram)
+#define REGS (m.smp_regs [0])
+#define REGS_IN (m.smp_regs [1])
-// Optimize performance for the most common instructions, and size for the rest:
-//
-// 15% 0xF0 BEQ rel
-// 8% 0xE4 MOV A,dp
-// 4% 0xF5 MOV A,abs+X
-// 4% 0xD0 BNE rel
-// 4% 0x6F RET
-// 4% 0x3F CALL addr
-// 4% 0xF4 MOV A,dp+X
-// 3% 0xC4 MOV dp,A
-// 2% 0xEB MOV Y,dp
-// 2% 0x3D INC X
-// 2% 0xF6 MOV A,abs+Y
-// (1% and below not shown)
+// (n ? n : 256)
+#define IF_0_THEN_256( n ) ((uint8_t) ((n) - 1) + 1)
-Spc_Cpu::Spc_Cpu( Snes_Spc* e, uint8_t* ram_in ) : ram( ram_in ), emu( *e )
-{
- remain_ = 0;
- assert( INT_MAX >= 0x7FFFFFFF ); // requires 32-bit int
- blargg_verify_byte_order();
-}
+// Note: SPC_MORE_ACCURACY exists mainly so I can run my validation tests, which
+// do crazy echo buffer accesses.
+#ifndef SPC_MORE_ACCURACY
+ #define SPC_MORE_ACCURACY 0
+#endif
-#define READ( addr ) (emu.read( addr ))
-#define WRITE( addr, value ) (emu.write( addr, value ))
+#ifdef BLARGG_ENABLE_OPTIMIZER
+ #include BLARGG_ENABLE_OPTIMIZER
+#endif
-#define READ_DP( addr ) READ( (addr) + dp )
-#define WRITE_DP( addr, value ) WRITE( (addr) + dp, value )
-#define READ_PROG( addr ) (ram [addr])
-#define READ_PROG16( addr ) GET_LE16( &READ_PROG( addr ) )
+//// Timers
-int Spc_Cpu::read( spc_addr_t addr )
+#if SPC_DISABLE_TEMPO
+ #define TIMER_DIV( t, n ) ((n) >> t->prescaler)
+ #define TIMER_MUL( t, n ) ((n) << t->prescaler)
+#else
+ #define TIMER_DIV( t, n ) ((n) / t->prescaler)
+ #define TIMER_MUL( t, n ) ((n) * t->prescaler)
+#endif
+
+Snes_Spc::Timer* Snes_Spc::run_timer_( Timer* t, rel_time_t time )
{
- return READ( addr );
+ int elapsed = TIMER_DIV( t, time - t->next_time ) + 1;
+ t->next_time += TIMER_MUL( t, elapsed );
+
+ if ( t->enabled )
+ {
+ int remain = IF_0_THEN_256( t->period - t->divider );
+ int divider = t->divider + elapsed;
+ int over = elapsed - remain;
+ if ( over >= 0 )
+ {
+ int n = over / t->period;
+ t->counter = (t->counter + 1 + n) & 0x0F;
+ divider = over - n * t->period;
+ }
+ t->divider = (uint8_t) divider;
+ }
+ return t;
}
-void Spc_Cpu::write( spc_addr_t addr, int data )
+inline Snes_Spc::Timer* Snes_Spc::run_timer( Timer* t, rel_time_t time )
{
- WRITE( addr, data );
+ if ( time >= t->next_time )
+ t = run_timer_( t, time );
+ return t;
}
-// Cycle table derived from text copy of SPC-700 manual (using regular expressions)
-static unsigned char const cycle_table [0x100] = {
-// 0 1 2 3 4 5 6 7 8 9 A B C D E F
- 2,8,4,5,3,4,3,6,2,6,5,4,5,4,6,8, // 0
- 2,8,4,5,4,5,5,6,5,5,6,5,2,2,4,6, // 1
- 2,8,4,5,3,4,3,6,2,6,5,4,5,4,5,4, // 2
- 2,8,4,5,4,5,5,6,5,5,6,5,2,2,3,8, // 3
- 2,8,4,5,3,4,3,6,2,6,4,4,5,4,6,6, // 4
- 2,8,4,5,4,5,5,6,5,5,4,5,2,2,4,3, // 5
- 2,8,4,5,3,4,3,6,2,6,4,4,5,4,5,5, // 6
- 2,8,4,5,4,5,5,6,5,5,5,5,2,2,3,6, // 7
- 2,8,4,5,3,4,3,6,2,6,5,4,5,2,4,5, // 8
- 2,8,4,5,4,5,5,6,5,5,5,5,2,2,12,5,// 9
- 3,8,4,5,3,4,3,6,2,6,4,4,5,2,4,4, // A
- 2,8,4,5,4,5,5,6,5,5,5,5,2,2,3,4, // B
- 3,8,4,5,4,5,4,7,2,5,6,4,5,2,4,9, // C
- 2,8,4,5,5,6,6,7,4,5,4,5,2,2,6,3, // D
- 2,8,4,5,3,4,3,6,2,4,5,3,4,3,4,3, // E
- 2,8,4,5,4,5,5,6,3,4,5,4,2,2,4,3 // F
-};
-// The C,mem instructions are hardly used, so a non-inline function is used for
-// the common access code.
-unsigned Spc_Cpu::mem_bit( spc_addr_t pc )
+//// ROM
+
+void Snes_Spc::enable_rom( int enable )
{
- unsigned addr = READ_PROG16( pc );
- unsigned t = READ( addr & 0x1FFF ) >> (addr >> 13);
- return (t << 8) & 0x100;
+ if ( m.rom_enabled != enable )
+ {
+ m.rom_enabled = enable;
+ if ( enable )
+ memcpy( m.hi_ram, &RAM [rom_addr], sizeof m.hi_ram );
+ memcpy( &RAM [rom_addr], (enable ? m.rom : m.hi_ram), rom_size );
+ // TODO: ROM can still get overwritten when DSP writes to echo buffer
+ }
}
-spc_time_t Spc_Cpu::run( spc_time_t cycle_count )
-{
- remain_ = cycle_count;
-
- uint8_t* const ram = this->ram; // cache
-
- // Stack pointer is kept one greater than usual SPC stack pointer to allow
- // common pre-decrement and post-increment memory instructions that some
- // processors have. Address wrap-around isn't supported.
- #define PUSH( v ) (*--sp = uint8_t (v))
- #define PUSH16( v ) (sp -= 2, SET_LE16( sp, v ))
- #define POP() (*sp++)
- #define SET_SP( v ) (sp = ram + 0x101 + (v))
- #define GET_SP() (sp - 0x101 - ram)
- uint8_t* sp;
- SET_SP( r.sp );
-
- // registers
- unsigned pc = (unsigned) r.pc;
- int a = r.a;
- int x = r.x;
- int y = r.y;
-
- // status flags
-
- const int st_n = 0x80;
- const int st_v = 0x40;
- const int st_p = 0x20;
- const int st_b = 0x10;
- const int st_h = 0x08;
- const int st_i = 0x04;
- const int st_z = 0x02;
- const int st_c = 0x01;
-
- #define IS_NEG (nz & 0x880)
-
- #define CALC_STATUS( out ) do {\
- out = status & ~(st_n | st_z | st_c);\
- out |= (c >> 8) & st_c;\
- out |= (dp >> 3) & st_p;\
- if ( IS_NEG ) out |= st_n;\
- if ( !(nz & 0xFF) ) out |= st_z;\
- } while ( 0 )
+//// DSP
- #define SET_STATUS( in ) do {\
- status = in & ~(st_n | st_z | st_c | st_p);\
- c = in << 8;\
- nz = (in << 4) & 0x800;\
- nz |= ~in & st_z;\
- dp = (in << 3) & 0x100;\
- } while ( 0 )
+#if SPC_LESS_ACCURATE
+ int const max_reg_time = 29;
- int status;
- int c; // store C as 'c' & 0x100.
- int nz; // Z set if (nz & 0xFF) == 0, N set if (nz & 0x880) != 0
- unsigned dp; // direct page base
+ signed char const Snes_Spc::reg_times_ [256] =
{
- int temp = r.status;
- SET_STATUS( temp );
- }
+ -1, 0,-11,-10,-15,-11, -2, -2, 4, 3, 14, 14, 26, 26, 14, 22,
+ 2, 3, 0, 1,-12, 0, 1, 1, 7, 6, 14, 14, 27, 14, 14, 23,
+ 5, 6, 3, 4, -1, 3, 4, 4, 10, 9, 14, 14, 26, -5, 14, 23,
+ 8, 9, 6, 7, 2, 6, 7, 7, 13, 12, 14, 14, 27, -4, 14, 24,
+ 11, 12, 9, 10, 5, 9, 10, 10, 16, 15, 14, 14, -2, -4, 14, 24,
+ 14, 15, 12, 13, 8, 12, 13, 13, 19, 18, 14, 14, -2,-36, 14, 24,
+ 17, 18, 15, 16, 11, 15, 16, 16, 22, 21, 14, 14, 28, -3, 14, 25,
+ 20, 21, 18, 19, 14, 18, 19, 19, 25, 24, 14, 14, 14, 29, 14, 25,
+
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+ };
+
+ #define RUN_DSP( time, offset ) \
+ int count = (time) - (offset) - m.dsp_time;\
+ if ( count >= 0 )\
+ {\
+ int clock_count = (count & ~(clocks_per_sample - 1)) + clocks_per_sample;\
+ m.dsp_time += clock_count;\
+ dsp.run( clock_count );\
+ }
+#else
+ #define RUN_DSP( time, offset ) \
+ {\
+ int count = (time) - m.dsp_time;\
+ if ( !SPC_MORE_ACCURACY || count )\
+ {\
+ assert( count > 0 );\
+ m.dsp_time = (time);\
+ dsp.run( count );\
+ }\
+ }
+#endif
- goto loop;
-
- unsigned data; // first operand of instruction and temporary across function calls
-
- // Common endings for instructions
-cbranch_taken_loop: // compare and branch
- pc += (BOOST::int8_t) READ_PROG( pc );
- remain_ -= 2;
-inc_pc_loop: // end of instruction with an operand
- pc++;
-loop:
-
- check( (unsigned) pc < 0x10000 );
- check( (unsigned) GET_SP() < 0x100 );
-
- check( (unsigned) a < 0x100 );
- check( (unsigned) x < 0x100 );
- check( (unsigned) y < 0x100 );
-
- unsigned opcode = READ_PROG( pc );
- pc++;
- // to do: if pc is at end of memory, this will get wrong byte
- data = READ_PROG( pc );
-
- if ( remain_ <= 0 )
- goto stop;
-
- remain_ -= cycle_table [opcode];
+int Snes_Spc::dsp_read( rel_time_t time )
+{
+ RUN_DSP( time, reg_times [REGS [r_dspaddr] & 0x7F] );
- // Use 'data' for temporaries whose lifetime crosses read/write calls, otherwise
- // use a local temporary.
- switch ( opcode )
- {
+ int result = dsp.read( REGS [r_dspaddr] & 0x7F );
- #define BRANCH( cond ) {\
- pc++;\
- int offset = (BOOST::int8_t) data;\
- if ( cond ) {\
- pc += offset;\
- remain_ -= 2;\
- }\
- goto loop;\
- }
+ #ifdef SPC_DSP_READ_HOOK
+ SPC_DSP_READ_HOOK( spc_time + time, (REGS [r_dspaddr] & 0x7F), result );
+ #endif
-// Most-Common
+ return result;
+}
- case 0xF0: // BEQ (most common)
- BRANCH( !(uint8_t) nz )
-
- case 0xD0: // BNE
- BRANCH( (uint8_t) nz )
+inline void Snes_Spc::dsp_write( int data, rel_time_t time )
+{
+ RUN_DSP( time, reg_times [REGS [r_dspaddr]] )
+ #if SPC_LESS_ACCURATE
+ else if ( m.dsp_time == skipping_time )
+ {
+ int r = REGS [r_dspaddr];
+ if ( r == Spc_Dsp::r_kon )
+ m.skipped_kon |= data & ~dsp.read( Spc_Dsp::r_koff );
+
+ if ( r == Spc_Dsp::r_koff )
+ {
+ m.skipped_koff |= data;
+ m.skipped_kon &= ~data;
+ }
+ }
+ #endif
- case 0x3F: // CALL
- PUSH16( pc + 2 );
- pc = READ_PROG16( pc );
- goto loop;
+ #ifdef SPC_DSP_WRITE_HOOK
+ SPC_DSP_WRITE_HOOK( m.spc_time + time, REGS [r_dspaddr], (uint8_t) data );
+ #endif
- case 0x6F: // RET
- pc = POP();
- pc += POP() * 0x100;
- goto loop;
-
-#define CASE( n ) case n:
-
-// Define common address modes based on opcode for immediate mode. Execution
-// ends with data set to the address of the operand.
-#define ADDR_MODES( op )\
- CASE( op - 0x02 ) /* (X) */\
- data = x + dp;\
- pc--;\
- goto end_##op;\
- CASE( op + 0x0F ) /* (dp)+Y */\
- data = READ_PROG16( data + dp ) + y;\
- goto end_##op;\
- CASE( op - 0x01 ) /* (dp+X) */\
- data = READ_PROG16( uint8_t (data + x) + dp );\
- goto end_##op;\
- CASE( op + 0x0E ) /* abs+Y */\
- data += y;\
- goto abs_##op;\
- CASE( op + 0x0D ) /* abs+X */\
- data += x;\
- CASE( op - 0x03 ) /* abs */\
- abs_##op:\
- pc++;\
- data += 0x100 * READ_PROG( pc );\
- goto end_##op;\
- CASE( op + 0x0C ) /* dp+X */\
- data = uint8_t (data + x);\
- CASE( op - 0x04 ) /* dp */\
- data += dp;\
- end_##op:
-
-// 1. 8-bit Data Transmission Commands. Group I
+ if ( REGS [r_dspaddr] <= 0x7F )
+ dsp.write( REGS [r_dspaddr], data );
+ else if ( !SPC_MORE_ACCURACY )
+ debug_printf( "SPC wrote to DSP register > $7F\n" );
+}
- ADDR_MODES( 0xE8 ) // MOV A,addr
- // case 0xE4: // MOV a,dp (most common)
- mov_a_addr:
- a = nz = READ( data );
- goto inc_pc_loop;
- case 0xBF: // MOV A,(X)+
- data = x + dp;
- x = uint8_t (x + 1);
- pc--;
- goto mov_a_addr;
-
- case 0xE8: // MOV A,imm
- a = data;
- nz = data;
- goto inc_pc_loop;
-
- case 0xF9: // MOV X,dp+Y
- data = uint8_t (data + y);
- case 0xF8: // MOV X,dp
- data += dp;
- goto mov_x_addr;
- case 0xE9: // MOV X,abs
- data = READ_PROG16( pc );
- pc++;
- mov_x_addr:
- data = READ( data );
- case 0xCD: // MOV X,imm
- x = data;
- nz = data;
- goto inc_pc_loop;
-
- case 0xFB: // MOV Y,dp+X
- data = uint8_t (data + x);
- case 0xEB: // MOV Y,dp
- data += dp;
- goto mov_y_addr;
- case 0xEC: // MOV Y,abs
- data = READ_PROG16( pc );
- pc++;
- mov_y_addr:
- data = READ( data );
- case 0x8D: // MOV Y,imm
- y = data;
- nz = data;
- goto inc_pc_loop;
-// 2. 8-BIT DATA TRANSMISSION COMMANDS, GROUP 2
+//// Memory access extras
- ADDR_MODES( 0xC8 ) // MOV addr,A
- WRITE( data, a );
- goto inc_pc_loop;
-
- {
- int temp;
- case 0xCC: // MOV abs,Y
- temp = y;
- goto mov_abs_temp;
- case 0xC9: // MOV abs,X
- temp = x;
- mov_abs_temp:
- WRITE( READ_PROG16( pc ), temp );
- pc += 2;
- goto loop;
- }
-
- case 0xD9: // MOV dp+Y,X
- data = uint8_t (data + y);
- case 0xD8: // MOV dp,X
- WRITE( data + dp, x );
- goto inc_pc_loop;
-
- case 0xDB: // MOV dp+X,Y
- data = uint8_t (data + x);
- case 0xCB: // MOV dp,Y
- WRITE( data + dp, y );
- goto inc_pc_loop;
-
- case 0xFA: // MOV dp,dp
- data = READ( data + dp );
- case 0x8F: // MOV dp,#imm
- pc++;
- WRITE_DP( READ_PROG( pc ), data );
- goto inc_pc_loop;
-
-// 3. 8-BIT DATA TRANSMISSIN COMMANDS, GROUP 3.
-
- case 0x7D: // MOV A,X
- a = x;
- nz = x;
- goto loop;
-
- case 0xDD: // MOV A,Y
- a = y;
- nz = y;
- goto loop;
-
- case 0x5D: // MOV X,A
- x = a;
- nz = a;
- goto loop;
-
- case 0xFD: // MOV Y,A
- y = a;
- nz = a;
- goto loop;
-
- case 0x9D: // MOV X,SP
- x = nz = GET_SP();
- goto loop;
-
- case 0xBD: // MOV SP,X
- SET_SP( x );
- goto loop;
-
- //case 0xC6: // MOV (X),A (handled by MOV addr,A in group 2)
-
- case 0xAF: // MOV (X)+,A
- WRITE_DP( x, a );
- x++;
- goto loop;
-
-// 5. 8-BIT LOGIC OPERATION COMMANDS
-
-#define LOGICAL_OP( op, func )\
- ADDR_MODES( op ) /* addr */\
- data = READ( data );\
- case op: /* imm */\
- nz = a func##= data;\
- goto inc_pc_loop;\
- { unsigned addr;\
- case op + 0x11: /* X,Y */\
- data = READ_DP( y );\
- addr = x + dp;\
- pc--;\
- goto addr_##op;\
- case op + 0x01: /* dp,dp */\
- data = READ_DP( data );\
- case op + 0x10: /*dp,imm*/\
- pc++;\
- addr = READ_PROG( pc ) + dp;\
- addr_##op:\
- nz = data func READ( addr );\
- WRITE( addr, nz );\
- goto inc_pc_loop;\
+#if SPC_MORE_ACCURACY
+ #define MEM_ACCESS( time, addr ) \
+ {\
+ if ( time >= m.dsp_time )\
+ {\
+ RUN_DSP( time, max_reg_time );\
+ }\
}
+#elif !defined (NDEBUG)
+ // Debug-only check for read/write within echo buffer, since this might result in
+ // inaccurate emulation due to the DSP not being caught up to the present.
- LOGICAL_OP( 0x28, & ); // AND
-
- LOGICAL_OP( 0x08, | ); // OR
-
- LOGICAL_OP( 0x48, ^ ); // EOR
-
-// 4. 8-BIT ARITHMETIC OPERATION COMMANDS
-
- ADDR_MODES( 0x68 ) // CMP addr
- data = READ( data );
- case 0x68: // CMP imm
- nz = a - data;
- c = ~nz;
- nz &= 0xFF;
- goto inc_pc_loop;
-
- case 0x79: // CMP (X),(Y)
- data = READ_DP( x );
- nz = data - READ_DP( y );
- c = ~nz;
- nz &= 0xFF;
- goto loop;
-
- case 0x69: // CMP (dp),(dp)
- data = READ_DP( data );
- case 0x78: // CMP dp,imm
- pc++;
- nz = READ_DP( READ_PROG( pc ) ) - data;
- c = ~nz;
- nz &= 0xFF;
- goto inc_pc_loop;
-
- case 0x3E: // CMP X,dp
- data += dp;
- goto cmp_x_addr;
- case 0x1E: // CMP X,abs
- data = READ_PROG16( pc );
- pc++;
- cmp_x_addr:
- data = READ( data );
- case 0xC8: // CMP X,imm
- nz = x - data;
- c = ~nz;
- nz &= 0xFF;
- goto inc_pc_loop;
-
- case 0x7E: // CMP Y,dp
- data += dp;
- goto cmp_y_addr;
- case 0x5E: // CMP Y,abs
- data = READ_PROG16( pc );
- pc++;
- cmp_y_addr:
- data = READ( data );
- case 0xAD: // CMP Y,imm
- nz = y - data;
- c = ~nz;
- nz &= 0xFF;
- goto inc_pc_loop;
-
+ bool Snes_Spc::check_echo_access( int addr )
{
- int addr;
- case 0xB9: // SBC (x),(y)
- case 0x99: // ADC (x),(y)
- pc--; // compensate for inc later
- data = READ_DP( x );
- addr = y + dp;
- goto adc_addr;
- case 0xA9: // SBC dp,dp
- case 0x89: // ADC dp,dp
- data = READ_DP( data );
- case 0xB8: // SBC dp,imm
- case 0x98: // ADC dp,imm
- pc++;
- addr = READ_PROG( pc ) + dp;
- adc_addr:
- nz = READ( addr );
- goto adc_data;
-
-// catch ADC and SBC together, then decode later based on operand
-#undef CASE
-#define CASE( n ) case n: case (n) + 0x20:
- ADDR_MODES( 0x88 ) // ADC/SBC addr
- data = READ( data );
- case 0xA8: // SBC imm
- case 0x88: // ADC imm
- addr = -1; // A
- nz = a;
- adc_data: {
- if ( opcode & 0x20 )
- data ^= 0xFF; // SBC
- int carry = (c >> 8) & 1;
- int ov = (nz ^ 0x80) + carry + (BOOST::int8_t) data; // sign-extend
- int hc = (nz & 15) + carry;
- c = nz += data + carry;
- hc = (nz & 15) - hc;
- status = (status & ~(st_v | st_h)) | ((ov >> 2) & st_v) | ((hc >> 1) & st_h);
- if ( addr < 0 ) {
- a = (uint8_t) nz;
- goto inc_pc_loop;
+ if ( !(dsp.read( Spc_Dsp::r_flg ) & 0x20) )
+ {
+ int start = 0x100 * dsp.read( Spc_Dsp::r_esa );
+ int size = 0x800 * (dsp.read( Spc_Dsp::r_edl ) & 0x0F);
+ int end = start + (size ? size : 4);
+ if ( start <= addr && addr < end )
+ {
+ if ( !m.echo_accessed )
+ {
+ m.echo_accessed = 1;
+ return true;
+ }
+ }
}
- WRITE( addr, (uint8_t) nz );
- goto inc_pc_loop;
- }
-
+ return false;
}
-// 6. ADDITION & SUBTRACTION COMMANDS
-
-#define INC_DEC_REG( reg, n )\
- nz = reg + n;\
- reg = (uint8_t) nz;\
- goto loop;
-
- case 0xBC: INC_DEC_REG( a, 1 ) // INC A
- case 0x3D: INC_DEC_REG( x, 1 ) // INC X
- case 0xFC: INC_DEC_REG( y, 1 ) // INC Y
-
- case 0x9C: INC_DEC_REG( a, -1 ) // DEC A
- case 0x1D: INC_DEC_REG( x, -1 ) // DEC X
- case 0xDC: INC_DEC_REG( y, -1 ) // DEC Y
+ #define MEM_ACCESS( time, addr ) check( !check_echo_access( (uint16_t) addr ) );
+#else
+ #define MEM_ACCESS( time, addr )
+#endif
- case 0x9B: // DEC dp+X
- case 0xBB: // INC dp+X
- data = uint8_t (data + x);
- case 0x8B: // DEC dp
- case 0xAB: // INC dp
- data += dp;
- goto inc_abs;
- case 0x8C: // DEC abs
- case 0xAC: // INC abs
- data = READ_PROG16( pc );
- pc++;
- inc_abs:
- nz = ((opcode >> 4) & 2) - 1;
- nz += READ( data );
- WRITE( data, (uint8_t) nz );
- goto inc_pc_loop;
-
-// 7. SHIFT, ROTATION COMMANDS
- case 0x5C: // LSR A
- c = 0;
- case 0x7C:{// ROR A
- nz = ((c >> 1) & 0x80) | (a >> 1);
- c = a << 8;
- a = nz;
- goto loop;
- }
-
- case 0x1C: // ASL A
- c = 0;
- case 0x3C:{// ROL A
- int temp = (c >> 8) & 1;
- c = a << 1;
- nz = c | temp;
- a = (uint8_t) nz;
- goto loop;
- }
-
- case 0x0B: // ASL dp
- c = 0;
- data += dp;
- goto rol_mem;
- case 0x1B: // ASL dp+X
- c = 0;
- case 0x3B: // ROL dp+X
- data = uint8_t (data + x);
- case 0x2B: // ROL dp
- data += dp;
- goto rol_mem;
- case 0x0C: // ASL abs
- c = 0;
- case 0x2C: // ROL abs
- data = READ_PROG16( pc );
- pc++;
- rol_mem:
- nz = (c >> 8) & 1;
- nz |= (c = READ( data ) << 1);
- WRITE( data, (uint8_t) nz );
- goto inc_pc_loop;
-
- case 0x4B: // LSR dp
- c = 0;
- data += dp;
- goto ror_mem;
- case 0x5B: // LSR dp+X
- c = 0;
- case 0x7B: // ROR dp+X
- data = uint8_t (data + x);
- case 0x6B: // ROR dp
- data += dp;
- goto ror_mem;
- case 0x4C: // LSR abs
- c = 0;
- case 0x6C: // ROR abs
- data = READ_PROG16( pc );
- pc++;
- ror_mem: {
- int temp = READ( data );
- nz = ((c >> 1) & 0x80) | (temp >> 1);
- c = temp << 8;
- WRITE( data, nz );
- goto inc_pc_loop;
- }
+//// CPU write
- case 0x9F: // XCN
- nz = a = (a >> 4) | uint8_t (a << 4);
- goto loop;
+#if SPC_MORE_ACCURACY
+static unsigned char const glitch_probs [3] [256] =
+{
+ 0xC3,0x92,0x5B,0x1C,0xD1,0x92,0x5B,0x1C,0xDB,0x9C,0x72,0x18,0xCD,0x5C,0x38,0x0B,
+ 0xE1,0x9C,0x74,0x17,0xCF,0x75,0x45,0x0C,0xCF,0x6E,0x4A,0x0D,0xA3,0x3A,0x1D,0x08,
+ 0xDB,0xA0,0x82,0x19,0xD9,0x73,0x3C,0x0E,0xCB,0x76,0x52,0x0B,0xA5,0x46,0x1D,0x09,
+ 0xDA,0x74,0x55,0x0F,0xA2,0x3F,0x21,0x05,0x9A,0x40,0x20,0x07,0x63,0x1E,0x10,0x01,
+ 0xDF,0xA9,0x85,0x1D,0xD3,0x84,0x4B,0x0E,0xCF,0x6F,0x49,0x0F,0xB3,0x48,0x1E,0x05,
+ 0xD8,0x77,0x52,0x12,0xB7,0x49,0x23,0x06,0xAA,0x45,0x28,0x07,0x7D,0x28,0x0F,0x07,
+ 0xCC,0x7B,0x4A,0x0E,0xB2,0x4F,0x24,0x07,0xAD,0x43,0x2C,0x06,0x86,0x29,0x11,0x07,
+ 0xAE,0x48,0x1F,0x0A,0x76,0x21,0x19,0x05,0x76,0x21,0x14,0x05,0x44,0x11,0x0B,0x01,
+ 0xE7,0xAD,0x96,0x23,0xDC,0x86,0x59,0x0E,0xDC,0x7C,0x5F,0x15,0xBB,0x53,0x2E,0x09,
+ 0xD6,0x7C,0x4A,0x16,0xBB,0x4A,0x25,0x08,0xB3,0x4F,0x28,0x0B,0x8E,0x23,0x15,0x08,
+ 0xCF,0x7F,0x57,0x11,0xB5,0x4A,0x23,0x0A,0xAA,0x42,0x28,0x05,0x7D,0x22,0x12,0x03,
+ 0xA6,0x49,0x28,0x09,0x82,0x2B,0x0D,0x04,0x7A,0x20,0x0F,0x04,0x3D,0x0F,0x09,0x03,
+ 0xD1,0x7C,0x4C,0x0F,0xAF,0x4E,0x21,0x09,0xA8,0x46,0x2A,0x07,0x85,0x1F,0x0E,0x07,
+ 0xA6,0x3F,0x26,0x07,0x7C,0x24,0x14,0x07,0x78,0x22,0x16,0x04,0x46,0x12,0x0A,0x02,
+ 0xA6,0x41,0x2C,0x0A,0x7E,0x28,0x11,0x05,0x73,0x1B,0x14,0x05,0x3D,0x11,0x0A,0x02,
+ 0x70,0x22,0x17,0x05,0x48,0x13,0x08,0x03,0x3C,0x07,0x0D,0x07,0x26,0x07,0x06,0x01,
+
+ 0xE0,0x9F,0xDA,0x7C,0x4F,0x18,0x28,0x0D,0xE9,0x9F,0xDA,0x7C,0x4F,0x18,0x1F,0x07,
+ 0xE6,0x97,0xD8,0x72,0x64,0x13,0x26,0x09,0xDC,0x67,0xA9,0x38,0x21,0x07,0x15,0x06,
+ 0xE9,0x91,0xD2,0x6B,0x63,0x14,0x2B,0x0E,0xD6,0x61,0xB7,0x41,0x2B,0x0E,0x10,0x09,
+ 0xCF,0x59,0xB0,0x2F,0x35,0x08,0x0F,0x07,0xB6,0x30,0x7A,0x21,0x17,0x07,0x09,0x03,
+ 0xE7,0xA3,0xE5,0x6B,0x65,0x1F,0x34,0x09,0xD8,0x6B,0xBE,0x45,0x27,0x07,0x10,0x07,
+ 0xDA,0x54,0xB1,0x39,0x2E,0x0E,0x17,0x08,0xA9,0x3C,0x86,0x22,0x16,0x06,0x07,0x03,
+ 0xD4,0x51,0xBC,0x3D,0x38,0x0A,0x13,0x06,0xB2,0x37,0x79,0x1C,0x17,0x05,0x0E,0x06,
+ 0xA7,0x31,0x74,0x1C,0x11,0x06,0x0C,0x02,0x6D,0x1A,0x38,0x10,0x0B,0x05,0x06,0x03,
+ 0xEB,0x9A,0xE1,0x7A,0x6F,0x13,0x34,0x0E,0xE6,0x75,0xC5,0x45,0x3E,0x0B,0x1A,0x05,
+ 0xD8,0x63,0xC1,0x40,0x3C,0x1B,0x19,0x06,0xB3,0x42,0x83,0x29,0x18,0x0A,0x08,0x04,
+ 0xD4,0x58,0xBA,0x43,0x3F,0x0A,0x1F,0x09,0xB1,0x33,0x8A,0x1F,0x1F,0x06,0x0D,0x05,
+ 0xAF,0x3C,0x7A,0x1F,0x16,0x08,0x0A,0x01,0x72,0x1B,0x52,0x0D,0x0B,0x09,0x06,0x01,
+ 0xCF,0x63,0xB7,0x47,0x40,0x10,0x14,0x06,0xC0,0x41,0x96,0x20,0x1C,0x09,0x10,0x05,
+ 0xA6,0x35,0x82,0x1A,0x20,0x0C,0x0E,0x04,0x80,0x1F,0x53,0x0F,0x0B,0x02,0x06,0x01,
+ 0xA6,0x31,0x81,0x1B,0x1D,0x01,0x08,0x08,0x7B,0x20,0x4D,0x19,0x0E,0x05,0x07,0x03,
+ 0x6B,0x17,0x49,0x07,0x0E,0x03,0x0A,0x05,0x37,0x0B,0x1F,0x06,0x04,0x02,0x07,0x01,
+
+ 0xF0,0xD6,0xED,0xAD,0xEC,0xB1,0xEB,0x79,0xAC,0x22,0x47,0x1E,0x6E,0x1B,0x32,0x0A,
+ 0xF0,0xD6,0xEA,0xA4,0xED,0xC4,0xDE,0x82,0x98,0x1F,0x50,0x13,0x52,0x15,0x2A,0x0A,
+ 0xF1,0xD1,0xEB,0xA2,0xEB,0xB7,0xD8,0x69,0xA2,0x1F,0x5B,0x18,0x55,0x18,0x2C,0x0A,
+ 0xED,0xB5,0xDE,0x7E,0xE6,0x85,0xD3,0x59,0x59,0x0F,0x2C,0x09,0x24,0x07,0x15,0x09,
+ 0xF1,0xD6,0xEA,0xA0,0xEC,0xBB,0xDA,0x77,0xA9,0x23,0x58,0x14,0x5D,0x12,0x2F,0x09,
+ 0xF1,0xC1,0xE3,0x86,0xE4,0x87,0xD2,0x4E,0x68,0x15,0x26,0x0B,0x27,0x09,0x15,0x02,
+ 0xEE,0xA6,0xE0,0x5C,0xE0,0x77,0xC3,0x41,0x67,0x1B,0x3C,0x07,0x2A,0x06,0x19,0x07,
+ 0xE4,0x75,0xC6,0x43,0xCC,0x50,0x95,0x23,0x35,0x09,0x14,0x04,0x15,0x05,0x0B,0x04,
+ 0xEE,0xD6,0xED,0xAD,0xEC,0xB1,0xEB,0x79,0xAC,0x22,0x56,0x14,0x5A,0x12,0x26,0x0A,
+ 0xEE,0xBB,0xE7,0x7E,0xE9,0x8D,0xCB,0x49,0x67,0x11,0x34,0x07,0x2B,0x0B,0x14,0x07,
+ 0xED,0xA7,0xE5,0x76,0xE3,0x7E,0xC4,0x4B,0x77,0x14,0x34,0x08,0x27,0x07,0x14,0x04,
+ 0xE7,0x8B,0xD2,0x4C,0xCA,0x56,0x9E,0x31,0x36,0x0C,0x11,0x07,0x14,0x04,0x0A,0x02,
+ 0xF0,0x9B,0xEA,0x6F,0xE5,0x81,0xC4,0x43,0x74,0x10,0x30,0x0B,0x2D,0x08,0x1B,0x06,
+ 0xE6,0x83,0xCA,0x48,0xD9,0x56,0xA7,0x23,0x3B,0x09,0x12,0x09,0x15,0x07,0x0A,0x03,
+ 0xE5,0x5F,0xCB,0x3C,0xCF,0x48,0x91,0x22,0x31,0x0A,0x17,0x08,0x15,0x04,0x0D,0x02,
+ 0xD1,0x43,0x91,0x20,0xA9,0x2D,0x54,0x12,0x17,0x07,0x09,0x02,0x0C,0x04,0x05,0x03,
+};
+#endif
-// 8. 16-BIT TRANSMISION COMMANDS
+// Read/write handlers are divided into multiple functions to keep rarely-used
+// functionality separate so often-used functionality can be optimized better
+// by compiler.
- case 0xBA: // MOVW YA,dp
- a = READ_DP( data );
- nz = (a & 0x7F) | (a >> 1);
- y = READ_DP( uint8_t (data + 1) );
- nz |= y;
- goto inc_pc_loop;
-
- case 0xDA: // MOVW dp,YA
- WRITE_DP( data, a );
- WRITE_DP( uint8_t (data + 1), y );
- goto inc_pc_loop;
-
-// 9. 16-BIT OPERATION COMMANDS
+// If write isn't preceded by read, data has this added to it
+int const no_read_before_write = 0x2000;
- case 0x3A: // INCW dp
- case 0x1A:{// DECW dp
- data += dp;
-
- // low byte
- int temp = READ( data );
- temp += ((opcode >> 4) & 2) - 1; // +1 for INCW, -1 for DECW
- nz = ((temp >> 1) | temp) & 0x7F;
- WRITE( data, (uint8_t) temp );
-
- // high byte
- data = uint8_t (data + 1) + dp;
- temp >>= 8;
- temp = uint8_t (temp + READ( data ));
- nz |= temp;
- WRITE( data, temp );
-
- goto inc_pc_loop;
- }
-
- case 0x9A: // SUBW YA,dp
- case 0x7A: // ADDW YA,dp
+void Snes_Spc::cpu_write_smp_reg_( int data, rel_time_t time, uint16_t addr )
+{
+ switch ( addr )
{
- // read 16-bit addend
- int temp = READ_DP( data );
- int sign = READ_DP( uint8_t (data + 1) );
- temp += 0x100 * sign;
- status &= ~(st_v | st_h);
-
- // to do: fix half-carry for SUBW (it's probably wrong)
-
- // for SUBW, negate and truncate to 16 bits
- if ( opcode & 0x80 ) {
- temp = (temp ^ 0xFFFF) + 1;
- sign = temp >> 8;
+ case r_t0target:
+ case r_t1target:
+ case r_t2target: {
+ Timer* t = &m.timers [addr - r_t0target];
+ int period = IF_0_THEN_256( data );
+ if ( t->period != period )
+ {
+ t = run_timer( t, time );
+ #if SPC_MORE_ACCURACY
+ // Insane behavior when target is written just after counter is
+ // clocked and counter matches new period and new period isn't 1, 2, 4, or 8
+ if ( t->divider == (period & 0xFF) &&
+ t->next_time == time + TIMER_MUL( t, 1 ) &&
+ ((period - 1) | ~0x0F) & period )
+ {
+ //debug_printf( "SPC pathological timer target write\n" );
+
+ // If the period is 3, 5, or 9, there's a probability this behavior won't occur,
+ // based on the previous period
+ int prob = 0xFF;
+ int old_period = t->period & 0xFF;
+ if ( period == 3 ) prob = glitch_probs [0] [old_period];
+ if ( period == 5 ) prob = glitch_probs [1] [old_period];
+ if ( period == 9 ) prob = glitch_probs [2] [old_period];
+
+ // The glitch suppresses incrementing of one of the counter bits, based on
+ // the lowest set bit in the new period
+ int b = 1;
+ while ( !(period & b) )
+ b <<= 1;
+
+ if ( (rand() >> 4 & 0xFF) <= prob )
+ t->divider = (t->divider - b) & 0xFF;
+ }
+ #endif
+ t->period = period;
}
-
- // add low byte (A)
- temp += a;
- a = (uint8_t) temp;
- nz = (temp | (temp >> 1)) & 0x7F;
-
- // add high byte (Y)
- temp >>= 8;
- c = y + temp;
- nz = (nz | c) & 0xFF;
-
- // half-carry (temporary avoids CodeWarrior optimizer bug)
- unsigned hc = (c & 15) - (y & 15);
- status |= (hc >> 4) & st_h;
-
- // overflow if sign of YA changed when previous sign and addend sign were same
- status |= (((c ^ y) & ~(y ^ sign)) >> 1) & st_v;
-
- y = (uint8_t) c;
-
- goto inc_pc_loop;
- }
-
- case 0x5A: { // CMPW YA,dp
- int temp = a - READ_DP( data );
- nz = ((temp >> 1) | temp) & 0x7F;
- temp = y + (temp >> 8);
- temp -= READ_DP( uint8_t (data + 1) );
- nz |= temp;
- c = ~temp;
- nz &= 0xFF;
- goto inc_pc_loop;
+ break;
}
-// 10. MULTIPLICATION & DIVISON COMMANDS
-
- case 0xCF: { // MUL YA
- unsigned temp = y * a;
- a = (uint8_t) temp;
- nz = ((temp >> 1) | temp) & 0x7F;
- y = temp >> 8;
- nz |= y;
- goto loop;
- }
-
- case 0x9E: // DIV YA,X
- {
- // behavior based on SPC CPU tests
-
- status &= ~(st_h | st_v);
+ case r_t0out:
+ case r_t1out:
+ case r_t2out:
+ if ( !SPC_MORE_ACCURACY )
+ debug_printf( "SPC wrote to counter %d\n", (int) addr - r_t0out );
- if ( (y & 15) >= (x & 15) )
- status |= st_h;
-
- if ( y >= x )
- status |= st_v;
-
- unsigned ya = y * 0x100 + a;
- if ( y < x * 2 )
+ if ( data < no_read_before_write / 2 )
+ run_timer( &m.timers [addr - r_t0out], time - 1 )->counter = 0;
+ break;
+
+ // Registers that act like RAM
+ case 0x8:
+ case 0x9:
+ REGS_IN [addr] = (uint8_t) data;
+ break;
+
+ case r_test:
+ if ( (uint8_t) data != 0x0A )
+ debug_printf( "SPC wrote to test register\n" );
+ break;
+
+ case r_control:
+ // port clears
+ if ( data & 0x10 )
{
- a = ya / x;
- y = ya - a * x;
+ REGS_IN [r_cpuio0] = 0;
+ REGS_IN [r_cpuio1] = 0;
}
- else
+ if ( data & 0x20 )
{
- a = 255 - (ya - x * 0x200) / (256 - x);
- y = x + (ya - x * 0x200) % (256 - x);
+ REGS_IN [r_cpuio2] = 0;
+ REGS_IN [r_cpuio3] = 0;
}
- nz = (uint8_t) a;
- a = (uint8_t) a;
-
- goto loop;
+ // timers
+ {
+ for ( int i = 0; i < timer_count; i++ )
+ {
+ Timer* t = &m.timers [i];
+ int enabled = data >> i & 1;
+ if ( t->enabled != enabled )
+ {
+ t = run_timer( t, time );
+ t->enabled = enabled;
+ if ( enabled )
+ {
+ t->divider = 0;
+ t->counter = 0;
+ }
+ }
+ }
+ }
+ enable_rom( data & 0x80 );
+ break;
}
-
-// 11. DECIMAL COMPENSATION COMMANDS
-
- // seem unused
- // case 0xDF: // DAA
- // case 0xBE: // DAS
-
-// 12. BRANCHING COMMANDS
+}
- case 0x2F: // BRA rel
- pc += (BOOST::int8_t) data;
- goto inc_pc_loop;
-
- case 0x30: // BMI
- BRANCH( IS_NEG )
-
- case 0x10: // BPL
- BRANCH( !IS_NEG )
-
- case 0xB0: // BCS
- BRANCH( c & 0x100 )
-
- case 0x90: // BCC
- BRANCH( !(c & 0x100) )
-
- case 0x70: // BVS
- BRANCH( status & st_v )
-
- case 0x50: // BVC
- BRANCH( !(status & st_v) )
-
- case 0x03: // BBS dp.bit,rel
- case 0x23:
- case 0x43:
- case 0x63:
- case 0x83:
- case 0xA3:
- case 0xC3:
- case 0xE3:
- pc++;
- if ( (READ_DP( data ) >> (opcode >> 5)) & 1 )
- goto cbranch_taken_loop;
- goto inc_pc_loop;
-
- case 0x13: // BBC dp.bit,rel
- case 0x33:
- case 0x53:
- case 0x73:
- case 0x93:
- case 0xB3:
- case 0xD3:
- case 0xF3:
- pc++;
- if ( !((READ_DP( data ) >> (opcode >> 5)) & 1) )
- goto cbranch_taken_loop;
- goto inc_pc_loop;
-
- case 0xDE: // CBNE dp+X,rel
- data = uint8_t (data + x);
- // fall through
- case 0x2E: // CBNE dp,rel
- pc++;
- if ( READ_DP( data ) != a )
- goto cbranch_taken_loop;
- goto inc_pc_loop;
-
- case 0xFE: // DBNZ Y,rel
- y = uint8_t (y - 1);
- BRANCH( y )
-
- case 0x6E: { // DBNZ dp,rel
- pc++;
- unsigned temp = READ_DP( data ) - 1;
- WRITE_DP( (uint8_t) data, (uint8_t) temp );
- if ( temp )
- goto cbranch_taken_loop;
- goto inc_pc_loop;
- }
-
- case 0x1F: // JMP (abs+X)
- pc = READ_PROG16( pc ) + x;
- // fall through
- case 0x5F: // JMP abs
- pc = READ_PROG16( pc );
- goto loop;
-
-// 13. SUB-ROUTINE CALL RETURN COMMANDS
-
- case 0x0F:{// BRK
- check( false ); // untested
- PUSH16( pc + 1 );
- pc = READ_PROG16( 0xFFDE ); // vector address verified
- int temp;
- CALC_STATUS( temp );
- PUSH( temp );
- status = (status | st_b) & ~st_i;
- goto loop;
- }
-
- case 0x4F: // PCALL offset
- pc++;
- PUSH16( pc );
- pc = 0xFF00 + data;
- goto loop;
-
- case 0x01: // TCALL n
- case 0x11:
- case 0x21:
- case 0x31:
- case 0x41:
- case 0x51:
- case 0x61:
- case 0x71:
- case 0x81:
- case 0x91:
- case 0xA1:
- case 0xB1:
- case 0xC1:
- case 0xD1:
- case 0xE1:
- case 0xF1:
- PUSH16( pc );
- pc = READ_PROG16( 0xFFDE - (opcode >> 3) );
- goto loop;
-
-// 14. STACK OPERATION COMMANDS
+void Snes_Spc::cpu_write_smp_reg( int data, rel_time_t time, uint16_t addr )
+{
+ if ( addr == r_dspdata ) // 99%
+ dsp_write( data, time );
+ else
+ cpu_write_smp_reg_( data, time, addr );
+}
- {
- int temp;
- case 0x7F: // RET1
- temp = POP();
- pc = POP();
- pc |= POP() << 8;
- goto set_status;
- case 0x8E: // POP PSW
- temp = POP();
- set_status:
- SET_STATUS( temp );
- goto loop;
- }
+void Snes_Spc::cpu_write_high( int data, uint8_t i )
+{
+ assert ( i < rom_size );
+ m.hi_ram [i] = (uint8_t) data;
+ if ( m.rom_enabled )
+ RAM [i + rom_addr] = m.rom [i]; // restore overwritten ROM
+}
+
+void Snes_Spc::cpu_write( int data, uint16_t addr, rel_time_t time )
+{
+ MEM_ACCESS( time, addr )
- case 0x0D: { // PUSH PSW
- int temp;
- CALC_STATUS( temp );
- PUSH( temp );
- goto loop;
+ // RAM
+ RAM [addr] = (uint8_t) data;
+ if ( addr >= 0xF0 ) // 64%
+ {
+ const uint16_t reg = addr - 0xF0;
+ // $F0-$FF
+ if ( reg < reg_count ) // 87%
+ {
+ REGS [reg] = (uint8_t) data;
+
+ // Ports
+ #ifdef SPC_PORT_WRITE_HOOK
+ if ( (unsigned) (reg - r_cpuio0) < port_count )
+ SPC_PORT_WRITE_HOOK( m.spc_time + time, (reg - r_cpuio0),
+ (uint8_t) data, &REGS [r_cpuio0] );
+ #endif
+
+ // Registers other than $F2 and $F4-$F7
+ if ( reg != 2 && (reg < 4 || reg > 7) ) // 36%
+ cpu_write_smp_reg( data, time, reg );
+ }
+ // High mem/address wrap-around
+ else if ( addr >= rom_addr ) // 1% in IPL ROM area or address wrapped around
+ cpu_write_high( data, addr - rom_addr );
}
+}
- case 0x2D: // PUSH A
- PUSH( a );
- goto loop;
-
- case 0x4D: // PUSH X
- PUSH( x );
- goto loop;
-
- case 0x6D: // PUSH Y
- PUSH( y );
- goto loop;
-
- case 0xAE: // POP A
- a = POP();
- goto loop;
-
- case 0xCE: // POP X
- x = POP();
- goto loop;
-
- case 0xEE: // POP Y
- y = POP();
- goto loop;
-
-// 15. BIT OPERATION COMMANDS
- case 0x02: // SET1
- case 0x22:
- case 0x42:
- case 0x62:
- case 0x82:
- case 0xA2:
- case 0xC2:
- case 0xE2:
- case 0x12: // CLR1
- case 0x32:
- case 0x52:
- case 0x72:
- case 0x92:
- case 0xB2:
- case 0xD2:
- case 0xF2: {
- data += dp;
- int bit = 1 << (opcode >> 5);
- int mask = ~bit;
- if ( opcode & 0x10 )
- bit = 0;
- WRITE( data, (READ( data ) & mask) | bit );
- goto inc_pc_loop;
- }
-
- case 0x0E: // TSET1 abs
- case 0x4E:{// TCLR1 abs
- data = READ_PROG16( pc );
- pc += 2;
- unsigned temp = READ( data );
- nz = temp & a;
- temp &= ~a;
- if ( !(opcode & 0x40) )
- temp |= a;
- WRITE( data, temp );
- goto loop;
- }
-
- case 0x4A: // AND1 C,mem.bit
- c &= mem_bit( pc );
- pc += 2;
- goto loop;
-
- case 0x6A: // AND1 C,/mem.bit
- check( false ); // untested
- c &= ~mem_bit( pc );
- pc += 2;
- goto loop;
-
- case 0x0A: // OR1 C,mem.bit
- check( false ); // untested
- c |= mem_bit( pc );
- pc += 2;
- goto loop;
-
- case 0x2A: // OR1 C,/mem.bit
- check( false ); // untested
- c |= ~mem_bit( pc );
- pc += 2;
- goto loop;
-
- case 0x8A: // EOR1 C,mem.bit
- c ^= mem_bit( pc );
- pc += 2;
- goto loop;
-
- case 0xEA: { // NOT1 mem.bit
- data = READ_PROG16( pc );
- pc += 2;
- unsigned temp = READ( data & 0x1FFF );
- temp ^= 1 << (data >> 13);
- WRITE( data & 0x1FFF, temp );
- goto loop;
+//// CPU read
+
+inline int Snes_Spc::cpu_read_smp_reg( int reg, rel_time_t time )
+{
+ int result = REGS_IN [reg];
+ reg -= r_dspaddr;
+ // DSP addr and data
+ if ( (unsigned) reg <= 1 ) // 4% 0xF2 and 0xF3
+ {
+ result = REGS [r_dspaddr];
+ if ( (unsigned) reg == 1 )
+ result = dsp_read( time ); // 0xF3
}
+ return result;
+}
+
+int Snes_Spc::cpu_read( uint16_t addr, rel_time_t time )
+{
+ MEM_ACCESS( time, addr )
- case 0xCA: { // MOV1 mem.bit,C
- data = READ_PROG16( pc );
- pc += 2;
- unsigned temp = READ( data & 0x1FFF );
- unsigned bit = data >> 13;
- temp = (temp & ~(1 << bit)) | (((c >> 8) & 1) << bit);
- WRITE( data & 0x1FFF, temp );
- goto loop;
+ // RAM
+ int result = RAM [addr];
+ int reg = addr - 0xF0;
+ if ( reg >= 0 ) // 40%
+ {
+ reg -= 0x10;
+ if ( (unsigned) reg >= 0xFF00 ) // 21%
+ {
+ reg += 0x10 - r_t0out;
+
+ // Timers
+ if ( (unsigned) reg < timer_count ) // 90%
+ {
+ Timer* t = &m.timers [reg];
+ if ( time >= t->next_time )
+ t = run_timer_( t, time );
+ result = t->counter;
+ t->counter = 0;
+ }
+ // Other registers
+ else if ( reg < 0 ) // 10%
+ {
+ result = cpu_read_smp_reg( reg + r_t0out, time );
+ }
+ else // 1%
+ {
+ assert( reg + (r_t0out + 0xF0 - 0x10000) < 0x100 );
+ result = cpu_read( reg + (r_t0out + 0xF0 - 0x10000), time );
+ }
+ }
}
- case 0xAA: // MOV1 C,mem.bit
- c = mem_bit( pc );
- pc += 2;
- goto loop;
-
-// 16. PROGRAM STATUS FLAG OPERATION COMMANDS
+ return result;
+}
- case 0x60: // CLRC
- c = 0;
- goto loop;
-
- case 0x80: // SETC
- c = ~0;
- goto loop;
-
- case 0xED: // NOTC
- c ^= 0x100;
- goto loop;
-
- case 0xE0: // CLRV
- status &= ~(st_v | st_h);
- goto loop;
-
- case 0x20: // CLRP
- dp = 0;
- goto loop;
-
- case 0x40: // SETP
- dp = 0x100;
- goto loop;
-
- case 0xA0: // EI
- check( false ); // untested
- status |= st_i;
- goto loop;
-
- case 0xC0: // DI
- check( false ); // untested
- status &= ~st_i;
- goto loop;
-
-// 17. OTHER COMMANDS
- case 0x00: // NOP
- goto loop;
-
- //case 0xEF: // SLEEP
- //case 0xFF: // STOP
+//// Run
+
+// Prefix and suffix for CPU emulator function
+#define SPC_CPU_RUN_FUNC \
+uint8_t* Snes_Spc::run_until_( time_t end_time )\
+{\
+ rel_time_t rel_time = m.spc_time - end_time;\
+ assert( rel_time <= 0 );\
+ m.spc_time = end_time;\
+ m.dsp_time += rel_time;\
+ m.timers [0].next_time += rel_time;\
+ m.timers [1].next_time += rel_time;\
+ m.timers [2].next_time += rel_time;
+
+#define SPC_CPU_RUN_FUNC_END \
+ m.spc_time += rel_time;\
+ m.dsp_time -= rel_time;\
+ m.timers [0].next_time -= rel_time;\
+ m.timers [1].next_time -= rel_time;\
+ m.timers [2].next_time -= rel_time;\
+ assert( m.spc_time <= end_time );\
+ return &REGS [r_cpuio0];\
+}
+
+int const cpu_lag_max = 12 - 1; // DIV YA,X takes 12 clocks
+
+void Snes_Spc::end_frame( time_t end_time )
+{
+ // Catch CPU up to as close to end as possible. If final instruction
+ // would exceed end, does NOT execute it and leaves m.spc_time < end.
+ if ( end_time > m.spc_time )
+ run_until_( end_time );
- } // switch
+ m.spc_time -= end_time;
+ m.extra_clocks += end_time;
- // unhandled instructions fall out of switch so emulator can catch them
+ // Greatest number of clocks early that emulation can stop early due to
+ // not being able to execute current instruction without going over
+ // allowed time.
+ assert( -cpu_lag_max <= m.spc_time && m.spc_time <= 0 );
-stop:
- pc--;
+ // Catch timers up to CPU
+ for ( int i = 0; i < timer_count; i++ )
+ run_timer( &m.timers [i], 0 );
+ // Catch DSP up to CPU
+ if ( m.dsp_time < 0 )
{
- int temp;
- CALC_STATUS( temp );
- r.status = (uint8_t) temp;
+ RUN_DSP( 0, max_reg_time );
}
- r.pc = pc;
- r.sp = (uint8_t) GET_SP();
- r.a = (uint8_t) a;
- r.x = (uint8_t) x;
- r.y = (uint8_t) y;
-
- return remain_;
+ // Save any extra samples beyond what should be generated
+ if ( m.buf_begin )
+ save_extra();
}
+
+// Inclusion here allows static memory access functions and better optimization
+#include "Spc_Cpu.h"
diff --git a/src/libs/gme/Spc_Cpu.h b/src/libs/gme/Spc_Cpu.h
index 40f55aea..2dd3e63c 100644
--- a/src/libs/gme/Spc_Cpu.h
+++ b/src/libs/gme/Spc_Cpu.h
@@ -1,57 +1,1182 @@
-// Super Nintendo (SNES) SPC-700 CPU emulator
-
-// Game_Music_Emu 0.5.5
-#ifndef SPC_CPU_H
-#define SPC_CPU_H
-
-#include "blargg_common.h"
-
-typedef unsigned spc_addr_t;
-typedef blargg_long spc_time_t;
-
-class Snes_Spc;
-
-class Spc_Cpu {
- typedef BOOST::uint8_t uint8_t;
- uint8_t* const ram;
-public:
- // Keeps pointer to 64K RAM
- Spc_Cpu( Snes_Spc* spc, uint8_t* ram );
-
- // SPC-700 registers. *Not* kept updated during a call to run().
- struct registers_t {
- long pc; // more than 16 bits to allow overflow detection
- uint8_t a;
- uint8_t x;
- uint8_t y;
- uint8_t status;
- uint8_t sp;
- } r;
-
- // Run CPU for at least 'count' cycles. Return the number of cycles remaining
- // when emulation stopped (negative if extra cycles were emulated). Emulation
- // stops when there are no more remaining cycles or an unhandled instruction
- // is encountered (STOP, SLEEP, and any others not yet implemented). In the
- // latter case, the return value is greater than zero.
- spc_time_t run( spc_time_t count );
-
- // Number of clock cycles remaining for current run() call
- spc_time_t remain() const;
-
- // Access memory as the emulated CPU does
- int read ( spc_addr_t );
- void write( spc_addr_t, int );
-
-private:
- // noncopyable
- Spc_Cpu( const Spc_Cpu& );
- Spc_Cpu& operator = ( const Spc_Cpu& );
- unsigned mem_bit( spc_addr_t );
-
- spc_time_t remain_;
- Snes_Spc& emu;
-};
-
-inline spc_time_t Spc_Cpu::remain() const { return remain_; }
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
+/* Copyright (C) 2004-2007 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 */
+
+//// Memory access
+
+#if SPC_MORE_ACCURACY
+ #define SUSPICIOUS_OPCODE( name ) ((void) 0)
+#else
+ #define SUSPICIOUS_OPCODE( name ) debug_printf( "SPC: suspicious opcode: " name "\n" )
+#endif
+
+#define CPU_READ( time, offset, addr )\
+ cpu_read( addr, time + offset )
+
+#define CPU_WRITE( time, offset, addr, data )\
+ cpu_write( data, addr, time + offset )
+
+#if SPC_MORE_ACCURACY
+ #define CPU_READ_TIMER( time, offset, addr, out )\
+ { out = CPU_READ( time, offset, addr ); }
+
+#else
+ // timers are by far the most common thing read from dp
+ #define CPU_READ_TIMER( time, offset, addr_, out )\
+ {\
+ rel_time_t adj_time = time + offset;\
+ int dp_addr = addr_;\
+ int ti = dp_addr - (r_t0out + 0xF0);\
+ if ( (unsigned) ti < timer_count )\
+ {\
+ Timer* t = &m.timers [ti];\
+ if ( adj_time >= t->next_time )\
+ t = run_timer_( t, adj_time );\
+ out = t->counter;\
+ t->counter = 0;\
+ }\
+ else\
+ {\
+ out = ram [dp_addr];\
+ int i = dp_addr - 0xF0;\
+ if ( (unsigned) i < 0x10 )\
+ out = cpu_read_smp_reg( i, adj_time );\
+ }\
+ }
#endif
+
+#define TIME_ADJ( n ) (n)
+
+#define READ_TIMER( time, addr, out ) CPU_READ_TIMER( rel_time, TIME_ADJ(time), (addr), out )
+#define READ( time, addr ) CPU_READ ( rel_time, TIME_ADJ(time), (addr) )
+#define WRITE( time, addr, data ) CPU_WRITE( rel_time, TIME_ADJ(time), (addr), (data) )
+
+#define DP_ADDR( addr ) (dp + (addr))
+
+#define READ_DP_TIMER( time, addr, out ) CPU_READ_TIMER( rel_time, TIME_ADJ(time), DP_ADDR( addr ), out )
+#define READ_DP( time, addr ) READ ( time, DP_ADDR( addr ) )
+#define WRITE_DP( time, addr, data ) WRITE( time, DP_ADDR( addr ), data )
+
+#define READ_PROG16( addr ) (RAM [(addr) & 0xffff] | (RAM [((addr) + 1) & 0xffff] << 8))
+
+#define SET_PC( n ) (pc = n)
+#define GET_PC() (pc)
+#define READ_PC( pc ) (ram [pc])
+#define READ_PC16( pc ) READ_PROG16( pc )
+
+#define SET_SP( v ) (sp = v)
+#define GET_SP() ((uint8_t) (sp))
+
+#define PUSH16( data )\
+{\
+ PUSH( (data & 0xff00) >> 8 );\
+ PUSH( data & 0xff );\
+}
+
+#define PUSH( data )\
+{\
+ ram [0x100 + sp] = (uint8_t) (data);\
+ --sp;\
+}
+
+#define POP( out )\
+{\
+ ++sp;\
+ out = ram [0x100 + sp];\
+}
+
+#define MEM_BIT( rel ) CPU_mem_bit( pc, rel_time + rel )
+
+unsigned Snes_Spc::CPU_mem_bit( uint16_t pc, rel_time_t rel_time )
+{
+ unsigned addr = READ_PC16( pc );
+ unsigned t = READ( 0, addr & 0x1FFF ) >> (addr >> 13);
+ return t << 8 & 0x100;
+}
+
+//// Status flag handling
+
+// Hex value in name to clarify code and bit shifting.
+// Flag stored in indicated variable during emulation
+int const n80 = 0x80; // nz
+int const v40 = 0x40; // psw
+int const p20 = 0x20; // dp
+int const b10 = 0x10; // psw
+int const h08 = 0x08; // psw
+int const i04 = 0x04; // psw
+int const z02 = 0x02; // nz
+int const c01 = 0x01; // c
+
+int const nz_neg_mask = 0x880; // either bit set indicates N flag set
+
+#define GET_PSW( out )\
+{\
+ out = psw & ~(n80 | p20 | z02 | c01);\
+ out |= c >> 8 & c01;\
+ out |= dp >> 3 & p20;\
+ out |= ((nz >> 4) | nz) & n80;\
+ if ( !(uint8_t) nz ) out |= z02;\
+}
+
+#define SET_PSW( in )\
+{\
+ psw = in;\
+ c = in << 8;\
+ dp = in << 3 & 0x100;\
+ nz = (in << 4 & 0x800) | (~in & z02);\
+}
+
+SPC_CPU_RUN_FUNC
+{
+ uint8_t* const ram = RAM;
+ uint8_t a = m.cpu_regs.a;
+ uint8_t x = m.cpu_regs.x;
+ uint8_t y = m.cpu_regs.y;
+ uint16_t pc;
+ uint8_t sp;
+ int psw;
+ int c;
+ int nz;
+ int dp;
+
+ SET_PC( m.cpu_regs.pc );
+ SET_SP( m.cpu_regs.sp );
+ SET_PSW( m.cpu_regs.psw );
+
+ goto loop;
+
+
+ // Main loop
+
+cbranch_taken_loop:
+ pc += (int8_t) ram [pc];
+inc_pc_loop:
+ pc++;
+loop:
+{
+ unsigned opcode;
+ unsigned data;
+
+ check( (unsigned) a < 0x100 );
+ check( (unsigned) x < 0x100 );
+ check( (unsigned) y < 0x100 );
+
+ opcode = ram [pc];
+ if ( (rel_time += m.cycle_table [opcode]) > 0 )
+ goto out_of_time;
+
+ #ifdef SPC_CPU_OPCODE_HOOK
+ SPC_CPU_OPCODE_HOOK( GET_PC(), opcode );
+ #endif
+ /*
+ //SUB_CASE_COUNTER( 1 );
+ #define PROFILE_TIMER_LOOP( op, addr, len )\
+ if ( opcode == op )\
+ {\
+ int cond = (unsigned) ((addr) - 0xFD) < 3 &&\
+ pc [len] == 0xF0 && pc [len+1] == 0xFE - len;\
+ SUB_CASE_COUNTER( op && cond );\
+ }
+
+ PROFILE_TIMER_LOOP( 0xEC, GET_LE16( pc + 1 ), 3 );
+ PROFILE_TIMER_LOOP( 0xEB, pc [1], 2 );
+ PROFILE_TIMER_LOOP( 0xE4, pc [1], 2 );
+ */
+
+ // TODO: if PC is at end of memory, this will get wrong operand (very obscure)
+ pc++;
+ data = ram [pc];
+ switch ( opcode )
+ {
+
+// Common instructions
+
+#define BRANCH( cond )\
+{\
+ pc++;\
+ pc += (int8_t) data;\
+ if ( cond )\
+ goto loop;\
+ pc -= (int8_t) data;\
+ rel_time -= 2;\
+ goto loop;\
+}
+
+ case 0xF0: // BEQ
+ BRANCH( !(uint8_t) nz ) // 89% taken
+
+ case 0xD0: // BNE
+ BRANCH( (uint8_t) nz )
+
+ case 0x3F:{// CALL
+ int old_addr = GET_PC() + 2;
+ SET_PC( READ_PC16( pc ) );
+ PUSH16( old_addr );
+ goto loop;
+ }
+
+ case 0x6F:// RET
+ {
+ uint8_t l, h;
+ POP( l );
+ POP( h );
+ SET_PC( l | (h << 8) );
+ }
+ goto loop;
+
+ case 0xE4: // MOV a,dp
+ ++pc;
+ // 80% from timer
+ READ_DP_TIMER( 0, data, a = nz );
+ goto loop;
+
+ case 0xFA:{// MOV dp,dp
+ int temp;
+ READ_DP_TIMER( -2, data, temp );
+ data = temp + no_read_before_write ;
+ }
+ // fall through
+ case 0x8F:{// MOV dp,#imm
+ int temp = READ_PC( pc + 1 );
+ pc += 2;
+
+ #if !SPC_MORE_ACCURACY
+ {
+ int i = dp + temp;
+ ram [i] = (uint8_t) data;
+ i -= 0xF0;
+ if ( (unsigned) i < 0x10 ) // 76%
+ {
+ REGS [i] = (uint8_t) data;
+
+ // Registers other than $F2 and $F4-$F7
+ if ( i != 2 && (i < 4 || i > 7)) // 12%
+ cpu_write_smp_reg( data, rel_time, i );
+ }
+ }
+ #else
+ WRITE_DP( 0, temp, data );
+ #endif
+ goto loop;
+ }
+
+ case 0xC4: // MOV dp,a
+ ++pc;
+ #if !SPC_MORE_ACCURACY
+ {
+ int i = dp + data;
+ ram [i] = (uint8_t) a;
+ i -= 0xF0;
+ if ( (unsigned) i < 0x10 ) // 39%
+ {
+ unsigned sel = i - 2;
+ REGS [i] = (uint8_t) a;
+
+ if ( sel == 1 ) // 51% $F3
+ dsp_write( a, rel_time );
+ else if ( sel > 1 ) // 1% not $F2 or $F3
+ cpu_write_smp_reg_( a, rel_time, i );
+ }
+ }
+ #else
+ WRITE_DP( 0, data, a );
+ #endif
+ goto loop;
+
+#define CASE( n ) case n:
+
+// Define common address modes based on opcode for immediate mode. Execution
+// ends with data set to the address of the operand.
+#define ADDR_MODES_( op )\
+ CASE( op - 0x02 ) /* (X) */\
+ data = x + dp;\
+ pc--;\
+ goto end_##op;\
+ CASE( op + 0x0F ) /* (dp)+Y */\
+ data = READ_PROG16( data + dp ) + y;\
+ goto end_##op;\
+ CASE( op - 0x01 ) /* (dp+X) */\
+ data = READ_PROG16( ((uint8_t) (data + x)) + dp );\
+ goto end_##op;\
+ CASE( op + 0x0E ) /* abs+Y */\
+ data += y;\
+ goto abs_##op;\
+ CASE( op + 0x0D ) /* abs+X */\
+ data += x;\
+ CASE( op - 0x03 ) /* abs */\
+ abs_##op:\
+ data += 0x100 * READ_PC( ++pc );\
+ goto end_##op;\
+ CASE( op + 0x0C ) /* dp+X */\
+ data = (uint8_t) (data + x);
+
+#define ADDR_MODES_NO_DP( op )\
+ ADDR_MODES_( op )\
+ data += dp;\
+ end_##op:
+
+#define ADDR_MODES( op )\
+ ADDR_MODES_( op )\
+ CASE( op - 0x04 ) /* dp */\
+ data += dp;\
+ end_##op:
+
+// 1. 8-bit Data Transmission Commands. Group I
+
+ ADDR_MODES_NO_DP( 0xE8 ) // MOV A,addr
+ a = nz = READ( 0, data );
+ goto inc_pc_loop;
+
+ case 0xBF:{// MOV A,(X)+
+ int temp = x + dp;
+ x = (uint8_t) (x + 1);
+ a = nz = READ( -1, temp );
+ goto loop;
+ }
+
+ case 0xE8: // MOV A,imm
+ a = data;
+ nz = data;
+ goto inc_pc_loop;
+
+ case 0xF9: // MOV X,dp+Y
+ data = (uint8_t) (data + y);
+ case 0xF8: // MOV X,dp
+ READ_DP_TIMER( 0, data, x = nz );
+ goto inc_pc_loop;
+
+ case 0xE9: // MOV X,abs
+ data = READ_PC16( pc );
+ ++pc;
+ data = READ( 0, data );
+ case 0xCD: // MOV X,imm
+ x = data;
+ nz = data;
+ goto inc_pc_loop;
+
+ case 0xFB: // MOV Y,dp+X
+ data = (uint8_t) (data + x);
+ case 0xEB: // MOV Y,dp
+ // 70% from timer
+ pc++;
+ READ_DP_TIMER( 0, data, y = nz );
+ goto loop;
+
+ case 0xEC:{// MOV Y,abs
+ int temp = READ_PC16( pc );
+ pc += 2;
+ READ_TIMER( 0, temp, y = nz );
+ //y = nz = READ( 0, temp );
+ goto loop;
+ }
+
+ case 0x8D: // MOV Y,imm
+ y = data;
+ nz = data;
+ goto inc_pc_loop;
+
+// 2. 8-BIT DATA TRANSMISSION COMMANDS, GROUP 2
+
+ ADDR_MODES_NO_DP( 0xC8 ) // MOV addr,A
+ WRITE( 0, data, a );
+ goto inc_pc_loop;
+
+ {
+ int temp;
+ case 0xCC: // MOV abs,Y
+ temp = y;
+ goto mov_abs_temp;
+ case 0xC9: // MOV abs,X
+ temp = x;
+ mov_abs_temp:
+ WRITE( 0, READ_PC16( pc ), temp );
+ pc += 2;
+ goto loop;
+ }
+
+ case 0xD9: // MOV dp+Y,X
+ data = (uint8_t) (data + y);
+ case 0xD8: // MOV dp,X
+ WRITE( 0, data + dp, x );
+ goto inc_pc_loop;
+
+ case 0xDB: // MOV dp+X,Y
+ data = (uint8_t) (data + x);
+ case 0xCB: // MOV dp,Y
+ WRITE( 0, data + dp, y );
+ goto inc_pc_loop;
+
+// 3. 8-BIT DATA TRANSMISSIN COMMANDS, GROUP 3.
+
+ case 0x7D: // MOV A,X
+ a = x;
+ nz = x;
+ goto loop;
+
+ case 0xDD: // MOV A,Y
+ a = y;
+ nz = y;
+ goto loop;
+
+ case 0x5D: // MOV X,A
+ x = a;
+ nz = a;
+ goto loop;
+
+ case 0xFD: // MOV Y,A
+ y = a;
+ nz = a;
+ goto loop;
+
+ case 0x9D: // MOV X,SP
+ x = nz = GET_SP();
+ goto loop;
+
+ case 0xBD: // MOV SP,X
+ SET_SP( x );
+ goto loop;
+
+ //case 0xC6: // MOV (X),A (handled by MOV addr,A in group 2)
+
+ case 0xAF: // MOV (X)+,A
+ WRITE_DP( 0, x, a + no_read_before_write );
+ x = (uint8_t) (x + 1);
+ goto loop;
+
+// 5. 8-BIT LOGIC OPERATION COMMANDS
+
+#define LOGICAL_OP( op, func )\
+ ADDR_MODES( op ) /* addr */\
+ data = READ( 0, data );\
+ case op: /* imm */\
+ nz = a func##= data;\
+ goto inc_pc_loop;\
+ { unsigned addr;\
+ case op + 0x11: /* X,Y */\
+ data = READ_DP( -2, y );\
+ addr = x + dp;\
+ goto addr_##op;\
+ case op + 0x01: /* dp,dp */\
+ data = READ_DP( -3, data );\
+ case op + 0x10:{/*dp,imm*/\
+ uint16_t addr2 = pc + 1;\
+ pc += 2;\
+ addr = READ_PC( addr2 ) + dp;\
+ }\
+ addr_##op:\
+ nz = data func READ( -1, addr );\
+ WRITE( 0, addr, nz );\
+ goto loop;\
+ }
+
+ LOGICAL_OP( 0x28, & ); // AND
+
+ LOGICAL_OP( 0x08, | ); // OR
+
+ LOGICAL_OP( 0x48, ^ ); // EOR
+
+// 4. 8-BIT ARITHMETIC OPERATION COMMANDS
+
+ ADDR_MODES( 0x68 ) // CMP addr
+ data = READ( 0, data );
+ case 0x68: // CMP imm
+ nz = a - data;
+ c = ~nz;
+ nz &= 0xFF;
+ goto inc_pc_loop;
+
+ case 0x79: // CMP (X),(Y)
+ data = READ_DP( -2, y );
+ nz = READ_DP( -1, x ) - data;
+ c = ~nz;
+ nz &= 0xFF;
+ goto loop;
+
+ case 0x69: // CMP dp,dp
+ data = READ_DP( -3, data );
+ case 0x78: // CMP dp,imm
+ nz = READ_DP( -1, READ_PC( ++pc ) ) - data;
+ c = ~nz;
+ nz &= 0xFF;
+ goto inc_pc_loop;
+
+ case 0x3E: // CMP X,dp
+ data += dp;
+ goto cmp_x_addr;
+ case 0x1E: // CMP X,abs
+ data = READ_PC16( pc );
+ pc++;
+ cmp_x_addr:
+ data = READ( 0, data );
+ case 0xC8: // CMP X,imm
+ nz = x - data;
+ c = ~nz;
+ nz &= 0xFF;
+ goto inc_pc_loop;
+
+ case 0x7E: // CMP Y,dp
+ data += dp;
+ goto cmp_y_addr;
+ case 0x5E: // CMP Y,abs
+ data = READ_PC16( pc );
+ pc++;
+ cmp_y_addr:
+ data = READ( 0, data );
+ case 0xAD: // CMP Y,imm
+ nz = y - data;
+ c = ~nz;
+ nz &= 0xFF;
+ goto inc_pc_loop;
+
+ {
+ int addr;
+ case 0xB9: // SBC (x),(y)
+ case 0x99: // ADC (x),(y)
+ pc--; // compensate for inc later
+ data = READ_DP( -2, y );
+ addr = x + dp;
+ goto adc_addr;
+ case 0xA9: // SBC dp,dp
+ case 0x89: // ADC dp,dp
+ data = READ_DP( -3, data );
+ case 0xB8: // SBC dp,imm
+ case 0x98: // ADC dp,imm
+ addr = READ_PC( ++pc ) + dp;
+ adc_addr:
+ nz = READ( -1, addr );
+ goto adc_data;
+
+// catch ADC and SBC together, then decode later based on operand
+#undef CASE
+#define CASE( n ) case n: case (n) + 0x20:
+ ADDR_MODES( 0x88 ) // ADC/SBC addr
+ data = READ( 0, data );
+ case 0xA8: // SBC imm
+ case 0x88: // ADC imm
+ addr = -1; // A
+ nz = a;
+ adc_data: {
+ int flags;
+ if ( opcode >= 0xA0 ) // SBC
+ data ^= 0xFF;
+
+ flags = data ^ nz;
+ nz += data + (c >> 8 & 1);
+ flags ^= nz;
+
+ psw = (psw & ~(v40 | h08)) |
+ (flags >> 1 & h08) |
+ ((flags + 0x80) >> 2 & v40);
+ c = nz;
+ if ( addr < 0 )
+ {
+ a = (uint8_t) nz;
+ goto inc_pc_loop;
+ }
+ WRITE( 0, addr, /*(uint8_t)*/ nz );
+ goto inc_pc_loop;
+ }
+
+ }
+
+// 6. ADDITION & SUBTRACTION COMMANDS
+
+#define INC_DEC_REG( reg, op )\
+ nz = reg op;\
+ reg = (uint8_t) nz;\
+ goto loop;
+
+ case 0xBC: INC_DEC_REG( a, + 1 ) // INC A
+ case 0x3D: INC_DEC_REG( x, + 1 ) // INC X
+ case 0xFC: INC_DEC_REG( y, + 1 ) // INC Y
+
+ case 0x9C: INC_DEC_REG( a, - 1 ) // DEC A
+ case 0x1D: INC_DEC_REG( x, - 1 ) // DEC X
+ case 0xDC: INC_DEC_REG( y, - 1 ) // DEC Y
+
+ case 0x9B: // DEC dp+X
+ case 0xBB: // INC dp+X
+ data = (uint8_t) (data + x);
+ case 0x8B: // DEC dp
+ case 0xAB: // INC dp
+ data += dp;
+ goto inc_abs;
+ case 0x8C: // DEC abs
+ case 0xAC: // INC abs
+ data = READ_PC16( pc );
+ pc++;
+ inc_abs:
+ nz = (opcode >> 4 & 2) - 1;
+ nz += READ( -1, data );
+ WRITE( 0, data, /*(uint8_t)*/ nz );
+ goto inc_pc_loop;
+
+// 7. SHIFT, ROTATION COMMANDS
+
+ case 0x5C: // LSR A
+ c = 0;
+ case 0x7C:{// ROR A
+ nz = (c >> 1 & 0x80) | (a >> 1);
+ c = a << 8;
+ a = nz;
+ goto loop;
+ }
+
+ case 0x1C: // ASL A
+ c = 0;
+ case 0x3C:{// ROL A
+ int temp = c >> 8 & 1;
+ c = a << 1;
+ nz = c | temp;
+ a = (uint8_t) nz;
+ goto loop;
+ }
+
+ case 0x0B: // ASL dp
+ c = 0;
+ data += dp;
+ goto rol_mem;
+ case 0x1B: // ASL dp+X
+ c = 0;
+ case 0x3B: // ROL dp+X
+ data = (uint8_t) (data + x);
+ case 0x2B: // ROL dp
+ data += dp;
+ goto rol_mem;
+ case 0x0C: // ASL abs
+ c = 0;
+ case 0x2C: // ROL abs
+ data = READ_PC16( pc );
+ pc++;
+ rol_mem:
+ nz = c >> 8 & 1;
+ nz |= (c = READ( -1, data ) << 1);
+ WRITE( 0, data, /*(uint8_t)*/ nz );
+ goto inc_pc_loop;
+
+ case 0x4B: // LSR dp
+ c = 0;
+ data += dp;
+ goto ror_mem;
+ case 0x5B: // LSR dp+X
+ c = 0;
+ case 0x7B: // ROR dp+X
+ data = (uint8_t) (data + x);
+ case 0x6B: // ROR dp
+ data += dp;
+ goto ror_mem;
+ case 0x4C: // LSR abs
+ c = 0;
+ case 0x6C: // ROR abs
+ data = READ_PC16( pc );
+ pc++;
+ ror_mem: {
+ int temp = READ( -1, data );
+ nz = (c >> 1 & 0x80) | (temp >> 1);
+ c = temp << 8;
+ WRITE( 0, data, nz );
+ goto inc_pc_loop;
+ }
+
+ case 0x9F: // XCN
+ nz = a = (a >> 4) | (uint8_t) (a << 4);
+ goto loop;
+
+// 8. 16-BIT TRANSMISION COMMANDS
+
+ case 0xBA: // MOVW YA,dp
+ a = READ_DP( -2, data );
+ nz = (a & 0x7F) | (a >> 1);
+ y = READ_DP( 0, (uint8_t) (data + 1) );
+ nz |= y;
+ goto inc_pc_loop;
+
+ case 0xDA: // MOVW dp,YA
+ WRITE_DP( -1, data, a );
+ WRITE_DP( 0, (uint8_t) (data + 1), y + no_read_before_write );
+ goto inc_pc_loop;
+
+// 9. 16-BIT OPERATION COMMANDS
+
+ case 0x3A: // INCW dp
+ case 0x1A:{// DECW dp
+ int temp;
+ // low byte
+ data += dp;
+ temp = READ( -3, data );
+ temp += (opcode >> 4 & 2) - 1; // +1 for INCW, -1 for DECW
+ nz = ((temp >> 1) | temp) & 0x7F;
+ WRITE( -2, data, /*(uint8_t)*/ temp );
+
+ // high byte
+ data = (uint8_t) (data + 1) + dp;
+ temp = (uint8_t) ((temp >> 8) + READ( -1, data ));
+ nz |= temp;
+ WRITE( 0, data, temp );
+
+ goto inc_pc_loop;
+ }
+
+ case 0x7A: // ADDW YA,dp
+ case 0x9A:{// SUBW YA,dp
+ int lo = READ_DP( -2, data );
+ int hi = READ_DP( 0, (uint8_t) (data + 1) );
+ int result;
+ int flags;
+
+ if ( opcode == 0x9A ) // SUBW
+ {
+ lo = (lo ^ 0xFF) + 1;
+ hi ^= 0xFF;
+ }
+
+ lo += a;
+ result = y + hi + (lo >> 8);
+ flags = hi ^ y ^ result;
+
+ psw = (psw & ~(v40 | h08)) |
+ (flags >> 1 & h08) |
+ ((flags + 0x80) >> 2 & v40);
+ c = result;
+ a = (uint8_t) lo;
+ result = (uint8_t) result;
+ y = result;
+ nz = (((lo >> 1) | lo) & 0x7F) | result;
+
+ goto inc_pc_loop;
+ }
+
+ case 0x5A: { // CMPW YA,dp
+ int temp = a - READ_DP( -1, data );
+ nz = ((temp >> 1) | temp) & 0x7F;
+ temp = y + (temp >> 8);
+ temp -= READ_DP( 0, (uint8_t) (data + 1) );
+ nz |= temp;
+ c = ~temp;
+ nz &= 0xFF;
+ goto inc_pc_loop;
+ }
+
+// 10. MULTIPLICATION & DIVISON COMMANDS
+
+ case 0xCF: { // MUL YA
+ unsigned temp = y * a;
+ a = (uint8_t) temp;
+ nz = ((temp >> 1) | temp) & 0x7F;
+ y = (uint8_t) (temp >> 8);
+ nz |= y;
+ goto loop;
+ }
+
+ case 0x9E: // DIV YA,X
+ {
+ unsigned ya = y * 0x100 + a;
+
+ psw &= ~(h08 | v40);
+
+ if ( y >= x )
+ psw |= v40;
+
+ if ( (y & 15) >= (x & 15) )
+ psw |= h08;
+
+ if ( y < x * 2 )
+ {
+ a = ya / x;
+ y = ya - a * x;
+ }
+ else
+ {
+ a = 255 - (ya - x * 0x200) / (256 - x);
+ y = x + (ya - x * 0x200) % (256 - x);
+ }
+
+ nz = (uint8_t) a;
+ a = (uint8_t) a;
+ y = (uint8_t) y;
+
+ goto loop;
+ }
+
+// 11. DECIMAL COMPENSATION COMMANDS
+
+ case 0xDF: // DAA
+ SUSPICIOUS_OPCODE( "DAA" );
+ if ( a > 0x99 || c & 0x100 )
+ {
+ a += 0x60;
+ c = 0x100;
+ }
+
+ if ( (a & 0x0F) > 9 || psw & h08 )
+ a += 0x06;
+
+ nz = a;
+ a = (uint8_t) a;
+ goto loop;
+
+ case 0xBE: // DAS
+ SUSPICIOUS_OPCODE( "DAS" );
+ if ( a > 0x99 || !(c & 0x100) )
+ {
+ a -= 0x60;
+ c = 0;
+ }
+
+ if ( (a & 0x0F) > 9 || !(psw & h08) )
+ a -= 0x06;
+
+ nz = a;
+ a = (uint8_t) a;
+ goto loop;
+
+// 12. BRANCHING COMMANDS
+
+ case 0x2F: // BRA rel
+ pc += (int8_t) data;
+ goto inc_pc_loop;
+
+ case 0x30: // BMI
+ BRANCH( (nz & nz_neg_mask) )
+
+ case 0x10: // BPL
+ BRANCH( !(nz & nz_neg_mask) )
+
+ case 0xB0: // BCS
+ BRANCH( c & 0x100 )
+
+ case 0x90: // BCC
+ BRANCH( !(c & 0x100) )
+
+ case 0x70: // BVS
+ BRANCH( psw & v40 )
+
+ case 0x50: // BVC
+ BRANCH( !(psw & v40) )
+
+ #define CBRANCH( cond )\
+ {\
+ pc++;\
+ if ( cond )\
+ goto cbranch_taken_loop;\
+ rel_time -= 2;\
+ goto inc_pc_loop;\
+ }
+
+ case 0x03: // BBS dp.bit,rel
+ case 0x23:
+ case 0x43:
+ case 0x63:
+ case 0x83:
+ case 0xA3:
+ case 0xC3:
+ case 0xE3:
+ CBRANCH( READ_DP( -4, data ) >> (opcode >> 5) & 1 )
+
+ case 0x13: // BBC dp.bit,rel
+ case 0x33:
+ case 0x53:
+ case 0x73:
+ case 0x93:
+ case 0xB3:
+ case 0xD3:
+ case 0xF3:
+ CBRANCH( !(READ_DP( -4, data ) >> (opcode >> 5) & 1) )
+
+ case 0xDE: // CBNE dp+X,rel
+ data = (uint8_t) (data + x);
+ // fall through
+ case 0x2E:{// CBNE dp,rel
+ int temp;
+ // 61% from timer
+ READ_DP_TIMER( -4, data, temp );
+ CBRANCH( temp != a )
+ }
+
+ case 0x6E: { // DBNZ dp,rel
+ unsigned temp = READ_DP( -4, data ) - 1;
+ WRITE_DP( -3, (uint8_t) data, /*(uint8_t)*/ temp + no_read_before_write );
+ CBRANCH( temp )
+ }
+
+ case 0xFE: // DBNZ Y,rel
+ y = (uint8_t) (y - 1);
+ BRANCH( y )
+
+ case 0x1F: // JMP [abs+X]
+ SET_PC( READ_PC16( pc ) + x );
+ // fall through
+ case 0x5F: // JMP abs
+ SET_PC( READ_PC16( pc ) );
+ goto loop;
+
+// 13. SUB-ROUTINE CALL RETURN COMMANDS
+
+ case 0x0F:{// BRK
+ int temp;
+ int ret_addr = GET_PC();
+ SUSPICIOUS_OPCODE( "BRK" );
+ SET_PC( READ_PROG16( 0xFFDE ) ); // vector address verified
+ PUSH16( ret_addr );
+ GET_PSW( temp );
+ psw = (psw | b10) & ~i04;
+ PUSH( temp );
+ goto loop;
+ }
+
+ case 0x4F:{// PCALL offset
+ int ret_addr = GET_PC() + 1;
+ SET_PC( 0xFF00 | data );
+ PUSH16( ret_addr );
+ goto loop;
+ }
+
+ case 0x01: // TCALL n
+ case 0x11:
+ case 0x21:
+ case 0x31:
+ case 0x41:
+ case 0x51:
+ case 0x61:
+ case 0x71:
+ case 0x81:
+ case 0x91:
+ case 0xA1:
+ case 0xB1:
+ case 0xC1:
+ case 0xD1:
+ case 0xE1:
+ case 0xF1: {
+ int ret_addr = GET_PC();
+ SET_PC( READ_PROG16( 0xFFDE - (opcode >> 3) ) );
+ PUSH16( ret_addr );
+ goto loop;
+ }
+
+// 14. STACK OPERATION COMMANDS
+
+ {
+ int temp;
+ uint8_t l, h;
+ case 0x7F: // RET1
+ POP (temp);
+ POP (l);
+ POP (h);
+ SET_PC( l | (h << 8) );
+ goto set_psw;
+ case 0x8E: // POP PSW
+ POP( temp );
+ set_psw:
+ SET_PSW( temp );
+ goto loop;
+ }
+
+ case 0x0D: { // PUSH PSW
+ int temp;
+ GET_PSW( temp );
+ PUSH( temp );
+ goto loop;
+ }
+
+ case 0x2D: // PUSH A
+ PUSH( a );
+ goto loop;
+
+ case 0x4D: // PUSH X
+ PUSH( x );
+ goto loop;
+
+ case 0x6D: // PUSH Y
+ PUSH( y );
+ goto loop;
+
+ case 0xAE: // POP A
+ POP( a );
+ goto loop;
+
+ case 0xCE: // POP X
+ POP( x );
+ goto loop;
+
+ case 0xEE: // POP Y
+ POP( y );
+ goto loop;
+
+// 15. BIT OPERATION COMMANDS
+
+ case 0x02: // SET1
+ case 0x22:
+ case 0x42:
+ case 0x62:
+ case 0x82:
+ case 0xA2:
+ case 0xC2:
+ case 0xE2:
+ case 0x12: // CLR1
+ case 0x32:
+ case 0x52:
+ case 0x72:
+ case 0x92:
+ case 0xB2:
+ case 0xD2:
+ case 0xF2: {
+ int bit = 1 << (opcode >> 5);
+ int mask = ~bit;
+ if ( opcode & 0x10 )
+ bit = 0;
+ data += dp;
+ WRITE( 0, data, (READ( -1, data ) & mask) | bit );
+ goto inc_pc_loop;
+ }
+
+ case 0x0E: // TSET1 abs
+ case 0x4E: // TCLR1 abs
+ data = READ_PC16( pc );
+ pc += 2;
+ {
+ unsigned temp = READ( -2, data );
+ nz = (uint8_t) (a - temp);
+ temp &= ~a;
+ if ( opcode == 0x0E )
+ temp |= a;
+ WRITE( 0, data, temp );
+ }
+ goto loop;
+
+ case 0x4A: // AND1 C,mem.bit
+ c &= MEM_BIT( 0 );
+ pc += 2;
+ goto loop;
+
+ case 0x6A: // AND1 C,/mem.bit
+ c &= ~MEM_BIT( 0 );
+ pc += 2;
+ goto loop;
+
+ case 0x0A: // OR1 C,mem.bit
+ c |= MEM_BIT( -1 );
+ pc += 2;
+ goto loop;
+
+ case 0x2A: // OR1 C,/mem.bit
+ c |= ~MEM_BIT( -1 );
+ pc += 2;
+ goto loop;
+
+ case 0x8A: // EOR1 C,mem.bit
+ c ^= MEM_BIT( -1 );
+ pc += 2;
+ goto loop;
+
+ case 0xEA: // NOT1 mem.bit
+ data = READ_PC16( pc );
+ pc += 2;
+ {
+ unsigned temp = READ( -1, data & 0x1FFF );
+ temp ^= 1 << (data >> 13);
+ WRITE( 0, data & 0x1FFF, temp );
+ }
+ goto loop;
+
+ case 0xCA: // MOV1 mem.bit,C
+ data = READ_PC16( pc );
+ pc += 2;
+ {
+ unsigned temp = READ( -2, data & 0x1FFF );
+ unsigned bit = data >> 13;
+ temp = (temp & ~(1 << bit)) | ((c >> 8 & 1) << bit);
+ WRITE( 0, data & 0x1FFF, temp + no_read_before_write );
+ }
+ goto loop;
+
+ case 0xAA: // MOV1 C,mem.bit
+ c = MEM_BIT( 0 );
+ pc += 2;
+ goto loop;
+
+// 16. PROGRAM PSW FLAG OPERATION COMMANDS
+
+ case 0x60: // CLRC
+ c = 0;
+ goto loop;
+
+ case 0x80: // SETC
+ c = ~0;
+ goto loop;
+
+ case 0xED: // NOTC
+ c ^= 0x100;
+ goto loop;
+
+ case 0xE0: // CLRV
+ psw &= ~(v40 | h08);
+ goto loop;
+
+ case 0x20: // CLRP
+ dp = 0;
+ goto loop;
+
+ case 0x40: // SETP
+ dp = 0x100;
+ goto loop;
+
+ case 0xA0: // EI
+ SUSPICIOUS_OPCODE( "EI" );
+ psw |= i04;
+ goto loop;
+
+ case 0xC0: // DI
+ SUSPICIOUS_OPCODE( "DI" );
+ psw &= ~i04;
+ goto loop;
+
+// 17. OTHER COMMANDS
+
+ case 0x00: // NOP
+ goto loop;
+
+ case 0xFF:{// STOP
+ // handle PC wrap-around
+ if ( pc == 0x0000 )
+ {
+ debug_printf( "SPC: PC wrapped around\n" );
+ goto loop;
+ }
+ }
+ // fall through
+ case 0xEF: // SLEEP
+ SUSPICIOUS_OPCODE( "STOP/SLEEP" );
+ --pc;
+ rel_time = 0;
+ m.cpu_error = "SPC emulation error";
+ goto stop;
+ } // switch
+
+ assert( 0 ); // catch any unhandled instructions
+}
+out_of_time:
+ rel_time -= m.cycle_table [ ram [pc] ]; // undo partial execution of opcode
+stop:
+
+ // Uncache registers
+ m.cpu_regs.pc = (uint16_t) GET_PC();
+ m.cpu_regs.sp = ( uint8_t) GET_SP();
+ m.cpu_regs.a = ( uint8_t) a;
+ m.cpu_regs.x = ( uint8_t) x;
+ m.cpu_regs.y = ( uint8_t) y;
+ {
+ int temp;
+ GET_PSW( temp );
+ m.cpu_regs.psw = (uint8_t) temp;
+ }
+}
+SPC_CPU_RUN_FUNC_END
diff --git a/src/libs/gme/Spc_Dsp.cpp b/src/libs/gme/Spc_Dsp.cpp
index 814ff2bd..51556434 100644
--- a/src/libs/gme/Spc_Dsp.cpp
+++ b/src/libs/gme/Spc_Dsp.cpp
@@ -1,666 +1,704 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
-
-// Based on Brad Martin's OpenSPC DSP emulator
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Spc_Dsp.h"
#include "blargg_endian.h"
#include <string.h>
-/* Copyright (C) 2002 Brad Martin */
-/* Copyright (C) 2004-2006 Shay Green. This module is free software; you
+/* Copyright (C) 2007 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"
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
-Spc_Dsp::Spc_Dsp( uint8_t* ram_ ) : ram( ram_ )
-{
- set_gain( 1.0 );
- mute_voices( 0 );
- disable_surround( false );
-
- assert( offsetof (globals_t,unused9 [2]) == register_count );
- assert( sizeof (voice) == register_count );
- blargg_verify_byte_order();
-}
+#if INT_MAX < 0x7FFFFFFF
+ #error "Requires that int type have at least 32 bits"
+#endif
-void Spc_Dsp::mute_voices( int mask )
-{
- for ( int i = 0; i < voice_count; i++ )
- voice_state [i].enabled = (mask >> i & 1) ? 31 : 7;
-}
-void Spc_Dsp::reset()
+// TODO: add to blargg_endian.h
+#define GET_LE16SA( addr ) ((int16_t) GET_LE16( addr ))
+#define GET_LE16A( addr ) GET_LE16( addr )
+#define SET_LE16A( addr, data ) SET_LE16( addr, data )
+
+static uint8_t const initial_regs [Spc_Dsp::register_count] =
{
- keys = 0;
- echo_ptr = 0;
- noise_count = 0;
- noise = 1;
- fir_offset = 0;
-
- g.flags = 0xE0; // reset, mute, echo off
- g.key_ons = 0;
-
- for ( int i = 0; i < voice_count; i++ )
- {
- voice_t& v = voice_state [i];
- v.on_cnt = 0;
- v.volume [0] = 0;
- v.volume [1] = 0;
- v.envstate = state_release;
- }
-
- memset( fir_buf, 0, sizeof fir_buf );
+ 0x45,0x8B,0x5A,0x9A,0xE4,0x82,0x1B,0x78,0x00,0x00,0xAA,0x96,0x89,0x0E,0xE0,0x80,
+ 0x2A,0x49,0x3D,0xBA,0x14,0xA0,0xAC,0xC5,0x00,0x00,0x51,0xBB,0x9C,0x4E,0x7B,0xFF,
+ 0xF4,0xFD,0x57,0x32,0x37,0xD9,0x42,0x22,0x00,0x00,0x5B,0x3C,0x9F,0x1B,0x87,0x9A,
+ 0x6F,0x27,0xAF,0x7B,0xE5,0x68,0x0A,0xD9,0x00,0x00,0x9A,0xC5,0x9C,0x4E,0x7B,0xFF,
+ 0xEA,0x21,0x78,0x4F,0xDD,0xED,0x24,0x14,0x00,0x00,0x77,0xB1,0xD1,0x36,0xC1,0x67,
+ 0x52,0x57,0x46,0x3D,0x59,0xF4,0x87,0xA4,0x00,0x00,0x7E,0x44,0x9C,0x4E,0x7B,0xFF,
+ 0x75,0xF5,0x06,0x97,0x10,0xC3,0x24,0xBB,0x00,0x00,0x7B,0x7A,0xE0,0x60,0x12,0x0F,
+ 0xF7,0x74,0x1C,0xE5,0x39,0x3D,0x73,0xC1,0x00,0x00,0x7A,0xB3,0xFF,0x4E,0x7B,0xFF
+};
+
+// if ( io < -32768 ) io = -32768;
+// if ( io > 32767 ) io = 32767;
+#define CLAMP16( io )\
+{\
+ if ( (int16_t) io != io )\
+ io = (io >> 31) ^ 0x7FFF;\
}
-void Spc_Dsp::write( int i, int data )
+// Access global DSP register
+#define REG(n) m.regs [r_##n]
+
+// Access voice DSP register
+#define VREG(r,n) r [v_##n]
+
+#define WRITE_SAMPLES( l, r, out ) \
+{\
+ out [0] = l;\
+ out [1] = r;\
+ out += 2;\
+ if ( out >= m.out_end )\
+ {\
+ check( out == m.out_end );\
+ check( m.out_end != &m.extra [extra_size] || \
+ (m.extra <= m.out_begin && m.extra < &m.extra [extra_size]) );\
+ out = m.extra;\
+ m.out_end = &m.extra [extra_size];\
+ }\
+}\
+
+void Spc_Dsp::set_output( sample_t* out, int size )
{
- require( (unsigned) i < register_count );
-
- reg [i] = data;
- int high = i >> 4;
- switch ( i & 0x0F )
+ require( (size & 1) == 0 ); // must be even
+ if ( !out )
{
- // voice volume
- case 0:
- case 1: {
- short* volume = voice_state [high].volume;
- int left = (int8_t) reg [i & ~1];
- int right = (int8_t) reg [i | 1];
- volume [0] = left;
- volume [1] = right;
- // kill surround only if enabled and signs of volumes differ
- if ( left * right < surround_threshold )
- {
- if ( left < 0 )
- volume [0] = -left;
- else
- volume [1] = -right;
- }
- break;
- }
-
- // fir coefficients
- case 0x0F:
- fir_coeff [high] = (int8_t) data; // sign-extend
- break;
+ out = m.extra;
+ size = extra_size;
}
+ m.out_begin = out;
+ m.out = out;
+ m.out_end = out + size;
}
-// This table is for envelope timing. It represents the number of counts
-// that should be subtracted from the counter each sample period (32kHz).
-// The counter starts at 30720 (0x7800). Each count divides exactly into
-// 0x7800 without remainder.
-const int env_rate_init = 0x7800;
-static short const env_rates [0x20] =
+// Volume registers and efb are signed! Easy to forget int8_t cast.
+// Prefixes are to avoid accidental use of locals with same names.
+
+// Interleved gauss table (to improve cache coherency)
+// interleved_gauss [i] = gauss [(i & 1) * 256 + 255 - (i >> 1 & 0xFF)]
+static short const interleved_gauss [512] =
{
- 0x0000, 0x000F, 0x0014, 0x0018, 0x001E, 0x0028, 0x0030, 0x003C,
- 0x0050, 0x0060, 0x0078, 0x00A0, 0x00C0, 0x00F0, 0x0140, 0x0180,
- 0x01E0, 0x0280, 0x0300, 0x03C0, 0x0500, 0x0600, 0x0780, 0x0A00,
- 0x0C00, 0x0F00, 0x1400, 0x1800, 0x1E00, 0x2800, 0x3C00, 0x7800
+ 370,1305, 366,1305, 362,1304, 358,1304, 354,1304, 351,1304, 347,1304, 343,1303,
+ 339,1303, 336,1303, 332,1302, 328,1302, 325,1301, 321,1300, 318,1300, 314,1299,
+ 311,1298, 307,1297, 304,1297, 300,1296, 297,1295, 293,1294, 290,1293, 286,1292,
+ 283,1291, 280,1290, 276,1288, 273,1287, 270,1286, 267,1284, 263,1283, 260,1282,
+ 257,1280, 254,1279, 251,1277, 248,1275, 245,1274, 242,1272, 239,1270, 236,1269,
+ 233,1267, 230,1265, 227,1263, 224,1261, 221,1259, 218,1257, 215,1255, 212,1253,
+ 210,1251, 207,1248, 204,1246, 201,1244, 199,1241, 196,1239, 193,1237, 191,1234,
+ 188,1232, 186,1229, 183,1227, 180,1224, 178,1221, 175,1219, 173,1216, 171,1213,
+ 168,1210, 166,1207, 163,1205, 161,1202, 159,1199, 156,1196, 154,1193, 152,1190,
+ 150,1186, 147,1183, 145,1180, 143,1177, 141,1174, 139,1170, 137,1167, 134,1164,
+ 132,1160, 130,1157, 128,1153, 126,1150, 124,1146, 122,1143, 120,1139, 118,1136,
+ 117,1132, 115,1128, 113,1125, 111,1121, 109,1117, 107,1113, 106,1109, 104,1106,
+ 102,1102, 100,1098, 99,1094, 97,1090, 95,1086, 94,1082, 92,1078, 90,1074,
+ 89,1070, 87,1066, 86,1061, 84,1057, 83,1053, 81,1049, 80,1045, 78,1040,
+ 77,1036, 76,1032, 74,1027, 73,1023, 71,1019, 70,1014, 69,1010, 67,1005,
+ 66,1001, 65, 997, 64, 992, 62, 988, 61, 983, 60, 978, 59, 974, 58, 969,
+ 56, 965, 55, 960, 54, 955, 53, 951, 52, 946, 51, 941, 50, 937, 49, 932,
+ 48, 927, 47, 923, 46, 918, 45, 913, 44, 908, 43, 904, 42, 899, 41, 894,
+ 40, 889, 39, 884, 38, 880, 37, 875, 36, 870, 36, 865, 35, 860, 34, 855,
+ 33, 851, 32, 846, 32, 841, 31, 836, 30, 831, 29, 826, 29, 821, 28, 816,
+ 27, 811, 27, 806, 26, 802, 25, 797, 24, 792, 24, 787, 23, 782, 23, 777,
+ 22, 772, 21, 767, 21, 762, 20, 757, 20, 752, 19, 747, 19, 742, 18, 737,
+ 17, 732, 17, 728, 16, 723, 16, 718, 15, 713, 15, 708, 15, 703, 14, 698,
+ 14, 693, 13, 688, 13, 683, 12, 678, 12, 674, 11, 669, 11, 664, 11, 659,
+ 10, 654, 10, 649, 10, 644, 9, 640, 9, 635, 9, 630, 8, 625, 8, 620,
+ 8, 615, 7, 611, 7, 606, 7, 601, 6, 596, 6, 592, 6, 587, 6, 582,
+ 5, 577, 5, 573, 5, 568, 5, 563, 4, 559, 4, 554, 4, 550, 4, 545,
+ 4, 540, 3, 536, 3, 531, 3, 527, 3, 522, 3, 517, 2, 513, 2, 508,
+ 2, 504, 2, 499, 2, 495, 2, 491, 2, 486, 1, 482, 1, 477, 1, 473,
+ 1, 469, 1, 464, 1, 460, 1, 456, 1, 451, 1, 447, 1, 443, 1, 439,
+ 0, 434, 0, 430, 0, 426, 0, 422, 0, 418, 0, 414, 0, 410, 0, 405,
+ 0, 401, 0, 397, 0, 393, 0, 389, 0, 385, 0, 381, 0, 378, 0, 374,
};
-const int env_range = 0x800;
-inline int Spc_Dsp::clock_envelope( int v )
-{ /* Return value is current
- * ENVX */
- raw_voice_t& raw_voice = this->voice [v];
- voice_t& voice = voice_state [v];
-
- int envx = voice.envx;
- if ( voice.envstate == state_release )
- {
- /*
- * Docs: "When in the state of "key off". the "click" sound is
- * prevented by the addition of the fixed value 1/256" WTF???
- * Alright, I'm going to choose to interpret that this way:
- * When a note is keyed off, start the RELEASE state, which
- * subtracts 1/256th each sample period (32kHz). Note there's
- * no need for a count because it always happens every update.
- */
- envx -= env_range / 256;
- if ( envx <= 0 )
- {
- envx = 0;
- keys &= ~(1 << v);
- return -1;
- }
- voice.envx = envx;
- raw_voice.envx = envx >> 8;
- return envx;
- }
+//// Counters
+
+#define RATE( rate, div )\
+ (rate >= div ? rate / div * 8 - 1 : rate - 1)
+
+static unsigned const counter_mask [32] =
+{
+ RATE( 2,2), RATE(2048,4), RATE(1536,3),
+ RATE(1280,5), RATE(1024,4), RATE( 768,3),
+ RATE( 640,5), RATE( 512,4), RATE( 384,3),
+ RATE( 320,5), RATE( 256,4), RATE( 192,3),
+ RATE( 160,5), RATE( 128,4), RATE( 96,3),
+ RATE( 80,5), RATE( 64,4), RATE( 48,3),
+ RATE( 40,5), RATE( 32,4), RATE( 24,3),
+ RATE( 20,5), RATE( 16,4), RATE( 12,3),
+ RATE( 10,5), RATE( 8,4), RATE( 6,3),
+ RATE( 5,5), RATE( 4,4), RATE( 3,3),
+ RATE( 2,4),
+ RATE( 1,4)
+};
+#undef RATE
+
+inline void Spc_Dsp::init_counter()
+{
+ // counters start out with this synchronization
+ m.counters [0] = 1;
+ m.counters [1] = 0;
+ m.counters [2] = -0x20u;
+ m.counters [3] = 0x0B;
- int cnt = voice.envcnt;
- int adsr1 = raw_voice.adsr [0];
- if ( adsr1 & 0x80 )
+ int n = 2;
+ for ( int i = 1; i < 32; i++ )
{
- switch ( voice.envstate )
- {
- case state_attack: {
- // increase envelope by 1/64 each step
- int t = adsr1 & 15;
- if ( t == 15 )
- {
- envx += env_range / 2;
- }
- else
- {
- cnt -= env_rates [t * 2 + 1];
- if ( cnt > 0 )
- break;
- envx += env_range / 64;
- cnt = env_rate_init;
- }
- if ( envx >= env_range )
- {
- envx = env_range - 1;
- voice.envstate = state_decay;
- }
- voice.envx = envx;
- break;
- }
-
- case state_decay: {
- // Docs: "DR... [is multiplied] by the fixed value
- // 1-1/256." Well, at least that makes some sense.
- // Multiplying ENVX by 255/256 every time DECAY is
- // updated.
- cnt -= env_rates [((adsr1 >> 3) & 0xE) + 0x10];
- if ( cnt <= 0 )
- {
- cnt = env_rate_init;
- envx -= ((envx - 1) >> 8) + 1;
- voice.envx = envx;
- }
- int sustain_level = raw_voice.adsr [1] >> 5;
-
- if ( envx <= (sustain_level + 1) * 0x100 )
- voice.envstate = state_sustain;
- break;
- }
-
- case state_sustain:
- // Docs: "SR [is multiplied] by the fixed value 1-1/256."
- // Multiplying ENVX by 255/256 every time SUSTAIN is
- // updated.
- cnt -= env_rates [raw_voice.adsr [1] & 0x1F];
- if ( cnt <= 0 )
- {
- cnt = env_rate_init;
- envx -= ((envx - 1) >> 8) + 1;
- voice.envx = envx;
- }
- break;
-
- case state_release:
- // handled above
- break;
- }
+ m.counter_select [i] = &m.counters [n];
+ if ( !--n )
+ n = 3;
}
- else
- { /* GAIN mode is set */
- /*
- * Note: if the game switches between ADSR and GAIN modes
- * partway through, should the count be reset, or should it
- * continue from where it was? Does the DSP actually watch for
- * that bit to change, or does it just go along with whatever
- * it sees when it performs the update? I'm going to assume
- * the latter and not update the count, unless I see a game
- * that obviously wants the other behavior. The effect would
- * be pretty subtle, in any case.
- */
- int t = raw_voice.gain;
- if (t < 0x80)
- {
- envx = voice.envx = t << 4;
- }
- else switch (t >> 5)
- {
- case 4: /* Docs: "Decrease (linear): Subtraction
- * of the fixed value 1/64." */
- cnt -= env_rates [t & 0x1F];
- if (cnt > 0)
- break;
- cnt = env_rate_init;
- envx -= env_range / 64;
- if ( envx < 0 )
- {
- envx = 0;
- if ( voice.envstate == state_attack )
- voice.envstate = state_decay;
- }
- voice.envx = envx;
- break;
- case 5: /* Docs: "Drecrease <sic> (exponential):
- * Multiplication by the fixed value
- * 1-1/256." */
- cnt -= env_rates [t & 0x1F];
- if (cnt > 0)
- break;
- cnt = env_rate_init;
- envx -= ((envx - 1) >> 8) + 1;
- if ( envx < 0 )
- {
- envx = 0;
- if ( voice.envstate == state_attack )
- voice.envstate = state_decay;
- }
- voice.envx = envx;
- break;
- case 6: /* Docs: "Increase (linear): Addition of
- * the fixed value 1/64." */
- cnt -= env_rates [t & 0x1F];
- if (cnt > 0)
- break;
- cnt = env_rate_init;
- envx += env_range / 64;
- if ( envx >= env_range )
- envx = env_range - 1;
- voice.envx = envx;
- break;
- case 7: /* Docs: "Increase (bent line): Addition
- * of the constant 1/64 up to .75 of the
- * constaint <sic> 1/256 from .75 to 1." */
- cnt -= env_rates [t & 0x1F];
- if (cnt > 0)
- break;
- cnt = env_rate_init;
- if ( envx < env_range * 3 / 4 )
- envx += env_range / 64;
- else
- envx += env_range / 256;
- if ( envx >= env_range )
- envx = env_range - 1;
- voice.envx = envx;
- break;
- }
- }
- voice.envcnt = cnt;
- raw_voice.envx = envx >> 4;
- return envx;
+ m.counter_select [ 0] = &m.counters [0];
+ m.counter_select [30] = &m.counters [2];
}
-// Clamp n into range -32768 <= n <= 32767
-inline int clamp_16( int n )
+inline void Spc_Dsp::run_counter( int i )
{
- if ( (BOOST::int16_t) n != n )
- n = BOOST::int16_t (0x7FFF - (n >> 31));
- return n;
+ int n = m.counters [i];
+ if ( !(n-- & 7) )
+ n -= 6 - i;
+ m.counters [i] = n;
}
-void Spc_Dsp::run( long count, short* out_buf )
+#define READ_COUNTER( rate )\
+ (*m.counter_select [rate] & counter_mask [rate])
+
+
+//// Emulation
+
+void Spc_Dsp::run( int clock_count )
{
- // to do: make clock_envelope() inline so that this becomes a leaf function?
-
- // Should we just fill the buffer with silence? Flags won't be cleared
- // during this run so it seems it should keep resetting every sample.
- if ( g.flags & 0x80 )
- reset();
-
- struct src_dir {
- char start [2];
- char loop [2];
- };
+ int new_phase = m.phase + clock_count;
+ int count = new_phase >> 5;
+ m.phase = new_phase & 31;
+ if ( !count )
+ return;
- const src_dir* const sd = (src_dir*) &ram [g.wave_page * 0x100];
+ uint8_t* const ram = m.ram;
+ uint8_t const* const dir = &ram [REG(dir) * 0x100];
+ int const slow_gaussian = (REG(pmon) >> 1) | REG(non);
+ int const noise_rate = REG(flg) & 0x1F;
- int left_volume = g.left_volume;
- int right_volume = g.right_volume;
- if ( left_volume * right_volume < surround_threshold )
- right_volume = -right_volume; // kill global surround
- left_volume *= emu_gain;
- right_volume *= emu_gain;
+ // Global volume
+ int mvoll = (int8_t) REG(mvoll);
+ int mvolr = (int8_t) REG(mvolr);
+ if ( mvoll * mvolr < m.surround_threshold )
+ mvoll = -mvoll; // eliminate surround
- while ( --count >= 0 )
+ do
{
- // Here we check for keys on/off. Docs say that successive writes
- // to KON/KOF must be separated by at least 2 Ts periods or risk
- // being neglected. Therefore DSP only looks at these during an
- // update, and not at the time of the write. Only need to do this
- // once however, since the regs haven't changed over the whole
- // period we need to catch up with.
+ // KON/KOFF reading
+ if ( (m.every_other_sample ^= 1) != 0 )
+ {
+ m.new_kon &= ~m.kon;
+ m.kon = m.new_kon;
+ m.t_koff = REG(koff);
+ }
- g.wave_ended &= ~g.key_ons; // Keying on a voice resets that bit in ENDX.
+ run_counter( 1 );
+ run_counter( 2 );
+ run_counter( 3 );
- if ( g.noise_enables )
+ // Noise
+ if ( !READ_COUNTER( noise_rate ) )
{
- noise_count -= env_rates [g.flags & 0x1F];
- if ( noise_count <= 0 )
- {
- noise_count = env_rate_init;
-
- noise_amp = BOOST::int16_t (noise * 2);
-
- // TODO: switch to Galios style
- int feedback = (noise << 13) ^ (noise << 14);
- noise = (feedback & 0x4000) | (noise >> 1);
- }
+ int feedback = (m.noise << 13) ^ (m.noise << 14);
+ m.noise = (feedback & 0x4000) ^ (m.noise >> 1);
}
- // What is the expected behavior when pitch modulation is enabled on
- // voice 0? Jurassic Park 2 does this. Assume 0 for now.
- blargg_long prev_outx = 0;
-
- int echol = 0;
- int echor = 0;
- int left = 0;
- int right = 0;
- for ( int vidx = 0; vidx < voice_count; vidx++ )
+ // Voices
+ int pmon_input = 0;
+ int main_out_l = 0;
+ int main_out_r = 0;
+ int echo_out_l = 0;
+ int echo_out_r = 0;
+ voice_t* v = m.voices;
+ uint8_t* v_regs = m.regs;
+ int vbit = 1;
+ do
{
- const int vbit = 1 << vidx;
- raw_voice_t& raw_voice = voice [vidx];
- voice_t& voice = voice_state [vidx];
+ #define SAMPLE_PTR(i) GET_LE16A( &dir [VREG(v_regs,srcn) * 4 + i * 2] )
+
+ int brr_header = ram [v->brr_addr];
+ int kon_delay = v->kon_delay;
- if ( voice.on_cnt && !--voice.on_cnt )
+ // Pitch
+ int pitch = GET_LE16A( &VREG(v_regs,pitchl) ) & 0x3FFF;
+ if ( REG(pmon) & vbit )
+ pitch += ((pmon_input >> 5) * pitch) >> 10;
+
+ // KON phases
+ if ( --kon_delay >= 0 )
{
- // key on
- keys |= vbit;
- voice.addr = GET_LE16( sd [raw_voice.waveform].start );
- voice.block_remain = 1;
- voice.envx = 0;
- voice.block_header = 0;
- voice.fraction = 0x3FFF; // decode three samples immediately
- voice.interp0 = 0; // BRR decoder filter uses previous two samples
- voice.interp1 = 0;
+ v->kon_delay = kon_delay;
+
+ // Get ready to start BRR decoding on next sample
+ if ( kon_delay == 4 )
+ {
+ v->brr_addr = SAMPLE_PTR( 0 );
+ v->brr_offset = 1;
+ v->buf_pos = v->buf;
+ brr_header = 0; // header is ignored on this sample
+ }
+
+ // Envelope is never run during KON
+ v->env = 0;
+ v->hidden_env = 0;
+
+ // Disable BRR decoding until last three samples
+ v->interp_pos = (kon_delay & 3 ? 0x4000 : 0);
- // NOTE: Real SNES does *not* appear to initialize the
- // envelope counter to anything in particular. The first
- // cycle always seems to come at a random time sooner than
- // expected; as yet, I have been unable to find any
- // pattern. I doubt it will matter though, so we'll go
- // ahead and do the full time for now.
- voice.envcnt = env_rate_init;
- voice.envstate = state_attack;
+ // Pitch is never added during KON
+ pitch = 0;
}
- if ( g.key_ons & vbit & ~g.key_offs )
+ int env = v->env;
+
+ // Gaussian interpolation
{
- // voice doesn't come on if key off is set
- g.key_ons &= ~vbit;
- voice.on_cnt = 8;
+ int output = 0;
+ VREG(v_regs,envx) = (uint8_t) (env >> 4);
+ if ( env )
+ {
+ // Make pointers into gaussian based on fractional position between samples
+ int offset = (unsigned) v->interp_pos >> 3 & 0x1FE;
+ short const* fwd = interleved_gauss + offset;
+ short const* rev = interleved_gauss + 510 - offset; // mirror left half of gaussian
+
+ int const* in = &v->buf_pos [(unsigned) v->interp_pos >> 12];
+
+ if ( !(slow_gaussian & vbit) ) // 99%
+ {
+ // Faster approximation when exact sample value isn't necessary for pitch mod
+ output = (fwd [0] * in [0] +
+ fwd [1] * in [1] +
+ rev [1] * in [2] +
+ rev [0] * in [3]) >> 11;
+ output = (output * env) >> 11;
+ }
+ else
+ {
+ output = (int16_t) (m.noise * 2);
+ if ( !(REG(non) & vbit) )
+ {
+ output = (fwd [0] * in [0]) >> 11;
+ output += (fwd [1] * in [1]) >> 11;
+ output += (rev [1] * in [2]) >> 11;
+ output = (int16_t) output;
+ output += (rev [0] * in [3]) >> 11;
+
+ CLAMP16( output );
+ output &= ~1;
+ }
+ output = (output * env) >> 11 & ~1;
+ }
+
+ // Output
+ int l = output * v->volume [0];
+ int r = output * v->volume [1];
+
+ main_out_l += l;
+ main_out_r += r;
+
+ if ( REG(eon) & vbit )
+ {
+ echo_out_l += l;
+ echo_out_r += r;
+ }
+ }
+
+ pmon_input = output;
+ VREG(v_regs,outx) = (uint8_t) (output >> 8);
}
- if ( keys & g.key_offs & vbit )
+ // Soft reset or end of sample
+ if ( REG(flg) & 0x80 || (brr_header & 3) == 1 )
{
- // key off
- voice.envstate = state_release;
- voice.on_cnt = 0;
+ v->env_mode = env_release;
+ env = 0;
}
- int envx;
- if ( !(keys & vbit) || (envx = clock_envelope( vidx )) < 0 )
+ if ( m.every_other_sample )
{
- raw_voice.envx = 0;
- raw_voice.outx = 0;
- prev_outx = 0;
- continue;
+ // KOFF
+ if ( m.t_koff & vbit )
+ v->env_mode = env_release;
+
+ // KON
+ if ( m.kon & vbit )
+ {
+ v->kon_delay = 5;
+ v->env_mode = env_attack;
+ REG(endx) &= ~vbit;
+ }
}
- // Decode samples when fraction >= 1.0 (0x1000)
- for ( int n = voice.fraction >> 12; --n >= 0; )
+ // Envelope
+ if ( !v->kon_delay )
{
- if ( !--voice.block_remain )
+ if ( v->env_mode == env_release ) // 97%
{
- if ( voice.block_header & 1 )
+ env -= 0x8;
+ v->env = env;
+ if ( env <= 0 )
{
- g.wave_ended |= vbit;
-
- if ( voice.block_header & 2 )
+ v->env = 0;
+ goto skip_brr; // no BRR decoding for you!
+ }
+ }
+ else // 3%
+ {
+ int rate;
+ int const adsr0 = VREG(v_regs,adsr0);
+ int env_data = VREG(v_regs,adsr1);
+ if ( adsr0 >= 0x80 ) // 97% ADSR
+ {
+ if ( v->env_mode > env_decay ) // 89%
+ {
+ env--;
+ env -= env >> 8;
+ rate = env_data & 0x1F;
+
+ // optimized handling
+ v->hidden_env = env;
+ if ( READ_COUNTER( rate ) )
+ goto exit_env;
+ v->env = env;
+ goto exit_env;
+ }
+ else if ( v->env_mode == env_decay )
+ {
+ env--;
+ env -= env >> 8;
+ rate = (adsr0 >> 3 & 0x0E) + 0x10;
+ }
+ else // env_attack
+ {
+ rate = (adsr0 & 0x0F) * 2 + 1;
+ env += rate < 31 ? 0x20 : 0x400;
+ }
+ }
+ else // GAIN
+ {
+ int mode;
+ env_data = VREG(v_regs,gain);
+ mode = env_data >> 5;
+ if ( mode < 4 ) // direct
{
- // verified (played endless looping sample and ENDX was set)
- voice.addr = GET_LE16( sd [raw_voice.waveform].loop );
+ env = env_data * 0x10;
+ rate = 31;
}
else
{
- // first block was end block; don't play anything (verified)
- goto sample_ended; // to do: find alternative to goto
+ rate = env_data & 0x1F;
+ if ( mode == 4 ) // 4: linear decrease
+ {
+ env -= 0x20;
+ }
+ else if ( mode < 6 ) // 5: exponential decrease
+ {
+ env--;
+ env -= env >> 8;
+ }
+ else // 6,7: linear increase
+ {
+ env += 0x20;
+ if ( mode > 6 && (unsigned) v->hidden_env >= 0x600 )
+ env += 0x8 - 0x20; // 7: two-slope linear increase
+ }
}
}
- voice.block_header = ram [voice.addr++];
- voice.block_remain = 16; // nybbles
- }
-
- // if next block has end flag set, *this* block ends *early* (verified)
- if ( voice.block_remain == 9 && (ram [voice.addr + 5] & 3) == 1 &&
- (voice.block_header & 3) != 3 )
- {
- sample_ended:
- g.wave_ended |= vbit;
- keys &= ~vbit;
- raw_voice.envx = 0;
- voice.envx = 0;
- // add silence samples to interpolation buffer
- do
+ // Sustain level
+ if ( (env >> 8) == (env_data >> 5) && v->env_mode == env_decay )
+ v->env_mode = env_sustain;
+
+ v->hidden_env = env;
+
+ // unsigned cast because linear decrease going negative also triggers this
+ if ( (unsigned) env > 0x7FF )
{
- voice.interp3 = voice.interp2;
- voice.interp2 = voice.interp1;
- voice.interp1 = voice.interp0;
- voice.interp0 = 0;
+ env = (env < 0 ? 0 : 0x7FF);
+ if ( v->env_mode == env_attack )
+ v->env_mode = env_decay;
}
- while ( --n >= 0 );
- break;
- }
-
- int delta = ram [voice.addr];
- if ( voice.block_remain & 1 )
- {
- delta <<= 4; // use lower nybble
- voice.addr++;
+
+ if ( !READ_COUNTER( rate ) )
+ v->env = env; // nothing else is controlled by the counter
}
+ }
+ exit_env:
+
+ {
+ // Apply pitch
+ int old_pos = v->interp_pos;
+ int interp_pos = (old_pos & 0x3FFF) + pitch;
+ if ( interp_pos > 0x7FFF )
+ interp_pos = 0x7FFF;
+ v->interp_pos = interp_pos;
- // Use sign-extended upper nybble
- delta = int8_t (delta) >> 4;
-
- // For invalid ranges (D,E,F): if the nybble is negative,
- // the result is F000. If positive, 0000. Nothing else
- // like previous range, etc seems to have any effect. If
- // range is valid, do the shift normally. Note these are
- // both shifted right once to do the filters properly, but
- // the output will be shifted back again at the end.
- int shift = voice.block_header >> 4;
- delta = (delta << shift) >> 1;
- if ( shift > 0x0C )
- delta = (delta >> 14) & ~0x7FF;
-
- // One, two and three point IIR filters
- int smp1 = voice.interp0;
- int smp2 = voice.interp1;
- if ( voice.block_header & 8 )
+ // BRR decode if necessary
+ if ( old_pos >= 0x4000 )
{
- delta += smp1;
- delta -= smp2 >> 1;
- if ( !(voice.block_header & 4) )
+ // Arrange the four input nybbles in 0xABCD order for easy decoding
+ int nybbles = ram [(v->brr_addr + v->brr_offset) & 0xFFFF] * 0x100 +
+ ram [(v->brr_addr + v->brr_offset + 1) & 0xFFFF];
+
+ // Advance read position
+ int const brr_block_size = 9;
+ int brr_offset = v->brr_offset;
+ if ( (brr_offset += 2) >= brr_block_size )
{
- delta += (-smp1 - (smp1 >> 1)) >> 5;
- delta += smp2 >> 5;
+ // Next BRR block
+ int brr_addr = (v->brr_addr + brr_block_size) & 0xFFFF;
+ assert( brr_offset == brr_block_size );
+ if ( brr_header & 1 )
+ {
+ brr_addr = SAMPLE_PTR( 1 );
+ if ( !v->kon_delay )
+ REG(endx) |= vbit;
+ }
+ v->brr_addr = brr_addr;
+ brr_offset = 1;
}
- else
+ v->brr_offset = brr_offset;
+
+ // Decode
+
+ // 0: >>1 1: <<0 2: <<1 ... 12: <<11 13-15: >>4 <<11
+ static unsigned char const shifts [16 * 2] = {
+ 13,12,12,12,12,12,12,12,12,12,12, 12, 12, 16, 16, 16,
+ 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 11, 11
+ };
+ int const scale = brr_header >> 4;
+ int const right_shift = shifts [scale];
+ int const left_shift = shifts [scale + 16];
+
+ // Write to next four samples in circular buffer
+ int* pos = v->buf_pos;
+ int* end;
+
+ // Decode four samples
+ for ( end = pos + 4; pos < end; pos++, nybbles <<= 4 )
{
- delta += (-smp1 * 13) >> 7;
- delta += (smp2 + (smp2 >> 1)) >> 4;
+ // Extract upper nybble and scale appropriately. Every cast is
+ // necessary to maintain correctness and avoid undef behavior
+ int s = int16_t(uint16_t((int16_t) nybbles >> right_shift) << left_shift);
+
+ // Apply IIR filter (8 is the most commonly used)
+ int const filter = brr_header & 0x0C;
+ int const p1 = pos [brr_buf_size - 1];
+ int const p2 = pos [brr_buf_size - 2] >> 1;
+ if ( filter >= 8 )
+ {
+ s += p1;
+ s -= p2;
+ if ( filter == 8 ) // s += p1 * 0.953125 - p2 * 0.46875
+ {
+ s += p2 >> 4;
+ s += (p1 * -3) >> 6;
+ }
+ else // s += p1 * 0.8984375 - p2 * 0.40625
+ {
+ s += (p1 * -13) >> 7;
+ s += (p2 * 3) >> 4;
+ }
+ }
+ else if ( filter ) // s += p1 * 0.46875
+ {
+ s += p1 >> 1;
+ s += (-p1) >> 5;
+ }
+
+ // Adjust and write sample
+ CLAMP16( s );
+ s = (int16_t) (s * 2);
+ pos [brr_buf_size] = pos [0] = s; // second copy simplifies wrap-around
}
+
+ if ( pos >= &v->buf [brr_buf_size] )
+ pos = v->buf;
+ v->buf_pos = pos;
}
- else if ( voice.block_header & 4 )
- {
- delta += smp1 >> 1;
- delta += (-smp1) >> 5;
- }
-
- voice.interp3 = voice.interp2;
- voice.interp2 = smp2;
- voice.interp1 = smp1;
- voice.interp0 = BOOST::int16_t (clamp_16( delta ) * 2); // sign-extend
}
-
- // rate (with possible modulation)
- int rate = GET_LE16( raw_voice.rate ) & 0x3FFF;
- if ( g.pitch_mods & vbit )
- rate = (rate * (prev_outx + 32768)) >> 15;
-
- // Gaussian interpolation using most recent 4 samples
- int index = voice.fraction >> 2 & 0x3FC;
- voice.fraction = (voice.fraction & 0x0FFF) + rate;
- const BOOST::int16_t* table = (BOOST::int16_t const*) ((char const*) gauss + index);
- const BOOST::int16_t* table2 = (BOOST::int16_t const*) ((char const*) gauss + (255*4 - index));
- int s = ((table [0] * voice.interp3) >> 12) +
- ((table [1] * voice.interp2) >> 12) +
- ((table2 [1] * voice.interp1) >> 12);
- s = (BOOST::int16_t) (s * 2);
- s += (table2 [0] * voice.interp0) >> 11 & ~1;
- int output = clamp_16( s );
- if ( g.noise_enables & vbit )
- output = noise_amp;
-
- // scale output and set outx values
- output = (output * envx) >> 11 & ~1;
-
- // output and apply muting (by setting voice.enabled to 31)
- // if voice is externally disabled (not a SNES feature)
- int l = (voice.volume [0] * output) >> voice.enabled;
- int r = (voice.volume [1] * output) >> voice.enabled;
- prev_outx = output;
- raw_voice.outx = int8_t (output >> 8);
- if ( g.echo_ons & vbit )
- {
- echol += l;
- echor += r;
- }
- left += l;
- right += r;
+skip_brr:
+ // Next voice
+ vbit <<= 1;
+ v_regs += 0x10;
+ v++;
}
- // end of channel loop
-
- // main volume control
- left = (left * left_volume ) >> (7 + emu_gain_bits);
- right = (right * right_volume) >> (7 + emu_gain_bits);
+ while ( vbit < 0x100 );
- // Echo FIR filter
-
- // read feedback from echo buffer
- int echo_ptr = this->echo_ptr;
- uint8_t* echo_buf = &ram [(g.echo_page * 0x100 + echo_ptr) & 0xFFFF];
- echo_ptr += 4;
- if ( echo_ptr >= (g.echo_delay & 15) * 0x800 )
- echo_ptr = 0;
- int fb_left = (BOOST::int16_t) GET_LE16( echo_buf ); // sign-extend
- int fb_right = (BOOST::int16_t) GET_LE16( echo_buf + 2 ); // sign-extend
- this->echo_ptr = echo_ptr;
-
- // put samples in history ring buffer
- const int fir_offset = this->fir_offset;
- short (*fir_pos) [2] = &fir_buf [fir_offset];
- this->fir_offset = (fir_offset + 7) & 7; // move backwards one step
- fir_pos [0] [0] = (short) fb_left;
- fir_pos [0] [1] = (short) fb_right;
- fir_pos [8] [0] = (short) fb_left; // duplicate at +8 eliminates wrap checking below
- fir_pos [8] [1] = (short) fb_right;
+ // Echo position
+ int echo_offset = m.echo_offset;
+ uint8_t* const echo_ptr = &ram [(REG(esa) * 0x100 + echo_offset) & 0xFFFF];
+ if ( !echo_offset )
+ m.echo_length = (REG(edl) & 0x0F) * 0x800;
+ echo_offset += 4;
+ if ( echo_offset >= m.echo_length )
+ echo_offset = 0;
+ m.echo_offset = echo_offset;
// FIR
- fb_left = fb_left * fir_coeff [7] +
- fir_pos [1] [0] * fir_coeff [6] +
- fir_pos [2] [0] * fir_coeff [5] +
- fir_pos [3] [0] * fir_coeff [4] +
- fir_pos [4] [0] * fir_coeff [3] +
- fir_pos [5] [0] * fir_coeff [2] +
- fir_pos [6] [0] * fir_coeff [1] +
- fir_pos [7] [0] * fir_coeff [0];
+ int echo_in_l = GET_LE16SA( echo_ptr + 0 );
+ int echo_in_r = GET_LE16SA( echo_ptr + 2 );
- fb_right = fb_right * fir_coeff [7] +
- fir_pos [1] [1] * fir_coeff [6] +
- fir_pos [2] [1] * fir_coeff [5] +
- fir_pos [3] [1] * fir_coeff [4] +
- fir_pos [4] [1] * fir_coeff [3] +
- fir_pos [5] [1] * fir_coeff [2] +
- fir_pos [6] [1] * fir_coeff [1] +
- fir_pos [7] [1] * fir_coeff [0];
+ int (*echo_hist_pos) [2] = m.echo_hist_pos;
+ if ( ++echo_hist_pos >= &m.echo_hist [echo_hist_size] )
+ echo_hist_pos = m.echo_hist;
+ m.echo_hist_pos = echo_hist_pos;
- left += (fb_left * g.left_echo_volume ) >> 14;
- right += (fb_right * g.right_echo_volume) >> 14;
+ echo_hist_pos [0] [0] = echo_hist_pos [8] [0] = echo_in_l;
+ echo_hist_pos [0] [1] = echo_hist_pos [8] [1] = echo_in_r;
- // echo buffer feedback
- if ( !(g.flags & 0x20) )
- {
- echol += (fb_left * g.echo_feedback) >> 14;
- echor += (fb_right * g.echo_feedback) >> 14;
- SET_LE16( echo_buf , clamp_16( echol ) );
- SET_LE16( echo_buf + 2, clamp_16( echor ) );
- }
+ #define CALC_FIR_( i, in ) ((in) * (int8_t) REG(fir + i * 0x10))
+ echo_in_l = CALC_FIR_( 7, echo_in_l );
+ echo_in_r = CALC_FIR_( 7, echo_in_r );
- if ( out_buf )
+ #define CALC_FIR( i, ch ) CALC_FIR_( i, echo_hist_pos [i + 1] [ch] )
+ #define DO_FIR( i )\
+ echo_in_l += CALC_FIR( i, 0 );\
+ echo_in_r += CALC_FIR( i, 1 );
+ DO_FIR( 0 );
+ DO_FIR( 1 );
+ DO_FIR( 2 );
+ #if defined (__MWERKS__) && __MWERKS__ < 0x3200
+ __eieio(); // keeps compiler from stupidly "caching" things in memory
+ #endif
+ DO_FIR( 3 );
+ DO_FIR( 4 );
+ DO_FIR( 5 );
+ DO_FIR( 6 );
+
+ // Echo out
+ if ( !(REG(flg) & 0x20) )
{
- // write final samples
-
- left = clamp_16( left );
- right = clamp_16( right );
+ int l = (echo_out_l >> 7) + ((echo_in_l * (int8_t) REG(efb)) >> 14);
+ int r = (echo_out_r >> 7) + ((echo_in_r * (int8_t) REG(efb)) >> 14);
- int mute = g.flags & 0x40;
+ // just to help pass more validation tests
+ #if SPC_MORE_ACCURACY
+ l &= ~1;
+ r &= ~1;
+ #endif
- out_buf [0] = (short) left;
- out_buf [1] = (short) right;
- out_buf += 2;
+ CLAMP16( l );
+ CLAMP16( r );
- // muting
- if ( mute )
- {
- out_buf [-2] = 0;
- out_buf [-1] = 0;
- }
+ SET_LE16A( echo_ptr + 0, l );
+ SET_LE16A( echo_ptr + 2, r );
}
+
+ // Sound out
+ int l = (main_out_l * mvoll + echo_in_l * (int8_t) REG(evoll)) >> 14;
+ int r = (main_out_r * mvolr + echo_in_r * (int8_t) REG(evolr)) >> 14;
+
+ CLAMP16( l );
+ CLAMP16( r );
+
+ if ( (REG(flg) & 0x40) )
+ {
+ l = 0;
+ r = 0;
+ }
+
+ sample_t* out = m.out;
+ WRITE_SAMPLES( l, r, out );
+ m.out = out;
}
+ while ( --count );
}
-// Base normal_gauss table is almost exactly (with an error of 0 or -1 for each entry):
-// int normal_gauss [512];
-// normal_gauss [i] = exp((i-511)*(i-511)*-9.975e-6)*pow(sin(0.00307096*i),1.7358)*1304.45
-// Interleved gauss table (to improve cache coherency).
-// gauss [i * 2 + j] = normal_gauss [(1 - j) * 256 + i]
-const BOOST::int16_t Spc_Dsp::gauss [512] =
+//// Setup
+
+void Spc_Dsp::mute_voices( int mask )
{
- 370,1305, 366,1305, 362,1304, 358,1304, 354,1304, 351,1304, 347,1304, 343,1303,
- 339,1303, 336,1303, 332,1302, 328,1302, 325,1301, 321,1300, 318,1300, 314,1299,
- 311,1298, 307,1297, 304,1297, 300,1296, 297,1295, 293,1294, 290,1293, 286,1292,
- 283,1291, 280,1290, 276,1288, 273,1287, 270,1286, 267,1284, 263,1283, 260,1282,
- 257,1280, 254,1279, 251,1277, 248,1275, 245,1274, 242,1272, 239,1270, 236,1269,
- 233,1267, 230,1265, 227,1263, 224,1261, 221,1259, 218,1257, 215,1255, 212,1253,
- 210,1251, 207,1248, 204,1246, 201,1244, 199,1241, 196,1239, 193,1237, 191,1234,
- 188,1232, 186,1229, 183,1227, 180,1224, 178,1221, 175,1219, 173,1216, 171,1213,
- 168,1210, 166,1207, 163,1205, 161,1202, 159,1199, 156,1196, 154,1193, 152,1190,
- 150,1186, 147,1183, 145,1180, 143,1177, 141,1174, 139,1170, 137,1167, 134,1164,
- 132,1160, 130,1157, 128,1153, 126,1150, 124,1146, 122,1143, 120,1139, 118,1136,
- 117,1132, 115,1128, 113,1125, 111,1121, 109,1117, 107,1113, 106,1109, 104,1106,
- 102,1102, 100,1098, 99,1094, 97,1090, 95,1086, 94,1082, 92,1078, 90,1074,
- 89,1070, 87,1066, 86,1061, 84,1057, 83,1053, 81,1049, 80,1045, 78,1040,
- 77,1036, 76,1032, 74,1027, 73,1023, 71,1019, 70,1014, 69,1010, 67,1005,
- 66,1001, 65, 997, 64, 992, 62, 988, 61, 983, 60, 978, 59, 974, 58, 969,
- 56, 965, 55, 960, 54, 955, 53, 951, 52, 946, 51, 941, 50, 937, 49, 932,
- 48, 927, 47, 923, 46, 918, 45, 913, 44, 908, 43, 904, 42, 899, 41, 894,
- 40, 889, 39, 884, 38, 880, 37, 875, 36, 870, 36, 865, 35, 860, 34, 855,
- 33, 851, 32, 846, 32, 841, 31, 836, 30, 831, 29, 826, 29, 821, 28, 816,
- 27, 811, 27, 806, 26, 802, 25, 797, 24, 792, 24, 787, 23, 782, 23, 777,
- 22, 772, 21, 767, 21, 762, 20, 757, 20, 752, 19, 747, 19, 742, 18, 737,
- 17, 732, 17, 728, 16, 723, 16, 718, 15, 713, 15, 708, 15, 703, 14, 698,
- 14, 693, 13, 688, 13, 683, 12, 678, 12, 674, 11, 669, 11, 664, 11, 659,
- 10, 654, 10, 649, 10, 644, 9, 640, 9, 635, 9, 630, 8, 625, 8, 620,
- 8, 615, 7, 611, 7, 606, 7, 601, 6, 596, 6, 592, 6, 587, 6, 582,
- 5, 577, 5, 573, 5, 568, 5, 563, 4, 559, 4, 554, 4, 550, 4, 545,
- 4, 540, 3, 536, 3, 531, 3, 527, 3, 522, 3, 517, 2, 513, 2, 508,
- 2, 504, 2, 499, 2, 495, 2, 491, 2, 486, 1, 482, 1, 477, 1, 473,
- 1, 469, 1, 464, 1, 460, 1, 456, 1, 451, 1, 447, 1, 443, 1, 439,
- 0, 434, 0, 430, 0, 426, 0, 422, 0, 418, 0, 414, 0, 410, 0, 405,
- 0, 401, 0, 397, 0, 393, 0, 389, 0, 385, 0, 381, 0, 378, 0, 374,
-};
+ m.mute_mask = mask;
+ for ( int i = 0; i < voice_count; i++ )
+ {
+ m.voices [i].enabled = (mask >> i & 1) - 1;
+ update_voice_vol( i * 0x10 );
+ }
+}
+
+void Spc_Dsp::init( void* ram_64k )
+{
+ m.ram = (uint8_t*) ram_64k;
+ mute_voices( 0 );
+ disable_surround( false );
+ set_output( 0, 0 );
+ reset();
+
+ #ifndef NDEBUG
+ // be sure this sign-extends
+ assert( (int16_t) 0x8000 == -0x8000 );
+
+ // be sure right shift preserves sign
+ assert( (-1 >> 1) == -1 );
+
+ // check clamp macro
+ int i;
+ i = +0x8000; CLAMP16( i ); assert( i == +0x7FFF );
+ i = -0x8001; CLAMP16( i ); assert( i == -0x8000 );
+
+ blargg_verify_byte_order();
+ #endif
+}
+
+void Spc_Dsp::soft_reset_common()
+{
+ require( m.ram ); // init() must have been called already
+
+ m.noise = 0x4000;
+ m.echo_hist_pos = m.echo_hist;
+ m.every_other_sample = 1;
+ m.echo_offset = 0;
+ m.phase = 0;
+
+ init_counter();
+}
+
+void Spc_Dsp::soft_reset()
+{
+ REG(flg) = 0xE0;
+ soft_reset_common();
+}
+
+void Spc_Dsp::load( uint8_t const regs [register_count] )
+{
+ memcpy( m.regs, regs, sizeof m.regs );
+ memset( &m.regs [register_count], 0, offsetof (state_t,ram) - register_count );
+
+ // Internal state
+ int i;
+ for ( i = voice_count; --i >= 0; )
+ {
+ voice_t& v = m.voices [i];
+ v.brr_offset = 1;
+ v.buf_pos = v.buf;
+ }
+ m.new_kon = REG(kon);
+
+ mute_voices( m.mute_mask );
+ soft_reset_common();
+}
+
+void Spc_Dsp::reset() { load( initial_regs ); }
diff --git a/src/libs/gme/Spc_Dsp.h b/src/libs/gme/Spc_Dsp.h
index 1e79870a..b364f084 100644
--- a/src/libs/gme/Spc_Dsp.h
+++ b/src/libs/gme/Spc_Dsp.h
@@ -1,152 +1,207 @@
-// Super Nintendo (SNES) SPC DSP emulator
+// Fast SNES SPC-700 DSP emulator (about 3x speed of accurate one)
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SPC_DSP_H
#define SPC_DSP_H
#include "blargg_common.h"
-class Spc_Dsp {
- typedef BOOST::int8_t int8_t;
- typedef BOOST::uint8_t uint8_t;
+struct Spc_Dsp {
public:
+// Setup
- // Keeps pointer to 64K ram
- Spc_Dsp( uint8_t* ram );
-
- // Mute voice n if bit n (1 << n) of mask is clear.
- enum { voice_count = 8 };
- void mute_voices( int mask );
+ // Initializes DSP and has it use the 64K RAM provided
+ void init( void* ram_64k );
+
+ // Sets destination for output samples. If out is NULL or out_size is 0,
+ // doesn't generate any.
+ typedef short sample_t;
+ void set_output( sample_t* out, int out_size );
+
+ // Number of samples written to output since it was last set, always
+ // a multiple of 2. Undefined if more samples were generated than
+ // output buffer could hold.
+ int sample_count() const;
+
+// Emulation
- // Clear state and silence everything.
+ // Resets DSP to power-on state
void reset();
+
+ // Emulates pressing reset switch on SNES
+ void soft_reset();
- // Set gain, where 1.0 is normal. When greater than 1.0, output is clamped to
- // the 16-bit sample range.
- void set_gain( double );
-
- // If true, prevent channels and global volumes from being phase-negated
- void disable_surround( bool disable );
+ // Reads/writes DSP registers. For accuracy, you must first call spc_run_dsp()
+ // to catch the DSP up to present.
+ int read ( int addr ) const;
+ void write( int addr, int data );
+
+ // Runs DSP for specified number of clocks (~1024000 per second). Every 32 clocks
+ // a pair of samples is be generated.
+ void run( int clock_count );
+
+// Sound control
+
+ // Mutes voices corresponding to non-zero bits in mask (overrides VxVOL with 0).
+ // Reduces emulation accuracy.
+ enum { voice_count = 8 };
+ void mute_voices( int mask );
+
+ // If true, prevents channels and global volumes from being phase-negated
+ void disable_surround( bool disable = true );
+
+// State
- // Read/write register 'n', where n ranges from 0 to register_count - 1.
+ // Resets DSP and uses supplied values to initialize registers
enum { register_count = 128 };
- int read ( int n );
- void write( int n, int );
-
- // Run DSP for 'count' samples. Write resulting samples to 'buf' if not NULL.
- void run( long count, short* buf = NULL );
-
-
-// End of public interface
-private:
-
- struct raw_voice_t {
- int8_t left_vol;
- int8_t right_vol;
- uint8_t rate [2];
- uint8_t waveform;
- uint8_t adsr [2]; // envelope rates for attack, decay, and sustain
- uint8_t gain; // envelope gain (if not using ADSR)
- int8_t envx; // current envelope level
- int8_t outx; // current sample
- int8_t unused [6];
- };
-
- struct globals_t {
- int8_t unused1 [12];
- int8_t left_volume; // 0C Main Volume Left (-.7)
- int8_t echo_feedback; // 0D Echo Feedback (-.7)
- int8_t unused2 [14];
- int8_t right_volume; // 1C Main Volume Right (-.7)
- int8_t unused3 [15];
- int8_t left_echo_volume; // 2C Echo Volume Left (-.7)
- uint8_t pitch_mods; // 2D Pitch Modulation on/off for each voice
- int8_t unused4 [14];
- int8_t right_echo_volume; // 3C Echo Volume Right (-.7)
- uint8_t noise_enables; // 3D Noise output on/off for each voice
- int8_t unused5 [14];
- uint8_t key_ons; // 4C Key On for each voice
- uint8_t echo_ons; // 4D Echo on/off for each voice
- int8_t unused6 [14];
- uint8_t key_offs; // 5C key off for each voice (instantiates release mode)
- uint8_t wave_page; // 5D source directory (wave table offsets)
- int8_t unused7 [14];
- uint8_t flags; // 6C flags and noise freq
- uint8_t echo_page; // 6D
- int8_t unused8 [14];
- uint8_t wave_ended; // 7C
- uint8_t echo_delay; // 7D ms >> 4
- char unused9 [2];
+ void load( uint8_t const regs [register_count] );
+
+// DSP register addresses
+
+ // Global registers
+ enum {
+ r_mvoll = 0x0C, r_mvolr = 0x1C,
+ r_evoll = 0x2C, r_evolr = 0x3C,
+ r_kon = 0x4C, r_koff = 0x5C,
+ r_flg = 0x6C, r_endx = 0x7C,
+ r_efb = 0x0D, r_pmon = 0x2D,
+ r_non = 0x3D, r_eon = 0x4D,
+ r_dir = 0x5D, r_esa = 0x6D,
+ r_edl = 0x7D,
+ r_fir = 0x0F // 8 coefficients at 0x0F, 0x1F ... 0x7F
};
-
- union {
- raw_voice_t voice [voice_count];
- uint8_t reg [register_count];
- globals_t g;
+
+ // Voice registers
+ enum {
+ v_voll = 0x00, v_volr = 0x01,
+ v_pitchl = 0x02, v_pitchh = 0x03,
+ v_srcn = 0x04, v_adsr0 = 0x05,
+ v_adsr1 = 0x06, v_gain = 0x07,
+ v_envx = 0x08, v_outx = 0x09
};
-
- uint8_t* const ram;
-
- // Cache of echo FIR values for faster access
- short fir_coeff [voice_count];
-
- // fir_buf [i + 8] == fir_buf [i], to avoid wrap checking in FIR code
- short fir_buf [16] [2];
- int fir_offset; // (0 to 7)
-
- enum { emu_gain_bits = 8 };
- int emu_gain;
-
- int keyed_on; // 8-bits for 8 voices
- int keys;
-
- int echo_ptr;
- int noise_amp;
- int noise;
- int noise_count;
-
- int surround_threshold;
-
- static BOOST::int16_t const gauss [];
-
- enum state_t {
- state_attack,
- state_decay,
- state_sustain,
- state_release
+
+public:
+ enum { extra_size = 16 };
+ sample_t* extra() { return m.extra; }
+ sample_t const* out_pos() const { return m.out; }
+public:
+ BLARGG_DISABLE_NOTHROW
+
+ enum { echo_hist_size = 8 };
+
+ enum env_mode_t { env_release, env_attack, env_decay, env_sustain };
+ enum { brr_buf_size = 12 };
+ struct voice_t
+ {
+ int buf [brr_buf_size*2];// decoded samples (twice the size to simplify wrap handling)
+ int* buf_pos; // place in buffer where next samples will be decoded
+ int interp_pos; // relative fractional position in sample (0x1000 = 1.0)
+ int brr_addr; // address of current BRR block
+ int brr_offset; // current decoding offset in BRR block
+ int kon_delay; // KON delay/current setup phase
+ env_mode_t env_mode;
+ int env; // current envelope level
+ int hidden_env; // used by GAIN mode 7, very obscure quirk
+ int volume [2]; // copy of volume from DSP registers, with surround disabled
+ int enabled; // -1 if enabled, 0 if muted
};
-
- struct voice_t {
- short volume [2];
- short fraction;// 12-bit fractional position
- short interp3; // most recent four decoded samples
- short interp2;
- short interp1;
- short interp0;
- short block_remain; // number of nybbles remaining in current block
- unsigned short addr;
- short block_header; // header byte from current block
- short envcnt;
- short envx;
- short on_cnt;
- short enabled; // 7 if enabled, 31 if disabled
- short envstate;
- short unused; // pad to power of 2
+private:
+ struct state_t
+ {
+ uint8_t regs [register_count];
+
+ // Echo history keeps most recent 8 samples (twice the size to simplify wrap handling)
+ int echo_hist [echo_hist_size * 2] [2];
+ int (*echo_hist_pos) [2]; // &echo_hist [0 to 7]
+
+ int every_other_sample; // toggles every sample
+ int kon; // KON value when last checked
+ int noise;
+ int echo_offset; // offset from ESA in echo buffer
+ int echo_length; // number of bytes that echo_offset will stop at
+ int phase; // next clock cycle to run (0-31)
+ unsigned counters [4];
+
+ int new_kon;
+ int t_koff;
+
+ voice_t voices [voice_count];
+
+ unsigned* counter_select [32];
+
+ // non-emulation state
+ uint8_t* ram; // 64K shared RAM between DSP and SMP
+ int mute_mask;
+ int surround_threshold;
+ sample_t* out;
+ sample_t* out_end;
+ sample_t* out_begin;
+ sample_t extra [extra_size];
};
+ state_t m;
- voice_t voice_state [voice_count];
-
- int clock_envelope( int );
+ void init_counter();
+ void run_counter( int );
+ void soft_reset_common();
+ void write_outline( int addr, int data );
+ void update_voice_vol( int addr );
};
-inline void Spc_Dsp::disable_surround( bool disable ) { surround_threshold = disable ? 0 : -0x7FFF; }
+#include <assert.h>
-inline void Spc_Dsp::set_gain( double v ) { emu_gain = (int) (v * (1 << emu_gain_bits)); }
+inline int Spc_Dsp::sample_count() const { return m.out - m.out_begin; }
-inline int Spc_Dsp::read( int i )
+inline int Spc_Dsp::read( int addr ) const
{
- assert( (unsigned) i < register_count );
- return reg [i];
+ assert( (unsigned) addr < register_count );
+ return m.regs [addr];
}
+inline void Spc_Dsp::update_voice_vol( int addr )
+{
+ int l = (int8_t) m.regs [addr + v_voll];
+ int r = (int8_t) m.regs [addr + v_volr];
+
+ if ( l * r < m.surround_threshold )
+ {
+ // signs differ, so negate those that are negative
+ l ^= l >> 7;
+ r ^= r >> 7;
+ }
+
+ voice_t& v = m.voices [addr >> 4];
+ int enabled = v.enabled;
+ v.volume [0] = l & enabled;
+ v.volume [1] = r & enabled;
+}
+
+inline void Spc_Dsp::write( int addr, int data )
+{
+ assert( (unsigned) addr < register_count );
+
+ m.regs [addr] = (uint8_t) data;
+ int low = addr & 0x0F;
+ if ( low < 0x2 ) // voice volumes
+ {
+ update_voice_vol( low ^ addr );
+ }
+ else if ( low == 0xC )
+ {
+ if ( addr == r_kon )
+ m.new_kon = (uint8_t) data;
+
+ if ( addr == r_endx ) // always cleared, regardless of data written
+ m.regs [r_endx] = 0;
+ }
+}
+
+inline void Spc_Dsp::disable_surround( bool disable )
+{
+ m.surround_threshold = disable ? 0 : -0x4000;
+}
+
+#define SPC_NO_COPY_STATE_FUNCS 1
+
+#define SPC_LESS_ACCURATE 1
+
#endif
diff --git a/src/libs/gme/Spc_Emu.cpp b/src/libs/gme/Spc_Emu.cpp
index a5002bf7..5215e2d1 100644
--- a/src/libs/gme/Spc_Emu.cpp
+++ b/src/libs/gme/Spc_Emu.cpp
@@ -1,328 +1,352 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Spc_Emu.h"
#include "blargg_endian.h"
#include <stdlib.h>
#include <string.h>
/* Copyright (C) 2004-2006 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"
+// TODO: support Spc_Filter's bass
+
Spc_Emu::Spc_Emu()
{
set_type( gme_spc_type );
static const char* const names [Snes_Spc::voice_count] = {
"DSP 1", "DSP 2", "DSP 3", "DSP 4", "DSP 5", "DSP 6", "DSP 7", "DSP 8"
};
set_voice_names( names );
set_gain( 1.4 );
}
Spc_Emu::~Spc_Emu() { }
// Track info
long const trailer_offset = 0x10200;
byte const* Spc_Emu::trailer() const { return &file_data [min( file_size, trailer_offset )]; }
long Spc_Emu::trailer_size() const { return max( 0L, file_size - trailer_offset ); }
static void get_spc_xid6( byte const* begin, long size, track_info_t* out )
{
// header
byte const* end = begin + size;
if ( size < 8 || memcmp( begin, "xid6", 4 ) )
{
check( false );
return;
}
long info_size = get_le32( begin + 4 );
byte const* in = begin + 8;
if ( end - in > info_size )
{
debug_printf( "Extra data after SPC xid6 info\n" );
end = in + info_size;
}
int year = 0;
char copyright [256 + 5];
int copyright_len = 0;
int const year_len = 5;
while ( end - in >= 4 )
{
// header
int id = in [0];
int data = in [3] * 0x100 + in [2];
int type = in [1];
int len = type ? data : 0;
in += 4;
if ( len > end - in )
{
check( false );
break; // block goes past end of data
}
// handle specific block types
char* field = 0;
switch ( id )
{
case 0x01: field = out->song; break;
case 0x02: field = out->game; break;
case 0x03: field = out->author; break;
case 0x04: field = out->dumper; break;
case 0x07: field = out->comment; break;
case 0x14: year = data; break;
//case 0x30: // intro length
// Many SPCs have intro length set wrong for looped tracks, making it useless
/*
case 0x30:
check( len == 4 );
if ( len >= 4 )
{
out->intro_length = get_le32( in ) / 64;
if ( out->length > 0 )
{
long loop = out->length - out->intro_length;
if ( loop >= 2000 )
out->loop_length = loop;
}
}
break;
*/
case 0x13:
copyright_len = min( len, (int) sizeof copyright - year_len );
memcpy( &copyright [year_len], in, copyright_len );
break;
default:
if ( id < 0x01 || (id > 0x07 && id < 0x10) ||
(id > 0x14 && id < 0x30) || id > 0x36 )
debug_printf( "Unknown SPC xid6 block: %X\n", (int) id );
break;
}
if ( field )
{
check( type == 1 );
Gme_File::copy_field_( field, (char const*) in, len );
}
// skip to next block
in += len;
// blocks are supposed to be 4-byte aligned with zero-padding...
byte const* unaligned = in;
while ( (in - begin) & 3 && in < end )
{
if ( *in++ != 0 )
{
// ...but some files have no padding
in = unaligned;
debug_printf( "SPC info tag wasn't properly padded to align\n" );
break;
}
}
}
char* p = &copyright [year_len];
if ( year )
{
*--p = ' ';
for ( int n = 4; n--; )
{
*--p = char (year % 10 + '0');
year /= 10;
}
copyright_len += year_len;
}
if ( copyright_len )
Gme_File::copy_field_( out->copyright, p, copyright_len );
check( in == end );
}
static void get_spc_info( Spc_Emu::header_t const& h, byte const* xid6, long xid6_size,
track_info_t* out )
{
// decode length (can be in text or binary format, sometimes ambiguous ugh)
long len_secs = 0;
for ( int i = 0; i < 3; i++ )
{
unsigned n = h.len_secs [i] - '0';
if ( n > 9 )
{
// ignore single-digit text lengths
// (except if author field is present and begins at offset 1, ugh)
if ( i == 1 && (h.author [0] || !h.author [1]) )
len_secs = 0;
break;
}
len_secs *= 10;
len_secs += n;
}
if ( !len_secs || len_secs > 0x1FFF )
len_secs = get_le16( h.len_secs );
if ( len_secs < 0x1FFF )
out->length = len_secs * 1000;
int offset = (h.author [0] < ' ' || unsigned (h.author [0] - '0') <= 9);
Gme_File::copy_field_( out->author, &h.author [offset], sizeof h.author - offset );
GME_COPY_FIELD( h, out, song );
GME_COPY_FIELD( h, out, game );
GME_COPY_FIELD( h, out, dumper );
GME_COPY_FIELD( h, out, comment );
if ( xid6_size )
get_spc_xid6( xid6, xid6_size, out );
}
blargg_err_t Spc_Emu::track_info_( track_info_t* out, int ) const
{
get_spc_info( header(), trailer(), trailer_size(), out );
return 0;
}
static blargg_err_t check_spc_header( void const* header )
{
if ( memcmp( header, "SNES-SPC700 Sound File Data", 27 ) )
return gme_wrong_file_type;
return 0;
}
struct Spc_File : Gme_Info_
{
Spc_Emu::header_t header;
blargg_vector<byte> xid6;
Spc_File() { set_type( gme_spc_type ); }
blargg_err_t load_( Data_Reader& in )
{
long file_size = in.remain();
- if ( file_size < Snes_Spc::spc_file_size )
+ if ( file_size < Snes_Spc::spc_min_file_size )
return gme_wrong_file_type;
RETURN_ERR( in.read( &header, Spc_Emu::header_size ) );
RETURN_ERR( check_spc_header( header.tag ) );
long const xid6_offset = 0x10200;
long xid6_size = file_size - xid6_offset;
if ( xid6_size > 0 )
{
RETURN_ERR( xid6.resize( xid6_size ) );
RETURN_ERR( in.skip( xid6_offset - Spc_Emu::header_size ) );
RETURN_ERR( in.read( xid6.begin(), xid6.size() ) );
}
return 0;
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
get_spc_info( header, xid6.begin(), xid6.size(), out );
return 0;
}
};
static Music_Emu* new_spc_emu () { return BLARGG_NEW Spc_Emu ; }
static Music_Emu* new_spc_file() { return BLARGG_NEW Spc_File; }
static gme_type_t_ const gme_spc_type_ = { "Super Nintendo", 1, &new_spc_emu, &new_spc_file, "SPC", 0 };
-gme_type_t const gme_spc_type = &gme_spc_type_;
+BLARGG_EXPORT extern gme_type_t const gme_spc_type = &gme_spc_type_;
// Setup
blargg_err_t Spc_Emu::set_sample_rate_( long sample_rate )
{
- apu.set_gain( gain() );
+ RETURN_ERR( apu.init() );
+ enable_accuracy( false );
if ( sample_rate != native_sample_rate )
{
RETURN_ERR( resampler.buffer_size( native_sample_rate / 20 * 2 ) );
resampler.time_ratio( (double) native_sample_rate / sample_rate, 0.9965 );
}
return 0;
}
+void Spc_Emu::enable_accuracy_( bool b )
+{
+ Music_Emu::enable_accuracy_( b );
+ filter.enable( b );
+}
+
void Spc_Emu::mute_voices_( int m )
{
Music_Emu::mute_voices_( m );
apu.mute_voices( m );
}
blargg_err_t Spc_Emu::load_mem_( byte const* in, long size )
{
assert( offsetof (header_t,unused2 [46]) == header_size );
file_data = in;
file_size = size;
set_voice_count( Snes_Spc::voice_count );
- if ( size < Snes_Spc::spc_file_size )
+ if ( size < Snes_Spc::spc_min_file_size )
return gme_wrong_file_type;
return check_spc_header( in );
}
// Emulation
-void Spc_Emu::set_tempo_( double t ) { apu.set_tempo( t ); }
+void Spc_Emu::set_tempo_( double t )
+{
+ apu.set_tempo( (int) (t * apu.tempo_unit) );
+}
blargg_err_t Spc_Emu::start_track_( int track )
{
RETURN_ERR( Music_Emu::start_track_( track ) );
resampler.clear();
+ filter.clear();
RETURN_ERR( apu.load_spc( file_data, file_size ) );
+ filter.set_gain( (int) (gain() * SPC_Filter::gain_unit) );
apu.clear_echo();
return 0;
}
+blargg_err_t Spc_Emu::play_and_filter( long count, sample_t out [] )
+{
+ RETURN_ERR( apu.play( count, out ) );
+ filter.run( out, count );
+ return 0;
+}
+
blargg_err_t Spc_Emu::skip_( long count )
{
if ( sample_rate() != native_sample_rate )
{
count = long (count * resampler.ratio()) & ~1;
count -= resampler.skip_input( count );
}
// TODO: shouldn't skip be adjusted for the 64 samples read afterwards?
if ( count > 0 )
+ {
RETURN_ERR( apu.skip( count ) );
+ filter.clear();
+ }
// eliminate pop due to resampler
const int resampler_latency = 64;
sample_t buf [resampler_latency];
return play_( resampler_latency, buf );
}
blargg_err_t Spc_Emu::play_( long count, sample_t* out )
{
if ( sample_rate() == native_sample_rate )
- return apu.play( count, out );
+ return play_and_filter( count, out );
long remain = count;
while ( remain > 0 )
{
remain -= resampler.read( &out [count - remain], remain );
if ( remain > 0 )
{
long n = resampler.max_write();
- RETURN_ERR( apu.play( n, resampler.buffer() ) );
+ RETURN_ERR( play_and_filter( n, resampler.buffer() ) );
resampler.write( n );
}
}
check( remain == 0 );
return 0;
}
diff --git a/src/libs/gme/Spc_Emu.h b/src/libs/gme/Spc_Emu.h
index 5f998d51..76e1ac63 100644
--- a/src/libs/gme/Spc_Emu.h
+++ b/src/libs/gme/Spc_Emu.h
@@ -1,77 +1,82 @@
// Super Nintendo SPC music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef SPC_EMU_H
#define SPC_EMU_H
#include "Fir_Resampler.h"
#include "Music_Emu.h"
#include "Snes_Spc.h"
+#include "Spc_Filter.h"
class Spc_Emu : public Music_Emu {
public:
// The Super Nintendo hardware samples at 32kHz. Other sample rates are
// handled by resampling the 32kHz output; emulation accuracy is not affected.
enum { native_sample_rate = 32000 };
// SPC file header
enum { header_size = 0x100 };
struct header_t
{
char tag [35];
byte format;
byte version;
byte pc [2];
byte a, x, y, psw, sp;
byte unused [2];
char song [32];
char game [32];
char dumper [16];
char comment [32];
byte date [11];
byte len_secs [3];
byte fade_msec [4];
char author [32]; // sometimes first char should be skipped (see official SPC spec)
byte mute_mask;
byte emulator;
byte unused2 [46];
};
// Header for currently loaded file
header_t const& header() const { return *(header_t const*) file_data; }
// Prevents channels and global volumes from being phase-negated
void disable_surround( bool disable = true );
static gme_type_t static_type() { return gme_spc_type; }
public:
// deprecated
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
byte const* trailer() const; // use track_info()
long trailer_size() const;
public:
Spc_Emu();
~Spc_Emu();
protected:
blargg_err_t load_mem_( byte const*, long );
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t set_sample_rate_( long );
blargg_err_t start_track_( int );
blargg_err_t play_( long, sample_t* );
blargg_err_t skip_( long );
void mute_voices_( int );
void set_tempo_( double );
+ void enable_accuracy_( bool );
private:
byte const* file_data;
long file_size;
Fir_Resampler<24> resampler;
+ SPC_Filter filter;
Snes_Spc apu;
+
+ blargg_err_t play_and_filter( long count, sample_t out [] );
};
inline void Spc_Emu::disable_surround( bool b ) { apu.disable_surround( b ); }
#endif
diff --git a/src/libs/gme/Spc_Filter.cpp b/src/libs/gme/Spc_Filter.cpp
new file mode 100644
index 00000000..2cc77fc9
--- /dev/null
+++ b/src/libs/gme/Spc_Filter.cpp
@@ -0,0 +1,83 @@
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
+
+#include "Spc_Filter.h"
+
+#include <string.h>
+
+/* Copyright (C) 2007 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"
+
+void SPC_Filter::clear() { memset( ch, 0, sizeof ch ); }
+
+SPC_Filter::SPC_Filter()
+{
+ enabled = true;
+ gain = gain_unit;
+ bass = bass_norm;
+ clear();
+}
+
+void SPC_Filter::run( short* io, int count )
+{
+ require( (count & 1) == 0 ); // must be even
+
+ int const gain = this->gain;
+ if ( enabled )
+ {
+ int const bass = this->bass;
+ chan_t* c = &ch [2];
+ do
+ {
+ // cache in registers
+ int sum = (--c)->sum;
+ int pp1 = c->pp1;
+ int p1 = c->p1;
+
+ for ( int i = 0; i < count; i += 2 )
+ {
+ // Low-pass filter (two point FIR with coeffs 0.25, 0.75)
+ int f = io [i] + p1;
+ p1 = io [i] * 3;
+
+ // High-pass filter ("leaky integrator")
+ int delta = f - pp1;
+ pp1 = f;
+ int s = sum >> (gain_bits + 2);
+ sum += (delta * gain) - (sum >> bass);
+
+ // Clamp to 16 bits
+ if ( (short) s != s )
+ s = (s >> 31) ^ 0x7FFF;
+
+ io [i] = (short) s;
+ }
+
+ c->p1 = p1;
+ c->pp1 = pp1;
+ c->sum = sum;
+ ++io;
+ }
+ while ( c != ch );
+ }
+ else if ( gain != gain_unit )
+ {
+ short* const end = io + count;
+ while ( io < end )
+ {
+ int s = (*io * gain) >> gain_bits;
+ if ( (short) s != s )
+ s = (s >> 31) ^ 0x7FFF;
+ *io++ = (short) s;
+ }
+ }
+}
diff --git a/src/libs/gme/Spc_Filter.h b/src/libs/gme/Spc_Filter.h
new file mode 100644
index 00000000..d9994af5
--- /dev/null
+++ b/src/libs/gme/Spc_Filter.h
@@ -0,0 +1,53 @@
+// Simple low-pass and high-pass filter to better match sound output of a SNES
+
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
+#ifndef SPC_FILTER_H
+#define SPC_FILTER_H
+
+#include "blargg_common.h"
+
+struct SPC_Filter {
+public:
+
+ // Filters count samples of stereo sound in place. Count must be a multiple of 2.
+ typedef short sample_t;
+ void run( sample_t* io, int count );
+
+// Optional features
+
+ // Clears filter to silence
+ void clear();
+
+ // Sets gain (volume), where gain_unit is normal. Gains greater than gain_unit
+ // are fine, since output is clamped to 16-bit sample range.
+ enum { gain_unit = 0x100 };
+ void set_gain( int gain );
+
+ // Enables/disables filtering (when disabled, gain is still applied)
+ void enable( bool b );
+
+ // Sets amount of bass (logarithmic scale)
+ enum { bass_none = 0 };
+ enum { bass_norm = 8 }; // normal amount
+ enum { bass_max = 31 };
+ void set_bass( int bass );
+
+public:
+ SPC_Filter();
+ BLARGG_DISABLE_NOTHROW
+private:
+ enum { gain_bits = 8 };
+ int gain;
+ int bass;
+ bool enabled;
+ struct chan_t { int p1, pp1, sum; };
+ chan_t ch [2];
+};
+
+inline void SPC_Filter::enable( bool b ) { enabled = b; }
+
+inline void SPC_Filter::set_gain( int g ) { gain = g; }
+
+inline void SPC_Filter::set_bass( int b ) { bass = b; }
+
+#endif
diff --git a/src/libs/gme/Vgm_Emu.cpp b/src/libs/gme/Vgm_Emu.cpp
index 6a7cb98a..8f19b7de 100644
--- a/src/libs/gme/Vgm_Emu.cpp
+++ b/src/libs/gme/Vgm_Emu.cpp
@@ -1,416 +1,434 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Vgm_Emu.h"
#include "blargg_endian.h"
#include <string.h>
#include <math.h>
/* Copyright (C) 2003-2006 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"
double const fm_gain = 3.0; // FM emulators are internally quieter to avoid 16-bit overflow
double const rolloff = 0.990;
double const oversample_factor = 1.5;
Vgm_Emu::Vgm_Emu()
{
disable_oversampling_ = false;
psg_rate = 0;
set_type( gme_vgm_type );
static int const types [8] = {
wave_type | 1, wave_type | 0, wave_type | 2, noise_type | 0
};
set_voice_types( types );
set_silence_lookahead( 1 ); // tracks should already be trimmed
- static equalizer_t const eq = { -14.0, 80 };
- set_equalizer( eq );
+ set_equalizer( make_equalizer( -14.0, 80 ) );
}
Vgm_Emu::~Vgm_Emu() { }
// Track info
static byte const* skip_gd3_str( byte const* in, byte const* end )
{
while ( end - in >= 2 )
{
in += 2;
if ( !(in [-2] | in [-1]) )
break;
}
return in;
}
static byte const* get_gd3_str( byte const* in, byte const* end, char* field )
{
byte const* mid = skip_gd3_str( in, end );
int len = (mid - in) / 2 - 1;
if ( len > 0 )
{
len = min( len, (int) Gme_File::max_field_ );
field [len] = 0;
for ( int i = 0; i < len; i++ )
field [i] = (in [i * 2 + 1] ? '?' : in [i * 2]); // TODO: convert to utf-8
}
return mid;
}
static byte const* get_gd3_pair( byte const* in, byte const* end, char* field )
{
return skip_gd3_str( get_gd3_str( in, end, field ), end );
}
static void parse_gd3( byte const* in, byte const* end, track_info_t* out )
{
in = get_gd3_pair( in, end, out->song );
in = get_gd3_pair( in, end, out->game );
in = get_gd3_pair( in, end, out->system );
in = get_gd3_pair( in, end, out->author );
in = get_gd3_str ( in, end, out->copyright );
in = get_gd3_pair( in, end, out->dumper );
in = get_gd3_str ( in, end, out->comment );
}
int const gd3_header_size = 12;
static long check_gd3_header( byte const* h, long remain )
{
if ( remain < gd3_header_size ) return 0;
if ( memcmp( h, "Gd3 ", 4 ) ) return 0;
if ( get_le32( h + 4 ) >= 0x200 ) return 0;
long gd3_size = get_le32( h + 8 );
if ( gd3_size > remain - gd3_header_size ) return 0;
return gd3_size;
}
byte const* Vgm_Emu::gd3_data( int* size ) const
{
if ( size )
*size = 0;
long gd3_offset = get_le32( header().gd3_offset ) - 0x2C;
if ( gd3_offset < 0 )
return 0;
byte const* gd3 = data + header_size + gd3_offset;
long gd3_size = check_gd3_header( gd3, data_end - gd3 );
if ( !gd3_size )
return 0;
if ( size )
*size = gd3_size + gd3_header_size;
return gd3;
}
static void get_vgm_length( Vgm_Emu::header_t const& h, track_info_t* out )
{
long length = get_le32( h.track_duration ) * 10 / 441;
if ( length > 0 )
{
long loop = get_le32( h.loop_duration );
if ( loop > 0 && get_le32( h.loop_offset ) )
{
out->loop_length = loop * 10 / 441;
out->intro_length = length - out->loop_length;
}
else
{
out->length = length; // 1000 / 44100 (VGM files used 44100 as timebase)
out->intro_length = length; // make it clear that track is no longer than length
out->loop_length = 0;
}
}
}
blargg_err_t Vgm_Emu::track_info_( track_info_t* out, int ) const
{
get_vgm_length( header(), out );
int size;
byte const* gd3 = gd3_data( &size );
if ( gd3 )
parse_gd3( gd3 + gd3_header_size, gd3 + size, out );
return 0;
}
static blargg_err_t check_vgm_header( Vgm_Emu::header_t const& h )
{
if ( memcmp( h.tag, "Vgm ", 4 ) )
return gme_wrong_file_type;
return 0;
}
struct Vgm_File : Gme_Info_
{
Vgm_Emu::header_t h;
blargg_vector<byte> gd3;
Vgm_File() { set_type( gme_vgm_type ); }
blargg_err_t load_( Data_Reader& in )
{
long file_size = in.remain();
if ( file_size <= Vgm_Emu::header_size )
return gme_wrong_file_type;
RETURN_ERR( in.read( &h, Vgm_Emu::header_size ) );
RETURN_ERR( check_vgm_header( h ) );
long gd3_offset = get_le32( h.gd3_offset ) - 0x2C;
long remain = file_size - Vgm_Emu::header_size - gd3_offset;
byte gd3_h [gd3_header_size];
if ( gd3_offset > 0 && remain >= gd3_header_size )
{
RETURN_ERR( in.skip( gd3_offset ) );
RETURN_ERR( in.read( gd3_h, sizeof gd3_h ) );
long gd3_size = check_gd3_header( gd3_h, remain );
if ( gd3_size )
{
RETURN_ERR( gd3.resize( gd3_size ) );
RETURN_ERR( in.read( gd3.begin(), gd3.size() ) );
}
}
return 0;
}
blargg_err_t track_info_( track_info_t* out, int ) const
{
get_vgm_length( h, out );
if ( gd3.size() )
parse_gd3( gd3.begin(), gd3.end(), out );
return 0;
}
};
static Music_Emu* new_vgm_emu () { return BLARGG_NEW Vgm_Emu ; }
static Music_Emu* new_vgm_file() { return BLARGG_NEW Vgm_File; }
static gme_type_t_ const gme_vgm_type_ = { "Sega SMS/Genesis", 1, &new_vgm_emu, &new_vgm_file, "VGM", 1 };
-gme_type_t const gme_vgm_type = &gme_vgm_type_;
+BLARGG_EXPORT extern gme_type_t const gme_vgm_type = &gme_vgm_type_;
static gme_type_t_ const gme_vgz_type_ = { "Sega SMS/Genesis", 1, &new_vgm_emu, &new_vgm_file, "VGZ", 1 };
-gme_type_t const gme_vgz_type = &gme_vgz_type_;
+BLARGG_EXPORT extern gme_type_t const gme_vgz_type = &gme_vgz_type_;
// Setup
void Vgm_Emu::set_tempo_( double t )
{
if ( psg_rate )
{
vgm_rate = (long) (44100 * t + 0.5);
blip_time_factor = (long) floor( double (1L << blip_time_bits) / vgm_rate * psg_rate + 0.5 );
//debug_printf( "blip_time_factor: %ld\n", blip_time_factor );
//debug_printf( "vgm_rate: %ld\n", vgm_rate );
// TODO: remove? calculates vgm_rate more accurately (above differs at most by one Hz only)
//blip_time_factor = (long) floor( double (1L << blip_time_bits) * psg_rate / 44100 / t + 0.5 );
//vgm_rate = (long) floor( double (1L << blip_time_bits) * psg_rate / blip_time_factor + 0.5 );
fm_time_factor = 2 + (long) floor( fm_rate * (1L << fm_time_bits) / vgm_rate + 0.5 );
}
}
blargg_err_t Vgm_Emu::set_sample_rate_( long sample_rate )
{
RETURN_ERR( blip_buf.set_sample_rate( sample_rate, 1000 / 30 ) );
return Classic_Emu::set_sample_rate_( sample_rate );
}
+blargg_err_t Vgm_Emu::set_multi_channel ( bool is_enabled )
+{
+ // we acutally should check here whether this is classic emu or not
+ // however set_multi_channel() is called before setup_fm() resulting in uninited is_classic_emu()
+ // hard code it to unsupported
+#if 0
+ if ( is_classic_emu() )
+ {
+ RETURN_ERR( Music_Emu::set_multi_channel_( is_enabled ) );
+ return 0;
+ }
+ else
+#endif
+ {
+ (void) is_enabled;
+ return "multichannel rendering not supported for YM2*** FM sound chip emulators";
+ }
+}
+
void Vgm_Emu::update_eq( blip_eq_t const& eq )
{
psg.treble_eq( eq );
dac_synth.treble_eq( eq );
}
void Vgm_Emu::set_voice( int i, Blip_Buffer* c, Blip_Buffer* l, Blip_Buffer* r )
{
if ( i < psg.osc_count )
psg.osc_output( i, c, l, r );
}
void Vgm_Emu::mute_voices_( int mask )
{
Classic_Emu::mute_voices_( mask );
dac_synth.output( &blip_buf );
if ( uses_fm )
{
psg.output( (mask & 0x80) ? 0 : &blip_buf );
if ( ym2612.enabled() )
{
dac_synth.volume( (mask & 0x40) ? 0.0 : 0.1115 / 256 * fm_gain * gain() );
ym2612.mute_voices( mask );
}
if ( ym2413.enabled() )
{
int m = mask & 0x3F;
if ( mask & 0x20 )
m |= 0x01E0; // channels 5-8
if ( mask & 0x40 )
m |= 0x3E00;
ym2413.mute_voices( m );
}
}
}
blargg_err_t Vgm_Emu::load_mem_( byte const* new_data, long new_size )
{
assert( offsetof (header_t,unused2 [8]) == header_size );
if ( new_size <= header_size )
return gme_wrong_file_type;
header_t const& h = *(header_t const*) new_data;
RETURN_ERR( check_vgm_header( h ) );
check( get_le32( h.version ) <= 0x150 );
// psg rate
psg_rate = get_le32( h.psg_rate );
if ( !psg_rate )
psg_rate = 3579545;
blip_buf.clock_rate( psg_rate );
data = new_data;
data_end = new_data + new_size;
// get loop
loop_begin = data_end;
if ( get_le32( h.loop_offset ) )
loop_begin = &data [get_le32( h.loop_offset ) + offsetof (header_t,loop_offset)];
set_voice_count( psg.osc_count );
RETURN_ERR( setup_fm() );
static const char* const fm_names [] = {
"FM 1", "FM 2", "FM 3", "FM 4", "FM 5", "FM 6", "PCM", "PSG"
};
static const char* const psg_names [] = { "Square 1", "Square 2", "Square 3", "Noise" };
set_voice_names( uses_fm ? fm_names : psg_names );
// do after FM in case output buffer is changed
return Classic_Emu::setup_buffer( psg_rate );
}
blargg_err_t Vgm_Emu::setup_fm()
{
long ym2612_rate = get_le32( header().ym2612_rate );
long ym2413_rate = get_le32( header().ym2413_rate );
if ( ym2413_rate && get_le32( header().version ) < 0x110 )
update_fm_rates( &ym2413_rate, &ym2612_rate );
uses_fm = false;
fm_rate = blip_buf.sample_rate() * oversample_factor;
if ( ym2612_rate )
{
uses_fm = true;
if ( disable_oversampling_ )
fm_rate = ym2612_rate / 144.0;
Dual_Resampler::setup( fm_rate / blip_buf.sample_rate(), rolloff, fm_gain * gain() );
RETURN_ERR( ym2612.set_rate( fm_rate, ym2612_rate ) );
ym2612.enable( true );
set_voice_count( 8 );
}
if ( !uses_fm && ym2413_rate )
{
uses_fm = true;
if ( disable_oversampling_ )
fm_rate = ym2413_rate / 72.0;
Dual_Resampler::setup( fm_rate / blip_buf.sample_rate(), rolloff, fm_gain * gain() );
int result = ym2413.set_rate( fm_rate, ym2413_rate );
if ( result == 2 )
return "YM2413 FM sound isn't supported";
CHECK_ALLOC( !result );
ym2413.enable( true );
set_voice_count( 8 );
}
if ( uses_fm )
{
RETURN_ERR( Dual_Resampler::reset( blip_buf.length() * blip_buf.sample_rate() / 1000 ) );
psg.volume( 0.135 * fm_gain * gain() );
}
else
{
ym2612.enable( false );
ym2413.enable( false );
psg.volume( gain() );
}
return 0;
}
// Emulation
blargg_err_t Vgm_Emu::start_track_( int track )
{
RETURN_ERR( Classic_Emu::start_track_( track ) );
psg.reset( get_le16( header().noise_feedback ), header().noise_width );
dac_disabled = -1;
pos = data + header_size;
pcm_data = pos;
pcm_pos = pos;
dac_amp = -1;
vgm_time = 0;
if ( get_le32( header().version ) >= 0x150 )
{
long data_offset = get_le32( header().data_offset );
check( data_offset );
if ( data_offset )
pos += data_offset + offsetof (header_t,data_offset) - 0x40;
}
if ( uses_fm )
{
if ( ym2413.enabled() )
ym2413.reset();
if ( ym2612.enabled() )
ym2612.reset();
fm_time_offset = 0;
blip_buf.clear();
Dual_Resampler::clear();
}
return 0;
}
blargg_err_t Vgm_Emu::run_clocks( blip_time_t& time_io, int msec )
{
time_io = run_commands( msec * vgm_rate / 1000 );
psg.end_frame( time_io );
return 0;
}
blargg_err_t Vgm_Emu::play_( long count, sample_t* out )
{
if ( !uses_fm )
return Classic_Emu::play_( count, out );
Dual_Resampler::dual_play( count, out, blip_buf );
return 0;
}
diff --git a/src/libs/gme/Vgm_Emu.h b/src/libs/gme/Vgm_Emu.h
index 6f365992..40cfb710 100644
--- a/src/libs/gme/Vgm_Emu.h
+++ b/src/libs/gme/Vgm_Emu.h
@@ -1,84 +1,86 @@
// Sega Master System/Mark III, Sega Genesis/Mega Drive, BBC Micro VGM music file emulator
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef VGM_EMU_H
#define VGM_EMU_H
#include "Vgm_Emu_Impl.h"
// Emulates VGM music using SN76489/SN76496 PSG, YM2612, and YM2413 FM sound chips.
// Supports custom sound buffer and frequency equalization when VGM uses just the PSG.
// FM sound chips can be run at their proper rates, or slightly higher to reduce
// aliasing on high notes. Currently YM2413 support requires that you supply a
// YM2413 sound chip emulator. I can provide one I've modified to work with the library.
class Vgm_Emu : public Vgm_Emu_Impl {
public:
// True if custom buffer and custom equalization are supported
// TODO: move into Music_Emu and rename to something like supports_custom_buffer()
bool is_classic_emu() const { return !uses_fm; }
+ blargg_err_t set_multi_channel ( bool is_enabled ) override;
+
// Disable running FM chips at higher than normal rate. Will result in slightly
// more aliasing of high notes.
void disable_oversampling( bool disable = true ) { disable_oversampling_ = disable; }
// VGM header format
enum { header_size = 0x40 };
struct header_t
{
char tag [4];
byte data_size [4];
byte version [4];
byte psg_rate [4];
byte ym2413_rate [4];
byte gd3_offset [4];
byte track_duration [4];
byte loop_offset [4];
byte loop_duration [4];
byte frame_rate [4];
byte noise_feedback [2];
byte noise_width;
byte unused1;
byte ym2612_rate [4];
byte ym2151_rate [4];
byte data_offset [4];
byte unused2 [8];
};
// Header for currently loaded file
header_t const& header() const { return *(header_t const*) data; }
static gme_type_t static_type() { return gme_vgm_type; }
public:
// deprecated
using Music_Emu::load;
blargg_err_t load( header_t const& h, Data_Reader& in ) // use Remaining_Reader
{ return load_remaining_( &h, sizeof h, in ); }
byte const* gd3_data( int* size_out = 0 ) const; // use track_info()
public:
Vgm_Emu();
~Vgm_Emu();
protected:
blargg_err_t track_info_( track_info_t*, int track ) const;
blargg_err_t load_mem_( byte const*, long );
blargg_err_t set_sample_rate_( long sample_rate );
blargg_err_t start_track_( int );
blargg_err_t play_( long count, sample_t* );
blargg_err_t run_clocks( blip_time_t&, int );
void set_tempo_( double );
void mute_voices_( int mask );
void set_voice( int, Blip_Buffer*, Blip_Buffer*, Blip_Buffer* );
void update_eq( blip_eq_t const& );
private:
// removed; use disable_oversampling() and set_tempo() instead
Vgm_Emu( bool oversample, double tempo = 1.0 );
double fm_rate;
long psg_rate;
long vgm_rate;
bool disable_oversampling_;
bool uses_fm;
blargg_err_t setup_fm();
};
#endif
diff --git a/src/libs/gme/Vgm_Emu_Impl.cpp b/src/libs/gme/Vgm_Emu_Impl.cpp
index 5a9b724a..0d400254 100644
--- a/src/libs/gme/Vgm_Emu_Impl.cpp
+++ b/src/libs/gme/Vgm_Emu_Impl.cpp
@@ -1,314 +1,314 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Vgm_Emu.h"
#include <math.h>
#include <string.h>
#include "blargg_endian.h"
/* Copyright (C) 2003-2006 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"
enum {
cmd_gg_stereo = 0x4F,
cmd_psg = 0x50,
cmd_ym2413 = 0x51,
cmd_ym2612_port0 = 0x52,
cmd_ym2612_port1 = 0x53,
cmd_ym2151 = 0x54,
cmd_delay = 0x61,
cmd_delay_735 = 0x62,
cmd_delay_882 = 0x63,
cmd_byte_delay = 0x64,
cmd_end = 0x66,
cmd_data_block = 0x67,
cmd_short_delay = 0x70,
cmd_pcm_delay = 0x80,
cmd_pcm_seek = 0xE0,
pcm_block_type = 0x00,
ym2612_dac_port = 0x2A
};
inline int command_len( int command )
{
switch ( command >> 4 )
{
case 0x03:
case 0x04:
return 2;
case 0x05:
case 0x0A:
case 0x0B:
return 3;
case 0x0C:
case 0x0D:
return 4;
case 0x0E:
case 0x0F:
return 5;
}
check( false );
return 1;
}
template<class Emu>
inline void Ym_Emu<Emu>::begin_frame( short* p )
{
require( enabled() );
out = p;
last_time = 0;
}
template<class Emu>
inline int Ym_Emu<Emu>::run_until( int time )
{
int count = time - last_time;
if ( count > 0 )
{
if ( last_time < 0 )
return false;
last_time = time;
short* p = out;
out += count * Emu::out_chan_count;
Emu::run( count, p );
}
return true;
}
inline Vgm_Emu_Impl::fm_time_t Vgm_Emu_Impl::to_fm_time( vgm_time_t t ) const
{
return (t * fm_time_factor + fm_time_offset) >> fm_time_bits;
}
inline blip_time_t Vgm_Emu_Impl::to_blip_time( vgm_time_t t ) const
{
return (t * blip_time_factor) >> blip_time_bits;
}
void Vgm_Emu_Impl::write_pcm( vgm_time_t vgm_time, int amp )
{
blip_time_t blip_time = to_blip_time( vgm_time );
int old = dac_amp;
int delta = amp - old;
dac_amp = amp;
if ( old >= 0 )
dac_synth.offset_inline( blip_time, delta, &blip_buf );
else
dac_amp |= dac_disabled;
}
blip_time_t Vgm_Emu_Impl::run_commands( vgm_time_t end_time )
{
vgm_time_t vgm_time = this->vgm_time;
byte const* pos = this->pos;
if ( pos >= data_end )
{
set_track_ended();
if ( pos > data_end )
set_warning( "Stream lacked end event" );
}
while ( vgm_time < end_time && pos < data_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:
pos = loop_begin; // if not looped, loop_begin == data_end
break;
case cmd_delay_735:
vgm_time += 735;
break;
case cmd_delay_882:
vgm_time += 882;
break;
case cmd_gg_stereo:
psg.write_ggstereo( to_blip_time( vgm_time ), *pos++ );
break;
case cmd_psg:
psg.write_data( to_blip_time( vgm_time ), *pos++ );
break;
case cmd_delay:
vgm_time += pos [1] * 0x100L + pos [0];
pos += 2;
break;
case cmd_byte_delay:
vgm_time += *pos++;
break;
case cmd_ym2413:
if ( ym2413.run_until( to_fm_time( vgm_time ) ) )
ym2413.write( pos [0], pos [1] );
pos += 2;
break;
case cmd_ym2612_port0:
if ( pos [0] == ym2612_dac_port )
{
write_pcm( vgm_time, pos [1] );
}
else if ( ym2612.run_until( to_fm_time( vgm_time ) ) )
{
if ( pos [0] == 0x2B )
{
dac_disabled = (pos [1] >> 7 & 1) - 1;
dac_amp |= dac_disabled;
}
ym2612.write0( pos [0], pos [1] );
}
pos += 2;
break;
case cmd_ym2612_port1:
if ( ym2612.run_until( to_fm_time( vgm_time ) ) )
ym2612.write1( pos [0], pos [1] );
pos += 2;
break;
case cmd_data_block: {
check( *pos == cmd_end );
int type = pos [1];
long size = get_le32( pos + 2 );
pos += 6;
if ( type == pcm_block_type )
pcm_data = pos;
pos += size;
break;
}
case cmd_pcm_seek:
pcm_pos = pcm_data + pos [3] * 0x1000000L + pos [2] * 0x10000L +
pos [1] * 0x100L + pos [0];
pos += 4;
break;
default:
int cmd = pos [-1];
switch ( cmd & 0xF0 )
{
case cmd_pcm_delay:
write_pcm( vgm_time, *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_blip_time( end_time );
}
int Vgm_Emu_Impl::play_frame( blip_time_t blip_time, int sample_count, sample_t* buf )
{
// to do: timing is working mostly by luck
int min_pairs = sample_count >> 1;
int vgm_time = ((long) min_pairs << fm_time_bits) / fm_time_factor - 1;
assert( to_fm_time( vgm_time ) <= min_pairs );
int pairs = min_pairs;
while ( (pairs = to_fm_time( vgm_time )) < min_pairs )
vgm_time++;
//debug_printf( "pairs: %d, min_pairs: %d\n", pairs, min_pairs );
if ( ym2612.enabled() )
{
ym2612.begin_frame( buf );
memset( buf, 0, pairs * stereo * sizeof *buf );
}
else if ( ym2413.enabled() )
{
ym2413.begin_frame( buf );
}
run_commands( vgm_time );
ym2612.run_until( pairs );
ym2413.run_until( pairs );
fm_time_offset = (vgm_time * fm_time_factor + fm_time_offset) -
((long) pairs << fm_time_bits);
psg.end_frame( blip_time );
return pairs * stereo;
}
// Update pre-1.10 header FM rates by scanning commands
void Vgm_Emu_Impl::update_fm_rates( long* ym2413_rate, long* ym2612_rate ) const
{
byte const* p = data + 0x40;
while ( p < data_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_ym2413:
*ym2612_rate = 0;
return;
case cmd_ym2612_port0:
case cmd_ym2612_port1:
*ym2612_rate = *ym2413_rate;
*ym2413_rate = 0;
return;
case cmd_ym2151:
*ym2413_rate = 0;
*ym2612_rate = 0;
return;
default:
p += command_len( *p );
}
}
}
diff --git a/src/libs/gme/Vgm_Emu_Impl.h b/src/libs/gme/Vgm_Emu_Impl.h
index 8a73c328..dadbb920 100644
--- a/src/libs/gme/Vgm_Emu_Impl.h
+++ b/src/libs/gme/Vgm_Emu_Impl.h
@@ -1,71 +1,71 @@
// Low-level parts of Vgm_Emu
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef VGM_EMU_IMPL_H
#define VGM_EMU_IMPL_H
#include "Dual_Resampler.h"
#include "Classic_Emu.h"
#include "Ym2413_Emu.h"
#include "Ym2612_Emu.h"
#include "Sms_Apu.h"
template<class Emu>
class Ym_Emu : public Emu {
protected:
int last_time;
short* out;
enum { disabled_time = -1 };
public:
Ym_Emu() : last_time( disabled_time ), out( NULL ) { }
void enable( bool b ) { last_time = b ? 0 : disabled_time; }
bool enabled() const { return last_time != disabled_time; }
void begin_frame( short* p );
int run_until( int time );
};
class Vgm_Emu_Impl : public Classic_Emu, private Dual_Resampler {
public:
typedef Classic_Emu::sample_t sample_t;
protected:
enum { stereo = 2 };
typedef int vgm_time_t;
enum { fm_time_bits = 12 };
typedef int fm_time_t;
long fm_time_offset;
int fm_time_factor;
fm_time_t to_fm_time( vgm_time_t ) const;
enum { blip_time_bits = 12 };
int blip_time_factor;
blip_time_t to_blip_time( vgm_time_t ) const;
byte const* data;
byte const* loop_begin;
byte const* data_end;
void update_fm_rates( long* ym2413_rate, long* ym2612_rate ) const;
vgm_time_t vgm_time;
byte const* pos;
blip_time_t run_commands( vgm_time_t );
int play_frame( blip_time_t blip_time, int sample_count, sample_t* buf );
byte const* pcm_data;
byte const* pcm_pos;
int dac_amp;
int dac_disabled; // -1 if disabled
void write_pcm( vgm_time_t, int amp );
Ym_Emu<Ym2612_Emu> ym2612;
Ym_Emu<Ym2413_Emu> ym2413;
Blip_Buffer blip_buf;
Sms_Apu psg;
Blip_Synth<blip_med_quality,1> dac_synth;
friend class Vgm_Emu;
};
#endif
diff --git a/src/libs/gme/Ym2413_Emu.cpp b/src/libs/gme/Ym2413_Emu.cpp
index be5b2d8c..01e796d9 100644
--- a/src/libs/gme/Ym2413_Emu.cpp
+++ b/src/libs/gme/Ym2413_Emu.cpp
@@ -1,21 +1,21 @@
// Use in place of Ym2413_Emu.cpp and ym2413.c to disable support for this chip
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Ym2413_Emu.h"
Ym2413_Emu::Ym2413_Emu() { }
Ym2413_Emu::~Ym2413_Emu() { }
int Ym2413_Emu::set_rate( double, double ) { return 2; }
void Ym2413_Emu::reset() { }
void Ym2413_Emu::write( int, int ) { }
void Ym2413_Emu::mute_voices( int ) { }
void Ym2413_Emu::run( int, sample_t* ) { }
diff --git a/src/libs/gme/Ym2413_Emu.h b/src/libs/gme/Ym2413_Emu.h
index 42314435..ed4fd11d 100644
--- a/src/libs/gme/Ym2413_Emu.h
+++ b/src/libs/gme/Ym2413_Emu.h
@@ -1,33 +1,33 @@
// YM2413 FM sound chip emulator interface
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef YM2413_EMU_H
#define YM2413_EMU_H
class Ym2413_Emu {
struct OPLL* opll;
public:
Ym2413_Emu();
~Ym2413_Emu();
// Set output sample rate and chip clock rates, in Hz. Returns non-zero
// if error.
int set_rate( double sample_rate, double clock_rate );
// Reset to power-up state
void reset();
// Mute voice n if bit n (1 << n) of mask is set
enum { channel_count = 14 };
void mute_voices( int mask );
// Write 'data' to 'addr'
void write( int addr, int data );
// Run and write pair_count samples to output
typedef short sample_t;
enum { out_chan_count = 2 }; // stereo
void run( int pair_count, sample_t* out );
};
#endif
diff --git a/src/libs/gme/Ym2612_Emu.cpp b/src/libs/gme/Ym2612_Emu.cpp
index 390fdfce..a9438b3a 100644
--- a/src/libs/gme/Ym2612_Emu.cpp
+++ b/src/libs/gme/Ym2612_Emu.cpp
@@ -1,1319 +1,1319 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
// Based on Gens 2.10 ym2612.c
#include "Ym2612_Emu.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdio.h>
#include <math.h>
/* Copyright (C) 2002 St?phane Dallongeville (gens AT consolemul.com) */
/* Copyright (C) 2004-2006 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 */
// This is mostly the original source in its C style and all.
//
// Somewhat optimized and simplified. Uses a template to generate the many
// variants of Update_Chan. Rewrote header file. In need of full rewrite by
// someone more familiar with FM sound and the YM2612. Has some inaccuracies
// compared to the Sega Genesis sound, particularly being mixed at such a
// high sample accuracy (the Genesis sounds like it has only 8 bit samples).
// - Shay
#ifdef BLARGG_ENABLE_OPTIMIZER
#include BLARGG_ENABLE_OPTIMIZER
#endif
const int output_bits = 14;
struct slot_t
{
const int *DT; // parametre detune
int MUL; // parametre "multiple de frequence"
int TL; // Total Level = volume lorsque l'enveloppe est au plus haut
int TLL; // Total Level ajusted
int SLL; // Sustin Level (ajusted) = volume o? l'enveloppe termine sa premiere phase de regression
int KSR_S; // Key Scale Rate Shift = facteur de prise en compte du KSL dans la variations de l'enveloppe
int KSR; // Key Scale Rate = cette valeur est calculee par rapport ? la frequence actuelle, elle va influer
// sur les differents parametres de l'enveloppe comme l'attaque, le decay ... comme dans la realite !
int SEG; // Type enveloppe SSG
int env_xor;
int env_max;
const int *AR; // Attack Rate (table pointeur) = Taux d'attaque (AR[KSR])
const int *DR; // Decay Rate (table pointeur) = Taux pour la regression (DR[KSR])
const int *SR; // Sustin Rate (table pointeur) = Taux pour le maintien (SR[KSR])
const int *RR; // Release Rate (table pointeur) = Taux pour le rel'chement (RR[KSR])
int Fcnt; // Frequency Count = compteur-frequence pour determiner l'amplitude actuelle (SIN[Finc >> 16])
int Finc; // frequency step = pas d'incrementation du compteur-frequence
// plus le pas est grand, plus la frequence est a?gu (ou haute)
int Ecurp; // Envelope current phase = cette variable permet de savoir dans quelle phase
// de l'enveloppe on se trouve, par exemple phase d'attaque ou phase de maintenue ...
// en fonction de la valeur de cette variable, on va appeler une fonction permettant
// de mettre ? jour l'enveloppe courante.
int Ecnt; // Envelope counter = le compteur-enveloppe permet de savoir o? l'on se trouve dans l'enveloppe
int Einc; // Envelope step courant
int Ecmp; // Envelope counter limite pour la prochaine phase
int EincA; // Envelope step for Attack = pas d'incrementation du compteur durant la phase d'attaque
// cette valeur est egal ? AR[KSR]
int EincD; // Envelope step for Decay = pas d'incrementation du compteur durant la phase de regression
// cette valeur est egal ? DR[KSR]
int EincS; // Envelope step for Sustain = pas d'incrementation du compteur durant la phase de maintenue
// cette valeur est egal ? SR[KSR]
int EincR; // Envelope step for Release = pas d'incrementation du compteur durant la phase de rel'chement
// cette valeur est egal ? RR[KSR]
int *OUTp; // pointeur of SLOT output = pointeur permettant de connecter la sortie de ce slot ? l'entree
// d'un autre ou carrement ? la sortie de la voie
int INd; // input data of the slot = donnees en entree du slot
int ChgEnM; // Change envelop mask.
int AMS; // AMS depth level of this SLOT = degre de modulation de l'amplitude par le LFO
int AMSon; // AMS enable flag = drapeau d'activation de l'AMS
};
struct channel_t
{
int S0_OUT[4]; // anciennes sorties slot 0 (pour le feed back)
int LEFT; // LEFT enable flag
int RIGHT; // RIGHT enable flag
int ALGO; // Algorythm = determine les connections entre les operateurs
int FB; // shift count of self feed back = degre de "Feed-Back" du SLOT 1 (il est son unique entree)
int FMS; // Frequency Modulation Sensitivity of channel = degre de modulation de la frequence sur la voie par le LFO
int AMS; // Amplitude Modulation Sensitivity of channel = degre de modulation de l'amplitude sur la voie par le LFO
int FNUM[4]; // hauteur frequence de la voie (+ 3 pour le mode special)
int FOCT[4]; // octave de la voie (+ 3 pour le mode special)
int KC[4]; // Key Code = valeur fonction de la frequence (voir KSR pour les slots, KSR = KC >> KSR_S)
slot_t SLOT[4]; // four slot.operators = les 4 slots de la voie
int FFlag; // Frequency step recalculation flag
};
struct state_t
{
int TimerBase; // TimerBase calculation
int Status; // YM2612 Status (timer overflow)
int TimerA; // timerA limit = valeur jusqu'? laquelle le timer A doit compter
int TimerAL;
int TimerAcnt; // timerA counter = valeur courante du Timer A
int TimerB; // timerB limit = valeur jusqu'? laquelle le timer B doit compter
int TimerBL;
int TimerBcnt; // timerB counter = valeur courante du Timer B
int Mode; // Mode actuel des voie 3 et 6 (normal / special)
int DAC; // DAC enabled flag
channel_t CHANNEL[Ym2612_Emu::channel_count]; // Les 6 voies du YM2612
int REG[2][0x100]; // Sauvegardes des valeurs de tout les registres, c'est facultatif
// cela nous rend le debuggage plus facile
};
#ifndef PI
#define PI 3.14159265358979323846
#endif
#define ATTACK 0
#define DECAY 1
#define SUBSTAIN 2
#define RELEASE 3
// SIN_LBITS <= 16
// LFO_HBITS <= 16
// (SIN_LBITS + SIN_HBITS) <= 26
// (ENV_LBITS + ENV_HBITS) <= 28
// (LFO_LBITS + LFO_HBITS) <= 28
#define SIN_HBITS 12 // Sinus phase counter int part
#define SIN_LBITS (26 - SIN_HBITS) // Sinus phase counter float part (best setting)
#if (SIN_LBITS > 16)
#define SIN_LBITS 16 // Can't be greater than 16 bits
#endif
#define ENV_HBITS 12 // Env phase counter int part
#define ENV_LBITS (28 - ENV_HBITS) // Env phase counter float part (best setting)
#define LFO_HBITS 10 // LFO phase counter int part
#define LFO_LBITS (28 - LFO_HBITS) // LFO phase counter float part (best setting)
#define SIN_LENGHT (1 << SIN_HBITS)
#define ENV_LENGHT (1 << ENV_HBITS)
#define LFO_LENGHT (1 << LFO_HBITS)
#define TL_LENGHT (ENV_LENGHT * 3) // Env + TL scaling + LFO
#define SIN_MASK (SIN_LENGHT - 1)
#define ENV_MASK (ENV_LENGHT - 1)
#define LFO_MASK (LFO_LENGHT - 1)
#define ENV_STEP (96.0 / ENV_LENGHT) // ENV_MAX = 96 dB
#define ENV_ATTACK ((ENV_LENGHT * 0) << ENV_LBITS)
#define ENV_DECAY ((ENV_LENGHT * 1) << ENV_LBITS)
#define ENV_END ((ENV_LENGHT * 2) << ENV_LBITS)
#define MAX_OUT_BITS (SIN_HBITS + SIN_LBITS + 2) // Modulation = -4 <--> +4
#define MAX_OUT ((1 << MAX_OUT_BITS) - 1)
#define PG_CUT_OFF ((int) (78.0 / ENV_STEP))
#define ENV_CUT_OFF ((int) (68.0 / ENV_STEP))
#define AR_RATE 399128
#define DR_RATE 5514396
//#define AR_RATE 426136
//#define DR_RATE (AR_RATE * 12)
#define LFO_FMS_LBITS 9 // FIXED (LFO_FMS_BASE gives somethink as 1)
#define LFO_FMS_BASE ((int) (0.05946309436 * 0.0338 * (double) (1 << LFO_FMS_LBITS)))
#define S0 0 // Stupid typo of the YM2612
#define S1 2
#define S2 1
#define S3 3
inline void set_seg( slot_t& s, int seg )
{
s.env_xor = 0;
s.env_max = INT_MAX;
s.SEG = seg;
if ( seg & 4 )
{
s.env_xor = ENV_MASK;
s.env_max = ENV_MASK;
}
}
struct tables_t
{
short SIN_TAB [SIN_LENGHT]; // SINUS TABLE (offset into TL TABLE)
int LFOcnt; // LFO counter = compteur-frequence pour le LFO
int LFOinc; // LFO step counter = pas d'incrementation du compteur-frequence du LFO
// plus le pas est grand, plus la frequence est grande
unsigned int AR_TAB [128]; // Attack rate table
unsigned int DR_TAB [96]; // Decay rate table
unsigned int DT_TAB [8] [32]; // Detune table
unsigned int SL_TAB [16]; // Substain level table
unsigned int NULL_RATE [32]; // Table for NULL rate
int LFO_INC_TAB [8]; // LFO step table
short ENV_TAB [2 * ENV_LENGHT + 8]; // ENV CURVE TABLE (attack & decay)
short LFO_ENV_TAB [LFO_LENGHT]; // LFO AMS TABLE (adjusted for 11.8 dB)
short LFO_FREQ_TAB [LFO_LENGHT]; // LFO FMS TABLE
int TL_TAB [TL_LENGHT * 2]; // TOTAL LEVEL TABLE (positif and minus)
unsigned int DECAY_TO_ATTACK [ENV_LENGHT]; // Conversion from decay to attack phase
unsigned int FINC_TAB [2048]; // Frequency step table
};
static const unsigned char DT_DEF_TAB [4 * 32] =
{
// FD = 0
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
// FD = 1
0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8,
// FD = 2
1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5,
5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 16, 16, 16, 16,
// FD = 3
2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7,
8 , 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 22, 22, 22
};
static const unsigned char FKEY_TAB [16] =
{
0, 0, 0, 0,
0, 0, 0, 1,
2, 3, 3, 3,
3, 3, 3, 3
};
static const unsigned char LFO_AMS_TAB [4] =
{
31, 4, 1, 0
};
static const unsigned char LFO_FMS_TAB [8] =
{
LFO_FMS_BASE * 0, LFO_FMS_BASE * 1,
LFO_FMS_BASE * 2, LFO_FMS_BASE * 3,
LFO_FMS_BASE * 4, LFO_FMS_BASE * 6,
LFO_FMS_BASE * 12, LFO_FMS_BASE * 24
};
inline void YM2612_Special_Update() { }
struct Ym2612_Impl
{
enum { channel_count = Ym2612_Emu::channel_count };
state_t YM2612;
int mute_mask;
tables_t g;
void KEY_ON( channel_t&, int );
void KEY_OFF( channel_t&, int );
int SLOT_SET( int, int );
int CHANNEL_SET( int, int );
int YM_SET( int, int );
void set_rate( double sample_rate, double clock_factor );
void reset();
void write0( int addr, int data );
void write1( int addr, int data );
void run_timer( int );
void run( int pair_count, Ym2612_Emu::sample_t* );
};
void Ym2612_Impl::KEY_ON( channel_t& ch, int nsl)
{
slot_t *SL = &(ch.SLOT [nsl]); // on recupere le bon pointeur de slot
if (SL->Ecurp == RELEASE) // la touche est-elle rel'chee ?
{
SL->Fcnt = 0;
// Fix Ecco 2 splash sound
SL->Ecnt = (g.DECAY_TO_ATTACK [g.ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK) & SL->ChgEnM;
SL->ChgEnM = ~0;
// SL->Ecnt = g.DECAY_TO_ATTACK [g.ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK;
// SL->Ecnt = 0;
SL->Einc = SL->EincA;
SL->Ecmp = ENV_DECAY;
SL->Ecurp = ATTACK;
}
}
void Ym2612_Impl::KEY_OFF(channel_t& ch, int nsl)
{
slot_t *SL = &(ch.SLOT [nsl]); // on recupere le bon pointeur de slot
if (SL->Ecurp != RELEASE) // la touche est-elle appuyee ?
{
if (SL->Ecnt < ENV_DECAY) // attack phase ?
{
SL->Ecnt = (g.ENV_TAB [SL->Ecnt >> ENV_LBITS] << ENV_LBITS) + ENV_DECAY;
}
SL->Einc = SL->EincR;
SL->Ecmp = ENV_END;
SL->Ecurp = RELEASE;
}
}
int Ym2612_Impl::SLOT_SET( int Adr, int data )
{
int nch = Adr & 3;
if ( nch == 3 )
return 1;
channel_t& ch = YM2612.CHANNEL [nch + (Adr & 0x100 ? 3 : 0)];
slot_t& sl = ch.SLOT [(Adr >> 2) & 3];
switch ( Adr & 0xF0 )
{
case 0x30:
if ( (sl.MUL = (data & 0x0F)) != 0 ) sl.MUL <<= 1;
else sl.MUL = 1;
sl.DT = (int*) g.DT_TAB [(data >> 4) & 7];
ch.SLOT [0].Finc = -1;
break;
case 0x40:
sl.TL = data & 0x7F;
// SOR2 do a lot of TL adjustement and this fix R.Shinobi jump sound...
YM2612_Special_Update();
#if ((ENV_HBITS - 7) < 0)
sl.TLL = sl.TL >> (7 - ENV_HBITS);
#else
sl.TLL = sl.TL << (ENV_HBITS - 7);
#endif
break;
case 0x50:
sl.KSR_S = 3 - (data >> 6);
ch.SLOT [0].Finc = -1;
if (data &= 0x1F) sl.AR = (int*) &g.AR_TAB [data << 1];
else sl.AR = (int*) &g.NULL_RATE [0];
sl.EincA = sl.AR [sl.KSR];
if (sl.Ecurp == ATTACK) sl.Einc = sl.EincA;
break;
case 0x60:
if ( (sl.AMSon = (data & 0x80)) != 0 ) sl.AMS = ch.AMS;
else sl.AMS = 31;
if (data &= 0x1F) sl.DR = (int*) &g.DR_TAB [data << 1];
else sl.DR = (int*) &g.NULL_RATE [0];
sl.EincD = sl.DR [sl.KSR];
if (sl.Ecurp == DECAY) sl.Einc = sl.EincD;
break;
case 0x70:
if (data &= 0x1F) sl.SR = (int*) &g.DR_TAB [data << 1];
else sl.SR = (int*) &g.NULL_RATE [0];
sl.EincS = sl.SR [sl.KSR];
if ((sl.Ecurp == SUBSTAIN) && (sl.Ecnt < ENV_END)) sl.Einc = sl.EincS;
break;
case 0x80:
sl.SLL = g.SL_TAB [data >> 4];
sl.RR = (int*) &g.DR_TAB [((data & 0xF) << 2) + 2];
sl.EincR = sl.RR [sl.KSR];
if ((sl.Ecurp == RELEASE) && (sl.Ecnt < ENV_END)) sl.Einc = sl.EincR;
break;
case 0x90:
// SSG-EG envelope shapes :
/*
E At Al H
1 0 0 0 \\\\
1 0 0 1 \___
1 0 1 0 \/\/
1 0 1 1 \
1 1 0 0 ////
1 1 0 1 /
1 1 1 0 /\/\
1 1 1 1 /___
E = SSG-EG enable
At = Start negate
Al = Altern
H = Hold */
set_seg( sl, (data & 8) ? (data & 0x0F) : 0 );
break;
}
return 0;
}
int Ym2612_Impl::CHANNEL_SET( int Adr, int data )
{
int num = Adr & 3;
if ( num == 3 )
return 1;
channel_t& ch = YM2612.CHANNEL [num + (Adr & 0x100 ? 3 : 0)];
switch ( Adr & 0xFC )
{
case 0xA0:
YM2612_Special_Update();
ch.FNUM [0] = (ch.FNUM [0] & 0x700) + data;
ch.KC [0] = (ch.FOCT [0] << 2) | FKEY_TAB [ch.FNUM [0] >> 7];
ch.SLOT [0].Finc = -1;
break;
case 0xA4:
YM2612_Special_Update();
ch.FNUM [0] = (ch.FNUM [0] & 0x0FF) + ((data & 0x07) << 8);
ch.FOCT [0] = (data & 0x38) >> 3;
ch.KC [0] = (ch.FOCT [0] << 2) | FKEY_TAB [ch.FNUM [0] >> 7];
ch.SLOT [0].Finc = -1;
break;
case 0xA8:
if ( Adr < 0x100 )
{
num++;
YM2612_Special_Update();
YM2612.CHANNEL [2].FNUM [num] = (YM2612.CHANNEL [2].FNUM [num] & 0x700) + data;
YM2612.CHANNEL [2].KC [num] = (YM2612.CHANNEL [2].FOCT [num] << 2) |
FKEY_TAB [YM2612.CHANNEL [2].FNUM [num] >> 7];
YM2612.CHANNEL [2].SLOT [0].Finc = -1;
}
break;
case 0xAC:
if ( Adr < 0x100 )
{
num++;
YM2612_Special_Update();
YM2612.CHANNEL [2].FNUM [num] = (YM2612.CHANNEL [2].FNUM [num] & 0x0FF) + ((data & 0x07) << 8);
YM2612.CHANNEL [2].FOCT [num] = (data & 0x38) >> 3;
YM2612.CHANNEL [2].KC [num] = (YM2612.CHANNEL [2].FOCT [num] << 2) |
FKEY_TAB [YM2612.CHANNEL [2].FNUM [num] >> 7];
YM2612.CHANNEL [2].SLOT [0].Finc = -1;
}
break;
case 0xB0:
if ( ch.ALGO != (data & 7) )
{
// Fix VectorMan 2 heli sound (level 1)
YM2612_Special_Update();
ch.ALGO = data & 7;
ch.SLOT [0].ChgEnM = 0;
ch.SLOT [1].ChgEnM = 0;
ch.SLOT [2].ChgEnM = 0;
ch.SLOT [3].ChgEnM = 0;
}
ch.FB = 9 - ((data >> 3) & 7); // Real thing ?
// if (ch.FB = ((data >> 3) & 7)) ch.FB = 9 - ch.FB; // Thunder force 4 (music stage 8), Gynoug, Aladdin bug sound...
// else ch.FB = 31;
break;
case 0xB4: {
YM2612_Special_Update();
ch.LEFT = 0 - ((data >> 7) & 1);
ch.RIGHT = 0 - ((data >> 6) & 1);
ch.AMS = LFO_AMS_TAB [(data >> 4) & 3];
ch.FMS = LFO_FMS_TAB [data & 7];
for ( int i = 0; i < 4; i++ )
{
slot_t& sl = ch.SLOT [i];
sl.AMS = (sl.AMSon ? ch.AMS : 31);
}
break;
}
}
return 0;
}
int Ym2612_Impl::YM_SET(int Adr, int data)
{
switch ( Adr )
{
case 0x22:
if (data & 8) // LFO enable
{
// Cool Spot music 1, LFO modified severals time which
// distord the sound, have to check that on a real genesis...
g.LFOinc = g.LFO_INC_TAB [data & 7];
}
else
{
g.LFOinc = g.LFOcnt = 0;
}
break;
case 0x24:
YM2612.TimerA = (YM2612.TimerA & 0x003) | (((int) data) << 2);
if (YM2612.TimerAL != (1024 - YM2612.TimerA) << 12)
{
YM2612.TimerAcnt = YM2612.TimerAL = (1024 - YM2612.TimerA) << 12;
}
break;
case 0x25:
YM2612.TimerA = (YM2612.TimerA & 0x3FC) | (data & 3);
if (YM2612.TimerAL != (1024 - YM2612.TimerA) << 12)
{
YM2612.TimerAcnt = YM2612.TimerAL = (1024 - YM2612.TimerA) << 12;
}
break;
case 0x26:
YM2612.TimerB = data;
if (YM2612.TimerBL != (256 - YM2612.TimerB) << (4 + 12))
{
YM2612.TimerBcnt = YM2612.TimerBL = (256 - YM2612.TimerB) << (4 + 12);
}
break;
case 0x27:
// Parametre divers
// b7 = CSM MODE
// b6 = 3 slot mode
// b5 = reset b
// b4 = reset a
// b3 = timer enable b
// b2 = timer enable a
// b1 = load b
// b0 = load a
if ((data ^ YM2612.Mode) & 0x40)
{
// We changed the channel 2 mode, so recalculate phase step
// This fix the punch sound in Street of Rage 2
YM2612_Special_Update();
YM2612.CHANNEL [2].SLOT [0].Finc = -1; // recalculate phase step
}
// if ((data & 2) && (YM2612.Status & 2)) YM2612.TimerBcnt = YM2612.TimerBL;
// if ((data & 1) && (YM2612.Status & 1)) YM2612.TimerAcnt = YM2612.TimerAL;
// YM2612.Status &= (~data >> 4); // Reset du Status au cas ou c'est demande
YM2612.Status &= (~data >> 4) & (data >> 2); // Reset Status
YM2612.Mode = data;
break;
case 0x28: {
int nch = data & 3;
if ( nch == 3 )
return 1;
if ( data & 4 )
nch += 3;
channel_t& ch = YM2612.CHANNEL [nch];
YM2612_Special_Update();
if (data & 0x10) KEY_ON(ch, S0); // On appuie sur la touche pour le slot 1
else KEY_OFF(ch, S0); // On rel'che la touche pour le slot 1
if (data & 0x20) KEY_ON(ch, S1); // On appuie sur la touche pour le slot 3
else KEY_OFF(ch, S1); // On rel'che la touche pour le slot 3
if (data & 0x40) KEY_ON(ch, S2); // On appuie sur la touche pour le slot 2
else KEY_OFF(ch, S2); // On rel'che la touche pour le slot 2
if (data & 0x80) KEY_ON(ch, S3); // On appuie sur la touche pour le slot 4
else KEY_OFF(ch, S3); // On rel'che la touche pour le slot 4
break;
}
case 0x2B:
if (YM2612.DAC ^ (data & 0x80)) YM2612_Special_Update();
YM2612.DAC = data & 0x80; // activation/desactivation du DAC
break;
}
return 0;
}
void Ym2612_Impl::set_rate( double sample_rate, double clock_rate )
{
assert( sample_rate );
assert( clock_rate > sample_rate );
int i;
// 144 = 12 * (prescale * 2) = 12 * 6 * 2
// prescale set to 6 by default
double Frequence = clock_rate / sample_rate / 144.0;
if ( fabs( Frequence - 1.0 ) < 0.0000001 )
Frequence = 1.0;
YM2612.TimerBase = int (Frequence * 4096.0);
// Tableau TL :
// [0 - 4095] = +output [4095 - ...] = +output overflow (fill with 0)
// [12288 - 16383] = -output [16384 - ...] = -output overflow (fill with 0)
for(i = 0; i < TL_LENGHT; i++)
{
if (i >= PG_CUT_OFF) // YM2612 cut off sound after 78 dB (14 bits output ?)
{
g.TL_TAB [TL_LENGHT + i] = g.TL_TAB [i] = 0;
}
else
{
double x = MAX_OUT; // Max output
x /= pow( 10.0, (ENV_STEP * i) / 20.0 ); // Decibel -> Voltage
g.TL_TAB [i] = (int) x;
g.TL_TAB [TL_LENGHT + i] = -g.TL_TAB [i];
}
}
// Tableau SIN :
// g.SIN_TAB [x] [y] = sin(x) * y;
// x = phase and y = volume
g.SIN_TAB [0] = g.SIN_TAB [SIN_LENGHT / 2] = PG_CUT_OFF;
for(i = 1; i <= SIN_LENGHT / 4; i++)
{
double x = sin(2.0 * PI * (double) (i) / (double) (SIN_LENGHT)); // Sinus
x = 20 * log10(1 / x); // convert to dB
int j = (int) (x / ENV_STEP); // Get TL range
if (j > PG_CUT_OFF) j = (int) PG_CUT_OFF;
g.SIN_TAB [i] = g.SIN_TAB [(SIN_LENGHT / 2) - i] = j;
g.SIN_TAB [(SIN_LENGHT / 2) + i] = g.SIN_TAB [SIN_LENGHT - i] = TL_LENGHT + j;
}
// Tableau LFO (LFO wav) :
for(i = 0; i < LFO_LENGHT; i++)
{
double x = sin(2.0 * PI * (double) (i) / (double) (LFO_LENGHT)); // Sinus
x += 1.0;
x /= 2.0; // positive only
x *= 11.8 / ENV_STEP; // ajusted to MAX enveloppe modulation
g.LFO_ENV_TAB [i] = (int) x;
x = sin(2.0 * PI * (double) (i) / (double) (LFO_LENGHT)); // Sinus
x *= (double) ((1 << (LFO_HBITS - 1)) - 1);
g.LFO_FREQ_TAB [i] = (int) x;
}
// Tableau Enveloppe :
// g.ENV_TAB [0] -> g.ENV_TAB [ENV_LENGHT - 1] = attack curve
// g.ENV_TAB [ENV_LENGHT] -> g.ENV_TAB [2 * ENV_LENGHT - 1] = decay curve
for(i = 0; i < ENV_LENGHT; i++)
{
// Attack curve (x^8 - music level 2 Vectorman 2)
double x = pow(((double) ((ENV_LENGHT - 1) - i) / (double) (ENV_LENGHT)), 8);
x *= ENV_LENGHT;
g.ENV_TAB [i] = (int) x;
// Decay curve (just linear)
x = pow(((double) (i) / (double) (ENV_LENGHT)), 1);
x *= ENV_LENGHT;
g.ENV_TAB [ENV_LENGHT + i] = (int) x;
}
for ( i = 0; i < 8; i++ )
g.ENV_TAB [i + ENV_LENGHT * 2] = 0;
g.ENV_TAB [ENV_END >> ENV_LBITS] = ENV_LENGHT - 1; // for the stopped state
// Tableau pour la conversion Attack -> Decay and Decay -> Attack
int j = ENV_LENGHT - 1;
for ( i = 0; i < ENV_LENGHT; i++ )
{
while ( j && g.ENV_TAB [j] < i )
j--;
g.DECAY_TO_ATTACK [i] = j << ENV_LBITS;
}
// Tableau pour le Substain Level
for(i = 0; i < 15; i++)
{
double x = i * 3; // 3 and not 6 (Mickey Mania first music for test)
x /= ENV_STEP;
g.SL_TAB [i] = ((int) x << ENV_LBITS) + ENV_DECAY;
}
g.SL_TAB [15] = ((ENV_LENGHT - 1) << ENV_LBITS) + ENV_DECAY; // special case : volume off
// Tableau Frequency Step
for(i = 0; i < 2048; i++)
{
double x = (double) (i) * Frequence;
#if ((SIN_LBITS + SIN_HBITS - (21 - 7)) < 0)
x /= (double) (1 << ((21 - 7) - SIN_LBITS - SIN_HBITS));
#else
x *= (double) (1 << (SIN_LBITS + SIN_HBITS - (21 - 7)));
#endif
x /= 2.0; // because MUL = value * 2
g.FINC_TAB [i] = (unsigned int) x;
}
// Tableaux Attack & Decay Rate
for(i = 0; i < 4; i++)
{
g.AR_TAB [i] = 0;
g.DR_TAB [i] = 0;
}
for(i = 0; i < 60; i++)
{
double x = Frequence;
x *= 1.0 + ((i & 3) * 0.25); // bits 0-1 : x1.00, x1.25, x1.50, x1.75
x *= (double) (1 << ((i >> 2))); // bits 2-5 : shift bits (x2^0 - x2^15)
x *= (double) (ENV_LENGHT << ENV_LBITS); // on ajuste pour le tableau g.ENV_TAB
g.AR_TAB [i + 4] = (unsigned int) (x / AR_RATE);
g.DR_TAB [i + 4] = (unsigned int) (x / DR_RATE);
}
for(i = 64; i < 96; i++)
{
g.AR_TAB [i] = g.AR_TAB [63];
g.DR_TAB [i] = g.DR_TAB [63];
g.NULL_RATE [i - 64] = 0;
}
for ( i = 96; i < 128; i++ )
g.AR_TAB [i] = 0;
// Tableau Detune
for(i = 0; i < 4; i++)
{
for (int j = 0; j < 32; j++)
{
#if ((SIN_LBITS + SIN_HBITS - 21) < 0)
double y = (double) DT_DEF_TAB [(i << 5) + j] * Frequence / (double) (1 << (21 - SIN_LBITS - SIN_HBITS));
#else
double y = (double) DT_DEF_TAB [(i << 5) + j] * Frequence * (double) (1 << (SIN_LBITS + SIN_HBITS - 21));
#endif
g.DT_TAB [i + 0] [j] = (int) y;
g.DT_TAB [i + 4] [j] = (int) -y;
}
}
// Tableau LFO
g.LFO_INC_TAB [0] = (unsigned int) (3.98 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [1] = (unsigned int) (5.56 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [2] = (unsigned int) (6.02 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [3] = (unsigned int) (6.37 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [4] = (unsigned int) (6.88 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [5] = (unsigned int) (9.63 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [6] = (unsigned int) (48.1 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
g.LFO_INC_TAB [7] = (unsigned int) (72.2 * (double) (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate);
reset();
}
const char* Ym2612_Emu::set_rate( double sample_rate, double clock_rate )
{
if ( !impl )
{
impl = (Ym2612_Impl*) malloc( sizeof *impl );
if ( !impl )
return "Out of memory";
impl->mute_mask = 0;
}
memset( &impl->YM2612, 0, sizeof impl->YM2612 );
impl->set_rate( sample_rate, clock_rate );
return 0;
}
Ym2612_Emu::~Ym2612_Emu()
{
free( impl );
}
inline void Ym2612_Impl::write0( int opn_addr, int data )
{
assert( (unsigned) data <= 0xFF );
if ( opn_addr < 0x30 )
{
YM2612.REG [0] [opn_addr] = data;
YM_SET( opn_addr, data );
}
else if ( YM2612.REG [0] [opn_addr] != data )
{
YM2612.REG [0] [opn_addr] = data;
if ( opn_addr < 0xA0 )
SLOT_SET( opn_addr, data );
else
CHANNEL_SET( opn_addr, data );
}
}
inline void Ym2612_Impl::write1( int opn_addr, int data )
{
assert( (unsigned) data <= 0xFF );
if ( opn_addr >= 0x30 && YM2612.REG [1] [opn_addr] != data )
{
YM2612.REG [1] [opn_addr] = data;
if ( opn_addr < 0xA0 )
SLOT_SET( opn_addr + 0x100, data );
else
CHANNEL_SET( opn_addr + 0x100, data );
}
}
void Ym2612_Emu::reset()
{
impl->reset();
}
void Ym2612_Impl::reset()
{
g.LFOcnt = 0;
YM2612.TimerA = 0;
YM2612.TimerAL = 0;
YM2612.TimerAcnt = 0;
YM2612.TimerB = 0;
YM2612.TimerBL = 0;
YM2612.TimerBcnt = 0;
YM2612.DAC = 0;
YM2612.Status = 0;
int i;
for ( i = 0; i < channel_count; i++ )
{
channel_t& ch = YM2612.CHANNEL [i];
ch.LEFT = ~0;
ch.RIGHT = ~0;
ch.ALGO = 0;
ch.FB = 31;
ch.FMS = 0;
ch.AMS = 0;
for ( int j = 0 ;j < 4 ; j++ )
{
ch.S0_OUT [j] = 0;
ch.FNUM [j] = 0;
ch.FOCT [j] = 0;
ch.KC [j] = 0;
ch.SLOT [j].Fcnt = 0;
ch.SLOT [j].Finc = 0;
ch.SLOT [j].Ecnt = ENV_END; // Put it at the end of Decay phase...
ch.SLOT [j].Einc = 0;
ch.SLOT [j].Ecmp = 0;
ch.SLOT [j].Ecurp = RELEASE;
ch.SLOT [j].ChgEnM = 0;
}
}
for ( i = 0; i < 0x100; i++ )
{
YM2612.REG [0] [i] = -1;
YM2612.REG [1] [i] = -1;
}
for ( i = 0xB6; i >= 0xB4; i-- )
{
write0( i, 0xC0 );
write1( i, 0xC0 );
}
for ( i = 0xB2; i >= 0x22; i-- )
{
write0( i, 0 );
write1( i, 0 );
}
write0( 0x2A, 0x80 );
}
void Ym2612_Emu::write0( int addr, int data )
{
impl->write0( addr, data );
}
void Ym2612_Emu::write1( int addr, int data )
{
impl->write1( addr, data );
}
void Ym2612_Emu::mute_voices( int mask ) { impl->mute_mask = mask; }
static void update_envelope_( slot_t* sl )
{
switch ( sl->Ecurp )
{
case 0:
// Env_Attack_Next
// Verified with Gynoug even in HQ (explode SFX)
sl->Ecnt = ENV_DECAY;
sl->Einc = sl->EincD;
sl->Ecmp = sl->SLL;
sl->Ecurp = DECAY;
break;
case 1:
// Env_Decay_Next
// Verified with Gynoug even in HQ (explode SFX)
sl->Ecnt = sl->SLL;
sl->Einc = sl->EincS;
sl->Ecmp = ENV_END;
sl->Ecurp = SUBSTAIN;
break;
case 2:
// Env_Substain_Next(slot_t *SL)
if (sl->SEG & 8) // SSG envelope type
{
int release = sl->SEG & 1;
if ( !release )
{
// re KEY ON
// sl->Fcnt = 0;
// sl->ChgEnM = ~0;
sl->Ecnt = 0;
sl->Einc = sl->EincA;
sl->Ecmp = ENV_DECAY;
sl->Ecurp = ATTACK;
}
set_seg( *sl, (sl->SEG << 1) & 4 );
if ( !release )
break;
}
// fall through
case 3:
// Env_Release_Next
sl->Ecnt = ENV_END;
sl->Einc = 0;
sl->Ecmp = ENV_END + 1;
break;
// default: no op
}
}
inline void update_envelope( slot_t& sl )
{
int ecmp = sl.Ecmp;
if ( (sl.Ecnt += sl.Einc) >= ecmp )
update_envelope_( &sl );
}
template<int algo>
struct ym2612_update_chan {
static void func( tables_t&, channel_t&, Ym2612_Emu::sample_t*, int );
};
typedef void (*ym2612_update_chan_t)( tables_t&, channel_t&, Ym2612_Emu::sample_t*, int );
template<int algo>
void ym2612_update_chan<algo>::func( tables_t& g, channel_t& ch,
Ym2612_Emu::sample_t* buf, int length )
{
int not_end = ch.SLOT [S3].Ecnt - ENV_END;
// algo is a compile-time constant, so all conditions based on it are resolved
// during compilation
// special cases
if ( algo == 7 )
not_end |= ch.SLOT [S0].Ecnt - ENV_END;
if ( algo >= 5 )
not_end |= ch.SLOT [S2].Ecnt - ENV_END;
if ( algo >= 4 )
not_end |= ch.SLOT [S1].Ecnt - ENV_END;
int CH_S0_OUT_1 = ch.S0_OUT [1];
int in0 = ch.SLOT [S0].Fcnt;
int in1 = ch.SLOT [S1].Fcnt;
int in2 = ch.SLOT [S2].Fcnt;
int in3 = ch.SLOT [S3].Fcnt;
int YM2612_LFOinc = g.LFOinc;
int YM2612_LFOcnt = g.LFOcnt + YM2612_LFOinc;
if ( !not_end )
return;
do
{
// envelope
int const env_LFO = g.LFO_ENV_TAB [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK];
short const* const ENV_TAB = g.ENV_TAB;
#define CALC_EN( x ) \
int temp##x = ENV_TAB [ch.SLOT [S##x].Ecnt >> ENV_LBITS] + ch.SLOT [S##x].TLL; \
int en##x = ((temp##x ^ ch.SLOT [S##x].env_xor) + (env_LFO >> ch.SLOT [S##x].AMS)) & \
((temp##x - ch.SLOT [S##x].env_max) >> 31);
CALC_EN( 0 )
CALC_EN( 1 )
CALC_EN( 2 )
CALC_EN( 3 )
int const* const TL_TAB = g.TL_TAB;
#define SINT( i, o ) (TL_TAB [g.SIN_TAB [(i)] + (o)])
// feedback
int CH_S0_OUT_0 = ch.S0_OUT [0];
{
int temp = in0 + ((CH_S0_OUT_0 + CH_S0_OUT_1) >> ch.FB);
CH_S0_OUT_1 = CH_S0_OUT_0;
CH_S0_OUT_0 = SINT( (temp >> SIN_LBITS) & SIN_MASK, en0 );
}
int CH_OUTd;
if ( algo == 0 )
{
int temp = in1 + CH_S0_OUT_1;
temp = in2 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 );
temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 );
CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 );
}
else if ( algo == 1 )
{
int temp = in2 + CH_S0_OUT_1 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 );
temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 );
CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 );
}
else if ( algo == 2 )
{
int temp = in2 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 );
temp = in3 + CH_S0_OUT_1 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 );
CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 );
}
else if ( algo == 3 )
{
int temp = in1 + CH_S0_OUT_1;
temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 ) +
SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 );
CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 );
}
else if ( algo == 4 )
{
int temp = in3 + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 );
CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ) +
SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 );
//DO_LIMIT
}
else if ( algo == 5 )
{
int temp = CH_S0_OUT_1;
CH_OUTd = SINT( ((in3 + temp) >> SIN_LBITS) & SIN_MASK, en3 ) +
SINT( ((in1 + temp) >> SIN_LBITS) & SIN_MASK, en1 ) +
SINT( ((in2 + temp) >> SIN_LBITS) & SIN_MASK, en2 );
//DO_LIMIT
}
else if ( algo == 6 )
{
CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) +
SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 ) +
SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 );
//DO_LIMIT
}
else if ( algo == 7 )
{
CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) +
SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ) +
SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ) + CH_S0_OUT_1;
//DO_LIMIT
}
CH_OUTd >>= MAX_OUT_BITS - output_bits + 2;
// update phase
unsigned freq_LFO = ((g.LFO_FREQ_TAB [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK] *
ch.FMS) >> (LFO_HBITS - 1 + 1)) + (1L << (LFO_FMS_LBITS - 1));
YM2612_LFOcnt += YM2612_LFOinc;
in0 += (ch.SLOT [S0].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1);
in1 += (ch.SLOT [S1].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1);
in2 += (ch.SLOT [S2].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1);
in3 += (ch.SLOT [S3].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1);
int t0 = buf [0] + (CH_OUTd & ch.LEFT);
int t1 = buf [1] + (CH_OUTd & ch.RIGHT);
update_envelope( ch.SLOT [0] );
update_envelope( ch.SLOT [1] );
update_envelope( ch.SLOT [2] );
update_envelope( ch.SLOT [3] );
ch.S0_OUT [0] = CH_S0_OUT_0;
buf [0] = t0;
buf [1] = t1;
buf += 2;
}
while ( --length );
ch.S0_OUT [1] = CH_S0_OUT_1;
ch.SLOT [S0].Fcnt = in0;
ch.SLOT [S1].Fcnt = in1;
ch.SLOT [S2].Fcnt = in2;
ch.SLOT [S3].Fcnt = in3;
}
static const ym2612_update_chan_t UPDATE_CHAN [8] = {
&ym2612_update_chan<0>::func,
&ym2612_update_chan<1>::func,
&ym2612_update_chan<2>::func,
&ym2612_update_chan<3>::func,
&ym2612_update_chan<4>::func,
&ym2612_update_chan<5>::func,
&ym2612_update_chan<6>::func,
&ym2612_update_chan<7>::func
};
void Ym2612_Impl::run_timer( int length )
{
int const step = 6;
int remain = length;
do
{
int n = step;
if ( n > remain )
n = remain;
remain -= n;
long i = n * YM2612.TimerBase;
if (YM2612.Mode & 1) // Timer A ON ?
{
// if ((YM2612.TimerAcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL)
if ((YM2612.TimerAcnt -= i) <= 0)
{
// timer a overflow
YM2612.Status |= (YM2612.Mode & 0x04) >> 2;
YM2612.TimerAcnt += YM2612.TimerAL;
if (YM2612.Mode & 0x80)
{
KEY_ON( YM2612.CHANNEL [2], 0 );
KEY_ON( YM2612.CHANNEL [2], 1 );
KEY_ON( YM2612.CHANNEL [2], 2 );
KEY_ON( YM2612.CHANNEL [2], 3 );
}
}
}
if (YM2612.Mode & 2) // Timer B ON ?
{
// if ((YM2612.TimerBcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL)
if ((YM2612.TimerBcnt -= i) <= 0)
{
// timer b overflow
YM2612.Status |= (YM2612.Mode & 0x08) >> 2;
YM2612.TimerBcnt += YM2612.TimerBL;
}
}
}
while ( remain > 0 );
}
void Ym2612_Impl::run( int pair_count, Ym2612_Emu::sample_t* out )
{
if ( pair_count <= 0 )
return;
if ( YM2612.Mode & 3 )
run_timer( pair_count );
// Mise ? jour des pas des compteurs-frequences s'ils ont ete modifies
for ( int chi = 0; chi < channel_count; chi++ )
{
channel_t& ch = YM2612.CHANNEL [chi];
if ( ch.SLOT [0].Finc != -1 )
continue;
int i2 = 0;
if ( chi == 2 && (YM2612.Mode & 0x40) )
i2 = 2;
for ( int i = 0; i < 4; i++ )
{
// static int seq [4] = { 2, 1, 3, 0 };
// if ( i2 ) i2 = seq [i];
slot_t& sl = ch.SLOT [i];
int finc = g.FINC_TAB [ch.FNUM [i2]] >> (7 - ch.FOCT [i2]);
int ksr = ch.KC [i2] >> sl.KSR_S; // keycode attenuation
sl.Finc = (finc + sl.DT [ch.KC [i2]]) * sl.MUL;
if (sl.KSR != ksr) // si le KSR a change alors
{ // les differents taux pour l'enveloppe sont mis ? jour
sl.KSR = ksr;
sl.EincA = sl.AR [ksr];
sl.EincD = sl.DR [ksr];
sl.EincS = sl.SR [ksr];
sl.EincR = sl.RR [ksr];
if (sl.Ecurp == ATTACK)
{
sl.Einc = sl.EincA;
}
else if (sl.Ecurp == DECAY)
{
sl.Einc = sl.EincD;
}
else if (sl.Ecnt < ENV_END)
{
if (sl.Ecurp == SUBSTAIN)
sl.Einc = sl.EincS;
else if (sl.Ecurp == RELEASE)
sl.Einc = sl.EincR;
}
}
if ( i2 )
i2 = (i2 ^ 2) ^ (i2 >> 1);
}
}
for ( int i = 0; i < channel_count; i++ )
{
if ( !(mute_mask & (1 << i)) && (i != 5 || !YM2612.DAC) )
UPDATE_CHAN [YM2612.CHANNEL [i].ALGO]( g, YM2612.CHANNEL [i], out, pair_count );
}
g.LFOcnt += g.LFOinc * pair_count;
}
void Ym2612_Emu::run( int pair_count, sample_t* out ) { impl->run( pair_count, out ); }
diff --git a/src/libs/gme/Ym2612_Emu.h b/src/libs/gme/Ym2612_Emu.h
index 314b3399..054b9481 100644
--- a/src/libs/gme/Ym2612_Emu.h
+++ b/src/libs/gme/Ym2612_Emu.h
@@ -1,38 +1,38 @@
// YM2612 FM sound chip emulator interface
-// Game_Music_Emu 0.5.5
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#ifndef YM2612_EMU_H
#define YM2612_EMU_H
struct Ym2612_Impl;
class Ym2612_Emu {
Ym2612_Impl* impl;
public:
Ym2612_Emu() { impl = 0; }
~Ym2612_Emu();
// Set output sample rate and chip clock rates, in Hz. Returns non-zero
// if error.
const char* set_rate( double sample_rate, double clock_rate );
// Reset to power-up state
void reset();
// Mute voice n if bit n (1 << n) of mask is set
enum { channel_count = 6 };
void mute_voices( int mask );
// Write addr to register 0 then data to register 1
void write0( int addr, int data );
// Write addr to register 2 then data to register 3
void write1( int addr, int data );
// Run and add pair_count samples into current output buffer contents
typedef short sample_t;
enum { out_chan_count = 2 }; // stereo
void run( int pair_count, sample_t* out );
};
#endif
diff --git a/src/libs/gme/blargg_common.h b/src/libs/gme/blargg_common.h
index e48d6469..312a0f16 100644
--- a/src/libs/gme/blargg_common.h
+++ b/src/libs/gme/blargg_common.h
@@ -1,175 +1,157 @@
// Sets up common environment for Shay Green's libraries.
// To change configuration options, modify blargg_config.h, not this file.
#ifndef BLARGG_COMMON_H
#define BLARGG_COMMON_H
#include <stddef.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#undef BLARGG_COMMON_H
// allow blargg_config.h to #include blargg_common.h
#include "blargg_config.h"
#ifndef BLARGG_COMMON_H
#define BLARGG_COMMON_H
+// BLARGG_RESTRICT: equivalent to restrict, where supported
+#if __GNUC__ >= 3 || _MSC_VER >= 1100
+ #define BLARGG_RESTRICT __restrict
+#else
+ #define BLARGG_RESTRICT
+#endif
+
// STATIC_CAST(T,expr): Used in place of static_cast<T> (expr)
#ifndef STATIC_CAST
#define STATIC_CAST(T,expr) ((T) (expr))
#endif
// blargg_err_t (0 on success, otherwise error string)
#ifndef blargg_err_t
typedef const char* blargg_err_t;
#endif
// blargg_vector - very lightweight vector of POD types (no constructor/destructor)
template<class T>
class blargg_vector {
T* begin_;
size_t size_;
public:
blargg_vector() : begin_( 0 ), size_( 0 ) { }
~blargg_vector() { free( begin_ ); }
size_t size() const { return size_; }
T* begin() const { return begin_; }
T* end() const { return begin_ + size_; }
blargg_err_t resize( size_t n )
{
void* p = realloc( begin_, n * sizeof (T) );
if ( !p && n )
return "Out of memory";
begin_ = (T*) p;
size_ = n;
return 0;
}
void clear() { void* p = begin_; begin_ = 0; size_ = 0; free( p ); }
T& operator [] ( size_t n ) const
{
assert( n <= size_ ); // <= to allow past-the-end value
return begin_ [n];
}
};
#ifndef BLARGG_DISABLE_NOTHROW
- #if __cplusplus < 199711
- #define BLARGG_THROWS( spec )
- #else
+ // throw spec mandatory in ISO C++ if operator new can return NULL
+ #if __cplusplus >= 199711 || __GNUC__ >= 3
#define BLARGG_THROWS( spec ) throw spec
+ #else
+ #define BLARGG_THROWS( spec )
#endif
#define BLARGG_DISABLE_NOTHROW \
void* operator new ( size_t s ) BLARGG_THROWS(()) { return malloc( s ); }\
void operator delete ( void* p ) { free( p ); }
#define BLARGG_NEW new
#else
#include <new>
#define BLARGG_NEW new (std::nothrow)
#endif
+// BLARGG_4CHAR('a','b','c','d') = 'abcd' (four character integer constant)
#define BLARGG_4CHAR( a, b, c, d ) \
((a&0xFF)*0x1000000L + (b&0xFF)*0x10000L + (c&0xFF)*0x100L + (d&0xFF))
// BOOST_STATIC_ASSERT( expr ): Generates compile error if expr is 0.
#ifndef BOOST_STATIC_ASSERT
#ifdef _MSC_VER
// MSVC6 (_MSC_VER < 1300) fails for use of __LINE__ when /Zl is specified
#define BOOST_STATIC_ASSERT( expr ) \
void blargg_failed_( int (*arg) [2 / (int) !!(expr) - 1] )
#else
// Some other compilers fail when declaring same function multiple times in class,
// so differentiate them by line
#define BOOST_STATIC_ASSERT( expr ) \
void blargg_failed_( int (*arg) [2 / !!(expr) - 1] [__LINE__] )
#endif
#endif
// BLARGG_COMPILER_HAS_BOOL: If 0, provides bool support for old compiler. If 1,
// compiler is assumed to support bool. If undefined, availability is determined.
#ifndef BLARGG_COMPILER_HAS_BOOL
#if defined (__MWERKS__)
#if !__option(bool)
#define BLARGG_COMPILER_HAS_BOOL 0
#endif
#elif defined (_MSC_VER)
#if _MSC_VER < 1100
#define BLARGG_COMPILER_HAS_BOOL 0
#endif
#elif defined (__GNUC__)
// supports bool
#elif __cplusplus < 199711
#define BLARGG_COMPILER_HAS_BOOL 0
#endif
#endif
#if defined (BLARGG_COMPILER_HAS_BOOL) && !BLARGG_COMPILER_HAS_BOOL
// If you get errors here, modify your blargg_config.h file
typedef int bool;
const bool true = 1;
const bool false = 0;
#endif
// blargg_long/blargg_ulong = at least 32 bits, int if it's big enough
-#include <limits.h>
-#if INT_MAX >= 0x7FFFFFFF
- typedef int blargg_long;
-#else
+#if INT_MAX < 0x7FFFFFFF || LONG_MAX == 0x7FFFFFFF
typedef long blargg_long;
+#else
+ typedef int blargg_long;
#endif
-#if UINT_MAX >= 0xFFFFFFFF
- typedef unsigned blargg_ulong;
-#else
+#if UINT_MAX < 0xFFFFFFFF || ULONG_MAX == 0xFFFFFFFF
typedef unsigned long blargg_ulong;
+#else
+ typedef unsigned blargg_ulong;
#endif
-// BOOST::int8_t etc.
+// int8_t etc.
-// HAVE_STDINT_H: If defined, use <stdint.h> for int8_t etc.
-#if defined (HAVE_STDINT_H)
+// TODO: Add CMake check for this, although I'd likely just point affected
+// persons to a real compiler...
+#if 1 || defined (HAVE_STDINT_H)
#include <stdint.h>
- #define BOOST
-
-// HAVE_INTTYPES_H: If defined, use <stdint.h> for int8_t etc.
-#elif defined (HAVE_INTTYPES_H)
- #include <inttypes.h>
- #define BOOST
+#endif
+#if __GNUC__ >= 3
+ #define BLARGG_DEPRECATED __attribute__ ((deprecated))
#else
- struct BOOST
- {
- #if UCHAR_MAX == 0xFF && SCHAR_MAX == 0x7F
- typedef signed char int8_t;
- typedef unsigned char uint8_t;
- #else
- // No suitable 8-bit type available
- typedef struct see_blargg_common_h int8_t;
- typedef struct see_blargg_common_h uint8_t;
- #endif
-
- #if USHRT_MAX == 0xFFFF
- typedef short int16_t;
- typedef unsigned short uint16_t;
- #else
- // No suitable 16-bit type available
- typedef struct see_blargg_common_h int16_t;
- typedef struct see_blargg_common_h uint16_t;
- #endif
-
- #if ULONG_MAX == 0xFFFFFFFF
- typedef long int32_t;
- typedef unsigned long uint32_t;
- #elif UINT_MAX == 0xFFFFFFFF
- typedef int int32_t;
- typedef unsigned int uint32_t;
- #else
- // No suitable 32-bit type available
- typedef struct see_blargg_common_h int32_t;
- typedef struct see_blargg_common_h uint32_t;
- #endif
- };
+ #define BLARGG_DEPRECATED
+#endif
+
+// Use in place of "= 0;" for a pure virtual, since these cause calls to std C++ lib.
+// During development, BLARGG_PURE( x ) expands to = 0;
+// virtual int func() BLARGG_PURE( { return 0; } )
+#ifndef BLARGG_PURE
+ #define BLARGG_PURE( def ) def
#endif
#endif
#endif
diff --git a/src/libs/gme/blargg_config.h b/src/libs/gme/blargg_config.h
index e71ce0a9..377dd2d8 100644
--- a/src/libs/gme/blargg_config.h
+++ b/src/libs/gme/blargg_config.h
@@ -1,29 +1,43 @@
// Library configuration. Modify this file as necessary.
#ifndef BLARGG_CONFIG_H
#define BLARGG_CONFIG_H
// Uncomment to use zlib for transparent decompression of gzipped files
//#define HAVE_ZLIB_H
+// Uncomment and edit list to support only the listed game music types,
+// so that the others don't get linked in at all.
+/*
+#define GME_TYPE_LIST \
+ gme_ay_type,\
+ gme_gbs_type,\
+ gme_gym_type,\
+ gme_hes_type,\
+ gme_kss_type,\
+ gme_nsf_type,\
+ gme_nsfe_type,\
+ gme_sap_type,\
+ gme_spc_type,\
+ gme_vgm_type,\
+ gme_vgz_type
+*/
+
// Uncomment to enable platform-specific optimizations
//#define BLARGG_NONPORTABLE 1
// Uncomment to use faster, lower quality sound synthesis
//#define BLIP_BUFFER_FAST 1
// Uncomment if automatic byte-order determination doesn't work
//#define BLARGG_BIG_ENDIAN 1
// Uncomment if you get errors in the bool section of blargg_common.h
//#define BLARGG_COMPILER_HAS_BOOL 1
// Use standard config.h if present
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-// Add supported emulator types
-#include "gme_types.h"
-
#endif
diff --git a/src/libs/gme/blargg_endian.h b/src/libs/gme/blargg_endian.h
index 61ffb371..46e58e2f 100644
--- a/src/libs/gme/blargg_endian.h
+++ b/src/libs/gme/blargg_endian.h
@@ -1,165 +1,184 @@
// CPU Byte Order Utilities
-// Game_Music_Emu 0.5.5
#ifndef BLARGG_ENDIAN
#define BLARGG_ENDIAN
#include "blargg_common.h"
// BLARGG_CPU_CISC: Defined if CPU has very few general-purpose registers (< 16)
-#if defined (_M_IX86) || defined (_M_IA64) || defined (__i486__) || \
- defined (__x86_64__) || defined (__ia64__) || defined (__i386__)
+#if defined (__i386__) || defined (__x86_64__) || defined (_M_IX86) || defined (_M_X64)
#define BLARGG_CPU_X86 1
#define BLARGG_CPU_CISC 1
#endif
-#if defined (__powerpc__) || defined (__ppc__) || defined (__POWERPC__) || defined (__powerc)
+#if defined (__powerpc__) || defined (__ppc__) || defined (__ppc64__) || \
+ defined (__POWERPC__) || defined (__powerc)
#define BLARGG_CPU_POWERPC 1
+ #define BLARGG_CPU_RISC 1
#endif
// BLARGG_BIG_ENDIAN, BLARGG_LITTLE_ENDIAN: Determined automatically, otherwise only
// one may be #defined to 1. Only needed if something actually depends on byte order.
#if !defined (BLARGG_BIG_ENDIAN) && !defined (BLARGG_LITTLE_ENDIAN)
#ifdef __GLIBC__
// GCC handles this for us
#include <endian.h>
#if __BYTE_ORDER == __LITTLE_ENDIAN
#define BLARGG_LITTLE_ENDIAN 1
#elif __BYTE_ORDER == __BIG_ENDIAN
#define BLARGG_BIG_ENDIAN 1
#endif
#else
#if defined (LSB_FIRST) || defined (__LITTLE_ENDIAN__) || BLARGG_CPU_X86 || \
(defined (LITTLE_ENDIAN) && LITTLE_ENDIAN+0 != 1234)
#define BLARGG_LITTLE_ENDIAN 1
#endif
#if defined (MSB_FIRST) || defined (__BIG_ENDIAN__) || defined (WORDS_BIGENDIAN) || \
- defined (__mips__) || defined (__sparc__) || BLARGG_CPU_POWERPC || \
+ defined (__sparc__) || BLARGG_CPU_POWERPC || \
(defined (BIG_ENDIAN) && BIG_ENDIAN+0 != 4321)
#define BLARGG_BIG_ENDIAN 1
-#else
+#elif !defined (__mips__)
// No endian specified; assume little-endian, since it's most common
#define BLARGG_LITTLE_ENDIAN 1
#endif
#endif
#endif
#if BLARGG_LITTLE_ENDIAN && BLARGG_BIG_ENDIAN
#undef BLARGG_LITTLE_ENDIAN
#undef BLARGG_BIG_ENDIAN
#endif
-/* force little endian for the psp */
-#ifdef MINPSPW
-#undef BLARGG_LITTLE_ENDIAN
-#undef BLARGG_BIG_ENDIAN
-#define BLARGG_LITTLE_ENDIAN 1
-#endif
-
inline void blargg_verify_byte_order()
{
#ifndef NDEBUG
#if BLARGG_BIG_ENDIAN
volatile int i = 1;
assert( *(volatile char*) &i == 0 );
#elif BLARGG_LITTLE_ENDIAN
volatile int i = 1;
assert( *(volatile char*) &i != 0 );
#endif
#endif
}
-inline unsigned get_le16( void const* p ) {
- return ((unsigned char const*) p) [1] * 0x100u +
- ((unsigned char const*) p) [0];
+inline unsigned get_le16( void const* p )
+{
+ return (unsigned) ((unsigned char const*) p) [1] << 8 |
+ (unsigned) ((unsigned char const*) p) [0];
}
-inline unsigned get_be16( void const* p ) {
- return ((unsigned char const*) p) [0] * 0x100u +
- ((unsigned char const*) p) [1];
+
+inline unsigned get_be16( void const* p )
+{
+ return (unsigned) ((unsigned char const*) p) [0] << 8 |
+ (unsigned) ((unsigned char const*) p) [1];
}
-inline blargg_ulong get_le32( void const* p ) {
- return ((unsigned char const*) p) [3] * 0x01000000u +
- ((unsigned char const*) p) [2] * 0x00010000u +
- ((unsigned char const*) p) [1] * 0x00000100u +
- ((unsigned char const*) p) [0];
+
+inline blargg_ulong get_le32( void const* p )
+{
+ return (blargg_ulong) ((unsigned char const*) p) [3] << 24 |
+ (blargg_ulong) ((unsigned char const*) p) [2] << 16 |
+ (blargg_ulong) ((unsigned char const*) p) [1] << 8 |
+ (blargg_ulong) ((unsigned char const*) p) [0];
}
-inline blargg_ulong get_be32( void const* p ) {
- return ((unsigned char const*) p) [0] * 0x01000000u +
- ((unsigned char const*) p) [1] * 0x00010000u +
- ((unsigned char const*) p) [2] * 0x00000100u +
- ((unsigned char const*) p) [3];
+
+inline blargg_ulong get_be32( void const* p )
+{
+ return (blargg_ulong) ((unsigned char const*) p) [0] << 24 |
+ (blargg_ulong) ((unsigned char const*) p) [1] << 16 |
+ (blargg_ulong) ((unsigned char const*) p) [2] << 8 |
+ (blargg_ulong) ((unsigned char const*) p) [3];
}
-inline void set_le16( void* p, unsigned n ) {
+
+inline void set_le16( void* p, unsigned n )
+{
((unsigned char*) p) [1] = (unsigned char) (n >> 8);
((unsigned char*) p) [0] = (unsigned char) n;
}
-inline void set_be16( void* p, unsigned n ) {
+
+inline void set_be16( void* p, unsigned n )
+{
((unsigned char*) p) [0] = (unsigned char) (n >> 8);
((unsigned char*) p) [1] = (unsigned char) n;
}
-inline void set_le32( void* p, blargg_ulong n ) {
- ((unsigned char*) p) [3] = (unsigned char) (n >> 24);
- ((unsigned char*) p) [2] = (unsigned char) (n >> 16);
- ((unsigned char*) p) [1] = (unsigned char) (n >> 8);
+
+inline void set_le32( void* p, blargg_ulong n )
+{
((unsigned char*) p) [0] = (unsigned char) n;
+ ((unsigned char*) p) [1] = (unsigned char) (n >> 8);
+ ((unsigned char*) p) [2] = (unsigned char) (n >> 16);
+ ((unsigned char*) p) [3] = (unsigned char) (n >> 24);
}
-inline void set_be32( void* p, blargg_ulong n ) {
- ((unsigned char*) p) [0] = (unsigned char) (n >> 24);
- ((unsigned char*) p) [1] = (unsigned char) (n >> 16);
- ((unsigned char*) p) [2] = (unsigned char) (n >> 8);
+
+inline void set_be32( void* p, blargg_ulong n )
+{
((unsigned char*) p) [3] = (unsigned char) n;
+ ((unsigned char*) p) [2] = (unsigned char) (n >> 8);
+ ((unsigned char*) p) [1] = (unsigned char) (n >> 16);
+ ((unsigned char*) p) [0] = (unsigned char) (n >> 24);
}
#if BLARGG_NONPORTABLE
// Optimized implementation if byte order is known
#if BLARGG_LITTLE_ENDIAN
- #define GET_LE16( addr ) (*(BOOST::uint16_t*) (addr))
- #define GET_LE32( addr ) (*(BOOST::uint32_t*) (addr))
- #define SET_LE16( addr, data ) (void) (*(BOOST::uint16_t*) (addr) = (data))
- #define SET_LE32( addr, data ) (void) (*(BOOST::uint32_t*) (addr) = (data))
+ #define GET_LE16( addr ) (*(uint16_t*) (addr))
+ #define GET_LE32( addr ) (*(uint32_t*) (addr))
+ #define SET_LE16( addr, data ) (void) (*(uint16_t*) (addr) = (data))
+ #define SET_LE32( addr, data ) (void) (*(uint32_t*) (addr) = (data))
#elif BLARGG_BIG_ENDIAN
- #define GET_BE16( addr ) (*(BOOST::uint16_t*) (addr))
- #define GET_BE32( addr ) (*(BOOST::uint32_t*) (addr))
- #define SET_BE16( addr, data ) (void) (*(BOOST::uint16_t*) (addr) = (data))
- #define SET_BE32( addr, data ) (void) (*(BOOST::uint32_t*) (addr) = (data))
- #endif
-
- #if BLARGG_CPU_POWERPC && defined (__MWERKS__)
- // PowerPC has special byte-reversed instructions
- // to do: assumes that PowerPC is running in big-endian mode
- // to do: implement for other compilers which don't support these macros
- #define GET_LE16( addr ) (__lhbrx( (addr), 0 ))
- #define GET_LE32( addr ) (__lwbrx( (addr), 0 ))
- #define SET_LE16( addr, data ) (__sthbrx( (data), (addr), 0 ))
- #define SET_LE32( addr, data ) (__stwbrx( (data), (addr), 0 ))
+ #define GET_BE16( addr ) (*(uint16_t*) (addr))
+ #define GET_BE32( addr ) (*(uint32_t*) (addr))
+ #define SET_BE16( addr, data ) (void) (*(uint16_t*) (addr) = (data))
+ #define SET_BE32( addr, data ) (void) (*(uint32_t*) (addr) = (data))
+
+ #if BLARGG_CPU_POWERPC
+ // PowerPC has special byte-reversed instructions
+ #if defined (__MWERKS__)
+ #define GET_LE16( addr ) (__lhbrx( addr, 0 ))
+ #define GET_LE32( addr ) (__lwbrx( addr, 0 ))
+ #define SET_LE16( addr, in ) (__sthbrx( in, addr, 0 ))
+ #define SET_LE32( addr, in ) (__stwbrx( in, addr, 0 ))
+ #elif defined (__GNUC__)
+ #define GET_LE16( addr ) ({unsigned short ppc_lhbrx_; __asm__ volatile( "lhbrx %0,0,%1" : "=r" (ppc_lhbrx_) : "r" (addr) : "memory" ); ppc_lhbrx_;})
+ #define GET_LE32( addr ) ({unsigned short ppc_lwbrx_; __asm__ volatile( "lwbrx %0,0,%1" : "=r" (ppc_lwbrx_) : "r" (addr) : "memory" ); ppc_lwbrx_;})
+ #define SET_LE16( addr, in ) ({__asm__ volatile( "sthbrx %0,0,%1" : : "r" (in), "r" (addr) : "memory" );})
+ #define SET_LE32( addr, in ) ({__asm__ volatile( "stwbrx %0,0,%1" : : "r" (in), "r" (addr) : "memory" );})
+ #endif
+ #endif
#endif
#endif
#ifndef GET_LE16
#define GET_LE16( addr ) get_le16( addr )
- #define GET_LE32( addr ) get_le32( addr )
#define SET_LE16( addr, data ) set_le16( addr, data )
+#endif
+
+#ifndef GET_LE32
+ #define GET_LE32( addr ) get_le32( addr )
#define SET_LE32( addr, data ) set_le32( addr, data )
#endif
#ifndef GET_BE16
#define GET_BE16( addr ) get_be16( addr )
- #define GET_BE32( addr ) get_be32( addr )
#define SET_BE16( addr, data ) set_be16( addr, data )
+#endif
+
+#ifndef GET_BE32
+ #define GET_BE32( addr ) get_be32( addr )
#define SET_BE32( addr, data ) set_be32( addr, data )
#endif
// auto-selecting versions
-inline void set_le( BOOST::uint16_t* p, unsigned n ) { SET_LE16( p, n ); }
-inline void set_le( BOOST::uint32_t* p, blargg_ulong n ) { SET_LE32( p, n ); }
-inline void set_be( BOOST::uint16_t* p, unsigned n ) { SET_BE16( p, n ); }
-inline void set_be( BOOST::uint32_t* p, blargg_ulong n ) { SET_BE32( p, n ); }
-inline unsigned get_le( BOOST::uint16_t* p ) { return GET_LE16( p ); }
-inline blargg_ulong get_le( BOOST::uint32_t* p ) { return GET_LE32( p ); }
-inline unsigned get_be( BOOST::uint16_t* p ) { return GET_BE16( p ); }
-inline blargg_ulong get_be( BOOST::uint32_t* p ) { return GET_BE32( p ); }
+inline void set_le( uint16_t* p, unsigned n ) { SET_LE16( p, n ); }
+inline void set_le( uint32_t* p, blargg_ulong n ) { SET_LE32( p, n ); }
+inline void set_be( uint16_t* p, unsigned n ) { SET_BE16( p, n ); }
+inline void set_be( uint32_t* p, blargg_ulong n ) { SET_BE32( p, n ); }
+inline unsigned get_le( uint16_t* p ) { return GET_LE16( p ); }
+inline blargg_ulong get_le( uint32_t* p ) { return GET_LE32( p ); }
+inline unsigned get_be( uint16_t* p ) { return GET_BE16( p ); }
+inline blargg_ulong get_be( uint32_t* p ) { return GET_BE32( p ); }
#endif
diff --git a/src/libs/gme/blargg_source.h b/src/libs/gme/blargg_source.h
index 2b568d19..b011777a 100644
--- a/src/libs/gme/blargg_source.h
+++ b/src/libs/gme/blargg_source.h
@@ -1,78 +1,110 @@
-// Included at the beginning of library source files, after all other #include lines
+/* Included at the beginning of library source files, after all other #include lines.
+Sets up helpful macros and services used in my source code. They don't need
+module an annoying module prefix on their names since they are defined after
+all other #include lines. */
+
#ifndef BLARGG_SOURCE_H
#define BLARGG_SOURCE_H
// If debugging is enabled, abort program if expr is false. Meant for checking
// internal state and consistency. A failed assertion indicates a bug in the module.
// void assert( bool expr );
#include <assert.h>
// If debugging is enabled and expr is false, abort program. Meant for checking
// caller-supplied parameters and operations that are outside the control of the
// module. A failed requirement indicates a bug outside the module.
// void require( bool expr );
#undef require
#define require( expr ) assert( expr )
// Like printf() except output goes to debug log file. Might be defined to do
// nothing (not even evaluate its arguments).
// void debug_printf( const char* format, ... );
-inline void blargg_dprintf_( const char*, ... ) { }
+static inline void blargg_dprintf_( const char*, ... ) { }
#undef debug_printf
#define debug_printf (1) ? (void) 0 : blargg_dprintf_
// If enabled, evaluate expr and if false, make debug log entry with source file
// and line. Meant for finding situations that should be examined further, but that
// don't indicate a problem. In all cases, execution continues normally.
#undef check
#define check( expr ) ((void) 0)
// If expr yields error string, return it from current function, otherwise continue.
#undef RETURN_ERR
#define RETURN_ERR( expr ) do { \
blargg_err_t blargg_return_err_ = (expr); \
if ( blargg_return_err_ ) return blargg_return_err_; \
} while ( 0 )
// If ptr is 0, return out of memory error string.
#undef CHECK_ALLOC
#define CHECK_ALLOC( ptr ) do { if ( (ptr) == 0 ) return "Out of memory"; } while ( 0 )
// Avoid any macros which evaluate their arguments multiple times
#undef min
#undef max
+#define DEF_MIN_MAX( type ) \
+ static inline type min( type x, type y ) { if ( x < y ) return x; return y; }\
+ static inline type max( type x, type y ) { if ( y < x ) return x; return y; }
+
+DEF_MIN_MAX( int )
+DEF_MIN_MAX( unsigned )
+DEF_MIN_MAX( long )
+DEF_MIN_MAX( unsigned long )
+DEF_MIN_MAX( float )
+DEF_MIN_MAX( double )
+
+#undef DEF_MIN_MAX
+
+/*
// using const references generates crappy code, and I am currenly only using these
// for built-in types, so they take arguments by value
+// TODO: remove
+inline int min( int x, int y )
template<class T>
inline T min( T x, T y )
{
if ( x < y )
return x;
return y;
}
template<class T>
inline T max( T x, T y )
{
if ( x < y )
return y;
return x;
}
+*/
// TODO: good idea? bad idea?
#undef byte
#define byte byte_
typedef unsigned char byte;
+// Setup compiler defines useful for exporting required public API symbols in gme.cpp
+#ifndef BLARGG_EXPORT
+ #if defined (_WIN32) && defined(BLARGG_BUILD_DLL)
+ #define BLARGG_EXPORT __declspec(dllexport)
+ #elif defined (LIBGME_VISIBILITY)
+ #define BLARGG_EXPORT __attribute__((visibility ("default")))
+ #else
+ #define BLARGG_EXPORT
+ #endif
+#endif
+
// deprecated
#define BLARGG_CHECK_ALLOC CHECK_ALLOC
#define BLARGG_RETURN_ERR RETURN_ERR
// BLARGG_SOURCE_BEGIN: If defined, #included, allowing redefition of debug_printf and check
#ifdef BLARGG_SOURCE_BEGIN
#include BLARGG_SOURCE_BEGIN
#endif
#endif
diff --git a/src/libs/gme/gb_cpu_io.h b/src/libs/gme/gb_cpu_io.h
index cd98ffd5..8bd69aa2 100644
--- a/src/libs/gme/gb_cpu_io.h
+++ b/src/libs/gme/gb_cpu_io.h
@@ -1,72 +1,72 @@
#include "Gbs_Emu.h"
#include "blargg_source.h"
int Gbs_Emu::cpu_read( gb_addr_t addr )
{
int result = *cpu::get_code( addr );
if ( unsigned (addr - Gb_Apu::start_addr) < Gb_Apu::register_count )
result = apu.read_register( clock(), addr );
#ifndef NDEBUG
else if ( unsigned (addr - 0x8000) < 0x2000 || unsigned (addr - 0xE000) < 0x1F00 )
debug_printf( "Read from unmapped memory $%.4x\n", (unsigned) addr );
else if ( unsigned (addr - 0xFF01) < 0xFF80 - 0xFF01 )
debug_printf( "Unhandled I/O read 0x%4X\n", (unsigned) addr );
#endif
return result;
}
void Gbs_Emu::cpu_write( gb_addr_t addr, int data )
{
unsigned offset = addr - ram_addr;
if ( offset <= 0xFFFF - ram_addr )
{
ram [offset] = data;
if ( (addr ^ 0xE000) <= 0x1F80 - 1 )
{
if ( unsigned (addr - Gb_Apu::start_addr) < Gb_Apu::register_count )
{
GME_APU_HOOK( this, addr - Gb_Apu::start_addr, data );
apu.write_register( clock(), addr, data );
}
else if ( (addr ^ 0xFF06) < 2 )
update_timer();
else if ( addr == joypad_addr )
ram [offset] = 0; // keep joypad return value 0
else
ram [offset] = 0xFF;
//if ( addr == 0xFFFF )
// debug_printf( "Wrote interrupt mask\n" );
}
}
else if ( (addr ^ 0x2000) <= 0x2000 - 1 )
{
set_bank( data );
}
#ifndef NDEBUG
else if ( unsigned (addr - 0x8000) < 0x2000 || unsigned (addr - 0xE000) < 0x1F00 )
{
debug_printf( "Wrote to unmapped memory $%.4x\n", (unsigned) addr );
}
#endif
}
#define CPU_READ_FAST( cpu, addr, time, out ) \
CPU_READ_FAST_( STATIC_CAST(Gbs_Emu*,cpu), addr, time, out )
#define CPU_READ_FAST_( emu, addr, time, out ) \
{\
out = READ_PROG( addr );\
- if ( unsigned (addr - Gb_Apu::start_addr) <= Gb_Apu::register_count )\
+ if ( unsigned (addr - Gb_Apu::start_addr) < Gb_Apu::register_count )\
out = emu->apu.read_register( emu->cpu_time - time * clocks_per_instr, addr );\
else\
check( out == emu->cpu_read( addr ) );\
}
#define CPU_READ( cpu, addr, time ) \
STATIC_CAST(Gbs_Emu*,cpu)->cpu_read( addr )
#define CPU_WRITE( cpu, addr, data, time ) \
STATIC_CAST(Gbs_Emu*,cpu)->cpu_write( addr, data )
diff --git a/src/libs/gme/gme.cpp b/src/libs/gme/gme.cpp
index 6b9dc0b8..b649da6d 100644
--- a/src/libs/gme/gme.cpp
+++ b/src/libs/gme/gme.cpp
@@ -1,367 +1,408 @@
-// Game_Music_Emu 0.5.5. http://www.slack.net/~ant/
+// Game_Music_Emu https://bitbucket.org/mpyne/game-music-emu/
#include "Music_Emu.h"
+#include "gme_types.h"
#if !GME_DISABLE_STEREO_DEPTH
#include "Effects_Buffer.h"
#endif
#include "blargg_endian.h"
#include <string.h>
#include <ctype.h>
/* Copyright (C) 2003-2006 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"
-gme_type_t const* gme_type_list()
+BLARGG_EXPORT gme_type_t const* gme_type_list()
{
static gme_type_t const gme_type_list_ [] = {
-#ifdef USE_GME_AY
- gme_ay_type,
+#ifdef GME_TYPE_LIST
+ GME_TYPE_LIST,
+#else
+ #ifdef USE_GME_AY
+ gme_ay_type,
+ #endif
+ #ifdef USE_GME_GBS
+ gme_gbs_type,
+ #endif
+ #ifdef USE_GME_GYM
+ gme_gym_type,
+ #endif
+ #ifdef USE_GME_HES
+ gme_hes_type,
+ #endif
+ #ifdef USE_GME_KSS
+ gme_kss_type,
+ #endif
+ #ifdef USE_GME_NSF
+ gme_nsf_type,
+ #endif
+ #ifdef USE_GME_NSFE
+ gme_nsfe_type,
+ #endif
+ #ifdef USE_GME_SAP
+ gme_sap_type,
+ #endif
+ #ifdef USE_GME_SPC
+ gme_spc_type,
+ #endif
+ #ifdef USE_GME_VGM
+ gme_vgm_type,
+ gme_vgz_type,
+ #endif
#endif
-#ifdef USE_GME_GBS
- gme_gbs_type,
-#endif
-#ifdef USE_GME_GYM
- gme_gym_type,
-#endif
-#ifdef USE_GME_HES
- gme_hes_type,
-#endif
-#ifdef USE_GME_KSS
- gme_kss_type,
-#endif
-#if defined(USE_GME_NSF) || defined(USE_GME_NSFE)
- gme_nsf_type,
-#endif
-#ifdef USE_GME_NSFE
- gme_nsfe_type,
-#endif
-#ifdef USE_GME_SAP
- gme_sap_type,
-#endif
-#ifdef USE_GME_SPC
- gme_spc_type,
-#endif
-#ifdef USE_GME_VGM
- gme_vgm_type,
- gme_vgz_type,
-#endif
- 0 };
+ 0
+ };
return gme_type_list_;
}
-const char* gme_identify_header( void const* header )
+BLARGG_EXPORT const char* gme_identify_header( void const* header )
{
switch ( get_be32( header ) )
{
case BLARGG_4CHAR('Z','X','A','Y'): return "AY";
case BLARGG_4CHAR('G','B','S',0x01): return "GBS";
case BLARGG_4CHAR('G','Y','M','X'): return "GYM";
case BLARGG_4CHAR('H','E','S','M'): return "HES";
case BLARGG_4CHAR('K','S','C','C'):
case BLARGG_4CHAR('K','S','S','X'): return "KSS";
case BLARGG_4CHAR('N','E','S','M'): return "NSF";
case BLARGG_4CHAR('N','S','F','E'): return "NSFE";
case BLARGG_4CHAR('S','A','P',0x0D): return "SAP";
case BLARGG_4CHAR('S','N','E','S'): return "SPC";
case BLARGG_4CHAR('V','g','m',' '): return "VGM";
}
return "";
}
static void to_uppercase( const char* in, int len, char* out )
{
for ( int i = 0; i < len; i++ )
{
if ( !(out [i] = toupper( in [i] )) )
return;
}
*out = 0; // extension too long
}
-gme_type_t gme_identify_extension( const char* extension_ )
+BLARGG_EXPORT gme_type_t gme_identify_extension( const char* extension_ )
{
char const* end = strrchr( extension_, '.' );
if ( end )
extension_ = end + 1;
char extension [6];
to_uppercase( extension_, sizeof extension, extension );
for ( gme_type_t const* types = gme_type_list(); *types; types++ )
if ( !strcmp( extension, (*types)->extension_ ) )
return *types;
return 0;
}
-gme_err_t gme_identify_file( const char* path, gme_type_t* type_out )
+BLARGG_EXPORT const char *gme_type_extension( gme_type_t music_type )
+{
+ const gme_type_t_ *const music_typeinfo = static_cast<const gme_type_t_ *>( music_type );
+ if ( music_type )
+ return music_typeinfo->extension_;
+ return "";
+}
+
+BLARGG_EXPORT gme_err_t gme_identify_file( const char* path, gme_type_t* type_out )
{
*type_out = gme_identify_extension( path );
// TODO: don't examine header if file has extension?
if ( !*type_out )
{
char header [4];
GME_FILE_READER in;
RETURN_ERR( in.open( path ) );
RETURN_ERR( in.read( header, sizeof header ) );
*type_out = gme_identify_extension( gme_identify_header( header ) );
}
return 0;
}
-gme_err_t gme_open_data( void const* data, long size, Music_Emu** out, int sample_rate )
+BLARGG_EXPORT gme_err_t gme_open_data( void const* data, long size, Music_Emu** out, int sample_rate )
{
require( (data || !size) && out );
*out = 0;
gme_type_t file_type = 0;
if ( size >= 4 )
file_type = gme_identify_extension( gme_identify_header( data ) );
if ( !file_type )
return gme_wrong_file_type;
Music_Emu* emu = gme_new_emu( file_type, sample_rate );
CHECK_ALLOC( emu );
gme_err_t err = gme_load_data( emu, data, size );
if ( err )
delete emu;
else
*out = emu;
return err;
}
-gme_err_t gme_open_file( const char* path, Music_Emu** out, int sample_rate )
+BLARGG_EXPORT gme_err_t gme_open_file( const char* path, Music_Emu** out, int sample_rate )
{
require( path && out );
*out = 0;
GME_FILE_READER in;
RETURN_ERR( in.open( path ) );
char header [4];
int header_size = 0;
gme_type_t file_type = gme_identify_extension( path );
if ( !file_type )
{
header_size = sizeof header;
RETURN_ERR( in.read( header, sizeof header ) );
file_type = gme_identify_extension( gme_identify_header( header ) );
}
if ( !file_type )
return gme_wrong_file_type;
Music_Emu* emu = gme_new_emu( file_type, sample_rate );
CHECK_ALLOC( emu );
// optimization: avoids seeking/re-reading header
Remaining_Reader rem( header, header_size, &in );
gme_err_t err = emu->load( rem );
in.close();
if ( err )
delete emu;
else
*out = emu;
return err;
}
-Music_Emu* gme_new_emu( gme_type_t type, int rate )
+// Used to implement gme_new_emu and gme_new_emu_multi_channel
+Music_Emu* gme_internal_new_emu_( gme_type_t type, int rate, bool multi_channel )
{
if ( type )
{
if ( rate == gme_info_only )
return type->new_info();
Music_Emu* me = type->new_emu();
if ( me )
{
#if !GME_DISABLE_STEREO_DEPTH
+ me->set_multi_channel( multi_channel );
+
if ( type->flags_ & 1 )
{
- me->effects_buffer = BLARGG_NEW Effects_Buffer;
+ if ( me->multi_channel() )
+ {
+ me->effects_buffer = BLARGG_NEW Effects_Buffer(8);
+ }
+ else
+ {
+ me->effects_buffer = BLARGG_NEW Effects_Buffer(1);
+ }
if ( me->effects_buffer )
me->set_buffer( me->effects_buffer );
}
if ( !(type->flags_ & 1) || me->effects_buffer )
#endif
{
if ( !me->set_sample_rate( rate ) )
{
check( me->type() == type );
return me;
}
}
delete me;
}
}
return 0;
}
-gme_err_t gme_load_file( Music_Emu* me, const char* path ) { return me->load_file( path ); }
+BLARGG_EXPORT Music_Emu* gme_new_emu( gme_type_t type, int rate )
+{
+ return gme_internal_new_emu_( type, rate, false /* no multichannel */);
+}
-gme_err_t gme_load_data( Music_Emu* me, void const* data, long size )
+BLARGG_EXPORT Music_Emu* gme_new_emu_multi_channel( gme_type_t type, int rate )
+{
+ // multi-channel emulator (if possible, not all emu types support multi-channel)
+ return gme_internal_new_emu_( type, rate, true /* multichannel */);
+}
+
+BLARGG_EXPORT gme_err_t gme_load_file( Music_Emu* me, const char* path ) { return me->load_file( path ); }
+
+BLARGG_EXPORT gme_err_t gme_load_data( Music_Emu* me, void const* data, long size )
{
Mem_File_Reader in( data, size );
return me->load( in );
}
-gme_err_t gme_load_custom( Music_Emu* me, gme_reader_t func, long size, void* data )
+BLARGG_EXPORT gme_err_t gme_load_custom( Music_Emu* me, gme_reader_t func, long size, void* data )
{
Callback_Reader in( func, size, data );
return me->load( in );
}
-void gme_delete( Music_Emu* me ) { delete me; }
+BLARGG_EXPORT void gme_delete( Music_Emu* me ) { delete me; }
-gme_type_t gme_type( Music_Emu const* me ) { return me->type(); }
+BLARGG_EXPORT gme_type_t gme_type( Music_Emu const* me ) { return me->type(); }
-const char* gme_warning( Music_Emu* me ) { return me->warning(); }
+BLARGG_EXPORT const char* gme_warning( Music_Emu* me ) { return me->warning(); }
-int gme_track_count( Music_Emu const* me ) { return me->track_count(); }
+BLARGG_EXPORT int gme_track_count( Music_Emu const* me ) { return me->track_count(); }
struct gme_info_t_ : gme_info_t
{
track_info_t info;
BLARGG_DISABLE_NOTHROW
};
-gme_err_t gme_track_info( Music_Emu const* me, gme_info_t** out, int track )
+BLARGG_EXPORT gme_err_t gme_track_info( Music_Emu const* me, gme_info_t** out, int track )
{
*out = NULL;
gme_info_t_* info = BLARGG_NEW gme_info_t_;
CHECK_ALLOC( info );
gme_err_t err = me->track_info( &info->info, track );
if ( err )
{
gme_free_info( info );
return err;
}
#define COPY(name) info->name = info->info.name;
COPY( length );
COPY( intro_length );
COPY( loop_length );
info->i4 = -1;
info->i5 = -1;
info->i6 = -1;
info->i7 = -1;
info->i8 = -1;
info->i9 = -1;
info->i10 = -1;
info->i11 = -1;
info->i12 = -1;
info->i13 = -1;
info->i14 = -1;
info->i15 = -1;
info->s7 = "";
info->s8 = "";
info->s9 = "";
info->s10 = "";
info->s11 = "";
info->s12 = "";
info->s13 = "";
info->s14 = "";
info->s15 = "";
COPY( system );
COPY( game );
COPY( song );
COPY( author );
COPY( copyright );
COPY( comment );
COPY( dumper );
#undef COPY
info->play_length = info->length;
if ( info->play_length <= 0 )
{
info->play_length = info->intro_length + 2 * info->loop_length; // intro + 2 loops
if ( info->play_length <= 0 )
info->play_length = 150 * 1000; // 2.5 minutes
}
*out = info;
return 0;
}
-void gme_free_info( gme_info_t* info )
+BLARGG_EXPORT void gme_free_info( gme_info_t* info )
{
delete STATIC_CAST(gme_info_t_*,info);
}
-void gme_set_stereo_depth( Music_Emu* me, double depth )
+BLARGG_EXPORT void gme_set_stereo_depth( Music_Emu* me, double depth )
{
#if !GME_DISABLE_STEREO_DEPTH
if ( me->effects_buffer )
STATIC_CAST(Effects_Buffer*,me->effects_buffer)->set_depth( depth );
#endif
}
-void* gme_user_data ( Music_Emu const* me ) { return me->user_data(); }
-void gme_set_user_data ( Music_Emu* me, void* new_user_data ) { me->set_user_data( new_user_data ); }
-void gme_set_user_cleanup(Music_Emu* me, gme_user_cleanup_t func ) { me->set_user_cleanup( func ); }
-
-gme_err_t gme_start_track ( Music_Emu* me, int index ) { return me->start_track( index ); }
-gme_err_t gme_play ( Music_Emu* me, int n, short* p ) { return me->play( n, p ); }
-void gme_set_fade ( Music_Emu* me, int start_msec ) { me->set_fade( start_msec ); }
-int gme_track_ended ( Music_Emu const* me ) { return me->track_ended(); }
-int gme_tell ( Music_Emu const* me ) { return me->tell(); }
-gme_err_t gme_seek ( Music_Emu* me, int msec ) { return me->seek( msec ); }
-int gme_voice_count ( Music_Emu const* me ) { return me->voice_count(); }
-void gme_ignore_silence ( Music_Emu* me, int disable ) { me->ignore_silence( disable != 0 ); }
-void gme_set_tempo ( Music_Emu* me, double t ) { me->set_tempo( t ); }
-void gme_mute_voice ( Music_Emu* me, int index, int mute ) { me->mute_voice( index, mute != 0 ); }
-void gme_mute_voices ( Music_Emu* me, int mask ) { me->mute_voices( mask ); }
-
-void gme_set_equalizer ( Music_Emu* me, gme_equalizer_t const* eq )
+BLARGG_EXPORT void* gme_user_data ( Music_Emu const* me ) { return me->user_data(); }
+BLARGG_EXPORT void gme_set_user_data ( Music_Emu* me, void* new_user_data ) { me->set_user_data( new_user_data ); }
+BLARGG_EXPORT void gme_set_user_cleanup(Music_Emu* me, gme_user_cleanup_t func ) { me->set_user_cleanup( func ); }
+
+BLARGG_EXPORT gme_err_t gme_start_track ( Music_Emu* me, int index ) { return me->start_track( index ); }
+BLARGG_EXPORT gme_err_t gme_play ( Music_Emu* me, int n, short* p ) { return me->play( n, p ); }
+BLARGG_EXPORT void gme_set_fade ( Music_Emu* me, int start_msec ) { me->set_fade( start_msec ); }
+BLARGG_EXPORT int gme_track_ended ( Music_Emu const* me ) { return me->track_ended(); }
+BLARGG_EXPORT int gme_tell ( Music_Emu const* me ) { return me->tell(); }
+BLARGG_EXPORT int gme_tell_samples ( Music_Emu const* me ) { return me->tell_samples(); }
+BLARGG_EXPORT gme_err_t gme_seek ( Music_Emu* me, int msec ) { return me->seek( msec ); }
+BLARGG_EXPORT gme_err_t gme_seek_samples ( Music_Emu* me, int n ) { return me->seek_samples( n ); }
+BLARGG_EXPORT int gme_voice_count ( Music_Emu const* me ) { return me->voice_count(); }
+BLARGG_EXPORT void gme_ignore_silence ( Music_Emu* me, int disable ) { me->ignore_silence( disable != 0 ); }
+BLARGG_EXPORT void gme_set_tempo ( Music_Emu* me, double t ) { me->set_tempo( t ); }
+BLARGG_EXPORT void gme_mute_voice ( Music_Emu* me, int index, int mute ) { me->mute_voice( index, mute != 0 ); }
+BLARGG_EXPORT void gme_mute_voices ( Music_Emu* me, int mask ) { me->mute_voices( mask ); }
+BLARGG_EXPORT void gme_enable_accuracy( Music_Emu* me, int enabled ) { me->enable_accuracy( enabled ); }
+BLARGG_EXPORT void gme_clear_playlist ( Music_Emu* me ) { me->clear_playlist(); }
+BLARGG_EXPORT int gme_type_multitrack( gme_type_t t ) { return t->track_count != 1; }
+BLARGG_EXPORT int gme_multi_channel ( Music_Emu const* me ) { return me->multi_channel(); }
+
+BLARGG_EXPORT void gme_set_equalizer ( Music_Emu* me, gme_equalizer_t const* eq )
{
Music_Emu::equalizer_t e = me->equalizer();
e.treble = eq->treble;
e.bass = eq->bass;
me->set_equalizer( e );
}
-void gme_equalizer( Music_Emu const* me, gme_equalizer_t* out )
+BLARGG_EXPORT void gme_equalizer( Music_Emu const* me, gme_equalizer_t* out )
{
- gme_equalizer_t e = { };
+ gme_equalizer_t e = gme_equalizer_t(); // Default-init all fields to 0.0f
e.treble = me->equalizer().treble;
e.bass = me->equalizer().bass;
*out = e;
}
-const char* gme_voice_name( Music_Emu const* me, int i )
+BLARGG_EXPORT const char* gme_voice_name( Music_Emu const* me, int i )
{
assert( (unsigned) i < (unsigned) me->voice_count() );
return me->voice_names() [i];
}
-const char* gme_type_system( gme_type_t type )
+BLARGG_EXPORT const char* gme_type_system( gme_type_t type )
{
assert( type );
return type->system;
}
diff --git a/src/libs/gme/gme.h b/src/libs/gme/gme.h
index 575eea38..80c6ce84 100644
--- a/src/libs/gme/gme.h
+++ b/src/libs/gme/gme.h
@@ -1,236 +1,267 @@
/* Game music emulator library C interface (also usable from C++) */
-/* Game_Music_Emu 0.5.5 */
+/* Game_Music_Emu 0.6.2 */
#ifndef GME_H
#define GME_H
#ifdef __cplusplus
extern "C" {
#endif
+#define GME_VERSION 0x000602 /* 1 byte major, 1 byte minor, 1 byte patch-level */
+
/* Error string returned by library functions, or NULL if no error (success) */
typedef const char* gme_err_t;
/* First parameter of most gme_ functions is a pointer to the Music_Emu */
-typedef class Music_Emu Music_Emu;
+typedef struct Music_Emu Music_Emu;
/******** Basic operations ********/
/* Create emulator and load game music file/data into it. Sets *out to new emulator. */
gme_err_t gme_open_file( const char path [], Music_Emu** out, int sample_rate );
/* Number of tracks available */
int gme_track_count( Music_Emu const* );
/* Start a track, where 0 is the first track */
gme_err_t gme_start_track( Music_Emu*, int index );
/* Generate 'count' 16-bit signed samples info 'out'. Output is in stereo. */
gme_err_t gme_play( Music_Emu*, int count, short out [] );
/* Finish using emulator and free memory */
void gme_delete( Music_Emu* );
/******** Track position/length ********/
/* Set time to start fading track out. Once fade ends track_ended() returns true.
Fade time can be changed while track is playing. */
void gme_set_fade( Music_Emu*, int start_msec );
/* True if a track has reached its end */
int gme_track_ended( Music_Emu const* );
/* Number of milliseconds (1000 = one second) played since beginning of track */
int gme_tell( Music_Emu const* );
+/* Number of samples generated since beginning of track */
+int gme_tell_samples( Music_Emu const* );
+
/* Seek to new time in track. Seeking backwards or far forward can take a while. */
gme_err_t gme_seek( Music_Emu*, int msec );
+/* Equivalent to restarting track then skipping n samples */
+gme_err_t gme_seek_samples( Music_Emu*, int n );
+
/******** Informational ********/
/* If you only need track information from a music file, pass gme_info_only for
sample_rate to open/load. */
enum { gme_info_only = -1 };
/* Most recent warning string, or NULL if none. Clears current warning after returning.
Warning is also cleared when loading a file and starting a track. */
const char* gme_warning( Music_Emu* );
/* Load m3u playlist file (must be done after loading music) */
gme_err_t gme_load_m3u( Music_Emu*, const char path [] );
/* Clear any loaded m3u playlist and any internal playlist that the music format
supports (NSFE for example). */
void gme_clear_playlist( Music_Emu* );
/* Gets information for a particular track (length, name, author, etc.).
Must be freed after use. */
typedef struct gme_info_t gme_info_t;
gme_err_t gme_track_info( Music_Emu const*, gme_info_t** out, int track );
/* Frees track information */
void gme_free_info( gme_info_t* );
struct gme_info_t
{
/* times in milliseconds; -1 if unknown */
int length; /* total length, if file specifies it */
int intro_length; /* length of song up to looping section */
int loop_length; /* length of looping section */
/* Length if available, otherwise intro_length+loop_length*2 if available,
otherwise a default of 150000 (2.5 minutes). */
int play_length;
int i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15; /* reserved */
/* empty string ("") if not available */
const char* system;
const char* game;
const char* song;
const char* author;
const char* copyright;
const char* comment;
const char* dumper;
const char *s7,*s8,*s9,*s10,*s11,*s12,*s13,*s14,*s15; /* reserved */
};
/******** Advanced playback ********/
/* Adjust stereo echo depth, where 0.0 = off and 1.0 = maximum. Has no effect for
GYM, SPC, and Sega Genesis VGM music */
void gme_set_stereo_depth( Music_Emu*, double depth );
/* Disable automatic end-of-track detection and skipping of silence at beginning
if ignore is true */
void gme_ignore_silence( Music_Emu*, int ignore );
/* Adjust song tempo, where 1.0 = normal, 0.5 = half speed, 2.0 = double speed.
Track length as returned by track_info() assumes a tempo of 1.0. */
void gme_set_tempo( Music_Emu*, double tempo );
/* Number of voices used by currently loaded file */
int gme_voice_count( Music_Emu const* );
/* Name of voice i, from 0 to gme_voice_count() - 1 */
const char* gme_voice_name( Music_Emu const*, int i );
/* Mute/unmute voice i, where voice 0 is first voice */
void gme_mute_voice( Music_Emu*, int index, int mute );
/* Set muting state of all voices at once using a bit mask, where -1 mutes all
voices, 0 unmutes them all, 0x01 mutes just the first voice, etc. */
void gme_mute_voices( Music_Emu*, int muting_mask );
/* Frequency equalizer parameters (see gme.txt) */
+/* Implementers: If modified, also adjust Music_Emu::make_equalizer as needed */
typedef struct gme_equalizer_t
{
double treble; /* -50.0 = muffled, 0 = flat, +5.0 = extra-crisp */
double bass; /* 1 = full bass, 90 = average, 16000 = almost no bass */
double d2,d3,d4,d5,d6,d7,d8,d9; /* reserved */
} gme_equalizer_t;
/* Get current frequency equalizater parameters */
void gme_equalizer( Music_Emu const*, gme_equalizer_t* out );
/* Change frequency equalizer parameters */
void gme_set_equalizer( Music_Emu*, gme_equalizer_t const* eq );
+/* Enables/disables most accurate sound emulation options */
+void gme_enable_accuracy( Music_Emu*, int enabled );
/******** Game music types ********/
/* Music file type identifier. Can also hold NULL. */
typedef const struct gme_type_t_* gme_type_t;
/* Emulator type constants for each supported file type */
extern const gme_type_t
gme_ay_type,
gme_gbs_type,
gme_gym_type,
gme_hes_type,
gme_kss_type,
gme_nsf_type,
gme_nsfe_type,
gme_sap_type,
gme_spc_type,
gme_vgm_type,
gme_vgz_type;
/* Type of this emulator */
gme_type_t gme_type( Music_Emu const* );
/* Pointer to array of all music types, with NULL entry at end. Allows a player linked
to this library to support new music types without having to be updated. */
gme_type_t const* gme_type_list();
/* Name of game system for this music file type */
const char* gme_type_system( gme_type_t );
/* True if this music file type supports multiple tracks */
int gme_type_multitrack( gme_type_t );
+/* whether the pcm output retrieved by gme_play() will have all 8 voices rendered to their
+ * individual stereo channel or (if false) these voices get mixed into one single stereo channel
+ * @since 0.6.2 */
+int gme_multi_channel( Music_Emu const* );
/******** Advanced file loading ********/
/* Error returned if file type is not supported */
extern const char* const gme_wrong_file_type;
-/* Same as gme_open_file(), but uses file data already in memory. Makes copy of data. */
+/* Same as gme_open_file(), but uses file data already in memory. Makes copy of data.
+ * The resulting Music_Emu object will be set to single channel mode. */
gme_err_t gme_open_data( void const* data, long size, Music_Emu** out, int sample_rate );
/* Determine likely game music type based on first four bytes of file. Returns
string containing proper file suffix (i.e. "NSF", "SPC", etc.) or "" if
file header is not recognized. */
const char* gme_identify_header( void const* header );
/* Get corresponding music type for file path or extension passed in. */
gme_type_t gme_identify_extension( const char path_or_extension [] );
+/**
+ * Get typical file extension for a given music type. This is not a replacement
+ * for a file content identification library (but see gme_identify_header).
+ *
+ * @since 0.6.2
+ */
+const char* gme_type_extension( gme_type_t music_type );
+
/* Determine file type based on file's extension or header (if extension isn't recognized).
Sets *type_out to type, or 0 if unrecognized or error. */
gme_err_t gme_identify_file( const char path [], gme_type_t* type_out );
/* Create new emulator and set sample rate. Returns NULL if out of memory. If you only need
track information, pass gme_info_only for sample_rate. */
Music_Emu* gme_new_emu( gme_type_t, int sample_rate );
+/* Create new multichannel emulator and set sample rate. Returns NULL if out of memory.
+ * If you only need track information, pass gme_info_only for sample_rate.
+ * (see gme_multi_channel for more information on multichannel support)
+ * @since 0.6.2
+ */
+Music_Emu* gme_new_emu_multi_channel( gme_type_t, int sample_rate );
+
/* Load music file into emulator */
gme_err_t gme_load_file( Music_Emu*, const char path [] );
/* Load music file from memory into emulator. Makes a copy of data passed. */
gme_err_t gme_load_data( Music_Emu*, void const* data, long size );
/* Load music file using custom data reader function that will be called to
read file data. Most emulators load the entire file in one read call. */
typedef gme_err_t (*gme_reader_t)( void* your_data, void* out, int count );
gme_err_t gme_load_custom( Music_Emu*, gme_reader_t, long file_size, void* your_data );
/* Load m3u playlist file from memory (must be done after loading music) */
gme_err_t gme_load_m3u_data( Music_Emu*, void const* data, long size );
/******** User data ********/
/* Set/get pointer to data you want to associate with this emulator.
You can use this for whatever you want. */
void gme_set_user_data( Music_Emu*, void* new_user_data );
void* gme_user_data( Music_Emu const* );
/* Register cleanup function to be called when deleting emulator, or NULL to
clear it. Passes user_data to cleanup function. */
typedef void (*gme_user_cleanup_t)( void* user_data );
void gme_set_user_cleanup( Music_Emu*, gme_user_cleanup_t func );
#ifdef __cplusplus
}
#endif
#endif
diff --git a/src/libs/gme/gme_types.h b/src/libs/gme/gme_types.h
index 9427a53f..06226f4a 100644
--- a/src/libs/gme/gme_types.h
+++ b/src/libs/gme/gme_types.h
@@ -1,23 +1,21 @@
#ifndef GME_TYPES_H
#define GME_TYPES_H
-/* CMake will either define the following to 1, or #undef it,
- * depending on the options passed to CMake. This is used to
- * conditionally compile in the various emulator types.
- *
- * See gme_type_list() in gme.cpp
+/*
+ * This is a default gme_types.h for use when *not* using
+ * CMake. If CMake is in use gme_types.h.in will be
+ * processed instead.
*/
-
-#define USE_GME_AY 1
-#define USE_GME_GBS 1
-#define USE_GME_GYM 1
-#define USE_GME_HES 1
-#define USE_GME_KSS 1
-#define USE_GME_NSF 1
-#define USE_GME_NSFE 1
-#define USE_GME_SAP 1
-#define USE_GME_SPC 1
+#define USE_GME_AY
+#define USE_GME_GBS
+#define USE_GME_GYM
+#define USE_GME_HES
+#define USE_GME_KSS
+#define USE_GME_NSF
+#define USE_GME_NSFE
+#define USE_GME_SAP
+#define USE_GME_SPC
/* VGM and VGZ are a package deal */
-#define USE_GME_VGM 1
+#define USE_GME_VGM
#endif /* GME_TYPES_H */

File Metadata

Mime Type
text/x-diff
Expires
Wed, Jun 17, 9:32 PM (1 w, 5 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
72334
Default Alt Text
(781 KB)

Event Timeline