alac: split element parsing into a separate function
[ffmpeg.git] / libavcodec / alac.c
1 /*
2  * ALAC (Apple Lossless Audio Codec) decoder
3  * Copyright (c) 2005 David Hammerton
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * ALAC (Apple Lossless Audio Codec) decoder
25  * @author 2005 David Hammerton
26  * @see http://crazney.net/programs/itunes/alac.html
27  *
28  * Note: This decoder expects a 36-byte QuickTime atom to be
29  * passed through the extradata[_size] fields. This atom is tacked onto
30  * the end of an 'alac' stsd atom and has the following format:
31  *
32  * 32bit  atom size
33  * 32bit  tag                  ("alac")
34  * 32bit  tag version          (0)
35  * 32bit  samples per frame    (used when not set explicitly in the frames)
36  *  8bit  compatible version   (0)
37  *  8bit  sample size
38  *  8bit  history mult         (40)
39  *  8bit  initial history      (14)
40  *  8bit  rice param limit     (10)
41  *  8bit  channels
42  * 16bit  maxRun               (255)
43  * 32bit  max coded frame size (0 means unknown)
44  * 32bit  average bitrate      (0 means unknown)
45  * 32bit  samplerate
46  */
47
48
49 #include "avcodec.h"
50 #include "get_bits.h"
51 #include "bytestream.h"
52 #include "unary.h"
53 #include "mathops.h"
54
55 #define ALAC_EXTRADATA_SIZE 36
56 #define MAX_CHANNELS 2
57
58 typedef struct {
59
60     AVCodecContext *avctx;
61     AVFrame frame;
62     GetBitContext gb;
63
64     int channels;
65
66     /* buffers */
67     int32_t *predict_error_buffer[MAX_CHANNELS];
68     int32_t *output_samples_buffer[MAX_CHANNELS];
69     int32_t *extra_bits_buffer[MAX_CHANNELS];
70
71     uint32_t max_samples_per_frame;
72     uint8_t  sample_size;
73     uint8_t  rice_history_mult;
74     uint8_t  rice_initial_history;
75     uint8_t  rice_limit;
76
77     int extra_bits;                         /**< number of extra bits beyond 16-bit */
78     int nb_samples;                         /**< number of samples in the current frame */
79 } ALACContext;
80
81 enum RawDataBlockType {
82     /* At the moment, only SCE, CPE, LFE, and END are recognized. */
83     TYPE_SCE,
84     TYPE_CPE,
85     TYPE_CCE,
86     TYPE_LFE,
87     TYPE_DSE,
88     TYPE_PCE,
89     TYPE_FIL,
90     TYPE_END
91 };
92
93 static inline unsigned int decode_scalar(GetBitContext *gb, int k,
94                                          int readsamplesize)
95 {
96     unsigned int x = get_unary_0_9(gb);
97
98     if (x > 8) { /* RICE THRESHOLD */
99         /* use alternative encoding */
100         x = get_bits_long(gb, readsamplesize);
101     } else if (k != 1) {
102         int extrabits = show_bits(gb, k);
103
104         /* multiply x by 2^k - 1, as part of their strange algorithm */
105         x = (x << k) - x;
106
107         if (extrabits > 1) {
108             x += extrabits - 1;
109             skip_bits(gb, k);
110         } else
111             skip_bits(gb, k - 1);
112     }
113     return x;
114 }
115
116 static void bastardized_rice_decompress(ALACContext *alac,
117                                         int32_t *output_buffer,
118                                         int output_size,
119                                         int readsamplesize,
120                                         int rice_history_mult)
121 {
122     int output_count;
123     unsigned int history = alac->rice_initial_history;
124     int sign_modifier = 0;
125
126     for (output_count = 0; output_count < output_size; output_count++) {
127         int k;
128         unsigned int x;
129
130         /* read k, that is bits as is */
131         k = av_log2((history >> 9) + 3);
132         k = FFMIN(k, alac->rice_limit);
133         x = decode_scalar(&alac->gb, k, readsamplesize);
134         x += sign_modifier;
135         sign_modifier = 0;
136
137         output_buffer[output_count] = (x >> 1) ^ -(x & 1);
138
139         /* now update the history */
140         if (x > 0xffff)
141             history = 0xffff;
142         else
143             history +=         x * rice_history_mult -
144                        ((history * rice_history_mult) >> 9);
145
146         /* special case: there may be compressed blocks of 0 */
147         if ((history < 128) && (output_count+1 < output_size)) {
148             int block_size;
149
150             k = 7 - av_log2(history) + ((history + 16) >> 6 /* / 64 */);
151             k = FFMIN(k, alac->rice_limit);
152
153             block_size = decode_scalar(&alac->gb, k, 16);
154
155             if (block_size > 0) {
156                 if(block_size >= output_size - output_count){
157                     av_log(alac->avctx, AV_LOG_ERROR, "invalid zero block size of %d %d %d\n", block_size, output_size, output_count);
158                     block_size= output_size - output_count - 1;
159                 }
160                 memset(&output_buffer[output_count + 1], 0,
161                        block_size * sizeof(*output_buffer));
162                 output_count += block_size;
163             }
164
165             if (block_size <= 0xffff)
166                 sign_modifier = 1;
167
168             history = 0;
169         }
170     }
171 }
172
173 static inline int sign_only(int v)
174 {
175     return v ? FFSIGN(v) : 0;
176 }
177
178 static void predictor_decompress_fir_adapt(int32_t *error_buffer,
179                                            int32_t *buffer_out,
180                                            int output_size,
181                                            int readsamplesize,
182                                            int16_t *predictor_coef_table,
183                                            int predictor_coef_num,
184                                            int predictor_quantitization)
185 {
186     int i;
187
188     /* first sample always copies */
189     *buffer_out = *error_buffer;
190
191     if (output_size <= 1)
192         return;
193
194     if (!predictor_coef_num) {
195         memcpy(&buffer_out[1], &error_buffer[1],
196                (output_size - 1) * sizeof(*buffer_out));
197         return;
198     }
199
200     if (predictor_coef_num == 31) {
201         /* simple 1st-order prediction */
202         for (i = 1; i < output_size; i++) {
203             buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],
204                                         readsamplesize);
205         }
206         return;
207     }
208
209     /* read warm-up samples */
210     for (i = 0; i < predictor_coef_num; i++) {
211         buffer_out[i + 1] = sign_extend(buffer_out[i] + error_buffer[i + 1],
212                                         readsamplesize);
213     }
214
215     /* NOTE: 4 and 8 are very common cases that could be optimized. */
216
217     /* general case */
218     for (i = predictor_coef_num; i < output_size - 1; i++) {
219         int j;
220         int val = 0;
221         int error_val = error_buffer[i + 1];
222         int error_sign;
223         int d = buffer_out[i - predictor_coef_num];
224
225         for (j = 0; j < predictor_coef_num; j++) {
226             val += (buffer_out[i - j] - d) *
227                    predictor_coef_table[j];
228         }
229
230         val = (val + (1 << (predictor_quantitization - 1))) >>
231               predictor_quantitization;
232         val += d + error_val;
233
234         buffer_out[i + 1] = sign_extend(val, readsamplesize);
235
236         /* adapt LPC coefficients */
237         error_sign = sign_only(error_val);
238         if (error_sign) {
239             for (j = predictor_coef_num - 1; j >= 0 && error_val * error_sign > 0; j--) {
240                 int sign;
241                 val  = d - buffer_out[i - j];
242                 sign = sign_only(val) * error_sign;
243                 predictor_coef_table[j] -= sign;
244                 val *= sign;
245                 error_val -= ((val >> predictor_quantitization) *
246                               (predictor_coef_num - j));
247             }
248         }
249     }
250 }
251
252 static void decorrelate_stereo(int32_t *buffer[MAX_CHANNELS],
253                                int numsamples, uint8_t interlacing_shift,
254                                uint8_t interlacing_leftweight)
255 {
256     int i;
257
258     for (i = 0; i < numsamples; i++) {
259         int32_t a, b;
260
261         a = buffer[0][i];
262         b = buffer[1][i];
263
264         a -= (b * interlacing_leftweight) >> interlacing_shift;
265         b += a;
266
267         buffer[0][i] = b;
268         buffer[1][i] = a;
269     }
270 }
271
272 static void append_extra_bits(int32_t *buffer[MAX_CHANNELS],
273                               int32_t *extra_bits_buffer[MAX_CHANNELS],
274                               int extra_bits, int numchannels, int numsamples)
275 {
276     int i, ch;
277
278     for (ch = 0; ch < numchannels; ch++)
279         for (i = 0; i < numsamples; i++)
280             buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];
281 }
282
283 static int decode_element(AVCodecContext *avctx, void *data, int ch_index,
284                           int channels)
285 {
286     ALACContext *alac = avctx->priv_data;
287     int hassize;
288     unsigned int readsamplesize;
289     int is_compressed;
290     uint8_t interlacing_shift;
291     uint8_t interlacing_leftweight;
292     uint32_t output_samples;
293     int i, ch, ret;
294
295     skip_bits(&alac->gb, 4);  /* element instance tag */
296     skip_bits(&alac->gb, 12); /* unused header bits */
297
298     /* the number of output samples is stored in the frame */
299     hassize = get_bits1(&alac->gb);
300
301     alac->extra_bits = get_bits(&alac->gb, 2) << 3;
302     readsamplesize = alac->sample_size - alac->extra_bits + channels - 1;
303     if (readsamplesize > 32) {
304         av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", readsamplesize);
305         return AVERROR_PATCHWELCOME;
306     }
307
308     /* whether the frame is compressed */
309     is_compressed = !get_bits1(&alac->gb);
310
311     if (hassize)
312         output_samples = get_bits_long(&alac->gb, 32);
313     else
314         output_samples = alac->max_samples_per_frame;
315     if (!output_samples || output_samples > alac->max_samples_per_frame) {
316         av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %d\n",
317                output_samples);
318         return AVERROR_INVALIDDATA;
319     }
320     if (!alac->nb_samples) {
321         /* get output buffer */
322         alac->frame.nb_samples = output_samples;
323         if ((ret = avctx->get_buffer(avctx, &alac->frame)) < 0) {
324             av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
325             return ret;
326         }
327         if (alac->sample_size > 16) {
328             for (ch = 0; ch < channels; ch++)
329                 alac->output_samples_buffer[ch] = (int32_t *)alac->frame.data[ch_index + ch];
330         }
331     } else if (output_samples != alac->nb_samples) {
332         av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %u != %d\n",
333                output_samples, alac->nb_samples);
334         return AVERROR_INVALIDDATA;
335     }
336     alac->nb_samples = output_samples;
337
338     if (is_compressed) {
339         int16_t predictor_coef_table[MAX_CHANNELS][32];
340         int predictor_coef_num[MAX_CHANNELS];
341         int prediction_type[MAX_CHANNELS];
342         int prediction_quantitization[MAX_CHANNELS];
343         int ricemodifier[MAX_CHANNELS];
344
345         interlacing_shift = get_bits(&alac->gb, 8);
346         interlacing_leftweight = get_bits(&alac->gb, 8);
347
348         for (ch = 0; ch < channels; ch++) {
349             prediction_type[ch] = get_bits(&alac->gb, 4);
350             prediction_quantitization[ch] = get_bits(&alac->gb, 4);
351
352             ricemodifier[ch] = get_bits(&alac->gb, 3);
353             predictor_coef_num[ch] = get_bits(&alac->gb, 5);
354
355             /* read the predictor table */
356             for (i = 0; i < predictor_coef_num[ch]; i++)
357                 predictor_coef_table[ch][i] = get_sbits(&alac->gb, 16);
358         }
359
360         if (alac->extra_bits) {
361             for (i = 0; i < alac->nb_samples; i++) {
362                 for (ch = 0; ch < channels; ch++)
363                     alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);
364             }
365         }
366         for (ch = 0; ch < channels; ch++) {
367             bastardized_rice_decompress(alac,
368                                         alac->predict_error_buffer[ch],
369                                         alac->nb_samples,
370                                         readsamplesize,
371                                         ricemodifier[ch] * alac->rice_history_mult / 4);
372
373             /* adaptive FIR filter */
374             if (prediction_type[ch] == 15) {
375                 /* Prediction type 15 runs the adaptive FIR twice.
376                  * The first pass uses the special-case coef_num = 31, while
377                  * the second pass uses the coefs from the bitstream.
378                  *
379                  * However, this prediction type is not currently used by the
380                  * reference encoder.
381                  */
382                 predictor_decompress_fir_adapt(alac->predict_error_buffer[ch],
383                                                alac->predict_error_buffer[ch],
384                                                alac->nb_samples, readsamplesize,
385                                                NULL, 31, 0);
386             } else if (prediction_type[ch] > 0) {
387                 av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",
388                        prediction_type[ch]);
389             }
390             predictor_decompress_fir_adapt(alac->predict_error_buffer[ch],
391                                            alac->output_samples_buffer[ch],
392                                            alac->nb_samples, readsamplesize,
393                                            predictor_coef_table[ch],
394                                            predictor_coef_num[ch],
395                                            prediction_quantitization[ch]);
396         }
397     } else {
398         /* not compressed, easy case */
399         for (i = 0; i < alac->nb_samples; i++) {
400             for (ch = 0; ch < channels; ch++) {
401                 alac->output_samples_buffer[ch][i] = get_sbits_long(&alac->gb, alac->sample_size);
402             }
403         }
404         alac->extra_bits = 0;
405         interlacing_shift = 0;
406         interlacing_leftweight = 0;
407     }
408
409     if (channels == 2 && interlacing_leftweight) {
410         decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples,
411                            interlacing_shift, interlacing_leftweight);
412     }
413
414     if (alac->extra_bits) {
415         append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer,
416                           alac->extra_bits, channels, alac->nb_samples);
417     }
418
419     switch(alac->sample_size) {
420     case 16: {
421         for (ch = 0; ch < channels; ch++) {
422             int16_t *outbuffer = (int16_t *)alac->frame.data[ch_index + ch];
423             for (i = 0; i < alac->nb_samples; i++)
424                 *outbuffer++ = alac->output_samples_buffer[ch][i];
425         }}
426         break;
427     case 24: {
428         for (ch = 0; ch < channels; ch++) {
429             for (i = 0; i < alac->nb_samples; i++)
430                 alac->output_samples_buffer[ch][i] <<= 8;
431         }}
432         break;
433     }
434
435     return 0;
436 }
437
438 static int alac_decode_frame(AVCodecContext *avctx, void *data,
439                              int *got_frame_ptr, AVPacket *avpkt)
440 {
441     ALACContext *alac = avctx->priv_data;
442     enum RawDataBlockType element;
443     int channels;
444     int ch, ret;
445
446     init_get_bits(&alac->gb, avpkt->data, avpkt->size * 8);
447
448     alac->nb_samples = 0;
449     ch = 0;
450     while (get_bits_left(&alac->gb)) {
451         element = get_bits(&alac->gb, 3);
452         if (element == TYPE_END)
453             break;
454         if (element > TYPE_CPE && element != TYPE_LFE) {
455             av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d", element);
456             return AVERROR_PATCHWELCOME;
457         }
458
459         channels = (element == TYPE_CPE) ? 2 : 1;
460         if (ch + channels > alac->channels) {
461             av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n");
462             return AVERROR_INVALIDDATA;
463         }
464
465         ret = decode_element(avctx, data, ch, channels);
466         if (ret < 0)
467             return ret;
468
469         ch += channels;
470     }
471
472     if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8)
473         av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n",
474                avpkt->size * 8 - get_bits_count(&alac->gb));
475
476     *got_frame_ptr   = 1;
477     *(AVFrame *)data = alac->frame;
478
479     return avpkt->size;
480 }
481
482 static av_cold int alac_decode_close(AVCodecContext *avctx)
483 {
484     ALACContext *alac = avctx->priv_data;
485
486     int ch;
487     for (ch = 0; ch < alac->channels; ch++) {
488         av_freep(&alac->predict_error_buffer[ch]);
489         if (alac->sample_size == 16)
490             av_freep(&alac->output_samples_buffer[ch]);
491         av_freep(&alac->extra_bits_buffer[ch]);
492     }
493
494     return 0;
495 }
496
497 static int allocate_buffers(ALACContext *alac)
498 {
499     int ch;
500     for (ch = 0; ch < alac->channels; ch++) {
501         int buf_size = alac->max_samples_per_frame * sizeof(int32_t);
502
503         FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch],
504                          buf_size, buf_alloc_fail);
505
506         if (alac->sample_size == 16) {
507             FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch],
508                              buf_size, buf_alloc_fail);
509         }
510
511         FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch],
512                          buf_size, buf_alloc_fail);
513     }
514     return 0;
515 buf_alloc_fail:
516     alac_decode_close(alac->avctx);
517     return AVERROR(ENOMEM);
518 }
519
520 static int alac_set_info(ALACContext *alac)
521 {
522     GetByteContext gb;
523
524     bytestream2_init(&gb, alac->avctx->extradata,
525                      alac->avctx->extradata_size);
526
527     bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4
528
529     alac->max_samples_per_frame = bytestream2_get_be32u(&gb);
530     if (!alac->max_samples_per_frame || alac->max_samples_per_frame > INT_MAX) {
531         av_log(alac->avctx, AV_LOG_ERROR, "max samples per frame invalid: %u\n",
532                alac->max_samples_per_frame);
533         return AVERROR_INVALIDDATA;
534     }
535     bytestream2_skipu(&gb, 1);  // compatible version
536     alac->sample_size          = bytestream2_get_byteu(&gb);
537     alac->rice_history_mult    = bytestream2_get_byteu(&gb);
538     alac->rice_initial_history = bytestream2_get_byteu(&gb);
539     alac->rice_limit           = bytestream2_get_byteu(&gb);
540     alac->channels             = bytestream2_get_byteu(&gb);
541     bytestream2_get_be16u(&gb); // maxRun
542     bytestream2_get_be32u(&gb); // max coded frame size
543     bytestream2_get_be32u(&gb); // average bitrate
544     bytestream2_get_be32u(&gb); // samplerate
545
546     return 0;
547 }
548
549 static av_cold int alac_decode_init(AVCodecContext * avctx)
550 {
551     int ret;
552     ALACContext *alac = avctx->priv_data;
553     alac->avctx = avctx;
554
555     /* initialize from the extradata */
556     if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
557         av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
558             ALAC_EXTRADATA_SIZE);
559         return -1;
560     }
561     if (alac_set_info(alac)) {
562         av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
563         return -1;
564     }
565
566     switch (alac->sample_size) {
567     case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
568              break;
569     case 24:
570     case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
571              break;
572     default: av_log_ask_for_sample(avctx, "Sample depth %d is not supported.\n",
573                                    alac->sample_size);
574              return AVERROR_PATCHWELCOME;
575     }
576
577     if (alac->channels < 1) {
578         av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");
579         alac->channels = avctx->channels;
580     } else {
581         if (alac->channels > MAX_CHANNELS)
582             alac->channels = avctx->channels;
583         else
584             avctx->channels = alac->channels;
585     }
586     if (avctx->channels > MAX_CHANNELS) {
587         av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",
588                avctx->channels);
589         return AVERROR_PATCHWELCOME;
590     }
591
592     if ((ret = allocate_buffers(alac)) < 0) {
593         av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");
594         return ret;
595     }
596
597     avcodec_get_frame_defaults(&alac->frame);
598     avctx->coded_frame = &alac->frame;
599
600     return 0;
601 }
602
603 AVCodec ff_alac_decoder = {
604     .name           = "alac",
605     .type           = AVMEDIA_TYPE_AUDIO,
606     .id             = CODEC_ID_ALAC,
607     .priv_data_size = sizeof(ALACContext),
608     .init           = alac_decode_init,
609     .close          = alac_decode_close,
610     .decode         = alac_decode_frame,
611     .capabilities   = CODEC_CAP_DR1,
612     .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
613 };