2
** Copyright (C) 2002-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
4
** This program is free software; you can redistribute it and/or modify
5
** it under the terms of the GNU Lesser General Public License as published by
6
** the Free Software Foundation; either version 2.1 of the License, or
7
** (at your option) any later version.
9
** This program is distributed in the hope that it will be useful,
10
** but WITHOUT ANY WARRANTY; without even the implied warranty of
11
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
** GNU Lesser General Public License for more details.
14
** You should have received a copy of the GNU Lesser General Public License
15
** along with this program; if not, write to the Free Software
16
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
/*===========================================================================
20
** Delta Word Variable Width
22
** This decoder and encoder were implemented using information found in this
23
** document : http://home.swbell.net/rubywand/R011SNDFMTS.TXT
25
** According to the document, the algorithm "was invented 1991 by Magnus
26
** Lidstrom and is copyright 1993 by NuEdge Development".
37
#include "float_cast.h"
41
{ int dwm_maxsize, bit_width, max_delta, span ;
43
int bit_count, bits, last_delta_width, last_sample ;
46
unsigned char buffer [256] ;
50
/*============================================================================================
53
static sf_count_t dwvw_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
54
static sf_count_t dwvw_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
55
static sf_count_t dwvw_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
56
static sf_count_t dwvw_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
58
static sf_count_t dwvw_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
59
static sf_count_t dwvw_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
60
static sf_count_t dwvw_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
61
static sf_count_t dwvw_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
63
static sf_count_t dwvw_seek (SF_PRIVATE *psf, int mode, sf_count_t offset) ;
64
static int dwvw_close (SF_PRIVATE *psf) ;
66
static int dwvw_decode_data (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int *ptr, int len) ;
67
static int dwvw_decode_load_bits (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int bit_count) ;
69
static int dwvw_encode_data (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, const int *ptr, int len) ;
70
static void dwvw_encode_store_bits (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int data, int new_bits) ;
71
static void dwvw_read_reset (DWVW_PRIVATE *pdwvw) ;
73
/*============================================================================================
74
** DWVW initialisation function.
78
dwvw_init (SF_PRIVATE *psf, int bitwidth)
79
{ DWVW_PRIVATE *pdwvw ;
81
if (psf->fdata != NULL)
82
{ psf_log_printf (psf, "*** psf->fdata is not NULL.\n") ;
87
return SFE_DWVW_BAD_BITWIDTH ;
89
if (psf->mode == SFM_RDWR)
90
return SFE_BAD_MODE_RW ;
92
if ((pdwvw = calloc (1, sizeof (DWVW_PRIVATE))) == NULL)
93
return SFE_MALLOC_FAILED ;
95
psf->fdata = (void*) pdwvw ;
97
pdwvw->bit_width = bitwidth ;
98
pdwvw->dwm_maxsize = bitwidth / 2 ;
99
pdwvw->max_delta = 1 << (bitwidth - 1) ;
100
pdwvw->span = 1 << bitwidth ;
102
dwvw_read_reset (pdwvw) ;
104
if (psf->mode == SFM_READ)
105
{ psf->read_short = dwvw_read_s ;
106
psf->read_int = dwvw_read_i ;
107
psf->read_float = dwvw_read_f ;
108
psf->read_double = dwvw_read_d ;
111
if (psf->mode == SFM_WRITE)
112
{ psf->write_short = dwvw_write_s ;
113
psf->write_int = dwvw_write_i ;
114
psf->write_float = dwvw_write_f ;
115
psf->write_double = dwvw_write_d ;
118
psf->codec_close = dwvw_close ;
119
psf->seek = dwvw_seek ;
121
/* FIXME : This is bogus. */
122
psf->sf.frames = SF_COUNT_MAX ;
123
psf->datalength = psf->sf.frames ;
124
/* EMXIF : This is bogus. */
129
/*--------------------------------------------------------------------------------------------
133
dwvw_close (SF_PRIVATE *psf)
134
{ DWVW_PRIVATE *pdwvw ;
136
if (psf->fdata == NULL)
138
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
140
if (psf->mode == SFM_WRITE)
141
{ static int last_values [12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } ;
143
/* Write 8 zero samples to fully flush output. */
144
dwvw_encode_data (psf, pdwvw, last_values, 12) ;
146
/* Write the last buffer worth of data to disk. */
147
psf_fwrite (pdwvw->b.buffer, 1, pdwvw->b.index, psf) ;
149
if (psf->write_header)
150
psf->write_header (psf, SF_TRUE) ;
157
dwvw_seek (SF_PRIVATE *psf, int mode, sf_count_t offset)
158
{ DWVW_PRIVATE *pdwvw ;
163
{ psf->error = SFE_INTERNAL ;
164
return PSF_SEEK_ERROR ;
167
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
170
{ psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
171
dwvw_read_reset (pdwvw) ;
175
psf->error = SFE_BAD_SEEK ;
176
return PSF_SEEK_ERROR ;
180
/*==============================================================================
184
dwvw_read_s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
185
{ DWVW_PRIVATE *pdwvw ;
187
int k, bufferlen, readcount = 0, count ;
188
sf_count_t total = 0 ;
192
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
195
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
197
{ readcount = (len >= bufferlen) ? bufferlen : len ;
198
count = dwvw_decode_data (psf, pdwvw, iptr, readcount) ;
199
for (k = 0 ; k < readcount ; k++)
200
ptr [total + k] = iptr [k] >> 16 ;
204
if (count != readcount)
212
dwvw_read_i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
213
{ DWVW_PRIVATE *pdwvw ;
214
int readcount, count ;
215
sf_count_t total = 0 ;
219
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
222
{ readcount = (len > 0x10000000) ? 0x10000000 : (int) len ;
224
count = dwvw_decode_data (psf, pdwvw, ptr, readcount) ;
229
if (count != readcount)
237
dwvw_read_f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
238
{ DWVW_PRIVATE *pdwvw ;
240
int k, bufferlen, readcount = 0, count ;
241
sf_count_t total = 0 ;
246
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
248
normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x80000000) : 1.0 ;
251
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
253
{ readcount = (len >= bufferlen) ? bufferlen : len ;
254
count = dwvw_decode_data (psf, pdwvw, iptr, readcount) ;
255
for (k = 0 ; k < readcount ; k++)
256
ptr [total + k] = normfact * (float) (iptr [k]) ;
260
if (count != readcount)
268
dwvw_read_d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
269
{ DWVW_PRIVATE *pdwvw ;
271
int k, bufferlen, readcount = 0, count ;
272
sf_count_t total = 0 ;
277
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
279
normfact = (psf->norm_double == SF_TRUE) ? 1.0 / ((double) 0x80000000) : 1.0 ;
282
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
284
{ readcount = (len >= bufferlen) ? bufferlen : len ;
285
count = dwvw_decode_data (psf, pdwvw, iptr, readcount) ;
286
for (k = 0 ; k < readcount ; k++)
287
ptr [total + k] = normfact * (double) (iptr [k]) ;
291
if (count != readcount)
299
dwvw_decode_data (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int *ptr, int len)
301
int delta_width_modifier, delta_width, delta_negative, delta, sample ;
303
/* Restore state from last decode call. */
304
delta_width = pdwvw->last_delta_width ;
305
sample = pdwvw->last_sample ;
307
for (count = 0 ; count < len ; count++)
308
{ /* If bit_count parameter is zero get the delta_width_modifier. */
309
delta_width_modifier = dwvw_decode_load_bits (psf, pdwvw, -1) ;
311
/* Check for end of input bit stream. Break loop if end. */
312
if (delta_width_modifier < 0)
315
if (delta_width_modifier && dwvw_decode_load_bits (psf, pdwvw, 1))
316
delta_width_modifier = - delta_width_modifier ;
318
/* Calculate the current word width. */
319
delta_width = (delta_width + delta_width_modifier + pdwvw->bit_width) % pdwvw->bit_width ;
321
/* Load the delta. */
324
{ delta = dwvw_decode_load_bits (psf, pdwvw, delta_width - 1) | (1 << (delta_width - 1)) ;
325
delta_negative = dwvw_decode_load_bits (psf, pdwvw, 1) ;
326
if (delta == pdwvw->max_delta - 1)
327
delta += dwvw_decode_load_bits (psf, pdwvw, 1) ;
332
/* Calculate the sample */
335
if (sample >= pdwvw->max_delta)
336
sample -= pdwvw->span ;
337
else if (sample < - pdwvw->max_delta)
338
sample += pdwvw->span ;
340
/* Store the sample justifying to the most significant bit. */
341
ptr [count] = sample << (32 - pdwvw->bit_width) ;
343
if (pdwvw->b.end == 0 && pdwvw->bit_count == 0)
347
pdwvw->last_delta_width = delta_width ;
348
pdwvw->last_sample = sample ;
350
pdwvw->samplecount += count ;
353
} /* dwvw_decode_data */
356
dwvw_decode_load_bits (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int bit_count)
357
{ int output = 0, get_dwm = SF_FALSE ;
360
** Depending on the value of parameter bit_count, either get the
361
** required number of bits (ie bit_count > 0) or the
362
** delta_width_modifier (otherwise).
366
{ get_dwm = SF_TRUE ;
367
/* modify bit_count to ensure we have enought bits for finding dwm. */
368
bit_count = pdwvw->dwm_maxsize ;
371
/* Load bits in bit reseviour. */
372
while (pdwvw->bit_count < bit_count)
373
{ if (pdwvw->b.index >= pdwvw->b.end)
374
{ pdwvw->b.end = psf_fread (pdwvw->b.buffer, 1, sizeof (pdwvw->b.buffer), psf) ;
378
/* Check for end of input stream. */
379
if (bit_count < 8 && pdwvw->b.end == 0)
382
pdwvw->bits = (pdwvw->bits << 8) ;
384
if (pdwvw->b.index < pdwvw->b.end)
385
{ pdwvw->bits |= pdwvw->b.buffer [pdwvw->b.index] ;
388
pdwvw->bit_count += 8 ;
391
/* If asked to get bits do so. */
393
{ output = (pdwvw->bits >> (pdwvw->bit_count - bit_count)) & ((1 << bit_count) - 1) ;
394
pdwvw->bit_count -= bit_count ;
398
/* Otherwise must have been asked to get delta_width_modifier. */
399
while (output < (pdwvw->dwm_maxsize))
400
{ pdwvw->bit_count -= 1 ;
401
if (pdwvw->bits & (1 << pdwvw->bit_count))
407
} /* dwvw_decode_load_bits */
410
dwvw_read_reset (DWVW_PRIVATE *pdwvw)
411
{ pdwvw->samplecount = 0 ;
414
pdwvw->bit_count = 0 ;
416
pdwvw->last_delta_width = 0 ;
417
pdwvw->last_sample = 0 ;
418
} /* dwvw_read_reset */
421
dwvw_encode_store_bits (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, int data, int new_bits)
424
/* Shift the bits into the resevoir. */
425
pdwvw->bits = (pdwvw->bits << new_bits) | (data & ((1 << new_bits) - 1)) ;
426
pdwvw->bit_count += new_bits ;
428
/* Transfer bit to buffer. */
429
while (pdwvw->bit_count >= 8)
430
{ byte = pdwvw->bits >> (pdwvw->bit_count - 8) ;
431
pdwvw->bit_count -= 8 ;
432
pdwvw->b.buffer [pdwvw->b.index] = byte & 0xFF ;
436
if (pdwvw->b.index > SIGNED_SIZEOF (pdwvw->b.buffer) - 4)
437
{ psf_fwrite (pdwvw->b.buffer, 1, pdwvw->b.index, psf) ;
442
} /* dwvw_encode_store_bits */
445
/* Debigging routine. */
447
dump_bits (DWVW_PRIVATE *pdwvw)
450
for (k = 0 ; k < 10 && k < pdwvw->b.index ; k++)
453
{ putchar (mask & pdwvw->b.buffer [k] ? '1' : '0') ;
459
for (k = pdwvw->bit_count - 1 ; k >= 0 ; k --)
460
putchar (pdwvw->bits & (1 << k) ? '1' : '0') ;
466
#define HIGHEST_BIT(x,count) \
476
dwvw_encode_data (SF_PRIVATE *psf, DWVW_PRIVATE *pdwvw, const int *ptr, int len)
478
int delta_width_modifier, delta, delta_negative, delta_width, extra_bit ;
480
for (count = 0 ; count < len ; count++)
481
{ delta = (ptr [count] >> (32 - pdwvw->bit_width)) - pdwvw->last_sample ;
483
/* Calculate extra_bit if needed. */
486
if (delta < -pdwvw->max_delta)
487
delta = pdwvw->max_delta + (delta % pdwvw->max_delta) ;
488
else if (delta == -pdwvw->max_delta)
491
delta = pdwvw->max_delta - 1 ;
493
else if (delta > pdwvw->max_delta)
494
{ delta_negative = 1 ;
495
delta = pdwvw->span - delta ;
496
delta = abs (delta) ;
498
else if (delta == pdwvw->max_delta)
500
delta = pdwvw->max_delta - 1 ;
503
{ delta_negative = 1 ;
504
delta = abs (delta) ;
507
if (delta == pdwvw->max_delta - 1 && extra_bit == -1)
510
/* Find width in bits of delta */
511
HIGHEST_BIT (delta, delta_width) ;
513
/* Calculate the delta_width_modifier */
514
delta_width_modifier = (delta_width - pdwvw->last_delta_width) % pdwvw->bit_width ;
515
if (delta_width_modifier > pdwvw->dwm_maxsize)
516
delta_width_modifier -= pdwvw->bit_width ;
517
if (delta_width_modifier < -pdwvw->dwm_maxsize)
518
delta_width_modifier += pdwvw->bit_width ;
520
/* Write delta_width_modifier zeros, followed by terminating '1'. */
521
dwvw_encode_store_bits (psf, pdwvw, 0, abs (delta_width_modifier)) ;
522
if (abs (delta_width_modifier) != pdwvw->dwm_maxsize)
523
dwvw_encode_store_bits (psf, pdwvw, 1, 1) ;
525
/* Write delta_width_modifier sign. */
526
if (delta_width_modifier < 0)
527
dwvw_encode_store_bits (psf, pdwvw, 1, 1) ;
528
if (delta_width_modifier > 0)
529
dwvw_encode_store_bits (psf, pdwvw, 0, 1) ;
531
/* Write delta and delta sign bit. */
533
{ dwvw_encode_store_bits (psf, pdwvw, delta, abs (delta_width) - 1) ;
534
dwvw_encode_store_bits (psf, pdwvw, (delta_negative ? 1 : 0), 1) ;
537
/* Write extra bit!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
539
dwvw_encode_store_bits (psf, pdwvw, extra_bit, 1) ;
541
pdwvw->last_sample = ptr [count] >> (32 - pdwvw->bit_width) ;
542
pdwvw->last_delta_width = delta_width ;
545
pdwvw->samplecount += count ;
548
} /* dwvw_encode_data */
551
dwvw_write_s (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
552
{ DWVW_PRIVATE *pdwvw ;
554
int k, bufferlen, writecount = 0, count ;
555
sf_count_t total = 0 ;
559
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
562
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
564
{ writecount = (len >= bufferlen) ? bufferlen : len ;
565
for (k = 0 ; k < writecount ; k++)
566
iptr [k] = ptr [total + k] << 16 ;
567
count = dwvw_encode_data (psf, pdwvw, iptr, writecount) ;
571
if (count != writecount)
579
dwvw_write_i (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
580
{ DWVW_PRIVATE *pdwvw ;
581
int writecount, count ;
582
sf_count_t total = 0 ;
586
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
589
{ writecount = (len > 0x10000000) ? 0x10000000 : (int) len ;
591
count = dwvw_encode_data (psf, pdwvw, ptr, writecount) ;
596
if (count != writecount)
604
dwvw_write_f (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
605
{ DWVW_PRIVATE *pdwvw ;
607
int k, bufferlen, writecount = 0, count ;
608
sf_count_t total = 0 ;
613
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
615
normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFFFFFF) : 1.0 ;
618
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
620
{ writecount = (len >= bufferlen) ? bufferlen : len ;
621
for (k = 0 ; k < writecount ; k++)
622
iptr [k] = lrintf (normfact * ptr [total + k]) ;
623
count = dwvw_encode_data (psf, pdwvw, iptr, writecount) ;
627
if (count != writecount)
635
dwvw_write_d (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
636
{ DWVW_PRIVATE *pdwvw ;
638
int k, bufferlen, writecount = 0, count ;
639
sf_count_t total = 0 ;
644
pdwvw = (DWVW_PRIVATE*) psf->fdata ;
646
normfact = (psf->norm_double == SF_TRUE) ? (1.0 * 0x7FFFFFFF) : 1.0 ;
649
bufferlen = ARRAY_LEN (psf->u.ibuf) ;
651
{ writecount = (len >= bufferlen) ? bufferlen : len ;
652
for (k = 0 ; k < writecount ; k++)
653
iptr [k] = lrint (normfact * ptr [total + k]) ;
654
count = dwvw_encode_data (psf, pdwvw, iptr, writecount) ;
658
if (count != writecount)
666
** Do not edit or modify anything in this comment block.
667
** The arch-tag line is a file identity tag for the GNU Arch
668
** revision control system.
670
** arch-tag: 1ca09552-b01f-4d7f-9bcf-612f834fe41d
added
removed
lib-src/libsndfile/src/dwvw.c
