LCOV - code coverage report
Current view: top level - libavcodec - mlpdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 445 622 71.5 %
Date: 2017-12-13 18:07:29 Functions: 18 18 100.0 %

          Line data    Source code
       1             : /*
       2             :  * MLP decoder
       3             :  * Copyright (c) 2007-2008 Ian Caulfield
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * MLP decoder
      25             :  */
      26             : 
      27             : #include <stdint.h>
      28             : 
      29             : #include "avcodec.h"
      30             : #include "libavutil/internal.h"
      31             : #include "libavutil/intreadwrite.h"
      32             : #include "libavutil/channel_layout.h"
      33             : #include "get_bits.h"
      34             : #include "internal.h"
      35             : #include "libavutil/crc.h"
      36             : #include "parser.h"
      37             : #include "mlp_parser.h"
      38             : #include "mlpdsp.h"
      39             : #include "mlp.h"
      40             : #include "config.h"
      41             : 
      42             : /** number of bits used for VLC lookup - longest Huffman code is 9 */
      43             : #if ARCH_ARM
      44             : #define VLC_BITS            5
      45             : #define VLC_STATIC_SIZE     64
      46             : #else
      47             : #define VLC_BITS            9
      48             : #define VLC_STATIC_SIZE     512
      49             : #endif
      50             : 
      51             : typedef struct SubStream {
      52             :     /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.
      53             :     uint8_t     restart_seen;
      54             : 
      55             :     //@{
      56             :     /** restart header data */
      57             :     /// The type of noise to be used in the rematrix stage.
      58             :     uint16_t    noise_type;
      59             : 
      60             :     /// The index of the first channel coded in this substream.
      61             :     uint8_t     min_channel;
      62             :     /// The index of the last channel coded in this substream.
      63             :     uint8_t     max_channel;
      64             :     /// The number of channels input into the rematrix stage.
      65             :     uint8_t     max_matrix_channel;
      66             :     /// For each channel output by the matrix, the output channel to map it to
      67             :     uint8_t     ch_assign[MAX_CHANNELS];
      68             :     /// The channel layout for this substream
      69             :     uint64_t    mask;
      70             :     /// The matrix encoding mode for this substream
      71             :     enum AVMatrixEncoding matrix_encoding;
      72             : 
      73             :     /// Channel coding parameters for channels in the substream
      74             :     ChannelParams channel_params[MAX_CHANNELS];
      75             : 
      76             :     /// The left shift applied to random noise in 0x31ea substreams.
      77             :     uint8_t     noise_shift;
      78             :     /// The current seed value for the pseudorandom noise generator(s).
      79             :     uint32_t    noisegen_seed;
      80             : 
      81             :     /// Set if the substream contains extra info to check the size of VLC blocks.
      82             :     uint8_t     data_check_present;
      83             : 
      84             :     /// Bitmask of which parameter sets are conveyed in a decoding parameter block.
      85             :     uint8_t     param_presence_flags;
      86             : #define PARAM_BLOCKSIZE     (1 << 7)
      87             : #define PARAM_MATRIX        (1 << 6)
      88             : #define PARAM_OUTSHIFT      (1 << 5)
      89             : #define PARAM_QUANTSTEP     (1 << 4)
      90             : #define PARAM_FIR           (1 << 3)
      91             : #define PARAM_IIR           (1 << 2)
      92             : #define PARAM_HUFFOFFSET    (1 << 1)
      93             : #define PARAM_PRESENCE      (1 << 0)
      94             :     //@}
      95             : 
      96             :     //@{
      97             :     /** matrix data */
      98             : 
      99             :     /// Number of matrices to be applied.
     100             :     uint8_t     num_primitive_matrices;
     101             : 
     102             :     /// matrix output channel
     103             :     uint8_t     matrix_out_ch[MAX_MATRICES];
     104             : 
     105             :     /// Whether the LSBs of the matrix output are encoded in the bitstream.
     106             :     uint8_t     lsb_bypass[MAX_MATRICES];
     107             :     /// Matrix coefficients, stored as 2.14 fixed point.
     108             :     DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];
     109             :     /// Left shift to apply to noise values in 0x31eb substreams.
     110             :     uint8_t     matrix_noise_shift[MAX_MATRICES];
     111             :     //@}
     112             : 
     113             :     /// Left shift to apply to Huffman-decoded residuals.
     114             :     uint8_t     quant_step_size[MAX_CHANNELS];
     115             : 
     116             :     /// number of PCM samples in current audio block
     117             :     uint16_t    blocksize;
     118             :     /// Number of PCM samples decoded so far in this frame.
     119             :     uint16_t    blockpos;
     120             : 
     121             :     /// Left shift to apply to decoded PCM values to get final 24-bit output.
     122             :     int8_t      output_shift[MAX_CHANNELS];
     123             : 
     124             :     /// Running XOR of all output samples.
     125             :     int32_t     lossless_check_data;
     126             : 
     127             : } SubStream;
     128             : 
     129             : typedef struct MLPDecodeContext {
     130             :     AVCodecContext *avctx;
     131             : 
     132             :     /// Current access unit being read has a major sync.
     133             :     int         is_major_sync_unit;
     134             : 
     135             :     /// Size of the major sync unit, in bytes
     136             :     int         major_sync_header_size;
     137             : 
     138             :     /// Set if a valid major sync block has been read. Otherwise no decoding is possible.
     139             :     uint8_t     params_valid;
     140             : 
     141             :     /// Number of substreams contained within this stream.
     142             :     uint8_t     num_substreams;
     143             : 
     144             :     /// Index of the last substream to decode - further substreams are skipped.
     145             :     uint8_t     max_decoded_substream;
     146             : 
     147             :     /// Stream needs channel reordering to comply with FFmpeg's channel order
     148             :     uint8_t     needs_reordering;
     149             : 
     150             :     /// number of PCM samples contained in each frame
     151             :     int         access_unit_size;
     152             :     /// next power of two above the number of samples in each frame
     153             :     int         access_unit_size_pow2;
     154             : 
     155             :     SubStream   substream[MAX_SUBSTREAMS];
     156             : 
     157             :     int         matrix_changed;
     158             :     int         filter_changed[MAX_CHANNELS][NUM_FILTERS];
     159             : 
     160             :     int8_t      noise_buffer[MAX_BLOCKSIZE_POW2];
     161             :     int8_t      bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];
     162             :     DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];
     163             : 
     164             :     MLPDSPContext dsp;
     165             : } MLPDecodeContext;
     166             : 
     167             : static const uint64_t thd_channel_order[] = {
     168             :     AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT,                     // LR
     169             :     AV_CH_FRONT_CENTER,                                      // C
     170             :     AV_CH_LOW_FREQUENCY,                                     // LFE
     171             :     AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT,                       // LRs
     172             :     AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT,             // LRvh
     173             :     AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
     174             :     AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT,                       // LRrs
     175             :     AV_CH_BACK_CENTER,                                       // Cs
     176             :     AV_CH_TOP_CENTER,                                        // Ts
     177             :     AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd
     178             :     AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT,                       // LRw
     179             :     AV_CH_TOP_FRONT_CENTER,                                  // Cvh
     180             :     AV_CH_LOW_FREQUENCY_2,                                   // LFE2
     181             : };
     182             : 
     183        1757 : static int mlp_channel_layout_subset(uint64_t channel_layout, uint64_t mask)
     184             : {
     185        1757 :     return channel_layout && ((channel_layout & mask) == channel_layout);
     186             : }
     187             : 
     188        2140 : static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,
     189             :                                                    int index)
     190             : {
     191             :     int i;
     192             : 
     193        2140 :     if (av_get_channel_layout_nb_channels(channel_layout) <= index)
     194           0 :         return 0;
     195             : 
     196        5778 :     for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)
     197        5778 :         if (channel_layout & thd_channel_order[i] && !index--)
     198        2140 :             return thd_channel_order[i];
     199           0 :     return 0;
     200             : }
     201             : 
     202             : static VLC huff_vlc[3];
     203             : 
     204             : /** Initialize static data, constant between all invocations of the codec. */
     205             : 
     206           6 : static av_cold void init_static(void)
     207             : {
     208           6 :     if (!huff_vlc[0].bits) {
     209           3 :         INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,
     210             :                     &ff_mlp_huffman_tables[0][0][1], 2, 1,
     211             :                     &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);
     212           3 :         INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,
     213             :                     &ff_mlp_huffman_tables[1][0][1], 2, 1,
     214             :                     &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);
     215           3 :         INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,
     216             :                     &ff_mlp_huffman_tables[2][0][1], 2, 1,
     217             :                     &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);
     218             :     }
     219             : 
     220           6 :     ff_mlp_init_crc();
     221           6 : }
     222             : 
     223       12178 : static inline int32_t calculate_sign_huff(MLPDecodeContext *m,
     224             :                                           unsigned int substr, unsigned int ch)
     225             : {
     226       12178 :     SubStream *s = &m->substream[substr];
     227       12178 :     ChannelParams *cp = &s->channel_params[ch];
     228       12178 :     int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];
     229       12178 :     int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);
     230       12178 :     int32_t sign_huff_offset = cp->huff_offset;
     231             : 
     232       12178 :     if (cp->codebook > 0)
     233        9059 :         sign_huff_offset -= 7 << lsb_bits;
     234             : 
     235       12178 :     if (sign_shift >= 0)
     236       11461 :         sign_huff_offset -= 1 << sign_shift;
     237             : 
     238       12178 :     return sign_huff_offset;
     239             : }
     240             : 
     241             : /** Read a sample, consisting of either, both or neither of entropy-coded MSBs
     242             :  *  and plain LSBs. */
     243             : 
     244      767880 : static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,
     245             :                                      unsigned int substr, unsigned int pos)
     246             : {
     247      767880 :     SubStream *s = &m->substream[substr];
     248             :     unsigned int mat, channel;
     249             : 
     250     1990960 :     for (mat = 0; mat < s->num_primitive_matrices; mat++)
     251     1223080 :         if (s->lsb_bypass[mat])
     252           0 :             m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);
     253             : 
     254     2576440 :     for (channel = s->min_channel; channel <= s->max_channel; channel++) {
     255     1808560 :         ChannelParams *cp = &s->channel_params[channel];
     256     1808560 :         int codebook = cp->codebook;
     257     1808560 :         int quant_step_size = s->quant_step_size[channel];
     258     1808560 :         int lsb_bits = cp->huff_lsbs - quant_step_size;
     259     1808560 :         int result = 0;
     260             : 
     261     1808560 :         if (codebook > 0)
     262     1703520 :             result = get_vlc2(gbp, huff_vlc[codebook-1].table,
     263             :                             VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);
     264             : 
     265     1808560 :         if (result < 0)
     266           0 :             return AVERROR_INVALIDDATA;
     267             : 
     268     1808560 :         if (lsb_bits > 0)
     269     1751336 :             result = (result << lsb_bits) + get_bits(gbp, lsb_bits);
     270             : 
     271     1808560 :         result  += cp->sign_huff_offset;
     272     1808560 :         result *= 1 << quant_step_size;
     273             : 
     274     1808560 :         m->sample_buffer[pos + s->blockpos][channel] = result;
     275             :     }
     276             : 
     277      767880 :     return 0;
     278             : }
     279             : 
     280           6 : static av_cold int mlp_decode_init(AVCodecContext *avctx)
     281             : {
     282           6 :     MLPDecodeContext *m = avctx->priv_data;
     283             :     int substr;
     284             : 
     285           6 :     init_static();
     286           6 :     m->avctx = avctx;
     287          30 :     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
     288          24 :         m->substream[substr].lossless_check_data = 0xffffffff;
     289           6 :     ff_mlpdsp_init(&m->dsp);
     290             : 
     291           6 :     return 0;
     292             : }
     293             : 
     294             : /** Read a major sync info header - contains high level information about
     295             :  *  the stream - sample rate, channel arrangement etc. Most of this
     296             :  *  information is not actually necessary for decoding, only for playback.
     297             :  */
     298             : 
     299        1543 : static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)
     300             : {
     301             :     MLPHeaderInfo mh;
     302             :     int substr, ret;
     303             : 
     304        1543 :     if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)
     305           0 :         return ret;
     306             : 
     307        1543 :     if (mh.group1_bits == 0) {
     308           0 :         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");
     309           0 :         return AVERROR_INVALIDDATA;
     310             :     }
     311        1543 :     if (mh.group2_bits > mh.group1_bits) {
     312           0 :         av_log(m->avctx, AV_LOG_ERROR,
     313             :                "Channel group 2 cannot have more bits per sample than group 1.\n");
     314           0 :         return AVERROR_INVALIDDATA;
     315             :     }
     316             : 
     317        1543 :     if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {
     318           0 :         av_log(m->avctx, AV_LOG_ERROR,
     319             :                "Channel groups with differing sample rates are not currently supported.\n");
     320           0 :         return AVERROR_INVALIDDATA;
     321             :     }
     322             : 
     323        1543 :     if (mh.group1_samplerate == 0) {
     324           0 :         av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");
     325           0 :         return AVERROR_INVALIDDATA;
     326             :     }
     327        1543 :     if (mh.group1_samplerate > MAX_SAMPLERATE) {
     328           0 :         av_log(m->avctx, AV_LOG_ERROR,
     329             :                "Sampling rate %d is greater than the supported maximum (%d).\n",
     330             :                mh.group1_samplerate, MAX_SAMPLERATE);
     331           0 :         return AVERROR_INVALIDDATA;
     332             :     }
     333        1543 :     if (mh.access_unit_size > MAX_BLOCKSIZE) {
     334           0 :         av_log(m->avctx, AV_LOG_ERROR,
     335             :                "Block size %d is greater than the supported maximum (%d).\n",
     336             :                mh.access_unit_size, MAX_BLOCKSIZE);
     337           0 :         return AVERROR_INVALIDDATA;
     338             :     }
     339        1543 :     if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {
     340           0 :         av_log(m->avctx, AV_LOG_ERROR,
     341             :                "Block size pow2 %d is greater than the supported maximum (%d).\n",
     342             :                mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);
     343           0 :         return AVERROR_INVALIDDATA;
     344             :     }
     345             : 
     346        1543 :     if (mh.num_substreams == 0)
     347           0 :         return AVERROR_INVALIDDATA;
     348        1543 :     if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {
     349           0 :         av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");
     350           0 :         return AVERROR_INVALIDDATA;
     351             :     }
     352        1543 :     if (mh.num_substreams > MAX_SUBSTREAMS) {
     353           0 :         avpriv_request_sample(m->avctx,
     354             :                               "%d substreams (more than the "
     355             :                               "maximum supported by the decoder)",
     356             :                               mh.num_substreams);
     357           0 :         return AVERROR_PATCHWELCOME;
     358             :     }
     359             : 
     360        1543 :     m->major_sync_header_size = mh.header_size;
     361             : 
     362        1543 :     m->access_unit_size      = mh.access_unit_size;
     363        1543 :     m->access_unit_size_pow2 = mh.access_unit_size_pow2;
     364             : 
     365        1543 :     m->num_substreams        = mh.num_substreams;
     366             : 
     367             :     /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */
     368        1543 :     m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);
     369             : 
     370        1543 :     m->avctx->sample_rate    = mh.group1_samplerate;
     371        1543 :     m->avctx->frame_size     = mh.access_unit_size;
     372             : 
     373        1543 :     m->avctx->bits_per_raw_sample = mh.group1_bits;
     374        1543 :     if (mh.group1_bits > 16)
     375         428 :         m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
     376             :     else
     377        1115 :         m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
     378        6172 :     m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,
     379        1543 :                                                            m->substream[m->max_decoded_substream].output_shift,
     380        1543 :                                                            m->substream[m->max_decoded_substream].max_matrix_channel,
     381        1543 :                                                            m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
     382             : 
     383        1543 :     m->params_valid = 1;
     384        7715 :     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
     385        6172 :         m->substream[substr].restart_seen = 0;
     386             : 
     387             :     /* Set the layout for each substream. When there's more than one, the first
     388             :      * substream is Stereo. Subsequent substreams' layouts are indicated in the
     389             :      * major sync. */
     390        1543 :     if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
     391        1115 :         if (mh.stream_type != 0xbb) {
     392           0 :             avpriv_request_sample(m->avctx,
     393             :                         "unexpected stream_type %X in MLP",
     394             :                         mh.stream_type);
     395           0 :             return AVERROR_PATCHWELCOME;
     396             :         }
     397        1115 :         if ((substr = (mh.num_substreams > 1)))
     398           0 :             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
     399        1115 :         m->substream[substr].mask = mh.channel_layout_mlp;
     400             :     } else {
     401         428 :         if (mh.stream_type != 0xba) {
     402           0 :             avpriv_request_sample(m->avctx,
     403             :                         "unexpected stream_type %X in !MLP",
     404             :                         mh.stream_type);
     405           0 :             return AVERROR_PATCHWELCOME;
     406             :         }
     407         428 :         if ((substr = (mh.num_substreams > 1)))
     408         428 :             m->substream[0].mask = AV_CH_LAYOUT_STEREO;
     409         428 :         if (mh.num_substreams > 2)
     410           0 :             if (mh.channel_layout_thd_stream2)
     411           0 :                 m->substream[2].mask = mh.channel_layout_thd_stream2;
     412             :             else
     413           0 :                 m->substream[2].mask = mh.channel_layout_thd_stream1;
     414         428 :         m->substream[substr].mask = mh.channel_layout_thd_stream1;
     415             : 
     416         428 :         if (m->avctx->channels<=2 && m->substream[substr].mask == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {
     417           0 :             av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");
     418           0 :             m->max_decoded_substream = 0;
     419           0 :             if (m->avctx->channels==2)
     420           0 :                 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;
     421             :         }
     422             :     }
     423             : 
     424        1543 :     m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;
     425             : 
     426             :     /* Parse the TrueHD decoder channel modifiers and set each substream's
     427             :      * AVMatrixEncoding accordingly.
     428             :      *
     429             :      * The meaning of the modifiers depends on the channel layout:
     430             :      *
     431             :      * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel
     432             :      *
     433             :      * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)
     434             :      *
     435             :      * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to
     436             :      *   layouts with an Ls/Rs channel pair
     437             :      */
     438        7715 :     for (substr = 0; substr < MAX_SUBSTREAMS; substr++)
     439        6172 :         m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;
     440        1543 :     if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
     441         428 :         if (mh.num_substreams > 2 &&
     442           0 :             mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&
     443           0 :             mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&
     444           0 :             mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)
     445           0 :             m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
     446             : 
     447         856 :         if (mh.num_substreams > 1 &&
     448         856 :             mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&
     449         856 :             mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&
     450         428 :             mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)
     451           0 :             m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
     452             : 
     453         428 :         if (mh.num_substreams > 0)
     454         428 :             switch (mh.channel_modifier_thd_stream0) {
     455           0 :             case THD_CH_MODIFIER_LTRT:
     456           0 :                 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
     457           0 :                 break;
     458           0 :             case THD_CH_MODIFIER_LBINRBIN:
     459           0 :                 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
     460           0 :                 break;
     461         428 :             default:
     462         428 :                 break;
     463             :             }
     464        1115 :     }
     465             : 
     466        1543 :     return 0;
     467             : }
     468             : 
     469             : /** Read a restart header from a block in a substream. This contains parameters
     470             :  *  required to decode the audio that do not change very often. Generally
     471             :  *  (always) present only in blocks following a major sync. */
     472             : 
     473        1757 : static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
     474             :                                const uint8_t *buf, unsigned int substr)
     475             : {
     476        1757 :     SubStream *s = &m->substream[substr];
     477             :     unsigned int ch;
     478             :     int sync_word, tmp;
     479             :     uint8_t checksum;
     480             :     uint8_t lossless_check;
     481        1757 :     int start_count = get_bits_count(gbp);
     482             :     int min_channel, max_channel, max_matrix_channel;
     483        3514 :     const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP
     484             :                                      ? MAX_MATRIX_CHANNEL_MLP
     485        1757 :                                      : MAX_MATRIX_CHANNEL_TRUEHD;
     486             : 
     487        1757 :     sync_word = get_bits(gbp, 13);
     488             : 
     489        1757 :     if (sync_word != 0x31ea >> 1) {
     490           0 :         av_log(m->avctx, AV_LOG_ERROR,
     491             :                "restart header sync incorrect (got 0x%04x)\n", sync_word);
     492           0 :         return AVERROR_INVALIDDATA;
     493             :     }
     494             : 
     495        1757 :     s->noise_type = get_bits1(gbp);
     496             : 
     497        1757 :     if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {
     498           0 :         av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");
     499           0 :         return AVERROR_INVALIDDATA;
     500             :     }
     501             : 
     502        1757 :     skip_bits(gbp, 16); /* Output timestamp */
     503             : 
     504        1757 :     min_channel        = get_bits(gbp, 4);
     505        1757 :     max_channel        = get_bits(gbp, 4);
     506        1757 :     max_matrix_channel = get_bits(gbp, 4);
     507             : 
     508        1757 :     if (max_matrix_channel > std_max_matrix_channel) {
     509           0 :         av_log(m->avctx, AV_LOG_ERROR,
     510             :                "Max matrix channel cannot be greater than %d.\n",
     511             :                std_max_matrix_channel);
     512           0 :         return AVERROR_INVALIDDATA;
     513             :     }
     514             : 
     515        1757 :     if (max_channel != max_matrix_channel) {
     516           0 :         av_log(m->avctx, AV_LOG_ERROR,
     517             :                "Max channel must be equal max matrix channel.\n");
     518           0 :         return AVERROR_INVALIDDATA;
     519             :     }
     520             : 
     521             :     /* This should happen for TrueHD streams with >6 channels and MLP's noise
     522             :      * type. It is not yet known if this is allowed. */
     523        1757 :     if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {
     524           0 :         avpriv_request_sample(m->avctx,
     525             :                               "%d channels (more than the "
     526             :                               "maximum supported by the decoder)",
     527             :                               max_channel + 2);
     528           0 :         return AVERROR_PATCHWELCOME;
     529             :     }
     530             : 
     531        1757 :     if (min_channel > max_channel) {
     532           0 :         av_log(m->avctx, AV_LOG_ERROR,
     533             :                "Substream min channel cannot be greater than max channel.\n");
     534           0 :         return AVERROR_INVALIDDATA;
     535             :     }
     536             : 
     537        1757 :     s->min_channel        = min_channel;
     538        1757 :     s->max_channel        = max_channel;
     539        1757 :     s->max_matrix_channel = max_matrix_channel;
     540             : 
     541        1971 :     if (mlp_channel_layout_subset(m->avctx->request_channel_layout, s->mask) &&
     542         214 :         m->max_decoded_substream > substr) {
     543         428 :         av_log(m->avctx, AV_LOG_DEBUG,
     544             :                "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "
     545             :                "Further substreams will be skipped.\n",
     546         214 :                s->max_channel + 1, s->mask, substr);
     547         214 :         m->max_decoded_substream = substr;
     548             :     }
     549             : 
     550        1757 :     s->noise_shift   = get_bits(gbp,  4);
     551        1757 :     s->noisegen_seed = get_bits(gbp, 23);
     552             : 
     553        1757 :     skip_bits(gbp, 19);
     554             : 
     555        1757 :     s->data_check_present = get_bits1(gbp);
     556        1757 :     lossless_check = get_bits(gbp, 8);
     557        1757 :     if (substr == m->max_decoded_substream
     558        1543 :         && s->lossless_check_data != 0xffffffff) {
     559        1540 :         tmp = xor_32_to_8(s->lossless_check_data);
     560        1540 :         if (tmp != lossless_check)
     561           0 :             av_log(m->avctx, AV_LOG_WARNING,
     562             :                    "Lossless check failed - expected %02x, calculated %02x.\n",
     563             :                    lossless_check, tmp);
     564             :     }
     565             : 
     566        1757 :     skip_bits(gbp, 16);
     567             : 
     568        1757 :     memset(s->ch_assign, 0, sizeof(s->ch_assign));
     569             : 
     570        6127 :     for (ch = 0; ch <= s->max_matrix_channel; ch++) {
     571        4370 :         int ch_assign = get_bits(gbp, 6);
     572        4370 :         if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {
     573        2140 :             uint64_t channel = thd_channel_layout_extract_channel(s->mask,
     574             :                                                                   ch_assign);
     575        2140 :             ch_assign = av_get_channel_layout_channel_index(s->mask,
     576             :                                                             channel);
     577             :         }
     578        4370 :         if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {
     579           0 :             avpriv_request_sample(m->avctx,
     580             :                                   "Assignment of matrix channel %d to invalid output channel %d",
     581             :                                   ch, ch_assign);
     582           0 :             return AVERROR_PATCHWELCOME;
     583             :         }
     584        4370 :         s->ch_assign[ch_assign] = ch;
     585             :     }
     586             : 
     587        1757 :     checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);
     588             : 
     589        1757 :     if (checksum != get_bits(gbp, 8))
     590           0 :         av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");
     591             : 
     592             :     /* Set default decoding parameters. */
     593        1757 :     s->param_presence_flags   = 0xff;
     594        1757 :     s->num_primitive_matrices = 0;
     595        1757 :     s->blocksize              = 8;
     596        1757 :     s->lossless_check_data    = 0;
     597             : 
     598        1757 :     memset(s->output_shift   , 0, sizeof(s->output_shift   ));
     599        1757 :     memset(s->quant_step_size, 0, sizeof(s->quant_step_size));
     600             : 
     601        5699 :     for (ch = s->min_channel; ch <= s->max_channel; ch++) {
     602        3942 :         ChannelParams *cp = &s->channel_params[ch];
     603        3942 :         cp->filter_params[FIR].order = 0;
     604        3942 :         cp->filter_params[IIR].order = 0;
     605        3942 :         cp->filter_params[FIR].shift = 0;
     606        3942 :         cp->filter_params[IIR].shift = 0;
     607             : 
     608             :         /* Default audio coding is 24-bit raw PCM. */
     609        3942 :         cp->huff_offset      = 0;
     610        3942 :         cp->sign_huff_offset = -(1 << 23);
     611        3942 :         cp->codebook         = 0;
     612        3942 :         cp->huff_lsbs        = 24;
     613             :     }
     614             : 
     615        1757 :     if (substr == m->max_decoded_substream) {
     616        1543 :         m->avctx->channels       = s->max_matrix_channel + 1;
     617        1543 :         m->avctx->channel_layout = s->mask;
     618        6172 :         m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
     619        1543 :                                                                s->output_shift,
     620        1543 :                                                                s->max_matrix_channel,
     621        1543 :                                                                m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
     622             : 
     623        1543 :         if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {
     624           0 :             if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||
     625           0 :                 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {
     626           0 :                 int i = s->ch_assign[4];
     627           0 :                 s->ch_assign[4] = s->ch_assign[3];
     628           0 :                 s->ch_assign[3] = s->ch_assign[2];
     629           0 :                 s->ch_assign[2] = i;
     630           0 :             } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {
     631           0 :                 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);
     632           0 :                 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);
     633             :             }
     634             :         }
     635             : 
     636             :     }
     637             : 
     638        1757 :     return 0;
     639             : }
     640             : 
     641             : /** Read parameters for one of the prediction filters. */
     642             : 
     643        4446 : static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,
     644             :                               unsigned int substr, unsigned int channel,
     645             :                               unsigned int filter)
     646             : {
     647        4446 :     SubStream *s = &m->substream[substr];
     648        4446 :     FilterParams *fp = &s->channel_params[channel].filter_params[filter];
     649        4446 :     const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;
     650        4446 :     const char fchar = filter ? 'I' : 'F';
     651             :     int i, order;
     652             : 
     653             :     // Filter is 0 for FIR, 1 for IIR.
     654        4446 :     av_assert0(filter < 2);
     655             : 
     656        4446 :     if (m->filter_changed[channel][filter]++ > 1) {
     657           0 :         av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");
     658           0 :         return AVERROR_INVALIDDATA;
     659             :     }
     660             : 
     661        4446 :     order = get_bits(gbp, 4);
     662        4446 :     if (order > max_order) {
     663           0 :         av_log(m->avctx, AV_LOG_ERROR,
     664             :                "%cIR filter order %d is greater than maximum %d.\n",
     665             :                fchar, order, max_order);
     666           0 :         return AVERROR_INVALIDDATA;
     667             :     }
     668        4446 :     fp->order = order;
     669             : 
     670        4446 :     if (order > 0) {
     671        4446 :         int32_t *fcoeff = s->channel_params[channel].coeff[filter];
     672             :         int coeff_bits, coeff_shift;
     673             : 
     674        4446 :         fp->shift = get_bits(gbp, 4);
     675             : 
     676        4446 :         coeff_bits  = get_bits(gbp, 5);
     677        4446 :         coeff_shift = get_bits(gbp, 3);
     678        4446 :         if (coeff_bits < 1 || coeff_bits > 16) {
     679           0 :             av_log(m->avctx, AV_LOG_ERROR,
     680             :                    "%cIR filter coeff_bits must be between 1 and 16.\n",
     681             :                    fchar);
     682           0 :             return AVERROR_INVALIDDATA;
     683             :         }
     684        4446 :         if (coeff_bits + coeff_shift > 16) {
     685           0 :             av_log(m->avctx, AV_LOG_ERROR,
     686             :                    "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",
     687             :                    fchar);
     688           0 :             return AVERROR_INVALIDDATA;
     689             :         }
     690             : 
     691       23529 :         for (i = 0; i < order; i++)
     692       19083 :             fcoeff[i] = get_sbits(gbp, coeff_bits) * (1 << coeff_shift);
     693             : 
     694        4446 :         if (get_bits1(gbp)) {
     695             :             int state_bits, state_shift;
     696             : 
     697         502 :             if (filter == FIR) {
     698           0 :                 av_log(m->avctx, AV_LOG_ERROR,
     699             :                        "FIR filter has state data specified.\n");
     700           0 :                 return AVERROR_INVALIDDATA;
     701             :             }
     702             : 
     703         502 :             state_bits  = get_bits(gbp, 4);
     704         502 :             state_shift = get_bits(gbp, 4);
     705             : 
     706             :             /* TODO: Check validity of state data. */
     707             : 
     708        1443 :             for (i = 0; i < order; i++)
     709         941 :                 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) * (1 << state_shift) : 0;
     710             :         }
     711             :     }
     712             : 
     713        4446 :     return 0;
     714             : }
     715             : 
     716             : /** Read parameters for primitive matrices. */
     717             : 
     718        1474 : static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)
     719             : {
     720        1474 :     SubStream *s = &m->substream[substr];
     721             :     unsigned int mat, ch;
     722        2948 :     const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP
     723             :                                      ? MAX_MATRICES_MLP
     724        1474 :                                      : MAX_MATRICES_TRUEHD;
     725             : 
     726        1474 :     if (m->matrix_changed++ > 1) {
     727           0 :         av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");
     728           0 :         return AVERROR_INVALIDDATA;
     729             :     }
     730             : 
     731        1474 :     s->num_primitive_matrices = get_bits(gbp, 4);
     732             : 
     733        1474 :     if (s->num_primitive_matrices > max_primitive_matrices) {
     734           0 :         av_log(m->avctx, AV_LOG_ERROR,
     735             :                "Number of primitive matrices cannot be greater than %d.\n",
     736             :                max_primitive_matrices);
     737           0 :         goto error;
     738             :     }
     739             : 
     740        3805 :     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
     741             :         int frac_bits, max_chan;
     742        2331 :         s->matrix_out_ch[mat] = get_bits(gbp, 4);
     743        2331 :         frac_bits             = get_bits(gbp, 4);
     744        2331 :         s->lsb_bypass   [mat] = get_bits1(gbp);
     745             : 
     746        2331 :         if (s->matrix_out_ch[mat] > s->max_matrix_channel) {
     747           0 :             av_log(m->avctx, AV_LOG_ERROR,
     748             :                     "Invalid channel %d specified as output from matrix.\n",
     749           0 :                     s->matrix_out_ch[mat]);
     750           0 :             goto error;
     751             :         }
     752        2331 :         if (frac_bits > 14) {
     753           0 :             av_log(m->avctx, AV_LOG_ERROR,
     754             :                     "Too many fractional bits specified.\n");
     755           0 :             goto error;
     756             :         }
     757             : 
     758        2331 :         max_chan = s->max_matrix_channel;
     759        2331 :         if (!s->noise_type)
     760        1688 :             max_chan+=2;
     761             : 
     762       12941 :         for (ch = 0; ch <= max_chan; ch++) {
     763       10610 :             int coeff_val = 0;
     764       10610 :             if (get_bits1(gbp))
     765        5923 :                 coeff_val = get_sbits(gbp, frac_bits + 2);
     766             : 
     767       10610 :             s->matrix_coeff[mat][ch] = coeff_val * (1 << (14 - frac_bits));
     768             :         }
     769             : 
     770        2331 :         if (s->noise_type)
     771         643 :             s->matrix_noise_shift[mat] = get_bits(gbp, 4);
     772             :         else
     773        1688 :             s->matrix_noise_shift[mat] = 0;
     774             :     }
     775             : 
     776        1474 :     return 0;
     777           0 : error:
     778           0 :     s->num_primitive_matrices = 0;
     779           0 :     memset(s->matrix_out_ch, 0, sizeof(s->matrix_out_ch));
     780             : 
     781           0 :     return AVERROR_INVALIDDATA;
     782             : }
     783             : 
     784             : /** Read channel parameters. */
     785             : 
     786       11750 : static int read_channel_params(MLPDecodeContext *m, unsigned int substr,
     787             :                                GetBitContext *gbp, unsigned int ch)
     788             : {
     789       11750 :     SubStream *s = &m->substream[substr];
     790       11750 :     ChannelParams *cp = &s->channel_params[ch];
     791       11750 :     FilterParams *fir = &cp->filter_params[FIR];
     792       11750 :     FilterParams *iir = &cp->filter_params[IIR];
     793             :     int ret;
     794             : 
     795       11750 :     if (s->param_presence_flags & PARAM_FIR)
     796       11750 :         if (get_bits1(gbp))
     797        3944 :             if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)
     798           0 :                 return ret;
     799             : 
     800       11750 :     if (s->param_presence_flags & PARAM_IIR)
     801       11750 :         if (get_bits1(gbp))
     802         502 :             if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)
     803           0 :                 return ret;
     804             : 
     805       11750 :     if (fir->order + iir->order > 8) {
     806           0 :         av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");
     807           0 :         return AVERROR_INVALIDDATA;
     808             :     }
     809             : 
     810       12699 :     if (fir->order && iir->order &&
     811         949 :         fir->shift != iir->shift) {
     812           0 :         av_log(m->avctx, AV_LOG_ERROR,
     813             :                 "FIR and IIR filters must use the same precision.\n");
     814           0 :         return AVERROR_INVALIDDATA;
     815             :     }
     816             :     /* The FIR and IIR filters must have the same precision.
     817             :      * To simplify the filtering code, only the precision of the
     818             :      * FIR filter is considered. If only the IIR filter is employed,
     819             :      * the FIR filter precision is set to that of the IIR filter, so
     820             :      * that the filtering code can use it. */
     821       11750 :     if (!fir->order && iir->order)
     822           0 :         fir->shift = iir->shift;
     823             : 
     824       11750 :     if (s->param_presence_flags & PARAM_HUFFOFFSET)
     825       11750 :         if (get_bits1(gbp))
     826        2180 :             cp->huff_offset = get_sbits(gbp, 15);
     827             : 
     828       11750 :     cp->codebook  = get_bits(gbp, 2);
     829       11750 :     cp->huff_lsbs = get_bits(gbp, 5);
     830             : 
     831       11750 :     if (cp->huff_lsbs > 24) {
     832           0 :         av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");
     833           0 :         cp->huff_lsbs = 0;
     834           0 :         return AVERROR_INVALIDDATA;
     835             :     }
     836             : 
     837       11750 :     return 0;
     838             : }
     839             : 
     840             : /** Read decoding parameters that change more often than those in the restart
     841             :  *  header. */
     842             : 
     843       13437 : static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,
     844             :                                 unsigned int substr)
     845             : {
     846       13437 :     SubStream *s = &m->substream[substr];
     847             :     unsigned int ch;
     848       13437 :     int ret = 0;
     849       13437 :     unsigned recompute_sho = 0;
     850             : 
     851       13437 :     if (s->param_presence_flags & PARAM_PRESENCE)
     852       13437 :         if (get_bits1(gbp))
     853           0 :             s->param_presence_flags = get_bits(gbp, 8);
     854             : 
     855       13437 :     if (s->param_presence_flags & PARAM_BLOCKSIZE)
     856       13437 :         if (get_bits1(gbp)) {
     857        3514 :             s->blocksize = get_bits(gbp, 9);
     858        3514 :             if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {
     859           0 :                 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");
     860           0 :                 s->blocksize = 0;
     861           0 :                 return AVERROR_INVALIDDATA;
     862             :             }
     863             :         }
     864             : 
     865       13437 :     if (s->param_presence_flags & PARAM_MATRIX)
     866       13437 :         if (get_bits1(gbp))
     867        1474 :             if ((ret = read_matrix_params(m, substr, gbp)) < 0)
     868           0 :                 return ret;
     869             : 
     870       13437 :     if (s->param_presence_flags & PARAM_OUTSHIFT)
     871       13437 :         if (get_bits1(gbp)) {
     872        4344 :             for (ch = 0; ch <= s->max_matrix_channel; ch++) {
     873        3180 :                 s->output_shift[ch] = get_sbits(gbp, 4);
     874        3180 :                 if (s->output_shift[ch] < 0) {
     875           0 :                     avpriv_request_sample(m->avctx, "Negative output_shift");
     876           0 :                     s->output_shift[ch] = 0;
     877             :                 }
     878             :             }
     879        1164 :             if (substr == m->max_decoded_substream)
     880        4608 :                 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,
     881        1152 :                                                                        s->output_shift,
     882        1152 :                                                                        s->max_matrix_channel,
     883        1152 :                                                                        m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
     884             :         }
     885             : 
     886       13437 :     if (s->param_presence_flags & PARAM_QUANTSTEP)
     887       13437 :         if (get_bits1(gbp))
     888        6127 :             for (ch = 0; ch <= s->max_channel; ch++) {
     889        4370 :                 s->quant_step_size[ch] = get_bits(gbp, 4);
     890             : 
     891        4370 :                 recompute_sho |= 1<<ch;
     892             :             }
     893             : 
     894       43337 :     for (ch = s->min_channel; ch <= s->max_channel; ch++)
     895       29900 :         if (get_bits1(gbp)) {
     896       11750 :             recompute_sho |= 1<<ch;
     897       11750 :             if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)
     898           0 :                 goto fail;
     899             :         }
     900             : 
     901             : 
     902       13437 : fail:
     903       46363 :     for (ch = 0; ch <= s->max_channel; ch++) {
     904       32926 :         if (recompute_sho & (1<<ch)) {
     905       12178 :             ChannelParams *cp = &s->channel_params[ch];
     906             : 
     907       12178 :             if (cp->codebook > 0 && cp->huff_lsbs < s->quant_step_size[ch]) {
     908           0 :                 if (ret >= 0) {
     909           0 :                     av_log(m->avctx, AV_LOG_ERROR, "quant_step_size larger than huff_lsbs\n");
     910           0 :                     ret = AVERROR_INVALIDDATA;
     911             :                 }
     912           0 :                 s->quant_step_size[ch] = 0;
     913             :             }
     914             : 
     915       12178 :             cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);
     916             :         }
     917             :     }
     918       13437 :     return ret;
     919             : }
     920             : 
     921             : #define MSB_MASK(bits)  (-1u << (bits))
     922             : 
     923             : /** Generate PCM samples using the prediction filters and residual values
     924             :  *  read from the data stream, and update the filter state. */
     925             : 
     926       49156 : static void filter_channel(MLPDecodeContext *m, unsigned int substr,
     927             :                            unsigned int channel)
     928             : {
     929       49156 :     SubStream *s = &m->substream[substr];
     930       49156 :     const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];
     931             :     int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];
     932       49156 :     int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;
     933       49156 :     int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;
     934       49156 :     FilterParams *fir = &s->channel_params[channel].filter_params[FIR];
     935       49156 :     FilterParams *iir = &s->channel_params[channel].filter_params[IIR];
     936       49156 :     unsigned int filter_shift = fir->shift;
     937       49156 :     int32_t mask = MSB_MASK(s->quant_step_size[channel]);
     938             : 
     939       49156 :     memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));
     940       49156 :     memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));
     941             : 
     942      245780 :     m->dsp.mlp_filter_channel(firbuf, fircoeff,
     943       98312 :                               fir->order, iir->order,
     944       49156 :                               filter_shift, mask, s->blocksize,
     945       49156 :                               &m->sample_buffer[s->blockpos][channel]);
     946             : 
     947       49156 :     memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));
     948       49156 :     memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));
     949       49156 : }
     950             : 
     951             : /** Read a block of PCM residual data (or actual if no filtering active). */
     952             : 
     953       20954 : static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,
     954             :                            unsigned int substr)
     955             : {
     956       20954 :     SubStream *s = &m->substream[substr];
     957       20954 :     unsigned int i, ch, expected_stream_pos = 0;
     958             :     int ret;
     959             : 
     960       20954 :     if (s->data_check_present) {
     961           0 :         expected_stream_pos  = get_bits_count(gbp);
     962           0 :         expected_stream_pos += get_bits(gbp, 16);
     963           0 :         avpriv_request_sample(m->avctx,
     964             :                               "Substreams with VLC block size check info");
     965             :     }
     966             : 
     967       20954 :     if (s->blockpos + s->blocksize > m->access_unit_size) {
     968           0 :         av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");
     969           0 :         return AVERROR_INVALIDDATA;
     970             :     }
     971             : 
     972       20954 :     memset(&m->bypassed_lsbs[s->blockpos][0], 0,
     973       20954 :            s->blocksize * sizeof(m->bypassed_lsbs[0]));
     974             : 
     975      788834 :     for (i = 0; i < s->blocksize; i++)
     976      767880 :         if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)
     977           0 :             return ret;
     978             : 
     979       70110 :     for (ch = s->min_channel; ch <= s->max_channel; ch++)
     980       49156 :         filter_channel(m, substr, ch);
     981             : 
     982       20954 :     s->blockpos += s->blocksize;
     983             : 
     984       20954 :     if (s->data_check_present) {
     985           0 :         if (get_bits_count(gbp) != expected_stream_pos)
     986           0 :             av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");
     987           0 :         skip_bits(gbp, 8);
     988             :     }
     989             : 
     990       20954 :     return 0;
     991             : }
     992             : 
     993             : /** Data table used for TrueHD noise generation function. */
     994             : 
     995             : static const int8_t noise_table[256] = {
     996             :      30,  51,  22,  54,   3,   7,  -4,  38,  14,  55,  46,  81,  22,  58,  -3,   2,
     997             :      52,  31,  -7,  51,  15,  44,  74,  30,  85, -17,  10,  33,  18,  80,  28,  62,
     998             :      10,  32,  23,  69,  72,  26,  35,  17,  73,  60,   8,  56,   2,   6,  -2,  -5,
     999             :      51,   4,  11,  50,  66,  76,  21,  44,  33,  47,   1,  26,  64,  48,  57,  40,
    1000             :      38,  16, -10, -28,  92,  22, -18,  29, -10,   5, -13,  49,  19,  24,  70,  34,
    1001             :      61,  48,  30,  14,  -6,  25,  58,  33,  42,  60,  67,  17,  54,  17,  22,  30,
    1002             :      67,  44,  -9,  50, -11,  43,  40,  32,  59,  82,  13,  49, -14,  55,  60,  36,
    1003             :      48,  49,  31,  47,  15,  12,   4,  65,   1,  23,  29,  39,  45,  -2,  84,  69,
    1004             :       0,  72,  37,  57,  27,  41, -15, -16,  35,  31,  14,  61,  24,   0,  27,  24,
    1005             :      16,  41,  55,  34,  53,   9,  56,  12,  25,  29,  53,   5,  20, -20,  -8,  20,
    1006             :      13,  28,  -3,  78,  38,  16,  11,  62,  46,  29,  21,  24,  46,  65,  43, -23,
    1007             :      89,  18,  74,  21,  38, -12,  19,  12, -19,   8,  15,  33,   4,  57,   9,  -8,
    1008             :      36,  35,  26,  28,   7,  83,  63,  79,  75,  11,   3,  87,  37,  47,  34,  40,
    1009             :      39,  19,  20,  42,  27,  34,  39,  77,  13,  42,  59,  64,  45,  -1,  32,  37,
    1010             :      45,  -5,  53,  -6,   7,  36,  50,  23,   6,  32,   9, -21,  18,  71,  27,  52,
    1011             :     -25,  31,  35,  42,  -1,  68,  63,  52,  26,  43,  66,  37,  41,  25,  40,  70,
    1012             : };
    1013             : 
    1014             : /** Noise generation functions.
    1015             :  *  I'm not sure what these are for - they seem to be some kind of pseudorandom
    1016             :  *  sequence generators, used to generate noise data which is used when the
    1017             :  *  channels are rematrixed. I'm not sure if they provide a practical benefit
    1018             :  *  to compression, or just obfuscate the decoder. Are they for some kind of
    1019             :  *  dithering? */
    1020             : 
    1021             : /** Generate two channels of noise, used in the matrix when
    1022             :  *  restart sync word == 0x31ea. */
    1023             : 
    1024       12377 : static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)
    1025             : {
    1026       12377 :     SubStream *s = &m->substream[substr];
    1027             :     unsigned int i;
    1028       12377 :     uint32_t seed = s->noisegen_seed;
    1029       12377 :     unsigned int maxchan = s->max_matrix_channel;
    1030             : 
    1031      507457 :     for (i = 0; i < s->blockpos; i++) {
    1032      495080 :         uint16_t seed_shr7 = seed >> 7;
    1033      495080 :         m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) * (1 << s->noise_shift);
    1034      495080 :         m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7)   * (1 << s->noise_shift);
    1035             : 
    1036      495080 :         seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);
    1037             :     }
    1038             : 
    1039       12377 :     s->noisegen_seed = seed;
    1040       12377 : }
    1041             : 
    1042             : /** Generate a block of noise, used when restart sync word == 0x31eb. */
    1043             : 
    1044        3410 : static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)
    1045             : {
    1046        3410 :     SubStream *s = &m->substream[substr];
    1047             :     unsigned int i;
    1048        3410 :     uint32_t seed = s->noisegen_seed;
    1049             : 
    1050      221650 :     for (i = 0; i < m->access_unit_size_pow2; i++) {
    1051      218240 :         uint8_t seed_shr15 = seed >> 15;
    1052      218240 :         m->noise_buffer[i] = noise_table[seed_shr15];
    1053      218240 :         seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);
    1054             :     }
    1055             : 
    1056        3410 :     s->noisegen_seed = seed;
    1057        3410 : }
    1058             : 
    1059             : /** Write the audio data into the output buffer. */
    1060             : 
    1061       15787 : static int output_data(MLPDecodeContext *m, unsigned int substr,
    1062             :                        AVFrame *frame, int *got_frame_ptr)
    1063             : {
    1064       15787 :     AVCodecContext *avctx = m->avctx;
    1065       15787 :     SubStream *s = &m->substream[substr];
    1066             :     unsigned int mat;
    1067             :     unsigned int maxchan;
    1068             :     int ret;
    1069       15787 :     int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);
    1070             : 
    1071       15787 :     if (m->avctx->channels != s->max_matrix_channel + 1) {
    1072           0 :         av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");
    1073           0 :         return AVERROR_INVALIDDATA;
    1074             :     }
    1075             : 
    1076       15787 :     if (!s->blockpos) {
    1077           0 :         av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");
    1078           0 :         return AVERROR_INVALIDDATA;
    1079             :     }
    1080             : 
    1081       15787 :     maxchan = s->max_matrix_channel;
    1082       15787 :     if (!s->noise_type) {
    1083       12377 :         generate_2_noise_channels(m, substr);
    1084       12377 :         maxchan += 2;
    1085             :     } else {
    1086        3410 :         fill_noise_buffer(m, substr);
    1087             :     }
    1088             : 
    1089             :     /* Apply the channel matrices in turn to reconstruct the original audio
    1090             :      * samples. */
    1091       39544 :     for (mat = 0; mat < s->num_primitive_matrices; mat++) {
    1092       23757 :         unsigned int dest_ch = s->matrix_out_ch[mat];
    1093      142542 :         m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],
    1094       23757 :                                     s->matrix_coeff[mat],
    1095       23757 :                                     &m->bypassed_lsbs[0][mat],
    1096       23757 :                                     m->noise_buffer,
    1097       23757 :                                     s->num_primitive_matrices - mat,
    1098             :                                     dest_ch,
    1099       23757 :                                     s->blockpos,
    1100             :                                     maxchan,
    1101       23757 :                                     s->matrix_noise_shift[mat],
    1102             :                                     m->access_unit_size_pow2,
    1103       23757 :                                     MSB_MASK(s->quant_step_size[dest_ch]));
    1104             :     }
    1105             : 
    1106             :     /* get output buffer */
    1107       15787 :     frame->nb_samples = s->blockpos;
    1108       15787 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
    1109           0 :         return ret;
    1110       47361 :     s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,
    1111       15787 :                                                     s->blockpos,
    1112       15787 :                                                     m->sample_buffer,
    1113       15787 :                                                     frame->data[0],
    1114       15787 :                                                     s->ch_assign,
    1115       15787 :                                                     s->output_shift,
    1116       15787 :                                                     s->max_matrix_channel,
    1117             :                                                     is32);
    1118             : 
    1119             :     /* Update matrix encoding side data */
    1120       15787 :     if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)
    1121           0 :         return ret;
    1122             : 
    1123       15787 :     *got_frame_ptr = 1;
    1124             : 
    1125       15787 :     return 0;
    1126             : }
    1127             : 
    1128             : /** Read an access unit from the stream.
    1129             :  *  @return negative on error, 0 if not enough data is present in the input stream,
    1130             :  *  otherwise the number of bytes consumed. */
    1131             : 
    1132       15787 : static int read_access_unit(AVCodecContext *avctx, void* data,
    1133             :                             int *got_frame_ptr, AVPacket *avpkt)
    1134             : {
    1135       15787 :     const uint8_t *buf = avpkt->data;
    1136       15787 :     int buf_size = avpkt->size;
    1137       15787 :     MLPDecodeContext *m = avctx->priv_data;
    1138             :     GetBitContext gb;
    1139             :     unsigned int length, substr;
    1140             :     unsigned int substream_start;
    1141       15787 :     unsigned int header_size = 4;
    1142       15787 :     unsigned int substr_header_size = 0;
    1143             :     uint8_t substream_parity_present[MAX_SUBSTREAMS];
    1144             :     uint16_t substream_data_len[MAX_SUBSTREAMS];
    1145             :     uint8_t parity_bits;
    1146             :     int ret;
    1147             : 
    1148       15787 :     if (buf_size < 4)
    1149           0 :         return AVERROR_INVALIDDATA;
    1150             : 
    1151       15787 :     length = (AV_RB16(buf) & 0xfff) * 2;
    1152             : 
    1153       15787 :     if (length < 4 || length > buf_size)
    1154           0 :         return AVERROR_INVALIDDATA;
    1155             : 
    1156       15787 :     init_get_bits(&gb, (buf + 4), (length - 4) * 8);
    1157             : 
    1158       15787 :     m->is_major_sync_unit = 0;
    1159       15787 :     if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {
    1160        1543 :         if (read_major_sync(m, &gb) < 0)
    1161           0 :             goto error;
    1162        1543 :         m->is_major_sync_unit = 1;
    1163        1543 :         header_size += m->major_sync_header_size;
    1164             :     }
    1165             : 
    1166       15787 :     if (!m->params_valid) {
    1167           0 :         av_log(m->avctx, AV_LOG_WARNING,
    1168             :                "Stream parameters not seen; skipping frame.\n");
    1169           0 :         *got_frame_ptr = 0;
    1170           0 :         return length;
    1171             :     }
    1172             : 
    1173       15787 :     substream_start = 0;
    1174             : 
    1175       38394 :     for (substr = 0; substr < m->num_substreams; substr++) {
    1176             :         int extraword_present, checkdata_present, end, nonrestart_substr;
    1177             : 
    1178       22607 :         extraword_present = get_bits1(&gb);
    1179       22607 :         nonrestart_substr = get_bits1(&gb);
    1180       22607 :         checkdata_present = get_bits1(&gb);
    1181       22607 :         skip_bits1(&gb);
    1182             : 
    1183       22607 :         end = get_bits(&gb, 12) * 2;
    1184             : 
    1185       22607 :         substr_header_size += 2;
    1186             : 
    1187       22607 :         if (extraword_present) {
    1188         104 :             if (m->avctx->codec_id == AV_CODEC_ID_MLP) {
    1189           0 :                 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");
    1190           0 :                 goto error;
    1191             :             }
    1192         104 :             skip_bits(&gb, 16);
    1193         104 :             substr_header_size += 2;
    1194             :         }
    1195             : 
    1196       22607 :         if (length < header_size + substr_header_size) {
    1197           0 :             av_log(m->avctx, AV_LOG_ERROR, "Insuffient data for headers\n");
    1198           0 :             goto error;
    1199             :         }
    1200             : 
    1201       22607 :         if (!(nonrestart_substr ^ m->is_major_sync_unit)) {
    1202           0 :             av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");
    1203           0 :             goto error;
    1204             :         }
    1205             : 
    1206       22607 :         if (end + header_size + substr_header_size > length) {
    1207           0 :             av_log(m->avctx, AV_LOG_ERROR,
    1208             :                    "Indicated length of substream %d data goes off end of "
    1209             :                    "packet.\n", substr);
    1210           0 :             end = length - header_size - substr_header_size;
    1211             :         }
    1212             : 
    1213       22607 :         if (end < substream_start) {
    1214           0 :             av_log(avctx, AV_LOG_ERROR,
    1215             :                    "Indicated end offset of substream %d data "
    1216             :                    "is smaller than calculated start offset.\n",
    1217             :                    substr);
    1218           0 :             goto error;
    1219             :         }
    1220             : 
    1221       22607 :         if (substr > m->max_decoded_substream)
    1222        3196 :             continue;
    1223             : 
    1224       19411 :         substream_parity_present[substr] = checkdata_present;
    1225       19411 :         substream_data_len[substr] = end - substream_start;
    1226       19411 :         substream_start = end;
    1227             :     }
    1228             : 
    1229       15787 :     parity_bits  = ff_mlp_calculate_parity(buf, 4);
    1230       15787 :     parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);
    1231             : 
    1232       15787 :     if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {
    1233           0 :         av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");
    1234           0 :         goto error;
    1235             :     }
    1236             : 
    1237       15787 :     buf += header_size + substr_header_size;
    1238             : 
    1239       34984 :     for (substr = 0; substr <= m->max_decoded_substream; substr++) {
    1240       19197 :         SubStream *s = &m->substream[substr];
    1241       19197 :         init_get_bits(&gb, buf, substream_data_len[substr] * 8);
    1242             : 
    1243       19197 :         m->matrix_changed = 0;
    1244       19197 :         memset(m->filter_changed, 0, sizeof(m->filter_changed));
    1245             : 
    1246       19197 :         s->blockpos = 0;
    1247             :         do {
    1248       20954 :             if (get_bits1(&gb)) {
    1249       13437 :                 if (get_bits1(&gb)) {
    1250             :                     /* A restart header should be present. */
    1251        1757 :                     if (read_restart_header(m, &gb, buf, substr) < 0)
    1252           0 :                         goto next_substr;
    1253        1757 :                     s->restart_seen = 1;
    1254             :                 }
    1255             : 
    1256       13437 :                 if (!s->restart_seen)
    1257           0 :                     goto next_substr;
    1258       13437 :                 if (read_decoding_params(m, &gb, substr) < 0)
    1259           0 :                     goto next_substr;
    1260             :             }
    1261             : 
    1262       20954 :             if (!s->restart_seen)
    1263           0 :                 goto next_substr;
    1264             : 
    1265       20954 :             if ((ret = read_block_data(m, &gb, substr)) < 0)
    1266           0 :                 return ret;
    1267             : 
    1268       20954 :             if (get_bits_count(&gb) >= substream_data_len[substr] * 8)
    1269           0 :                 goto substream_length_mismatch;
    1270             : 
    1271       20954 :         } while (!get_bits1(&gb));
    1272             : 
    1273       19197 :         skip_bits(&gb, (-get_bits_count(&gb)) & 15);
    1274             : 
    1275       19197 :         if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {
    1276             :             int shorten_by;
    1277             : 
    1278           0 :             if (get_bits(&gb, 16) != 0xD234)
    1279           0 :                 return AVERROR_INVALIDDATA;
    1280             : 
    1281           0 :             shorten_by = get_bits(&gb, 16);
    1282           0 :             if      (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by  & 0x2000)
    1283           0 :                 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);
    1284           0 :             else if (m->avctx->codec_id == AV_CODEC_ID_MLP    && shorten_by != 0xD234)
    1285           0 :                 return AVERROR_INVALIDDATA;
    1286             : 
    1287           0 :             if (substr == m->max_decoded_substream)
    1288           0 :                 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");
    1289             :         }
    1290             : 
    1291       19197 :         if (substream_parity_present[substr]) {
    1292             :             uint8_t parity, checksum;
    1293             : 
    1294       19197 :             if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)
    1295           0 :                 goto substream_length_mismatch;
    1296             : 
    1297       19197 :             parity   = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);
    1298       19197 :             checksum = ff_mlp_checksum8       (buf, substream_data_len[substr] - 2);
    1299             : 
    1300       19197 :             if ((get_bits(&gb, 8) ^ parity) != 0xa9    )
    1301           0 :                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);
    1302       19197 :             if ( get_bits(&gb, 8)           != checksum)
    1303           0 :                 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n"    , substr);
    1304             :         }
    1305             : 
    1306       19197 :         if (substream_data_len[substr] * 8 != get_bits_count(&gb))
    1307           0 :             goto substream_length_mismatch;
    1308             : 
    1309       19197 : next_substr:
    1310       19197 :         if (!s->restart_seen)
    1311           0 :             av_log(m->avctx, AV_LOG_ERROR,
    1312             :                    "No restart header present in substream %d.\n", substr);
    1313             : 
    1314       19197 :         buf += substream_data_len[substr];
    1315             :     }
    1316             : 
    1317       15787 :     if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)
    1318           0 :         return ret;
    1319             : 
    1320       15787 :     return length;
    1321             : 
    1322           0 : substream_length_mismatch:
    1323           0 :     av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);
    1324           0 :     return AVERROR_INVALIDDATA;
    1325             : 
    1326           0 : error:
    1327           0 :     m->params_valid = 0;
    1328           0 :     return AVERROR_INVALIDDATA;
    1329             : }
    1330             : 
    1331             : #if CONFIG_MLP_DECODER
    1332             : AVCodec ff_mlp_decoder = {
    1333             :     .name           = "mlp",
    1334             :     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
    1335             :     .type           = AVMEDIA_TYPE_AUDIO,
    1336             :     .id             = AV_CODEC_ID_MLP,
    1337             :     .priv_data_size = sizeof(MLPDecodeContext),
    1338             :     .init           = mlp_decode_init,
    1339             :     .decode         = read_access_unit,
    1340             :     .capabilities   = AV_CODEC_CAP_DR1,
    1341             : };
    1342             : #endif
    1343             : #if CONFIG_TRUEHD_DECODER
    1344             : AVCodec ff_truehd_decoder = {
    1345             :     .name           = "truehd",
    1346             :     .long_name      = NULL_IF_CONFIG_SMALL("TrueHD"),
    1347             :     .type           = AVMEDIA_TYPE_AUDIO,
    1348             :     .id             = AV_CODEC_ID_TRUEHD,
    1349             :     .priv_data_size = sizeof(MLPDecodeContext),
    1350             :     .init           = mlp_decode_init,
    1351             :     .decode         = read_access_unit,
    1352             :     .capabilities   = AV_CODEC_CAP_DR1,
    1353             : };
    1354             : #endif /* CONFIG_TRUEHD_DECODER */

Generated by: LCOV version 1.13