interpreter/lib/src/libsndfile-1.0.25/src/alaw.c

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