static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)

{

    MLPHeaderInfo mh;

    int substr, ret;



    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)

        return ret;



    if (mh.group1_bits == 0) {

        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

        return AVERROR_INVALIDDATA;


    if (mh.group2_bits > mh.group1_bits) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Channel group 2 cannot have more bits per sample than group 1.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Channel groups with differing sample rates are not currently supported.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group1_samplerate == 0) {

        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

        return AVERROR_INVALIDDATA;


    if (mh.group1_samplerate > MAX_SAMPLERATE) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Sampling rate %d is greater than the supported maximum (%d).\n",

               mh.group1_samplerate, MAX_SAMPLERATE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size > MAX_BLOCKSIZE) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Block size %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size, MAX_BLOCKSIZE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Block size pow2 %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);

        return AVERROR_INVALIDDATA;




    if (mh.num_substreams == 0)

        return AVERROR_INVALIDDATA;

    if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {

        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

        return AVERROR_INVALIDDATA;


    if (mh.num_substreams > MAX_SUBSTREAMS) {


                              "%d substreams (more than the "

                              "maximum supported by the decoder)",

                              mh.num_substreams);





    m->access_unit_size      = mh.access_unit_size;

    m->access_unit_size_pow2 = mh.access_unit_size_pow2;



    m->num_substreams        = mh.num_substreams;

    m->max_decoded_substream = m->num_substreams - 1;



    m->avctx->sample_rate    = mh.group1_samplerate;

    m->avctx->frame_size     = mh.access_unit_size;



    m->avctx->bits_per_raw_sample = mh.group1_bits;

    if (mh.group1_bits > 16)

        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

    else

        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;



    m->params_valid = 1;

    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)

        m->substream[substr].restart_seen = 0;



    /* Set the layout for each substream. When there's more than one, the first

     * substream is Stereo. Subsequent substreams' layouts are indicated in the

     * major sync. */

    if (m->avctx->codec_id == AV_CODEC_ID_MLP) {







        if ((substr = (mh.num_substreams > 1)))

            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        m->substream[substr].ch_layout = mh.channel_layout_mlp;

    } else {







        if ((substr = (mh.num_substreams > 1)))

            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        if (mh.num_substreams > 2)

            if (mh.channel_layout_thd_stream2)

                m->substream[2].ch_layout = mh.channel_layout_thd_stream2;

            else

                m->substream[2].ch_layout = mh.channel_layout_thd_stream1;

        m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;



        if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {

            av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");

            m->max_decoded_substream = 0;

            if (m->avctx->channels==2)

                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;





    m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;



    return 0;

static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)

{

    MLPHeaderInfo mh;

    int substr, ret;



    if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)

        return ret;



    if (mh.group1_bits == 0) {

        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

        return AVERROR_INVALIDDATA;


    if (mh.group2_bits > mh.group1_bits) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Channel group 2 cannot have more bits per sample than group 1.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Channel groups with differing sample rates are not currently supported.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group1_samplerate == 0) {

        av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

        return AVERROR_INVALIDDATA;


    if (mh.group1_samplerate > MAX_SAMPLERATE) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Sampling rate %d is greater than the supported maximum (%d).\n",

               mh.group1_samplerate, MAX_SAMPLERATE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size > MAX_BLOCKSIZE) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Block size %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size, MAX_BLOCKSIZE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

        av_log(m->avctx, AV_LOG_ERROR,

               "Block size pow2 %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);

        return AVERROR_INVALIDDATA;




    if (mh.num_substreams == 0)

        return AVERROR_INVALIDDATA;

    if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {

        av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

        return AVERROR_INVALIDDATA;


    if (mh.num_substreams > MAX_SUBSTREAMS) {


                              "%d substreams (more than the "

                              "maximum supported by the decoder)",

                              mh.num_substreams);





    m->access_unit_size      = mh.access_unit_size;

    m->access_unit_size_pow2 = mh.access_unit_size_pow2;



    m->num_substreams        = mh.num_substreams;

    m->max_decoded_substream = m->num_substreams - 1;



    m->avctx->sample_rate    = mh.group1_samplerate;

    m->avctx->frame_size     = mh.access_unit_size;



    m->avctx->bits_per_raw_sample = mh.group1_bits;

    if (mh.group1_bits > 16)

        m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

    else

        m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;



    m->params_valid = 1;

    for (substr = 0; substr < MAX_SUBSTREAMS; substr++)

        m->substream[substr].restart_seen = 0;



    





    if (m->avctx->codec_id == AV_CODEC_ID_MLP) {







        if ((substr = (mh.num_substreams > 1)))

            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        m->substream[substr].ch_layout = mh.channel_layout_mlp;

    } else {







        if ((substr = (mh.num_substreams > 1)))

            m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        if (mh.num_substreams > 2)

            if (mh.channel_layout_thd_stream2)

                m->substream[2].ch_layout = mh.channel_layout_thd_stream2;

            else

                m->substream[2].ch_layout = mh.channel_layout_thd_stream1;

        m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;



        if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {

            av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");

            m->max_decoded_substream = 0;

            if (m->avctx->channels==2)

                m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;





    m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;



    return 0;

static int FUNC_0(MLPDecodeContext *VAR_0, GetBitContext *VAR_1)

{

    MLPHeaderInfo mh;

    int VAR_2, VAR_3;



    if ((VAR_3 = ff_mlp_read_major_sync(VAR_0->avctx, &mh, VAR_1)) != 0)

        return VAR_3;



    if (mh.group1_bits == 0) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

        return AVERROR_INVALIDDATA;


    if (mh.group2_bits > mh.group1_bits) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Channel group 2 cannot have more bits per sample than group 1.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Channel groups with differing sample rates are not currently supported.\n");

        return AVERROR_INVALIDDATA;




    if (mh.group1_samplerate == 0) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

        return AVERROR_INVALIDDATA;


    if (mh.group1_samplerate > MAX_SAMPLERATE) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Sampling rate %d is greater than the supported maximum (%d).\n",

               mh.group1_samplerate, MAX_SAMPLERATE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size > MAX_BLOCKSIZE) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Block size %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size, MAX_BLOCKSIZE);

        return AVERROR_INVALIDDATA;


    if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

        av_log(VAR_0->avctx, AV_LOG_ERROR,

               "Block size pow2 %d is greater than the supported maximum (%d).\n",

               mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);

        return AVERROR_INVALIDDATA;




    if (mh.num_substreams == 0)

        return AVERROR_INVALIDDATA;

    if (VAR_0->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {

        av_log(VAR_0->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

        return AVERROR_INVALIDDATA;


    if (mh.num_substreams > MAX_SUBSTREAMS) {


                              "%d substreams (more than the "

                              "maximum supported by the decoder)",

                              mh.num_substreams);





    VAR_0->access_unit_size      = mh.access_unit_size;

    VAR_0->access_unit_size_pow2 = mh.access_unit_size_pow2;



    VAR_0->num_substreams        = mh.num_substreams;

    VAR_0->max_decoded_substream = VAR_0->num_substreams - 1;



    VAR_0->avctx->sample_rate    = mh.group1_samplerate;

    VAR_0->avctx->frame_size     = mh.access_unit_size;



    VAR_0->avctx->bits_per_raw_sample = mh.group1_bits;

    if (mh.group1_bits > 16)

        VAR_0->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

    else

        VAR_0->avctx->sample_fmt = AV_SAMPLE_FMT_S16;



    VAR_0->params_valid = 1;

    for (VAR_2 = 0; VAR_2 < MAX_SUBSTREAMS; VAR_2++)

        VAR_0->substream[VAR_2].restart_seen = 0;



    





    if (VAR_0->avctx->codec_id == AV_CODEC_ID_MLP) {







        if ((VAR_2 = (mh.num_substreams > 1)))

            VAR_0->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        VAR_0->substream[VAR_2].ch_layout = mh.channel_layout_mlp;

    } else {







        if ((VAR_2 = (mh.num_substreams > 1)))

            VAR_0->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

        if (mh.num_substreams > 2)

            if (mh.channel_layout_thd_stream2)

                VAR_0->substream[2].ch_layout = mh.channel_layout_thd_stream2;

            else

                VAR_0->substream[2].ch_layout = mh.channel_layout_thd_stream1;

        VAR_0->substream[VAR_2].ch_layout = mh.channel_layout_thd_stream1;



        if (VAR_0->avctx->channels<=2 && VAR_0->substream[VAR_2].ch_layout == AV_CH_LAYOUT_MONO && VAR_0->max_decoded_substream == 1) {

            av_log(VAR_0->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");

            VAR_0->max_decoded_substream = 0;

            if (VAR_0->avctx->channels==2)

                VAR_0->avctx->channel_layout = AV_CH_LAYOUT_STEREO;





    VAR_0->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;



    return 0;

static int FUNC_0(MLPDecodeContext *VAR_0, GetBitContext *VAR_1)
{ MLPHeaderInfo mh; int VAR_2, VAR_3; if ((VAR_3 = ff_mlp_read_major_sync(VAR_0->avctx, &mh, VAR_1)) != 0)
return VAR_3; if (mh.group1_bits == 0) { av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n"); return AVERROR_INVALIDDATA; if (mh.group2_bits > mh.group1_bits) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Channel group 2 cannot have more bits per sample than group 1.\n"); return AVERROR_INVALIDDATA; if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Channel groups with differing sample rates are not currently supported.\n"); return AVERROR_INVALIDDATA; if (mh.group1_samplerate == 0) { av_log(VAR_0->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n"); return AVERROR_INVALIDDATA; if (mh.group1_samplerate > MAX_SAMPLERATE) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Sampling rate %d is greater than the supported maximum (%d).\n",
mh.group1_samplerate, MAX_SAMPLERATE); return AVERROR_INVALIDDATA; if (mh.access_unit_size > MAX_BLOCKSIZE) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Block size %d is greater than the supported maximum (%d).\n",
mh.access_unit_size, MAX_BLOCKSIZE); return AVERROR_INVALIDDATA; if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Block size pow2 %d is greater than the supported maximum (%d).\n",
mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2); return AVERROR_INVALIDDATA; if (mh.num_substreams == 0)
return AVERROR_INVALIDDATA; if (VAR_0->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) { av_log(VAR_0->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n"); return AVERROR_INVALIDDATA; if (mh.num_substreams > MAX_SUBSTREAMS) { "%d substreams (more than the "
"maximum supported by the decoder)",
mh.num_substreams); VAR_0->access_unit_size      = mh.access_unit_size; VAR_0->access_unit_size_pow2 = mh.access_unit_size_pow2; VAR_0->num_substreams        = mh.num_substreams; VAR_0->max_decoded_substream = VAR_0->num_substreams - 1; VAR_0->avctx->sample_rate    = mh.group1_samplerate; VAR_0->avctx->frame_size     = mh.access_unit_size; VAR_0->avctx->bits_per_raw_sample = mh.group1_bits; if (mh.group1_bits > 16)
VAR_0->avctx->sample_fmt = AV_SAMPLE_FMT_S32; else
VAR_0->avctx->sample_fmt = AV_SAMPLE_FMT_S16; VAR_0->params_valid = 1; for (VAR_2 = 0; VAR_2 < MAX_SUBSTREAMS; VAR_2++) VAR_0->substream[VAR_2].restart_seen = 0; if (VAR_0->avctx->codec_id == AV_CODEC_ID_MLP) { if ((VAR_2 = (mh.num_substreams > 1)))
VAR_0->substream[0].ch_layout = AV_CH_LAYOUT_STEREO; VAR_0->substream[VAR_2].ch_layout = mh.channel_layout_mlp; } else { if ((VAR_2 = (mh.num_substreams > 1)))
VAR_0->substream[0].ch_layout = AV_CH_LAYOUT_STEREO; if (mh.num_substreams > 2)
if (mh.channel_layout_thd_stream2)
VAR_0->substream[2].ch_layout = mh.channel_layout_thd_stream2; else
VAR_0->substream[2].ch_layout = mh.channel_layout_thd_stream1; VAR_0->substream[VAR_2].ch_layout = mh.channel_layout_thd_stream1; if (VAR_0->avctx->channels<=2 && VAR_0->substream[VAR_2].ch_layout == AV_CH_LAYOUT_MONO && VAR_0->max_decoded_substream == 1) { av_log(VAR_0->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n"); VAR_0->max_decoded_substream = 0; if (VAR_0->avctx->channels==2)
VAR_0->avctx->channel_layout = AV_CH_LAYOUT_STEREO; VAR_0->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20; return 0;