Mercurial > mplayer.hg
comparison adpcm.c @ 3939:6b31db273596
fixed FOX61 ADPCM; still working on FOX62
author | melanson |
---|---|
date | Wed, 02 Jan 2002 00:45:41 +0000 |
parents | 60db4273246d |
children | ae6f97724b84 |
comparison
equal
deleted
inserted
replaced
3938:745c37031e1e | 3939:6b31db273596 |
---|---|
30 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, | 30 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, |
31 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, | 31 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, |
32 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 | 32 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 |
33 }; | 33 }; |
34 | 34 |
35 //static int fox62_step[89] = | |
36 static int fox62_step[] = | |
37 { | |
38 0x7, 0x8, 0x9, 0xa, | |
39 0xb, 0xc, 0xd, 0xf, | |
40 0x10, 0x12, 0x13, 0x15, | |
41 0x17, 0x1a, 0x1c, 0x1f, | |
42 0x22, 0x26, 0x29, 0x2e, | |
43 0x32, 0x37, 0x3d, 0x43, | |
44 0x4a, 0x51, 0x59, 0x62, | |
45 0x6c, 0x76, 0x82, 0x8f, | |
46 0x9e, 0xad, 0xbf, 0xd2, | |
47 0xe7, 0xfe, 0x117, 0x133, | |
48 0x152, 0x174, 0x199, 0x1c2, | |
49 0x1ef, 0x220, 0x256, 0x292, | |
50 0x2d4, 0x31d, 0x36c, 0x3c4, | |
51 0x424, 0x48e, 0x503, 0x583, | |
52 0x610, 0x6ac, 0x756, 0x812, | |
53 0x8e1, 0x9c4, 0xabe, 0x8d1, | |
54 0xcff, 0xe4c, 0xfba, 0x114d, | |
55 0x1308, 0x14ef, 0x1707, 0x1954, | |
56 0x1bdd, 0x1ea6, 0x21b7, 0x2516, | |
57 0x28cb, 0x2cdf, 0x315c, 0x364c, | |
58 0x3bba, 0x41b2, 0x4844, 0x4f7e, | |
59 0x5771, 0x6030, 0x69ce, 0x7463, | |
60 0x7FFF | |
61 }; | |
62 | |
63 static int adpcm_index[16] = | 35 static int adpcm_index[16] = |
64 { | 36 { |
65 -1, -1, -1, -1, 2, 4, 6, 8, | 37 -1, -1, -1, -1, 2, 4, 6, 8, |
66 -1, -1, -1, -1, 2, 4, 6, 8 | 38 -1, -1, -1, -1, 2, 4, 6, 8 |
67 }; | |
68 | |
69 static int fox62_extra_table[16] = | |
70 { | |
71 1, 3, 5, 7, 9, 11, 13, 15, | |
72 -1, -3, -5, -7, -9, -11, -13, -15 | |
73 }; | 39 }; |
74 | 40 |
75 static int ms_adapt_table[] = | 41 static int ms_adapt_table[] = |
76 { | 42 { |
77 230, 230, 230, 230, 307, 409, 512, 614, | 43 230, 230, 230, 230, 307, 409, 512, 614, |
99 // sign extend a 16-bit value | 65 // sign extend a 16-bit value |
100 #define SE_16BIT(x) if (x & 0x8000) x -= 0x10000; | 66 #define SE_16BIT(x) if (x & 0x8000) x -= 0x10000; |
101 // sign extend a 4-bit value | 67 // sign extend a 4-bit value |
102 #define SE_4BIT(x) if (x & 0x8) x -= 0x10; | 68 #define SE_4BIT(x) if (x & 0x8) x -= 0x10; |
103 | 69 |
104 void ima_dvi_decode_nibbles(unsigned short *output, int channels, | 70 void decode_nibbles(unsigned short *output, |
71 int output_size, int channels, | |
105 int predictor_l, int index_l, | 72 int predictor_l, int index_l, |
106 int predictor_r, int index_r) | 73 int predictor_r, int index_r) |
107 { | 74 { |
108 int step[2]; | 75 int step[2]; |
109 int predictor[2]; | 76 int predictor[2]; |
119 predictor[0] = predictor_l; | 86 predictor[0] = predictor_l; |
120 predictor[1] = predictor_r; | 87 predictor[1] = predictor_r; |
121 index[0] = index_l; | 88 index[0] = index_l; |
122 index[1] = index_r; | 89 index[1] = index_r; |
123 | 90 |
124 for (i = 0; i < IMA_ADPCM_SAMPLES_PER_BLOCK * channels; i++) | 91 for (i = 0; i < output_size; i++) |
125 { | 92 { |
126 delta = output[i]; | 93 delta = output[i]; |
127 | 94 |
128 index[channel_number] += adpcm_index[delta]; | 95 index[channel_number] += adpcm_index[delta]; |
129 CLAMP_0_TO_88(index[channel_number]); | 96 CLAMP_0_TO_88(index[channel_number]); |
145 output[i] = predictor[channel_number]; | 112 output[i] = predictor[channel_number]; |
146 step[channel_number] = adpcm_step[index[channel_number]]; | 113 step[channel_number] = adpcm_step[index[channel_number]]; |
147 | 114 |
148 // toggle channel | 115 // toggle channel |
149 channel_number ^= channels - 1; | 116 channel_number ^= channels - 1; |
117 | |
150 } | 118 } |
151 } | 119 } |
152 | 120 |
153 int ima_adpcm_decode_block(unsigned short *output, unsigned char *input, | 121 int ima_adpcm_decode_block(unsigned short *output, unsigned char *input, |
154 int channels) | 122 int channels) |
201 output[i * 4 + 1] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] & 0x0F; | 169 output[i * 4 + 1] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] & 0x0F; |
202 output[i * 4 + 2] = input[2 + i] >> 4; | 170 output[i * 4 + 2] = input[2 + i] >> 4; |
203 output[i * 4 + 3] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] >> 4; | 171 output[i * 4 + 3] = input[2 + IMA_ADPCM_BLOCK_SIZE + i] >> 4; |
204 } | 172 } |
205 | 173 |
206 ima_dvi_decode_nibbles(output, channels, | 174 decode_nibbles(output, |
175 IMA_ADPCM_SAMPLES_PER_BLOCK * channels, channels, | |
207 initial_predictor_l, initial_index_l, | 176 initial_predictor_l, initial_index_l, |
208 initial_predictor_r, initial_index_r); | 177 initial_predictor_r, initial_index_r); |
209 | 178 |
210 return IMA_ADPCM_SAMPLES_PER_BLOCK * channels; | 179 return IMA_ADPCM_SAMPLES_PER_BLOCK * channels; |
211 } | 180 } |
301 // note: This decoder assumes the format 0x61 data always comes in | 270 // note: This decoder assumes the format 0x61 data always comes in |
302 // mono flavor | 271 // mono flavor |
303 int fox61_adpcm_decode_block(unsigned short *output, unsigned char *input) | 272 int fox61_adpcm_decode_block(unsigned short *output, unsigned char *input) |
304 { | 273 { |
305 int i; | 274 int i; |
306 int out_ptr = 0; | |
307 | |
308 int predictor; | 275 int predictor; |
309 int index; | 276 int index; |
310 int nibble; | 277 |
311 int sign; | 278 // the first predictor value goes straight to the output |
312 int delta; | 279 predictor = output[0] = LE_16(&input[0]); |
313 int diff; | 280 SE_16BIT(predictor); |
314 int step; | |
315 | |
316 predictor = output[out_ptr++] = LE_16(&input[0]); | |
317 index = input[2]; | 281 index = input[2]; |
318 | 282 |
319 // iterate through and decode the rest of the bytes | 283 // unpack the nibbles |
320 for (i = 4; i < FOX61_ADPCM_BLOCK_SIZE; i++) | 284 for (i = 4; i < FOX61_ADPCM_BLOCK_SIZE; i++) |
321 { | 285 { |
322 nibble = (input[i] >> 4) & 0x0F; | 286 output[1 + (i - 4) * 2 + 0] = (input[i] >> 4) & 0x0F; |
323 | 287 output[1 + (i - 4) * 2 + 1] = input[i] & 0x0F; |
324 step = adpcm_step[index]; | 288 } |
325 sign = nibble & 8; | 289 |
326 delta = nibble & 7; | 290 decode_nibbles(&output[1], FOX61_ADPCM_SAMPLES_PER_BLOCK - 1, 1, |
327 diff = step >> 3; | 291 predictor, index, |
328 if (delta & 4) diff += step; | 292 0, 0); |
329 if (delta & 2) diff += step >> 1; | |
330 if (delta & 1) diff += step >> 2; | |
331 if (sign) | |
332 predictor -= diff; | |
333 else | |
334 predictor += diff; | |
335 CLAMP_S16(predictor); | |
336 output[out_ptr++] = predictor; | |
337 index += adpcm_index[nibble]; | |
338 CLAMP_0_TO_88(index); | |
339 | |
340 nibble = input[i] & 0x0F; | |
341 | |
342 step = adpcm_step[index]; | |
343 sign = nibble & 8; | |
344 delta = nibble & 7; | |
345 diff = step >> 3; | |
346 if (delta & 4) diff += step; | |
347 if (delta & 2) diff += step >> 1; | |
348 if (delta & 1) diff += step >> 2; | |
349 if (sign) | |
350 predictor -= diff; | |
351 else | |
352 predictor += diff; | |
353 CLAMP_S16(predictor); | |
354 output[out_ptr++] = predictor; | |
355 index += adpcm_index[nibble]; | |
356 CLAMP_0_TO_88(index); | |
357 } | |
358 | 293 |
359 return FOX61_ADPCM_SAMPLES_PER_BLOCK; | 294 return FOX61_ADPCM_SAMPLES_PER_BLOCK; |
360 } | 295 } |
361 | |
362 | 296 |
363 // note: This decoder assumes the format 0x62 data always comes in | 297 // note: This decoder assumes the format 0x62 data always comes in |
364 // stereo flavor | 298 // stereo flavor |
365 int fox62_adpcm_decode_block(unsigned short *output, unsigned char *input, | 299 int fox62_adpcm_decode_block(unsigned short *output, unsigned char *input, |
366 int channels) | 300 int channels) |
367 { | 301 { |
368 int predictor_l; | 302 int predictor_l; |
369 int predictor_r; | 303 int predictor_r; |
370 int index_l; | 304 int index_l; |
371 int index_r; | 305 int index_r; |
372 int code_l; | |
373 int code_r; | |
374 int i; | 306 int i; |
375 int out_ptr = 0; | 307 int adjustment; |
376 | 308 |
377 int temp1, temp2, edi, eax, edx; | |
378 static int counter = 0; | 309 static int counter = 0; |
379 | 310 |
380 predictor_l = LE_16(&input[10]); | 311 predictor_l = LE_16(&input[10]); |
381 edi = predictor_r = LE_16(&input[12]); | 312 predictor_r = LE_16(&input[12]); |
382 SE_16BIT(predictor_l); | 313 SE_16BIT(predictor_l); |
383 SE_16BIT(predictor_r); | 314 SE_16BIT(predictor_r); |
384 index_l = input[14]; | 315 index_l = input[14]; |
385 index_r = input[15]; | 316 index_r = input[15]; |
386 | 317 |
387 for (i = 16; i < FOX62_ADPCM_BLOCK_SIZE; i++) | 318 for (i = 16; i < FOX62_ADPCM_BLOCK_SIZE; i++) |
388 { | 319 { |
389 code_l = input[i] & 0x0F; | 320 output[(i - 16) * 2 + 0] = input[i] & 0x0F; |
390 code_r = input[i] >> 4; | 321 output[(i - 16) * 2 + 1] = (input[i] >> 4) & 0x0F; |
391 if (counter == 0) | 322 } |
392 printf ("code_l = %02X, predictor_l = %04X, index_l = %02X\n", | 323 |
393 code_l, predictor_l, index_l); | 324 decode_nibbles(output, FOX62_ADPCM_SAMPLES_PER_BLOCK * channels, channels, |
394 if (counter == 0) | 325 predictor_l, index_l, |
395 printf ("code_r = %02X, predictor_r = %04X, index_r = %02X\n", | 326 predictor_r, index_r); |
396 code_r, predictor_r, index_r); | 327 |
397 | 328 |
398 // left side | 329 for (i = 0; i < FOX62_ADPCM_SAMPLES_PER_BLOCK / 2; i += 2) |
399 if (counter == 0) | 330 { |
400 printf ("step = %04X, extra = %02X\n", fox62_step[index_l], fox62_extra_table[code_l]); | 331 adjustment = (predictor_r + output[i + 1]) / 2; |
401 temp1 = fox62_step[index_l] * fox62_extra_table[code_l]; | 332 if (counter < 20) |
402 if (counter == 0) | 333 { |
403 printf ("temp1 (before) = %04X\n", temp1); | 334 printf ("(L, R) = %04X, %04X, prev_r = %04X, adjustment = %04X\n", |
404 if (temp1 < 0) | 335 output[i], output[i+1], predictor_r, adjustment); |
405 temp1 += 7; | 336 counter++; |
406 if (counter == 0) | 337 } |
407 printf ("temp1 (after) = %04X\n", temp1); | 338 predictor_r = output[i + 1]; |
408 | 339 output[i + 1] = output[i] - adjustment; |
409 temp2 = predictor_l; | 340 output[i] += adjustment; |
410 temp1 /= 8; | 341 } |
411 if (counter == 0) | 342 |
412 printf ("temp1 (after div) = %04X\n", temp1); | 343 if (counter++ == 20) |
413 temp2 += temp1; | 344 { |
414 if (counter == 0) | 345 printf (" after:\n"); |
415 printf ("temp2 (predictor_l before clamp) = %04X\n", temp2); | 346 for (i = 0; i < 20; i++) |
416 CLAMP_S16(temp2); | 347 printf ("%04X\n", output[i]); |
417 if (counter == 0) | 348 } |
418 printf ("temp2 (predictor_l after clamp) = %04X\n", temp2); | |
419 predictor_l = temp2; | |
420 | |
421 index_l += adpcm_index[code_l]; | |
422 if (counter == 0) | |
423 printf ("adjusted index_l = %02X\n", index_l); | |
424 CLAMP_0_TO_88(index_l); | |
425 | |
426 // right side | |
427 if (counter == 0) | |
428 printf ("step = %04X, extra = %02X\n", fox62_step[index_r], fox62_extra_table[code_r]); | |
429 temp1 = fox62_step[index_r] * fox62_extra_table[code_r]; | |
430 if (counter == 0) | |
431 printf ("temp1 (before) = %04X\n", temp1); | |
432 if (temp1 < 0) | |
433 temp1 += 7; | |
434 if (counter == 0) | |
435 printf ("temp1 (after) = %04X\n", temp1); | |
436 | |
437 temp2 = predictor_r; | |
438 temp1 /= 8; | |
439 if (counter == 0) | |
440 printf ("temp1 (after div) = %04X\n", temp1); | |
441 temp2 += temp1; | |
442 if (counter == 0) | |
443 printf ("temp2 (predictor_r before clamp) = %04X\n", temp2); | |
444 CLAMP_S16(temp2); | |
445 if (counter == 0) | |
446 printf ("temp2 (predictor_r after clamp) = %04X\n", temp2); | |
447 predictor_r = temp2; | |
448 | |
449 index_r += adpcm_index[code_r]; | |
450 if (counter == 0) | |
451 printf ("adjusted index_r = %02X\n", index_r); | |
452 CLAMP_0_TO_88(index_r); | |
453 | |
454 // do the weird final output process | |
455 edi += predictor_r; | |
456 edi /= 2; | |
457 eax = predictor_l + edi; | |
458 edx = edi * 2; | |
459 if (counter == 0) | |
460 printf ("eax = %08X, edx = %08X, edi = %08X\n", eax, edx, edi); | |
461 output[out_ptr++] = eax; | |
462 | |
463 predictor_l = eax; | |
464 eax -= edx; | |
465 if (counter == 0) | |
466 printf ("eax = %08X, edx = %08X, edi = %08X\n", eax, edx, edi); | |
467 // x24 += 4 | |
468 output[out_ptr++] = eax; | |
469 predictor_l = eax; | |
470 eax += edi; | |
471 if (counter == 0) | |
472 printf ("eax = %08X, edx = %08X, edi = %08X\n", eax, edx, edi); | |
473 edi = predictor_r; | |
474 if (counter == 0) | |
475 printf ("eax = %08X, edx = %08X, edi = %08X\n", eax, edx, edi); | |
476 predictor_l = eax; | |
477 | |
478 if (counter == 0) | |
479 printf ("L-sample = %04X, R-sample = %04X\n", | |
480 output[out_ptr-2], output[out_ptr-1]); | |
481 counter++; | |
482 } | |
483 | |
484 return FOX62_ADPCM_SAMPLES_PER_BLOCK * channels; | 349 return FOX62_ADPCM_SAMPLES_PER_BLOCK * channels; |
485 } | 350 } |