← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/audacity/gutsy-backports

« back to all changes in this revision

Viewing changes to lib-src/libsndfile/src/alaw.c

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2008-02-18 21:58:19 UTC
  • mfrom: (13.1.2 hardy)
  • Revision ID: james.westby@ubuntu.com-20080218215819-tmbcf1rx238r8gdv
Tags: 1.3.4-1.1ubuntu1~gutsy1
Automated backport upload; no source changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-src/libsndfile/src/alaw.c
1
 
/*
2
 
** Copyright (C) 1999-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
3
 
**
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.
8
 
**
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.
13
 
**
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.
17
 
*/
18
 
 
19
 
#include        "sndfile.h"
20
 
#include        "float_cast.h"
21
 
#include        "common.h"
22
 
 
23
 
static sf_count_t alaw_read_alaw2s (SF_PRIVATE *psf, short *ptr, sf_count_t len) ;
24
 
static sf_count_t alaw_read_alaw2i (SF_PRIVATE *psf, int *ptr, sf_count_t len) ;
25
 
static sf_count_t alaw_read_alaw2f (SF_PRIVATE *psf, float *ptr, sf_count_t len) ;
26
 
static sf_count_t alaw_read_alaw2d (SF_PRIVATE *psf, double *ptr, sf_count_t len) ;
27
 
 
28
 
static sf_count_t alaw_write_s2alaw (SF_PRIVATE *psf, const short *ptr, sf_count_t len) ;
29
 
static sf_count_t alaw_write_i2alaw (SF_PRIVATE *psf, const int *ptr, sf_count_t len) ;
30
 
static sf_count_t alaw_write_f2alaw (SF_PRIVATE *psf, const float *ptr, sf_count_t len) ;
31
 
static sf_count_t alaw_write_d2alaw (SF_PRIVATE *psf, const double *ptr, sf_count_t len) ;
32
 
 
33
 
static void alaw2s_array (unsigned char *buffer, int count, short *ptr) ;
34
 
static void alaw2i_array (unsigned char *buffer, int count, int *ptr) ;
35
 
static void alaw2f_array (unsigned char *buffer, int count, float *ptr, float normfact) ;
36
 
static void alaw2d_array (unsigned char *buffer, int count, double *ptr, double normfact) ;
37
 
 
38
 
static void s2alaw_array (const short *buffer, int count, unsigned char *ptr) ;
39
 
static void i2alaw_array (const int *buffer, int count, unsigned char *ptr) ;
40
 
static void f2alaw_array (const float *buffer, int count, unsigned char *ptr, float normfact) ;
41
 
static void d2alaw_array (const double *buffer, int count, unsigned char *ptr, double normfact) ;
42
 
 
43
 
 
44
 
int
45
 
alaw_init (SF_PRIVATE *psf)
46
 
{
47
 
        if (psf->mode == SFM_READ || psf->mode == SFM_RDWR)
48
 
        {       psf->read_short         = alaw_read_alaw2s ;
49
 
                psf->read_int           = alaw_read_alaw2i ;
50
 
                psf->read_float         = alaw_read_alaw2f ;
51
 
                psf->read_double        = alaw_read_alaw2d ;
52
 
                } ;
53
 
 
54
 
        if (psf->mode == SFM_WRITE || psf->mode == SFM_RDWR)
55
 
        {       psf->write_short        = alaw_write_s2alaw ;
56
 
                psf->write_int          = alaw_write_i2alaw ;
57
 
                psf->write_float        = alaw_write_f2alaw ;
58
 
                psf->write_double       = alaw_write_d2alaw ;
59
 
                } ;
60
 
 
61
 
        psf->bytewidth = 1 ;
62
 
        psf->blockwidth = psf->sf.channels ;
63
 
 
64
 
        if (psf->filelength > psf->dataoffset)
65
 
                psf->datalength = (psf->dataend) ? psf->dataend - psf->dataoffset : psf->filelength - psf->dataoffset ;
66
 
        else
67
 
                psf->datalength = 0 ;
68
 
 
69
 
        psf->sf.frames = psf->datalength / psf->blockwidth ;
70
 
 
71
 
        return 0 ;
72
 
} /* alaw_init */
73
 
 
74
 
/*==============================================================================
75
 
 *      Private static functions and data.
76
 
 */
77
 
 
78
 
static
79
 
short alaw_decode [256] =
80
 
{       -5504,  -5248,  -6016,  -5760,  -4480,  -4224,  -4992,  -4736,
81
 
        -7552,  -7296,  -8064,  -7808,  -6528,  -6272,  -7040,  -6784,
82
 
        -2752,  -2624,  -3008,  -2880,  -2240,  -2112,  -2496,  -2368,
83
 
        -3776,  -3648,  -4032,  -3904,  -3264,  -3136,  -3520,  -3392,
84
 
        -22016, -20992, -24064, -23040, -17920, -16896, -19968, -18944,
85
 
        -30208, -29184, -32256, -31232, -26112, -25088, -28160, -27136,
86
 
        -11008, -10496, -12032, -11520, -8960,  -8448,  -9984,  -9472,
87
 
        -15104, -14592, -16128, -15616, -13056, -12544, -14080, -13568,
88
 
        -344,   -328,   -376,   -360,   -280,   -264,   -312,   -296,
89
 
        -472,   -456,   -504,   -488,   -408,   -392,   -440,   -424,
90
 
        -88,    -72,    -120,   -104,   -24,    -8,             -56,    -40,
91
 
        -216,   -200,   -248,   -232,   -152,   -136,   -184,   -168,
92
 
        -1376,  -1312,  -1504,  -1440,  -1120,  -1056,  -1248,  -1184,
93
 
        -1888,  -1824,  -2016,  -1952,  -1632,  -1568,  -1760,  -1696,
94
 
        -688,   -656,   -752,   -720,   -560,   -528,   -624,   -592,
95
 
        -944,   -912,   -1008,  -976,   -816,   -784,   -880,   -848,
96
 
        5504,   5248,   6016,   5760,   4480,   4224,   4992,   4736,
97
 
        7552,   7296,   8064,   7808,   6528,   6272,   7040,   6784,
98
 
        2752,   2624,   3008,   2880,   2240,   2112,   2496,   2368,
99
 
        3776,   3648,   4032,   3904,   3264,   3136,   3520,   3392,
100
 
        22016,  20992,  24064,  23040,  17920,  16896,  19968,  18944,
101
 
        30208,  29184,  32256,  31232,  26112,  25088,  28160,  27136,
102
 
        11008,  10496,  12032,  11520,  8960,   8448,   9984,   9472,
103
 
        15104,  14592,  16128,  15616,  13056,  12544,  14080,  13568,
104
 
        344,    328,    376,    360,    280,    264,    312,    296,
105
 
        472,    456,    504,    488,    408,    392,    440,    424,
106
 
        88,             72,             120,    104,    24,             8,              56,             40,
107
 
        216,    200,    248,    232,    152,    136,    184,    168,
108
 
        1376,   1312,   1504,   1440,   1120,   1056,   1248,   1184,
109
 
        1888,   1824,   2016,   1952,   1632,   1568,   1760,   1696,
110
 
        688,    656,    752,    720,    560,    528,    624,    592,
111
 
        944,    912,    1008,   976,    816,    784,    880,    848
112
 
} ; /* alaw_decode */
113
 
 
114
 
static
115
 
unsigned char alaw_encode [2048 + 1] =
116
 
{       0xd5, 0xd4, 0xd7, 0xd6, 0xd1, 0xd0, 0xd3, 0xd2, 0xdd, 0xdc, 0xdf, 0xde,
117
 
        0xd9, 0xd8, 0xdb, 0xda, 0xc5, 0xc4, 0xc7, 0xc6, 0xc1, 0xc0, 0xc3, 0xc2,
118
 
        0xcd, 0xcc, 0xcf, 0xce, 0xc9, 0xc8, 0xcb, 0xca, 0xf5, 0xf5, 0xf4, 0xf4,
119
 
        0xf7, 0xf7, 0xf6, 0xf6, 0xf1, 0xf1, 0xf0, 0xf0, 0xf3, 0xf3, 0xf2, 0xf2,
120
 
        0xfd, 0xfd, 0xfc, 0xfc, 0xff, 0xff, 0xfe, 0xfe, 0xf9, 0xf9, 0xf8, 0xf8,
121
 
        0xfb, 0xfb, 0xfa, 0xfa, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4,
122
 
        0xe7, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe1, 0xe1, 0xe1, 0xe1,
123
 
        0xe0, 0xe0, 0xe0, 0xe0, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2,
124
 
        0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xef, 0xef, 0xef, 0xef,
125
 
        0xee, 0xee, 0xee, 0xee, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8,
126
 
        0xeb, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0x95, 0x95, 0x95, 0x95,
127
 
        0x95, 0x95, 0x95, 0x95, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
128
 
        0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96, 0x96,
129
 
        0x96, 0x96, 0x96, 0x96, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
130
 
        0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x93, 0x93, 0x93, 0x93,
131
 
        0x93, 0x93, 0x93, 0x93, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
132
 
        0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c, 0x9c, 0x9c, 0x9c,
133
 
        0x9c, 0x9c, 0x9c, 0x9c, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
134
 
        0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x99, 0x99, 0x99, 0x99,
135
 
        0x99, 0x99, 0x99, 0x99, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
136
 
        0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9a, 0x9a, 0x9a, 0x9a,
137
 
        0x9a, 0x9a, 0x9a, 0x9a, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
138
 
        0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84,
139
 
        0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
140
 
        0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
141
 
        0x87, 0x87, 0x87, 0x87, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
142
 
        0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x81, 0x81, 0x81, 0x81,
143
 
        0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
144
 
        0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
145
 
        0x80, 0x80, 0x80, 0x80, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
146
 
        0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
147
 
        0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
148
 
        0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
149
 
        0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
150
 
        0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8f, 0x8f, 0x8f, 0x8f,
151
 
        0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
152
 
        0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
153
 
        0x8e, 0x8e, 0x8e, 0x8e, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
154
 
        0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88,
155
 
        0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
156
 
        0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
157
 
        0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
158
 
        0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0xb5, 0xb5, 0xb5, 0xb5,
159
 
        0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
160
 
        0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
161
 
        0xb5, 0xb5, 0xb5, 0xb5, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
162
 
        0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
163
 
        0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
164
 
        0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
165
 
        0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
166
 
        0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb6, 0xb6, 0xb6, 0xb6,
167
 
        0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
168
 
        0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
169
 
        0xb6, 0xb6, 0xb6, 0xb6, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
170
 
        0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
171
 
        0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
172
 
        0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
173
 
        0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
174
 
        0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb3, 0xb3, 0xb3, 0xb3,
175
 
        0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
176
 
        0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
177
 
        0xb3, 0xb3, 0xb3, 0xb3, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
178
 
        0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
179
 
        0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
180
 
        0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
181
 
        0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
182
 
        0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc, 0xbc, 0xbc, 0xbc,
183
 
        0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
184
 
        0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
185
 
        0xbc, 0xbc, 0xbc, 0xbc, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
186
 
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
187
 
        0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
188
 
        0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
189
 
        0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
190
 
        0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xb9, 0xb9, 0xb9, 0xb9,
191
 
        0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
192
 
        0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
193
 
        0xb9, 0xb9, 0xb9, 0xb9, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
194
 
        0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
195
 
        0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
196
 
        0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
197
 
        0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
198
 
        0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba, 0xba, 0xba, 0xba,
199
 
        0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
200
 
        0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
201
 
        0xba, 0xba, 0xba, 0xba, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
202
 
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
203
 
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
204
 
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
205
 
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
206
 
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4,
207
 
        0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
208
 
        0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
209
 
        0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
210
 
        0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
211
 
        0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
212
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
213
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
214
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
215
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
216
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
217
 
        0xa7, 0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
218
 
        0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
219
 
        0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
220
 
        0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
221
 
        0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
222
 
        0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa1, 0xa1, 0xa1, 0xa1,
223
 
        0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
224
 
        0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
225
 
        0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
226
 
        0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
227
 
        0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
228
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
229
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
230
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
231
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
232
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
233
 
        0xa0, 0xa0, 0xa0, 0xa0, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
234
 
        0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
235
 
        0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
236
 
        0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
237
 
        0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
238
 
        0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2,
239
 
        0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
240
 
        0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
241
 
        0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
242
 
        0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
243
 
        0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
244
 
        0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
245
 
        0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
246
 
        0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
247
 
        0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
248
 
        0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
249
 
        0xad, 0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
250
 
        0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
251
 
        0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
252
 
        0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
253
 
        0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
254
 
        0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xaf, 0xaf, 0xaf, 0xaf,
255
 
        0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
256
 
        0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
257
 
        0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
258
 
        0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
259
 
        0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
260
 
        0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
261
 
        0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
262
 
        0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
263
 
        0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
264
 
        0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
265
 
        0xae, 0xae, 0xae, 0xae, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
266
 
        0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
267
 
        0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
268
 
        0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
269
 
        0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
270
 
        0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8,
271
 
        0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
272
 
        0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
273
 
        0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
274
 
        0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
275
 
        0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
276
 
        0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
277
 
        0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
278
 
        0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
279
 
        0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
280
 
        0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
281
 
        0xab, 0xab, 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
282
 
        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
283
 
        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
284
 
        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
285
 
        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
286
 
        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0x2a
287
 
} ; /* alaw_encode */
288
 
 
289
 
static inline void
290
 
alaw2s_array (unsigned char *buffer, int count, short *ptr)
291
 
{       while (--count >= 0)
292
 
                ptr [count] = alaw_decode [(int) buffer [count]] ;
293
 
} /* alaw2s_array */
294
 
 
295
 
static inline void
296
 
alaw2i_array (unsigned char *buffer, int count, int *ptr)
297
 
{       while (--count >= 0)
298
 
                ptr [count] = alaw_decode [(int) buffer [count]] << 16 ;
299
 
} /* alaw2i_array */
300
 
 
301
 
static inline void
302
 
alaw2f_array (unsigned char *buffer, int count, float *ptr, float normfact)
303
 
{       while (--count >= 0)
304
 
                ptr [count] = normfact * alaw_decode [(int) buffer [count]] ;
305
 
} /* alaw2f_array */
306
 
 
307
 
static inline void
308
 
alaw2d_array (unsigned char *buffer, int count, double *ptr, double normfact)
309
 
{       while (--count >= 0)
310
 
                ptr [count] = normfact * alaw_decode [(int) buffer [count]] ;
311
 
} /* alaw2d_array */
312
 
 
313
 
static inline void
314
 
s2alaw_array (const short *ptr, int count, unsigned char *buffer)
315
 
{       while (--count >= 0)
316
 
        {       if (ptr [count] >= 0)
317
 
                        buffer [count] = alaw_encode [ptr [count] / 16] ;
318
 
                else
319
 
                        buffer [count] = 0x7F & alaw_encode [ptr [count] / -16] ;
320
 
                } ;
321
 
} /* s2alaw_array */
322
 
 
323
 
static inline void
324
 
i2alaw_array (const int *ptr, int count, unsigned char *buffer)
325
 
{       while (--count >= 0)
326
 
        {       if (ptr [count] >= 0)
327
 
                        buffer [count] = alaw_encode [ptr [count] >> (16 + 4)] ;
328
 
                else
329
 
                        buffer [count] = 0x7F & alaw_encode [- ptr [count] >> (16 + 4)] ;
330
 
                } ;
331
 
} /* i2alaw_array */
332
 
 
333
 
static inline void
334
 
f2alaw_array (const float *ptr, int count, unsigned char *buffer, float normfact)
335
 
{       while (--count >= 0)
336
 
        {       if (ptr [count] >= 0)
337
 
                        buffer [count] = alaw_encode [lrintf (normfact * ptr [count])] ;
338
 
                else
339
 
                        buffer [count] = 0x7F & alaw_encode [- lrintf (normfact * ptr [count])] ;
340
 
                } ;
341
 
} /* f2alaw_array */
342
 
 
343
 
static inline void
344
 
d2alaw_array (const double *ptr, int count, unsigned char *buffer, double normfact)
345
 
{       while (--count >= 0)
346
 
        {       if (ptr [count] >= 0)
347
 
                        buffer [count] = alaw_encode [lrint (normfact * ptr [count])] ;
348
 
                else
349
 
                        buffer [count] = 0x7F & alaw_encode [- lrint (normfact * ptr [count])] ;
350
 
                } ;
351
 
} /* d2alaw_array */
352
 
 
353
 
/*==============================================================================
354
 
*/
355
 
 
356
 
static sf_count_t
357
 
alaw_read_alaw2s (SF_PRIVATE *psf, short *ptr, sf_count_t len)
358
 
{       int                     bufferlen, readcount ;
359
 
        sf_count_t      total = 0 ;
360
 
 
361
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
362
 
 
363
 
        while (len > 0)
364
 
        {       if (len < bufferlen)
365
 
                        bufferlen = (int) len ;
366
 
                readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
367
 
                alaw2s_array (psf->u.ucbuf, readcount, ptr + total) ;
368
 
                total += readcount ;
369
 
                if (readcount < bufferlen)
370
 
                        break ;
371
 
                len -= readcount ;
372
 
                } ;
373
 
 
374
 
        return total ;
375
 
} /* alaw_read_alaw2s */
376
 
 
377
 
static sf_count_t
378
 
alaw_read_alaw2i (SF_PRIVATE *psf, int *ptr, sf_count_t len)
379
 
{       int                     bufferlen, readcount ;
380
 
        sf_count_t      total = 0 ;
381
 
 
382
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
383
 
 
384
 
        while (len > 0)
385
 
        {       if (len < bufferlen)
386
 
                        bufferlen = (int) len ;
387
 
                readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
388
 
                alaw2i_array (psf->u.ucbuf, readcount, ptr + total) ;
389
 
                total += readcount ;
390
 
                if (readcount < bufferlen)
391
 
                        break ;
392
 
                len -= readcount ;
393
 
                } ;
394
 
 
395
 
        return total ;
396
 
} /* alaw_read_alaw2i */
397
 
 
398
 
static sf_count_t
399
 
alaw_read_alaw2f (SF_PRIVATE *psf, float *ptr, sf_count_t len)
400
 
{       int                     bufferlen, readcount ;
401
 
        sf_count_t      total = 0 ;
402
 
        float   normfact ;
403
 
 
404
 
        normfact = (psf->norm_float == SF_TRUE) ? 1.0 / ((float) 0x8000) : 1.0 ;
405
 
 
406
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
407
 
 
408
 
        while (len > 0)
409
 
        {       if (len < bufferlen)
410
 
                        bufferlen = (int) len ;
411
 
                readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
412
 
                alaw2f_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
413
 
                total += readcount ;
414
 
                if (readcount < bufferlen)
415
 
                        break ;
416
 
                len -= readcount ;
417
 
                } ;
418
 
 
419
 
        return total ;
420
 
} /* alaw_read_alaw2f */
421
 
 
422
 
static sf_count_t
423
 
alaw_read_alaw2d (SF_PRIVATE *psf, double *ptr, sf_count_t len)
424
 
{       int                     bufferlen, readcount ;
425
 
        sf_count_t      total = 0 ;
426
 
        double  normfact ;
427
 
 
428
 
        normfact = (psf->norm_double) ? 1.0 / ((double) 0x8000) : 1.0 ;
429
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
430
 
 
431
 
        while (len > 0)
432
 
        {       if (len < bufferlen)
433
 
                        bufferlen = (int) len ;
434
 
                readcount = psf_fread (psf->u.ucbuf, 1, bufferlen, psf) ;
435
 
                alaw2d_array (psf->u.ucbuf, readcount, ptr + total, normfact) ;
436
 
                total += readcount ;
437
 
                if (readcount < bufferlen)
438
 
                        break ;
439
 
                len -= readcount ;
440
 
                } ;
441
 
 
442
 
        return total ;
443
 
} /* alaw_read_alaw2d */
444
 
 
445
 
/*=============================================================================================
446
 
*/
447
 
 
448
 
static sf_count_t
449
 
alaw_write_s2alaw       (SF_PRIVATE *psf, const short *ptr, sf_count_t len)
450
 
{       int                     bufferlen, writecount ;
451
 
        sf_count_t      total = 0 ;
452
 
 
453
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
454
 
 
455
 
        while (len > 0)
456
 
        {       if (len < bufferlen)
457
 
                        bufferlen = (int) len ;
458
 
                s2alaw_array (ptr + total, bufferlen, psf->u.ucbuf) ;
459
 
                writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
460
 
                total += writecount ;
461
 
                if (writecount < bufferlen)
462
 
                        break ;
463
 
                len -= writecount ;
464
 
                } ;
465
 
 
466
 
        return total ;
467
 
} /* alaw_write_s2alaw */
468
 
 
469
 
static sf_count_t
470
 
alaw_write_i2alaw       (SF_PRIVATE *psf, const int *ptr, sf_count_t len)
471
 
{       int                     bufferlen, writecount ;
472
 
        sf_count_t      total = 0 ;
473
 
 
474
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
475
 
 
476
 
        while (len > 0)
477
 
        {       if (len < bufferlen)
478
 
                        bufferlen = (int) len ;
479
 
                i2alaw_array (ptr + total, bufferlen, psf->u.ucbuf) ;
480
 
                writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
481
 
                total += writecount ;
482
 
                if (writecount < bufferlen)
483
 
                        break ;
484
 
                len -= writecount ;
485
 
                } ;
486
 
 
487
 
        return total ;
488
 
} /* alaw_write_i2alaw */
489
 
 
490
 
static sf_count_t
491
 
alaw_write_f2alaw       (SF_PRIVATE *psf, const float *ptr, sf_count_t len)
492
 
{       int                     bufferlen, writecount ;
493
 
        sf_count_t      total = 0 ;
494
 
        float   normfact ;
495
 
 
496
 
        normfact = (psf->norm_float == SF_TRUE) ? (1.0 * 0x7FFF) / 16.0 : 1.0 / 16 ;
497
 
 
498
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
499
 
 
500
 
        while (len > 0)
501
 
        {       if (len < bufferlen)
502
 
                        bufferlen = (int) len ;
503
 
                f2alaw_array (ptr + total, bufferlen, psf->u.ucbuf, normfact) ;
504
 
                writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
505
 
                total += writecount ;
506
 
                if (writecount < bufferlen)
507
 
                        break ;
508
 
                len -= writecount ;
509
 
                } ;
510
 
 
511
 
        return total ;
512
 
} /* alaw_write_f2alaw */
513
 
 
514
 
static sf_count_t
515
 
alaw_write_d2alaw       (SF_PRIVATE *psf, const double *ptr, sf_count_t len)
516
 
{       int                     bufferlen, writecount ;
517
 
        sf_count_t      total = 0 ;
518
 
        double  normfact ;
519
 
 
520
 
        normfact = (psf->norm_double) ? (1.0 * 0x7FFF) / 16.0 : 1.0 / 16.0 ;
521
 
 
522
 
        bufferlen = ARRAY_LEN (psf->u.ucbuf) ;
523
 
 
524
 
        while (len > 0)
525
 
        {       if (len < bufferlen)
526
 
                        bufferlen = (int) len ;
527
 
                d2alaw_array (ptr + total, bufferlen, psf->u.ucbuf, normfact) ;
528
 
                writecount = psf_fwrite (psf->u.ucbuf, 1, bufferlen, psf) ;
529
 
                total += writecount ;
530
 
                if (writecount < bufferlen)
531
 
                        break ;
532
 
                len -= writecount ;
533
 
                } ;
534
 
 
535
 
        return total ;
536
 
} /* alaw_write_d2alaw */
537
 
 
538
 
/*
539
 
** Do not edit or modify anything in this comment block.
540
 
** The arch-tag line is a file identity tag for the GNU Arch 
541
 
** revision control system.
542
 
**
543
 
** arch-tag: 289ccfc2-42a6-4f1f-a29f-4dcc9bfa8752
544
 
*/