f7325d49c126e61f1f54e492b1b292d3a8d29dde
[ffmpeg.git] / libavcodec / aacenc.c
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  * add temporal noise shaping
31  ***********************************/
32
33 #include "libavutil/float_dsp.h"
34 #include "libavutil/opt.h"
35 #include "avcodec.h"
36 #include "put_bits.h"
37 #include "internal.h"
38 #include "mpeg4audio.h"
39 #include "kbdwin.h"
40 #include "sinewin.h"
41
42 #include "aac.h"
43 #include "aactab.h"
44 #include "aacenc.h"
45
46 #include "psymodel.h"
47
48 #define AAC_MAX_CHANNELS 6
49
50 #define ERROR_IF(cond, ...) \
51     if (cond) { \
52         av_log(avctx, AV_LOG_ERROR, __VA_ARGS__); \
53         return AVERROR(EINVAL); \
54     }
55
56 #define WARN_IF(cond, ...) \
57     if (cond) { \
58         av_log(avctx, AV_LOG_WARNING, __VA_ARGS__); \
59     }
60
61 float ff_aac_pow34sf_tab[428];
62
63 static const uint8_t swb_size_1024_96[] = {
64     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8,
65     12, 12, 12, 12, 12, 16, 16, 24, 28, 36, 44,
66     64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
67 };
68
69 static const uint8_t swb_size_1024_64[] = {
70     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8,
71     12, 12, 12, 16, 16, 16, 20, 24, 24, 28, 36,
72     40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40
73 };
74
75 static const uint8_t swb_size_1024_48[] = {
76     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
77     12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
78     32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
79     96
80 };
81
82 static const uint8_t swb_size_1024_32[] = {
83     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8,
84     12, 12, 12, 12, 16, 16, 20, 20, 24, 24, 28, 28,
85     32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
86 };
87
88 static const uint8_t swb_size_1024_24[] = {
89     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
90     12, 12, 12, 12, 16, 16, 16, 20, 20, 24, 24, 28, 28,
91     32, 36, 36, 40, 44, 48, 52, 52, 64, 64, 64, 64, 64
92 };
93
94 static const uint8_t swb_size_1024_16[] = {
95     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
96     12, 12, 12, 12, 12, 12, 12, 12, 12, 16, 16, 16, 16, 20, 20, 20, 24, 24, 28, 28,
97     32, 36, 40, 40, 44, 48, 52, 56, 60, 64, 64, 64
98 };
99
100 static const uint8_t swb_size_1024_8[] = {
101     12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
102     16, 16, 16, 16, 16, 16, 16, 20, 20, 20, 20, 24, 24, 24, 28, 28,
103     32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80
104 };
105
106 static const uint8_t *swb_size_1024[] = {
107     swb_size_1024_96, swb_size_1024_96, swb_size_1024_64,
108     swb_size_1024_48, swb_size_1024_48, swb_size_1024_32,
109     swb_size_1024_24, swb_size_1024_24, swb_size_1024_16,
110     swb_size_1024_16, swb_size_1024_16, swb_size_1024_8,
111     swb_size_1024_8
112 };
113
114 static const uint8_t swb_size_128_96[] = {
115     4, 4, 4, 4, 4, 4, 8, 8, 8, 16, 28, 36
116 };
117
118 static const uint8_t swb_size_128_48[] = {
119     4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16
120 };
121
122 static const uint8_t swb_size_128_24[] = {
123     4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 20
124 };
125
126 static const uint8_t swb_size_128_16[] = {
127     4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 12, 12, 16, 20, 20
128 };
129
130 static const uint8_t swb_size_128_8[] = {
131     4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20
132 };
133
134 static const uint8_t *swb_size_128[] = {
135     /* the last entry on the following row is swb_size_128_64 but is a
136        duplicate of swb_size_128_96 */
137     swb_size_128_96, swb_size_128_96, swb_size_128_96,
138     swb_size_128_48, swb_size_128_48, swb_size_128_48,
139     swb_size_128_24, swb_size_128_24, swb_size_128_16,
140     swb_size_128_16, swb_size_128_16, swb_size_128_8,
141     swb_size_128_8
142 };
143
144 /** default channel configurations */
145 static const uint8_t aac_chan_configs[6][5] = {
146  {1, TYPE_SCE},                               // 1 channel  - single channel element
147  {1, TYPE_CPE},                               // 2 channels - channel pair
148  {2, TYPE_SCE, TYPE_CPE},                     // 3 channels - center + stereo
149  {3, TYPE_SCE, TYPE_CPE, TYPE_SCE},           // 4 channels - front center + stereo + back center
150  {3, TYPE_SCE, TYPE_CPE, TYPE_CPE},           // 5 channels - front center + stereo + back stereo
151  {4, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_LFE}, // 6 channels - front center + stereo + back stereo + LFE
152 };
153
154 /**
155  * Table to remap channels from libavcodec's default order to AAC order.
156  */
157 static const uint8_t aac_chan_maps[AAC_MAX_CHANNELS][AAC_MAX_CHANNELS] = {
158     { 0 },
159     { 0, 1 },
160     { 2, 0, 1 },
161     { 2, 0, 1, 3 },
162     { 2, 0, 1, 3, 4 },
163     { 2, 0, 1, 4, 5, 3 },
164 };
165
166 /**
167  * Make AAC audio config object.
168  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
169  */
170 static void put_audio_specific_config(AVCodecContext *avctx)
171 {
172     PutBitContext pb;
173     AACEncContext *s = avctx->priv_data;
174
175     init_put_bits(&pb, avctx->extradata, avctx->extradata_size);
176     put_bits(&pb, 5, 2); //object type - AAC-LC
177     put_bits(&pb, 4, s->samplerate_index); //sample rate index
178     put_bits(&pb, 4, s->channels);
179     //GASpecificConfig
180     put_bits(&pb, 1, 0); //frame length - 1024 samples
181     put_bits(&pb, 1, 0); //does not depend on core coder
182     put_bits(&pb, 1, 0); //is not extension
183
184     //Explicitly Mark SBR absent
185     put_bits(&pb, 11, 0x2b7); //sync extension
186     put_bits(&pb, 5,  AOT_SBR);
187     put_bits(&pb, 1,  0);
188     flush_put_bits(&pb);
189 }
190
191 #define WINDOW_FUNC(type) \
192 static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
193                                     SingleChannelElement *sce, \
194                                     const float *audio)
195
196 WINDOW_FUNC(only_long)
197 {
198     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
199     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
200     float *out = sce->ret_buf;
201
202     fdsp->vector_fmul        (out,        audio,        lwindow, 1024);
203     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
204 }
205
206 WINDOW_FUNC(long_start)
207 {
208     const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
209     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
210     float *out = sce->ret_buf;
211
212     fdsp->vector_fmul(out, audio, lwindow, 1024);
213     memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
214     fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
215     memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
216 }
217
218 WINDOW_FUNC(long_stop)
219 {
220     const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
221     const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
222     float *out = sce->ret_buf;
223
224     memset(out, 0, sizeof(out[0]) * 448);
225     fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
226     memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
227     fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
228 }
229
230 WINDOW_FUNC(eight_short)
231 {
232     const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
233     const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
234     const float *in = audio + 448;
235     float *out = sce->ret_buf;
236     int w;
237
238     for (w = 0; w < 8; w++) {
239         fdsp->vector_fmul        (out, in, w ? pwindow : swindow, 128);
240         out += 128;
241         in  += 128;
242         fdsp->vector_fmul_reverse(out, in, swindow, 128);
243         out += 128;
244     }
245 }
246
247 static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
248                                      SingleChannelElement *sce,
249                                      const float *audio) = {
250     [ONLY_LONG_SEQUENCE]   = apply_only_long_window,
251     [LONG_START_SEQUENCE]  = apply_long_start_window,
252     [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
253     [LONG_STOP_SEQUENCE]   = apply_long_stop_window
254 };
255
256 static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce,
257                                   float *audio)
258 {
259     int i;
260     float *output = sce->ret_buf;
261
262     apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
263
264     if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
265         s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
266     else
267         for (i = 0; i < 1024; i += 128)
268             s->mdct128.mdct_calc(&s->mdct128, sce->coeffs + i, output + i*2);
269     memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
270     memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
271 }
272
273 /**
274  * Encode ics_info element.
275  * @see Table 4.6 (syntax of ics_info)
276  */
277 static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
278 {
279     int w;
280
281     put_bits(&s->pb, 1, 0);                // ics_reserved bit
282     put_bits(&s->pb, 2, info->window_sequence[0]);
283     put_bits(&s->pb, 1, info->use_kb_window[0]);
284     if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
285         put_bits(&s->pb, 6, info->max_sfb);
286         put_bits(&s->pb, 1, 0);            // no prediction
287     } else {
288         put_bits(&s->pb, 4, info->max_sfb);
289         for (w = 1; w < 8; w++)
290             put_bits(&s->pb, 1, !info->group_len[w]);
291     }
292 }
293
294 /**
295  * Encode MS data.
296  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
297  */
298 static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
299 {
300     int i, w;
301
302     put_bits(pb, 2, cpe->ms_mode);
303     if (cpe->ms_mode == 1)
304         for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
305             for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
306                 put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
307 }
308
309 /**
310  * Produce integer coefficients from scalefactors provided by the model.
311  */
312 static void adjust_frame_information(ChannelElement *cpe, int chans)
313 {
314     int i, w, w2, g, ch;
315     int start, maxsfb, cmaxsfb;
316
317     for (ch = 0; ch < chans; ch++) {
318         IndividualChannelStream *ics = &cpe->ch[ch].ics;
319         start = 0;
320         maxsfb = 0;
321         cpe->ch[ch].pulse.num_pulse = 0;
322         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
323             for (w2 = 0; w2 < ics->group_len[w]; w2++) {
324                 start = (w+w2) * 128;
325                 for (g = 0; g < ics->num_swb; g++) {
326                     //apply M/S
327                     if (cpe->common_window && !ch && cpe->ms_mask[w*16 + g]) {
328                         for (i = 0; i < ics->swb_sizes[g]; i++) {
329                             cpe->ch[0].coeffs[start+i] = (cpe->ch[0].pcoeffs[start+i] + cpe->ch[1].pcoeffs[start+i]) * 0.5f;
330                             cpe->ch[1].coeffs[start+i] = cpe->ch[0].coeffs[start+i] - cpe->ch[1].pcoeffs[start+i];
331                         }
332                     }
333                     start += ics->swb_sizes[g];
334                 }
335                 for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
336                     ;
337                 maxsfb = FFMAX(maxsfb, cmaxsfb);
338             }
339         }
340         ics->max_sfb = maxsfb;
341
342         //adjust zero bands for window groups
343         for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
344             for (g = 0; g < ics->max_sfb; g++) {
345                 i = 1;
346                 for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
347                     if (!cpe->ch[ch].zeroes[w2*16 + g]) {
348                         i = 0;
349                         break;
350                     }
351                 }
352                 cpe->ch[ch].zeroes[w*16 + g] = i;
353             }
354         }
355     }
356
357     if (chans > 1 && cpe->common_window) {
358         IndividualChannelStream *ics0 = &cpe->ch[0].ics;
359         IndividualChannelStream *ics1 = &cpe->ch[1].ics;
360         int msc = 0;
361         ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
362         ics1->max_sfb = ics0->max_sfb;
363         for (w = 0; w < ics0->num_windows*16; w += 16)
364             for (i = 0; i < ics0->max_sfb; i++)
365                 if (cpe->ms_mask[w+i])
366                     msc++;
367         if (msc == 0 || ics0->max_sfb == 0)
368             cpe->ms_mode = 0;
369         else
370             cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
371     }
372 }
373
374 /**
375  * Encode scalefactor band coding type.
376  */
377 static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
378 {
379     int w;
380
381     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
382         s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
383 }
384
385 /**
386  * Encode scalefactors.
387  */
388 static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
389                                  SingleChannelElement *sce)
390 {
391     int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
392     int off_is = 0, noise_flag = 1;
393     int i, w;
394
395     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
396         for (i = 0; i < sce->ics.max_sfb; i++) {
397             if (!sce->zeroes[w*16 + i]) {
398                 if (sce->band_type[w*16 + i] == NOISE_BT) {
399                     diff = sce->sf_idx[w*16 + i] - off_pns;
400                     off_pns = sce->sf_idx[w*16 + i];
401                     if (noise_flag-- > 0) {
402                         put_bits(&s->pb, NOISE_PRE_BITS, diff + NOISE_PRE);
403                         continue;
404                     }
405                 } else if (sce->band_type[w*16 + i] == INTENSITY_BT  ||
406                            sce->band_type[w*16 + i] == INTENSITY_BT2) {
407                     diff = sce->sf_idx[w*16 + i] - off_is;
408                     off_is = sce->sf_idx[w*16 + i];
409                 } else {
410                     diff = sce->sf_idx[w*16 + i] - off_sf;
411                     off_sf = sce->sf_idx[w*16 + i];
412                 }
413                 diff += SCALE_DIFF_ZERO;
414                 av_assert0(diff >= 0 && diff <= 120);
415                 put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
416             }
417         }
418     }
419 }
420
421 /**
422  * Encode pulse data.
423  */
424 static void encode_pulses(AACEncContext *s, Pulse *pulse)
425 {
426     int i;
427
428     put_bits(&s->pb, 1, !!pulse->num_pulse);
429     if (!pulse->num_pulse)
430         return;
431
432     put_bits(&s->pb, 2, pulse->num_pulse - 1);
433     put_bits(&s->pb, 6, pulse->start);
434     for (i = 0; i < pulse->num_pulse; i++) {
435         put_bits(&s->pb, 5, pulse->pos[i]);
436         put_bits(&s->pb, 4, pulse->amp[i]);
437     }
438 }
439
440 /**
441  * Encode spectral coefficients processed by psychoacoustic model.
442  */
443 static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
444 {
445     int start, i, w, w2;
446
447     for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
448         start = 0;
449         for (i = 0; i < sce->ics.max_sfb; i++) {
450             if (sce->zeroes[w*16 + i]) {
451                 start += sce->ics.swb_sizes[i];
452                 continue;
453             }
454             for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++)
455                 s->coder->quantize_and_encode_band(s, &s->pb, sce->coeffs + start + w2*128,
456                                                    sce->ics.swb_sizes[i],
457                                                    sce->sf_idx[w*16 + i],
458                                                    sce->band_type[w*16 + i],
459                                                    s->lambda);
460             start += sce->ics.swb_sizes[i];
461         }
462     }
463 }
464
465 /**
466  * Encode one channel of audio data.
467  */
468 static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
469                                      SingleChannelElement *sce,
470                                      int common_window)
471 {
472     put_bits(&s->pb, 8, sce->sf_idx[0]);
473     if (!common_window)
474         put_ics_info(s, &sce->ics);
475     encode_band_info(s, sce);
476     encode_scale_factors(avctx, s, sce);
477     encode_pulses(s, &sce->pulse);
478     put_bits(&s->pb, 1, 0); //tns
479     put_bits(&s->pb, 1, 0); //ssr
480     encode_spectral_coeffs(s, sce);
481     return 0;
482 }
483
484 /**
485  * Write some auxiliary information about the created AAC file.
486  */
487 static void put_bitstream_info(AACEncContext *s, const char *name)
488 {
489     int i, namelen, padbits;
490
491     namelen = strlen(name) + 2;
492     put_bits(&s->pb, 3, TYPE_FIL);
493     put_bits(&s->pb, 4, FFMIN(namelen, 15));
494     if (namelen >= 15)
495         put_bits(&s->pb, 8, namelen - 14);
496     put_bits(&s->pb, 4, 0); //extension type - filler
497     padbits = -put_bits_count(&s->pb) & 7;
498     avpriv_align_put_bits(&s->pb);
499     for (i = 0; i < namelen - 2; i++)
500         put_bits(&s->pb, 8, name[i]);
501     put_bits(&s->pb, 12 - padbits, 0);
502 }
503
504 /*
505  * Copy input samples.
506  * Channels are reordered from libavcodec's default order to AAC order.
507  */
508 static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
509 {
510     int ch;
511     int end = 2048 + (frame ? frame->nb_samples : 0);
512     const uint8_t *channel_map = aac_chan_maps[s->channels - 1];
513
514     /* copy and remap input samples */
515     for (ch = 0; ch < s->channels; ch++) {
516         /* copy last 1024 samples of previous frame to the start of the current frame */
517         memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
518
519         /* copy new samples and zero any remaining samples */
520         if (frame) {
521             memcpy(&s->planar_samples[ch][2048],
522                    frame->extended_data[channel_map[ch]],
523                    frame->nb_samples * sizeof(s->planar_samples[0][0]));
524         }
525         memset(&s->planar_samples[ch][end], 0,
526                (3072 - end) * sizeof(s->planar_samples[0][0]));
527     }
528 }
529
530 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
531                             const AVFrame *frame, int *got_packet_ptr)
532 {
533     AACEncContext *s = avctx->priv_data;
534     float **samples = s->planar_samples, *samples2, *la, *overlap;
535     ChannelElement *cpe;
536     int i, ch, w, g, chans, tag, start_ch, ret, ms_mode = 0;
537     int chan_el_counter[4];
538     FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
539
540     if (s->last_frame == 2)
541         return 0;
542
543     /* add current frame to queue */
544     if (frame) {
545         if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
546             return ret;
547     }
548
549     copy_input_samples(s, frame);
550     if (s->psypp)
551         ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
552
553     if (!avctx->frame_number)
554         return 0;
555
556     start_ch = 0;
557     for (i = 0; i < s->chan_map[0]; i++) {
558         FFPsyWindowInfo* wi = windows + start_ch;
559         tag      = s->chan_map[i+1];
560         chans    = tag == TYPE_CPE ? 2 : 1;
561         cpe      = &s->cpe[i];
562         for (ch = 0; ch < chans; ch++) {
563             IndividualChannelStream *ics = &cpe->ch[ch].ics;
564             int cur_channel = start_ch + ch;
565             overlap  = &samples[cur_channel][0];
566             samples2 = overlap + 1024;
567             la       = samples2 + (448+64);
568             if (!frame)
569                 la = NULL;
570             if (tag == TYPE_LFE) {
571                 wi[ch].window_type[0] = ONLY_LONG_SEQUENCE;
572                 wi[ch].window_shape   = 0;
573                 wi[ch].num_windows    = 1;
574                 wi[ch].grouping[0]    = 1;
575
576                 /* Only the lowest 12 coefficients are used in a LFE channel.
577                  * The expression below results in only the bottom 8 coefficients
578                  * being used for 11.025kHz to 16kHz sample rates.
579                  */
580                 ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
581             } else {
582                 wi[ch] = s->psy.model->window(&s->psy, samples2, la, cur_channel,
583                                               ics->window_sequence[0]);
584             }
585             ics->window_sequence[1] = ics->window_sequence[0];
586             ics->window_sequence[0] = wi[ch].window_type[0];
587             ics->use_kb_window[1]   = ics->use_kb_window[0];
588             ics->use_kb_window[0]   = wi[ch].window_shape;
589             ics->num_windows        = wi[ch].num_windows;
590             ics->swb_sizes          = s->psy.bands    [ics->num_windows == 8];
591             ics->num_swb            = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
592             for (w = 0; w < ics->num_windows; w++)
593                 ics->group_len[w] = wi[ch].grouping[w];
594
595             apply_window_and_mdct(s, &cpe->ch[ch], overlap);
596             if (isnan(cpe->ch->coeffs[0])) {
597                 av_log(avctx, AV_LOG_ERROR, "Input contains NaN\n");
598                 return AVERROR(EINVAL);
599             }
600         }
601         start_ch += chans;
602     }
603     if ((ret = ff_alloc_packet2(avctx, avpkt, 8192 * s->channels)) < 0)
604         return ret;
605     do {
606         int frame_bits;
607
608         init_put_bits(&s->pb, avpkt->data, avpkt->size);
609
610         if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT))
611             put_bitstream_info(s, LIBAVCODEC_IDENT);
612         start_ch = 0;
613         memset(chan_el_counter, 0, sizeof(chan_el_counter));
614         for (i = 0; i < s->chan_map[0]; i++) {
615             FFPsyWindowInfo* wi = windows + start_ch;
616             const float *coeffs[2];
617             tag      = s->chan_map[i+1];
618             chans    = tag == TYPE_CPE ? 2 : 1;
619             cpe      = &s->cpe[i];
620             memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
621             memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
622             put_bits(&s->pb, 3, tag);
623             put_bits(&s->pb, 4, chan_el_counter[tag]++);
624             for (ch = 0; ch < chans; ch++)
625                 coeffs[ch] = cpe->ch[ch].coeffs;
626             s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
627             for (ch = 0; ch < chans; ch++) {
628                 s->cur_channel = start_ch + ch;
629                 s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
630             }
631             cpe->common_window = 0;
632             if (chans > 1
633                 && wi[0].window_type[0] == wi[1].window_type[0]
634                 && wi[0].window_shape   == wi[1].window_shape) {
635
636                 cpe->common_window = 1;
637                 for (w = 0; w < wi[0].num_windows; w++) {
638                     if (wi[0].grouping[w] != wi[1].grouping[w]) {
639                         cpe->common_window = 0;
640                         break;
641                     }
642                 }
643             }
644             if (s->options.pns && s->coder->search_for_pns) {
645                 for (ch = 0; ch < chans; ch++) {
646                     s->cur_channel = start_ch + ch;
647                     s->coder->search_for_pns(s, avctx, &cpe->ch[ch], s->lambda);
648                 }
649             }
650             s->cur_channel = start_ch;
651             if (s->options.stereo_mode && cpe->common_window) {
652                 if (s->options.stereo_mode > 0) {
653                     IndividualChannelStream *ics = &cpe->ch[0].ics;
654                     for (w = 0; w < ics->num_windows; w += ics->group_len[w])
655                         for (g = 0;  g < ics->num_swb; g++)
656                             cpe->ms_mask[w*16+g] = 1;
657                 } else if (s->coder->search_for_ms) {
658                     s->coder->search_for_ms(s, cpe, s->lambda);
659                 }
660             }
661             if (s->coder->set_special_band_scalefactors)
662                 for (ch = 0; ch < chans; ch++)
663                     s->coder->set_special_band_scalefactors(s, &cpe->ch[ch]);
664             adjust_frame_information(cpe, chans);
665             if (chans == 2) {
666                 put_bits(&s->pb, 1, cpe->common_window);
667                 if (cpe->common_window) {
668                     put_ics_info(s, &cpe->ch[0].ics);
669                     encode_ms_info(&s->pb, cpe);
670                     if (cpe->ms_mode) ms_mode = 1;
671                 }
672             }
673             for (ch = 0; ch < chans; ch++) {
674                 s->cur_channel = start_ch + ch;
675                 encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
676             }
677             start_ch += chans;
678         }
679
680         frame_bits = put_bits_count(&s->pb);
681         if (frame_bits <= 6144 * s->channels - 3) {
682             s->psy.bitres.bits = frame_bits / s->channels;
683             break;
684         }
685         if (ms_mode) {
686             for (i = 0; i < s->chan_map[0]; i++) {
687                 // Must restore coeffs
688                 chans = tag == TYPE_CPE ? 2 : 1;
689                 cpe = &s->cpe[i];
690                 for (ch = 0; ch < chans; ch++)
691                     memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
692             }
693         }
694
695         s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits;
696
697     } while (1);
698
699     put_bits(&s->pb, 3, TYPE_END);
700     flush_put_bits(&s->pb);
701     avctx->frame_bits = put_bits_count(&s->pb);
702
703     // rate control stuff
704     if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
705         float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
706         s->lambda *= ratio;
707         s->lambda = FFMIN(s->lambda, 65536.f);
708     }
709
710     if (!frame)
711         s->last_frame++;
712
713     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
714                        &avpkt->duration);
715
716     avpkt->size = put_bits_count(&s->pb) >> 3;
717     *got_packet_ptr = 1;
718     return 0;
719 }
720
721 static av_cold int aac_encode_end(AVCodecContext *avctx)
722 {
723     AACEncContext *s = avctx->priv_data;
724
725     ff_mdct_end(&s->mdct1024);
726     ff_mdct_end(&s->mdct128);
727     ff_psy_end(&s->psy);
728     if (s->psypp)
729         ff_psy_preprocess_end(s->psypp);
730     av_freep(&s->buffer.samples);
731     av_freep(&s->cpe);
732     av_freep(&s->fdsp);
733     ff_af_queue_close(&s->afq);
734     return 0;
735 }
736
737 static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
738 {
739     int ret = 0;
740
741     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
742     if (!s->fdsp)
743         return AVERROR(ENOMEM);
744
745     // window init
746     ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
747     ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
748     ff_init_ff_sine_windows(10);
749     ff_init_ff_sine_windows(7);
750
751     if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
752         return ret;
753     if ((ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0)) < 0)
754         return ret;
755
756     return 0;
757 }
758
759 static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
760 {
761     int ch;
762     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail);
763     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail);
764     FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + FF_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
765
766     for(ch = 0; ch < s->channels; ch++)
767         s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
768
769     return 0;
770 alloc_fail:
771     return AVERROR(ENOMEM);
772 }
773
774 static av_cold int aac_encode_init(AVCodecContext *avctx)
775 {
776     AACEncContext *s = avctx->priv_data;
777     int i, ret = 0;
778     const uint8_t *sizes[2];
779     uint8_t grouping[AAC_MAX_CHANNELS];
780     int lengths[2];
781
782     avctx->frame_size = 1024;
783
784     for (i = 0; i < 16; i++)
785         if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
786             break;
787
788     s->channels = avctx->channels;
789
790     ERROR_IF(i == 16
791                 || i >= (sizeof(swb_size_1024) / sizeof(*swb_size_1024))
792                 || i >= (sizeof(swb_size_128) / sizeof(*swb_size_128)),
793              "Unsupported sample rate %d\n", avctx->sample_rate);
794     ERROR_IF(s->channels > AAC_MAX_CHANNELS,
795              "Unsupported number of channels: %d\n", s->channels);
796     ERROR_IF(avctx->profile != FF_PROFILE_UNKNOWN && avctx->profile != FF_PROFILE_AAC_LOW,
797              "Unsupported profile %d\n", avctx->profile);
798     WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
799              "Too many bits per frame requested, clamping to max\n");
800
801     avctx->bit_rate = (int)FFMIN(
802         6144 * s->channels / 1024.0 * avctx->sample_rate,
803         avctx->bit_rate);
804
805     s->samplerate_index = i;
806
807     s->chan_map = aac_chan_configs[s->channels-1];
808
809     if ((ret = dsp_init(avctx, s)) < 0)
810         goto fail;
811
812     if ((ret = alloc_buffers(avctx, s)) < 0)
813         goto fail;
814
815     avctx->extradata_size = 5;
816     put_audio_specific_config(avctx);
817
818     sizes[0]   = swb_size_1024[i];
819     sizes[1]   = swb_size_128[i];
820     lengths[0] = ff_aac_num_swb_1024[i];
821     lengths[1] = ff_aac_num_swb_128[i];
822     for (i = 0; i < s->chan_map[0]; i++)
823         grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
824     if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
825                            s->chan_map[0], grouping)) < 0)
826         goto fail;
827     s->psypp = ff_psy_preprocess_init(avctx);
828     s->coder = &ff_aac_coders[s->options.aac_coder];
829
830     if (HAVE_MIPSDSPR1)
831         ff_aac_coder_init_mips(s);
832
833     s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
834
835     ff_aac_tableinit();
836
837     for (i = 0; i < 428; i++)
838         ff_aac_pow34sf_tab[i] = sqrt(ff_aac_pow2sf_tab[i] * sqrt(ff_aac_pow2sf_tab[i]));
839
840     avctx->initial_padding = 1024;
841     ff_af_queue_init(avctx, &s->afq);
842
843     return 0;
844 fail:
845     aac_encode_end(avctx);
846     return ret;
847 }
848
849 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
850 static const AVOption aacenc_options[] = {
851     {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), AV_OPT_TYPE_INT, {.i64 = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},
852         {"auto",     "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
853         {"ms_off",   "Disable Mid/Side coding", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
854         {"ms_force", "Force Mid/Side for the whole frame if possible", 0, AV_OPT_TYPE_CONST, {.i64 =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
855     {"aac_coder", "", offsetof(AACEncContext, options.aac_coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "aac_coder"},
856         {"faac",     "FAAC-inspired method",      0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAAC},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
857         {"anmr",     "ANMR method",               0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
858         {"twoloop",  "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
859         {"fast",     "Constant quantizer",        0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
860     {"aac_pns", "Perceptual Noise Substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AACENC_FLAGS, "aac_pns"},
861         {"disable",  "Disable PNS", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_pns"},
862         {"enable",   "Enable PNS (Proof of concept)",  0, AV_OPT_TYPE_CONST, {.i64 =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_pns"},
863     {NULL}
864 };
865
866 static const AVClass aacenc_class = {
867     "AAC encoder",
868     av_default_item_name,
869     aacenc_options,
870     LIBAVUTIL_VERSION_INT,
871 };
872
873 /* duplicated from avpriv_mpeg4audio_sample_rates to avoid shared build
874  * failures */
875 static const int mpeg4audio_sample_rates[16] = {
876     96000, 88200, 64000, 48000, 44100, 32000,
877     24000, 22050, 16000, 12000, 11025, 8000, 7350
878 };
879
880 AVCodec ff_aac_encoder = {
881     .name           = "aac",
882     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
883     .type           = AVMEDIA_TYPE_AUDIO,
884     .id             = AV_CODEC_ID_AAC,
885     .priv_data_size = sizeof(AACEncContext),
886     .init           = aac_encode_init,
887     .encode2        = aac_encode_frame,
888     .close          = aac_encode_end,
889     .supported_samplerates = mpeg4audio_sample_rates,
890     .capabilities   = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY |
891                       CODEC_CAP_EXPERIMENTAL,
892     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
893                                                      AV_SAMPLE_FMT_NONE },
894     .priv_class     = &aacenc_class,
895 };