libretro/fuse-libretro
1
0
Fork 0
mirror of https://github.com/libretro/fuse-libretro.git synced 2024-11-27 02:30:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
cad85b7b1b
fuse-libretro/libspectrum/rzx.c
Thomas Conté fee06e95f0 Revert "Revert "Update to Fuse 1.6.0 and libspectrum 1.5.0"" 
This reverts commit 67ebf22dda.
2021-04-10 15:34:37 +02:00

1765 lines
47 KiB
C
Raw Blame History

/* rzx.c: routines for dealing with .rzx files
Copyright (c) 2002-2015 Philip Kendall
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.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
Author contact information:
E-mail: philip-fuse@shadowmagic.org.uk
*/
#include "config.h"
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#ifdef HAVE_STRINGS_H
#include <strings.h> /* Needed for strcasecmp() on QNX6 */
#endif /* #ifdef HAVE_STRINGS_H */
#ifdef HAVE_GCRYPT_H
#include <gcrypt.h>
#endif /* #ifdef HAVE_GCRYPT_H */
#include "internals.h"
/* The strings used for each snapshot type */
typedef struct snapshot_string_t {
libspectrum_id_t format;
const char *string;
} snapshot_string_t;
static snapshot_string_t snapshot_strings[] = {
{ LIBSPECTRUM_ID_SNAPSHOT_SNA, "SNA" },
{ LIBSPECTRUM_ID_SNAPSHOT_SZX, "SZX" },
{ LIBSPECTRUM_ID_SNAPSHOT_Z80, "Z80" },
{ 0, NULL }, /* End marker */
};
typedef struct libspectrum_rzx_frame_t {
size_t instructions;
size_t count;
libspectrum_byte* in_bytes;
int repeat_last; /* Set if we should use the last
frame's IN bytes */
} libspectrum_rzx_frame_t;
typedef struct input_block_t {
libspectrum_rzx_frame_t *frames;
size_t count;
size_t allocated;
size_t tstates;
/* Used for recording to note the last non-repeated frame. We can't
really use a direct pointer to the frame here as that will move
around when we do a renew on the array, so just dereference it
every time */
size_t non_repeat;
} input_block_t;
typedef struct snapshot_block_t {
libspectrum_snap *snap;
int automatic;
} snapshot_block_t;
typedef struct signature_block_t {
size_t length; /* Length of the signed data from rzx->signed_start */
#ifdef HAVE_GCRYPT_H
gcry_mpi_t r, s;
#endif /* #ifdef HAVE_GCRYPT_H */
} signature_block_t;
typedef struct rzx_block_t {
libspectrum_rzx_block_id type;
union {
input_block_t input;
snapshot_block_t snap;
libspectrum_dword keyid;
signature_block_t signature;
} types;
} rzx_block_t;
struct libspectrum_rzx {
GSList *blocks;
/* Playback variables */
GSList *current_block;
input_block_t *current_input;
size_t current_frame;
libspectrum_rzx_frame_t *data_frame;
size_t in_count;
/* Signature parameters */
const libspectrum_byte *signed_start;
size_t signed_length;
};
static libspectrum_error
rzx_read_header( const libspectrum_byte **ptr, const libspectrum_byte *end );
static libspectrum_error
rzx_read_creator( const libspectrum_byte **ptr, const libspectrum_byte *end );
static libspectrum_error
rzx_read_snapshot( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end );
static libspectrum_error
rzx_read_input( libspectrum_rzx *rzx,
const libspectrum_byte **ptr, const libspectrum_byte *end );
static libspectrum_error
rzx_read_frames( input_block_t *block, const libspectrum_byte **ptr,
const libspectrum_byte *end );
static libspectrum_error
rzx_read_sign_start( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end );
static libspectrum_error
rzx_read_sign_end( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end );
static void
rzx_write_header( libspectrum_buffer *buffer, int sign );
static void
rzx_write_creator( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_creator *creator );
static libspectrum_error
rzx_write_snapshot( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_snap *snap, libspectrum_id_t snap_format,
libspectrum_creator *creator, int compress );
static void
rzx_write_input( input_block_t *block, libspectrum_buffer *buffer,
libspectrum_buffer *block_data, int compress );
static libspectrum_error
rzx_write_signed_start( libspectrum_buffer *buffer,
libspectrum_buffer *block_data,
libspectrum_rzx_dsa_key *key,
libspectrum_creator *creator );
static libspectrum_error
rzx_write_signed_end( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_rzx_dsa_key *key );
/* The signature used to identify .rzx files */
static const char * const rzx_signature = "RZX!";
/* The IN count used to signify 'repeat last frame' */
const libspectrum_word libspectrum_rzx_repeat_frame = 0xffff;
/*
* Generic block handling routines
*/
static void
block_alloc( rzx_block_t **block, libspectrum_rzx_block_id type )
{
*block = libspectrum_new( rzx_block_t, 1 );
(*block)->type = type;
}
static libspectrum_error
block_free( rzx_block_t *block )
{
size_t i;
input_block_t *input;
#ifdef HAVE_GCRYPT_H
signature_block_t *signature;
#endif /* #ifdef HAVE_GCRYPT_H */
switch( block->type ) {
case LIBSPECTRUM_RZX_INPUT_BLOCK:
input = &( block->types.input );
for( i = 0; i < input->count; i++ )
if( !input->frames[i].repeat_last ) libspectrum_free( input->frames[i].in_bytes );
libspectrum_free( input->frames );
libspectrum_free( block );
return LIBSPECTRUM_ERROR_NONE;
case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
libspectrum_snap_free( block->types.snap.snap );
libspectrum_free( block );
return LIBSPECTRUM_ERROR_NONE;
case LIBSPECTRUM_RZX_SIGN_START_BLOCK:
libspectrum_free( block );
return LIBSPECTRUM_ERROR_NONE;
case LIBSPECTRUM_RZX_SIGN_END_BLOCK:
#ifdef HAVE_GCRYPT_H
signature = &( block->types.signature );
gcry_mpi_release( signature->r );
gcry_mpi_release( signature->s );
#endif /* #ifdef HAVE_GCRYPT_H */
libspectrum_free( block );
return LIBSPECTRUM_ERROR_NONE;
case LIBSPECTRUM_RZX_CREATOR_BLOCK:
break;
}
libspectrum_print_error( LIBSPECTRUM_ERROR_LOGIC,
"unknown RZX block type %d at %s:%d", block->type,
__FILE__, __LINE__ );
return LIBSPECTRUM_ERROR_LOGIC;
}
static void
block_free_wrapper( gpointer data, gpointer user_data )
{
block_free( data );
}
static gint
find_block( gconstpointer a, gconstpointer b )
{
const rzx_block_t *block = a;
libspectrum_byte id = GPOINTER_TO_INT( b );
return block->type - id;
}
/*
* Main routines
*/
libspectrum_rzx*
libspectrum_rzx_alloc( void )
{
libspectrum_rzx *rzx = libspectrum_new( libspectrum_rzx, 1 );
rzx->blocks = NULL;
rzx->current_block = NULL;
rzx->current_input = NULL;
rzx->signed_start = NULL;
return rzx;
}
void
libspectrum_rzx_start_input( libspectrum_rzx *rzx, libspectrum_dword tstates )
{
rzx_block_t *block;
block_alloc( &block, LIBSPECTRUM_RZX_INPUT_BLOCK );
rzx->current_input = &( block->types.input );
rzx->current_input->tstates = tstates;
rzx->current_input->frames = NULL;
rzx->current_input->allocated = 0;
rzx->current_input->count = 0;
rzx->current_input->non_repeat = 0;
rzx->blocks = g_slist_append( rzx->blocks, block );
}
libspectrum_error
libspectrum_rzx_stop_input( libspectrum_rzx *rzx )
{
rzx->current_input = NULL;
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_add_snap( libspectrum_rzx *rzx, libspectrum_snap *snap, int automatic )
{
rzx_block_t *block;
libspectrum_rzx_stop_input( rzx );
block_alloc( &block, LIBSPECTRUM_RZX_SNAPSHOT_BLOCK );
block->types.snap.snap = snap;
block->types.snap.automatic = automatic;
rzx->blocks = g_slist_append( rzx->blocks, block );
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_rollback( libspectrum_rzx *rzx, libspectrum_snap **snap )
{
GSList *previous, *list;
rzx_block_t *block;
/* Find the last snapshot block in the file */
previous = NULL; list = rzx->blocks;
while( 1 ) {
list =
g_slist_find_custom( list,
GINT_TO_POINTER( LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ),
find_block );
if( !list ) break;
previous = list;
list = list->next;
}
if( !previous ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"no snapshot block found in recording" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
if( rzx->current_input ) {
libspectrum_rzx_stop_input( rzx );
}
/* Delete all blocks after the snapshot */
g_slist_foreach( previous->next, block_free_wrapper, NULL );
previous->next = NULL;
block = previous->data;
*snap = block->types.snap.snap;
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_rollback_to( libspectrum_rzx *rzx, libspectrum_snap **snap,
size_t which )
{
GSList *previous = NULL, *list;
rzx_block_t *block;
size_t i;
/* Find the nth snapshot block in the file */
for( i = 0, list = rzx->blocks; i <= which; i++, list = list->next ) {
list =
g_slist_find_custom( list,
GINT_TO_POINTER( LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ),
find_block );
if( !list ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"snapshot block %lu not found in recording",
(unsigned long)which );
return LIBSPECTRUM_ERROR_CORRUPT;
}
previous = list;
}
if( rzx->current_input ) {
libspectrum_rzx_stop_input( rzx );
}
/* Delete all blocks after the snapshot */
g_slist_foreach( previous->next, block_free_wrapper, NULL );
previous->next = NULL;
block = previous->data;
*snap = block->types.snap.snap;
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
input_block_resize( input_block_t *input, size_t new_count )
{
libspectrum_rzx_frame_t *ptr;
size_t new_allocated;
/* Get more space if we need it; allocate twice as much as we currently
have, with a minimum of 50 */
if( new_count > input->allocated ) {
new_allocated = input->allocated >= 25 ? 2 * input->allocated : 50;
if( new_allocated < new_count ) new_allocated = new_count;
ptr = libspectrum_renew( libspectrum_rzx_frame_t, input->frames,
new_allocated );
if( !ptr ) return LIBSPECTRUM_ERROR_MEMORY;
input->frames = ptr;
input->allocated = new_allocated;
}
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_store_frame( libspectrum_rzx *rzx, size_t instructions,
size_t count, libspectrum_byte *in_bytes )
{
input_block_t *input;
libspectrum_rzx_frame_t *frame;
libspectrum_error error;
input = rzx->current_input;
/* Check we've got an IRB to record to */
if( !input ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_INVALID,
"libspectrum_rzx_store_frame called with no active input block"
);
return LIBSPECTRUM_ERROR_INVALID;
}
/* Get more space if we need it */
if( input->allocated == input->count ) {
error = input_block_resize( input, input->count + 1 );
if( error ) return error;
}
frame = &input->frames[ input->count ];
frame->instructions = instructions;
/* Check for repeated frames */
if( input->count != 0 && count != 0 &&
count == input->frames[ input->non_repeat ].count &&
!memcmp( in_bytes, input->frames[ input->non_repeat ].in_bytes,
count )
) {
frame->repeat_last = 1;
frame->count = 0;
frame->in_bytes = NULL;
} else {
frame->repeat_last = 0;
frame->count = count;
/* Note this as the last non-repeated frame */
input->non_repeat = input->count;
if( count ) {
frame->in_bytes = libspectrum_new( libspectrum_byte, count );
memcpy( frame->in_bytes, in_bytes,
count * sizeof( *( frame->in_bytes ) ) );
} else {
frame->in_bytes = NULL;
}
}
/* Move along to the next frame */
input->count++;
return 0;
}
libspectrum_error
libspectrum_rzx_start_playback( libspectrum_rzx *rzx, int which,
libspectrum_snap **snap )
{
GSList *list, *previous;
rzx_block_t *block;
int i;
*snap = NULL;
for( i = which, previous = NULL, list = rzx->blocks;
list;
previous = list, list = list->next ) {
block = list->data;
/* Skip any blocks which aren't input recording blocks */
if( block->type != LIBSPECTRUM_RZX_INPUT_BLOCK ) continue;
/* Skip input recording blocks until we find the one we want */
if( i-- ) continue;
rzx->current_block = list;
rzx->current_input = &( block->types.input );
rzx->current_frame = 0; rzx->in_count = 0;
rzx->data_frame = rzx->current_input->frames;
/* If the previous frame was a snap, return that as well */
if( previous ) {
block = previous->data;
if( block->type == LIBSPECTRUM_RZX_SNAPSHOT_BLOCK )
*snap = block->types.snap.snap;
}
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_print_error(
LIBSPECTRUM_ERROR_INVALID,
"libspectrum_rzx_start_playback: input recording block %d does not exist",
which
);
return LIBSPECTRUM_ERROR_INVALID;
}
libspectrum_error
libspectrum_rzx_playback_frame( libspectrum_rzx *rzx, int *finished,
libspectrum_snap **snap )
{
*snap = NULL;
*finished = 0;
/* Check we read the correct number of INs during this frame */
if( rzx->in_count != rzx->data_frame->count ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"libspectrum_rzx_playback_frame: wrong number of INs in frame %lu: expected %lu, got %lu",
(unsigned long)rzx->current_frame,
(unsigned long)rzx->data_frame->count, (unsigned long)rzx->in_count
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* Increment the frame count and see if we've finished with this file */
if( ++rzx->current_frame >= rzx->current_input->count ) {
GSList *it = rzx->current_block->next;
rzx->current_block = NULL;
for( ; it; it = it->next ) {
rzx_block_t *block = it->data;
if( block->type == LIBSPECTRUM_RZX_INPUT_BLOCK ) {
rzx->current_block = it;
break;
} else if( block->type == LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ) {
*snap = block->types.snap.snap;
}
}
if( rzx->current_block ) {
rzx_block_t *block = rzx->current_block->data;
rzx->current_input = &( block->types.input );
rzx->current_frame = 0; rzx->in_count = 0;
rzx->data_frame = rzx->current_input->frames;
} else {
*finished = 1;
}
return LIBSPECTRUM_ERROR_NONE;
}
/* Move the data frame pointer along, unless we're supposed to be
repeating the last frame */
if( !rzx->current_input->frames[ rzx->current_frame ].repeat_last )
rzx->data_frame = &rzx->current_input->frames[ rzx->current_frame ];
/* And start with the first byte of the new frame */
rzx->in_count = 0;
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_playback( libspectrum_rzx *rzx, libspectrum_byte *byte )
{
/* Check we're not trying to read off the end of the array */
if( rzx->in_count >= rzx->data_frame->count ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"libspectrum_rzx_playback: more INs during frame %lu than stored in RZX file (%lu)",
(unsigned long)rzx->current_frame, (unsigned long)rzx->data_frame->count
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
*byte = rzx->data_frame->in_bytes[ rzx->in_count++ ];
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_free( libspectrum_rzx *rzx )
{
g_slist_foreach( rzx->blocks, block_free_wrapper, NULL );
g_slist_free( rzx->blocks );
libspectrum_free( rzx );
return LIBSPECTRUM_ERROR_NONE;
}
size_t
libspectrum_rzx_tstates( libspectrum_rzx *rzx )
{
return rzx->current_input->tstates;
}
size_t
libspectrum_rzx_instructions( libspectrum_rzx *rzx )
{
return rzx->current_input->frames[ rzx->current_frame ].instructions;
}
libspectrum_dword
libspectrum_rzx_get_keyid( libspectrum_rzx *rzx )
{
GSList *list;
rzx_block_t *block;
list =
g_slist_find_custom( rzx->blocks,
GINT_TO_POINTER( LIBSPECTRUM_RZX_SIGN_START_BLOCK ),
find_block );
if( !list ) return 0;
block = list->data;
return block->types.keyid;
}
libspectrum_error
libspectrum_rzx_get_signature( libspectrum_rzx *rzx,
libspectrum_signature *signature )
{
GSList *list;
rzx_block_t *block;
signature_block_t *sigblock;
list =
g_slist_find_custom( rzx->blocks,
GINT_TO_POINTER( LIBSPECTRUM_RZX_SIGN_END_BLOCK ),
find_block );
if( !list ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"no end of signed data block found" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
block = list->data;
sigblock = &( block->types.signature );
signature->start = rzx->signed_start;
signature->length = sigblock->length;
#ifdef HAVE_GCRYPT_H
signature->r = gcry_mpi_copy( sigblock->r );
signature->s = gcry_mpi_copy( sigblock->s );
#endif /* #ifdef HAVE_GCRYPT_H */
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_read( libspectrum_rzx *rzx, const libspectrum_byte *buffer,
size_t length )
{
libspectrum_error error;
const libspectrum_byte *ptr, *end;
libspectrum_byte *new_buffer;
libspectrum_id_t raw_type;
libspectrum_class_t class;
/* Find out if this file needs decompression */
new_buffer = NULL;
error = libspectrum_identify_file_raw( &raw_type, NULL, buffer, length );
if( error ) return error;
error = libspectrum_identify_class( &class, raw_type );
if( error ) return error;
if( class == LIBSPECTRUM_CLASS_COMPRESSED ) {
size_t new_length;
error = libspectrum_uncompress_file( &new_buffer, &new_length, NULL,
raw_type, buffer, length, NULL );
if( error ) return error;
buffer = new_buffer; length = new_length;
}
ptr = buffer; end = buffer + length;
error = rzx_read_header( &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) { libspectrum_free( new_buffer ); return error; }
rzx->signed_start = ptr;
while( ptr < end ) {
libspectrum_byte id;
id = *ptr++;
switch( id ) {
case LIBSPECTRUM_RZX_CREATOR_BLOCK:
error = rzx_read_creator( &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_free( new_buffer );
return error;
}
break;
case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
error = rzx_read_snapshot( rzx, &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_free( new_buffer );
return error;
}
break;
case LIBSPECTRUM_RZX_INPUT_BLOCK:
error = rzx_read_input( rzx, &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_free( new_buffer );
return error;
}
break;
case LIBSPECTRUM_RZX_SIGN_START_BLOCK:
error = rzx_read_sign_start( rzx, &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_free( new_buffer );
return error;
}
break;
case LIBSPECTRUM_RZX_SIGN_END_BLOCK:
error = rzx_read_sign_end( rzx, &ptr, end );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_free( new_buffer );
return error;
}
break;
default:
libspectrum_print_error(
LIBSPECTRUM_ERROR_UNKNOWN,
"libspectrum_rzx_read: unknown RZX block ID 0x%02x", id
);
libspectrum_free( new_buffer );
return LIBSPECTRUM_ERROR_UNKNOWN;
}
}
libspectrum_free( new_buffer );
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_header( const libspectrum_byte **ptr, const libspectrum_byte *end )
{
/* Check the header exists */
if( end - (*ptr) < (ptrdiff_t)strlen( rzx_signature ) + 6 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_header: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* Check the RZX signature exists */
if( memcmp( *ptr, rzx_signature, strlen( rzx_signature ) ) ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_SIGNATURE,
"rzx_read_header: RZX signature not found" );
return LIBSPECTRUM_ERROR_SIGNATURE;
}
/* Skip over the signature and the version numbers */
(*ptr) += strlen( rzx_signature ) + 2;
/* And skip the flags as well - separate call as we'll need the return
value if we ever fix the stuff below */
libspectrum_read_dword( ptr );
/* FIXME: how to handle signatures */
/* This is where the signed data starts (if it's signed at all) */
/* if( signature && ( flags & 0x01 ) ) signature->start = *ptr; */
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_creator( const libspectrum_byte **ptr, const libspectrum_byte *end )
{
size_t length;
/* Check we've got enough data for the block */
if( end - (*ptr) < 28 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_creator: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* Get the length */
length = libspectrum_read_dword( ptr );
/* Check there's still enough data (the -5 is because we've already read
the block ID and the length) */
if( end - (*ptr) < (ptrdiff_t)length - 5 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_creator: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
(*ptr) += length - 5;
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_snapshot( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end )
{
rzx_block_t *block;
libspectrum_snap *snap;
size_t blocklength, snaplength;
libspectrum_error error = LIBSPECTRUM_ERROR_NONE;
libspectrum_dword flags;
const libspectrum_byte *snap_ptr;
int done;
snapshot_string_t *type;
/* For deflated snapshot data: */
int compressed;
libspectrum_byte *gzsnap = NULL; size_t uncompressed_length = 0;
if( end - (*ptr) < 16 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_snapshot: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
blocklength = libspectrum_read_dword( ptr );
if( end - (*ptr) < (ptrdiff_t)blocklength - 5 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_snapshot: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* See if we want a compressed snap */
flags = libspectrum_read_dword( ptr );
/* We don't handle 'links' to external snapshots. I really think these
are just more trouble than they're worth */
if( flags & 0x01 ) {
/* TODO log error if this isn't the first block as that can't be easily
covered by prompting the user for a snapshot file (but should be
unlikely to encounter in reality?) */
(*ptr) += blocklength - 9;
return LIBSPECTRUM_ERROR_NONE;
}
/* Do we have a compressed snapshot? */
compressed = flags & 0x02;
/* How long is the (uncompressed) snap? */
(*ptr) += 4;
snaplength = libspectrum_read_dword( ptr );
(*ptr) -= 8;
/* If compressed, uncompress the data */
if( compressed ) {
#ifdef HAVE_ZLIB_H
error = libspectrum_zlib_inflate( (*ptr) + 8, blocklength - 17,
&gzsnap, &uncompressed_length );
if( error != LIBSPECTRUM_ERROR_NONE ) return error;
if( uncompressed_length != snaplength ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_snapshot: compressed snapshot has wrong length"
);
libspectrum_free( gzsnap );
return LIBSPECTRUM_ERROR_CORRUPT;
}
snap_ptr = gzsnap;
#else /* #ifdef HAVE_ZLIB_H */
libspectrum_print_error(
LIBSPECTRUM_ERROR_UNKNOWN,
"rzx_read_snapshot: zlib needed for decompression\n"
);
return LIBSPECTRUM_ERROR_UNKNOWN;
#endif /* #ifdef HAVE_ZLIB_H */
} else {
/* If not compressed, check things are consistent */
if( blocklength != snaplength + 17 ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_snapshot: inconsistent snapshot lengths"
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
snap_ptr = (*ptr) + 8;
uncompressed_length = snaplength;
}
block_alloc( &block, LIBSPECTRUM_RZX_SNAPSHOT_BLOCK );
block->types.snap.snap = libspectrum_snap_alloc();
block->types.snap.automatic = 0;
snap = block->types.snap.snap;
for( done = 0, type = snapshot_strings; type->format; type++ ) {
if( !strncasecmp( (char*)*ptr, type->string, 4 ) ) {
error = libspectrum_snap_read( snap, snap_ptr, uncompressed_length,
type->format, NULL );
done = 1;
}
}
if( !done ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_UNKNOWN,
"%s:rzx_read_snapshot: unrecognised snapshot format", __FILE__
);
if( compressed ) libspectrum_free( gzsnap );
block_free( block );
return LIBSPECTRUM_ERROR_UNKNOWN;
}
if( error != LIBSPECTRUM_ERROR_NONE ) {
if( compressed ) libspectrum_free( gzsnap );
block_free( block );
return error;
}
/* Free the decompressed data (if we created it) */
if( compressed ) libspectrum_free( gzsnap );
/* Skip over the data */
(*ptr) += blocklength - 9;
rzx->blocks = g_slist_append( rzx->blocks, block );
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_input( libspectrum_rzx *rzx,
const libspectrum_byte **ptr, const libspectrum_byte *end )
{
size_t blocklength;
libspectrum_dword flags; int compressed;
libspectrum_error error;
rzx_block_t *rzx_block;
input_block_t *block;
/* Check we've got enough data for the block */
if( end - (*ptr) < 18 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_input: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
block_alloc( &rzx_block, LIBSPECTRUM_RZX_INPUT_BLOCK );
block = &( rzx_block->types.input );
/* Get the length and number of frames */
blocklength = libspectrum_read_dword( ptr );
block->count = libspectrum_read_dword( ptr );
/* Frame size is undefined, so just skip it */
(*ptr)++;
/* Allocate memory for the frames */
block->frames = libspectrum_new( libspectrum_rzx_frame_t, block->count );
block->allocated = block->count;
/* Fetch the T-state counter and the flags */
block->tstates = libspectrum_read_dword( ptr );
flags = libspectrum_read_dword( ptr );
compressed = flags & 0x02;
if( compressed ) {
#ifdef HAVE_ZLIB_H
libspectrum_byte *data; const libspectrum_byte *data_ptr;
size_t data_length = 0;
/* Discount the block intro */
blocklength -= 18;
/* Check that we've got enough compressed data */
if( end - (*ptr) < (ptrdiff_t)blocklength ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_input: not enough data in buffer" );
libspectrum_free( rzx_block );
return LIBSPECTRUM_ERROR_CORRUPT;
}
error = libspectrum_zlib_inflate( *ptr, blocklength, &data, &data_length );
if( error != LIBSPECTRUM_ERROR_NONE ) {
block_free( rzx_block );
return error;
}
*ptr += blocklength;
data_ptr = data;
error = rzx_read_frames( block, &data_ptr, data + data_length );
if( error ) { libspectrum_free( rzx_block ); libspectrum_free( data ); return error; }
libspectrum_free( data );
#else /* #ifdef HAVE_ZLIB_H */
libspectrum_print_error( LIBSPECTRUM_ERROR_UNKNOWN,
"rzx_read_input: zlib needed for decompression" );
libspectrum_free( rzx_block );
return LIBSPECTRUM_ERROR_UNKNOWN;
#endif /* #ifdef HAVE_ZLIB_H */
} else { /* Data not compressed */
error = rzx_read_frames( block, ptr, end );
if( error ) { libspectrum_free( rzx_block ); return error; }
}
rzx->blocks = g_slist_append( rzx->blocks, rzx_block );
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_frames( input_block_t *block, const libspectrum_byte **ptr,
const libspectrum_byte *end )
{
size_t i, j;
/* And read in the frames */
for( i=0; i < block->count; i++ ) {
/* Check the two length bytes exist */
if( end - (*ptr) < 4 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_frames: not enough data in buffer" );
for( j=0; j<i; j++ ) {
if( !block->frames[i].repeat_last ) libspectrum_free( block->frames[j].in_bytes );
}
return LIBSPECTRUM_ERROR_CORRUPT;
}
block->frames[i].instructions = libspectrum_read_word( ptr );
block->frames[i].count = libspectrum_read_word( ptr );
if( block->frames[i].count == libspectrum_rzx_repeat_frame ) {
block->frames[i].repeat_last = 1;
continue;
}
block->frames[i].repeat_last = 0;
if( end - (*ptr) < (ptrdiff_t)block->frames[i].count ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_frames: not enough data in buffer" );
for( j=0; j<i; j++ ) {
if( !block->frames[i].repeat_last ) libspectrum_free( block->frames[j].in_bytes );
}
return LIBSPECTRUM_ERROR_CORRUPT;
}
if( block->frames[i].count ) {
block->frames[i].in_bytes =
libspectrum_new( libspectrum_byte, block->frames[i].count );
memcpy( block->frames[i].in_bytes, *ptr, block->frames[i].count );
} else {
block->frames[i].in_bytes = NULL;
}
(*ptr) += block->frames[i].count;
}
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_sign_start( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end )
{
rzx_block_t *block;
libspectrum_dword length;
/* Check we've got enough data for the length */
if( end - (*ptr) < 4 ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_sign_start: not enough data in buffer"
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
length = libspectrum_read_dword( ptr );
/* Check the length is at least the expected 13 bytes */
if( length < 13 ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_sign_start: block length %lu less than the minimum 13 bytes",
(unsigned long)length
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* Check there's still enough data (the -5 is because we've already read
the length and the block ID) */
if( end - (*ptr) < (ptrdiff_t)length - 5 ) {
libspectrum_print_error(
LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_sign_start: not enough data in buffer"
);
return LIBSPECTRUM_ERROR_CORRUPT;
}
block_alloc( &block, LIBSPECTRUM_RZX_SIGN_START_BLOCK );
block->types.keyid = libspectrum_read_dword( ptr );
/* Skip the week code */
*ptr += 4;
/* Skip anything we don't know about */
*ptr += length - 13;
rzx->blocks = g_slist_append( rzx->blocks, block );
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_read_sign_end( libspectrum_rzx *rzx, const libspectrum_byte **ptr,
const libspectrum_byte *end )
{
rzx_block_t *block;
signature_block_t *signature;
size_t length;
/* Check we've got enough data for the length */
if( end - (*ptr) < 4 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_sign_end: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
/* Get the length; the -5 is because we've read the block ID and the length
bytes */
length = libspectrum_read_dword( ptr ) - 5;
/* Check there's still enough data */
if( end - (*ptr) < (ptrdiff_t)length ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"rzx_read_sign_end: not enough data in buffer" );
return LIBSPECTRUM_ERROR_CORRUPT;
}
block_alloc( &block, LIBSPECTRUM_RZX_SIGN_END_BLOCK );
signature = &( block->types.signature );
/* - 5 as we don't sign the block ID and length of this block */
signature->length = ( *ptr - rzx->signed_start ) - 5;
#ifdef HAVE_GCRYPT_H
{
gcry_error_t error; size_t mpi_length;
error = gcry_mpi_scan( &signature->r, GCRYMPI_FMT_PGP, *ptr, length,
&mpi_length );
if( error ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"error reading 'r': %s",
gcry_strerror( error ) );
libspectrum_free( block );
return LIBSPECTRUM_ERROR_CORRUPT;
}
(*ptr) += mpi_length; length -= mpi_length;
error = gcry_mpi_scan( &signature->s, GCRYMPI_FMT_PGP, *ptr, length,
&mpi_length );
if( error ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
"error reading 's': %s",
gcry_strerror( error ) );
gcry_mpi_release( signature->r );
libspectrum_free( block );
return LIBSPECTRUM_ERROR_CORRUPT;
}
(*ptr) += mpi_length; length -= mpi_length;
}
#endif /* #ifdef HAVE_GCRYPT_H */
(*ptr) += length;
rzx->blocks = g_slist_append( rzx->blocks, block );
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_error
libspectrum_rzx_write( libspectrum_byte **buffer, size_t *length,
libspectrum_rzx *rzx, libspectrum_id_t snap_format,
libspectrum_creator *creator, int compress,
libspectrum_rzx_dsa_key *key )
{
libspectrum_error error;
GSList *list;
libspectrum_byte *ptr = *buffer;
libspectrum_buffer *new_buffer = libspectrum_buffer_alloc();
libspectrum_buffer *block_data = libspectrum_buffer_alloc();
if( creator ) rzx_write_creator( new_buffer, block_data, creator );
if( key ) {
error = rzx_write_signed_start( new_buffer, block_data, key, creator );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_buffer_free( new_buffer );
libspectrum_buffer_free( block_data );
return error;
}
}
for( list = rzx->blocks; list; list = list->next ) {
rzx_block_t *block = list->data;
switch( block->type ) {
case LIBSPECTRUM_RZX_SNAPSHOT_BLOCK:
error = rzx_write_snapshot( new_buffer, block_data,
block->types.snap.snap, snap_format, creator,
compress );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_buffer_free( new_buffer );
libspectrum_buffer_free( block_data );
return error;
}
break;
case LIBSPECTRUM_RZX_INPUT_BLOCK:
/* z80 snapshots can't safely store an intermediate state */
snap_format = LIBSPECTRUM_ID_SNAPSHOT_SZX;
rzx_write_input( &( block->types.input ), new_buffer, block_data,
compress );
break;
case LIBSPECTRUM_RZX_CREATOR_BLOCK:
case LIBSPECTRUM_RZX_SIGN_START_BLOCK:
case LIBSPECTRUM_RZX_SIGN_END_BLOCK:
break;
}
}
if( key ) {
error = rzx_write_signed_end( new_buffer, block_data, key );
if( error != LIBSPECTRUM_ERROR_NONE ) {
libspectrum_buffer_free( new_buffer );
libspectrum_buffer_free( block_data );
return error;
}
}
rzx_write_header( block_data, key ? 1 : 0 );
libspectrum_buffer_append( buffer, length, &ptr, block_data );
libspectrum_buffer_free( block_data );
libspectrum_buffer_append( buffer, length, &ptr, new_buffer );
libspectrum_buffer_free( new_buffer );
return LIBSPECTRUM_ERROR_NONE;
}
static void
rzx_write_header( libspectrum_buffer *buffer, int sign )
{
libspectrum_buffer_write( buffer, rzx_signature, strlen( rzx_signature ) );
libspectrum_buffer_write_byte( buffer, 0 ); /* Major version number */
/* Flags */
#ifdef HAVE_GCRYPT_H
/* Minor version number: 12 if we're not signing, 13 if we are */
libspectrum_buffer_write_byte( buffer, sign ? 13 : 12 ); /* Minor version number */
libspectrum_buffer_write_dword( buffer, sign ? 0x01 : 0x00 );
#else /* #ifdef HAVE_GCRYPT_H */
libspectrum_buffer_write_byte( buffer, 12 ); /* Minor version number */
libspectrum_buffer_write_dword( buffer, 0 );
#endif /* #ifdef HAVE_GCRYPT_H */
}
static void
rzx_write_block_header( libspectrum_buffer *dest, libspectrum_buffer *src,
libspectrum_byte type )
{
size_t block_length = libspectrum_buffer_get_data_size( src ) +
sizeof( libspectrum_dword ) + sizeof( libspectrum_byte );
libspectrum_buffer_write_byte( dest, type );
libspectrum_buffer_write_dword( dest, block_length );
libspectrum_buffer_write_buffer( dest, src );
libspectrum_buffer_clear( src );
}
static void
rzx_write_creator( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_creator *creator )
{
size_t custom_length = libspectrum_creator_custom_length( creator );
libspectrum_buffer_write( block_data, libspectrum_creator_program( creator ),
20 );
libspectrum_buffer_write_word( block_data, libspectrum_creator_major( creator ) );
libspectrum_buffer_write_word( block_data, libspectrum_creator_minor( creator ) );
if( custom_length ) {
libspectrum_buffer_write( block_data,
libspectrum_creator_custom( creator ),
custom_length );
}
rzx_write_block_header( buffer, block_data, LIBSPECTRUM_RZX_CREATOR_BLOCK );
}
static libspectrum_error
rzx_compress( libspectrum_buffer *dest, libspectrum_buffer *src, int *compress )
{
#ifdef HAVE_ZLIB_H
libspectrum_byte *out_data = libspectrum_buffer_get_data( src );
size_t out_length = libspectrum_buffer_get_data_size( src );
libspectrum_byte *compressed_data = NULL;
libspectrum_error error;
#endif
if( !(*compress) ) {
libspectrum_buffer_write_buffer( dest, src );
return LIBSPECTRUM_ERROR_NONE;
}
#ifdef HAVE_ZLIB_H
error = libspectrum_zlib_compress( out_data, out_length, &compressed_data,
&out_length );
if( error != LIBSPECTRUM_ERROR_NONE ||
out_length >= libspectrum_buffer_get_data_size( src ) ) {
*compress = 0;
/* We couldn't compress the data, so just copy the uncompressed data
across instead */
libspectrum_buffer_write_buffer( dest, src );
libspectrum_free( compressed_data );
return LIBSPECTRUM_ERROR_NONE;
}
libspectrum_buffer_write( dest, compressed_data, out_length );
libspectrum_free( compressed_data );
return LIBSPECTRUM_ERROR_NONE;
#else /* #ifdef HAVE_ZLIB_H */
libspectrum_print_error( LIBSPECTRUM_ERROR_UNKNOWN,
"rzx_compress: compression needs zlib" );
return LIBSPECTRUM_ERROR_UNKNOWN;
#endif /* #ifdef HAVE_ZLIB_H */
}
static libspectrum_error
rzx_write_snapshot( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_snap *snap, libspectrum_id_t snap_format,
libspectrum_creator *creator, int compress )
{
libspectrum_error error = LIBSPECTRUM_ERROR_NONE;
int flags, done;
snapshot_string_t *type;
libspectrum_buffer *snap_data = libspectrum_buffer_alloc();
size_t uncompressed_data_size;
if( snap_format == LIBSPECTRUM_ID_UNKNOWN ) {
/* If not given a snap format, try using .z80. If that would result
in major information loss, use .szx instead */
snap_format = LIBSPECTRUM_ID_SNAPSHOT_Z80;
error = libspectrum_snap_write_buffer( block_data, &flags, snap,
snap_format, creator, 0 );
if( error ) { goto cleanup; }
if( flags & LIBSPECTRUM_FLAG_SNAPSHOT_MAJOR_INFO_LOSS ) {
libspectrum_buffer_clear( block_data );
snap_format = LIBSPECTRUM_ID_SNAPSHOT_SZX;
error = libspectrum_snap_write_buffer( block_data, &flags, snap,
snap_format, creator, 0 );
if( error ) { goto cleanup; }
}
} else {
error = libspectrum_snap_write_buffer( block_data, &flags, snap,
snap_format, creator, 0 );
if( error ) { goto cleanup; }
}
if( flags & LIBSPECTRUM_FLAG_SNAPSHOT_MAJOR_INFO_LOSS ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_WARNING,
"%s:rzx_write_snapshot: embedded snapshot has lost a significant amount of information",
__FILE__ );
}
uncompressed_data_size = libspectrum_buffer_get_data_size( block_data );
rzx_compress( snap_data, block_data, &compress );
libspectrum_buffer_clear( block_data );
libspectrum_buffer_write_dword( block_data, compress ? 2 : 0 );
for( type = snapshot_strings, done = 0; type->format; type++ ) {
if( type->format == snap_format ) {
libspectrum_buffer_write( block_data, type->string, 4 );
done = 1;
break;
}
}
if( !done ) {
error = LIBSPECTRUM_ERROR_UNKNOWN;
libspectrum_print_error(
error,
"%s:rzx_write_snapshot: unexpected snap type %d", __FILE__, snap_format
);
goto cleanup;
}
/* Uncompressed snapshot length */
libspectrum_buffer_write_dword( block_data, uncompressed_data_size );
libspectrum_buffer_write_buffer( block_data, snap_data );
rzx_write_block_header( buffer, block_data, LIBSPECTRUM_RZX_SNAPSHOT_BLOCK );
cleanup:
libspectrum_buffer_free( snap_data );
return LIBSPECTRUM_ERROR_NONE;
}
static void
rzx_write_input( input_block_t *block, libspectrum_buffer *buffer,
libspectrum_buffer *block_data, int compress )
{
size_t i;
libspectrum_buffer *frame_data = libspectrum_buffer_alloc();
/* Write the frames */
for( i = 0; i < block->count; i++ ) {
libspectrum_rzx_frame_t *frame = &block->frames[i];
libspectrum_buffer_write_word( block_data, frame->instructions );
if( frame->repeat_last ) {
libspectrum_buffer_write_word( block_data, libspectrum_rzx_repeat_frame );
} else {
libspectrum_buffer_write_word( block_data, frame->count );
libspectrum_buffer_write( block_data, frame->in_bytes, frame->count );
}
}
rzx_compress( frame_data, block_data, &compress );
libspectrum_buffer_clear( block_data );
/* How many frames? */
libspectrum_buffer_write_dword( block_data, block->count );
/* Each frame has an undefined length, so write a zero */
libspectrum_buffer_write_byte( block_data, 0 );
/* T-state counter */
libspectrum_buffer_write_dword( block_data, block->tstates );
/* Flags */
libspectrum_buffer_write_dword( block_data, compress ? 0x02 : 0 );
libspectrum_buffer_write_buffer( block_data, frame_data );
rzx_write_block_header( buffer, block_data, LIBSPECTRUM_RZX_INPUT_BLOCK );
libspectrum_buffer_clear( block_data );
libspectrum_buffer_free( frame_data );
}
static libspectrum_error
rzx_write_signed_start( libspectrum_buffer *buffer,
libspectrum_buffer *block_data,
libspectrum_rzx_dsa_key *key,
libspectrum_creator *creator )
{
#ifdef HAVE_GCRYPT_H
/* Key ID */
if( !key || !key->y || strlen( key->y ) < 8 ) {
libspectrum_print_error( LIBSPECTRUM_ERROR_INVALID,
"rzx_write_signed_start: invalid key" );
return LIBSPECTRUM_ERROR_INVALID;
}
libspectrum_buffer_write_dword(
block_data, strtoul( &key->y[ strlen( key->y ) - 8 ], NULL, 16 )
);
/* Week code */
if( creator ) {
libspectrum_buffer_write_dword( block_data,
libspectrum_creator_competition_code( creator ) );
} else {
libspectrum_buffer_write_dword( block_data, 0 );
}
rzx_write_block_header( buffer, block_data,
LIBSPECTRUM_RZX_SIGN_START_BLOCK );
#endif /* #ifdef HAVE_GCRYPT_H */
return LIBSPECTRUM_ERROR_NONE;
}
static libspectrum_error
rzx_write_signed_end( libspectrum_buffer *buffer, libspectrum_buffer *block_data,
libspectrum_rzx_dsa_key *key )
{
#ifdef HAVE_GCRYPT_H
libspectrum_error error;
libspectrum_byte *signature; size_t sig_length;
/* Get the actual signature */
error = libspectrum_sign_data( &signature, &sig_length,
libspectrum_buffer_get_data( buffer ),
libspectrum_buffer_get_data_size( buffer ),
key );
if( error ) return error;
/* Write the signature */
libspectrum_buffer_write( block_data, signature, sig_length );
libspectrum_free( signature );
rzx_write_block_header( buffer, block_data,
LIBSPECTRUM_RZX_SIGN_END_BLOCK );
#endif /* #ifdef HAVE_GCRYPT_H */
return LIBSPECTRUM_ERROR_NONE;
}
void
libspectrum_rzx_insert_snap( libspectrum_rzx *rzx, libspectrum_snap *snap,
int where )
{
rzx_block_t *block;
block_alloc( &block, LIBSPECTRUM_RZX_SNAPSHOT_BLOCK );
block->types.snap.snap = snap;
block->types.snap.automatic = 0;
rzx->blocks = g_slist_insert( rzx->blocks, block, where );
}
/*
* Iterator functions
*/
libspectrum_rzx_iterator
libspectrum_rzx_iterator_begin( libspectrum_rzx *rzx )
{
return rzx->blocks;
}
libspectrum_rzx_iterator
libspectrum_rzx_iterator_next( libspectrum_rzx_iterator it )
{
return it->next;
}
libspectrum_rzx_iterator
libspectrum_rzx_iterator_last( libspectrum_rzx *rzx )
{
/* This function iterates over the whole list */
return g_slist_last( rzx->blocks );
}
libspectrum_rzx_block_id
libspectrum_rzx_iterator_get_type( libspectrum_rzx_iterator it )
{
rzx_block_t *block = it->data;
return block->type;
}
size_t
libspectrum_rzx_iterator_get_frames( libspectrum_rzx_iterator it )
{
rzx_block_t *block = it->data;
if( block->type != LIBSPECTRUM_RZX_INPUT_BLOCK ) return -1;
return block->types.input.count;
}
void
libspectrum_rzx_iterator_delete( libspectrum_rzx *rzx,
libspectrum_rzx_iterator it )
{
block_free( it->data );
rzx->blocks = g_slist_delete_link( rzx->blocks, it );
}
libspectrum_snap*
libspectrum_rzx_iterator_get_snap( libspectrum_rzx_iterator it )
{
rzx_block_t *block = it->data;
if( block->type != LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ) return NULL;
return block->types.snap.snap;
}
int
libspectrum_rzx_iterator_snap_is_automatic( libspectrum_rzx_iterator it )
{
rzx_block_t *block = it->data;
if( block->type != LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ) return 0;
return block->types.snap.automatic;
}
static libspectrum_error
input_block_merge( input_block_t *input, input_block_t *next_input )
{
libspectrum_error error;
/* Get more space if we need it */
if( input->allocated < input->count + next_input->count ) {
error = input_block_resize( input, input->count + next_input->count );
if( error ) return error;
}
/* Note in_bytes are not duplicated */
memcpy( &( input->frames[input->count] ), next_input->frames,
next_input->count * sizeof( libspectrum_rzx_frame_t ) );
input->non_repeat = input->count + next_input->non_repeat;
input->count += next_input->count;
next_input->count = 0; /* don't free reused in_bytes */
return 0;
}
libspectrum_error
libspectrum_rzx_finalise( libspectrum_rzx *rzx )
{
GSList *list, *item, *next_item;
rzx_block_t *block, *next_block;
libspectrum_error error;
int first_snap = 1;
int finalised = 0;
/* Delete interspersed snapshots */
list = rzx->blocks;
while( list ) {
item = list;
block = list->data;
list = list->next;
if( block->type == LIBSPECTRUM_RZX_SNAPSHOT_BLOCK ) {
if( first_snap ) {
first_snap = 0;
} else {
block_free( block );
rzx->blocks = g_slist_delete_link( rzx->blocks, item );
finalised = 1;
}
}
}
/* Merge adjacent input blocks */
list = rzx->blocks;
while( list ) {
block = list->data;
if( block->type == LIBSPECTRUM_RZX_INPUT_BLOCK ) {
next_item = list->next;
if( !next_item ) break;
next_block = next_item->data;
if( next_block->type == LIBSPECTRUM_RZX_INPUT_BLOCK ) {
error = input_block_merge( &( block->types.input ),
&( next_block->types.input ) );
if( error ) return error;
block_free( next_block );
rzx->blocks = g_slist_delete_link( rzx->blocks, next_item );
finalised = 1;
} else {
list = list->next;
}
} else {
list = list->next;
}
}
return finalised? LIBSPECTRUM_ERROR_NONE : LIBSPECTRUM_ERROR_INVALID;
}
Reference in New Issue View Git Blame Copy Permalink