1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/Makefile	Fri Oct 21 05:53:11 2011 -0700
     1.3 @@ -0,0 +1,11 @@
     1.4 +spc_record: 
     1.5 +
     1.6 +
     1.7 +whatever : snes_spc/SNES_SPC.cpp
     1.8 +	g++ -c snes_spc/*.cpp
     1.9 +
    1.10 +
    1.11 +
    1.12 +clean: 
    1.13 +	find . \( -name "*.o" -print0 \) -o \
    1.14 +               \( -name "spc" -print0 \) | xargs -t -0 rm
    1.15 \ No newline at end of file

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/changes.txt	Fri Oct 21 05:53:11 2011 -0700
     2.3 @@ -0,0 +1,107 @@
     2.4 +snes_spc Change Log
     2.5 +-------------------
     2.6 +
     2.7 +snes_spc 0.9.0
     2.8 +--------------
     2.9 +- Improved documentation
    2.10 +
    2.11 +- SPC: Added spc_skip() function for quickly seeking in an SPC music
    2.12 +file. Runs 3-4x faster than normal playback using the fast DSP (or about
    2.13 +43-60X real-time on my 400 MHz Mac).
    2.14 +
    2.15 +- SPC: Added spc_set_tempo() to change tempo of SPC music playback.
    2.16 +
    2.17 +- SPC: Sample generation is now corrected to generate exactly one pair
    2.18 +of samples every 32 clocks without exception. Before it could generate a
    2.19 +few samples more or less depending on how far ahead or behind DSP was at
    2.20 +the moment.
    2.21 +
    2.22 +- SPC: Changed spc_reset() and spc_soft_reset() to also reset output
    2.23 +buffer (see spc.h).
    2.24 +
    2.25 +- SPC: Fixed minor timer counting bug.
    2.26 +
    2.27 +- SPC: Stack pointer wrap-around is now emulated (and without any
    2.28 +noticeable performance hit).
    2.29 +
    2.30 +- SPC: Runs about 5% faster due to various optimizations.
    2.31 +
    2.32 +- SPC: Found way to make fast DSP register accesses cycle-accurate in
    2.33 +most cases, without reducing performance. Allows fast DSP to pass most
    2.34 +of my validation tests.
    2.35 +
    2.36 +- DSP: Added surround disable support to fast DSP again.
    2.37 +
    2.38 +- DSP: Improved voice un-muting to take effect immediately on fast DSP.
    2.39 +
    2.40 +- DSP: Noise shift register now starts at 0x4000 instead of 0x4001 as it
    2.41 +incorrectly did before.
    2.42 +
    2.43 +- Converted library to C++ code internally. A C interface is still
    2.44 +included in spc.h and dsp.h. Note that these are different than the
    2.45 +previous interface, so your code will require minor changes:
    2.46 +
    2.47 +	Old SPC code                            New SPC code
    2.48 +	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    2.49 +	#include "spc/spc.h"                    #include "snes_spc/spc.h"
    2.50 +
    2.51 +	snes_spc_t* spc;                        SNES_SPC* spc;
    2.52 +	spc = malloc( sizeof (snes_spc_t) );    spc = spc_new();
    2.53 +	spc_init( spc );
    2.54 +	
    2.55 +	spc_end_frame( time );                  spc_end_frame( spc, time );
    2.56 +	/* etc. */
    2.57 +	
    2.58 +	/* done using SPC */                    spc_delete( spc );
    2.59 +	
    2.60 +	
    2.61 +	Old DSP code                            New DSP code
    2.62 +	- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    2.63 +	#include "spc/spc_dsp.h"                #include "snes_spc/dsp.h"
    2.64 +	
    2.65 +	spc_dsp_init( ram );                    SPC_DSP* dsp;
    2.66 +											dsp = spc_dsp_new();
    2.67 +											spc_dsp_init( dsp, ram );
    2.68 +	
    2.69 +	spc_dsp_run( count );                   spc_dsp_run( dsp, count );
    2.70 +	/* etc. */
    2.71 +	
    2.72 +	/* done using DSP */                    spc_dsp_delete( dsp );
    2.73 +	
    2.74 +
    2.75 +snes_spc 0.8.0
    2.76 +--------------
    2.77 +- Added several demos
    2.78 +
    2.79 +- Added high-pass/low-pass filter to better match SNES sound
    2.80 +
    2.81 +- Added save state functionality for SPC and accurate DSP (but not fast
    2.82 +DSP)
    2.83 +
    2.84 +- Added emulation of reset switch on NES (soft reset)
    2.85 +
    2.86 +- Made source more compatible with pre-C99 compilers by eliminating
    2.87 +mid-block declarations
    2.88 +
    2.89 +- SPC: Many S-SMP accuracy improvements, mostly in memory access times
    2.90 +
    2.91 +- SPC: S-SMP speed improvements
    2.92 +
    2.93 +- SPC: Added SPC load/save functions and KON checking to help trim
    2.94 +silence from beginning
    2.95 +
    2.96 +- SPC: Changed spc_init() to have you allocate most of the memory used
    2.97 +by the library so you have more control over it
    2.98 +
    2.99 +- DSP: New highly accurate DSP and faster version derived from same code
   2.100 +
   2.101 +- DSP: Changed prefix from dsp_ to spc_dsp_. Your DSP code will require
   2.102 +changes.
   2.103 +
   2.104 +- DSP: Removed surround disable and gain. Gain can now be done with the
   2.105 +dsp_filter module, and surround disable will probably only be
   2.106 +implemented in the fast DSP at some point.
   2.107 +
   2.108 +- DSP: Changed interface to work in clocks rather than samples,
   2.109 +necessary for the new accurate DSP. Sample output is now done with
   2.110 +separate functions. Your DSP code will require changes.

     3.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.2 +++ b/demo/benchmark.c	Fri Oct 21 05:53:11 2011 -0700
     3.3 @@ -0,0 +1,58 @@
     3.4 +/* Measures performance of SPC emulator. Takes about 4 seconds.
     3.5 +NOTE: This assumes that the program is getting all processor time; you might need to
     3.6 +arrange for this or else the performance will be reported lower than it really is.
     3.7 +
     3.8 +Usage: benchmark [test.spc]
     3.9 +*/
    3.10 +
    3.11 +#include "snes_spc/spc.h"
    3.12 +
    3.13 +#include "demo_util.h" /* error(), load_file() */
    3.14 +#include <time.h>
    3.15 +
    3.16 +clock_t start_timing( int seconds );
    3.17 +
    3.18 +int main( int argc, char** argv )
    3.19 +{
    3.20 +	/* Load SPC */
    3.21 +	long spc_size;
    3.22 +	void* spc = load_file( (argc > 1) ? argv [1] : "test.spc", &spc_size );
    3.23 +	SNES_SPC* snes_spc = spc_new();
    3.24 +	if ( !snes_spc ) error( "Out of memory" );
    3.25 +	spc_load_spc( snes_spc, spc, spc_size );
    3.26 +	free( spc );
    3.27 +	
    3.28 +	{
    3.29 +		/* Repeatedly fill buffer for 4 seconds */
    3.30 +		int const seconds = 4;
    3.31 +		#define BUF_SIZE 4096
    3.32 +		clock_t end = start_timing( seconds );
    3.33 +		int count = 0;
    3.34 +		while ( clock() < end )
    3.35 +		{
    3.36 +			static short buf [BUF_SIZE];
    3.37 +			error( spc_play( snes_spc, BUF_SIZE, buf ) );
    3.38 +			count++;
    3.39 +		}
    3.40 +		
    3.41 +		/* Report performance based on how many buffer fills were possible */
    3.42 +		{
    3.43 +			double rate = (double) count * BUF_SIZE / (spc_sample_rate * 2 * seconds);
    3.44 +			printf( "Performance: %.3fx real-time, or %.0f%% CPU for normal rate\n",
    3.45 +					rate, 100.0 / rate );
    3.46 +		}
    3.47 +	}
    3.48 +	
    3.49 +	return 0;
    3.50 +}
    3.51 +
    3.52 +/* Synchronizes with host clock and returns clock() time that is duration seconds from now */
    3.53 +clock_t start_timing( int duration )
    3.54 +{
    3.55 +	clock_t clock_dur = duration * CLOCKS_PER_SEC;
    3.56 +	clock_t time = clock();
    3.57 +	while ( clock() == time ) { }
    3.58 +	if ( clock() - time > clock_dur )
    3.59 +		error( "Insufficient clock() time resolution" );
    3.60 +	return clock() + clock_dur;
    3.61 +}

     4.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     4.2 +++ b/demo/comm.c	Fri Oct 21 05:53:11 2011 -0700
     4.3 @@ -0,0 +1,70 @@
     4.4 +/* Communicates with SPC the way the SNES would.
     4.5 +
     4.6 +Note: You'll need an "spc_rom.h" file that contains the 64-byte IPL ROM contents */
     4.7 +
     4.8 +#include "snes_spc/spc.h"
     4.9 +
    4.10 +#include "demo_util.h"
    4.11 +#include <string.h>
    4.12 +#include <stdio.h>
    4.13 +
    4.14 +static SNES_SPC* snes_spc;
    4.15 +
    4.16 +/* Make port access more convenient. Fakes time by simply incrementing it each call. */
    4.17 +static spc_time_t stime;
    4.18 +static int  pread ( int port )           { return spc_read_port( snes_spc, stime++, port ); }
    4.19 +static void pwrite( int port, int data ) { spc_write_port( snes_spc, stime++, port, data ); }
    4.20 +
    4.21 +static unsigned char const spc_rom [spc_rom_size] = {
    4.22 +	/* ROM data not provided with emulator */
    4.23 +	#include "spc_rom.h"
    4.24 +};
    4.25 +
    4.26 +int main()
    4.27 +{
    4.28 +	int i;
    4.29 +	
    4.30 +	/* Data to upload */
    4.31 +	static unsigned char const data [4] = "\xFA\xDE\xD1";
    4.32 +	unsigned const data_addr = 0xF5; /* second I/O port */
    4.33 +	
    4.34 +	snes_spc = spc_new();
    4.35 +	if ( !snes_spc ) error( "Out of memory" );
    4.36 +	spc_init_rom( snes_spc, spc_rom );
    4.37 +	spc_reset( snes_spc );
    4.38 +	
    4.39 +	/* Simulate reads and writes that SNES code would do */
    4.40 +	
    4.41 +	/* Wait for SPC to be ready */
    4.42 +	while ( pread( 0 ) != 0xAA || pread( 1 ) != 0xBB ) { }
    4.43 +	
    4.44 +	/* Start address */
    4.45 +	pwrite( 2, data_addr & 0xFF );
    4.46 +	pwrite( 3, data_addr >> 8 );
    4.47 +	
    4.48 +	/* Tell SPC to start transfer and wait for acknowledgement */
    4.49 +	pwrite( 0, 0xCC );
    4.50 +	pwrite( 1, 0x01 );
    4.51 +	while ( pread( 0 ) != 0xCC ) { }
    4.52 +	
    4.53 +	/* Send each byte and wait for acknowledgement */
    4.54 +	for ( i = 0; i < 4; i++ )
    4.55 +	{
    4.56 +		printf( "%02X ", data [i] );
    4.57 +		pwrite( 1, data [i] );
    4.58 +		pwrite( 0, i );
    4.59 +		while ( pread( 0 ) != i ) { }
    4.60 +	}
    4.61 +	printf( "\n" );
    4.62 +	
    4.63 +	/* Verify that data was transferred properly */
    4.64 +	for ( i = 0; i < 3; i++ )
    4.65 +		printf( "%02X ", pread( i + 1 ) );
    4.66 +	printf( "\n" );
    4.67 +	
    4.68 +	printf( "Cycles: %ld\n", (long) stime );
    4.69 +	
    4.70 +	spc_delete( snes_spc );
    4.71 +	
    4.72 +	return 0;
    4.73 +}

     5.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     5.2 +++ b/demo/demo_util.c	Fri Oct 21 05:53:11 2011 -0700
     5.3 @@ -0,0 +1,57 @@
     5.4 +#include "demo_util.h"
     5.5 +
     5.6 +#include <assert.h>
     5.7 +#include <string.h>
     5.8 +#include <stdlib.h>
     5.9 +#include <stdio.h>
    5.10 +
    5.11 +/* Copyright (C) 2007 Shay Green. This module is free software; you
    5.12 +can redistribute it and/or modify it under the terms of the GNU Lesser
    5.13 +General Public License as published by the Free Software Foundation; either
    5.14 +version 2.1 of the License, or (at your option) any later version. This
    5.15 +module is distributed in the hope that it will be useful, but WITHOUT ANY
    5.16 +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    5.17 +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    5.18 +details. You should have received a copy of the GNU Lesser General Public
    5.19 +License along with this module; if not, write to the Free Software Foundation,
    5.20 +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
    5.21 +
    5.22 +unsigned char* load_file( const char* path, long* size_out )
    5.23 +{
    5.24 +	size_t size;
    5.25 +	unsigned char* data;
    5.26 +	
    5.27 +	FILE* in = fopen( path, "rb" );
    5.28 +	if ( !in ) error( "Couldn't open file" );
    5.29 +	
    5.30 +	fseek( in, 0, SEEK_END );
    5.31 +	size = ftell( in );
    5.32 +	if ( size_out )
    5.33 +		*size_out = size;
    5.34 +	rewind( in );
    5.35 +	
    5.36 +	data = (unsigned char*) malloc( size );
    5.37 +	if ( !data ) error( "Out of memory" );
    5.38 +	
    5.39 +	if ( fread( data, 1, size, in ) < size ) error( "Couldn't read file" );
    5.40 +	fclose( in );
    5.41 +	
    5.42 +	return data;
    5.43 +}
    5.44 +
    5.45 +void write_file( const char* path, void const* in, long size )
    5.46 +{
    5.47 +	FILE* out = fopen( path, "wb" );
    5.48 +	if ( !out ) error( "Couldn't create file" );
    5.49 +	if ( (long) fwrite( in, 1, size, out ) < size ) error( "Couldn't write file" );
    5.50 +	fclose( out );
    5.51 +}
    5.52 +
    5.53 +void error( const char* str )
    5.54 +{
    5.55 +	if ( str )
    5.56 +	{
    5.57 +		fprintf( stderr, "Error: %s\n", str );
    5.58 +		exit( EXIT_FAILURE );
    5.59 +	}
    5.60 +}

     6.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     6.2 +++ b/demo/demo_util.h	Fri Oct 21 05:53:11 2011 -0700
     6.3 @@ -0,0 +1,31 @@
     6.4 +/* General-purpose utilities used by demos */
     6.5 +
     6.6 +/* snes_spc 0.9.0 */
     6.7 +#ifndef DEMO_UTIL_H
     6.8 +#define DEMO_UTIL_H
     6.9 +
    6.10 +/* commonly used headers */
    6.11 +#include <assert.h>
    6.12 +#include <stdlib.h>
    6.13 +#include <string.h>
    6.14 +#include <stdio.h>
    6.15 +
    6.16 +#ifdef __cplusplus
    6.17 +	extern "C" {
    6.18 +#endif
    6.19 +
    6.20 +/* If str is not NULL, prints it and exits program, otherwise returns */
    6.21 +void error( const char* str );
    6.22 +
    6.23 +/* Loads file and returns pointer to data in memory, allocated with malloc().
    6.24 +If size_out != NULL, sets *size_out to size of data. */
    6.25 +unsigned char* load_file( const char* path, long* size_out );
    6.26 +
    6.27 +/* Writes data to file */
    6.28 +void write_file( const char* path, void const* in, long size );
    6.29 +
    6.30 +#ifdef __cplusplus
    6.31 +	}
    6.32 +#endif
    6.33 +
    6.34 +#endif

     7.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     7.2 +++ b/demo/play_spc.c	Fri Oct 21 05:53:11 2011 -0700
     7.3 @@ -0,0 +1,57 @@
     7.4 +/* Records SPC into wave file. Uses dsp_filter to give more authentic sound.
     7.5 +
     7.6 +Usage: play_spc [test.spc]
     7.7 +*/
     7.8 +
     7.9 +#include "snes_spc/spc.h"
    7.10 +
    7.11 +#include "wave_writer.h"
    7.12 +#include "demo_util.h" /* error(), load_file() */
    7.13 +
    7.14 +int main( int argc, char** argv )
    7.15 +{
    7.16 +	/* Create emulator and filter */
    7.17 +	SNES_SPC* snes_spc = spc_new();
    7.18 +	SPC_Filter* filter = spc_filter_new();
    7.19 +	if ( !snes_spc || !filter ) error( "Out of memory" );
    7.20 +	
    7.21 +	/* Load SPC */
    7.22 +	{
    7.23 +		/* Load file into memory */
    7.24 +		long spc_size;
    7.25 +		void* spc = load_file( (argc > 1) ? argv [1] : "test.spc", &spc_size );
    7.26 +		
    7.27 +		/* Load SPC data into emulator */
    7.28 +		error( spc_load_spc( snes_spc, spc, spc_size ) );
    7.29 +		free( spc ); /* emulator makes copy of data */
    7.30 +		
    7.31 +		/* Most SPC files have garbage data in the echo buffer, so clear that */
    7.32 +		spc_clear_echo( snes_spc );
    7.33 +		
    7.34 +		/* Clear filter before playing */
    7.35 +		spc_filter_clear( filter );
    7.36 +	}
    7.37 +	
    7.38 +	/* Record 20 seconds to wave file */
    7.39 +	wave_open( spc_sample_rate, "out.wav" );
    7.40 +	wave_enable_stereo();
    7.41 +	while ( wave_sample_count() < 20 * spc_sample_rate * 2 )
    7.42 +	{
    7.43 +		/* Play into buffer */
    7.44 +		#define BUF_SIZE 2048
    7.45 +		short buf [BUF_SIZE];
    7.46 +		error( spc_play( snes_spc, BUF_SIZE, buf ) );
    7.47 +		
    7.48 +		/* Filter samples */
    7.49 +		spc_filter_run( filter, buf, BUF_SIZE );
    7.50 +		
    7.51 +		wave_write( buf, BUF_SIZE );
    7.52 +	}
    7.53 +	
    7.54 +	/* Cleanup */
    7.55 +	spc_filter_delete( filter );
    7.56 +	spc_delete( snes_spc );
    7.57 +	wave_close();
    7.58 +	
    7.59 +	return 0;
    7.60 +}

     8.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     8.2 +++ b/demo/save_state.c	Fri Oct 21 05:53:11 2011 -0700
     8.3 @@ -0,0 +1,107 @@
     8.4 +/* Loads "test.spc", skips 5 seconds, saves exact emulator state to "state.bin",
     8.5 +hen records 5 seconds to "first.wav". When run again, loads this state back into
     8.6 +emulator and records 5 seconds to "second.wav". These two wave files should
     8.7 +be identical.
     8.8 +
     8.9 +Usage: save_state [test.spc]
    8.10 +*/
    8.11 +
    8.12 +#include "snes_spc/spc.h"
    8.13 +
    8.14 +#include "wave_writer.h"
    8.15 +#include "demo_util.h" /* error(), load_file() */
    8.16 +
    8.17 +static SNES_SPC* snes_spc;
    8.18 +
    8.19 +void record_wav( const char* path, int secs )
    8.20 +{
    8.21 +	/* Start writing wave file */
    8.22 +	wave_open( spc_sample_rate, path );
    8.23 +	wave_enable_stereo();
    8.24 +	while ( wave_sample_count() < secs * spc_sample_rate * 2 )
    8.25 +	{
    8.26 +		/* Play into buffer */
    8.27 +		#define BUF_SIZE 2048
    8.28 +		short buf [BUF_SIZE];
    8.29 +		error( spc_play( snes_spc, BUF_SIZE, buf ) );
    8.30 +		
    8.31 +		wave_write( buf, BUF_SIZE );
    8.32 +	}
    8.33 +	wave_close();
    8.34 +}
    8.35 +
    8.36 +void state_save( unsigned char** out, void* in, size_t size )
    8.37 +{
    8.38 +	memcpy( *out, in, size );
    8.39 +	*out += size;
    8.40 +}
    8.41 +
    8.42 +void make_save_state( const char* path )
    8.43 +{
    8.44 +	/* Load SPC */
    8.45 +	long spc_size;
    8.46 +	void* spc = load_file( path, &spc_size );
    8.47 +	error( spc_load_spc( snes_spc, spc, spc_size ) );
    8.48 +	free( spc );
    8.49 +	spc_clear_echo( snes_spc );
    8.50 +	
    8.51 +	/* Skip several seconds */
    8.52 +	error( spc_play( snes_spc, 5 * spc_sample_rate * 2, 0 ) );
    8.53 +	
    8.54 +	/* Save state to file */
    8.55 +	{
    8.56 +		static unsigned char state [spc_state_size]; /* buffer large enough for data */
    8.57 +		unsigned char* out = state;
    8.58 +		spc_copy_state( snes_spc, &out, state_save );
    8.59 +		write_file( "state.bin", state, out - state );
    8.60 +	}
    8.61 +	
    8.62 +	record_wav( "first.wav", 5 );
    8.63 +}
    8.64 +
    8.65 +void state_load( unsigned char** in, void* out, size_t size )
    8.66 +{
    8.67 +	memcpy( out, *in, size );
    8.68 +	*in += size;
    8.69 +}
    8.70 +
    8.71 +void use_save_state()
    8.72 +{
    8.73 +	/* Load state into memory */
    8.74 +	long state_size;
    8.75 +	unsigned char* state = load_file( "state.bin", &state_size );
    8.76 +	
    8.77 +	/* Load into emulator */
    8.78 +	unsigned char* in = state;
    8.79 +	spc_copy_state( snes_spc, &in, state_load );
    8.80 +	assert( in  - state <= state_size ); /* be sure it didn't read past end */
    8.81 +	
    8.82 +	record_wav( "second.wav", 5 );
    8.83 +}
    8.84 +
    8.85 +int file_exists( const char* path )
    8.86 +{
    8.87 +	FILE* file = fopen( path, "rb" );
    8.88 +	if ( !file )
    8.89 +		return 0;
    8.90 +	
    8.91 +	fclose( file );
    8.92 +	return 1;
    8.93 +}
    8.94 +
    8.95 +int main( int argc, char** argv )
    8.96 +{
    8.97 +	snes_spc = spc_new();
    8.98 +	if ( !snes_spc ) error( "Out of memory" );
    8.99 +	
   8.100 +	/* Make new state if it doesn't exist, otherwise load it and
   8.101 +	record to wave file */
   8.102 +	if ( !file_exists( "state.bin" ) )
   8.103 +		make_save_state( (argc > 1) ? argv [1] : "test.spc" );
   8.104 +	else
   8.105 +		use_save_state();
   8.106 +	
   8.107 +	spc_delete( snes_spc );
   8.108 +	
   8.109 +	return 0;
   8.110 +}

     9.1 Binary file demo/spc_record has changed

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/demo/trim_spc.c	Fri Oct 21 05:53:11 2011 -0700
    10.3 @@ -0,0 +1,83 @@
    10.4 +/* Trims silence off beginning of SPC file.
    10.5 +Requires the accurate DSP; won't compile with the fast DSP.
    10.6 +Please note that the algorithm could be improved; this is just
    10.7 +a simple example showing the idea.
    10.8 +
    10.9 +Usage: trim_spc [test.spc [trimmed.spc]]
   10.10 +*/
   10.11 +
   10.12 +#include "snes_spc/spc.h"
   10.13 +
   10.14 +#include "demo_util.h" /* error(), load_file() */
   10.15 +
   10.16 +/* Change to 1 to have it trim to next key on event rather than trim silence */
   10.17 +enum { use_kon_check = 0 };
   10.18 +
   10.19 +/* True if all count samples from in are silent (or very close to it) */
   10.20 +int is_silent( short const* in, int count );
   10.21 +
   10.22 +int main( int argc, char** argv )
   10.23 +{
   10.24 +	/* Load file into memory */
   10.25 +	long spc_size;
   10.26 +	void* spc = load_file( (argc > 1) ? argv [1] : "test.spc", &spc_size );
   10.27 +	
   10.28 +	/* Load into emulator */
   10.29 +	SNES_SPC* snes_spc = spc_new();
   10.30 +	if ( !snes_spc ) error( "Out of memory" );
   10.31 +	error( spc_load_spc( snes_spc, spc, spc_size ) );
   10.32 +	
   10.33 +	/* Expand SPC data so there's enough room for emulator to save to.
   10.34 +	We simply overwrite the emulator data in the old SPC file rather
   10.35 +	than creating new SPC data. This preserves the text tags from
   10.36 +	the old file. */
   10.37 +	if ( spc_size < spc_file_size )
   10.38 +	{
   10.39 +		spc_size = spc_file_size;
   10.40 +		spc = realloc( spc, spc_size ); /* leaks memory if allocation fails */
   10.41 +		if ( !spc ) error( "Out of memory" );
   10.42 +	}
   10.43 +	
   10.44 +	/* Keep saving SPC, then playing a little more. Once SPC becomes non-silent,
   10.45 +	write the SPC data saved just before this. */
   10.46 +	{
   10.47 +		long samples_trimmed = 0;
   10.48 +		while ( 1 )
   10.49 +		{
   10.50 +			#define BUF_SIZE 1024
   10.51 +			short buf [BUF_SIZE];
   10.52 +			
   10.53 +			if ( samples_trimmed > 10 * spc_sample_rate * 2 )
   10.54 +				error( "Excess silence found" );
   10.55 +			
   10.56 +			spc_clear_echo( snes_spc );
   10.57 +			spc_save_spc( snes_spc, spc );
   10.58 +			
   10.59 +			/* Fill buffer */
   10.60 +			error( spc_play( snes_spc, BUF_SIZE, buf ) );
   10.61 +			samples_trimmed += BUF_SIZE;
   10.62 +			
   10.63 +			/* See if SPC became non-silent */
   10.64 +			if ( use_kon_check ? spc_check_kon( snes_spc ) : !is_silent( buf, BUF_SIZE ) )
   10.65 +				break;
   10.66 +		}
   10.67 +		
   10.68 +		printf( "Trimmed %.1f seconds\n", (double) samples_trimmed / spc_sample_rate / 2 );
   10.69 +	}
   10.70 +	
   10.71 +	spc_delete( snes_spc );
   10.72 +	write_file( (argc > 2) ? argv [2] : "trimmed.spc", spc, spc_size );
   10.73 +	
   10.74 +	return 0;
   10.75 +}
   10.76 +
   10.77 +int is_silent( short const* in, int count )
   10.78 +{
   10.79 +	unsigned const threshold = 0x10;
   10.80 +	while ( count-- )
   10.81 +	{
   10.82 +		if ( (unsigned) (*in++ + threshold / 2) > threshold )
   10.83 +			return 0;
   10.84 +	}
   10.85 +	return 1;
   10.86 +}

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/demo/wave_writer.c	Fri Oct 21 05:53:11 2011 -0700
    11.3 @@ -0,0 +1,153 @@
    11.4 +/* snes_spc 0.9.0. http://www.slack.net/~ant/ */
    11.5 +
    11.6 +#include "wave_writer.h"
    11.7 +
    11.8 +#include <assert.h>
    11.9 +#include <stdlib.h>
   11.10 +#include <stdio.h>
   11.11 +
   11.12 +/* Copyright (C) 2003-2007 Shay Green. This module is free software; you
   11.13 +can redistribute it and/or modify it under the terms of the GNU Lesser
   11.14 +General Public License as published by the Free Software Foundation; either
   11.15 +version 2.1 of the License, or (at your option) any later version. This
   11.16 +module is distributed in the hope that it will be useful, but WITHOUT ANY
   11.17 +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   11.18 +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   11.19 +details. You should have received a copy of the GNU Lesser General Public
   11.20 +License along with this module; if not, write to the Free Software Foundation,
   11.21 +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
   11.22 +
   11.23 +enum { buf_size = 32768 * 2 };
   11.24 +enum { header_size = 0x2C };
   11.25 +
   11.26 +typedef short sample_t;
   11.27 +
   11.28 +static unsigned char* buf;
   11.29 +static FILE* file;
   11.30 +static long  sample_count_;
   11.31 +static long  sample_rate_;
   11.32 +static long  buf_pos;
   11.33 +static int   chan_count;
   11.34 +
   11.35 +static void exit_with_error( const char* str )
   11.36 +{
   11.37 +	printf( "Error: %s\n", str ); getchar();
   11.38 +	exit( EXIT_FAILURE );
   11.39 +}
   11.40 +
   11.41 +void wave_open( long sample_rate, const char* filename )
   11.42 +{
   11.43 +	sample_count_ = 0;
   11.44 +	sample_rate_  = sample_rate;
   11.45 +	buf_pos       = header_size;
   11.46 +	chan_count    = 1;
   11.47 +	
   11.48 +	buf = (unsigned char*) malloc( buf_size * sizeof *buf );
   11.49 +	if ( !buf )
   11.50 +		exit_with_error( "Out of memory" );
   11.51 +	
   11.52 +	file = fopen( filename, "wb" );
   11.53 +	if ( !file )
   11.54 +		exit_with_error( "Couldn't open WAVE file for writing" );
   11.55 +	
   11.56 +	setvbuf( file, 0, _IOFBF, 32 * 1024L );
   11.57 +}
   11.58 +
   11.59 +void wave_enable_stereo( void )
   11.60 +{
   11.61 +	chan_count = 2;
   11.62 +}
   11.63 +
   11.64 +static void flush_()
   11.65 +{
   11.66 +	if ( buf_pos && !fwrite( buf, buf_pos, 1, file ) )
   11.67 +		exit_with_error( "Couldn't write WAVE data" );
   11.68 +	buf_pos = 0;
   11.69 +}
   11.70 +
   11.71 +void wave_write( short const* in, long remain )
   11.72 +{
   11.73 +	sample_count_ += remain;
   11.74 +	while ( remain )
   11.75 +	{
   11.76 +		if ( buf_pos >= buf_size )
   11.77 +			flush_();
   11.78 +		
   11.79 +		{
   11.80 +			unsigned char* p = &buf [buf_pos];
   11.81 +			long n = (buf_size - buf_pos) / sizeof (sample_t);
   11.82 +			if ( n > remain )
   11.83 +				n = remain;
   11.84 +			remain -= n;
   11.85 +			
   11.86 +			/* convert to LSB first format */
   11.87 +			while ( n-- )
   11.88 +			{
   11.89 +				int s = *in++;
   11.90 +				*p++ = (unsigned char) s;
   11.91 +				*p++ = (unsigned char) (s >> 8);
   11.92 +			}
   11.93 +			
   11.94 +			buf_pos = p - buf;
   11.95 +			assert( buf_pos <= buf_size );
   11.96 +		}
   11.97 +	}
   11.98 +}
   11.99 +
  11.100 +long wave_sample_count( void )
  11.101 +{
  11.102 +	return sample_count_;
  11.103 +}
  11.104 +
  11.105 +static void set_le32( void* p, unsigned long n )
  11.106 +{
  11.107 +	((unsigned char*) p) [0] = (unsigned char) n;
  11.108 +	((unsigned char*) p) [1] = (unsigned char) (n >> 8);
  11.109 +	((unsigned char*) p) [2] = (unsigned char) (n >> 16);
  11.110 +	((unsigned char*) p) [3] = (unsigned char) (n >> 24);
  11.111 +}
  11.112 +
  11.113 +void wave_close( void )
  11.114 +{
  11.115 +	if ( file )
  11.116 +	{
  11.117 +		/* generate header */
  11.118 +		unsigned char h [header_size] =
  11.119 +		{
  11.120 +			'R','I','F','F',
  11.121 +			0,0,0,0,        /* length of rest of file */
  11.122 +			'W','A','V','E',
  11.123 +			'f','m','t',' ',
  11.124 +			0x10,0,0,0,     /* size of fmt chunk */
  11.125 +			1,0,            /* uncompressed format */
  11.126 +			0,0,            /* channel count */
  11.127 +			0,0,0,0,        /* sample rate */
  11.128 +			0,0,0,0,        /* bytes per second */
  11.129 +			0,0,            /* bytes per sample frame */
  11.130 +			16,0,           /* bits per sample */
  11.131 +			'd','a','t','a',
  11.132 +			0,0,0,0,        /* size of sample data */
  11.133 +			/* ... */       /* sample data */
  11.134 +		};
  11.135 +		long ds = sample_count_ * sizeof (sample_t);
  11.136 +		int frame_size = chan_count * sizeof (sample_t);
  11.137 +		
  11.138 +		set_le32( h + 0x04, header_size - 8 + ds );
  11.139 +		h [0x16] = chan_count;
  11.140 +		set_le32( h + 0x18, sample_rate_ );
  11.141 +		set_le32( h + 0x1C, sample_rate_ * frame_size );
  11.142 +		h [0x20] = frame_size;
  11.143 +		set_le32( h + 0x28, ds );
  11.144 +		
  11.145 +		flush_();
  11.146 +		
  11.147 +		/* write header */
  11.148 +		fseek( file, 0, SEEK_SET );
  11.149 +		fwrite( h, sizeof h, 1, file );
  11.150 +		
  11.151 +		fclose( file );
  11.152 +		file = 0;
  11.153 +		free( buf );
  11.154 +		buf = 0;
  11.155 +	}
  11.156 +}

    12.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    12.2 +++ b/demo/wave_writer.h	Fri Oct 21 05:53:11 2011 -0700
    12.3 @@ -0,0 +1,20 @@
    12.4 +/* WAVE sound file writer for recording 16-bit output during program development */
    12.5 +
    12.6 +#ifndef WAVE_WRITER_H
    12.7 +#define WAVE_WRITER_H
    12.8 +
    12.9 +#ifdef __cplusplus
   12.10 +	extern "C" {
   12.11 +#endif
   12.12 +
   12.13 +void wave_open( long sample_rate, const char* filename );
   12.14 +void wave_enable_stereo( void );
   12.15 +void wave_write( short const* in, long count );
   12.16 +long wave_sample_count( void );
   12.17 +void wave_close( void );
   12.18 +
   12.19 +#ifdef __cplusplus
   12.20 +	}
   12.21 +#endif
   12.22 +
   12.23 +#endif

    13.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    13.2 +++ b/fast_dsp/SPC_DSP.cpp	Fri Oct 21 05:53:11 2011 -0700
    13.3 @@ -0,0 +1,703 @@
    13.4 +// snes_spc 0.9.0. http://www.slack.net/~ant/
    13.5 +
    13.6 +#include "SPC_DSP.h"
    13.7 +
    13.8 +#include "blargg_endian.h"
    13.9 +#include <string.h>
   13.10 +
   13.11 +/* Copyright (C) 2007 Shay Green. This module is free software; you
   13.12 +can redistribute it and/or modify it under the terms of the GNU Lesser
   13.13 +General Public License as published by the Free Software Foundation; either
   13.14 +version 2.1 of the License, or (at your option) any later version. This
   13.15 +module is distributed in the hope that it will be useful, but WITHOUT ANY
   13.16 +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   13.17 +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   13.18 +details. You should have received a copy of the GNU Lesser General Public
   13.19 +License along with this module; if not, write to the Free Software Foundation,
   13.20 +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
   13.21 +
   13.22 +#include "blargg_source.h"
   13.23 +
   13.24 +#ifdef BLARGG_ENABLE_OPTIMIZER
   13.25 +	#include BLARGG_ENABLE_OPTIMIZER
   13.26 +#endif
   13.27 +
   13.28 +#if INT_MAX < 0x7FFFFFFF
   13.29 +	#error "Requires that int type have at least 32 bits"
   13.30 +#endif
   13.31 +
   13.32 +
   13.33 +// TODO: add to blargg_endian.h
   13.34 +#define GET_LE16SA( addr )      ((BOOST::int16_t) GET_LE16( addr ))
   13.35 +#define GET_LE16A( addr )       GET_LE16( addr )
   13.36 +#define SET_LE16A( addr, data ) SET_LE16( addr, data )
   13.37 +
   13.38 +static BOOST::uint8_t const initial_regs [SPC_DSP::register_count] =
   13.39 +{
   13.40 +	0x45,0x8B,0x5A,0x9A,0xE4,0x82,0x1B,0x78,0x00,0x00,0xAA,0x96,0x89,0x0E,0xE0,0x80,
   13.41 +	0x2A,0x49,0x3D,0xBA,0x14,0xA0,0xAC,0xC5,0x00,0x00,0x51,0xBB,0x9C,0x4E,0x7B,0xFF,
   13.42 +	0xF4,0xFD,0x57,0x32,0x37,0xD9,0x42,0x22,0x00,0x00,0x5B,0x3C,0x9F,0x1B,0x87,0x9A,
   13.43 +	0x6F,0x27,0xAF,0x7B,0xE5,0x68,0x0A,0xD9,0x00,0x00,0x9A,0xC5,0x9C,0x4E,0x7B,0xFF,
   13.44 +	0xEA,0x21,0x78,0x4F,0xDD,0xED,0x24,0x14,0x00,0x00,0x77,0xB1,0xD1,0x36,0xC1,0x67,
   13.45 +	0x52,0x57,0x46,0x3D,0x59,0xF4,0x87,0xA4,0x00,0x00,0x7E,0x44,0x9C,0x4E,0x7B,0xFF,
   13.46 +	0x75,0xF5,0x06,0x97,0x10,0xC3,0x24,0xBB,0x00,0x00,0x7B,0x7A,0xE0,0x60,0x12,0x0F,
   13.47 +	0xF7,0x74,0x1C,0xE5,0x39,0x3D,0x73,0xC1,0x00,0x00,0x7A,0xB3,0xFF,0x4E,0x7B,0xFF
   13.48 +};
   13.49 +
   13.50 +// if ( io < -32768 ) io = -32768;
   13.51 +// if ( io >  32767 ) io =  32767;
   13.52 +#define CLAMP16( io )\
   13.53 +{\
   13.54 +	if ( (int16_t) io != io )\
   13.55 +		io = (io >> 31) ^ 0x7FFF;\
   13.56 +}
   13.57 +
   13.58 +// Access global DSP register
   13.59 +#define REG(n)      m.regs [r_##n]
   13.60 +
   13.61 +// Access voice DSP register
   13.62 +#define VREG(r,n)   r [v_##n]
   13.63 +
   13.64 +#define WRITE_SAMPLES( l, r, out ) \
   13.65 +{\
   13.66 +	out [0] = l;\
   13.67 +	out [1] = r;\
   13.68 +	out += 2;\
   13.69 +	if ( out >= m.out_end )\
   13.70 +	{\
   13.71 +		check( out == m.out_end );\
   13.72 +		check( m.out_end != &m.extra [extra_size] || \
   13.73 +			(m.extra <= m.out_begin && m.extra < &m.extra [extra_size]) );\
   13.74 +		out       = m.extra;\
   13.75 +		m.out_end = &m.extra [extra_size];\
   13.76 +	}\
   13.77 +}\
   13.78 +
   13.79 +void SPC_DSP::set_output( sample_t* out, int size )
   13.80 +{
   13.81 +	require( (size & 1) == 0 ); // must be even
   13.82 +	if ( !out )
   13.83 +	{
   13.84 +		out  = m.extra;
   13.85 +		size = extra_size;
   13.86 +	}
   13.87 +	m.out_begin = out;
   13.88 +	m.out       = out;
   13.89 +	m.out_end   = out + size;
   13.90 +}
   13.91 +
   13.92 +// Volume registers and efb are signed! Easy to forget int8_t cast.
   13.93 +// Prefixes are to avoid accidental use of locals with same names.
   13.94 +
   13.95 +// Interleved gauss table (to improve cache coherency)
   13.96 +// interleved_gauss [i] = gauss [(i & 1) * 256 + 255 - (i >> 1 & 0xFF)]
   13.97 +static short const interleved_gauss [512] =
   13.98 +{
   13.99 + 370,1305, 366,1305, 362,1304, 358,1304, 354,1304, 351,1304, 347,1304, 343,1303,
  13.100 + 339,1303, 336,1303, 332,1302, 328,1302, 325,1301, 321,1300, 318,1300, 314,1299,
  13.101 + 311,1298, 307,1297, 304,1297, 300,1296, 297,1295, 293,1294, 290,1293, 286,1292,
  13.102 + 283,1291, 280,1290, 276,1288, 273,1287, 270,1286, 267,1284, 263,1283, 260,1282,
  13.103 + 257,1280, 254,1279, 251,1277, 248,1275, 245,1274, 242,1272, 239,1270, 236,1269,
  13.104 + 233,1267, 230,1265, 227,1263, 224,1261, 221,1259, 218,1257, 215,1255, 212,1253,
  13.105 + 210,1251, 207,1248, 204,1246, 201,1244, 199,1241, 196,1239, 193,1237, 191,1234,
  13.106 + 188,1232, 186,1229, 183,1227, 180,1224, 178,1221, 175,1219, 173,1216, 171,1213,
  13.107 + 168,1210, 166,1207, 163,1205, 161,1202, 159,1199, 156,1196, 154,1193, 152,1190,
  13.108 + 150,1186, 147,1183, 145,1180, 143,1177, 141,1174, 139,1170, 137,1167, 134,1164,
  13.109 + 132,1160, 130,1157, 128,1153, 126,1150, 124,1146, 122,1143, 120,1139, 118,1136,
  13.110 + 117,1132, 115,1128, 113,1125, 111,1121, 109,1117, 107,1113, 106,1109, 104,1106,
  13.111 + 102,1102, 100,1098,  99,1094,  97,1090,  95,1086,  94,1082,  92,1078,  90,1074,
  13.112 +  89,1070,  87,1066,  86,1061,  84,1057,  83,1053,  81,1049,  80,1045,  78,1040,
  13.113 +  77,1036,  76,1032,  74,1027,  73,1023,  71,1019,  70,1014,  69,1010,  67,1005,
  13.114 +  66,1001,  65, 997,  64, 992,  62, 988,  61, 983,  60, 978,  59, 974,  58, 969,
  13.115 +  56, 965,  55, 960,  54, 955,  53, 951,  52, 946,  51, 941,  50, 937,  49, 932,
  13.116 +  48, 927,  47, 923,  46, 918,  45, 913,  44, 908,  43, 904,  42, 899,  41, 894,
  13.117 +  40, 889,  39, 884,  38, 880,  37, 875,  36, 870,  36, 865,  35, 860,  34, 855,
  13.118 +  33, 851,  32, 846,  32, 841,  31, 836,  30, 831,  29, 826,  29, 821,  28, 816,
  13.119 +  27, 811,  27, 806,  26, 802,  25, 797,  24, 792,  24, 787,  23, 782,  23, 777,
  13.120 +  22, 772,  21, 767,  21, 762,  20, 757,  20, 752,  19, 747,  19, 742,  18, 737,
  13.121 +  17, 732,  17, 728,  16, 723,  16, 718,  15, 713,  15, 708,  15, 703,  14, 698,
  13.122 +  14, 693,  13, 688,  13, 683,  12, 678,  12, 674,  11, 669,  11, 664,  11, 659,
  13.123 +  10, 654,  10, 649,  10, 644,   9, 640,   9, 635,   9, 630,   8, 625,   8, 620,
  13.124 +   8, 615,   7, 611,   7, 606,   7, 601,   6, 596,   6, 592,   6, 587,   6, 582,
  13.125 +   5, 577,   5, 573,   5, 568,   5, 563,   4, 559,   4, 554,   4, 550,   4, 545,
  13.126 +   4, 540,   3, 536,   3, 531,   3, 527,   3, 522,   3, 517,   2, 513,   2, 508,
  13.127 +   2, 504,   2, 499,   2, 495,   2, 491,   2, 486,   1, 482,   1, 477,   1, 473,
  13.128 +   1, 469,   1, 464,   1, 460,   1, 456,   1, 451,   1, 447,   1, 443,   1, 439,
  13.129 +   0, 434,   0, 430,   0, 426,   0, 422,   0, 418,   0, 414,   0, 410,   0, 405,
  13.130 +   0, 401,   0, 397,   0, 393,   0, 389,   0, 385,   0, 381,   0, 378,   0, 374,
  13.131 +};
  13.132 +
  13.133 +
  13.134 +//// Counters
  13.135 +
  13.136 +#define RATE( rate, div )\
  13.137 +	(rate >= div ? rate / div * 8 - 1 : rate - 1)
  13.138 +
  13.139 +static unsigned const counter_mask [32] =
  13.140 +{
  13.141 +	RATE(   2,2), RATE(2048,4), RATE(1536,3),
  13.142 +	RATE(1280,5), RATE(1024,4), RATE( 768,3),
  13.143 +	RATE( 640,5), RATE( 512,4), RATE( 384,3),
  13.144 +	RATE( 320,5), RATE( 256,4), RATE( 192,3),
  13.145 +	RATE( 160,5), RATE( 128,4), RATE(  96,3),
  13.146 +	RATE(  80,5), RATE(  64,4), RATE(  48,3),
  13.147 +	RATE(  40,5), RATE(  32,4), RATE(  24,3),
  13.148 +	RATE(  20,5), RATE(  16,4), RATE(  12,3),
  13.149 +	RATE(  10,5), RATE(   8,4), RATE(   6,3),
  13.150 +	RATE(   5,5), RATE(   4,4), RATE(   3,3),
  13.151 +	              RATE(   2,4),
  13.152 +	              RATE(   1,4)
  13.153 +};
  13.154 +#undef RATE
  13.155 +
  13.156 +inline void SPC_DSP::init_counter()
  13.157 +{
  13.158 +	// counters start out with this synchronization
  13.159 +	m.counters [0] =     1;
  13.160 +	m.counters [1] =     0;
  13.161 +	m.counters [2] = -0x20u;
  13.162 +	m.counters [3] =  0x0B;
  13.163 +	
  13.164 +	int n = 2;
  13.165 +	for ( int i = 1; i < 32; i++ )
  13.166 +	{
  13.167 +		m.counter_select [i] = &m.counters [n];
  13.168 +		if ( !--n )
  13.169 +			n = 3;
  13.170 +	}
  13.171 +	m.counter_select [ 0] = &m.counters [0];
  13.172 +	m.counter_select [30] = &m.counters [2];
  13.173 +}
  13.174 +
  13.175 +inline void SPC_DSP::run_counter( int i )
  13.176 +{
  13.177 +	int n = m.counters [i];
  13.178 +	if ( !(n-- & 7) )
  13.179 +		n -= 6 - i;
  13.180 +	m.counters [i] = n;
  13.181 +}
  13.182 +
  13.183 +#define READ_COUNTER( rate )\
  13.184 +	(*m.counter_select [rate] & counter_mask [rate])
  13.185 +
  13.186 +
  13.187 +//// Emulation
  13.188 +
  13.189 +void SPC_DSP::run( int clock_count )
  13.190 +{
  13.191 +	int new_phase = m.phase + clock_count;
  13.192 +	int count = new_phase >> 5;
  13.193 +	m.phase = new_phase & 31;
  13.194 +	if ( !count )
  13.195 +		return;
  13.196 +	
  13.197 +	uint8_t* const ram = m.ram;
  13.198 +	uint8_t const* const dir = &ram [REG(dir) * 0x100];
  13.199 +	int const slow_gaussian = (REG(pmon) >> 1) | REG(non);
  13.200 +	int const noise_rate = REG(flg) & 0x1F;
  13.201 +	
  13.202 +	// Global volume
  13.203 +	int mvoll = (int8_t) REG(mvoll);
  13.204 +	int mvolr = (int8_t) REG(mvolr);
  13.205 +	if ( mvoll * mvolr < m.surround_threshold )
  13.206 +		mvoll = -mvoll; // eliminate surround
  13.207 +	
  13.208 +	do
  13.209 +	{
  13.210 +		// KON/KOFF reading
  13.211 +		if ( (m.every_other_sample ^= 1) != 0 )
  13.212 +		{
  13.213 +			m.new_kon &= ~m.kon;
  13.214 +			m.kon    = m.new_kon;
  13.215 +			m.t_koff = REG(koff); 
  13.216 +		}
  13.217 +		
  13.218 +		run_counter( 1 );
  13.219 +		run_counter( 2 );
  13.220 +		run_counter( 3 );
  13.221 +		
  13.222 +		// Noise
  13.223 +		if ( !READ_COUNTER( noise_rate ) )
  13.224 +		{
  13.225 +			int feedback = (m.noise << 13) ^ (m.noise << 14);
  13.226 +			m.noise = (feedback & 0x4000) ^ (m.noise >> 1);
  13.227 +		}
  13.228 +		
  13.229 +		// Voices
  13.230 +		int pmon_input = 0;
  13.231 +		int main_out_l = 0;
  13.232 +		int main_out_r = 0;
  13.233 +		int echo_out_l = 0;
  13.234 +		int echo_out_r = 0;
  13.235 +		voice_t* v = m.voices;
  13.236 +		uint8_t* v_regs = m.regs;
  13.237 +		int vbit = 1;
  13.238 +		do
  13.239 +		{
  13.240 +			#define SAMPLE_PTR(i) GET_LE16A( &dir [VREG(v_regs,srcn) * 4 + i * 2] )
  13.241 +			
  13.242 +			int brr_header = ram [v->brr_addr];
  13.243 +			int kon_delay = v->kon_delay;
  13.244 +			
  13.245 +			// Pitch
  13.246 +			int pitch = GET_LE16A( &VREG(v_regs,pitchl) ) & 0x3FFF;
  13.247 +			if ( REG(pmon) & vbit )
  13.248 +				pitch += ((pmon_input >> 5) * pitch) >> 10;
  13.249 +			
  13.250 +			// KON phases
  13.251 +			if ( --kon_delay >= 0 )
  13.252 +			{
  13.253 +				v->kon_delay = kon_delay;
  13.254 +				
  13.255 +				// Get ready to start BRR decoding on next sample
  13.256 +				if ( kon_delay == 4 )
  13.257 +				{
  13.258 +					v->brr_addr   = SAMPLE_PTR( 0 );
  13.259 +					v->brr_offset = 1;
  13.260 +					v->buf_pos    = v->buf;
  13.261 +					brr_header    = 0; // header is ignored on this sample
  13.262 +				}
  13.263 +				
  13.264 +				// Envelope is never run during KON
  13.265 +				v->env        = 0;
  13.266 +				v->hidden_env = 0;
  13.267 +				
  13.268 +				// Disable BRR decoding until last three samples
  13.269 +				v->interp_pos = (kon_delay & 3 ? 0x4000 : 0);
  13.270 +				
  13.271 +				// Pitch is never added during KON
  13.272 +				pitch = 0;
  13.273 +			}
  13.274 +			
  13.275 +			int env = v->env;
  13.276 +			
  13.277 +			// Gaussian interpolation
  13.278 +			{
  13.279 +				int output = 0;
  13.280 +				VREG(v_regs,envx) = (uint8_t) (env >> 4);
  13.281 +				if ( env )
  13.282 +				{
  13.283 +					// Make pointers into gaussian based on fractional position between samples
  13.284 +					int offset = (unsigned) v->interp_pos >> 3 & 0x1FE;
  13.285 +					short const* fwd = interleved_gauss       + offset;
  13.286 +					short const* rev = interleved_gauss + 510 - offset; // mirror left half of gaussian
  13.287 +					
  13.288 +					int const* in = &v->buf_pos [(unsigned) v->interp_pos >> 12];
  13.289 +					
  13.290 +					if ( !(slow_gaussian & vbit) ) // 99%
  13.291 +					{
  13.292 +						// Faster approximation when exact sample value isn't necessary for pitch mod
  13.293 +						output = (fwd [0] * in [0] +
  13.294 +						          fwd [1] * in [1] +
  13.295 +						          rev [1] * in [2] +
  13.296 +						          rev [0] * in [3]) >> 11;
  13.297 +						output = (output * env) >> 11;
  13.298 +					}
  13.299 +					else
  13.300 +					{
  13.301 +						output = (int16_t) (m.noise * 2);
  13.302 +						if ( !(REG(non) & vbit) )
  13.303 +						{
  13.304 +							output  = (fwd [0] * in [0]) >> 11;
  13.305 +							output += (fwd [1] * in [1]) >> 11;
  13.306 +							output += (rev [1] * in [2]) >> 11;
  13.307 +							output = (int16_t) output;
  13.308 +							output += (rev [0] * in [3]) >> 11;
  13.309 +							
  13.310 +							CLAMP16( output );
  13.311 +							output &= ~1;
  13.312 +						}
  13.313 +						output = (output * env) >> 11 & ~1;
  13.314 +					}
  13.315 +					
  13.316 +					// Output
  13.317 +					int l = output * v->volume [0];
  13.318 +					int r = output * v->volume [1];
  13.319 +					
  13.320 +					main_out_l += l;
  13.321 +					main_out_r += r;
  13.322 +					
  13.323 +					if ( REG(eon) & vbit )
  13.324 +					{
  13.325 +						echo_out_l += l;
  13.326 +						echo_out_r += r;
  13.327 +					}
  13.328 +				}
  13.329 +				
  13.330 +				pmon_input = output;
  13.331 +				VREG(v_regs,outx) = (uint8_t) (output >> 8);
  13.332 +			}
  13.333 +			
  13.334 +			// Soft reset or end of sample
  13.335 +			if ( REG(flg) & 0x80 || (brr_header & 3) == 1 )
  13.336 +			{
  13.337 +				v->env_mode = env_release;
  13.338 +				env         = 0;
  13.339 +			}
  13.340 +			
  13.341 +			if ( m.every_other_sample )
  13.342 +			{
  13.343 +				// KOFF
  13.344 +				if ( m.t_koff & vbit )
  13.345 +					v->env_mode = env_release;
  13.346 +				
  13.347 +				// KON
  13.348 +				if ( m.kon & vbit )
  13.349 +				{
  13.350 +					v->kon_delay = 5;
  13.351 +					v->env_mode  = env_attack;
  13.352 +					REG(endx) &= ~vbit;
  13.353 +				}
  13.354 +			}
  13.355 +			
  13.356 +			// Envelope
  13.357 +			if ( !v->kon_delay )
  13.358 +			{
  13.359 +				if ( v->env_mode == env_release ) // 97%
  13.360 +				{
  13.361 +					env -= 0x8;
  13.362 +					v->env = env;
  13.363 +					if ( env <= 0 )
  13.364 +					{
  13.365 +						v->env = 0;
  13.366 +						goto skip_brr; // no BRR decoding for you!
  13.367 +					}
  13.368 +				}
  13.369 +				else // 3%
  13.370 +				{
  13.371 +					int rate;
  13.372 +					int const adsr0 = VREG(v_regs,adsr0);
  13.373 +					int env_data = VREG(v_regs,adsr1);
  13.374 +					if ( adsr0 >= 0x80 ) // 97% ADSR
  13.375 +					{
  13.376 +						if ( v->env_mode > env_decay ) // 89%
  13.377 +						{
  13.378 +							env--;
  13.379 +							env -= env >> 8;
  13.380 +							rate = env_data & 0x1F;
  13.381 +							
  13.382 +							// optimized handling
  13.383 +							v->hidden_env = env;
  13.384 +							if ( READ_COUNTER( rate ) )
  13.385 +								goto exit_env;
  13.386 +							v->env = env;
  13.387 +							goto exit_env;
  13.388 +						}
  13.389 +						else if ( v->env_mode == env_decay )
  13.390 +						{
  13.391 +							env--;
  13.392 +							env -= env >> 8;
  13.393 +							rate = (adsr0 >> 3 & 0x0E) + 0x10;
  13.394 +						}
  13.395 +						else // env_attack
  13.396 +						{
  13.397 +							rate = (adsr0 & 0x0F) * 2 + 1;
  13.398 +							env += rate < 31 ? 0x20 : 0x400;
  13.399 +						}
  13.400 +					}
  13.401 +					else // GAIN
  13.402 +					{
  13.403 +						int mode;
  13.404 +						env_data = VREG(v_regs,gain);
  13.405 +						mode = env_data >> 5;
  13.406 +						if ( mode < 4 ) // direct
  13.407 +						{
  13.408 +							env = env_data * 0x10;
  13.409 +							rate = 31;
  13.410 +						}
  13.411 +						else
  13.412 +						{
  13.413 +							rate = env_data & 0x1F;
  13.414 +							if ( mode == 4 ) // 4: linear decrease
  13.415 +							{
  13.416 +								env -= 0x20;
  13.417 +							}
  13.418 +							else if ( mode < 6 ) // 5: exponential decrease
  13.419 +							{
  13.420 +								env--;
  13.421 +								env -= env >> 8;
  13.422 +							}
  13.423 +							else // 6,7: linear increase
  13.424 +							{
  13.425 +								env += 0x20;
  13.426 +								if ( mode > 6 && (unsigned) v->hidden_env >= 0x600 )
  13.427 +									env += 0x8 - 0x20; // 7: two-slope linear increase
  13.428 +							}
  13.429 +						}
  13.430 +					}
  13.431 +					
  13.432 +					// Sustain level
  13.433 +					if ( (env >> 8) == (env_data >> 5) && v->env_mode == env_decay )
  13.434 +						v->env_mode = env_sustain;
  13.435 +					
  13.436 +					v->hidden_env = env;
  13.437 +					
  13.438 +					// unsigned cast because linear decrease going negative also triggers this
  13.439 +					if ( (unsigned) env > 0x7FF )
  13.440 +					{
  13.441 +						env = (env < 0 ? 0 : 0x7FF);
  13.442 +						if ( v->env_mode == env_attack )
  13.443 +							v->env_mode = env_decay;
  13.444 +					}
  13.445 +					
  13.446 +					if ( !READ_COUNTER( rate ) )
  13.447 +						v->env = env; // nothing else is controlled by the counter
  13.448 +				}
  13.449 +			}
  13.450 +		exit_env:
  13.451 +			
  13.452 +			{
  13.453 +				// Apply pitch
  13.454 +				int old_pos = v->interp_pos;
  13.455 +				int interp_pos = (old_pos & 0x3FFF) + pitch;
  13.456 +				if ( interp_pos > 0x7FFF )
  13.457 +					interp_pos = 0x7FFF;
  13.458 +				v->interp_pos = interp_pos;
  13.459 +				
  13.460 +				// BRR decode if necessary
  13.461 +				if ( old_pos >= 0x4000 )
  13.462 +				{
  13.463 +					// Arrange the four input nybbles in 0xABCD order for easy decoding
  13.464 +					int nybbles = ram [(v->brr_addr + v->brr_offset) & 0xFFFF] * 0x100 +
  13.465 +							ram [(v->brr_addr + v->brr_offset + 1) & 0xFFFF];
  13.466 +					
  13.467 +					// Advance read position
  13.468 +					int const brr_block_size = 9;
  13.469 +					int brr_offset = v->brr_offset;
  13.470 +					if ( (brr_offset += 2) >= brr_block_size )
  13.471 +					{
  13.472 +						// Next BRR block
  13.473 +						int brr_addr = (v->brr_addr + brr_block_size) & 0xFFFF;
  13.474 +						assert( brr_offset == brr_block_size );
  13.475 +						if ( brr_header & 1 )
  13.476 +						{
  13.477 +							brr_addr = SAMPLE_PTR( 1 );
  13.478 +							if ( !v->kon_delay )
  13.479 +								REG(endx) |= vbit;
  13.480 +						}
  13.481 +						v->brr_addr = brr_addr;
  13.482 +						brr_offset  = 1;
  13.483 +					}
  13.484 +					v->brr_offset = brr_offset;
  13.485 +					
  13.486 +					// Decode
  13.487 +					
  13.488 +					// 0: >>1  1: <<0  2: <<1 ... 12: <<11  13-15: >>4 <<11
  13.489 +					static unsigned char const shifts [16 * 2] = {
  13.490 +						13,12,12,12,12,12,12,12,12,12,12, 12, 12, 16, 16, 16,
  13.491 +						 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 11, 11, 11
  13.492 +					};
  13.493 +					int const scale = brr_header >> 4;
  13.494 +					int const right_shift = shifts [scale];
  13.495 +					int const left_shift  = shifts [scale + 16];
  13.496 +					
  13.497 +					// Write to next four samples in circular buffer
  13.498 +					int* pos = v->buf_pos;
  13.499 +					int* end;
  13.500 +					
  13.501 +					// Decode four samples
  13.502 +					for ( end = pos + 4; pos < end; pos++, nybbles <<= 4 )
  13.503 +					{
  13.504 +						// Extract upper nybble and scale appropriately
  13.505 +						int s = ((int16_t) nybbles >> right_shift) << left_shift;
  13.506 +						
  13.507 +						// Apply IIR filter (8 is the most commonly used)
  13.508 +						int const filter = brr_header & 0x0C;
  13.509 +						int const p1 = pos [brr_buf_size - 1];
  13.510 +						int const p2 = pos [brr_buf_size - 2] >> 1;
  13.511 +						if ( filter >= 8 )
  13.512 +						{
  13.513 +							s += p1;
  13.514 +							s -= p2;
  13.515 +							if ( filter == 8 ) // s += p1 * 0.953125 - p2 * 0.46875
  13.516 +							{
  13.517 +								s += p2 >> 4;
  13.518 +								s += (p1 * -3) >> 6;
  13.519 +							}
  13.520 +							else // s += p1 * 0.8984375 - p2 * 0.40625
  13.521 +							{
  13.522 +								s += (p1 * -13) >> 7;
  13.523 +								s += (p2 * 3) >> 4;
  13.524 +							}
  13.525 +						}
  13.526 +						else if ( filter ) // s += p1 * 0.46875
  13.527 +						{
  13.528 +							s += p1 >> 1;
  13.529 +							s += (-p1) >> 5;
  13.530 +						}
  13.531 +						
  13.532 +						// Adjust and write sample
  13.533 +						CLAMP16( s );
  13.534 +						s = (int16_t) (s * 2);
  13.535 +						pos [brr_buf_size] = pos [0] = s; // second copy simplifies wrap-around
  13.536 +					}
  13.537 +					
  13.538 +					if ( pos >= &v->buf [brr_buf_size] )
  13.539 +						pos = v->buf;
  13.540 +					v->buf_pos = pos;
  13.541 +				}
  13.542 +			}
  13.543 +skip_brr:
  13.544 +			// Next voice
  13.545 +			vbit <<= 1;
  13.546 +			v_regs += 0x10;
  13.547 +			v++;
  13.548 +		}
  13.549 +		while ( vbit < 0x100 );
  13.550 +		
  13.551 +		// Echo position
  13.552 +		int echo_offset = m.echo_offset;
  13.553 +		uint8_t* const echo_ptr = &ram [(REG(esa) * 0x100 + echo_offset) & 0xFFFF];
  13.554 +		if ( !echo_offset )
  13.555 +			m.echo_length = (REG(edl) & 0x0F) * 0x800;
  13.556 +		echo_offset += 4;
  13.557 +		if ( echo_offset >= m.echo_length )
  13.558 +			echo_offset = 0;
  13.559 +		m.echo_offset = echo_offset;
  13.560 +		
  13.561 +		// FIR
  13.562 +		int echo_in_l = GET_LE16SA( echo_ptr + 0 );
  13.563 +		int echo_in_r = GET_LE16SA( echo_ptr + 2 );
  13.564 +		
  13.565 +		int (*echo_hist_pos) [2] = m.echo_hist_pos;
  13.566 +		if ( ++echo_hist_pos >= &m.echo_hist [echo_hist_size] )
  13.567 +			echo_hist_pos = m.echo_hist;
  13.568 +		m.echo_hist_pos = echo_hist_pos;
  13.569 +		
  13.570 +		echo_hist_pos [0] [0] = echo_hist_pos [8] [0] = echo_in_l;
  13.571 +		echo_hist_pos [0] [1] = echo_hist_pos [8] [1] = echo_in_r;
  13.572 +		
  13.573 +		#define CALC_FIR_( i, in )  ((in) * (int8_t) REG(fir + i * 0x10))
  13.574 +		echo_in_l = CALC_FIR_( 7, echo_in_l );
  13.575 +		echo_in_r = CALC_FIR_( 7, echo_in_r );
  13.576 +		
  13.577 +		#define CALC_FIR( i, ch )   CALC_FIR_( i, echo_hist_pos [i + 1] [ch] )
  13.578 +		#define DO_FIR( i )\
  13.579 +			echo_in_l += CALC_FIR( i, 0 );\
  13.580 +			echo_in_r += CALC_FIR( i, 1 );
  13.581 +		DO_FIR( 0 );
  13.582 +		DO_FIR( 1 );
  13.583 +		DO_FIR( 2 );
  13.584 +		#if defined (__MWERKS__) && __MWERKS__ < 0x3200
  13.585 +			__eieio(); // keeps compiler from stupidly "caching" things in memory
  13.586 +		#endif
  13.587 +		DO_FIR( 3 );
  13.588 +		DO_FIR( 4 );
  13.589 +		DO_FIR( 5 );
  13.590 +		DO_FIR( 6 );
  13.591 +		
  13.592 +		// Echo out
  13.593 +		if ( !(REG(flg) & 0x20) )
  13.594 +		{
  13.595 +			int l = (echo_out_l >> 7) + ((echo_in_l * (int8_t) REG(efb)) >> 14);
  13.596 +			int r = (echo_out_r >> 7) + ((echo_in_r * (int8_t) REG(efb)) >> 14);
  13.597 +			
  13.598 +			// just to help pass more validation tests
  13.599 +			#if SPC_MORE_ACCURACY
  13.600 +				l &= ~1;
  13.601 +				r &= ~1;
  13.602 +			#endif
  13.603 +			
  13.604 +			CLAMP16( l );
  13.605 +			CLAMP16( r );
  13.606 +			
  13.607 +			SET_LE16A( echo_ptr + 0, l );
  13.608 +			SET_LE16A( echo_ptr + 2, r );
  13.609 +		}
  13.610 +		
  13.611 +		// Sound out
  13.612 +		int l = (main_out_l * mvoll + echo_in_l * (int8_t) REG(evoll)) >> 14;
  13.613 +		int r = (main_out_r * mvolr + echo_in_r * (int8_t) REG(evolr)) >> 14;
  13.614 +		
  13.615 +		CLAMP16( l );
  13.616 +		CLAMP16( r );
  13.617 +		
  13.618 +		if ( (REG(flg) & 0x40) )
  13.619 +		{
  13.620 +			l = 0;
  13.621 +			r = 0;
  13.622 +		}
  13.623 +		
  13.624 +		sample_t* out = m.out;
  13.625 +		WRITE_SAMPLES( l, r, out );
  13.626 +		m.out = out;
  13.627 +	}
  13.628 +	while ( --count );
  13.629 +}
  13.630 +
  13.631 +
  13.632 +//// Setup
  13.633 +
  13.634 +void SPC_DSP::mute_voices( int mask )
  13.635 +{
  13.636 +	m.mute_mask = mask;
  13.637 +	for ( int i = 0; i < voice_count; i++ )
  13.638 +	{
  13.639 +		m.voices [i].enabled = (mask >> i & 1) - 1;
  13.640 +		update_voice_vol( i * 0x10 );
  13.641 +	}
  13.642 +}
  13.643 +
  13.644 +void SPC_DSP::init( void* ram_64k )
  13.645 +{
  13.646 +	m.ram = (uint8_t*) ram_64k;
  13.647 +	mute_voices( 0 );
  13.648 +	disable_surround( false );
  13.649 +	set_output( 0, 0 );
  13.650 +	reset();
  13.651 +	
  13.652 +	#ifndef NDEBUG
  13.653 +		// be sure this sign-extends
  13.654 +		assert( (int16_t) 0x8000 == -0x8000 );
  13.655 +		
  13.656 +		// be sure right shift preserves sign
  13.657 +		assert( (-1 >> 1) == -1 );
  13.658 +		
  13.659 +		// check clamp macro
  13.660 +		int i;
  13.661 +		i = +0x8000; CLAMP16( i ); assert( i == +0x7FFF );
  13.662 +		i = -0x8001; CLAMP16( i ); assert( i == -0x8000 );
  13.663 +		
  13.664 +		blargg_verify_byte_order();
  13.665 +	#endif
  13.666 +}
  13.667 +
  13.668 +void SPC_DSP::soft_reset_common()
  13.669 +{
  13.670 +	require( m.ram ); // init() must have been called already
  13.671 +	
  13.672 +	m.noise              = 0x4000;
  13.673 +	m.echo_hist_pos      = m.echo_hist;
  13.674 +	m.every_other_sample = 1;
  13.675 +	m.echo_offset        = 0;
  13.676 +	m.phase              = 0;
  13.677 +	
  13.678 +	init_counter();
  13.679 +}
  13.680 +
  13.681 +void SPC_DSP::soft_reset()
  13.682 +{
  13.683 +	REG(flg) = 0xE0;
  13.684 +	soft_reset_common();
  13.685 +}
  13.686 +
  13.687 +void SPC_DSP::load( uint8_t const regs [register_count] )
  13.688 +{
  13.689 +	memcpy( m.regs, regs, sizeof m.regs );
  13.690 +	memset( &m.regs [register_count], 0, offsetof (state_t,ram) - register_count );
  13.691 +	
  13.692 +	// Internal state
  13.693 +	int i;
  13.694 +	for ( i = voice_count; --i >= 0; )
  13.695 +	{
  13.696 +		voice_t& v = m.voices [i];
  13.697 +		v.brr_offset = 1;
  13.698 +		v.buf_pos    = v.buf;
  13.699 +	}
  13.700 +	m.new_kon = REG(kon);
  13.701 +	
  13.702 +	mute_voices( m.mute_mask );
  13.703 +	soft_reset_common();
  13.704 +}
  13.705 +
  13.706 +void SPC_DSP::reset() { load( initial_regs ); }

    14.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    14.2 +++ b/fast_dsp/SPC_DSP.h	Fri Oct 21 05:53:11 2011 -0700
    14.3 @@ -0,0 +1,212 @@
    14.4 +// Fast SNES SPC-700 DSP emulator (about 3x speed of accurate one)
    14.5 +
    14.6 +// snes_spc 0.9.0
    14.7 +#ifndef SPC_DSP_H
    14.8 +#define SPC_DSP_H
    14.9 +
   14.10 +#include "blargg_common.h"
   14.11 +
   14.12 +class SPC_DSP {
   14.13 +public:
   14.14 +	typedef BOOST::uint8_t uint8_t;
   14.15 +	
   14.16 +// Setup
   14.17 +	
   14.18 +	// Initializes DSP and has it use the 64K RAM provided
   14.19 +	void init( void* ram_64k );
   14.20 +
   14.21 +	// Sets destination for output samples. If out is NULL or out_size is 0,
   14.22 +	// doesn't generate any.
   14.23 +	typedef short sample_t;
   14.24 +	void set_output( sample_t* out, int out_size );
   14.25 +
   14.26 +	// Number of samples written to output since it was last set, always
   14.27 +	// a multiple of 2. Undefined if more samples were generated than
   14.28 +	// output buffer could hold.
   14.29 +	int sample_count() const;
   14.30 +
   14.31 +// Emulation
   14.32 +	
   14.33 +	// Resets DSP to power-on state
   14.34 +	void reset();
   14.35 +
   14.36 +	// Emulates pressing reset switch on SNES
   14.37 +	void soft_reset();
   14.38 +	
   14.39 +	// Reads/writes DSP registers. For accuracy, you must first call spc_run_dsp()
   14.40 +	// to catch the DSP up to present.
   14.41 +	int  read ( int addr ) const;
   14.42 +	void write( int addr, int data );
   14.43 +
   14.44 +	// Runs DSP for specified number of clocks (~1024000 per second). Every 32 clocks
   14.45 +	// a pair of samples is be generated.
   14.46 +	void run( int clock_count );
   14.47 +
   14.48 +// Sound control
   14.49 +
   14.50 +	// Mutes voices corresponding to non-zero bits in mask (overrides VxVOL with 0).
   14.51 +	// Reduces emulation accuracy.
   14.52 +	enum { voice_count = 8 };
   14.53 +	void mute_voices( int mask );
   14.54 +
   14.55 +	// If true, prevents channels and global volumes from being phase-negated
   14.56 +	void disable_surround( bool disable = true );
   14.57 +
   14.58 +// State
   14.59 +	
   14.60 +	// Resets DSP and uses supplied values to initialize registers
   14.61 +	enum { register_count = 128 };
   14.62 +	void load( uint8_t const regs [register_count] );
   14.63 +
   14.64 +// DSP register addresses
   14.65 +
   14.66 +	// Global registers
   14.67 +	enum {
   14.68 +	    r_mvoll = 0x0C, r_mvolr = 0x1C,
   14.69 +	    r_evoll = 0x2C, r_evolr = 0x3C,
   14.70 +	    r_kon   = 0x4C, r_koff  = 0x5C,
   14.71 +	    r_flg   = 0x6C, r_endx  = 0x7C,
   14.72 +	    r_efb   = 0x0D, r_pmon  = 0x2D,
   14.73 +	    r_non   = 0x3D, r_eon   = 0x4D,
   14.74 +	    r_dir   = 0x5D, r_esa   = 0x6D,
   14.75 +	    r_edl   = 0x7D,
   14.76 +	    r_fir   = 0x0F // 8 coefficients at 0x0F, 0x1F ... 0x7F
   14.77 +	};
   14.78 +
   14.79 +	// Voice registers
   14.80 +	enum {
   14.81 +		v_voll   = 0x00, v_volr   = 0x01,
   14.82 +		v_pitchl = 0x02, v_pitchh = 0x03,
   14.83 +		v_srcn   = 0x04, v_adsr0  = 0x05,
   14.84 +		v_adsr1  = 0x06, v_gain   = 0x07,
   14.85 +		v_envx   = 0x08, v_outx   = 0x09
   14.86 +	};
   14.87 +
   14.88 +public:
   14.89 +	enum { extra_size = 16 };
   14.90 +	sample_t* extra()               { return m.extra; }
   14.91 +	sample_t const* out_pos() const { return m.out; }
   14.92 +public:
   14.93 +	BLARGG_DISABLE_NOTHROW
   14.94 +	
   14.95 +	typedef BOOST::int8_t   int8_t;
   14.96 +	typedef BOOST::int16_t int16_t;
   14.97 +	
   14.98 +	enum { echo_hist_size = 8 };
   14.99 +	
  14.100 +	enum env_mode_t { env_release, env_attack, env_decay, env_sustain };
  14.101 +	enum { brr_buf_size = 12 };
  14.102 +	struct voice_t
  14.103 +	{
  14.104 +		int buf [brr_buf_size*2];// decoded samples (twice the size to simplify wrap handling)
  14.105 +		int* buf_pos;           // place in buffer where next samples will be decoded
  14.106 +		int interp_pos;         // relative fractional position in sample (0x1000 = 1.0)
  14.107 +		int brr_addr;           // address of current BRR block
  14.108 +		int brr_offset;         // current decoding offset in BRR block
  14.109 +		int kon_delay;          // KON delay/current setup phase
  14.110 +		env_mode_t env_mode;
  14.111 +		int env;                // current envelope level
  14.112 +		int hidden_env;         // used by GAIN mode 7, very obscure quirk
  14.113 +		int volume [2];         // copy of volume from DSP registers, with surround disabled
  14.114 +		int enabled;            // -1 if enabled, 0 if muted
  14.115 +	};
  14.116 +private:
  14.117 +	struct state_t
  14.118 +	{
  14.119 +		uint8_t regs [register_count];
  14.120 +		
  14.121 +		// Echo history keeps most recent 8 samples (twice the size to simplify wrap handling)
  14.122 +		int echo_hist [echo_hist_size * 2] [2];
  14.123 +		int (*echo_hist_pos) [2]; // &echo_hist [0 to 7]
  14.124 +		
  14.125 +		int every_other_sample; // toggles every sample
  14.126 +		int kon;                // KON value when last checked
  14.127 +		int noise;
  14.128 +		int echo_offset;        // offset from ESA in echo buffer
  14.129 +		int echo_length;        // number of bytes that echo_offset will stop at
  14.130 +		int phase;              // next clock cycle to run (0-31)
  14.131 +		unsigned counters [4];
  14.132 +		
  14.133 +		int new_kon;
  14.134 +		int t_koff;
  14.135 +		
  14.136 +		voice_t voices [voice_count];
  14.137 +		
  14.138 +		unsigned* counter_select [32];
  14.139 +		
  14.140 +		// non-emulation state
  14.141 +		uint8_t* ram; // 64K shared RAM between DSP and SMP
  14.142 +		int mute_mask;
  14.143 +		int surround_threshold;
  14.144 +		sample_t* out;
  14.145 +		sample_t* out_end;
  14.146 +		sample_t* out_begin;
  14.147 +		sample_t extra [extra_size];
  14.148 +	};
  14.149 +	state_t m;
  14.150 +	
  14.151 +	void init_counter();
  14.152 +	void run_counter( int );
  14.153 +	void soft_reset_common();
  14.154 +	void write_outline( int addr, int data );
  14.155 +	void update_voice_vol( int addr );
  14.156 +};
  14.157 +
  14.158 +#include <assert.h>
  14.159 +
  14.160 +inline int SPC_DSP::sample_count() const { return m.out - m.out_begin; }
  14.161 +
  14.162 +inline int SPC_DSP::read( int addr ) const
  14.163 +{
  14.164 +	assert( (unsigned) addr < register_count );
  14.165 +	return m.regs [addr];
  14.166 +}
  14.167 +
  14.168 +inline void SPC_DSP::update_voice_vol( int addr )
  14.169 +{
  14.170 +	int l = (int8_t) m.regs [addr + v_voll];
  14.171 +	int r = (int8_t) m.regs [addr + v_volr];
  14.172 +	
  14.173 +	if ( l * r < m.surround_threshold )
  14.174 +	{
  14.175 +		// signs differ, so negate those that are negative
  14.176 +		l ^= l >> 7;
  14.177 +		r ^= r >> 7;
  14.178 +	}
  14.179 +	
  14.180 +	voice_t& v = m.voices [addr >> 4];
  14.181 +	int enabled = v.enabled;
  14.182 +	v.volume [0] = l & enabled;
  14.183 +	v.volume [1] = r & enabled;
  14.184 +}
  14.185 +
  14.186 +inline void SPC_DSP::write( int addr, int data )
  14.187 +{
  14.188 +	assert( (unsigned) addr < register_count );
  14.189 +	
  14.190 +	m.regs [addr] = (uint8_t) data;
  14.191 +	int low = addr & 0x0F;
  14.192 +	if ( low < 0x2 ) // voice volumes
  14.193 +	{
  14.194 +		update_voice_vol( low ^ addr );
  14.195 +	}
  14.196 +	else if ( low == 0xC )
  14.197 +	{
  14.198 +		if ( addr == r_kon )
  14.199 +			m.new_kon = (uint8_t) data;
  14.200 +		
  14.201 +		if ( addr == r_endx ) // always cleared, regardless of data written
  14.202 +			m.regs [r_endx] = 0;
  14.203 +	}
  14.204 +}
  14.205 +
  14.206 +inline void SPC_DSP::disable_surround( bool disable )
  14.207 +{
  14.208 +	m.surround_threshold = disable ? 0 : -0x4000;
  14.209 +}
  14.210 +
  14.211 +#define SPC_NO_COPY_STATE_FUNCS 1
  14.212 +
  14.213 +#define SPC_LESS_ACCURATE 1
  14.214 +
  14.215 +#endif

    15.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    15.2 +++ b/license.txt	Fri Oct 21 05:53:11 2011 -0700
    15.3 @@ -0,0 +1,504 @@
    15.4 +		  GNU LESSER GENERAL PUBLIC LICENSE
    15.5 +		       Version 2.1, February 1999
    15.6 +
    15.7 + Copyright (C) 1991, 1999 Free Software Foundation, Inc.
    15.8 + 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
    15.9 + Everyone is permitted to copy and distribute verbatim copies
   15.10 + of this license document, but changing it is not allowed.
   15.11 +
   15.12 +[This is the first released version of the Lesser GPL.  It also counts
   15.13 + as the successor of the GNU Library Public License, version 2, hence
   15.14 + the version number 2.1.]
   15.15 +
   15.16 +			    Preamble
   15.17 +
   15.18 +  The licenses for most software are designed to take away your
   15.19 +freedom to share and change it.  By contrast, the GNU General Public
   15.20 +Licenses are intended to guarantee your freedom to share and change
   15.21 +free software--to make sure the software is free for all its users.
   15.22 +
   15.23 +  This license, the Lesser General Public License, applies to some
   15.24 +specially designated software packages--typically libraries--of the
   15.25 +Free Software Foundation and other authors who decide to use it.  You
   15.26 +can use it too, but we suggest you first think carefully about whether
   15.27 +this license or the ordinary General Public License is the better
   15.28 +strategy to use in any particular case, based on the explanations below.
   15.29 +
   15.30 +  When we speak of free software, we are referring to freedom of use,
   15.31 +not price.  Our General Public Licenses are designed to make sure that
   15.32 +you have the freedom to distribute copies of free software (and charge
   15.33 +for this service if you wish); that you receive source code or can get
   15.34 +it if you want it; that you can change the software and use pieces of
   15.35 +it in new free programs; and that you are informed that you can do
   15.36 +these things.
   15.37 +
   15.38 +  To protect your rights, we need to make restrictions that forbid
   15.39 +distributors to deny you these rights or to ask you to surrender these
   15.40 +rights.  These restrictions translate to certain responsibilities for
   15.41 +you if you distribute copies of the library or if you modify it.
   15.42 +
   15.43 +  For example, if you distribute copies of the library, whether gratis
   15.44 +or for a fee, you must give the recipients all the rights that we gave
   15.45 +you.  You must make sure that they, too, receive or can get the source
   15.46 +code.  If you link other code with the library, you must provide
   15.47 +complete object files to the recipients, so that they can relink them
   15.48 +with the library after making changes to the library and recompiling
   15.49 +it.  And you must show them these terms so they know their rights.
   15.50 +
   15.51 +  We protect your rights with a two-step method: (1) we copyright the
   15.52 +library, and (2) we offer you this license, which gives you legal
   15.53 +permission to copy, distribute and/or modify the library.
   15.54 +
   15.55 +  To protect each distributor, we want to make it very clear that
   15.56 +there is no warranty for the free library.  Also, if the library is
   15.57 +modified by someone else and passed on, the recipients should know
   15.58 +that what they have is not the original version, so that the original
   15.59 +author's reputation will not be affected by problems that might be
   15.60 +introduced by others.
   15.61 +
   15.62 +  Finally, software patents pose a constant threat to the existence of
   15.63 +any free program.  We wish to make sure that a company cannot
   15.64 +effectively restrict the users of a free program by obtaining a
   15.65 +restrictive license from a patent holder.  Therefore, we insist that
   15.66 +any patent license obtained for a version of the library must be
   15.67 +consistent with the full freedom of use specified in this license.
   15.68 +
   15.69 +  Most GNU software, including some libraries, is covered by the
   15.70 +ordinary GNU General Public License.  This license, the GNU Lesser
   15.71 +General Public License, applies to certain designated libraries, and
   15.72 +is quite different from the ordinary General Public License.  We use
   15.73 +this license for certain libraries in order to permit linking those
   15.74 +libraries into non-free programs.
   15.75 +
   15.76 +  When a program is linked with a library, whether statically or using
   15.77 +a shared library, the combination of the two is legally speaking a
   15.78 +combined work, a derivative of the original library.  The ordinary
   15.79 +General Public License therefore permits such linking only if the
   15.80 +entire combination fits its criteria of freedom.  The Lesser General
   15.81 +Public License permits more lax criteria for linking other code with
   15.82 +the library.
   15.83 +
   15.84 +  We call this license the "Lesser" General Public License because it
   15.85 +does Less to protect the user's freedom than the ordinary General
   15.86 +Public License.  It also provides other free software developers Less
   15.87 +of an advantage over competing non-free programs.  These disadvantages
   15.88 +are the reason we use the ordinary General Public License for many
   15.89 +libraries.  However, the Lesser license provides advantages in certain
   15.90 +special circumstances.
   15.91 +
   15.92 +  For example, on rare occasions, there may be a special need to
   15.93 +encourage the widest possible use of a certain library, so that it becomes
   15.94 +a de-facto standard.  To achieve this, non-free programs must be
   15.95 +allowed to use the library.  A more frequent case is that a free
   15.96 +library does the same job as widely used non-free libraries.  In this
   15.97 +case, there is little to gain by limiting the free library to free
   15.98 +software only, so we use the Lesser General Public License.
   15.99 +
  15.100 +  In other cases, permission to use a particular library in non-free
  15.101 +programs enables a greater number of people to use a large body of
  15.102 +free software.  For example, permission to use the GNU C Library in
  15.103 +non-free programs enables many more people to use the whole GNU
  15.104 +operating system, as well as its variant, the GNU/Linux operating
  15.105 +system.
  15.106 +
  15.107 +  Although the Lesser General Public License is Less protective of the
  15.108 +users' freedom, it does ensure that the user of a program that is
  15.109 +linked with the Library has the freedom and the wherewithal to run
  15.110 +that program using a modified version of the Library.
  15.111 +
  15.112 +  The precise terms and conditions for copying, distribution and
  15.113 +modification follow.  Pay close attention to the difference between a
  15.114 +"work based on the library" and a "work that uses the library".  The
  15.115 +former contains code derived from the library, whereas the latter must
  15.116 +be combined with the library in order to run.
  15.117 +
  15.118 +		  GNU LESSER GENERAL PUBLIC LICENSE
  15.119 +   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
  15.120 +
  15.121 +  0. This License Agreement applies to any software library or other
  15.122 +program which contains a notice placed by the copyright holder or
  15.123 +other authorized party saying it may be distributed under the terms of
  15.124 +this Lesser General Public License (also called "this License").
  15.125 +Each licensee is addressed as "you".
  15.126 +
  15.127 +  A "library" means a collection of software functions and/or data
  15.128 +prepared so as to be conveniently linked with application programs
  15.129 +(which use some of those functions and data) to form executables.
  15.130 +
  15.131 +  The "Library", below, refers to any such software library or work
  15.132 +which has been distributed under these terms.  A "work based on the
  15.133 +Library" means either the Library or any derivative work under
  15.134 +copyright law: that is to say, a work containing the Library or a
  15.135 +portion of it, either verbatim or with modifications and/or translated
  15.136 +straightforwardly into another language.  (Hereinafter, translation is
  15.137 +included without limitation in the term "modification".)
  15.138 +
  15.139 +  "Source code" for a work means the preferred form of the work for
  15.140 +making modifications to it.  For a library, complete source code means
  15.141 +all the source code for all modules it contains, plus any associated
  15.142 +interface definition files, plus the scripts used to control compilation
  15.143 +and installation of the library.
  15.144 +
  15.145 +  Activities other than copying, distribution and modification are not
  15.146 +covered by this License; they are outside its scope.  The act of
  15.147 +running a program using the Library is not restricted, and output from
  15.148 +such a program is covered only if its contents constitute a work based
  15.149 +on the Library (independent of the use of the Library in a tool for
  15.150 +writing it).  Whether that is true depends on what the Library does
  15.151 +and what the program that uses the Library does.
  15.152 +  
  15.153 +  1. You may copy and distribute verbatim copies of the Library's
  15.154 +complete source code as you receive it, in any medium, provided that
  15.155 +you conspicuously and appropriately publish on each copy an
  15.156 +appropriate copyright notice and disclaimer of warranty; keep intact
  15.157 +all the notices that refer to this License and to the absence of any
  15.158 +warranty; and distribute a copy of this License along with the
  15.159 +Library.
  15.160 +
  15.161 +  You may charge a fee for the physical act of transferring a copy,
  15.162 +and you may at your option offer warranty protection in exchange for a
  15.163 +fee.
  15.164 +
  15.165 +  2. You may modify your copy or copies of the Library or any portion
  15.166 +of it, thus forming a work based on the Library, and copy and
  15.167 +distribute such modifications or work under the terms of Section 1
  15.168 +above, provided that you also meet all of these conditions:
  15.169 +
  15.170 +    a) The modified work must itself be a software library.
  15.171 +
  15.172 +    b) You must cause the files modified to carry prominent notices
  15.173 +    stating that you changed the files and the date of any change.
  15.174 +
  15.175 +    c) You must cause the whole of the work to be licensed at no
  15.176 +    charge to all third parties under the terms of this License.
  15.177 +
  15.178 +    d) If a facility in the modified Library refers to a function or a
  15.179 +    table of data to be supplied by an application program that uses
  15.180 +    the facility, other than as an argument passed when the facility
  15.181 +    is invoked, then you must make a good faith effort to ensure that,
  15.182 +    in the event an application does not supply such function or
  15.183 +    table, the facility still operates, and performs whatever part of
  15.184 +    its purpose remains meaningful.
  15.185 +
  15.186 +    (For example, a function in a library to compute square roots has
  15.187 +    a purpose that is entirely well-defined independent of the
  15.188 +    application.  Therefore, Subsection 2d requires that any
  15.189 +    application-supplied function or table used by this function must
  15.190 +    be optional: if the application does not supply it, the square
  15.191 +    root function must still compute square roots.)
  15.192 +
  15.193 +These requirements apply to the modified work as a whole.  If
  15.194 +identifiable sections of that work are not derived from the Library,
  15.195 +and can be reasonably considered independent and separate works in
  15.196 +themselves, then this License, and its terms, do not apply to those
  15.197 +sections when you distribute them as separate works.  But when you
  15.198 +distribute the same sections as part of a whole which is a work based
  15.199 +on the Library, the distribution of the whole must be on the terms of
  15.200 +this License, whose permissions for other licensees extend to the
  15.201 +entire whole, and thus to each and every part regardless of who wrote
  15.202 +it.
  15.203 +
  15.204 +Thus, it is not the intent of this section to claim rights or contest
  15.205 +your rights to work written entirely by you; rather, the intent is to
  15.206 +exercise the right to control the distribution of derivative or
  15.207 +collective works based on the Library.
  15.208 +
  15.209 +In addition, mere aggregation of another work not based on the Library
  15.210 +with the Library (or with a work based on the Library) on a volume of
  15.211 +a storage or distribution medium does not bring the other work under
  15.212 +the scope of this License.
  15.213 +
  15.214 +  3. You may opt to apply the terms of the ordinary GNU General Public
  15.215 +License instead of this License to a given copy of the Library.  To do
  15.216 +this, you must alter all the notices that refer to this License, so
  15.217 +that they refer to the ordinary GNU General Public License, version 2,
  15.218 +instead of to this License.  (If a newer version than version 2 of the
  15.219 +ordinary GNU General Public License has appeared, then you can specify
  15.220 +that version instead if you wish.)  Do not make any other change in
  15.221 +these notices.
  15.222 +
  15.223 +  Once this change is made in a given copy, it is irreversible for
  15.224 +that copy, so the ordinary GNU General Public License applies to all
  15.225 +subsequent copies and derivative works made from that copy.
  15.226 +
  15.227 +  This option is useful when you wish to copy part of the code of
  15.228 +the Library into a program that is not a library.
  15.229 +
  15.230 +  4. You may copy and distribute the Library (or a portion or
  15.231 +derivative of it, under Section 2) in object code or executable form
  15.232 +under the terms of Sections 1 and 2 above provided that you accompany
  15.233 +it with the complete corresponding machine-readable source code, which
  15.234 +must be distributed under the terms of Sections 1 and 2 above on a
  15.235 +medium customarily used for software interchange.
  15.236 +
  15.237 +  If distribution of object code is made by offering access to copy
  15.238 +from a designated place, then offering equivalent access to copy the
  15.239 +source code from the same place satisfies the requirement to
  15.240 +distribute the source code, even though third parties are not
  15.241 +compelled to copy the source along with the object code.
  15.242 +
  15.243 +  5. A program that contains no derivative of any portion of the
  15.244 +Library, but is designed to work with the Library by being compiled or
  15.245 +linked with it, is called a "work that uses the Library".  Such a
  15.246 +work, in isolation, is not a derivative work of the Library, and
  15.247 +therefore falls outside the scope of this License.
  15.248 +
  15.249 +  However, linking a "work that uses the Library" with the Library
  15.250 +creates an executable that is a derivative of the Library (because it
  15.251 +contains portions of the Library), rather than a "work that uses the
  15.252 +library".  The executable is therefore covered by this License.
  15.253 +Section 6 states terms for distribution of such executables.
  15.254 +
  15.255 +  When a "work that uses the Library" uses material from a header file
  15.256 +that is part of the Library, the object code for the work may be a
  15.257 +derivative work of the Library even though the source code is not.
  15.258 +Whether this is true is especially significant if the work can be
  15.259 +linked without the Library, or if the work is itself a library.  The
  15.260 +threshold for this to be true is not precisely defined by law.
  15.261 +
  15.262 +  If such an object file uses only numerical parameters, data
  15.263 +structure layouts and accessors, and small macros and small inline
  15.264 +functions (ten lines or less in length), then the use of the object
  15.265 +file is unrestricted, regardless of whether it is legally a derivative
  15.266 +work.  (Executables containing this object code plus portions of the
  15.267 +Library will still fall under Section 6.)
  15.268 +
  15.269 +  Otherwise, if the work is a derivative of the Library, you may
  15.270 +distribute the object code for the work under the terms of Section 6.
  15.271 +Any executables containing that work also fall under Section 6,
  15.272 +whether or not they are linked directly with the Library itself.
  15.273 +
  15.274 +  6. As an exception to the Sections above, you may also combine or
  15.275 +link a "work that uses the Library" with the Library to produce a
  15.276 +work containing portions of the Library, and distribute that work
  15.277 +under terms of your choice, provided that the terms permit
  15.278 +modification of the work for the customer's own use and reverse
  15.279 +engineering for debugging such modifications.
  15.280 +
  15.281 +  You must give prominent notice with each copy of the work that the
  15.282 +Library is used in it and that the Library and its use are covered by
  15.283 +this License.  You must supply a copy of this License.  If the work
  15.284 +during execution displays copyright notices, you must include the
  15.285 +copyright notice for the Library among them, as well as a reference
  15.286 +directing the user to the copy of this License.  Also, you must do one
  15.287 +of these things:
  15.288 +
  15.289 +    a) Accompany the work with the complete corresponding
  15.290 +    machine-readable source code for the Library including whatever
  15.291 +    changes were used in the work (which must be distributed under
  15.292 +    Sections 1 and 2 above); and, if the work is an executable linked
  15.293 +    with the Library, with the complete machine-readable "work that
  15.294 +    uses the Library", as object code and/or source code, so that the
  15.295 +    user can modify the Library and then relink to produce a modified
  15.296 +    executable containing the modified Library.  (It is understood
  15.297 +    that the user who changes the contents of definitions files in the
  15.298 +    Library will not necessarily be able to recompile the application
  15.299 +    to use the modified definitions.)
  15.300 +
  15.301 +    b) Use a suitable shared library mechanism for linking with the
  15.302 +    Library.  A suitable mechanism is one that (1) uses at run time a
  15.303 +    copy of the library already present on the user's computer system,
  15.304 +    rather than copying library functions into the executable, and (2)
  15.305 +    will operate properly with a modified version of the library, if
  15.306 +    the user installs one, as long as the modified version is
  15.307 +    interface-compatible with the version that the work was made with.
  15.308 +
  15.309 +    c) Accompany the work with a written offer, valid for at
  15.310 +    least three years, to give the same user the materials
  15.311 +    specified in Subsection 6a, above, for a charge no more
  15.312 +    than the cost of performing this distribution.
  15.313 +
  15.314 +    d) If distribution of the work is made by offering access to copy
  15.315 +    from a designated place, offer equivalent access to copy the above
  15.316 +    specified materials from the same place.
  15.317 +
  15.318 +    e) Verify that the user has already received a copy of these
  15.319 +    materials or that you have already sent this user a copy.
  15.320 +
  15.321 +  For an executable, the required form of the "work that uses the
  15.322 +Library" must include any data and utility programs needed for
  15.323 +reproducing the executable from it.  However, as a special exception,
  15.324 +the materials to be distributed need not include anything that is
  15.325 +normally distributed (in either source or binary form) with the major
  15.326 +components (compiler, kernel, and so on) of the operating system on
  15.327 +which the executable runs, unless that component itself accompanies
  15.328 +the executable.
  15.329 +
  15.330 +  It may happen that this requirement contradicts the license
  15.331 +restrictions of other proprietary libraries that do not normally
  15.332 +accompany the operating system.  Such a contradiction means you cannot
  15.333 +use both them and the Library together in an executable that you
  15.334 +distribute.
  15.335 +
  15.336 +  7. You may place library facilities that are a work based on the
  15.337 +Library side-by-side in a single library together with other library
  15.338 +facilities not covered by this License, and distribute such a combined
  15.339 +library, provided that the separate distribution of the work based on
  15.340 +the Library and of the other library facilities is otherwise
  15.341 +permitted, and provided that you do these two things:
  15.342 +
  15.343 +    a) Accompany the combined library with a copy of the same work
  15.344 +    based on the Library, uncombined with any other library
  15.345 +    facilities.  This must be distributed under the terms of the
  15.346 +    Sections above.
  15.347 +
  15.348 +    b) Give prominent notice with the combined library of the fact
  15.349 +    that part of it is a work based on the Library, and explaining
  15.350 +    where to find the accompanying uncombined form of the same work.
  15.351 +
  15.352 +  8. You may not copy, modify, sublicense, link with, or distribute
  15.353 +the Library except as expressly provided under this License.  Any
  15.354 +attempt otherwise to copy, modify, sublicense, link with, or
  15.355 +distribute the Library is void, and will automatically terminate your
  15.356 +rights under this License.  However, parties who have received copies,
  15.357 +or rights, from you under this License will not have their licenses
  15.358 +terminated so long as such parties remain in full compliance.
  15.359 +
  15.360 +  9. You are not required to accept this License, since you have not
  15.361 +signed it.  However, nothing else grants you permission to modify or
  15.362 +distribute the Library or its derivative works.  These actions are
  15.363 +prohibited by law if you do not accept this License.  Therefore, by
  15.364 +modifying or distributing the Library (or any work based on the
  15.365 +Library), you indicate your acceptance of this License to do so, and
  15.366 +all its terms and conditions for copying, distributing or modifying
  15.367 +the Library or works based on it.
  15.368 +
  15.369 +  10. Each time you redistribute the Library (or any work based on the
  15.370 +Library), the recipient automatically receives a license from the
  15.371 +original licensor to copy, distribute, link with or modify the Library
  15.372 +subject to these terms and conditions.  You may not impose any further
  15.373 +restrictions on the recipients' exercise of the rights granted herein.
  15.374 +You are not responsible for enforcing compliance by third parties with
  15.375 +this License.
  15.376 +
  15.377 +  11. If, as a consequence of a court judgment or allegation of patent
  15.378 +infringement or for any other reason (not limited to patent issues),
  15.379 +conditions are imposed on you (whether by court order, agreement or
  15.380 +otherwise) that contradict the conditions of this License, they do not
  15.381 +excuse you from the conditions of this License.  If you cannot
  15.382 +distribute so as to satisfy simultaneously your obligations under this
  15.383 +License and any other pertinent obligations, then as a consequence you
  15.384 +may not distribute the Library at all.  For example, if a patent
  15.385 +license would not permit royalty-free redistribution of the Library by
  15.386 +all those who receive copies directly or indirectly through you, then
  15.387 +the only way you could satisfy both it and this License would be to
  15.388 +refrain entirely from distribution of the Library.
  15.389 +
  15.390 +If any portion of this section is held invalid or unenforceable under any
  15.391 +particular circumstance, the balance of the section is intended to apply,
  15.392 +and the section as a whole is intended to apply in other circumstances.
  15.393 +
  15.394 +It is not the purpose of this section to induce you to infringe any
  15.395 +patents or other property right claims or to contest validity of any
  15.396 +such claims; this section has the sole purpose of protecting the
  15.397 +integrity of the free software distribution system which is
  15.398 +implemented by public license practices.  Many people have made
  15.399 +generous contributions to the wide range of software distributed
  15.400 +through that system in reliance on consistent application of that
  15.401 +system; it is up to the author/donor to decide if he or she is willing
  15.402 +to distribute software through any other system and a licensee cannot
  15.403 +impose that choice.
  15.404 +
  15.405 +This section is intended to make thoroughly clear what is believed to
  15.406 +be a consequence of the rest of this License.
  15.407 +
  15.408 +  12. If the distribution and/or use of the Library is restricted in
  15.409 +certain countries either by patents or by copyrighted interfaces, the
  15.410 +original copyright holder who places the Library under this License may add
  15.411 +an explicit geographical distribution limitation excluding those countries,
  15.412 +so that distribution is permitted only in or among countries not thus
  15.413 +excluded.  In such case, this License incorporates the limitation as if
  15.414 +written in the body of this License.
  15.415 +
  15.416 +  13. The Free Software Foundation may publish revised and/or new
  15.417 +versions of the Lesser General Public License from time to time.
  15.418 +Such new versions will be similar in spirit to the present version,
  15.419 +but may differ in detail to address new problems or concerns.
  15.420 +
  15.421 +Each version is given a distinguishing version number.  If the Library
  15.422 +specifies a version number of this License which applies to it and
  15.423 +"any later version", you have the option of following the terms and
  15.424 +conditions either of that version or of any later version published by
  15.425 +the Free Software Foundation.  If the Library does not specify a
  15.426 +license version number, you may choose any version ever published by
  15.427 +the Free Software Foundation.
  15.428 +
  15.429 +  14. If you wish to incorporate parts of the Library into other free
  15.430 +programs whose distribution conditions are incompatible with these,
  15.431 +write to the author to ask for permission.  For software which is
  15.432 +copyrighted by the Free Software Foundation, write to the Free
  15.433 +Software Foundation; we sometimes make exceptions for this.  Our
  15.434 +decision will be guided by the two goals of preserving the free status
  15.435 +of all derivatives of our free software and of promoting the sharing
  15.436 +and reuse of software generally.
  15.437 +
  15.438 +			    NO WARRANTY
  15.439 +
  15.440 +  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
  15.441 +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
  15.442 +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
  15.443 +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
  15.444 +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
  15.445 +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  15.446 +PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
  15.447 +LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
  15.448 +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
  15.449 +
  15.450 +  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
  15.451 +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
  15.452 +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
  15.453 +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
  15.454 +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
  15.455 +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
  15.456 +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
  15.457 +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
  15.458 +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  15.459 +DAMAGES.
  15.460 +
  15.461 +		     END OF TERMS AND CONDITIONS
  15.462 +
  15.463 +           How to Apply These Terms to Your New Libraries
  15.464 +
  15.465 +  If you develop a new library, and you want it to be of the greatest
  15.466 +possible use to the public, we recommend making it free software that
  15.467 +everyone can redistribute and change.  You can do so by permitting
  15.468 +redistribution under these terms (or, alternatively, under the terms of the
  15.469 +ordinary General Public License).
  15.470 +
  15.471 +  To apply these terms, attach the following notices to the library.  It is
  15.472 +safest to attach them to the start of each source file to most effectively
  15.473 +convey the exclusion of warranty; and each file should have at least the
  15.474 +"copyright" line and a pointer to where the full notice is found.
  15.475 +
  15.476 +    <one line to give the library's name and a brief idea of what it does.>
  15.477 +    Copyright (C) <year>  <name of author>
  15.478 +
  15.479 +    This library is free software; you can redistribute it and/or
  15.480 +    modify it under the terms of the GNU Lesser General Public
  15.481 +    License as published by the Free Software Foundation; either
  15.482 +    version 2.1 of the License, or (at your option) any later version.
  15.483 +
  15.484 +    This library is distributed in the hope that it will be useful,
  15.485 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.486 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.487 +    Lesser General Public License for more details.
  15.488 +
  15.489 +    You should have received a copy of the GNU Lesser General Public
  15.490 +    License along with this library; if not, write to the Free Software
  15.491 +    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  15.492 +
  15.493 +Also add information on how to contact you by electronic and paper mail.
  15.494 +
  15.495 +You should also get your employer (if you work as a programmer) or your
  15.496 +school, if any, to sign a "copyright disclaimer" for the library, if
  15.497 +necessary.  Here is a sample; alter the names:
  15.498 +
  15.499 +  Yoyodyne, Inc., hereby disclaims all copyright interest in the
  15.500 +  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
  15.501 +
  15.502 +  <signature of Ty Coon>, 1 April 1990
  15.503 +  Ty Coon, President of Vice
  15.504 +
  15.505 +That's all there is to it!
  15.506 +
  15.507 +

    16.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    16.2 +++ b/readme.txt	Fri Oct 21 05:53:11 2011 -0700
    16.3 @@ -0,0 +1,86 @@
    16.4 +snes_spc 0.9.0: SNES SPC-700 APU Emulator
    16.5 +-----------------------------------------
    16.6 +This library includes a full SPC emulator and an S-DSP emulator that can
    16.7 +be used on its own. Two S-DSP emulators are available: a highly accurate
    16.8 +one for use in a SNES emulator, and a 3x faster one for use in an SPC
    16.9 +music player or a resource-limited SNES emulator.
   16.10 +
   16.11 +* Can be used from C and C++ code
   16.12 +* Full SPC-700 APU emulator with cycle accuracy in most cases
   16.13 +* Loads, plays, and saves SPC music files
   16.14 +* Can save and load exact full emulator state
   16.15 +* DSP voice muting, surround sound disable, and song tempo adjustment
   16.16 +* Uses 7% CPU average on 400 MHz Mac to play an SPC using fast DSP
   16.17 +
   16.18 +The accurate DSP emulator is based on past research by others and
   16.19 +hundreds of hours of recent research by me. It passes over a hundred
   16.20 +strenuous timing and behavior validation tests that were also run on the
   16.21 +SNES. As far as I know, it's the first DSP emulator with cycle accuracy,
   16.22 +properly emulating every DSP register and memory access at the exact SPC
   16.23 +cycle it occurs at, whereas previous DSP emulators emulated these only
   16.24 +to the nearest sample (which occurs every 32 clocks).
   16.25 +
   16.26 +Author : Shay Green <gblargg@gmail.com>
   16.27 +Website: http://www.slack.net/~ant/
   16.28 +Forum  : http://groups.google.com/group/blargg-sound-libs
   16.29 +License: GNU Lesser General Public License (LGPL)
   16.30 +
   16.31 +
   16.32 +Getting Started
   16.33 +---------------
   16.34 +Build a program consisting of demo/play_spc.c, demo/demo_util.c,
   16.35 +demo/wave_writer.c, and all source files in snes_spc/. Put an SPC music
   16.36 +file in the same directory and name it "test.spc". Running the program
   16.37 +should generate the recording "out.wav".
   16.38 +
   16.39 +Read snes_spc.txt for more information. Post to the discussion forum for
   16.40 +assistance.
   16.41 +
   16.42 +
   16.43 +Files
   16.44 +-----
   16.45 +snes_spc.txt            Documentation
   16.46 +changes.txt             Change log
   16.47 +license.txt             GNU LGPL license
   16.48 +
   16.49 +demo/
   16.50 +  play_spc.c            Records SPC file to wave sound file
   16.51 +  benchmark.c           Finds how fast emulator runs on your computer
   16.52 +  trim_spc.c            Trims silence off beginning of an SPC file
   16.53 +  save_state.c          Saves/loads exact emulator state to/from file
   16.54 +  comm.c                Communicates with SPC how SNES would
   16.55 +  demo_util.h           General utility functions used by demos
   16.56 +  demo_util.c
   16.57 +  wave_writer.h         WAVE sound file writer used for demo output
   16.58 +  wave_writer.c
   16.59 +
   16.60 +fast_dsp/               Optional standalone fast DSP emulator
   16.61 +  SPC_DSP.h             To use with full SPC emulator, move into
   16.62 +  SPC_DSP.cpp           snes_spc/ and replace original files
   16.63 +
   16.64 +snes_spc/               Library sources
   16.65 +  blargg_config.h       Configuration (modify as necessary)
   16.66 +  
   16.67 +  spc.h                 C interface to SPC emulator and sound filter
   16.68 +  spc.cpp
   16.69 +  
   16.70 +  SPC_Filter.h          Optional filter to make sound more authentic
   16.71 +  SPC_Filter.cpp
   16.72 +  
   16.73 +  SNES_SPC.h            Full SPC emulator
   16.74 +  SNES_SPC.cpp
   16.75 +  SNES_SPC_misc.cpp
   16.76 +  SNES_SPC_state.cpp
   16.77 +  SPC_CPU.h
   16.78 +  
   16.79 +  dsp.h                 C interface to DSP emulator
   16.80 +  dsp.cpp
   16.81 +  
   16.82 +  SPC_DSP.h             Standalone accurate DSP emulator
   16.83 +  SPC_DSP.cpp
   16.84 +  blargg_common.h
   16.85 +  blargg_endian.h
   16.86 +  blargg_source.h
   16.87 +
   16.88 +-- 
   16.89 +Shay Green <gblargg@gmail.com>

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/snes_spc.txt	Fri Oct 21 05:53:11 2011 -0700
    17.3 @@ -0,0 +1,318 @@
    17.4 +snes_spc 0.9.0: SNES SPC-700 APU Emulator
    17.5 +-----------------------------------------
    17.6 +Author : Shay Green <gblargg@gmail.com>
    17.7 +Website: http://www.slack.net/~ant/
    17.8 +Forum  : http://groups.google.com/group/blargg-sound-libs
    17.9 +License: GNU Lesser General Public License (LGPL)
   17.10 +
   17.11 +
   17.12 +Contents
   17.13 +--------
   17.14 +* C and C++ Interfaces
   17.15 +* Overview
   17.16 +* Full SPC Emulation
   17.17 +* DSP Emulation
   17.18 +* SPC Music Playback
   17.19 +* State Copying
   17.20 +* Library Compilation
   17.21 +* Error handling
   17.22 +* Solving Problems
   17.23 +* Accurate S-DSP Limitations
   17.24 +* Fast S-DSP Limitations
   17.25 +* S-SMP Limitations
   17.26 +* To Do
   17.27 +* Thanks
   17.28 +
   17.29 +
   17.30 +C and C++ Interfaces
   17.31 +--------------------
   17.32 +The library includes a C interface in spc.h and dsp.h, which can be used
   17.33 +from C and C++. This C interface is referred to in the following
   17.34 +documentation. If you're building this as a shared library (rather than
   17.35 +linking statically), you should use the C interface since it will change
   17.36 +less in future versions.
   17.37 +
   17.38 +The native C++ interface is in the header files SNES_SPC.h, SPC_DSP.h,
   17.39 +and SPC_Filter.h, and the two interfaces can be freely mixed in C++
   17.40 +code. Conversion between the two interfaces generally follows a pattern:
   17.41 +
   17.42 +	C interface                     C++ interface
   17.43 +	- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   17.44 +	SNES_SPC* spc;                  SNES_SPC* spc;
   17.45 +	
   17.46 +	spc = spc_new();                spc = new SNES_SPC;
   17.47 +	
   17.48 +	spc_play( spc, count, buf );    spc->play( count, buf );
   17.49 +	
   17.50 +	spc_sample_rate                 SNES_SPC::sample_rate
   17.51 +	
   17.52 +	spc_delete( spc );              delete spc;
   17.53 +
   17.54 +
   17.55 +Overview
   17.56 +--------
   17.57 +There are three main roles for this library:
   17.58 +* Full SPC emulation in a SNES emulator
   17.59 +* DSP emulation in a SNES emulator (where you emulate the SMP CPU)
   17.60 +* SPC playback in an SPC music file player
   17.61 +
   17.62 +Each of these uses are described separately below.
   17.63 +
   17.64 +
   17.65 +Full SPC Emulation
   17.66 +------------------
   17.67 +See spc.h for full function reference (SNES_SPC.h if using C++).
   17.68 +
   17.69 +* Create SPC emulator with spc_new() and check for NULL.
   17.70 +
   17.71 +* Call spc_init_rom() with a pointer to the 64-byte IPL ROM dump (not
   17.72 +included with library).
   17.73 +
   17.74 +* When your emulated SNES is powered on, call spc_reset(). When the
   17.75 +reset switch is pressed, call spc_soft_reset().
   17.76 +
   17.77 +* Call spc_set_output() with your output buffer, then do emulation.
   17.78 +
   17.79 +* When the SNES CPU accesses APU ports, call spc_read_port() and
   17.80 +spc_write_port().
   17.81 +
   17.82 +* When your emulator's timebase is going back to 0, call
   17.83 +spc_end_frame(), usually at the end of a video frame or scanline.
   17.84 +
   17.85 +* Periodically play samples from your buffer. Use spc_sample_count() to
   17.86 +find out how many samples have been written, then spc_set_output() after
   17.87 +you've made more space in your buffer.
   17.88 +
   17.89 +* Save/load full emulator state with spc_copy_state().
   17.90 +
   17.91 +* You can save as an SPC music file with spc_save_spc().
   17.92 +
   17.93 +* When done, use spc_delete() to free memory.
   17.94 +
   17.95 +
   17.96 +DSP Emulation
   17.97 +-------------
   17.98 +See dsp.h for full function reference (SPC_DSP.h if using C++).
   17.99 +
  17.100 +* Create DSP emulator with spc_dsp_new() and check for NULL.
  17.101 +
  17.102 +* Let the DSP know where your 64K RAM is with spc_dsp_init().
  17.103 +
  17.104 +* When your emulated SNES is powered on, call spc_dsp_reset(). When the
  17.105 +reset switch is pressed, call spc_dsp_soft_reset().
  17.106 +
  17.107 +* Call spc_dsp_set_output() with your output buffer, then do emulation.
  17.108 +
  17.109 +* Use spc_dsp_run() to run DSP for specified number of clocks (1024000
  17.110 +per second). Every 32 clocks a pair of samples is added to your output
  17.111 +buffer.
  17.112 +
  17.113 +* Use spc_dsp_read() and spc_dsp_write() to handle DSP reads/writes from
  17.114 +the S-SMP. Before calling these always catch the DSP up to present time
  17.115 +with spc_dsp_run().
  17.116 +
  17.117 +* Periodically play samples from your buffer. Use spc_dsp_sample_count()
  17.118 +to find out how many samples have been written, then
  17.119 +spc_dsp_set_output() after you've made more space in your buffer.
  17.120 +
  17.121 +* Use spc_dsp_copy_state() to save/load full DSP state.
  17.122 +
  17.123 +* When done, use spc_delete() to free memory.
  17.124 +
  17.125 +
  17.126 +SPC Music Playback
  17.127 +------------------
  17.128 +See spc.h for full function reference (SNES_SPC.h if using C++).
  17.129 +
  17.130 +* Create SPC emulator with spc_new() and check for NULL.
  17.131 +
  17.132 +* Load SPC with spc_load_spc() and check for error.
  17.133 +
  17.134 +* Optionally cear echo buffer with spc_clear_echo(). Many SPCs have
  17.135 +garbage in echo buffer, which causes noise at the beginning.
  17.136 +
  17.137 +* Generate samples as needed with spc_play().
  17.138 +
  17.139 +* When done, use spc_delete() to free memory.
  17.140 +
  17.141 +* For a more complete game music playback library, use Game_Music_Emu
  17.142 +
  17.143 +
  17.144 +State Copying
  17.145 +-------------
  17.146 +The SPC and DSP modules include state save/load functions. They take a
  17.147 +pointer to a pointer to a buffer to store state, and a copy function.
  17.148 +This copy function can either copy data to the buffer or from it,
  17.149 +allowing state save and restore with the same library function. The
  17.150 +internal save state format allows for future expansion without making
  17.151 +previous save states unusable.
  17.152 +
  17.153 +The SPC save state format puts the most important parts first to make it
  17.154 +easier to manually examine. It's organized as follows:
  17.155 +
  17.156 +Offset  Size    Data
  17.157 +- - - - - - - - - - - - - - - - - -
  17.158 +     0 $10000   SPC RAM
  17.159 +$10000    $10   SMP $F0-$FF registers
  17.160 +$10010      4   SMP $F4-$F8 output registers
  17.161 +$10014      2   PC
  17.162 +$10016      1   A
  17.163 +$10017      1   X
  17.164 +$10018      1   Y
  17.165 +$10019      1   PSW
  17.166 +$1001A      1   SP
  17.167 +$1001B      5   internal
  17.168 +$10020    $80   DSP registers
  17.169 +$100A0    ...   internal
  17.170 +
  17.171 +
  17.172 +Library Compilation
  17.173 +-------------------
  17.174 +While this library is in C++, it has been written to easily link in a C
  17.175 +program *without* needing the standard C++ library. It doesn't use
  17.176 +exception handling or run-time type information (RTTI), so you can
  17.177 +disable these in your C++ compiler to increase efficiency.
  17.178 +
  17.179 +If you're building a shared library (DLL), I recommend only exporting
  17.180 +the C interfaces in spc.h and dsp.h, as the C++ interfaces expose
  17.181 +implementation details that will break link compatibility across
  17.182 +versions.
  17.183 +
  17.184 +If you're using C and compiling with GCC, I recommend the following
  17.185 +command-line options when compiling the library source, otherwise GCC
  17.186 +will insert calls to the standard C++ library and require that it be
  17.187 +linked in:
  17.188 +
  17.189 +	-fno-rtti -fno-exceptions
  17.190 +
  17.191 +For maximum optimization, see the NDEBUG and BLARGG_NONPORTABLE options
  17.192 +in blargg_config. If using GCC, you can enable these by adding the
  17.193 +following command-line options when you invoke gcc. If you encounter
  17.194 +problems, try without -DBLARGG_NONPORTABLE; if that works, contact me so
  17.195 +I can figure out why BLARGG_NONPORTABLE was causing it to fail.
  17.196 +
  17.197 +	-O3 -DNDEBUG -DBLARGG_NONPORTABLE -fno-rtti -fno-exceptions
  17.198 +
  17.199 +
  17.200 +
  17.201 +Error handling
  17.202 +--------------
  17.203 +Functions which can fail have a return type of spc_err_t (blargg_err_t
  17.204 +in the C++ interfaces), which is a pointer to an error string (const
  17.205 +char*). If a function is successful it returns NULL. Errors that you can
  17.206 +easily avoid are checked with debug assertions; spc_err_t return values
  17.207 +are only used for genuine run-time errors that can't be easily predicted
  17.208 +in advance (out of memory, I/O errors, incompatible file data). Your
  17.209 +code should check all error values.
  17.210 +
  17.211 +To improve usability for C programmers, C++ programmers unfamiliar with
  17.212 +exceptions, and compatibility with older C++ compilers, the library does
  17.213 +*not* throw any C++ exceptions and uses malloc() instead of the standard
  17.214 +operator new. This means that you *must* check for NULL when creating a
  17.215 +library object with the new operator.
  17.216 +
  17.217 +
  17.218 +Solving Problems
  17.219 +----------------
  17.220 +If you're having problems, try the following:
  17.221 +
  17.222 +* If you're getting garbled sound, try this simple siren generator in
  17.223 +place of your call to play(). This will quickly tell whether the problem
  17.224 +is in the library or in your code.
  17.225 +
  17.226 +	static void play_siren( long count, short* out )
  17.227 +	{
  17.228 +		static double a, a2;
  17.229 +		while ( count-- )
  17.230 +			*out++ = 0x2000 * sin( a += .1 + .05*sin( a2+=.00005 ) );
  17.231 +	}
  17.232 +
  17.233 +* Enable debugging support in your environment. This enables assertions
  17.234 +and other run-time checks.
  17.235 +
  17.236 +* Turn the compiler's optimizer is off. Sometimes an optimizer generates
  17.237 +bad code.
  17.238 +
  17.239 +* If multiple threads are being used, ensure that only one at a time is
  17.240 +accessing a given set of objects from the library. This library is not
  17.241 +in general thread-safe, though independent objects can be used in
  17.242 +separate threads.
  17.243 +
  17.244 +* If all else fails, see if the demos work.
  17.245 +
  17.246 +
  17.247 +Accurate S-DSP Limitations
  17.248 +--------------------------
  17.249 +* Power-up and soft reset behavior might have slight inaccuracies.
  17.250 +
  17.251 +* Muting (FLG bit 6) behavior when toggling bit very rapidly is not
  17.252 +emulated properly.
  17.253 +
  17.254 +* No other known inaccuracies. Has passed 100+ strenuous tests.
  17.255 +
  17.256 +
  17.257 +Fast S-DSP Limitations
  17.258 +----------------------
  17.259 +* Uses faster sample calculations except in cases where exact value is
  17.260 +actually important (BRR decoding, and gaussian interpolation combined
  17.261 +with pitch modulation).
  17.262 +
  17.263 +* Stops decoding BRR data when a voice's envelope has released to
  17.264 +silence.
  17.265 +
  17.266 +* Emulates 32 clocks at a time, so DSP register and memory accesses are
  17.267 +all done in a bunch rather than spread out. Even though, some clever
  17.268 +code makes register accesses separated by 40 or so clocks occur with
  17.269 +cycle-accurate timing.
  17.270 +
  17.271 +
  17.272 +S-SMP Limitations
  17.273 +-----------------
  17.274 +* Opcode fetches and indirect pointers are always read directly from
  17.275 +memory, even for the $F0-$FF region, and the DSP is not caught up for
  17.276 +these fetches.
  17.277 +
  17.278 +* Attempts to perversely execute data in registers or an area being
  17.279 +modified by echo will not be emulated properly.
  17.280 +
  17.281 +* Has not been thoroughly tested.
  17.282 +
  17.283 +* Test register ($F0) is not implemented.
  17.284 +
  17.285 +* Echo buffer can overwrite IPL ROM area, and does not correctly update
  17.286 +extra RAM there.
  17.287 +
  17.288 +
  17.289 +To Do
  17.290 +-----
  17.291 +* I'd like feedback on the interface and any ways to improve it. In
  17.292 +particular, the differing features between the accurate and fast DSP
  17.293 +emulators might make it harder to cleanly switch between them without
  17.294 +modifying source code.
  17.295 +
  17.296 +* Finish thorough tests on SMP memory access times.
  17.297 +
  17.298 +* Finish thorough tests on SMP instruction behavior (flags, registers).
  17.299 +
  17.300 +* Finish thorough tests on SMP timers.
  17.301 +
  17.302 +* Finish power-up and reset behavior testing.
  17.303 +
  17.304 +* Come up with best starting conditions to play an SPC and implement in
  17.305 +hardware SNES SPC player for verification.
  17.306 +
  17.307 +
  17.308 +Thanks
  17.309 +------
  17.310 +Thanks to Anti-Resonance's SPC2ROM and help getting SPCs playing on my
  17.311 +SNES in the first place, then Brad Martin's openspc and Chris Moeller's
  17.312 +openspc++ C++ adaptation, giving me a good SPC emulator to start with
  17.313 +several years ago. Thanks to Richard Bannister, Mahendra Tallur, Shazz,
  17.314 +nenolod, theHobbit, Johan Samuelsson, nes6502, and Micket for helping
  17.315 +test my Game_Music_Emu library. Thanks to hcs for help in converting to
  17.316 +C for the Rockbox port. Thanks to byuu (bsnes author) and pagefault and
  17.317 +Nach (zsnes team) for testing and using my new rewritten DSP in their
  17.318 +emulators. Thanks to anomie for his good SNES documentation and
  17.319 +discussions with me to keep it up to date with my latest findings.
  17.320 +-- 
  17.321 +Shay Green <gblargg@gmail.com>

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/snes_spc/SNES_SPC.cpp	Fri Oct 21 05:53:11 2011 -0700
    18.3 @@ -0,0 +1,564 @@
    18.4 +// Core SPC emulation: CPU, timers, SMP registers, memory
    18.5 +
    18.6 +// snes_spc 0.9.0. http://www.slack.net/~ant/
    18.7 +
    18.8 +#include "SNES_SPC.h"
    18.9 +
   18.10 +#include <string.h>
   18.11 +
   18.12 +/* Copyright (C) 2004-2007 Shay Green. This module is free software; you
   18.13 +can redistribute it and/or modify it under the terms of the GNU Lesser
   18.14 +General Public License as published by the Free Software Foundation; either
   18.15 +version 2.1 of the License, or (at your option) any later version. This
   18.16 +module is distributed in the hope that it will be useful, but WITHOUT ANY
   18.17 +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   18.18 +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   18.19 +details. You should have received a copy of the GNU Lesser General Public
   18.20 +License along with this module; if not, write to the Free Software Foundation,
   18.21 +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
   18.22 +
   18.23 +#include "blargg_source.h"
   18.24 +
   18.25 +#define RAM         (m.ram.ram)
   18.26 +#define REGS        (m.smp_regs [0])
   18.27 +#define REGS_IN     (m.smp_regs [1])
   18.28 +
   18.29 +// (n ? n : 256)
   18.30 +#define IF_0_THEN_256( n ) ((uint8_t) ((n) - 1) + 1)
   18.31 +
   18.32 +// Note: SPC_MORE_ACCURACY exists mainly so I can run my validation tests, which
   18.33 +// do crazy echo buffer accesses.
   18.34 +#ifndef SPC_MORE_ACCURACY
   18.35 +	#define SPC_MORE_ACCURACY 0
   18.36 +#endif
   18.37 +
   18.38 +#ifdef BLARGG_ENABLE_OPTIMIZER
   18.39 +	#include BLARGG_ENABLE_OPTIMIZER
   18.40 +#endif
   18.41 +
   18.42 +
   18.43 +//// Timers
   18.44 +
   18.45 +#if SPC_DISABLE_TEMPO
   18.46 +	#define TIMER_DIV( t, n ) ((n) >> t->prescaler)
   18.47 +	#define TIMER_MUL( t, n ) ((n) << t->prescaler)
   18.48 +#else
   18.49 +	#define TIMER_DIV( t, n ) ((n) / t->prescaler)
   18.50 +	#define TIMER_MUL( t, n ) ((n) * t->prescaler)
   18.51 +#endif
   18.52 +
   18.53 +SNES_SPC::Timer* SNES_SPC::run_timer_( Timer* t, rel_time_t time )
   18.54 +{
   18.55 +	int elapsed = TIMER_DIV( t, time - t->next_time ) + 1;
   18.56 +	t->next_time += TIMER_MUL( t, elapsed );
   18.57 +	
   18.58 +	if ( t->enabled )
   18.59 +	{
   18.60 +		int remain = IF_0_THEN_256( t->period - t->divider );
   18.61 +		int divider = t->divider + elapsed;
   18.62 +		int over = elapsed - remain;
   18.63 +		if ( over >= 0 )
   18.64 +		{
   18.65 +			int n = over / t->period;
   18.66 +			t->counter = (t->counter + 1 + n) & 0x0F;
   18.67 +			divider = over - n * t->period;
   18.68 +		}
   18.69 +		t->divider = (uint8_t) divider;
   18.70 +	}
   18.71 +	return t;
   18.72 +}
   18.73 +
   18.74 +inline SNES_SPC::Timer* SNES_SPC::run_timer( Timer* t, rel_time_t time )
   18.75 +{
   18.76 +	if ( time >= t->next_time )
   18.77 +		t = run_timer_( t, time );
   18.78 +	return t;
   18.79 +}
   18.80 +
   18.81 +
   18.82 +//// ROM
   18.83 +
   18.84 +void SNES_SPC::enable_rom( int enable )
   18.85 +{
   18.86 +	if ( m.rom_enabled != enable )
   18.87 +	{
   18.88 +		m.rom_enabled = enable;
   18.89 +		if ( enable )
   18.90 +			memcpy( m.hi_ram, &RAM [rom_addr], sizeof m.hi_ram );
   18.91 +		memcpy( &RAM [rom_addr], (enable ? m.rom : m.hi_ram), rom_size );
   18.92 +		// TODO: ROM can still get overwritten when DSP writes to echo buffer
   18.93 +	}
   18.94 +}
   18.95 +
   18.96 +
   18.97 +//// DSP
   18.98 +
   18.99 +#if SPC_LESS_ACCURATE
  18.100 +	int const max_reg_time = 29;
  18.101 +	
  18.102 +	signed char const SNES_SPC::reg_times_ [256] =
  18.103 +	{
  18.104 +		 -1,  0,-11,-10,-15,-11, -2, -2,  4,  3, 14, 14, 26, 26, 14, 22,
  18.105 +		  2,  3,  0,  1,-12,  0,  1,  1,  7,  6, 14, 14, 27, 14, 14, 23,
  18.106 +		  5,  6,  3,  4, -1,  3,  4,  4, 10,  9, 14, 14, 26, -5, 14, 23,
  18.107 +		  8,  9,  6,  7,  2,  6,  7,  7, 13, 12, 14, 14, 27, -4, 14, 24,
  18.108 +		 11, 12,  9, 10,  5,  9, 10, 10, 16, 15, 14, 14, -2, -4, 14, 24,
  18.109 +		 14, 15, 12, 13,  8, 12, 13, 13, 19, 18, 14, 14, -2,-36, 14, 24,
  18.110 +		 17, 18, 15, 16, 11, 15, 16, 16, 22, 21, 14, 14, 28, -3, 14, 25,
  18.111 +		 20, 21, 18, 19, 14, 18, 19, 19, 25, 24, 14, 14, 14, 29, 14, 25,
  18.112 +		 
  18.113 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.114 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.115 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.116 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.117 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.118 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.119 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.120 +		 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
  18.121 +	};
  18.122 +	
  18.123 +	#define RUN_DSP( time, offset ) \
  18.124 +		int count = (time) - (offset) - m.dsp_time;\
  18.125 +		if ( count >= 0 )\
  18.126 +		{\
  18.127 +			int clock_count = (count & ~(clocks_per_sample - 1)) + clocks_per_sample;\
  18.128 +			m.dsp_time += clock_count;\
  18.129 +			dsp.run( clock_count );\
  18.130 +		}
  18.131 +#else
  18.132 +	#define RUN_DSP( time, offset ) \
  18.133 +		{\
  18.134 +			int count = (time) - m.dsp_time;\
  18.135 +			if ( !SPC_MORE_ACCURACY || count )\
  18.136 +			{\
  18.137 +				assert( count > 0 );\
  18.138 +				m.dsp_time = (time);\
  18.139 +				dsp.run( count );\
  18.140 +			}\
  18.141 +		}
  18.142 +#endif
  18.143 +
  18.144 +int SNES_SPC::dsp_read( rel_time_t time )
  18.145 +{
  18.146 +	RUN_DSP( time, reg_times [REGS [r_dspaddr] & 0x7F] );
  18.147 +	
  18.148 +	int result = dsp.read( REGS [r_dspaddr] & 0x7F );
  18.149 +	
  18.150 +	#ifdef SPC_DSP_READ_HOOK
  18.151 +		SPC_DSP_READ_HOOK( spc_time + time, (REGS [r_dspaddr] & 0x7F), result );
  18.152 +	#endif
  18.153 +	
  18.154 +	return result;
  18.155 +}
  18.156 +
  18.157 +inline void SNES_SPC::dsp_write( int data, rel_time_t time )
  18.158 +{
  18.159 +	RUN_DSP( time, reg_times [REGS [r_dspaddr]] )
  18.160 +	#if SPC_LESS_ACCURATE
  18.161 +		else if ( m.dsp_time == skipping_time )
  18.162 +		{
  18.163 +			int r = REGS [r_dspaddr];
  18.164 +			if ( r == SPC_DSP::r_kon )
  18.165 +				m.skipped_kon |= data & ~dsp.read( SPC_DSP::r_koff );
  18.166 +			
  18.167 +			if ( r == SPC_DSP::r_koff )
  18.168 +			{
  18.169 +				m.skipped_koff |= data;
  18.170 +				m.skipped_kon &= ~data;
  18.171 +			}
  18.172 +		}
  18.173 +	#endif
  18.174 +	
  18.175 +	#ifdef SPC_DSP_WRITE_HOOK
  18.176 +		SPC_DSP_WRITE_HOOK( m.spc_time + time, REGS [r_dspaddr], (uint8_t) data );
  18.177 +	#endif
  18.178 +	
  18.179 +	if ( REGS [r_dspaddr] <= 0x7F )
  18.180 +		dsp.write( REGS [r_dspaddr], data );
  18.181 +	else if ( !SPC_MORE_ACCURACY )
  18.182 +		dprintf( "SPC wrote to DSP register > $7F\n" );
  18.183 +}
  18.184 +
  18.185 +
  18.186 +//// Memory access extras
  18.187 +
  18.188 +#if SPC_MORE_ACCURACY
  18.189 +	#define MEM_ACCESS( time, addr ) \
  18.190 +	{\
  18.191 +		if ( time >= m.dsp_time )\
  18.192 +		{\
  18.193 +			RUN_DSP( time, max_reg_time );\
  18.194 +		}\
  18.195 +	}
  18.196 +#elif !defined (NDEBUG)
  18.197 +	// Debug-only check for read/write within echo buffer, since this might result in
  18.198 +	// inaccurate emulation due to the DSP not being caught up to the present.
  18.199 +	
  18.200 +	bool SNES_SPC::check_echo_access( int addr )
  18.201 +	{
  18.202 +		if ( !(dsp.read( SPC_DSP::r_flg ) & 0x20) )
  18.203 +		{
  18.204 +			int start = 0x100 * dsp.read( SPC_DSP::r_esa );
  18.205 +			int size  = 0x800 * (dsp.read( SPC_DSP::r_edl ) & 0x0F);
  18.206 +			int end   = start + (size ? size : 4);
  18.207 +			if ( start <= addr && addr < end )
  18.208 +			{
  18.209 +				if ( !m.echo_accessed )
  18.210 +				{
  18.211 +					m.echo_accessed = 1;
  18.212 +					return true;
  18.213 +				}
  18.214 +			}
  18.215 +		}
  18.216 +		return false;
  18.217 +	}
  18.218 +	
  18.219 +	#define MEM_ACCESS( time, addr ) check( !check_echo_access( (uint16_t) addr ) );
  18.220 +#else
  18.221 +	#define MEM_ACCESS( time, addr )
  18.222 +#endif
  18.223 +
  18.224 +
  18.225 +//// CPU write
  18.226 +
  18.227 +#if SPC_MORE_ACCURACY
  18.228 +static unsigned char const glitch_probs [3] [256] =
  18.229 +{
  18.230 +	0xC3,0x92,0x5B,0x1C,0xD1,0x92,0x5B,0x1C,0xDB,0x9C,0x72,0x18,0xCD,0x5C,0x38,0x0B,
  18.231 +	0xE1,0x9C,0x74,0x17,0xCF,0x75,0x45,0x0C,0xCF,0x6E,0x4A,0x0D,0xA3,0x3A,0x1D,0x08,
  18.232 +	0xDB,0xA0,0x82,0x19,0xD9,0x73,0x3C,0x0E,0xCB,0x76,0x52,0x0B,0xA5,0x46,0x1D,0x09,
  18.233 +	0xDA,0x74,0x55,0x0F,0xA2,0x3F,0x21,0x05,0x9A,0x40,0x20,0x07,0x63,0x1E,0x10,0x01,
  18.234 +	0xDF,0xA9,0x85,0x1D,0xD3,0x84,0x4B,0x0E,0xCF,0x6F,0x49,0x0F,0xB3,0x48,0x1E,0x05,
  18.235 +	0xD8,0x77,0x52,0x12,0xB7,0x49,0x23,0x06,0xAA,0x45,0x28,0x07,0x7D,0x28,0x0F,0x07,
  18.236 +	0xCC,0x7B,0x4A,0x0E,0xB2,0x4F,0x24,0x07,0xAD,0x43,0x2C,0x06,0x86,0x29,0x11,0x07,
  18.237 +	0xAE,0x48,0x1F,0x0A,0x76,0x21,0x19,0x05,0x76,0x21,0x14,0x05,0x44,0x11,0x0B,0x01,
  18.238 +	0xE7,0xAD,0x96,0x23,0xDC,0x86,0x59,0x0E,0xDC,0x7C,0x5F,0x15,0xBB,0x53,0x2E,0x09,
  18.239 +	0xD6,0x7C,0x4A,0x16,0xBB,0x4A,0x25,0x08,0xB3,0x4F,0x28,0x0B,0x8E,0x23,0x15,0x08,
  18.240 +	0xCF,0x7F,0x57,0x11,0xB5,0x4A,0x23,0x0A,0xAA,0x42,0x28,0x05,0x7D,0x22,0x12,0x03,
  18.241 +	0xA6,0x49,0x28,0x09,0x82,0x2B,0x0D,0x04,0x7A,0x20,0x0F,0x04,0x3D,0x0F,0x09,0x03,
  18.242 +	0xD1,0x7C,0x4C,0x0F,0xAF,0x4E,0x21,0x09,0xA8,0x46,0x2A,0x07,0x85,0x1F,0x0E,0x07,
  18.243 +	0xA6,0x3F,0x26,0x07,0x7C,0x24,0x14,0x07,0x78,0x22,0x16,0x04,0x46,0x12,0x0A,0x02,
  18.244 +	0xA6,0x41,0x2C,0x0A,0x7E,0x28,0x11,0x05,0x73,0x1B,0x14,0x05,0x3D,0x11,0x0A,0x02,
  18.245 +	0x70,0x22,0x17,0x05,0x48,0x13,0x08,0x03,0x3C,0x07,0x0D,0x07,0x26,0x07,0x06,0x01,
  18.246 +	
  18.247 +	0xE0,0x9F,0xDA,0x7C,0x4F,0x18,0x28,0x0D,0xE9,0x9F,0xDA,0x7C,0x4F,0x18,0x1F,0x07,
  18.248 +	0xE6,0x97,0xD8,0x72,0x64,0x13,0x26,0x09,0xDC,0x67,0xA9,0x38,0x21,0x07,0x15,0x06,
  18.249 +	0xE9,0x91,0xD2,0x6B,0x63,0x14,0x2B,0x0E,0xD6,0x61,0xB7,0x41,0x2B,0x0E,0x10,0x09,
  18.250 +	0xCF,0x59,0xB0,0x2F,0x35,0x08,0x0F,0x07,0xB6,0x30,0x7A,0x21,0x17,0x07,0x09,0x03,
  18.251 +	0xE7,0xA3,0xE5,0x6B,0x65,0x1F,0x34,0x09,0xD8,0x6B,0xBE,0x45,0x27,0x07,0x10,0x07,
  18.252 +	0xDA,0x54,0xB1,0x39,0x2E,0x0E,0x17,0x08,0xA9,0x3C,0x86,0x22,0x16,0x06,0x07,0x03,
  18.253 +	0xD4,0x51,0xBC,0x3D,0x38,0x0A,0x13,0x06,0xB2,0x37,0x79,0x1C,0x17,0x05,0x0E,0x06,
  18.254 +	0xA7,0x31,0x74,0x1C,0x11,0x06,0x0C,0x02,0x6D,0x1A,0x38,0x10,0x0B,0x05,0x06,0x03,
  18.255 +	0xEB,0x9A,0xE1,0x7A,0x6F,0x13,0x34,0x0E,0xE6,0x75,0xC5,0x45,0x3E,0x0B,0x1A,0x05,
  18.256 +	0xD8,0x63,0xC1,0x40,0x3C,0x1B,0x19,0x06,0xB3,0x42,0x83,0x29,0x18,0x0A,0x08,0x04,
  18.257 +	0xD4,0x58,0xBA,0x43,0x3F,0x0A,0x1F,0x09,0xB1,0x33,0x8A,0x1F,0x1F,0x06,0x0D,0x05,
  18.258 +	0xAF,0x3C,0x7A,0x1F,0x16,0x08,0x0A,0x01,0x72,0x1B,0x52,0x0D,0x0B,0x09,0x06,0x01,
  18.259 +	0xCF,0x63,0xB7,0x47,0x40,0x10,0x14,0x06,0xC0,0x41,0x96,0x20,0x1C,0x09,0x10,0x05,
  18.260 +	0xA6,0x35,0x82,0x1A,0x20,0x0C,0x0E,0x04,0x80,0x1F,0x53,0x0F,0x0B,0x02,0x06,0x01,
  18.261 +	0xA6,0x31,0x81,0x1B,0x1D,0x01,0x08,0x08,0x7B,0x20,0x4D,0x19,0x0E,0x05,0x07,0x03,
  18.262 +	0x6B,0x17,0x49,0x07,0x0E,0x03,0x0A,0x05,0x37,0x0B,0x1F,0x06,0x04,0x02,0x07,0x01,
  18.263 +	
  18.264 +	0xF0,0xD6,0xED,0xAD,0xEC,0xB1,0xEB,0x79,0xAC,0x22,0x47,0x1E,0x6E,0x1B,0x32,0x0A,
  18.265 +	0xF0,0xD6,0xEA,0xA4,0xED,0xC4,0xDE,0x82,0x98,0x1F,0x50,0x13,0x52,0x15,0x2A,0x0A,
  18.266 +	0xF1,0xD1,0xEB,0xA2,0xEB,0xB7,0xD8,0x69,0xA2,0x1F,0x5B,0x18,0x55,0x18,0x2C,0x0A,
  18.267 +	0xED,0xB5,0xDE,0x7E,0xE6,0x85,0xD3,0x59,0x59,0x0F,0x2C,0x09,0x24,0x07,0x15,0x09,
  18.268 +	0xF1,0xD6,0xEA,0xA0,0xEC,0xBB,0xDA,0x77,0xA9,0x23,0x58,0x14,0x5D,0x12,0x2F,0x09,
  18.269 +	0xF1,0xC1,0xE3,0x86,0xE4,0x87,0xD2,0x4E,0x68,0x15,0x26,0x0B,0x27,0x09,0x15,0x02,
  18.270 +	0xEE,0xA6,0xE0,0x5C,0xE0,0x77,0xC3,0x41,0x67,0x1B,0x3C,0x07,0x2A,0x06,0x19,0x07,
  18.271 +	0xE4,0x75,0xC6,0x43,0xCC,0x50,0x95,0x23,0x35,0x09,0x14,0x04,0x15,0x05,0x0B,0x04,
  18.272 +	0xEE,0xD6,0xED,0xAD,0xEC,0xB1,0xEB,0x79,0xAC,0x22,0x56,0x14,0x5A,0x12,0x26,0x0A,
  18.273 +	0xEE,0xBB,0xE7,0x7E,0xE9,0x8D,0xCB,0x49,0x67,0x11,0x34,0x07,0x2B,0x0B,0x14,0x07,
  18.274 +	0xED,0xA7,0xE5,0x76,0xE3,0x7E,0xC4,0x4B,0x77,0x14,0x34,0x08,0x27,0x07,0x14,0x04,
  18.275 +	0xE7,0x8B,0xD2,0x4C,0xCA,0x56,0x9E,0x31,0x36,0x0C,0x11,0x07,0x14,0x04,0x0A,0x02,
  18.276 +	0xF0,0x9B,0xEA,0x6F,0xE5,0x81,0xC4,0x43,0x74,0x10,0x30,0x0B,0x2D,0x08,0x1B,0x06,
  18.277 +	0xE6,0x83,0xCA,0x48,0xD9,0x56,0xA7,0x23,0x3B,0x09,0x12,0x09,0x15,0x07,0x0A,0x03,
  18.278 +	0xE5,0x5F,0xCB,0x3C,0xCF,0x48,0x91,0x22,0x31,0x0A,0x17,0x08,0x15,0x04,0x0D,0x02,
  18.279 +	0xD1,0x43,0x91,0x20,0xA9,0x2D,0x54,0x12,0x17,0x07,0x09,0x02,0x0C,0x04,0x05,0x03,
  18.280 +};
  18.281 +#endif
  18.282 +
  18.283 +// divided into multiple functions to keep rarely-used functionality separate
  18.284 +// so often-used functionality can be optimized better by compiler
  18.285 +
  18.286 +// If write isn't preceded by read, data has this added to it
  18.287 +int const no_read_before_write = 0x2000;
  18.288 +
  18.289 +void SNES_SPC::cpu_write_smp_reg_( int data, rel_time_t time, int addr )
  18.290 +{
  18.291 +	switch ( addr )
  18.292 +	{
  18.293 +	case r_t0target:
  18.294 +	case r_t1target:
  18.295 +	case r_t2target: {
  18.296 +		Timer* t = &m.timers [addr - r_t0target];
  18.297 +		int period = IF_0_THEN_256( data );
  18.298 +		if ( t->period != period )
  18.299 +		{
  18.300 +			t = run_timer( t, time );
  18.301 +			#if SPC_MORE_ACCURACY
  18.302 +				// Insane behavior when target is written just after counter is
  18.303 +				// clocked and counter matches new period and new period isn't 1, 2, 4, or 8
  18.304 +				if ( t->divider == (period & 0xFF) &&
  18.305 +						t->next_time == time + TIMER_MUL( t, 1 ) &&
  18.306 +						((period - 1) | ~0x0F) & period )
  18.307 +				{
  18.308 +					//dprintf( "SPC pathological timer target write\n" );
  18.309 +					
  18.310 +					// If the period is 3, 5, or 9, there's a probability this behavior won't occur,
  18.311 +					// based on the previous period
  18.312 +					int prob = 0xFF;
  18.313 +					int old_period = t->period & 0xFF;
  18.314 +					if ( period == 3 ) prob = glitch_probs [0] [old_period];
  18.315 +					if ( period == 5 ) prob = glitch_probs [1] [old_period];
  18.316 +					if ( period == 9 ) prob = glitch_probs [2] [old_period];
  18.317 +					
  18.318 +					// The glitch suppresses incrementing of one of the counter bits, based on
  18.319 +					// the lowest set bit in the new period
  18.320 +					int b = 1;
  18.321 +					while ( !(period & b) )
  18.322 +						b <<= 1;
  18.323 +					
  18.324 +					if ( (rand() >> 4 & 0xFF) <= prob )
  18.325 +						t->divider = (t->divider - b) & 0xFF;
  18.326 +				}
  18.327 +			#endif
  18.328 +			t->period = period;
  18.329 +		}
  18.330 +		break;
  18.331 +	}
  18.332 +	
  18.333 +	case r_t0out:
  18.334 +	case r_t1out:
  18.335 +	case r_t2out:
  18.336 +		if ( !SPC_MORE_ACCURACY )
  18.337 +			dprintf( "SPC wrote to counter %d\n", (int) addr - r_t0out );
  18.338 +		
  18.339 +		if ( data < no_read_before_write  / 2 )
  18.340 +			run_timer( &m.timers [addr - r_t0out], time - 1 )->counter = 0;
  18.341 +		break;
  18.342 +	
  18.343 +	// Registers that act like RAM
  18.344 +	case 0x8:
  18.345 +	case 0x9:
  18.346 +		REGS_IN [addr] = (uint8_t) data;
  18.347 +		break;
  18.348 +	
  18.349 +	case r_test:
  18.350 +		if ( (uint8_t) data != 0x0A )
  18.351 +			dprintf( "SPC wrote to test register\n" );
  18.352 +		break;
  18.353 +	
  18.354 +	case r_control:
  18.355 +		// port clears
  18.356 +		if ( data & 0x10 )
  18.357 +		{
  18.358 +			REGS_IN [r_cpuio0] = 0;
  18.359 +			REGS_IN [r_cpuio1] = 0;
  18.360 +		}
  18.361 +		if ( data & 0x20 )
  18.362 +		{
  18.363 +			REGS_IN [r_cpuio2] = 0;
  18.364 +			REGS_IN [r_cpuio3] = 0;
  18.365 +		}
  18.366 +		
  18.367 +		// timers
  18.368 +		{
  18.369 +			for ( int i = 0; i < timer_count; i++ )
  18.370 +			{
  18.371 +				Timer* t = &m.timers [i];
  18.372 +				int enabled = data >> i & 1;
  18.373 +				if ( t->enabled != enabled )
  18.374 +				{
  18.375 +					t = run_timer( t, time );
  18.376 +					t->enabled = enabled;
  18.377 +					if ( enabled )
  18.378 +					{
  18.379 +						t->divider = 0;
  18.380 +						t->counter = 0;
  18.381 +					}
  18.382 +				}
  18.383 +			}
  18.384 +		}
  18.385 +		enable_rom( data & 0x80 );
  18.386 +		break;
  18.387 +	}
  18.388 +}
  18.389 +
  18.390 +void SNES_SPC::cpu_write_smp_reg( int data, rel_time_t time, int addr )
  18.391 +{
  18.392 +	if ( addr == r_dspdata ) // 99%
  18.393 +		dsp_write( data, time );
  18.394 +	else
  18.395 +		cpu_write_smp_reg_( data, time, addr );
  18.396 +}
  18.397 +
  18.398 +void SNES_SPC::cpu_write_high( int data, int i, rel_time_t time )
  18.399 +{
  18.400 +	if ( i < rom_size )
  18.401 +	{
  18.402 +		m.hi_ram [i] = (uint8_t) data;
  18.403 +		if ( m.rom_enabled )
  18.404 +			RAM [i + rom_addr] = m.rom [i]; // restore overwritten ROM
  18.405 +	}
  18.406 +	else
  18.407 +	{
  18.408 +		assert( RAM [i + rom_addr] == (uint8_t) data );
  18.409 +		RAM [i + rom_addr] = cpu_pad_fill; // restore overwritten padding
  18.410 +		cpu_write( data, i + rom_addr - 0x10000, time );
  18.411 +	}
  18.412 +}
  18.413 +
  18.414 +int const bits_in_int = CHAR_BIT * sizeof (int);
  18.415 +
  18.416 +void SNES_SPC::cpu_write( int data, int addr, rel_time_t time )
  18.417 +{
  18.418 +	MEM_ACCESS( time, addr )
  18.419 +	
  18.420 +	// RAM
  18.421 +	RAM [addr] = (uint8_t) data;
  18.422 +	int reg = addr - 0xF0;
  18.423 +	if ( reg >= 0 ) // 64%
  18.424 +	{
  18.425 +		// $F0-$FF
  18.426 +		if ( reg < reg_count ) // 87%
  18.427 +		{
  18.428 +			REGS [reg] = (uint8_t) data;
  18.429 +			
  18.430 +			// Ports
  18.431 +			#ifdef SPC_PORT_WRITE_HOOK
  18.432 +				if ( (unsigned) (reg - r_cpuio0) < port_count )
  18.433 +					SPC_PORT_WRITE_HOOK( m.spc_time + time, (reg - r_cpuio0),
  18.434 +							(uint8_t) data, &REGS [r_cpuio0] );
  18.435 +			#endif
  18.436 +			
  18.437 +			// Registers other than $F2 and $F4-$F7
  18.438 +			//if ( reg != 2 && reg != 4 && reg != 5 && reg != 6 && reg != 7 )
  18.439 +			// TODO: this is a bit on the fragile side
  18.440 +			if ( ((~0x2F00 << (bits_in_int - 16)) << reg) < 0 ) // 36%
  18.441 +				cpu_write_smp_reg( data, time, reg );
  18.442 +		}
  18.443 +		// High mem/address wrap-around
  18.444 +		else
  18.445 +		{
  18.446 +			reg -= rom_addr - 0xF0;
  18.447 +			if ( reg >= 0 ) // 1% in IPL ROM area or address wrapped around
  18.448 +				cpu_write_high( data, reg, time );
  18.449 +		}
  18.450 +	}
  18.451 +}
  18.452 +
  18.453 +
  18.454 +//// CPU read
  18.455 +
  18.456 +inline int SNES_SPC::cpu_read_smp_reg( int reg, rel_time_t time )
  18.457 +{
  18.458 +	int result = REGS_IN [reg];
  18.459 +	reg -= r_dspaddr;
  18.460 +	// DSP addr and data
  18.461 +	if ( (unsigned) reg <= 1 ) // 4% 0xF2 and 0xF3
  18.462 +	{
  18.463 +		result = REGS [r_dspaddr];
  18.464 +		if ( (unsigned) reg == 1 )
  18.465 +			result = dsp_read( time ); // 0xF3
  18.466 +	}
  18.467 +	return result;
  18.468 +}
  18.469 +
  18.470 +int SNES_SPC::cpu_read( int addr, rel_time_t time )
  18.471 +{
  18.472 +	MEM_ACCESS( time, addr )
  18.473 +	
  18.474 +	// RAM
  18.475 +	int result = RAM [addr];
  18.476 +	int reg = addr - 0xF0;
  18.477 +	if ( reg >= 0 ) // 40%
  18.478 +	{
  18.479 +		reg -= 0x10;
  18.480 +		if ( (unsigned) reg >= 0xFF00 ) // 21%
  18.481 +		{
  18.482 +			reg += 0x10 - r_t0out;
  18.483 +			
  18.484 +			// Timers
  18.485 +			if ( (unsigned) reg < timer_count ) // 90%
  18.486 +			{
  18.487 +				Timer* t = &m.timers [reg];
  18.488 +				if ( time >= t->next_time )
  18.489 +					t = run_timer_( t, time );
  18.490 +				result = t->counter;
  18.491 +				t->counter = 0;
  18.492 +			}
  18.493 +			// Other registers
  18.494 +			else if ( reg < 0 ) // 10%
  18.495 +			{
  18.496 +				result = cpu_read_smp_reg( reg + r_t0out, time );
  18.497 +			}
  18.498 +			else // 1%
  18.499 +			{
  18.500 +				assert( reg + (r_t0out + 0xF0 - 0x10000) < 0x100 );
  18.501 +				result = cpu_read( reg + (r_t0out + 0xF0 - 0x10000), time );
  18.502 +			}
  18.503 +		}
  18.504 +	}
  18.505 +	
  18.506 +	return result;
  18.507 +}
  18.508 +
  18.509 +
  18.510 +//// Run
  18.511 +
  18.512 +// Prefix and suffix for CPU emulator function
  18.513 +#define SPC_CPU_RUN_FUNC \
  18.514 +BOOST::uint8_t* SNES_SPC::run_until_( time_t end_time )\
  18.515 +{\
  18.516 +	rel_time_t rel_time = m.spc_time - end_time;\
  18.517 +	assert( rel_time <= 0 );\
  18.518 +	m.spc_time = end_time;\
  18.519 +	m.dsp_time += rel_time;\
  18.520 +	m.timers [0].next_time += rel_time;\
  18.521 +	m.timers [1].next_time += rel_time;\
  18.522 +	m.timers [2].next_time += rel_time;
  18.523 +
  18.524 +#define SPC_CPU_RUN_FUNC_END \
  18.525 +	m.spc_time += rel_time;\
  18.526 +	m.dsp_time -= rel_time;\
  18.527 +	m.timers [0].next_time -= rel_time;\
  18.528 +	m.timers [1].next_time -= rel_time;\
  18.529 +	m.timers [2].next_time -= rel_time;\
  18.530 +	assert( m.spc_time <= end_time );\
  18.531 +	return &REGS [r_cpuio0];\
  18.532 +}
  18.533 +
  18.534 +int const cpu_lag_max = 12 - 1; // DIV YA,X takes 12 clocks
  18.535 +
  18.536 +void SNES_SPC::end_frame( time_t end_time )
  18.537 +{
  18.538 +	// Catch CPU up to as close to end as possible. If final instruction
  18.539 +	// would exceed end, does NOT execute it and leaves m.spc_time < end.
  18.540 +	if ( end_time > m.spc_time )
  18.541 +		run_until_( end_time );
  18.542 +	
  18.543 +	m.spc_time     -= end_time;
  18.544 +	m.extra_clocks += end_time;
  18.545 +	
  18.546 +	// Greatest number of clocks early that emulation can stop early due to
  18.547 +	// not being able to execute current instruction without going over
  18.548 +	// allowed time.
  18.549 +	assert( -cpu_lag_max <= m.spc_time && m.spc_time <= 0 );
  18.550 +	
  18.551 +	// Catch timers up to CPU
  18.552 +	for ( int i = 0; i < timer_count; i++ )
  18.553 +		run_timer( &m.timers [i], 0 );
  18.554 +	
  18.555 +	// Catch DSP up to CPU
  18.556 +	if ( m.dsp_time < 0 )
  18.557 +	{
  18.558 +		RUN_DSP( 0, max_reg_time );
  18.559 +	}
  18.560 +	
  18.561 +	// Save any extra samples beyond what should be generated
  18.562 +	if ( m.buf_begin )
  18.563 +		save_extra();
  18.564 +}
  18.565 +
  18.566 +// Inclusion here allows static memory access functions and better optimization
  18.567 +#include "SPC_CPU.h"

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/snes_spc/SNES_SPC.h	Fri Oct 21 05:53:11 2011 -0700
    19.3 @@ -0,0 +1,279 @@
    19.4 +// SNES SPC-700 APU emulator
    19.5 +
    19.6 +// snes_spc 0.9.0
    19.7 +#ifndef SNES_SPC_H
    19.8 +#define SNES_SPC_H
    19.9 +
   19.10 +#include "SPC_DSP.h"
   19.11 +#include "blargg_endian.h"
   19.12 +
   19.13 +struct SNES_SPC {
   19.14 +public:
   19.15 +	typedef BOOST::uint8_t uint8_t;
   19.16 +	
   19.17 +	// Must be called once before using
   19.18 +	blargg_err_t init();
   19.19 +	
   19.20 +	// Sample pairs generated per second
   19.21 +	enum { sample_rate = 32000 };
   19.22 +	
   19.23 +// Emulator use
   19.24 +	
   19.25 +	// Sets IPL ROM data. Library does not include ROM data. Most SPC music files
   19.26 +	// don't need ROM, but a full emulator must provide this.
   19.27 +	enum { rom_size = 0x40 };
   19.28 +	void init_rom( uint8_t const rom [rom_size] );
   19.29 +
   19.30 +	// Sets destination for output samples
   19.31 +	typedef short sample_t;
   19.32 +	void set_output( sample_t* out, int out_size );
   19.33 +
   19.34 +	// Number of samples written to output since last set
   19.35 +	int sample_count() const;
   19.36 +
   19.37 +	// Resets SPC to power-on state. This resets your output buffer, so you must
   19.38 +	// call set_output() after this.
   19.39 +	void reset();
   19.40 +
   19.41 +	// Emulates pressing reset switch on SNES. This resets your output buffer, so
   19.42 +	// you must call set_output() after this.
   19.43 +	void soft_reset();
   19.44 +
   19.45 +	// 1024000 SPC clocks per second, sample pair every 32 clocks
   19.46 +	typedef int time_t;
   19.47 +	enum { clock_rate = 1024000 };
   19.48 +	enum { clocks_per_sample = 32 };
   19.49 +	
   19.50 +	// Emulated port read/write at specified time
   19.51 +	enum { port_count = 4 };
   19.52 +	int  read_port ( time_t, int port );
   19.53 +	void write_port( time_t, int port, int data );
   19.54 +
   19.55 +	// Runs SPC to end_time and starts a new time frame at 0
   19.56 +	void end_frame( time_t end_time );
   19.57 +	
   19.58 +// Sound control
   19.59 +	
   19.60 +	// Mutes voices corresponding to non-zero bits in mask (issues repeated KOFF events).
   19.61 +	// Reduces emulation accuracy.
   19.62 +	enum { voice_count = 8 };
   19.63 +	void mute_voices( int mask );
   19.64 +	
   19.65 +	// If true, prevents channels and global volumes from being phase-negated.
   19.66 +	// Only supported by fast DSP.
   19.67 +	void disable_surround( bool disable = true );
   19.68 +	
   19.69 +	// Sets tempo, where tempo_unit = normal, tempo_unit / 2 = half speed, etc.
   19.70 +	enum { tempo_unit = 0x100 };
   19.71 +	void set_tempo( int );
   19.72 +
   19.73 +// SPC music files
   19.74 +
   19.75 +	// Loads SPC data into emulator
   19.76 +	enum { spc_min_file_size = 0x10180 };
   19.77 +	enum { spc_file_size     = 0x10200 };
   19.78 +	blargg_err_t load_spc( void const* in, long size );
   19.79 +	
   19.80 +	// Clears echo region. Useful after loading an SPC as many have garbage in echo.
   19.81 +	void clear_echo();
   19.82 +
   19.83 +	// Plays for count samples and write samples to out. Discards samples if out
   19.84 +	// is NULL. Count must be a multiple of 2 since output is stereo.
   19.85 +	blargg_err_t play( int count, sample_t* out );
   19.86 +	
   19.87 +	// Skips count samples. Several times faster than play() when using fast DSP.
   19.88 +	blargg_err_t skip( int count );
   19.89 +	
   19.90 +// State save/load (only available with accurate DSP)
   19.91 +
   19.92 +#if !SPC_NO_COPY_STATE_FUNCS
   19.93 +	// Saves/loads state
   19.94 +	enum { state_size = 67 * 1024L }; // maximum space needed when saving
   19.95 +	typedef SPC_DSP::copy_func_t copy_func_t;
   19.96 +	void copy_state( unsigned char** io, copy_func_t );
   19.97 +	
   19.98 +	// Writes minimal header to spc_out
   19.99 +	static void init_header( void* spc_out );
  19.100 +
  19.101 +	// Saves emulator state as SPC file data. Writes spc_file_size bytes to spc_out.
  19.102 +	// Does not set up SPC header; use init_header() for that.
  19.103 +	void save_spc( void* spc_out );
  19.104 +
  19.105 +	// Returns true if new key-on events occurred since last check. Useful for
  19.106 +	// trimming silence while saving an SPC.
  19.107 +	bool check_kon();
  19.108 +#endif
  19.109 +
  19.110 +public:
  19.111 +	BLARGG_DISABLE_NOTHROW
  19.112 +	
  19.113 +	typedef BOOST::uint16_t uint16_t;
  19.114 +	
  19.115 +	// Time relative to m_spc_time. Speeds up code a bit by eliminating need to
  19.116 +	// constantly add m_spc_time to time from CPU. CPU uses time that ends at
  19.117 +	// 0 to eliminate reloading end time every instruction. It pays off.
  19.118 +	typedef int rel_time_t;
  19.119 +	
  19.120 +	struct Timer
  19.121 +	{
  19.122 +		rel_time_t next_time; // time of next event
  19.123 +		int prescaler;
  19.124 +		int period;
  19.125 +		int divider;
  19.126 +		int enabled;
  19.127 +		int counter;
  19.128 +	};
  19.129 +	enum { reg_count = 0x10 };
  19.130 +	enum { timer_count = 3 };
  19.131 +	enum { extra_size = SPC_DSP::extra_size };
  19.132 +	
  19.133 +	enum { signature_size = 35 };
  19.134 +	
  19.135 +private:
  19.136 +	SPC_DSP dsp;
  19.137 +	
  19.138 +	#if SPC_LESS_ACCURATE
  19.139 +		static signed char const reg_times_ [256];
  19.140 +		signed char reg_times [256];
  19.141 +	#endif
  19.142 +	
  19.143 +	struct state_t
  19.144 +	{
  19.145 +		Timer timers [timer_count];
  19.146 +		
  19.147 +		uint8_t smp_regs [2] [reg_count];
  19.148 +		
  19.149 +		struct
  19.150 +		{
  19.151 +			int pc;
  19.152 +			int a;
  19.153 +			int x;
  19.154 +			int y;
  19.155 +			int psw;
  19.156 +			int sp;
  19.157 +		} cpu_regs;
  19.158 +		
  19.159 +		rel_time_t  dsp_time;
  19.160 +		time_t      spc_time;
  19.161 +		bool        echo_accessed;
  19.162 +		
  19.163 +		int         tempo;
  19.164 +		int         skipped_kon;
  19.165 +		int         skipped_koff;
  19.166 +		const char* cpu_error;
  19.167 +		
  19.168 +		int         extra_clocks;
  19.169 +		sample_t*   buf_begin;
  19.170 +		sample_t const* buf_end;
  19.171 +		sample_t*   extra_pos;
  19.172 +		sample_t    extra_buf [extra_size];
  19.173 +		
  19.174 +		int         rom_enabled;
  19.175 +		uint8_t     rom    [rom_size];
  19.176 +		uint8_t     hi_ram [rom_size];
  19.177 +		
  19.178 +		unsigned char cycle_table [256];
  19.179 +		
  19.180 +		struct
  19.181 +		{
  19.182 +			// padding to neutralize address overflow
  19.183 +			union {
  19.184 +				uint8_t padding1 [0x100];
  19.185 +				uint16_t align; // makes compiler align data for 16-bit access
  19.186 +			} padding1 [1];
  19.187 +			uint8_t ram      [0x10000];
  19.188 +			uint8_t padding2 [0x100];
  19.189 +		} ram;
  19.190 +	};
  19.191 +	state_t m;
  19.192 +	
  19.193 +	enum { rom_addr = 0xFFC0 };
  19.194 +	
  19.195 +	enum { skipping_time = 127 };
  19.196 +	
  19.197 +	// Value that padding should be filled with
  19.198 +	enum { cpu_pad_fill = 0xFF };
  19.199 +	
  19.200 +	enum {
  19.201 +        r_test     = 0x0, r_control  = 0x1,
  19.202 +        r_dspaddr  = 0x2, r_dspdata  = 0x3,
  19.203 +        r_cpuio0   = 0x4, r_cpuio1   = 0x5,
  19.204 +        r_cpuio2   = 0x6, r_cpuio3   = 0x7,
  19.205 +        r_f8       = 0x8, r_f9       = 0x9,
  19.206 +        r_t0target = 0xA, r_t1target = 0xB, r_t2target = 0xC,
  19.207 +        r_t0out    = 0xD, r_t1out    = 0xE, r_t2out    = 0xF
  19.208 +	};
  19.209 +	
  19.210 +	void timers_loaded();
  19.211 +	void enable_rom( int enable );
  19.212 +	void reset_buf();
  19.213 +	void save_extra();
  19.214 +	void load_regs( uint8_t const in [reg_count] );
  19.215 +	void ram_loaded();
  19.216 +	void regs_loaded();
  19.217 +	void reset_time_regs();
  19.218 +	void reset_common( int timer_counter_init );
  19.219 +	
  19.220 +	Timer* run_timer_      ( Timer* t, rel_time_t );
  19.221 +	Timer* run_timer       ( Timer* t, rel_time_t );
  19.222 +	int dsp_read           ( rel_time_t );
  19.223 +	void dsp_write         ( int data, rel_time_t );
  19.224 +	void cpu_write_smp_reg_( int data, rel_time_t, int addr );
  19.225 +	void cpu_write_smp_reg ( int data, rel_time_t, int addr );
  19.226 +	void cpu_write_high    ( int data, int i, rel_time_t );
  19.227 +	void cpu_write         ( int data, int addr, rel_time_t );
  19.228 +	int cpu_read_smp_reg   ( int i, rel_time_t );
  19.229 +	int cpu_read           ( int addr, rel_time_t );
  19.230 +	unsigned CPU_mem_bit   ( uint8_t const* pc, rel_time_t );
  19.231 +	
  19.232 +	bool check_echo_access ( int addr );
  19.233 +	uint8_t* run_until_( time_t end_time );
  19.234 +	
  19.235 +	struct spc_file_t
  19.236 +	{
  19.237 +		char    signature [signature_size];
  19.238 +		uint8_t has_id666;
  19.239 +		uint8_t version;
  19.240 +		uint8_t pcl, pch;
  19.241 +		uint8_t a;
  19.242 +		uint8_t x;
  19.243 +		uint8_t y;
  19.244 +		uint8_t psw;
  19.245 +		uint8_t sp;
  19.246 +		char    text [212];
  19.247 +		uint8_t ram [0x10000];
  19.248 +		uint8_t dsp [128];
  19.249 +		uint8_t unused [0x40];
  19.250 +		uint8_t ipl_rom [0x40];
  19.251 +	};
  19.252 +
  19.253 +	static char const signature [signature_size + 1];
  19.254 +	
  19.255 +	void save_regs( uint8_t out [reg_count] );
  19.256 +};
  19.257 +
  19.258 +#include <assert.h>
  19.259 +
  19.260 +inline int SNES_SPC::sample_count() const { return (m.extra_clocks >> 5) * 2; }
  19.261 +
  19.262 +inline int SNES_SPC::read_port( time_t t, int port )
  19.263 +{
  19.264 +	assert( (unsigned) port < port_count );
  19.265 +	return run_until_( t ) [port];
  19.266 +}
  19.267 +
  19.268 +inline void SNES_SPC::write_port( time_t t, int port, int data )
  19.269 +{
  19.270 +	assert( (unsigned) port < port_count );
  19.271 +	run_until_( t ) [0x10 + port] = data;
  19.272 +}
  19.273 +
  19.274 +inline void SNES_SPC::mute_voices( int mask ) { dsp.mute_voices( mask ); }
  19.275 +	
  19.276 +inline void SNES_SPC::disable_surround( bool disable ) { dsp.disable_surround( disable ); }
  19.277 +
  19.278 +#if !SPC_NO_COPY_STATE_FUNCS
  19.279 +inline bool SNES_SPC::check_kon() { return dsp.check_kon(); }
  19.280 +#endif
  19.281 +
  19.282 +#endif

    20.1 Binary file snes_spc/SNES_SPC.h.gch has changed

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/snes_spc/SNES_SPC_misc.cpp	Fri Oct 21 05:53:11 2011 -0700
    21.3 @@ -0,0 +1,380 @@
    21.4 +// SPC emulation support: init, sample buffering, reset, SPC loading
    21.5 +
    21.6 +// snes_spc 0.9.0. http://www.slack.net/~ant/
    21.7 +
    21.8 +#include "SNES_SPC.h"
    21.9 +
   21.10 +#include <string.h>
   21.11 +
   21.12 +/* Copyright (C) 2004-2007 Shay Green. This module is free software; you
   21.13 +can redistribute it and/or modify it under the terms of the GNU Lesser
   21.14 +General Public License as published by the Free Software Foundation; either
   21.15 +version 2.1 of the License, or (at your option) any later version. This
   21.16 +module is distributed in the hope that it will be useful, but WITHOUT ANY
   21.17 +WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   21.18 +FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   21.19 +details. You should have received a copy of the GNU Lesser General Public
   21.20 +License along with this module; if not, write to the Free Software Foundation,
   21.21 +Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
   21.22 +
   21.23 +#include "blargg_source.h"
   21.24 +
   21.25 +#define RAM         (m.ram.ram)
   21.26 +#define REGS        (m.smp_regs [0])
   21.27 +#define REGS_IN     (m.smp_regs [1])
   21.28 +
   21.29 +// (n ? n : 256)
   21.30 +#define IF_0_THEN_256( n ) ((uint8_t) ((n) - 1) + 1)
   21.31 +
   21.32 +
   21.33 +//// Init
   21.34 +
   21.35 +blargg_err_t SNES_SPC::init()
   21.36 +{
   21.37 +	memset( &m, 0, sizeof m );
   21.38 +	dsp.init( RAM );
   21.39 +	
   21.40 +	m.tempo = tempo_unit;
   21.41 +	
   21.42 +	// Most SPC music doesn't need ROM, and almost all the rest only rely
   21.43 +	// on these two bytes
   21.44 +	m.rom [0x3E] = 0xFF;
   21.45 +	m.rom [0x3F] = 0xC0;
   21.46 +	
   21.47 +	static unsigned char const cycle_table [128] =
   21.48 +	{//   01   23   45   67   89   AB   CD   EF
   21.49 +	    0x28,0x47,0x34,0x36,0x26,0x54,0x54,0x68, // 0
   21.50 +	    0x48,0x47,0x45,0x56,0x55,0x65,0x22,0x46, // 1
   21.51 +	    0x28,0x47,0x34,0x36,0x26,0x54,0x54,0x74, // 2
   21.52 +	    0x48,0x47,0x45,0x56,0x55,0x65,0x22,0x38, // 3
   21.53 +	    0x28,0x47,0x34,0x36,0x26,0x44,0x54,0x66, // 4
   21.54 +	    0x48,0x47,0x45,0x56,0x55,0x45,0x22,0x43, // 5
   21.55 +	    0x28,0x47,0x34,0x36,0x26,0x44,0x54,0x75, // 6
   21.56 +	    0x48,0x47,0x45,0x56,0x55,0x55,0x22,0x36, // 7
   21.57 +	    0x28,0x47,0x34,0x36,0x26,0x54,0x52,0x45, // 8
   21.58 +	    0x48,0x47,0x45,0x56,0x55,0x55,0x22,0xC5, // 9
   21.59 +	    0x38,0x47,0x34,0x36,0x26,0x44,0x52,0x44, // A
   21.60 +	    0x48,0x47,0x45,0x56,0x55,0x55,0x22,0x34, // B
   21.61 +	    0x38,0x47,0x45,0x47,0x25,0x64,0x52,0x49, // C
   21.62 +	    0x48,0x47,0x56,0x67,0x45,0x55,0x22,0x83, // D
   21.63 +	    0x28,0x47,0x34,0x36,0x24,0x53,0x43,0x40, // E
   21.64 +	    0x48,0x47,0x45,0x56,0x34,0x54,0x22,0x60, // F
   21.65 +	};
   21.66 +	
   21.67 +	// unpack cycle table
   21.68 +	for ( int i = 0; i < 128; i++ )
   21.69 +	{
   21.70 +		int n = cycle_table [i];
   21.71 +		m.cycle_table [i * 2 + 0] = n >> 4;
   21.72 +		m.cycle_table [i * 2 + 1] = n & 0x0F;
   21.73 +	}
   21.74 +	
   21.75 +	#if SPC_LESS_ACCURATE
   21.76 +		memcpy( reg_times, reg_times_, sizeof reg_times );
   21.77 +	#endif
   21.78 +	
   21.79 +	reset();
   21.80 +	return 0;
   21.81 +}
   21.82 +
   21.83 +void SNES_SPC::init_rom( uint8_t const in [rom_size] )
   21.84 +{
   21.85 +	memcpy( m.rom, in, sizeof m.rom );
   21.86 +}
   21.87 +
   21.88 +void SNES_SPC::set_tempo( int t )
   21.89 +{
   21.90 +	m.tempo = t;
   21.91 +	int const timer2_shift = 4; // 64 kHz
   21.92 +	int const other_shift  = 3; //  8 kHz
   21.93 +	
   21.94 +	#if SPC_DISABLE_TEMPO
   21.95 +		m.timers [2].prescaler = timer2_shift;
   21.96 +		m.timers [1].prescaler = timer2_shift + other_shift;
   21.97 +		m.timers [0].prescaler = timer2_shift + other_shift;
   21.98 +	#else
   21.99 +		if ( !t )
  21.100 +			t = 1;
  21.101 +		int const timer2_rate  = 1 << timer2_shift;
  21.102 +		int rate = (timer2_rate * tempo_unit + (t >> 1)) / t;
  21.103 +		if ( rate < timer2_rate / 4 )
  21.104 +			rate = timer2_rate / 4; // max 4x tempo
  21.105 +		m.timers [2].prescaler = rate;
  21.106 +		m.timers [1].prescaler = rate << other_shift;
  21.107 +		m.timers [0].prescaler = rate << other_shift;
  21.108 +	#endif
  21.109 +}
  21.110 +
  21.111 +// Timer registers have been loaded. Applies these to the timers. Does not
  21.112 +// reset timer prescalers or dividers.
  21.113 +void SNES_SPC::timers_loaded()
  21.114 +{
  21.115 +	int i;
  21.116 +	for ( i = 0; i < timer_count; i++ )
  21.117 +	{
  21.118 +		Timer* t = &m.timers [i];
  21.119 +		t->period  = IF_0_THEN_256( REGS [r_t0target + i] );
  21.120 +		t->enabled = REGS [r_control] >> i & 1;
  21.121 +		t->counter = REGS_IN [r_t0out + i] & 0x0F;
  21.122 +	}
  21.123 +	
  21.124 +	set_tempo( m.tempo );
  21.125 +}
  21.126 +
  21.127 +// Loads registers from unified 16-byte format
  21.128 +void SNES_SPC::load_regs( uint8_t const in [reg_count] )
  21.129 +{
  21.130 +	memcpy( REGS, in, reg_count );
  21.131 +	memcpy( REGS_IN, REGS, reg_count );
  21.132 +	
  21.133 +	// These always read back as 0
  21.134 +	REGS_IN [r_test    ] = 0;
  21.135 +	REGS_IN [r_control ] = 0;
  21.136 +	REGS_IN [r_t0target] = 0;
  21.137 +	REGS_IN [r_t1target] = 0;
  21.138 +	REGS_IN [r_t2target] = 0;
  21.139 +}
  21.140 +
  21.141 +// RAM was just loaded from SPC, with $F0-$FF containing SMP registers
  21.142 +// and timer counts. Copies these to proper registers.
  21.143 +void SNES_SPC::ram_loaded()
  21.144 +{
  21.145 +	m.rom_enabled = 0;
  21.146 +	load_regs( &RAM [0xF0] );
  21.147 +	
  21.148 +	// Put STOP instruction around memory to catch PC underflow/overflow
  21.149 +	memset( m.ram.padding1, cpu_pad_fill, sizeof m.ram.padding1 );
  21.150 +	memset( m.ram.padding2, cpu_pad_fill, sizeof m.ram.padding2 );
  21.151 +}
  21.152 +
  21.153 +// Registers were just loaded. Applies these new values.
  21.154 +void SNES_SPC::regs_loaded()
  21.155 +{
  21.156 +	enable_rom( REGS [r_control] & 0x80 );
  21.157 +	timers_loaded();
  21.158 +}
  21.159 +
  21.160 +void SNES_SPC::reset_time_regs()
  21.161 +{
  21.162 +	m.cpu_error     = 0;
  21.163 +	m.echo_accessed = 0;
  21.164 +	m.spc_time      = 0;
  21.165 +	m.dsp_time      = 0;
  21.166 +	#if SPC_LESS_ACCURATE
  21.167 +		m.dsp_time = clocks_per_sample + 1;
  21.168 +	#endif
  21.169 +	
  21.170 +	for ( int i = 0; i < timer_count; i++ )
  21.171 +	{
  21.172 +		Timer* t = &m.timers [i];
  21.173 +		t->next_time = 1;
  21.174 +		t->divider   = 0;
  21.175 +	}
  21.176 +	
  21.177 +	regs_loaded();
  21.178 +	
  21.179 +	m.extra_clocks = 0;
  21.180 +	reset_buf();
  21.181 +}
  21.182 +
  21.183 +void SNES_SPC::reset_common( int timer_counter_init )
  21.184 +{
  21.185 +	int i;
  21.186 +	for ( i = 0; i < timer_count; i++ )
  21.187 +		REGS_IN [r_t0out + i] = timer_counter_init;
  21.188 +	
  21.189 +	// Run IPL ROM
  21.190 +	memset( &m.cpu_regs, 0, sizeof m.cpu_regs );
  21.191 +	m.cpu_regs.pc = rom_addr;
  21.192 +	
  21.193 +	REGS [r_test   ] = 0x0A;
  21.194 +	REGS [r_control] = 0xB0; // ROM enabled, clear ports
  21.195 +	for ( i = 0; i < port_count; i++ )
  21.196 +		REGS_IN [r_cpuio0 + i] = 0;
  21.197 +	
  21.198 +	reset_time_regs();
  21.199 +}
  21.200 +
  21.201 +void SNES_SPC::soft_reset()
  21.202 +{
  21.203 +	reset_common( 0 );
  21.204 +	dsp.soft_reset();
  21.205 +}
  21.206 +
  21.207 +void SNES_SPC::reset()
  21.208 +{
  21.209 +	memset( RAM, 0xFF, 0x10000 );
  21.210 +	ram_loaded();
  21.211 +	reset_common( 0x0F );
  21.212 +	dsp.reset();
  21.213 +}
  21.214 +
  21.215 +char const SNES_SPC::signature [signature_size + 1] =
  21.216 +		"SNES-SPC700 Sound File Data v0.30\x1A\x1A";
  21.217 +
  21.218 +blargg_err_t SNES_SPC::load_spc( void const* data, long size )
  21.219 +{
  21.220 +	spc_file_t const* const spc = (spc_file_t const*) data;
  21.221 +	
  21.222 +	// be sure compiler didn't insert any padding into fle_t
  21.223 +	assert( sizeof (spc_file_t) == spc_min_file_size + 0x80 );
  21.224 +	
  21.225 +	// Check signature and file size
  21.226 +	if ( size < signature_size || memcmp( spc, signature, 27 ) )
  21.227 +		return "Not an SPC file";
  21.228 +	
  21.229 +	if ( size < spc_min_file_size )
  21.230 +		return "Corrupt SPC file";
  21.231 +	
  21.232 +	// CPU registers
  21.233 +	m.cpu_regs.pc  = spc->pch * 0x100 + spc->pcl;
  21.234 +	m.cpu_regs.a   = spc->a;
  21.235 +	m.cpu_regs.x   = spc->x;
  21.236 +	m.cpu_regs.y   = spc->y;
  21.237 +	m.cpu_regs.psw = spc->psw;
  21.238 +	m.cpu_regs.sp  = spc->sp;
  21.239 +	
  21.240 +	// RAM and registers
  21.241 +	memcpy( RAM, spc->ram, 0x10000 );
  21.242 +	ram_loaded();
  21.243 +	
  21.244 +	// DSP registers
  21.245 +	dsp.load( spc->dsp );
  21.246 +	
  21.247 +	reset_time_regs();
  21.248 +	
  21.249 +	return 0;
  21.250 +}
  21.251 +
  21.252 +void SNES_SPC::clear_echo()
  21.253 +{
  21.254 +	if ( !(dsp.read( SPC_DSP::r_flg ) & 0x20) )
  21.255 +	{
  21.256 +		int addr = 0x100 * dsp.read( SPC_DSP::r_esa );
  21.257 +		int end  = addr + 0x800 * (dsp.read( SPC_DSP::r_edl ) & 0x0F);
  21.258 +		if ( end > 0x10000 )
  21.259 +			end = 0x10000;
  21.260 +		memset( &RAM [addr], 0xFF, end - addr );
  21.261 +	}
  21.262 +}
  21.263 +
  21.264 +
  21.265 +//// Sample output
  21.266 +
  21.267 +void SNES_SPC::reset_buf()
  21.268 +{
  21.269 +	// Start with half extra buffer of silence
  21.270 +	sample_t* out = m.extra_buf;
  21.271 +	while ( out < &m.extra_buf [extra_size / 2] )
  21.272 +		*out++ = 0;
  21.273 +	
  21.274 +	m.extra_pos = out;
  21.275 +	m.buf_begin = 0;
  21.276 +	
  21.277 +	dsp.set_output( 0, 0 );
  21.278 +}
  21.279 +
  21.280 +void SNES_SPC::set_output( sample_t* out, int size )
  21.281 +{
  21.282 +	require( (size & 1) == 0 ); // size must be even
  21.283 +	
  21.284 +	m.extra_clocks &= clocks_per_sample - 1;
  21.285 +	if ( out )
  21.286 +	{
  21.287 +		sample_t const* out_end = out + size;
  21.288 +		m.buf_begin = out;
  21.289 +		m.buf_end   = out_end;
  21.290 +		
  21.291 +		// Copy extra to output
  21.292 +		sample_t const* in = m.extra_buf;
  21.293 +		while ( in < m.extra_pos && out < out_end )
  21.294 +			*out++ = *in++;
  21.295 +		
  21.296 +		// Handle output being full already
  21.297 +		if ( out >= out_end )
  21.298 +		{
  21.299 +			// Have DSP write to remaining extra space
  21.300 +			out     = dsp.extra();
  21.301 +			out_end = &dsp.extra() [extra_size];
  21.302 +			
  21.303 +			// Copy any remaining extra samples as if DSP wrote them
  21.304 +			while ( in < m.extra_pos )
  21.305 +				*out++ = *in++;
  21.306 +			assert( out <= out_end );
  21.307 +		}
  21.308 +		
  21.309 +		dsp.set_output( out, out_end - out );
  21.310 +	}
  21.311 +	else
  21.312 +	{
  21.313 +		reset_buf();
  21.314 +	}
  21.315 +}
  21.316 +
  21.317 +void SNES_SPC::save_extra()
  21.318 +{
  21.319 +	// Get end pointers
  21.320 +	sample_t const* main_end = m.buf_end;     // end of data written to buf
  21.321 +	sample_t const* dsp_end  = dsp.out_pos(); // end of data written to dsp.extra()
  21.322 +	if ( m.buf_begin <= dsp_end && dsp_end <= main_end )
  21.323 +	{
  21.324 +		main_end = dsp_end;
  21.325 +		dsp_end  = dsp.extra(); // nothing in DSP's extra
  21.326 +	}
  21.327 +	
  21.328 +	// Copy any extra samples at these ends into extra_buf
  21.329 +	sample_t* out = m.extra_buf;
  21.330 +	sample_t const* in;
  21.331 +	for ( in = m.buf_begin + sample_count(); in < main_end; in++ )
  21.332 +		*out++ = *in;
  21.333 +	for ( in = dsp.extra(); in < dsp_end ; in++ )
  21.334 +		*out++ = *in;
  21.335 +	
  21.336 +	m.extra_pos = out;
  21.337 +	assert( out <= &m.extra_buf [extra_size] );
  21.338 +}
  21.339 +
  21.340 +blargg_err_t SNES_SPC::play( int count, sample_t* out )
  21.341 +{
  21.342 +	require( (count & 1) == 0 ); // must be even
  21.343 +	if ( count )
  21.344 +	{
  21.345 +		set_output( out, count );
  21.346 +		end_frame( count * (clocks_per_sample / 2) );
  21.347 +	}
  21.348 +	
  21.349 +	const char* err = m.cpu_error;
  21.350 +	m.cpu_error = 0;
  21.351 +	return err;
  21.352 +}
  21.353 +
  21.354 +blargg_err_t SNES_SPC::skip( int count )
  21.355 +{
  21.356 +	#if SPC_LESS_ACCURATE
  21.357 +	if ( count > 2 * sample_rate * 2 )
  21.358 +	{
  21.359 +		set_output( 0, 0 );
  21.360 +		
  21.361 +		// Skip a multiple of 4 samples
  21.362 +		time_t end = count;
  21.363 +		count = (count & 3) + 1 * sample_rate * 2;
  21.364 +		end = (end - count) * (clocks_per_sample / 2);
  21.365 +		
  21.366 +		m.skipped_kon  = 0;
  21.367 +		m.skipped_koff = 0;
  21.368 +		
  21.369 +		// Preserve DSP and timer synchronization
  21.370 +		// TODO: verify that this really preserves it
  21.371 +		int old_dsp_time = m.dsp_time + m.spc_time;
  21.372 +		m.dsp_time = end - m.spc_time + skipping_time;
  21.373 +		end_frame( end );
  21.374 +		m.dsp_time = m.dsp_time - skipping_time + old_dsp_time;
  21.375 +		
  21.376 +		dsp.write( SPC_DSP::r_koff, m.skipped_koff & ~m.skipped_kon );
  21.377 +		dsp.write( SPC_DSP::r_kon , m.skipped_kon );
  21.378 +		clear_echo();
  21.379 +	}
  21.380 +	#endif
  21.381 +	
  21.382 +	return play( count, 0 );
  21.383 +}