399d2e4ace5fcff98b4425459aa1dc020b3a8318
2 ** Copyright (C) 2007-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
3 ** Copyright (c) 2007 <robs@users.sourceforge.net>
5 ** This library is free software; you can redistribute it and/or modify it
6 ** under the terms of the GNU Lesser General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or (at
8 ** your option) any later version.
10 ** This library is distributed in the hope that it will be useful, but
11 ** WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
13 ** General Public License for more details.
15 ** You should have received a copy of the GNU Lesser General Public License
16 ** along with this library. If not, write to the Free Software Foundation,
17 ** Fifth Floor, 51 Franklin Street, Boston, MA 02111-1301, USA.
20 /* ADPCM: IMA, OKI <==> 16-bit PCM. */
26 /* Set up for libsndfile environment: */
29 #include "ima_oki_adpcm.h"
31 #define MIN_SAMPLE -0x8000
32 #define MAX_SAMPLE 0x7fff
34 static int const ima_steps
[] = /* ~16-bit precision */
35 { 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
36 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230,
37 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963,
38 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
39 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442,
40 11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794,
44 static int const oki_steps
[] = /* ~12-bit precision */
45 { 256, 272, 304, 336, 368, 400, 448, 496, 544, 592, 656, 720, 800, 880, 960,
46 1056, 1168, 1280, 1408, 1552, 1712, 1888, 2080, 2288, 2512, 2768, 3040, 3344,
47 3680, 4048, 4464, 4912, 5392, 5936, 6528, 7184, 7904, 8704, 9568, 10528,
48 11584, 12736, 14016, 15408, 16960, 18656, 20512, 22576, 24832
51 static int const step_changes
[] = { -1, -1, -1, -1, 2, 4, 6, 8 } ;
54 ima_oki_adpcm_init (IMA_OKI_ADPCM
* state
, IMA_OKI_ADPCM_TYPE type
)
56 memset (state
, 0, sizeof (*state
)) ;
58 if (type
== IMA_OKI_ADPCM_TYPE_IMA
)
59 { state
->max_step_index
= ARRAY_LEN (ima_steps
) - 1 ;
60 state
->steps
= ima_steps
;
64 { state
->max_step_index
= ARRAY_LEN (oki_steps
) - 1 ;
65 state
->steps
= oki_steps
;
66 state
->mask
= (~0) << 4 ;
69 } /* ima_oki_adpcm_init */
73 adpcm_decode (IMA_OKI_ADPCM
* state
, int code
)
76 s
= ((code
& 7) << 1) | 1 ;
77 s
= ((state
->steps
[state
->step_index
] * s
) >> 3) & state
->mask
;
81 s
+= state
->last_output
;
83 if (s
< MIN_SAMPLE
|| s
> MAX_SAMPLE
)
86 grace
= (state
->steps
[state
->step_index
] >> 3) & state
->mask
;
88 if (s
< MIN_SAMPLE
- grace
|| s
> MAX_SAMPLE
+ grace
)
91 s
= s
< MIN_SAMPLE
? MIN_SAMPLE
: MAX_SAMPLE
;
94 state
->step_index
+= step_changes
[code
& 7] ;
95 state
->step_index
= SF_MIN (SF_MAX (state
->step_index
, 0), state
->max_step_index
) ;
96 state
->last_output
= s
;
102 adpcm_encode (IMA_OKI_ADPCM
* state
, int sample
)
103 { int delta
, sign
= 0, code
;
105 delta
= sample
- state
->last_output
;
112 code
= 4 * delta
/ state
->steps
[state
->step_index
] ;
113 code
= sign
| SF_MIN (code
, 7) ;
114 adpcm_decode (state
, code
) ; /* Update encoder state */
121 ima_oki_adpcm_decode_block (IMA_OKI_ADPCM
* state
)
122 { unsigned char code
;
125 for (k
= 0 ; k
< state
->code_count
; k
++)
126 { code
= state
->codes
[k
] ;
127 state
->pcm
[2 * k
] = adpcm_decode (state
, code
>> 4) ;
128 state
->pcm
[2 * k
+ 1] = adpcm_decode (state
, code
) ;
131 state
->pcm_count
= 2 * k
;
132 } /* ima_oki_adpcm_decode_block */
136 ima_oki_adpcm_encode_block (IMA_OKI_ADPCM
* state
)
137 { unsigned char code
;
141 ** The codec expects an even number of input samples.
143 ** Samples should always be passed in even length blocks. If the last block to
144 ** be encoded is odd length, extend that block by one zero valued sample.
146 if (state
->pcm_count
% 2 == 1)
147 state
->pcm
[state
->pcm_count
++] = 0 ;
149 for (k
= 0 ; k
< state
->pcm_count
/ 2 ; k
++)
150 { code
= adpcm_encode (state
, state
->pcm
[2 * k
]) << 4 ;
151 code
|= adpcm_encode (state
, state
->pcm
[2 * k
+ 1]) ;
152 state
->codes
[k
] = code
;
155 state
->code_count
= k
;
156 } /* ima_oki_adpcm_encode_block */
161 static const unsigned char test_codes
[] =
162 { 0x08, 0x08, 0x04, 0x7f, 0x72, 0xf7, 0x9f, 0x7c, 0xd7, 0xbc, 0x7a, 0xa7, 0xb8,
163 0x4b, 0x0b, 0x38, 0xf6, 0x9d, 0x7a, 0xd7, 0xbc, 0x7a, 0xd7, 0xa8, 0x6c, 0x81,
164 0x98, 0xe4, 0x0e, 0x7a, 0xd7, 0x9e, 0x7b, 0xc7, 0xab, 0x7a, 0x85, 0xc0, 0xb3,
165 0x8f, 0x58, 0xd7, 0xad, 0x7a, 0xd7, 0xad, 0x7a, 0x87, 0xd0, 0x2b, 0x0e, 0x48,
166 0xd7, 0xad, 0x78, 0xf7, 0xbc, 0x7a, 0xb7, 0xa8, 0x4b, 0x88, 0x18, 0xd5, 0x8d,
167 0x6a, 0xa4, 0x98, 0x08, 0x00, 0x80, 0x88,
170 static const short test_pcm
[] =
171 { 32, 0, 32, 0, 32, 320, 880, -336, 2304, 4192, -992, 10128, 5360, -16352,
172 30208, 2272, -31872, 14688, -7040, -32432, 14128, -1392, -15488, 22960,
173 1232, -1584, 21488, -240, 2576, -15360, 960, -1152, -30032, 10320, 1008,
174 -30032, 16528, 1008, -30032, 16528, -5200, -30592, 15968, 448, -30592,
175 15968, 448, -2368, 30960, 3024, -80, 8384, 704, -1616, -29168, -1232, 1872,
176 -32768, 13792, -1728, -32768, 13792, 4480, -32192, 14368, -7360, -32752,
177 13808, -1712, -21456, 16992, 1472, -1344, 26848, -1088, 2016, -17728, 208,
178 -2112, -32768, 1376, -1728, -32768, 13792, -1728, -32768, 13792, -1728,
179 -32768, 13792, -1728, -32768, 13792, -1728, -4544, 32767, -1377, 1727,
180 15823, -2113, 207, -27345, 591, -2513, -32768, 13792, -1728, -32768, 13792,
181 10688, -31632, 14928, -6800, -32192, 14368, -1152, -20896, 17552, 2032,
182 -784, 22288, 560, -2256, -4816, 2176, 64, -21120, 9920, 6816, -24224, 16128,
183 608, -13488, 9584, 272, -2544, 16, -2304, -192, 1728, -16, 1568, 128, -1184,
188 test_oki_adpcm (void)
190 IMA_OKI_ADPCM adpcm
;
194 printf (" Testing encoder : ") ;
197 ima_oki_adpcm_init (&adpcm
, IMA_OKI_ADPCM_TYPE_OKI
) ;
198 for (i
= 0 ; i
< ARRAY_LEN (test_codes
) ; i
++)
199 for (j
= 0, code
= test_codes
[i
] ; j
< 2 ; j
++, code
<<= 4)
200 if (adpcm_decode (&adpcm
, code
>> 4) != test_pcm
[2 * i
+ j
])
201 { printf ("\n\nFail at i = %d, j = %d.\n\n", i
, j
) ;
207 printf (" Testing decoder : ") ;
210 ima_oki_adpcm_init (&adpcm
, IMA_OKI_ADPCM_TYPE_OKI
) ;
211 for (i
= 0 ; i
< ARRAY_LEN (test_pcm
) ; i
+= j
)
212 { code
= adpcm_encode (&adpcm
, test_pcm
[i
]) ;
213 code
= (code
<< 4) | adpcm_encode (&adpcm
, test_pcm
[i
+ 1]) ;
214 if (code
!= test_codes
[i
/ 2])
215 { printf ("\n\nFail at i = %d, %d should be %d\n\n", i
, code
, test_codes
[i
/ 2]) ;
221 } /* test_oki_adpcm */
224 test_oki_adpcm_block (void)
226 IMA_OKI_ADPCM adpcm
;
229 if (ARRAY_LEN (adpcm
.pcm
) < ARRAY_LEN (test_pcm
))
230 { printf ("\n\nLine %d : ARRAY_LEN (adpcm->pcm) > ARRAY_LEN (test_pcm) (%d > %d).\n\n", __LINE__
, ARRAY_LEN (adpcm
.pcm
), ARRAY_LEN (test_pcm
)) ;
234 if (ARRAY_LEN (adpcm
.codes
) < ARRAY_LEN (test_codes
))
235 { printf ("\n\nLine %d : ARRAY_LEN (adcodes->codes) > ARRAY_LEN (test_codes).n", __LINE__
) ;
239 printf (" Testing block encoder : ") ;
242 ima_oki_adpcm_init (&adpcm
, IMA_OKI_ADPCM_TYPE_OKI
) ;
244 memcpy (adpcm
.pcm
, test_pcm
, sizeof (adpcm
.pcm
[0]) * ARRAY_LEN (test_pcm
)) ;
245 adpcm
.pcm_count
= ARRAY_LEN (test_pcm
) ;
246 adpcm
.code_count
= 13 ;
248 ima_oki_adpcm_encode_block (&adpcm
) ;
250 if (adpcm
.code_count
* 2 != ARRAY_LEN (test_pcm
))
251 { printf ("\n\nLine %d : %d * 2 != %d\n\n", __LINE__
, adpcm
.code_count
* 2, ARRAY_LEN (test_pcm
)) ;
255 for (k
= 0 ; k
< ARRAY_LEN (test_codes
) ; k
++)
256 if (adpcm
.codes
[k
] != test_codes
[k
])
257 { printf ("\n\nLine %d : Fail at k = %d, %d should be %d\n\n", __LINE__
, k
, adpcm
.codes
[k
], test_codes
[k
]) ;
263 printf (" Testing block decoder : ") ;
266 ima_oki_adpcm_init (&adpcm
, IMA_OKI_ADPCM_TYPE_OKI
) ;
268 memcpy (adpcm
.codes
, test_codes
, sizeof (adpcm
.codes
[0]) * ARRAY_LEN (test_codes
)) ;
269 adpcm
.code_count
= ARRAY_LEN (test_codes
) ;
270 adpcm
.pcm_count
= 13 ;
272 ima_oki_adpcm_decode_block (&adpcm
) ;
274 if (adpcm
.pcm_count
!= 2 * ARRAY_LEN (test_codes
))
275 { printf ("\n\nLine %d : %d * 2 != %d\n\n", __LINE__
, adpcm
.pcm_count
, 2 * ARRAY_LEN (test_codes
)) ;
279 for (k
= 0 ; k
< ARRAY_LEN (test_pcm
) ; k
++)
280 if (adpcm
.pcm
[k
] != test_pcm
[k
])
281 { printf ("\n\nLine %d : Fail at i = %d, %d should be %d.\n\n", __LINE__
, k
, adpcm
.pcm
[k
], test_pcm
[k
]) ;
286 } /* test_oki_adpcm_block */
292 test_oki_adpcm_block () ;