static void
tzx_write_pause( libspectrum_tape_block *block, libspectrum_byte **buffer,
libspectrum_byte **ptr, size_t *length )
{
libspectrum_make_room( buffer, 3, ptr, length );
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_PAUSE;
libspectrum_write_word( ptr, libspectrum_tape_block_pause( block ) );
}
static libspectrum_error
tzx_write_generalised_data( libspectrum_tape_block *block,
libspectrum_byte **buffer, libspectrum_byte **ptr,
size_t *length )
{
size_t data_length, bits_per_symbol;
libspectrum_error error;
libspectrum_tape_generalised_data_symbol_table *pilot_table, *data_table;
libspectrum_dword pilot_symbol_count, data_symbol_count, i;
data_length = generalised_data_length( block );
libspectrum_make_room( buffer, 5 + data_length, ptr, length );
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA;
libspectrum_write_dword( ptr, data_length );
libspectrum_write_word( ptr, libspectrum_tape_block_pause( block ) );
pilot_table = libspectrum_tape_block_pilot_table( block );
data_table = libspectrum_tape_block_data_table( block );
error = serialise_generalised_data_table( ptr, pilot_table );
if( error != LIBSPECTRUM_ERROR_NONE ) return error;
error = serialise_generalised_data_table( ptr, data_table );
if( error != LIBSPECTRUM_ERROR_NONE ) return error;
serialise_generalised_data_symbols( ptr, pilot_table );
pilot_symbol_count = libspectrum_tape_generalised_data_symbol_table_symbols_in_block( pilot_table );
for( i = 0; i < pilot_symbol_count; i++ ) {
*(*ptr)++ = libspectrum_tape_block_pilot_symbols( block, i );
libspectrum_write_word( ptr, libspectrum_tape_block_pilot_repeats( block, i ) );
}
serialise_generalised_data_symbols( ptr, data_table );
bits_per_symbol = libspectrum_tape_block_bits_per_data_symbol( block );
data_symbol_count = libspectrum_tape_generalised_data_symbol_table_symbols_in_block( data_table );
data_length = ( ( bits_per_symbol * data_symbol_count ) + 7 ) / 8;
memcpy( *ptr, libspectrum_tape_block_data( block ), data_length );
(*ptr) += data_length;
return LIBSPECTRUM_ERROR_NONE;
}
static void
tzx_write_rom( libspectrum_tape_block *block, libspectrum_byte **buffer,
libspectrum_byte **ptr, size_t *length )
{
/* Make room for the ID byte, the pause, the length and the actual data */
libspectrum_make_room( buffer, 5 + libspectrum_tape_block_data_length( block ), ptr, length);
/* Write the ID byte and the pause */
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_ROM;
libspectrum_write_word( ptr, libspectrum_tape_block_pause( block ) );
/* Copy the data across */
tzx_write_bytes( ptr, libspectrum_tape_block_data_length( block ), 2,
libspectrum_tape_block_data( block ) );
}
static void
tzx_write_message( libspectrum_tape_block *block, libspectrum_byte **buffer,
libspectrum_byte **ptr, size_t *length )
{
char *message; size_t text_length;
message = libspectrum_tape_block_text( block );
text_length = strlen( (char*)message );
/* Make room for the ID byte, the time byte, length byte and the text */
libspectrum_make_room( buffer, 3 + text_length, ptr, length );
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_MESSAGE;
*(*ptr)++ = libspectrum_tape_block_pause( block );
tzx_write_string( ptr, message );
}
static void
tzx_write_raw_data( libspectrum_tape_block *block, libspectrum_byte **buffer,
libspectrum_byte **ptr, size_t *length )
{
size_t data_length;
/* Make room for the ID byte, the metadata and the actual data */
data_length = libspectrum_tape_block_data_length( block );
libspectrum_make_room( buffer, 8 + data_length, ptr, length );
/* Write the ID byte and the metadata */
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_RAW_DATA;
libspectrum_write_word( ptr, libspectrum_tape_block_bit_length( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_pause( block ) );
*(*ptr)++ = libspectrum_tape_block_bits_in_last_byte( block );
tzx_write_bytes( ptr, data_length, 3, libspectrum_tape_block_data( block ) );
}
static void
tzx_write_turbo( libspectrum_tape_block *block, libspectrum_byte **buffer,
libspectrum_byte **ptr, size_t *length )
{
/* Make room for the ID byte, the metadata and the actual data */
libspectrum_make_room( buffer, 19 + libspectrum_tape_block_data_length( block ), ptr, length);
/* Write the ID byte and the metadata */
*(*ptr)++ = LIBSPECTRUM_TAPE_BLOCK_TURBO;
libspectrum_write_word( ptr, libspectrum_tape_block_pilot_length( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_sync1_length( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_sync2_length( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_bit0_length ( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_bit1_length ( block ) );
libspectrum_write_word( ptr, libspectrum_tape_block_pilot_pulses( block ) );
*(*ptr)++ = libspectrum_tape_block_bits_in_last_byte( block );
libspectrum_write_word( ptr, libspectrum_tape_block_pause ( block ) );
tzx_write_bytes( ptr, libspectrum_tape_block_data_length( block ), 3,
libspectrum_tape_block_data( block ) );
}
// Return a string describing a give tape block
const char *Tape::GetBlockDetails (libspectrum_tape_block *block)
{
static char sz[128];
sz[0] = '\0';
char szExtra[64] = "";
char szName[11] = "";
const char *psz = NULL;
libspectrum_byte *data = libspectrum_tape_block_data(block);
long length = static_cast<long>(libspectrum_tape_block_data_length(block));
// Is there enough data to include a possible filename?
if (length >= 12)
{
for (int i = 0 ; i < 10 ; i++)
{
char ch = data[i+2];
szName[i] = (ch >= ' ' && ch <= 0x7f) ? ch : '?';
}
szName[10] = '\0';
}
// Spectrum header length and type byte?
if (length == 17+2 && data[0] == 0x00)
{
// Examine Spectrum file type
switch (data[1])
{
case 0:
{
psz = "ZX BASIC";
UINT uLine = (data[15] << 8) | data[14];
if (uLine != 0xffff)
sprintf(szExtra, " LINE %u", uLine);
break;
}
case 1: psz = "ZX DATA()"; break;
case 2: psz = "ZX DATA$()"; break;
case 3:
{
psz = "ZX CODE";
UINT uAddr = (data[15] << 8) | data[14];
UINT uLen = (data[13] << 8) | data[12];
sprintf(szExtra, " %u,%u", uAddr, uLen);
break;
}
}
}
// SAM header length and type byte?
// Real length is 82, but TZX spec suggests there could be up to 7-8 trailing bits, so accept 83
else if ((length == 80+2 || length == 80+1+2) && data[0] == 0x01)
{
// Examine SAM file type
switch (data[1])
{
case 16:
{
psz = "BASIC";
UINT uLine = (data[40] << 8) | data[39];
if (data[38] == 0)
sprintf(szExtra, " LINE %u", uLine);
break;
}
case 17: psz = "DATA()"; break;
case 18: psz = "DATA$"; break;
case 19:
{
psz = "CODE";
UINT uAddr = TPeek(data+32) + 16384;
UINT uLen = TPeek(data+35);
sprintf(szExtra, " %u,%u", uAddr, uLen);
if (data[38] == 0)
sprintf(szExtra+strlen(szExtra), ",%u", TPeek(data+38));
break;
}
case 20:
{
psz = "SCREEN$";
UINT uMode = data[17]+1;
sprintf(szExtra, " MODE %u", uMode);
break;
}
}
}
// Do we have a type string?
if (psz)
{
// Start with type and append filename
strcpy(sz, psz);
strcat(sz, ": '");
strcat(sz, szName);
strcat(sz, "'");
// Append any additional type-specific details
if (szExtra[0])
{
strcat(sz, " ");
strcat(sz, szExtra);
}
}
// No details yet?
if (!sz[0])
{
libspectrum_tape_type type = libspectrum_tape_block_type(block);
switch (type)
{
case LIBSPECTRUM_TAPE_BLOCK_ROM:
case LIBSPECTRUM_TAPE_BLOCK_TURBO:
{
// Raw tape block data length
size_t length = libspectrum_tape_block_data_length(block);
// If possible, exclude the type, sync, and checksum bytes from the length
if (length >= 3)
length -= 3;
snprintf(sz, sizeof(sz), "%u bytes", length);
break;
}
case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA:
case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA:
snprintf(sz, sizeof(sz), "%u bytes", libspectrum_tape_block_data_length(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE:
snprintf(sz, sizeof(sz), "%u tstates", libspectrum_tape_block_pulse_length(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_PULSES:
snprintf(sz, sizeof(sz), "%u pulses", libspectrum_tape_block_count(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_PAUSE:
snprintf(sz, sizeof(sz), "%ums", libspectrum_tape_block_pause(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_GROUP_START:
case LIBSPECTRUM_TAPE_BLOCK_COMMENT:
case LIBSPECTRUM_TAPE_BLOCK_MESSAGE:
case LIBSPECTRUM_TAPE_BLOCK_CUSTOM:
snprintf(sz, sizeof(sz), "%s", libspectrum_tape_block_text(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_JUMP:
{
int offset = libspectrum_tape_block_offset(block);
if (offset >= 0)
snprintf(sz, sizeof(sz), "Forward %d blocks", offset);
else
snprintf(sz, sizeof(sz), "Backward %d blocks", -offset);
break;
}
case LIBSPECTRUM_TAPE_BLOCK_LOOP_START:
snprintf(sz, sizeof(sz), "%u iterations", libspectrum_tape_block_count(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_SELECT:
snprintf(sz, sizeof(sz), "%u options", libspectrum_tape_block_count(block));
break;
case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA:
snprintf(sz, sizeof(sz), "%u data symbols",
libspectrum_tape_generalised_data_symbol_table_symbols_in_block(libspectrum_tape_block_data_table(block)));
break;
case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO:
{
size_t count = libspectrum_tape_block_count(block);
for (size_t i = 0 ; i < count ; i++)
{
int id = libspectrum_tape_block_ids(block, i);
const char *value = libspectrum_tape_block_texts(block, i);
// Full title TZX id?
if (id == 0x00)
strncpy(sz, value, sizeof(sz)-1);
}
break;
}
case LIBSPECTRUM_TAPE_BLOCK_HARDWARE:
{
size_t count = libspectrum_tape_block_count(block);
for (size_t i = 0 ; i < count ; i++)
{
int type = libspectrum_tape_block_types(block, i);
int id = libspectrum_tape_block_ids(block, i);
// Skip anything but the TZX "Computers" type
if (type != 0)
continue;
// Check for relevant computer ids
if (id == 9)
strcpy(sz, "SAM Coupe");
else if ((id >= 0x00 && id <= 0x05) || id == 0x0e)
strcpy(sz, "ZX Spectrum");
else if (id == 0x08)
strcpy(sz, "Pentagon");
else if (id == 0x06 || id == 0x07)
strcpy(sz, "Timex Sinclair");
else
snprintf(sz, sizeof(sz), "Unknown (%02X)", id);
}
break;
}
default:
break;
}
}
return sz;
}
int
tape_block_details( char *buffer, size_t length,
libspectrum_tape_block *block )
{
libspectrum_byte *data;
const char *type; unsigned char name[11];
int offset;
size_t i;
unsigned long total_pulses;
buffer[0] = '\0';
switch( libspectrum_tape_block_type( block ) ) {
case LIBSPECTRUM_TAPE_BLOCK_ROM:
case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK:
/* See if this looks like a standard Spectrum header and if so
display some extra data */
if( libspectrum_tape_block_data_length( block ) != 19 ) goto normal;
data = libspectrum_tape_block_data( block );
/* Flag byte is 0x00 for headers */
if( data[0] != 0x00 ) goto normal;
switch( data[1] ) {
case 0x00: type = "Program"; break;
case 0x01: type = "Number array"; break;
case 0x02: type = "Character array"; break;
case 0x03: type = "Bytes"; break;
default: goto normal;
}
make_name( name, &data[2] );
snprintf( buffer, length, "%s: \"%s\"", type, name );
break;
normal:
snprintf( buffer, length, "%lu bytes",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_TURBO:
case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA:
case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA:
snprintf( buffer, length, "%lu bytes",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE:
snprintf( buffer, length, "%lu tstates",
(unsigned long)libspectrum_tape_block_pulse_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PULSES:
snprintf( buffer, length, "%lu pulses",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PULSE_SEQUENCE:
total_pulses = 0;
for( i=0; i < libspectrum_tape_block_count( block ); i++ )
total_pulses += libspectrum_tape_block_pulse_repeats( block, i );
snprintf( buffer, length, "%lu pulses", total_pulses );
break;
case LIBSPECTRUM_TAPE_BLOCK_PAUSE:
snprintf( buffer, length, "%lu ms",
(unsigned long)libspectrum_tape_block_pause( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_GROUP_START:
case LIBSPECTRUM_TAPE_BLOCK_COMMENT:
case LIBSPECTRUM_TAPE_BLOCK_MESSAGE:
case LIBSPECTRUM_TAPE_BLOCK_CUSTOM:
snprintf( buffer, length, "%s", libspectrum_tape_block_text( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_JUMP:
offset = libspectrum_tape_block_offset( block );
if( offset > 0 ) {
snprintf( buffer, length, "Forward %d blocks", offset );
} else {
snprintf( buffer, length, "Backward %d blocks", -offset );
}
break;
case LIBSPECTRUM_TAPE_BLOCK_LOOP_START:
snprintf( buffer, length, "%lu iterations",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_SELECT:
snprintf( buffer, length, "%lu options",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA:
snprintf( buffer, length, "%lu data symbols",
(unsigned long)libspectrum_tape_generalised_data_symbol_table_symbols_in_block( libspectrum_tape_block_data_table( block ) ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE:
/* Could do something better with this one */
break;
case LIBSPECTRUM_TAPE_BLOCK_GROUP_END:
case LIBSPECTRUM_TAPE_BLOCK_LOOP_END:
case LIBSPECTRUM_TAPE_BLOCK_STOP48:
case LIBSPECTRUM_TAPE_BLOCK_SET_SIGNAL_LEVEL:
case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO:
case LIBSPECTRUM_TAPE_BLOCK_HARDWARE:
case LIBSPECTRUM_TAPE_BLOCK_CONCAT:
break;
}
return 0;
}
int
tape_block_details( char *buffer, size_t length,
libspectrum_tape_block *block )
{
libspectrum_byte *data;
const char *type; unsigned char name[11];
int offset;
buffer[0] = '\0';
switch( libspectrum_tape_block_type( block ) ) {
case LIBSPECTRUM_TAPE_BLOCK_ROM:
/* See if this looks like a standard Spectrum header and if so
display some extra data */
if( libspectrum_tape_block_data_length( block ) != 19 ) goto normal;
data = libspectrum_tape_block_data( block );
/* Flag byte is 0x00 for headers */
if( data[0] != 0x00 ) goto normal;
switch( data[1] ) {
case 0x00: type = "Program"; break;
case 0x01: type = "Number array"; break;
case 0x02: type = "Character array"; break;
case 0x03: type = "Bytes"; break;
default: goto normal;
}
make_name( name, &data[2] );
snprintf( buffer, length, "%s: \"%s\"", type, name );
break;
normal:
snprintf( buffer, length, "Data (%lu Bytes)",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_TURBO:
snprintf( buffer, length, "Turbo Data (%lu Bytes)",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA:
snprintf( buffer, length, "Pure Data (%lu Bytes)",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA:
snprintf( buffer, length, "Raw Data (%lu Bytes)",
(unsigned long)libspectrum_tape_block_data_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE:
snprintf( buffer, length, "Pure Tone (%lu tstates)",
(unsigned long)libspectrum_tape_block_pulse_length( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PULSES:
snprintf( buffer, length, "Sequence Of %lu Pulses",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_PAUSE:
if((unsigned long)libspectrum_tape_block_pause( block )==0)
snprintf( buffer, length, "[Stop The Tape]");
else
snprintf( buffer, length, "[Pause - %lu ms]",(unsigned long)libspectrum_tape_block_pause( block ));
break;
case LIBSPECTRUM_TAPE_BLOCK_GROUP_START:
case LIBSPECTRUM_TAPE_BLOCK_COMMENT:
case LIBSPECTRUM_TAPE_BLOCK_MESSAGE:
case LIBSPECTRUM_TAPE_BLOCK_CUSTOM:
snprintf( buffer, length, "[%s]", libspectrum_tape_block_text( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_JUMP:
offset = libspectrum_tape_block_offset( block );
if( offset > 0 ) {
snprintf( buffer, length, "[Forward %d Blocks]", offset );
} else {
snprintf( buffer, length, "[Backward %d Blocks]", -offset );
}
break;
case LIBSPECTRUM_TAPE_BLOCK_LOOP_START:
snprintf( buffer, length, "[Loop %lu Times]",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_SELECT:
snprintf( buffer, length, "[Select %lu Options]",
(unsigned long)libspectrum_tape_block_count( block ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA:
snprintf( buffer, length, "[Generalised Data - %lu Data Symbols]",
(unsigned long)libspectrum_tape_generalised_data_symbol_table_symbols_in_block( (void*)libspectrum_tape_block_data_table( block ) ) );
break;
case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE:
/* Could do something better with this one */
break;
case LIBSPECTRUM_TAPE_BLOCK_GROUP_END:
snprintf( buffer, length, "[Group End]");
break;
case LIBSPECTRUM_TAPE_BLOCK_LOOP_END:
snprintf( buffer, length, "[Loop End]");
break;
case LIBSPECTRUM_TAPE_BLOCK_STOP48:
snprintf( buffer, length, "[Stop The Tape If 48]");
break;
case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO:
snprintf( buffer, length, "[Archive Info]");
break;
case LIBSPECTRUM_TAPE_BLOCK_HARDWARE:
snprintf( buffer, length, "[Hardware]");
break;
case LIBSPECTRUM_TAPE_BLOCK_CONCAT:
snprintf( buffer, length, "[Concat]");
break;
}
return 0;
}
int
main(int argc, char *argv[])
{
int opt, i, quiet = 0;
char *output = "output.tzx", *p;
int turbo_params[6] = { 2168, 3323, 667, 735, 855, 1710 };
FILE *fd;
size_t data_len;
libspectrum_tape *tape;
libspectrum_byte *data;
libspectrum_tape_block *block;
libspectrum_dword pause, pause_tstates;
while ((opt = getopt(argc, argv, "vhqt:o:")) != -1)
{
switch(opt)
{
case 'q':
quiet = 1;
break;
case 't':
if (sscanf(optarg, "%i:%i:%i:%i:%i:%i", &turbo_params[0],
&turbo_params[1], &turbo_params[2], &turbo_params[3],
&turbo_params[4], &turbo_params[5]) != 6)
fatal(argv[0], "Failed to parse turbo params");
break;
case 'o':
output = strdup(optarg);
break;
case 'h':
help(argv[0]);
exit(0);
case 'v':
fprintf(stderr, VERSION "\n");
exit(0);
default:
fprintf(stderr, "\n");
help(argv[0]);
exit(1);
}
}
if (optind >= argc)
fatal(argv[0], "Expected input filename to process");
if (libspectrum_init())
fatal(argv[0], "Failed to init libspectrum");
fd = fopen(argv[optind], "rb");
if (!fd)
fatal(argv[0], "Failed to open input file");
fseek(fd, 0, SEEK_END);
data_len = ftell(fd);
fseek(fd, 0, SEEK_SET);
data = (libspectrum_byte *) malloc(data_len);
if (!data)
{
fclose(fd);
fatal(argv[0], "Failed to allocate memory");
}
if (fread(data, sizeof(libspectrum_byte), data_len, fd) != data_len)
{
fclose(fd);
free(data);
fatal(argv[0], "Failed to read input file");
}
fclose(fd);
tape = libspectrum_tape_alloc();
if (!tape)
{
fclose(fd);
free(data);
fatal(argv[0], "Failed to allocate tape memory");
}
if (libspectrum_tape_read(tape, data, data_len, LIBSPECTRUM_ID_UNKNOWN, argv[optind]))
{
fclose(fd);
free(data);
free(tape);
fatal(argv[0], "Failed to read tape");
}
free(data);
for (i = optind + 1; i < argc; i++)
{
for (p = argv[i]; *p && isdigit(*p); p++);
if (*p)
{
fprintf(stderr, "WARNING: Parameter is not a valid block number, skipping\n");
continue;
}
if (libspectrum_tape_nth_block(tape, atoi(argv[i])))
continue;
block = libspectrum_tape_current_block(tape);
if (!block)
continue;
if (!quiet)
printf("%s: Setting block #%i (type 0x%02x): ", argv[0], atoi(argv[i]),
libspectrum_tape_block_type(block));
data = libspectrum_tape_block_data(block);
data_len = libspectrum_tape_block_data_length(block);
pause = libspectrum_tape_block_pause(block);
pause_tstates = libspectrum_tape_block_pause_tstates(block);
if (libspectrum_tape_block_set_type(block, LIBSPECTRUM_TAPE_BLOCK_TURBO)
|| libspectrum_tape_block_set_pilot_pulses(block, turbo_params[1])
|| libspectrum_tape_block_set_pilot_length(block, turbo_params[0])
|| libspectrum_tape_block_set_sync1_length(block, turbo_params[2])
|| libspectrum_tape_block_set_sync2_length(block, turbo_params[3])
|| libspectrum_tape_block_set_bit0_length(block, turbo_params[4])
|| libspectrum_tape_block_set_bit1_length(block, turbo_params[5])
|| libspectrum_tape_block_set_data(block, data)
|| libspectrum_tape_block_set_data_length(block, data_len)
|| libspectrum_tape_block_set_pause(block, pause)
|| libspectrum_tape_block_set_pause_tstates(block, pause_tstates)
|| libspectrum_tape_block_set_bits_in_last_byte(block, 8)
)
{
if (!quiet)
printf("failed!\n");
fprintf(stderr, "WARNING: Failed to set block %i\n", atoi(argv[i]));
continue;
}
if (!quiet)
printf("OK\n");
}
data = NULL;
data_len = 0;
if (libspectrum_tape_write(&data, &data_len, tape, LIBSPECTRUM_ID_TAPE_TZX))
{
free(tape);
fatal(argv[0], "Failed to write the output file");
}
fd = fopen(output, "wb");
if (!fd)
{
free(data);
free(tape);
fatal(argv[0], "Failed to open output file");
}
if (fwrite(data, sizeof(libspectrum_byte), data_len, fd) != data_len)
{
fclose(fd);
free(data);
free(tape);
fatal(argv[0], "Failed to write output file");
}
fclose(fd);
free(data);
free(tape);
exit(0);
}
