3756
|
1 /*
|
|
2 Unified ADPCM Decoder for MPlayer
|
|
3
|
3787
|
4 This file is in charge of decoding all of the various ADPCM data
|
|
5 formats that various entities have created. Details about the data
|
|
6 formats can be found here:
|
|
7 http://www.pcisys.net/~melanson/codecs/
|
|
8
|
3756
|
9 (C) 2001 Mike Melanson
|
|
10 */
|
|
11
|
|
12 #include "config.h"
|
|
13 #include "bswap.h"
|
|
14 #include "adpcm.h"
|
|
15
|
|
16 #define BE_16(x) (be2me_16(*(unsigned short *)(x)))
|
|
17 #define BE_32(x) (be2me_32(*(unsigned int *)(x)))
|
|
18 #define LE_16(x) (le2me_16(*(unsigned short *)(x)))
|
|
19 #define LE_32(x) (le2me_32(*(unsigned int *)(x)))
|
|
20
|
3787
|
21 // pertinent tables
|
|
22 static int adpcm_step[89] =
|
|
23 {
|
|
24 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
|
|
25 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
|
|
26 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
|
|
27 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
|
|
28 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
|
|
29 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
|
|
30 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
|
|
31 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
|
|
32 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
|
|
33 };
|
|
34
|
|
35 static int adpcm_index[16] =
|
|
36 {
|
|
37 -1, -1, -1, -1, 2, 4, 6, 8,
|
|
38 -1, -1, -1, -1, 2, 4, 6, 8
|
|
39 };
|
|
40
|
|
41 static int format_0x62_table[16] =
|
|
42 {
|
|
43 1, 3, 5, 7, 9, 11, 13, 15,
|
|
44 -1, -3, -5, -7, -9, -11, -13, -15
|
|
45 };
|
|
46
|
|
47 static int ms_adapt_table[] =
|
|
48 {
|
|
49 230, 230, 230, 230, 307, 409, 512, 614,
|
|
50 768, 614, 512, 409, 307, 230, 230, 230
|
|
51 };
|
|
52
|
|
53 static int ms_adapt_coeff1[] =
|
|
54 {
|
|
55 256, 512, 0, 192, 240, 460, 392
|
|
56 };
|
|
57
|
|
58 static int ms_adapt_coeff2[] =
|
|
59 {
|
|
60 0, -256, 0, 64, 0, -208, -232
|
|
61 };
|
|
62
|
|
63 // useful macros
|
3756
|
64 // clamp a number between 0 and 88
|
|
65 #define CLAMP_0_TO_88(x) if (x < 0) x = 0; else if (x > 88) x = 88;
|
|
66 // clamp a number within a signed 16-bit range
|
|
67 #define CLAMP_S16(x) if (x < -32768) x = -32768; \
|
|
68 else if (x > 32767) x = 32767;
|
3787
|
69 // clamp a number above 16
|
|
70 #define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
|
3756
|
71 // sign extend a 16-bit value
|
|
72 #define SE_16BIT(x) if (x & 0x8000) x -= 0x10000;
|
3787
|
73 // sign extend a 4-bit value
|
|
74 #define SE_4BIT(x) if (x & 0x8) x -= 0x10;
|
3756
|
75
|
|
76 void ima_dvi_decode_nibbles(unsigned short *output, int channels,
|
|
77 int predictor_l, int index_l,
|
|
78 int predictor_r, int index_r)
|
|
79 {
|
|
80 int step[2];
|
|
81 int predictor[2];
|
|
82 int index[2];
|
|
83 int diff;
|
|
84 int i;
|
|
85 int sign;
|
|
86 int delta;
|
|
87 int channel_number = 0;
|
|
88
|
|
89 step[0] = adpcm_step[index_l];
|
|
90 step[1] = adpcm_step[index_r];
|
|
91 predictor[0] = predictor_l;
|
|
92 predictor[1] = predictor_r;
|
|
93 index[0] = index_l;
|
|
94 index[1] = index_r;
|
|
95
|
|
96 for (i = 0; i < IMA_ADPCM_SAMPLES_PER_BLOCK * channels; i++)
|
|
97 {
|
|
98 delta = output[i];
|
|
99
|
|
100 index[channel_number] += adpcm_index[delta];
|
|
101 CLAMP_0_TO_88(index[channel_number]);
|
|
102
|
|
103 sign = delta & 8;
|
|
104 delta = delta & 7;
|
|
105
|
|
106 diff = step[channel_number] >> 3;
|
|
107 if (delta & 4) diff += step[channel_number];
|
|
108 if (delta & 2) diff += step[channel_number] >> 1;
|
|
109 if (delta & 1) diff += step[channel_number] >> 2;
|
|
110
|
|
111 if (sign)
|
|
112 predictor[channel_number] -= diff;
|
|
113 else
|
|
114 predictor[channel_number] += diff;
|
|
115
|
|
116 CLAMP_S16(predictor[channel_number]);
|
|
117 output[i] = predictor[channel_number];
|
|
118 step[channel_number] = adpcm_step[index[channel_number]];
|
|
119
|
|
120 // toggle channel
|
|
121 channel_number ^= channels - 1;
|
|
122 }
|
|
123 }
|
|
124
|
|
125 int ima_adpcm_decode_block(unsigned short *output, unsigned char *input,
|
|
126 int channels)
|
|
127 {
|
|
128 int initial_predictor_l = 0;
|
|
129 int initial_predictor_r = 0;
|
|
130 int initial_index_l = 0;
|
|
131 int initial_index_r = 0;
|
|
132 int i;
|
|
133
|
3763
|
134 initial_predictor_l = BE_16(&input[0]);
|
3756
|
135 initial_index_l = initial_predictor_l;
|
|
136
|
|
137 // mask, sign-extend, and clamp the predictor portion
|
|
138 initial_predictor_l &= 0xFF80;
|
|
139 SE_16BIT(initial_predictor_l);
|
|
140 CLAMP_S16(initial_predictor_l);
|
|
141
|
|
142 // mask and clamp the index portion
|
|
143 initial_index_l &= 0x7F;
|
|
144 CLAMP_0_TO_88(initial_index_l);
|
|
145
|
|
146 // handle stereo
|
|
147 if (channels > 1)
|
|
148 {
|
3763
|
149 initial_predictor_r = BE_16(&input[IMA_ADPCM_BLOCK_SIZE]);
|
3756
|
150 initial_index_r = initial_predictor_r;
|
|
151
|
|
152 // mask, sign-extend, and clamp the predictor portion
|
|
153 initial_predictor_r &= 0xFF80;
|
|
154 SE_16BIT(initial_predictor_r);
|
|
155 CLAMP_S16(initial_predictor_r);
|
|
156
|
|
157 // mask and clamp the index portion
|
|
158 initial_index_r &= 0x7F;
|
|
159 CLAMP_0_TO_88(initial_index_r);
|
|
160 }
|
|
161
|
|
162 // break apart all of the nibbles in the block
|
|
163 if (channels == 1)
|
|
164 for (i = 0; i < IMA_ADPCM_SAMPLES_PER_BLOCK / 2; i++)
|
|
165 {
|
3763
|
166 output[i * 2 + 0] = input[2 + i] & 0x0F;
|
|
167 output[i * 2 + 1] = input[2 + i] >> 4;
|
3756
|
168 }
|
|
169 else
|
|
170 for (i = 0; i < IMA_ADPCM_SAMPLES_PER_BLOCK / 2 * 2; i++)
|
|
171 {
|
3763
|
172 output[i * 4 + 0] = input[2 + i] & 0x0F;
|
|
173 output[i * 4 + 1] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] & 0x0F;
|
|
174 output[i * 4 + 2] = input[2 + i] >> 4;
|
|
175 output[i * 4 + 3] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] >> 4;
|
3756
|
176 }
|
|
177
|
|
178 ima_dvi_decode_nibbles(output, channels,
|
|
179 initial_predictor_l, initial_index_l,
|
|
180 initial_predictor_r, initial_index_r);
|
|
181
|
|
182 return IMA_ADPCM_SAMPLES_PER_BLOCK * channels;
|
|
183 }
|
3787
|
184
|
|
185 int ms_adpcm_decode_block(unsigned short *output, unsigned char *input,
|
|
186 int channels)
|
|
187 {
|
|
188 int current_channel = 0;
|
|
189 int idelta[2];
|
|
190 int sample1[2];
|
|
191 int sample2[2];
|
|
192 int coeff1[2];
|
|
193 int coeff2[2];
|
|
194 int stream_ptr = 0;
|
|
195 int out_ptr = 0;
|
|
196 int upper_nibble = 1;
|
|
197 int nibble;
|
|
198 int snibble; // signed nibble
|
|
199 int predictor;
|
|
200
|
|
201 // fetch the header information, in stereo if both channels are present
|
|
202 coeff1[0] = ms_adapt_coeff1[input[stream_ptr]];
|
|
203 coeff2[0] = ms_adapt_coeff2[input[stream_ptr]];
|
|
204 stream_ptr++;
|
|
205 if (channels == 2)
|
|
206 {
|
|
207 coeff1[1] = ms_adapt_coeff1[input[stream_ptr]];
|
|
208 coeff2[1] = ms_adapt_coeff2[input[stream_ptr]];
|
|
209 stream_ptr++;
|
|
210 }
|
|
211
|
|
212 idelta[0] = LE_16(&input[stream_ptr]);
|
|
213 stream_ptr += 2;
|
|
214 SE_16BIT(idelta[0]);
|
|
215 if (channels == 2)
|
|
216 {
|
|
217 idelta[1] = LE_16(&input[stream_ptr]);
|
|
218 stream_ptr += 2;
|
|
219 SE_16BIT(idelta[1]);
|
|
220 }
|
|
221
|
|
222 sample1[0] = LE_16(&input[stream_ptr]);
|
|
223 stream_ptr += 2;
|
|
224 SE_16BIT(sample1[0]);
|
|
225 if (channels == 2)
|
|
226 {
|
|
227 sample1[1] = LE_16(&input[stream_ptr]);
|
|
228 stream_ptr += 2;
|
|
229 SE_16BIT(sample1[1]);
|
|
230 }
|
|
231
|
|
232 sample2[0] = LE_16(&input[stream_ptr]);
|
|
233 stream_ptr += 2;
|
|
234 SE_16BIT(sample2[0]);
|
|
235 if (channels == 2)
|
|
236 {
|
|
237 sample2[1] = LE_16(&input[stream_ptr]);
|
|
238 stream_ptr += 2;
|
|
239 SE_16BIT(sample2[1]);
|
|
240 }
|
|
241
|
|
242 while (stream_ptr < MS_ADPCM_BLOCK_SIZE * channels)
|
|
243 {
|
|
244 // get the next nibble
|
|
245 if (upper_nibble)
|
|
246 nibble = snibble = input[stream_ptr] >> 4;
|
|
247 else
|
|
248 nibble = snibble = input[stream_ptr++] & 0x0F;
|
|
249 upper_nibble ^= 1;
|
|
250 SE_4BIT(snibble);
|
|
251
|
|
252 predictor = (
|
|
253 ((sample1[current_channel] * coeff1[current_channel]) +
|
|
254 (sample2[current_channel] * coeff2[current_channel])) / 256) +
|
|
255 (snibble * idelta[current_channel]);
|
|
256 CLAMP_S16(predictor);
|
|
257 sample2[current_channel] = sample1[current_channel];
|
|
258 sample1[current_channel] = predictor;
|
|
259 output[out_ptr++] = predictor;
|
|
260
|
|
261 // compute the next adaptive scale factor (a.k.a. the variable idelta)
|
|
262 idelta[current_channel] =
|
|
263 (ms_adapt_table[nibble] * idelta[current_channel]) / 256;
|
|
264 CLAMP_ABOVE_16(idelta[current_channel]);
|
|
265
|
|
266 // toggle the channel
|
|
267 current_channel ^= channels - 1;
|
|
268 }
|
|
269
|
|
270 return MS_ADPCM_SAMPLES_PER_BLOCK * channels;
|
|
271 }
|