// Gb_Snd_Emu 0.2.0. http://www.slack.net/~ant/

#include "Gb_Apu.h"

/* Copyright (C) 2003-2007 Shay Green. This module is free software; you
can redistribute it and/or modify it under the terms of the GNU Lesser
General Public License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version. This
module is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details. You should have received a copy of the GNU Lesser General Public
License along with this module; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

static const bool cgb_02 = false; // enables bug in early CGB units that causes problems in some games
static const bool cgb_05 = false; // enables CGB-05 zombie behavior

static const int trigger_mask = 0x80;
static const int length_enabled = 0x40;

void Gb_Osc::reset()
{
	this->output = nullptr;
	this->last_amp = this->delay = 0;
	this->phase = 0;
	this->enabled = false;
}

void Gb_Osc::update_amp(blip_time_t time, int new_amp)
{
	this->output->set_modified();
	int delta = new_amp - this->last_amp;
	if (delta)
	{
		this->last_amp = new_amp;
		this->med_synth->offset(time, delta, this->output);
	}
}

// Units

void Gb_Osc::clock_length()
{
	if ((this->regs[4] & length_enabled) && this->length_ctr)
	{
		if (--this->length_ctr <= 0)
			this->enabled = false;
	}
}

int Gb_Env::reload_env_timer()
{
	int raw = this->regs[2] & 7;
	this->env_delay = raw ? raw : 8;
	return raw;
}

void Gb_Env::clock_envelope()
{
	if (this->env_enabled && --this->env_delay <= 0 && this->reload_env_timer())
	{
		int v = this->volume + (this->regs[2] & 0x08 ? 1 : -1);
		if (0 <= v && v <= 15)
			this->volume = v;
		else
			this->env_enabled = false;
	}
}

void Gb_Sweep_Square::reload_sweep_timer()
{
	this->sweep_delay = (this->regs[0] & period_mask) >> 4;
	if (!this->sweep_delay)
		this->sweep_delay = 8;
}

void Gb_Sweep_Square::calc_sweep(bool update)
{
	int shift = this->regs[0] & shift_mask;
	int delta = this->sweep_freq >> shift;
	this->sweep_neg = !!(this->regs[0] & 0x08);
	int freq = this->sweep_freq + (this->sweep_neg ? -delta : delta);

	if (freq > 0x7FF)
		this->enabled = false;
	else if (shift && update)
	{
		this->sweep_freq = freq;

		this->regs[3] = freq & 0xFF;
		this->regs[4] = (this->regs[4] & ~0x07) | (freq >> 8 & 0x07);
	}
}

void Gb_Sweep_Square::clock_sweep()
{
	if (--this->sweep_delay <= 0)
	{
		this->reload_sweep_timer();
		if (this->sweep_enabled && (this->regs[0] & period_mask))
		{
			this->calc_sweep(true);
			this->calc_sweep(false);
		}
	}
}

int Gb_Wave::access(unsigned addr) const
{
	if (this->enabled && this->mode != Gb_Apu::mode_agb)
	{
		addr = this->phase & (bank_size - 1);
		if (this->mode == Gb_Apu::mode_dmg)
		{
			++addr;
			if (this->delay > clk_mul)
				return -1; // can only access within narrow time window while playing
		}
		addr >>= 1;
	}
	return addr & 0x0F;
}

// write_register

int Gb_Osc::write_trig(int frame_phase, int max_len, int old_data)
{
	int data = this->regs[4];

	if ((frame_phase & 1) && !(old_data & length_enabled) && this->length_ctr)
	{
		if ((data & length_enabled) || cgb_02)
			--this->length_ctr;
	}

	if (data & trigger_mask)
	{
		this->enabled = true;
		if (!this->length_ctr)
		{
			this->length_ctr = max_len;
			if ((frame_phase & 1) && (data & length_enabled))
				--this->length_ctr;
		}
	}

	if (!this->length_ctr)
		this->enabled = false;

	return data & trigger_mask;
}

void Gb_Env::zombie_volume(int old, int data)
{
	int v = this->volume;
	if (this->mode == Gb_Apu::mode_agb || cgb_05)
	{
		// CGB-05 behavior, very close to AGB behavior as well
		if ((old ^ data) & 8)
		{
			if (!(old & 8))
			{
				++v;
				if (old & 7)
					++v;
			}

			v = 16 - v;
		}
		else if ((old & 0x0F) == 8)
			++v;
	}
	else
	{
		// CGB-04&02 behavior, very close to MGB behavior as well
		if (!(old & 7) && this->env_enabled)
			++v;
		else if (!(old & 8))
			v += 2;

		if ((old ^ data) & 8)
			v = 16 - v;
	}
	this->volume = v & 0x0F;
}

bool Gb_Env::write_register(int frame_phase, int reg, int old, int data)
{
	static const int max_len = 64;

	switch (reg)
	{
		case 1:
			this->length_ctr = max_len - (data & (max_len - 1));
			break;

		case 2:
			if (!this->dac_enabled())
				this->enabled = false;

			this->zombie_volume(old, data);

			if ((data & 7) && this->env_delay == 8)
			{
				this->env_delay = 1;
				this->clock_envelope(); // TODO: really happens at next length clock
			}
			break;

		case 4:
			if (this->write_trig(frame_phase, max_len, old))
			{
				this->volume = this->regs[2] >> 4;
				this->reload_env_timer();
				this->env_enabled = true;
				if (frame_phase == 7)
					++this->env_delay;
				if (!this->dac_enabled())
					this->enabled = false;
				return true;
			}
	}
	return false;
}

bool Gb_Square::write_register(int frame_phase, int reg, int old_data, int data)
{
	bool result = Gb_Env::write_register(frame_phase, reg, old_data, data);
	if (result)
		this->delay = (this->delay & (4 * clk_mul - 1)) + this->period();
	return result;
}

void Gb_Noise::write_register(int frame_phase, int reg, int old_data, int data)
{
	if (Gb_Env::write_register(frame_phase, reg, old_data, data))
	{
		this->phase = 0x7FFF;
		this->delay += 8 * clk_mul;
	}
}

void Gb_Sweep_Square::write_register(int frame_phase, int reg, int old_data, int data)
{
	if (!reg && this->sweep_enabled && this->sweep_neg && !(data & 0x08))
		this->enabled = false; // sweep negate disabled after used

	if (Gb_Square::write_register(frame_phase, reg, old_data, data))
	{
		this->sweep_freq = this->frequency();
		this->sweep_neg = false;
		this->reload_sweep_timer();
		this->sweep_enabled = !!(this->regs[0] & (period_mask | shift_mask));
		if (this->regs[0] & shift_mask)
			this->calc_sweep(false);
	}
}

void Gb_Wave::corrupt_wave()
{
	int pos = ((this->phase + 1) & (bank_size - 1)) >> 1;
	if (pos < 4)
		this->wave_ram[0] = this->wave_ram[pos];
	else
		for (int i = 4; --i >= 0; )
			this->wave_ram[i] = this->wave_ram[(pos & ~3) + i];
}

void Gb_Wave::write_register(int frame_phase, int reg, int old_data, int data)
{
	static const int max_len = 256;

	switch (reg)
	{
		case 0:
			if (!this->dac_enabled())
				this->enabled = false;
			break;

		case 1:
			this->length_ctr = max_len - data;
			break;

		case 4:
			bool was_enabled = this->enabled;
			if (this->write_trig(frame_phase, max_len, old_data))
			{
				if (!this->dac_enabled())
					this->enabled = false;
				else if (this->mode == Gb_Apu::mode_dmg && was_enabled && static_cast<unsigned>(this->delay - 2 * clk_mul) < 2 * clk_mul)
					this->corrupt_wave();

				this->phase = 0;
				this->delay = this->period() + 6 * clk_mul;
			}
	}
}

void Gb_Apu::write_osc(int index, int reg, int old_data, int data)
{
	reg -= index * 5;
	switch (index)
	{
		case 0:
			this->square1.write_register(this->frame_phase, reg, old_data, data);
			break;
		case 1:
			this->square2.write_register(this->frame_phase, reg, old_data, data);
			break;
		case 2:
			this->wave.write_register(this->frame_phase, reg, old_data, data);
			break;
		case 3:
			this->noise.write_register(this->frame_phase, reg, old_data, data);
	}
}

// Synthesis

void Gb_Square::run(blip_time_t time, blip_time_t end_time)
{
	// Calc duty and phase
	static const uint8_t duty_offsets[] = { 1, 1, 3, 7 };
	static const uint8_t duties[] = { 1, 2, 4, 6 };
	int duty_code = this->regs[1] >> 6;
	int duty_offset = duty_offsets[duty_code];
	int duty = duties[duty_code];
	if (this->mode == Gb_Apu::mode_agb)
	{
		// AGB uses inverted duty
		duty_offset -= duty;
		duty = 8 - duty;
	}
	int ph = (this->phase + duty_offset) & 7;

	// Determine what will be generated
	int vol = 0;
	auto out = this->output;
	if (out)
	{
		int amp = this->dac_off_amp;
		if (this->dac_enabled())
		{
			if (this->enabled)
				vol = this->volume;

			amp = -dac_bias;
			if (this->mode == Gb_Apu::mode_agb)
				amp = -(vol >> 1);

			// Play inaudible frequencies as constant amplitude
			if (this->frequency() >= 0x7FA && this->delay < 32 * clk_mul)
			{
				amp += (vol * duty) >> 3;
				vol = 0;
			}

			if (ph < duty)
			{
				amp += vol;
				vol = -vol;
			}
		}
		this->update_amp(time, amp);
	}

	// Generate wave
	time += this->delay;
	if (time < end_time)
	{
		int per = this->period();
		if (!vol)
		{
			// Maintain phase when not playing
			int count = (end_time - time + per - 1) / per;
			ph += count; // will be masked below
			time += static_cast<blip_time_t>(count) * per;
		}
		else
		{
			// Output amplitude transitions
			int delta = vol;
			do
			{
				ph = (ph + 1) & 7;
				if (!ph || ph == duty)
				{
					this->good_synth->offset_inline(time, delta, out);
					delta = -delta;
				}
				time += per;
			} while (time < end_time);

			if (delta != vol)
				this->last_amp -= delta;
		}
		this->phase = (ph - duty_offset) & 7;
	}
	this->delay = time - end_time;
}

// Quickly runs LFSR for a large number of clocks. For use when noise is generating
// no sound.
static unsigned run_lfsr(unsigned s, unsigned mask, int count)
{
	static const bool optimized = true; // set to false to use only unoptimized loop in middle

	// optimization used in several places:
	// ((s & (1 << b)) << n) ^ ((s & (1 << b)) << (n + 1)) = (s & (1 << b)) * (3 << n)

	if (mask == 0x4000 && optimized)
	{
		if (count >= 32767)
			count %= 32767;

		// Convert from Fibonacci to Galois configuration,
		// shifted left 1 bit
		s ^= (s & 1) * 0x8000;

		// Each iteration is equivalent to clocking LFSR 255 times
		while ((count -= 255) > 0)
			s ^= ((s & 0xE) << 12) ^ ((s & 0xE) << 11) ^ (s >> 3);
		count += 255;

		// Each iteration is equivalent to clocking LFSR 15 times
		// (interesting similarity to single clocking below)
		while ((count -= 15) > 0)
			s ^= ((s & 2) * (3 << 13)) ^ (s >> 1);
		count += 15;

		// Remaining singles
		while (--count >= 0)
			s = ((s & 2) * (3 << 13)) ^ (s >> 1);

		// Convert back to Fibonacci configuration
		s &= 0x7FFF;
	}
	else if (count < 8 || !optimized)
	{
		// won't fully replace upper 8 bits, so have to do the unoptimized way
		while (--count >= 0)
			s = (s >> 1 | mask) ^ (mask & (0 - ((s - 1) & 2)));
	}
	else
	{
		if (count > 127)
		{
			count %= 127;
			if (!count)
				count = 127; // must run at least once
		}

		// Need to keep one extra bit of history
		s = s << 1 & 0xFF;

		// Convert from Fibonacci to Galois configuration,
		// shifted left 2 bits
		s ^= (s & 2) * 0x80;

		// Each iteration is equivalent to clocking LFSR 7 times
		// (interesting similarity to single clocking below)
		while ((count -= 7) > 0)
			s ^= ((s & 4) * (3 << 5)) ^ (s >> 1);
		count += 7;

		// Remaining singles
		while (--count >= 0)
			s = ((s & 4) * (3 << 5)) ^ (s >> 1);

		// Convert back to Fibonacci configuration and
		// repeat last 8 bits above significant 7
		s = (s << 7 & 0x7F80) | (s >> 1 & 0x7F);
	}

	return s;
}

void Gb_Noise::run(blip_time_t time, blip_time_t end_time)
{
	// Determine what will be generated
	int vol = 0;
	auto out = this->output;
	if (out)
	{
		int amp = this->dac_off_amp;
		if (this->dac_enabled())
		{
			if (this->enabled)
				vol = this->volume;

			amp = -dac_bias;
			if (this->mode == Gb_Apu::mode_agb)
				amp = -(vol >> 1);

			if (!(this->phase & 1))
			{
				amp += vol;
				vol = -vol;
			}
		}

		// AGB negates final output
		if (this->mode == Gb_Apu::mode_agb)
		{
			vol = -vol;
			amp = -amp;
		}

		this->update_amp(time, amp);
	}

	// Run timer and calculate time of next LFSR clock
	static const uint8_t period1s[] = { 1, 2, 4, 6, 8, 10, 12, 14 };
	int period1 = period1s[this->regs[3] & 7] * clk_mul;
	int extra = (end_time - time) - this->delay;
	int per2 = this->period2();
	time += this->delay + ((this->divider ^ (per2 >> 1)) & (per2 - 1)) * period1;

	int count = extra < 0 ? 0 : (extra + period1 - 1) / period1;
	this->divider = (this->divider - count) & period2_mask;
	this->delay = count * period1 - extra;

	// Generate wave
	if (time < end_time)
	{
		unsigned mask = this->lfsr_mask();
		unsigned bits = this->phase;

		int per = this->period2(period1 * 8);
		if (this->period2_index() >= 0xE)
			time = end_time;
		else if (!vol)
		{
			// Maintain phase when not playing
			int count = (end_time - time + per - 1) / per;
			time += static_cast<blip_time_t>(count) * per;
			bits = run_lfsr(bits, ~mask, count);
		}
		else
		{
			// Output amplitude transitions
			int delta = -vol;
			do
			{
				unsigned changed = bits + 1;
				bits = bits >> 1 & mask;
				if (changed & 2)
				{
					bits |= ~mask;
					delta = -delta;
					this->med_synth->offset_inline(time, delta, out);
				}
				time += per;
			} while (time < end_time);

			if (delta == vol)
				this->last_amp += delta;
		}
		this->phase = bits;
	}
}

void Gb_Wave::run(blip_time_t time, blip_time_t end_time)
{
	// Calc volume
	static const uint8_t volumes[] = { 0, 4, 2, 1, 3, 3, 3, 3 };
	static const int volume_shift = 2;
	int volume_idx = this->regs[2] >> 5 & (this->agb_mask | 3); // 2 bits on DMG/CGB, 3 on AGB
	int volume_mul = volumes[volume_idx];

	// Determine what will be generated
	int playing = 0;
	auto out = this->output;
	if (out)
	{
		int amp = this->dac_off_amp;
		if (this->dac_enabled())
		{
			// Play inaudible frequencies as constant amplitude
			amp = 8 << 4; // really depends on average of all samples in wave

			// if delay is larger, constant amplitude won't start yet
			if (this->frequency() <= 0x7FB || this->delay > 15 * clk_mul)
			{
				if (volume_mul)
					playing = static_cast<int>(this->enabled);

				amp = (this->sample_buf << (this->phase << 2 & 4) & 0xF0) * playing;
			}

			amp = ((amp * volume_mul) >> (volume_shift + 4)) - dac_bias;
		}
		this->update_amp(time, amp);
	}

	// Generate wave
	time += this->delay;
	if (time < end_time)
	{
		auto wave = this->wave_ram;

		// wave size and bank
		static const int size20_mask = 0x20;
		int flags = this->regs[0] & this->agb_mask;
		int wave_mask = (flags & size20_mask) | 0x1F;
		int swap_banks = 0;
		if (flags & bank40_mask)
		{
			swap_banks = flags & size20_mask;
			wave += bank_size / 2 - (swap_banks >> 1);
		}

		int ph = this->phase ^ swap_banks;
		ph = (ph + 1) & wave_mask; // pre-advance

		int per = this->period();
		if (!playing)
		{
			// Maintain phase when not playing
			int count = (end_time - time + per - 1) / per;
			ph += count; // will be masked below
			time += static_cast<blip_time_t>(count) * per;
		}
		else
		{
			// Output amplitude transitions
			int lamp = this->last_amp + dac_bias;
			do
			{
				// Extract nybble
				int nybble = wave[ph >> 1] << (ph << 2 & 4) & 0xF0;
				ph = (ph + 1) & wave_mask;

				// Scale by volume
				int amp = (nybble * volume_mul) >> (volume_shift + 4);

				int delta = amp - lamp;
				if (delta)
				{
					lamp = amp;
					this->med_synth->offset_inline(time, delta, out);
				}
				time += per;
			} while (time < end_time);
			this->last_amp = lamp - dac_bias;
		}
		ph = (ph - 1) & wave_mask; // undo pre-advance and mask position

		// Keep track of last byte read
		if (this->enabled)
			this->sample_buf = wave[ph >> 1];

		this->phase = ph ^ swap_banks; // undo swapped banks
	}
	this->delay = time - end_time;
}