CLK/Storage/Tape/Formats/TapePRG.cpp

//
//  TapePRG.cpp
//  Clock Signal
//
//  Created by Thomas Harte on 14/08/2016.
//  Copyright © 2016 Thomas Harte. All rights reserved.
//

#include "TapePRG.hpp"

/*
	My interpretation of Commodore's tape format is such that a PRG is encoded as:

	[long block of lead-in tone]
	[short block of lead-in tone]
	[count down][header; 192 bytes fixed length]
	[short block of lead-in tone]
	[count down][copy of header; 192 bytes fixed length]
	[gap]
	[short block of lead-in tone]
	[count down][data; length as in file]
	[short block of lead-in tone]
	[count down][copy of data]
	... and repeat ...

	Individual bytes are composed of:

		word marker
		least significant bit
		...
		most significant bit
		parity bit

	Both the header and data blocks additionally end with an end-of-block marker.

	Encoding is via square-wave cycles of four lengths, in ascending order: lead-in, zero, one, marker.

	Lead-in tone is always just repetitions of the lead-in wave.
	A word marker is a marker wave followed by a one wave.
	An end-of-block marker is a marker wave followed by a zero wave.
	A zero bit is a zero wave followed by a one wave.
	A one bit is a one wave followed by a zero wave.

	Parity is 1 if there are an even number of bits in the byte; 0 otherwise.
*/

#include <sys/stat.h>

using namespace Storage::Tape;

PRG::PRG(const char *file_name) :
	bit_phase_(3),
	file_phase_(FilePhaseLeadIn),
	phase_offset_(0),
	copy_mask_(0x80),
	Storage::FileHolder(file_name)
{
	// There's really no way to validate other than that if this file is larger than 64kb,
	// of if load address + length > 65536 then it's broken.
	if(file_stats_.st_size >= 65538 || file_stats_.st_size < 3)
		throw ErrorBadFormat;

	load_address_ = fgetc16le();
	length_ = (uint16_t)(file_stats_.st_size - 2);

	if (load_address_ + length_ >= 65536)
		throw ErrorBadFormat;
}

Storage::Tape::Tape::Pulse PRG::virtual_get_next_pulse()
{
	// these are all microseconds per pole
	static const unsigned int leader_zero_length = 179;
	static const unsigned int zero_length = 169;
	static const unsigned int one_length = 247;
	static const unsigned int marker_length = 328;

	bit_phase_ = (bit_phase_+1)&3;
	if(!bit_phase_) get_next_output_token();

	Tape::Pulse pulse;
	pulse.length.clock_rate = 1000000;
	pulse.type = (bit_phase_&1) ? Tape::Pulse::High : Tape::Pulse::Low;
	switch(output_token_)
	{
		case Leader:		pulse.length.length = leader_zero_length;							break;
		case Zero:			pulse.length.length = (bit_phase_&2) ? one_length : zero_length;		break;
		case One:			pulse.length.length = (bit_phase_&2) ? zero_length : one_length;		break;
		case WordMarker:	pulse.length.length = (bit_phase_&2) ? one_length : marker_length;	break;
		case EndOfBlock:	pulse.length.length = (bit_phase_&2) ? zero_length : marker_length;	break;
		case Silence:		pulse.type = Tape::Pulse::Zero; pulse.length.length = 5000;			break;
	}
	return pulse;
}

void PRG::virtual_reset()
{
	bit_phase_ = 3;
	fseek(file_, 2, SEEK_SET);
	file_phase_ = FilePhaseLeadIn;
	phase_offset_ = 0;
	copy_mask_ = 0x80;
}

bool PRG::is_at_end()
{
	return file_phase_ == FilePhaseAtEnd;
}

void PRG::get_next_output_token()
{
	static const int block_length = 192;	// not counting the checksum
	static const int countdown_bytes = 9;
	static const int leadin_length = 20000;
	static const int block_leadin_length = 5000;

	if(file_phase_ == FilePhaseHeaderDataGap || file_phase_ == FilePhaseAtEnd)
	{
		output_token_ = Silence;
		if(file_phase_ != FilePhaseAtEnd) file_phase_ = FilePhaseData;
		return;
	}

	// the lead-in is 20,000 instances of the lead-in pair; every other phase begins with 5000
	// before doing whatever it should be doing
	if(file_phase_ == FilePhaseLeadIn || phase_offset_ < block_leadin_length)
	{
		output_token_ = Leader;
		phase_offset_++;
		if(file_phase_ == FilePhaseLeadIn && phase_offset_ == leadin_length)
		{
			phase_offset_ = 0;
			file_phase_ = (file_phase_ == FilePhaseLeadIn) ? FilePhaseHeader : FilePhaseData;
		}
		return;
	}

	// determine whether a new byte needs to be queued up
	int block_offset = phase_offset_ - block_leadin_length;
	int bit_offset = block_offset % 10;
	int byte_offset = block_offset / 10;
	phase_offset_++;

	if(!bit_offset &&
		(
			(file_phase_ == FilePhaseHeader && byte_offset == block_length + countdown_bytes + 1) ||
			feof(file_)
		)
	)
	{
		output_token_ = EndOfBlock;
		phase_offset_ = 0;

		switch(file_phase_)
		{
			default: break;
			case FilePhaseHeader:
				copy_mask_ ^= 0x80;
				if(copy_mask_) file_phase_ = FilePhaseHeaderDataGap;
			break;
			case FilePhaseData:
				copy_mask_ ^= 0x80;
				fseek(file_, 2, SEEK_SET);
				if(copy_mask_) file_phase_ = FilePhaseAtEnd;
			break;
		}
		return;
	}

	if(bit_offset == 0)
	{
		// the first nine bytes are countdown; the high bit is set if this is a header
		if(byte_offset < countdown_bytes)
		{
			output_byte_ = (uint8_t)(countdown_bytes - byte_offset) | copy_mask_;
		}
		else
		{
			if(file_phase_ == FilePhaseHeader)
			{
				if(byte_offset == countdown_bytes + block_length)
				{
					output_byte_ = check_digit_;
				}
				else
				{
					if(byte_offset == countdown_bytes) check_digit_ = 0;
					if(file_phase_ == FilePhaseHeader)
					{
						switch(byte_offset - countdown_bytes)
						{
							case 0:	output_byte_ = 0x03;										break;
							case 1: output_byte_ = load_address_ & 0xff;						break;
							case 2: output_byte_ = (load_address_ >> 8)&0xff;					break;
							case 3: output_byte_ = (load_address_ + length_) & 0xff;			break;
							case 4: output_byte_ = ((load_address_ + length_) >> 8) & 0xff;		break;

							case 5: output_byte_ = 0x50;	break; // P
							case 6: output_byte_ = 0x52;	break; // R
							case 7: output_byte_ = 0x47;	break; // G
							default:
								output_byte_ = 0x20;
							break;
						}
					}
				}
			}
			else
			{
				output_byte_ = (uint8_t)fgetc(file_);
				if(feof(file_))
				{
					output_byte_ = check_digit_;
				}
			}

			check_digit_ ^= output_byte_;
		}
	}

	switch(bit_offset)
	{
		case 0:
			output_token_ = WordMarker;
		break;
		default:	// i.e. 1–8
			output_token_ = (output_byte_ & (1 << (bit_offset - 1))) ? One : Zero;
		break;
		case 9:
		{
			uint8_t parity = output_byte_;
			parity ^= (parity >> 4);
			parity ^= (parity >> 2);
			parity ^= (parity >> 1);
			output_token_ = (parity&1) ? Zero : One;
		}
		break;
	}
}