AxibugEmuOnline/OtherCore/MyNes.Standard2/MyNes.Core/MMC5Sqr.cs

using System.IO;

namespace MyNes.Core
{
    internal class MMC5Sqr
    {
    	private byte[][] duty_cycle_sequences = new byte[4][]
    	{
    		new byte[8] { 0, 0, 0, 0, 0, 0, 0, 1 },
    		new byte[8] { 0, 0, 0, 0, 0, 0, 1, 1 },
    		new byte[8] { 0, 0, 0, 0, 1, 1, 1, 1 },
    		new byte[8] { 1, 1, 1, 1, 1, 1, 0, 0 }
    	};

    	private byte[] duration_table = new byte[32]
    	{
    		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
    	};

    	private byte duty_cycle;

    	private bool length_halt;

    	private bool constant_volume_envelope;

    	private byte volume_devider_period;

    	private int timer;

    	private int period_devider;

    	private byte seqencer;

    	private bool length_enabled;

    	private int length_counter;

    	private bool envelope_start_flag;

    	private byte envelope_devider;

    	private byte envelope_decay_level_counter;

    	private byte envelope;

    	internal int output;

    	internal bool Outputable;

    	internal void HardReset()
    	{
    		duty_cycle = 0;
    		length_halt = false;
    		constant_volume_envelope = false;
    		volume_devider_period = 0;
    		timer = 0;
    		period_devider = 0;
    		seqencer = 0;
    		length_enabled = false;
    		length_counter = 0;
    		envelope_start_flag = false;
    		envelope_devider = 0;
    		envelope_decay_level_counter = 0;
    		envelope = 0;
    	}

    	internal void SoftReset()
    	{
    		HardReset();
    	}

    	internal void Clock()
    	{
    		period_devider--;
    		if (period_devider > 0)
    		{
    			return;
    		}
    		period_devider = timer + 1;
    		if (length_counter > 0)
    		{
    			if (Outputable)
    			{
    				output = duty_cycle_sequences[duty_cycle][seqencer] * envelope;
    			}
    		}
    		else
    		{
    			output = 0;
    		}
    		if (seqencer == 0)
    		{
    			seqencer = 7;
    		}
    		else
    		{
    			seqencer--;
    		}
    	}

    	internal void ClockLength()
    	{
    		if (length_counter > 0 && !length_halt)
    		{
    			length_counter--;
    		}
    	}

    	internal void ClockEnvelope()
    	{
    		if (envelope_start_flag)
    		{
    			envelope_start_flag = false;
    			envelope_decay_level_counter = 15;
    			envelope_devider = (byte)(volume_devider_period + 1);
    		}
    		else if (envelope_devider > 0)
    		{
    			envelope_devider--;
    		}
    		else
    		{
    			envelope_devider = (byte)(volume_devider_period + 1);
    			if (envelope_decay_level_counter > 0)
    			{
    				envelope_decay_level_counter--;
    			}
    			else if (length_halt)
    			{
    				envelope_decay_level_counter = 15;
    			}
    		}
    		envelope = (constant_volume_envelope ? volume_devider_period : envelope_decay_level_counter);
    	}

    	internal void Write0(ref byte value)
    	{
    		duty_cycle = (byte)((value & 0xC0) >> 6);
    		volume_devider_period = (byte)(value & 0xFu);
    		length_halt = (value & 0x20) != 0;
    		constant_volume_envelope = (value & 0x10) != 0;
    		envelope = (constant_volume_envelope ? volume_devider_period : envelope_decay_level_counter);
    	}

    	internal void Write2(ref byte value)
    	{
    		timer = (timer & 0xFF00) | value;
    	}

    	internal void Write3(ref byte value)
    	{
    		timer = (timer & 0xFF) | ((value & 7) << 8);
    		if (length_enabled)
    		{
    			length_counter = duration_table[value >> 3];
    		}
    		seqencer = 0;
    		envelope_start_flag = true;
    	}

    	internal void WriteEnabled(bool enabled)
    	{
    		length_enabled = enabled;
    		if (!length_enabled)
    		{
    			length_counter = 0;
    		}
    	}

    	internal bool ReadEnable()
    	{
    		return length_counter > 0;
    	}

    	internal void WriteStateData(ref BinaryWriter bin)
    	{
    		bin.Write(duty_cycle);
    		bin.Write(length_halt);
    		bin.Write(constant_volume_envelope);
    		bin.Write(volume_devider_period);
    		bin.Write(timer);
    		bin.Write(period_devider);
    		bin.Write(seqencer);
    		bin.Write(length_enabled);
    		bin.Write(length_counter);
    		bin.Write(envelope_start_flag);
    		bin.Write(envelope_devider);
    		bin.Write(envelope_decay_level_counter);
    		bin.Write(envelope);
    		bin.Write(output);
    	}

    	internal void ReadStateData(ref BinaryReader bin)
    	{
    		duty_cycle = bin.ReadByte();
    		length_halt = bin.ReadBoolean();
    		constant_volume_envelope = bin.ReadBoolean();
    		volume_devider_period = bin.ReadByte();
    		timer = bin.ReadInt32();
    		period_devider = bin.ReadInt32();
    		seqencer = bin.ReadByte();
    		length_enabled = bin.ReadBoolean();
    		length_counter = bin.ReadInt32();
    		envelope_start_flag = bin.ReadBoolean();
    		envelope_devider = bin.ReadByte();
    		envelope_decay_level_counter = bin.ReadByte();
    		envelope = bin.ReadByte();
    		output = bin.ReadInt32();
    	}
    }
}