378 lines
9.6 KiB
C
378 lines
9.6 KiB
C
/*
|
|
** Copyright (C) 2002-2012 Erik de Castro Lopo <erikd@mega-nerd.com>
|
|
**
|
|
** This program is free software; you can redistribute it and/or modify
|
|
** it under the terms of the GNU Lesser General Public License as published by
|
|
** the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU Lesser General Public License
|
|
** along with this program; if not, write to the Free Software
|
|
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/*===========================================================================
|
|
** Yamaha TX16 Sampler Files.
|
|
**
|
|
** This header parser was written using information from the SoX source code
|
|
** and trial and error experimentation. The code here however is all original.
|
|
*/
|
|
|
|
#include "sfconfig.h"
|
|
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#include "sndfile.h"
|
|
#include "sfendian.h"
|
|
#include "common.h"
|
|
|
|
#if (ENABLE_EXPERIMENTAL_CODE == 0)
|
|
|
|
int
|
|
txw_open (SF_PRIVATE *psf)
|
|
{ if (psf)
|
|
return SFE_UNIMPLEMENTED ;
|
|
return 0 ;
|
|
} /* txw_open */
|
|
|
|
#else
|
|
|
|
/*------------------------------------------------------------------------------
|
|
** Markers.
|
|
*/
|
|
|
|
#define TXW_DATA_OFFSET 32
|
|
|
|
#define TXW_LOOPED 0x49
|
|
#define TXW_NO_LOOP 0xC9
|
|
|
|
/*------------------------------------------------------------------------------
|
|
** Private static functions.
|
|
*/
|
|
|
|
static int txw_read_header (SF_PRIVATE *psf) ;
|
|
|
|
static sf_count_t txw_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
|
|
static sf_count_t txw_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
|
|
static sf_count_t txw_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
|
|
static sf_count_t txw_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
|
|
|
|
static sf_count_t txw_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
|
|
|
|
/*------------------------------------------------------------------------------
|
|
** Public functions.
|
|
*/
|
|
|
|
/*
|
|
* ftp://ftp.t0.or.at/pub/sound/tx16w/samples.yamaha
|
|
* ftp://ftp.t0.or.at/pub/sound/tx16w/faq/tx16w.tec
|
|
* http://www.t0.or.at/~mpakesch/tx16w/
|
|
*
|
|
* from tx16w.c sox 12.15: (7-Oct-98) (Mark Lakata and Leigh Smith)
|
|
* char filetype[6] "LM8953"
|
|
* nulls[10],
|
|
* dummy_aeg[6]
|
|
* format 0x49 = looped, 0xC9 = non-looped
|
|
* sample_rate 1 = 33 kHz, 2 = 50 kHz, 3 = 16 kHz
|
|
* atc_length[3] if sample rate 0, [2]&0xfe = 6: 33kHz, 0x10:50, 0xf6: 16,
|
|
* depending on [5] but to heck with it
|
|
* rpt_length[3] (these are for looped samples, attack and loop lengths)
|
|
* unused[2]
|
|
*/
|
|
|
|
typedef struct
|
|
{ unsigned char format, srate, sr2, sr3 ;
|
|
unsigned short srhash ;
|
|
unsigned int attacklen, repeatlen ;
|
|
} TXW_HEADER ;
|
|
|
|
#define ERROR_666 666
|
|
|
|
int
|
|
txw_open (SF_PRIVATE *psf)
|
|
{ int error ;
|
|
|
|
if (psf->file.mode != SFM_READ)
|
|
return SFE_UNIMPLEMENTED ;
|
|
|
|
if ((error = txw_read_header (psf)))
|
|
return error ;
|
|
|
|
if (psf_fseek (psf, psf->dataoffset, SEEK_SET) != psf->dataoffset)
|
|
return SFE_BAD_SEEK ;
|
|
|
|
psf->read_short = txw_read_s ;
|
|
psf->read_int = txw_read_i ;
|
|
psf->read_float = txw_read_f ;
|
|
psf->read_double = txw_read_d ;
|
|
|
|
psf->seek = txw_seek ;
|
|
|
|
return 0 ;
|
|
} /* txw_open */
|
|
|
|
/*------------------------------------------------------------------------------
|
|
*/
|
|
|
|
static int
|
|
txw_read_header (SF_PRIVATE *psf)
|
|
{ BUF_UNION ubuf ;
|
|
TXW_HEADER txwh ;
|
|
const char *strptr ;
|
|
|
|
memset (&txwh, 0, sizeof (txwh)) ;
|
|
memset (ubuf.cbuf, 0, sizeof (ubuf.cbuf)) ;
|
|
psf_binheader_readf (psf, "pb", 0, ubuf.cbuf, 16) ;
|
|
|
|
if (memcmp (ubuf.cbuf, "LM8953\0\0\0\0\0\0\0\0\0\0", 16) != 0)
|
|
return ERROR_666 ;
|
|
|
|
psf_log_printf (psf, "Read only : Yamaha TX-16 Sampler (.txw)\nLM8953\n") ;
|
|
|
|
/* Jump 6 bytes (dummp_aeg), read format, read sample rate. */
|
|
psf_binheader_readf (psf, "j11", 6, &txwh.format, &txwh.srate) ;
|
|
|
|
/* 8 bytes (atc_length[3], rpt_length[3], unused[2]). */
|
|
psf_binheader_readf (psf, "e33j", &txwh.attacklen, &txwh.repeatlen, 2) ;
|
|
txwh.sr2 = (txwh.attacklen >> 16) & 0xFE ;
|
|
txwh.sr3 = (txwh.repeatlen >> 16) & 0xFE ;
|
|
txwh.attacklen &= 0x1FFFF ;
|
|
txwh.repeatlen &= 0x1FFFF ;
|
|
|
|
switch (txwh.format)
|
|
{ case TXW_LOOPED :
|
|
strptr = "looped" ;
|
|
break ;
|
|
|
|
case TXW_NO_LOOP :
|
|
strptr = "non-looped" ;
|
|
break ;
|
|
|
|
default :
|
|
psf_log_printf (psf, " Format : 0x%02x => ?????\n", txwh.format) ;
|
|
return ERROR_666 ;
|
|
} ;
|
|
|
|
psf_log_printf (psf, " Format : 0x%02X => %s\n", txwh.format, strptr) ;
|
|
|
|
strptr = NULL ;
|
|
|
|
switch (txwh.srate)
|
|
{ case 1 :
|
|
psf->sf.samplerate = 33333 ;
|
|
break ;
|
|
|
|
case 2 :
|
|
psf->sf.samplerate = 50000 ;
|
|
break ;
|
|
|
|
case 3 :
|
|
psf->sf.samplerate = 16667 ;
|
|
break ;
|
|
|
|
default :
|
|
/* This is ugly and braindead. */
|
|
txwh.srhash = ((txwh.sr2 & 0xFE) << 8) | (txwh.sr3 & 0xFE) ;
|
|
switch (txwh.srhash)
|
|
{ case ((0x6 << 8) | 0x52) :
|
|
psf->sf.samplerate = 33333 ;
|
|
break ;
|
|
|
|
case ((0x10 << 8) | 0x52) :
|
|
psf->sf.samplerate = 50000 ;
|
|
break ;
|
|
|
|
case ((0xF6 << 8) | 0x52) :
|
|
psf->sf.samplerate = 166667 ;
|
|
break ;
|
|
|
|
default :
|
|
strptr = " Sample Rate : Unknown : forcing to 33333\n" ;
|
|
psf->sf.samplerate = 33333 ;
|
|
break ;
|
|
} ;
|
|
} ;
|
|
|
|
|
|
if (strptr)
|
|
psf_log_printf (psf, strptr) ;
|
|
else if (txwh.srhash)
|
|
psf_log_printf (psf, " Sample Rate : %d (0x%X) => %d\n", txwh.srate, txwh.srhash, psf->sf.samplerate) ;
|
|
else
|
|
psf_log_printf (psf, " Sample Rate : %d => %d\n", txwh.srate, psf->sf.samplerate) ;
|
|
|
|
if (txwh.format == TXW_LOOPED)
|
|
{ psf_log_printf (psf, " Attack Len : %d\n", txwh.attacklen) ;
|
|
psf_log_printf (psf, " Repeat Len : %d\n", txwh.repeatlen) ;
|
|
} ;
|
|
|
|
psf->dataoffset = TXW_DATA_OFFSET ;
|
|
psf->datalength = psf->filelength - TXW_DATA_OFFSET ;
|
|
psf->sf.frames = 2 * psf->datalength / 3 ;
|
|
|
|
|
|
if (psf->datalength % 3 == 1)
|
|
psf_log_printf (psf, "*** File seems to be truncated, %d extra bytes.\n",
|
|
(int) (psf->datalength % 3)) ;
|
|
|
|
if (txwh.attacklen + txwh.repeatlen > psf->sf.frames)
|
|
psf_log_printf (psf, "*** File has been truncated.\n") ;
|
|
|
|
psf->sf.format = SF_FORMAT_TXW | SF_FORMAT_PCM_16 ;
|
|
psf->sf.channels = 1 ;
|
|
psf->sf.sections = 1 ;
|
|
psf->sf.seekable = SF_TRUE ;
|
|
|
|
return 0 ;
|
|
} /* txw_read_header */
|
|
|
|
static sf_count_t
|
|
txw_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
|
|
{ BUF_UNION ubuf ;
|
|
unsigned char *ucptr ;
|
|
short sample ;
|
|
int k, bufferlen, readcount, count ;
|
|
sf_count_t total = 0 ;
|
|
|
|
bufferlen = sizeof (ubuf.cbuf) / 3 ;
|
|
bufferlen -= (bufferlen & 1) ;
|
|
while (len > 0)
|
|
{ readcount = (len >= bufferlen) ? bufferlen : len ;
|
|
count = psf_fread (ubuf.cbuf, 3, readcount, psf) ;
|
|
|
|
ucptr = ubuf.ucbuf ;
|
|
for (k = 0 ; k < readcount ; k += 2)
|
|
{ sample = (ucptr [0] << 8) | (ucptr [1] & 0xF0) ;
|
|
ptr [total + k] = sample ;
|
|
sample = (ucptr [2] << 8) | ((ucptr [1] & 0xF) << 4) ;
|
|
ptr [total + k + 1] = sample ;
|
|
ucptr += 3 ;
|
|
} ;
|
|
|
|
total += count ;
|
|
len -= readcount ;
|
|
} ;
|
|
|
|
return total ;
|
|
} /* txw_read_s */
|
|
|
|
static sf_count_t
|
|
txw_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
|
|
{ BUF_UNION ubuf ;
|
|
unsigned char *ucptr ;
|
|
short sample ;
|
|
int k, bufferlen, readcount, count ;
|
|
sf_count_t total = 0 ;
|
|
|
|
bufferlen = sizeof (ubuf.cbuf) / 3 ;
|
|
bufferlen -= (bufferlen & 1) ;
|
|
while (len > 0)
|
|
{ readcount = (len >= bufferlen) ? bufferlen : len ;
|
|
count = psf_fread (ubuf.cbuf, 3, readcount, psf) ;
|
|
|
|
ucptr = ubuf.ucbuf ;
|
|
for (k = 0 ; k < readcount ; k += 2)
|
|
{ sample = (ucptr [0] << 8) | (ucptr [1] & 0xF0) ;
|
|
ptr [total + k] = sample << 16 ;
|
|
sample = (ucptr [2] << 8) | ((ucptr [1] & 0xF) << 4) ;
|
|
ptr [total + k + 1] = sample << 16 ;
|
|
ucptr += 3 ;
|
|
} ;
|
|
|
|
total += count ;
|
|
len -= readcount ;
|
|
} ;
|
|
|
|
return total ;
|
|
} /* txw_read_i */
|
|
|
|
static sf_count_t
|
|
txw_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
|
|
{ BUF_UNION ubuf ;
|
|
unsigned char *ucptr ;
|
|
short sample ;
|
|
int k, bufferlen, readcount, count ;
|
|
sf_count_t total = 0 ;
|
|
float normfact ;
|
|
|
|
if (psf->norm_float == SF_TRUE)
|
|
normfact = 1.0 / 0x8000 ;
|
|
else
|
|
normfact = 1.0 / 0x10 ;
|
|
|
|
bufferlen = sizeof (ubuf.cbuf) / 3 ;
|
|
bufferlen -= (bufferlen & 1) ;
|
|
while (len > 0)
|
|
{ readcount = (len >= bufferlen) ? bufferlen : len ;
|
|
count = psf_fread (ubuf.cbuf, 3, readcount, psf) ;
|
|
|
|
ucptr = ubuf.ucbuf ;
|
|
for (k = 0 ; k < readcount ; k += 2)
|
|
{ sample = (ucptr [0] << 8) | (ucptr [1] & 0xF0) ;
|
|
ptr [total + k] = normfact * sample ;
|
|
sample = (ucptr [2] << 8) | ((ucptr [1] & 0xF) << 4) ;
|
|
ptr [total + k + 1] = normfact * sample ;
|
|
ucptr += 3 ;
|
|
} ;
|
|
|
|
total += count ;
|
|
len -= readcount ;
|
|
} ;
|
|
|
|
return total ;
|
|
} /* txw_read_f */
|
|
|
|
static sf_count_t
|
|
txw_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
|
|
{ BUF_UNION ubuf ;
|
|
unsigned char *ucptr ;
|
|
short sample ;
|
|
int k, bufferlen, readcount, count ;
|
|
sf_count_t total = 0 ;
|
|
double normfact ;
|
|
|
|
if (psf->norm_double == SF_TRUE)
|
|
normfact = 1.0 / 0x8000 ;
|
|
else
|
|
normfact = 1.0 / 0x10 ;
|
|
|
|
bufferlen = sizeof (ubuf.cbuf) / 3 ;
|
|
bufferlen -= (bufferlen & 1) ;
|
|
while (len > 0)
|
|
{ readcount = (len >= bufferlen) ? bufferlen : len ;
|
|
count = psf_fread (ubuf.cbuf, 3, readcount, psf) ;
|
|
|
|
ucptr = ubuf.ucbuf ;
|
|
for (k = 0 ; k < readcount ; k += 2)
|
|
{ sample = (ucptr [0] << 8) | (ucptr [1] & 0xF0) ;
|
|
ptr [total + k] = normfact * sample ;
|
|
sample = (ucptr [2] << 8) | ((ucptr [1] & 0xF) << 4) ;
|
|
ptr [total + k + 1] = normfact * sample ;
|
|
ucptr += 3 ;
|
|
} ;
|
|
|
|
total += count ;
|
|
len -= readcount ;
|
|
} ;
|
|
|
|
return total ;
|
|
} /* txw_read_d */
|
|
|
|
static sf_count_t
|
|
txw_seek (SF_PRIVATE *psf, int mode, sf_count_t offset)
|
|
{ if (psf && mode)
|
|
return offset ;
|
|
|
|
return 0 ;
|
|
} /* txw_seek */
|
|
|
|
#endif
|