Add read-only cassette emulation to IBM 5150 PC. Patch from JohnElliott.
This commit is contained in:
SarahW
parent
750d7021e4
commit
84a098bc98
18 changed files with 1891 additions and 1136 deletions
419
src/pzx.c
Normal file
419
src/pzx.c
Normal file
|
|
@ -0,0 +1,419 @@
|
|||
/************************************************************************
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in a new issue