Add multi-channel correlation support for ALS.
[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 <stdint.h>
39
40 /** Rice parameters and corresponding index offsets for decoding the
41  *  indices of scaled PARCOR values. The table choosen is set globally
42  *  by the encoder and stored in ALSSpecificConfig.
43  */
44 static const int8_t parcor_rice_table[3][20][2] = {
45     { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
46       { 12, 3}, { -7, 3}, {  9, 3}, { -5, 3}, {  6, 3},
47       { -4, 3}, {  3, 3}, { -3, 2}, {  3, 2}, { -2, 2},
48       {  3, 2}, { -1, 2}, {  2, 2}, { -1, 2}, {  2, 2} },
49     { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
50       { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
51       {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
52       {  7, 3}, { -4, 4}, {  3, 3}, { -1, 3}, {  1, 3} },
53     { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
54       { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
55       {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
56       {  3, 3}, {  0, 3}, { -1, 3}, {  2, 3}, { -1, 2} }
57 };
58
59
60 /** Scaled PARCOR values used for the first two PARCOR coefficients.
61  *  To be indexed by the Rice coded indices.
62  *  Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
63  *  Actual values are divided by 32 in order to be stored in 16 bits.
64  */
65 static const int16_t parcor_scaled_values[] = {
66     -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
67     -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
68     -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
69     -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
70     -1013728 / 32, -1009376 / 32, -1004768 / 32,  -999904 / 32,
71      -994784 / 32,  -989408 / 32,  -983776 / 32,  -977888 / 32,
72      -971744 / 32,  -965344 / 32,  -958688 / 32,  -951776 / 32,
73      -944608 / 32,  -937184 / 32,  -929504 / 32,  -921568 / 32,
74      -913376 / 32,  -904928 / 32,  -896224 / 32,  -887264 / 32,
75      -878048 / 32,  -868576 / 32,  -858848 / 32,  -848864 / 32,
76      -838624 / 32,  -828128 / 32,  -817376 / 32,  -806368 / 32,
77      -795104 / 32,  -783584 / 32,  -771808 / 32,  -759776 / 32,
78      -747488 / 32,  -734944 / 32,  -722144 / 32,  -709088 / 32,
79      -695776 / 32,  -682208 / 32,  -668384 / 32,  -654304 / 32,
80      -639968 / 32,  -625376 / 32,  -610528 / 32,  -595424 / 32,
81      -580064 / 32,  -564448 / 32,  -548576 / 32,  -532448 / 32,
82      -516064 / 32,  -499424 / 32,  -482528 / 32,  -465376 / 32,
83      -447968 / 32,  -430304 / 32,  -412384 / 32,  -394208 / 32,
84      -375776 / 32,  -357088 / 32,  -338144 / 32,  -318944 / 32,
85      -299488 / 32,  -279776 / 32,  -259808 / 32,  -239584 / 32,
86      -219104 / 32,  -198368 / 32,  -177376 / 32,  -156128 / 32,
87      -134624 / 32,  -112864 / 32,   -90848 / 32,   -68576 / 32,
88       -46048 / 32,   -23264 / 32,     -224 / 32,    23072 / 32,
89        46624 / 32,    70432 / 32,    94496 / 32,   118816 / 32,
90       143392 / 32,   168224 / 32,   193312 / 32,   218656 / 32,
91       244256 / 32,   270112 / 32,   296224 / 32,   322592 / 32,
92       349216 / 32,   376096 / 32,   403232 / 32,   430624 / 32,
93       458272 / 32,   486176 / 32,   514336 / 32,   542752 / 32,
94       571424 / 32,   600352 / 32,   629536 / 32,   658976 / 32,
95       688672 / 32,   718624 / 32,   748832 / 32,   779296 / 32,
96       810016 / 32,   840992 / 32,   872224 / 32,   903712 / 32,
97       935456 / 32,   967456 / 32,   999712 / 32,  1032224 / 32
98 };
99
100
101 /** Gain values of p(0) for long-term prediction.
102  *  To be indexed by the Rice coded indices.
103  */
104 static const uint8_t ltp_gain_values [4][4] = {
105     { 0,  8, 16,  24},
106     {32, 40, 48,  56},
107     {64, 70, 76,  82},
108     {88, 92, 96, 100}
109 };
110
111
112 /** Inter-channel weighting factors for multi-channel correlation.
113  *  To be indexed by the Rice coded indices.
114  */
115 static const int16_t mcc_weightings[] = {
116     204,  192,  179,  166,  153,  140,  128,  115,
117     102,   89,   76,   64,   51,   38,   25,   12,
118       0,  -12,  -25,  -38,  -51,  -64,  -76,  -89,
119    -102, -115, -128, -140, -153, -166, -179, -192
120 };
121
122
123 enum RA_Flag {
124     RA_FLAG_NONE,
125     RA_FLAG_FRAMES,
126     RA_FLAG_HEADER
127 };
128
129
130 typedef struct {
131     uint32_t samples;         ///< number of samples, 0xFFFFFFFF if unknown
132     int resolution;           ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
133     int floating;             ///< 1 = IEEE 32-bit floating-point, 0 = integer
134     int frame_length;         ///< frame length for each frame (last frame may differ)
135     int ra_distance;          ///< distance between RA frames (in frames, 0...255)
136     enum RA_Flag ra_flag;     ///< indicates where the size of ra units is stored
137     int adapt_order;          ///< adaptive order: 1 = on, 0 = off
138     int coef_table;           ///< table index of Rice code parameters
139     int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
140     int max_order;            ///< maximum prediction order (0..1023)
141     int block_switching;      ///< number of block switching levels
142     int bgmc;                 ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
143     int sb_part;              ///< sub-block partition
144     int joint_stereo;         ///< joint stereo: 1 = on, 0 = off
145     int mc_coding;            ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
146     int chan_config;          ///< indicates that a chan_config_info field is present
147     int chan_sort;            ///< channel rearrangement: 1 = on, 0 = off
148     int rlslms;               ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
149     int chan_config_info;     ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
150     int *chan_pos;            ///< original channel positions
151     uint32_t header_size;     ///< header size of original audio file in bytes, provided for debugging
152     uint32_t trailer_size;    ///< trailer size of original audio file in bytes, provided for debugging
153 } ALSSpecificConfig;
154
155
156 typedef struct {
157     int stop_flag;
158     int master_channel;
159     int time_diff_flag;
160     int time_diff_sign;
161     int time_diff_index;
162     int weighting[6];
163 } ALSChannelData;
164
165
166 typedef struct {
167     AVCodecContext *avctx;
168     ALSSpecificConfig sconf;
169     GetBitContext gb;
170     unsigned int cur_frame_length;  ///< length of the current frame to decode
171     unsigned int frame_id;          ///< the frame ID / number of the current frame
172     unsigned int js_switch;         ///< if true, joint-stereo decoding is enforced
173     unsigned int num_blocks;        ///< number of blocks used in the current frame
174     int ltp_lag_length;             ///< number of bits used for ltp lag value
175     int *use_ltp;                   ///< contains use_ltp flags for all channels
176     int *ltp_lag;                   ///< contains ltp lag values for all channels
177     int **ltp_gain;                 ///< gain values for ltp 5-tap filter for a channel
178     int *ltp_gain_buffer;           ///< contains all gain values for ltp 5-tap filter
179     int32_t **quant_cof;            ///< quantized parcor coefficients for a channel
180     int32_t *quant_cof_buffer;      ///< contains all quantized parcor coefficients
181     int32_t **lpc_cof;              ///< coefficients of the direct form prediction filter for a channel
182     int32_t *lpc_cof_buffer;        ///< contains all coefficients of the direct form prediction filter
183     ALSChannelData **chan_data;     ///< channel data for multi-channel correlation
184     ALSChannelData *chan_data_buffer; ///< contains channel data for all channels
185     int *reverted_channels;         ///< stores a flag for each reverted channel
186     int32_t *prev_raw_samples;      ///< contains unshifted raw samples from the previous block
187     int32_t **raw_samples;          ///< decoded raw samples for each channel
188     int32_t *raw_buffer;            ///< contains all decoded raw samples including carryover samples
189 } ALSDecContext;
190
191
192 typedef struct {
193     unsigned int block_length;      ///< number of samples within the block
194     unsigned int ra_block;          ///< if true, this is a random access block
195     int          const_block;       ///< if true, this is a constant value block
196     int32_t      const_val;         ///< the sample value of a constant block
197     int          js_blocks;         ///< true if this block contains a difference signal
198     unsigned int shift_lsbs;        ///< shift of values for this block
199     unsigned int opt_order;         ///< prediction order of this block
200     int          store_prev_samples;///< if true, carryover samples have to be stored
201     int          *use_ltp;          ///< if true, long-term prediction is used
202     int          *ltp_lag;          ///< lag value for long-term prediction
203     int          *ltp_gain;         ///< gain values for ltp 5-tap filter
204     int32_t      *quant_cof;        ///< quantized parcor coefficients
205     int32_t      *lpc_cof;          ///< coefficients of the direct form prediction
206     int32_t      *raw_samples;      ///< decoded raw samples / residuals for this block
207     int32_t      *prev_raw_samples; ///< contains unshifted raw samples from the previous block
208     int32_t      *raw_other;        ///< decoded raw samples of the other channel of a channel pair
209 } ALSBlockData;
210
211
212 static av_cold void dprint_specific_config(ALSDecContext *ctx)
213 {
214 #ifdef DEBUG
215     AVCodecContext *avctx    = ctx->avctx;
216     ALSSpecificConfig *sconf = &ctx->sconf;
217
218     dprintf(avctx, "resolution = %i\n",           sconf->resolution);
219     dprintf(avctx, "floating = %i\n",             sconf->floating);
220     dprintf(avctx, "frame_length = %i\n",         sconf->frame_length);
221     dprintf(avctx, "ra_distance = %i\n",          sconf->ra_distance);
222     dprintf(avctx, "ra_flag = %i\n",              sconf->ra_flag);
223     dprintf(avctx, "adapt_order = %i\n",          sconf->adapt_order);
224     dprintf(avctx, "coef_table = %i\n",           sconf->coef_table);
225     dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
226     dprintf(avctx, "max_order = %i\n",            sconf->max_order);
227     dprintf(avctx, "block_switching = %i\n",      sconf->block_switching);
228     dprintf(avctx, "bgmc = %i\n",                 sconf->bgmc);
229     dprintf(avctx, "sb_part = %i\n",              sconf->sb_part);
230     dprintf(avctx, "joint_stereo = %i\n",         sconf->joint_stereo);
231     dprintf(avctx, "mc_coding = %i\n",            sconf->mc_coding);
232     dprintf(avctx, "chan_config = %i\n",          sconf->chan_config);
233     dprintf(avctx, "chan_sort = %i\n",            sconf->chan_sort);
234     dprintf(avctx, "RLSLMS = %i\n",               sconf->rlslms);
235     dprintf(avctx, "chan_config_info = %i\n",     sconf->chan_config_info);
236     dprintf(avctx, "header_size = %i\n",          sconf->header_size);
237     dprintf(avctx, "trailer_size = %i\n",         sconf->trailer_size);
238 #endif
239 }
240
241
242 /** Reads an ALSSpecificConfig from a buffer into the output struct.
243  */
244 static av_cold int read_specific_config(ALSDecContext *ctx)
245 {
246     GetBitContext gb;
247     uint64_t ht_size;
248     int i, config_offset, crc_enabled;
249     MPEG4AudioConfig m4ac;
250     ALSSpecificConfig *sconf = &ctx->sconf;
251     AVCodecContext *avctx    = ctx->avctx;
252     uint32_t als_id;
253
254     init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);
255
256     config_offset = ff_mpeg4audio_get_config(&m4ac, avctx->extradata,
257                                              avctx->extradata_size);
258
259     if (config_offset < 0)
260         return -1;
261
262     skip_bits_long(&gb, config_offset);
263
264     if (get_bits_left(&gb) < (30 << 3))
265         return -1;
266
267     // read the fixed items
268     als_id                      = get_bits_long(&gb, 32);
269     avctx->sample_rate          = m4ac.sample_rate;
270     skip_bits_long(&gb, 32); // sample rate already known
271     sconf->samples              = get_bits_long(&gb, 32);
272     avctx->channels             = m4ac.channels;
273     skip_bits(&gb, 16);      // number of channels already knwon
274     skip_bits(&gb, 3);       // skip file_type
275     sconf->resolution           = get_bits(&gb, 3);
276     sconf->floating             = get_bits1(&gb);
277     skip_bits1(&gb);         // skip msb_first
278     sconf->frame_length         = get_bits(&gb, 16) + 1;
279     sconf->ra_distance          = get_bits(&gb, 8);
280     sconf->ra_flag              = get_bits(&gb, 2);
281     sconf->adapt_order          = get_bits1(&gb);
282     sconf->coef_table           = get_bits(&gb, 2);
283     sconf->long_term_prediction = get_bits1(&gb);
284     sconf->max_order            = get_bits(&gb, 10);
285     sconf->block_switching      = get_bits(&gb, 2);
286     sconf->bgmc                 = get_bits1(&gb);
287     sconf->sb_part              = get_bits1(&gb);
288     sconf->joint_stereo         = get_bits1(&gb);
289     sconf->mc_coding            = get_bits1(&gb);
290     sconf->chan_config          = get_bits1(&gb);
291     sconf->chan_sort            = get_bits1(&gb);
292     crc_enabled                 = get_bits1(&gb);
293     sconf->rlslms               = get_bits1(&gb);
294     skip_bits(&gb, 5);       // skip 5 reserved bits
295     skip_bits1(&gb);         // skip aux_data_enabled
296
297
298     // check for ALSSpecificConfig struct
299     if (als_id != MKBETAG('A','L','S','\0'))
300         return -1;
301
302     ctx->cur_frame_length = sconf->frame_length;
303
304     // read channel config
305     if (sconf->chan_config)
306         sconf->chan_config_info = get_bits(&gb, 16);
307     // TODO: use this to set avctx->channel_layout
308
309
310     // read channel sorting
311     if (sconf->chan_sort && avctx->channels > 1) {
312         int chan_pos_bits = av_ceil_log2(avctx->channels);
313         int bits_needed  = avctx->channels * chan_pos_bits + 7;
314         if (get_bits_left(&gb) < bits_needed)
315             return -1;
316
317         if (!(sconf->chan_pos = av_malloc(avctx->channels * sizeof(*sconf->chan_pos))))
318             return AVERROR(ENOMEM);
319
320         for (i = 0; i < avctx->channels; i++)
321             sconf->chan_pos[i] = get_bits(&gb, chan_pos_bits);
322
323         align_get_bits(&gb);
324         // TODO: use this to actually do channel sorting
325     } else {
326         sconf->chan_sort = 0;
327     }
328
329
330     // read fixed header and trailer sizes,
331     // if size = 0xFFFFFFFF then there is no data field!
332     if (get_bits_left(&gb) < 64)
333         return -1;
334
335     sconf->header_size  = get_bits_long(&gb, 32);
336     sconf->trailer_size = get_bits_long(&gb, 32);
337     if (sconf->header_size  == 0xFFFFFFFF)
338         sconf->header_size  = 0;
339     if (sconf->trailer_size == 0xFFFFFFFF)
340         sconf->trailer_size = 0;
341
342     ht_size = ((int64_t)(sconf->header_size) + (int64_t)(sconf->trailer_size)) << 3;
343
344
345     // skip the header and trailer data
346     if (get_bits_left(&gb) < ht_size)
347         return -1;
348
349     if (ht_size > INT32_MAX)
350         return -1;
351
352     skip_bits_long(&gb, ht_size);
353
354
355     // skip the crc data
356     if (crc_enabled) {
357         if (get_bits_left(&gb) < 32)
358             return -1;
359
360         skip_bits_long(&gb, 32);
361     }
362
363
364     // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
365
366     dprint_specific_config(ctx);
367
368     return 0;
369 }
370
371
372 /** Checks the ALSSpecificConfig for unsupported features.
373  */
374 static int check_specific_config(ALSDecContext *ctx)
375 {
376     ALSSpecificConfig *sconf = &ctx->sconf;
377     int error = 0;
378
379     // report unsupported feature and set error value
380     #define MISSING_ERR(cond, str, errval)              \
381     {                                                   \
382         if (cond) {                                     \
383             av_log_missing_feature(ctx->avctx, str, 0); \
384             error = errval;                             \
385         }                                               \
386     }
387
388     MISSING_ERR(sconf->floating,             "Floating point decoding",     -1);
389     MISSING_ERR(sconf->bgmc,                 "BGMC entropy decoding",       -1);
390     MISSING_ERR(sconf->rlslms,               "Adaptive RLS-LMS prediction", -1);
391     MISSING_ERR(sconf->chan_sort,            "Channel sorting",              0);
392
393     return error;
394 }
395
396
397 /** Parses the bs_info field to extract the block partitioning used in
398  *  block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
399  */
400 static void parse_bs_info(const uint32_t bs_info, unsigned int n,
401                           unsigned int div, unsigned int **div_blocks,
402                           unsigned int *num_blocks)
403 {
404     if (n < 31 && ((bs_info << n) & 0x40000000)) {
405         // if the level is valid and the investigated bit n is set
406         // then recursively check both children at bits (2n+1) and (2n+2)
407         n   *= 2;
408         div += 1;
409         parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
410         parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
411     } else {
412         // else the bit is not set or the last level has been reached
413         // (bit implicitly not set)
414         **div_blocks = div;
415         (*div_blocks)++;
416         (*num_blocks)++;
417     }
418 }
419
420
421 /** Reads and decodes a Rice codeword.
422  */
423 static int32_t decode_rice(GetBitContext *gb, unsigned int k)
424 {
425     int max = get_bits_left(gb) - k;
426     int q   = get_unary(gb, 0, max);
427     int r   = k ? get_bits1(gb) : !(q & 1);
428
429     if (k > 1) {
430         q <<= (k - 1);
431         q  += get_bits_long(gb, k - 1);
432     } else if (!k) {
433         q >>= 1;
434     }
435     return r ? q : ~q;
436 }
437
438
439 /** Converts PARCOR coefficient k to direct filter coefficient.
440  */
441 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
442 {
443     int i, j;
444
445     for (i = 0, j = k - 1; i < j; i++, j--) {
446         int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
447         cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
448         cof[i]  += tmp1;
449     }
450     if (i == j)
451         cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
452
453     cof[k] = par[k];
454 }
455
456
457 /** Reads block switching field if necessary and sets actual block sizes.
458  *  Also assures that the block sizes of the last frame correspond to the
459  *  actual number of samples.
460  */
461 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
462                             uint32_t *bs_info)
463 {
464     ALSSpecificConfig *sconf     = &ctx->sconf;
465     GetBitContext *gb            = &ctx->gb;
466     unsigned int *ptr_div_blocks = div_blocks;
467     unsigned int b;
468
469     if (sconf->block_switching) {
470         unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
471         *bs_info = get_bits_long(gb, bs_info_len);
472         *bs_info <<= (32 - bs_info_len);
473     }
474
475     ctx->num_blocks = 0;
476     parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
477
478     // The last frame may have an overdetermined block structure given in
479     // the bitstream. In that case the defined block structure would need
480     // more samples than available to be consistent.
481     // The block structure is actually used but the block sizes are adapted
482     // to fit the actual number of available samples.
483     // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
484     // This results in the actual block sizes:    2 2 1 0.
485     // This is not specified in 14496-3 but actually done by the reference
486     // codec RM22 revision 2.
487     // This appears to happen in case of an odd number of samples in the last
488     // frame which is actually not allowed by the block length switching part
489     // of 14496-3.
490     // The ALS conformance files feature an odd number of samples in the last
491     // frame.
492
493     for (b = 0; b < ctx->num_blocks; b++)
494         div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
495
496     if (ctx->cur_frame_length != ctx->sconf.frame_length) {
497         unsigned int remaining = ctx->cur_frame_length;
498
499         for (b = 0; b < ctx->num_blocks; b++) {
500             if (remaining < div_blocks[b]) {
501                 div_blocks[b] = remaining;
502                 ctx->num_blocks = b + 1;
503                 break;
504             }
505
506             remaining -= div_blocks[b];
507         }
508     }
509 }
510
511
512 /** Reads the block data for a constant block
513  */
514 static void read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
515 {
516     ALSSpecificConfig *sconf = &ctx->sconf;
517     AVCodecContext *avctx    = ctx->avctx;
518     GetBitContext *gb        = &ctx->gb;
519
520     bd->const_val    = 0;
521     bd->const_block  = get_bits1(gb);    // 1 = constant value, 0 = zero block (silence)
522     bd->js_blocks    = get_bits1(gb);
523
524     // skip 5 reserved bits
525     skip_bits(gb, 5);
526
527     if (bd->const_block) {
528         unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
529         bd->const_val = get_sbits_long(gb, const_val_bits);
530     }
531
532     // ensure constant block decoding by reusing this field
533     bd->const_block = 1;
534 }
535
536
537 /** Decodes the block data for a constant block
538  */
539 static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
540 {
541     int      smp = bd->block_length;
542     int32_t  val = bd->const_val;
543     int32_t *dst = bd->raw_samples;
544
545     // write raw samples into buffer
546     for (; smp; smp--)
547         *dst++ = val;
548 }
549
550
551 /** Reads the block data for a non-constant block
552  */
553 static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
554 {
555     ALSSpecificConfig *sconf = &ctx->sconf;
556     AVCodecContext *avctx    = ctx->avctx;
557     GetBitContext *gb        = &ctx->gb;
558     unsigned int k;
559     unsigned int s[8];
560     unsigned int sub_blocks, log2_sub_blocks, sb_length;
561     unsigned int start      = 0;
562     unsigned int opt_order;
563     int          sb;
564     int32_t      *quant_cof = bd->quant_cof;
565
566
567     // ensure variable block decoding by reusing this field
568     bd->const_block = 0;
569
570     bd->opt_order   = 1;
571     bd->js_blocks   = get_bits1(gb);
572
573     opt_order       = bd->opt_order;
574
575     // determine the number of subblocks for entropy decoding
576     if (!sconf->bgmc && !sconf->sb_part) {
577         log2_sub_blocks = 0;
578     } else {
579         if (sconf->bgmc && sconf->sb_part)
580             log2_sub_blocks = get_bits(gb, 2);
581         else
582             log2_sub_blocks = 2 * get_bits1(gb);
583     }
584
585     sub_blocks = 1 << log2_sub_blocks;
586
587     // do not continue in case of a damaged stream since
588     // block_length must be evenly divisible by sub_blocks
589     if (bd->block_length & (sub_blocks - 1)) {
590         av_log(avctx, AV_LOG_WARNING,
591                "Block length is not evenly divisible by the number of subblocks.\n");
592         return -1;
593     }
594
595     sb_length = bd->block_length >> log2_sub_blocks;
596
597
598     if (sconf->bgmc) {
599         // TODO: BGMC mode
600     } else {
601         s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
602         for (k = 1; k < sub_blocks; k++)
603             s[k] = s[k - 1] + decode_rice(gb, 0);
604     }
605
606     if (get_bits1(gb))
607         bd->shift_lsbs = get_bits(gb, 4) + 1;
608
609     bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || bd->shift_lsbs;
610
611
612     if (!sconf->rlslms) {
613         if (sconf->adapt_order) {
614             int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
615                                                 2, sconf->max_order + 1));
616             bd->opt_order        = get_bits(gb, opt_order_length);
617         } else {
618             bd->opt_order = sconf->max_order;
619         }
620
621         opt_order = bd->opt_order;
622
623         if (opt_order) {
624             int add_base;
625
626             if (sconf->coef_table == 3) {
627                 add_base = 0x7F;
628
629                 // read coefficient 0
630                 quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
631
632                 // read coefficient 1
633                 if (opt_order > 1)
634                     quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
635
636                 // read coefficients 2 to opt_order
637                 for (k = 2; k < opt_order; k++)
638                     quant_cof[k] = get_bits(gb, 7);
639             } else {
640                 int k_max;
641                 add_base = 1;
642
643                 // read coefficient 0 to 19
644                 k_max = FFMIN(opt_order, 20);
645                 for (k = 0; k < k_max; k++) {
646                     int rice_param = parcor_rice_table[sconf->coef_table][k][1];
647                     int offset     = parcor_rice_table[sconf->coef_table][k][0];
648                     quant_cof[k] = decode_rice(gb, rice_param) + offset;
649                 }
650
651                 // read coefficients 20 to 126
652                 k_max = FFMIN(opt_order, 127);
653                 for (; k < k_max; k++)
654                     quant_cof[k] = decode_rice(gb, 2) + (k & 1);
655
656                 // read coefficients 127 to opt_order
657                 for (; k < opt_order; k++)
658                     quant_cof[k] = decode_rice(gb, 1);
659
660                 quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
661
662                 if (opt_order > 1)
663                     quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
664             }
665
666             for (k = 2; k < opt_order; k++)
667                 quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
668         }
669     }
670
671     // read LTP gain and lag values
672     if (sconf->long_term_prediction) {
673         *bd->use_ltp = get_bits1(gb);
674
675         if (*bd->use_ltp) {
676             bd->ltp_gain[0]   = decode_rice(gb, 1) << 3;
677             bd->ltp_gain[1]   = decode_rice(gb, 2) << 3;
678
679             bd->ltp_gain[2]   = ltp_gain_values[get_unary(gb, 0, 4)][get_bits(gb, 2)];
680
681             bd->ltp_gain[3]   = decode_rice(gb, 2) << 3;
682             bd->ltp_gain[4]   = decode_rice(gb, 1) << 3;
683
684             *bd->ltp_lag      = get_bits(gb, ctx->ltp_lag_length);
685             *bd->ltp_lag     += FFMAX(4, opt_order + 1);
686         }
687     }
688
689     // read first value and residuals in case of a random access block
690     if (bd->ra_block) {
691         if (opt_order)
692             bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
693         if (opt_order > 1)
694             bd->raw_samples[1] = decode_rice(gb, s[0] + 3);
695         if (opt_order > 2)
696             bd->raw_samples[2] = decode_rice(gb, s[0] + 1);
697
698         start = FFMIN(opt_order, 3);
699     }
700
701     // read all residuals
702     if (sconf->bgmc) {
703         // TODO: BGMC mode
704     } else {
705         int32_t *current_res = bd->raw_samples + start;
706
707         for (sb = 0; sb < sub_blocks; sb++, start = 0)
708             for (; start < sb_length; start++)
709                 *current_res++ = decode_rice(gb, s[sb]);
710      }
711
712     if (!sconf->mc_coding || ctx->js_switch)
713         align_get_bits(gb);
714
715     return 0;
716 }
717
718
719 /** Decodes the block data for a non-constant block
720  */
721 static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
722 {
723     ALSSpecificConfig *sconf = &ctx->sconf;
724     unsigned int block_length = bd->block_length;
725     unsigned int smp = 0;
726     unsigned int k;
727     unsigned int opt_order    = bd->opt_order;
728     int sb;
729     int64_t y;
730     int32_t *quant_cof        = bd->quant_cof;
731     int32_t *lpc_cof          = bd->lpc_cof;
732     int32_t *raw_samples      = bd->raw_samples;
733     int32_t *raw_samples_end  = bd->raw_samples + bd->block_length;
734     int32_t lpc_cof_reversed[opt_order];
735
736     // reverse long-term prediction
737     if (*bd->use_ltp) {
738         int ltp_smp;
739
740         for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
741             int center = ltp_smp - *bd->ltp_lag;
742             int begin  = FFMAX(0, center - 2);
743             int end    = center + 3;
744             int tab    = 5 - (end - begin);
745             int base;
746
747             y = 1 << 6;
748
749             for (base = begin; base < end; base++, tab++)
750                 y += MUL64(bd->ltp_gain[tab], raw_samples[base]);
751
752             raw_samples[ltp_smp] += y >> 7;
753         }
754     }
755
756     // reconstruct all samples from residuals
757     if (bd->ra_block) {
758         for (smp = 0; smp < opt_order; smp++) {
759             y = 1 << 19;
760
761             for (sb = 0; sb < smp; sb++)
762                 y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
763
764             *raw_samples++ -= y >> 20;
765             parcor_to_lpc(smp, quant_cof, lpc_cof);
766         }
767     } else {
768         for (k = 0; k < opt_order; k++)
769             parcor_to_lpc(k, quant_cof, lpc_cof);
770
771         // store previous samples in case that they have to be altered
772         if (bd->store_prev_samples)
773             memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
774                    sizeof(*bd->prev_raw_samples) * sconf->max_order);
775
776         // reconstruct difference signal for prediction (joint-stereo)
777         if (bd->js_blocks && bd->raw_other) {
778             int32_t *left, *right;
779
780             if (bd->raw_other > raw_samples) {  // D = R - L
781                 left  = raw_samples;
782                 right = bd->raw_other;
783             } else {                                // D = R - L
784                 left  = bd->raw_other;
785                 right = raw_samples;
786             }
787
788             for (sb = -1; sb >= -sconf->max_order; sb--)
789                 raw_samples[sb] = right[sb] - left[sb];
790         }
791
792         // reconstruct shifted signal
793         if (bd->shift_lsbs)
794             for (sb = -1; sb >= -sconf->max_order; sb--)
795                 raw_samples[sb] >>= bd->shift_lsbs;
796     }
797
798     // reverse linear prediction coefficients for efficiency
799     lpc_cof = lpc_cof + opt_order;
800
801     for (sb = 0; sb < opt_order; sb++)
802         lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
803
804     // reconstruct raw samples
805     raw_samples = bd->raw_samples + smp;
806     lpc_cof     = lpc_cof_reversed + opt_order;
807
808     for (; raw_samples < raw_samples_end; raw_samples++) {
809         y = 1 << 19;
810
811         for (sb = -opt_order; sb < 0; sb++)
812             y += MUL64(lpc_cof[sb], raw_samples[sb]);
813
814         *raw_samples -= y >> 20;
815     }
816
817     raw_samples = bd->raw_samples;
818
819     // restore previous samples in case that they have been altered
820     if (bd->store_prev_samples)
821         memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
822                sizeof(*raw_samples) * sconf->max_order);
823
824     return 0;
825 }
826
827
828 /** Reads the block data.
829  */
830 static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
831 {
832     GetBitContext *gb        = &ctx->gb;
833
834     // read block type flag and read the samples accordingly
835     if (get_bits1(gb)) {
836         if (read_var_block_data(ctx, bd))
837             return -1;
838     } else {
839         read_const_block_data(ctx, bd);
840     }
841
842     return 0;
843 }
844
845
846 /** Decodes the block data.
847  */
848 static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
849 {
850     unsigned int smp;
851
852     // read block type flag and read the samples accordingly
853     if (bd->const_block)
854         decode_const_block_data(ctx, bd);
855     else if (decode_var_block_data(ctx, bd))
856         return -1;
857
858     // TODO: read RLSLMS extension data
859
860     if (bd->shift_lsbs)
861         for (smp = 0; smp < bd->block_length; smp++)
862             bd->raw_samples[smp] <<= bd->shift_lsbs;
863
864     return 0;
865 }
866
867
868 /** Reads and decodes block data successively.
869  */
870 static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
871 {
872     int ret;
873
874     ret = read_block(ctx, bd);
875
876     if (ret)
877         return ret;
878
879     ret = decode_block(ctx, bd);
880
881     return ret;
882 }
883
884
885 /** Computes the number of samples left to decode for the current frame and
886  *  sets these samples to zero.
887  */
888 static void zero_remaining(unsigned int b, unsigned int b_max,
889                            const unsigned int *div_blocks, int32_t *buf)
890 {
891     unsigned int count = 0;
892
893     while (b < b_max)
894         count += div_blocks[b];
895
896     if (count)
897         memset(buf, 0, sizeof(*buf) * count);
898 }
899
900
901 /** Decodes blocks independently.
902  */
903 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
904                              unsigned int c, const unsigned int *div_blocks,
905                              unsigned int *js_blocks)
906 {
907     unsigned int b;
908     ALSBlockData bd;
909
910     memset(&bd, 0, sizeof(ALSBlockData));
911
912     bd.ra_block         = ra_frame;
913     bd.use_ltp          = ctx->use_ltp;
914     bd.ltp_lag          = ctx->ltp_lag;
915     bd.ltp_gain         = ctx->ltp_gain[0];
916     bd.quant_cof        = ctx->quant_cof[0];
917     bd.lpc_cof          = ctx->lpc_cof[0];
918     bd.prev_raw_samples = ctx->prev_raw_samples;
919     bd.raw_samples      = ctx->raw_samples[c];
920
921
922     for (b = 0; b < ctx->num_blocks; b++) {
923         bd.shift_lsbs       = 0;
924         bd.block_length     = div_blocks[b];
925
926         if (read_decode_block(ctx, &bd)) {
927             // damaged block, write zero for the rest of the frame
928             zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
929             return -1;
930         }
931         bd.raw_samples += div_blocks[b];
932         bd.ra_block     = 0;
933     }
934
935     return 0;
936 }
937
938
939 /** Decodes blocks dependently.
940  */
941 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
942                          unsigned int c, const unsigned int *div_blocks,
943                          unsigned int *js_blocks)
944 {
945     ALSSpecificConfig *sconf = &ctx->sconf;
946     unsigned int offset = 0;
947     unsigned int b;
948     ALSBlockData bd[2];
949
950     memset(bd, 0, 2 * sizeof(ALSBlockData));
951
952     bd[0].ra_block         = ra_frame;
953     bd[0].use_ltp          = ctx->use_ltp;
954     bd[0].ltp_lag          = ctx->ltp_lag;
955     bd[0].ltp_gain         = ctx->ltp_gain[0];
956     bd[0].quant_cof        = ctx->quant_cof[0];
957     bd[0].lpc_cof          = ctx->lpc_cof[0];
958     bd[0].prev_raw_samples = ctx->prev_raw_samples;
959     bd[0].js_blocks        = *js_blocks;
960
961     bd[1].ra_block         = ra_frame;
962     bd[1].use_ltp          = ctx->use_ltp;
963     bd[1].ltp_lag          = ctx->ltp_lag;
964     bd[1].ltp_gain         = ctx->ltp_gain[0];
965     bd[1].quant_cof        = ctx->quant_cof[0];
966     bd[1].lpc_cof          = ctx->lpc_cof[0];
967     bd[1].prev_raw_samples = ctx->prev_raw_samples;
968     bd[1].js_blocks        = *(js_blocks + 1);
969
970     // decode all blocks
971     for (b = 0; b < ctx->num_blocks; b++) {
972         unsigned int s;
973
974         bd[0].shift_lsbs   = 0;
975         bd[1].shift_lsbs   = 0;
976
977         bd[0].block_length = div_blocks[b];
978         bd[1].block_length = div_blocks[b];
979
980         bd[0].raw_samples  = ctx->raw_samples[c    ] + offset;
981         bd[1].raw_samples  = ctx->raw_samples[c + 1] + offset;
982
983         bd[0].raw_other    = bd[1].raw_samples;
984         bd[1].raw_other    = bd[0].raw_samples;
985
986         if(read_decode_block(ctx, &bd[0]) || read_decode_block(ctx, &bd[1])) {
987             // damaged block, write zero for the rest of the frame
988             zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
989             zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
990             return -1;
991         }
992
993         // reconstruct joint-stereo blocks
994         if (bd[0].js_blocks) {
995             if (bd[1].js_blocks)
996                 av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n");
997
998             for (s = 0; s < div_blocks[b]; s++)
999                 bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
1000         } else if (bd[1].js_blocks) {
1001             for (s = 0; s < div_blocks[b]; s++)
1002                 bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s];
1003         }
1004
1005         offset  += div_blocks[b];
1006         bd[0].ra_block = 0;
1007         bd[1].ra_block = 0;
1008     }
1009
1010     // store carryover raw samples,
1011     // the others channel raw samples are stored by the calling function.
1012     memmove(ctx->raw_samples[c] - sconf->max_order,
1013             ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1014             sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1015
1016     return 0;
1017 }
1018
1019
1020 /** Reads the channel data.
1021   */
1022 static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
1023 {
1024     GetBitContext *gb       = &ctx->gb;
1025     ALSChannelData *current = cd;
1026     unsigned int channels   = ctx->avctx->channels;
1027     int entries             = 0;
1028
1029     while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1030         current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1031
1032         if (current->master_channel >= channels) {
1033             av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel!\n");
1034             return -1;
1035         }
1036
1037         if (current->master_channel != c) {
1038             current->time_diff_flag = get_bits1(gb);
1039             current->weighting[0]   = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1040             current->weighting[1]   = mcc_weightings[av_clip(decode_rice(gb, 2) + 14, 0, 32)];
1041             current->weighting[2]   = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1042
1043             if (current->time_diff_flag) {
1044                 current->weighting[3] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1045                 current->weighting[4] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1046                 current->weighting[5] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1047
1048                 current->time_diff_sign  = get_bits1(gb);
1049                 current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1050             }
1051         }
1052
1053         current++;
1054         entries++;
1055     }
1056
1057     if (entries == channels) {
1058         av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data!\n");
1059         return -1;
1060     }
1061
1062     align_get_bits(gb);
1063     return 0;
1064 }
1065
1066
1067 /** Recursively reverts the inter-channel correlation for a block.
1068  */
1069 static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
1070                                        ALSChannelData **cd, int *reverted,
1071                                        unsigned int offset, int c)
1072 {
1073     ALSChannelData *ch = cd[c];
1074     unsigned int   dep = 0;
1075     unsigned int channels = ctx->avctx->channels;
1076
1077     if (reverted[c])
1078         return 0;
1079
1080     reverted[c] = 1;
1081
1082     while (dep < channels && !ch[dep].stop_flag) {
1083         revert_channel_correlation(ctx, bd, cd, reverted, offset,
1084                                    ch[dep].master_channel);
1085
1086         dep++;
1087     }
1088
1089     if (dep == channels) {
1090         av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation!\n");
1091         return -1;
1092     }
1093
1094     bd->use_ltp     = ctx->use_ltp + c;
1095     bd->ltp_lag     = ctx->ltp_lag + c;
1096     bd->ltp_gain    = ctx->ltp_gain[c];
1097     bd->lpc_cof     = ctx->lpc_cof[c];
1098     bd->quant_cof   = ctx->quant_cof[c];
1099     bd->raw_samples = ctx->raw_samples[c] + offset;
1100
1101     dep = 0;
1102     while (!ch[dep].stop_flag) {
1103         unsigned int smp;
1104         unsigned int begin = 1;
1105         unsigned int end   = bd->block_length - 1;
1106         int64_t y;
1107         int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1108
1109         if (ch[dep].time_diff_flag) {
1110             int t = ch[dep].time_diff_index;
1111
1112             if (ch[dep].time_diff_sign) {
1113                 t      = -t;
1114                 begin -= t;
1115             } else {
1116                 end   -= t;
1117             }
1118
1119             for (smp = begin; smp < end; smp++) {
1120                 y  = (1 << 6) +
1121                      MUL64(ch[dep].weighting[0], master[smp - 1    ]) +
1122                      MUL64(ch[dep].weighting[1], master[smp        ]) +
1123                      MUL64(ch[dep].weighting[2], master[smp + 1    ]) +
1124                      MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1125                      MUL64(ch[dep].weighting[4], master[smp     + t]) +
1126                      MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1127
1128                 bd->raw_samples[smp] += y >> 7;
1129             }
1130         } else {
1131             for (smp = begin; smp < end; smp++) {
1132                 y  = (1 << 6) +
1133                      MUL64(ch[dep].weighting[0], master[smp - 1]) +
1134                      MUL64(ch[dep].weighting[1], master[smp    ]) +
1135                      MUL64(ch[dep].weighting[2], master[smp + 1]);
1136
1137                 bd->raw_samples[smp] += y >> 7;
1138             }
1139         }
1140
1141         dep++;
1142     }
1143
1144     return 0;
1145 }
1146
1147
1148 /** Reads the frame data.
1149  */
1150 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1151 {
1152     ALSSpecificConfig *sconf = &ctx->sconf;
1153     AVCodecContext *avctx    = ctx->avctx;
1154     GetBitContext *gb = &ctx->gb;
1155     unsigned int div_blocks[32];                ///< block sizes.
1156     unsigned int c;
1157     unsigned int js_blocks[2];
1158
1159     uint32_t bs_info = 0;
1160
1161     // skip the size of the ra unit if present in the frame
1162     if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1163         skip_bits_long(gb, 32);
1164
1165     if (sconf->mc_coding && sconf->joint_stereo) {
1166         ctx->js_switch = get_bits1(gb);
1167         align_get_bits(gb);
1168     }
1169
1170     if (!sconf->mc_coding || ctx->js_switch) {
1171         int independent_bs = !sconf->joint_stereo;
1172
1173         for (c = 0; c < avctx->channels; c++) {
1174             js_blocks[0] = 0;
1175             js_blocks[1] = 0;
1176
1177             get_block_sizes(ctx, div_blocks, &bs_info);
1178
1179             // if joint_stereo and block_switching is set, independent decoding
1180             // is signaled via the first bit of bs_info
1181             if (sconf->joint_stereo && sconf->block_switching)
1182                 if (bs_info >> 31)
1183                     independent_bs = 2;
1184
1185             // if this is the last channel, it has to be decoded independently
1186             if (c == avctx->channels - 1)
1187                 independent_bs = 1;
1188
1189             if (independent_bs) {
1190                 if (decode_blocks_ind(ctx, ra_frame, c, div_blocks, js_blocks))
1191                     return -1;
1192
1193                 independent_bs--;
1194             } else {
1195                 if (decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks))
1196                     return -1;
1197
1198                 c++;
1199             }
1200
1201             // store carryover raw samples
1202             memmove(ctx->raw_samples[c] - sconf->max_order,
1203                     ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1204                     sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1205         }
1206     } else { // multi-channel coding
1207         ALSBlockData   bd;
1208         int            b;
1209         int            *reverted_channels = ctx->reverted_channels;
1210         unsigned int   offset             = 0;
1211
1212         for (c = 0; c < avctx->channels; c++)
1213             if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1214                 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data!\n");
1215                 return -1;
1216             }
1217
1218         memset(&bd,               0, sizeof(ALSBlockData));
1219         memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1220
1221         bd.ra_block         = ra_frame;
1222         bd.prev_raw_samples = ctx->prev_raw_samples;
1223
1224         get_block_sizes(ctx, div_blocks, &bs_info);
1225
1226         for (b = 0; b < ctx->num_blocks; b++) {
1227             bd.shift_lsbs   = 0;
1228             bd.block_length = div_blocks[b];
1229
1230             for (c = 0; c < avctx->channels; c++) {
1231                 bd.use_ltp     = ctx->use_ltp + c;
1232                 bd.ltp_lag     = ctx->ltp_lag + c;
1233                 bd.ltp_gain    = ctx->ltp_gain[c];
1234                 bd.lpc_cof     = ctx->lpc_cof[c];
1235                 bd.quant_cof   = ctx->quant_cof[c];
1236                 bd.raw_samples = ctx->raw_samples[c] + offset;
1237                 bd.raw_other   = NULL;
1238
1239                 read_block(ctx, &bd);
1240                 if (read_channel_data(ctx, ctx->chan_data[c], c))
1241                     return -1;
1242             }
1243
1244             for (c = 0; c < avctx->channels; c++)
1245                 if (revert_channel_correlation(ctx, &bd, ctx->chan_data,
1246                                                reverted_channels, offset, c))
1247                     return -1;
1248
1249             for (c = 0; c < avctx->channels; c++) {
1250                 bd.use_ltp     = ctx->use_ltp + c;
1251                 bd.ltp_lag     = ctx->ltp_lag + c;
1252                 bd.ltp_gain    = ctx->ltp_gain[c];
1253                 bd.lpc_cof     = ctx->lpc_cof[c];
1254                 bd.quant_cof   = ctx->quant_cof[c];
1255                 bd.raw_samples = ctx->raw_samples[c] + offset;
1256                 decode_block(ctx, &bd);
1257             }
1258
1259             memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1260             offset      += div_blocks[b];
1261             bd.ra_block  = 0;
1262         }
1263
1264         // store carryover raw samples
1265         for (c = 0; c < avctx->channels; c++)
1266             memmove(ctx->raw_samples[c] - sconf->max_order,
1267                     ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1268                     sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1269     }
1270
1271     // TODO: read_diff_float_data
1272
1273     return 0;
1274 }
1275
1276
1277 /** Decodes an ALS frame.
1278  */
1279 static int decode_frame(AVCodecContext *avctx,
1280                         void *data, int *data_size,
1281                         AVPacket *avpkt)
1282 {
1283     ALSDecContext *ctx       = avctx->priv_data;
1284     ALSSpecificConfig *sconf = &ctx->sconf;
1285     const uint8_t *buffer    = avpkt->data;
1286     int buffer_size          = avpkt->size;
1287     int invalid_frame, size;
1288     unsigned int c, sample, ra_frame, bytes_read, shift;
1289
1290     init_get_bits(&ctx->gb, buffer, buffer_size * 8);
1291
1292     // In the case that the distance between random access frames is set to zero
1293     // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1294     // For the first frame, if prediction is used, all samples used from the
1295     // previous frame are assumed to be zero.
1296     ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1297
1298     // the last frame to decode might have a different length
1299     if (sconf->samples != 0xFFFFFFFF)
1300         ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1301                                       sconf->frame_length);
1302     else
1303         ctx->cur_frame_length = sconf->frame_length;
1304
1305     // decode the frame data
1306     if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0))
1307         av_log(ctx->avctx, AV_LOG_WARNING,
1308                "Reading frame data failed. Skipping RA unit.\n");
1309
1310     ctx->frame_id++;
1311
1312     // check for size of decoded data
1313     size = ctx->cur_frame_length * avctx->channels *
1314            (av_get_bits_per_sample_format(avctx->sample_fmt) >> 3);
1315
1316     if (size > *data_size) {
1317         av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
1318         return -1;
1319     }
1320
1321     *data_size = size;
1322
1323     // transform decoded frame into output format
1324     #define INTERLEAVE_OUTPUT(bps)                                 \
1325     {                                                              \
1326         int##bps##_t *dest = (int##bps##_t*) data;                 \
1327         shift = bps - ctx->avctx->bits_per_raw_sample;             \
1328         for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1329             for (c = 0; c < avctx->channels; c++)                  \
1330                 *dest++ = ctx->raw_samples[c][sample] << shift;    \
1331     }
1332
1333     if (ctx->avctx->bits_per_raw_sample <= 16) {
1334         INTERLEAVE_OUTPUT(16)
1335     } else {
1336         INTERLEAVE_OUTPUT(32)
1337     }
1338
1339     bytes_read = invalid_frame ? buffer_size :
1340                                  (get_bits_count(&ctx->gb) + 7) >> 3;
1341
1342     return bytes_read;
1343 }
1344
1345
1346 /** Uninitializes the ALS decoder.
1347  */
1348 static av_cold int decode_end(AVCodecContext *avctx)
1349 {
1350     ALSDecContext *ctx = avctx->priv_data;
1351
1352     av_freep(&ctx->sconf.chan_pos);
1353
1354     av_freep(&ctx->use_ltp);
1355     av_freep(&ctx->ltp_lag);
1356     av_freep(&ctx->ltp_gain);
1357     av_freep(&ctx->ltp_gain_buffer);
1358     av_freep(&ctx->quant_cof);
1359     av_freep(&ctx->lpc_cof);
1360     av_freep(&ctx->quant_cof_buffer);
1361     av_freep(&ctx->lpc_cof_buffer);
1362     av_freep(&ctx->prev_raw_samples);
1363     av_freep(&ctx->raw_samples);
1364     av_freep(&ctx->raw_buffer);
1365     av_freep(&ctx->chan_data);
1366     av_freep(&ctx->chan_data_buffer);
1367     av_freep(&ctx->reverted_channels);
1368
1369     return 0;
1370 }
1371
1372
1373 /** Initializes the ALS decoder.
1374  */
1375 static av_cold int decode_init(AVCodecContext *avctx)
1376 {
1377     unsigned int c;
1378     unsigned int channel_size;
1379     int num_buffers;
1380     ALSDecContext *ctx = avctx->priv_data;
1381     ALSSpecificConfig *sconf = &ctx->sconf;
1382     ctx->avctx = avctx;
1383
1384     if (!avctx->extradata) {
1385         av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1386         return -1;
1387     }
1388
1389     if (read_specific_config(ctx)) {
1390         av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1391         decode_end(avctx);
1392         return -1;
1393     }
1394
1395     if (check_specific_config(ctx)) {
1396         decode_end(avctx);
1397         return -1;
1398     }
1399
1400     if (sconf->floating) {
1401         avctx->sample_fmt          = SAMPLE_FMT_FLT;
1402         avctx->bits_per_raw_sample = 32;
1403     } else {
1404         avctx->sample_fmt          = sconf->resolution > 1
1405                                      ? SAMPLE_FMT_S32 : SAMPLE_FMT_S16;
1406         avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1407     }
1408
1409     // set lag value for long-term prediction
1410     ctx->ltp_lag_length = 8 + (avctx->sample_rate >=  96000) +
1411                               (avctx->sample_rate >= 192000);
1412
1413     // allocate quantized parcor coefficient buffer
1414     num_buffers = sconf->mc_coding ? avctx->channels : 1;
1415
1416     ctx->quant_cof        = av_malloc(sizeof(*ctx->quant_cof) * num_buffers);
1417     ctx->lpc_cof          = av_malloc(sizeof(*ctx->lpc_cof)   * num_buffers);
1418     ctx->quant_cof_buffer = av_malloc(sizeof(*ctx->quant_cof_buffer) *
1419                                       num_buffers * sconf->max_order);
1420     ctx->lpc_cof_buffer   = av_malloc(sizeof(*ctx->lpc_cof_buffer) *
1421                                       num_buffers * sconf->max_order);
1422
1423     if (!ctx->quant_cof        || !ctx->lpc_cof       ||
1424         !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer) {
1425         av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1426         return AVERROR(ENOMEM);
1427     }
1428
1429     // assign quantized parcor coefficient buffers
1430     for (c = 0; c < num_buffers; c++) {
1431         ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
1432         ctx->lpc_cof[c]   = ctx->lpc_cof_buffer   + c * sconf->max_order;
1433     }
1434
1435     // allocate and assign lag and gain data buffer for ltp mode
1436     ctx->use_ltp         = av_mallocz(sizeof(*ctx->use_ltp)  * num_buffers);
1437     ctx->ltp_lag         = av_malloc (sizeof(*ctx->ltp_lag)  * num_buffers);
1438     ctx->ltp_gain        = av_malloc (sizeof(*ctx->ltp_gain) * num_buffers);
1439     ctx->ltp_gain_buffer = av_malloc (sizeof(*ctx->ltp_gain_buffer) *
1440                                       num_buffers * 5);
1441
1442     if (!ctx->use_ltp  || !ctx->ltp_lag ||
1443         !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
1444         av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1445         decode_end(avctx);
1446         return AVERROR(ENOMEM);
1447     }
1448
1449     for (c = 0; c < num_buffers; c++)
1450         ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
1451
1452     // allocate and assign channel data buffer for mcc mode
1453     if (sconf->mc_coding) {
1454         ctx->chan_data_buffer  = av_malloc(sizeof(*ctx->chan_data_buffer) *
1455                                            num_buffers);
1456         ctx->chan_data         = av_malloc(sizeof(ALSChannelData) *
1457                                            num_buffers);
1458         ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) *
1459                                            num_buffers);
1460
1461         if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
1462             av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1463             decode_end(avctx);
1464             return AVERROR(ENOMEM);
1465         }
1466
1467         for (c = 0; c < num_buffers; c++)
1468             ctx->chan_data[c] = ctx->chan_data_buffer + c;
1469     } else {
1470         ctx->chan_data         = NULL;
1471         ctx->chan_data_buffer  = NULL;
1472         ctx->reverted_channels = NULL;
1473     }
1474
1475     avctx->frame_size = sconf->frame_length;
1476     channel_size      = sconf->frame_length + sconf->max_order;
1477
1478     ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order);
1479     ctx->raw_buffer       = av_mallocz(sizeof(*ctx->     raw_buffer)  * avctx->channels * channel_size);
1480     ctx->raw_samples      = av_malloc (sizeof(*ctx->     raw_samples) * avctx->channels);
1481
1482     // allocate previous raw sample buffer
1483     if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
1484         av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1485         decode_end(avctx);
1486         return AVERROR(ENOMEM);
1487     }
1488
1489     // assign raw samples buffers
1490     ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
1491     for (c = 1; c < avctx->channels; c++)
1492         ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
1493
1494     return 0;
1495 }
1496
1497
1498 /** Flushes (resets) the frame ID after seeking.
1499  */
1500 static av_cold void flush(AVCodecContext *avctx)
1501 {
1502     ALSDecContext *ctx = avctx->priv_data;
1503
1504     ctx->frame_id = 0;
1505 }
1506
1507
1508 AVCodec als_decoder = {
1509     "als",
1510     CODEC_TYPE_AUDIO,
1511     CODEC_ID_MP4ALS,
1512     sizeof(ALSDecContext),
1513     decode_init,
1514     NULL,
1515     decode_end,
1516     decode_frame,
1517     .flush = flush,
1518     .capabilities = CODEC_CAP_SUBFRAMES,
1519     .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
1520 };
1521