Add blank instance of blip_buf

2026-09-22 14:45:57 +00:00 · 2018-10-16 15:44:46 -07:00
parent 13a9efee6e
commit 22fb689097
7 changed files with 463 additions and 30 deletions
--- a/bugs/unimplementedHardware.txt
+++ b/bugs/unimplementedHardware.txt
@@ -6,12 +6,11 @@ On hardware PDIRQEG seems not to actually work at all(CPUID:0x57000000)
 SCR privilege violation doesnt trigger the same as on hardware(likely has to do with not emulating the unused chip selects)

 CPU I/O:
-Peripheral Control Register, audio ppm mixing selection and timer cascade mode
+Peripheral Control Register, audio ppm mixing selection
 Setting the battery dead bit(PDDATA 0x80) if the emulated battery percent gets too low(don't know how low this is, a test will be slow and painful with how big the battery is on my device)
 DRAMC write enable
 Port M Infrared shutdown (PMDATA 0x20)
 some undocumented I/O might be on port e and port j
-if a timer triggers more than once per CLK32(> 32768 times a second) it will lose any triggers after the first and get out of sync
 SPI1, probably the SD card since SD cards use SPI for data transfer
 SPITEST SSTATUS is undocumented and therefore unemulated
 may need to trigger an interrupt if a IMR masked interrupt becomes unmasked and its bit is still set in IPR
@@ -26,7 +25,6 @@ ICR POL(1,2,3,6) may flip the pin value as well as the interrupt, POL5 does not
 edge triggered INT* don't clear on write to ISR when masked in IMR(at least that seems to be the reason)
 PWM1 FIFOAV is always set true
 if a sound interrupt is triggered while the button interrupt is disabled the button interrupt will still trigger(in galax game)
-may need to force sound generation until buffer is adequately filled when sound is on(since SYSCLK precision is not possible)

 Debug tools:
 ADS7846 channels can't be read in single reference mode in hwTestSuite
@@ -50,6 +48,9 @@ in the edge case that SPICLK2 is disabled while using ADS7846 and a 1 was the la


 Fixed:
+may need to force sound generation until buffer is adequately filled when sound is on(not possible, INT_PWM1 is masked)
+if a timer triggers more than once per CLK32(> 32768 times a second) it will lose any triggers after the first and get out of sync(still not perfect but resolution is much higher)
+Peripheral Control Register, timer cascade mode
 MakePalmIcon 8bpp bitmaps have corrupt palettes
 missing home screen icons
 EMUCS memory range is unemulated(used for emu registers if enabled, invalid access otherwise)
--- a/qtBuildSystem/Mu/Mu.pro
+++ b/qtBuildSystem/Mu/Mu.pro
@@ -62,60 +62,62 @@ CONFIG += c++11
 INCLUDEPATH += $$PWD/qt-common/include

 SOURCES += \
+    debugviewer.cpp \
+    emuwrapper.cpp \
    main.cpp \
    mainwindow.cpp \
+    statemanager.cpp \
    touchscreen.cpp \
+    src/audio/blip_buf.c \
+    src/debug/sandbox.c \
    src/m68k/m68kcpu.c \
    src/m68k/m68kdasm.c \
    src/m68k/m68kopac.c \
    src/m68k/m68kopdm.c \
    src/m68k/m68kopnz.c \
    src/m68k/m68kops.c \
+    src/ads7846.c \
    src/emulator.c \
    src/hardwareRegisters.c \
+    src/m68328.c \
    src/memoryAccess.c \
+    src/pdiUsbD12.c \
    src/sdCard.c \
    src/sed1376.c \
-    src/silkscreen.c \
-    src/ads7846.c \
-    debugviewer.cpp \
-    emuwrapper.cpp \
-    src/debug/sandbox.c \
-    statemanager.cpp \
-    src/m68328.c \
-    src/pdiUsbD12.c
+    src/silkscreen.c

 HEADERS += \
+    src/audio/blip_buf.h \
+    src/debug/sandbox.h \
+    src/debug/sandboxTrapNumToName.c.h \
+    src/debug/trapNames.h \
    src/m68k/m68k.h \
    src/m68k/m68kconf.h \
    src/m68k/m68kcpu.h \
    src/m68k/m68kops.h \
+    src/specs/emuFeatureRegistersSpec.h \
+    src/specs/hardwareRegisterNames.h \
+    src/specs/pdiUsbD12Commands.h \
+    src/specs/sed1376RegisterNames.h \
+    src/ads7846.h \
    src/emulator.h \
+    src/endianness.h \
    src/hardwareRegisters.h \
+    src/hardwareRegistersAccessors.c.h \
+    src/hardwareRegistersTiming.c.h \
+    src/m68328.h \
    src/memoryAccess.h \
+    src/pdiUsbD12.h \
    src/portability.h \
    src/sdCard.h \
    src/sed1376.h \
-    src/silkscreen.h \
-    mainwindow.h \
-    touchscreen.h \
-    src/hardwareRegistersTiming.c.h \
    src/sed1376Accessors.c.h \
-    src/hardwareRegistersAccessors.c.h \
-    src/endianness.h \
-    src/ads7846.h \
+    src/silkscreen.h \
    debugviewer.h \
-    src/specs/emuFeatureRegistersSpec.h \
-    src/specs/hardwareRegisterNames.h \
-    src/specs/sed1376RegisterNames.h \
    emuwrapper.h \
-    src/debug/sandbox.h \
-    src/debug/sandboxTrapNumToName.c.h \
+    mainwindow.h \
    statemanager.h \
-    src/m68328.h \
-    src/pdiUsbD12.h \
-    src/specs/pdiUsbD12Commands.h \
-    src/debug/trapNames.h
+    touchscreen.h

 FORMS += \
    mainwindow.ui \
--- a/src/audio/blip_buf.c
+++ b/src/audio/blip_buf.c
@@ -0,0 +1,344 @@
+/* blip_buf 1.1.0. http://www.slack.net/~ant/ */
+
+#include "blip_buf.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <string.h>
+#include <stdlib.h>
+
+/* Library Copyright (C) 2003-2009 Shay Green. This library is free software;
+you can redistribute it and/or modify it under the terms of the GNU Lesser
+General Public License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version. This
+library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
+details. You should have received a copy of the GNU Lesser General Public
+License along with this module; if not, write to the Free Software Foundation,
+Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
+
+#if defined (BLARGG_TEST) && BLARGG_TEST
+	#include "blargg_test.h"
+#endif
+
+/* Equivalent to ULONG_MAX >= 0xFFFFFFFF00000000.
+Avoids constants that don't fit in 32 bits. */
+#if ULONG_MAX/0xFFFFFFFF > 0xFFFFFFFF
+	typedef unsigned long fixed_t;
+	enum { pre_shift = 32 };
+
+#elif defined(ULLONG_MAX)
+	typedef unsigned long long fixed_t;
+	enum { pre_shift = 32 };
+
+#else
+	typedef unsigned fixed_t;
+	enum { pre_shift = 0 };
+
+#endif
+
+enum { time_bits = pre_shift + 20 };
+
+static fixed_t const time_unit = (fixed_t) 1 << time_bits;
+
+enum { bass_shift  = 9 }; /* affects high-pass filter breakpoint frequency */
+enum { end_frame_extra = 2 }; /* allows deltas slightly after frame length */
+
+enum { half_width  = 8 };
+enum { buf_extra   = half_width*2 + end_frame_extra };
+enum { phase_bits  = 5 };
+enum { phase_count = 1 << phase_bits };
+enum { delta_bits  = 15 };
+enum { delta_unit  = 1 << delta_bits };
+enum { frac_bits = time_bits - pre_shift };
+
+/* We could eliminate avail and encode whole samples in offset, but that would
+limit the total buffered samples to blip_max_frame. That could only be
+increased by decreasing time_bits, which would reduce resample ratio accuracy.
+*/
+
+/** Sample buffer that resamples to output rate and accumulates samples
+until they're read out */
+struct blip_t
+{
+	fixed_t factor;
+	fixed_t offset;
+	int avail;
+	int size;
+	int integrator;
+};
+
+typedef int buf_t;
+
+/* probably not totally portable */
+#define SAMPLES( buf ) ((buf_t*) ((buf) + 1))
+
+/* Arithmetic (sign-preserving) right shift */
+#define ARITH_SHIFT( n, shift ) \
+	((n) >> (shift))
+
+enum { max_sample = +32767 };
+enum { min_sample = -32768 };
+
+#define CLAMP( n ) \
+	{\
+		if ( (short) n != n )\
+			n = ARITH_SHIFT( n, 16 ) ^ max_sample;\
+	}
+
+static void check_assumptions( void )
+{
+	int n;
+	
+	#if INT_MAX < 0x7FFFFFFF || UINT_MAX < 0xFFFFFFFF
+		#error "int must be at least 32 bits"
+	#endif
+	
+	assert( (-3 >> 1) == -2 ); /* right shift must preserve sign */
+	
+	n = max_sample * 2;
+	CLAMP( n );
+	assert( n == max_sample );
+	
+	n = min_sample * 2;
+	CLAMP( n );
+	assert( n == min_sample );
+	
+	assert( blip_max_ratio <= time_unit );
+	assert( blip_max_frame <= (fixed_t) -1 >> time_bits );
+}
+
+blip_t* blip_new( int size )
+{
+	blip_t* m;
+	assert( size >= 0 );
+	
+	m = (blip_t*) malloc( sizeof *m + (size + buf_extra) * sizeof (buf_t) );
+	if ( m )
+	{
+		m->factor = time_unit / blip_max_ratio;
+		m->size   = size;
+		blip_clear( m );
+		check_assumptions();
+	}
+	return m;
+}
+
+void blip_delete( blip_t* m )
+{
+	if ( m != NULL )
+	{
+		/* Clear fields in case user tries to use after freeing */
+		memset( m, 0, sizeof *m );
+		free( m );
+	}
+}
+
+void blip_set_rates( blip_t* m, double clock_rate, double sample_rate )
+{
+	double factor = time_unit * sample_rate / clock_rate;
+	m->factor = (fixed_t) factor;
+	
+	/* Fails if clock_rate exceeds maximum, relative to sample_rate */
+	assert( 0 <= factor - m->factor && factor - m->factor < 1 );
+	
+	/* Avoid requiring math.h. Equivalent to
+	m->factor = (int) ceil( factor ) */
+	if ( m->factor < factor )
+		m->factor++;
+	
+	/* At this point, factor is most likely rounded up, but could still
+	have been rounded down in the floating-point calculation. */
+}
+
+void blip_clear( blip_t* m )
+{
+	/* We could set offset to 0, factor/2, or factor-1. 0 is suitable if
+	factor is rounded up. factor-1 is suitable if factor is rounded down.
+	Since we don't know rounding direction, factor/2 accommodates either,
+	with the slight loss of showing an error in half the time. Since for
+	a 64-bit factor this is years, the halving isn't a problem. */
+	
+	m->offset     = m->factor / 2;
+	m->avail      = 0;
+	m->integrator = 0;
+	memset( SAMPLES( m ), 0, (m->size + buf_extra) * sizeof (buf_t) );
+}
+
+int blip_clocks_needed( const blip_t* m, int samples )
+{
+	fixed_t needed;
+	
+	/* Fails if buffer can't hold that many more samples */
+	assert( samples >= 0 && m->avail + samples <= m->size );
+	
+	needed = (fixed_t) samples * time_unit;
+	if ( needed < m->offset )
+		return 0;
+	
+	return (needed - m->offset + m->factor - 1) / m->factor;
+}
+
+void blip_end_frame( blip_t* m, unsigned t )
+{
+	fixed_t off = t * m->factor + m->offset;
+	m->avail += off >> time_bits;
+	m->offset = off & (time_unit - 1);
+	
+	/* Fails if buffer size was exceeded */
+	assert( m->avail <= m->size );
+}
+
+int blip_samples_avail( const blip_t* m )
+{
+	return m->avail;
+}
+
+static void remove_samples( blip_t* m, int count )
+{
+	buf_t* buf = SAMPLES( m );
+	int remain = m->avail + buf_extra - count;
+	m->avail -= count;
+	
+	memmove( &buf [0], &buf [count], remain * sizeof buf [0] );
+	memset( &buf [remain], 0, count * sizeof buf [0] );
+}
+
+int blip_read_samples( blip_t* m, short out [], int count, int stereo )
+{
+	assert( count >= 0 );
+	
+	if ( count > m->avail )
+		count = m->avail;
+	
+	if ( count )
+	{
+		int const step = stereo ? 2 : 1;
+		buf_t const* in  = SAMPLES( m );
+		buf_t const* end = in + count;
+		int sum = m->integrator;
+		do
+		{
+			/* Eliminate fraction */
+			int s = ARITH_SHIFT( sum, delta_bits );
+			
+			sum += *in++;
+			
+			CLAMP( s );
+			
+			*out = s;
+			out += step;
+			
+			/* High-pass filter */
+			sum -= s << (delta_bits - bass_shift);
+		}
+		while ( in != end );
+		m->integrator = sum;
+		
+		remove_samples( m, count );
+	}
+	
+	return count;
+}
+
+/* Things that didn't help performance on x86:
+	__attribute__((aligned(128)))
+	#define short int
+	restrict
+*/
+
+/* Sinc_Generator( 0.9, 0.55, 4.5 ) */
+static short const bl_step [phase_count + 1] [half_width] =
+{
+{   43, -115,  350, -488, 1136, -914, 5861,21022},
+{   44, -118,  348, -473, 1076, -799, 5274,21001},
+{   45, -121,  344, -454, 1011, -677, 4706,20936},
+{   46, -122,  336, -431,  942, -549, 4156,20829},
+{   47, -123,  327, -404,  868, -418, 3629,20679},
+{   47, -122,  316, -375,  792, -285, 3124,20488},
+{   47, -120,  303, -344,  714, -151, 2644,20256},
+{   46, -117,  289, -310,  634,  -17, 2188,19985},
+{   46, -114,  273, -275,  553,  117, 1758,19675},
+{   44, -108,  255, -237,  471,  247, 1356,19327},
+{   43, -103,  237, -199,  390,  373,  981,18944},
+{   42,  -98,  218, -160,  310,  495,  633,18527},
+{   40,  -91,  198, -121,  231,  611,  314,18078},
+{   38,  -84,  178,  -81,  153,  722,   22,17599},
+{   36,  -76,  157,  -43,   80,  824, -241,17092},
+{   34,  -68,  135,   -3,    8,  919, -476,16558},
+{   32,  -61,  115,   34,  -60, 1006, -683,16001},
+{   29,  -52,   94,   70, -123, 1083, -862,15422},
+{   27,  -44,   73,  106, -184, 1152,-1015,14824},
+{   25,  -36,   53,  139, -239, 1211,-1142,14210},
+{   22,  -27,   34,  170, -290, 1261,-1244,13582},
+{   20,  -20,   16,  199, -335, 1301,-1322,12942},
+{   18,  -12,   -3,  226, -375, 1331,-1376,12293},
+{   15,   -4,  -19,  250, -410, 1351,-1408,11638},
+{   13,    3,  -35,  272, -439, 1361,-1419,10979},
+{   11,    9,  -49,  292, -464, 1362,-1410,10319},
+{    9,   16,  -63,  309, -483, 1354,-1383, 9660},
+{    7,   22,  -75,  322, -496, 1337,-1339, 9005},
+{    6,   26,  -85,  333, -504, 1312,-1280, 8355},
+{    4,   31,  -94,  341, -507, 1278,-1205, 7713},
+{    3,   35, -102,  347, -506, 1238,-1119, 7082},
+{    1,   40, -110,  350, -499, 1190,-1021, 6464},
+{    0,   43, -115,  350, -488, 1136, -914, 5861}
+};
+
+/* Shifting by pre_shift allows calculation using unsigned int rather than
+possibly-wider fixed_t. On 32-bit platforms, this is likely more efficient.
+And by having pre_shift 32, a 32-bit platform can easily do the shift by
+simply ignoring the low half. */
+
+void blip_add_delta( blip_t* m, unsigned time, int delta )
+{
+	unsigned fixed = (unsigned) ((time * m->factor + m->offset) >> pre_shift);
+	buf_t* out = SAMPLES( m ) + m->avail + (fixed >> frac_bits);
+	
+	int const phase_shift = frac_bits - phase_bits;
+	int phase = fixed >> phase_shift & (phase_count - 1);
+	short const* in  = bl_step [phase];
+	short const* rev = bl_step [phase_count - phase];
+	
+	int interp = fixed >> (phase_shift - delta_bits) & (delta_unit - 1);
+	int delta2 = (delta * interp) >> delta_bits;
+	delta -= delta2;
+	
+	/* Fails if buffer size was exceeded */
+	assert( out <= &SAMPLES( m ) [m->size + end_frame_extra] );
+	
+	out [0] += in[0]*delta + in[half_width+0]*delta2;
+	out [1] += in[1]*delta + in[half_width+1]*delta2;
+	out [2] += in[2]*delta + in[half_width+2]*delta2;
+	out [3] += in[3]*delta + in[half_width+3]*delta2;
+	out [4] += in[4]*delta + in[half_width+4]*delta2;
+	out [5] += in[5]*delta + in[half_width+5]*delta2;
+	out [6] += in[6]*delta + in[half_width+6]*delta2;
+	out [7] += in[7]*delta + in[half_width+7]*delta2;
+	
+	in = rev;
+	out [ 8] += in[7]*delta + in[7-half_width]*delta2;
+	out [ 9] += in[6]*delta + in[6-half_width]*delta2;
+	out [10] += in[5]*delta + in[5-half_width]*delta2;
+	out [11] += in[4]*delta + in[4-half_width]*delta2;
+	out [12] += in[3]*delta + in[3-half_width]*delta2;
+	out [13] += in[2]*delta + in[2-half_width]*delta2;
+	out [14] += in[1]*delta + in[1-half_width]*delta2;
+	out [15] += in[0]*delta + in[0-half_width]*delta2;
+}
+
+void blip_add_delta_fast( blip_t* m, unsigned time, int delta )
+{
+	unsigned fixed = (unsigned) ((time * m->factor + m->offset) >> pre_shift);
+	buf_t* out = SAMPLES( m ) + m->avail + (fixed >> frac_bits);
+	
+	int interp = fixed >> (frac_bits - delta_bits) & (delta_unit - 1);
+	int delta2 = delta * interp;
+	
+	/* Fails if buffer size was exceeded */
+	assert( out <= &SAMPLES( m ) [m->size + end_frame_extra] );
+	
+	out [7] += delta * delta_unit - delta2;
+	out [8] += delta2;
+}
--- a/src/audio/blip_buf.h
+++ b/src/audio/blip_buf.h
@@ -0,0 +1,72 @@
+/** \file
+Sample buffer that resamples from input clock rate to output sample rate */
+
+/* blip_buf 1.1.0 */
+#ifndef BLIP_BUF_H 
+#define BLIP_BUF_H
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+/** First parameter of most functions is blip_t*, or const blip_t* if nothing
+is changed. */
+typedef struct blip_t blip_t;
+
+/** Creates new buffer that can hold at most sample_count samples. Sets rates
+so that there are blip_max_ratio clocks per sample. Returns pointer to new
+buffer, or NULL if insufficient memory. */
+blip_t* blip_new( int sample_count );
+
+/** Sets approximate input clock rate and output sample rate. For every
+clock_rate input clocks, approximately sample_rate samples are generated. */
+void blip_set_rates( blip_t*, double clock_rate, double sample_rate );
+
+enum { /** Maximum clock_rate/sample_rate ratio. For a given sample_rate,
+clock_rate must not be greater than sample_rate*blip_max_ratio. */
+blip_max_ratio = 1 << 20 };
+
+/** Clears entire buffer. Afterwards, blip_samples_avail() == 0. */
+void blip_clear( blip_t* );
+
+/** Adds positive/negative delta into buffer at specified clock time. */
+void blip_add_delta( blip_t*, unsigned int clock_time, int delta );
+
+/** Same as blip_add_delta(), but uses faster, lower-quality synthesis. */
+void blip_add_delta_fast( blip_t*, unsigned int clock_time, int delta );
+
+/** Length of time frame, in clocks, needed to make sample_count additional
+samples available. */
+int blip_clocks_needed( const blip_t*, int sample_count );
+
+enum { /** Maximum number of samples that can be generated from one time frame. */
+blip_max_frame = 4000 };
+
+/** Makes input clocks before clock_duration available for reading as output
+samples. Also begins new time frame at clock_duration, so that clock time 0 in
+the new time frame specifies the same clock as clock_duration in the old time
+frame specified. Deltas can have been added slightly past clock_duration (up to
+however many clocks there are in two output samples). */
+void blip_end_frame( blip_t*, unsigned int clock_duration );
+
+/** Number of buffered samples available for reading. */
+int blip_samples_avail( const blip_t* );
+
+/** Reads and removes at most 'count' samples and writes them to 'out'. If
+'stereo' is true, writes output to every other element of 'out', allowing easy
+interleaving of two buffers into a stereo sample stream. Outputs 16-bit signed
+samples. Returns number of samples actually read.  */
+int blip_read_samples( blip_t*, short out [], int count, int stereo );
+
+/** Frees buffer. No effect if NULL is passed. */
+void blip_delete( blip_t* );
+
+
+/* Deprecated */
+typedef blip_t blip_buffer_t;
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif
--- a/src/emulator.c
+++ b/src/emulator.c
@@ -4,6 +4,7 @@
 #include <string.h>

 #include "m68k/m68k.h"
+#include "audio/blip_buf.h"
 #include "m68328.h"
 #include "emulator.h"
 #include "hardwareRegisters.h"
@@ -40,6 +41,7 @@ sd_card_t palmSdCard;
 misc_hw_t palmMisc;
 uint16_t  palmFramebuffer[160 * (160 + 60)];//really 160*160, the extra pixels are the silkscreened digitizer area
 uint16_t* palmExtendedFramebuffer;
+blip_t*   palmAudioResampler;
 int16_t   palmAudio[AUDIO_SAMPLES_PER_FRAME * 2];
 uint32_t  palmSpecialFeatures;
 double    palmSysclksPerClk32;//how many SYSCLK cycles before toggling the 32.768 kHz crystal
@@ -57,15 +59,18 @@ uint32_t emulatorInit(buffer_t palmRomDump, buffer_t palmBootDump, uint32_t spec
   //allocate the buffers
   palmRam = malloc((specialFeatures & FEATURE_RAM_HUGE) ? SUPERMASSIVE_RAM_SIZE : RAM_SIZE);
   palmRom = malloc(ROM_SIZE);
+   palmAudioResampler = blip_new(AUDIO_SAMPLES_PER_FRAME);
   if(specialFeatures & FEATURE_320x320)
      palmExtendedFramebuffer = malloc(320 * (320 + 120) * sizeof(uint16_t));//really 320*320, the extra pixels are the silkscreened digitizer area
   else
      palmExtendedFramebuffer = NULL;
-   if(!palmRam || !palmRom || (!palmExtendedFramebuffer && (specialFeatures & FEATURE_320x320))){
+   if(!palmRam || !palmRom || !palmAudioResampler || (!palmExtendedFramebuffer && (specialFeatures & FEATURE_320x320))){
      if(palmRam)
         free(palmRam);
      if(palmRom)
         free(palmRom);
+      if(palmAudioResampler)
+         blip_delete(palmAudioResampler);
      if(palmExtendedFramebuffer)
         free(palmExtendedFramebuffer);
      return EMU_ERROR_OUT_OF_MEMORY;
@@ -124,6 +129,7 @@ void emulatorExit(){
   if(emulatorInitialized){
      free(palmRam);
      free(palmRom);
+      blip_delete(palmAudioResampler);
      if(palmSpecialFeatures & FEATURE_320x320)
         free(palmExtendedFramebuffer);
      if(palmSdCard.flashChip.data)
@@ -504,5 +510,10 @@ void emulateFrame(){
      m68328Execute();
   palmCycleCounter -= (double)CRYSTAL_FREQUENCY / EMU_FPS;

+   //blip_end_frame(palmAudioResampler, 5);
+   //blip_read_samples(palmAudioResampler, palmAudio, AUDIO_SAMPLES_PER_FRAME, true);
+   //for(uint32_t samples = 0; samples < AUDIO_SAMPLES_PER_FRAME * 2; samples += 2)
+   //   palmAudio[samples + 1] = palmAudio[samples];
+
   sed1376Render();
 }
--- a/src/emulator.h
+++ b/src/emulator.h
@@ -10,6 +10,7 @@ extern "C" {
 #include <stdarg.h>
 #include <stdio.h>

+#include "audio/blip_buf.h"
 #include "memoryAccess.h"//for size macros
 #include "specs/emuFeatureRegistersSpec.h"//for feature names

@@ -130,6 +131,7 @@ extern sd_card_t palmSdCard;//dont touch
 extern misc_hw_t palmMisc;//read/write allowed
 extern uint16_t  palmFramebuffer[];//read allowed if FEATURE_320x320 is off, or else invalid data will be displayed
 extern uint16_t* palmExtendedFramebuffer;//read allowed if FEATURE_320x320 is on, or else SIGSEGV
+extern blip_t*   palmAudioResampler;//dont touch
 extern int16_t   palmAudio[];//read allowed, 2 channel signed 16 bit audio
 extern uint32_t  palmSpecialFeatures;//read allowed
 extern double    palmSysclksPerClk32;//dont touch
--- a/src/makefile.all
+++ b/src/makefile.all
@@ -1,4 +1,4 @@
-EMU_SOURCES_C := $(EMU_PATH)/emulator.c \
+EMU_SOURCES_C := $(EMU_PATH)/emulator.c \
      $(EMU_PATH)/memoryAccess.c \
      $(EMU_PATH)/hardwareRegisters.c \
      $(EMU_PATH)/sed1376.c \
@@ -6,11 +6,12 @@ EMU_SOURCES_C := $(EMU_PATH)/emulator.c \
      $(EMU_PATH)/pdiUsbD12.c \
      $(EMU_PATH)/sdCard.c \
      $(EMU_PATH)/silkscreen.c \
-      $(EMU_PATH)/m68328.c \
+      $(EMU_PATH)/m68328.c \
      $(EMU_PATH)/m68k/m68kops.c \
      $(EMU_PATH)/m68k/m68kopnz.c \
      $(EMU_PATH)/m68k/m68kopdm.c \
      $(EMU_PATH)/m68k/m68kopac.c \
      $(EMU_PATH)/m68k/m68kdasm.c \
      $(EMU_PATH)/m68k/m68kcpu.c \
+      $(EMU_PATH)/audio/blip_buf.c \
      $(EMU_PATH)/debug/sandbox.c