ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavcodec/alsdec.c

 /*
  * MPEG-4 ALS decoder
  * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.com>
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
@@ skipping 16 matching lines @@
 
 
 //#define DEBUG
 
 
 #include "avcodec.h"
 #include "get_bits.h"
 #include "unary.h"
 #include "mpeg4audio.h"
 #include "bytestream.h"
+#include "bgmc.h"
 
 #include <stdint.h>
 
 /** Rice parameters and corresponding index offsets for decoding the
  *  indices of scaled PARCOR values. The table choosen is set globally
  *  by the encoder and stored in ALSSpecificConfig.
  */
 static const int8_t parcor_rice_table[3][20][2] = {
     { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4},
       { 12, 3}, { -7, 3}, {  9, 3}, { -5, 3}, {  6, 3},
@@ skipping 66 matching lines @@
  *  To be indexed by the Rice coded indices.
  */
 static const int16_t mcc_weightings[] = {
     204,  192,  179,  166,  153,  140,  128,  115,
     102,   89,   76,   64,   51,   38,   25,   12,
       0,  -12,  -25,  -38,  -51,  -64,  -76,  -89,
    -102, -115, -128, -140, -153, -166, -179, -192
 };
 
 
+/** Tail codes used in arithmetic coding using block Gilbert-Moore codes.
+ */
+static const uint8_t tail_code[16][6] = {
+    { 74, 44, 25, 13,  7, 3},
+    { 68, 42, 24, 13,  7, 3},
+    { 58, 39, 23, 13,  7, 3},
+    {126, 70, 37, 19, 10, 5},
+    {132, 70, 37, 20, 10, 5},
+    {124, 70, 38, 20, 10, 5},
+    {120, 69, 37, 20, 11, 5},
+    {116, 67, 37, 20, 11, 5},
+    {108, 66, 36, 20, 10, 5},
+    {102, 62, 36, 20, 10, 5},
+    { 88, 58, 34, 19, 10, 5},
+    {162, 89, 49, 25, 13, 7},
+    {156, 87, 49, 26, 14, 7},
+    {150, 86, 47, 26, 14, 7},
+    {142, 84, 47, 26, 14, 7},
+    {131, 79, 46, 26, 14, 7}
+};
+
+
 enum RA_Flag {
     RA_FLAG_NONE,
     RA_FLAG_FRAMES,
     RA_FLAG_HEADER
 };
 
 
 typedef struct {
     uint32_t samples;         ///< number of samples, 0xFFFFFFFF if unknown
     int resolution;           ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit
@@ skipping 29 matching lines @@
 
 
 typedef struct {
     AVCodecContext *avctx;
     ALSSpecificConfig sconf;
     GetBitContext gb;
     unsigned int cur_frame_length;  ///< length of the current frame to decode
     unsigned int frame_id;          ///< the frame ID / number of the current frame
     unsigned int js_switch;         ///< if true, joint-stereo decoding is enforced
     unsigned int num_blocks;        ///< number of blocks used in the current frame
+    unsigned int s_max;             ///< maximum Rice parameter allowed in entropy coding
+    uint8_t *bgmc_lut;              ///< pointer at lookup tables used for BGMC
+    unsigned int *bgmc_lut_status;  ///< pointer at lookup table status flags used for BGMC
     int ltp_lag_length;             ///< number of bits used for ltp lag value
     int *use_ltp;                   ///< contains use_ltp flags for all channels
     int *ltp_lag;                   ///< contains ltp lag values for all channels
     int **ltp_gain;                 ///< gain values for ltp 5-tap filter for a channel
     int *ltp_gain_buffer;           ///< contains all gain values for ltp 5-tap filter
     int32_t **quant_cof;            ///< quantized parcor coefficients for a channel
     int32_t *quant_cof_buffer;      ///< contains all quantized parcor coefficients
     int32_t **lpc_cof;              ///< coefficients of the direct form prediction filter for a channel
     int32_t *lpc_cof_buffer;        ///< contains all coefficients of the direct form prediction filter
     int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer
@@ skipping 194 matching lines @@
     // report unsupported feature and set error value
     #define MISSING_ERR(cond, str, errval)              \
     {                                                   \
         if (cond) {                                     \
             av_log_missing_feature(ctx->avctx, str, 0); \
             error = errval;                             \
         }                                               \
     }
 
     MISSING_ERR(sconf->floating,             "Floating point decoding",     -1);
-    MISSING_ERR(sconf->bgmc,                 "BGMC entropy decoding",       -1);
     MISSING_ERR(sconf->rlslms,               "Adaptive RLS-LMS prediction", -1);
     MISSING_ERR(sconf->chan_sort,            "Channel sorting",              0);
 
     return error;
 }
 
 
 /** Parses the bs_info field to extract the block partitioning used in
  *  block switching mode, refer to ISO/IEC 14496-3, section 11.6.2.
  */
@@ skipping 90 matching lines @@
     // The ALS conformance files feature an odd number of samples in the last
     // frame.
 
     for (b = 0; b < ctx->num_blocks; b++)
         div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b];
 
     if (ctx->cur_frame_length != ctx->sconf.frame_length) {
         unsigned int remaining = ctx->cur_frame_length;
 
         for (b = 0; b < ctx->num_blocks; b++) {
-            if (remaining < div_blocks[b]) {
+            if (remaining <= div_blocks[b]) {
                 div_blocks[b] = remaining;
                 ctx->num_blocks = b + 1;
                 break;
             }
 
             remaining -= div_blocks[b];
         }
     }
 }
 
@@ skipping 39 matching lines @@
 
 /** Reads the block data for a non-constant block
  */
 static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd)
 {
     ALSSpecificConfig *sconf = &ctx->sconf;
     AVCodecContext *avctx    = ctx->avctx;
     GetBitContext *gb        = &ctx->gb;
     unsigned int k;
     unsigned int s[8];
+    unsigned int sx[8];
     unsigned int sub_blocks, log2_sub_blocks, sb_length;
     unsigned int start      = 0;
     unsigned int opt_order;
     int          sb;
     int32_t      *quant_cof = bd->quant_cof;
+    int32_t      *current_res;
 
 
     // ensure variable block decoding by reusing this field
     bd->const_block = 0;
 
     bd->opt_order   = 1;
     bd->js_blocks   = get_bits1(gb);
 
     opt_order       = bd->opt_order;
 
@@ skipping 12 matching lines @@
     // do not continue in case of a damaged stream since
     // block_length must be evenly divisible by sub_blocks
     if (bd->block_length & (sub_blocks - 1)) {
         av_log(avctx, AV_LOG_WARNING,
                "Block length is not evenly divisible by the number of subblocks.\n");
         return -1;
     }
 
     sb_length = bd->block_length >> log2_sub_blocks;
 
+    if (sconf->bgmc) {
+        s[0] = get_bits(gb, 8 + (sconf->resolution > 1));
+        for (k = 1; k < sub_blocks; k++)
+            s[k] = s[k - 1] + decode_rice(gb, 2);
 
-    if (sconf->bgmc) {
-        // TODO: BGMC mode
+        for (k = 0; k < sub_blocks; k++) {
+            sx[k]   = s[k] & 0x0F;
+            s [k] >>= 4;
+        }
     } else {
         s[0] = get_bits(gb, 4 + (sconf->resolution > 1));
         for (k = 1; k < sub_blocks; k++)
             s[k] = s[k - 1] + decode_rice(gb, 0);
     }
 
     if (get_bits1(gb))
         bd->shift_lsbs = get_bits(gb, 4) + 1;
 
     bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || bd->shift_lsbs;
@@ skipping 56 matching lines @@
             for (k = 2; k < opt_order; k++)
                 quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13);
         }
     }
 
     // read LTP gain and lag values
     if (sconf->long_term_prediction) {
         *bd->use_ltp = get_bits1(gb);
 
         if (*bd->use_ltp) {
+            int r, c;
+
             bd->ltp_gain[0]   = decode_rice(gb, 1) << 3;
             bd->ltp_gain[1]   = decode_rice(gb, 2) << 3;
 
-            bd->ltp_gain[2]   = ltp_gain_values[get_unary(gb, 0, 4)][get_bits(gb, 2)];
+            r                 = get_unary(gb, 0, 4);
+            c                 = get_bits(gb, 2);
+            bd->ltp_gain[2]   = ltp_gain_values[r][c];
 
             bd->ltp_gain[3]   = decode_rice(gb, 2) << 3;
             bd->ltp_gain[4]   = decode_rice(gb, 1) << 3;
 
             *bd->ltp_lag      = get_bits(gb, ctx->ltp_lag_length);
             *bd->ltp_lag     += FFMAX(4, opt_order + 1);
         }
     }
 
     // read first value and residuals in case of a random access block
     if (bd->ra_block) {
         if (opt_order)
             bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4);
         if (opt_order > 1)
-            bd->raw_samples[1] = decode_rice(gb, s[0] + 3);
+            bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max));
         if (opt_order > 2)
-            bd->raw_samples[2] = decode_rice(gb, s[0] + 1);
+            bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max));
 
         start = FFMIN(opt_order, 3);
     }
 
     // read all residuals
     if (sconf->bgmc) {
-        // TODO: BGMC mode
+        unsigned int delta[sub_blocks];
+        unsigned int k    [sub_blocks];
+        unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5);
+        unsigned int i = start;
+
+        // read most significant bits
+        unsigned int high;
+        unsigned int low;
+        unsigned int value;
+
+        ff_bgmc_decode_init(gb, &high, &low, &value);
+
+        current_res = bd->raw_samples + start;
+
+        for (sb = 0; sb < sub_blocks; sb++, i = 0) {
+            k    [sb] = s[sb] > b ? s[sb] - b : 0;
+            delta[sb] = 5 - s[sb] + k[sb];
+
+            ff_bgmc_decode(gb, sb_length, current_res,
+                        delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status);
+
+            current_res += sb_length;
+        }
+
+        ff_bgmc_decode_end(gb);
+
+
+        // read least significant bits and tails
+        i = start;
+        current_res = bd->raw_samples + start;
+
+        for (sb = 0; sb < sub_blocks; sb++, i = 0) {
+            unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]];
+            unsigned int cur_k         = k[sb];
+            unsigned int cur_s         = s[sb];
+
+            for (; i < sb_length; i++) {
+                int32_t res = *current_res;
+
+                if (res == cur_tail_code) {
+                    unsigned int max_msb =   (2 + (sx[sb] > 2) + (sx[sb] > 10))
+                                          << (5 - delta[sb]);
+
+                    res = decode_rice(gb, cur_s);
+
+                    if (res >= 0) {
+                        res += (max_msb    ) << cur_k;
+                    } else {
+                        res -= (max_msb - 1) << cur_k;
+                    }
+                } else {
+                    if (res > cur_tail_code)
+                        res--;
+
+                    if (res & 1)
+                        res = -res;
+
+                    res >>= 1;
+
+                    if (cur_k) {
+                        res <<= cur_k;
+                        res  |= get_bits_long(gb, cur_k);
+                    }
+                }
+
+                *current_res++ = res;
+            }
+        }
     } else {
-        int32_t *current_res = bd->raw_samples + start;
+        current_res = bd->raw_samples + start;
 
         for (sb = 0; sb < sub_blocks; sb++, start = 0)
             for (; start < sb_length; start++)
                 *current_res++ = decode_rice(gb, s[sb]);
      }
 
     if (!sconf->mc_coding || ctx->js_switch)
         align_get_bits(gb);
 
     return 0;
@@ skipping 628 matching lines @@
 
 
 /** Uninitializes the ALS decoder.
  */
 static av_cold int decode_end(AVCodecContext *avctx)
 {
     ALSDecContext *ctx = avctx->priv_data;
 
     av_freep(&ctx->sconf.chan_pos);
 
+    ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status);
+
     av_freep(&ctx->use_ltp);
     av_freep(&ctx->ltp_lag);
     av_freep(&ctx->ltp_gain);
     av_freep(&ctx->ltp_gain_buffer);
     av_freep(&ctx->quant_cof);
     av_freep(&ctx->lpc_cof);
     av_freep(&ctx->quant_cof_buffer);
     av_freep(&ctx->lpc_cof_buffer);
     av_freep(&ctx->lpc_cof_reversed_buffer);
     av_freep(&ctx->prev_raw_samples);
@@ skipping 27 matching lines @@
         av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n");
         decode_end(avctx);
         return -1;
     }
 
     if (check_specific_config(ctx)) {
         decode_end(avctx);
         return -1;
     }
 
+    if (sconf->bgmc)
+        ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status);
+
     if (sconf->floating) {
         avctx->sample_fmt          = SAMPLE_FMT_FLT;
         avctx->bits_per_raw_sample = 32;
     } else {
         avctx->sample_fmt          = sconf->resolution > 1
                                      ? SAMPLE_FMT_S32 : SAMPLE_FMT_S16;
         avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8;
     }
 
+    // set maximum Rice parameter for progressive decoding based on resolution
+    // This is not specified in 14496-3 but actually done by the reference
+    // codec RM22 revision 2.
+    ctx->s_max = sconf->resolution > 1 ? 31 : 15;
+
     // set lag value for long-term prediction
     ctx->ltp_lag_length = 8 + (avctx->sample_rate >=  96000) +
                               (avctx->sample_rate >= 192000);
 
     // allocate quantized parcor coefficient buffer
     num_buffers = sconf->mc_coding ? avctx->channels : 1;
 
     ctx->quant_cof        = av_malloc(sizeof(*ctx->quant_cof) * num_buffers);
     ctx->lpc_cof          = av_malloc(sizeof(*ctx->lpc_cof)   * num_buffers);
     ctx->quant_cof_buffer = av_malloc(sizeof(*ctx->quant_cof_buffer) *
@@ skipping 29 matching lines @@
         decode_end(avctx);
         return AVERROR(ENOMEM);
     }
 
     for (c = 0; c < num_buffers; c++)
         ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5;
 
     // allocate and assign channel data buffer for mcc mode
     if (sconf->mc_coding) {
         ctx->chan_data_buffer  = av_malloc(sizeof(*ctx->chan_data_buffer) *
-                                           num_buffers);
-        ctx->chan_data         = av_malloc(sizeof(ALSChannelData) *
+                                           num_buffers * num_buffers);
+        ctx->chan_data         = av_malloc(sizeof(*ctx->chan_data) *
                                            num_buffers);
         ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) *
                                            num_buffers);
 
         if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) {
             av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n");
             decode_end(avctx);
             return AVERROR(ENOMEM);
         }
 
         for (c = 0; c < num_buffers; c++)
-            ctx->chan_data[c] = ctx->chan_data_buffer + c;
+            ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers;
     } else {
         ctx->chan_data         = NULL;
         ctx->chan_data_buffer  = NULL;
         ctx->reverted_channels = NULL;
     }
 
     avctx->frame_size = sconf->frame_length;
     channel_size      = sconf->frame_length + sconf->max_order;
 
     ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order);
@@ skipping 33 matching lines @@
     sizeof(ALSDecContext),
     decode_init,
     NULL,
     decode_end,
     decode_frame,
     .flush = flush,
     .capabilities = CODEC_CAP_SUBFRAMES,
     .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"),
 };