static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

                            const AVFrame *frame, int *got_packet_ptr)

{

    AACEncContext *s = avctx->priv_data;

    float **samples = s->planar_samples, *samples2, *la, *overlap;

    ChannelElement *cpe;

    SingleChannelElement *sce;

    IndividualChannelStream *ics;

    int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;

    int target_bits, rate_bits, too_many_bits, too_few_bits;

    int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;

    int chan_el_counter[4];

    FFPsyWindowInfo windows[AAC_MAX_CHANNELS];



    if (s->last_frame == 2)

        return 0;



    /* add current frame to queue */

    if (frame) {

        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)

            return ret;

    }



    copy_input_samples(s, frame);

    if (s->psypp)

        ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);



    if (!avctx->frame_number)

        return 0;



    start_ch = 0;

    for (i = 0; i < s->chan_map[0]; i++) {

        FFPsyWindowInfo* wi = windows + start_ch;

        tag      = s->chan_map[i+1];

        chans    = tag == TYPE_CPE ? 2 : 1;

        cpe      = &s->cpe[i];

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

            float clip_avoidance_factor;

            sce = &cpe->ch[ch];

            ics = &sce->ics;

            s->cur_channel = start_ch + ch;

            overlap  = &samples[s->cur_channel][0];

            samples2 = overlap + 1024;

            la       = samples2 + (448+64);

            if (!frame)

                la = NULL;

            if (tag == TYPE_LFE) {

                wi[ch].window_type[0] = ONLY_LONG_SEQUENCE;

                wi[ch].window_shape   = 0;

                wi[ch].num_windows    = 1;

                wi[ch].grouping[0]    = 1;



                /* Only the lowest 12 coefficients are used in a LFE channel.

                 * The expression below results in only the bottom 8 coefficients

                 * being used for 11.025kHz to 16kHz sample rates.

                 */

                ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;

            } else {

                wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,

                                              ics->window_sequence[0]);

            }

            ics->window_sequence[1] = ics->window_sequence[0];

            ics->window_sequence[0] = wi[ch].window_type[0];

            ics->use_kb_window[1]   = ics->use_kb_window[0];

            ics->use_kb_window[0]   = wi[ch].window_shape;

            ics->num_windows        = wi[ch].num_windows;

            ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];

            ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];

            ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb);

            ics->swb_offset         = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_swb_offset_128 [s->samplerate_index]:

                                        ff_swb_offset_1024[s->samplerate_index];

            ics->tns_max_bands      = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_tns_max_bands_128 [s->samplerate_index]:

                                        ff_tns_max_bands_1024[s->samplerate_index];

            clip_avoidance_factor = 0.0f;

            for (w = 0; w < ics->num_windows; w++)

                ics->group_len[w] = wi[ch].grouping[w];

            for (w = 0; w < ics->num_windows; w++) {

                if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {

                    ics->window_clipping[w] = 1;

                    clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);

                } else {

                    ics->window_clipping[w] = 0;

                }

            }

            if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {

                ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;

            } else {

                ics->clip_avoidance_factor = 1.0f;

            }



            apply_window_and_mdct(s, sce, overlap);



            if (s->options.ltp && s->coder->update_ltp) {

                s->coder->update_ltp(s, sce);

                apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);

                s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);

            }



            if (isnan(cpe->ch->coeffs[0])) {

                av_log(avctx, AV_LOG_ERROR, "Input contains NaN\n");

                return AVERROR(EINVAL);

            }

            avoid_clipping(s, sce);

        }

        start_ch += chans;

    }

    if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0)

        return ret;

    frame_bits = its = 0;

    do {

        init_put_bits(&s->pb, avpkt->data, avpkt->size);



        if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))

            put_bitstream_info(s, LIBAVCODEC_IDENT);

        start_ch = 0;

        target_bits = 0;

        memset(chan_el_counter, 0, sizeof(chan_el_counter));

        for (i = 0; i < s->chan_map[0]; i++) {

            FFPsyWindowInfo* wi = windows + start_ch;

            const float *coeffs[2];

            tag      = s->chan_map[i+1];

            chans    = tag == TYPE_CPE ? 2 : 1;

            cpe      = &s->cpe[i];

            cpe->common_window = 0;

            memset(cpe->is_mask, 0, sizeof(cpe->is_mask));

            memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));

            put_bits(&s->pb, 3, tag);

            put_bits(&s->pb, 4, chan_el_counter[tag]++);

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

                sce = &cpe->ch[ch];

                coeffs[ch] = sce->coeffs;

                sce->ics.predictor_present = 0;

                sce->ics.ltp.present = 0;

                memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));

                memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));

                memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));

                for (w = 0; w < 128; w++)

                    if (sce->band_type[w] > RESERVED_BT)

                        sce->band_type[w] = 0;

            }

            s->psy.bitres.alloc = -1;

            s->psy.bitres.bits = s->last_frame_pb_count / s->channels;

            s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);

            if (s->psy.bitres.alloc > 0) {

                /* Lambda unused here on purpose, we need to take psy's unscaled allocation */

                target_bits += s->psy.bitres.alloc

                    * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));

                s->psy.bitres.alloc /= chans;

            }

            s->cur_type = tag;

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

                s->cur_channel = start_ch + ch;

                if (s->options.pns && s->coder->mark_pns)

                    s->coder->mark_pns(s, avctx, &cpe->ch[ch]);

                s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);

            }

            if (chans > 1

                && wi[0].window_type[0] == wi[1].window_type[0]

                && wi[0].window_shape   == wi[1].window_shape) {



                cpe->common_window = 1;

                for (w = 0; w < wi[0].num_windows; w++) {

                    if (wi[0].grouping[w] != wi[1].grouping[w]) {

                        cpe->common_window = 0;

                        break;

                    }

                }

            }

            for (ch = 0; ch < chans; ch++) { /* TNS and PNS */

                sce = &cpe->ch[ch];

                s->cur_channel = start_ch + ch;

                if (s->options.tns && s->coder->search_for_tns)

                    s->coder->search_for_tns(s, sce);

                if (s->options.tns && s->coder->apply_tns_filt)

                    s->coder->apply_tns_filt(s, sce);

                if (sce->tns.present)

                    tns_mode = 1;

                if (s->options.pns && s->coder->search_for_pns)

                    s->coder->search_for_pns(s, avctx, sce);

            }

            s->cur_channel = start_ch;

            if (s->options.intensity_stereo) { /* Intensity Stereo */

                if (s->coder->search_for_is)

                    s->coder->search_for_is(s, avctx, cpe);

                if (cpe->is_mode) is_mode = 1;

                apply_intensity_stereo(cpe);

            }

            if (s->options.pred) { /* Prediction */

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->options.pred && s->coder->search_for_pred)

                        s->coder->search_for_pred(s, sce);

                    if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;

                }

                if (s->coder->adjust_common_pred)

                    s->coder->adjust_common_pred(s, cpe);

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->options.pred && s->coder->apply_main_pred)

                        s->coder->apply_main_pred(s, sce);

                }

                s->cur_channel = start_ch;

            }

            if (s->options.mid_side) { /* Mid/Side stereo */

                if (s->options.mid_side == -1 && s->coder->search_for_ms)

                    s->coder->search_for_ms(s, cpe);

                else if (cpe->common_window)

                    memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));

                apply_mid_side_stereo(cpe);

            }

            adjust_frame_information(cpe, chans);

            if (s->options.ltp) { /* LTP */

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->coder->search_for_ltp)

                        s->coder->search_for_ltp(s, sce, cpe->common_window);

                    if (sce->ics.ltp.present) pred_mode = 1;

                }

                s->cur_channel = start_ch;

                if (s->coder->adjust_common_ltp)

                    s->coder->adjust_common_ltp(s, cpe);

            }

            if (chans == 2) {

                put_bits(&s->pb, 1, cpe->common_window);

                if (cpe->common_window) {

                    put_ics_info(s, &cpe->ch[0].ics);

                    if (s->coder->encode_main_pred)

                        s->coder->encode_main_pred(s, &cpe->ch[0]);

                    if (s->coder->encode_ltp_info)

                        s->coder->encode_ltp_info(s, &cpe->ch[0], 1);

                    encode_ms_info(&s->pb, cpe);

                    if (cpe->ms_mode) ms_mode = 1;

                }

            }

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

                s->cur_channel = start_ch + ch;

                encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);

            }

            start_ch += chans;

        }



        if (avctx->flags & CODEC_FLAG_QSCALE) {

            /* When using a constant Q-scale, don't mess with lambda */

            break;

        }



        /* rate control stuff

         * allow between the nominal bitrate, and what psy's bit reservoir says to target

         * but drift towards the nominal bitrate always

         */

        frame_bits = put_bits_count(&s->pb);

        rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;

        rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);

        too_many_bits = FFMAX(target_bits, rate_bits);

        too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);

        too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);



        /* When using ABR, be strict (but only for increasing) */

        too_few_bits = too_few_bits - too_few_bits/8;

        too_many_bits = too_many_bits + too_many_bits/2;



        if (   its == 0 /* for steady-state Q-scale tracking */

            || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))

            || frame_bits >= 6144 * s->channels - 3  )

        {

            float ratio = ((float)rate_bits) / frame_bits;



            if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {

                /*

                 * This path is for steady-state Q-scale tracking

                 * When frame bits fall within the stable range, we still need to adjust

                 * lambda to maintain it like so in a stable fashion (large jumps in lambda

                 * create artifacts and should be avoided), but slowly

                 */

                ratio = sqrtf(sqrtf(ratio));

                ratio = av_clipf(ratio, 0.9f, 1.1f);

            } else {

                /* Not so fast though */

                ratio = sqrtf(ratio);

            }

            s->lambda = FFMIN(s->lambda * ratio, 65536.f);



            /* Keep iterating if we must reduce and lambda is in the sky */

            if (ratio > 0.9f && ratio < 1.1f) {

                break;

            } else {

                if (is_mode || ms_mode || tns_mode || pred_mode) {

                    for (i = 0; i < s->chan_map[0]; i++) {

                        // Must restore coeffs

                        chans = tag == TYPE_CPE ? 2 : 1;

                        cpe = &s->cpe[i];

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

                            memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));

                    }

                }

                its++;

            }

        } else {

            break;

        }

    } while (1);



    if (s->options.ltp && s->coder->ltp_insert_new_frame)

        s->coder->ltp_insert_new_frame(s);



    put_bits(&s->pb, 3, TYPE_END);

    flush_put_bits(&s->pb);



    s->last_frame_pb_count = put_bits_count(&s->pb);



    s->lambda_sum += s->lambda;

    s->lambda_count++;



    if (!frame)

        s->last_frame++;



    ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,

                       &avpkt->duration);



    avpkt->size = put_bits_count(&s->pb) >> 3;

    *got_packet_ptr = 1;

    return 0;

}

static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

                            const AVFrame *frame, int *got_packet_ptr)

{

    AACEncContext *s = avctx->priv_data;

    float **samples = s->planar_samples, *samples2, *la, *overlap;

    ChannelElement *cpe;

    SingleChannelElement *sce;

    IndividualChannelStream *ics;

    int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;

    int target_bits, rate_bits, too_many_bits, too_few_bits;

    int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;

    int chan_el_counter[4];

    FFPsyWindowInfo windows[AAC_MAX_CHANNELS];



    if (s->last_frame == 2)

        return 0;



    

    if (frame) {

        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)

            return ret;

    }



    copy_input_samples(s, frame);

    if (s->psypp)

        ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);



    if (!avctx->frame_number)

        return 0;



    start_ch = 0;

    for (i = 0; i < s->chan_map[0]; i++) {

        FFPsyWindowInfo* wi = windows + start_ch;

        tag      = s->chan_map[i+1];

        chans    = tag == TYPE_CPE ? 2 : 1;

        cpe      = &s->cpe[i];

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

            float clip_avoidance_factor;

            sce = &cpe->ch[ch];

            ics = &sce->ics;

            s->cur_channel = start_ch + ch;

            overlap  = &samples[s->cur_channel][0];

            samples2 = overlap + 1024;

            la       = samples2 + (448+64);

            if (!frame)

                la = NULL;

            if (tag == TYPE_LFE) {

                wi[ch].window_type[0] = ONLY_LONG_SEQUENCE;

                wi[ch].window_shape   = 0;

                wi[ch].num_windows    = 1;

                wi[ch].grouping[0]    = 1;



                







                ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;

            } else {

                wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,

                                              ics->window_sequence[0]);

            }

            ics->window_sequence[1] = ics->window_sequence[0];

            ics->window_sequence[0] = wi[ch].window_type[0];

            ics->use_kb_window[1]   = ics->use_kb_window[0];

            ics->use_kb_window[0]   = wi[ch].window_shape;

            ics->num_windows        = wi[ch].num_windows;

            ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];

            ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];

            ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb);

            ics->swb_offset         = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_swb_offset_128 [s->samplerate_index]:

                                        ff_swb_offset_1024[s->samplerate_index];

            ics->tns_max_bands      = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_tns_max_bands_128 [s->samplerate_index]:

                                        ff_tns_max_bands_1024[s->samplerate_index];

            clip_avoidance_factor = 0.0f;

            for (w = 0; w < ics->num_windows; w++)

                ics->group_len[w] = wi[ch].grouping[w];

            for (w = 0; w < ics->num_windows; w++) {

                if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {

                    ics->window_clipping[w] = 1;

                    clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);

                } else {

                    ics->window_clipping[w] = 0;

                }

            }

            if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {

                ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;

            } else {

                ics->clip_avoidance_factor = 1.0f;

            }



            apply_window_and_mdct(s, sce, overlap);



            if (s->options.ltp && s->coder->update_ltp) {

                s->coder->update_ltp(s, sce);

                apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);

                s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);

            }



            if (isnan(cpe->ch->coeffs[0])) {

                av_log(avctx, AV_LOG_ERROR, "Input contains NaN\n");

                return AVERROR(EINVAL);

            }

            avoid_clipping(s, sce);

        }

        start_ch += chans;

    }

    if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0)

        return ret;

    frame_bits = its = 0;

    do {

        init_put_bits(&s->pb, avpkt->data, avpkt->size);



        if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))

            put_bitstream_info(s, LIBAVCODEC_IDENT);

        start_ch = 0;

        target_bits = 0;

        memset(chan_el_counter, 0, sizeof(chan_el_counter));

        for (i = 0; i < s->chan_map[0]; i++) {

            FFPsyWindowInfo* wi = windows + start_ch;

            const float *coeffs[2];

            tag      = s->chan_map[i+1];

            chans    = tag == TYPE_CPE ? 2 : 1;

            cpe      = &s->cpe[i];

            cpe->common_window = 0;

            memset(cpe->is_mask, 0, sizeof(cpe->is_mask));

            memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));

            put_bits(&s->pb, 3, tag);

            put_bits(&s->pb, 4, chan_el_counter[tag]++);

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

                sce = &cpe->ch[ch];

                coeffs[ch] = sce->coeffs;

                sce->ics.predictor_present = 0;

                sce->ics.ltp.present = 0;

                memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));

                memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));

                memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));

                for (w = 0; w < 128; w++)

                    if (sce->band_type[w] > RESERVED_BT)

                        sce->band_type[w] = 0;

            }

            s->psy.bitres.alloc = -1;

            s->psy.bitres.bits = s->last_frame_pb_count / s->channels;

            s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);

            if (s->psy.bitres.alloc > 0) {

                

                target_bits += s->psy.bitres.alloc

                    * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));

                s->psy.bitres.alloc /= chans;

            }

            s->cur_type = tag;

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

                s->cur_channel = start_ch + ch;

                if (s->options.pns && s->coder->mark_pns)

                    s->coder->mark_pns(s, avctx, &cpe->ch[ch]);

                s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);

            }

            if (chans > 1

                && wi[0].window_type[0] == wi[1].window_type[0]

                && wi[0].window_shape   == wi[1].window_shape) {



                cpe->common_window = 1;

                for (w = 0; w < wi[0].num_windows; w++) {

                    if (wi[0].grouping[w] != wi[1].grouping[w]) {

                        cpe->common_window = 0;

                        break;

                    }

                }

            }

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

                sce = &cpe->ch[ch];

                s->cur_channel = start_ch + ch;

                if (s->options.tns && s->coder->search_for_tns)

                    s->coder->search_for_tns(s, sce);

                if (s->options.tns && s->coder->apply_tns_filt)

                    s->coder->apply_tns_filt(s, sce);

                if (sce->tns.present)

                    tns_mode = 1;

                if (s->options.pns && s->coder->search_for_pns)

                    s->coder->search_for_pns(s, avctx, sce);

            }

            s->cur_channel = start_ch;

            if (s->options.intensity_stereo) { 

                if (s->coder->search_for_is)

                    s->coder->search_for_is(s, avctx, cpe);

                if (cpe->is_mode) is_mode = 1;

                apply_intensity_stereo(cpe);

            }

            if (s->options.pred) { 

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->options.pred && s->coder->search_for_pred)

                        s->coder->search_for_pred(s, sce);

                    if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;

                }

                if (s->coder->adjust_common_pred)

                    s->coder->adjust_common_pred(s, cpe);

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->options.pred && s->coder->apply_main_pred)

                        s->coder->apply_main_pred(s, sce);

                }

                s->cur_channel = start_ch;

            }

            if (s->options.mid_side) { 

                if (s->options.mid_side == -1 && s->coder->search_for_ms)

                    s->coder->search_for_ms(s, cpe);

                else if (cpe->common_window)

                    memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));

                apply_mid_side_stereo(cpe);

            }

            adjust_frame_information(cpe, chans);

            if (s->options.ltp) { 

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

                    sce = &cpe->ch[ch];

                    s->cur_channel = start_ch + ch;

                    if (s->coder->search_for_ltp)

                        s->coder->search_for_ltp(s, sce, cpe->common_window);

                    if (sce->ics.ltp.present) pred_mode = 1;

                }

                s->cur_channel = start_ch;

                if (s->coder->adjust_common_ltp)

                    s->coder->adjust_common_ltp(s, cpe);

            }

            if (chans == 2) {

                put_bits(&s->pb, 1, cpe->common_window);

                if (cpe->common_window) {

                    put_ics_info(s, &cpe->ch[0].ics);

                    if (s->coder->encode_main_pred)

                        s->coder->encode_main_pred(s, &cpe->ch[0]);

                    if (s->coder->encode_ltp_info)

                        s->coder->encode_ltp_info(s, &cpe->ch[0], 1);

                    encode_ms_info(&s->pb, cpe);

                    if (cpe->ms_mode) ms_mode = 1;

                }

            }

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

                s->cur_channel = start_ch + ch;

                encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);

            }

            start_ch += chans;

        }



        if (avctx->flags & CODEC_FLAG_QSCALE) {

            

            break;

        }



        







        frame_bits = put_bits_count(&s->pb);

        rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;

        rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);

        too_many_bits = FFMAX(target_bits, rate_bits);

        too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);

        too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);



        

        too_few_bits = too_few_bits - too_few_bits/8;

        too_many_bits = too_many_bits + too_many_bits/2;



        if (   its == 0 

            || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))

            || frame_bits >= 6144 * s->channels - 3  )

        {

            float ratio = ((float)rate_bits) / frame_bits;



            if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {

                











                ratio = sqrtf(sqrtf(ratio));

                ratio = av_clipf(ratio, 0.9f, 1.1f);

            } else {

                

                ratio = sqrtf(ratio);

            }

            s->lambda = FFMIN(s->lambda * ratio, 65536.f);



            

            if (ratio > 0.9f && ratio < 1.1f) {

                break;

            } else {

                if (is_mode || ms_mode || tns_mode || pred_mode) {

                    for (i = 0; i < s->chan_map[0]; i++) {

                        

                        chans = tag == TYPE_CPE ? 2 : 1;

                        cpe = &s->cpe[i];

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

                            memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));

                    }

                }

                its++;

            }

        } else {

            break;

        }

    } while (1);



    if (s->options.ltp && s->coder->ltp_insert_new_frame)

        s->coder->ltp_insert_new_frame(s);



    put_bits(&s->pb, 3, TYPE_END);

    flush_put_bits(&s->pb);



    s->last_frame_pb_count = put_bits_count(&s->pb);



    s->lambda_sum += s->lambda;

    s->lambda_count++;



    if (!frame)

        s->last_frame++;



    ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,

                       &avpkt->duration);



    avpkt->size = put_bits_count(&s->pb) >> 3;

    *got_packet_ptr = 1;

    return 0;

}

static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,

                            const AVFrame *VAR_2, int *VAR_3)

{

    AACEncContext *s = VAR_0->priv_data;

    float **VAR_4 = s->planar_samples, *VAR_5, *VAR_6, *VAR_7;

    ChannelElement *cpe;

    SingleChannelElement *sce;

    IndividualChannelStream *ics;

    int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16;

    int VAR_17, VAR_18, VAR_19, VAR_20;

    int VAR_21 = 0, VAR_22 = 0, VAR_23 = 0, VAR_24 = 0;

    int VAR_25[4];

    FFPsyWindowInfo windows[AAC_MAX_CHANNELS];



    if (s->last_frame == 2)

        return 0;



    

    if (VAR_2) {

        if ((VAR_15 = ff_af_queue_add(&s->afq, VAR_2)) < 0)

            return VAR_15;

    }



    copy_input_samples(s, VAR_2);

    if (s->psypp)

        ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);



    if (!VAR_0->frame_number)

        return 0;



    VAR_14 = 0;

    for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {

        FFPsyWindowInfo* wi = windows + VAR_14;

        VAR_13      = s->chan_map[VAR_8+1];

        VAR_12    = VAR_13 == TYPE_CPE ? 2 : 1;

        cpe      = &s->cpe[VAR_8];

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

            float clip_avoidance_factor;

            sce = &cpe->VAR_10[VAR_10];

            ics = &sce->ics;

            s->cur_channel = VAR_14 + VAR_10;

            VAR_7  = &VAR_4[s->cur_channel][0];

            VAR_5 = VAR_7 + 1024;

            VAR_6       = VAR_5 + (448+64);

            if (!VAR_2)

                VAR_6 = NULL;

            if (VAR_13 == TYPE_LFE) {

                wi[VAR_10].window_type[0] = ONLY_LONG_SEQUENCE;

                wi[VAR_10].window_shape   = 0;

                wi[VAR_10].num_windows    = 1;

                wi[VAR_10].grouping[0]    = 1;



                







                ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;

            } else {

                wi[VAR_10] = s->psy.model->window(&s->psy, VAR_5, VAR_6, s->cur_channel,

                                              ics->window_sequence[0]);

            }

            ics->window_sequence[1] = ics->window_sequence[0];

            ics->window_sequence[0] = wi[VAR_10].window_type[0];

            ics->use_kb_window[1]   = ics->use_kb_window[0];

            ics->use_kb_window[0]   = wi[VAR_10].window_shape;

            ics->num_windows        = wi[VAR_10].num_windows;

            ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];

            ics->num_swb            = VAR_13 == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];

            ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb);

            ics->swb_offset         = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_swb_offset_128 [s->samplerate_index]:

                                        ff_swb_offset_1024[s->samplerate_index];

            ics->tns_max_bands      = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?

                                        ff_tns_max_bands_128 [s->samplerate_index]:

                                        ff_tns_max_bands_1024[s->samplerate_index];

            clip_avoidance_factor = 0.0f;

            for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++)

                ics->group_len[VAR_11] = wi[VAR_10].grouping[VAR_11];

            for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++) {

                if (wi[VAR_10].clipping[VAR_11] > CLIP_AVOIDANCE_FACTOR) {

                    ics->window_clipping[VAR_11] = 1;

                    clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[VAR_10].clipping[VAR_11]);

                } else {

                    ics->window_clipping[VAR_11] = 0;

                }

            }

            if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {

                ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;

            } else {

                ics->clip_avoidance_factor = 1.0f;

            }



            apply_window_and_mdct(s, sce, VAR_7);



            if (s->options.ltp && s->coder->update_ltp) {

                s->coder->update_ltp(s, sce);

                apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);

                s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);

            }



            if (isnan(cpe->VAR_10->coeffs[0])) {

                av_log(VAR_0, AV_LOG_ERROR, "Input contains NaN\n");

                return AVERROR(EINVAL);

            }

            avoid_clipping(s, sce);

        }

        VAR_14 += VAR_12;

    }

    if ((VAR_15 = ff_alloc_packet2(VAR_0, VAR_1, 8192 * s->channels, 0)) < 0)

        return VAR_15;

    VAR_16 = VAR_9 = 0;

    do {

        init_put_bits(&s->pb, VAR_1->data, VAR_1->size);



        if ((VAR_0->frame_number & 0xFF)==1 && !(VAR_0->flags & AV_CODEC_FLAG_BITEXACT))

            put_bitstream_info(s, LIBAVCODEC_IDENT);

        VAR_14 = 0;

        VAR_17 = 0;

        memset(VAR_25, 0, sizeof(VAR_25));

        for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {

            FFPsyWindowInfo* wi = windows + VAR_14;

            const float *coeffs[2];

            VAR_13      = s->chan_map[VAR_8+1];

            VAR_12    = VAR_13 == TYPE_CPE ? 2 : 1;

            cpe      = &s->cpe[VAR_8];

            cpe->common_window = 0;

            memset(cpe->is_mask, 0, sizeof(cpe->is_mask));

            memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));

            put_bits(&s->pb, 3, VAR_13);

            put_bits(&s->pb, 4, VAR_25[VAR_13]++);

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

                sce = &cpe->VAR_10[VAR_10];

                coeffs[VAR_10] = sce->coeffs;

                sce->ics.predictor_present = 0;

                sce->ics.ltp.present = 0;

                memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));

                memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));

                memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));

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

                    if (sce->band_type[VAR_11] > RESERVED_BT)

                        sce->band_type[VAR_11] = 0;

            }

            s->psy.bitres.alloc = -1;

            s->psy.bitres.bits = s->last_frame_pb_count / s->channels;

            s->psy.model->analyze(&s->psy, VAR_14, coeffs, wi);

            if (s->psy.bitres.alloc > 0) {

                

                VAR_17 += s->psy.bitres.alloc

                    * (s->lambda / (VAR_0->global_quality ? VAR_0->global_quality : 120));

                s->psy.bitres.alloc /= VAR_12;

            }

            s->cur_type = VAR_13;

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

                s->cur_channel = VAR_14 + VAR_10;

                if (s->options.pns && s->coder->mark_pns)

                    s->coder->mark_pns(s, VAR_0, &cpe->VAR_10[VAR_10]);

                s->coder->search_for_quantizers(VAR_0, s, &cpe->VAR_10[VAR_10], s->lambda);

            }

            if (VAR_12 > 1

                && wi[0].window_type[0] == wi[1].window_type[0]

                && wi[0].window_shape   == wi[1].window_shape) {



                cpe->common_window = 1;

                for (VAR_11 = 0; VAR_11 < wi[0].num_windows; VAR_11++) {

                    if (wi[0].grouping[VAR_11] != wi[1].grouping[VAR_11]) {

                        cpe->common_window = 0;

                        break;

                    }

                }

            }

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

                sce = &cpe->VAR_10[VAR_10];

                s->cur_channel = VAR_14 + VAR_10;

                if (s->options.tns && s->coder->search_for_tns)

                    s->coder->search_for_tns(s, sce);

                if (s->options.tns && s->coder->apply_tns_filt)

                    s->coder->apply_tns_filt(s, sce);

                if (sce->tns.present)

                    VAR_23 = 1;

                if (s->options.pns && s->coder->search_for_pns)

                    s->coder->search_for_pns(s, VAR_0, sce);

            }

            s->cur_channel = VAR_14;

            if (s->options.intensity_stereo) { 

                if (s->coder->search_for_is)

                    s->coder->search_for_is(s, VAR_0, cpe);

                if (cpe->VAR_22) VAR_22 = 1;

                apply_intensity_stereo(cpe);

            }

            if (s->options.pred) { 

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

                    sce = &cpe->VAR_10[VAR_10];

                    s->cur_channel = VAR_14 + VAR_10;

                    if (s->options.pred && s->coder->search_for_pred)

                        s->coder->search_for_pred(s, sce);

                    if (cpe->VAR_10[VAR_10].ics.predictor_present) VAR_24 = 1;

                }

                if (s->coder->adjust_common_pred)

                    s->coder->adjust_common_pred(s, cpe);

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

                    sce = &cpe->VAR_10[VAR_10];

                    s->cur_channel = VAR_14 + VAR_10;

                    if (s->options.pred && s->coder->apply_main_pred)

                        s->coder->apply_main_pred(s, sce);

                }

                s->cur_channel = VAR_14;

            }

            if (s->options.mid_side) { 

                if (s->options.mid_side == -1 && s->coder->search_for_ms)

                    s->coder->search_for_ms(s, cpe);

                else if (cpe->common_window)

                    memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));

                apply_mid_side_stereo(cpe);

            }

            adjust_frame_information(cpe, VAR_12);

            if (s->options.ltp) { 

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

                    sce = &cpe->VAR_10[VAR_10];

                    s->cur_channel = VAR_14 + VAR_10;

                    if (s->coder->search_for_ltp)

                        s->coder->search_for_ltp(s, sce, cpe->common_window);

                    if (sce->ics.ltp.present) VAR_24 = 1;

                }

                s->cur_channel = VAR_14;

                if (s->coder->adjust_common_ltp)

                    s->coder->adjust_common_ltp(s, cpe);

            }

            if (VAR_12 == 2) {

                put_bits(&s->pb, 1, cpe->common_window);

                if (cpe->common_window) {

                    put_ics_info(s, &cpe->VAR_10[0].ics);

                    if (s->coder->encode_main_pred)

                        s->coder->encode_main_pred(s, &cpe->VAR_10[0]);

                    if (s->coder->encode_ltp_info)

                        s->coder->encode_ltp_info(s, &cpe->VAR_10[0], 1);

                    encode_ms_info(&s->pb, cpe);

                    if (cpe->VAR_21) VAR_21 = 1;

                }

            }

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

                s->cur_channel = VAR_14 + VAR_10;

                encode_individual_channel(VAR_0, s, &cpe->VAR_10[VAR_10], cpe->common_window);

            }

            VAR_14 += VAR_12;

        }



        if (VAR_0->flags & CODEC_FLAG_QSCALE) {

            

            break;

        }



        







        VAR_16 = put_bits_count(&s->pb);

        VAR_18 = VAR_0->bit_rate * 1024 / VAR_0->sample_rate;

        VAR_18 = FFMIN(VAR_18, 6144 * s->channels - 3);

        VAR_19 = FFMAX(VAR_17, VAR_18);

        VAR_19 = FFMIN(VAR_19, 6144 * s->channels - 3);

        VAR_20 = FFMIN(FFMAX(VAR_18 - VAR_18/4, VAR_17), VAR_19);



        

        VAR_20 = VAR_20 - VAR_20/8;

        VAR_19 = VAR_19 + VAR_19/2;



        if (   VAR_9 == 0 

            || (VAR_9 < 5 && (VAR_16 < VAR_20 || VAR_16 > VAR_19))

            || VAR_16 >= 6144 * s->channels - 3  )

        {

            float VAR_26 = ((float)VAR_18) / VAR_16;



            if (VAR_16 >= VAR_20 && VAR_16 <= VAR_19) {

                











                VAR_26 = sqrtf(sqrtf(VAR_26));

                VAR_26 = av_clipf(VAR_26, 0.9f, 1.1f);

            } else {

                

                VAR_26 = sqrtf(VAR_26);

            }

            s->lambda = FFMIN(s->lambda * VAR_26, 65536.f);



            

            if (VAR_26 > 0.9f && VAR_26 < 1.1f) {

                break;

            } else {

                if (VAR_22 || VAR_21 || VAR_23 || VAR_24) {

                    for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) {

                        

                        VAR_12 = VAR_13 == TYPE_CPE ? 2 : 1;

                        cpe = &s->cpe[VAR_8];

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

                            memcpy(cpe->VAR_10[VAR_10].coeffs, cpe->VAR_10[VAR_10].pcoeffs, sizeof(cpe->VAR_10[VAR_10].coeffs));

                    }

                }

                VAR_9++;

            }

        } else {

            break;

        }

    } while (1);



    if (s->options.ltp && s->coder->ltp_insert_new_frame)

        s->coder->ltp_insert_new_frame(s);



    put_bits(&s->pb, 3, TYPE_END);

    flush_put_bits(&s->pb);



    s->last_frame_pb_count = put_bits_count(&s->pb);



    s->lambda_sum += s->lambda;

    s->lambda_count++;



    if (!VAR_2)

        s->last_frame++;



    ff_af_queue_remove(&s->afq, VAR_0->frame_size, &VAR_1->pts,

                       &VAR_1->duration);



    VAR_1->size = put_bits_count(&s->pb) >> 3;

    *VAR_3 = 1;

    return 0;

}

static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,
const AVFrame *VAR_2, int *VAR_3)
{ AACEncContext *s = VAR_0->priv_data; float **VAR_4 = s->planar_samples, *VAR_5, *VAR_6, *VAR_7; ChannelElement *cpe; SingleChannelElement *sce; IndividualChannelStream *ics; int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16; int VAR_17, VAR_18, VAR_19, VAR_20; int VAR_21 = 0, VAR_22 = 0, VAR_23 = 0, VAR_24 = 0; int VAR_25[4]; FFPsyWindowInfo windows[AAC_MAX_CHANNELS]; if (s->last_frame == 2)
return 0; if (VAR_2) { if ((VAR_15 = ff_af_queue_add(&s->afq, VAR_2)) < 0)
return VAR_15; } copy_input_samples(s, VAR_2); if (s->psypp)
ff_psy_preprocess(s->psypp, s->planar_samples, s->channels); if (!VAR_0->frame_number)
return 0; VAR_14 = 0; for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) { FFPsyWindowInfo* wi = windows + VAR_14; VAR_13      = s->chan_map[VAR_8+1]; VAR_12    = VAR_13 == TYPE_CPE ? 2 : 1; cpe      = &s->cpe[VAR_8]; for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { float clip_avoidance_factor; sce = &cpe->VAR_10[VAR_10]; ics = &sce->ics; s->cur_channel = VAR_14 + VAR_10; VAR_7  = &VAR_4[s->cur_channel][0]; VAR_5 = VAR_7 + 1024; VAR_6       = VAR_5 + (448+64); if (!VAR_2)
VAR_6 = NULL; if (VAR_13 == TYPE_LFE) { wi[VAR_10].window_type[0] = ONLY_LONG_SEQUENCE; wi[VAR_10].window_shape   = 0; wi[VAR_10].num_windows    = 1; wi[VAR_10].grouping[0]    = 1; ics->num_swb = s->samplerate_index >= 8 ? 1 : 3; } else { wi[VAR_10] = s->psy.model->window(&s->psy, VAR_5, VAR_6, s->cur_channel,
ics->window_sequence[0]); } ics->window_sequence[1] = ics->window_sequence[0]; ics->window_sequence[0] = wi[VAR_10].window_type[0]; ics->use_kb_window[1]   = ics->use_kb_window[0]; ics->use_kb_window[0]   = wi[VAR_10].window_shape; ics->num_windows        = wi[VAR_10].num_windows; ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8]; ics->num_swb            = VAR_13 == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8]; ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb); ics->swb_offset         = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?
ff_swb_offset_128 [s->samplerate_index]:
ff_swb_offset_1024[s->samplerate_index]; ics->tns_max_bands      = wi[VAR_10].window_type[0] == EIGHT_SHORT_SEQUENCE ?
ff_tns_max_bands_128 [s->samplerate_index]:
ff_tns_max_bands_1024[s->samplerate_index]; clip_avoidance_factor = 0.0f; for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++) ics->group_len[VAR_11] = wi[VAR_10].grouping[VAR_11]; for (VAR_11 = 0; VAR_11 < ics->num_windows; VAR_11++) { if (wi[VAR_10].clipping[VAR_11] > CLIP_AVOIDANCE_FACTOR) { ics->window_clipping[VAR_11] = 1; clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[VAR_10].clipping[VAR_11]); } else { ics->window_clipping[VAR_11] = 0; } } if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) { ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor; } else { ics->clip_avoidance_factor = 1.0f; } apply_window_and_mdct(s, sce, VAR_7); if (s->options.ltp && s->coder->update_ltp) { s->coder->update_ltp(s, sce); apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]); s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf); } if (isnan(cpe->VAR_10->coeffs[0])) { av_log(VAR_0, AV_LOG_ERROR, "Input contains NaN\n"); return AVERROR(EINVAL); } avoid_clipping(s, sce); } VAR_14 += VAR_12; } if ((VAR_15 = ff_alloc_packet2(VAR_0, VAR_1, 8192 * s->channels, 0)) < 0)
return VAR_15; VAR_16 = VAR_9 = 0; do { init_put_bits(&s->pb, VAR_1->data, VAR_1->size); if ((VAR_0->frame_number & 0xFF)==1 && !(VAR_0->flags & AV_CODEC_FLAG_BITEXACT))
put_bitstream_info(s, LIBAVCODEC_IDENT); VAR_14 = 0; VAR_17 = 0; memset(VAR_25, 0, sizeof(VAR_25)); for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) { FFPsyWindowInfo* wi = windows + VAR_14; const float *coeffs[2]; VAR_13      = s->chan_map[VAR_8+1]; VAR_12    = VAR_13 == TYPE_CPE ? 2 : 1; cpe      = &s->cpe[VAR_8]; cpe->common_window = 0; memset(cpe->is_mask, 0, sizeof(cpe->is_mask)); memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask)); put_bits(&s->pb, 3, VAR_13); put_bits(&s->pb, 4, VAR_25[VAR_13]++); for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { sce = &cpe->VAR_10[VAR_10]; coeffs[VAR_10] = sce->coeffs; sce->ics.predictor_present = 0; sce->ics.ltp.present = 0; memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used)); memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used)); memset(&sce->tns, 0, sizeof(TemporalNoiseShaping)); for (VAR_11 = 0; VAR_11 < 128; VAR_11++) if (sce->band_type[VAR_11] > RESERVED_BT)
sce->band_type[VAR_11] = 0; } s->psy.bitres.alloc = -1; s->psy.bitres.bits = s->last_frame_pb_count / s->channels; s->psy.model->analyze(&s->psy, VAR_14, coeffs, wi); if (s->psy.bitres.alloc > 0) { VAR_17 += s->psy.bitres.alloc
* (s->lambda / (VAR_0->global_quality ? VAR_0->global_quality : 120)); s->psy.bitres.alloc /= VAR_12; } s->cur_type = VAR_13; for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { s->cur_channel = VAR_14 + VAR_10; if (s->options.pns && s->coder->mark_pns)
s->coder->mark_pns(s, VAR_0, &cpe->VAR_10[VAR_10]); s->coder->search_for_quantizers(VAR_0, s, &cpe->VAR_10[VAR_10], s->lambda); } if (VAR_12 > 1
&& wi[0].window_type[0] == wi[1].window_type[0]
&& wi[0].window_shape   == wi[1].window_shape) { cpe->common_window = 1; for (VAR_11 = 0; VAR_11 < wi[0].num_windows; VAR_11++) { if (wi[0].grouping[VAR_11] != wi[1].grouping[VAR_11]) { cpe->common_window = 0; break; } } } for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { sce = &cpe->VAR_10[VAR_10]; s->cur_channel = VAR_14 + VAR_10; if (s->options.tns && s->coder->search_for_tns)
s->coder->search_for_tns(s, sce); if (s->options.tns && s->coder->apply_tns_filt)
s->coder->apply_tns_filt(s, sce); if (sce->tns.present)
VAR_23 = 1; if (s->options.pns && s->coder->search_for_pns)
s->coder->search_for_pns(s, VAR_0, sce); } s->cur_channel = VAR_14; if (s->options.intensity_stereo) { if (s->coder->search_for_is)
s->coder->search_for_is(s, VAR_0, cpe); if (cpe->VAR_22) VAR_22 = 1; apply_intensity_stereo(cpe); } if (s->options.pred) { for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { sce = &cpe->VAR_10[VAR_10]; s->cur_channel = VAR_14 + VAR_10; if (s->options.pred && s->coder->search_for_pred)
s->coder->search_for_pred(s, sce); if (cpe->VAR_10[VAR_10].ics.predictor_present) VAR_24 = 1; } if (s->coder->adjust_common_pred)
s->coder->adjust_common_pred(s, cpe); for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { sce = &cpe->VAR_10[VAR_10]; s->cur_channel = VAR_14 + VAR_10; if (s->options.pred && s->coder->apply_main_pred)
s->coder->apply_main_pred(s, sce); } s->cur_channel = VAR_14; } if (s->options.mid_side) { if (s->options.mid_side == -1 && s->coder->search_for_ms)
s->coder->search_for_ms(s, cpe); else if (cpe->common_window)
memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask)); apply_mid_side_stereo(cpe); } adjust_frame_information(cpe, VAR_12); if (s->options.ltp) { for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { sce = &cpe->VAR_10[VAR_10]; s->cur_channel = VAR_14 + VAR_10; if (s->coder->search_for_ltp)
s->coder->search_for_ltp(s, sce, cpe->common_window); if (sce->ics.ltp.present) VAR_24 = 1; } s->cur_channel = VAR_14; if (s->coder->adjust_common_ltp)
s->coder->adjust_common_ltp(s, cpe); } if (VAR_12 == 2) { put_bits(&s->pb, 1, cpe->common_window); if (cpe->common_window) { put_ics_info(s, &cpe->VAR_10[0].ics); if (s->coder->encode_main_pred)
s->coder->encode_main_pred(s, &cpe->VAR_10[0]); if (s->coder->encode_ltp_info)
s->coder->encode_ltp_info(s, &cpe->VAR_10[0], 1); encode_ms_info(&s->pb, cpe); if (cpe->VAR_21) VAR_21 = 1; } } for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { s->cur_channel = VAR_14 + VAR_10; encode_individual_channel(VAR_0, s, &cpe->VAR_10[VAR_10], cpe->common_window); } VAR_14 += VAR_12; } if (VAR_0->flags & CODEC_FLAG_QSCALE) { break; } VAR_16 = put_bits_count(&s->pb); VAR_18 = VAR_0->bit_rate * 1024 / VAR_0->sample_rate; VAR_18 = FFMIN(VAR_18, 6144 * s->channels - 3); VAR_19 = FFMAX(VAR_17, VAR_18); VAR_19 = FFMIN(VAR_19, 6144 * s->channels - 3); VAR_20 = FFMIN(FFMAX(VAR_18 - VAR_18/4, VAR_17), VAR_19); VAR_20 = VAR_20 - VAR_20/8; VAR_19 = VAR_19 + VAR_19/2; if (   VAR_9 == 0
|| (VAR_9 < 5 && (VAR_16 < VAR_20 || VAR_16 > VAR_19))
|| VAR_16 >= 6144 * s->channels - 3  )
{ float VAR_26 = ((float)VAR_18) / VAR_16; if (VAR_16 >= VAR_20 && VAR_16 <= VAR_19) { VAR_26 = sqrtf(sqrtf(VAR_26)); VAR_26 = av_clipf(VAR_26, 0.9f, 1.1f); } else { VAR_26 = sqrtf(VAR_26); } s->lambda = FFMIN(s->lambda * VAR_26, 65536.f); if (VAR_26 > 0.9f && VAR_26 < 1.1f) { break; } else { if (VAR_22 || VAR_21 || VAR_23 || VAR_24) { for (VAR_8 = 0; VAR_8 < s->chan_map[0]; VAR_8++) { VAR_12 = VAR_13 == TYPE_CPE ? 2 : 1; cpe = &s->cpe[VAR_8]; for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) memcpy(cpe->VAR_10[VAR_10].coeffs, cpe->VAR_10[VAR_10].pcoeffs, sizeof(cpe->VAR_10[VAR_10].coeffs)); } } VAR_9++; } } else { break; } } while (1); if (s->options.ltp && s->coder->ltp_insert_new_frame)
s->coder->ltp_insert_new_frame(s); put_bits(&s->pb, 3, TYPE_END); flush_put_bits(&s->pb); s->last_frame_pb_count = put_bits_count(&s->pb); s->lambda_sum += s->lambda; s->lambda_count++; if (!VAR_2)
s->last_frame++; ff_af_queue_remove(&s->afq, VAR_0->frame_size, &VAR_1->pts,
&VAR_1->duration); VAR_1->size = put_bits_count(&s->pb) >> 3; *VAR_3 = 1; return 0; }