src/tx16w.c

   1 /* libSoX Yamaha TX-16W sampler file support
   2  *
   3  * May 20, 1993
   4  * Copyright 1993 Rob Talley   (rob@aii.com)
   5  * This source code is freely redistributable and may be used for
   6  * any purpose. This copyright notice and the following copyright
   7  * notice must be maintained intact. No warranty whatsoever is
   8  * provided. This code is furnished AS-IS as a component of the
   9  * larger work Copyright 1991 Lance Norskog and Sundry Contributors.
  10  * Much appreciation to ross-c  for his sampConv utility for SGI/IRIX
  11  * from where these methods were derived.
  12  *
  13  * Jan 24, 1994
  14  * Pat McElhatton, HP Media Technology Lab <patmc@apollo.hp.com>
  15  * Handles reading of files which do not have the sample rate field
  16  * set to one of the expected by looking at some other bytes in the
  17  * attack/loop length fields, and defaulting to 33kHz if the sample
  18  * rate is still unknown.
  19  *
  20  * January 12, 1995
  21  * Copyright 1995 Mark Lakata (lakata@physics.berkeley.edu)
  22  * Additions to tx16w.c SOX handler.  This version writes as well as
  23  * reads TX16W format.
  24  *
  25  * July 31, 1998
  26  * Cleaned up by Leigh Smith (leigh@psychokiller.dialix.oz.au)
  27  * for incorporation into the main sox distribution.
  28  *
  29  * September 24, 1998
  30  * Forced output to mono signed words to match input.  It was basically
  31  * doing this anyways but now the user will see a display that it's been
  32  * overridden.  cbagwell@sprynet.com
  33  *
  34  */
  35
  36 #include "sox_i.h"
  37 #include <stdio.h>
  38 #include <string.h>
  39
  40 #define TXMAXLEN 0x3FF80
  41
  42 /* Private data for TX16 file */
  43 typedef struct {
  44   size_t   samples_out;
  45   size_t   bytes_out;
  46   size_t   rest;                 /* bytes remaining in sample file */
  47   sox_sample_t odd;
  48   sox_bool     odd_flag;
  49 } priv_t;
  50
  51 struct WaveHeader_ {
  52   char filetype[6]; /* = "LM8953", */
  53   unsigned char
  54     nulls[10],
  55     dummy_aeg[6],    /* space for the AEG (never mind this) */
  56     format,          /* 0x49 = looped, 0xC9 = non-looped */
  57     sample_rate,     /* 1 = 33 kHz, 2 = 50 kHz, 3 = 16 kHz */
  58     atc_length[3],   /* I'll get to this... */
  59     rpt_length[3],
  60     unused[2];       /* set these to null, to be on the safe side */
  61 };
  62
  63 static const unsigned char magic1[4] = {0, 0x06, 0x10, 0xF6};
  64 static const unsigned char magic2[4] = {0, 0x52, 0x00, 0x52};
  65
  66 /*
  67  * Do anything required before you start reading samples.
  68  * Read file header.
  69  *      Find out sampling rate,
  70  *      size and encoding of samples,
  71  *      mono/stereo/quad.
  72  */
  73 static int startread(sox_format_t * ft)
  74 {
  75     int c;
  76     char filetype[7];
  77     int8_t format;
  78     unsigned char sample_rate;
  79     size_t num_samp_bytes = 0;
  80     unsigned char gunk[8];
  81     int blewIt;
  82     uint8_t trash;
  83
  84     priv_t * sk = (priv_t *) ft->priv;
  85     /* If you need to seek around the input file. */
  86     if (! ft->seekable)
  87     {
  88         lsx_fail_errno(ft,SOX_EOF,"txw input file must be a file, not a pipe");
  89         return(SOX_EOF);
  90     }
  91
  92     /* This is dumb but portable, just count the bytes til EOF */
  93     while (lsx_read_b_buf(ft, &trash, (size_t) 1) == 1)
  94         num_samp_bytes++;
  95     num_samp_bytes -= 32;         /* calculate num samples by sub header size */
  96     lsx_seeki(ft, (off_t)0, 0);   /* rewind file */
  97     sk->rest = num_samp_bytes;    /* set how many sample bytes to read */
  98
  99     /* first 6 bytes are file type ID LM8953 */
 100     lsx_readchars(ft, filetype, sizeof(filetype) - 1);
 101     filetype[6] = '\0';
 102     for( c = 16; c > 0 ; c-- )    /* Discard next 16 bytes */
 103         lsx_readb(ft, &trash);
 104     lsx_readsb(ft, &format);
 105     lsx_readb(ft, &sample_rate);
 106     /*
 107      * save next 8 bytes - if sample rate is 0, then we need
 108      *  to look at gunk[2] and gunk[5] to get real rate
 109      */
 110     for( c = 0; c < 8; c++ )
 111         lsx_readb(ft, &(gunk[c]));
 112     /*
 113      * We should now be pointing at start of raw sample data in file
 114      */
 115
 116     /* Check to make sure we got a good filetype ID from file */
 117     lsx_debug("Found header filetype %s",filetype);
 118     if(strcmp(filetype,"LM8953"))
 119     {
 120         lsx_fail_errno(ft,SOX_EHDR,"Invalid filetype ID in input file header, != LM8953");
 121         return(SOX_EOF);
 122     }
 123     /*
 124      * Set up the sample rate as indicated by the header
 125      */
 126
 127     switch( sample_rate ) {
 128         case 1:
 129             ft->signal.rate = 1e5 / 3;
 130             break;
 131         case 2:
 132             ft->signal.rate = 1e5 / 2;
 133             break;
 134         case 3:
 135             ft->signal.rate = 1e5 / 6;
 136             break;
 137         default:
 138             blewIt = 1;
 139             switch( gunk[2] & 0xFE ) {
 140                 case 0x06:
 141                     if ( (gunk[5] & 0xFE) == 0x52 ) {
 142                         blewIt = 0;
 143                         ft->signal.rate = 1e5 / 3;
 144                     }
 145                     break;
 146                 case 0x10:
 147                     if ( (gunk[5] & 0xFE) == 0x00 ) {
 148                         blewIt = 0;
 149                         ft->signal.rate = 1e5 / 2;
 150                     }
 151                     break;
 152                 case 0xF6:
 153                     if ( (gunk[5] & 0xFE) == 0x52 ) {
 154                         blewIt = 0;
 155                         ft->signal.rate = 1e5 / 6;
 156                     }
 157                     break;
 158             }
 159             if ( blewIt ) {
 160                 lsx_debug("Invalid sample rate identifier found %d", sample_rate);
 161                 ft->signal.rate = 1e5 / 3;
 162             }
 163     }
 164     lsx_debug("Sample rate = %g", ft->signal.rate);
 165
 166     ft->signal.channels = 1 ; /* not sure about stereo sample data yet ??? */
 167     ft->encoding.bits_per_sample = 12;
 168     ft->encoding.encoding = SOX_ENCODING_SIGN2;
 169
 170     return(SOX_SUCCESS);
 171 }
 172
 173 /*
 174  * Read up to len samples from file.
 175  * Convert to sox_sample_t.
 176  * Place in buf[].
 177  * Return number of samples read.
 178  */
 179
 180 static size_t read_samples(sox_format_t * ft, sox_sample_t *buf, size_t len)
 181 {
 182     priv_t * sk = (priv_t *) ft->priv;
 183     size_t done = 0;
 184     unsigned char uc1,uc2,uc3;
 185     unsigned short s1,s2;
 186
 187     /*
 188      * This gets called by the top level 'process' routine.
 189      * We will essentially get called with a buffer pointer
 190      * and a max length to read. Graciously, it is always
 191      * an even amount so we don't have to worry about
 192      * hanging onto the left over odd samples since there
 193      * won't be any. Something to look out for though :-(
 194      * We return the number of samples we read.
 195      * We will get called over and over again until we return
 196      *  0 bytes read.
 197      */
 198
 199     /*
 200      * This is ugly but it's readable!
 201      * Read three bytes from stream, then decompose these into
 202      * two unsigned short samples.
 203      * TCC 3.0 appeared to do unwanted things, so we really specify
 204      *  exactly what we want to happen.
 205      * Convert unsigned short to sox_sample_t then shift up the result
 206      *  so that the 12-bit sample lives in the most significant
 207      *  12-bits of the sox_sample_t.
 208      * This gets our two samples into the internal format which we
 209      * deposit into the given buffer and adjust our counts respectivly.
 210      */
 211     for(done = 0; done < len; ) {
 212         if(sk->rest < 3) break; /* Finished reading from file? */
 213         lsx_readb(ft, &uc1);
 214         lsx_readb(ft, &uc2);
 215         lsx_readb(ft, &uc3);
 216         sk->rest -= 3; /* adjust remaining for bytes we just read */
 217         s1 = (unsigned short) (uc1 << 4) | (((uc2 >> 4) & 017));
 218         s2 = (unsigned short) (uc3 << 4) | (( uc2 & 017 ));
 219         *buf = (sox_sample_t) s1;
 220         *buf = (*buf << 20);
 221         buf++; /* sample one is done */
 222         *buf = (sox_sample_t) s2;
 223         *buf = (*buf << 20);
 224         buf++; /* sample two is done */
 225         done += 2; /* adjust converted & stored sample count */
 226     }
 227     return done;
 228 }
 229
 230 static int startwrite(sox_format_t * ft)
 231 {
 232   priv_t * sk = (priv_t *) ft->priv;
 233     struct WaveHeader_ WH;
 234
 235     lsx_debug("tx16w selected output");
 236
 237     memset(&WH, 0, sizeof(struct WaveHeader_));
 238
 239     /* If you have to seek around the output file */
 240     if (! ft->seekable)
 241     {
 242         lsx_fail_errno(ft,SOX_EOF,"Output .txw file must be a file, not a pipe");
 243         return(SOX_EOF);
 244     }
 245
 246     /* dummy numbers, just for place holder, real header is written
 247        at end of processing, since byte count is needed */
 248
 249     lsx_writebuf(ft, &WH, (size_t) 32);
 250     sk->bytes_out = 32;
 251     return(SOX_SUCCESS);
 252 }
 253
 254 static size_t write_samples(sox_format_t * ft, const sox_sample_t *buf, size_t len0)
 255 {
 256   priv_t * sk = (priv_t *) ft->priv;
 257   size_t last_i, i = 0, len = min(len0, TXMAXLEN - sk->samples_out);
 258   sox_sample_t w1, w2;
 259
 260   while (i < len) {
 261     last_i = i;
 262     if (sk->odd_flag) {
 263       w1 = sk->odd;
 264       sk->odd_flag = sox_false;
 265     }
 266     else w1 = *buf++ >> 20, ++i;
 267
 268     if (i < len) {
 269       w2 = *buf++ >> 20, ++i;
 270       if (lsx_writesb(ft, (w1 >> 4) & 0xFF) ||
 271           lsx_writesb(ft, (((w1 & 0x0F) << 4) | (w2 & 0x0F)) & 0xFF) ||
 272           lsx_writesb(ft, (w2 >> 4) & 0xFF)) {
 273         i = last_i;
 274         break;
 275       }
 276       sk->samples_out += 2;
 277       sk->bytes_out += 3;
 278     }
 279     else {
 280       sk->odd = w1;
 281       sk->odd_flag = sox_true;
 282     }
 283   }
 284   return i;
 285 }
 286
 287 static int stopwrite(sox_format_t * ft)
 288 {
 289   priv_t * sk = (priv_t *) ft->priv;
 290     struct WaveHeader_ WH;
 291     int AttackLength, LoopLength, i;
 292
 293     if (sk->odd_flag) {
 294       sox_sample_t pad = 0;
 295       write_samples(ft, &pad, (size_t) 1);
 296     }
 297
 298     /* All samples are already written out. */
 299     /* If file header needs fixing up, for example it needs the */
 300     /* the number of samples in a field, seek back and write them here. */
 301
 302     lsx_debug("tx16w:output finished");
 303
 304     memset(&WH, 0, sizeof(struct WaveHeader_));
 305     memcpy(WH.filetype, "LM8953", 6);
 306     for (i=0;i<10;i++) WH.nulls[i]=0;
 307     for (i=0;i<6;i++)  WH.dummy_aeg[i]=0;
 308     for (i=0;i<2;i++)  WH.unused[i]=0;
 309     for (i=0;i<2;i++)  WH.dummy_aeg[i] = 0;
 310     for (i=2;i<6;i++)  WH.dummy_aeg[i] = 0x7F;
 311
 312     WH.format = 0xC9;   /* loop off */
 313
 314     /* the actual sample rate is not that important ! */
 315     if (ft->signal.rate < 24000)      WH.sample_rate = 3;
 316     else if (ft->signal.rate < 41000) WH.sample_rate = 1;
 317     else                            WH.sample_rate = 2;
 318
 319     if (sk->samples_out >= TXMAXLEN) {
 320         lsx_warn("Sound too large for TX16W. Truncating, Loop Off");
 321         AttackLength       = TXMAXLEN/2;
 322         LoopLength         = TXMAXLEN/2;
 323     }
 324     else if (sk->samples_out >=TXMAXLEN/2) {
 325         AttackLength       = TXMAXLEN/2;
 326         LoopLength         = sk->samples_out - TXMAXLEN/2;
 327         if (LoopLength < 0x40) {
 328             LoopLength   +=0x40;
 329             AttackLength -= 0x40;
 330         }
 331     }
 332     else if (sk->samples_out >= 0x80) {
 333         AttackLength                       = sk->samples_out -0x40;
 334         LoopLength                         = 0x40;
 335     }
 336     else {
 337         AttackLength                       = 0x40;
 338         LoopLength                         = 0x40;
 339         for(i=sk->samples_out;i<0x80;i++) {
 340             lsx_writeb(ft, 0);
 341             lsx_writeb(ft, 0);
 342             lsx_writeb(ft, 0);
 343             sk->bytes_out += 3;
 344         }
 345     }
 346
 347     /* Fill up to 256 byte blocks; the TX16W seems to like that */
 348
 349     while ((sk->bytes_out % 0x100) != 0) {
 350         lsx_writeb(ft, 0);
 351         sk->bytes_out++;
 352     }
 353
 354     WH.atc_length[0] = 0xFF & AttackLength;
 355     WH.atc_length[1] = 0xFF & (AttackLength >> 8);
 356     WH.atc_length[2] = (0x01 & (AttackLength >> 16)) +
 357         magic1[WH.sample_rate];
 358
 359     WH.rpt_length[0] = 0xFF & LoopLength;
 360     WH.rpt_length[1] = 0xFF & (LoopLength >> 8);
 361     WH.rpt_length[2] = (0x01 & (LoopLength >> 16)) +
 362         magic2[WH.sample_rate];
 363
 364     lsx_rewind(ft);
 365     lsx_writebuf(ft, &WH, (size_t) 32);
 366
 367     return(SOX_SUCCESS);
 368 }
 369
 370 LSX_FORMAT_HANDLER(txw)
 371 {
 372   static char const * const names[] = {"txw", NULL};
 373   static sox_rate_t   const write_rates[] = {1e5/6, 1e5/3, 1e5/2, 0};
 374   static unsigned const write_encodings[] = {SOX_ENCODING_SIGN2, 12, 0, 0};
 375   static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
 376     "Yamaha TX-16W sampler", names, SOX_FILE_MONO,
 377     startread, read_samples, NULL,
 378     startwrite, write_samples, stopwrite,
 379     NULL, write_encodings, write_rates, sizeof(priv_t)
 380   };
 381   return &handler;
 382 }