warajevo_read.c

/* warajevo_read.c: Routines for reading Warajevo .tap files
   Copyright (c) 2001, 2002 Philip Kendall, Darren Salt
   Copyright (c) 2003-2015 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 <stddef.h>
#include <stdio.h>
#include <string.h>

#include "internals.h"

static const libspectrum_word RECORD_SAMPLES = 0xfffe;
static const libspectrum_word COMPRESSED_BLOCK = 0xffff;

enum raw_data_frequency {
    HZ15000 = 0,
    HZ22050,
    HZ30303,
    HZ44100
};

#ifdef WORDS_BIGENDIAN

typedef struct
{
    unsigned unused    : 3;
    unsigned frequency : 2;
    unsigned bits_used : 3;
} status_bits;

#else // #ifdef WORDS_BIGENDIAN

typedef struct
{
    unsigned bits_used : 3;
    unsigned frequency : 2;
    unsigned unused    : 3;
} status_bits;

#endif // #ifdef WORDS_BIGENDIAN

typedef union
{
    libspectrum_byte byte;
    status_bits bits;
} status_type;

// Non-terminating nodes from the size state machine
typedef enum state_type {
      b = 0, // start
      b0,
      b1,
      b01,
      b10,
      b11,
      b110,
      b111
} state_type;

// Non-terminating nodes from the offset state machine
typedef enum vstate_type {
      v = 0, // start
      v0,
      v01,
      v00,
      v000,
      v001,
      v0010,
      v0011
} vstate_type;

typedef struct
{
    int mode; /* 0 = copy byte to output, 1 = building copy size,
                 2 = building offset, 3 = command complete */
    state_type state;
    vstate_type vstate;
    int offset;
    unsigned int size;
    libspectrum_byte pattern;
    size_t pattern_depth;
} copy_command;

static copy_command command;

// The Warajevo .tap file signature (3rd group of 4 bytes) also end of tap marker
static const libspectrum_dword warajevo_signature = 0xffffffff;

/*** Local function prototypes ***/

static libspectrum_dword lsb2dword(const libspectrum_byte *mem);
static libspectrum_word lsb2word(const libspectrum_byte *mem);

static libspectrum_error exec_command(libspectrum_byte *dest,
                                      const libspectrum_byte *src,
                                      const libspectrum_byte *end,
                                      size_t *sp,
                                      size_t *pc,
                                      size_t *bytes_written,
                                      const size_t to_write);

static libspectrum_error get_next_block(size_t *offset,
                                        const libspectrum_byte *buffer,
                                        const libspectrum_byte *end,
                                        libspectrum_tape *tape);

static libspectrum_error read_rom_block(libspectrum_tape *tape,
                                        const libspectrum_byte *ptr,
                                        const libspectrum_byte *end,
                                        size_t offset);

static libspectrum_error read_raw_data(libspectrum_tape *tape,
                                       const libspectrum_byte *ptr,
                                       const libspectrum_byte *end,
                                       size_t offset);

static libspectrum_error add_bit_to_copy_command(libspectrum_byte *dest,
                                                 const libspectrum_byte *src,
                                                 const libspectrum_byte *end,
                                                 libspectrum_byte bit,
                                                 size_t *sp,
                                                 size_t *bytes_written);

static void reset_copy_command(void);

static libspectrum_error decompress_block(libspectrum_byte *dest,
                                          const libspectrum_byte *src,
                                          const libspectrum_byte *end,
                                          size_t signature,
                                          size_t length);

/*** Function definitions ***/

static libspectrum_dword lsb2dword(const libspectrum_byte *mem)
{
    return (mem[0] << 0) | (mem[1] << 8) | (mem[2] << 16) | (mem[3] << 24);
}


static libspectrum_word lsb2word(const libspectrum_byte *mem)
{
    return (mem[0] << 0) | (mem[1] << 8);
}

// The main load function


libspectrum_error internal_warajevo_read(libspectrum_tape *tape, const libspectrum_byte *buffer, size_t length)
{
    libspectrum_error error;
    const libspectrum_byte *ptr, *end;

    size_t offset;

    ptr = buffer;
    end = buffer + length;

    // Must be at least as many bytes as the signature, the initial block pointer and source pointer block
    if (length < 12) {
        libspectrum_print_error(LIBSPECTRUM_ERROR_CORRUPT, "libspectrum_warajevo_read: not enough data in buffer");
        return LIBSPECTRUM_ERROR_CORRUPT;
    }

    // Now check the signature
    if (lsb2dword(ptr + 8) != warajevo_signature) {
        libspectrum_print_error(LIBSPECTRUM_ERROR_SIGNATURE, "libspectrum_warajevo_read: wrong signature");
        return LIBSPECTRUM_ERROR_SIGNATURE;
    }

    // Get inital offset
    offset = lsb2dword(ptr);

    while (offset != warajevo_signature) {
        error = get_next_block(&offset, ptr, end, tape);
        if (error != LIBSPECTRUM_ERROR_NONE) {
            return error;
        }
    }

    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error get_next_block(size_t *offset,
                                        const libspectrum_byte *buffer,
                                        const libspectrum_byte *end,
                                        libspectrum_tape *tape)
{
    int error;
    libspectrum_dword next_block;

    // Check we have enough data
    if (((end - buffer) < *offset) || ((end - buffer - *offset) < 8)) {
        libspectrum_print_error(LIBSPECTRUM_ERROR_CORRUPT, "libspectrum_warajevo_read: not enough data in buffer");
        return LIBSPECTRUM_ERROR_CORRUPT;
    }

    next_block = lsb2dword(buffer + 4 + *offset);

    // Check for EOF marker
    if (next_block == warajevo_signature) {
        *offset = warajevo_signature;
        return LIBSPECTRUM_ERROR_NONE;
    }

    if (lsb2word(buffer + 8 + *offset) == RECORD_SAMPLES) {
        error = read_raw_data(tape, buffer, end, *offset);
    } else {
        error = read_rom_block(tape, buffer, end, *offset);
    }

    if (error) {
        libspectrum_tape_free(tape);
        return error;
    }

    // Advance to the next block
    *offset = next_block;

    return LIBSPECTRUM_ERROR_NONE;
}


// Executes a bytes worth of commands
static libspectrum_error exec_command(libspectrum_byte *dest,
                                      const libspectrum_byte *src,
                                      const libspectrum_byte *end GCC_UNUSED,
                                      size_t *sp,
                                      size_t *pc,
                                      size_t *bytes_written,
                                      const size_t to_write)
{
    size_t i;
    libspectrum_byte command_byte;
    libspectrum_byte bit;
    libspectrum_error error;

    command_byte = src[(*pc)++];

    for (i = 0; i < 8; i++) {
        bit = (command_byte & (0x80 >> i)) ? 1 : 0;

        error = add_bit_to_copy_command(dest, src, (dest + to_write), bit, sp, bytes_written);
        if (error) {
            return error;
        }

        if (*bytes_written >= to_write) {
            break;
        }
    }

    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error execute_copy_command(libspectrum_byte *dest, const libspectrum_byte *end, size_t *bytes_written)
{
    if (((*bytes_written + 1) < command.offset) ||
        ((dest + *bytes_written - command.offset + 1 + command.size) > end)) {
        libspectrum_print_error(LIBSPECTRUM_ERROR_CORRUPT, "execute_copy_command: corrupt compressed block in file");
        return LIBSPECTRUM_ERROR_CORRUPT;
    }

    memcpy((dest + *bytes_written), (dest + *bytes_written - command.offset + 1), command.size);

    *bytes_written += command.size;

    reset_copy_command();

    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error add_bit_to_copy_command(libspectrum_byte *dest,
                                                 const libspectrum_byte *src,
                                                 const libspectrum_byte *end,
                                                 libspectrum_byte bit,
                                                 size_t *sp,
                                                 size_t *bytes_written)
{
    if (command.mode == 0) {
        if (bit == 0) {
            dest[(*bytes_written)++] = src[(*sp)++];
        } else {
            command.mode = 1;
            return LIBSPECTRUM_ERROR_NONE;
        }
    }

    if (command.mode == 1) {
        switch (command.state){
            case  b: // start
                command.state = (bit == 0) ? b0 : b1;
                break;
            case b0:
                if (bit == 0) { // b00
                    command.size = 3;
                    command.mode = 2;
                } else {
                    command.state = b01;
                }
                break;
            case b1:
                command.state = (bit == 0) ? b10 : b11;
                break;
            case b01:
                if (bit == 0) { // b010
                    // no higher byte
                    command.size = 2;
                    command.mode = 3;
                    command.offset = src[(*sp)++];
                    return execute_copy_command(dest, end, bytes_written);
                } else { // b011
                    command.size = 10 + src[(*sp)++];
                    command.mode = 2;
                }
                break;
            case b10:
                if (bit == 0) { // b100
                    command.size = 4;
                    command.mode = 2;
                } else { // b101
                    command.size = 5;
                    command.mode = 2;
                }
                break;
            case b11:
                command.state = (bit == 0) ? b110 : b111;
                break;
            case b110:
                if (bit == 0) { // b1100
                    command.size = 6;
                    command.mode = 2;
                } else { // b1101
                    command.size = 7;
                    command.mode = 2;
                }
                break;
            case b111:
                if (bit == 0) { // b1110
                    command.size = 8;
                    command.mode = 2;
                } else { // b1111
                    command.size = 9;
                    command.mode = 2;
                }
                break;
            }
            return LIBSPECTRUM_ERROR_NONE;
        }

    if (command.mode == 2) {
        switch (command.vstate){
            case v: // start
                command.offset = src[(*sp)++];
                if (bit == 0) {
                    command.vstate = v0;
                } else { // v1
                    // no higher byte
                    command.mode = 3;
                }
                break;
            case v0:
                command.vstate = (bit == 0) ? v00 : v01;
                break;
            case v01: // v01 + nnnn
                command.pattern <<= 1;
                command.pattern |= bit;
                if (++command.pattern_depth == 4) {
                    command.offset += (command.pattern + 7) << 8;
                    command.mode = 3;
                }
                break;
            case v00:
                command.vstate = (bit == 0) ? v000 : v001;
                break;
            case v000:
                if (bit == 0) { // v0000
                    command.offset += 1 << 8;
                    command.mode = 3;
                } else { // v0001
                    command.offset += 2 << 8;
                    command.mode = 3;
                }
                break;
            case v001:
                command.vstate = (bit == 0) ? v0010 : v0011;
                break;
            case v0010:
                if (bit == 0) { // v00100
                    command.offset += 3 << 8;
                    command.mode = 3;
                } else { // v00101
                    command.offset += 4 << 8;
                    command.mode = 3;
                }
                break;
            case v0011:
                if (bit == 0) { // v00110
                    command.offset += 5 << 8;
                    command.mode = 3;
                } else { // v00111
                    command.offset += 6 << 8;
                    command.mode = 3;
                }
                break;
            }
    }

    if (command.mode == 3) {
        return execute_copy_command(dest, end, bytes_written);
    }

    return LIBSPECTRUM_ERROR_NONE;
}


static void reset_copy_command(void)
{
    memset(&command, 0, sizeof(copy_command));
}


static libspectrum_error read_rom_block(libspectrum_tape *tape,
                                        const libspectrum_byte *ptr,
                                        const libspectrum_byte *end,
                                        size_t offset)
{
    libspectrum_tape_block *block = libspectrum_tape_block_alloc(LIBSPECTRUM_TAPE_BLOCK_ROM);
    libspectrum_error error;
    libspectrum_word size;
    libspectrum_word block_size;
    const libspectrum_byte *data; libspectrum_byte *block_data;
    size_t i, length;

    size = lsb2word(ptr + offset + 8);

    if (size == COMPRESSED_BLOCK) {
        // Decompressed length + flag byte and checksum
        length = lsb2word(ptr + offset + 11) + 2;
        block_size = lsb2word(ptr + offset + 13);
        data = ptr + offset + 17 ;
    } else {
        // Get the length + flag byte and checksum
        length = size + 2;
        block_size = size;
        data = ptr + offset + 11;
    }
    libspectrum_tape_block_set_data_length(block, length);

    // Have we got enough bytes left in buffer?
    if ((end - data) < (ptrdiff_t)block_size) {
        libspectrum_free(block);
        libspectrum_print_error(LIBSPECTRUM_ERROR_CORRUPT, "warajevo_read_rom_block: not enough data in buffer");
        return LIBSPECTRUM_ERROR_CORRUPT;
    }

    // Allocate memory for the data
    block_data = libspectrum_new(libspectrum_byte, length);
    libspectrum_tape_block_set_data(block, block_data);

    // Add flag
    block_data[0] = *(ptr + offset + 10);

    if (size == COMPRESSED_BLOCK) {

        error = decompress_block((block_data + 1), data, end, lsb2word(ptr + offset + 15), (length - 2));
        if (error) {
            libspectrum_free(block_data);
            libspectrum_free(block);
            return error;
        }
    } else {
        // Uncompressed block: just copy the data across
        memcpy((block_data + 1), data, (length - 2));
    }

    // Calculate checksum
    block_data[length - 1] = 0;
    for (i = 0; i < (length - 1); i++) {
        block_data[length - 1] ^= block_data[i];
    }
    // Give a 1s pause after each block
    libspectrum_set_pause_ms(block, 1000);

    // Put the block into the block list
    libspectrum_tape_append_block(tape, block);

    // And return with no error
    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error read_raw_data(libspectrum_tape *tape,
                                       const libspectrum_byte *ptr,
                                       const libspectrum_byte *end,
                                       size_t offset)
{
    libspectrum_tape_block *block = libspectrum_tape_block_alloc(LIBSPECTRUM_TAPE_BLOCK_RAW_DATA);
    libspectrum_tape_block *last_block;
    libspectrum_error error;
    libspectrum_word compressed_size, decompressed_size;
    const libspectrum_byte *data = ptr + offset + 17;
    status_type status;
    size_t length, bit_length;
    libspectrum_byte *block_data;

    decompressed_size = lsb2word(ptr + offset + 11);
    compressed_size = lsb2word(ptr + offset + 13);

    length = decompressed_size;
    libspectrum_tape_block_set_data_length(block, length);

    // Have we got enough bytes left in buffer?
    if ((end - data) < (ptrdiff_t)compressed_size) {
        libspectrum_free(block);
        libspectrum_print_error(LIBSPECTRUM_ERROR_CORRUPT, "warajevo_read_raw_data: not enough data in buffer");
        return LIBSPECTRUM_ERROR_CORRUPT;
    }

    // Allocate memory for the data
    block_data = libspectrum_new(libspectrum_byte, length);
    libspectrum_tape_block_set_data(block, block_data);

    if (compressed_size != decompressed_size) {

        error = decompress_block(block_data, data, end, lsb2word(ptr + offset + 15), length);
        if (error) {
            libspectrum_free(block_data);
            libspectrum_free(block);
            return error;
        }
    } else {
        // Uncompressed block: just copy the data across
        memcpy(block_data, data, length);
    }

    status.byte = *(ptr + offset + 10);

    // Get the metadata
    switch (status.bits.frequency) {
        case HZ15000:
            bit_length = 233;
            break;
        case HZ22050:
            bit_length = 158;
            break;
        case HZ30303:
            bit_length = 115;
            break;
        case HZ44100:
            bit_length =  79;
            break;
        default:
            libspectrum_print_error(LIBSPECTRUM_ERROR_LOGIC, "read_raw_data: unknown frequency %d", status.bits.frequency);
            libspectrum_free(block_data);
            libspectrum_free(block);
            return LIBSPECTRUM_ERROR_LOGIC;
    }
    libspectrum_tape_block_set_bit_length(block, bit_length);

    libspectrum_set_pause_tstates(block, 0);
    libspectrum_tape_block_set_bits_in_last_byte(block, (status.bits.bits_used + 1));

    /* Warajevo TAPs have a relatively short limit on RAW blocks of 64995 bytes
       which is only 11.74 secs at 44100Hz.

       As a result when these blocks are used they often are a sequence of these
       short blocks as opposed to other formats which have a long single block
       corresponding to the sampled section of tape.

       This presents a problem for libspectrum which assumes that a pulse cannot
       span two different blocks, so we will work around this limitation by
       coalesing adjacent compatible RAW blocks to ensure the pulse structure is preserved. */

    /* Check if the last block was also a raw block of the same sample rate
       and with all 8 bits used in the last byte */
    last_block = libspectrum_tape_peek_last_block(tape);
    if (last_block && (libspectrum_tape_block_type(last_block) == LIBSPECTRUM_TAPE_BLOCK_RAW_DATA) &&
        (libspectrum_tape_block_bit_length(last_block) == bit_length) &&
        (libspectrum_tape_block_bits_in_last_byte(last_block) == 8)) {
        // Combine the two blocks
        size_t new_length = libspectrum_tape_block_data_length(last_block) + length;
        block_data = libspectrum_renew(libspectrum_byte, libspectrum_tape_block_data(last_block), new_length);

        memcpy((block_data + libspectrum_tape_block_data_length(last_block)), libspectrum_tape_block_data(block), length);
        libspectrum_tape_block_set_data(last_block, block_data);
        libspectrum_tape_block_set_data_length(last_block, new_length);
        libspectrum_tape_block_set_bits_in_last_byte(last_block, (status.bits.bits_used + 1));
        libspectrum_tape_block_free(block);
    } else {
        // Put the block into the block list
        libspectrum_tape_append_block(tape, block);
    }

    // And return with no error
    return LIBSPECTRUM_ERROR_NONE;
}


static libspectrum_error decompress_block(libspectrum_byte *dest,
                                          const libspectrum_byte *src,
                                          const libspectrum_byte *end,
                                          size_t signature,
                                          size_t length)
{
    size_t bytes_written = 0, pc = 0;
    size_t sp = signature + 1;

    libspectrum_error error;

    reset_copy_command();

    while ((pc <= signature) && (bytes_written != length)) {
        error = exec_command(dest, src, end, &sp, &pc, &bytes_written, length);
        if (error) {
            return error;
        }
    }

    return LIBSPECTRUM_ERROR_NONE;
}