using System; using System.IO; using System.Collections.Generic; using BizHawk.Emulation.Sound; //http://wiki.nesdev.com/w/index.php/APU_Mixer_Emulation //http://wiki.nesdev.com/w/index.php/APU //http://wiki.nesdev.com/w/index.php/APU_Pulse //sequencer ref: http://wiki.nesdev.com/w/index.php/APU_Frame_Counter namespace BizHawk.Emulation.Consoles.Nintendo { partial class NES { public class APU : ISoundProvider { public static bool CFG_USE_METASPU = true; public static bool CFG_DECLICK = true; NES nes; public APU(NES nes) { this.nes = nes; } static int[] LENGTH_TABLE = { 10, 254, 20, 2, 40, 4, 80, 6, 160, 8, 60, 10, 14, 12, 26, 14, 12, 16, 24, 18, 48, 20, 96, 22, 192, 24, 72, 26, 16, 28, 32, 30 }; static byte[,] PULSE_DUTY = { {0,1,0,0,0,0,0,0}, //(12.5%) {0,1,1,0,0,0,0,0}, //(25%) {0,1,1,1,1,0,0,0}, //(50%) {1,0,0,1,1,1,1,1}, //(25% negated (75%)) }; static byte[] TRIANGLE_TABLE = { 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; static int[] NOISE_TABLE = { 4, 8, 16, 32, 64, 96, 128, 160, 202, 254, 380, 508, 762, 1016, 2034, 4068 //NTSC //4, 7, 14, 30, 60, 88, 118, 148, 188, 236, 354, 472, 708, 944, 1890, 3778 //PAL }; class PulseUnit { public PulseUnit(int unit) { this.unit = unit; } public int unit; //reg0 int duty_cnt, env_loop, env_constant, env_cnt_value; //reg1 int sweep_en, sweep_divider_cnt, sweep_negate, sweep_shiftcount; bool sweep_reload; //reg2/3 int len_cnt; int timer_raw_reload_value, timer_reload_value; //misc.. int lenctr_en; public bool IsLenCntNonZero() { return len_cnt > 0; } public void WriteReg(int addr, byte val) { //Console.WriteLine("write pulse {0:X} {1:X}", addr, val); switch(addr) { case 0: env_cnt_value = val & 0xF; env_constant = (val >> 4) & 1; env_loop = (val >> 5) & 1; duty_cnt = (val >> 6) & 3; break; case 1: sweep_shiftcount = val & 7; sweep_negate = (val >> 3) & 1; sweep_divider_cnt = (val >> 4) & 7; sweep_en = (val >> 7) & 1; sweep_reload = true; break; case 2: timer_reload_value = (timer_reload_value & ~0xFF) | val; timer_raw_reload_value = timer_reload_value * 2 + 2; //if (unit == 1) Console.WriteLine("{0} timer_reload_value: {1}", unit, timer_reload_value); break; case 3: len_cnt = LENGTH_TABLE[(val >> 3) & 0x1F]; timer_reload_value = (timer_reload_value & 0xFF) | ((val & 0x07) << 8); timer_raw_reload_value = timer_reload_value * 2 + 2; //duty_step = 0; //?just a guess? timer_counter = timer_raw_reload_value; env_start_flag = 1; //allow the lenctr_en to kill the len_cnt set_lenctr_en(lenctr_en); //serves as a useful note-on diagnostic //if(unit==1) Console.WriteLine("{0} timer_reload_value: {1}", unit, timer_reload_value); break; } } public void set_lenctr_en(int value) { lenctr_en = value; //if the length counter is not enabled, then we must disable the length system in this way if (lenctr_en == 0) len_cnt = 0; } //state int swp_divider_counter; bool swp_silence; int duty_step; int timer_counter; public int sample; bool duty_value; int env_start_flag, env_divider, env_counter, env_output; public void clock_length_and_sweep() { //this should be optimized to update only when `timer_reload_value` changes int sweep_shifter = timer_reload_value >> sweep_shiftcount; if (sweep_negate == 1) sweep_shifter = ~sweep_shifter + unit; sweep_shifter += timer_reload_value; //this sweep logic is always enabled: swp_silence = (timer_reload_value < 8 || (sweep_shifter > 0x7FF && sweep_negate == 0)); //does enable only block the pitch bend? does the clocking proceed? if (sweep_en == 1) { //clock divider if (swp_divider_counter != 0) swp_divider_counter--; if (swp_divider_counter == 0) { swp_divider_counter = sweep_divider_cnt + 1; //divider was clocked: process sweep pitch bend if (sweep_shiftcount != 0 && !swp_silence) { timer_reload_value = sweep_shifter; timer_raw_reload_value = timer_reload_value * 2 + 2; } //TODO - does this change the user's reload value or the latched reload value? } //handle divider reload, after clocking happens if (sweep_reload) { swp_divider_counter = sweep_divider_cnt + 1; sweep_reload = false; } } //env_loopdoubles as "halt length counter" if (env_loop == 0 && len_cnt > 0) len_cnt--; } public void clock_env() { if (env_start_flag == 1) { env_start_flag = 0; env_divider = (env_cnt_value + 1); env_counter = 15; } else { if(env_divider != 0) env_divider--; if (env_divider == 0) { env_divider = (env_cnt_value + 1); if (env_counter == 0) { if (env_loop == 1) { env_counter = 15; } } else env_counter--; } } if (env_constant == 1) env_output = env_cnt_value; else env_output = env_counter; } public void Run() { if (timer_counter > 0) timer_counter--; if (timer_counter == 0 && timer_raw_reload_value!=0) { duty_step = (duty_step + 1) & 7; duty_value = PULSE_DUTY[duty_cnt, duty_step] == 1; //reload timer timer_counter = timer_raw_reload_value; } if (duty_value) //we are outputting something { sample = env_output; if (swp_silence) sample = 0; if (len_cnt==0) //length counter is 0 sample = 0; //silenced } else sample = 0; //duty cycle is 0, silenced. } } class NoiseUnit { //reg0 (sweep) int env_cnt_value, env_loop, env_constant; //reg2 (mode and period) int mode_cnt, period_cnt; //reg3 (length counter and envelop trigger) int len_cnt; //set from apu: int lenctr_en; //state int shift_register = 1; int timer_counter; public int sample; int env_output, env_start_flag, env_divider, env_counter; bool noise_bit = true; public bool IsLenCntNonZero() { return len_cnt > 0; } public void WriteReg(int addr, byte val) { switch (addr) { case 0: env_cnt_value = val & 0xF; env_constant = (val >> 4) & 1; env_loop = (val>>5)&1; break; case 1: break; case 2: period_cnt = NOISE_TABLE[val & 0xF]; mode_cnt = (val>>7)&1; //Console.WriteLine("noise period: {0}, vol: {1}", (val & 0xF), env_cnt_value); break; case 3: len_cnt = LENGTH_TABLE[(val >> 3) & 0x1F]; set_lenctr_en(lenctr_en); env_start_flag = 1; break; } } public void set_lenctr_en(int value) { lenctr_en = value; //Console.WriteLine("noise lenctr_en: " + lenctr_en); //if the length counter is not enabled, then we must disable the length system in this way if (lenctr_en == 0) len_cnt = 0; } public void clock_env() {} public void clock_length_and_sweep() { if (env_start_flag == 1) { env_start_flag = 0; env_divider = (env_cnt_value + 1); env_counter = 15; } else { if (env_divider != 0) env_divider--; if (env_divider == 0) { env_divider = (env_cnt_value + 1); if (env_counter == 0) { if (env_loop == 1) { env_counter = 15; } } else env_counter--; } if (env_constant == 1) env_output = env_cnt_value; else env_output = env_counter; } if (len_cnt > 0 && env_loop == 0) len_cnt--; } public void Run() { if (timer_counter > 0) timer_counter--; if (timer_counter == 0 && period_cnt != 0) { //reload timer timer_counter = period_cnt; int feedback_bit; if (mode_cnt == 1) feedback_bit = (shift_register >> 6) & 1; else feedback_bit = (shift_register >> 1) & 1; int feedback = feedback_bit ^ (shift_register & 1); shift_register >>= 1; shift_register &= ~(1 << 14); shift_register |= (feedback << 14); noise_bit = (shift_register & 1)!=0; } if (noise_bit || len_cnt==0) sample = 0; else sample = env_output; } } class TriangleUnit { //reg0 int linear_counter_reload, control_flag; //reg1 (n/a) //reg2/3 int timer_cnt, length_counter_load, halt_flag; public void WriteReg(int addr, byte val) { switch (addr) { case 0: linear_counter_reload = (val & 0x7F); control_flag = (val >> 7) & 1; break; case 1: break; case 2: timer_cnt = (timer_cnt & ~0xFF) | val; timer_cnt_reload = timer_cnt + 1; break; case 3: timer_cnt = (timer_cnt & 0xFF) | ((val & 0x7) << 8); timer_cnt_reload = timer_cnt + 1; length_counter_load = (val>>3)&0x1F; halt_flag = 1; break; } //Console.WriteLine("tri timer_reload_value: {0}", timer_cnt_reload); } int linear_counter, timer, timer_cnt_reload; int seq; public int sample; public void Run() { //when clocked by timer //seq steps forward //except when linear counter or //length counter is 0 bool en = length_counter_load != 0 && linear_counter != 0; //length counter and linear counter //is clocked in frame counter. if (en) { if(timer>0) timer--; if (timer == 0) { seq = (seq + 1) & 0x1F; timer = timer_cnt_reload; } //if(CFG_DECLICK) // sample = TRIANGLE_TABLE[(seq+8)&0x1F]; //else sample = TRIANGLE_TABLE[seq]; } } public void clock_length_and_sweep() { } public void clock_linear_counter() { // Console.WriteLine("linear_counter: {0}", linear_counter); if (halt_flag == 1) { linear_counter = linear_counter_reload; } else if (linear_counter != 0) { linear_counter--; } if (control_flag == 0) { halt_flag = 0; } } } PulseUnit[] pulse = { new PulseUnit(0), new PulseUnit(1) }; TriangleUnit triangle = new TriangleUnit(); NoiseUnit noise = new NoiseUnit(); int sequencer_counter, sequencer_step, sequencer_mode, sequencer_irq_inhibit; void sequencer_reset() { sequencer_counter = 0; sequencer_step = 1; if(sequencer_mode == 1) sequencer_check(); } //21477272 master clock //1789772 cpu clock (master / 12) //240 apu clock (master / 89490) = (cpu / 7457) void sequencer_tick() { sequencer_counter++; //this figure is not valid for PAL. it must be recalculated if (sequencer_counter != 7457) return; sequencer_counter = 0; sequencer_step++; sequencer_check(); } void sequencer_check() { switch (sequencer_mode) { case 0: //4-step pulse[0].clock_env(); pulse[1].clock_env(); triangle.clock_linear_counter(); noise.clock_env(); if (sequencer_step == 2 || sequencer_step == 4) { pulse[0].clock_length_and_sweep(); pulse[1].clock_length_and_sweep(); triangle.clock_length_and_sweep(); noise.clock_length_and_sweep(); } if (sequencer_step == 4) { if (sequencer_irq_inhibit == 0) { nes.irq_apu = true; } sequencer_step = 0; } break; case 1: //5-step if (sequencer_step != 5) { pulse[0].clock_env(); pulse[1].clock_env(); triangle.clock_linear_counter(); noise.clock_env(); } if (sequencer_step == 1 || sequencer_step == 3) { pulse[0].clock_length_and_sweep(); pulse[1].clock_length_and_sweep(); triangle.clock_length_and_sweep(); noise.clock_length_and_sweep(); } if (sequencer_step == 5) sequencer_step = 0; break; } } public void WriteReg(int addr, byte val) { switch (addr) { case 0x4000: case 0x4001: case 0x4002: case 0x4003: pulse[0].WriteReg(addr - 0x4000, val); break; case 0x4004: case 0x4005: case 0x4006: case 0x4007: pulse[1].WriteReg(addr - 0x4004, val); break; case 0x4008: case 0x4009: case 0x400A: case 0x400B: triangle.WriteReg(addr - 0x4008, val); break; case 0x400C: case 0x400D: case 0x400E: case 0x400F: noise.WriteReg(addr - 0x400C, val); break; case 0x4015: pulse[0].set_lenctr_en(val & 1); pulse[1].set_lenctr_en((val >> 1) & 1); //todo - triangle length counter? noise.set_lenctr_en((val >> 3) & 1); break; case 0x4017: sequencer_mode = (val>>7)&1; sequencer_irq_inhibit = (val >> 6) & 1; if (sequencer_irq_inhibit == 1) nes.irq_apu = false; sequencer_reset(); break; } } public byte ReadReg(int addr) { switch (addr) { case 0x4015: { //notice a missing bit here. should properly emulate with empty bus //if an interrupt flag was set at the same moment of the read, it will read back as 1 but it will not be cleared. int dmc_irq_flag = 0; //todo int dmc_nonzero = 0; //todo int noise_nonzero = noise.IsLenCntNonZero() ? 1 : 0; int tri_nonzero = 0; //todo int pulse1_nonzero = pulse[1].IsLenCntNonZero() ? 1 : 0; int pulse0_nonzero = pulse[0].IsLenCntNonZero() ? 1 : 0; int ret = (dmc_irq_flag << 7) | ((nes.irq_apu?1:0) << 6) | (dmc_nonzero << 4) | (noise_nonzero << 3) | (tri_nonzero<<2) | (pulse1_nonzero<<1) | (pulse0_nonzero); nes.irq_apu = false; return (byte)ret; } default: return 0x00; } } public void Run(int cycles) { for (int i = 0; i < cycles; i++) RunOne(); } public void DiscardSamples() { metaspu.buffer.clear(); } public void RunOne() { pulse[0].Run(); pulse[1].Run(); triangle.Run(); noise.Run(); int mix = 0; mix += pulse[0].sample; mix += pulse[1].sample; mix += triangle.sample; mix += noise.sample; EmitSample(mix); sequencer_tick(); //since the units run concurrently, the APU frame sequencer is ran last because //it can change the ouput values of the pulse/triangle channels //we want the changes to affect it on the *next* cycle. } double accumulate; double timer; Queue squeue = new Queue(); int last_hwsamp; int panic_sample, panic_count; void EmitSample(int samp) { //kill the annoying hum that is a consequence of the shitty code below if (samp == panic_sample) panic_count++; else panic_count = 0; if (panic_count > 178977) samp = 0; else panic_sample = samp; int this_samp = samp; const double kMixRate = 44100.0/1789772.0; const double kInvMixRate = (1 / kMixRate); timer += kMixRate; accumulate += samp; if (timer <= 1) return; accumulate -= samp; timer -= 1; double ratio = (timer / kMixRate); double fractional = (this_samp - last_hwsamp) * ratio; double factional_remainder = (this_samp - last_hwsamp) * (1-ratio); accumulate += fractional; accumulate *= 540; //32768/(15*4) -- adjust later for other sound channels int outsamp = (int)(accumulate / kInvMixRate); if (CFG_USE_METASPU) metaspu.buffer.enqueue_sample((short)outsamp, (short)outsamp); else squeue.Enqueue(outsamp); accumulate = factional_remainder; last_hwsamp = this_samp; } MetaspuSoundProvider metaspu = new MetaspuSoundProvider(ESynchMethod.ESynchMethod_Z); void ISoundProvider.GetSamples(short[] samples) { if (CFG_USE_METASPU) { metaspu.GetSamples(samples); //foreach(short sample in samples) bw.Write((short)sample); } else MyGetSamples(samples); } //static BinaryWriter bw = new BinaryWriter(File.OpenWrite("d:\\out.raw")); void MyGetSamples(short[] samples) { //Console.WriteLine("a: {0} with todo: {1}",squeue.Count,samples.Length/2); for (int i = 0; i < samples.Length/2; i++) { int samp = 0; if (squeue.Count != 0) samp = squeue.Dequeue(); samples[i*2+0] = (short)(samp); samples[i*2+1] = (short)(samp); //bw.Write((short)samp); } } } //class APU } }