/* 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;
}