git.sesse.net Git - ffmpeg/blob - libavcodec/alsdec.c

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