Statistics
| Branch: | Revision:

ffmpeg / libavcodec / alsdec.c @ 5d6e4c16

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 "libavcore/samplefmt.h"
40
#include "libavutil/crc.h"
41

    
42
#include <stdint.h>
43

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

    
63

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

    
104

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

    
115

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

    
126

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

    
148

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

    
155

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

    
181

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

    
191

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

    
226

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

    
246

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

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

    
274

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

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

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

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

    
295
    skip_bits_long(&gb, config_offset);
296

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

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

    
330

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

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

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

    
342

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

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

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

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

    
362

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

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

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

    
377

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

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

    
385
    skip_bits_long(&gb, ht_size);
386

    
387

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

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

    
401

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

    
404
    dprint_specific_config(ctx);
405

    
406
    return 0;
407
}
408

    
409

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

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

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

    
430
    return error;
431
}
432

    
433

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

    
457

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

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

    
475

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

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

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

    
493

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

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

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

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

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

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

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

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

    
548

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

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

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

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

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

    
573

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

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

    
587

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

    
605

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

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

    
612
    opt_order       = bd->opt_order;
613

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

    
624
    sub_blocks = 1 << log2_sub_blocks;
625

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

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

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

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

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

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

    
656

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

    
666
        opt_order = bd->opt_order;
667

    
668
        if (opt_order) {
669
            int add_base;
670

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
764
        current_res = bd->raw_samples + start;
765

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

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

    
773
            current_res += sb_length;
774
        }
775

    
776
        ff_bgmc_decode_end(gb);
777

    
778

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

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

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

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

    
795
                    res = decode_rice(gb, cur_s);
796

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

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

    
809
                    res >>= 1;
810

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

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

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

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

    
831
    return 0;
832
}
833

    
834

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

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

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

    
863
            y = 1 << 6;
864

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
933
    raw_samples = bd->raw_samples;
934

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

    
940
    return 0;
941
}
942

    
943

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

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

    
958
    return 0;
959
}
960

    
961

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

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

    
974
    // TODO: read RLSLMS extension data
975

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

    
980
    return 0;
981
}
982

    
983

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

    
990
    ret = read_block(ctx, bd);
991

    
992
    if (ret)
993
        return ret;
994

    
995
    ret = decode_block(ctx, bd);
996

    
997
    return ret;
998
}
999

    
1000

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

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

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

    
1016

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

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

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

    
1037

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

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

    
1051
    return 0;
1052
}
1053

    
1054

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1132
    return 0;
1133
}
1134

    
1135

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

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

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

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

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

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

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

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

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

    
1182

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

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

    
1196
    reverted[c] = 1;
1197

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

    
1202
        dep++;
1203
    }
1204

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

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

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

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

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

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

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

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

    
1257
        dep++;
1258
    }
1259

    
1260
    return 0;
1261
}
1262

    
1263

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

    
1275
    uint32_t bs_info = 0;
1276

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

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

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

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

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

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

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

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

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

    
1314
                c++;
1315
            }
1316

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

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

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

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

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

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

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

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

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

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

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

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

    
1387
    // TODO: read_diff_float_data
1388

    
1389
    return 0;
1390
}
1391

    
1392

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

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

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

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

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

    
1426
    ctx->frame_id++;
1427

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

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

    
1437
    *data_size = size;
1438

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

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

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

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

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

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

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

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

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

    
1499

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

    
1507

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

    
1511
    return bytes_read;
1512
}
1513

    
1514

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

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

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

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

    
1541
    return 0;
1542
}
1543

    
1544

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

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

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

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

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

    
1575
    if (sconf->floating) {
1576
        avctx->sample_fmt          = AV_SAMPLE_FMT_FLT;
1577
        avctx->bits_per_raw_sample = 32;
1578
    } else {
1579
        avctx->sample_fmt          = sconf->resolution > 1
1580
                                     ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S16;
1581
        avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
1582
    }
1583

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1693
    return 0;
1694
}
1695

    
1696

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

    
1703
    ctx->frame_id = 0;
1704
}
1705

    
1706

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