Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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