static int alac_decode_frame(AVCodecContext *avctx,

                             void *outbuffer, int *outputsize,

                             const uint8_t *inbuffer, int input_buffer_size)

{

    ALACContext *alac = avctx->priv_data;



    int channels;

    unsigned int outputsamples;

    int hassize;

    int readsamplesize;

    int wasted_bytes;

    int isnotcompressed;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;



    /* short-circuit null buffers */

    if (!inbuffer || !input_buffer_size)

        return input_buffer_size;



    /* initialize from the extradata */

    if (!alac->context_initialized) {

        if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {

            av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",

                ALAC_EXTRADATA_SIZE);

            return input_buffer_size;

        }

        if (alac_set_info(alac)) {

            av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");

            return input_buffer_size;

        }

        alac->context_initialized = 1;

    }



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



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

    if (channels > MAX_CHANNELS) {

        av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",

               MAX_CHANNELS);

        return input_buffer_size;

    }



    /* 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);



    wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */



    /* 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;



    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 - (wasted_bytes * 8) + channels - 1;



    if (!isnotcompressed) {

        /* so it is compressed */

        int16_t predictor_coef_table[channels][32];

        int predictor_coef_num[channels];

        int prediction_type[channels];

        int prediction_quantitization[channels];

        int ricemodifier[channels];

        int i, chan;



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

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



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

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

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



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

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



            /* read the predictor table */

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

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

        }



        if (wasted_bytes)

            av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");



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

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[chan],

                                        outputsamples,

                                        readsamplesize,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

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

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



            if (prediction_type[chan] == 0) {

                /* adaptive fir */

                predictor_decompress_fir_adapt(alac->predicterror_buffer[chan],

                                               alac->outputsamples_buffer[chan],

                                               outputsamples,

                                               readsamplesize,

                                               predictor_coef_table[chan],

                                               predictor_coef_num[chan],

                                               prediction_quantitization[chan]);

            } else {

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

                /* 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 */

        int i, chan;

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

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

                int32_t audiobits;



                audiobits = get_bits_long(&alac->gb, alac->setinfo_sample_size);

                audiobits = extend_sign32(audiobits, alac->setinfo_sample_size);



                alac->outputsamples_buffer[chan][i] = audiobits;

            }

        /* wasted_bytes = 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");



    switch(alac->setinfo_sample_size) {

    case 16:

        if (channels == 2) {

            reconstruct_stereo_16(alac->outputsamples_buffer,

                                  (int16_t*)outbuffer,

                                  alac->numchannels,

                                  outputsamples,

                                  interlacing_shift,

                                  interlacing_leftweight);

        } else {

            int i;

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

                int16_t sample = alac->outputsamples_buffer[0][i];

                ((int16_t*)outbuffer)[i * alac->numchannels] = sample;

            }

        }

        break;

    case 20:

    case 24:

        // It is not clear if there exist any encoder that creates 24 bit ALAC

        // files. iTunes convert 24 bit raw files to 16 bit before encoding.

    case 32:

        av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);

        break;

    default:

        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,

                             const uint8_t *inbuffer, int input_buffer_size)

{

    ALACContext *alac = avctx->priv_data;



    int channels;

    unsigned int outputsamples;

    int hassize;

    int readsamplesize;

    int wasted_bytes;

    int isnotcompressed;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;



    

    if (!inbuffer || !input_buffer_size)

        return input_buffer_size;



    

    if (!alac->context_initialized) {

        if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {

            av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",

                ALAC_EXTRADATA_SIZE);

            return input_buffer_size;

        }

        if (alac_set_info(alac)) {

            av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");

            return input_buffer_size;

        }

        alac->context_initialized = 1;

    }



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



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

    if (channels > MAX_CHANNELS) {

        av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",

               MAX_CHANNELS);

        return input_buffer_size;

    }



    





    skip_bits(&alac->gb, 4);



    skip_bits(&alac->gb, 12); 



    

    hassize = get_bits1(&alac->gb);



    wasted_bytes = get_bits(&alac->gb, 2); 



    

    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;



    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 - (wasted_bytes * 8) + channels - 1;



    if (!isnotcompressed) {

        

        int16_t predictor_coef_table[channels][32];

        int predictor_coef_num[channels];

        int prediction_type[channels];

        int prediction_quantitization[channels];

        int ricemodifier[channels];

        int i, chan;



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

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



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

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

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



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

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



            

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

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

        }



        if (wasted_bytes)

            av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");



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

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[chan],

                                        outputsamples,

                                        readsamplesize,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

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

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



            if (prediction_type[chan] == 0) {

                

                predictor_decompress_fir_adapt(alac->predicterror_buffer[chan],

                                               alac->outputsamples_buffer[chan],

                                               outputsamples,

                                               readsamplesize,

                                               predictor_coef_table[chan],

                                               predictor_coef_num[chan],

                                               prediction_quantitization[chan]);

            } else {

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

                











            }

        }

    } else {

        

        int i, chan;

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

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

                int32_t audiobits;



                audiobits = get_bits_long(&alac->gb, alac->setinfo_sample_size);

                audiobits = extend_sign32(audiobits, alac->setinfo_sample_size);



                alac->outputsamples_buffer[chan][i] = audiobits;

            }

        

        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");



    switch(alac->setinfo_sample_size) {

    case 16:

        if (channels == 2) {

            reconstruct_stereo_16(alac->outputsamples_buffer,

                                  (int16_t*)outbuffer,

                                  alac->numchannels,

                                  outputsamples,

                                  interlacing_shift,

                                  interlacing_leftweight);

        } else {

            int i;

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

                int16_t sample = alac->outputsamples_buffer[0][i];

                ((int16_t*)outbuffer)[i * alac->numchannels] = sample;

            }

        }

        break;

    case 20:

    case 24:

        

        

    case 32:

        av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);

        break;

    default:

        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;

}

    int readsamplesize;
static int FUNC_0(AVCodecContext *VAR_0,

                             void *VAR_1, int *VAR_2,

                             const uint8_t *VAR_3, int VAR_4)

{

    ALACContext *alac = VAR_0->priv_data;



    int VAR_5;

    unsigned int VAR_6;

    int VAR_7;

    int VAR_8;

    int VAR_9;

    int VAR_10;

    uint8_t interlacing_shift;

    uint8_t interlacing_leftweight;



    

    if (!VAR_3 || !VAR_4)

        return VAR_4;



    

    if (!alac->context_initialized) {

        if (alac->VAR_0->extradata_size != ALAC_EXTRADATA_SIZE) {

            av_log(VAR_0, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",

                ALAC_EXTRADATA_SIZE);

            return VAR_4;

        }

        if (alac_set_info(alac)) {

            av_log(VAR_0, AV_LOG_ERROR, "alac: set_info failed\n");

            return VAR_4;

        }

        alac->context_initialized = 1;

    }



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



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

    if (VAR_5 > MAX_CHANNELS) {

        av_log(VAR_0, AV_LOG_ERROR, "VAR_5 > %d not supported\n",

               MAX_CHANNELS);

        return VAR_4;

    }



    





    skip_bits(&alac->gb, 4);



    skip_bits(&alac->gb, 12); 



    

    VAR_7 = get_bits1(&alac->gb);



    VAR_9 = get_bits(&alac->gb, 2); 



    

    VAR_10 = get_bits1(&alac->gb);



    if (VAR_7) {

        

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

        if(VAR_6 > alac->setinfo_max_samples_per_frame){

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

            return -1;

        }

    } else

        VAR_6 = alac->setinfo_max_samples_per_frame;



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

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

        return -1;

    }



    *VAR_2 = VAR_6 * alac->bytespersample;

    VAR_8 = alac->setinfo_sample_size - (VAR_9 * 8) + VAR_5 - 1;



    if (!VAR_10) {

        

        int16_t predictor_coef_table[VAR_5][32];

        int VAR_11[VAR_5];

        int VAR_12[VAR_5];

        int VAR_13[VAR_5];

        int VAR_14[VAR_5];

        int VAR_17, VAR_17;



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

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



        for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) {

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

            VAR_13[VAR_17] = get_bits(&alac->gb, 4);



            VAR_14[VAR_17] = get_bits(&alac->gb, 3);

            VAR_11[VAR_17] = get_bits(&alac->gb, 5);



            

            for (VAR_17 = 0; VAR_17 < VAR_11[VAR_17]; VAR_17++)

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

        }



        if (VAR_9)

            av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of VAR_9\n");



        for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) {

            bastardized_rice_decompress(alac,

                                        alac->predicterror_buffer[VAR_17],

                                        VAR_6,

                                        VAR_8,

                                        alac->setinfo_rice_initialhistory,

                                        alac->setinfo_rice_kmodifier,

                                        VAR_14[VAR_17] * alac->setinfo_rice_historymult / 4,

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



            if (VAR_12[VAR_17] == 0) {

                

                predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_17],

                                               alac->outputsamples_buffer[VAR_17],

                                               VAR_6,

                                               VAR_8,

                                               predictor_coef_table[VAR_17],

                                               VAR_11[VAR_17],

                                               VAR_13[VAR_17]);

            } else {

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

                











            }

        }

    } else {

        

        int VAR_17, VAR_17;

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

            for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) {

                int32_t audiobits;



                audiobits = get_bits_long(&alac->gb, alac->setinfo_sample_size);

                audiobits = extend_sign32(audiobits, alac->setinfo_sample_size);



                alac->outputsamples_buffer[VAR_17][VAR_17] = audiobits;

            }

        

        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");



    switch(alac->setinfo_sample_size) {

    case 16:

        if (VAR_5 == 2) {

            reconstruct_stereo_16(alac->outputsamples_buffer,

                                  (int16_t*)VAR_1,

                                  alac->numchannels,

                                  VAR_6,

                                  interlacing_shift,

                                  interlacing_leftweight);

        } else {

            int VAR_17;

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

                int16_t sample = alac->outputsamples_buffer[0][VAR_17];

                ((int16_t*)VAR_1)[VAR_17 * alac->numchannels] = sample;

            }

        }

        break;

    case 20:

    case 24:

        

        

    case 32:

        av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented sample size %VAR_17\n", alac->setinfo_sample_size);

        break;

    default:

        break;

    }



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

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



    return VAR_4;

}

static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{ ALACContext *alac = VAR_0->priv_data; int VAR_5; unsigned int VAR_6; int VAR_7; int VAR_8; int VAR_9; int VAR_10; uint8_t interlacing_shift; uint8_t interlacing_leftweight; if (!VAR_3 || !VAR_4)
return VAR_4; if (!alac->context_initialized) { if (alac->VAR_0->extradata_size != ALAC_EXTRADATA_SIZE) { av_log(VAR_0, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
ALAC_EXTRADATA_SIZE); return VAR_4; } if (alac_set_info(alac)) { av_log(VAR_0, AV_LOG_ERROR, "alac: set_info failed\n"); return VAR_4; } alac->context_initialized = 1; } init_get_bits(&alac->gb, VAR_3, VAR_4 * 8); VAR_5 = get_bits(&alac->gb, 3) + 1; if (VAR_5 > MAX_CHANNELS) { av_log(VAR_0, AV_LOG_ERROR, "VAR_5 > %d not supported\n",
MAX_CHANNELS); return VAR_4; } skip_bits(&alac->gb, 4); skip_bits(&alac->gb, 12); VAR_7 = get_bits1(&alac->gb); VAR_9 = get_bits(&alac->gb, 2); VAR_10 = get_bits1(&alac->gb); if (VAR_7) { VAR_6 = get_bits_long(&alac->gb, 32); if(VAR_6 > alac->setinfo_max_samples_per_frame){ av_log(VAR_0, AV_LOG_ERROR, "VAR_6 %d > %d\n", VAR_6, alac->setinfo_max_samples_per_frame); return -1; } } else VAR_6 = alac->setinfo_max_samples_per_frame; if(VAR_6 > *VAR_2 / alac->bytespersample){ av_log(VAR_0, AV_LOG_ERROR, "sample buffer too small\n"); return -1; } *VAR_2 = VAR_6 * alac->bytespersample; VAR_8 = alac->setinfo_sample_size - (VAR_9 * 8) + VAR_5 - 1; if (!VAR_10) { int16_t predictor_coef_table[VAR_5][32]; int VAR_11[VAR_5]; int VAR_12[VAR_5]; int VAR_13[VAR_5]; int VAR_14[VAR_5]; int VAR_17, VAR_17; interlacing_shift = get_bits(&alac->gb, 8); interlacing_leftweight = get_bits(&alac->gb, 8); for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) { VAR_12[VAR_17] = get_bits(&alac->gb, 4); VAR_13[VAR_17] = get_bits(&alac->gb, 4); VAR_14[VAR_17] = get_bits(&alac->gb, 3); VAR_11[VAR_17] = get_bits(&alac->gb, 5); for (VAR_17 = 0; VAR_17 < VAR_11[VAR_17]; VAR_17++) predictor_coef_table[VAR_17][VAR_17] = (int16_t)get_bits(&alac->gb, 16); } if (VAR_9)
av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of VAR_9\n"); for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) { bastardized_rice_decompress(alac,
alac->predicterror_buffer[VAR_17],
VAR_6,
VAR_8,
alac->setinfo_rice_initialhistory,
alac->setinfo_rice_kmodifier,
VAR_14[VAR_17] * alac->setinfo_rice_historymult / 4,
(1 << alac->setinfo_rice_kmodifier) - 1); if (VAR_12[VAR_17] == 0) { predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_17],
alac->outputsamples_buffer[VAR_17],
VAR_6,
VAR_8,
predictor_coef_table[VAR_17],
VAR_11[VAR_17],
VAR_13[VAR_17]); } else { av_log(VAR_0, AV_LOG_ERROR, "FIXME: unhandled prediction type: %VAR_17\n", VAR_12[VAR_17]); } } } else { int VAR_17, VAR_17; for (VAR_17 = 0; VAR_17 < VAR_6; VAR_17++) for (VAR_17 = 0; VAR_17 < VAR_5; VAR_17++) { int32_t audiobits; audiobits = get_bits_long(&alac->gb, alac->setinfo_sample_size); audiobits = extend_sign32(audiobits, alac->setinfo_sample_size); alac->outputsamples_buffer[VAR_17][VAR_17] = audiobits; } 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"); switch(alac->setinfo_sample_size) { case 16:
if (VAR_5 == 2) { reconstruct_stereo_16(alac->outputsamples_buffer,
(int16_t*)VAR_1,
alac->numchannels,
VAR_6,
interlacing_shift,
interlacing_leftweight); } else { int VAR_17; for (VAR_17 = 0; VAR_17 < VAR_6; VAR_17++) { int16_t sample = alac->outputsamples_buffer[0][VAR_17]; ((int16_t*)VAR_1)[VAR_17 * alac->numchannels] = sample; } } break; case 20:
case 24:
case 32:
av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented sample size %VAR_17\n", alac->setinfo_sample_size); break; default:
break; } if (VAR_4 * 8 - get_bits_count(&alac->gb) > 8)
av_log(VAR_0, AV_LOG_ERROR, "Error : %d bits left\n", VAR_4 * 8 - get_bits_count(&alac->gb)); return VAR_4; }