Statistics
| Branch: | Revision:

ffmpeg / libavcodec / alsdec.c @ 2901cc9a

History | View | Annotate | Download (58.7 KB)

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
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
#include "bgmc.h"
38
#include "dsputil.h"
39
#include "libavutil/crc.h"
40

    
41
#include <stdint.h>
42

    
43
/** Rice parameters and corresponding index offsets for decoding the
44
 *  indices of scaled PARCOR values. The table chosen is set globally
45
 *  by the encoder and stored in ALSSpecificConfig.
46
 */
47
static const int8_t parcor_rice_table[3][20][2] = {
48
    { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
49
      { 12, 3}, { -7, 3}, {  9, 3}, { -5, 3}, {  6, 3},
50
      { -4, 3}, {  3, 3}, { -3, 2}, {  3, 2}, { -2, 2},
51
      {  3, 2}, { -1, 2}, {  2, 2}, { -1, 2}, {  2, 2} },
52
    { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4},
53
      { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4},
54
      {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4},
55
      {  7, 3}, { -4, 4}, {  3, 3}, { -1, 3}, {  1, 3} },
56
    { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4},
57
      { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3},
58
      {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3},
59
      {  3, 3}, {  0, 3}, { -1, 3}, {  2, 3}, { -1, 2} }
60
};
61

    
62

    
63
/** Scaled PARCOR values used for the first two PARCOR coefficients.
64
 *  To be indexed by the Rice coded indices.
65
 *  Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20)
66
 *  Actual values are divided by 32 in order to be stored in 16 bits.
67
 */
68
static const int16_t parcor_scaled_values[] = {
69
    -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32,
70
    -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32,
71
    -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32,
72
    -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32,
73
    -1013728 / 32, -1009376 / 32, -1004768 / 32,  -999904 / 32,
74
     -994784 / 32,  -989408 / 32,  -983776 / 32,  -977888 / 32,
75
     -971744 / 32,  -965344 / 32,  -958688 / 32,  -951776 / 32,
76
     -944608 / 32,  -937184 / 32,  -929504 / 32,  -921568 / 32,
77
     -913376 / 32,  -904928 / 32,  -896224 / 32,  -887264 / 32,
78
     -878048 / 32,  -868576 / 32,  -858848 / 32,  -848864 / 32,
79
     -838624 / 32,  -828128 / 32,  -817376 / 32,  -806368 / 32,
80
     -795104 / 32,  -783584 / 32,  -771808 / 32,  -759776 / 32,
81
     -747488 / 32,  -734944 / 32,  -722144 / 32,  -709088 / 32,
82
     -695776 / 32,  -682208 / 32,  -668384 / 32,  -654304 / 32,
83
     -639968 / 32,  -625376 / 32,  -610528 / 32,  -595424 / 32,
84
     -580064 / 32,  -564448 / 32,  -548576 / 32,  -532448 / 32,
85
     -516064 / 32,  -499424 / 32,  -482528 / 32,  -465376 / 32,
86
     -447968 / 32,  -430304 / 32,  -412384 / 32,  -394208 / 32,
87
     -375776 / 32,  -357088 / 32,  -338144 / 32,  -318944 / 32,
88
     -299488 / 32,  -279776 / 32,  -259808 / 32,  -239584 / 32,
89
     -219104 / 32,  -198368 / 32,  -177376 / 32,  -156128 / 32,
90
     -134624 / 32,  -112864 / 32,   -90848 / 32,   -68576 / 32,
91
      -46048 / 32,   -23264 / 32,     -224 / 32,    23072 / 32,
92
       46624 / 32,    70432 / 32,    94496 / 32,   118816 / 32,
93
      143392 / 32,   168224 / 32,   193312 / 32,   218656 / 32,
94
      244256 / 32,   270112 / 32,   296224 / 32,   322592 / 32,
95
      349216 / 32,   376096 / 32,   403232 / 32,   430624 / 32,
96
      458272 / 32,   486176 / 32,   514336 / 32,   542752 / 32,
97
      571424 / 32,   600352 / 32,   629536 / 32,   658976 / 32,
98
      688672 / 32,   718624 / 32,   748832 / 32,   779296 / 32,
99
      810016 / 32,   840992 / 32,   872224 / 32,   903712 / 32,
100
      935456 / 32,   967456 / 32,   999712 / 32,  1032224 / 32
101
};
102

    
103

    
104
/** Gain values of p(0) for long-term prediction.
105
 *  To be indexed by the Rice coded indices.
106
 */
107
static const uint8_t ltp_gain_values [4][4] = {
108
    { 0,  8, 16,  24},
109
    {32, 40, 48,  56},
110
    {64, 70, 76,  82},
111
    {88, 92, 96, 100}
112
};
113

    
114

    
115
/** Inter-channel weighting factors for multi-channel correlation.
116
 *  To be indexed by the Rice coded indices.
117
 */
118
static const int16_t mcc_weightings[] = {
119
    204,  192,  179,  166,  153,  140,  128,  115,
120
    102,   89,   76,   64,   51,   38,   25,   12,
121
      0,  -12,  -25,  -38,  -51,  -64,  -76,  -89,
122
   -102, -115, -128, -140, -153, -166, -179, -192
123
};
124

    
125

    
126
/** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
127
 */
128
static const uint8_t tail_code[16][6] = {
129
    { 74, 44, 25, 13,  7, 3},
130
    { 68, 42, 24, 13,  7, 3},
131
    { 58, 39, 23, 13,  7, 3},
132
    {126, 70, 37, 19, 10, 5},
133
    {132, 70, 37, 20, 10, 5},
134
    {124, 70, 38, 20, 10, 5},
135
    {120, 69, 37, 20, 11, 5},
136
    {116, 67, 37, 20, 11, 5},
137
    {108, 66, 36, 20, 10, 5},
138
    {102, 62, 36, 20, 10, 5},
139
    { 88, 58, 34, 19, 10, 5},
140
    {162, 89, 49, 25, 13, 7},
141
    {156, 87, 49, 26, 14, 7},
142
    {150, 86, 47, 26, 14, 7},
143
    {142, 84, 47, 26, 14, 7},
144
    {131, 79, 46, 26, 14, 7}
145
};
146

    
147

    
148
enum RA_Flag {
149
    RA_FLAG_NONE,
150
    RA_FLAG_FRAMES,
151
    RA_FLAG_HEADER
152
};
153

    
154

    
155
typedef struct {
156
    uint32_t samples;         ///< number of samples, 0xFFFFFFFF if unknown
157
    int resolution;           ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
158
    int floating;             ///< 1 = IEEE 32-bit floating-point, 0 = integer
159
    int msb_first;            ///< 1 = original CRC calculated on big-endian system, 0 = little-endian
160
    int frame_length;         ///< frame length for each frame (last frame may differ)
161
    int ra_distance;          ///< distance between RA frames (in frames, 0...255)
162
    enum RA_Flag ra_flag;     ///< indicates where the size of ra units is stored
163
    int adapt_order;          ///< adaptive order: 1 = on, 0 = off
164
    int coef_table;           ///< table index of Rice code parameters
165
    int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off
166
    int max_order;            ///< maximum prediction order (0..1023)
167
    int block_switching;      ///< number of block switching levels
168
    int bgmc;                 ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only)
169
    int sb_part;              ///< sub-block partition
170
    int joint_stereo;         ///< joint stereo: 1 = on, 0 = off
171
    int mc_coding;            ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off
172
    int chan_config;          ///< indicates that a chan_config_info field is present
173
    int chan_sort;            ///< channel rearrangement: 1 = on, 0 = off
174
    int rlslms;               ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off
175
    int chan_config_info;     ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented.
176
    int *chan_pos;            ///< original channel positions
177
    int crc_enabled;          ///< enable Cyclic Redundancy Checksum
178
} ALSSpecificConfig;
179

    
180

    
181
typedef struct {
182
    int stop_flag;
183
    int master_channel;
184
    int time_diff_flag;
185
    int time_diff_sign;
186
    int time_diff_index;
187
    int weighting[6];
188
} ALSChannelData;
189

    
190

    
191
typedef struct {
192
    AVCodecContext *avctx;
193
    ALSSpecificConfig sconf;
194
    GetBitContext gb;
195
    DSPContext dsp;
196
    const AVCRC *crc_table;
197
    uint32_t crc_org;               ///< CRC value of the original input data
198
    uint32_t crc;                   ///< CRC value calculated from decoded data
199
    unsigned int cur_frame_length;  ///< length of the current frame to decode
200
    unsigned int frame_id;          ///< the frame ID / number of the current frame
201
    unsigned int js_switch;         ///< if true, joint-stereo decoding is enforced
202
    unsigned int num_blocks;        ///< number of blocks used in the current frame
203
    unsigned int s_max;             ///< maximum Rice parameter allowed in entropy coding
204
    uint8_t *bgmc_lut;              ///< pointer at lookup tables used for BGMC
205
    unsigned int *bgmc_lut_status;  ///< pointer at lookup table status flags used for BGMC
206
    int ltp_lag_length;             ///< number of bits used for ltp lag value
207
    int *use_ltp;                   ///< contains use_ltp flags for all channels
208
    int *ltp_lag;                   ///< contains ltp lag values for all channels
209
    int **ltp_gain;                 ///< gain values for ltp 5-tap filter for a channel
210
    int *ltp_gain_buffer;           ///< contains all gain values for ltp 5-tap filter
211
    int32_t **quant_cof;            ///< quantized parcor coefficients for a channel
212
    int32_t *quant_cof_buffer;      ///< contains all quantized parcor coefficients
213
    int32_t **lpc_cof;              ///< coefficients of the direct form prediction filter for a channel
214
    int32_t *lpc_cof_buffer;        ///< contains all coefficients of the direct form prediction filter
215
    int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
216
    ALSChannelData **chan_data;     ///< channel data for multi-channel correlation
217
    ALSChannelData *chan_data_buffer; ///< contains channel data for all channels
218
    int *reverted_channels;         ///< stores a flag for each reverted channel
219
    int32_t *prev_raw_samples;      ///< contains unshifted raw samples from the previous block
220
    int32_t **raw_samples;          ///< decoded raw samples for each channel
221
    int32_t *raw_buffer;            ///< contains all decoded raw samples including carryover samples
222
    uint8_t *crc_buffer;            ///< buffer of byte order corrected samples used for CRC check
223
} ALSDecContext;
224

    
225

    
226
typedef struct {
227
    unsigned int block_length;      ///< number of samples within the block
228
    unsigned int ra_block;          ///< if true, this is a random access block
229
    int          const_block;       ///< if true, this is a constant value block
230
    int32_t      const_val;         ///< the sample value of a constant block
231
    int          js_blocks;         ///< true if this block contains a difference signal
232
    unsigned int shift_lsbs;        ///< shift of values for this block
233
    unsigned int opt_order;         ///< prediction order of this block
234
    int          store_prev_samples;///< if true, carryover samples have to be stored
235
    int          *use_ltp;          ///< if true, long-term prediction is used
236
    int          *ltp_lag;          ///< lag value for long-term prediction
237
    int          *ltp_gain;         ///< gain values for ltp 5-tap filter
238
    int32_t      *quant_cof;        ///< quantized parcor coefficients
239
    int32_t      *lpc_cof;          ///< coefficients of the direct form prediction
240
    int32_t      *raw_samples;      ///< decoded raw samples / residuals for this block
241
    int32_t      *prev_raw_samples; ///< contains unshifted raw samples from the previous block
242
    int32_t      *raw_other;        ///< decoded raw samples of the other channel of a channel pair
243
} ALSBlockData;
244

    
245

    
246
static av_cold void dprint_specific_config(ALSDecContext *ctx)
247
{
248
#ifdef DEBUG
249
    AVCodecContext *avctx    = ctx->avctx;
250
    ALSSpecificConfig *sconf = &ctx->sconf;
251

    
252
    dprintf(avctx, "resolution = %i\n",           sconf->resolution);
253
    dprintf(avctx, "floating = %i\n",             sconf->floating);
254
    dprintf(avctx, "frame_length = %i\n",         sconf->frame_length);
255
    dprintf(avctx, "ra_distance = %i\n",          sconf->ra_distance);
256
    dprintf(avctx, "ra_flag = %i\n",              sconf->ra_flag);
257
    dprintf(avctx, "adapt_order = %i\n",          sconf->adapt_order);
258
    dprintf(avctx, "coef_table = %i\n",           sconf->coef_table);
259
    dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction);
260
    dprintf(avctx, "max_order = %i\n",            sconf->max_order);
261
    dprintf(avctx, "block_switching = %i\n",      sconf->block_switching);
262
    dprintf(avctx, "bgmc = %i\n",                 sconf->bgmc);
263
    dprintf(avctx, "sb_part = %i\n",              sconf->sb_part);
264
    dprintf(avctx, "joint_stereo = %i\n",         sconf->joint_stereo);
265
    dprintf(avctx, "mc_coding = %i\n",            sconf->mc_coding);
266
    dprintf(avctx, "chan_config = %i\n",          sconf->chan_config);
267
    dprintf(avctx, "chan_sort = %i\n",            sconf->chan_sort);
268
    dprintf(avctx, "RLSLMS = %i\n",               sconf->rlslms);
269
    dprintf(avctx, "chan_config_info = %i\n",     sconf->chan_config_info);
270
#endif
271
}
272

    
273

    
274
/** Read an ALSSpecificConfig from a buffer into the output struct.
275
 */
276
static av_cold int read_specific_config(ALSDecContext *ctx)
277
{
278
    GetBitContext gb;
279
    uint64_t ht_size;
280
    int i, config_offset;
281
    MPEG4AudioConfig m4ac;
282
    ALSSpecificConfig *sconf = &ctx->sconf;
283
    AVCodecContext *avctx    = ctx->avctx;
284
    uint32_t als_id, header_size, trailer_size;
285

    
286
    init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8);
287

    
288
    config_offset = ff_mpeg4audio_get_config(&m4ac, avctx->extradata,
289
                                             avctx->extradata_size);
290

    
291
    if (config_offset < 0)
292
        return -1;
293

    
294
    skip_bits_long(&gb, config_offset);
295

    
296
    if (get_bits_left(&gb) < (30 << 3))
297
        return -1;
298

    
299
    // read the fixed items
300
    als_id                      = get_bits_long(&gb, 32);
301
    avctx->sample_rate          = m4ac.sample_rate;
302
    skip_bits_long(&gb, 32); // sample rate already known
303
    sconf->samples              = get_bits_long(&gb, 32);
304
    avctx->channels             = m4ac.channels;
305
    skip_bits(&gb, 16);      // number of channels already knwon
306
    skip_bits(&gb, 3);       // skip file_type
307
    sconf->resolution           = get_bits(&gb, 3);
308
    sconf->floating             = get_bits1(&gb);
309
    sconf->msb_first            = get_bits1(&gb);
310
    sconf->frame_length         = get_bits(&gb, 16) + 1;
311
    sconf->ra_distance          = get_bits(&gb, 8);
312
    sconf->ra_flag              = get_bits(&gb, 2);
313
    sconf->adapt_order          = get_bits1(&gb);
314
    sconf->coef_table           = get_bits(&gb, 2);
315
    sconf->long_term_prediction = get_bits1(&gb);
316
    sconf->max_order            = get_bits(&gb, 10);
317
    sconf->block_switching      = get_bits(&gb, 2);
318
    sconf->bgmc                 = get_bits1(&gb);
319
    sconf->sb_part              = get_bits1(&gb);
320
    sconf->joint_stereo         = get_bits1(&gb);
321
    sconf->mc_coding            = get_bits1(&gb);
322
    sconf->chan_config          = get_bits1(&gb);
323
    sconf->chan_sort            = get_bits1(&gb);
324
    sconf->crc_enabled          = get_bits1(&gb);
325
    sconf->rlslms               = get_bits1(&gb);
326
    skip_bits(&gb, 5);       // skip 5 reserved bits
327
    skip_bits1(&gb);         // skip aux_data_enabled
328

    
329

    
330
    // check for ALSSpecificConfig struct
331
    if (als_id != MKBETAG('A','L','S','\0'))
332
        return -1;
333

    
334
    ctx->cur_frame_length = sconf->frame_length;
335

    
336
    // read channel config
337
    if (sconf->chan_config)
338
        sconf->chan_config_info = get_bits(&gb, 16);
339
    // TODO: use this to set avctx->channel_layout
340

    
341

    
342
    // read channel sorting
343
    if (sconf->chan_sort && avctx->channels > 1) {
344
        int chan_pos_bits = av_ceil_log2(avctx->channels);
345
        int bits_needed  = avctx->channels * chan_pos_bits + 7;
346
        if (get_bits_left(&gb) < bits_needed)
347
            return -1;
348

    
349
        if (!(sconf->chan_pos = av_malloc(avctx->channels * sizeof(*sconf->chan_pos))))
350
            return AVERROR(ENOMEM);
351

    
352
        for (i = 0; i < avctx->channels; i++)
353
            sconf->chan_pos[i] = get_bits(&gb, chan_pos_bits);
354

    
355
        align_get_bits(&gb);
356
        // TODO: use this to actually do channel sorting
357
    } else {
358
        sconf->chan_sort = 0;
359
    }
360

    
361

    
362
    // read fixed header and trailer sizes,
363
    // if size = 0xFFFFFFFF then there is no data field!
364
    if (get_bits_left(&gb) < 64)
365
        return -1;
366

    
367
    header_size  = get_bits_long(&gb, 32);
368
    trailer_size = get_bits_long(&gb, 32);
369
    if (header_size  == 0xFFFFFFFF)
370
        header_size  = 0;
371
    if (trailer_size == 0xFFFFFFFF)
372
        trailer_size = 0;
373

    
374
    ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3;
375

    
376

    
377
    // skip the header and trailer data
378
    if (get_bits_left(&gb) < ht_size)
379
        return -1;
380

    
381
    if (ht_size > INT32_MAX)
382
        return -1;
383

    
384
    skip_bits_long(&gb, ht_size);
385

    
386

    
387
    // initialize CRC calculation
388
    if (sconf->crc_enabled) {
389
        if (get_bits_left(&gb) < 32)
390
            return -1;
391

    
392
        if (avctx->error_recognition >= FF_ER_CAREFUL) {
393
            ctx->crc_table = av_crc_get_table(AV_CRC_32_IEEE_LE);
394
            ctx->crc       = 0xFFFFFFFF;
395
            ctx->crc_org   = ~get_bits_long(&gb, 32);
396
        } else
397
            skip_bits_long(&gb, 32);
398
    }
399

    
400

    
401
    // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data)
402

    
403
    dprint_specific_config(ctx);
404

    
405
    return 0;
406
}
407

    
408

    
409
/** Check the ALSSpecificConfig for unsupported features.
410
 */
411
static int check_specific_config(ALSDecContext *ctx)
412
{
413
    ALSSpecificConfig *sconf = &ctx->sconf;
414
    int error = 0;
415

    
416
    // report unsupported feature and set error value
417
    #define MISSING_ERR(cond, str, errval)              \
418
    {                                                   \
419
        if (cond) {                                     \
420
            av_log_missing_feature(ctx->avctx, str, 0); \
421
            error = errval;                             \
422
        }                                               \
423
    }
424

    
425
    MISSING_ERR(sconf->floating,             "Floating point decoding",     -1);
426
    MISSING_ERR(sconf->rlslms,               "Adaptive RLS-LMS prediction", -1);
427
    MISSING_ERR(sconf->chan_sort,            "Channel sorting",              0);
428

    
429
    return error;
430
}
431

    
432

    
433
/** Parse the bs_info field to extract the block partitioning used in
434
 *  block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
435
 */
436
static void parse_bs_info(const uint32_t bs_info, unsigned int n,
437
                          unsigned int div, unsigned int **div_blocks,
438
                          unsigned int *num_blocks)
439
{
440
    if (n < 31 && ((bs_info << n) & 0x40000000)) {
441
        // if the level is valid and the investigated bit n is set
442
        // then recursively check both children at bits (2n+1) and (2n+2)
443
        n   *= 2;
444
        div += 1;
445
        parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks);
446
        parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks);
447
    } else {
448
        // else the bit is not set or the last level has been reached
449
        // (bit implicitly not set)
450
        **div_blocks = div;
451
        (*div_blocks)++;
452
        (*num_blocks)++;
453
    }
454
}
455

    
456

    
457
/** Read and decode a Rice codeword.
458
 */
459
static int32_t decode_rice(GetBitContext *gb, unsigned int k)
460
{
461
    int max = get_bits_left(gb) - k;
462
    int q   = get_unary(gb, 0, max);
463
    int r   = k ? get_bits1(gb) : !(q & 1);
464

    
465
    if (k > 1) {
466
        q <<= (k - 1);
467
        q  += get_bits_long(gb, k - 1);
468
    } else if (!k) {
469
        q >>= 1;
470
    }
471
    return r ? q : ~q;
472
}
473

    
474

    
475
/** Convert PARCOR coefficient k to direct filter coefficient.
476
 */
477
static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof)
478
{
479
    int i, j;
480

    
481
    for (i = 0, j = k - 1; i < j; i++, j--) {
482
        int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
483
        cof[j]  += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20);
484
        cof[i]  += tmp1;
485
    }
486
    if (i == j)
487
        cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20);
488

    
489
    cof[k] = par[k];
490
}
491

    
492

    
493
/** Read block switching field if necessary and set actual block sizes.
494
 *  Also assure that the block sizes of the last frame correspond to the
495
 *  actual number of samples.
496
 */
497
static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks,
498
                            uint32_t *bs_info)
499
{
500
    ALSSpecificConfig *sconf     = &ctx->sconf;
501
    GetBitContext *gb            = &ctx->gb;
502
    unsigned int *ptr_div_blocks = div_blocks;
503
    unsigned int b;
504

    
505
    if (sconf->block_switching) {
506
        unsigned int bs_info_len = 1 << (sconf->block_switching + 2);
507
        *bs_info = get_bits_long(gb, bs_info_len);
508
        *bs_info <<= (32 - bs_info_len);
509
    }
510

    
511
    ctx->num_blocks = 0;
512
    parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks);
513

    
514
    // The last frame may have an overdetermined block structure given in
515
    // the bitstream. In that case the defined block structure would need
516
    // more samples than available to be consistent.
517
    // The block structure is actually used but the block sizes are adapted
518
    // to fit the actual number of available samples.
519
    // Example: 5 samples, 2nd level block sizes: 2 2 2 2.
520
    // This results in the actual block sizes:    2 2 1 0.
521
    // This is not specified in 14496-3 but actually done by the reference
522
    // codec RM22 revision 2.
523
    // This appears to happen in case of an odd number of samples in the last
524
    // frame which is actually not allowed by the block length switching part
525
    // of 14496-3.
526
    // The ALS conformance files feature an odd number of samples in the last
527
    // frame.
528

    
529
    for (b = 0; b < ctx->num_blocks; b++)
530
        div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
531

    
532
    if (ctx->cur_frame_length != ctx->sconf.frame_length) {
533
        unsigned int remaining = ctx->cur_frame_length;
534

    
535
        for (b = 0; b < ctx->num_blocks; b++) {
536
            if (remaining <= div_blocks[b]) {
537
                div_blocks[b] = remaining;
538
                ctx->num_blocks = b + 1;
539
                break;
540
            }
541

    
542
            remaining -= div_blocks[b];
543
        }
544
    }
545
}
546

    
547

    
548
/** Read the block data for a constant block
549
 */
550
static void read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
551
{
552
    ALSSpecificConfig *sconf = &ctx->sconf;
553
    AVCodecContext *avctx    = ctx->avctx;
554
    GetBitContext *gb        = &ctx->gb;
555

    
556
    bd->const_val    = 0;
557
    bd->const_block  = get_bits1(gb);    // 1 = constant value, 0 = zero block (silence)
558
    bd->js_blocks    = get_bits1(gb);
559

    
560
    // skip 5 reserved bits
561
    skip_bits(gb, 5);
562

    
563
    if (bd->const_block) {
564
        unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample;
565
        bd->const_val = get_sbits_long(gb, const_val_bits);
566
    }
567

    
568
    // ensure constant block decoding by reusing this field
569
    bd->const_block = 1;
570
}
571

    
572

    
573
/** Decode the block data for a constant block
574
 */
575
static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd)
576
{
577
    int      smp = bd->block_length;
578
    int32_t  val = bd->const_val;
579
    int32_t *dst = bd->raw_samples;
580

    
581
    // write raw samples into buffer
582
    for (; smp; smp--)
583
        *dst++ = val;
584
}
585

    
586

    
587
/** Read the block data for a non-constant block
588
 */
589
static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
590
{
591
    ALSSpecificConfig *sconf = &ctx->sconf;
592
    AVCodecContext *avctx    = ctx->avctx;
593
    GetBitContext *gb        = &ctx->gb;
594
    unsigned int k;
595
    unsigned int s[8];
596
    unsigned int sx[8];
597
    unsigned int sub_blocks, log2_sub_blocks, sb_length;
598
    unsigned int start      = 0;
599
    unsigned int opt_order;
600
    int          sb;
601
    int32_t      *quant_cof = bd->quant_cof;
602
    int32_t      *current_res;
603

    
604

    
605
    // ensure variable block decoding by reusing this field
606
    bd->const_block = 0;
607

    
608
    bd->opt_order   = 1;
609
    bd->js_blocks   = get_bits1(gb);
610

    
611
    opt_order       = bd->opt_order;
612

    
613
    // determine the number of subblocks for entropy decoding
614
    if (!sconf->bgmc && !sconf->sb_part) {
615
        log2_sub_blocks = 0;
616
    } else {
617
        if (sconf->bgmc && sconf->sb_part)
618
            log2_sub_blocks = get_bits(gb, 2);
619
        else
620
            log2_sub_blocks = 2 * get_bits1(gb);
621
    }
622

    
623
    sub_blocks = 1 << log2_sub_blocks;
624

    
625
    // do not continue in case of a damaged stream since
626
    // block_length must be evenly divisible by sub_blocks
627
    if (bd->block_length & (sub_blocks - 1)) {
628
        av_log(avctx, AV_LOG_WARNING,
629
               "Block length is not evenly divisible by the number of subblocks.\n");
630
        return -1;
631
    }
632

    
633
    sb_length = bd->block_length >> log2_sub_blocks;
634

    
635
    if (sconf->bgmc) {
636
        s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
637
        for (k = 1; k < sub_blocks; k++)
638
            s[k] = s[k - 1] + decode_rice(gb, 2);
639

    
640
        for (k = 0; k < sub_blocks; k++) {
641
            sx[k]   = s[k] & 0x0F;
642
            s [k] >>= 4;
643
        }
644
    } else {
645
        s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
646
        for (k = 1; k < sub_blocks; k++)
647
            s[k] = s[k - 1] + decode_rice(gb, 0);
648
    }
649

    
650
    if (get_bits1(gb))
651
        bd->shift_lsbs = get_bits(gb, 4) + 1;
652

    
653
    bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || bd->shift_lsbs;
654

    
655

    
656
    if (!sconf->rlslms) {
657
        if (sconf->adapt_order) {
658
            int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1,
659
                                                2, sconf->max_order + 1));
660
            bd->opt_order        = get_bits(gb, opt_order_length);
661
        } else {
662
            bd->opt_order = sconf->max_order;
663
        }
664

    
665
        opt_order = bd->opt_order;
666

    
667
        if (opt_order) {
668
            int add_base;
669

    
670
            if (sconf->coef_table == 3) {
671
                add_base = 0x7F;
672

    
673
                // read coefficient 0
674
                quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)];
675

    
676
                // read coefficient 1
677
                if (opt_order > 1)
678
                    quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)];
679

    
680
                // read coefficients 2 to opt_order
681
                for (k = 2; k < opt_order; k++)
682
                    quant_cof[k] = get_bits(gb, 7);
683
            } else {
684
                int k_max;
685
                add_base = 1;
686

    
687
                // read coefficient 0 to 19
688
                k_max = FFMIN(opt_order, 20);
689
                for (k = 0; k < k_max; k++) {
690
                    int rice_param = parcor_rice_table[sconf->coef_table][k][1];
691
                    int offset     = parcor_rice_table[sconf->coef_table][k][0];
692
                    quant_cof[k] = decode_rice(gb, rice_param) + offset;
693
                }
694

    
695
                // read coefficients 20 to 126
696
                k_max = FFMIN(opt_order, 127);
697
                for (; k < k_max; k++)
698
                    quant_cof[k] = decode_rice(gb, 2) + (k & 1);
699

    
700
                // read coefficients 127 to opt_order
701
                for (; k < opt_order; k++)
702
                    quant_cof[k] = decode_rice(gb, 1);
703

    
704
                quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64];
705

    
706
                if (opt_order > 1)
707
                    quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64];
708
            }
709

    
710
            for (k = 2; k < opt_order; k++)
711
                quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
712
        }
713
    }
714

    
715
    // read LTP gain and lag values
716
    if (sconf->long_term_prediction) {
717
        *bd->use_ltp = get_bits1(gb);
718

    
719
        if (*bd->use_ltp) {
720
            int r, c;
721

    
722
            bd->ltp_gain[0]   = decode_rice(gb, 1) << 3;
723
            bd->ltp_gain[1]   = decode_rice(gb, 2) << 3;
724

    
725
            r                 = get_unary(gb, 0, 4);
726
            c                 = get_bits(gb, 2);
727
            bd->ltp_gain[2]   = ltp_gain_values[r][c];
728

    
729
            bd->ltp_gain[3]   = decode_rice(gb, 2) << 3;
730
            bd->ltp_gain[4]   = decode_rice(gb, 1) << 3;
731

    
732
            *bd->ltp_lag      = get_bits(gb, ctx->ltp_lag_length);
733
            *bd->ltp_lag     += FFMAX(4, opt_order + 1);
734
        }
735
    }
736

    
737
    // read first value and residuals in case of a random access block
738
    if (bd->ra_block) {
739
        if (opt_order)
740
            bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
741
        if (opt_order > 1)
742
            bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
743
        if (opt_order > 2)
744
            bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
745

    
746
        start = FFMIN(opt_order, 3);
747
    }
748

    
749
    // read all residuals
750
    if (sconf->bgmc) {
751
        unsigned int delta[8];
752
        unsigned int k    [8];
753
        unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
754
        unsigned int i = start;
755

    
756
        // read most significant bits
757
        unsigned int high;
758
        unsigned int low;
759
        unsigned int value;
760

    
761
        ff_bgmc_decode_init(gb, &high, &low, &value);
762

    
763
        current_res = bd->raw_samples + start;
764

    
765
        for (sb = 0; sb < sub_blocks; sb++, i = 0) {
766
            k    [sb] = s[sb] > b ? s[sb] - b : 0;
767
            delta[sb] = 5 - s[sb] + k[sb];
768

    
769
            ff_bgmc_decode(gb, sb_length, current_res,
770
                        delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
771

    
772
            current_res += sb_length;
773
        }
774

    
775
        ff_bgmc_decode_end(gb);
776

    
777

    
778
        // read least significant bits and tails
779
        i = start;
780
        current_res = bd->raw_samples + start;
781

    
782
        for (sb = 0; sb < sub_blocks; sb++, i = 0) {
783
            unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
784
            unsigned int cur_k         = k[sb];
785
            unsigned int cur_s         = s[sb];
786

    
787
            for (; i < sb_length; i++) {
788
                int32_t res = *current_res;
789

    
790
                if (res == cur_tail_code) {
791
                    unsigned int max_msb =   (2 + (sx[sb] > 2) + (sx[sb] > 10))
792
                                          << (5 - delta[sb]);
793

    
794
                    res = decode_rice(gb, cur_s);
795

    
796
                    if (res >= 0) {
797
                        res += (max_msb    ) << cur_k;
798
                    } else {
799
                        res -= (max_msb - 1) << cur_k;
800
                    }
801
                } else {
802
                    if (res > cur_tail_code)
803
                        res--;
804

    
805
                    if (res & 1)
806
                        res = -res;
807

    
808
                    res >>= 1;
809

    
810
                    if (cur_k) {
811
                        res <<= cur_k;
812
                        res  |= get_bits_long(gb, cur_k);
813
                    }
814
                }
815

    
816
                *current_res++ = res;
817
            }
818
        }
819
    } else {
820
        current_res = bd->raw_samples + start;
821

    
822
        for (sb = 0; sb < sub_blocks; sb++, start = 0)
823
            for (; start < sb_length; start++)
824
                *current_res++ = decode_rice(gb, s[sb]);
825
     }
826

    
827
    if (!sconf->mc_coding || ctx->js_switch)
828
        align_get_bits(gb);
829

    
830
    return 0;
831
}
832

    
833

    
834
/** Decode the block data for a non-constant block
835
 */
836
static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
837
{
838
    ALSSpecificConfig *sconf = &ctx->sconf;
839
    unsigned int block_length = bd->block_length;
840
    unsigned int smp = 0;
841
    unsigned int k;
842
    int opt_order             = bd->opt_order;
843
    int sb;
844
    int64_t y;
845
    int32_t *quant_cof        = bd->quant_cof;
846
    int32_t *lpc_cof          = bd->lpc_cof;
847
    int32_t *raw_samples      = bd->raw_samples;
848
    int32_t *raw_samples_end  = bd->raw_samples + bd->block_length;
849
    int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer;
850

    
851
    // reverse long-term prediction
852
    if (*bd->use_ltp) {
853
        int ltp_smp;
854

    
855
        for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) {
856
            int center = ltp_smp - *bd->ltp_lag;
857
            int begin  = FFMAX(0, center - 2);
858
            int end    = center + 3;
859
            int tab    = 5 - (end - begin);
860
            int base;
861

    
862
            y = 1 << 6;
863

    
864
            for (base = begin; base < end; base++, tab++)
865
                y += MUL64(bd->ltp_gain[tab], raw_samples[base]);
866

    
867
            raw_samples[ltp_smp] += y >> 7;
868
        }
869
    }
870

    
871
    // reconstruct all samples from residuals
872
    if (bd->ra_block) {
873
        for (smp = 0; smp < opt_order; smp++) {
874
            y = 1 << 19;
875

    
876
            for (sb = 0; sb < smp; sb++)
877
                y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]);
878

    
879
            *raw_samples++ -= y >> 20;
880
            parcor_to_lpc(smp, quant_cof, lpc_cof);
881
        }
882
    } else {
883
        for (k = 0; k < opt_order; k++)
884
            parcor_to_lpc(k, quant_cof, lpc_cof);
885

    
886
        // store previous samples in case that they have to be altered
887
        if (bd->store_prev_samples)
888
            memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order,
889
                   sizeof(*bd->prev_raw_samples) * sconf->max_order);
890

    
891
        // reconstruct difference signal for prediction (joint-stereo)
892
        if (bd->js_blocks && bd->raw_other) {
893
            int32_t *left, *right;
894

    
895
            if (bd->raw_other > raw_samples) {  // D = R - L
896
                left  = raw_samples;
897
                right = bd->raw_other;
898
            } else {                                // D = R - L
899
                left  = bd->raw_other;
900
                right = raw_samples;
901
            }
902

    
903
            for (sb = -1; sb >= -sconf->max_order; sb--)
904
                raw_samples[sb] = right[sb] - left[sb];
905
        }
906

    
907
        // reconstruct shifted signal
908
        if (bd->shift_lsbs)
909
            for (sb = -1; sb >= -sconf->max_order; sb--)
910
                raw_samples[sb] >>= bd->shift_lsbs;
911
    }
912

    
913
    // reverse linear prediction coefficients for efficiency
914
    lpc_cof = lpc_cof + opt_order;
915

    
916
    for (sb = 0; sb < opt_order; sb++)
917
        lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)];
918

    
919
    // reconstruct raw samples
920
    raw_samples = bd->raw_samples + smp;
921
    lpc_cof     = lpc_cof_reversed + opt_order;
922

    
923
    for (; raw_samples < raw_samples_end; raw_samples++) {
924
        y = 1 << 19;
925

    
926
        for (sb = -opt_order; sb < 0; sb++)
927
            y += MUL64(lpc_cof[sb], raw_samples[sb]);
928

    
929
        *raw_samples -= y >> 20;
930
    }
931

    
932
    raw_samples = bd->raw_samples;
933

    
934
    // restore previous samples in case that they have been altered
935
    if (bd->store_prev_samples)
936
        memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples,
937
               sizeof(*raw_samples) * sconf->max_order);
938

    
939
    return 0;
940
}
941

    
942

    
943
/** Read the block data.
944
 */
945
static int read_block(ALSDecContext *ctx, ALSBlockData *bd)
946
{
947
    GetBitContext *gb        = &ctx->gb;
948

    
949
    // read block type flag and read the samples accordingly
950
    if (get_bits1(gb)) {
951
        if (read_var_block_data(ctx, bd))
952
            return -1;
953
    } else {
954
        read_const_block_data(ctx, bd);
955
    }
956

    
957
    return 0;
958
}
959

    
960

    
961
/** Decode the block data.
962
 */
963
static int decode_block(ALSDecContext *ctx, ALSBlockData *bd)
964
{
965
    unsigned int smp;
966

    
967
    // read block type flag and read the samples accordingly
968
    if (bd->const_block)
969
        decode_const_block_data(ctx, bd);
970
    else if (decode_var_block_data(ctx, bd))
971
        return -1;
972

    
973
    // TODO: read RLSLMS extension data
974

    
975
    if (bd->shift_lsbs)
976
        for (smp = 0; smp < bd->block_length; smp++)
977
            bd->raw_samples[smp] <<= bd->shift_lsbs;
978

    
979
    return 0;
980
}
981

    
982

    
983
/** Read and decode block data successively.
984
 */
985
static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
986
{
987
    int ret;
988

    
989
    ret = read_block(ctx, bd);
990

    
991
    if (ret)
992
        return ret;
993

    
994
    ret = decode_block(ctx, bd);
995

    
996
    return ret;
997
}
998

    
999

    
1000
/** Compute the number of samples left to decode for the current frame and
1001
 *  sets these samples to zero.
1002
 */
1003
static void zero_remaining(unsigned int b, unsigned int b_max,
1004
                           const unsigned int *div_blocks, int32_t *buf)
1005
{
1006
    unsigned int count = 0;
1007

    
1008
    while (b < b_max)
1009
        count += div_blocks[b];
1010

    
1011
    if (count)
1012
        memset(buf, 0, sizeof(*buf) * count);
1013
}
1014

    
1015

    
1016
/** Decode blocks independently.
1017
 */
1018
static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame,
1019
                             unsigned int c, const unsigned int *div_blocks,
1020
                             unsigned int *js_blocks)
1021
{
1022
    unsigned int b;
1023
    ALSBlockData bd;
1024

    
1025
    memset(&bd, 0, sizeof(ALSBlockData));
1026

    
1027
    bd.ra_block         = ra_frame;
1028
    bd.use_ltp          = ctx->use_ltp;
1029
    bd.ltp_lag          = ctx->ltp_lag;
1030
    bd.ltp_gain         = ctx->ltp_gain[0];
1031
    bd.quant_cof        = ctx->quant_cof[0];
1032
    bd.lpc_cof          = ctx->lpc_cof[0];
1033
    bd.prev_raw_samples = ctx->prev_raw_samples;
1034
    bd.raw_samples      = ctx->raw_samples[c];
1035

    
1036

    
1037
    for (b = 0; b < ctx->num_blocks; b++) {
1038
        bd.shift_lsbs       = 0;
1039
        bd.block_length     = div_blocks[b];
1040

    
1041
        if (read_decode_block(ctx, &bd)) {
1042
            // damaged block, write zero for the rest of the frame
1043
            zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples);
1044
            return -1;
1045
        }
1046
        bd.raw_samples += div_blocks[b];
1047
        bd.ra_block     = 0;
1048
    }
1049

    
1050
    return 0;
1051
}
1052

    
1053

    
1054
/** Decode blocks dependently.
1055
 */
1056
static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame,
1057
                         unsigned int c, const unsigned int *div_blocks,
1058
                         unsigned int *js_blocks)
1059
{
1060
    ALSSpecificConfig *sconf = &ctx->sconf;
1061
    unsigned int offset = 0;
1062
    unsigned int b;
1063
    ALSBlockData bd[2];
1064

    
1065
    memset(bd, 0, 2 * sizeof(ALSBlockData));
1066

    
1067
    bd[0].ra_block         = ra_frame;
1068
    bd[0].use_ltp          = ctx->use_ltp;
1069
    bd[0].ltp_lag          = ctx->ltp_lag;
1070
    bd[0].ltp_gain         = ctx->ltp_gain[0];
1071
    bd[0].quant_cof        = ctx->quant_cof[0];
1072
    bd[0].lpc_cof          = ctx->lpc_cof[0];
1073
    bd[0].prev_raw_samples = ctx->prev_raw_samples;
1074
    bd[0].js_blocks        = *js_blocks;
1075

    
1076
    bd[1].ra_block         = ra_frame;
1077
    bd[1].use_ltp          = ctx->use_ltp;
1078
    bd[1].ltp_lag          = ctx->ltp_lag;
1079
    bd[1].ltp_gain         = ctx->ltp_gain[0];
1080
    bd[1].quant_cof        = ctx->quant_cof[0];
1081
    bd[1].lpc_cof          = ctx->lpc_cof[0];
1082
    bd[1].prev_raw_samples = ctx->prev_raw_samples;
1083
    bd[1].js_blocks        = *(js_blocks + 1);
1084

    
1085
    // decode all blocks
1086
    for (b = 0; b < ctx->num_blocks; b++) {
1087
        unsigned int s;
1088

    
1089
        bd[0].shift_lsbs   = 0;
1090
        bd[1].shift_lsbs   = 0;
1091

    
1092
        bd[0].block_length = div_blocks[b];
1093
        bd[1].block_length = div_blocks[b];
1094

    
1095
        bd[0].raw_samples  = ctx->raw_samples[c    ] + offset;
1096
        bd[1].raw_samples  = ctx->raw_samples[c + 1] + offset;
1097

    
1098
        bd[0].raw_other    = bd[1].raw_samples;
1099
        bd[1].raw_other    = bd[0].raw_samples;
1100

    
1101
        if(read_decode_block(ctx, &bd[0]) || read_decode_block(ctx, &bd[1])) {
1102
            // damaged block, write zero for the rest of the frame
1103
            zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples);
1104
            zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples);
1105
            return -1;
1106
        }
1107

    
1108
        // reconstruct joint-stereo blocks
1109
        if (bd[0].js_blocks) {
1110
            if (bd[1].js_blocks)
1111
                av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n");
1112

    
1113
            for (s = 0; s < div_blocks[b]; s++)
1114
                bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s];
1115
        } else if (bd[1].js_blocks) {
1116
            for (s = 0; s < div_blocks[b]; s++)
1117
                bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s];
1118
        }
1119

    
1120
        offset  += div_blocks[b];
1121
        bd[0].ra_block = 0;
1122
        bd[1].ra_block = 0;
1123
    }
1124

    
1125
    // store carryover raw samples,
1126
    // the others channel raw samples are stored by the calling function.
1127
    memmove(ctx->raw_samples[c] - sconf->max_order,
1128
            ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1129
            sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1130

    
1131
    return 0;
1132
}
1133

    
1134

    
1135
/** Read the channel data.
1136
  */
1137
static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c)
1138
{
1139
    GetBitContext *gb       = &ctx->gb;
1140
    ALSChannelData *current = cd;
1141
    unsigned int channels   = ctx->avctx->channels;
1142
    int entries             = 0;
1143

    
1144
    while (entries < channels && !(current->stop_flag = get_bits1(gb))) {
1145
        current->master_channel = get_bits_long(gb, av_ceil_log2(channels));
1146

    
1147
        if (current->master_channel >= channels) {
1148
            av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel!\n");
1149
            return -1;
1150
        }
1151

    
1152
        if (current->master_channel != c) {
1153
            current->time_diff_flag = get_bits1(gb);
1154
            current->weighting[0]   = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1155
            current->weighting[1]   = mcc_weightings[av_clip(decode_rice(gb, 2) + 14, 0, 32)];
1156
            current->weighting[2]   = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1157

    
1158
            if (current->time_diff_flag) {
1159
                current->weighting[3] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1160
                current->weighting[4] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1161
                current->weighting[5] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)];
1162

    
1163
                current->time_diff_sign  = get_bits1(gb);
1164
                current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3;
1165
            }
1166
        }
1167

    
1168
        current++;
1169
        entries++;
1170
    }
1171

    
1172
    if (entries == channels) {
1173
        av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data!\n");
1174
        return -1;
1175
    }
1176

    
1177
    align_get_bits(gb);
1178
    return 0;
1179
}
1180

    
1181

    
1182
/** Recursively reverts the inter-channel correlation for a block.
1183
 */
1184
static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd,
1185
                                       ALSChannelData **cd, int *reverted,
1186
                                       unsigned int offset, int c)
1187
{
1188
    ALSChannelData *ch = cd[c];
1189
    unsigned int   dep = 0;
1190
    unsigned int channels = ctx->avctx->channels;
1191

    
1192
    if (reverted[c])
1193
        return 0;
1194

    
1195
    reverted[c] = 1;
1196

    
1197
    while (dep < channels && !ch[dep].stop_flag) {
1198
        revert_channel_correlation(ctx, bd, cd, reverted, offset,
1199
                                   ch[dep].master_channel);
1200

    
1201
        dep++;
1202
    }
1203

    
1204
    if (dep == channels) {
1205
        av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation!\n");
1206
        return -1;
1207
    }
1208

    
1209
    bd->use_ltp     = ctx->use_ltp + c;
1210
    bd->ltp_lag     = ctx->ltp_lag + c;
1211
    bd->ltp_gain    = ctx->ltp_gain[c];
1212
    bd->lpc_cof     = ctx->lpc_cof[c];
1213
    bd->quant_cof   = ctx->quant_cof[c];
1214
    bd->raw_samples = ctx->raw_samples[c] + offset;
1215

    
1216
    dep = 0;
1217
    while (!ch[dep].stop_flag) {
1218
        unsigned int smp;
1219
        unsigned int begin = 1;
1220
        unsigned int end   = bd->block_length - 1;
1221
        int64_t y;
1222
        int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset;
1223

    
1224
        if (ch[dep].time_diff_flag) {
1225
            int t = ch[dep].time_diff_index;
1226

    
1227
            if (ch[dep].time_diff_sign) {
1228
                t      = -t;
1229
                begin -= t;
1230
            } else {
1231
                end   -= t;
1232
            }
1233

    
1234
            for (smp = begin; smp < end; smp++) {
1235
                y  = (1 << 6) +
1236
                     MUL64(ch[dep].weighting[0], master[smp - 1    ]) +
1237
                     MUL64(ch[dep].weighting[1], master[smp        ]) +
1238
                     MUL64(ch[dep].weighting[2], master[smp + 1    ]) +
1239
                     MUL64(ch[dep].weighting[3], master[smp - 1 + t]) +
1240
                     MUL64(ch[dep].weighting[4], master[smp     + t]) +
1241
                     MUL64(ch[dep].weighting[5], master[smp + 1 + t]);
1242

    
1243
                bd->raw_samples[smp] += y >> 7;
1244
            }
1245
        } else {
1246
            for (smp = begin; smp < end; smp++) {
1247
                y  = (1 << 6) +
1248
                     MUL64(ch[dep].weighting[0], master[smp - 1]) +
1249
                     MUL64(ch[dep].weighting[1], master[smp    ]) +
1250
                     MUL64(ch[dep].weighting[2], master[smp + 1]);
1251

    
1252
                bd->raw_samples[smp] += y >> 7;
1253
            }
1254
        }
1255

    
1256
        dep++;
1257
    }
1258

    
1259
    return 0;
1260
}
1261

    
1262

    
1263
/** Read the frame data.
1264
 */
1265
static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame)
1266
{
1267
    ALSSpecificConfig *sconf = &ctx->sconf;
1268
    AVCodecContext *avctx    = ctx->avctx;
1269
    GetBitContext *gb = &ctx->gb;
1270
    unsigned int div_blocks[32];                ///< block sizes.
1271
    unsigned int c;
1272
    unsigned int js_blocks[2];
1273

    
1274
    uint32_t bs_info = 0;
1275

    
1276
    // skip the size of the ra unit if present in the frame
1277
    if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame)
1278
        skip_bits_long(gb, 32);
1279

    
1280
    if (sconf->mc_coding && sconf->joint_stereo) {
1281
        ctx->js_switch = get_bits1(gb);
1282
        align_get_bits(gb);
1283
    }
1284

    
1285
    if (!sconf->mc_coding || ctx->js_switch) {
1286
        int independent_bs = !sconf->joint_stereo;
1287

    
1288
        for (c = 0; c < avctx->channels; c++) {
1289
            js_blocks[0] = 0;
1290
            js_blocks[1] = 0;
1291

    
1292
            get_block_sizes(ctx, div_blocks, &bs_info);
1293

    
1294
            // if joint_stereo and block_switching is set, independent decoding
1295
            // is signaled via the first bit of bs_info
1296
            if (sconf->joint_stereo && sconf->block_switching)
1297
                if (bs_info >> 31)
1298
                    independent_bs = 2;
1299

    
1300
            // if this is the last channel, it has to be decoded independently
1301
            if (c == avctx->channels - 1)
1302
                independent_bs = 1;
1303

    
1304
            if (independent_bs) {
1305
                if (decode_blocks_ind(ctx, ra_frame, c, div_blocks, js_blocks))
1306
                    return -1;
1307

    
1308
                independent_bs--;
1309
            } else {
1310
                if (decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks))
1311
                    return -1;
1312

    
1313
                c++;
1314
            }
1315

    
1316
            // store carryover raw samples
1317
            memmove(ctx->raw_samples[c] - sconf->max_order,
1318
                    ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1319
                    sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1320
        }
1321
    } else { // multi-channel coding
1322
        ALSBlockData   bd;
1323
        int            b;
1324
        int            *reverted_channels = ctx->reverted_channels;
1325
        unsigned int   offset             = 0;
1326

    
1327
        for (c = 0; c < avctx->channels; c++)
1328
            if (ctx->chan_data[c] < ctx->chan_data_buffer) {
1329
                av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data!\n");
1330
                return -1;
1331
            }
1332

    
1333
        memset(&bd,               0, sizeof(ALSBlockData));
1334
        memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels);
1335

    
1336
        bd.ra_block         = ra_frame;
1337
        bd.prev_raw_samples = ctx->prev_raw_samples;
1338

    
1339
        get_block_sizes(ctx, div_blocks, &bs_info);
1340

    
1341
        for (b = 0; b < ctx->num_blocks; b++) {
1342
            bd.shift_lsbs   = 0;
1343
            bd.block_length = div_blocks[b];
1344

    
1345
            for (c = 0; c < avctx->channels; c++) {
1346
                bd.use_ltp     = ctx->use_ltp + c;
1347
                bd.ltp_lag     = ctx->ltp_lag + c;
1348
                bd.ltp_gain    = ctx->ltp_gain[c];
1349
                bd.lpc_cof     = ctx->lpc_cof[c];
1350
                bd.quant_cof   = ctx->quant_cof[c];
1351
                bd.raw_samples = ctx->raw_samples[c] + offset;
1352
                bd.raw_other   = NULL;
1353

    
1354
                read_block(ctx, &bd);
1355
                if (read_channel_data(ctx, ctx->chan_data[c], c))
1356
                    return -1;
1357
            }
1358

    
1359
            for (c = 0; c < avctx->channels; c++)
1360
                if (revert_channel_correlation(ctx, &bd, ctx->chan_data,
1361
                                               reverted_channels, offset, c))
1362
                    return -1;
1363

    
1364
            for (c = 0; c < avctx->channels; c++) {
1365
                bd.use_ltp     = ctx->use_ltp + c;
1366
                bd.ltp_lag     = ctx->ltp_lag + c;
1367
                bd.ltp_gain    = ctx->ltp_gain[c];
1368
                bd.lpc_cof     = ctx->lpc_cof[c];
1369
                bd.quant_cof   = ctx->quant_cof[c];
1370
                bd.raw_samples = ctx->raw_samples[c] + offset;
1371
                decode_block(ctx, &bd);
1372
            }
1373

    
1374
            memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels));
1375
            offset      += div_blocks[b];
1376
            bd.ra_block  = 0;
1377
        }
1378

    
1379
        // store carryover raw samples
1380
        for (c = 0; c < avctx->channels; c++)
1381
            memmove(ctx->raw_samples[c] - sconf->max_order,
1382
                    ctx->raw_samples[c] - sconf->max_order + sconf->frame_length,
1383
                    sizeof(*ctx->raw_samples[c]) * sconf->max_order);
1384
    }
1385

    
1386
    // TODO: read_diff_float_data
1387

    
1388
    return 0;
1389
}
1390

    
1391

    
1392
/** Decode an ALS frame.
1393
 */
1394
static int decode_frame(AVCodecContext *avctx,
1395
                        void *data, int *data_size,
1396
                        AVPacket *avpkt)
1397
{
1398
    ALSDecContext *ctx       = avctx->priv_data;
1399
    ALSSpecificConfig *sconf = &ctx->sconf;
1400
    const uint8_t *buffer    = avpkt->data;
1401
    int buffer_size          = avpkt->size;
1402
    int invalid_frame, size;
1403
    unsigned int c, sample, ra_frame, bytes_read, shift;
1404

    
1405
    init_get_bits(&ctx->gb, buffer, buffer_size * 8);
1406

    
1407
    // In the case that the distance between random access frames is set to zero
1408
    // (sconf->ra_distance == 0) no frame is treated as a random access frame.
1409
    // For the first frame, if prediction is used, all samples used from the
1410
    // previous frame are assumed to be zero.
1411
    ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance);
1412

    
1413
    // the last frame to decode might have a different length
1414
    if (sconf->samples != 0xFFFFFFFF)
1415
        ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length,
1416
                                      sconf->frame_length);
1417
    else
1418
        ctx->cur_frame_length = sconf->frame_length;
1419

    
1420
    // decode the frame data
1421
    if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0))
1422
        av_log(ctx->avctx, AV_LOG_WARNING,
1423
               "Reading frame data failed. Skipping RA unit.\n");
1424

    
1425
    ctx->frame_id++;
1426

    
1427
    // check for size of decoded data
1428
    size = ctx->cur_frame_length * avctx->channels *
1429
           (av_get_bits_per_sample_format(avctx->sample_fmt) >> 3);
1430

    
1431
    if (size > *data_size) {
1432
        av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n");
1433
        return -1;
1434
    }
1435

    
1436
    *data_size = size;
1437

    
1438
    // transform decoded frame into output format
1439
    #define INTERLEAVE_OUTPUT(bps)                                 \
1440
    {                                                              \
1441
        int##bps##_t *dest = (int##bps##_t*) data;                 \
1442
        shift = bps - ctx->avctx->bits_per_raw_sample;             \
1443
        for (sample = 0; sample < ctx->cur_frame_length; sample++) \
1444
            for (c = 0; c < avctx->channels; c++)                  \
1445
                *dest++ = ctx->raw_samples[c][sample] << shift;    \
1446
    }
1447

    
1448
    if (ctx->avctx->bits_per_raw_sample <= 16) {
1449
        INTERLEAVE_OUTPUT(16)
1450
    } else {
1451
        INTERLEAVE_OUTPUT(32)
1452
    }
1453

    
1454
    // update CRC
1455
    if (sconf->crc_enabled && avctx->error_recognition >= FF_ER_CAREFUL) {
1456
        int swap = HAVE_BIGENDIAN != sconf->msb_first;
1457

    
1458
        if (ctx->avctx->bits_per_raw_sample == 24) {
1459
            int32_t *src = data;
1460

    
1461
            for (sample = 0;
1462
                 sample < ctx->cur_frame_length * avctx->channels;
1463
                 sample++) {
1464
                int32_t v;
1465

    
1466
                if (swap)
1467
                    v = av_bswap32(src[sample]);
1468
                else
1469
                    v = src[sample];
1470
                if (!HAVE_BIGENDIAN)
1471
                    v >>= 8;
1472

    
1473
                ctx->crc = av_crc(ctx->crc_table, ctx->crc, (uint8_t*)(&v), 3);
1474
            }
1475
        } else {
1476
            uint8_t *crc_source;
1477

    
1478
            if (swap) {
1479
                if (ctx->avctx->bits_per_raw_sample <= 16) {
1480
                    int16_t *src  = (int16_t*) data;
1481
                    int16_t *dest = (int16_t*) ctx->crc_buffer;
1482
                    for (sample = 0;
1483
                         sample < ctx->cur_frame_length * avctx->channels;
1484
                         sample++)
1485
                        *dest++ = av_bswap16(src[sample]);
1486
                } else {
1487
                    ctx->dsp.bswap_buf((uint32_t*)ctx->crc_buffer, data,
1488
                                       ctx->cur_frame_length * avctx->channels);
1489
                }
1490
                crc_source = ctx->crc_buffer;
1491
            } else {
1492
                crc_source = data;
1493
            }
1494

    
1495
            ctx->crc = av_crc(ctx->crc_table, ctx->crc, crc_source, size);
1496
        }
1497

    
1498

    
1499
        // check CRC sums if this is the last frame
1500
        if (ctx->cur_frame_length != sconf->frame_length &&
1501
            ctx->crc_org != ctx->crc) {
1502
            av_log(avctx, AV_LOG_ERROR, "CRC error.\n");
1503
        }
1504
    }
1505

    
1506

    
1507
    bytes_read = invalid_frame ? buffer_size :
1508
                                 (get_bits_count(&ctx->gb) + 7) >> 3;
1509

    
1510
    return bytes_read;
1511
}
1512

    
1513

    
1514
/** Uninitialize the ALS decoder.
1515
 */
1516
static av_cold int decode_end(AVCodecContext *avctx)
1517
{
1518
    ALSDecContext *ctx = avctx->priv_data;
1519

    
1520
    av_freep(&ctx->sconf.chan_pos);
1521

    
1522
    ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
1523

    
1524
    av_freep(&ctx->use_ltp);
1525
    av_freep(&ctx->ltp_lag);
1526
    av_freep(&ctx->ltp_gain);
1527
    av_freep(&ctx->ltp_gain_buffer);
1528
    av_freep(&ctx->quant_cof);
1529
    av_freep(&ctx->lpc_cof);
1530
    av_freep(&ctx->quant_cof_buffer);
1531
    av_freep(&ctx->lpc_cof_buffer);
1532
    av_freep(&ctx->lpc_cof_reversed_buffer);
1533
    av_freep(&ctx->prev_raw_samples);
1534
    av_freep(&ctx->raw_samples);
1535
    av_freep(&ctx->raw_buffer);
1536
    av_freep(&ctx->chan_data);
1537
    av_freep(&ctx->chan_data_buffer);
1538
    av_freep(&ctx->reverted_channels);
1539

    
1540
    return 0;
1541
}
1542

    
1543

    
1544
/** Initialize the ALS decoder.
1545
 */
1546
static av_cold int decode_init(AVCodecContext *avctx)
1547
{
1548
    unsigned int c;
1549
    unsigned int channel_size;
1550
    int num_buffers;
1551
    ALSDecContext *ctx = avctx->priv_data;
1552
    ALSSpecificConfig *sconf = &ctx->sconf;
1553
    ctx->avctx = avctx;
1554

    
1555
    if (!avctx->extradata) {
1556
        av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n");
1557
        return -1;
1558
    }
1559

    
1560
    if (read_specific_config(ctx)) {
1561
        av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
1562
        decode_end(avctx);
1563
        return -1;
1564
    }
1565

    
1566
    if (check_specific_config(ctx)) {
1567
        decode_end(avctx);
1568
        return -1;
1569
    }
1570

    
1571
    if (sconf->bgmc)
1572
        ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
1573

    
1574
    if (sconf->floating) {
1575
        avctx->sample_fmt          = SAMPLE_FMT_FLT;
1576
        avctx->bits_per_raw_sample = 32;
1577
    } else {
1578
        avctx->sample_fmt          = sconf->resolution > 1
1579
                                     ? SAMPLE_FMT_S32 : SAMPLE_FMT_S16;
1580
        avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1581
    }
1582

    
1583
    // set maximum Rice parameter for progressive decoding based on resolution
1584
    // This is not specified in 14496-3 but actually done by the reference
1585
    // codec RM22 revision 2.
1586
    ctx->s_max = sconf->resolution > 1 ? 31 : 15;
1587

    
1588
    // set lag value for long-term prediction
1589
    ctx->ltp_lag_length = 8 + (avctx->sample_rate >=  96000) +
1590
                              (avctx->sample_rate >= 192000);
1591

    
1592
    // allocate quantized parcor coefficient buffer
1593
    num_buffers = sconf->mc_coding ? avctx->channels : 1;
1594

    
1595
    ctx->quant_cof        = av_malloc(sizeof(*ctx->quant_cof) * num_buffers);
1596
    ctx->lpc_cof          = av_malloc(sizeof(*ctx->lpc_cof)   * num_buffers);
1597
    ctx->quant_cof_buffer = av_malloc(sizeof(*ctx->quant_cof_buffer) *
1598
                                      num_buffers * sconf->max_order);
1599
    ctx->lpc_cof_buffer   = av_malloc(sizeof(*ctx->lpc_cof_buffer) *
1600
                                      num_buffers * sconf->max_order);
1601
    ctx->lpc_cof_reversed_buffer = av_malloc(sizeof(*ctx->lpc_cof_buffer) *
1602
                                             sconf->max_order);
1603

    
1604
    if (!ctx->quant_cof              || !ctx->lpc_cof        ||
1605
        !ctx->quant_cof_buffer       || !ctx->lpc_cof_buffer ||
1606
        !ctx->lpc_cof_reversed_buffer) {
1607
        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1608
        return AVERROR(ENOMEM);
1609
    }
1610

    
1611
    // assign quantized parcor coefficient buffers
1612
    for (c = 0; c < num_buffers; c++) {
1613
        ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order;
1614
        ctx->lpc_cof[c]   = ctx->lpc_cof_buffer   + c * sconf->max_order;
1615
    }
1616

    
1617
    // allocate and assign lag and gain data buffer for ltp mode
1618
    ctx->use_ltp         = av_mallocz(sizeof(*ctx->use_ltp)  * num_buffers);
1619
    ctx->ltp_lag         = av_malloc (sizeof(*ctx->ltp_lag)  * num_buffers);
1620
    ctx->ltp_gain        = av_malloc (sizeof(*ctx->ltp_gain) * num_buffers);
1621
    ctx->ltp_gain_buffer = av_malloc (sizeof(*ctx->ltp_gain_buffer) *
1622
                                      num_buffers * 5);
1623

    
1624
    if (!ctx->use_ltp  || !ctx->ltp_lag ||
1625
        !ctx->ltp_gain || !ctx->ltp_gain_buffer) {
1626
        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1627
        decode_end(avctx);
1628
        return AVERROR(ENOMEM);
1629
    }
1630

    
1631
    for (c = 0; c < num_buffers; c++)
1632
        ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
1633

    
1634
    // allocate and assign channel data buffer for mcc mode
1635
    if (sconf->mc_coding) {
1636
        ctx->chan_data_buffer  = av_malloc(sizeof(*ctx->chan_data_buffer) *
1637
                                           num_buffers * num_buffers);
1638
        ctx->chan_data         = av_malloc(sizeof(*ctx->chan_data) *
1639
                                           num_buffers);
1640
        ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) *
1641
                                           num_buffers);
1642

    
1643
        if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
1644
            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1645
            decode_end(avctx);
1646
            return AVERROR(ENOMEM);
1647
        }
1648

    
1649
        for (c = 0; c < num_buffers; c++)
1650
            ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
1651
    } else {
1652
        ctx->chan_data         = NULL;
1653
        ctx->chan_data_buffer  = NULL;
1654
        ctx->reverted_channels = NULL;
1655
    }
1656

    
1657
    avctx->frame_size = sconf->frame_length;
1658
    channel_size      = sconf->frame_length + sconf->max_order;
1659

    
1660
    ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order);
1661
    ctx->raw_buffer       = av_mallocz(sizeof(*ctx->     raw_buffer)  * avctx->channels * channel_size);
1662
    ctx->raw_samples      = av_malloc (sizeof(*ctx->     raw_samples) * avctx->channels);
1663

    
1664
    // allocate previous raw sample buffer
1665
    if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) {
1666
        av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1667
        decode_end(avctx);
1668
        return AVERROR(ENOMEM);
1669
    }
1670

    
1671
    // assign raw samples buffers
1672
    ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order;
1673
    for (c = 1; c < avctx->channels; c++)
1674
        ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size;
1675

    
1676
    // allocate crc buffer
1677
    if (HAVE_BIGENDIAN != sconf->msb_first && sconf->crc_enabled &&
1678
        avctx->error_recognition >= FF_ER_CAREFUL) {
1679
        ctx->crc_buffer = av_malloc(sizeof(*ctx->crc_buffer) *
1680
                                    ctx->cur_frame_length *
1681
                                    avctx->channels *
1682
                                    (av_get_bits_per_sample_format(avctx->sample_fmt) >> 3));
1683
        if (!ctx->crc_buffer) {
1684
            av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
1685
            decode_end(avctx);
1686
            return AVERROR(ENOMEM);
1687
        }
1688
    }
1689

    
1690
    dsputil_init(&ctx->dsp, avctx);
1691

    
1692
    return 0;
1693
}
1694

    
1695

    
1696
/** Flush (reset) the frame ID after seeking.
1697
 */
1698
static av_cold void flush(AVCodecContext *avctx)
1699
{
1700
    ALSDecContext *ctx = avctx->priv_data;
1701

    
1702
    ctx->frame_id = 0;
1703
}
1704

    
1705

    
1706
AVCodec als_decoder = {
1707
    "als",
1708
    AVMEDIA_TYPE_AUDIO,
1709
    CODEC_ID_MP4ALS,
1710
    sizeof(ALSDecContext),
1711
    decode_init,
1712
    NULL,
1713
    decode_end,
1714
    decode_frame,
1715
    .flush = flush,
1716
    .capabilities = CODEC_CAP_SUBFRAMES,
1717
    .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
1718
};
1719