Fix a __warn_memset_zero_len gcc-4.4 warning.
[ffmpeg.git] / libavcodec / alsdec.c
1 /*
2  * MPEG-4 ALS decoder
3  * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 libavcodec/alsdec.c
24  * MPEG-4 ALS decoder
25  * @author Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
26  */
27
28
29 //#define DEBUG
30
31
32 #include "avcodec.h"
33 #include "get_bits.h"
34 #include "unary.h"
35 #include "mpeg4audio.h"
36 #include "bytestream.h"
37
38 #include "als_data.h"
39
40 enum RA_Flag {
41     RA_FLAG_NONE,
42     RA_FLAG_FRAMES,
43     RA_FLAG_HEADER
44 };
45
46
47 typedef struct {
48     uint32_t samples;         ///< number of samples, 0xFFFFFFFF if unknown
49     int resolution;           ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
50     int floating;             ///< 1 = IEEE 32-bit floating-point, 0 = integer
51     int frame_length;         ///< frame length for each frame (last frame may differ)
52     int ra_distance;          ///< distance between RA frames (in frames, 0...255)
53     enum RA_Flag ra_flag;     ///< indicates where the size of ra units is stored
54     int adapt_order;          ///< adaptive order: 1 = on, 0 = off
55     int coef_table;           ///< table index of Rice code parameters
56     int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
57     int max_order;            ///< maximum prediction order (0..1023)
58     int block_switching;      ///< number of block switching levels
59     int bgmc;                 ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
60     int sb_part;              ///< sub-block partition
61     int joint_stereo;         ///< joint stereo: 1 = on, 0 = off
62     int mc_coding;            ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
63     int chan_config;          ///< indicates that a chan_config_info field is present
64     int chan_sort;            ///< channel rearrangement: 1 = on, 0 = off
65     int rlslms;               ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
66     int chan_config_info;     ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
67     int *chan_pos;            ///< original channel positions
68     uint32_t header_size;     ///< header size of original audio file in bytes, provided for debugging
69     uint32_t trailer_size;    ///< trailer size of original audio file in bytes, provided for debugging
70 } ALSSpecificConfig;
71
72
73 typedef struct {
74     AVCodecContext *avctx;
75     ALSSpecificConfig sconf;
76     GetBitContext gb;
77     unsigned int cur_frame_length;  ///< length of the current frame to decode
78     unsigned int frame_id;          ///< the frame ID / number of the current frame
79     unsigned int js_switch;         ///< if true, joint-stereo decoding is enforced
80     unsigned int num_blocks;        ///< number of blocks used in the current frame
81     int32_t *quant_cof;             ///< quantized parcor coefficients
82     int32_t *lpc_cof;               ///< coefficients of the direct form prediction filter
83     int32_t *prev_raw_samples;      ///< contains unshifted raw samples from the previous block
84     int32_t **raw_samples;          ///< decoded raw samples for each channel
85     int32_t *raw_buffer;            ///< contains all decoded raw samples including carryover samples
86 } ALSDecContext;
87
88
89 static av_cold void dprint_specific_config(ALSDecContext *ctx)
90 {
91 #ifdef DEBUG
92     AVCodecContext *avctx    = ctx->avctx;
93     ALSSpecificConfig *sconf = &ctx->sconf;
94
95     dprintf(avctx, "resolution = %i\n",           sconf->resolution);
96     dprintf(avctx, "floating = %i\n",             sconf->floating);
97     dprintf(avctx, "frame_length = %i\n",         sconf->frame_length);
98     dprintf(avctx, "ra_distance = %i\n",          sconf->ra_distance);
99     dprintf(avctx, "ra_flag = %i\n",              sconf->ra_flag);
100     dprintf(avctx, "adapt_order = %i\n",          sconf->adapt_order);
101     dprintf(avctx, "coef_table = %i\n",           sconf->coef_table);
102     dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
103     dprintf(avctx, "max_order = %i\n",            sconf->max_order);
104     dprintf(avctx, "block_switching = %i\n",      sconf->block_switching);
105     dprintf(avctx, "bgmc = %i\n",                 sconf->bgmc);
106     dprintf(avctx, "sb_part = %i\n",              sconf->sb_part);
107     dprintf(avctx, "joint_stereo = %i\n",         sconf->joint_stereo);
108     dprintf(avctx, "mc_coding = %i\n",            sconf->mc_coding);
109     dprintf(avctx, "chan_config = %i\n",          sconf->chan_config);
110     dprintf(avctx, "chan_sort = %i\n",            sconf->chan_sort);
111     dprintf(avctx, "RLSLMS = %i\n",               sconf->rlslms);
112     dprintf(avctx, "chan_config_info = %i\n",     sconf->chan_config_info);
113     dprintf(avctx, "header_size = %i\n",          sconf->header_size);
114     dprintf(avctx, "trailer_size = %i\n",         sconf->trailer_size);
115 #endif
116 }
117
118
119 /** Reads an ALSSpecificConfig from a buffer into the output struct.
120  */
121 static av_cold int read_specific_config(ALSDecContext *ctx)
122 {
123     GetBitContext gb;
124     uint64_t ht_size;
125     int i, config_offset, crc_enabled;
126     MPEG4AudioConfig m4ac;
127     ALSSpecificConfig *sconf = &ctx->sconf;
128     AVCodecContext *avctx    = ctx->avctx;
129     uint32_t als_id;
130
131     init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);
132
133     config_offset = ff_mpeg4audio_get_config(&m4ac, avctx->extradata,
134                                              avctx->extradata_size);
135
136     if (config_offset < 0)
137         return -1;
138
139     skip_bits_long(&gb, config_offset);
140
141     if (get_bits_left(&gb) < (30 << 3))
142         return -1;
143
144     // read the fixed items
145     als_id                      = get_bits_long(&gb, 32);
146     avctx->sample_rate          = m4ac.sample_rate;
147     skip_bits_long(&gb, 32); // sample rate already known
148     sconf->samples              = get_bits_long(&gb, 32);
149     avctx->channels             = m4ac.channels;
150     skip_bits(&gb, 16);      // number of channels already knwon
151     skip_bits(&gb, 3);       // skip file_type
152     sconf->resolution           = get_bits(&gb, 3);
153     sconf->floating             = get_bits1(&gb);
154     skip_bits1(&gb);         // skip msb_first
155     sconf->frame_length         = get_bits(&gb, 16) + 1;
156     sconf->ra_distance          = get_bits(&gb, 8);
157     sconf->ra_flag              = get_bits(&gb, 2);
158     sconf->adapt_order          = get_bits1(&gb);
159     sconf->coef_table           = get_bits(&gb, 2);
160     sconf->long_term_prediction = get_bits1(&gb);
161     sconf->max_order            = get_bits(&gb, 10);
162     sconf->block_switching      = get_bits(&gb, 2);
163     sconf->bgmc                 = get_bits1(&gb);
164     sconf->sb_part              = get_bits1(&gb);
165     sconf->joint_stereo         = get_bits1(&gb);
166     sconf->mc_coding            = get_bits1(&gb);
167     sconf->chan_config          = get_bits1(&gb);
168     sconf->chan_sort            = get_bits1(&gb);
169     crc_enabled                 = get_bits1(&gb);
170     sconf->rlslms               = get_bits1(&gb);
171     skip_bits(&gb, 5);       // skip 5 reserved bits
172     skip_bits1(&gb);         // skip aux_data_enabled
173
174
175     // check for ALSSpecificConfig struct
176     if (als_id != MKBETAG('A','L','S','\0'))
177         return -1;
178
179     ctx->cur_frame_length = sconf->frame_length;
180
181     // allocate quantized parcor coefficient buffer
182     if (!(ctx->quant_cof = av_malloc(sizeof(*ctx->quant_cof) * sconf->max_order)) ||
183         !(ctx->lpc_cof   = av_malloc(sizeof(*ctx->lpc_cof)   * sconf->max_order))) {
184         av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
185         return AVERROR(ENOMEM);
186     }
187
188     // read channel config
189     if (sconf->chan_config)
190         sconf->chan_config_info = get_bits(&gb, 16);
191     // TODO: use this to set avctx->channel_layout
192
193
194     // read channel sorting
195     if (sconf->chan_sort && avctx->channels > 1) {
196         int chan_pos_bits = av_ceil_log2(avctx->channels);
197         int bits_needed  = avctx->channels * chan_pos_bits + 7;
198         if (get_bits_left(&gb) < bits_needed)
199             return -1;
200
201         if (!(sconf->chan_pos = av_malloc(avctx->channels * sizeof(*sconf->chan_pos))))
202             return AVERROR(ENOMEM);
203
204         for (i = 0; i < avctx->channels; i++)
205             sconf->chan_pos[i] = get_bits(&gb, chan_pos_bits);
206
207         align_get_bits(&gb);
208         // TODO: use this to actually do channel sorting
209     } else {
210         sconf->chan_sort = 0;
211     }
212
213
214     // read fixed header and trailer sizes,
215     // if size = 0xFFFFFFFF then there is no data field!
216     if (get_bits_left(&gb) < 64)
217         return -1;
218
219     sconf->header_size  = get_bits_long(&gb, 32);
220     sconf->trailer_size = get_bits_long(&gb, 32);
221     if (sconf->header_size  == 0xFFFFFFFF)
222         sconf->header_size  = 0;
223     if (sconf->trailer_size == 0xFFFFFFFF)
224         sconf->trailer_size = 0;
225
226     ht_size = ((int64_t)(sconf->header_size) + (int64_t)(sconf->trailer_size)) << 3;
227
228
229     // skip the header and trailer data
230     if (get_bits_left(&gb) < ht_size)
231         return -1;
232
233     if (ht_size > INT32_MAX)
234         return -1;
235
236     skip_bits_long(&gb, ht_size);
237
238
239     // skip the crc data
240     if (crc_enabled) {
241         if (get_bits_left(&gb) < 32)
242             return -1;
243
244         skip_bits_long(&gb, 32);
245     }
246
247
248     // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
249
250     dprint_specific_config(ctx);
251
252     return 0;
253 }
254
255
256 /** Checks the ALSSpecificConfig for unsupported features.
257  */
258 static int check_specific_config(ALSDecContext *ctx)
259 {
260     ALSSpecificConfig *sconf = &ctx->sconf;
261     int error = 0;
262
263     // report unsupported feature and set error value
264     #define MISSING_ERR(cond, str, errval)              \
265     {                                                   \
266         if (cond) {                                     \
267             av_log_missing_feature(ctx->avctx, str, 0); \
268             error = errval;                             \
269         }                                               \
270     }
271
272     MISSING_ERR(sconf->floating,             "Floating point decoding",     -1);
273     MISSING_ERR(sconf->long_term_prediction, "Long-term prediction",        -1);
274     MISSING_ERR(sconf->bgmc,                 "BGMC entropy decoding",       -1);
275     MISSING_ERR(sconf->mc_coding,            "Multi-channel correlation",   -1);
276     MISSING_ERR(sconf->rlslms,               "Adaptive RLS-LMS prediction", -1);
277     MISSING_ERR(sconf->chan_sort,            "Channel sorting",              0);
278
279     return error;
280 }
281
282
283 /** Parses the bs_info field to extract the block partitioning used in
284  *  block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
285  */
286 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
287                           unsigned int div, unsigned int **div_blocks,
288                           unsigned int *num_blocks)
289 {
290     if (n < 31 && ((bs_info << n) & 0x40000000)) {
291         // if the level is valid and the investigated bit n is set
292         // then recursively check both children at bits (2n+1) and (2n+2)
293         n   *= 2;
294         div += 1;
295         parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
296         parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
297     } else {
298         // else the bit is not set or the last level has been reached
299         // (bit implicitly not set)
300         **div_blocks = div;
301         (*div_blocks)++;
302         (*num_blocks)++;
303     }
304 }
305
306
307 /** Reads and decodes a Rice codeword.
308  */
309 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
310 {
311     int max = gb->size_in_bits - get_bits_count(gb) - k;
312     int q   = get_unary(gb, 0, max);
313     int r   = k ? get_bits1(gb) : !(q & 1);
314
315     if (k > 1) {
316         q <<= (k - 1);
317         q  += get_bits_long(gb, k - 1);
318     } else if (!k) {
319         q >>= 1;
320     }
321     return r ? q : ~q;
322 }
323
324
325 /** Converts PARCOR coefficient k to direct filter coefficient.
326  */
327 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
328 {
329     int i, j;
330
331     for (i = 0, j = k - 1; i < j; i++, j--) {
332         int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
333         cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
334         cof[i]  += tmp1;
335     }
336     if (i == j)
337         cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
338
339     cof[k] = par[k];
340 }
341
342
343 /** Reads block switching field if necessary and sets actual block sizes.
344  *  Also assures that the block sizes of the last frame correspond to the
345  *  actual number of samples.
346  */
347 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
348                             uint32_t *bs_info)
349 {
350     ALSSpecificConfig *sconf     = &ctx->sconf;
351     GetBitContext *gb            = &ctx->gb;
352     unsigned int *ptr_div_blocks = div_blocks;
353     unsigned int b;
354
355     if (sconf->block_switching) {
356         unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
357         *bs_info = get_bits_long(gb, bs_info_len);
358         *bs_info <<= (32 - bs_info_len);
359     }
360
361     ctx->num_blocks = 0;
362     parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
363
364     // The last frame may have an overdetermined block structure given in
365     // the bitstream. In that case the defined block structure would need
366     // more samples than available to be consistent.
367     // The block structure is actually used but the block sizes are adapted
368     // to fit the actual number of available samples.
369     // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
370     // This results in the actual block sizes:    2 2 1 0.
371     // This is not specified in 14496-3 but actually done by the reference
372     // codec RM22 revision 2.
373     // This appears to happen in case of an odd number of samples in the last
374     // frame which is actually not allowed by the block length switching part
375     // of 14496-3.
376     // The ALS conformance files feature an odd number of samples in the last
377     // frame.
378
379     for (b = 0; b < ctx->num_blocks; b++)
380         div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
381
382     if (ctx->cur_frame_length != ctx->sconf.frame_length) {
383         unsigned int remaining = ctx->cur_frame_length;
384
385         for (b = 0; b < ctx->num_blocks; b++) {
386             if (remaining < div_blocks[b]) {
387                 div_blocks[b] = remaining;
388                 ctx->num_blocks = b + 1;
389                 break;
390             }
391
392             remaining -= div_blocks[b];
393         }
394     }
395 }
396
397
398 /** Reads the block data for a constant block
399  */
400 static void read_const_block(ALSDecContext *ctx, int32_t *raw_samples,
401                              unsigned int block_length, unsigned int *js_blocks)
402 {
403     ALSSpecificConfig *sconf = &ctx->sconf;
404     AVCodecContext *avctx    = ctx->avctx;
405     GetBitContext *gb        = &ctx->gb;
406     int32_t const_val        = 0;
407     unsigned int const_block, k;
408
409     const_block  = get_bits1(gb);    // 1 = constant value, 0 = zero block (silence)
410     *js_blocks   = get_bits1(gb);
411
412     // skip 5 reserved bits
413     skip_bits(gb, 5);
414
415     if (const_block) {
416         unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
417         const_val = get_sbits_long(gb, const_val_bits);
418     }
419
420     // write raw samples into buffer
421     for (k = 0; k < block_length; k++)
422         raw_samples[k] = const_val;
423 }
424
425
426 /** Reads the block data for a non-constant block
427  */
428 static int read_var_block(ALSDecContext *ctx, unsigned int ra_block,
429                           int32_t *raw_samples, unsigned int block_length,
430                           unsigned int *js_blocks, int32_t *raw_other,
431                           unsigned int *shift_lsbs)
432 {
433     ALSSpecificConfig *sconf = &ctx->sconf;
434     AVCodecContext *avctx    = ctx->avctx;
435     GetBitContext *gb        = &ctx->gb;
436     unsigned int k;
437     unsigned int s[8];
438     unsigned int sub_blocks, log2_sub_blocks, sb_length;
439     unsigned int opt_order  = 1;
440     int32_t      *quant_cof = ctx->quant_cof;
441     int32_t      *lpc_cof   = ctx->lpc_cof;
442     unsigned int start      = 0;
443     int          smp        = 0;
444     int          sb, store_prev_samples;
445     int64_t      y;
446
447     *js_blocks  = get_bits1(gb);
448
449     // determine the number of subblocks for entropy decoding
450     if (!sconf->bgmc && !sconf->sb_part) {
451         log2_sub_blocks = 0;
452     } else {
453         if (sconf->bgmc && sconf->sb_part)
454             log2_sub_blocks = get_bits(gb, 2);
455         else
456             log2_sub_blocks = 2 * get_bits1(gb);
457     }
458
459     sub_blocks = 1 << log2_sub_blocks;
460
461     // do not continue in case of a damaged stream since
462     // block_length must be evenly divisible by sub_blocks
463     if (block_length & (sub_blocks - 1)) {
464         av_log(avctx, AV_LOG_WARNING,
465                "Block length is not evenly divisible by the number of subblocks.\n");
466         return -1;
467     }
468
469     sb_length = block_length >> log2_sub_blocks;
470
471
472     if (sconf->bgmc) {
473         // TODO: BGMC mode
474     } else {
475         s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
476         for (k = 1; k < sub_blocks; k++)
477             s[k] = s[k - 1] + decode_rice(gb, 0);
478     }
479
480     if (get_bits1(gb))
481         *shift_lsbs = get_bits(gb, 4) + 1;
482
483     store_prev_samples = (*js_blocks && raw_other) || *shift_lsbs;
484
485
486     if (!sconf->rlslms) {
487         if (sconf->adapt_order) {
488             int opt_order_length = av_ceil_log2(av_clip((block_length >> 3) - 1,
489                                                 2, sconf->max_order + 1));
490             opt_order            = get_bits(gb, opt_order_length);
491         } else {
492             opt_order = sconf->max_order;
493         }
494
495         if (opt_order) {
496             int add_base;
497
498             if (sconf->coef_table == 3) {
499                 add_base = 0x7F;
500
501                 // read coefficient 0
502                 quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
503
504                 // read coefficient 1
505                 if (opt_order > 1)
506                     quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
507
508                 // read coefficients 2 to opt_order
509                 for (k = 2; k < opt_order; k++)
510                     quant_cof[k] = get_bits(gb, 7);
511             } else {
512                 int k_max;
513                 add_base = 1;
514
515                 // read coefficient 0 to 19
516                 k_max = FFMIN(opt_order, 20);
517                 for (k = 0; k < k_max; k++) {
518                     int rice_param = parcor_rice_table[sconf->coef_table][k][1];
519                     int offset     = parcor_rice_table[sconf->coef_table][k][0];
520                     quant_cof[k] = decode_rice(gb, rice_param) + offset;
521                 }
522
523                 // read coefficients 20 to 126
524                 k_max = FFMIN(opt_order, 127);
525                 for (; k < k_max; k++)
526                     quant_cof[k] = decode_rice(gb, 2) + (k & 1);
527
528                 // read coefficients 127 to opt_order
529                 for (; k < opt_order; k++)
530                     quant_cof[k] = decode_rice(gb, 1);
531
532                 quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
533
534                 if (opt_order > 1)
535                     quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
536             }
537
538             for (k = 2; k < opt_order; k++)
539                 quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
540         }
541     }
542
543     // TODO: LTP mode
544
545     // read first value and residuals in case of a random access block
546     if (ra_block) {
547         if (opt_order)
548             raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
549         if (opt_order > 1)
550             raw_samples[1] = decode_rice(gb, s[0] + 3);
551         if (opt_order > 2)
552             raw_samples[2] = decode_rice(gb, s[0] + 1);
553
554         start = FFMIN(opt_order, 3);
555     }
556
557     // read all residuals
558     if (sconf->bgmc) {
559         // TODO: BGMC mode
560     } else {
561         int32_t *current_res = raw_samples + start;
562
563         for (sb = 0; sb < sub_blocks; sb++, start = 0)
564             for (; start < sb_length; start++)
565                 *current_res++ = decode_rice(gb, s[sb]);
566      }
567
568     // reconstruct all samples from residuals
569     if (ra_block) {
570         for (smp = 0; smp < opt_order; smp++) {
571             y = 1 << 19;
572
573             for (sb = 0; sb < smp; sb++)
574                 y += MUL64(lpc_cof[sb],raw_samples[smp - (sb + 1)]);
575
576             raw_samples[smp] -= y >> 20;
577             parcor_to_lpc(smp, quant_cof, lpc_cof);
578         }
579     } else {
580         for (k = 0; k < opt_order; k++)
581             parcor_to_lpc(k, quant_cof, lpc_cof);
582
583         // store previous samples in case that they have to be altered
584         if (store_prev_samples)
585             memcpy(ctx->prev_raw_samples, raw_samples - sconf->max_order,
586                    sizeof(*ctx->prev_raw_samples) * sconf->max_order);
587
588         // reconstruct difference signal for prediction (joint-stereo)
589         if (*js_blocks && raw_other) {
590             int32_t *left, *right;
591
592             if (raw_other > raw_samples) {          // D = R - L
593                 left  = raw_samples;
594                 right = raw_other;
595             } else {                                // D = R - L
596                 left  = raw_other;
597                 right = raw_samples;
598             }
599
600             for (sb = -1; sb >= -sconf->max_order; sb--)
601                 raw_samples[sb] = right[sb] - left[sb];
602         }
603
604         // reconstruct shifted signal
605         if (*shift_lsbs)
606             for (sb = -1; sb >= -sconf->max_order; sb--)
607                 raw_samples[sb] >>= *shift_lsbs;
608     }
609
610     // reconstruct raw samples
611     for (; smp < block_length; smp++) {
612         y = 1 << 19;
613
614         for (sb = 0; sb < opt_order; sb++)
615             y += MUL64(lpc_cof[sb],raw_samples[smp - (sb + 1)]);
616
617         raw_samples[smp] -= y >> 20;
618     }
619
620     // restore previous samples in case that they have been altered
621     if (store_prev_samples)
622         memcpy(raw_samples - sconf->max_order, ctx->prev_raw_samples,
623                sizeof(*raw_samples) * sconf->max_order);
624
625     return 0;
626 }
627
628
629 /** Reads the block data.
630  */
631 static int read_block_data(ALSDecContext *ctx, unsigned int ra_block,
632                            int32_t *raw_samples, unsigned int block_length,
633                            unsigned int *js_blocks, int32_t *raw_other)
634 {
635     ALSSpecificConfig *sconf = &ctx->sconf;
636     GetBitContext *gb        = &ctx->gb;
637     unsigned int shift_lsbs  = 0;
638     unsigned int k;
639
640     // read block type flag and read the samples accordingly
641     if (get_bits1(gb)) {
642         if (read_var_block(ctx, ra_block, raw_samples, block_length, js_blocks,
643                            raw_other, &shift_lsbs))
644             return -1;
645     } else {
646         read_const_block(ctx, raw_samples, block_length, js_blocks);
647     }
648
649     // TODO: read RLSLMS extension data
650
651     if (!sconf->mc_coding || ctx->js_switch)
652         align_get_bits(gb);
653
654     if (shift_lsbs)
655         for (k = 0; k < block_length; k++)
656             raw_samples[k] <<= shift_lsbs;
657
658     return 0;
659 }
660
661
662 /** Computes the number of samples left to decode for the current frame and
663  *  sets these samples to zero.
664  */
665 static void zero_remaining(unsigned int b, unsigned int b_max,
666                            const unsigned int *div_blocks, int32_t *buf)
667 {
668     unsigned int count = 0;
669
670     while (b < b_max)
671         count += div_blocks[b];
672
673     if (count)
674     memset(buf, 0, sizeof(*buf) * count);
675 }
676
677
678 /** Decodes blocks independently.
679  */
680 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
681                              unsigned int c, const unsigned int *div_blocks,
682                              unsigned int *js_blocks)
683 {
684     int32_t *raw_sample;
685     unsigned int b;
686     raw_sample = ctx->raw_samples[c];
687
688     for (b = 0; b < ctx->num_blocks; b++) {
689         if (read_block_data(ctx, ra_frame, raw_sample,
690                             div_blocks[b], &js_blocks[0], NULL)) {
691             // damaged block, write zero for the rest of the frame
692             zero_remaining(b, ctx->num_blocks, div_blocks, raw_sample);
693             return -1;
694         }
695         raw_sample += div_blocks[b];
696         ra_frame    = 0;
697     }
698
699     return 0;
700 }
701
702
703 /** Decodes blocks dependently.
704  */
705 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
706                          unsigned int c, const unsigned int *div_blocks,
707                          unsigned int *js_blocks)
708 {
709     ALSSpecificConfig *sconf = &ctx->sconf;
710     unsigned int offset = 0;
711     int32_t *raw_samples_R;
712     int32_t *raw_samples_L;
713     unsigned int b;
714
715     // decode all blocks
716     for (b = 0; b < ctx->num_blocks; b++) {
717         unsigned int s;
718         raw_samples_L = ctx->raw_samples[c    ] + offset;
719         raw_samples_R = ctx->raw_samples[c + 1] + offset;
720         if (read_block_data(ctx, ra_frame, raw_samples_L, div_blocks[b],
721                             &js_blocks[0], raw_samples_R) ||
722             read_block_data(ctx, ra_frame, raw_samples_R, div_blocks[b],
723                             &js_blocks[1], raw_samples_L)) {
724             // damaged block, write zero for the rest of the frame
725             zero_remaining(b, ctx->num_blocks, div_blocks, raw_samples_L);
726             zero_remaining(b, ctx->num_blocks, div_blocks, raw_samples_R);
727             return -1;
728         }
729
730         // reconstruct joint-stereo blocks
731         if (js_blocks[0]) {
732             if (js_blocks[1])
733                 av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n");
734
735             for (s = 0; s < div_blocks[b]; s++)
736                 raw_samples_L[s] = raw_samples_R[s] - raw_samples_L[s];
737         } else if (js_blocks[1]) {
738             for (s = 0; s < div_blocks[b]; s++)
739                 raw_samples_R[s] = raw_samples_R[s] + raw_samples_L[s];
740         }
741
742         offset  += div_blocks[b];
743         ra_frame = 0;
744     }
745
746     // store carryover raw samples,
747     // the others channel raw samples are stored by the calling function.
748     memmove(ctx->raw_samples[c] - sconf->max_order,
749             ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
750             sizeof(*ctx->raw_samples[c]) * sconf->max_order);
751
752     return 0;
753 }
754
755
756 /** Reads the frame data.
757  */
758 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
759 {
760     ALSSpecificConfig *sconf = &ctx->sconf;
761     AVCodecContext *avctx    = ctx->avctx;
762     GetBitContext *gb = &ctx->gb;
763     unsigned int div_blocks[32];                ///< block sizes.
764     unsigned int c;
765     unsigned int js_blocks[2];
766
767     uint32_t bs_info = 0;
768
769     // skip the size of the ra unit if present in the frame
770     if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
771         skip_bits_long(gb, 32);
772
773     if (sconf->mc_coding && sconf->joint_stereo) {
774         ctx->js_switch = get_bits1(gb);
775         align_get_bits(gb);
776     }
777
778     if (!sconf->mc_coding || ctx->js_switch) {
779         int independent_bs = !sconf->joint_stereo;
780
781         for (c = 0; c < avctx->channels; c++) {
782             js_blocks[0] = 0;
783             js_blocks[1] = 0;
784
785             get_block_sizes(ctx, div_blocks, &bs_info);
786
787             // if joint_stereo and block_switching is set, independent decoding
788             // is signaled via the first bit of bs_info
789             if (sconf->joint_stereo && sconf->block_switching)
790                 if (bs_info >> 31)
791                     independent_bs = 2;
792
793             // if this is the last channel, it has to be decoded independently
794             if (c == avctx->channels - 1)
795                 independent_bs = 1;
796
797             if (independent_bs) {
798                 if (decode_blocks_ind(ctx, ra_frame, c, div_blocks, js_blocks))
799                     return -1;
800
801                 independent_bs--;
802             } else {
803                 if (decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks))
804                     return -1;
805
806                 c++;
807             }
808
809             // store carryover raw samples
810             memmove(ctx->raw_samples[c] - sconf->max_order,
811                     ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
812                     sizeof(*ctx->raw_samples[c]) * sconf->max_order);
813         }
814     } else { // multi-channel coding
815         get_block_sizes(ctx, div_blocks, &bs_info);
816
817         // TODO: multi channel coding might use a temporary buffer instead as
818         //       the actual channel is not known when read_block-data is called
819         if (decode_blocks_ind(ctx, ra_frame, 0, div_blocks, js_blocks))
820             return -1;
821         // TODO: read_channel_data
822     }
823
824     // TODO: read_diff_float_data
825
826     return 0;
827 }
828
829
830 /** Decodes an ALS frame.
831  */
832 static int decode_frame(AVCodecContext *avctx,
833                         void *data, int *data_size,
834                         AVPacket *avpkt)
835 {
836     ALSDecContext *ctx       = avctx->priv_data;
837     ALSSpecificConfig *sconf = &ctx->sconf;
838     const uint8_t *buffer    = avpkt->data;
839     int buffer_size          = avpkt->size;
840     int invalid_frame, size;
841     unsigned int c, sample, ra_frame, bytes_read, shift;
842
843     init_get_bits(&ctx->gb, buffer, buffer_size * 8);
844
845     // In the case that the distance between random access frames is set to zero
846     // (sconf->ra_distance == 0) no frame is treated as a random access frame.
847     // For the first frame, if prediction is used, all samples used from the
848     // previous frame are assumed to be zero.
849     ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
850
851     // the last frame to decode might have a different length
852     if (sconf->samples != 0xFFFFFFFF)
853         ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
854                                       sconf->frame_length);
855     else
856         ctx->cur_frame_length = sconf->frame_length;
857
858     // decode the frame data
859     if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0))
860         av_log(ctx->avctx, AV_LOG_WARNING,
861                "Reading frame data failed. Skipping RA unit.\n");
862
863     ctx->frame_id++;
864
865     // check for size of decoded data
866     size = ctx->cur_frame_length * avctx->channels *
867            (av_get_bits_per_sample_format(avctx->sample_fmt) >> 3);
868
869     if (size > *data_size) {
870         av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
871         return -1;
872     }
873
874     *data_size = size;
875
876     // transform decoded frame into output format
877     #define INTERLEAVE_OUTPUT(bps)                                 \
878     {                                                              \
879         int##bps##_t *dest = (int##bps##_t*) data;                 \
880         shift = bps - ctx->avctx->bits_per_raw_sample;             \
881         for (sample = 0; sample < ctx->cur_frame_length; sample++) \
882             for (c = 0; c < avctx->channels; c++)                  \
883                 *dest++ = ctx->raw_samples[c][sample] << shift;    \
884     }
885
886     if (ctx->avctx->bits_per_raw_sample <= 16) {
887         INTERLEAVE_OUTPUT(16)
888     } else {
889         INTERLEAVE_OUTPUT(32)
890     }
891
892     bytes_read = invalid_frame ? buffer_size :
893                                  (get_bits_count(&ctx->gb) + 7) >> 3;
894
895     return bytes_read;
896 }
897
898
899 /** Uninitializes the ALS decoder.
900  */
901 static av_cold int decode_end(AVCodecContext *avctx)
902 {
903     ALSDecContext *ctx = avctx->priv_data;
904
905     av_freep(&ctx->sconf.chan_pos);
906
907     av_freep(&ctx->quant_cof);
908     av_freep(&ctx->lpc_cof);
909     av_freep(&ctx->prev_raw_samples);
910     av_freep(&ctx->raw_samples);
911     av_freep(&ctx->raw_buffer);
912
913     return 0;
914 }
915
916
917 /** Initializes the ALS decoder.
918  */
919 static av_cold int decode_init(AVCodecContext *avctx)
920 {
921     unsigned int c;
922     unsigned int channel_size;
923     ALSDecContext *ctx = avctx->priv_data;
924     ALSSpecificConfig *sconf = &ctx->sconf;
925     ctx->avctx = avctx;
926
927     if (!avctx->extradata) {
928         av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
929         return -1;
930     }
931
932     if (read_specific_config(ctx)) {
933         av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
934         decode_end(avctx);
935         return -1;
936     }
937
938     if (check_specific_config(ctx)) {
939         decode_end(avctx);
940         return -1;
941     }
942
943     if (sconf->floating) {
944         avctx->sample_fmt          = SAMPLE_FMT_FLT;
945         avctx->bits_per_raw_sample = 32;
946     } else {
947         avctx->sample_fmt          = sconf->resolution > 1
948                                      ? SAMPLE_FMT_S32 : SAMPLE_FMT_S16;
949         avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
950     }
951
952     avctx->frame_size = sconf->frame_length;
953     channel_size      = sconf->frame_length + sconf->max_order;
954
955     ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order);
956     ctx->raw_buffer       = av_mallocz(sizeof(*ctx->     raw_buffer)  * avctx->channels * channel_size);
957     ctx->raw_samples      = av_malloc (sizeof(*ctx->     raw_samples) * avctx->channels);
958
959     // allocate previous raw sample buffer
960     if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
961         av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
962         decode_end(avctx);
963         return AVERROR(ENOMEM);
964     }
965
966     // assign raw samples buffers
967     ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
968     for (c = 1; c < avctx->channels; c++)
969         ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
970
971     return 0;
972 }
973
974
975 /** Flushes (resets) the frame ID after seeking.
976  */
977 static av_cold void flush(AVCodecContext *avctx)
978 {
979     ALSDecContext *ctx = avctx->priv_data;
980
981     ctx->frame_id = 0;
982 }
983
984
985 AVCodec als_decoder = {
986     "als",
987     CODEC_TYPE_AUDIO,
988     CODEC_ID_MP4ALS,
989     sizeof(ALSDecContext),
990     decode_init,
991     NULL,
992     decode_end,
993     decode_frame,
994     .flush = flush,
995     .capabilities = CODEC_CAP_SUBFRAMES,
996     .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
997 };
998