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(&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);
    } else
        outputsamples = alac->setinfo_max_samples_per_frame;
    *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 */
        if (alac->setinfo_sample_size <= 16) {
            int i, chan;
            for (chan = 0; chan < channels; chan++)
                for (i = 0; i < outputsamples; i++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, alac->setinfo_sample_size);
                    audiobits = extend_sign32(audiobits, readsamplesize);
                    alac->outputsamples_buffer[chan][i] = audiobits;
        } else {
            int i, chan;
            for (chan = 0; chan < channels; chan++)
                for (i = 0; i < outputsamples; i++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, 16);
                    /* special case of sign extension..
                     * as we'll be ORing the low 16bits into this */
                    audiobits = audiobits << 16;
                    audiobits = audiobits >> (32 - alac->setinfo_sample_size);
                    audiobits |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
                    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(&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);
    } else
        outputsamples = alac->setinfo_max_samples_per_frame;
    *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 {
        
        if (alac->setinfo_sample_size <= 16) {
            int i, chan;
            for (chan = 0; chan < channels; chan++)
                for (i = 0; i < outputsamples; i++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, alac->setinfo_sample_size);
                    audiobits = extend_sign32(audiobits, readsamplesize);
                    alac->outputsamples_buffer[chan][i] = audiobits;
        } else {
            int i, chan;
            for (chan = 0; chan < channels; chan++)
                for (i = 0; i < outputsamples; i++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, 16);
                    

                    audiobits = audiobits << 16;
                    audiobits = audiobits >> (32 - alac->setinfo_sample_size);
                    audiobits |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
                    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;
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(&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);
    } else
        VAR_6 = alac->setinfo_max_samples_per_frame;
    *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_15, VAR_16;
        interlacing_shift = get_bits(&alac->gb, 8);
        interlacing_leftweight = get_bits(&alac->gb, 8);
        for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++) {
            VAR_12[VAR_16] = get_bits(&alac->gb, 4);
            VAR_13[VAR_16] = get_bits(&alac->gb, 4);
            VAR_14[VAR_16] = get_bits(&alac->gb, 3);
            VAR_11[VAR_16] = get_bits(&alac->gb, 5);
            
            for (VAR_15 = 0; VAR_15 < VAR_11[VAR_16]; VAR_15++)
                predictor_coef_table[VAR_16][VAR_15] = (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_16 = 0; VAR_16 < VAR_5; VAR_16++) {
            bastardized_rice_decompress(alac,
                                        alac->predicterror_buffer[VAR_16],
                                        VAR_6,
                                        VAR_8,
                                        alac->setinfo_rice_initialhistory,
                                        alac->setinfo_rice_kmodifier,
                                        VAR_14[VAR_16] * alac->setinfo_rice_historymult / 4,
                                        (1 << alac->setinfo_rice_kmodifier) - 1);
            if (VAR_12[VAR_16] == 0) {
                
                predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_16],
                                               alac->outputsamples_buffer[VAR_16],
                                               VAR_6,
                                               VAR_8,
                                               predictor_coef_table[VAR_16],
                                               VAR_11[VAR_16],
                                               VAR_13[VAR_16]);
            } else {
                av_log(VAR_0, AV_LOG_ERROR, "FIXME: unhandled prediction type: %VAR_15\n", VAR_12[VAR_16]);
                





    } else {
        
        if (alac->setinfo_sample_size <= 16) {
            int VAR_15, VAR_16;
            for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++)
                for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, alac->setinfo_sample_size);
                    audiobits = extend_sign32(audiobits, VAR_8);
                    alac->outputsamples_buffer[VAR_16][VAR_15] = audiobits;
        } else {
            int VAR_15, VAR_16;
            for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++)
                for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) {
                    int32_t audiobits;
                    audiobits = get_bits(&alac->gb, 16);
                    

                    audiobits = audiobits << 16;
                    audiobits = audiobits >> (32 - alac->setinfo_sample_size);
                    audiobits |= get_bits(&alac->gb, alac->setinfo_sample_size - 16);
                    alac->outputsamples_buffer[VAR_16][VAR_15] = 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_15;
            for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) {
                int16_t sample = alac->outputsamples_buffer[0][VAR_15];
                ((int16_t*)VAR_1)[VAR_15 * alac->numchannels] = sample;
        break;
    case 20:
    case 24:
        
        
    case 32:
        av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented sample size %VAR_15\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(&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); } else VAR_6 = alac->setinfo_max_samples_per_frame; *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_15, VAR_16; interlacing_shift = get_bits(&alac->gb, 8); interlacing_leftweight = get_bits(&alac->gb, 8); for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++) { VAR_12[VAR_16] = get_bits(&alac->gb, 4); VAR_13[VAR_16] = get_bits(&alac->gb, 4); VAR_14[VAR_16] = get_bits(&alac->gb, 3); VAR_11[VAR_16] = get_bits(&alac->gb, 5); for (VAR_15 = 0; VAR_15 < VAR_11[VAR_16]; VAR_15++) predictor_coef_table[VAR_16][VAR_15] = (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_16 = 0; VAR_16 < VAR_5; VAR_16++) { bastardized_rice_decompress(alac,
alac->predicterror_buffer[VAR_16],
VAR_6,
VAR_8,
alac->setinfo_rice_initialhistory,
alac->setinfo_rice_kmodifier,
VAR_14[VAR_16] * alac->setinfo_rice_historymult / 4,
(1 << alac->setinfo_rice_kmodifier) - 1); if (VAR_12[VAR_16] == 0) { predictor_decompress_fir_adapt(alac->predicterror_buffer[VAR_16],
alac->outputsamples_buffer[VAR_16],
VAR_6,
VAR_8,
predictor_coef_table[VAR_16],
VAR_11[VAR_16],
VAR_13[VAR_16]); } else { av_log(VAR_0, AV_LOG_ERROR, "FIXME: unhandled prediction type: %VAR_15\n", VAR_12[VAR_16]); } else { if (alac->setinfo_sample_size <= 16) { int VAR_15, VAR_16; for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++) for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) { int32_t audiobits; audiobits = get_bits(&alac->gb, alac->setinfo_sample_size); audiobits = extend_sign32(audiobits, VAR_8); alac->outputsamples_buffer[VAR_16][VAR_15] = audiobits; } else { int VAR_15, VAR_16; for (VAR_16 = 0; VAR_16 < VAR_5; VAR_16++) for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) { int32_t audiobits; audiobits = get_bits(&alac->gb, 16); audiobits = audiobits << 16; audiobits = audiobits >> (32 - alac->setinfo_sample_size); audiobits |= get_bits(&alac->gb, alac->setinfo_sample_size - 16); alac->outputsamples_buffer[VAR_16][VAR_15] = 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_15; for (VAR_15 = 0; VAR_15 < VAR_6; VAR_15++) { int16_t sample = alac->outputsamples_buffer[0][VAR_15]; ((int16_t*)VAR_1)[VAR_15 * alac->numchannels] = sample; break; case 20:
case 24:
case 32:
av_log(VAR_0, AV_LOG_ERROR, "FIXME: unimplemented sample size %VAR_15\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;