fixGB/apu.c

/*
 * Copyright (C) 2017 FIX94
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

#include <stdio.h>
#include <stdbool.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
#include "apu.h"
#include "audio.h"
#include "mem.h"
#include "cpu.h"

//Upper bits of FF25 are Left
#define P1_ENABLE_LEFT (1<<4)
#define P2_ENABLE_LEFT (1<<5)
#define WAV_ENABLE_LEFT (1<<6)
#define NOISE_ENABLE_LEFT (1<<7)

//Lower bits of FF25 are Right
#define P1_ENABLE_RIGHT (1<<0)
#define P2_ENABLE_RIGHT (1<<1)
#define WAV_ENABLE_RIGHT (1<<2)
#define NOISE_ENABLE_RIGHT (1<<3)

static uint8_t APU_IO_Reg[0x50];
#if AUDIO_FLOAT
static float lpVal;
static float hpVal;
static const float volLevel[8] = {
	0.125f, 0.25f, 0.375f, 0.5f, 0.625f, 0.75f, 0.875f, 1.0f,
};
static float *apuOutBuf;
#else
static int32_t lpVal;
static int32_t hpVal;
static int16_t *apuOutBuf;
#endif
static uint32_t apuBufSize;
static uint32_t apuBufSizeBytes;
static uint32_t curBufPos;
static uint32_t apuFrequency;
static uint16_t freq1;
static uint16_t freq2;
static uint16_t wavFreq;
static uint16_t noiseFreq;
static uint16_t noiseShiftReg;
static uint8_t p1LengthCtr, p2LengthCtr, noiseLengthCtr;
static uint8_t wavLinearCtr;
static uint16_t wavLengthCtr;
static uint8_t wavVolShift;
static uint16_t modeCurCtr;
static uint8_t modePos;
static uint16_t p1freqCtr, p2freqCtr, wavFreqCtr, noiseFreqCtr;
static uint8_t p1Cycle, p2Cycle, wavCycle;
static bool p1haltloop, p2haltloop, wavhaltloop, noisehaltloop;
static bool p1dacenable, p2dacenable, wavdacenable, noisedacenable;
static bool p1enable, p2enable, wavenable, noiseenable;
static bool soundEnabled;
static bool noiseMode1;
static bool wavEqual;

static envelope_t p1Env, p2Env, noiseEnv;

typedef struct _sweep_t {
	bool enabled;
	bool negative;
	bool inNegative;
	uint8_t period;
	uint8_t divider;
	uint8_t shift;
	uint16_t pfreq;
} sweep_t;

static sweep_t p1Sweep;

//used externally
const uint8_t pulseSeqs[4][8] = {
	{ 0, 1, 0, 0, 0, 0, 0, 0 },
	{ 0, 1, 1, 0, 0, 0, 0, 0 },
	{ 0, 1, 1, 1, 1, 0, 0, 0 },
	{ 1, 0, 0, 1, 1, 1, 1, 1 },
};

static const uint16_t noisePeriodNtsc[8] = {
	8, 16, 32, 48, 64, 80, 96, 112,
};

//wav values from http://gbdev.gg8.se/wiki/articles/Gameboy_sound_hardware#Power_Control
static const uint8_t startWavSetDMG[0x10] = {
	0x84, 0x40, 0x43, 0xAA, 0x2D, 0x78, 0x92, 0x3C,
	0x60, 0x59, 0x59, 0xB0, 0x34, 0xB8, 0x2E, 0xDA,
};

static const uint8_t startWavSetCGB[0x10] = {
	0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
	0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF,
};

//used externally
const uint16_t *noisePeriod;

static const uint8_t *p1seq = pulseSeqs[0], 
					*p2seq = pulseSeqs[1];

#define M_2_PI 6.28318530717958647692

void apuInitBufs()
{
	noisePeriod = noisePeriodNtsc;
	//effective frequency for 60.000Hz Video out
	//apuFrequency = 526680;
	//effective frequency for original LCD Video out
	apuFrequency = 262144;
	double dt = 1.0/((double)apuFrequency);

	//LP at 20kHz
	double rc = 1.0/(M_2_PI * 20000.0);
#if AUDIO_FLOAT
	lpVal = dt / (rc + dt);
#else
	//convert to 32bit int for calcs later
	lpVal = (int32_t)((dt / (rc + dt))*32768.0);
#endif
	//HP at 20Hz for GB/GBA (150Hz for GBC)
	rc = 1.0/(M_2_PI * 20.0);
#if AUDIO_FLOAT
	hpVal = rc / (rc + dt);
#else
	//convert to 32bit int for calcs later
	hpVal = (int32_t)((rc / (rc + dt))*32768.0);
#endif
	//keep exactly 1 frame buffer
	apuBufSize = 70224/16*2;
#if AUDIO_FLOAT
	apuBufSizeBytes = apuBufSize*sizeof(float);
	apuOutBuf = (float*)malloc(apuBufSizeBytes);
	printf("Audio: 32-bit Float Output\n"); 
#else
	apuBufSizeBytes = apuBufSize*sizeof(int16_t);
	apuOutBuf = (int16_t*)malloc(apuBufSizeBytes);
	printf("Audio: 16-bit Short Output\n");
#endif
}

void apuDeinitBufs()
{
	if(apuOutBuf)
		free(apuOutBuf);
	apuOutBuf = NULL;
}

#if AUDIO_FLOAT
static float lastHPOutLeft, lastHPOutRight, lastLPOutLeft, lastLPOutRight;
#else
static int32_t lastHPOutLeft, lastHPOutRight, lastLPOutLeft, lastLPOutRight;
#endif
//used externally
uint8_t curP1Out, curP2Out, curWavOut, curNoiseOut;

extern bool emuSkipVsync, emuSkipFrame;

extern bool gbCgbMode;
extern bool gbCgbBootrom;
void apuInit()
{
	memset(APU_IO_Reg,0,0x50);
	if(gbCgbMode) //essentially 50% duty pulse on CGB
		memcpy(APU_IO_Reg+0x30,startWavSetCGB,0x10);
	else //relatively random audio pattern on DMG
		memcpy(APU_IO_Reg+0x30,startWavSetDMG,0x10);
	memset(apuOutBuf, 0, apuBufSizeBytes);
	curBufPos = 0;

	modeCurCtr = 0;
	modePos = 0;

	freq1 = 0; freq2 = 0; wavFreq = 0; noiseFreq = 0;
	noiseShiftReg = 0;
	p1LengthCtr = 0; p2LengthCtr = 0;
	noiseLengthCtr = 0;	wavLengthCtr = 0;
	wavLinearCtr = 0;
	p1freqCtr = 0; p2freqCtr = 0; wavFreqCtr = 0, noiseFreqCtr = 0;
	p1Cycle = 0; p2Cycle = 0; wavCycle = 0;
	wavVolShift = 4; //default

	memset(&p1Env,0,sizeof(envelope_t));
	memset(&p2Env,0,sizeof(envelope_t));
	memset(&noiseEnv,0,sizeof(envelope_t));

	memset(&p1Sweep,0,sizeof(sweep_t));

	p1haltloop = false; p2haltloop = false;
	wavhaltloop = false; noisehaltloop = false;
	p1enable = false; p2enable = false;
	wavenable = false; noiseenable = false;
	p1dacenable = false; p2dacenable = false;
	wavdacenable = false; noisedacenable = false;
	noiseMode1 = false;
	wavEqual = false;
	if(gbCgbBootrom)
		soundEnabled = false;
	else //GB Bootrom
	{
		soundEnabled = true;
		APU_IO_Reg[0x24] = 0x77;
		APU_IO_Reg[0x25] = 0xF3;
	}

	lastHPOutLeft = 0, lastHPOutRight = 0, lastLPOutLeft = 0, lastLPOutRight = 0;
	curP1Out = 0, curP2Out = 0, curWavOut = 0, curNoiseOut = 0;
}

bool apuCycle()
{
	if(curBufPos == apuBufSize)
	{
#ifndef __LIBRETRO__
		int updateRes = audioUpdate();
		if(updateRes == 0)
		{
			emuSkipFrame = false;
			emuSkipVsync = false;
			return false;
		}
		if(updateRes > 6)
		{
			emuSkipVsync = true;
			emuSkipFrame = true;
		}
		else
		{
			emuSkipFrame = false;
			if(updateRes > 2)
				emuSkipVsync = true;
			else
				emuSkipVsync = false;
		}
#endif
		curBufPos = 0;
	}
	int8_t p1Out = 0, p2Out = 0, noiseOut = 0, wavOut = 0;
	int8_t p1OutLeft = 0, p2OutLeft = 0, 
		wavOutLeft = 0, noiseOutLeft = 0;
	int8_t p1OutRight = 0, p2OutRight = 0, 
		wavOutRight = 0, noiseOutRight = 0;
	int8_t apuMasterVolLeft = ((APU_IO_Reg[0x24]>>4)&7), apuMasterVolRight = (APU_IO_Reg[0x24]&7);
	if(p1enable && p1dacenable)
	{
		if(p1seq[p1Cycle])
			curP1Out = p1Env.curVol;
		else
			curP1Out = 0;
		//actually audible output
		if(freq1 > 0 && freq1 < 0x7FF)
		{
			//GB/GBC Behavior
			//p1Out = (curP1Out<<1)-15;
			//GBA Behavior
			p1Out = (curP1Out<<1)-p1Env.curVol;
		}
	}
	else
		curP1Out = 0;
	if(APU_IO_Reg[0x25] & P1_ENABLE_LEFT)
		p1OutLeft = p1Out;
	if(APU_IO_Reg[0x25] & P1_ENABLE_RIGHT)
		p1OutRight = p1Out;
	if(p2enable && p2dacenable)
	{
		if(p2seq[p2Cycle])
			curP2Out = p2Env.curVol;
		else
			curP2Out = 0;
		//actually audible output
		if(freq2 > 0 && freq2 < 0x7FF)
		{
			//GB/GBC Behavior
			//p2Out = (curP2Out<<1)-15;
			//GBA Behavior
			p2Out = (curP2Out<<1)-p2Env.curVol;
		}
	}
	else
		curP2Out = 0;
	if(APU_IO_Reg[0x25] & P2_ENABLE_LEFT)
		p2OutLeft = p2Out;
	if(APU_IO_Reg[0x25] & P2_ENABLE_RIGHT)
		p2OutRight = p2Out;
	if(wavenable && wavdacenable)
	{
		curWavOut = APU_IO_Reg[0x30+(wavCycle>>1)];
		if((wavCycle&1)==0)
			curWavOut >>= 4; 
		else
			curWavOut &= 0xF;
		curWavOut >>= wavVolShift;
		//actually audible output
		if((wavFreq > 0 && wavFreq < 0x7FF) || wavEqual)
			wavOut = (curWavOut<<1)-15;
	}
	else
		curWavOut = 0;
	if(APU_IO_Reg[0x25] & WAV_ENABLE_LEFT)
		wavOutLeft = wavOut;
	if(APU_IO_Reg[0x25] & WAV_ENABLE_RIGHT)
		wavOutRight = wavOut;
	if(noiseenable && noisedacenable)
	{
		if((noiseShiftReg&1) == 0)
			curNoiseOut = noiseEnv.curVol;
		else
			curNoiseOut = 0;
		//actually audible output
		if(noiseFreq > 0)
		{
			//GB/GBC Behavior
			//noiseOut = (curNoiseOut<<1)-15;
			//GBA Behavior
			noiseOut = (curNoiseOut<<1)-noiseEnv.curVol;
		}
	}
	else
		curNoiseOut = 0;
	if(APU_IO_Reg[0x25] & NOISE_ENABLE_LEFT)
		noiseOutLeft = noiseOut;
	if(APU_IO_Reg[0x25] & NOISE_ENABLE_RIGHT)
		noiseOutRight = noiseOut;
#if AUDIO_FLOAT
	//gen output Left
	float curInLeft = ((float)(p1OutLeft + p2OutLeft + wavOutLeft + noiseOutLeft))*volLevel[apuMasterVolLeft]/85.333333f;
	float curLPOutLeft = lastLPOutLeft+(lpVal*(curInLeft-lastLPOutLeft));
	float curHPOutLeft = hpVal*(lastHPOutLeft+lastLPOutLeft-curLPOutLeft);
	//gen output Right
	float curInRight = ((float)(p1OutRight + p2OutRight + wavOutRight + noiseOutRight))*volLevel[apuMasterVolRight]/85.333333f;
	float curLPOutRight = lastLPOutRight+(lpVal*(curInRight-lastLPOutRight));
	float curHPOutRight = hpVal*(lastHPOutRight+lastLPOutRight-curLPOutRight);
	//set output Left
	apuOutBuf[curBufPos++] = ((soundEnabled)?curHPOutLeft:0);
	//set output Right
	apuOutBuf[curBufPos++] = ((soundEnabled)?curHPOutRight:0);
	//save HP and LP Left
	lastLPOutLeft = curLPOutLeft;
	lastHPOutLeft = curHPOutLeft;
	//save HP and LP Right
	lastLPOutRight = curLPOutRight;
	lastHPOutRight = curHPOutRight;
#else
	int32_t curIn, curOut;
	//gen output Left
	curIn = (p1OutLeft + p2OutLeft + wavOutLeft + noiseOutLeft)*(apuMasterVolLeft+1)*48;
	curOut = lastLPOutLeft+((lpVal*(curIn-lastLPOutLeft))>>15); //Set Left Lowpass Output
	curIn = (lastHPOutLeft+lastLPOutLeft-curOut); //Set Left Highpass Input
	curIn += (curIn>>31)&1; //Add Sign Bit for proper Downshift later
	lastLPOutLeft = curOut; //Save Left Lowpass Output
	curOut = (hpVal*curIn)>>15; //Set Left Highpass Output
	lastHPOutLeft = curOut; //Save Left Highpass Output
	//Save Clipped Left Highpass Output
	apuOutBuf[curBufPos++] = ((soundEnabled)?((curOut > 32767)?(32767):((curOut < -32768)?(-32768):curOut)):0);
	//gen output Right
	curIn = (p1OutRight + p2OutRight + wavOutRight + noiseOutRight)*(apuMasterVolRight+1)*48;
	curOut = lastLPOutRight+((lpVal*(curIn-lastLPOutRight))>>15); //Set Right Lowpass Output
	curIn = (lastHPOutRight+lastLPOutRight-curOut); //Set Right Highpass Input
	curIn += (curIn>>31)&1; //Add Sign Bit for proper Downshift later
	lastLPOutRight = curOut; //Save Right Lowpass Output
	curOut = (hpVal*curIn)>>15; //Set Right Highpass Output
	lastHPOutRight = curOut; //Save Right Highpass Output
	//Save Clipped Right Highpass Output
	apuOutBuf[curBufPos++] = ((soundEnabled)?((curOut > 32767)?(32767):((curOut < -32768)?(-32768):curOut)):0);
#endif
	return true;
}

#ifdef __LIBRETRO__
void audioFrameEnd(int samples);
void apuFrameEnd()
{
	audioFrameEnd(curBufPos>>1);
	curBufPos = 0;
}
#endif

void doEnvelopeLogic(envelope_t *env)
{
	if(env->divider == 0)
	{
		if(env->period)
		{
			if(env->modeadd)
			{
				if(env->curVol < 15)
					env->curVol++;
			}
			else
			{
				if(env->curVol > 0)
					env->curVol--;
			}
		}
		//period 0 is actually period 8!
		env->divider = (env->period-1)&7;
	}
	else
		env->divider--;
}

void sweepUpdateFreq(sweep_t *sw, uint16_t *freq, bool update)
{
	if(!sw->enabled)
		return;
	//printf("%i\n", *freq);
	uint16_t inFreq = sw->pfreq;
	uint16_t shiftVal = (inFreq >> sw->shift);

	if(sw->negative)
	{
		sw->inNegative = true;
		inFreq -= shiftVal;
	}
	else
		inFreq += shiftVal;

	if(inFreq <= 0x7FF)
	{
		if(sw->enabled && sw->shift && sw->period && update)
		{
			*freq = inFreq;
			sw->pfreq = inFreq;
		}
	}
	else
	{
		//printf("Freq disabled\n");
		p1enable = false;
	}
}

void doSweepLogic(sweep_t *sw, uint16_t *freq)
{
	if(sw->divider == 0)
	{
		//printf("Divider 0\n");
		if(sw->period)
		{
			sweepUpdateFreq(sw, freq, true);
			//gameboy checks a SECOND time after updating...
			uint16_t inFreq = sw->pfreq;
			uint16_t shiftVal = (inFreq >> sw->shift);
			if(sw->negative)
				inFreq -= shiftVal;
			else
				inFreq += shiftVal;
			if(inFreq > 0x7FF)
			{
				//printf("Freq disabled\n");
				p1enable = false;
			}
		}
		//period 0 is actually period 8!
		sw->divider = (sw->period-1)&7;
	}
	else
		sw->divider--;
}

void apuClockA()
{
	//printf("Len clock\n");
	if(p1LengthCtr && !p1haltloop)
	{
		p1LengthCtr--;
		if(p1LengthCtr == 0)
			p1enable = false;
	}
	if(p2LengthCtr && !p2haltloop)
	{
		p2LengthCtr--;
		if(p2LengthCtr == 0)
			p2enable = false;
	}
	if(wavLengthCtr && !wavhaltloop)
	{
		wavLengthCtr--;
		if(wavLengthCtr == 0)
			wavenable = false;
	}
	if(noiseLengthCtr && !noisehaltloop)
	{
		noiseLengthCtr--;
		if(noiseLengthCtr == 0)
			noiseenable = false;
	}
}

void apuClockB()
{
	if(p1LengthCtr)
		doEnvelopeLogic(&p1Env);
	if(p2LengthCtr)
		doEnvelopeLogic(&p2Env);
	if(noiseLengthCtr)
		doEnvelopeLogic(&noiseEnv);
}

void apuClockTimers()
{
	if(modeCurCtr == 0)
	{
		modePos++;
		if(modePos&1)
			apuClockA();
		if(modePos == 3 || modePos == 7)
		{
			//printf("sweep clock\n");
			if(p1LengthCtr)
				doSweepLogic(&p1Sweep, &freq1);
		}
		if(modePos >= 8)
		{
			apuClockB();
			modePos = 0;
		}
		modeCurCtr = 8192;
	}
	if(modeCurCtr)
		modeCurCtr--;

	if(p1freqCtr == 0)
	{
		if(freq1)
			p1freqCtr = (2048-freq1)*4;
		p1Cycle++;
		if(p1Cycle >= 8)
			p1Cycle = 0;
	}
	if(p1freqCtr)
		p1freqCtr--;

	if(p2freqCtr == 0)
	{
		if(freq2)
			p2freqCtr = (2048-freq2)*4;
		p2Cycle++;
		if(p2Cycle >= 8)
			p2Cycle = 0;
	}
	if(p2freqCtr)
		p2freqCtr--;

	if(wavFreqCtr == 0)
	{
		wavFreqCtr = (2048-wavFreq)*2;
		wavCycle++;
		if(wavCycle >= 32)
			wavCycle = 0;
	}
	if(wavFreqCtr)
		wavFreqCtr--;

	if(noiseFreqCtr == 0)
	{
		noiseFreqCtr = noiseFreq;
		uint8_t cmpRes = (noiseShiftReg&1)^((noiseShiftReg>>1)&1);
		noiseShiftReg >>= 1;
		noiseShiftReg |= cmpRes << (noiseMode1 ? 6 : 14);
	}
	if(noiseFreqCtr)
		noiseFreqCtr--;
}

void apuSetReg8(uint16_t addr, uint8_t val)
{
	uint8_t reg = addr&0xFF;
	//printf("APU set %02x %02x\n", reg, val);
	if(reg == 0x26)
	{
		bool wasEnabled = soundEnabled;
		soundEnabled = (val&0x80)!=0;
		if(!soundEnabled)
		{
			// FULL reset of nearly every reg
			memset(APU_IO_Reg,0,0x30);
			// except for the wav buffer
			memset(APU_IO_Reg+0x40,0,0x10);
			memset(&p1Env,0,sizeof(envelope_t));
			memset(&p2Env,0,sizeof(envelope_t));
			memset(&noiseEnv,0,sizeof(envelope_t));
			memset(&p1Sweep,0,sizeof(sweep_t));
			p1LengthCtr = 0; p2LengthCtr = 0;
			wavLengthCtr = 0; noiseLengthCtr = 0;
			p1enable = false; p2enable = false;
			wavenable = false; noiseenable = false;
			p1dacenable = false; p2dacenable = false;
			wavdacenable = false; noisedacenable = false;
			freq1 = 0; freq2 = 0; wavFreq = 0; noiseFreq = 0;
			wavVolShift = 4; //default
		}
		else
		{
			APU_IO_Reg[0x26] = val;
			//on sound powerup, reset frame sequencer
			if(!wasEnabled)
			{
				modeCurCtr = 8192;
				modePos = 0;
			}
		}
		return;
	}
	//even if sound off, still update wav buffer
	else if(reg >= 0x30 && reg < 0x40)
	{
		if(wavenable)
			APU_IO_Reg[0x30+(wavCycle>>1)] = val;
		else
			APU_IO_Reg[reg] = val;
		//allow for manual wav inputs if all wav inputs are equal
		wavEqual = ((*(uint32_t*)(APU_IO_Reg+0x30) == *(uint32_t*)(APU_IO_Reg+0x34)) &&
					(*(uint32_t*)(APU_IO_Reg+0x34) == *(uint32_t*)(APU_IO_Reg+0x38)) &&
					(*(uint32_t*)(APU_IO_Reg+0x38) == *(uint32_t*)(APU_IO_Reg+0x3C)) );
		return;
	}
	//dont even bother with the switch if sound is off
	else if(!soundEnabled)
		return;
	bool p1prevhaltloop, p2prevhaltloop,
		wavprevhaltloop, noiseprevhaltloop;
	APU_IO_Reg[reg] = val;
	switch(reg)
	{
		case 0x10:
			//printf("P1 sweep %02x\n", val);
			p1Sweep.shift = val&7;
			p1Sweep.period = (val>>4)&7;
			p1Sweep.negative = ((val&0x8) != 0);
			if(p1Sweep.inNegative && !p1Sweep.negative)
				p1enable = false;
			break;
		case 0x11:
			p1seq = pulseSeqs[val>>6];
			p1LengthCtr = 64-(val&0x3F);
			break;
		case 0x12:
			p1Env.vol = (val>>4)&0xF;
			p1Env.modeadd = (val&8)!=0;
			if(p1Env.modeadd && p1Env.period == 0 && (val&7) == 0)
			{
				//"Zombie" Mode
				p1Env.curVol++;
				p1Env.curVol &= 0xF;
			}
			p1dacenable = (p1Env.modeadd || p1Env.vol);
			if(!p1dacenable)
				p1enable = false;
			p1Env.period = val&7;
			break;
		case 0x13:
			freq1 = ((freq1&~0xFF) | val);
			//printf("P1 new freq %04x\n", freq1);
			break;
		case 0x14:
			p1prevhaltloop = p1haltloop;
			p1haltloop = ((val&(1<<6)) == 0);
			freq1 = (freq1&0xFF) | ((val&7)<<8);
			//if length was previously frozen and we are in
			//an odd frame sequence, clock length right now
			if(p1prevhaltloop && !p1haltloop && p1LengthCtr && (modePos&1))
			{
				p1LengthCtr--;
				//disable channel immediately if length
				//reached 0 from this extra clock
				if(p1LengthCtr == 0)
					p1enable = false;
			}
			if(val&(1<<7))
			{
				if(p1dacenable)
					p1enable = true;
				if(p1LengthCtr == 0)
				{
					p1LengthCtr = 64;
					//if length enabled and we are in an odd frame
					//sequence, subtract one from newly set clock length
					if(!p1haltloop && (modePos&1))
						p1LengthCtr--;
				}
				//trigger reloads frequency timers
				p1Cycle = 0;
				if(freq1)
					p1freqCtr = (2048-freq1)*4;
				//trigger resets env volume
				p1Env.curVol = p1Env.vol;
				//period 0 is actually period 8!
				p1Env.divider = (p1Env.period-1)&7;
				//trigger used to enable/disable sweep
				if(p1Sweep.period || p1Sweep.shift)
					p1Sweep.enabled = true;
				else
					p1Sweep.enabled = false;
				//trigger also resets divider, neg mode and frequency
				p1Sweep.inNegative = false;
				p1Sweep.pfreq = freq1;
				//period 0 is actually period 8!
				p1Sweep.divider = (p1Sweep.period-1)&7;
				//if sweep shift>0, pre-calc frequency
				if(p1Sweep.shift)
					sweepUpdateFreq(&p1Sweep, &freq1, false);
			}
			//printf("P1 new freq %04x\n", freq1);
			break;
		case 0x16:
			p2seq = pulseSeqs[val>>6];
			p2LengthCtr = 64-(val&0x3F);
			break;
		case 0x17:
			p2Env.vol = (val>>4)&0xF;
			p2Env.modeadd = (val&8)!=0;
			if(p2Env.modeadd && p2Env.period == 0 && (val&7) == 0)
			{
				//"Zombie" Mode
				p2Env.curVol++;
				p2Env.curVol &= 0xF;
			}
			p2dacenable = (p2Env.modeadd || p2Env.vol);
			if(!p2dacenable)
				p2enable = false;
			p2Env.period = val&7;
			break;
		case 0x18:
			freq2 = ((freq2&~0xFF) | val);
			//printf("P2 new freq %04x\n", freq2);
			break;
		case 0x19:
			p2prevhaltloop = p2haltloop;
			p2haltloop = ((val&(1<<6)) == 0);
			freq2 = (freq2&0xFF) | ((val&7)<<8);
			//if length was previously frozen and we are in
			//an odd frame sequence, clock length right now
			if(p2prevhaltloop && !p2haltloop && p2LengthCtr && (modePos&1))
			{
				p2LengthCtr--;
				//disable channel immediately if length
				//reached 0 from this extra clock
				if(p2LengthCtr == 0)
					p2enable = false;
			}
			if(val&(1<<7))
			{
				if(p2dacenable)
					p2enable = true;
				if(p2LengthCtr == 0)
				{
					p2LengthCtr = 64;
					//if length enabled and we are in an odd frame
					//sequence, subtract one from newly set clock length
					if(!p2haltloop && (modePos&1))
						p2LengthCtr--;
				}
				//trigger reloads frequency timers
				p2Cycle = 0;
				if(freq2)
					p2freqCtr = (2048-freq2)*4;
				//trigger resets env volume
				p2Env.curVol = p2Env.vol;
				//period 0 is actually period 8!
				p2Env.divider = (p2Env.period-1)&7;
			}
			//printf("P2 new freq %04x\n", freq2);
			break;
		case 0x1A:
			wavdacenable = ((val&0x80)!=0);
			if(!wavdacenable)
				wavenable = false;
			break;
		case 0x1B:
			wavLengthCtr = 256-val;
			break;
		case 0x1C:
			//printf("wavVolShift %i\n", (val>>5)&3);
			switch((val>>5)&3)
			{
				case 0:
					wavVolShift=4;
					break;
				case 1:
					wavVolShift=0;
					break;
				case 2:
					wavVolShift=1;
					break;
				case 3:
					wavVolShift=2;
					break;
			}
			break;
		case 0x1D:
			wavFreq = ((wavFreq&~0xFF) | val);
			//printf("wav new freq %04x\n", wavFreq);
			break;
		case 0x1E:
			wavprevhaltloop = wavhaltloop;
			wavhaltloop = ((val&(1<<6)) == 0);
			wavFreq = (wavFreq&0xFF) | ((val&7)<<8);
			//if length was previously frozen and we are in
			//an odd frame sequence, clock length right now
			if(wavprevhaltloop && !wavhaltloop && wavLengthCtr && (modePos&1))
			{
				wavLengthCtr--;
				//disable channel immediately if length
				//reached 0 from this extra clock
				if(wavLengthCtr == 0)
					wavenable = false;
			}
			if(val&(1<<7))
			{
				if(wavdacenable)
					wavenable = true;
				if(wavLengthCtr == 0)
				{
					wavLengthCtr = 256;
					//if length enabled and we are in an odd frame
					//sequence, subtract one from newly set clock length
					if(!wavhaltloop && (modePos&1))
						wavLengthCtr--;
				}
				//trigger reloads frequency timers
				wavCycle = 0;
				//not sure why +4 needed to sync initally,
				//probably because of sample buffer byte
				wavFreqCtr = ((2048-wavFreq)*2)+4;
			}
			//printf("wav new freq %04x\n", wavFreq);
			break;
		case 0x20:
			noiseLengthCtr = 64-(val&0x3F);
			break;
		case 0x21:
			noiseEnv.vol = (val>>4)&0xF;
			noiseEnv.modeadd = (val&8)!=0;
			if(noiseEnv.modeadd && noiseEnv.period == 0 && (val&7) == 0)
			{
				//"Zombie" Mode
				noiseEnv.curVol++;
				noiseEnv.curVol &= 0xF;
			}
			noisedacenable = (noiseEnv.modeadd || noiseEnv.vol);
			if(!noisedacenable)
				noiseenable = false;
			noiseEnv.period=val&7;
			break;
		case 0x22:
			if((val>>4)<14)
				noiseFreq = noisePeriod[val&0x7]<<(val>>4);
			else
				noiseFreq = 0;
			noiseMode1 = ((val&0x8) != 0);
			break;
		case 0x23:
			noiseprevhaltloop = noisehaltloop;
			noisehaltloop = ((val&(1<<6)) == 0);
			//if length was previously frozen and we are in
			//an odd frame sequence, clock length right now
			if(noiseprevhaltloop && !noisehaltloop && noiseLengthCtr && (modePos&1))
			{
				noiseLengthCtr--;
				//disable channel immediately if length
				//reached 0 from this extra clock
				if(noiseLengthCtr == 0)
					noiseenable = false;
			}
			if(val&(1<<7))
			{
				if(noisedacenable)
					noiseenable = true;
				if(noiseLengthCtr == 0)
				{
					noiseLengthCtr = 64;
					//if length enabled and we are in an odd frame
					//sequence, subtract one from newly set clock length
					if(!noisehaltloop && (modePos&1))
						noiseLengthCtr--;
				}
				//trigger reloads frequency timers
				noiseFreqCtr = noiseFreq;
				//trigger resets env volume
				noiseEnv.curVol = noiseEnv.vol;
				//period 0 is actually period 8!
				noiseEnv.divider = (noiseEnv.period-1)&7;
				//trigger sets all shift reg bits
				noiseShiftReg = 0x7FFF;
			}
			break;
		default:
			break;
	}
}

//write-only bits are always set on reads by the cpu
static const uint8_t apuReadMask[0x20] =
{
	0x80, 0x3F, 0x00, 0xFF, 0xBF, 0xFF, 0x3F, 0x00, 0xFF, 0xBF, 0x7F, 0xFF, 0x9F, 0xFF, 0xBF, 0xFF, 
	0xFF, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
};

uint8_t apuGetReg8(uint16_t addr)
{
	uint8_t reg = addr&0xFF;
	//printf("APU get %02x\n", reg);
	switch(reg)
	{
		case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17:
		case 0x18: case 0x19: case 0x1A: case 0x1B: case 0x1C: case 0x1D: case 0x1E: case 0x1F:
		case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: /*case 0x26:*/ case 0x27:
		case 0x28: case 0x29: case 0x2A: case 0x2B: case 0x2C: case 0x2D: case 0x2E: case 0x2F:
			return APU_IO_Reg[reg]|apuReadMask[reg-0x10];
		case 0x26:
			return soundEnabled?((p1enable) | ((p2enable)<<1) | ((wavenable)<<2) | ((noiseenable)<<3)|0xF0):0x70;
		case 0x30: case 0x31: case 0x32: case 0x33: case 0x34: case 0x35: case 0x36: case 0x37:
		case 0x38: case 0x39: case 0x3A: case 0x3B: case 0x3C: case 0x3D: case 0x3E: case 0x3F:
			if(wavenable)
				return APU_IO_Reg[0x30+(wavCycle>>1)];
			return APU_IO_Reg[reg];
		default:
			break;
	}
	return 0xFF;
}

uint8_t *apuGetBuf()
{
	return (uint8_t*)apuOutBuf;
}

uint32_t apuGetBufSize()
{
	return apuBufSizeBytes;
}

uint32_t apuGetFrequency()
{
	return apuFrequency;
}