/* csw.c: Routines for handling CSW raw audio files
   Copyright (c) 2002-2015 Darren Salt, Fredrick Meunier
   Based on tap.c, copyright (c) 2001 Philip Kendall

   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: linux@youmustbejoking.demon.co.uk

*/

#include "config.h"
#include <string.h>

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

/* The .csw file signature (first 23 bytes) */
static const char * const csw_signature = "Compressed Square Wave\x1a";

libspectrum_error
libspectrum_csw_read( libspectrum_tape *tape,
		      const libspectrum_byte *buffer, size_t length )
{
  libspectrum_tape_block *block = NULL;
  libspectrum_tape_rle_pulse_block *csw_block;

  int compressed;

  size_t signature_length = strlen( csw_signature );

  if( length < signature_length + 2 ) goto csw_short;

  if( memcmp( csw_signature, buffer, signature_length ) ) {
    libspectrum_print_error( LIBSPECTRUM_ERROR_SIGNATURE,
			     "libspectrum_csw_read: wrong signature" );
    return LIBSPECTRUM_ERROR_SIGNATURE;
  }

  /* Claim memory for the block */
  block = libspectrum_new( libspectrum_tape_block, 1 );

  /* Set the block type */
  block->type = LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE;
  csw_block = &block->types.rle_pulse;

  buffer += signature_length;
  length -= signature_length;

  switch( buffer[0] ) {

  case 1:
    if( length < 9 ) goto csw_short;
    csw_block->scale = buffer[2] | buffer[3] << 8;
    if( buffer[4] != 1 ) goto csw_bad_compress;
    compressed = 0;
    buffer += 9;
    length -= 9;
    break;

  case 2:
    if( length < 29 ) goto csw_short;

    csw_block->scale =
      buffer[2]       |
      buffer[3] <<  8 |
      buffer[4] << 16 |
      buffer[5] << 24;
    compressed = buffer[10] - 1;

    if( compressed != 0 && compressed != 1 ) goto csw_bad_compress;

    if( length < 29 - buffer[12] ) goto csw_short;
    length -= 29 - buffer[12];
    buffer += 29 + buffer[12];

    break;

  default:
    libspectrum_print_error( LIBSPECTRUM_ERROR_MEMORY,
			     "libspectrum_csw_read: unknown CSW version" );
    return LIBSPECTRUM_ERROR_SIGNATURE;
  }

  if (csw_block->scale)
    csw_block->scale = 3500000 / csw_block->scale; /* approximate CPU speed */

  if( csw_block->scale < 0 || csw_block->scale >= 0x80000 ) {
    libspectrum_print_error (LIBSPECTRUM_ERROR_MEMORY,
			     "libspectrum_csw_read: bad sample rate" );
    return LIBSPECTRUM_ERROR_UNKNOWN;
  }

  if( !length ) goto csw_empty;

  if( compressed ) {
    /* Compressed data... */
#ifdef HAVE_ZLIB_H
    libspectrum_error error;

    csw_block->data = NULL;
    csw_block->length = 0;
    error = libspectrum_zlib_inflate( buffer, length, &csw_block->data,
                                      &csw_block->length );
    if( error != LIBSPECTRUM_ERROR_NONE ) return error;
#else
    libspectrum_print_error( LIBSPECTRUM_ERROR_UNKNOWN,
                             "zlib not available to decompress gzipped file" );
    return LIBSPECTRUM_ERROR_UNKNOWN;
#endif
  } else {
    /* Claim memory for the data (it's one big lump) */
    csw_block->length = length;
    csw_block->data = libspectrum_new( libspectrum_byte, length );

    /* Copy the data across */
    memcpy( csw_block->data, buffer, length );
  }

  libspectrum_tape_append_block( tape, block );

  /* Successful completion */
  return LIBSPECTRUM_ERROR_NONE;

  /* Error returns */

 csw_bad_compress:
  libspectrum_free( block );
  libspectrum_print_error( LIBSPECTRUM_ERROR_MEMORY,
			   "libspectrum_csw_read: unknown compression type" );
  return LIBSPECTRUM_ERROR_CORRUPT;

 csw_short:
  libspectrum_free( block );
  libspectrum_print_error( LIBSPECTRUM_ERROR_CORRUPT,
			   "libspectrum_csw_read: not enough data in buffer" );
  return LIBSPECTRUM_ERROR_CORRUPT;

 csw_empty:
  libspectrum_free( block );
  /* Successful completion */
  return LIBSPECTRUM_ERROR_NONE;
}

static libspectrum_dword
find_sample_rate( libspectrum_tape *tape )
{
  libspectrum_tape_iterator iterator;
  libspectrum_tape_block *block;
  libspectrum_dword sample_rate = 44100;
  int found = 0;

  /* FIXME: If tape has only one block that is a sampled type, just use it's rate
     and if it RLE, we should just zlib and write */
  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_RAW_DATA:
    case LIBSPECTRUM_TAPE_BLOCK_RLE_PULSE:
      {
      libspectrum_dword block_rate =
        3500000 / libspectrum_tape_block_bit_length( block );

      if( found ) {
        if( block_rate != sample_rate ) {
          libspectrum_print_error(
            LIBSPECTRUM_ERROR_WARNING,
            "find_sample_rate: converting tape with mixed sample rates; conversion may well not work"
          );
        }
      }
      sample_rate = block_rate;
      found = 1;
      }
      break;

    case LIBSPECTRUM_TAPE_BLOCK_ROM:
    case LIBSPECTRUM_TAPE_BLOCK_TURBO:
    case LIBSPECTRUM_TAPE_BLOCK_PURE_TONE:
    case LIBSPECTRUM_TAPE_BLOCK_PULSES:
    case LIBSPECTRUM_TAPE_BLOCK_PURE_DATA:
    case LIBSPECTRUM_TAPE_BLOCK_GENERALISED_DATA:
    case LIBSPECTRUM_TAPE_BLOCK_PAUSE:
    case LIBSPECTRUM_TAPE_BLOCK_GROUP_START:
    case LIBSPECTRUM_TAPE_BLOCK_GROUP_END:
    case LIBSPECTRUM_TAPE_BLOCK_JUMP:
    case LIBSPECTRUM_TAPE_BLOCK_LOOP_START:
    case LIBSPECTRUM_TAPE_BLOCK_LOOP_END:
    case LIBSPECTRUM_TAPE_BLOCK_SELECT:
    case LIBSPECTRUM_TAPE_BLOCK_STOP48:
    case LIBSPECTRUM_TAPE_BLOCK_COMMENT:
    case LIBSPECTRUM_TAPE_BLOCK_MESSAGE:
    case LIBSPECTRUM_TAPE_BLOCK_ARCHIVE_INFO:
    case LIBSPECTRUM_TAPE_BLOCK_HARDWARE:
    case LIBSPECTRUM_TAPE_BLOCK_CUSTOM:
    case LIBSPECTRUM_TAPE_BLOCK_CONCAT:
      break;

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

    }
  }

  return sample_rate;
}

static libspectrum_error
csw_write_body( libspectrum_buffer *buffer, libspectrum_tape *tape,
                libspectrum_dword sample_rate,
                size_t* body_uncompressed_length )
{
  libspectrum_error error;
  int flags = 0;
  libspectrum_dword pulse_tstates = 0;
  libspectrum_dword balance_tstates = 0;
  long scale = 3500000/sample_rate;
  libspectrum_tape_block_state it;

  if( libspectrum_tape_block_internal_init( &it, tape ) ) {
    while( !(flags & LIBSPECTRUM_TAPE_FLAGS_STOP) ) {
      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 ) return error;

      balance_tstates += pulse_tstates;

      if( flags & LIBSPECTRUM_TAPE_FLAGS_NO_EDGE ) continue;

      /* next RLE value is: balance_tstates / scale; */
      pulse_length = balance_tstates / scale;
      balance_tstates = balance_tstates % scale;

      if( pulse_length ) {
        if( pulse_length <= 0xff ) {
          libspectrum_buffer_write_byte( buffer, pulse_length );
        } else {
          libspectrum_buffer_write_byte( buffer, 0 );
          libspectrum_buffer_write_dword( buffer, pulse_length );
        }
      }
    }
  }

  /* Write the length in */
  *body_uncompressed_length = libspectrum_buffer_get_data_size( buffer );

  /* compression type */
#ifdef HAVE_ZLIB_H
  if( *body_uncompressed_length ) {
    libspectrum_byte *compressed_data = NULL;
    size_t compressed_length;

    error = libspectrum_zlib_compress( libspectrum_buffer_get_data( buffer ),
                                       libspectrum_buffer_get_data_size( buffer ),
                                       &compressed_data, &compressed_length );
    if( error ) return error;

    libspectrum_buffer_clear( buffer );
    libspectrum_buffer_write( buffer, compressed_data, compressed_length );
    libspectrum_free( compressed_data );
  }
#endif

  return LIBSPECTRUM_ERROR_NONE;
}

libspectrum_error
libspectrum_csw_write( libspectrum_buffer *new_buffer, libspectrum_tape *tape )
{
  libspectrum_error error = LIBSPECTRUM_ERROR_NONE;
  libspectrum_dword sample_rate;
  size_t i;

  libspectrum_buffer* body_buffer = libspectrum_buffer_alloc();
  size_t body_uncompressed_length = 0;

  sample_rate = find_sample_rate( tape );

  error =
    csw_write_body( body_buffer, tape, sample_rate, &body_uncompressed_length );
  if( error != LIBSPECTRUM_ERROR_NONE ) goto exit;

  /* First, write the .csw signature and the rest of the header */
  libspectrum_buffer_write( new_buffer, csw_signature, strlen( csw_signature ) );

  libspectrum_buffer_write_byte( new_buffer, 2 ); /* Major version number */
  libspectrum_buffer_write_byte( new_buffer, 0 ); /* Minor version number */

  /* sample rate */
  libspectrum_buffer_write_dword( new_buffer, sample_rate );

  /* Store where the total number of pulses (after decompression) will
     be written, and skip over those bytes */
  libspectrum_buffer_write_dword( new_buffer, body_uncompressed_length );

  /* compression type */
#ifdef HAVE_ZLIB_H
  libspectrum_buffer_write_byte( new_buffer, 2 ); /* Z-RLE */
#else
  libspectrum_buffer_write_byte( new_buffer, 1 ); /* RLE */
#endif

  /* flags */
  libspectrum_buffer_write_byte( new_buffer, 0 );		/* No flags */

  /* header extension length in bytes */
  libspectrum_buffer_write_byte( new_buffer, 0 );		/* No header extension */

  /* encoding application description */
  /* No creator for now */
  for( i = 0; i < 16; i++ ) {
    libspectrum_buffer_write_byte( new_buffer, 0 );
  }

  /* header extension data is zero so on to the data */
  libspectrum_buffer_write_buffer( new_buffer, body_buffer );

exit:
  libspectrum_buffer_free( body_buffer );
  return error;
}