ref: 99adb24d9994bbb63c5f26003632ed94d9e4eaab
dir: /src/voc.c/
/* libSoX Sound Blaster VOC handler sources.
* Copyright 1991 Lance Norskog And Sundry Contributors
*
* This source code is freely redistributable and may be used for
* any purpose. This copyright notice must be maintained.
* Lance Norskog And Sundry Contributors are not responsible for
* the consequences of using this software.
*
* September 8, 1993
* Copyright 1993 T. Allen Grider - for changes to support block type 9
* and word sized samples. Same caveats and disclaimer as above.
*
* February 22, 1996
* by Chris Bagwell (cbagwell@sprynet.com)
* Added support for block type 8 (extended) which allows for 8-bit stereo
* files. Added support for saving stereo files and 16-bit files.
* Added VOC format info from audio format FAQ so I don't have to keep
* looking around for it.
*
* February 5, 2001
* For sox-12-17 by Annonymous (see notes ANN)
* Added comments and notes for each procedure.
* Fixed so this now works with pipes, input does not have to
* be seekable anymore (in startread() )
* Added support for uLAW and aLaw (aLaw not tested).
* Fixed support of multi-part VOC files, and files with
* block 9 but no audio in the block....
* The following need to be tested: 16-bit, 2 channel, and aLaw.
*
* December 10, 2001
* For sox-12-17-3 by Annonymous (see notes ANN)
* Patch for sox-12-17 merged with sox-12-17-3-pre3 code.
*
*/
/*------------------------------------------------------------------------
The following is taken from the Audio File Formats FAQ dated 2-Jan-1995
and submitted by Guido van Rossum <guido@cwi.nl>.
--------------------------------------------------------------------------
Creative Voice (VOC) file format
--------------------------------
From: galt@dsd.es.com
(byte numbers are hex!)
HEADER (bytes 00-19)
Series of DATA BLOCKS (bytes 1A+) [Must end w/ Terminator Block]
- ---------------------------------------------------------------
HEADER:
-------
byte # Description
------ ------------------------------------------
00-12 "Creative Voice File"
13 1A (eof to abort printing of file)
14-15 Offset of first datablock in .voc file (std 1A 00
in Intel Notation)
16-17 Version number (minor,major) (VOC-HDR puts 0A 01)
18-19 2's Comp of Ver. # + 1234h (VOC-HDR puts 29 11)
- ---------------------------------------------------------------
DATA BLOCK:
-----------
Data Block: TYPE(1-byte), SIZE(3-bytes), INFO(0+ bytes)
NOTE: Terminator Block is an exception -- it has only the TYPE byte.
TYPE Description Size (3-byte int) Info
---- ----------- ----------------- -----------------------
00 Terminator (NONE) (NONE)
01 Sound data 2+length of data *
02 Sound continue length of data Voice Data
03 Silence 3 **
04 Marker 2 Marker# (2 bytes)
05 ASCII length of string null terminated string
06 Repeat 2 Count# (2 bytes)
07 End repeat 0 (NONE)
08 Extended 4 ***
09 New Header 16 see below
*Sound Info Format: **Silence Info Format:
--------------------- ----------------------------
00 Sample Rate 00-01 Length of silence - 1
01 Compression Type 02 Sample Rate
02+ Voice Data
***Extended Info Format:
---------------------
00-01 Time Constant: Mono: 65536 - (256000000/sample_rate)
Stereo: 65536 - (25600000/(2*sample_rate))
02 Pack
03 Mode: 0 = mono
1 = stereo
Marker# -- Driver keeps the most recent marker in a status byte
Count# -- Number of repetitions + 1
Count# may be 1 to FFFE for 0 - FFFD repetitions
or FFFF for endless repetitions
Sample Rate -- SR byte = 256-(1000000/sample_rate)
Length of silence -- in units of sampling cycle
Compression Type -- of voice data
8-bits = 0
4-bits = 1
2.6-bits = 2
2-bits = 3
Multi DAC = 3+(# of channels) [interesting--
this isn't in the developer's manual]
Detailed description of new data blocks (VOC files version 1.20 and above):
(Source is fax from Barry Boone at Creative Labs, 405/742-6622)
BLOCK 8 - digitized sound attribute extension, must preceed block 1.
Used to define stereo, 8 bit audio
BYTE bBlockID; // = 8
BYTE nBlockLen[3]; // 3 byte length
WORD wTimeConstant; // time constant = same as block 1
BYTE bPackMethod; // same as in block 1
BYTE bVoiceMode; // 0-mono, 1-stereo
Data is stored left, right
BLOCK 9 - data block that supersedes blocks 1 and 8.
Used for stereo, 16 bit (and uLaw, aLaw).
BYTE bBlockID; // = 9
BYTE nBlockLen[3]; // length 12 plus length of sound
DWORD dwSamplesPerSec; // samples per second, not time const.
BYTE bBitsPerSample; // e.g., 8 or 16
BYTE bChannels; // 1 for mono, 2 for stereo
WORD wFormat; // see below
BYTE reserved[4]; // pad to make block w/o data
// have a size of 16 bytes
Valid values of wFormat are:
0x0000 8-bit unsigned PCM
0x0001 Creative 8-bit to 4-bit ADPCM
0x0002 Creative 8-bit to 3-bit ADPCM
0x0003 Creative 8-bit to 2-bit ADPCM
0x0004 16-bit signed PCM
0x0006 CCITT a-Law
0x0007 CCITT u-Law
0x02000 Creative 16-bit to 4-bit ADPCM
Data is stored left, right
ANN: Multi-byte quantities are in Intel byte order (Little Endian).
------------------------------------------------------------------------*/
#include "sox_i.h"
#include "g711.h"
#include "adpcms.h"
#include <assert.h>
#include <string.h>
/* Private data for VOC file */
typedef struct {
long block_remaining; /* bytes remaining in current block */
long rate; /* rate code (byte) of this chunk */
int silent; /* sound or silence? */
long srate; /* rate code (byte) of silence */
size_t blockseek; /* start of current output block */
long samples; /* number of samples output */
int format; /* VOC audio format */
int size; /* word length of data */
int channels; /* number of sound channels */
long total_size; /* total size of all audio in file */
int extended; /* Has an extended block been read? */
adpcm_t adpcm;
} priv_t;
#define VOC_TERM 0
#define VOC_DATA 1
#define VOC_CONT 2
#define VOC_SILENCE 3
#define VOC_MARKER 4
#define VOC_TEXT 5
#define VOC_LOOP 6
#define VOC_LOOPEND 7
#define VOC_EXTENDED 8
#define VOC_DATA_16 9
/* ANN: Format encoding types */
#define VOC_FMT_LIN8U 0 /* 8 bit unsigned linear PCM */
#define VOC_FMT_CRLADPCM4 1 /* Creative 8-bit to 4-bit ADPCM */
#define VOC_FMT_CRLADPCM3 2 /* Creative 8-bit to 3-bit ADPCM */
#define VOC_FMT_CRLADPCM2 3 /* Creative 8-bit to 2-bit ADPCM */
#define VOC_FMT_LIN16 4 /* 16-bit signed PCM */
#define VOC_FMT_ALAW 6 /* CCITT a-Law 8-bit PCM */
#define VOC_FMT_MU255 7 /* CCITT u-Law 8-bit PCM */
#define VOC_FMT_CRLADPCM4A 0x200 /* Creative 16-bit to 4-bit ADPCM */
/* Prototypes for internal functions */
static int getblock(sox_format_t *);
static void blockstart(sox_format_t *);
/* Conversion macros (from raw.c) */
#define SOX_ALAW_BYTE_TO_SAMPLE(d) ((sox_sample_t)(sox_alaw2linear16(d)) << 16)
#define SOX_ULAW_BYTE_TO_SAMPLE(d) ((sox_sample_t)(sox_ulaw2linear16(d)) << 16)
/* public VOC functions for SOX */
/*-----------------------------------------------------------------
* startread() -- start reading a VOC file
*-----------------------------------------------------------------*/
static int startread(sox_format_t * ft)
{
char header[20];
priv_t * v = (priv_t *) ft->priv;
unsigned short sbseek;
int rc;
int ii; /* for getting rid of lseek */
unsigned char uc;
if (lsx_readbuf(ft, header, (size_t)20) != 20) {
lsx_fail_errno(ft, SOX_EHDR, "unexpected EOF in VOC header");
return (SOX_EOF);
}
if (strncmp(header, "Creative Voice File\032", (size_t)19)) {
lsx_fail_errno(ft, SOX_EHDR, "VOC file header incorrect");
return (SOX_EOF);
}
/* read the offset to data, from start of file */
/* after this read we have read 20 bytes of header + 2 */
lsx_readw(ft, &sbseek);
/* ANN: read to skip the header, instead of lseek */
/* this should allow use with pipes.... */
for (ii = 22; ii < sbseek; ii++)
lsx_readb(ft, &uc);
v->rate = -1;
v->format = -1;
v->channels = -1;
v->block_remaining = 0;
v->total_size = 0; /* ANN added */
v->extended = 0;
/* read until we get the format information.... */
rc = getblock(ft);
if (rc)
return rc;
/* get rate of data */
if (v->rate == -1) {
lsx_fail_errno(ft, SOX_EOF, "Input .voc file had no sound!");
return (SOX_EOF);
}
/* setup word length of data */
/* ANN: Check VOC format and map to the proper libSoX format value */
switch (v->format) {
case VOC_FMT_LIN8U: /* 0 8 bit unsigned linear PCM */
ft->encoding.encoding = SOX_ENCODING_UNSIGNED;
v->size = 8;
break;
case VOC_FMT_CRLADPCM4: /* 1 Creative 8-bit to 4-bit ADPCM */
ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
v->size = 4;
break;
case VOC_FMT_CRLADPCM3: /* 2 Creative 8-bit to 3-bit ADPCM */
ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
v->size = 3;
break;
case VOC_FMT_CRLADPCM2: /* 3 Creative 8-bit to 2-bit ADPCM */
ft->encoding.encoding = SOX_ENCODING_CL_ADPCM;
v->size = 2;
break;
case VOC_FMT_LIN16: /* 4 16-bit signed PCM */
ft->encoding.encoding = SOX_ENCODING_SIGN2;
v->size = 16;
break;
case VOC_FMT_ALAW: /* 6 CCITT a-Law 8-bit PCM */
ft->encoding.encoding = SOX_ENCODING_ALAW;
v->size = 8;
break;
case VOC_FMT_MU255: /* 7 CCITT u-Law 8-bit PCM */
ft->encoding.encoding = SOX_ENCODING_ULAW;
v->size = 8;
break;
case VOC_FMT_CRLADPCM4A: /*0x200 Creative 16-bit to 4-bit ADPCM */
ft->encoding.encoding = SOX_ENCODING_CL_ADPCM16;
v->size = 4;
break;
default:
lsx_fail("Unknown VOC format %d", v->format);
break;
}
ft->encoding.bits_per_sample = v->size;
/* setup number of channels */
if (ft->signal.channels == 0)
ft->signal.channels = v->channels;
return (SOX_SUCCESS);
}
/*-----------------------------------------------------------------
* read() -- read data from a VOC file
* ANN: Major changes here to support multi-part files and files
* that do not have audio in block 9's.
*-----------------------------------------------------------------*/
static size_t read_samples(sox_format_t * ft, sox_sample_t * buf,
size_t len)
{
priv_t * v = (priv_t *) ft->priv;
size_t done = 0;
int rc = 0;
int16_t sw;
unsigned char uc;
if (v->block_remaining == 0) { /* handle getting another cont. buffer */
rc = getblock(ft);
if (rc)
return 0;
}
if (v->block_remaining == 0) /* if no more data, return 0, i.e., done */
return 0;
if (v->silent) {
for (; v->block_remaining && (done < len); v->block_remaining--, done++)
*buf++ = 0; /* Fill in silence */
} else { /* not silence; read len samples of audio from the file */
size_t per = max(1, 9 / v->size);
for (; (done + per <= len); done += per) {
if (v->block_remaining == 0) { /* IF no more in this block, get another */
while (v->block_remaining == 0) { /* until have either EOF or a block with data */
rc = getblock(ft);
if (rc)
break;
}
if (rc) /* IF EOF, break out, no more data, next will return 0 */
break;
}
/* Read the data in the file */
if (v->size <= 4) {
if (!v->adpcm.setup.sign) {
SOX_SAMPLE_LOCALS;
if (lsx_readb(ft, &uc) == SOX_EOF) {
lsx_warn("VOC input: short file");
v->block_remaining = 0;
return done;
}
if(uc == 0) {
lsx_fail_errno(ft, EINVAL, "invalid rate value");
v->block_remaining = 0;
return done;
}
*buf = SOX_UNSIGNED_8BIT_TO_SAMPLE(uc,);
lsx_adpcm_init(&v->adpcm, 6 - v->size, SOX_SAMPLE_TO_SIGNED_16BIT(*buf, ft->clips));
++buf;
--v->block_remaining;
++done;
}
if (lsx_readb(ft, &uc) == SOX_EOF) {
lsx_warn("VOC input: short file");
v->block_remaining = 0;
return done;
}
switch (v->size) {
case 2:
if (v->format == VOC_FMT_CRLADPCM2) {
int u = uc;
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 6, &v->adpcm),);
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 4, &v->adpcm),);
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 2, &v->adpcm),);
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u , &v->adpcm),);
}
break;
case 3:
if (v->format == VOC_FMT_CRLADPCM3) {
int u = uc;
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 5, &v->adpcm),);
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 2, &v->adpcm),);
*buf++ = /* A bit from nowhere! */
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u << 1, &v->adpcm),);
}
break;
case 4:
if (v->format == VOC_FMT_CRLADPCM4) {
int u = uc;
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u >> 4, &v->adpcm),);
*buf++ =
SOX_SIGNED_16BIT_TO_SAMPLE(lsx_adpcm_decode (u , &v->adpcm),);
}
break;
}
} else
switch (v->size) {
case 8:
if (lsx_readb(ft, &uc) == SOX_EOF) {
lsx_warn("VOC input: short file");
v->block_remaining = 0;
return done;
}
if (v->format == VOC_FMT_MU255) {
*buf++ = SOX_ULAW_BYTE_TO_SAMPLE(uc);
} else if (v->format == VOC_FMT_ALAW) {
*buf++ = SOX_ALAW_BYTE_TO_SAMPLE(uc);
} else {
*buf++ = SOX_UNSIGNED_8BIT_TO_SAMPLE(uc,);
}
break;
case 16:
lsx_readsw(ft, &sw);
if (lsx_eof(ft)) {
lsx_warn("VOC input: short file");
v->block_remaining = 0;
return done;
}
*buf++ = SOX_SIGNED_16BIT_TO_SAMPLE(sw,);
v->block_remaining--; /* Processed 2 bytes so update */
break;
}
/* decrement count of processed bytes */
v->block_remaining--;
}
}
v->total_size += done;
return done;
}
/* When saving samples in VOC format the following outline is followed:
* If an 8-bit mono sample then use a VOC_DATA header.
* If an 8-bit stereo sample then use a VOC_EXTENDED header followed
* by a VOC_DATA header.
* If a 16-bit sample (either stereo or mono) then save with a
* VOC_DATA_16 header.
*
* ANN: Not supported: uLaw and aLaw output VOC files....
*
* This approach will cause the output to be an its most basic format
* which will work with the oldest software (eg. an 8-bit mono sample
* will be able to be played with a really old SB VOC player.)
*/
static int startwrite(sox_format_t * ft)
{
priv_t * v = (priv_t *) ft->priv;
if (!ft->seekable) {
lsx_fail_errno(ft, SOX_EOF,
"Output .voc file must be a file, not a pipe");
return (SOX_EOF);
}
v->samples = 0;
/* File format name and a ^Z (aborts printing under DOS) */
lsx_writes(ft, "Creative Voice File\032");
lsx_writew(ft, 26); /* size of header */
lsx_writew(ft, 0x10a); /* major/minor version number */
lsx_writew(ft, 0x1129); /* checksum of version number */
return (SOX_SUCCESS);
}
/*-----------------------------------------------------------------
* write() -- write a VOC file
*-----------------------------------------------------------------*/
static size_t write_samples(sox_format_t * ft, const sox_sample_t * buf,
size_t len)
{
priv_t * v = (priv_t *) ft->priv;
unsigned char uc;
int16_t sw;
size_t done = 0;
if (len && v->samples == 0) {
/* No silence packing yet. */
v->silent = 0;
blockstart(ft);
}
v->samples += len;
while (done < len) {
SOX_SAMPLE_LOCALS;
if (ft->encoding.bits_per_sample == 8) {
uc = SOX_SAMPLE_TO_UNSIGNED_8BIT(*buf++, ft->clips);
lsx_writeb(ft, uc);
} else {
sw = (int) SOX_SAMPLE_TO_SIGNED_16BIT(*buf++, ft->clips);
lsx_writesw(ft, sw);
}
done++;
}
return done;
}
/*-----------------------------------------------------------------
* blockstop() -- stop an output block
* End the current data or silence block.
*-----------------------------------------------------------------*/
static void blockstop(sox_format_t * ft)
{
priv_t * v = (priv_t *) ft->priv;
sox_sample_t datum;
lsx_writeb(ft, 0); /* End of file block code */
lsx_seeki(ft, (off_t) v->blockseek, 0); /* seek back to block length */
lsx_seeki(ft, (off_t)1, 1); /* seek forward one */
if (v->silent) {
lsx_writesw(ft, (signed)v->samples);
} else {
if (ft->encoding.bits_per_sample == 8) {
if (ft->signal.channels > 1) {
lsx_seeki(ft, (off_t)8, 1); /* forward 7 + 1 for new block header */
}
}
v->samples += 2; /* adjustment: SBDK pp. 3-5 */
datum = (v->samples * (ft->encoding.bits_per_sample >> 3)) & 0xff;
lsx_writesb(ft, datum); /* low byte of length */
datum = ((v->samples * (ft->encoding.bits_per_sample >> 3)) >> 8) & 0xff;
lsx_writesb(ft, datum); /* middle byte of length */
datum = ((v->samples * (ft->encoding.bits_per_sample >> 3)) >> 16) & 0xff;
lsx_writesb(ft, datum); /* high byte of length */
}
}
/*-----------------------------------------------------------------
* stopwrite() -- stop writing a VOC file
*-----------------------------------------------------------------*/
static int stopwrite(sox_format_t * ft)
{
blockstop(ft);
return (SOX_SUCCESS);
}
/*-----------------------------------------------------------------
* Voc-file handlers (static, private to this module)
*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------
* getblock() -- Read next block header, save info,
* leave position at start of dat
*-----------------------------------------------------------------*/
static int getblock(sox_format_t * ft)
{
priv_t * v = (priv_t *) ft->priv;
unsigned char uc, block;
uint16_t u16;
sox_uint24_t sblen;
uint16_t new_rate_16;
uint32_t new_rate_32;
v->silent = 0;
/* DO while we have no audio to read */
while (v->block_remaining == 0) {
if (lsx_eof(ft))
return SOX_EOF;
if (lsx_readb(ft, &block) == SOX_EOF)
return SOX_EOF;
if (block == VOC_TERM)
return SOX_EOF;
if (lsx_eof(ft))
return SOX_EOF;
lsx_read3(ft, &sblen);
/* Based on VOC block type, process the block */
/* audio may be in one or multiple blocks */
switch (block) {
case VOC_DATA:
lsx_readb(ft, &uc);
/* When DATA block preceeded by an EXTENDED */
/* block, the DATA blocks rate value is invalid */
if (!v->extended) {
if (uc == 0) {
lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
return (SOX_EOF);
}
if ((v->rate != -1) && (uc != v->rate)) {
lsx_fail_errno(ft, SOX_EFMT,
"sample rate codes differ: %ld != %d", v->rate,
uc);
return (SOX_EOF);
}
v->rate = uc;
ft->signal.rate = 1000000.0 / (256 - v->rate);
if (v->channels != -1 && v->channels != 1) {
lsx_fail_errno(ft, SOX_EFMT, "channel count changed");
return SOX_EOF;
}
v->channels = 1;
}
lsx_readb(ft, &uc);
if (v->format != -1 && uc != v->format) {
lsx_fail_errno(ft, SOX_EFMT, "format changed");
return SOX_EOF;
}
v->format = uc;
v->extended = 0;
v->block_remaining = sblen - 2;
return (SOX_SUCCESS);
case VOC_DATA_16:
lsx_readdw(ft, &new_rate_32);
if (new_rate_32 == 0) {
lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
return (SOX_EOF);
}
if ((v->rate != -1) && ((long) new_rate_32 != v->rate)) {
lsx_fail_errno(ft, SOX_EFMT, "sample rate codes differ: %ld != %d",
v->rate, new_rate_32);
return (SOX_EOF);
}
v->rate = new_rate_32;
ft->signal.rate = new_rate_32;
lsx_readb(ft, &uc);
v->size = uc;
lsx_readb(ft, &uc);
if (v->channels != -1 && uc != v->channels) {
lsx_fail_errno(ft, SOX_EFMT, "channel count changed");
return SOX_EOF;
}
v->channels = uc;
lsx_readw(ft, &u16); /* ANN: added format */
if (v->format != -1 && u16 != v->format) {
lsx_fail_errno(ft, SOX_EFMT, "format changed");
return SOX_EOF;
}
v->format = u16;
lsx_skipbytes(ft, (size_t) 4);
v->block_remaining = sblen - 12;
return (SOX_SUCCESS);
case VOC_CONT:
v->block_remaining = sblen;
return (SOX_SUCCESS);
case VOC_SILENCE:
{
unsigned short period;
lsx_readw(ft, &period);
lsx_readb(ft, &uc);
if (uc == 0) {
lsx_fail_errno(ft, SOX_EFMT, "Silence sample rate is zero");
return (SOX_EOF);
}
/*
* Some silence-packed files have gratuitously
* different sample rate codes in silence.
* Adjust period.
*/
if ((v->rate != -1) && (uc != v->rate))
period = (period * (256. - uc)) / (256 - v->rate) + .5;
else
v->rate = uc;
v->block_remaining = period;
v->silent = 1;
return (SOX_SUCCESS);
}
case VOC_MARKER:
lsx_readb(ft, &uc);
lsx_readb(ft, &uc);
/* Falling! Falling! */
case VOC_TEXT:
{
uint32_t i = sblen;
int8_t c /*, line_buf[80];
* int len = 0 */ ;
lsx_warn("VOC TEXT");
while (i--) {
lsx_readsb(ft, &c);
/* FIXME: this needs to be tested but I couldn't
* find a voc file with a VOC_TEXT chunk :(
if (c != '\0' && c != '\r')
line_buf[len++] = c;
if (len && (c == '\0' || c == '\r' ||
i == 0 || len == sizeof(line_buf) - 1))
{
lsx_report("%s", line_buf);
line_buf[len] = '\0';
len = 0;
}
*/
}
}
continue; /* get next block */
case VOC_LOOP:
case VOC_LOOPEND:
lsx_debug("skipping repeat loop");
lsx_skipbytes(ft, (size_t) sblen);
break;
case VOC_EXTENDED:
/* An Extended block is followed by a data block */
/* Set this byte so we know to use the rate */
/* value from the extended block and not the */
/* data block. */
v->extended = 1;
lsx_readw(ft, &new_rate_16);
if (new_rate_16 == 0) {
lsx_fail_errno(ft, SOX_EFMT, "Sample rate is zero?");
return (SOX_EOF);
}
if ((v->rate != -1) && (new_rate_16 != v->rate)) {
lsx_fail_errno(ft, SOX_EFMT, "sample rate codes differ: %ld != %d",
v->rate, new_rate_16);
return (SOX_EOF);
}
v->rate = new_rate_16;
lsx_readb(ft, &uc); /* bits_per_sample */
lsx_readb(ft, &uc);
if (v->channels != -1 && uc != v->channels) {
lsx_fail_errno(ft, SOX_EFMT, "channel count changed");
return SOX_EOF;
}
v->channels = uc;
ft->signal.channels = uc? 2 : 1; /* Stereo */
/* Needed number of channels before finishing
* compute for rate */
ft->signal.rate = (256e6 / (65536 - v->rate)) / ft->signal.channels;
/* An extended block must be followed by a data */
/* block to be valid so loop back to top so it */
/* can be grabed. */
continue;
default:
lsx_debug("skipping unknown block code %d", block);
lsx_skipbytes(ft, (size_t) sblen);
}
}
return SOX_SUCCESS;
}
/*-----------------------------------------------------------------
* vlockstart() -- start an output block
*-----------------------------------------------------------------*/
static void blockstart(sox_format_t * ft)
{
priv_t * v = (priv_t *) ft->priv;
v->blockseek = lsx_tell(ft);
if (v->silent) {
lsx_writeb(ft, VOC_SILENCE); /* Silence block code */
lsx_writeb(ft, 0); /* Period length */
lsx_writeb(ft, 0); /* Period length */
lsx_writesb(ft, (signed)v->rate); /* Rate code */
} else {
if (ft->encoding.bits_per_sample == 8) {
/* 8-bit sample section. By always setting the correct */
/* rate value in the DATA block (even when its preceeded */
/* by an EXTENDED block) old software can still play stereo */
/* files in mono by just skipping over the EXTENDED block. */
/* Prehaps the rate should be doubled though to make up for */
/* double amount of samples for a given time???? */
if (ft->signal.channels > 1) {
lsx_writeb(ft, VOC_EXTENDED); /* Voice Extended block code */
lsx_writeb(ft, 4); /* block length = 4 */
lsx_writeb(ft, 0); /* block length = 4 */
lsx_writeb(ft, 0); /* block length = 4 */
v->rate = 65536 - (256000000.0 / (2 * ft->signal.rate)) + .5;
lsx_writesw(ft, (signed) v->rate); /* Rate code */
lsx_writeb(ft, 0); /* File is not packed */
lsx_writeb(ft, 1); /* samples are in stereo */
}
lsx_writeb(ft, VOC_DATA); /* Voice Data block code */
lsx_writeb(ft, 0); /* block length (for now) */
lsx_writeb(ft, 0); /* block length (for now) */
lsx_writeb(ft, 0); /* block length (for now) */
v->rate = 256 - (1000000.0 / ft->signal.rate) + .5;
lsx_writesb(ft, (signed) v->rate); /* Rate code */
lsx_writeb(ft, 0); /* 8-bit raw data */
} else {
lsx_writeb(ft, VOC_DATA_16); /* Voice Data block code */
lsx_writeb(ft, 0); /* block length (for now) */
lsx_writeb(ft, 0); /* block length (for now) */
lsx_writeb(ft, 0); /* block length (for now) */
v->rate = ft->signal.rate + .5;
lsx_writedw(ft, (unsigned) v->rate); /* Rate code */
lsx_writeb(ft, 16); /* Sample Size */
lsx_writeb(ft, ft->signal.channels); /* Sample Size */
lsx_writew(ft, 0x0004); /* Encoding */
lsx_writeb(ft, 0); /* Unused */
lsx_writeb(ft, 0); /* Unused */
lsx_writeb(ft, 0); /* Unused */
lsx_writeb(ft, 0); /* Unused */
}
}
}
LSX_FORMAT_HANDLER(voc)
{
static char const *const names[] = { "voc", NULL };
static unsigned const write_encodings[] = {
SOX_ENCODING_SIGN2, 16, 0,
SOX_ENCODING_UNSIGNED, 8, 0,
0
};
static sox_format_handler_t const handler = {SOX_LIB_VERSION_CODE,
"Creative Technology Sound Blaster format",
names, SOX_FILE_LIT_END | SOX_FILE_MONO | SOX_FILE_STEREO,
startread, read_samples, NULL,
startwrite, write_samples, stopwrite,
NULL, write_encodings, NULL, sizeof(priv_t)
};
return &handler;
}