tzx_write.c

/* tzx_write.c: Routines for writing .tzx files
   Copyright (c) 2001-2007 Philip Kendall, Fredrick Meunier

   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 <stdio.h>
#include <string.h>

#include "tape_block.h"
#include "internals.h"


typedef struct {
    short bits_used; // The bits used in the current byte in progress
    short level; // The last level output to this block
    libspectrum_byte *tape_buffer; // The buffer we are writing into
    size_t tape_length; // size of the buffer allocated so far
    size_t length; // size of the buffer used so far
} rle_write_state;

static rle_write_state rle_state;


/*** Local function prototypes ***/


static void tzx_write_rom(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_turbo(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void add_pure_tone_block(libspectrum_buffer *buffer, libspectrum_dword pulse_length, size_t count);
static void tzx_write_pure_tone(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_data(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_raw_data(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static libspectrum_error tzx_write_generalised_data(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_pulses(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_pause(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_group_start(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_jump(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_loop_start(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_select(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_stop(libspectrum_buffer *buffer);
static void add_set_signal_level_block(libspectrum_buffer *buffer, int level);
static void tzx_write_set_signal_level(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_comment(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_message(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_archive_info(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_hardware(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static void tzx_write_custom(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static libspectrum_error tzx_write_rle(libspectrum_tape_block *block,
                                       libspectrum_buffer *buffer,
                                       libspectrum_tape *tape,
                                       libspectrum_tape_iterator iterator);
static void add_pulses_block(size_t pulse_count,
                             libspectrum_dword *lengths,
                             libspectrum_tape_block *block,
                             libspectrum_buffer *buffer);
static void tzx_write_pulse_sequence(libspectrum_tape_block *block, libspectrum_buffer *buffer);
static libspectrum_error tzx_write_data_block(libspectrum_tape_block *block, libspectrum_buffer *buffer);

static void tzx_write_empty_block(libspectrum_buffer *buffer, libspectrum_tape_type id);

static void tzx_write_bytes(libspectrum_buffer *buffer, size_t length, size_t length_bytes, libspectrum_byte *data);
static void tzx_write_string(libspectrum_buffer *buffer, char *string);

/*** Function definitions ***/

// The main write function


libspectrum_error internal_tzx_write(libspectrum_buffer *buffer, libspectrum_tape *tape)
{
    libspectrum_error error;
    libspectrum_tape_iterator iterator;
    libspectrum_tape_block *block;

    size_t signature_length = strlen(libspectrum_tzx_signature);

    // First, write the .tzx signature and the version numbers
    libspectrum_buffer_write(buffer, libspectrum_tzx_signature, signature_length);

    libspectrum_buffer_write_byte(buffer, 1); // Major version number
    libspectrum_buffer_write_byte(buffer, 20); // Minor version number

    for (block = libspectrum_tape_iterator_init(&iterator, tape);
         block;
         block = libspectrum_tape_iterator_next(&iterator)) {
        switch (libspectrum_tape_block_type(block)) {

            case LIBSPECTRUM_TAPE_BLOCK_ROM:
                tzx_write_rom(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_TURBO:
                tzx_write_turbo(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE:
                tzx_write_pure_tone(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_PULSES:
                tzx_write_pulses(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA:
                tzx_write_data(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_RAW_DATA:
                tzx_write_raw_data(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA:
                error = tzx_write_generalised_data(block, buffer);
                if (error != LIBSPECTRUM_ERROR_NONE) {
                    return error;
                }
                break;

            case LIBSPECTRUM_TAPE_BLOCK_PAUSE:
                tzx_write_pause(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_GROUP_START:
                tzx_write_group_start(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_GROUP_END:
                tzx_write_empty_block(buffer, libspectrum_tape_block_type(block));
                break;
            case LIBSPECTRUM_TAPE_BLOCK_JUMP:
                tzx_write_jump(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_LOOP_START:
                tzx_write_loop_start(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_LOOP_END:
                tzx_write_empty_block(buffer, libspectrum_tape_block_type(block));
                break;

            case LIBSPECTRUM_TAPE_BLOCK_SELECT:
                tzx_write_select(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_STOP48:
                tzx_write_stop(buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_SET_SIGNAL_LEVEL:
                tzx_write_set_signal_level(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_COMMENT:
                tzx_write_comment(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_MESSAGE:
                tzx_write_message(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO:
                tzx_write_archive_info(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_HARDWARE:
                tzx_write_hardware(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_CUSTOM:
                tzx_write_custom(block, buffer);
                break;

            case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE:
                error = tzx_write_rle(block, buffer, tape, iterator);
                if (error != LIBSPECTRUM_ERROR_NONE) {
                    return error;
                }
                break;

            case LIBSPECTRUM_TAPE_BLOCK_PULSE_SEQUENCE:
                tzx_write_pulse_sequence(block, buffer);
                break;
            case LIBSPECTRUM_TAPE_BLOCK_DATA_BLOCK:
                error = tzx_write_data_block(block, buffer);
                if (error != LIBSPECTRUM_ERROR_NONE) {
                    return error;
                }
                break;

            default:
                libspectrum_print_error(LIBSPECTRUM_ERROR_LOGIC,
                                        "libspectrum_tzx_write: unknown block type 0x%02x",
                                        libspectrum_tape_block_type(block));
                return LIBSPECTRUM_ERROR_LOGIC;
        }
    }

    return LIBSPECTRUM_ERROR_NONE;
}


static void tzx_write_rom(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    // Write the ID byte and the pause
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_ROM);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pause(block));

    // Copy the data across
    tzx_write_bytes(buffer, libspectrum_tape_block_data_length(block), 2, libspectrum_tape_block_data(block));
}


static void tzx_write_turbo(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    // Write the ID byte and the metadata
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_TURBO);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pilot_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_sync1_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_sync2_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_bit0_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_bit1_length (block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pilot_pulses(block));
    libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_bits_in_last_byte(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pause (block));

    tzx_write_bytes(buffer, libspectrum_tape_block_data_length(block), 3, libspectrum_tape_block_data(block));
}


static void add_pure_tone_block(libspectrum_buffer *buffer, libspectrum_dword pulse_length, size_t count)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_PURE_TONE);
    libspectrum_buffer_write_word(buffer, pulse_length);
    libspectrum_buffer_write_word(buffer, count);
}


static void tzx_write_pure_tone(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    add_pure_tone_block(buffer, libspectrum_tape_block_pulse_length(block), libspectrum_tape_block_count(block));
}


static void tzx_write_pulses(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t i;
    size_t count = libspectrum_tape_block_count(block);

    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_PULSES);
    libspectrum_buffer_write_byte(buffer, count);
    for (i = 0; i < count; i++) {
        libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pulse_lengths(block, i));
    }
}


static void tzx_write_data(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    // Write the ID byte and the metadata
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_PURE_DATA);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_bit0_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_bit1_length(block));
    libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_bits_in_last_byte(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pause(block));

    tzx_write_bytes(buffer, libspectrum_tape_block_data_length(block), 3, libspectrum_tape_block_data(block));
}


static void tzx_write_raw_data(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    // Write the ID byte and the metadata
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_RAW_DATA);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_bit_length(block));
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pause(block));
    libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_bits_in_last_byte(block));

    tzx_write_bytes(buffer, libspectrum_tape_block_data_length(block), 3, libspectrum_tape_block_data(block));
}


static size_t generalised_data_length(libspectrum_tape_generalised_data_symbol_table *pilot,
                                      libspectrum_tape_generalised_data_symbol_table *data,
                                      size_t data_bits_per_symbol)
{
    size_t data_length = 14; // Minimum if no tables or symbols present

    if (pilot->symbols_in_block) {

        data_length += ((2 * pilot->max_pulses) + 1) * pilot->symbols_in_table;
        data_length += 3 * pilot->symbols_in_block;

    }

    if (data->symbols_in_block) {

        data_length += ((2 * data->max_pulses) + 1) * data->symbols_in_table;
        data_length += libspectrum_bits_to_bytes(data_bits_per_symbol * data->symbols_in_block);

    }

    return data_length;
}


static libspectrum_error serialise_generalised_data_table(libspectrum_buffer *buffer,
                                                          libspectrum_tape_generalised_data_symbol_table *table)
{
    libspectrum_dword symbols_in_block;
    libspectrum_word symbols_in_table;

    symbols_in_block = libspectrum_tape_generalised_data_symbol_table_symbols_in_block(table);

    libspectrum_buffer_write_dword(buffer, symbols_in_block);
    libspectrum_buffer_write_byte(buffer, libspectrum_tape_generalised_data_symbol_table_max_pulses(table));

    symbols_in_table = libspectrum_tape_generalised_data_symbol_table_symbols_in_table(table);

    if ((symbols_in_block != 0) && ((symbols_in_table == 0) || (symbols_in_table > 256))) {
        libspectrum_print_error(LIBSPECTRUM_ERROR_INVALID,
                                "%s: invalid number of symbols in table: %d",
                                __func__,
                                symbols_in_table);
        return LIBSPECTRUM_ERROR_INVALID;
    } else if (symbols_in_table == 256) {
        symbols_in_table = 0;
    }

    libspectrum_buffer_write_byte(buffer, symbols_in_table);

    return LIBSPECTRUM_ERROR_NONE;
}


static void serialise_generalised_data_symbols(libspectrum_buffer *buffer,
                                               libspectrum_tape_generalised_data_symbol_table *table)
{
    libspectrum_word symbols_in_table = libspectrum_tape_generalised_data_symbol_table_symbols_in_table(table);
    libspectrum_byte max_pulses = libspectrum_tape_generalised_data_symbol_table_max_pulses(table);

    libspectrum_word i;
    libspectrum_byte j;

    if (!libspectrum_tape_generalised_data_symbol_table_symbols_in_block(table)) {
        return;
    }

    for (i = 0; i < symbols_in_table; i++) {

        libspectrum_tape_generalised_data_symbol *symbol = libspectrum_tape_generalised_data_symbol_table_symbol(table, i);

        libspectrum_buffer_write_byte(buffer, libspectrum_tape_generalised_data_symbol_type(symbol));

        for (j = 0; j < max_pulses; j++) {
            libspectrum_buffer_write_word(buffer, libspectrum_tape_generalised_data_symbol_pulse(symbol, j));
        }
    }
}


static libspectrum_error write_generalised_data_block(libspectrum_tape_block *block,
                                                      libspectrum_buffer *buffer,
                                                      size_t bits_per_symbol,
                                                      libspectrum_tape_generalised_data_symbol_table *pilot_table,
                                                      libspectrum_tape_generalised_data_symbol_table *data_table,
                                                      libspectrum_word pause_ms)
{
    size_t data_length;
    libspectrum_error error;
    libspectrum_dword pilot_symbol_count, data_symbol_count, i;

    data_length = generalised_data_length(pilot_table, data_table, bits_per_symbol);

    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA);
    libspectrum_buffer_write_dword(buffer, data_length);

    libspectrum_buffer_write_word(buffer, pause_ms);

    error = serialise_generalised_data_table(buffer, pilot_table);
    if (error != LIBSPECTRUM_ERROR_NONE) {
        return error;
    }

    error = serialise_generalised_data_table(buffer, data_table);
    if (error != LIBSPECTRUM_ERROR_NONE) {
        return error;
    }

    serialise_generalised_data_symbols(buffer, pilot_table);

    pilot_symbol_count = libspectrum_tape_generalised_data_symbol_table_symbols_in_block(pilot_table);

    for (i = 0; i < pilot_symbol_count; i++) {
        libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_pilot_symbols(block, i));
        libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pilot_repeats(block, i));
    }

    serialise_generalised_data_symbols(buffer, data_table);

    data_symbol_count = libspectrum_tape_generalised_data_symbol_table_symbols_in_block(data_table);

    data_length = libspectrum_bits_to_bytes(bits_per_symbol * data_symbol_count);

    libspectrum_buffer_write(buffer, libspectrum_tape_block_data(block), data_length);

    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error tzx_write_generalised_data(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t bits_per_symbol;
    libspectrum_tape_generalised_data_symbol_table *pilot_table, *data_table;

    pilot_table = libspectrum_tape_block_pilot_table(block);
    data_table = libspectrum_tape_block_data_table(block);

    bits_per_symbol = libspectrum_tape_block_bits_per_data_symbol(block);

    return write_generalised_data_block(block,
                                        buffer,
                                        bits_per_symbol,
                                        pilot_table,
                                        data_table,
                                        libspectrum_tape_block_pause(block));
}


static void tzx_write_pause(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    /* High pause when represented in the TZX format is really a set signal level 1
       and then a pulse as TZX format says that all pauses are low,
       a don't care pause is a pulse too */
    if (libspectrum_tape_block_level(block) != 0) {
        if (libspectrum_tape_block_level(block) == 1) {
            add_set_signal_level_block(buffer, 1);
        }

        add_pure_tone_block(buffer, libspectrum_tape_block_pause_tstates(block), 1);

        return;
    }

    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_PAUSE);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_pause(block));
}


static void tzx_write_group_start(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_GROUP_START);
    tzx_write_string(buffer, libspectrum_tape_block_text(block));
}


static void tzx_write_jump(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    int u_offset;

    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_JUMP);

    u_offset = libspectrum_tape_block_offset(block);
    if (u_offset < 0) {
        u_offset += 65536;
    }
    libspectrum_buffer_write_word(buffer, u_offset);
}


static void tzx_write_loop_start(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_LOOP_START);
    libspectrum_buffer_write_word(buffer, libspectrum_tape_block_count(block));
}


static void tzx_write_select(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t count, total_length, i;

    // The id byte, the total length (2 bytes), the count byte, and (2 offset bytes and 1 length byte) per selection
    count = libspectrum_tape_block_count(block);
    total_length = 4 + (3 * count);

    for (i = 0; i < count; i++) {
        total_length += strlen((char*)libspectrum_tape_block_texts(block, i));
    }
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_SELECT);
    libspectrum_buffer_write_word(buffer, total_length);
    libspectrum_buffer_write_byte(buffer, count);

    for (i = 0; i < count; i++) {
        libspectrum_buffer_write_word(buffer, libspectrum_tape_block_offsets(block, i));
        tzx_write_string(buffer, libspectrum_tape_block_texts(block, i));
    }
}


static void tzx_write_stop(libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_STOP48);
    libspectrum_buffer_write_dword(buffer, 0);
}


static void add_set_signal_level_block(libspectrum_buffer *buffer, int level)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_SET_SIGNAL_LEVEL);
    libspectrum_buffer_write_dword(buffer, 1);
    libspectrum_buffer_write_byte(buffer, level);
}


static void tzx_write_set_signal_level(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    add_set_signal_level_block(buffer, libspectrum_tape_block_level(block));
}


static void tzx_write_comment(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_COMMENT);
    tzx_write_string(buffer, libspectrum_tape_block_text(block));
}


static void tzx_write_message(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_MESSAGE);
    libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_pause(block));
    tzx_write_string(buffer, libspectrum_tape_block_text(block));
}


static void tzx_write_archive_info(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t i, count, total_length;

    count = libspectrum_tape_block_count(block);

    // 1 count byte, 2 bytes (ID and length) for every string
    total_length = 1 + (2 * count);
    // And then the length of all the strings
    for (i = 0; i < count; i++) {
        total_length += strlen((char*)libspectrum_tape_block_texts(block, i));
    }

    // Write out the metadata
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO);
    libspectrum_buffer_write_word(buffer, total_length);
    libspectrum_buffer_write_byte(buffer, count);

    // And the strings
    for (i = 0; i < count; i++) {
        libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_ids(block, i));
        tzx_write_string(buffer, libspectrum_tape_block_texts(block, i));
    }
}


static void tzx_write_hardware(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t i;
    size_t count = libspectrum_tape_block_count(block);

    // Write out the metadata
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_HARDWARE);
    libspectrum_buffer_write_byte(buffer, count);

    // And the info
    for (i = 0; i < count; i++) {
        libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_types(block, i));
        libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_ids(block, i));
        libspectrum_buffer_write_byte(buffer, libspectrum_tape_block_values(block, i));
    }
}


static void tzx_write_custom(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_buffer_write_byte(buffer, LIBSPECTRUM_TAPE_BLOCK_CUSTOM);
    libspectrum_buffer_write(buffer, libspectrum_tape_block_text(block), 16);
    tzx_write_bytes(buffer, libspectrum_tape_block_data_length(block), 4, libspectrum_tape_block_data(block));
}


// write a pulse of pulse_length bits into the tape_buffer
static void write_pulse(libspectrum_dword pulse_length)
{
    int i;
    size_t target_size = rle_state.length + (pulse_length / 8);

    if (rle_state.tape_length <= target_size) {
        rle_state.tape_length = target_size * 2;
        rle_state.tape_buffer = libspectrum_renew(libspectrum_byte, rle_state.tape_buffer, rle_state.tape_length);
    }

    for (i = pulse_length; i > 0; i--) {
        if (rle_state.level) {
            *(rle_state.tape_buffer + rle_state.length) |= 1 << (7 - rle_state.bits_used);
        }
        rle_state.bits_used++;

        if (rle_state.bits_used == 8) {
            rle_state.length++;
            *(rle_state.tape_buffer + rle_state.length) = 0;
            rle_state.bits_used = 0;
        }
    }

    rle_state.level = !rle_state.level;
}


// Convert RLE block to a TZX DRB as TZX CSW block support is limited :/
static libspectrum_error tzx_write_rle(libspectrum_tape_block *block,
                                       libspectrum_buffer *buffer,
                                       libspectrum_tape *tape,
                                       libspectrum_tape_iterator iterator)
{
    libspectrum_error error;
    libspectrum_tape_block_state it;
    libspectrum_dword scale = libspectrum_tape_block_scale(block);
    libspectrum_dword pulse_tstates = 0;
    libspectrum_dword balance_tstates = 0;
    int flags = 0;

    libspectrum_tape_block *raw_block = libspectrum_tape_block_alloc(LIBSPECTRUM_TAPE_BLOCK_RAW_DATA);

    libspectrum_tape_block_set_bit_length(raw_block, scale);
    libspectrum_set_pause_ms(raw_block, 0);

    rle_state.bits_used = 0;
    rle_state.level = 0;
    rle_state.length = 0;
    rle_state.tape_length = 8192;
    rle_state.tape_buffer = libspectrum_new(libspectrum_byte, rle_state.tape_length);

    *rle_state.tape_buffer = 0;

    it.current_block = iterator;
    error = libspectrum_tape_block_init(block, &it);
    if (error != LIBSPECTRUM_ERROR_NONE) {
        libspectrum_free(rle_state.tape_buffer);
        libspectrum_tape_block_free(raw_block);
        return error;
    }

    while (!(flags & LIBSPECTRUM_TAPE_FLAGS_BLOCK)) {
        libspectrum_dword pulse_length = 0;

        // Use internal version of this that doesn't bugger up the external tape status
        error = libspectrum_tape_get_next_edge_internal(&pulse_tstates, &flags, tape, &it);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            libspectrum_free(rle_state.tape_buffer);
            libspectrum_tape_block_free(raw_block);
            return error;
        }

        balance_tstates += pulse_tstates;

        // next set of pulses is: balance_tstates / scale;
        pulse_length = balance_tstates / scale;
        balance_tstates = balance_tstates % scale;

        // write pulse_length bits of the current level into the buffer
        write_pulse(pulse_length);
    }

    if (rle_state.length || rle_state.bits_used) {
        if (rle_state.bits_used) {
            rle_state.length++;
        } else {
            rle_state.bits_used = 8;
        }

        error = libspectrum_tape_block_set_bits_in_last_byte(raw_block, rle_state.bits_used);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            libspectrum_free(rle_state.tape_buffer);
            libspectrum_tape_block_free(raw_block);
            return error;
        }

        error = libspectrum_tape_block_set_data_length(raw_block, rle_state.length);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            libspectrum_free(rle_state.tape_buffer);
            libspectrum_tape_block_free(raw_block);
            return error;
        }

        error = libspectrum_tape_block_set_data(raw_block, rle_state.tape_buffer);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            libspectrum_free(rle_state.tape_buffer);
            libspectrum_tape_block_free(raw_block);
            return error;
        }

        // now have tzx_write_raw_data finish the job
        tzx_write_raw_data(raw_block, buffer);
    } else {
        libspectrum_free(rle_state.tape_buffer);
    }

    return libspectrum_tape_block_free(raw_block);
}


static void add_pulses_block(size_t pulse_count,
                             libspectrum_dword *lengths,
                             libspectrum_tape_block *block,
                             libspectrum_buffer *buffer)
{
    libspectrum_tape_block *pulses = libspectrum_tape_block_alloc(LIBSPECTRUM_TAPE_BLOCK_PULSES);

    libspectrum_tape_block_set_count(pulses, pulse_count);
    libspectrum_tape_block_set_pulse_lengths(pulses, lengths);

    tzx_write_pulses(pulses, buffer);

    libspectrum_tape_block_free(pulses);
}


/* Use ID 2B to set initial signal level,
   ID 12 Pure Tone for repeating pulses
   and ID 13 Pulse Sequence for non-repeating */
static void tzx_write_pulse_sequence(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    size_t count = libspectrum_tape_block_count(block);
    size_t i;
    size_t uncommitted_pulse_count = 0;
    size_t max_pulse_count = 0;
    libspectrum_dword *lengths = NULL;

    add_set_signal_level_block(buffer, 0);

    for (i = 0; i < count; i++) {
        size_t pulse_repeats = libspectrum_tape_block_pulse_repeats(block, i);
        if (pulse_repeats > 1) {
            // Close off any outstanding pulse blocks
            if (uncommitted_pulse_count > 0) {
                add_pulses_block(uncommitted_pulse_count, lengths, block, buffer);
                uncommitted_pulse_count = 0;
                max_pulse_count = 0;
                lengths = NULL;
            }

            add_pure_tone_block(buffer, libspectrum_tape_block_pulse_lengths(block, i), pulse_repeats);
        } else {
            if (uncommitted_pulse_count == max_pulse_count) {
                max_pulse_count = uncommitted_pulse_count + 64;
                lengths = libspectrum_renew(libspectrum_dword, lengths, max_pulse_count);
            }
            // Queue up pulse
            lengths[uncommitted_pulse_count++] = libspectrum_tape_block_pulse_lengths(block, i);
        }
    }

    // Close off any outstanding pulse blocks
    if (uncommitted_pulse_count > 0) {
        add_pulses_block(uncommitted_pulse_count, lengths, block, buffer);
    }
}


// Use ID 2B to set initial signal level, ID 14 Pure Data Block and a ID 12 Pure Tone for the tail pulse
static libspectrum_error tzx_write_data_block(libspectrum_tape_block *block, libspectrum_buffer *buffer)
{
    libspectrum_error error;
    libspectrum_tape_block *pure_data;
    size_t data_length, i;
    libspectrum_byte *data;
    libspectrum_tape_generalised_data_symbol_table pilot_table, data_table;

    tzx_write_set_signal_level(block, buffer);

    // Pure data block can only have two identical pulses for bit 0 and bit 1
    if ((libspectrum_tape_block_bit0_pulse_count(block) != 2) ||
        (libspectrum_tape_block_bit0_pulses(block, 0) != libspectrum_tape_block_bit0_pulses(block, 1)) ||
        (libspectrum_tape_block_bit1_pulse_count(block) != 2) ||
        (libspectrum_tape_block_bit1_pulses(block, 0) != libspectrum_tape_block_bit1_pulses(block, 1))) {
        pilot_table.symbols_in_block = 0;
        pilot_table.max_pulses = 0;
        pilot_table.symbols_in_table = 0;

        data_table.symbols_in_block = libspectrum_tape_block_count(block);
        data_table.max_pulses = MAX(libspectrum_tape_block_bit0_pulse_count(block),
                                    libspectrum_tape_block_bit1_pulse_count(block));
        data_table.symbols_in_table = 2;

        data_table.symbols = libspectrum_new(libspectrum_tape_generalised_data_symbol, data_table.symbols_in_table);

        data_table.symbols[0].edge_type = LIBSPECTRUM_TAPE_GENERALISED_DATA_SYMBOL_EDGE;
        data_table.symbols[0].lengths = libspectrum_new(libspectrum_word,
                                                        libspectrum_tape_block_bit0_pulse_count(block));
        for (i = 0; i < libspectrum_tape_block_bit0_pulse_count(block); i++) {
            data_table.symbols[0].lengths[i] = libspectrum_tape_block_bit0_pulses(block, i);
        }

        data_table.symbols[1].edge_type = LIBSPECTRUM_TAPE_GENERALISED_DATA_SYMBOL_EDGE;
        data_table.symbols[1].lengths = libspectrum_new(libspectrum_word,
                                                        libspectrum_tape_block_bit1_pulse_count(block));
        for (i = 0; i < libspectrum_tape_block_bit1_pulse_count(block); i++) {
            data_table.symbols[1].lengths[i] = libspectrum_tape_block_bit1_pulses(block, i);
        }

        error = write_generalised_data_block(block, buffer, 1, &pilot_table, &data_table, 0);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            return error;
        }
    } else {
        pure_data = libspectrum_tape_block_alloc(LIBSPECTRUM_TAPE_BLOCK_PURE_DATA);

        libspectrum_tape_block_set_bit0_length(pure_data, libspectrum_tape_block_bit0_pulses(block, 0));
        libspectrum_tape_block_set_bit1_length(pure_data, libspectrum_tape_block_bit1_pulses(block, 0));
        libspectrum_tape_block_set_bits_in_last_byte(pure_data, libspectrum_tape_block_bits_in_last_byte(block));
        libspectrum_set_pause_tstates(pure_data, 0);

        // And the actual data
        data_length = libspectrum_tape_block_data_length(block);
        libspectrum_tape_block_set_data_length(pure_data, data_length);
        data = libspectrum_new(libspectrum_byte, data_length);
        memcpy(data, libspectrum_tape_block_data(block), data_length);
        libspectrum_tape_block_set_data(pure_data, data);

        tzx_write_data(pure_data, buffer);

        libspectrum_tape_block_free(pure_data);
    }

    if (libspectrum_tape_block_tail_length(block)) {
        add_pure_tone_block(buffer, libspectrum_tape_block_tail_length(block), 1);
    }

    return LIBSPECTRUM_ERROR_NONE;
}


static void tzx_write_empty_block(libspectrum_buffer *buffer, libspectrum_tape_type id)
{
    libspectrum_buffer_write_byte(buffer, id);
}


static void tzx_write_bytes(libspectrum_buffer *buffer, size_t length, size_t length_bytes, libspectrum_byte *data)
{
    size_t i, shifter;

    // Write out the appropriate number of length bytes
    for (i = 0, shifter = length; i < length_bytes; i++, shifter >>= 8) {
        libspectrum_buffer_write_byte(buffer, (shifter & 0xff));
    }
    // And then the actual data
    libspectrum_buffer_write(buffer, data, length);
}


static void tzx_write_string(libspectrum_buffer *buffer, char *string)
{
    size_t i, length = strlen((char*)string);

    length &= 0xff;
    libspectrum_buffer_write_byte(buffer, length);

    // Fix up line endings as we go
    for (i = 0; i < length; i++) {
        libspectrum_buffer_write_byte(buffer, ((string[i] == '\x0a') ? '\x0d' : string[i]));
    }
}