diff options
Diffstat (limited to 'apps/codecs/libalac/alac.c')
-rw-r--r-- | apps/codecs/libalac/alac.c | 345 |
1 files changed, 203 insertions, 142 deletions
diff --git a/apps/codecs/libalac/alac.c b/apps/codecs/libalac/alac.c index 575bbf5abc..ae1b413eab 100644 --- a/apps/codecs/libalac/alac.c +++ b/apps/codecs/libalac/alac.c | |||
@@ -33,8 +33,9 @@ | |||
33 | #include <stdio.h> | 33 | #include <stdio.h> |
34 | #include <stdlib.h> | 34 | #include <stdlib.h> |
35 | #include <string.h> | 35 | #include <string.h> |
36 | #include <stdint.h> | 36 | #include <inttypes.h> |
37 | 37 | ||
38 | #include "../codec.h" | ||
38 | #include "decomp.h" | 39 | #include "decomp.h" |
39 | 40 | ||
40 | #define _Swap32(v) do { \ | 41 | #define _Swap32(v) do { \ |
@@ -47,53 +48,13 @@ | |||
47 | v = (((v) & 0x00FF) << 0x08) | \ | 48 | v = (((v) & 0x00FF) << 0x08) | \ |
48 | (((v) & 0xFF00) >> 0x08); } while (0) | 49 | (((v) & 0xFF00) >> 0x08); } while (0) |
49 | 50 | ||
50 | 51 | int16_t predictor_coef_table[32] IDATA_ATTR; | |
51 | extern int host_bigendian; | 52 | int16_t predictor_coef_table_a[32] IDATA_ATTR; |
52 | 53 | int16_t predictor_coef_table_b[32] IDATA_ATTR; | |
53 | struct alac_file | 54 | int32_t predicterror_buffer_a[4096]; |
54 | { | 55 | int32_t predicterror_buffer_b[4096]; |
55 | unsigned char *input_buffer; | 56 | int32_t outputsamples_buffer_a[4096] IDATA_ATTR; |
56 | int input_buffer_bitaccumulator; /* used so we can do arbitary | 57 | int32_t outputsamples_buffer_b[4096] IDATA_ATTR; |
57 | bit reads */ | ||
58 | |||
59 | int samplesize; | ||
60 | int numchannels; | ||
61 | int bytespersample; | ||
62 | |||
63 | |||
64 | /* buffers */ | ||
65 | int32_t *predicterror_buffer_a; | ||
66 | int32_t *predicterror_buffer_b; | ||
67 | |||
68 | int32_t *outputsamples_buffer_a; | ||
69 | int32_t *outputsamples_buffer_b; | ||
70 | |||
71 | |||
72 | /* stuff from setinfo */ | ||
73 | uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */ /* max samples per frame? */ | ||
74 | uint8_t setinfo_7a; /* 0x00 */ | ||
75 | uint8_t setinfo_sample_size; /* 0x10 */ | ||
76 | uint8_t setinfo_rice_historymult; /* 0x28 */ | ||
77 | uint8_t setinfo_rice_initialhistory; /* 0x0a */ | ||
78 | uint8_t setinfo_rice_kmodifier; /* 0x0e */ | ||
79 | uint8_t setinfo_7f; /* 0x02 */ | ||
80 | uint16_t setinfo_80; /* 0x00ff */ | ||
81 | uint32_t setinfo_82; /* 0x000020e7 */ | ||
82 | uint32_t setinfo_86; /* 0x00069fe4 */ | ||
83 | uint32_t setinfo_8a_rate; /* 0x0000ac44 */ | ||
84 | /* end setinfo stuff */ | ||
85 | |||
86 | }; | ||
87 | |||
88 | |||
89 | static void allocate_buffers(alac_file *alac) | ||
90 | { | ||
91 | alac->predicterror_buffer_a = malloc(alac->setinfo_max_samples_per_frame * 4); | ||
92 | alac->predicterror_buffer_b = malloc(alac->setinfo_max_samples_per_frame * 4); | ||
93 | |||
94 | alac->outputsamples_buffer_a = malloc(alac->setinfo_max_samples_per_frame * 4); | ||
95 | alac->outputsamples_buffer_b = malloc(alac->setinfo_max_samples_per_frame * 4); | ||
96 | } | ||
97 | 58 | ||
98 | void alac_set_info(alac_file *alac, char *inputbuffer) | 59 | void alac_set_info(alac_file *alac, char *inputbuffer) |
99 | { | 60 | { |
@@ -107,8 +68,9 @@ void alac_set_info(alac_file *alac, char *inputbuffer) | |||
107 | ptr += 4; /* 0 ? */ | 68 | ptr += 4; /* 0 ? */ |
108 | 69 | ||
109 | alac->setinfo_max_samples_per_frame = *(uint32_t*)ptr; /* buffer size / 2 ? */ | 70 | alac->setinfo_max_samples_per_frame = *(uint32_t*)ptr; /* buffer size / 2 ? */ |
110 | if (!host_bigendian) | 71 | #ifdef ROCKBOX_LITTLE_ENDIAN |
111 | _Swap32(alac->setinfo_max_samples_per_frame); | 72 | _Swap32(alac->setinfo_max_samples_per_frame); |
73 | #endif | ||
112 | ptr += 4; | 74 | ptr += 4; |
113 | alac->setinfo_7a = *(uint8_t*)ptr; | 75 | alac->setinfo_7a = *(uint8_t*)ptr; |
114 | ptr += 1; | 76 | ptr += 1; |
@@ -123,24 +85,25 @@ void alac_set_info(alac_file *alac, char *inputbuffer) | |||
123 | alac->setinfo_7f = *(uint8_t*)ptr; | 85 | alac->setinfo_7f = *(uint8_t*)ptr; |
124 | ptr += 1; | 86 | ptr += 1; |
125 | alac->setinfo_80 = *(uint16_t*)ptr; | 87 | alac->setinfo_80 = *(uint16_t*)ptr; |
126 | if (!host_bigendian) | 88 | #ifdef ROCKBOX_LITTLE_ENDIAN |
127 | _Swap16(alac->setinfo_80); | 89 | _Swap16(alac->setinfo_80); |
90 | #endif | ||
128 | ptr += 2; | 91 | ptr += 2; |
129 | alac->setinfo_82 = *(uint32_t*)ptr; | 92 | alac->setinfo_82 = *(uint32_t*)ptr; |
130 | if (!host_bigendian) | 93 | #ifdef ROCKBOX_LITTLE_ENDIAN |
131 | _Swap32(alac->setinfo_82); | 94 | _Swap32(alac->setinfo_82); |
95 | #endif | ||
132 | ptr += 4; | 96 | ptr += 4; |
133 | alac->setinfo_86 = *(uint32_t*)ptr; | 97 | alac->setinfo_86 = *(uint32_t*)ptr; |
134 | if (!host_bigendian) | 98 | #ifdef ROCKBOX_LITTLE_ENDIAN |
135 | _Swap32(alac->setinfo_86); | 99 | _Swap32(alac->setinfo_86); |
100 | #endif | ||
136 | ptr += 4; | 101 | ptr += 4; |
137 | alac->setinfo_8a_rate = *(uint32_t*)ptr; | 102 | alac->setinfo_8a_rate = *(uint32_t*)ptr; |
138 | if (!host_bigendian) | 103 | #ifdef ROCKBOX_LITTLE_ENDIAN |
139 | _Swap32(alac->setinfo_8a_rate); | 104 | _Swap32(alac->setinfo_8a_rate); |
105 | #endif | ||
140 | ptr += 4; | 106 | ptr += 4; |
141 | |||
142 | allocate_buffers(alac); | ||
143 | |||
144 | } | 107 | } |
145 | 108 | ||
146 | /* stream reading */ | 109 | /* stream reading */ |
@@ -432,23 +395,150 @@ static void predictor_decompress_fir_adapt(int32_t *error_buffer, | |||
432 | } | 395 | } |
433 | } | 396 | } |
434 | 397 | ||
435 | #if 0 | 398 | /* 4 and 8 are very common cases (the only ones i've seen). |
436 | /* 4 and 8 are very common cases (the only ones i've seen). these | 399 | |
437 | * should be unrolled and optimised | 400 | The following code is an initial attempt to unroll and optimise |
401 | these two cases by the Rockbox project. More work is needed. | ||
438 | */ | 402 | */ |
403 | |||
404 | /* optimised case: 4 */ | ||
439 | if (predictor_coef_num == 4) | 405 | if (predictor_coef_num == 4) |
440 | { | 406 | { |
441 | /* FIXME: optimised general case */ | 407 | for (i = 4 + 1; i < output_size; i++) |
408 | { | ||
409 | int sum = 0; | ||
410 | int outval; | ||
411 | int error_val = error_buffer[i]; | ||
412 | |||
413 | sum = (buffer_out[4] - buffer_out[0]) * predictor_coef_table[0] | ||
414 | + (buffer_out[3] - buffer_out[0]) * predictor_coef_table[1] | ||
415 | + (buffer_out[2] - buffer_out[0]) * predictor_coef_table[2] | ||
416 | + (buffer_out[1] - buffer_out[0]) * predictor_coef_table[3]; | ||
417 | |||
418 | outval = (1 << (predictor_quantitization-1)) + sum; | ||
419 | outval = outval >> predictor_quantitization; | ||
420 | outval = outval + buffer_out[0] + error_val; | ||
421 | outval = SIGN_EXTENDED32(outval, readsamplesize); | ||
422 | |||
423 | buffer_out[4+1] = outval; | ||
424 | |||
425 | if (error_val > 0) | ||
426 | { | ||
427 | int predictor_num = 4 - 1; | ||
428 | |||
429 | while (predictor_num >= 0 && error_val > 0) | ||
430 | { | ||
431 | int val = buffer_out[0] - buffer_out[4 - predictor_num]; | ||
432 | |||
433 | if (val!=0) { | ||
434 | if (val < 0) { | ||
435 | predictor_coef_table[predictor_num]++; | ||
436 | val=-val; | ||
437 | } else { | ||
438 | predictor_coef_table[predictor_num]--;; | ||
439 | } | ||
440 | error_val -= ((val >> predictor_quantitization) * (4 - predictor_num)); | ||
441 | } | ||
442 | predictor_num--; | ||
443 | } | ||
444 | } | ||
445 | else if (error_val < 0) | ||
446 | { | ||
447 | int predictor_num = 4 - 1; | ||
448 | |||
449 | while (predictor_num >= 0 && error_val < 0) | ||
450 | { | ||
451 | int val = buffer_out[0] - buffer_out[4 - predictor_num]; | ||
452 | |||
453 | if (val != 0) { | ||
454 | if (val > 0) { | ||
455 | predictor_coef_table[predictor_num]++; | ||
456 | val=-val; /* neg value */ | ||
457 | } else { | ||
458 | predictor_coef_table[predictor_num]--; | ||
459 | } | ||
460 | error_val -= ((val >> predictor_quantitization) * (4 - predictor_num)); | ||
461 | } | ||
462 | predictor_num--; | ||
463 | } | ||
464 | } | ||
465 | |||
466 | buffer_out++; | ||
467 | } | ||
442 | return; | 468 | return; |
443 | } | 469 | } |
444 | 470 | ||
445 | if (predictor_coef_table == 8) | 471 | /* optimised case: 8 */ |
472 | if (predictor_coef_num == 8) | ||
446 | { | 473 | { |
447 | /* FIXME: optimised general case */ | 474 | for (i = 8 + 1; |
448 | return; | 475 | i < output_size; |
449 | } | 476 | i++) |
450 | #endif | 477 | { |
478 | int sum; | ||
479 | int outval; | ||
480 | int error_val = error_buffer[i]; | ||
481 | |||
482 | sum = (buffer_out[8] - buffer_out[0]) * predictor_coef_table[0] | ||
483 | + (buffer_out[7] - buffer_out[0]) * predictor_coef_table[1] | ||
484 | + (buffer_out[6] - buffer_out[0]) * predictor_coef_table[2] | ||
485 | + (buffer_out[5] - buffer_out[0]) * predictor_coef_table[3] | ||
486 | + (buffer_out[4] - buffer_out[0]) * predictor_coef_table[4] | ||
487 | + (buffer_out[3] - buffer_out[0]) * predictor_coef_table[5] | ||
488 | + (buffer_out[2] - buffer_out[0]) * predictor_coef_table[6] | ||
489 | + (buffer_out[1] - buffer_out[0]) * predictor_coef_table[7]; | ||
490 | |||
491 | outval = (1 << (predictor_quantitization-1)) + sum; | ||
492 | outval = outval >> predictor_quantitization; | ||
493 | outval = outval + buffer_out[0] + error_val; | ||
494 | outval = SIGN_EXTENDED32(outval, readsamplesize); | ||
495 | |||
496 | buffer_out[8+1] = outval; | ||
497 | |||
498 | if (error_val > 0) | ||
499 | { | ||
500 | int predictor_num = 8 - 1; | ||
501 | |||
502 | while (predictor_num >= 0 && error_val > 0) | ||
503 | { | ||
504 | int val = buffer_out[0] - buffer_out[8 - predictor_num]; | ||
505 | |||
506 | if (val!=0) { | ||
507 | if (val < 0) { | ||
508 | predictor_coef_table[predictor_num]++; | ||
509 | val=-val; | ||
510 | } else { | ||
511 | predictor_coef_table[predictor_num]--;; | ||
512 | } | ||
513 | error_val -= ((val >> predictor_quantitization) * (8 - predictor_num)); | ||
514 | } | ||
515 | predictor_num--; | ||
516 | } | ||
517 | } | ||
518 | else if (error_val < 0) | ||
519 | { | ||
520 | int predictor_num = 8 - 1; | ||
451 | 521 | ||
522 | while (predictor_num >= 0 && error_val < 0) | ||
523 | { | ||
524 | int val = buffer_out[0] - buffer_out[8 - predictor_num]; | ||
525 | if (val != 0) { | ||
526 | if (val > 0) { | ||
527 | predictor_coef_table[predictor_num]++; | ||
528 | val=-val; /* neg value */ | ||
529 | } else { | ||
530 | predictor_coef_table[predictor_num]--; | ||
531 | } | ||
532 | error_val -= ((val >> predictor_quantitization) * (8 - predictor_num)); | ||
533 | } | ||
534 | predictor_num--; | ||
535 | } | ||
536 | } | ||
537 | |||
538 | buffer_out++; | ||
539 | } | ||
540 | return; | ||
541 | } | ||
452 | 542 | ||
453 | /* general case */ | 543 | /* general case */ |
454 | if (predictor_coef_num > 0) | 544 | if (predictor_coef_num > 0) |
@@ -534,26 +624,12 @@ void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b, | |||
534 | for (i = 0; i < numsamples; i++) | 624 | for (i = 0; i < numsamples; i++) |
535 | { | 625 | { |
536 | int32_t difference, midright; | 626 | int32_t difference, midright; |
537 | int16_t left; | ||
538 | int16_t right; | ||
539 | 627 | ||
540 | midright = buffer_a[i]; | 628 | midright = buffer_a[i]; |
541 | difference = buffer_b[i]; | 629 | difference = buffer_b[i]; |
542 | 630 | ||
543 | 631 | buffer_out[i*numchannels] = (midright - ((difference * interlacing_leftweight) >> interlacing_shift)) + difference; | |
544 | right = midright - ((difference * interlacing_leftweight) >> interlacing_shift); | 632 | buffer_out[i*numchannels + 1] = midright - ((difference * interlacing_leftweight) >> interlacing_shift); |
545 | left = (midright - ((difference * interlacing_leftweight) >> interlacing_shift)) | ||
546 | + difference; | ||
547 | |||
548 | /* output is always little endian */ | ||
549 | if (host_bigendian) | ||
550 | { | ||
551 | _Swap16(left); | ||
552 | _Swap16(right); | ||
553 | } | ||
554 | |||
555 | buffer_out[i*numchannels] = left; | ||
556 | buffer_out[i*numchannels + 1] = right; | ||
557 | } | 633 | } |
558 | 634 | ||
559 | return; | 635 | return; |
@@ -562,34 +638,27 @@ void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b, | |||
562 | /* otherwise basic interlacing took place */ | 638 | /* otherwise basic interlacing took place */ |
563 | for (i = 0; i < numsamples; i++) | 639 | for (i = 0; i < numsamples; i++) |
564 | { | 640 | { |
565 | int16_t left, right; | 641 | buffer_out[i*numchannels] = buffer_a[i]; |
566 | 642 | buffer_out[i*numchannels + 1] = buffer_b[i]; | |
567 | left = buffer_a[i]; | ||
568 | right = buffer_b[i]; | ||
569 | |||
570 | /* output is always little endian */ | ||
571 | if (host_bigendian) | ||
572 | { | ||
573 | _Swap16(left); | ||
574 | _Swap16(right); | ||
575 | } | ||
576 | |||
577 | buffer_out[i*numchannels] = left; | ||
578 | buffer_out[i*numchannels + 1] = right; | ||
579 | } | 643 | } |
580 | } | 644 | } |
581 | 645 | ||
582 | void decode_frame(alac_file *alac, | 646 | int16_t* decode_frame(alac_file *alac, |
583 | unsigned char *inbuffer, | 647 | unsigned char *inbuffer, |
584 | void *outbuffer, int *outputsize) | 648 | int *outputsize) |
585 | { | 649 | { |
586 | int channels; | 650 | int channels; |
651 | int16_t* outbuffer; | ||
587 | int32_t outputsamples = alac->setinfo_max_samples_per_frame; | 652 | int32_t outputsamples = alac->setinfo_max_samples_per_frame; |
588 | 653 | ||
589 | /* setup the stream */ | 654 | /* setup the stream */ |
590 | alac->input_buffer = inbuffer; | 655 | alac->input_buffer = inbuffer; |
591 | alac->input_buffer_bitaccumulator = 0; | 656 | alac->input_buffer_bitaccumulator = 0; |
592 | 657 | ||
658 | /* We can share the same buffer for outputbuffer | ||
659 | and outputsamples_buffer_b - and hence have them both in IRAM*/ | ||
660 | outbuffer=(int16_t*)outputsamples_buffer_b; | ||
661 | |||
593 | channels = readbits(alac, 3); | 662 | channels = readbits(alac, 3); |
594 | 663 | ||
595 | *outputsize = outputsamples * alac->bytespersample; | 664 | *outputsize = outputsamples * alac->bytespersample; |
@@ -631,7 +700,6 @@ void decode_frame(alac_file *alac, | |||
631 | 700 | ||
632 | if (!isnotcompressed) | 701 | if (!isnotcompressed) |
633 | { /* so it is compressed */ | 702 | { /* so it is compressed */ |
634 | int16_t predictor_coef_table[32]; | ||
635 | int predictor_coef_num; | 703 | int predictor_coef_num; |
636 | int prediction_type; | 704 | int prediction_type; |
637 | int prediction_quantitization; | 705 | int prediction_quantitization; |
@@ -659,11 +727,11 @@ void decode_frame(alac_file *alac, | |||
659 | /* these bytes seem to have something to do with | 727 | /* these bytes seem to have something to do with |
660 | * > 2 channel files. | 728 | * > 2 channel files. |
661 | */ | 729 | */ |
662 | fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); | 730 | //fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); |
663 | } | 731 | } |
664 | 732 | ||
665 | basterdised_rice_decompress(alac, | 733 | basterdised_rice_decompress(alac, |
666 | alac->predicterror_buffer_a, | 734 | predicterror_buffer_a, |
667 | outputsamples, | 735 | outputsamples, |
668 | readsamplesize, | 736 | readsamplesize, |
669 | alac->setinfo_rice_initialhistory, | 737 | alac->setinfo_rice_initialhistory, |
@@ -673,8 +741,8 @@ void decode_frame(alac_file *alac, | |||
673 | 741 | ||
674 | if (prediction_type == 0) | 742 | if (prediction_type == 0) |
675 | { /* adaptive fir */ | 743 | { /* adaptive fir */ |
676 | predictor_decompress_fir_adapt(alac->predicterror_buffer_a, | 744 | predictor_decompress_fir_adapt(predicterror_buffer_a, |
677 | alac->outputsamples_buffer_a, | 745 | outputsamples_buffer_a, |
678 | outputsamples, | 746 | outputsamples, |
679 | readsamplesize, | 747 | readsamplesize, |
680 | predictor_coef_table, | 748 | predictor_coef_table, |
@@ -683,7 +751,7 @@ void decode_frame(alac_file *alac, | |||
683 | } | 751 | } |
684 | else | 752 | else |
685 | { | 753 | { |
686 | fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type); | 754 | //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type); |
687 | /* i think the only other prediction type (or perhaps this is just a | 755 | /* i think the only other prediction type (or perhaps this is just a |
688 | * boolean?) runs adaptive fir twice.. like: | 756 | * boolean?) runs adaptive fir twice.. like: |
689 | * predictor_decompress_fir_adapt(predictor_error, tempout, ...) | 757 | * predictor_decompress_fir_adapt(predictor_error, tempout, ...) |
@@ -704,7 +772,7 @@ void decode_frame(alac_file *alac, | |||
704 | 772 | ||
705 | audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); | 773 | audiobits = SIGN_EXTENDED32(audiobits, readsamplesize); |
706 | 774 | ||
707 | alac->outputsamples_buffer_a[i] = audiobits; | 775 | outputsamples_buffer_a[i] = audiobits; |
708 | } | 776 | } |
709 | } | 777 | } |
710 | else | 778 | else |
@@ -722,7 +790,7 @@ void decode_frame(alac_file *alac, | |||
722 | 790 | ||
723 | audiobits |= readbits(alac, readsamplesize - 16); | 791 | audiobits |= readbits(alac, readsamplesize - 16); |
724 | 792 | ||
725 | alac->outputsamples_buffer_a[i] = audiobits; | 793 | outputsamples_buffer_a[i] = audiobits; |
726 | } | 794 | } |
727 | } | 795 | } |
728 | /* wasted_bytes = 0; // unused */ | 796 | /* wasted_bytes = 0; // unused */ |
@@ -735,17 +803,16 @@ void decode_frame(alac_file *alac, | |||
735 | int i; | 803 | int i; |
736 | for (i = 0; i < outputsamples; i++) | 804 | for (i = 0; i < outputsamples; i++) |
737 | { | 805 | { |
738 | int16_t sample = alac->outputsamples_buffer_a[i]; | 806 | /* Output mono data as stereo */ |
739 | if (host_bigendian) | 807 | outbuffer[i*2] = outputsamples_buffer_a[i]; |
740 | _Swap16(sample); | 808 | outbuffer[i*2+1] = outputsamples_buffer_a[i]; |
741 | ((int16_t*)outbuffer)[i * alac->numchannels] = sample; | ||
742 | } | 809 | } |
743 | break; | 810 | break; |
744 | } | 811 | } |
745 | case 20: | 812 | case 20: |
746 | case 24: | 813 | case 24: |
747 | case 32: | 814 | case 32: |
748 | fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); | 815 | //fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); |
749 | break; | 816 | break; |
750 | default: | 817 | default: |
751 | break; | 818 | break; |
@@ -788,13 +855,11 @@ void decode_frame(alac_file *alac, | |||
788 | 855 | ||
789 | if (!isnotcompressed) | 856 | if (!isnotcompressed) |
790 | { /* compressed */ | 857 | { /* compressed */ |
791 | int16_t predictor_coef_table_a[32]; | ||
792 | int predictor_coef_num_a; | 858 | int predictor_coef_num_a; |
793 | int prediction_type_a; | 859 | int prediction_type_a; |
794 | int prediction_quantitization_a; | 860 | int prediction_quantitization_a; |
795 | int ricemodifier_a; | 861 | int ricemodifier_a; |
796 | 862 | ||
797 | int16_t predictor_coef_table_b[32]; | ||
798 | int predictor_coef_num_b; | 863 | int predictor_coef_num_b; |
799 | int prediction_type_b; | 864 | int prediction_type_b; |
800 | int prediction_quantitization_b; | 865 | int prediction_quantitization_b; |
@@ -834,12 +899,12 @@ void decode_frame(alac_file *alac, | |||
834 | /*********************/ | 899 | /*********************/ |
835 | if (wasted_bytes) | 900 | if (wasted_bytes) |
836 | { /* see mono case */ | 901 | { /* see mono case */ |
837 | fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); | 902 | //fprintf(stderr, "FIXME: unimplemented, unhandling of wasted_bytes\n"); |
838 | } | 903 | } |
839 | 904 | ||
840 | /* channel 1 */ | 905 | /* channel 1 */ |
841 | basterdised_rice_decompress(alac, | 906 | basterdised_rice_decompress(alac, |
842 | alac->predicterror_buffer_a, | 907 | predicterror_buffer_a, |
843 | outputsamples, | 908 | outputsamples, |
844 | readsamplesize, | 909 | readsamplesize, |
845 | alac->setinfo_rice_initialhistory, | 910 | alac->setinfo_rice_initialhistory, |
@@ -849,8 +914,8 @@ void decode_frame(alac_file *alac, | |||
849 | 914 | ||
850 | if (prediction_type_a == 0) | 915 | if (prediction_type_a == 0) |
851 | { /* adaptive fir */ | 916 | { /* adaptive fir */ |
852 | predictor_decompress_fir_adapt(alac->predicterror_buffer_a, | 917 | predictor_decompress_fir_adapt(predicterror_buffer_a, |
853 | alac->outputsamples_buffer_a, | 918 | outputsamples_buffer_a, |
854 | outputsamples, | 919 | outputsamples, |
855 | readsamplesize, | 920 | readsamplesize, |
856 | predictor_coef_table_a, | 921 | predictor_coef_table_a, |
@@ -859,12 +924,12 @@ void decode_frame(alac_file *alac, | |||
859 | } | 924 | } |
860 | else | 925 | else |
861 | { /* see mono case */ | 926 | { /* see mono case */ |
862 | fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_a); | 927 | //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_a); |
863 | } | 928 | } |
864 | 929 | ||
865 | /* channel 2 */ | 930 | /* channel 2 */ |
866 | basterdised_rice_decompress(alac, | 931 | basterdised_rice_decompress(alac, |
867 | alac->predicterror_buffer_b, | 932 | predicterror_buffer_b, |
868 | outputsamples, | 933 | outputsamples, |
869 | readsamplesize, | 934 | readsamplesize, |
870 | alac->setinfo_rice_initialhistory, | 935 | alac->setinfo_rice_initialhistory, |
@@ -874,8 +939,8 @@ void decode_frame(alac_file *alac, | |||
874 | 939 | ||
875 | if (prediction_type_b == 0) | 940 | if (prediction_type_b == 0) |
876 | { /* adaptive fir */ | 941 | { /* adaptive fir */ |
877 | predictor_decompress_fir_adapt(alac->predicterror_buffer_b, | 942 | predictor_decompress_fir_adapt(predicterror_buffer_b, |
878 | alac->outputsamples_buffer_b, | 943 | outputsamples_buffer_b, |
879 | outputsamples, | 944 | outputsamples, |
880 | readsamplesize, | 945 | readsamplesize, |
881 | predictor_coef_table_b, | 946 | predictor_coef_table_b, |
@@ -884,7 +949,7 @@ void decode_frame(alac_file *alac, | |||
884 | } | 949 | } |
885 | else | 950 | else |
886 | { | 951 | { |
887 | fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_b); | 952 | //fprintf(stderr, "FIXME: unhandled predicition type: %i\n", prediction_type_b); |
888 | } | 953 | } |
889 | } | 954 | } |
890 | else | 955 | else |
@@ -902,8 +967,8 @@ void decode_frame(alac_file *alac, | |||
902 | audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); | 967 | audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size); |
903 | audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); | 968 | audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size); |
904 | 969 | ||
905 | alac->outputsamples_buffer_a[i] = audiobits_a; | 970 | outputsamples_buffer_a[i] = audiobits_a; |
906 | alac->outputsamples_buffer_b[i] = audiobits_b; | 971 | outputsamples_buffer_b[i] = audiobits_b; |
907 | } | 972 | } |
908 | } | 973 | } |
909 | else | 974 | else |
@@ -923,8 +988,8 @@ void decode_frame(alac_file *alac, | |||
923 | audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); | 988 | audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size); |
924 | audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16); | 989 | audiobits_b |= readbits(alac, alac->setinfo_sample_size - 16); |
925 | 990 | ||
926 | alac->outputsamples_buffer_a[i] = audiobits_a; | 991 | outputsamples_buffer_a[i] = audiobits_a; |
927 | alac->outputsamples_buffer_b[i] = audiobits_b; | 992 | outputsamples_buffer_b[i] = audiobits_b; |
928 | } | 993 | } |
929 | } | 994 | } |
930 | /* wasted_bytes = 0; */ | 995 | /* wasted_bytes = 0; */ |
@@ -936,8 +1001,8 @@ void decode_frame(alac_file *alac, | |||
936 | { | 1001 | { |
937 | case 16: | 1002 | case 16: |
938 | { | 1003 | { |
939 | deinterlace_16(alac->outputsamples_buffer_a, | 1004 | deinterlace_16(outputsamples_buffer_a, |
940 | alac->outputsamples_buffer_b, | 1005 | outputsamples_buffer_b, |
941 | (int16_t*)outbuffer, | 1006 | (int16_t*)outbuffer, |
942 | alac->numchannels, | 1007 | alac->numchannels, |
943 | outputsamples, | 1008 | outputsamples, |
@@ -948,7 +1013,7 @@ void decode_frame(alac_file *alac, | |||
948 | case 20: | 1013 | case 20: |
949 | case 24: | 1014 | case 24: |
950 | case 32: | 1015 | case 32: |
951 | fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); | 1016 | //fprintf(stderr, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size); |
952 | break; | 1017 | break; |
953 | default: | 1018 | default: |
954 | break; | 1019 | break; |
@@ -957,16 +1022,12 @@ void decode_frame(alac_file *alac, | |||
957 | break; | 1022 | break; |
958 | } | 1023 | } |
959 | } | 1024 | } |
1025 | return outbuffer; | ||
960 | } | 1026 | } |
961 | 1027 | ||
962 | alac_file *create_alac(int samplesize, int numchannels) | 1028 | void create_alac(int samplesize, int numchannels, alac_file* alac) |
963 | { | 1029 | { |
964 | alac_file *newfile = malloc(sizeof(alac_file)); | 1030 | alac->samplesize = samplesize; |
965 | 1031 | alac->numchannels = numchannels; | |
966 | newfile->samplesize = samplesize; | 1032 | alac->bytespersample = (samplesize / 8) * numchannels; |
967 | newfile->numchannels = numchannels; | ||
968 | newfile->bytespersample = (samplesize / 8) * numchannels; | ||
969 | |||
970 | return newfile; | ||
971 | } | 1033 | } |
972 | |||