static int read_matrix_params(MLPDecodeContext *m, SubStream *s, GetBitContext *gbp)

{

    unsigned int mat, ch;



    s->num_primitive_matrices = get_bits(gbp, 4);

    m->matrix_changed++;



    for (mat = 0; mat < s->num_primitive_matrices; mat++) {

        int frac_bits, max_chan;

        s->matrix_out_ch[mat] = get_bits(gbp, 4);

        frac_bits             = get_bits(gbp, 4);

        s->lsb_bypass   [mat] = get_bits1(gbp);



        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {

            av_log(m->avctx, AV_LOG_ERROR,

                    "Invalid channel %d specified as output from matrix.\n",

                    s->matrix_out_ch[mat]);

            return -1;

        }

        if (frac_bits > 14) {

            av_log(m->avctx, AV_LOG_ERROR,

                    "Too many fractional bits specified.\n");

            return -1;

        }



        max_chan = s->max_matrix_channel;

        if (!s->noise_type)

            max_chan+=2;



        for (ch = 0; ch <= max_chan; ch++) {

            int coeff_val = 0;

            if (get_bits1(gbp))

                coeff_val = get_sbits(gbp, frac_bits + 2);



            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);

        }



        if (s->noise_type)

            s->matrix_noise_shift[mat] = get_bits(gbp, 4);

        else

            s->matrix_noise_shift[mat] = 0;

    }



    return 0;

}

static int read_matrix_params(MLPDecodeContext *m, SubStream *s, GetBitContext *gbp)

{

    unsigned int mat, ch;



    s->num_primitive_matrices = get_bits(gbp, 4);

    m->matrix_changed++;



    for (mat = 0; mat < s->num_primitive_matrices; mat++) {

        int frac_bits, max_chan;

        s->matrix_out_ch[mat] = get_bits(gbp, 4);

        frac_bits             = get_bits(gbp, 4);

        s->lsb_bypass   [mat] = get_bits1(gbp);



        if (s->matrix_out_ch[mat] > s->max_matrix_channel) {

            av_log(m->avctx, AV_LOG_ERROR,

                    "Invalid channel %d specified as output from matrix.\n",

                    s->matrix_out_ch[mat]);

            return -1;

        }

        if (frac_bits > 14) {

            av_log(m->avctx, AV_LOG_ERROR,

                    "Too many fractional bits specified.\n");

            return -1;

        }



        max_chan = s->max_matrix_channel;

        if (!s->noise_type)

            max_chan+=2;



        for (ch = 0; ch <= max_chan; ch++) {

            int coeff_val = 0;

            if (get_bits1(gbp))

                coeff_val = get_sbits(gbp, frac_bits + 2);



            s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);

        }



        if (s->noise_type)

            s->matrix_noise_shift[mat] = get_bits(gbp, 4);

        else

            s->matrix_noise_shift[mat] = 0;

    }



    return 0;

}

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

{

    unsigned int VAR_3, VAR_4;



    VAR_1->num_primitive_matrices = get_bits(VAR_2, 4);

    VAR_0->matrix_changed++;



    for (VAR_3 = 0; VAR_3 < VAR_1->num_primitive_matrices; VAR_3++) {

        int frac_bits, max_chan;

        VAR_1->matrix_out_ch[VAR_3] = get_bits(VAR_2, 4);

        frac_bits             = get_bits(VAR_2, 4);

        VAR_1->lsb_bypass   [VAR_3] = get_bits1(VAR_2);



        if (VAR_1->matrix_out_ch[VAR_3] > VAR_1->max_matrix_channel) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                    "Invalid channel %d specified as output from matrix.\n",

                    VAR_1->matrix_out_ch[VAR_3]);

            return -1;

        }

        if (frac_bits > 14) {

            av_log(VAR_0->avctx, AV_LOG_ERROR,

                    "Too many fractional bits specified.\n");

            return -1;

        }



        max_chan = VAR_1->max_matrix_channel;

        if (!VAR_1->noise_type)

            max_chan+=2;



        for (VAR_4 = 0; VAR_4 <= max_chan; VAR_4++) {

            int coeff_val = 0;

            if (get_bits1(VAR_2))

                coeff_val = get_sbits(VAR_2, frac_bits + 2);



            VAR_1->matrix_coeff[VAR_3][VAR_4] = coeff_val << (14 - frac_bits);

        }



        if (VAR_1->noise_type)

            VAR_1->matrix_noise_shift[VAR_3] = get_bits(VAR_2, 4);

        else

            VAR_1->matrix_noise_shift[VAR_3] = 0;

    }



    return 0;

}

static int FUNC_0(MLPDecodeContext *VAR_0, SubStream *VAR_1, GetBitContext *VAR_2)
{ unsigned int VAR_3, VAR_4; VAR_1->num_primitive_matrices = get_bits(VAR_2, 4); VAR_0->matrix_changed++; for (VAR_3 = 0; VAR_3 < VAR_1->num_primitive_matrices; VAR_3++) { int frac_bits, max_chan; VAR_1->matrix_out_ch[VAR_3] = get_bits(VAR_2, 4); frac_bits             = get_bits(VAR_2, 4); VAR_1->lsb_bypass   [VAR_3] = get_bits1(VAR_2); if (VAR_1->matrix_out_ch[VAR_3] > VAR_1->max_matrix_channel) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Invalid channel %d specified as output from matrix.\n",
VAR_1->matrix_out_ch[VAR_3]); return -1; } if (frac_bits > 14) { av_log(VAR_0->avctx, AV_LOG_ERROR,
"Too many fractional bits specified.\n"); return -1; } max_chan = VAR_1->max_matrix_channel; if (!VAR_1->noise_type)
max_chan+=2; for (VAR_4 = 0; VAR_4 <= max_chan; VAR_4++) { int coeff_val = 0; if (get_bits1(VAR_2))
coeff_val = get_sbits(VAR_2, frac_bits + 2); VAR_1->matrix_coeff[VAR_3][VAR_4] = coeff_val << (14 - frac_bits); } if (VAR_1->noise_type)
VAR_1->matrix_noise_shift[VAR_3] = get_bits(VAR_2, 4); else
VAR_1->matrix_noise_shift[VAR_3] = 0; } return 0; }