LCOV - code coverage report
Current view: top level - src/libavcodec - aacenc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 579 615 94.1 %
Date: 2017-01-28 02:43:52 Functions: 26 26 100.0 %

          Line data    Source code
       1             : /*
       2             :  * AAC encoder
       3             :  * Copyright (C) 2008 Konstantin Shishkov
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * AAC encoder
      25             :  */
      26             : 
      27             : /***********************************
      28             :  *              TODOs:
      29             :  * add sane pulse detection
      30             :  ***********************************/
      31             : 
      32             : #include "libavutil/libm.h"
      33             : #include "libavutil/thread.h"
      34             : #include "libavutil/float_dsp.h"
      35             : #include "libavutil/opt.h"
      36             : #include "avcodec.h"
      37             : #include "put_bits.h"
      38             : #include "internal.h"
      39             : #include "mpeg4audio.h"
      40             : #include "kbdwin.h"
      41             : #include "sinewin.h"
      42             : 
      43             : #include "aac.h"
      44             : #include "aactab.h"
      45             : #include "aacenc.h"
      46             : #include "aacenctab.h"
      47             : #include "aacenc_utils.h"
      48             : 
      49             : #include "psymodel.h"
      50             : 
      51             : static AVOnce aac_table_init = AV_ONCE_INIT;
      52             : 
      53             : /**
      54             :  * Make AAC audio config object.
      55             :  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
      56             :  */
      57          12 : static void put_audio_specific_config(AVCodecContext *avctx)
      58             : {
      59             :     PutBitContext pb;
      60          12 :     AACEncContext *s = avctx->priv_data;
      61          12 :     int channels = s->channels - (s->channels == 8 ? 1 : 0);
      62             : 
      63          12 :     init_put_bits(&pb, avctx->extradata, avctx->extradata_size);
      64          12 :     put_bits(&pb, 5, s->profile+1); //profile
      65          12 :     put_bits(&pb, 4, s->samplerate_index); //sample rate index
      66          12 :     put_bits(&pb, 4, channels);
      67             :     //GASpecificConfig
      68          12 :     put_bits(&pb, 1, 0); //frame length - 1024 samples
      69          12 :     put_bits(&pb, 1, 0); //does not depend on core coder
      70          12 :     put_bits(&pb, 1, 0); //is not extension
      71             : 
      72             :     //Explicitly Mark SBR absent
      73          12 :     put_bits(&pb, 11, 0x2b7); //sync extension
      74          12 :     put_bits(&pb, 5,  AOT_SBR);
      75          12 :     put_bits(&pb, 1,  0);
      76          12 :     flush_put_bits(&pb);
      77          12 : }
      78             : 
      79       12020 : void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
      80             : {
      81       12020 :     ++s->quantize_band_cost_cache_generation;
      82       12020 :     if (s->quantize_band_cost_cache_generation == 0) {
      83           0 :         memset(s->quantize_band_cost_cache, 0, sizeof(s->quantize_band_cost_cache));
      84           0 :         s->quantize_band_cost_cache_generation = 1;
      85             :     }
      86       12020 : }
      87             : 
      88             : #define WINDOW_FUNC(type) \
      89             : static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
      90             :                                     SingleChannelElement *sce, \
      91             :                                     const float *audio)
      92             : 
      93        8467 : WINDOW_FUNC(only_long)
      94             : {
      95        8467 :     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
      96        8467 :     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
      97        8467 :     float *out = sce->ret_buf;
      98             : 
      99        8467 :     fdsp->vector_fmul        (out,        audio,        lwindow, 1024);
     100        8467 :     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
     101        8467 : }
     102             : 
     103         143 : WINDOW_FUNC(long_start)
     104             : {
     105         143 :     const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
     106         143 :     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
     107         143 :     float *out = sce->ret_buf;
     108             : 
     109         143 :     fdsp->vector_fmul(out, audio, lwindow, 1024);
     110         143 :     memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
     111         143 :     fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
     112         143 :     memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
     113         143 : }
     114             : 
     115         122 : WINDOW_FUNC(long_stop)
     116             : {
     117         122 :     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
     118         122 :     const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
     119         122 :     float *out = sce->ret_buf;
     120             : 
     121         122 :     memset(out, 0, sizeof(out[0]) * 448);
     122         122 :     fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
     123         122 :     memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
     124         122 :     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
     125         122 : }
     126             : 
     127         196 : WINDOW_FUNC(eight_short)
     128             : {
     129         196 :     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
     130         196 :     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
     131         196 :     const float *in = audio + 448;
     132         196 :     float *out = sce->ret_buf;
     133             :     int w;
     134             : 
     135        1764 :     for (w = 0; w < 8; w++) {
     136        1568 :         fdsp->vector_fmul        (out, in, w ? pwindow : swindow, 128);
     137        1568 :         out += 128;
     138        1568 :         in  += 128;
     139        1568 :         fdsp->vector_fmul_reverse(out, in, swindow, 128);
     140        1568 :         out += 128;
     141             :     }
     142         196 : }
     143             : 
     144             : static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
     145             :                                      SingleChannelElement *sce,
     146             :                                      const float *audio) = {
     147             :     [ONLY_LONG_SEQUENCE]   = apply_only_long_window,
     148             :     [LONG_START_SEQUENCE]  = apply_long_start_window,
     149             :     [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
     150             :     [LONG_STOP_SEQUENCE]   = apply_long_stop_window
     151             : };
     152             : 
     153        8106 : static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce,
     154             :                                   float *audio)
     155             : {
     156             :     int i;
     157        8106 :     const float *output = sce->ret_buf;
     158             : 
     159        8106 :     apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
     160             : 
     161        8106 :     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
     162        7926 :         s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
     163             :     else
     164        1620 :         for (i = 0; i < 1024; i += 128)
     165        1440 :             s->mdct128.mdct_calc(&s->mdct128, &sce->coeffs[i], output + i*2);
     166        8106 :     memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
     167        8106 :     memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
     168        8106 : }
     169             : 
     170             : /**
     171             :  * Encode ics_info element.
     172             :  * @see Table 4.6 (syntax of ics_info)
     173             :  */
     174        6715 : static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
     175             : {
     176             :     int w;
     177             : 
     178        6715 :     put_bits(&s->pb, 1, 0);                // ics_reserved bit
     179        6715 :     put_bits(&s->pb, 2, info->window_sequence[0]);
     180        6715 :     put_bits(&s->pb, 1, info->use_kb_window[0]);
     181        6715 :     if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
     182        6499 :         put_bits(&s->pb, 6, info->max_sfb);
     183        6499 :         put_bits(&s->pb, 1, !!info->predictor_present);
     184             :     } else {
     185         216 :         put_bits(&s->pb, 4, info->max_sfb);
     186        1728 :         for (w = 1; w < 8; w++)
     187        1512 :             put_bits(&s->pb, 1, !info->group_len[w]);
     188             :     }
     189        6715 : }
     190             : 
     191             : /**
     192             :  * Encode MS data.
     193             :  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
     194             :  */
     195        5408 : static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
     196             : {
     197             :     int i, w;
     198             : 
     199        5408 :     put_bits(pb, 2, cpe->ms_mode);
     200        5408 :     if (cpe->ms_mode == 1)
     201         690 :         for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
     202       16321 :             for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
     203       15968 :                 put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
     204        5408 : }
     205             : 
     206             : /**
     207             :  * Produce integer coefficients from scalefactors provided by the model.
     208             :  */
     209        6371 : static void adjust_frame_information(ChannelElement *cpe, int chans)
     210             : {
     211             :     int i, w, w2, g, ch;
     212             :     int maxsfb, cmaxsfb;
     213             : 
     214       18494 :     for (ch = 0; ch < chans; ch++) {
     215       12123 :         IndividualChannelStream *ics = &cpe->ch[ch].ics;
     216       12123 :         maxsfb = 0;
     217       12123 :         cpe->ch[ch].pulse.num_pulse = 0;
     218       25022 :         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
     219       27115 :             for (w2 =  0; w2 < ics->group_len[w]; w2++) {
     220       14216 :                 for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
     221             :                     ;
     222       14216 :                 maxsfb = FFMAX(maxsfb, cmaxsfb);
     223             :             }
     224             :         }
     225       12123 :         ics->max_sfb = maxsfb;
     226             : 
     227             :         //adjust zero bands for window groups
     228       25022 :         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
     229      573542 :             for (g = 0; g < ics->max_sfb; g++) {
     230      560643 :                 i = 1;
     231      563497 :                 for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
     232      560873 :                     if (!cpe->ch[ch].zeroes[w2*16 + g]) {
     233      558019 :                         i = 0;
     234      558019 :                         break;
     235             :                     }
     236             :                 }
     237      560643 :                 cpe->ch[ch].zeroes[w*16 + g] = i;
     238             :             }
     239             :         }
     240             :     }
     241             : 
     242        6371 :     if (chans > 1 && cpe->common_window) {
     243        5408 :         IndividualChannelStream *ics0 = &cpe->ch[0].ics;
     244        5408 :         IndividualChannelStream *ics1 = &cpe->ch[1].ics;
     245        5408 :         int msc = 0;
     246        5408 :         ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
     247        5408 :         ics1->max_sfb = ics0->max_sfb;
     248       11397 :         for (w = 0; w < ics0->num_windows*16; w += 16)
     249      259201 :             for (i = 0; i < ics0->max_sfb; i++)
     250      253212 :                 if (cpe->ms_mask[w+i])
     251       23253 :                     msc++;
     252        5408 :         if (msc == 0 || ics0->max_sfb == 0)
     253        4687 :             cpe->ms_mode = 0;
     254             :         else
     255         721 :             cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
     256             :     }
     257        6371 : }
     258             : 
     259        1243 : static void apply_intensity_stereo(ChannelElement *cpe)
     260             : {
     261             :     int w, w2, g, i;
     262        1243 :     IndividualChannelStream *ics = &cpe->ch[0].ics;
     263        1243 :     if (!cpe->common_window)
     264         652 :         return;
     265        1216 :     for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
     266        1314 :         for (w2 =  0; w2 < ics->group_len[w]; w2++) {
     267         689 :             int start = (w+w2) * 128;
     268       30530 :             for (g = 0; g < ics->num_swb; g++) {
     269       29841 :                 int p  = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
     270       29841 :                 float scale = cpe->ch[0].is_ener[w*16+g];
     271       29841 :                 if (!cpe->is_mask[w*16 + g]) {
     272       21423 :                     start += ics->swb_sizes[g];
     273       21423 :                     continue;
     274             :                 }
     275        8418 :                 if (cpe->ms_mask[w*16 + g])
     276        1362 :                     p *= -1;
     277      297066 :                 for (i = 0; i < ics->swb_sizes[g]; i++) {
     278      288648 :                     float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
     279      288648 :                     cpe->ch[0].coeffs[start+i] = sum;
     280      288648 :                     cpe->ch[1].coeffs[start+i] = 0.0f;
     281             :                 }
     282        8418 :                 start += ics->swb_sizes[g];
     283             :             }
     284             :         }
     285             :     }
     286             : }
     287             : 
     288        1046 : static void apply_mid_side_stereo(ChannelElement *cpe)
     289             : {
     290             :     int w, w2, g, i;
     291        1046 :     IndividualChannelStream *ics = &cpe->ch[0].ics;
     292        1046 :     if (!cpe->common_window)
     293         547 :         return;
     294        1032 :     for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
     295        1130 :         for (w2 =  0; w2 < ics->group_len[w]; w2++) {
     296         597 :             int start = (w+w2) * 128;
     297       25930 :             for (g = 0; g < ics->num_swb; g++) {
     298             :                 /* ms_mask can be used for other purposes in PNS and I/S,
     299             :                  * so must not apply M/S if any band uses either, even if
     300             :                  * ms_mask is set.
     301             :                  */
     302       25333 :                 if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
     303       22768 :                     || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
     304       22768 :                     || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
     305        2565 :                     start += ics->swb_sizes[g];
     306        2565 :                     continue;
     307             :                 }
     308      481180 :                 for (i = 0; i < ics->swb_sizes[g]; i++) {
     309      458412 :                     float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
     310      458412 :                     float R = L - cpe->ch[1].coeffs[start+i];
     311      458412 :                     cpe->ch[0].coeffs[start+i] = L;
     312      458412 :                     cpe->ch[1].coeffs[start+i] = R;
     313             :                 }
     314       22768 :                 start += ics->swb_sizes[g];
     315             :             }
     316             :         }
     317             :     }
     318             : }
     319             : 
     320             : /**
     321             :  * Encode scalefactor band coding type.
     322             :  */
     323       12123 : static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
     324             : {
     325             :     int w;
     326             : 
     327       12123 :     if (s->coder->set_special_band_scalefactors)
     328       12123 :         s->coder->set_special_band_scalefactors(s, sce);
     329             : 
     330       25022 :     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
     331       12899 :         s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
     332       12123 : }
     333             : 
     334             : /**
     335             :  * Encode scalefactors.
     336             :  */
     337       12123 : static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
     338             :                                  SingleChannelElement *sce)
     339             : {
     340       12123 :     int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
     341       12123 :     int off_is = 0, noise_flag = 1;
     342             :     int i, w;
     343             : 
     344       25022 :     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
     345      573549 :         for (i = 0; i < sce->ics.max_sfb; i++) {
     346      560650 :             if (!sce->zeroes[w*16 + i]) {
     347      558019 :                 if (sce->band_type[w*16 + i] == NOISE_BT) {
     348       15417 :                     diff = sce->sf_idx[w*16 + i] - off_pns;
     349       15417 :                     off_pns = sce->sf_idx[w*16 + i];
     350       15417 :                     if (noise_flag-- > 0) {
     351        1199 :                         put_bits(&s->pb, NOISE_PRE_BITS, diff + NOISE_PRE);
     352        1199 :                         continue;
     353             :                     }
     354     1078150 :                 } else if (sce->band_type[w*16 + i] == INTENSITY_BT  ||
     355      535548 :                            sce->band_type[w*16 + i] == INTENSITY_BT2) {
     356        8321 :                     diff = sce->sf_idx[w*16 + i] - off_is;
     357        8321 :                     off_is = sce->sf_idx[w*16 + i];
     358             :                 } else {
     359      534281 :                     diff = sce->sf_idx[w*16 + i] - off_sf;
     360      534281 :                     off_sf = sce->sf_idx[w*16 + i];
     361             :                 }
     362      556820 :                 diff += SCALE_DIFF_ZERO;
     363      556820 :                 av_assert0(diff >= 0 && diff <= 120);
     364      556820 :                 put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
     365             :             }
     366             :         }
     367             :     }
     368       12123 : }
     369             : 
     370             : /**
     371             :  * Encode pulse data.
     372             :  */
     373       12123 : static void encode_pulses(AACEncContext *s, Pulse *pulse)
     374             : {
     375             :     int i;
     376             : 
     377       12123 :     put_bits(&s->pb, 1, !!pulse->num_pulse);
     378       12123 :     if (!pulse->num_pulse)
     379       12123 :         return;
     380             : 
     381           0 :     put_bits(&s->pb, 2, pulse->num_pulse - 1);
     382           0 :     put_bits(&s->pb, 6, pulse->start);
     383           0 :     for (i = 0; i < pulse->num_pulse; i++) {
     384           0 :         put_bits(&s->pb, 5, pulse->pos[i]);
     385           0 :         put_bits(&s->pb, 4, pulse->amp[i]);
     386             :     }
     387             : }
     388             : 
     389             : /**
     390             :  * Encode spectral coefficients processed by psychoacoustic model.
     391             :  */
     392       12123 : static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
     393             : {
     394             :     int start, i, w, w2;
     395             : 
     396       25022 :     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
     397       12899 :         start = 0;
     398      573549 :         for (i = 0; i < sce->ics.max_sfb; i++) {
     399      560650 :             if (sce->zeroes[w*16 + i]) {
     400        2631 :                 start += sce->ics.swb_sizes[i];
     401        2631 :                 continue;
     402             :             }
     403     1126396 :             for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
     404     3410262 :                 s->coder->quantize_and_encode_band(s, &s->pb,
     405      568377 :                                                    &sce->coeffs[start + w2*128],
     406      568377 :                                                    NULL, sce->ics.swb_sizes[i],
     407      568377 :                                                    sce->sf_idx[w*16 + i],
     408      568377 :                                                    sce->band_type[w*16 + i],
     409             :                                                    s->lambda,
     410      568377 :                                                    sce->ics.window_clipping[w]);
     411             :             }
     412      558019 :             start += sce->ics.swb_sizes[i];
     413             :         }
     414             :     }
     415       12123 : }
     416             : 
     417             : /**
     418             :  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
     419             :  */
     420        8106 : static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
     421             : {
     422             :     int start, i, j, w;
     423             : 
     424        8106 :     if (sce->ics.clip_avoidance_factor < 1.0f) {
     425         419 :         for (w = 0; w < sce->ics.num_windows; w++) {
     426         241 :             start = 0;
     427        9031 :             for (i = 0; i < sce->ics.max_sfb; i++) {
     428        8790 :                 float *swb_coeffs = &sce->coeffs[start + w*128];
     429      171750 :                 for (j = 0; j < sce->ics.swb_sizes[i]; j++)
     430      162960 :                     swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
     431        8790 :                 start += sce->ics.swb_sizes[i];
     432             :             }
     433             :         }
     434             :     }
     435        8106 : }
     436             : 
     437             : /**
     438             :  * Encode one channel of audio data.
     439             :  */
     440       12123 : static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
     441             :                                      SingleChannelElement *sce,
     442             :                                      int common_window)
     443             : {
     444       12123 :     put_bits(&s->pb, 8, sce->sf_idx[0]);
     445       12123 :     if (!common_window) {
     446        1307 :         put_ics_info(s, &sce->ics);
     447        1307 :         if (s->coder->encode_main_pred)
     448        1307 :             s->coder->encode_main_pred(s, sce);
     449        1307 :         if (s->coder->encode_ltp_info)
     450        1307 :             s->coder->encode_ltp_info(s, sce, 0);
     451             :     }
     452       12123 :     encode_band_info(s, sce);
     453       12123 :     encode_scale_factors(avctx, s, sce);
     454       12123 :     encode_pulses(s, &sce->pulse);
     455       12123 :     put_bits(&s->pb, 1, !!sce->tns.present);
     456       12123 :     if (s->coder->encode_tns_info)
     457       12123 :         s->coder->encode_tns_info(s, sce);
     458       12123 :     put_bits(&s->pb, 1, 0); //ssr
     459       12123 :     encode_spectral_coeffs(s, sce);
     460       12123 :     return 0;
     461             : }
     462             : 
     463             : /**
     464             :  * Write some auxiliary information about the created AAC file.
     465             :  */
     466          22 : static void put_bitstream_info(AACEncContext *s, const char *name)
     467             : {
     468             :     int i, namelen, padbits;
     469             : 
     470          22 :     namelen = strlen(name) + 2;
     471          22 :     put_bits(&s->pb, 3, TYPE_FIL);
     472          22 :     put_bits(&s->pb, 4, FFMIN(namelen, 15));
     473          22 :     if (namelen >= 15)
     474          22 :         put_bits(&s->pb, 8, namelen - 14);
     475          22 :     put_bits(&s->pb, 4, 0); //extension type - filler
     476          22 :     padbits = -put_bits_count(&s->pb) & 7;
     477          22 :     avpriv_align_put_bits(&s->pb);
     478         308 :     for (i = 0; i < namelen - 2; i++)
     479         286 :         put_bits(&s->pb, 8, name[i]);
     480          22 :     put_bits(&s->pb, 12 - padbits, 0);
     481          22 : }
     482             : 
     483             : /*
     484             :  * Copy input samples.
     485             :  * Channels are reordered from libavcodec's default order to AAC order.
     486             :  */
     487        4228 : static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
     488             : {
     489             :     int ch;
     490        4228 :     int end = 2048 + (frame ? frame->nb_samples : 0);
     491        4228 :     const uint8_t *channel_map = aac_chan_maps[s->channels - 1];
     492             : 
     493             :     /* copy and remap input samples */
     494       12361 :     for (ch = 0; ch < s->channels; ch++) {
     495             :         /* copy last 1024 samples of previous frame to the start of the current frame */
     496        8133 :         memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
     497             : 
     498             :         /* copy new samples and zero any remaining samples */
     499        8133 :         if (frame) {
     500       16158 :             memcpy(&s->planar_samples[ch][2048],
     501        8079 :                    frame->extended_data[channel_map[ch]],
     502        8079 :                    frame->nb_samples * sizeof(s->planar_samples[0][0]));
     503             :         }
     504        8133 :         memset(&s->planar_samples[ch][end], 0,
     505        8133 :                (3072 - end) * sizeof(s->planar_samples[0][0]));
     506             :     }
     507        4228 : }
     508             : 
     509        4240 : static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     510             :                             const AVFrame *frame, int *got_packet_ptr)
     511             : {
     512        4240 :     AACEncContext *s = avctx->priv_data;
     513        4240 :     float **samples = s->planar_samples, *samples2, *la, *overlap;
     514             :     ChannelElement *cpe;
     515             :     SingleChannelElement *sce;
     516             :     IndividualChannelStream *ics;
     517             :     int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
     518             :     int target_bits, rate_bits, too_many_bits, too_few_bits;
     519        4240 :     int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
     520             :     int chan_el_counter[4];
     521             :     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
     522             : 
     523             :     /* add current frame to queue */
     524        4240 :     if (frame) {
     525        4204 :         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
     526           0 :             return ret;
     527             :     } else {
     528          36 :         if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
     529          12 :             return 0;
     530             :     }
     531             : 
     532        4228 :     copy_input_samples(s, frame);
     533        4228 :     if (s->psypp)
     534        4228 :         ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
     535             : 
     536        4228 :     if (!avctx->frame_number)
     537          12 :         return 0;
     538             : 
     539        4216 :     start_ch = 0;
     540        8576 :     for (i = 0; i < s->chan_map[0]; i++) {
     541        4360 :         FFPsyWindowInfo* wi = windows + start_ch;
     542        4360 :         tag      = s->chan_map[i+1];
     543        4360 :         chans    = tag == TYPE_CPE ? 2 : 1;
     544        4360 :         cpe      = &s->cpe[i];
     545       12466 :         for (ch = 0; ch < chans; ch++) {
     546             :             int k;
     547             :             float clip_avoidance_factor;
     548        8106 :             sce = &cpe->ch[ch];
     549        8106 :             ics = &sce->ics;
     550        8106 :             s->cur_channel = start_ch + ch;
     551        8106 :             overlap  = &samples[s->cur_channel][0];
     552        8106 :             samples2 = overlap + 1024;
     553        8106 :             la       = samples2 + (448+64);
     554        8106 :             if (!frame)
     555          54 :                 la = NULL;
     556        8106 :             if (tag == TYPE_LFE) {
     557          48 :                 wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
     558          48 :                 wi[ch].window_shape   = 0;
     559          48 :                 wi[ch].num_windows    = 1;
     560          48 :                 wi[ch].grouping[0]    = 1;
     561          48 :                 wi[ch].clipping[0]    = 0;
     562             : 
     563             :                 /* Only the lowest 12 coefficients are used in a LFE channel.
     564             :                  * The expression below results in only the bottom 8 coefficients
     565             :                  * being used for 11.025kHz to 16kHz sample rates.
     566             :                  */
     567          48 :                 ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
     568             :             } else {
     569       16116 :                 wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
     570        8058 :                                               ics->window_sequence[0]);
     571             :             }
     572        8106 :             ics->window_sequence[1] = ics->window_sequence[0];
     573        8106 :             ics->window_sequence[0] = wi[ch].window_type[0];
     574        8106 :             ics->use_kb_window[1]   = ics->use_kb_window[0];
     575        8106 :             ics->use_kb_window[0]   = wi[ch].window_shape;
     576        8106 :             ics->num_windows        = wi[ch].num_windows;
     577        8106 :             ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];
     578        8106 :             ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
     579        8106 :             ics->max_sfb            = FFMIN(ics->max_sfb, ics->num_swb);
     580       16212 :             ics->swb_offset         = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
     581       16032 :                                         ff_swb_offset_128 [s->samplerate_index]:
     582        7926 :                                         ff_swb_offset_1024[s->samplerate_index];
     583       16212 :             ics->tns_max_bands      = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
     584       16032 :                                         ff_tns_max_bands_128 [s->samplerate_index]:
     585        7926 :                                         ff_tns_max_bands_1024[s->samplerate_index];
     586             : 
     587       17472 :             for (w = 0; w < ics->num_windows; w++)
     588        9366 :                 ics->group_len[w] = wi[ch].grouping[w];
     589             : 
     590             :             /* Calculate input sample maximums and evaluate clipping risk */
     591        8106 :             clip_avoidance_factor = 0.0f;
     592       17472 :             for (w = 0; w < ics->num_windows; w++) {
     593        9366 :                 const float *wbuf = overlap + w * 128;
     594        9366 :                 const int wlen = 2048 / ics->num_windows;
     595        9366 :                 float max = 0;
     596             :                 int j;
     597             :                 /* mdct input is 2 * output */
     598    16610454 :                 for (j = 0; j < wlen; j++)
     599    16601088 :                     max = FFMAX(max, fabsf(wbuf[j]));
     600        9366 :                 wi[ch].clipping[w] = max;
     601             :             }
     602       17472 :             for (w = 0; w < ics->num_windows; w++) {
     603        9366 :                 if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
     604         187 :                     ics->window_clipping[w] = 1;
     605         187 :                     clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
     606             :                 } else {
     607        9179 :                     ics->window_clipping[w] = 0;
     608             :                 }
     609             :             }
     610        8106 :             if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
     611         178 :                 ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
     612             :             } else {
     613        7928 :                 ics->clip_avoidance_factor = 1.0f;
     614             :             }
     615             : 
     616        8106 :             apply_window_and_mdct(s, sce, overlap);
     617             : 
     618        8106 :             if (s->options.ltp && s->coder->update_ltp) {
     619         822 :                 s->coder->update_ltp(s, sce);
     620         822 :                 apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
     621         822 :                 s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);
     622             :             }
     623             : 
     624     8308650 :             for (k = 0; k < 1024; k++) {
     625     8300544 :                 if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
     626           0 :                     av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
     627           0 :                     return AVERROR(EINVAL);
     628             :                 }
     629             :             }
     630        8106 :             avoid_clipping(s, sce);
     631             :         }
     632        4360 :         start_ch += chans;
     633             :     }
     634        4216 :     if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels, 0)) < 0)
     635           0 :         return ret;
     636        4216 :     frame_bits = its = 0;
     637             :     do {
     638        8232 :         init_put_bits(&s->pb, avpkt->data, avpkt->size);
     639             : 
     640        6224 :         if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
     641          22 :             put_bitstream_info(s, LIBAVCODEC_IDENT);
     642        6224 :         start_ch = 0;
     643        6224 :         target_bits = 0;
     644        6224 :         memset(chan_el_counter, 0, sizeof(chan_el_counter));
     645       12595 :         for (i = 0; i < s->chan_map[0]; i++) {
     646        6371 :             FFPsyWindowInfo* wi = windows + start_ch;
     647             :             const float *coeffs[2];
     648        6371 :             tag      = s->chan_map[i+1];
     649        6371 :             chans    = tag == TYPE_CPE ? 2 : 1;
     650        6371 :             cpe      = &s->cpe[i];
     651        6371 :             cpe->common_window = 0;
     652        6371 :             memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
     653        6371 :             memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
     654        6371 :             put_bits(&s->pb, 3, tag);
     655        6371 :             put_bits(&s->pb, 4, chan_el_counter[tag]++);
     656       18494 :             for (ch = 0; ch < chans; ch++) {
     657       12123 :                 sce = &cpe->ch[ch];
     658       12123 :                 coeffs[ch] = sce->coeffs;
     659       12123 :                 sce->ics.predictor_present = 0;
     660       12123 :                 sce->ics.ltp.present = 0;
     661       12123 :                 memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
     662       12123 :                 memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
     663       12123 :                 memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
     664     1563867 :                 for (w = 0; w < 128; w++)
     665     1551744 :                     if (sce->band_type[w] > RESERVED_BT)
     666       23717 :                         sce->band_type[w] = 0;
     667             :             }
     668        6371 :             s->psy.bitres.alloc = -1;
     669        6371 :             s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
     670        6371 :             s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
     671        6371 :             if (s->psy.bitres.alloc > 0) {
     672             :                 /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
     673       12742 :                 target_bits += s->psy.bitres.alloc
     674        6371 :                     * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
     675        6371 :                 s->psy.bitres.alloc /= chans;
     676             :             }
     677        6371 :             s->cur_type = tag;
     678       18494 :             for (ch = 0; ch < chans; ch++) {
     679       12123 :                 s->cur_channel = start_ch + ch;
     680       12123 :                 if (s->options.pns && s->coder->mark_pns)
     681        1869 :                     s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
     682       12123 :                 s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
     683             :             }
     684        6371 :             if (chans > 1
     685        5752 :                 && wi[0].window_type[0] == wi[1].window_type[0]
     686        5419 :                 && wi[0].window_shape   == wi[1].window_shape) {
     687             : 
     688        5419 :                 cpe->common_window = 1;
     689       11408 :                 for (w = 0; w < wi[0].num_windows; w++) {
     690        6000 :                     if (wi[0].grouping[w] != wi[1].grouping[w]) {
     691          11 :                         cpe->common_window = 0;
     692          11 :                         break;
     693             :                     }
     694             :                 }
     695             :             }
     696       18494 :             for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
     697       12123 :                 sce = &cpe->ch[ch];
     698       12123 :                 s->cur_channel = start_ch + ch;
     699       12123 :                 if (s->options.tns && s->coder->search_for_tns)
     700        1865 :                     s->coder->search_for_tns(s, sce);
     701       12123 :                 if (s->options.tns && s->coder->apply_tns_filt)
     702        1865 :                     s->coder->apply_tns_filt(s, sce);
     703       12123 :                 if (sce->tns.present)
     704          40 :                     tns_mode = 1;
     705       12123 :                 if (s->options.pns && s->coder->search_for_pns)
     706        1869 :                     s->coder->search_for_pns(s, avctx, sce);
     707             :             }
     708        6371 :             s->cur_channel = start_ch;
     709        6371 :             if (s->options.intensity_stereo) { /* Intensity Stereo */
     710        1243 :                 if (s->coder->search_for_is)
     711        1243 :                     s->coder->search_for_is(s, avctx, cpe);
     712        1243 :                 if (cpe->is_mode) is_mode = 1;
     713        1243 :                 apply_intensity_stereo(cpe);
     714             :             }
     715        6371 :             if (s->options.pred) { /* Prediction */
     716        1248 :                 for (ch = 0; ch < chans; ch++) {
     717         832 :                     sce = &cpe->ch[ch];
     718         832 :                     s->cur_channel = start_ch + ch;
     719         832 :                     if (s->options.pred && s->coder->search_for_pred)
     720         832 :                         s->coder->search_for_pred(s, sce);
     721         832 :                     if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
     722             :                 }
     723         416 :                 if (s->coder->adjust_common_pred)
     724         416 :                     s->coder->adjust_common_pred(s, cpe);
     725        1248 :                 for (ch = 0; ch < chans; ch++) {
     726         832 :                     sce = &cpe->ch[ch];
     727         832 :                     s->cur_channel = start_ch + ch;
     728         832 :                     if (s->options.pred && s->coder->apply_main_pred)
     729         832 :                         s->coder->apply_main_pred(s, sce);
     730             :                 }
     731         416 :                 s->cur_channel = start_ch;
     732             :             }
     733        6371 :             if (s->options.mid_side) { /* Mid/Side stereo */
     734        1046 :                 if (s->options.mid_side == -1 && s->coder->search_for_ms)
     735         630 :                     s->coder->search_for_ms(s, cpe);
     736         416 :                 else if (cpe->common_window)
     737         390 :                     memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
     738        1046 :                 apply_mid_side_stereo(cpe);
     739             :             }
     740        6371 :             adjust_frame_information(cpe, chans);
     741        6371 :             if (s->options.ltp) { /* LTP */
     742        1251 :                 for (ch = 0; ch < chans; ch++) {
     743         834 :                     sce = &cpe->ch[ch];
     744         834 :                     s->cur_channel = start_ch + ch;
     745         834 :                     if (s->coder->search_for_ltp)
     746         834 :                         s->coder->search_for_ltp(s, sce, cpe->common_window);
     747         834 :                     if (sce->ics.ltp.present) pred_mode = 1;
     748             :                 }
     749         417 :                 s->cur_channel = start_ch;
     750         417 :                 if (s->coder->adjust_common_ltp)
     751         417 :                     s->coder->adjust_common_ltp(s, cpe);
     752             :             }
     753        6371 :             if (chans == 2) {
     754        5752 :                 put_bits(&s->pb, 1, cpe->common_window);
     755        5752 :                 if (cpe->common_window) {
     756        5408 :                     put_ics_info(s, &cpe->ch[0].ics);
     757        5408 :                     if (s->coder->encode_main_pred)
     758        5408 :                         s->coder->encode_main_pred(s, &cpe->ch[0]);
     759        5408 :                     if (s->coder->encode_ltp_info)
     760        5408 :                         s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
     761        5408 :                     encode_ms_info(&s->pb, cpe);
     762        5408 :                     if (cpe->ms_mode) ms_mode = 1;
     763             :                 }
     764             :             }
     765       18494 :             for (ch = 0; ch < chans; ch++) {
     766       12123 :                 s->cur_channel = start_ch + ch;
     767       12123 :                 encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
     768             :             }
     769        6371 :             start_ch += chans;
     770             :         }
     771             : 
     772        6224 :         if (avctx->flags & CODEC_FLAG_QSCALE) {
     773             :             /* When using a constant Q-scale, don't mess with lambda */
     774           0 :             break;
     775             :         }
     776             : 
     777             :         /* rate control stuff
     778             :          * allow between the nominal bitrate, and what psy's bit reservoir says to target
     779             :          * but drift towards the nominal bitrate always
     780             :          */
     781        6224 :         frame_bits = put_bits_count(&s->pb);
     782        6224 :         rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
     783        6224 :         rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
     784        6224 :         too_many_bits = FFMAX(target_bits, rate_bits);
     785        6224 :         too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
     786        6224 :         too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
     787             : 
     788             :         /* When using ABR, be strict (but only for increasing) */
     789        6224 :         too_few_bits = too_few_bits - too_few_bits/8;
     790        6224 :         too_many_bits = too_many_bits + too_many_bits/2;
     791             : 
     792        6224 :         if (   its == 0 /* for steady-state Q-scale tracking */
     793        2008 :             || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
     794         408 :             || frame_bits >= 6144 * s->channels - 3  )
     795             :         {
     796        5816 :             float ratio = ((float)rate_bits) / frame_bits;
     797             : 
     798        5816 :             if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
     799             :                 /*
     800             :                  * This path is for steady-state Q-scale tracking
     801             :                  * When frame bits fall within the stable range, we still need to adjust
     802             :                  * lambda to maintain it like so in a stable fashion (large jumps in lambda
     803             :                  * create artifacts and should be avoided), but slowly
     804             :                  */
     805        3243 :                 ratio = sqrtf(sqrtf(ratio));
     806        3243 :                 ratio = av_clipf(ratio, 0.9f, 1.1f);
     807             :             } else {
     808             :                 /* Not so fast though */
     809        2573 :                 ratio = sqrtf(ratio);
     810             :             }
     811        5816 :             s->lambda = FFMIN(s->lambda * ratio, 65536.f);
     812             : 
     813             :             /* Keep iterating if we must reduce and lambda is in the sky */
     814        5816 :             if (ratio > 0.9f && ratio < 1.1f) {
     815             :                 break;
     816             :             } else {
     817        2008 :                 if (is_mode || ms_mode || tns_mode || pred_mode) {
     818          21 :                     for (i = 0; i < s->chan_map[0]; i++) {
     819             :                         // Must restore coeffs
     820          12 :                         chans = tag == TYPE_CPE ? 2 : 1;
     821          12 :                         cpe = &s->cpe[i];
     822          32 :                         for (ch = 0; ch < chans; ch++)
     823          20 :                             memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
     824             :                     }
     825             :                 }
     826        2008 :                 its++;
     827             :             }
     828             :         } else {
     829             :             break;
     830             :         }
     831             :     } while (1);
     832             : 
     833        4216 :     if (s->options.ltp && s->coder->ltp_insert_new_frame)
     834         411 :         s->coder->ltp_insert_new_frame(s);
     835             : 
     836        4216 :     put_bits(&s->pb, 3, TYPE_END);
     837        4216 :     flush_put_bits(&s->pb);
     838             : 
     839        4216 :     s->last_frame_pb_count = put_bits_count(&s->pb);
     840             : 
     841        4216 :     s->lambda_sum += s->lambda;
     842        4216 :     s->lambda_count++;
     843             : 
     844        4216 :     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
     845             :                        &avpkt->duration);
     846             : 
     847        4216 :     avpkt->size = put_bits_count(&s->pb) >> 3;
     848        4216 :     *got_packet_ptr = 1;
     849        4216 :     return 0;
     850             : }
     851             : 
     852          12 : static av_cold int aac_encode_end(AVCodecContext *avctx)
     853             : {
     854          12 :     AACEncContext *s = avctx->priv_data;
     855             : 
     856          12 :     av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_sum / s->lambda_count);
     857             : 
     858          12 :     ff_mdct_end(&s->mdct1024);
     859          12 :     ff_mdct_end(&s->mdct128);
     860          12 :     ff_psy_end(&s->psy);
     861          12 :     ff_lpc_end(&s->lpc);
     862          12 :     if (s->psypp)
     863          12 :         ff_psy_preprocess_end(s->psypp);
     864          12 :     av_freep(&s->buffer.samples);
     865          12 :     av_freep(&s->cpe);
     866          12 :     av_freep(&s->fdsp);
     867          12 :     ff_af_queue_close(&s->afq);
     868          12 :     return 0;
     869             : }
     870             : 
     871          12 : static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
     872             : {
     873          12 :     int ret = 0;
     874             : 
     875          12 :     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
     876          12 :     if (!s->fdsp)
     877           0 :         return AVERROR(ENOMEM);
     878             : 
     879             :     // window init
     880          12 :     ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
     881          12 :     ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
     882          12 :     ff_init_ff_sine_windows(10);
     883          12 :     ff_init_ff_sine_windows(7);
     884             : 
     885          12 :     if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
     886           0 :         return ret;
     887          12 :     if ((ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0)) < 0)
     888           0 :         return ret;
     889             : 
     890          12 :     return 0;
     891             : }
     892             : 
     893          12 : static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
     894             : {
     895             :     int ch;
     896          12 :     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail);
     897          12 :     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail);
     898          12 :     FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + AV_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
     899             : 
     900          39 :     for(ch = 0; ch < s->channels; ch++)
     901          27 :         s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
     902             : 
     903          12 :     return 0;
     904             : alloc_fail:
     905           0 :     return AVERROR(ENOMEM);
     906             : }
     907             : 
     908          12 : static av_cold void aac_encode_init_tables(void)
     909             : {
     910          12 :     ff_aac_tableinit();
     911          12 : }
     912             : 
     913          12 : static av_cold int aac_encode_init(AVCodecContext *avctx)
     914             : {
     915          12 :     AACEncContext *s = avctx->priv_data;
     916          12 :     int i, ret = 0;
     917             :     const uint8_t *sizes[2];
     918             :     uint8_t grouping[AAC_MAX_CHANNELS];
     919             :     int lengths[2];
     920             : 
     921             :     /* Constants */
     922          12 :     s->last_frame_pb_count = 0;
     923          12 :     avctx->extradata_size = 5;
     924          12 :     avctx->frame_size = 1024;
     925          12 :     avctx->initial_padding = 1024;
     926          12 :     s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
     927             : 
     928             :     /* Channel map and unspecified bitrate guessing */
     929          12 :     s->channels = avctx->channels;
     930          12 :     ERROR_IF(s->channels > AAC_MAX_CHANNELS || s->channels == 7,
     931             :              "Unsupported number of channels: %d\n", s->channels);
     932          12 :     s->chan_map = aac_chan_configs[s->channels-1];
     933          12 :     if (!avctx->bit_rate) {
     934           9 :         for (i = 1; i <= s->chan_map[0]; i++) {
     935           9 :             avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
     936           3 :                                s->chan_map[i] == TYPE_LFE ? 16000  : /* LFE  */
     937             :                                                             69000  ; /* SCE  */
     938             :         }
     939             :     }
     940             : 
     941             :     /* Samplerate */
     942          59 :     for (i = 0; i < 16; i++)
     943          59 :         if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
     944          12 :             break;
     945          12 :     s->samplerate_index = i;
     946          12 :     ERROR_IF(s->samplerate_index == 16 ||
     947             :              s->samplerate_index >= ff_aac_swb_size_1024_len ||
     948             :              s->samplerate_index >= ff_aac_swb_size_128_len,
     949             :              "Unsupported sample rate %d\n", avctx->sample_rate);
     950             : 
     951             :     /* Bitrate limiting */
     952          12 :     WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
     953             :              "Too many bits %f > %d per frame requested, clamping to max\n",
     954             :              1024.0 * avctx->bit_rate / avctx->sample_rate,
     955             :              6144 * s->channels);
     956          12 :     avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
     957             :                                      avctx->bit_rate);
     958             : 
     959             :     /* Profile and option setting */
     960          12 :     avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
     961             :                      avctx->profile;
     962          24 :     for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
     963          24 :         if (avctx->profile == aacenc_profiles[i])
     964          12 :             break;
     965          12 :     if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
     966           0 :         avctx->profile = FF_PROFILE_AAC_LOW;
     967           0 :         ERROR_IF(s->options.pred,
     968             :                  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
     969           0 :         ERROR_IF(s->options.ltp,
     970             :                  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
     971           0 :         WARN_IF(s->options.pns,
     972             :                 "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
     973           0 :         s->options.pns = 0;
     974          12 :     } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
     975           1 :         s->options.ltp = 1;
     976           1 :         ERROR_IF(s->options.pred,
     977             :                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
     978          11 :     } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
     979           1 :         s->options.pred = 1;
     980           1 :         ERROR_IF(s->options.ltp,
     981             :                  "LTP prediction unavailable in the \"aac_main\" profile\n");
     982          10 :     } else if (s->options.ltp) {
     983           0 :         avctx->profile = FF_PROFILE_AAC_LTP;
     984           0 :         WARN_IF(1,
     985             :                 "Chainging profile to \"aac_ltp\"\n");
     986           0 :         ERROR_IF(s->options.pred,
     987             :                  "Main prediction unavailable in the \"aac_ltp\" profile\n");
     988          10 :     } else if (s->options.pred) {
     989           0 :         avctx->profile = FF_PROFILE_AAC_MAIN;
     990           0 :         WARN_IF(1,
     991             :                 "Chainging profile to \"aac_main\"\n");
     992           0 :         ERROR_IF(s->options.ltp,
     993             :                  "LTP prediction unavailable in the \"aac_main\" profile\n");
     994             :     }
     995          12 :     s->profile = avctx->profile;
     996             : 
     997             :     /* Coder limitations */
     998          12 :     s->coder = &ff_aac_coders[s->options.coder];
     999          12 :     if (s->options.coder == AAC_CODER_ANMR) {
    1000           0 :         ERROR_IF(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
    1001             :                  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
    1002           0 :         s->options.intensity_stereo = 0;
    1003           0 :         s->options.pns = 0;
    1004             :     }
    1005          12 :     ERROR_IF(s->options.ltp && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL,
    1006             :              "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
    1007             : 
    1008             :     /* M/S introduces horrible artifacts with multichannel files, this is temporary */
    1009          12 :     if (s->channels > 3)
    1010           1 :         s->options.mid_side = 0;
    1011             : 
    1012          12 :     if ((ret = dsp_init(avctx, s)) < 0)
    1013           0 :         goto fail;
    1014             : 
    1015          12 :     if ((ret = alloc_buffers(avctx, s)) < 0)
    1016           0 :         goto fail;
    1017             : 
    1018          12 :     put_audio_specific_config(avctx);
    1019             : 
    1020          12 :     sizes[0]   = ff_aac_swb_size_1024[s->samplerate_index];
    1021          12 :     sizes[1]   = ff_aac_swb_size_128[s->samplerate_index];
    1022          12 :     lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
    1023          12 :     lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
    1024          27 :     for (i = 0; i < s->chan_map[0]; i++)
    1025          15 :         grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
    1026          12 :     if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
    1027          12 :                            s->chan_map[0], grouping)) < 0)
    1028           0 :         goto fail;
    1029          12 :     s->psypp = ff_psy_preprocess_init(avctx);
    1030          12 :     ff_lpc_init(&s->lpc, 2*avctx->frame_size, TNS_MAX_ORDER, FF_LPC_TYPE_LEVINSON);
    1031          12 :     s->random_state = 0x1f2e3d4c;
    1032             : 
    1033          12 :     s->abs_pow34   = abs_pow34_v;
    1034          12 :     s->quant_bands = quantize_bands;
    1035             : 
    1036             :     if (ARCH_X86)
    1037          12 :         ff_aac_dsp_init_x86(s);
    1038             : 
    1039             :     if (HAVE_MIPSDSP)
    1040             :         ff_aac_coder_init_mips(s);
    1041             : 
    1042          12 :     if ((ret = ff_thread_once(&aac_table_init, &aac_encode_init_tables)) != 0)
    1043           0 :         return AVERROR_UNKNOWN;
    1044             : 
    1045          12 :     ff_af_queue_init(avctx, &s->afq);
    1046             : 
    1047          12 :     return 0;
    1048             : fail:
    1049           0 :     aac_encode_end(avctx);
    1050           0 :     return ret;
    1051             : }
    1052             : 
    1053             : #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
    1054             : static const AVOption aacenc_options[] = {
    1055             :     {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "coder"},
    1056             :         {"anmr",     "ANMR method",               0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
    1057             :         {"twoloop",  "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
    1058             :         {"fast",     "Constant quantizer",        0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST},    INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
    1059             :     {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
    1060             :     {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
    1061             :     {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
    1062             :     {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
    1063             :     {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
    1064             :     {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
    1065             :     {NULL}
    1066             : };
    1067             : 
    1068             : static const AVClass aacenc_class = {
    1069             :     "AAC encoder",
    1070             :     av_default_item_name,
    1071             :     aacenc_options,
    1072             :     LIBAVUTIL_VERSION_INT,
    1073             : };
    1074             : 
    1075             : static const AVCodecDefault aac_encode_defaults[] = {
    1076             :     { "b", "0" },
    1077             :     { NULL }
    1078             : };
    1079             : 
    1080             : AVCodec ff_aac_encoder = {
    1081             :     .name           = "aac",
    1082             :     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
    1083             :     .type           = AVMEDIA_TYPE_AUDIO,
    1084             :     .id             = AV_CODEC_ID_AAC,
    1085             :     .priv_data_size = sizeof(AACEncContext),
    1086             :     .init           = aac_encode_init,
    1087             :     .encode2        = aac_encode_frame,
    1088             :     .close          = aac_encode_end,
    1089             :     .defaults       = aac_encode_defaults,
    1090             :     .supported_samplerates = mpeg4audio_sample_rates,
    1091             :     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
    1092             :     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_DELAY,
    1093             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
    1094             :                                                      AV_SAMPLE_FMT_NONE },
    1095             :     .priv_class     = &aacenc_class,
    1096             : };

Generated by: LCOV version 1.12