static int
tape_play( int autoplay )
{
if( !libspectrum_tape_present( tape ) ) return 1;
/* Otherwise, start the tape going */
tape_playing = 1;
tape_autoplay = autoplay;
tape_microphone = 0;
event_remove_type( tape_mic_off_event );
/* Update the status bar */
ui_statusbar_update( UI_STATUSBAR_ITEM_TAPE, UI_STATUSBAR_STATE_ACTIVE );
/* If we're fastloading, turn sound off */
if( settings_current.fastload ) sound_pause();
loader_tape_play();
event_add( tstates + next_tape_edge_tstates, tape_edge_event );
next_tape_edge_tstates = 0;
debugger_event( play_event );
return 0;
}
/* Rewind to block 0, if any */
int
tape_rewind( void )
{
if( !libspectrum_tape_present( tape ) ) return 0;
return tape_select_block( 0 );
}
int
tape_read_buffer( unsigned char *buffer, size_t length, libspectrum_id_t type,
const char *filename, int autoload )
{
int error;
if( libspectrum_tape_present( tape ) ) {
error = tape_close(); if( error ) return error;
}
error = libspectrum_tape_read( tape, buffer, length, type, filename );
if( error ) return error;
//ui_tape_browser_update( UI_TAPE_BROWSER_NEW_TAPE, NULL );
/*
if( autoload ) {
error = tape_autoload( machine_current->machine );
if( error ) return error;
}
*/
return 0;
}
/* Which block is current? */
int
tape_get_current_block( void )
{
int n;
libspectrum_error error;
if( !libspectrum_tape_present( tape ) ) return -1;
error = libspectrum_tape_position( &n, tape );
if( error ) return -1;
return n;
}
static int
tape_play( int autoplay )
{
libspectrum_tape_block* block;
int error;
if( !libspectrum_tape_present( tape ) ) return 1;
ZX_Unpatch_ROM();//unpatch rom so some protection loader schemes works
tape_playing = 1;
//tape_autoplay = autoplay;
tape_microphone = 0;
/* Update the status bar */
//ui_statusbar_update( UI_STATUSBAR_ITEM_TAPE, UI_STATUSBAR_STATE_ACTIVE );
//if( ( !( machine_current->timex ) ) && settings_current.sound_load )
//sound_beeper( 1, tape_microphone );
//loader_tape_play();
//el edge lo cojera directamente el Z80patch
int edge_tstates;
int flag;
error = tape_next_edge( NULL, &edge_tstates,&flag);
tape_edge_tstates_target = edge_tstates;
tape_edge_tstates_current=0;
if( error ) return error;
return 0;
}
int
tape_present( void )
{
return libspectrum_tape_present( tape );
}
/* Load the next tape block into memory; returns 0 if a block was
loaded (even if it had an tape loading error or equivalent) or
non-zero if there was an error at the emulator level, or tape traps
are not active */
int tape_load_trap( void )
{
libspectrum_tape_block *block, *next_block;
int error;
/* Do nothing if tape traps aren't active, or the tape is already playing */
if( !settings_current.tape_traps || tape_playing ) return 2;
/* Do nothing if we're not in the correct ROM */
if( !trap_check_rom( CHECK_TAPE_ROM ) ) return 3;
/* Return with error if no tape file loaded */
if( !libspectrum_tape_present( tape ) ) return 1;
block = libspectrum_tape_current_block( tape );
/* Skip over any meta-data blocks */
while( libspectrum_tape_block_metadata( block ) ) {
block = libspectrum_tape_select_next_block( tape );
if( !block ) return 1;
}
/* If this block isn't a ROM loader, start the block playing. After
that, return with `error' so that we actually do whichever
instruction it was that caused the trap to hit */
if( libspectrum_tape_block_type( block ) != LIBSPECTRUM_TAPE_BLOCK_ROM ||
libspectrum_tape_state( tape ) != LIBSPECTRUM_TAPE_STATE_PILOT ) {
tape_play( 1 );
return -1;
}
/* We don't properly handle the case of partial loading, so don't run
the traps in that situation */
if( libspectrum_tape_block_data_length( block ) != DE + 2 ) {
tape_play( 1 );
return -1;
}
/* All returns made via the RET at #05E2, except on Timex 2068 at #0136 */
if ( machine_current->machine == LIBSPECTRUM_MACHINE_TC2068 ||
machine_current->machine == LIBSPECTRUM_MACHINE_TS2068 ) {
PC = 0x0136;
} else {
PC = 0x05e2;
}
error = trap_load_block( block );
if( error ) return error;
/* Peek at the next block. If it's a ROM block, move along, initialise
the block, and return */
next_block = libspectrum_tape_peek_next_block( tape );
if( libspectrum_tape_block_type(next_block) == LIBSPECTRUM_TAPE_BLOCK_ROM ) {
next_block = libspectrum_tape_select_next_block( tape );
if( !next_block ) return 1;
ui_tape_browser_update( UI_TAPE_BROWSER_SELECT_BLOCK, NULL );
return 0;
}
/* If the next block isn't a ROM block, set ourselves up such that the
next thing to occur is the pause at the end of the current block */
libspectrum_tape_set_state( tape, LIBSPECTRUM_TAPE_STATE_PAUSE );
return 0;
}
/* Load the next tape block into memory; returns 0 if a block was
loaded (even if it had an tape loading error or equivalent) or
non-zero if there was an error at the emulator level, or tape traps
are not active */
int tape_load_trap(Z80Regs * regs)
{
libspectrum_tape_block *block, *next_block;
int error;
/* Do nothing if tape traps aren't active, or the tape is already playing */
if( !mconfig.flash_loading || tape_playing ) return 1;
/* Do nothing if we're not in the correct ROM */
//if( ! trap_check_rom() ) return 3;
/* Return with error if no tape file loaded */
if( !libspectrum_tape_present( tape ) ) return 1;
block = libspectrum_tape_current_block( tape );
/* Skip over any meta-data blocks */
while( libspectrum_tape_block_metadata( block ) ) {
block = libspectrum_tape_select_next_block( tape );
if( !block ) return 1;
}
/* If this block isn't a ROM loader, start the block playing. After
that, return with `error' so that we actually do whichever
instruction it was that caused the trap to hit */
if( libspectrum_tape_block_type( block ) != LIBSPECTRUM_TAPE_BLOCK_ROM
|| libspectrum_tape_state( tape ) != LIBSPECTRUM_TAPE_STATE_PILOT
) {
tape_play( 1 );
return /*-1*/1;
}
/* We don't properly handle the case of partial loading, so don't run
the traps in that situation *///Esto hace cascar algunos games
/*
if( libspectrum_tape_block_data_length( block ) != regs->DE.W + 2 ) {
tape_play( 1 );
return 1;
}
*/
error = trap_load_block( block , regs);//carga el bloque
if( error ) return -1;
/* Peek at the next block. If it's a ROM block, move along, initialise
the block, and return */
next_block = libspectrum_tape_peek_next_block( tape );
if( libspectrum_tape_block_type(next_block) == LIBSPECTRUM_TAPE_BLOCK_ROM ) {
next_block = libspectrum_tape_select_next_block( tape );
if( !next_block ) return 1;
//ui_tape_browser_update( UI_TAPE_BROWSER_SELECT_BLOCK, NULL );
return 0;//FLASHLOADED!
}
/* If the next block isn't a ROM block, set ourselves up such that the
next thing to occur is the pause at the end of the current block */
libspectrum_tape_set_state( tape, LIBSPECTRUM_TAPE_STATE_PAUSE );//TODO ? autodetect, sino no tira?
//libspectrum_tape_block_set_state( block, LIBSPECTRUM_TAPE_STATE_PAUSE );
/*
error = tape_play(1);
if( error ) return -1;
*/
return 0;
}
/* Given a tape file, attempt to guess which sort of hardware it should run
on by looking for a hardware block (0x33).
Deliberately not mentioned in libspectrum.h(.in) as I'm really not
sure this function is actually useful.
*/
libspectrum_error
libspectrum_tape_guess_hardware( libspectrum_machine *machine,
const libspectrum_tape *tape )
{
GSList *ptr; int score, current_score; size_t i;
*machine = LIBSPECTRUM_MACHINE_UNKNOWN; current_score = 0;
if( !libspectrum_tape_present( tape ) ) return LIBSPECTRUM_ERROR_NONE;
for( ptr = tape->blocks; ptr; ptr = ptr->next ) {
libspectrum_tape_block *block = (libspectrum_tape_block*)ptr->data;
libspectrum_tape_hardware_block *hardware;
if( block->type != LIBSPECTRUM_TAPE_BLOCK_HARDWARE ) continue;
hardware = &( block->types.hardware );
for( i=0; i<hardware->count; i++ ) {
/* Only interested in which computer types this tape runs on */
if( hardware->types[i] != 0 ) continue;
/* Skip if the tape doesn't run on this hardware */
if( hardware->values[i] == 3 ) continue;
/* If the tape uses the special hardware, choose that preferentially.
If it doesn't (or is unknown), it's a possibility */
if( hardware->values[i] == 1 ) { score = 2; } else { score = 1; }
if( score <= current_score ) continue;
switch( hardware->ids[i] ) {
case 0: /* 16K Spectrum */
*machine = LIBSPECTRUM_MACHINE_16; current_score = score;
break;
case 1: /* 48K Spectrum */
case 2: /* 48K Issue 1 Spectrum */
*machine = LIBSPECTRUM_MACHINE_48; current_score = score;
break;
case 3: /* 128K Spectrum */
*machine = LIBSPECTRUM_MACHINE_128; current_score = score;
break;
case 4: /* +2 */
*machine = LIBSPECTRUM_MACHINE_PLUS2; current_score = score;
break;
case 5: /* +2A and +3. Gee, thanks to whoever designed the TZX format
for distinguishing those :-( */
*machine = LIBSPECTRUM_MACHINE_PLUS3; current_score = score;
break;
case 6: /* TC2048 */
*machine = LIBSPECTRUM_MACHINE_TC2048; current_score = score;
break;
}
}
}
return LIBSPECTRUM_ERROR_NONE;
}
