Merge commit '94c54d97e7f4fe90570c323803f2bdf6246c1010'
[ffmpeg.git] / libavcodec / mlpdec.c
index fa94f6f..4d40e18 100644 (file)
@@ -2,20 +2,20 @@
  * MLP decoder
  * Copyright (c) 2007-2008 Ian Caulfield
  *
- * This file is part of Libav.
+ * This file is part of FFmpeg.
  *
- * Libav is free software; you can redistribute it and/or
+ * 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.
  *
- * Libav is distributed in the hope that it will be useful,
+ * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
- * License along with Libav; if not, write to the Free Software
+ * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 
 #include <stdint.h>
 
+#include "avcodec.h"
 #include "libavutil/internal.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/channel_layout.h"
-#include "libavutil/crc.h"
-
-#include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
 #include "internal.h"
+#include "libavutil/crc.h"
 #include "parser.h"
 #include "mlp_parser.h"
 #include "mlpdsp.h"
@@ -106,7 +105,7 @@ typedef struct SubStream {
     /// Whether the LSBs of the matrix output are encoded in the bitstream.
     uint8_t     lsb_bypass[MAX_MATRICES];
     /// Matrix coefficients, stored as 2.14 fixed point.
-    int32_t     matrix_coeff[MAX_MATRICES][MAX_CHANNELS];
+    DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
     /// Left shift to apply to noise values in 0x31eb substreams.
     uint8_t     matrix_noise_shift[MAX_MATRICES];
     //@}
@@ -145,6 +144,9 @@ typedef struct MLPDecodeContext {
     /// Index of the last substream to decode - further substreams are skipped.
     uint8_t     max_decoded_substream;
 
+    /// Stream needs channel reordering to comply with FFmpeg's channel order
+    uint8_t     needs_reordering;
+
     /// number of PCM samples contained in each frame
     int         access_unit_size;
     /// next power of two above the number of samples in each frame
@@ -157,7 +159,7 @@ typedef struct MLPDecodeContext {
 
     int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
     int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
-    int32_t     sample_buffer[MAX_BLOCKSIZE][MAX_CHANNELS];
+    DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
 
     MLPDSPContext dsp;
 } MLPDecodeContext;
@@ -234,7 +236,7 @@ static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
  *  and plain LSBs. */
 
-static inline int read_huff_channels(MLPDecodeContext *m, BitstreamContext *bc,
+static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
                                      unsigned int substr, unsigned int pos)
 {
     SubStream *s = &m->substream[substr];
@@ -242,7 +244,7 @@ static inline int read_huff_channels(MLPDecodeContext *m, BitstreamContext *bc,
 
     for (mat = 0; mat < s->num_primitive_matrices; mat++)
         if (s->lsb_bypass[mat])
-            m->bypassed_lsbs[pos + s->blockpos][mat] = bitstream_read_bit(bc);
+            m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
 
     for (channel = s->min_channel; channel <= s->max_channel; channel++) {
         ChannelParams *cp = &s->channel_params[channel];
@@ -252,18 +254,17 @@ static inline int read_huff_channels(MLPDecodeContext *m, BitstreamContext *bc,
         int result = 0;
 
         if (codebook > 0)
-            result = bitstream_read_vlc(bc, huff_vlc[codebook-1].table,
-                                        VLC_BITS,
-                                        (9 + VLC_BITS - 1) / VLC_BITS);
+            result = get_vlc2(gbp, huff_vlc[codebook-1].table,
+                            VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
 
         if (result < 0)
             return AVERROR_INVALIDDATA;
 
         if (lsb_bits > 0)
-            result = (result << lsb_bits) + bitstream_read(bc, lsb_bits);
+            result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
 
         result  += cp->sign_huff_offset;
-        result <<= quant_step_size;
+        result *= 1 << quant_step_size;
 
         m->sample_buffer[pos + s->blockpos][channel] = result;
     }
@@ -290,12 +291,12 @@ static av_cold int mlp_decode_init(AVCodecContext *avctx)
  *  information is not actually necessary for decoding, only for playback.
  */
 
-static int read_major_sync(MLPDecodeContext *m, BitstreamContext *bc)
+static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
 {
     MLPHeaderInfo mh;
     int substr, ret;
 
-    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, bc)) != 0)
+    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
         return ret;
 
     if (mh.group1_bits == 0) {
@@ -382,10 +383,22 @@ static int read_major_sync(MLPDecodeContext *m, BitstreamContext *bc)
      * substream is Stereo. Subsequent substreams' layouts are indicated in the
      * major sync. */
     if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
+        if (mh.stream_type != 0xbb) {
+            avpriv_request_sample(m->avctx,
+                        "unexpected stream_type %X in MLP",
+                        mh.stream_type);
+            return AVERROR_PATCHWELCOME;
+        }
         if ((substr = (mh.num_substreams > 1)))
             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
         m->substream[substr].mask = mh.channel_layout_mlp;
     } else {
+        if (mh.stream_type != 0xba) {
+            avpriv_request_sample(m->avctx,
+                        "unexpected stream_type %X in !MLP",
+                        mh.stream_type);
+            return AVERROR_PATCHWELCOME;
+        }
         if ((substr = (mh.num_substreams > 1)))
             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
         if (mh.num_substreams > 2)
@@ -394,8 +407,17 @@ static int read_major_sync(MLPDecodeContext *m, BitstreamContext *bc)
             else
                 m->substream[2].mask = mh.channel_layout_thd_stream1;
         m->substream[substr].mask = mh.channel_layout_thd_stream1;
+
+        if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
+            av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
+            m->max_decoded_substream = 0;
+            if (m->avctx->channels==2)
+                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
+        }
     }
 
+    m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
+
     /* Parse the TrueHD decoder channel modifiers and set each substream's
      * AVMatrixEncoding accordingly.
      *
@@ -443,7 +465,7 @@ static int read_major_sync(MLPDecodeContext *m, BitstreamContext *bc)
  *  required to decode the audio that do not change very often. Generally
  *  (always) present only in blocks following a major sync. */
 
-static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
+static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
                                const uint8_t *buf, unsigned int substr)
 {
     SubStream *s = &m->substream[substr];
@@ -451,13 +473,13 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
     int sync_word, tmp;
     uint8_t checksum;
     uint8_t lossless_check;
-    int start_count = bitstream_tell(bc);
+    int start_count = get_bits_count(gbp);
     int min_channel, max_channel, max_matrix_channel;
     const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
                                      ? MAX_MATRIX_CHANNEL_MLP
                                      : MAX_MATRIX_CHANNEL_TRUEHD;
 
-    sync_word = bitstream_read(bc, 13);
+    sync_word = get_bits(gbp, 13);
 
     if (sync_word != 0x31ea >> 1) {
         av_log(m->avctx, AV_LOG_ERROR,
@@ -465,23 +487,23 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
         return AVERROR_INVALIDDATA;
     }
 
-    s->noise_type = bitstream_read_bit(bc);
+    s->noise_type = get_bits1(gbp);
 
     if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
         return AVERROR_INVALIDDATA;
     }
 
-    bitstream_skip(bc, 16); /* Output timestamp */
+    skip_bits(gbp, 16); /* Output timestamp */
 
-    min_channel        = bitstream_read(bc, 4);
-    max_channel        = bitstream_read(bc, 4);
-    max_matrix_channel = bitstream_read(bc, 4);
+    min_channel        = get_bits(gbp, 4);
+    max_channel        = get_bits(gbp, 4);
+    max_matrix_channel = get_bits(gbp, 4);
 
     if (max_matrix_channel > std_max_matrix_channel) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Max matrix channel cannot be greater than %d.\n",
-               max_matrix_channel);
+               std_max_matrix_channel);
         return AVERROR_INVALIDDATA;
     }
 
@@ -493,11 +515,11 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
 
     /* This should happen for TrueHD streams with >6 channels and MLP's noise
      * type. It is not yet known if this is allowed. */
-    if (s->max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
+    if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
         avpriv_request_sample(m->avctx,
                               "%d channels (more than the "
                               "maximum supported by the decoder)",
-                              s->max_channel + 2);
+                              max_channel + 2);
         return AVERROR_PATCHWELCOME;
     }
 
@@ -520,13 +542,13 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
         m->max_decoded_substream = substr;
     }
 
-    s->noise_shift   = bitstream_read(bc,  4);
-    s->noisegen_seed = bitstream_read(bc, 23);
+    s->noise_shift   = get_bits(gbp,  4);
+    s->noisegen_seed = get_bits(gbp, 23);
 
-    bitstream_skip(bc, 19);
+    skip_bits(gbp, 19);
 
-    s->data_check_present = bitstream_read_bit(bc);
-    lossless_check = bitstream_read(bc, 8);
+    s->data_check_present = get_bits1(gbp);
+    lossless_check = get_bits(gbp, 8);
     if (substr == m->max_decoded_substream
         && s->lossless_check_data != 0xffffffff) {
         tmp = xor_32_to_8(s->lossless_check_data);
@@ -536,12 +558,12 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
                    lossless_check, tmp);
     }
 
-    bitstream_skip(bc, 16);
+    skip_bits(gbp, 16);
 
     memset(s->ch_assign, 0, sizeof(s->ch_assign));
 
     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
-        int ch_assign = bitstream_read(bc, 6);
+        int ch_assign = get_bits(gbp, 6);
         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
             uint64_t channel = thd_channel_layout_extract_channel(s->mask,
                                                                   ch_assign);
@@ -557,9 +579,9 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
         s->ch_assign[ch_assign] = ch;
     }
 
-    checksum = ff_mlp_restart_checksum(buf, bitstream_tell(bc) - start_count);
+    checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
 
-    if (checksum != bitstream_read(bc, 8))
+    if (checksum != get_bits(gbp, 8))
         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
 
     /* Set default decoding parameters. */
@@ -592,6 +614,20 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
                                                                s->output_shift,
                                                                s->max_matrix_channel,
                                                                m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
+
+        if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
+            if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
+                m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
+                int i = s->ch_assign[4];
+                s->ch_assign[4] = s->ch_assign[3];
+                s->ch_assign[3] = s->ch_assign[2];
+                s->ch_assign[2] = i;
+            } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
+                FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
+                FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
+            }
+        }
+
     }
 
     return 0;
@@ -599,7 +635,7 @@ static int read_restart_header(MLPDecodeContext *m, BitstreamContext *bc,
 
 /** Read parameters for one of the prediction filters. */
 
-static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
+static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
                               unsigned int substr, unsigned int channel,
                               unsigned int filter)
 {
@@ -610,14 +646,14 @@ static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
     int i, order;
 
     // Filter is 0 for FIR, 1 for IIR.
-    assert(filter < 2);
+    av_assert0(filter < 2);
 
     if (m->filter_changed[channel][filter]++ > 1) {
         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
         return AVERROR_INVALIDDATA;
     }
 
-    order = bitstream_read(bc, 4);
+    order = get_bits(gbp, 4);
     if (order > max_order) {
         av_log(m->avctx, AV_LOG_ERROR,
                "%cIR filter order %d is greater than maximum %d.\n",
@@ -630,10 +666,10 @@ static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
         int coeff_bits, coeff_shift;
 
-        fp->shift = bitstream_read(bc, 4);
+        fp->shift = get_bits(gbp, 4);
 
-        coeff_bits  = bitstream_read(bc, 5);
-        coeff_shift = bitstream_read(bc, 3);
+        coeff_bits  = get_bits(gbp, 5);
+        coeff_shift = get_bits(gbp, 3);
         if (coeff_bits < 1 || coeff_bits > 16) {
             av_log(m->avctx, AV_LOG_ERROR,
                    "%cIR filter coeff_bits must be between 1 and 16.\n",
@@ -648,9 +684,9 @@ static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
         }
 
         for (i = 0; i < order; i++)
-            fcoeff[i] = bitstream_read_signed(bc, coeff_bits) << coeff_shift;
+            fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
 
-        if (bitstream_read_bit(bc)) {
+        if (get_bits1(gbp)) {
             int state_bits, state_shift;
 
             if (filter == FIR) {
@@ -659,13 +695,13 @@ static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
                 return AVERROR_INVALIDDATA;
             }
 
-            state_bits  = bitstream_read(bc, 4);
-            state_shift = bitstream_read(bc, 4);
+            state_bits  = get_bits(gbp, 4);
+            state_shift = get_bits(gbp, 4);
 
             /* TODO: Check validity of state data. */
 
             for (i = 0; i < order; i++)
-                fp->state[i] = bitstream_read_signed(bc, state_bits) << state_shift;
+                fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
         }
     }
 
@@ -674,8 +710,7 @@ static int read_filter_params(MLPDecodeContext *m, BitstreamContext *bc,
 
 /** Read parameters for primitive matrices. */
 
-static int read_matrix_params(MLPDecodeContext *m, unsigned int substr,
-                              BitstreamContext *bc)
+static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
 {
     SubStream *s = &m->substream[substr];
     unsigned int mat, ch;
@@ -688,31 +723,31 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr,
         return AVERROR_INVALIDDATA;
     }
 
-    s->num_primitive_matrices = bitstream_read(bc, 4);
+    s->num_primitive_matrices = get_bits(gbp, 4);
 
     if (s->num_primitive_matrices > max_primitive_matrices) {
         av_log(m->avctx, AV_LOG_ERROR,
                "Number of primitive matrices cannot be greater than %d.\n",
                max_primitive_matrices);
-        return AVERROR_INVALIDDATA;
+        goto error;
     }
 
     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
         int frac_bits, max_chan;
-        s->matrix_out_ch[mat] = bitstream_read(bc, 4);
-        frac_bits             = bitstream_read(bc, 4);
-        s->lsb_bypass[mat]    = bitstream_read_bit(bc);
+        s->matrix_out_ch[mat] = get_bits(gbp, 4);
+        frac_bits             = get_bits(gbp, 4);
+        s->lsb_bypass   [mat] = get_bits1(gbp);
 
         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
             av_log(m->avctx, AV_LOG_ERROR,
                     "Invalid channel %d specified as output from matrix.\n",
                     s->matrix_out_ch[mat]);
-            return AVERROR_INVALIDDATA;
+            goto error;
         }
         if (frac_bits > 14) {
             av_log(m->avctx, AV_LOG_ERROR,
                     "Too many fractional bits specified.\n");
-            return AVERROR_INVALIDDATA;
+            goto error;
         }
 
         max_chan = s->max_matrix_channel;
@@ -721,25 +756,30 @@ static int read_matrix_params(MLPDecodeContext *m, unsigned int substr,
 
         for (ch = 0; ch <= max_chan; ch++) {
             int coeff_val = 0;
-            if (bitstream_read_bit(bc))
-                coeff_val = bitstream_read_signed(bc, frac_bits + 2);
+            if (get_bits1(gbp))
+                coeff_val = get_sbits(gbp, frac_bits + 2);
 
-            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);
+            s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
         }
 
         if (s->noise_type)
-            s->matrix_noise_shift[mat] = bitstream_read(bc, 4);
+            s->matrix_noise_shift[mat] = get_bits(gbp, 4);
         else
             s->matrix_noise_shift[mat] = 0;
     }
 
     return 0;
+error:
+    s->num_primitive_matrices = 0;
+    memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
+
+    return AVERROR_INVALIDDATA;
 }
 
 /** Read channel parameters. */
 
 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
-                               BitstreamContext *bc, unsigned int ch)
+                               GetBitContext *gbp, unsigned int ch)
 {
     SubStream *s = &m->substream[substr];
     ChannelParams *cp = &s->channel_params[ch];
@@ -748,13 +788,13 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
     int ret;
 
     if (s->param_presence_flags & PARAM_FIR)
-        if (bitstream_read_bit(bc))
-            if ((ret = read_filter_params(m, bc, substr, ch, FIR)) < 0)
+        if (get_bits1(gbp))
+            if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
                 return ret;
 
     if (s->param_presence_flags & PARAM_IIR)
-        if (bitstream_read_bit(bc))
-            if ((ret = read_filter_params(m, bc, substr, ch, IIR)) < 0)
+        if (get_bits1(gbp))
+            if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
                 return ret;
 
     if (fir->order + iir->order > 8) {
@@ -777,55 +817,60 @@ static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
         fir->shift = iir->shift;
 
     if (s->param_presence_flags & PARAM_HUFFOFFSET)
-        if (bitstream_read_bit(bc))
-            cp->huff_offset = bitstream_read_signed(bc, 15);
+        if (get_bits1(gbp))
+            cp->huff_offset = get_sbits(gbp, 15);
 
-    cp->codebook  = bitstream_read(bc, 2);
-    cp->huff_lsbs = bitstream_read(bc, 5);
+    cp->codebook  = get_bits(gbp, 2);
+    cp->huff_lsbs = get_bits(gbp, 5);
 
     if (cp->huff_lsbs > 24) {
         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
+        cp->huff_lsbs = 0;
         return AVERROR_INVALIDDATA;
     }
 
-    cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
-
     return 0;
 }
 
 /** Read decoding parameters that change more often than those in the restart
  *  header. */
 
-static int read_decoding_params(MLPDecodeContext *m, BitstreamContext *bc,
+static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
                                 unsigned int substr)
 {
     SubStream *s = &m->substream[substr];
     unsigned int ch;
-    int ret;
+    int ret = 0;
+    unsigned recompute_sho = 0;
 
     if (s->param_presence_flags & PARAM_PRESENCE)
-        if (bitstream_read_bit(bc))
-            s->param_presence_flags = bitstream_read(bc, 8);
+        if (get_bits1(gbp))
+            s->param_presence_flags = get_bits(gbp, 8);
 
     if (s->param_presence_flags & PARAM_BLOCKSIZE)
-        if (bitstream_read_bit(bc)) {
-            s->blocksize = bitstream_read(bc, 9);
+        if (get_bits1(gbp)) {
+            s->blocksize = get_bits(gbp, 9);
             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
-                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.");
+                av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
                 s->blocksize = 0;
                 return AVERROR_INVALIDDATA;
             }
         }
 
     if (s->param_presence_flags & PARAM_MATRIX)
-        if (bitstream_read_bit(bc))
-            if ((ret = read_matrix_params(m, substr, bc)) < 0)
+        if (get_bits1(gbp))
+            if ((ret = read_matrix_params(m, substr, gbp)) < 0)
                 return ret;
 
     if (s->param_presence_flags & PARAM_OUTSHIFT)
-        if (bitstream_read_bit(bc)) {
-            for (ch = 0; ch <= s->max_matrix_channel; ch++)
-                s->output_shift[ch] = bitstream_read_signed(bc, 4);
+        if (get_bits1(gbp)) {
+            for (ch = 0; ch <= s->max_matrix_channel; ch++) {
+                s->output_shift[ch] = get_sbits(gbp, 4);
+                if (s->output_shift[ch] < 0) {
+                    avpriv_request_sample(m->avctx, "Negative output_shift");
+                    s->output_shift[ch] = 0;
+                }
+            }
             if (substr == m->max_decoded_substream)
                 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
                                                                        s->output_shift,
@@ -834,24 +879,41 @@ static int read_decoding_params(MLPDecodeContext *m, BitstreamContext *bc,
         }
 
     if (s->param_presence_flags & PARAM_QUANTSTEP)
-        if (bitstream_read_bit(bc))
+        if (get_bits1(gbp))
             for (ch = 0; ch <= s->max_channel; ch++) {
-                ChannelParams *cp = &s->channel_params[ch];
-
-                s->quant_step_size[ch] = bitstream_read(bc, 4);
+                s->quant_step_size[ch] = get_bits(gbp, 4);
 
-                cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
+                recompute_sho |= 1<<ch;
             }
 
     for (ch = s->min_channel; ch <= s->max_channel; ch++)
-        if (bitstream_read_bit(bc))
-            if ((ret = read_channel_params(m, substr, bc, ch)) < 0)
-                return ret;
+        if (get_bits1(gbp)) {
+            recompute_sho |= 1<<ch;
+            if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
+                goto fail;
+        }
 
-    return 0;
+
+fail:
+    for (ch = 0; ch <= s->max_channel; ch++) {
+        if (recompute_sho & (1<<ch)) {
+            ChannelParams *cp = &s->channel_params[ch];
+
+            if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
+                if (ret >= 0) {
+                    av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
+                    ret = AVERROR_INVALIDDATA;
+                }
+                s->quant_step_size[ch] = 0;
+            }
+
+            cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
+        }
+    }
+    return ret;
 }
 
-#define MSB_MASK(bits)  (-1u << bits)
+#define MSB_MASK(bits)  (-1u << (bits))
 
 /** Generate PCM samples using the prediction filters and residual values
  *  read from the data stream, and update the filter state. */
@@ -883,7 +945,7 @@ static void filter_channel(MLPDecodeContext *m, unsigned int substr,
 
 /** Read a block of PCM residual data (or actual if no filtering active). */
 
-static int read_block_data(MLPDecodeContext *m, BitstreamContext *bc,
+static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
                            unsigned int substr)
 {
     SubStream *s = &m->substream[substr];
@@ -891,8 +953,8 @@ static int read_block_data(MLPDecodeContext *m, BitstreamContext *bc,
     int ret;
 
     if (s->data_check_present) {
-        expected_stream_pos  = bitstream_tell(bc);
-        expected_stream_pos += bitstream_read(bc, 16);
+        expected_stream_pos  = get_bits_count(gbp);
+        expected_stream_pos += get_bits(gbp, 16);
         avpriv_request_sample(m->avctx,
                               "Substreams with VLC block size check info");
     }
@@ -906,7 +968,7 @@ static int read_block_data(MLPDecodeContext *m, BitstreamContext *bc,
            s->blocksize * sizeof(m->bypassed_lsbs[0]));
 
     for (i = 0; i < s->blocksize; i++)
-        if ((ret = read_huff_channels(m, bc, substr, i)) < 0)
+        if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
             return ret;
 
     for (ch = s->min_channel; ch <= s->max_channel; ch++)
@@ -915,9 +977,9 @@ static int read_block_data(MLPDecodeContext *m, BitstreamContext *bc,
     s->blockpos += s->blocksize;
 
     if (s->data_check_present) {
-        if (bitstream_tell(bc) != expected_stream_pos)
+        if (get_bits_count(gbp) != expected_stream_pos)
             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
-        bitstream_skip(bc, 8);
+        skip_bits(gbp, 8);
     }
 
     return 0;
@@ -963,8 +1025,8 @@ static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
 
     for (i = 0; i < s->blockpos; i++) {
         uint16_t seed_shr7 = seed >> 7;
-        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;
-        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   << s->noise_shift;
+        m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
+        m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   * (1 << s->noise_shift);
 
         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
     }
@@ -989,15 +1051,27 @@ static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
     s->noisegen_seed = seed;
 }
 
+/** Write the audio data into the output buffer. */
 
-/** Apply the channel matrices in turn to reconstruct the original audio
- *  samples. */
-
-static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
+static int output_data(MLPDecodeContext *m, unsigned int substr,
+                       AVFrame *frame, int *got_frame_ptr)
 {
+    AVCodecContext *avctx = m->avctx;
     SubStream *s = &m->substream[substr];
     unsigned int mat;
     unsigned int maxchan;
+    int ret;
+    int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
+
+    if (m->avctx->channels != s->max_matrix_channel + 1) {
+        av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (!s->blockpos) {
+        av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
+        return AVERROR_INVALIDDATA;
+    }
 
     maxchan = s->max_matrix_channel;
     if (!s->noise_type) {
@@ -1007,6 +1081,8 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
         fill_noise_buffer(m, substr);
     }
 
+    /* Apply the channel matrices in turn to reconstruct the original audio
+     * samples. */
     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
         unsigned int dest_ch = s->matrix_out_ch[mat];
         m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
@@ -1021,34 +1097,11 @@ static void rematrix_channels(MLPDecodeContext *m, unsigned int substr)
                                     m->access_unit_size_pow2,
                                     MSB_MASK(s->quant_step_size[dest_ch]));
     }
-}
-
-/** Write the audio data into the output buffer. */
-
-static int output_data(MLPDecodeContext *m, unsigned int substr,
-                       AVFrame *frame, int *got_frame_ptr)
-{
-    AVCodecContext *avctx = m->avctx;
-    SubStream *s = &m->substream[substr];
-    int ret;
-    int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
-
-    if (m->avctx->channels != s->max_matrix_channel + 1) {
-        av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
-        return AVERROR_INVALIDDATA;
-    }
-
-    if (!s->blockpos) {
-        av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
-        return AVERROR_INVALIDDATA;
-    }
 
     /* get output buffer */
     frame->nb_samples = s->blockpos;
-    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
-        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
         return ret;
-    }
     s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
                                                     s->blockpos,
                                                     m->sample_buffer,
@@ -1077,7 +1130,7 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
     const uint8_t *buf = avpkt->data;
     int buf_size = avpkt->size;
     MLPDecodeContext *m = avctx->priv_data;
-    BitstreamContext bc;
+    GetBitContext gb;
     unsigned int length, substr;
     unsigned int substream_start;
     unsigned int header_size = 4;
@@ -1088,18 +1141,18 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
     int ret;
 
     if (buf_size < 4)
-        return 0;
+        return AVERROR_INVALIDDATA;
 
     length = (AV_RB16(buf) & 0xfff) * 2;
 
     if (length < 4 || length > buf_size)
         return AVERROR_INVALIDDATA;
 
-    bitstream_init8(&bc, buf + 4, length - 4);
+    init_get_bits(&gb, (buf + 4), (length - 4) * 8);
 
     m->is_major_sync_unit = 0;
-    if (bitstream_peek(&bc, 31) == (0xf8726fba >> 1)) {
-        if (read_major_sync(m, &bc) < 0)
+    if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
+        if (read_major_sync(m, &gb) < 0)
             goto error;
         m->is_major_sync_unit = 1;
         header_size += m->major_sync_header_size;
@@ -1117,12 +1170,12 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
     for (substr = 0; substr < m->num_substreams; substr++) {
         int extraword_present, checkdata_present, end, nonrestart_substr;
 
-        extraword_present = bitstream_read_bit(&bc);
-        nonrestart_substr = bitstream_read_bit(&bc);
-        checkdata_present = bitstream_read_bit(&bc);
-        bitstream_skip(&bc, 1);
+        extraword_present = get_bits1(&gb);
+        nonrestart_substr = get_bits1(&gb);
+        checkdata_present = get_bits1(&gb);
+        skip_bits1(&gb);
 
-        end = bitstream_read(&bc, 12) * 2;
+        end = get_bits(&gb, 12) * 2;
 
         substr_header_size += 2;
 
@@ -1131,10 +1184,15 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
                 goto error;
             }
-            bitstream_skip(&bc, 16);
+            skip_bits(&gb, 16);
             substr_header_size += 2;
         }
 
+        if (length < header_size + substr_header_size) {
+            av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
+            goto error;
+        }
+
         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
             goto error;
@@ -1175,47 +1233,47 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
 
     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
         SubStream *s = &m->substream[substr];
-        bitstream_init8(&bc, buf, substream_data_len[substr]);
+        init_get_bits(&gb, buf, substream_data_len[substr] * 8);
 
         m->matrix_changed = 0;
         memset(m->filter_changed, 0, sizeof(m->filter_changed));
 
         s->blockpos = 0;
         do {
-            if (bitstream_read_bit(&bc)) {
-                if (bitstream_read_bit(&bc)) {
+            if (get_bits1(&gb)) {
+                if (get_bits1(&gb)) {
                     /* A restart header should be present. */
-                    if (read_restart_header(m, &bc, buf, substr) < 0)
+                    if (read_restart_header(m, &gb, buf, substr) < 0)
                         goto next_substr;
                     s->restart_seen = 1;
                 }
 
                 if (!s->restart_seen)
                     goto next_substr;
-                if (read_decoding_params(m, &bc, substr) < 0)
+                if (read_decoding_params(m, &gb, substr) < 0)
                     goto next_substr;
             }
 
             if (!s->restart_seen)
                 goto next_substr;
 
-            if ((ret = read_block_data(m, &bc, substr)) < 0)
+            if ((ret = read_block_data(m, &gb, substr)) < 0)
                 return ret;
 
-            if (bitstream_tell(&bc) >= substream_data_len[substr] * 8)
+            if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
                 goto substream_length_mismatch;
 
-        } while (!bitstream_read_bit(&bc));
+        } while (!get_bits1(&gb));
 
-        bitstream_skip(&bc, (-bitstream_tell(&bc)) & 15);
+        skip_bits(&gb, (-get_bits_count(&gb)) & 15);
 
-        if (substream_data_len[substr] * 8 - bitstream_tell(&bc) >= 32) {
+        if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
             int shorten_by;
 
-            if (bitstream_read(&bc, 16) != 0xD234)
+            if (get_bits(&gb, 16) != 0xD234)
                 return AVERROR_INVALIDDATA;
 
-            shorten_by = bitstream_read(&bc, 16);
+            shorten_by = get_bits(&gb, 16);
             if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
             else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
@@ -1228,19 +1286,19 @@ static int read_access_unit(AVCodecContext *avctx, void* data,
         if (substream_parity_present[substr]) {
             uint8_t parity, checksum;
 
-            if (substream_data_len[substr] * 8 - bitstream_tell(&bc) != 16)
+            if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
                 goto substream_length_mismatch;
 
             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
 
-            if ((bitstream_read(&bc, 8) ^ parity) != 0xa9)
+            if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
-            if (bitstream_read(&bc, 8) != checksum)
+            if ( get_bits(&gb, 8)           != checksum)
                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
         }
 
-        if (substream_data_len[substr] * 8 != bitstream_tell(&bc))
+        if (substream_data_len[substr] * 8 != get_bits_count(&gb))
             goto substream_length_mismatch;
 
 next_substr:
@@ -1251,8 +1309,6 @@ next_substr:
         buf += substream_data_len[substr];
     }
 
-    rematrix_channels(m, m->max_decoded_substream);
-
     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
         return ret;
 
@@ -1267,6 +1323,7 @@ error:
     return AVERROR_INVALIDDATA;
 }
 
+#if CONFIG_MLP_DECODER
 AVCodec ff_mlp_decoder = {
     .name           = "mlp",
     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
@@ -1277,7 +1334,7 @@ AVCodec ff_mlp_decoder = {
     .decode         = read_access_unit,
     .capabilities   = AV_CODEC_CAP_DR1,
 };
-
+#endif
 #if CONFIG_TRUEHD_DECODER
 AVCodec ff_truehd_decoder = {
     .name           = "truehd",