Merge commit '970c76f32283bddf3a5afd24fe52db7a96186244'
authorJames Almer <jamrial@gmail.com>
Mon, 30 Oct 2017 20:20:45 +0000 (17:20 -0300)
committerJames Almer <jamrial@gmail.com>
Mon, 30 Oct 2017 20:20:45 +0000 (17:20 -0300)
* commit '970c76f32283bddf3a5afd24fe52db7a96186244':
  mlp_parser: Drop in-parser downmix functionality

Merged-by: James Almer <jamrial@gmail.com>
1  2 
libavcodec/mlp_parser.c
libavcodec/mlp_parser.h
libavcodec/mlpdec.c

diff --combined libavcodec/mlp_parser.c
@@@ -2,20 -2,20 +2,20 @@@
   * MLP parser
   * Copyright (c) 2007 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
   */
  
@@@ -29,7 -29,8 +29,7 @@@
  #include "libavutil/channel_layout.h"
  #include "libavutil/crc.h"
  #include "libavutil/internal.h"
 -
 -#include "bitstream.h"
 +#include "get_bits.h"
  #include "parser.h"
  #include "mlp_parser.h"
  #include "mlp.h"
@@@ -44,28 -45,28 +44,28 @@@ static const uint8_t mlp_channels[32] 
      5, 6, 5, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  };
  
 -static const uint64_t mlp_layout[32] = {
 +const uint64_t ff_mlp_layout[32] = {
      AV_CH_LAYOUT_MONO,
      AV_CH_LAYOUT_STEREO,
      AV_CH_LAYOUT_2_1,
 -    AV_CH_LAYOUT_2_2,
 +    AV_CH_LAYOUT_QUAD,
      AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY,
      AV_CH_LAYOUT_2_1|AV_CH_LOW_FREQUENCY,
 -    AV_CH_LAYOUT_2_2|AV_CH_LOW_FREQUENCY,
 +    AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
      AV_CH_LAYOUT_SURROUND,
      AV_CH_LAYOUT_4POINT0,
 -    AV_CH_LAYOUT_5POINT0,
 +    AV_CH_LAYOUT_5POINT0_BACK,
      AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
      AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
 -    AV_CH_LAYOUT_5POINT1,
 +    AV_CH_LAYOUT_5POINT1_BACK,
      AV_CH_LAYOUT_4POINT0,
 -    AV_CH_LAYOUT_5POINT0,
 +    AV_CH_LAYOUT_5POINT0_BACK,
      AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
      AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
 -    AV_CH_LAYOUT_5POINT1,
 -    AV_CH_LAYOUT_2_2|AV_CH_LOW_FREQUENCY,
 -    AV_CH_LAYOUT_5POINT0,
 -    AV_CH_LAYOUT_5POINT1,
 +    AV_CH_LAYOUT_5POINT1_BACK,
 +    AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
 +    AV_CH_LAYOUT_5POINT0_BACK,
 +    AV_CH_LAYOUT_5POINT1_BACK,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  };
  
@@@ -108,7 -109,7 +108,7 @@@ static int truehd_channels(int chanmap
      return channels;
  }
  
 -static uint64_t truehd_layout(int chanmap)
 +uint64_t ff_truehd_layout(int chanmap)
  {
      int i;
      uint64_t layout = 0;
      return layout;
  }
  
- int ff_mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
- {
-     return channel_layout && ((channel_layout & mask) == channel_layout);
- }
  static int mlp_get_major_sync_size(const uint8_t * buf, int bufsize)
  {
      int has_extension, extensions = 0;
  /** Read a major sync info header - contains high level information about
   *  the stream - sample rate, channel arrangement etc. Most of this
   *  information is not actually necessary for decoding, only for playback.
 - *  bc must be a freshly-initialized BitstreamContext with no bits read.
 + *  gb must be a freshly initialized GetBitContext with no bits read.
   */
  
 -int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, BitstreamContext *bc)
 +int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
  {
      int ratebits, channel_arrangement, header_size;
      uint16_t checksum;
  
 -    assert(bitstream_tell(bc) == 0);
 +    av_assert1(get_bits_count(gb) == 0);
  
 -    header_size = mlp_get_major_sync_size(bc->buffer, bc->size_in_bits >> 3);
 -    if (header_size < 0 || bc->size_in_bits < header_size << 3) {
 +    header_size = mlp_get_major_sync_size(gb->buffer, gb->size_in_bits >> 3);
 +    if (header_size < 0 || gb->size_in_bits < header_size << 3) {
          av_log(log, AV_LOG_ERROR, "packet too short, unable to read major sync\n");
          return -1;
      }
  
 -    checksum = ff_mlp_checksum16(bc->buffer, header_size - 2);
 -    if (checksum != AV_RL16(bc->buffer + header_size - 2)) {
 +    checksum = ff_mlp_checksum16(gb->buffer, header_size - 2);
 +    if (checksum != AV_RL16(gb->buffer+header_size-2)) {
          av_log(log, AV_LOG_ERROR, "major sync info header checksum error\n");
          return AVERROR_INVALIDDATA;
      }
  
 -    if (bitstream_read(bc, 24) != 0xf8726f) /* Sync words */
 +    if (get_bits_long(gb, 24) != 0xf8726f) /* Sync words */
          return AVERROR_INVALIDDATA;
  
 -    mh->stream_type = bitstream_read(bc, 8);
 +    mh->stream_type = get_bits(gb, 8);
      mh->header_size = header_size;
  
      if (mh->stream_type == 0xbb) {
 -        mh->group1_bits = mlp_quants[bitstream_read(bc, 4)];
 -        mh->group2_bits = mlp_quants[bitstream_read(bc, 4)];
 +        mh->group1_bits = mlp_quants[get_bits(gb, 4)];
 +        mh->group2_bits = mlp_quants[get_bits(gb, 4)];
  
 -        ratebits = bitstream_read(bc, 4);
 +        ratebits = get_bits(gb, 4);
          mh->group1_samplerate = mlp_samplerate(ratebits);
 -        mh->group2_samplerate = mlp_samplerate(bitstream_read(bc, 4));
 +        mh->group2_samplerate = mlp_samplerate(get_bits(gb, 4));
  
 -        bitstream_skip(bc, 11);
 +        skip_bits(gb, 11);
  
 -        channel_arrangement    = bitstream_read(bc, 5);
 +        mh->channel_arrangement=
 +        channel_arrangement    = get_bits(gb, 5);
          mh->channels_mlp       = mlp_channels[channel_arrangement];
 -        mh->channel_layout_mlp = mlp_layout[channel_arrangement];
 +        mh->channel_layout_mlp = ff_mlp_layout[channel_arrangement];
      } else if (mh->stream_type == 0xba) {
          mh->group1_bits = 24; // TODO: Is this information actually conveyed anywhere?
          mh->group2_bits = 0;
  
 -        ratebits = bitstream_read(bc, 4);
 +        ratebits = get_bits(gb, 4);
          mh->group1_samplerate = mlp_samplerate(ratebits);
          mh->group2_samplerate = 0;
  
 -        bitstream_skip(bc, 4);
 +        skip_bits(gb, 4);
  
 -        mh->channel_modifier_thd_stream0 = bitstream_read(bc, 2);
 -        mh->channel_modifier_thd_stream1 = bitstream_read(bc, 2);
 +        mh->channel_modifier_thd_stream0 = get_bits(gb, 2);
 +        mh->channel_modifier_thd_stream1 = get_bits(gb, 2);
  
 -        channel_arrangement            = bitstream_read(bc, 5);
 +        mh->channel_arrangement=
 +        channel_arrangement            = get_bits(gb, 5);
          mh->channels_thd_stream1       = truehd_channels(channel_arrangement);
 -        mh->channel_layout_thd_stream1 = truehd_layout(channel_arrangement);
 +        mh->channel_layout_thd_stream1 = ff_truehd_layout(channel_arrangement);
  
 -        mh->channel_modifier_thd_stream2 = bitstream_read(bc, 2);
 +        mh->channel_modifier_thd_stream2 = get_bits(gb, 2);
  
 -        channel_arrangement            = bitstream_read(bc, 13);
 +        channel_arrangement            = get_bits(gb, 13);
          mh->channels_thd_stream2       = truehd_channels(channel_arrangement);
 -        mh->channel_layout_thd_stream2 = truehd_layout(channel_arrangement);
 +        mh->channel_layout_thd_stream2 = ff_truehd_layout(channel_arrangement);
      } else
          return AVERROR_INVALIDDATA;
  
      mh->access_unit_size = 40 << (ratebits & 7);
      mh->access_unit_size_pow2 = 64 << (ratebits & 7);
  
 -    bitstream_skip(bc, 48);
 +    skip_bits_long(gb, 48);
  
 -    mh->is_vbr = bitstream_read_bit(bc);
 +    mh->is_vbr = get_bits1(gb);
  
 -    mh->peak_bitrate = (bitstream_read(bc, 15) * mh->group1_samplerate + 8) >> 4;
 +    mh->peak_bitrate = (get_bits(gb, 15) * mh->group1_samplerate + 8) >> 4;
  
 -    mh->num_substreams = bitstream_read(bc, 4);
 +    mh->num_substreams = get_bits(gb, 4);
  
 -    bitstream_skip(bc, 4 + (header_size - 17) * 8);
 +    skip_bits_long(gb, 4 + (header_size - 17) * 8);
  
      return 0;
  }
@@@ -254,7 -248,6 +249,7 @@@ static int mlp_parse(AVCodecParserConte
      int sync_present;
      uint8_t parity_bits;
      int next;
 +    int ret;
      int i, p = 0;
  
      *poutbuf_size = 0;
          }
  
          if (!mp->in_sync) {
 -            ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size);
 +            if (ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size) != -1)
 +                av_log(avctx, AV_LOG_WARNING, "ff_combine_frame failed\n");
              return buf_size;
          }
  
 -        ff_combine_frame(&mp->pc, i - 7, &buf, &buf_size);
 +        if ((ret = ff_combine_frame(&mp->pc, i - 7, &buf, &buf_size)) < 0) {
 +            av_log(avctx, AV_LOG_WARNING, "ff_combine_frame failed\n");
 +            return ret;
 +        }
  
          return i - 7;
      }
          }
  
          if (mp->pc.index + buf_size < 2) {
 -            ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size);
 +            if (ff_combine_frame(&mp->pc, END_NOT_FOUND, &buf, &buf_size) != -1)
 +                av_log(avctx, AV_LOG_WARNING, "ff_combine_frame failed\n");
              return buf_size;
          }
  
          mp->bytes_left = ((mp->pc.index > 0 ? mp->pc.buffer[0] : buf[0]) << 8)
                         |  (mp->pc.index > 1 ? mp->pc.buffer[1] : buf[1-mp->pc.index]);
          mp->bytes_left = (mp->bytes_left & 0xfff) * 2;
 +        if (mp->bytes_left <= 0) { // prevent infinite loop
 +            goto lost_sync;
 +        }
          mp->bytes_left -= mp->pc.index;
      }
  
              goto lost_sync;
          }
      } else {
 -        BitstreamContext bc;
 +        GetBitContext gb;
          MLPHeaderInfo mh;
-         int stereo_requested = ff_mlp_channel_layout_subset(avctx->request_channel_layout,
-                                                             AV_CH_LAYOUT_STEREO);
  
 -        bitstream_init8(&bc, buf + 4, buf_size - 4);
 -        if (ff_mlp_read_major_sync(avctx, &mh, &bc) < 0)
 +        init_get_bits(&gb, buf + 4, (buf_size - 4) << 3);
 +        if (ff_mlp_read_major_sync(avctx, &mh, &gb) < 0)
              goto lost_sync;
  
          avctx->bits_per_raw_sample = mh.group1_bits;
          avctx->sample_rate = mh.group1_samplerate;
          s->duration = mh.access_unit_size;
  
 +        if(!avctx->channels || !avctx->channel_layout) {
          if (mh.stream_type == 0xbb) {
              /* MLP stream */
-             if (stereo_requested && mh.num_substreams > 1) {
-                 avctx->channels       = 2;
-                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
-             } else {
-                 avctx->channels       = mh.channels_mlp;
-                 avctx->channel_layout = mh.channel_layout_mlp;
-             }
+             avctx->channels       = mh.channels_mlp;
+             avctx->channel_layout = mh.channel_layout_mlp;
          } else { /* mh.stream_type == 0xba */
              /* TrueHD stream */
-             if (stereo_requested && mh.num_substreams > 1) {
-                 avctx->channels       = 2;
-                 avctx->channel_layout = AV_CH_LAYOUT_STEREO;
-             } else if (!mh.channels_thd_stream2 ||
-                        ff_mlp_channel_layout_subset(avctx->request_channel_layout,
-                                                     mh.channel_layout_thd_stream1)) {
+             if (!mh.channels_thd_stream2) {
                  avctx->channels       = mh.channels_thd_stream1;
                  avctx->channel_layout = mh.channel_layout_thd_stream1;
              } else {
                  avctx->channel_layout = mh.channel_layout_thd_stream2;
              }
          }
 +        }
  
          if (!mh.is_vbr) /* Stream is CBR */
              avctx->bit_rate = mh.peak_bitrate;
diff --combined libavcodec/mlp_parser.h
@@@ -2,20 -2,20 +2,20 @@@
   * MLP parser prototypes
   * Copyright (c) 2007 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
   */
  
@@@ -27,7 -27,7 +27,7 @@@
  #ifndef AVCODEC_MLP_PARSER_H
  #define AVCODEC_MLP_PARSER_H
  
 -#include "bitstream.h"
 +#include "get_bits.h"
  
  typedef struct MLPHeaderInfo
  {
@@@ -40,8 -40,6 +40,8 @@@
      int group1_samplerate;                  ///< Sample rate of first substream
      int group2_samplerate;                  ///< Sample rate of second substream (MLP only)
  
 +    int channel_arrangement;
 +
      int channel_modifier_thd_stream0;       ///< Channel modifier for substream 0 of TrueHD streams ("2-channel presentation")
      int channel_modifier_thd_stream1;       ///< Channel modifier for substream 1 of TrueHD streams ("6-channel presentation")
      int channel_modifier_thd_stream2;       ///< Channel modifier for substream 2 of TrueHD streams ("8-channel presentation")
  } MLPHeaderInfo;
  
  
 -int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, BitstreamContext *bc);
 +int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb);
 +uint64_t ff_truehd_layout(int chanmap);
 +
 +extern const uint64_t ff_mlp_layout[32];
  
- int ff_mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask);
  #endif /* AVCODEC_MLP_PARSER_H */
diff --combined libavcodec/mlpdec.c
@@@ -2,20 -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"
@@@ -105,7 -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];
      //@}
@@@ -144,9 -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
  
      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;
@@@ -180,6 -178,11 +180,11 @@@ static const uint64_t thd_channel_order
      AV_CH_LOW_FREQUENCY_2,                                   // LFE2
  };
  
+ static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
+ {
+     return channel_layout && ((channel_layout & mask) == channel_layout);
+ }
  static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
                                                     int index)
  {
@@@ -236,7 -239,7 +241,7 @@@ static inline int32_t calculate_sign_hu
  /** 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];
  
      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];
          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;
      }
@@@ -291,12 -295,12 +296,12 @@@ static av_cold int mlp_decode_init(AVCo
   *  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) {
       * 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)
              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.
       *
   *  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];
      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,
          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;
      }
  
  
      /* 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;
      }
  
      s->max_channel        = max_channel;
      s->max_matrix_channel = max_matrix_channel;
  
-     if (ff_mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
+     if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
          m->max_decoded_substream > substr) {
          av_log(m->avctx, AV_LOG_DEBUG,
                 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
          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);
                     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);
          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. */
                                                                 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;
  
  /** 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)
  {
      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",
          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",
          }
  
          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) {
                  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;
          }
      }
  
  
  /** 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;
          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;
  
          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];
      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) {
          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,
          }
  
      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. */
@@@ -945,7 -888,7 +950,7 @@@ static void filter_channel(MLPDecodeCon
  
  /** 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];
      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");
      }
             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++)
      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;
@@@ -1025,8 -968,8 +1030,8 @@@ static void generate_2_noise_channels(M
  
      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);
      }
@@@ -1051,27 -994,15 +1056,27 @@@ static void fill_noise_buffer(MLPDecode
      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) {
          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],
                                      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,
@@@ -1130,7 -1082,7 +1135,7 @@@ static int read_access_unit(AVCodecCont
      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;
      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;
      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;
  
                  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;
  
      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)
          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:
          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;
  
@@@ -1323,7 -1272,6 +1328,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)"),
      .decode         = read_access_unit,
      .capabilities   = AV_CODEC_CAP_DR1,
  };
 -
 +#endif
  #if CONFIG_TRUEHD_DECODER
  AVCodec ff_truehd_decoder = {
      .name           = "truehd",