pcem/src/pzx.c

/************************************************************************

    PCem: IBM 5150 Cassette support

    Copyright (C) 2019  John Elliott <seasip.webmaster@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*************************************************************************/

#include <stdlib.h>
#include "ibm.h"
#include "pzx.h"

/* This module is intended to abstract all the details of a PZX file and 
 * emit its contents as a bitstream in a form suitable for PCem. Similar
 * modules could be written to add support for other tape formats such as TZX, 
 * TAP or CSW. */

#define CAS_LOG(x) pclog x
/* #define CAS_LOG(x)  */

static uint32_t peek2(uint8_t *data)
{
       return (((uint32_t)data[1]) <<  8) | data[0];
}

static uint32_t peek4(uint8_t *data)
{
	return (((uint32_t)data[3]) << 24) |
	       (((uint32_t)data[2]) << 16) |
	       (((uint32_t)data[1]) <<  8) | data[0];
}

/* Cue up the next pulse definition from the current PULS block. */
static void pzx_parse_pulse(pzxfile_t *pzx)
{
	pzx->puls_duration = peek2(pzx->curblock + pzx->puls_ptr);
	pzx->puls_ptr += 2;
	if (pzx->puls_duration > 0x8000)
	{
		pzx->puls_count = pzx->puls_duration & 0x7FFF;
		pzx->puls_duration = peek2(pzx->curblock + pzx->puls_ptr);
		pzx->puls_ptr += 2;
	}
	if (pzx->puls_duration >= 0x8000)
	{
		pzx->puls_duration &= 0x7FFF;
		pzx->puls_duration <<= 16;
		pzx->puls_duration |= peek2(pzx->curblock + pzx->puls_ptr);
		pzx->puls_ptr += 2;
	}
	if (!pzx->puls_count) pzx->puls_count = 1;
}



void pzx_init(pzxfile_t *pzx)
{
	memset(pzx, 0, sizeof(pzxfile_t));
	pzx->state = PZX_CLOSED;
}

/* Load the next block from a PZX-format file. 
 *
 * Returns block if successful, NULL if end of file or error
 * Caller must free the block with free(). */
uint8_t *pzx_load_block(FILE *fp)
{
	uint8_t block_header[8];
	uint8_t *block_data;
	uint32_t block_len;

	/* The first 8 bytes of a PZX block are fixed: the first 4 give
	 * the ID, the second 4 the length (excluding the header itself) */
	if (fread(block_header, 1, 8, fp) < 8) return NULL;	/* EoF */

	block_len = peek4(block_header + 4);
	block_data = malloc(8 + block_len);
	if (!block_data) return NULL;
	memcpy(block_data, block_header, 8);
	if (!block_len)	/* Block is only the header */
	{
/*		CAS_LOG(("Loaded PZX block: %-4.4s\n", block_data)); */
		return block_data;
	}	
	if (fread(block_data + 8, 1, block_len, fp) < block_len)
	{
		free(block_data);	/* Unexpected EoF */
		return NULL;
	}
/* 	CAS_LOG(("Loaded PZX block: %-4.4s\n", block_data)); */
	return block_data;	
}


/* Search the current file for PZX version headers and check they're all 1.x */
static const char * pzx_check_version(FILE *fp)
{
	uint8_t *block;
	static char message[80];

	rewind(fp);
	while ( (block = pzx_load_block(fp)) )
	{
		if (!memcmp(block, "PZXT", 4))
		{
			CAS_LOG(("PZX version %d.%d\n", block[8], block[9]));
			if (block[8] != 1) 
			{
				sprintf(message, "Unsupported PZX version %d.%d\n", block[8], block[9]);
				free(block);
				return message;
			}
		}
		free(block);
	}
	rewind(fp);
	return NULL;
}


const char *pzx_open(pzxfile_t *pzx, FILE *fp)
{
	const char *result;

	rewind(fp);
	/* Check that this file is compatible */
	result = pzx_check_version(fp);
	if (result) return result;

	pzx->level = 0;
	pzx->state = PZX_IDLE;
	pzx->input = fp;
	return NULL;	
}

void pzx_close(pzxfile_t *pzx)
{
	if (pzx->input)
	{
		fclose(pzx->input);
		pzx->input = NULL;
	}
	if (pzx->curblock)
	{
		free(pzx->curblock);
		pzx->curblock = NULL;
	}
	pzx->state = PZX_CLOSED;
}

/* Read the next block of type DATA, PAUS or PULS */
int pzx_next_block(pzxfile_t *pzx)
{
	long pos;

	pos = ftell(pzx->input);
	while (pzx->state == PZX_IDLE)
	{
		uint8_t *blk;

		/* In idle state there should be no current block. But
		 * make sure of that */
		if (pzx->curblock)
		{
			free(pzx->curblock);
			pzx->curblock = NULL;
		}

		/* Load the next block */
		blk = pzx_load_block(pzx->input);

		/* If that didn't load we've reached the end of file; wrap to
		 * beginning. */
		if (!blk)	
		{
			rewind(pzx->input);
			blk = pzx_load_block(pzx->input);
			if (!blk)	/* Couldn't even load first block */
			{
				pzx_close(pzx);
				return 0;
			}
			/* Have we read the whole file and come back to where
			 * we were? */
			if (ftell(pzx->input) == pos)	
			{
				free(blk);
				pzx_close(pzx);
				return 0;
			}
		}
		/* We have loaded the next block. What is it? */
		if (!memcmp(blk, "PULS", 4))
		{
			pzx->state = PZX_IN_PULS;
			pzx->curblock = blk;
			pzx->puls_len = 8 + peek4(blk + 4);
			pzx->puls_ptr = 8;
			pzx->puls_count = 0;
			pzx->puls_remain = 0;
			pzx->puls_duration = 0;
			pzx->level = 0;
			CAS_LOG(("Beginning PULS block\n"));
		}
		else if (!memcmp(blk, "PAUS", 4))
		{
			pzx->state = PZX_IN_PAUS;
			pzx->curblock = blk;
			pzx->paus_remain = peek4(blk + 8);
			pzx->level = (pzx->paus_remain >> 31);
			pzx->paus_remain &= 0x7FFFFFFF;
			CAS_LOG(("Beginning PAUS block, duration=%d\n",
					pzx->paus_remain));
		}
		else if (!memcmp(blk, "DATA", 4))
		{
			pzx->state = PZX_IN_DATA;
			pzx->curblock = blk;
			pzx->data_bits = peek4(blk + 8);
			pzx->level = (pzx->data_bits >> 31);
			pzx->data_bits &= 0x7FFFFFFF;
			pzx->data_tail = peek2(blk + 12);
			pzx->data_p0   = blk[14];
			pzx->data_p1   = blk[15];
			pzx->data_p    = 0;
			pzx->data_w    = 16;
			pzx->data_remain = 0;
			pzx->data_ptr = 16 + 2 * (pzx->data_p0 + pzx->data_p1);
			pzx->data_mask = 0x80;
			CAS_LOG(("Beginning DATA block, length=%d p0=%d p1=%d"
				" data_ptr=%d\n",
					pzx->data_bits, 
					pzx->data_p0, pzx->data_p1, 
					pzx->data_ptr));
		}
	}
	return 1;
}

static void pzx_endblock(pzxfile_t *pzx)
{
	if (pzx->curblock) free(pzx->curblock);
	pzx->curblock = NULL;
	pzx->state = PZX_IDLE;
}

/* PAUS is easy - just run the timer down */
static int pzx_advance_paus(pzxfile_t *pzx, int time)
{
	if (pzx->paus_remain > time)
	{
		pzx->paus_remain -= time;
		return 0;
	}
	time -= pzx->paus_remain;
	pzx_endblock(pzx);
	return time;
}




	

static int pzx_advance_puls(pzxfile_t *pzx, int time)
{
	/* At the start of a pulse sequence? */
	if (pzx->puls_count == 0)
	{
		pzx_parse_pulse(pzx);
		pzx->puls_remain = pzx->puls_duration;
	}
	/* Does sample trigger a pulse change? If not, that's easy. */
	if (time < pzx->puls_remain)
	{
		pzx->puls_remain -= time;
		return 0;
	}
	/* Sample does trigger a pulse change */
	time -= pzx->puls_remain;
	/* If there's another pulse in the current sequence, that's 
	 * straightforward; just flip the level and continue */
	--pzx->puls_count;
	pzx->level = !pzx->level;
	if (pzx->puls_count)
	{
		pzx->puls_remain = pzx->puls_duration;
		return time;
	}
	/* If we've reached the end of the pulse sequence, there may be 
	 * another one */
	if (pzx->puls_ptr < pzx->puls_len)
	{
		return time;
	}
	/* If there isn't another one, it's the end of the block */
	pzx_endblock(pzx);
	return time;
}


/* Decode a DATA block */
static int pzx_advance_data(pzxfile_t *pzx, int time)
{
	uint8_t bit;

	/* Reached end of data? */
	if (pzx->data_bits == 0)
	{
		/* Time interval is covered by the tail bit */
		if (pzx->data_tail > time)
		{
			pzx->data_tail -= time;
			return 0;	
		}
		/* Have run out of block */
		time -= pzx->data_tail;
		pzx_endblock(pzx);
		return time;
	}
	/* No more time remaining on the current bit? */
	if (pzx->data_p < 1 && !pzx->data_remain)	
	{
		bit = pzx->curblock[pzx->data_ptr] & pzx->data_mask;
		pzx->data_mask >>= 1;
		if (!pzx->data_mask)
		{
			pzx->data_mask = 0x80;
			++pzx->data_ptr;
		}
		--pzx->data_bits;	

		if (bit)
		{
			pzx->data_p = pzx->data_p1;
			pzx->data_w = 16 + 2 * pzx->data_p0;
			pzx->data_remain = 0;
		}
		else
		{
			pzx->data_p = pzx->data_p0;
			pzx->data_w = 16;
			pzx->data_remain = 0;
		}
	}
	/* See if we've started processing the current waveform. If not, 
	 * load its first element (assuming that there is one) */
	if (!pzx->data_remain)
	{
		if (pzx->data_p)
		{
			pzx->data_remain = peek2(pzx->curblock + pzx->data_w);
			pzx->data_w += 2;
			pzx->data_p--;
		}
	}
	if (pzx->data_remain > time)
	{
		/* Time advance is contained within current wave */
		pzx->data_remain -= time;
		return 0;
	}
	else	/* Move on to next element of wave / next bit / next block */
	{
		time -= pzx->data_remain;
		pzx->data_remain = 0;
		pzx->level = !pzx->level;
	}

	return time;
}




int pzx_advance(pzxfile_t *pzx, int time)
{
	if (pzx->state == PZX_CLOSED) return 0;	/* No tape loaded */

	while (time)
	{
		switch (pzx->state)
		{
			case PZX_IDLE:
				if (!pzx_next_block(pzx)) return 0;
				break;
			case PZX_IN_PULS:
				time = pzx_advance_puls(pzx, time);
				break;
			case PZX_IN_PAUS:
				time = pzx_advance_paus(pzx, time);
				break;
			case PZX_IN_DATA:
				time = pzx_advance_data(pzx, time);
				break;
                        case PZX_CLOSED: /*Should never get here*/
                                return 0;
	
		}
	}
	return pzx->level;
}