wav2cas.c

/**************************************************************************/
/*                                                                        */
/* file:         wav2cas.c                                                */
/* version:      1.31 (April 11, 2016)                                    */
/*                                                                        */
/* description:  This tool exports the contents of a .wav file to a .cas  */
/*               file. The .cas format is the standard format for MSX to  */
/*               emulate tape recorders and can be used with most         */
/*               emulators.                                               */
/*                                                                        */
/*                                                                        */
/*  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, or (at your option)   */
/*  any later version. See COPYING for more details.                      */
/*                                                                        */
/*                                                                        */
/* Copyright 2001-2016 Vincent van Dam (vincentd@erg.verweg.com)          */
/* MultiCPU Copyright 2007 Ramones     (ramones@kurarizeku.net)           */
/*                                                                        */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <memory.h>

#ifndef bool
#define true   1
#define false  0
#define bool   int
#endif

#define THRESHOLD_SILENCE   100
#define THRESHOLD_HEADER    25

/* CPU type defines */
#if (BIGENDIAN)
#define BIGENDIANSHORT(value)  ( ((value & 0x00FF) << 8) | \
                                 ((value & 0xFF00) >>8 ) )
#define BIGENDIANINT(value)    ( ((value & 0x000000FF) << 24) | \
                                 ((value & 0x0000FF00) << 8)  | \
                                 ((value & 0x00FF0000) >> 8)  | \
                                 ((value & 0xFF000000) >> 24) )
#define	BIGENDIANLONG(value)   BIGENDIANINT(value) // I suppose Long=int
#else
#define BIGENDIANSHORT(value) value
#define BIGENDIANINT(value)   value
#define	BIGENDIANLONG(value)  value
#endif

/* default arguments */
int   threshold = 5;     /* amplitude threshold  */
bool  envelope  = 2;     /* envelope correction  */
bool  normalize = false; /* amplitude normalize  */
bool  phase     = true;  /* phase shift */
float window    = 1.5;   /* window factor */

/* header definitions of a wav file */
typedef struct
{
  char     RiffID[4];
  uint32_t RiffSize;
  char     WaveID[4];
  char     FmtID[4];
  uint32_t FmtSize;
  uint16_t wFormatTag;
  uint16_t nChannels;
  uint32_t nSamplesPerSec;
  uint32_t nAvgBytesPerSec;
  uint16_t nBlockAlign;
  uint16_t wBitsPerSample;
} WAVE_HEADER;

typedef struct
{
  char     DataID[4];
  uint32_t nDataBytes;
} WAVE_BLOCK;



/* Read wav file for tape image */
int tapeRead(char* szFileName, int8_t** pBuffer, int32_t *size)
{
  FILE* wav_file;
  WAVE_HEADER header;
  WAVE_BLOCK  block;

  int  adder;
  int32_t i,j,pos;
  int8_t data;
  bool found;

  if ((wav_file=fopen(szFileName,"rb"))==NULL) return -1;

  fread(&header,sizeof(header),1,wav_file);

  /* Make header compatible with PPC micro */
  #if (BIGENDIAN)
  header.RiffSize       = BIGENDIANLONG(header.RiffSize);
  header.FmtSize        = BIGENDIANLONG(header.FmtSize);
  header.nSamplesPerSec = BIGENDIANLONG(header.nSamplesPerSec);
  header.nAvgBytesPerSec= BIGENDIANLONG(header.nAvgBytesPerSec);
  header.wFormatTag     = BIGENDIANSHORT(header.wFormatTag);
  header.nChannels      = BIGENDIANSHORT(header.nChannels);
  header.nBlockAlign    = BIGENDIANSHORT(header.nBlockAlign);
  header.wBitsPerSample = BIGENDIANSHORT(header.wBitsPerSample);
  #endif

  /* Determine how many bytes to skip in reading file for 8-bit mono */
  adder=header.nChannels*(header.wBitsPerSample/8);

  /* Search for data tag */
  found = false;
  pos = ftell(wav_file);
  while(fread(&block,sizeof(block),1,wav_file))
    if (!strncmp(block.DataID,"data",4)) {
      *size=BIGENDIANLONG(block.nDataBytes)/adder ;
      *pBuffer=(int8_t*)malloc(*size*sizeof(int8_t));
      found = true;
      break;
    } else {
      fseek(wav_file,pos++,SEEK_SET);
    }

  /* Basic error handling */
  if (!found) {
    fprintf(stderr,"Incorrect wav header!\n");
    return -1;
  }

  if (*pBuffer==NULL) {
    fprintf(stderr,"Not enough memory!\n");
    return -1;
  }

  /* Show wav info */
  printf("Reading %s (%d Hz, %d-bits, %s)...\n",
	 szFileName,
	 (int)header.nSamplesPerSec,
	 (int)header.wBitsPerSample,
	 header.nChannels==1 ? "mono" : "stereo" );

  /* Read file */
  for (i=0;i<(*size);i++) {

    for (j=1; j<adder; j++) fread(&data,sizeof(int8_t),1,wav_file);
    fread(&data,sizeof(int8_t),1,wav_file);
    if (header.wBitsPerSample==8) data^=128;
    if (phase) data=-data;
    (*pBuffer)[i]=data;
  }

  fclose(wav_file);
  return header.nSamplesPerSec;
}



/* correct envelope and denoise signal */
void correctEnvelope(int8_t **buffer,int32_t size)
{
  int32_t i;
  for (i=1;i<size-1;i++)

    (*buffer)[i] = ( 0.5*(*buffer)[i-1] +
		     1.0*(*buffer)[i]   +
		     2.0*(*buffer)[i+1]   ) / 3.5;
}



/* make signal as loud as possible */
void normalizeAmplitude(int8_t **buffer,int32_t size)
{
  int32_t i;
  int  maximum=0;
  for (i=0;i<size;i++)
    if (abs((*buffer)[i])>maximum) maximum=abs((*buffer)[i]);
  for (i=0;i<size;i++) (*buffer)[i]*=127/(float)maximum;
}



/* detect silence */
bool isSilence(int8_t *buffer,int32_t index,int32_t size)
{
  int32_t silent=0;

  while (index<size && silent<THRESHOLD_SILENCE) {

    if ((buffer[index] >= threshold ||
	 buffer[index] <= -threshold )) return false;

    silent++; index++;
  }

  return true;
}



/* skip silent parts */
void skipSilence(int8_t *buffer, int32_t *index, int32_t size)
{
  while(*index<size &&
	(buffer[*index] <= threshold &&
	 buffer[*index] >= -threshold )) (*index)++;
}



/* get the number of bytes of one pulse */
int32_t getPulseWidth(int8_t *buffer, int32_t *index, int32_t size)
{
  int min = 1000;
  int max =-1000;
  int pt  = max;

  int prev = *index > 0 ? buffer[(*index)-1] : 0;

  int32_t width = 0;
  for(;*index<size;width++) {

    /* ascending */
    if (buffer[*index]>prev) {

      if (prev==min) {

	if (pt-min>=threshold) {

	  while(width>1) {

	    if (buffer[*index]>=pt-(pt-min)/2) break;
	    width--; (*index)--;
	  }

	  return width;
	}

	min=1000;
      }

      if (buffer[*index]>max) max=buffer[*index];
    }


    /* descending */
    if (buffer[*index]<prev) {

      if (prev==max) {

	if (max>pt) pt=max;
	max=-1000;
      }

      if (buffer[*index]<min) min=buffer[*index];
    }

    prev=buffer[(*index)++];
  }

  return width;
}



/* detect headers */
bool isHeader(int8_t *buffer, int32_t index, int32_t size)
{

  int32_t width;
  int32_t pulses  = 0;
  int32_t biggest = 0;

  /* skip first pulse for phase independance */
  getPulseWidth(buffer,&index,size);

  while (index<size && pulses<THRESHOLD_HEADER ) {

    width = getPulseWidth(buffer,&index,size);
    if (!biggest) biggest=width;
    if (width>(float)biggest*window) return false;
    if (width>biggest) biggest = width;
    pulses++;
  }

  if (pulses>=THRESHOLD_HEADER) return true;

  return false;
}



/* skip header and return average with of a short pulse */
float skipHeader(int8_t *buffer, int32_t *index, int32_t size)
{

  int32_t  width;
  int32_t  count   = 0;
  float average = 0;

  /* skip first pulse for phase independance */
  getPulseWidth(buffer,index,size);

  while (*index<size) {

    width=getPulseWidth(buffer,index,size);

    if (average && width>(float)average*window ) {

	*index-=width;
	return average;
    }

    /* average=(count*average+width)/++count; */
    count++; average=((count-1)*average+width)/count;
  }

  return average;
}



/* read a byte from wave data */
int readByte(int8_t *buffer, int32_t *index, int32_t size, float average)
{
  int  bit;
  int32_t width;
  int  value = 0;
  int  i;

  /* start bit (int32_t pulse) */
  width=getPulseWidth(buffer,index,size);
  if (isSilence(buffer,*index,size) ||
      width<average*window) return -1;

  /* data bits (lsb first) */
  for (bit=0;bit<8;bit++) {

    width=getPulseWidth(buffer,index,size);
    if (isSilence(buffer,*index,size)) return -1;

    if (width<average*window) {

      value+=(1<<bit);
      getPulseWidth(buffer,index,size); /* skip 2nd short pulse */
      if (isSilence(buffer,*index,size)) return -1;
    }
  }

  /* two stop bits (four short pulses) */
  for (i=0;i<3;i++) {

    getPulseWidth(buffer,index,size);
    if (isSilence(buffer,*index,size)) return -1;
  }
  getPulseWidth(buffer,index,size);

  return value;
}



/* show a brief description */
void showUsage(char *progname)
{
  printf("usage: %s [-np] [-t threshold] [-w window] [-e envelope] <ifile> <ofile>\n"
	 " -n   normalize amplitude level\n"
	 " -p   phase shift signal\n"
	 " -w   window factor (default:%.1f)\n"
	 " -e   level of envelope correction (default:%d)\n"
	 " -t   threshold factor (default:%d)\n"
	 ,progname,window,envelope,threshold);
}



int main(int argc, char* argv[])
{
  FILE *output;
  int8_t *buffer;
  int32_t frequency,size,index,written;
  float average;
  int   data,i,j;
  bool  header;

  char  *ifile = NULL;
  char  *ofile = NULL;

  /* parse command line options */
  for (i=1; i<argc; i++) {

    if (argv[i][0]=='-') {

      for(j=1;j && argv[i][j]!='\0';j++)

	switch(argv[i][j]) {

	case 'n': normalize=true; break;
	case 'p': phase=false; break;
	case 'w': window=atof(argv[++i]);    j=-1; break;
	case 't': threshold=atoi(argv[++i]); j=-1; break;
	case 'e': envelope=atoi(argv[++i]);  j=-1; break;

	default:
	  fprintf(stderr,"%s: invalid option\n",argv[0]);
	  exit(1);
	}

      continue;
    }

    if (ifile==NULL) { ifile=argv[i]; continue; }
    if (ofile==NULL) { ofile=argv[i]; continue; }

    fprintf(stderr,"%s: invalid option\n",argv[0]);
    exit(1);
  }

  if (ifile==NULL || ofile==NULL) { showUsage(argv[0]); exit(1); }

  /* read the sample data and store it in buffer */
  frequency=tapeRead(ifile,&buffer,&size);
  if (frequency<0) {

    fprintf(stderr,"%s: failed reading %s\n",argv[0],ifile);
    exit(1);
  }

  /* open/create the output data file */
  if ((output=fopen(ofile,"wb"))==NULL) {

    fprintf(stderr,"%s: failed writing %s\n",argv[0],ofile);
    exit(1);
  }

  /* work on signal first */
  if (normalize) normalizeAmplitude(&buffer,size);
  for(i=0;i<envelope;i++) correctEnvelope(&buffer,size);

  /* let's do it */
  printf("Decoding audio data...\n");

  /* sample probably starts with some silence before the data, skip it */
  written=index=0;
  skipSilence(buffer,&index,size);

  header=false;
  /* loop through all audio data and extract the contents */
  for (;index<size;index++) {

    /* detect silent parts and skip them */
    if (isSilence(buffer,index,size)) {

      printf("[%.1f] skipping silence\n",(double)index/frequency);
      skipSilence(buffer,&index,size);
    }

    /* detect header and proces the data block followed */
    if (isHeader(buffer,index,size)) {

      printf("[%.1f] header detected\n",(double)index/frequency);
      average=skipHeader(buffer,&index,size);

      /* write .cas header if none already written */
      if (!header) {

	/* .cas headers always start at fixed positions */
	for (;written&7;written++) putc(0x00,output);

	/* write a .cas header */
	putc(0x1f,output); putc(0xa6,output);
	putc(0xde,output); putc(0xba,output);
	putc(0xcc,output); putc(0x13,output);
	putc(0x7d,output); putc(0x74,output);
	written+=8;
	header=true;
      }

      printf("[%.1f] data block\n",(double)index/frequency);

      while (!isSilence(buffer,index,size) && index<size) {
	data=readByte(buffer,&index,size,average);
	if (data>=0) { putc(data,output); written++; header=false; }
	else break;
      }

    } else {

      /* data found without a header, skip it */
      printf("[%.1f] skipping headerless data\n",(double)index/frequency);
      while(!isSilence(buffer,index,size) && index<size ) index++;
    }

  }

  fclose(output);
  free(buffer);

  printf("All done...\n");
  return 0;
}