make some tables const
[ffmpeg.git] / libavcodec / alac.c
1 /*
2  * ALAC (Apple Lossless Audio Codec) decoder
3  * Copyright (c) 2005 David Hammerton
4  * All rights reserved.
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file alac.c
23  * ALAC (Apple Lossless Audio Codec) decoder
24  * @author 2005 David Hammerton
25  *
26  * For more information on the ALAC format, visit:
27  *  http://crazney.net/programs/itunes/alac.html
28  *
29  * Note: This decoder expects a 36- (0x24-)byte QuickTime atom to be
30  * passed through the extradata[_size] fields. This atom is tacked onto
31  * the end of an 'alac' stsd atom and has the following format:
32  *  bytes 0-3   atom size (0x24), big-endian
33  *  bytes 4-7   atom type ('alac', not the 'alac' tag from start of stsd)
34  *  bytes 8-35  data bytes needed by decoder
35  *
36  * Extradata:
37  * 32bit  size
38  * 32bit  tag (=alac)
39  * 32bit  zero?
40  * 32bit  max sample per frame
41  *  8bit  ?? (zero?)
42  *  8bit  sample size
43  *  8bit  history mult
44  *  8bit  initial history
45  *  8bit  kmodifier
46  *  8bit  channels?
47  * 16bit  ??
48  * 32bit  max coded frame size
49  * 32bit  bitrate?
50  * 32bit  samplerate
51  */
52
53
54 #include "avcodec.h"
55 #include "bitstream.h"
56
57 #define ALAC_EXTRADATA_SIZE 36
58
59 typedef struct {
60
61     AVCodecContext *avctx;
62     GetBitContext gb;
63     /* init to 0; first frame decode should initialize from extradata and
64      * set this to 1 */
65     int context_initialized;
66
67     int samplesize;
68     int numchannels;
69     int bytespersample;
70
71     /* buffers */
72     int32_t *predicterror_buffer_a;
73     int32_t *predicterror_buffer_b;
74
75     int32_t *outputsamples_buffer_a;
76     int32_t *outputsamples_buffer_b;
77
78     /* stuff from setinfo */
79     uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */    /* max samples per frame? */
80     uint8_t setinfo_7a; /* 0x00 */
81     uint8_t setinfo_sample_size; /* 0x10 */
82     uint8_t setinfo_rice_historymult; /* 0x28 */
83     uint8_t setinfo_rice_initialhistory; /* 0x0a */
84     uint8_t setinfo_rice_kmodifier; /* 0x0e */
85     uint8_t setinfo_7f; /* 0x02 */
86     uint16_t setinfo_80; /* 0x00ff */
87     uint32_t setinfo_82; /* 0x000020e7 */
88     uint32_t setinfo_86; /* 0x00069fe4 */
89     uint32_t setinfo_8a_rate; /* 0x0000ac44 */
90     /* end setinfo stuff */
91
92 } ALACContext;
93
94 static void allocate_buffers(ALACContext *alac)
95 {
96     alac->predicterror_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4);
97     alac->predicterror_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4);
98
99     alac->outputsamples_buffer_a = av_malloc(alac->setinfo_max_samples_per_frame * 4);
100     alac->outputsamples_buffer_b = av_malloc(alac->setinfo_max_samples_per_frame * 4);
101 }
102
103 static int alac_set_info(ALACContext *alac)
104 {
105     unsigned char *ptr = alac->avctx->extradata;
106
107     ptr += 4; /* size */
108     ptr += 4; /* alac */
109     ptr += 4; /* 0 ? */
110
111     if(BE_32(ptr) >= UINT_MAX/4){
112         av_log(alac->avctx, AV_LOG_ERROR, "setinfo_max_samples_per_frame too large\n");
113         return -1;
114     }
115     alac->setinfo_max_samples_per_frame = BE_32(ptr); /* buffer size / 2 ? */
116     ptr += 4;
117     alac->setinfo_7a = *ptr++;
118     alac->setinfo_sample_size = *ptr++;
119     alac->setinfo_rice_historymult = *ptr++;
120     alac->setinfo_rice_initialhistory = *ptr++;
121     alac->setinfo_rice_kmodifier = *ptr++;
122     alac->setinfo_7f = *ptr++; // channels?
123     alac->setinfo_80 = BE_16(ptr);
124     ptr += 2;
125     alac->setinfo_82 = BE_32(ptr); // max coded frame size
126     ptr += 4;
127     alac->setinfo_86 = BE_32(ptr); // bitrate ?
128     ptr += 4;
129     alac->setinfo_8a_rate = BE_32(ptr); // samplerate
130     ptr += 4;
131
132     allocate_buffers(alac);
133
134     return 0;
135 }
136
137 /* hideously inefficient. could use a bitmask search,
138  * alternatively bsr on x86,
139  */
140 static int count_leading_zeros(int32_t input)
141 {
142     int i = 0;
143     while (!(0x80000000 & input) && i < 32) {
144         i++;
145         input = input << 1;
146     }
147     return i;
148 }
149
150 static void bastardized_rice_decompress(ALACContext *alac,
151                                  int32_t *output_buffer,
152                                  int output_size,
153                                  int readsamplesize, /* arg_10 */
154                                  int rice_initialhistory, /* arg424->b */
155                                  int rice_kmodifier, /* arg424->d */
156                                  int rice_historymult, /* arg424->c */
157                                  int rice_kmodifier_mask /* arg424->e */
158         )
159 {
160     int output_count;
161     unsigned int history = rice_initialhistory;
162     int sign_modifier = 0;
163
164     for (output_count = 0; output_count < output_size; output_count++) {
165         int32_t x = 0;
166         int32_t x_modified;
167         int32_t final_val;
168
169         /* read x - number of 1s before 0 represent the rice */
170         while (x <= 8 && get_bits1(&alac->gb)) {
171             x++;
172         }
173
174
175         if (x > 8) { /* RICE THRESHOLD */
176           /* use alternative encoding */
177             int32_t value;
178
179             value = get_bits(&alac->gb, readsamplesize);
180
181             /* mask value to readsamplesize size */
182             if (readsamplesize != 32)
183                 value &= (0xffffffff >> (32 - readsamplesize));
184
185             x = value;
186         } else {
187           /* standard rice encoding */
188             int extrabits;
189             int k; /* size of extra bits */
190
191             /* read k, that is bits as is */
192             k = 31 - rice_kmodifier - count_leading_zeros((history >> 9) + 3);
193
194             if (k < 0)
195                 k += rice_kmodifier;
196             else
197                 k = rice_kmodifier;
198
199             if (k != 1) {
200                 extrabits = show_bits(&alac->gb, k);
201
202                 /* multiply x by 2^k - 1, as part of their strange algorithm */
203                 x = (x << k) - x;
204
205                 if (extrabits > 1) {
206                     x += extrabits - 1;
207                     get_bits(&alac->gb, k);
208                 } else {
209                     get_bits(&alac->gb, k - 1);
210                 }
211             }
212         }
213
214         x_modified = sign_modifier + x;
215         final_val = (x_modified + 1) / 2;
216         if (x_modified & 1) final_val *= -1;
217
218         output_buffer[output_count] = final_val;
219
220         sign_modifier = 0;
221
222         /* now update the history */
223         history += (x_modified * rice_historymult)
224                  - ((history * rice_historymult) >> 9);
225
226         if (x_modified > 0xffff)
227             history = 0xffff;
228
229         /* special case: there may be compressed blocks of 0 */
230         if ((history < 128) && (output_count+1 < output_size)) {
231             int block_size;
232
233             sign_modifier = 1;
234
235             x = 0;
236             while (x <= 8 && get_bits1(&alac->gb)) {
237                 x++;
238             }
239
240             if (x > 8) {
241                 block_size = get_bits(&alac->gb, 16);
242                 block_size &= 0xffff;
243             } else {
244                 int k;
245                 int extrabits;
246
247                 k = count_leading_zeros(history) + ((history + 16) >> 6 /* / 64 */) - 24;
248
249                 extrabits = show_bits(&alac->gb, k);
250
251                 block_size = (((1 << k) - 1) & rice_kmodifier_mask) * x
252                            + extrabits - 1;
253
254                 if (extrabits < 2) {
255                     x = 1 - extrabits;
256                     block_size += x;
257                     get_bits(&alac->gb, k - 1);
258                 } else {
259                     get_bits(&alac->gb, k);
260                 }
261             }
262
263             if (block_size > 0) {
264                 memset(&output_buffer[output_count+1], 0, block_size * 4);
265                 output_count += block_size;
266
267             }
268
269             if (block_size > 0xffff)
270                 sign_modifier = 0;
271
272             history = 0;
273         }
274     }
275 }
276
277 #define SIGN_EXTENDED32(val, bits) ((val << (32 - bits)) >> (32 - bits))
278
279 #define SIGN_ONLY(v) \
280                      ((v < 0) ? (-1) : \
281                                 ((v > 0) ? (1) : \
282                                            (0)))
283
284 static void predictor_decompress_fir_adapt(int32_t *error_buffer,
285                                            int32_t *buffer_out,
286                                            int output_size,
287                                            int readsamplesize,
288                                            int16_t *predictor_coef_table,
289                                            int predictor_coef_num,
290                                            int predictor_quantitization)
291 {
292     int i;
293
294     /* first sample always copies */
295     *buffer_out = *error_buffer;
296
297     if (!predictor_coef_num) {
298         if (output_size <= 1) return;
299         memcpy(buffer_out+1, error_buffer+1, (output_size-1) * 4);
300         return;
301     }
302
303     if (predictor_coef_num == 0x1f) { /* 11111 - max value of predictor_coef_num */
304       /* second-best case scenario for fir decompression,
305        * error describes a small difference from the previous sample only
306        */
307         if (output_size <= 1) return;
308         for (i = 0; i < output_size - 1; i++) {
309             int32_t prev_value;
310             int32_t error_value;
311
312             prev_value = buffer_out[i];
313             error_value = error_buffer[i+1];
314             buffer_out[i+1] = SIGN_EXTENDED32((prev_value + error_value), readsamplesize);
315         }
316         return;
317     }
318
319     /* read warm-up samples */
320     if (predictor_coef_num > 0) {
321         int i;
322         for (i = 0; i < predictor_coef_num; i++) {
323             int32_t val;
324
325             val = buffer_out[i] + error_buffer[i+1];
326
327             val = SIGN_EXTENDED32(val, readsamplesize);
328
329             buffer_out[i+1] = val;
330         }
331     }
332
333 #if 0
334     /* 4 and 8 are very common cases (the only ones i've seen). these
335      * should be unrolled and optimised
336      */
337     if (predictor_coef_num == 4) {
338         /* FIXME: optimised general case */
339         return;
340     }
341
342     if (predictor_coef_table == 8) {
343         /* FIXME: optimised general case */
344         return;
345     }
346 #endif
347
348
349     /* general case */
350     if (predictor_coef_num > 0) {
351         for (i = predictor_coef_num + 1;
352              i < output_size;
353              i++) {
354             int j;
355             int sum = 0;
356             int outval;
357             int error_val = error_buffer[i];
358
359             for (j = 0; j < predictor_coef_num; j++) {
360                 sum += (buffer_out[predictor_coef_num-j] - buffer_out[0]) *
361                        predictor_coef_table[j];
362             }
363
364             outval = (1 << (predictor_quantitization-1)) + sum;
365             outval = outval >> predictor_quantitization;
366             outval = outval + buffer_out[0] + error_val;
367             outval = SIGN_EXTENDED32(outval, readsamplesize);
368
369             buffer_out[predictor_coef_num+1] = outval;
370
371             if (error_val > 0) {
372                 int predictor_num = predictor_coef_num - 1;
373
374                 while (predictor_num >= 0 && error_val > 0) {
375                     int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
376                     int sign = SIGN_ONLY(val);
377
378                     predictor_coef_table[predictor_num] -= sign;
379
380                     val *= sign; /* absolute value */
381
382                     error_val -= ((val >> predictor_quantitization) *
383                                   (predictor_coef_num - predictor_num));
384
385                     predictor_num--;
386                 }
387             } else if (error_val < 0) {
388                 int predictor_num = predictor_coef_num - 1;
389
390                 while (predictor_num >= 0 && error_val < 0) {
391                     int val = buffer_out[0] - buffer_out[predictor_coef_num - predictor_num];
392                     int sign = - SIGN_ONLY(val);
393
394                     predictor_coef_table[predictor_num] -= sign;
395
396                     val *= sign; /* neg value */
397
398                     error_val -= ((val >> predictor_quantitization) *
399                                   (predictor_coef_num - predictor_num));
400
401                     predictor_num--;
402                 }
403             }
404
405             buffer_out++;
406         }
407     }
408 }
409
410 static void deinterlace_16(int32_t *buffer_a, int32_t *buffer_b,
411                     int16_t *buffer_out,
412                     int numchannels, int numsamples,
413                     uint8_t interlacing_shift,
414                     uint8_t interlacing_leftweight)
415 {
416     int i;
417     if (numsamples <= 0) return;
418
419     /* weighted interlacing */
420     if (interlacing_leftweight) {
421         for (i = 0; i < numsamples; i++) {
422             int32_t difference, midright;
423             int16_t left;
424             int16_t right;
425
426             midright = buffer_a[i];
427             difference = buffer_b[i];
428
429
430             right = midright - ((difference * interlacing_leftweight) >> interlacing_shift);
431             left = (midright - ((difference * interlacing_leftweight) >> interlacing_shift))
432                  + difference;
433
434             buffer_out[i*numchannels] = left;
435             buffer_out[i*numchannels + 1] = right;
436         }
437
438         return;
439     }
440
441     /* otherwise basic interlacing took place */
442     for (i = 0; i < numsamples; i++) {
443         int16_t left, right;
444
445         left = buffer_a[i];
446         right = buffer_b[i];
447
448         buffer_out[i*numchannels] = left;
449         buffer_out[i*numchannels + 1] = right;
450     }
451 }
452
453 static int alac_decode_frame(AVCodecContext *avctx,
454                              void *outbuffer, int *outputsize,
455                              uint8_t *inbuffer, int input_buffer_size)
456 {
457     ALACContext *alac = avctx->priv_data;
458
459     int channels;
460     int32_t outputsamples;
461
462     /* short-circuit null buffers */
463     if (!inbuffer || !input_buffer_size)
464         return input_buffer_size;
465
466     /* initialize from the extradata */
467     if (!alac->context_initialized) {
468         if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
469             av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
470                 ALAC_EXTRADATA_SIZE);
471             return input_buffer_size;
472         }
473         alac_set_info(alac);
474         alac->context_initialized = 1;
475     }
476
477     outputsamples = alac->setinfo_max_samples_per_frame;
478
479     init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
480
481     channels = get_bits(&alac->gb, 3);
482
483     *outputsize = outputsamples * alac->bytespersample;
484
485     switch(channels) {
486     case 0: { /* 1 channel */
487         int hassize;
488         int isnotcompressed;
489         int readsamplesize;
490
491         int wasted_bytes;
492         int ricemodifier;
493
494
495         /* 2^result = something to do with output waiting.
496          * perhaps matters if we read > 1 frame in a pass?
497          */
498         get_bits(&alac->gb, 4);
499
500         get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
501
502         hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */
503
504         wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
505
506         isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */
507
508         if (hassize) {
509             /* now read the number of samples,
510              * as a 32bit integer */
511             outputsamples = get_bits(&alac->gb, 32);
512             *outputsize = outputsamples * alac->bytespersample;
513         }
514
515         readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8);
516
517         if (!isnotcompressed) {
518          /* so it is compressed */
519             int16_t predictor_coef_table[32];
520             int predictor_coef_num;
521             int prediction_type;
522             int prediction_quantitization;
523             int i;
524
525             /* FIXME: skip 16 bits, not sure what they are. seem to be used in
526              * two channel case */
527             get_bits(&alac->gb, 8);
528             get_bits(&alac->gb, 8);
529
530             prediction_type = get_bits(&alac->gb, 4);
531             prediction_quantitization = get_bits(&alac->gb, 4);
532
533             ricemodifier = get_bits(&alac->gb, 3);
534             predictor_coef_num = get_bits(&alac->gb, 5);
535
536             /* read the predictor table */
537             for (i = 0; i < predictor_coef_num; i++) {
538                 predictor_coef_table[i] = (int16_t)get_bits(&alac->gb, 16);
539             }
540
541             if (wasted_bytes) {
542                 /* these bytes seem to have something to do with
543                  * > 2 channel files.
544                  */
545                 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");
546             }
547
548             bastardized_rice_decompress(alac,
549                                         alac->predicterror_buffer_a,
550                                         outputsamples,
551                                         readsamplesize,
552                                         alac->setinfo_rice_initialhistory,
553                                         alac->setinfo_rice_kmodifier,
554                                         ricemodifier * alac->setinfo_rice_historymult / 4,
555                                         (1 << alac->setinfo_rice_kmodifier) - 1);
556
557             if (prediction_type == 0) {
558               /* adaptive fir */
559                 predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
560                                                alac->outputsamples_buffer_a,
561                                                outputsamples,
562                                                readsamplesize,
563                                                predictor_coef_table,
564                                                predictor_coef_num,
565                                                prediction_quantitization);
566             } else {
567                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type);
568                 /* i think the only other prediction type (or perhaps this is just a
569                  * boolean?) runs adaptive fir twice.. like:
570                  * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
571                  * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
572                  * little strange..
573                  */
574             }
575
576         } else {
577           /* not compressed, easy case */
578             if (readsamplesize <= 16) {
579                 int i;
580                 for (i = 0; i < outputsamples; i++) {
581                     int32_t audiobits = get_bits(&alac->gb, readsamplesize);
582
583                     audiobits = SIGN_EXTENDED32(audiobits, readsamplesize);
584
585                     alac->outputsamples_buffer_a[i] = audiobits;
586                 }
587             } else {
588                 int i;
589                 for (i = 0; i < outputsamples; i++) {
590                     int32_t audiobits;
591
592                     audiobits = get_bits(&alac->gb, 16);
593                     /* special case of sign extension..
594                      * as we'll be ORing the low 16bits into this */
595                     audiobits = audiobits << 16;
596                     audiobits = audiobits >> (32 - readsamplesize);
597
598                     audiobits |= get_bits(&alac->gb, readsamplesize - 16);
599
600                     alac->outputsamples_buffer_a[i] = audiobits;
601                 }
602             }
603             /* wasted_bytes = 0; // unused */
604         }
605
606         switch(alac->setinfo_sample_size) {
607         case 16: {
608             int i;
609             for (i = 0; i < outputsamples; i++) {
610                 int16_t sample = alac->outputsamples_buffer_a[i];
611                 ((int16_t*)outbuffer)[i * alac->numchannels] = sample;
612             }
613             break;
614         }
615         case 20:
616         case 24:
617         case 32:
618             av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
619             break;
620         default:
621             break;
622         }
623         break;
624     }
625     case 1: { /* 2 channels */
626         int hassize;
627         int isnotcompressed;
628         int readsamplesize;
629
630         int wasted_bytes;
631
632         uint8_t interlacing_shift;
633         uint8_t interlacing_leftweight;
634
635         /* 2^result = something to do with output waiting.
636          * perhaps matters if we read > 1 frame in a pass?
637          */
638         get_bits(&alac->gb, 4);
639
640         get_bits(&alac->gb, 12); /* unknown, skip 12 bits */
641
642         hassize = get_bits(&alac->gb, 1); /* the output sample size is stored soon */
643
644         wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
645
646         isnotcompressed = get_bits(&alac->gb, 1); /* whether the frame is compressed */
647
648         if (hassize) {
649             /* now read the number of samples,
650              * as a 32bit integer */
651             outputsamples = get_bits(&alac->gb, 32);
652             *outputsize = outputsamples * alac->bytespersample;
653         }
654
655         readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + 1;
656
657         if (!isnotcompressed) {
658          /* compressed */
659             int16_t predictor_coef_table_a[32];
660             int predictor_coef_num_a;
661             int prediction_type_a;
662             int prediction_quantitization_a;
663             int ricemodifier_a;
664
665             int16_t predictor_coef_table_b[32];
666             int predictor_coef_num_b;
667             int prediction_type_b;
668             int prediction_quantitization_b;
669             int ricemodifier_b;
670
671             int i;
672
673             interlacing_shift = get_bits(&alac->gb, 8);
674             interlacing_leftweight = get_bits(&alac->gb, 8);
675
676             /******** channel 1 ***********/
677             prediction_type_a = get_bits(&alac->gb, 4);
678             prediction_quantitization_a = get_bits(&alac->gb, 4);
679
680             ricemodifier_a = get_bits(&alac->gb, 3);
681             predictor_coef_num_a = get_bits(&alac->gb, 5);
682
683             /* read the predictor table */
684             for (i = 0; i < predictor_coef_num_a; i++) {
685                 predictor_coef_table_a[i] = (int16_t)get_bits(&alac->gb, 16);
686             }
687
688             /******** channel 2 *********/
689             prediction_type_b = get_bits(&alac->gb, 4);
690             prediction_quantitization_b = get_bits(&alac->gb, 4);
691
692             ricemodifier_b = get_bits(&alac->gb, 3);
693             predictor_coef_num_b = get_bits(&alac->gb, 5);
694
695             /* read the predictor table */
696             for (i = 0; i < predictor_coef_num_b; i++) {
697                 predictor_coef_table_b[i] = (int16_t)get_bits(&alac->gb, 16);
698             }
699
700             /*********************/
701             if (wasted_bytes) {
702               /* see mono case */
703                 av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");
704             }
705
706             /* channel 1 */
707             bastardized_rice_decompress(alac,
708                                         alac->predicterror_buffer_a,
709                                         outputsamples,
710                                         readsamplesize,
711                                         alac->setinfo_rice_initialhistory,
712                                         alac->setinfo_rice_kmodifier,
713                                         ricemodifier_a * alac->setinfo_rice_historymult / 4,
714                                         (1 << alac->setinfo_rice_kmodifier) - 1);
715
716             if (prediction_type_a == 0) {
717               /* adaptive fir */
718                 predictor_decompress_fir_adapt(alac->predicterror_buffer_a,
719                                                alac->outputsamples_buffer_a,
720                                                outputsamples,
721                                                readsamplesize,
722                                                predictor_coef_table_a,
723                                                predictor_coef_num_a,
724                                                prediction_quantitization_a);
725             } else {
726               /* see mono case */
727                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_a);
728             }
729
730             /* channel 2 */
731             bastardized_rice_decompress(alac,
732                                         alac->predicterror_buffer_b,
733                                         outputsamples,
734                                         readsamplesize,
735                                         alac->setinfo_rice_initialhistory,
736                                         alac->setinfo_rice_kmodifier,
737                                         ricemodifier_b * alac->setinfo_rice_historymult / 4,
738                                         (1 << alac->setinfo_rice_kmodifier) - 1);
739
740             if (prediction_type_b == 0) {
741               /* adaptive fir */
742                 predictor_decompress_fir_adapt(alac->predicterror_buffer_b,
743                                                alac->outputsamples_buffer_b,
744                                                outputsamples,
745                                                readsamplesize,
746                                                predictor_coef_table_b,
747                                                predictor_coef_num_b,
748                                                prediction_quantitization_b);
749             } else {
750                 av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type_b);
751             }
752         } else {
753          /* not compressed, easy case */
754             if (alac->setinfo_sample_size <= 16) {
755                 int i;
756                 for (i = 0; i < outputsamples; i++) {
757                     int32_t audiobits_a, audiobits_b;
758
759                     audiobits_a = get_bits(&alac->gb, alac->setinfo_sample_size);
760                     audiobits_b = get_bits(&alac->gb, alac->setinfo_sample_size);
761
762                     audiobits_a = SIGN_EXTENDED32(audiobits_a, alac->setinfo_sample_size);
763                     audiobits_b = SIGN_EXTENDED32(audiobits_b, alac->setinfo_sample_size);
764
765                     alac->outputsamples_buffer_a[i] = audiobits_a;
766                     alac->outputsamples_buffer_b[i] = audiobits_b;
767                 }
768             } else {
769                 int i;
770                 for (i = 0; i < outputsamples; i++) {
771                     int32_t audiobits_a, audiobits_b;
772
773                     audiobits_a = get_bits(&alac->gb, 16);
774                     audiobits_a = audiobits_a << 16;
775                     audiobits_a = audiobits_a >> (32 - alac->setinfo_sample_size);
776                     audiobits_a |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
777
778                     audiobits_b = get_bits(&alac->gb, 16);
779                     audiobits_b = audiobits_b << 16;
780                     audiobits_b = audiobits_b >> (32 - alac->setinfo_sample_size);
781                     audiobits_b |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
782
783                     alac->outputsamples_buffer_a[i] = audiobits_a;
784                     alac->outputsamples_buffer_b[i] = audiobits_b;
785                 }
786             }
787             /* wasted_bytes = 0; */
788             interlacing_shift = 0;
789             interlacing_leftweight = 0;
790         }
791
792         switch(alac->setinfo_sample_size) {
793         case 16: {
794             deinterlace_16(alac->outputsamples_buffer_a,
795                            alac->outputsamples_buffer_b,
796                            (int16_t*)outbuffer,
797                            alac->numchannels,
798                            outputsamples,
799                            interlacing_shift,
800                            interlacing_leftweight);
801             break;
802         }
803         case 20:
804         case 24:
805         case 32:
806             av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
807             break;
808         default:
809             break;
810         }
811
812         break;
813     }
814     }
815
816     return input_buffer_size;
817 }
818
819 static int alac_decode_init(AVCodecContext * avctx)
820 {
821     ALACContext *alac = avctx->priv_data;
822     alac->avctx = avctx;
823     alac->context_initialized = 0;
824
825     alac->samplesize = alac->avctx->bits_per_sample;
826     alac->numchannels = alac->avctx->channels;
827     alac->bytespersample = (alac->samplesize / 8) * alac->numchannels;
828
829     return 0;
830 }
831
832 static int alac_decode_close(AVCodecContext *avctx)
833 {
834     ALACContext *alac = avctx->priv_data;
835
836     av_free(alac->predicterror_buffer_a);
837     av_free(alac->predicterror_buffer_b);
838
839     av_free(alac->outputsamples_buffer_a);
840     av_free(alac->outputsamples_buffer_b);
841
842     return 0;
843 }
844
845 AVCodec alac_decoder = {
846     "alac",
847     CODEC_TYPE_AUDIO,
848     CODEC_ID_ALAC,
849     sizeof(ALACContext),
850     alac_decode_init,
851     NULL,
852     alac_decode_close,
853     alac_decode_frame,
854 };