static int alac_decode_frame(AVCodecContext *avctx,

                             void *outbuffer, int *outputsize,

                             AVPacket *avpkt)

{

    const uint8_t *inbuffer = avpkt->data;

    int input_buffer_size = avpkt->size;

    ALACContext *alac = avctx->priv_data;



    int channels;

    unsigned int outputsamples;

    int hassize;

    unsigned int readsamplesize;

    int isnotcompressed;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;

    int i, ch;



    /* short-circuit null buffers */

    if (!inbuffer || !input_buffer_size)

        return -1;



    init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);



    channels = get_bits(&alac->gb, 3) + 1;

    if (channels != avctx->channels) {

        av_log(avctx, AV_LOG_ERROR, "frame header channel count mismatch\n");

        return AVERROR_INVALIDDATA;

    }



    /* 2^result = something to do with output waiting.

     * perhaps matters if we read > 1 frame in a pass?

     */

    skip_bits(&alac->gb, 4);



    skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */



    /* the output sample size is stored soon */

    hassize = get_bits1(&alac->gb);



    alac->extra_bits = get_bits(&alac->gb, 2) << 3;



    /* whether the frame is compressed */

    isnotcompressed = get_bits1(&alac->gb);



    if (hassize) {

        /* now read the number of samples as a 32bit integer */

        outputsamples = get_bits_long(&alac->gb, 32);

        if(outputsamples > alac->setinfo_max_samples_per_frame){

            av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);

            return -1;

        }

    } else

        outputsamples = alac->setinfo_max_samples_per_frame;



    alac->bytespersample = channels * av_get_bytes_per_sample(avctx->sample_fmt);



    if(outputsamples > *outputsize / alac->bytespersample){

        av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");

        return -1;

    }



    *outputsize = outputsamples * alac->bytespersample;

    readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1;

    if (readsamplesize > MIN_CACHE_BITS) {

        av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);

        return -1;

    }



    if (!isnotcompressed) {

        /* so it is compressed */

        int16_t predictor_coef_table[MAX_CHANNELS][32];

        int predictor_coef_num[MAX_CHANNELS];

        int prediction_type[MAX_CHANNELS];

        int prediction_quantitization[MAX_CHANNELS];

        int ricemodifier[MAX_CHANNELS];



        interlacing_shift = get_bits(&alac->gb, 8);

        interlacing_leftweight = get_bits(&alac->gb, 8);



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

            prediction_type[ch] = get_bits(&alac->gb, 4);

            prediction_quantitization[ch] = get_bits(&alac->gb, 4);



            ricemodifier[ch] = get_bits(&alac->gb, 3);

            predictor_coef_num[ch] = get_bits(&alac->gb, 5);



            /* read the predictor table */

            for (i = 0; i < predictor_coef_num[ch]; i++)

                predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16);

        }



        if (alac->extra_bits) {

            for (i = 0; i < outputsamples; i++) {

                for (ch = 0; ch < channels; ch++)

                    alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);

            }

        }

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

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[ch],

                                        outputsamples,

                                        readsamplesize,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

                                        ricemodifier[ch] * alac->setinfo_rice_historymult / 4,

                                        (1 << alac->setinfo_rice_kmodifier) - 1);



            if (prediction_type[ch] == 0) {

                /* adaptive fir */

                predictor_decompress_fir_adapt(alac->predicterror_buffer[ch],

                                               alac->outputsamples_buffer[ch],

                                               outputsamples,

                                               readsamplesize,

                                               predictor_coef_table[ch],

                                               predictor_coef_num[ch],

                                               prediction_quantitization[ch]);

            } else {

                av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[ch]);

                /* I think the only other prediction type (or perhaps this is

                 * just a boolean?) runs adaptive fir twice.. like:

                 * predictor_decompress_fir_adapt(predictor_error, tempout, ...)

                 * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)

                 * little strange..

                 */

            }

        }

    } else {

        /* not compressed, easy case */

        for (i = 0; i < outputsamples; i++) {

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

                alac->outputsamples_buffer[ch][i] = get_sbits_long(&alac->gb,

                                                                   alac->setinfo_sample_size);

            }

        }

        alac->extra_bits = 0;

        interlacing_shift = 0;

        interlacing_leftweight = 0;

    }

    if (get_bits(&alac->gb, 3) != 7)

        av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");



    if (channels == 2 && interlacing_leftweight) {

        decorrelate_stereo(alac->outputsamples_buffer, outputsamples,

                           interlacing_shift, interlacing_leftweight);

    }



    if (alac->extra_bits) {

        append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,

                          alac->extra_bits, alac->numchannels, outputsamples);

    }



    switch(alac->setinfo_sample_size) {

    case 16:

        if (channels == 2) {

            interleave_stereo_16(alac->outputsamples_buffer, outbuffer,

                                 outputsamples);

        } else {

            for (i = 0; i < outputsamples; i++) {

                ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];

            }

        }

        break;

    case 24:

        if (channels == 2) {

            interleave_stereo_24(alac->outputsamples_buffer, outbuffer,

                                 outputsamples);

        } else {

            for (i = 0; i < outputsamples; i++)

                ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;

        }

        break;

    }



    if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)

        av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));



    return input_buffer_size;

}

static int alac_decode_frame(AVCodecContext *avctx,

                             void *outbuffer, int *outputsize,

                             AVPacket *avpkt)

{

    const uint8_t *inbuffer = avpkt->data;

    int input_buffer_size = avpkt->size;

    ALACContext *alac = avctx->priv_data;



    int channels;

    unsigned int outputsamples;

    int hassize;

    unsigned int readsamplesize;

    int isnotcompressed;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;

    int i, ch;



    

    if (!inbuffer || !input_buffer_size)

        return -1;



    init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);



    channels = get_bits(&alac->gb, 3) + 1;

    if (channels != avctx->channels) {

        av_log(avctx, AV_LOG_ERROR, "frame header channel count mismatch\n");

        return AVERROR_INVALIDDATA;

    }



    





    skip_bits(&alac->gb, 4);



    skip_bits(&alac->gb, 12); 



    

    hassize = get_bits1(&alac->gb);



    alac->extra_bits = get_bits(&alac->gb, 2) << 3;



    

    isnotcompressed = get_bits1(&alac->gb);



    if (hassize) {

        

        outputsamples = get_bits_long(&alac->gb, 32);

        if(outputsamples > alac->setinfo_max_samples_per_frame){

            av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);

            return -1;

        }

    } else

        outputsamples = alac->setinfo_max_samples_per_frame;



    alac->bytespersample = channels * av_get_bytes_per_sample(avctx->sample_fmt);



    if(outputsamples > *outputsize / alac->bytespersample){

        av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");

        return -1;

    }



    *outputsize = outputsamples * alac->bytespersample;

    readsamplesize = alac->setinfo_sample_size - alac->extra_bits + channels - 1;

    if (readsamplesize > MIN_CACHE_BITS) {

        av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);

        return -1;

    }



    if (!isnotcompressed) {

        

        int16_t predictor_coef_table[MAX_CHANNELS][32];

        int predictor_coef_num[MAX_CHANNELS];

        int prediction_type[MAX_CHANNELS];

        int prediction_quantitization[MAX_CHANNELS];

        int ricemodifier[MAX_CHANNELS];



        interlacing_shift = get_bits(&alac->gb, 8);

        interlacing_leftweight = get_bits(&alac->gb, 8);



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

            prediction_type[ch] = get_bits(&alac->gb, 4);

            prediction_quantitization[ch] = get_bits(&alac->gb, 4);



            ricemodifier[ch] = get_bits(&alac->gb, 3);

            predictor_coef_num[ch] = get_bits(&alac->gb, 5);



            

            for (i = 0; i < predictor_coef_num[ch]; i++)

                predictor_coef_table[ch][i] = (int16_t)get_bits(&alac->gb, 16);

        }



        if (alac->extra_bits) {

            for (i = 0; i < outputsamples; i++) {

                for (ch = 0; ch < channels; ch++)

                    alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);

            }

        }

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

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[ch],

                                        outputsamples,

                                        readsamplesize,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

                                        ricemodifier[ch] * alac->setinfo_rice_historymult / 4,

                                        (1 << alac->setinfo_rice_kmodifier) - 1);



            if (prediction_type[ch] == 0) {

                

                predictor_decompress_fir_adapt(alac->predicterror_buffer[ch],

                                               alac->outputsamples_buffer[ch],

                                               outputsamples,

                                               readsamplesize,

                                               predictor_coef_table[ch],

                                               predictor_coef_num[ch],

                                               prediction_quantitization[ch]);

            } else {

                av_log(avctx, AV_LOG_ERROR, "FIXME: unhandled prediction type: %i\n", prediction_type[ch]);

                











            }

        }

    } else {

        

        for (i = 0; i < outputsamples; i++) {

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

                alac->outputsamples_buffer[ch][i] = get_sbits_long(&alac->gb,

                                                                   alac->setinfo_sample_size);

            }

        }

        alac->extra_bits = 0;

        interlacing_shift = 0;

        interlacing_leftweight = 0;

    }

    if (get_bits(&alac->gb, 3) != 7)

        av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");



    if (channels == 2 && interlacing_leftweight) {

        decorrelate_stereo(alac->outputsamples_buffer, outputsamples,

                           interlacing_shift, interlacing_leftweight);

    }



    if (alac->extra_bits) {

        append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,

                          alac->extra_bits, alac->numchannels, outputsamples);

    }



    switch(alac->setinfo_sample_size) {

    case 16:

        if (channels == 2) {

            interleave_stereo_16(alac->outputsamples_buffer, outbuffer,

                                 outputsamples);

        } else {

            for (i = 0; i < outputsamples; i++) {

                ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];

            }

        }

        break;

    case 24:

        if (channels == 2) {

            interleave_stereo_24(alac->outputsamples_buffer, outbuffer,

                                 outputsamples);

        } else {

            for (i = 0; i < outputsamples; i++)

                ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;

        }

        break;

    }



    if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)

        av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));



    return input_buffer_size;

}

static int FUNC_0(AVCodecContext *VAR_0,

                             void *VAR_1, int *VAR_2,

                             AVPacket *VAR_3)

{

    const uint8_t *VAR_4 = VAR_3->data;

    int VAR_5 = VAR_3->size;

    ALACContext *alac = VAR_0->priv_data;



    int VAR_6;

    unsigned int VAR_7;

    int VAR_8;

    unsigned int VAR_9;

    int VAR_10;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;

    int VAR_11, VAR_12;



    

    if (!VAR_4 || !VAR_5)

        return -1;



    init_get_bits(&alac->gb, VAR_4, VAR_5 * 8);



    VAR_6 = get_bits(&alac->gb, 3) + 1;

    if (VAR_6 != VAR_0->VAR_6) {

        av_log(VAR_0, AV_LOG_ERROR, "frame header channel count mismatch\n");

        return AVERROR_INVALIDDATA;

    }



    





    skip_bits(&alac->gb, 4);



    skip_bits(&alac->gb, 12); 



    

    VAR_8 = get_bits1(&alac->gb);



    alac->extra_bits = get_bits(&alac->gb, 2) << 3;



    

    VAR_10 = get_bits1(&alac->gb);



    if (VAR_8) {

        

        VAR_7 = get_bits_long(&alac->gb, 32);

        if(VAR_7 > alac->setinfo_max_samples_per_frame){

            av_log(VAR_0, AV_LOG_ERROR, "VAR_7 %d > %d\n", VAR_7, alac->setinfo_max_samples_per_frame);

            return -1;

        }

    } else

        VAR_7 = alac->setinfo_max_samples_per_frame;



    alac->bytespersample = VAR_6 * av_get_bytes_per_sample(VAR_0->sample_fmt);



    if(VAR_7 > *VAR_2 / alac->bytespersample){

        av_log(VAR_0, AV_LOG_ERROR, "sample buffer too small\n");

        return -1;

    }



    *VAR_2 = VAR_7 * alac->bytespersample;

    VAR_9 = alac->setinfo_sample_size - alac->extra_bits + VAR_6 - 1;

    if (VAR_9 > MIN_CACHE_BITS) {

        av_log(VAR_0, AV_LOG_ERROR, "VAR_9 too big (%d)\n", VAR_9);

        return -1;

    }



    if (!VAR_10) {

        

        int16_t predictor_coef_table[MAX_CHANNELS][32];

        int VAR_13[MAX_CHANNELS];

        int VAR_14[MAX_CHANNELS];

        int VAR_15[MAX_CHANNELS];

        int VAR_16[MAX_CHANNELS];



        interlacing_shift = get_bits(&alac->gb, 8);

        interlacing_leftweight = get_bits(&alac->gb, 8);



        for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {

            VAR_14[VAR_12] = get_bits(&alac->gb, 4);

            VAR_15[VAR_12] = get_bits(&alac->gb, 4);



            VAR_16[VAR_12] = get_bits(&alac->gb, 3);

            VAR_13[VAR_12] = get_bits(&alac->gb, 5);



            

            for (VAR_11 = 0; VAR_11 < VAR_13[VAR_12]; VAR_11++)

                predictor_coef_table[VAR_12][VAR_11] = (int16_t)get_bits(&alac->gb, 16);

        }



        if (alac->extra_bits) {

            for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {

                for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++)

                    alac->extra_bits_buffer[VAR_12][VAR_11] = get_bits(&alac->gb, alac->extra_bits);

            }

        }

        for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[VAR_12],

                                        VAR_7,

                                        VAR_9,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

                                        VAR_16[VAR_12] * alac->setinfo_rice_historymult / 4,

                                        (1 << alac->setinfo_rice_kmodifier) - 1);



            if (VAR_14[VAR_12] == 0) {

                

                predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_12],

                                               alac->outputsamples_buffer[VAR_12],

                                               VAR_7,

                                               VAR_9,

                                               predictor_coef_table[VAR_12],

                                               VAR_13[VAR_12],

                                               VAR_15[VAR_12]);

            } else {

                av_log(VAR_0, AV_LOG_ERROR, "FIXME: unhandled prediction type: %VAR_11\n", VAR_14[VAR_12]);

                











            }

        }

    } else {

        

        for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {

            for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) {

                alac->outputsamples_buffer[VAR_12][VAR_11] = get_sbits_long(&alac->gb,

                                                                   alac->setinfo_sample_size);

            }

        }

        alac->extra_bits = 0;

        interlacing_shift = 0;

        interlacing_leftweight = 0;

    }

    if (get_bits(&alac->gb, 3) != 7)

        av_log(VAR_0, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");



    if (VAR_6 == 2 && interlacing_leftweight) {

        decorrelate_stereo(alac->outputsamples_buffer, VAR_7,

                           interlacing_shift, interlacing_leftweight);

    }



    if (alac->extra_bits) {

        append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,

                          alac->extra_bits, alac->numchannels, VAR_7);

    }



    switch(alac->setinfo_sample_size) {

    case 16:

        if (VAR_6 == 2) {

            interleave_stereo_16(alac->outputsamples_buffer, VAR_1,

                                 VAR_7);

        } else {

            for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) {

                ((int16_t*)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11];

            }

        }

        break;

    case 24:

        if (VAR_6 == 2) {

            interleave_stereo_24(alac->outputsamples_buffer, VAR_1,

                                 VAR_7);

        } else {

            for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++)

                ((int32_t *)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11] << 8;

        }

        break;

    }



    if (VAR_5 * 8 - get_bits_count(&alac->gb) > 8)

        av_log(VAR_0, AV_LOG_ERROR, "Error : %d bits left\n", VAR_5 * 8 - get_bits_count(&alac->gb));



    return VAR_5;

}

static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{ const uint8_t *VAR_4 = VAR_3->data; int VAR_5 = VAR_3->size; ALACContext *alac = VAR_0->priv_data; int VAR_6; unsigned int VAR_7; int VAR_8; unsigned int VAR_9; int VAR_10; uint8_t interlacing_shift; uint8_t interlacing_leftweight; int VAR_11, VAR_12; if (!VAR_4 || !VAR_5)
return -1; init_get_bits(&alac->gb, VAR_4, VAR_5 * 8); VAR_6 = get_bits(&alac->gb, 3) + 1; if (VAR_6 != VAR_0->VAR_6) { av_log(VAR_0, AV_LOG_ERROR, "frame header channel count mismatch\n"); return AVERROR_INVALIDDATA; } skip_bits(&alac->gb, 4); skip_bits(&alac->gb, 12); VAR_8 = get_bits1(&alac->gb); alac->extra_bits = get_bits(&alac->gb, 2) << 3; VAR_10 = get_bits1(&alac->gb); if (VAR_8) { VAR_7 = get_bits_long(&alac->gb, 32); if(VAR_7 > alac->setinfo_max_samples_per_frame){ av_log(VAR_0, AV_LOG_ERROR, "VAR_7 %d > %d\n", VAR_7, alac->setinfo_max_samples_per_frame); return -1; } } else VAR_7 = alac->setinfo_max_samples_per_frame; alac->bytespersample = VAR_6 * av_get_bytes_per_sample(VAR_0->sample_fmt); if(VAR_7 > *VAR_2 / alac->bytespersample){ av_log(VAR_0, AV_LOG_ERROR, "sample buffer too small\n"); return -1; } *VAR_2 = VAR_7 * alac->bytespersample; VAR_9 = alac->setinfo_sample_size - alac->extra_bits + VAR_6 - 1; if (VAR_9 > MIN_CACHE_BITS) { av_log(VAR_0, AV_LOG_ERROR, "VAR_9 too big (%d)\n", VAR_9); return -1; } if (!VAR_10) { int16_t predictor_coef_table[MAX_CHANNELS][32]; int VAR_13[MAX_CHANNELS]; int VAR_14[MAX_CHANNELS]; int VAR_15[MAX_CHANNELS]; int VAR_16[MAX_CHANNELS]; interlacing_shift = get_bits(&alac->gb, 8); interlacing_leftweight = get_bits(&alac->gb, 8); for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) { VAR_14[VAR_12] = get_bits(&alac->gb, 4); VAR_15[VAR_12] = get_bits(&alac->gb, 4); VAR_16[VAR_12] = get_bits(&alac->gb, 3); VAR_13[VAR_12] = get_bits(&alac->gb, 5); for (VAR_11 = 0; VAR_11 < VAR_13[VAR_12]; VAR_11++) predictor_coef_table[VAR_12][VAR_11] = (int16_t)get_bits(&alac->gb, 16); } if (alac->extra_bits) { for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) { for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) alac->extra_bits_buffer[VAR_12][VAR_11] = get_bits(&alac->gb, alac->extra_bits); } } for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) { bastardized_rice_decompress(alac,
alac->predicterror_buffer[VAR_12],
VAR_7,
VAR_9,
alac->setinfo_rice_initialhistory,
alac->setinfo_rice_kmodifier,
VAR_16[VAR_12] * alac->setinfo_rice_historymult / 4,
(1 << alac->setinfo_rice_kmodifier) - 1); if (VAR_14[VAR_12] == 0) { predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_12],
alac->outputsamples_buffer[VAR_12],
VAR_7,
VAR_9,
predictor_coef_table[VAR_12],
VAR_13[VAR_12],
VAR_15[VAR_12]); } else { av_log(VAR_0, AV_LOG_ERROR, "FIXME: unhandled prediction type: %VAR_11\n", VAR_14[VAR_12]); } } } else { for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) { for (VAR_12 = 0; VAR_12 < VAR_6; VAR_12++) { alac->outputsamples_buffer[VAR_12][VAR_11] = get_sbits_long(&alac->gb,
alac->setinfo_sample_size); } } alac->extra_bits = 0; interlacing_shift = 0; interlacing_leftweight = 0; } if (get_bits(&alac->gb, 3) != 7)
av_log(VAR_0, AV_LOG_ERROR, "Error : Wrong End Of Frame\n"); if (VAR_6 == 2 && interlacing_leftweight) { decorrelate_stereo(alac->outputsamples_buffer, VAR_7,
interlacing_shift, interlacing_leftweight); } if (alac->extra_bits) { append_extra_bits(alac->outputsamples_buffer, alac->extra_bits_buffer,
alac->extra_bits, alac->numchannels, VAR_7); } switch(alac->setinfo_sample_size) { case 16:
if (VAR_6 == 2) { interleave_stereo_16(alac->outputsamples_buffer, VAR_1,
VAR_7); } else { for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) { ((int16_t*)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11]; } } break; case 24:
if (VAR_6 == 2) { interleave_stereo_24(alac->outputsamples_buffer, VAR_1,
VAR_7); } else { for (VAR_11 = 0; VAR_11 < VAR_7; VAR_11++) ((int32_t *)VAR_1)[VAR_11] = alac->outputsamples_buffer[0][VAR_11] << 8; } break; } if (VAR_5 * 8 - get_bits_count(&alac->gb) > 8)
av_log(VAR_0, AV_LOG_ERROR, "Error : %d bits left\n", VAR_5 * 8 - get_bits_count(&alac->gb)); return VAR_5; }