src/voc.c

   1 /* libSoX Sound Blaster VOC handler sources.
   2  * Copyright 1991 Lance Norskog And Sundry Contributors
   3  *
   4  * This source code is freely redistributable and may be used for
   5  * any purpose.  This copyright notice must be maintained.
   6  * Lance Norskog And Sundry Contributors are not responsible for
   7  * the consequences of using this software.
   8  *
   9  * September 8, 1993
  10  * Copyright 1993 T. Allen Grider - for changes to support block type 9
  11  * and word sized samples.  Same caveats and disclaimer as above.
  12  *
  13  * February 22, 1996
  14  * by Chris Bagwell (cbagwell@sprynet.com)
  15  * Added support for block type 8 (extended) which allows for 8-bit stereo
  16  * files.  Added support for saving stereo files and 16-bit files.
  17  * Added VOC format info from audio format FAQ so I don't have to keep
  18  * looking around for it.
  19  *
  20  * February 5, 2001
  21  * For sox-12-17 by Annonymous (see notes ANN)
  22  * Added comments and notes for each procedure.
  23  * Fixed so this now works with pipes, input does not have to
  24  * be seekable anymore (in startread() )
  25  * Added support for uLAW and aLaw (aLaw not tested).
  26  * Fixed support of multi-part VOC files, and files with
  27  * block 9 but no audio in the block....
  28  * The following need to be tested:  16-bit, 2 channel, and aLaw.
  29  *
  30  * December 10, 2001
  31  * For sox-12-17-3 by Annonymous (see notes ANN)
  32  * Patch for sox-12-17 merged with sox-12-17-3-pre3 code.
  33  *
  34  */
  35
  36 /*------------------------------------------------------------------------
  37 The following is taken from the Audio File Formats FAQ dated 2-Jan-1995
  38 and submitted by Guido van Rossum <guido@cwi.nl>.
  39 --------------------------------------------------------------------------
  40 Creative Voice (VOC) file format
  41 --------------------------------
  42
  43 From: galt@dsd.es.com
  44
  45 (byte numbers are hex!)
  46
  47     HEADER (bytes 00-19)
  48     Series of DATA BLOCKS (bytes 1A+) [Must end w/ Terminator Block]
  49
  50 - ---------------------------------------------------------------
  51
  52 HEADER:
  53 -------
  54      byte #     Description
  55      ------     ------------------------------------------
  56      00-12      "Creative Voice File"
  57      13         1A (eof to abort printing of file)
  58      14-15      Offset of first datablock in .voc file (std 1A 00
  59                 in Intel Notation)
  60      16-17      Version number (minor,major) (VOC-HDR puts 0A 01)
  61      18-19      2's Comp of Ver. # + 1234h (VOC-HDR puts 29 11)
  62
  63 - ---------------------------------------------------------------
  64
  65 DATA BLOCK:
  66 -----------
  67
  68    Data Block:  TYPE(1-byte), SIZE(3-bytes), INFO(0+ bytes)
  69    NOTE: Terminator Block is an exception -- it has only the TYPE byte.
  70
  71       TYPE   Description     Size (3-byte int)   Info
  72       ----   -----------     -----------------   -----------------------
  73       00     Terminator      (NONE)              (NONE)
  74       01     Sound data      2+length of data    *
  75       02     Sound continue  length of data      Voice Data
  76       03     Silence         3                   **
  77       04     Marker          2                   Marker# (2 bytes)
  78       05     ASCII           length of string    null terminated string
  79       06     Repeat          2                   Count# (2 bytes)
  80       07     End repeat      0                   (NONE)
  81       08     Extended        4                   ***
  82       09     New Header      16                  see below
  83
  84
  85       *Sound Info Format:       **Silence Info Format:
  86        ---------------------      ----------------------------
  87        00   Sample Rate           00-01  Length of silence - 1
  88        01   Compression Type      02     Sample Rate
  89        02+  Voice Data
  90
  91     ***Extended Info Format:
  92        ---------------------
  93        00-01  Time Constant: Mono: 65536 - (256000000/sample_rate)
  94                              Stereo: 65536 - (25600000/(2*sample_rate))
  95        02     Pack
  96        03     Mode: 0 = mono
  97                     1 = stereo
  98
  99
 100   Marker#           -- Driver keeps the most recent marker in a status byte
 101   Count#            -- Number of repetitions + 1
 102                          Count# may be 1 to FFFE for 0 - FFFD repetitions
 103                          or FFFF for endless repetitions
 104   Sample Rate       -- SR byte = 256-(1000000/sample_rate)
 105   Length of silence -- in units of sampling cycle
 106   Compression Type  -- of voice data
 107                          8-bits    = 0
 108                          4-bits    = 1
 109                          2.6-bits  = 2
 110                          2-bits    = 3
 111                          Multi DAC = 3+(# of channels) [interesting--
 112                                        this isn't in the developer's manual]
 113
 114 Detailed description of new data blocks (VOC files version 1.20 and above):
 115
 116         (Source is fax from Barry Boone at Creative Labs, 405/742-6622)
 117
 118 BLOCK 8 - digitized sound attribute extension, must preceed block 1.
 119           Used to define stereo, 8 bit audio
 120         BYTE bBlockID;       // = 8
 121         BYTE nBlockLen[3];   // 3 byte length
 122         WORD wTimeConstant;  // time constant = same as block 1
 123         BYTE bPackMethod;    // same as in block 1
 124         BYTE bVoiceMode;     // 0-mono, 1-stereo
 125
 126         Data is stored left, right
 127
 128 BLOCK 9 - data block that supersedes blocks 1 and 8.
 129           Used for stereo, 16 bit (and uLaw, aLaw).
 130
 131         BYTE bBlockID;          // = 9
 132         BYTE nBlockLen[3];      // length 12 plus length of sound
 133         DWORD dwSamplesPerSec;  // samples per second, not time const.
 134         BYTE bBitsPerSample;    // e.g., 8 or 16
 135         BYTE bChannels;         // 1 for mono, 2 for stereo
 136         WORD wFormat;           // see below
 137         BYTE reserved[4];       // pad to make block w/o data
 138                                 // have a size of 16 bytes
 139
 140         Valid values of wFormat are:
 141
 142                 0x0000  8-bit unsigned PCM
 143                 0x0001  Creative 8-bit to 4-bit ADPCM
 144                 0x0002  Creative 8-bit to 3-bit ADPCM
 145                 0x0003  Creative 8-bit to 2-bit ADPCM
 146                 0x0004  16-bit signed PCM
 147                 0x0006  CCITT a-Law
 148                 0x0007  CCITT u-Law
 149                 0x02000 Creative 16-bit to 4-bit ADPCM
 150
 151         Data is stored left, right
 152
 153         ANN:  Multi-byte quantities are in Intel byte order (Little Endian).
 154
 155 ------------------------------------------------------------------------*/
 156
 157 #include "sox_i.h"
 158 #include "g711.h"
 159 #include "adpcms.h"
 160 #include <assert.h>
 161 #include <string.h>
 162
 163 /* Private data for VOC file */
 164 typedef struct {
 165   long block_remaining;         /* bytes remaining in current block */
 166   long rate;                    /* rate code (byte) of this chunk */
 167   int silent;                   /* sound or silence? */
 168   long srate;                   /* rate code (byte) of silence */
 169   size_t blockseek;         /* start of current output block */
 170   long samples;                 /* number of samples output */
 171   uint16_t format;              /* VOC audio format */
 172   int size;                     /* word length of data */
 173   unsigned char channels;       /* number of sound channels */
 174   long total_size;              /* total size of all audio in file */
 175   int extended;                 /* Has an extended block been read? */
 176   adpcm_t adpcm;
 177 } priv_t;
 178
 179 #define VOC_TERM        0
 180 #define VOC_DATA        1
 181 #define VOC_CONT        2
 182 #define VOC_SILENCE     3
 183 #define VOC_MARKER      4
 184 #define VOC_TEXT        5
 185 #define VOC_LOOP        6
 186 #define VOC_LOOPEND     7
 187 #define VOC_EXTENDED    8
 188 #define VOC_DATA_16     9
 189
 190 /* ANN:  Format encoding types */
 191 #define VOC_FMT_LIN8U          0        /* 8 bit unsigned linear PCM */
 192 #define VOC_FMT_CRLADPCM4      1        /* Creative 8-bit to 4-bit ADPCM */
 193 #define VOC_FMT_CRLADPCM3      2        /* Creative 8-bit to 3-bit ADPCM */
 194 #define VOC_FMT_CRLADPCM2      3        /* Creative 8-bit to 2-bit ADPCM */
 195 #define VOC_FMT_LIN16          4        /* 16-bit signed PCM */
 196 #define VOC_FMT_ALAW           6        /* CCITT a-Law 8-bit PCM */
 197 #define VOC_FMT_MU255          7        /* CCITT u-Law 8-bit PCM */
 198 #define VOC_FMT_CRLADPCM4A 0x200        /* Creative 16-bit to 4-bit ADPCM */
 199
 200 /* Prototypes for internal functions */
 201 static int getblock(sox_format_t *);
 202 static void blockstart(sox_format_t *);
 203
 204 /* Conversion macros (from raw.c) */
 205 #define SOX_ALAW_BYTE_TO_SAMPLE(d) ((sox_sample_t)(sox_alaw2linear16(d)) << 16)
 206 #define SOX_ULAW_BYTE_TO_SAMPLE(d) ((sox_sample_t)(sox_ulaw2linear16(d)) << 16)
 207
 208 /* public VOC functions for SOX */
 209
 210 /*-----------------------------------------------------------------
 211  * startread() -- start reading a VOC file
 212  *-----------------------------------------------------------------*/
 213 static int startread(sox_format_t * ft)
 214 {
 215   char header[20];
 216   priv_t * v = (priv_t *) ft->priv;
 217   unsigned short sbseek;
 218   int rc;
 219   int ii;                       /* for getting rid of lseek */
 220   unsigned char uc;
 221
 222   if (lsx_readbuf(ft, header, (size_t)20) != 20) {
 223     lsx_fail_errno(ft, SOX_EHDR, "unexpected EOF in VOC header");
 224     return (SOX_EOF);
 225   }
 226   if (strncmp(header, "Creative Voice File\032", (size_t)19)) {
 227     lsx_fail_errno(ft, SOX_EHDR, "VOC file header incorrect");
 228     return (SOX_EOF);
 229   }
 230
 231   /* read the offset to data, from start of file */
 232   /* after this read we have read 20 bytes of header + 2 */
 233   lsx_readw(ft, &sbseek);
 234
 235   /* ANN:  read to skip the header, instead of lseek */
 236   /* this should allow use with pipes.... */
 237   for (ii = 22; ii < sbseek; ii++)
 238     lsx_readb(ft, &uc);
 239
 240   v->rate = -1;
 241   v->block_remaining = 0;
 242   v->total_size = 0;    /* ANN added */
 243   v->extended = 0;
 244
 245   /* read until we get the format information.... */
 246   rc = getblock(ft);
 247   if (rc)
 248     return rc;
 249
 250   /* get rate of data */
 251   if (v->rate == -1) {
 252     lsx_fail_errno(ft, SOX_EOF, "Input .voc file had no sound!");
 253     return (SOX_EOF);
 254   }
 255
 256   /* setup word length of data */
 257
 258   /* ANN:  Check VOC format and map to the proper libSoX format value */
 259   switch (v->format) {
 260     case VOC_FMT_LIN8U:        /*     0    8 bit unsigned linear PCM */
 261       ft->encoding.encoding = SOX_ENCODING_UNSIGNED;
 262       v->size = 8;
 263       break;
 264     case VOC_FMT_CRLADPCM4:    /*     1    Creative 8-bit to 4-bit ADPCM */
 265       ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
 266       v->size = 4;
 267       break;
 268     case VOC_FMT_CRLADPCM3:    /*     2    Creative 8-bit to 3-bit ADPCM */
 269       ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
 270       v->size = 3;
 271       break;
 272     case VOC_FMT_CRLADPCM2:    /*     3    Creative 8-bit to 2-bit ADPCM */
 273       ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
 274       v->size = 2;
 275       break;
 276     case VOC_FMT_LIN16:        /*     4    16-bit signed PCM */
 277       ft->encoding.encoding = SOX_ENCODING_SIGN2;
 278       v->size = 16;
 279       break;
 280     case VOC_FMT_ALAW: /*     6    CCITT a-Law 8-bit PCM */
 281       ft->encoding.encoding = SOX_ENCODING_ALAW;
 282       v->size = 8;
 283       break;
 284     case VOC_FMT_MU255:        /*     7    CCITT u-Law 8-bit PCM */
 285       ft->encoding.encoding = SOX_ENCODING_ULAW;
 286       v->size = 8;
 287       break;
 288     case VOC_FMT_CRLADPCM4A:   /*0x200    Creative 16-bit to 4-bit ADPCM */
 289       ft->encoding.encoding = SOX_ENCODING_CL_ADPCM16;
 290       v->size = 4;
 291       break;
 292     default:
 293       lsx_fail("Unknown VOC format %d", v->format);
 294       break;
 295   }
 296   ft->encoding.bits_per_sample = v->size;
 297
 298   /* setup number of channels */
 299   if (ft->signal.channels == 0)
 300     ft->signal.channels = v->channels;
 301
 302   return (SOX_SUCCESS);
 303 }
 304
 305 /*-----------------------------------------------------------------
 306  * read() -- read data from a VOC file
 307  * ANN:  Major changes here to support multi-part files and files
 308  *       that do not have audio in block 9's.
 309  *-----------------------------------------------------------------*/
 310 static size_t read_samples(sox_format_t * ft, sox_sample_t * buf,
 311                                size_t len)
 312 {
 313   priv_t * v = (priv_t *) ft->priv;
 314   size_t done = 0;
 315   int rc = 0;
 316   int16_t sw;
 317   unsigned char uc;
 318
 319   if (v->block_remaining == 0) {        /* handle getting another cont. buffer */
 320     rc = getblock(ft);
 321     if (rc)
 322       return 0;
 323   }
 324
 325   if (v->block_remaining == 0)  /* if no more data, return 0, i.e., done */
 326     return 0;
 327
 328   if (v->silent) {
 329     for (; v->block_remaining && (done < len); v->block_remaining--, done++)
 330       *buf++ = 0;       /* Fill in silence */
 331   } else {      /* not silence; read len samples of audio from the file */
 332     size_t per = max(1, 9 / v->size);
 333
 334     for (; (done + per <= len); done += per) {
 335       if (v->block_remaining == 0) {    /* IF no more in this block, get another */
 336         while (v->block_remaining == 0) {       /* until have either EOF or a block with data */
 337           rc = getblock(ft);
 338           if (rc)
 339             break;
 340         }
 341         if (rc) /* IF EOF, break out, no more data, next will return 0 */
 342           break;
 343       }
 344
 345       /* Read the data in the file */
 346       if (v->size <= 4) {
 347         if (!v->adpcm.setup.sign) {
 348           SOX_SAMPLE_LOCALS;
 349           if (lsx_readb(ft, &uc) == SOX_EOF) {
 350             lsx_warn("VOC input: short file");
 351             v->block_remaining = 0;
 352             return done;
 353           }
 354           *buf = SOX_UNSIGNED_8BIT_TO_SAMPLE(uc,);
 355           lsx_adpcm_init(&v->adpcm, 6 - v->size, SOX_SAMPLE_TO_SIGNED_16BIT(*buf, ft->clips));
 356           ++buf;
 357           --v->block_remaining;
 358           ++done;
 359         }
 360         if (lsx_readb(ft, &uc) == SOX_EOF) {
 361           lsx_warn("VOC input: short file");
 362           v->block_remaining = 0;
 363           return done;
 364         }
 365         switch (v->size) {
 366           case 2:
 367             if (v->format == VOC_FMT_CRLADPCM2) {
 368               int u = uc;
 369
 370               *buf++ =
 371                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 6, &v->adpcm),);
 372               *buf++ =
 373                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 4, &v->adpcm),);
 374               *buf++ =
 375                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 2, &v->adpcm),);
 376               *buf++ =
 377                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u     , &v->adpcm),);
 378             }
 379             break;
 380           case 3:
 381             if (v->format == VOC_FMT_CRLADPCM3) {
 382               int u = uc;
 383
 384               *buf++ =
 385                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 5, &v->adpcm),);
 386               *buf++ =
 387                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 2, &v->adpcm),);
 388               *buf++ =                              /* A bit from nowhere! */
 389                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u << 1, &v->adpcm),);
 390             }
 391             break;
 392           case 4:
 393             if (v->format == VOC_FMT_CRLADPCM4) {
 394               int u = uc;
 395
 396               *buf++ =
 397                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 4, &v->adpcm),);
 398               *buf++ =
 399                   SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u     , &v->adpcm),);
 400             }
 401             break;
 402         }
 403       } else
 404         switch (v->size) {
 405           case 8:
 406             if (lsx_readb(ft, &uc) == SOX_EOF) {
 407               lsx_warn("VOC input: short file");
 408               v->block_remaining = 0;
 409               return done;
 410             }
 411             if (v->format == VOC_FMT_MU255) {
 412               *buf++ = SOX_ULAW_BYTE_TO_SAMPLE(uc);
 413             } else if (v->format == VOC_FMT_ALAW) {
 414               *buf++ = SOX_ALAW_BYTE_TO_SAMPLE(uc);
 415             } else {
 416               *buf++ = SOX_UNSIGNED_8BIT_TO_SAMPLE(uc,);
 417             }
 418             break;
 419           case 16:
 420             lsx_readsw(ft, &sw);
 421             if (lsx_eof(ft)) {
 422               lsx_warn("VOC input: short file");
 423               v->block_remaining = 0;
 424               return done;
 425             }
 426             *buf++ = SOX_SIGNED_16BIT_TO_SAMPLE(sw,);
 427             v->block_remaining--;       /* Processed 2 bytes so update */
 428             break;
 429         }
 430       /* decrement count of processed bytes */
 431       v->block_remaining--;
 432     }
 433   }
 434   v->total_size += done;
 435   return done;
 436 }
 437
 438
 439 /* When saving samples in VOC format the following outline is followed:
 440  * If an 8-bit mono sample then use a VOC_DATA header.
 441  * If an 8-bit stereo sample then use a VOC_EXTENDED header followed
 442  * by a VOC_DATA header.
 443  * If a 16-bit sample (either stereo or mono) then save with a
 444  * VOC_DATA_16 header.
 445  *
 446  * ANN:  Not supported:  uLaw and aLaw output VOC files....
 447  *
 448  * This approach will cause the output to be an its most basic format
 449  * which will work with the oldest software (eg. an 8-bit mono sample
 450  * will be able to be played with a really old SB VOC player.)
 451  */
 452 static int startwrite(sox_format_t * ft)
 453 {
 454   priv_t * v = (priv_t *) ft->priv;
 455
 456   if (!ft->seekable) {
 457     lsx_fail_errno(ft, SOX_EOF,
 458                    "Output .voc file must be a file, not a pipe");
 459     return (SOX_EOF);
 460   }
 461
 462   v->samples = 0;
 463
 464   /* File format name and a ^Z (aborts printing under DOS) */
 465   lsx_writes(ft, "Creative Voice File\032");
 466   lsx_writew(ft, 26);   /* size of header */
 467   lsx_writew(ft, 0x10a);        /* major/minor version number */
 468   lsx_writew(ft, 0x1129);       /* checksum of version number */
 469
 470   return (SOX_SUCCESS);
 471 }
 472
 473 /*-----------------------------------------------------------------
 474  * write() -- write a VOC file
 475  *-----------------------------------------------------------------*/
 476 static size_t write_samples(sox_format_t * ft, const sox_sample_t * buf,
 477                                 size_t len)
 478 {
 479   priv_t * v = (priv_t *) ft->priv;
 480   unsigned char uc;
 481   int16_t sw;
 482   size_t done = 0;
 483
 484   if (len && v->samples == 0) {
 485     /* No silence packing yet. */
 486     v->silent = 0;
 487     blockstart(ft);
 488   }
 489   v->samples += len;
 490   while (done < len) {
 491     SOX_SAMPLE_LOCALS;
 492     if (ft->encoding.bits_per_sample == 8) {
 493       uc = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips);
 494       lsx_writeb(ft, uc);
 495     } else {
 496       sw = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
 497       lsx_writesw(ft, sw);
 498     }
 499     done++;
 500   }
 501   return done;
 502 }
 503
 504 /*-----------------------------------------------------------------
 505  * blockstop() -- stop an output block
 506  * End the current data or silence block.
 507  *-----------------------------------------------------------------*/
 508 static void blockstop(sox_format_t * ft)
 509 {
 510   priv_t * v = (priv_t *) ft->priv;
 511   sox_sample_t datum;
 512
 513   lsx_writeb(ft, 0);    /* End of file block code */
 514   lsx_seeki(ft, (off_t) v->blockseek, 0); /* seek back to block length */
 515   lsx_seeki(ft, (off_t)1, 1);  /* seek forward one */
 516   if (v->silent) {
 517     lsx_writesw(ft, (signed)v->samples);
 518   } else {
 519     if (ft->encoding.bits_per_sample == 8) {
 520       if (ft->signal.channels > 1) {
 521         lsx_seeki(ft, (off_t)8, 1);    /* forward 7 + 1 for new block header */
 522       }
 523     }
 524     v->samples += 2;    /* adjustment: SBDK pp. 3-5 */
 525     datum = (v->samples * (ft->encoding.bits_per_sample >> 3)) & 0xff;
 526     lsx_writesb(ft, datum);     /* low byte of length */
 527     datum = ((v->samples * (ft->encoding.bits_per_sample >> 3)) >> 8) & 0xff;
 528     lsx_writesb(ft, datum);     /* middle byte of length */
 529     datum = ((v->samples * (ft->encoding.bits_per_sample >> 3)) >> 16) & 0xff;
 530     lsx_writesb(ft, datum);     /* high byte of length */
 531   }
 532 }
 533
 534 /*-----------------------------------------------------------------
 535  * stopwrite() -- stop writing a VOC file
 536  *-----------------------------------------------------------------*/
 537 static int stopwrite(sox_format_t * ft)
 538 {
 539   blockstop(ft);
 540   return (SOX_SUCCESS);
 541 }
 542
 543 /*-----------------------------------------------------------------
 544  * Voc-file handlers (static, private to this module)
 545  *-----------------------------------------------------------------*/
 546
 547 /*-----------------------------------------------------------------
 548  * getblock() -- Read next block header, save info,
 549  *               leave position at start of dat
 550  *-----------------------------------------------------------------*/
 551 static int getblock(sox_format_t * ft)
 552 {
 553   priv_t * v = (priv_t *) ft->priv;
 554   unsigned char uc, block;
 555   sox_uint24_t sblen;
 556   uint16_t new_rate_16;
 557   uint32_t new_rate_32;
 558
 559   v->silent = 0;
 560   /* DO while we have no audio to read */
 561   while (v->block_remaining == 0) {
 562     if (lsx_eof(ft))
 563       return SOX_EOF;
 564
 565     if (lsx_readb(ft, &block) == SOX_EOF)
 566       return SOX_EOF;
 567
 568     if (block == VOC_TERM)
 569       return SOX_EOF;
 570
 571     if (lsx_eof(ft))
 572       return SOX_EOF;
 573
 574     lsx_read3(ft, &sblen);
 575
 576     /* Based on VOC block type, process the block */
 577     /* audio may be in one or multiple blocks */
 578     switch (block) {
 579       case VOC_DATA:
 580         lsx_readb(ft, &uc);
 581         /* When DATA block preceeded by an EXTENDED     */
 582         /* block, the DATA blocks rate value is invalid */
 583         if (!v->extended) {
 584           if (uc == 0) {
 585             lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
 586             return (SOX_EOF);
 587           }
 588           if ((v->rate != -1) && (uc != v->rate)) {
 589             lsx_fail_errno(ft, SOX_EFMT,
 590                            "sample rate codes differ: %ld != %d", v->rate,
 591                            uc);
 592             return (SOX_EOF);
 593           }
 594           v->rate = uc;
 595           ft->signal.rate = 1000000.0 / (256 - v->rate);
 596           v->channels = 1;
 597         }
 598         lsx_readb(ft, &uc);
 599         v->format = uc;
 600         v->extended = 0;
 601         v->block_remaining = sblen - 2;
 602         return (SOX_SUCCESS);
 603       case VOC_DATA_16:
 604         lsx_readdw(ft, &new_rate_32);
 605         if (new_rate_32 == 0) {
 606           lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
 607           return (SOX_EOF);
 608         }
 609         if ((v->rate != -1) && ((long) new_rate_32 != v->rate)) {
 610           lsx_fail_errno(ft, SOX_EFMT, "sample rate codes differ: %ld != %d",
 611                          v->rate, new_rate_32);
 612           return (SOX_EOF);
 613         }
 614         v->rate = new_rate_32;
 615         ft->signal.rate = new_rate_32;
 616         lsx_readb(ft, &uc);
 617         v->size = uc;
 618         lsx_readb(ft, &(v->channels));
 619         lsx_readw(ft, &(v->format));    /* ANN: added format */
 620         lsx_skipbytes(ft, (size_t) 4);
 621         v->block_remaining = sblen - 12;
 622         return (SOX_SUCCESS);
 623       case VOC_CONT:
 624         v->block_remaining = sblen;
 625         return (SOX_SUCCESS);
 626       case VOC_SILENCE:
 627         {
 628           unsigned short period;
 629
 630           lsx_readw(ft, &period);
 631           lsx_readb(ft, &uc);
 632           if (uc == 0) {
 633             lsx_fail_errno(ft, SOX_EFMT, "Silence sample rate is zero");
 634             return (SOX_EOF);
 635           }
 636           /*
 637            * Some silence-packed files have gratuitously
 638            * different sample rate codes in silence.
 639            * Adjust period.
 640            */
 641           if ((v->rate != -1) && (uc != v->rate))
 642             period = (period * (256. - uc)) / (256 - v->rate) + .5;
 643           else
 644             v->rate = uc;
 645           v->block_remaining = period;
 646           v->silent = 1;
 647           return (SOX_SUCCESS);
 648         }
 649       case VOC_MARKER:
 650         lsx_readb(ft, &uc);
 651         lsx_readb(ft, &uc);
 652         /* Falling! Falling! */
 653       case VOC_TEXT:
 654         {
 655           uint32_t i = sblen;
 656           int8_t c                /*, line_buf[80];
 657                                  * int len = 0 */ ;
 658
 659           lsx_warn("VOC TEXT");
 660           while (i--) {
 661             lsx_readsb(ft, &c);
 662             /* FIXME: this needs to be tested but I couldn't
 663              * find a voc file with a VOC_TEXT chunk :(
 664              if (c != '\0' && c != '\r')
 665              line_buf[len++] = c;
 666              if (len && (c == '\0' || c == '\r' ||
 667              i == 0 || len == sizeof(line_buf) - 1))
 668              {
 669              lsx_report("%s", line_buf);
 670              line_buf[len] = '\0';
 671              len = 0;
 672              }
 673              */
 674           }
 675         }
 676         continue;       /* get next block */
 677       case VOC_LOOP:
 678       case VOC_LOOPEND:
 679         lsx_debug("skipping repeat loop");
 680         lsx_skipbytes(ft, (size_t) sblen);
 681         break;
 682       case VOC_EXTENDED:
 683         /* An Extended block is followed by a data block */
 684         /* Set this byte so we know to use the rate      */
 685         /* value from the extended block and not the     */
 686         /* data block.                                   */
 687         v->extended = 1;
 688         lsx_readw(ft, &new_rate_16);
 689         if (new_rate_16 == 0) {
 690           lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
 691           return (SOX_EOF);
 692         }
 693         if ((v->rate != -1) && (new_rate_16 != v->rate)) {
 694           lsx_fail_errno(ft, SOX_EFMT, "sample rate codes differ: %ld != %d",
 695                          v->rate, new_rate_16);
 696           return (SOX_EOF);
 697         }
 698         v->rate = new_rate_16;
 699         lsx_readb(ft, &uc); /* bits_per_sample */
 700         lsx_readb(ft, &uc);
 701         ft->signal.channels = uc? 2 : 1;      /* Stereo */
 702         /* Needed number of channels before finishing
 703          * compute for rate */
 704         ft->signal.rate = (256e6 / (65536 - v->rate)) / ft->signal.channels;
 705         /* An extended block must be followed by a data */
 706         /* block to be valid so loop back to top so it  */
 707         /* can be grabed.                               */
 708         continue;
 709       default:
 710         lsx_debug("skipping unknown block code %d", block);
 711         lsx_skipbytes(ft, (size_t) sblen);
 712     }
 713   }
 714   return SOX_SUCCESS;
 715 }
 716
 717 /*-----------------------------------------------------------------
 718  * vlockstart() -- start an output block
 719  *-----------------------------------------------------------------*/
 720 static void blockstart(sox_format_t * ft)
 721 {
 722   priv_t * v = (priv_t *) ft->priv;
 723
 724   v->blockseek = lsx_tell(ft);
 725   if (v->silent) {
 726     lsx_writeb(ft, VOC_SILENCE);        /* Silence block code */
 727     lsx_writeb(ft, 0);  /* Period length */
 728     lsx_writeb(ft, 0);  /* Period length */
 729     lsx_writesb(ft, (signed)v->rate);   /* Rate code */
 730   } else {
 731     if (ft->encoding.bits_per_sample == 8) {
 732       /* 8-bit sample section.  By always setting the correct     */
 733       /* rate value in the DATA block (even when its preceeded    */
 734       /* by an EXTENDED block) old software can still play stereo */
 735       /* files in mono by just skipping over the EXTENDED block.  */
 736       /* Prehaps the rate should be doubled though to make up for */
 737       /* double amount of samples for a given time????            */
 738       if (ft->signal.channels > 1) {
 739         lsx_writeb(ft, VOC_EXTENDED);   /* Voice Extended block code */
 740         lsx_writeb(ft, 4);      /* block length = 4 */
 741         lsx_writeb(ft, 0);      /* block length = 4 */
 742         lsx_writeb(ft, 0);      /* block length = 4 */
 743         v->rate = 65536 - (256000000.0 / (2 * ft->signal.rate)) + .5;
 744         lsx_writesw(ft, (signed) v->rate);       /* Rate code */
 745         lsx_writeb(ft, 0);      /* File is not packed */
 746         lsx_writeb(ft, 1);      /* samples are in stereo */
 747       }
 748       lsx_writeb(ft, VOC_DATA); /* Voice Data block code */
 749       lsx_writeb(ft, 0);        /* block length (for now) */
 750       lsx_writeb(ft, 0);        /* block length (for now) */
 751       lsx_writeb(ft, 0);        /* block length (for now) */
 752       v->rate = 256 - (1000000.0 / ft->signal.rate) + .5;
 753       lsx_writesb(ft, (signed) v->rate); /* Rate code */
 754       lsx_writeb(ft, 0);        /* 8-bit raw data */
 755     } else {
 756       lsx_writeb(ft, VOC_DATA_16);      /* Voice Data block code */
 757       lsx_writeb(ft, 0);        /* block length (for now) */
 758       lsx_writeb(ft, 0);        /* block length (for now) */
 759       lsx_writeb(ft, 0);        /* block length (for now) */
 760       v->rate = ft->signal.rate + .5;
 761       lsx_writedw(ft, (unsigned) v->rate);      /* Rate code */
 762       lsx_writeb(ft, 16);       /* Sample Size */
 763       lsx_writeb(ft, ft->signal.channels);      /* Sample Size */
 764       lsx_writew(ft, 0x0004);   /* Encoding */
 765       lsx_writeb(ft, 0);        /* Unused */
 766       lsx_writeb(ft, 0);        /* Unused */
 767       lsx_writeb(ft, 0);        /* Unused */
 768       lsx_writeb(ft, 0);        /* Unused */
 769     }
 770   }
 771 }
 772
 773 LSX_FORMAT_HANDLER(voc)
 774 {
 775   static char const *const names[] = { "voc", NULL };
 776   static unsigned const write_encodings[] = {
 777     SOX_ENCODING_SIGN2, 16, 0,
 778     SOX_ENCODING_UNSIGNED, 8, 0,
 779     0
 780   };
 781   static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
 782     "Creative Technology Sound Blaster format",
 783     names, SOX_FILE_LIT_END | SOX_FILE_MONO | SOX_FILE_STEREO,
 784     startread, read_samples, NULL,
 785     startwrite, write_samples, stopwrite,
 786     NULL, write_encodings, NULL, sizeof(priv_t)
 787   };
 788   return &handler;
 789 }