/project/jni/sndfile/src/alaw.c

https://github.com/aichunyu/FFPlayer · C · 540 lines · 453 code · 63 blank · 24 comment · 47 complexity · 8bf929ae234900b2ee75998ed23bf499 MD5 · raw file

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