aacenc: add support for coding of intensity stereo scalefactor indices
[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             put_bits(&s->pb, 3, tag);
621             put_bits(&s->pb, 4, chan_el_counter[tag]++);
622             for (ch = 0; ch < chans; ch++)
623                 coeffs[ch] = cpe->ch[ch].coeffs;
624             s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
625             for (ch = 0; ch < chans; ch++) {
626                 s->cur_channel = start_ch + ch;
627                 s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
628             }
629             cpe->common_window = 0;
630             if (chans > 1
631                 && wi[0].window_type[0] == wi[1].window_type[0]
632                 && wi[0].window_shape   == wi[1].window_shape) {
633
634                 cpe->common_window = 1;
635                 for (w = 0; w < wi[0].num_windows; w++) {
636                     if (wi[0].grouping[w] != wi[1].grouping[w]) {
637                         cpe->common_window = 0;
638                         break;
639                     }
640                 }
641             }
642             s->cur_channel = start_ch;
643             if (s->options.stereo_mode && cpe->common_window) {
644                 if (s->options.stereo_mode > 0) {
645                     IndividualChannelStream *ics = &cpe->ch[0].ics;
646                     for (w = 0; w < ics->num_windows; w += ics->group_len[w])
647                         for (g = 0;  g < ics->num_swb; g++)
648                             cpe->ms_mask[w*16+g] = 1;
649                 } else if (s->coder->search_for_ms) {
650                     s->coder->search_for_ms(s, cpe, s->lambda);
651                 }
652             }
653             adjust_frame_information(cpe, chans);
654             if (chans == 2) {
655                 put_bits(&s->pb, 1, cpe->common_window);
656                 if (cpe->common_window) {
657                     put_ics_info(s, &cpe->ch[0].ics);
658                     encode_ms_info(&s->pb, cpe);
659                     if (cpe->ms_mode) ms_mode = 1;
660                 }
661             }
662             for (ch = 0; ch < chans; ch++) {
663                 s->cur_channel = start_ch + ch;
664                 encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
665             }
666             start_ch += chans;
667         }
668
669         frame_bits = put_bits_count(&s->pb);
670         if (frame_bits <= 6144 * s->channels - 3) {
671             s->psy.bitres.bits = frame_bits / s->channels;
672             break;
673         }
674         if (ms_mode) {
675             for (i = 0; i < s->chan_map[0]; i++) {
676                 // Must restore coeffs
677                 chans = tag == TYPE_CPE ? 2 : 1;
678                 cpe = &s->cpe[i];
679                 for (ch = 0; ch < chans; ch++)
680                     memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
681             }
682         }
683
684         s->lambda *= avctx->bit_rate * 1024.0f / avctx->sample_rate / frame_bits;
685
686     } while (1);
687
688     put_bits(&s->pb, 3, TYPE_END);
689     flush_put_bits(&s->pb);
690     avctx->frame_bits = put_bits_count(&s->pb);
691
692     // rate control stuff
693     if (!(avctx->flags & CODEC_FLAG_QSCALE)) {
694         float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
695         s->lambda *= ratio;
696         s->lambda = FFMIN(s->lambda, 65536.f);
697     }
698
699     if (!frame)
700         s->last_frame++;
701
702     ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
703                        &avpkt->duration);
704
705     avpkt->size = put_bits_count(&s->pb) >> 3;
706     *got_packet_ptr = 1;
707     return 0;
708 }
709
710 static av_cold int aac_encode_end(AVCodecContext *avctx)
711 {
712     AACEncContext *s = avctx->priv_data;
713
714     ff_mdct_end(&s->mdct1024);
715     ff_mdct_end(&s->mdct128);
716     ff_psy_end(&s->psy);
717     if (s->psypp)
718         ff_psy_preprocess_end(s->psypp);
719     av_freep(&s->buffer.samples);
720     av_freep(&s->cpe);
721     av_freep(&s->fdsp);
722     ff_af_queue_close(&s->afq);
723     return 0;
724 }
725
726 static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
727 {
728     int ret = 0;
729
730     s->fdsp = avpriv_float_dsp_alloc(avctx->flags & CODEC_FLAG_BITEXACT);
731     if (!s->fdsp)
732         return AVERROR(ENOMEM);
733
734     // window init
735     ff_kbd_window_init(ff_aac_kbd_long_1024, 4.0, 1024);
736     ff_kbd_window_init(ff_aac_kbd_short_128, 6.0, 128);
737     ff_init_ff_sine_windows(10);
738     ff_init_ff_sine_windows(7);
739
740     if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
741         return ret;
742     if ((ret = ff_mdct_init(&s->mdct128,   8, 0, 32768.0)) < 0)
743         return ret;
744
745     return 0;
746 }
747
748 static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
749 {
750     int ch;
751     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->buffer.samples, s->channels, 3 * 1024 * sizeof(s->buffer.samples[0]), alloc_fail);
752     FF_ALLOCZ_ARRAY_OR_GOTO(avctx, s->cpe, s->chan_map[0], sizeof(ChannelElement), alloc_fail);
753     FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + FF_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
754
755     for(ch = 0; ch < s->channels; ch++)
756         s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
757
758     return 0;
759 alloc_fail:
760     return AVERROR(ENOMEM);
761 }
762
763 static av_cold int aac_encode_init(AVCodecContext *avctx)
764 {
765     AACEncContext *s = avctx->priv_data;
766     int i, ret = 0;
767     const uint8_t *sizes[2];
768     uint8_t grouping[AAC_MAX_CHANNELS];
769     int lengths[2];
770
771     avctx->frame_size = 1024;
772
773     for (i = 0; i < 16; i++)
774         if (avctx->sample_rate == avpriv_mpeg4audio_sample_rates[i])
775             break;
776
777     s->channels = avctx->channels;
778
779     ERROR_IF(i == 16
780                 || i >= (sizeof(swb_size_1024) / sizeof(*swb_size_1024))
781                 || i >= (sizeof(swb_size_128) / sizeof(*swb_size_128)),
782              "Unsupported sample rate %d\n", avctx->sample_rate);
783     ERROR_IF(s->channels > AAC_MAX_CHANNELS,
784              "Unsupported number of channels: %d\n", s->channels);
785     ERROR_IF(avctx->profile != FF_PROFILE_UNKNOWN && avctx->profile != FF_PROFILE_AAC_LOW,
786              "Unsupported profile %d\n", avctx->profile);
787     WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
788              "Too many bits per frame requested, clamping to max\n");
789
790     avctx->bit_rate = (int)FFMIN(
791         6144 * s->channels / 1024.0 * avctx->sample_rate,
792         avctx->bit_rate);
793
794     s->samplerate_index = i;
795
796     s->chan_map = aac_chan_configs[s->channels-1];
797
798     if ((ret = dsp_init(avctx, s)) < 0)
799         goto fail;
800
801     if ((ret = alloc_buffers(avctx, s)) < 0)
802         goto fail;
803
804     avctx->extradata_size = 5;
805     put_audio_specific_config(avctx);
806
807     sizes[0]   = swb_size_1024[i];
808     sizes[1]   = swb_size_128[i];
809     lengths[0] = ff_aac_num_swb_1024[i];
810     lengths[1] = ff_aac_num_swb_128[i];
811     for (i = 0; i < s->chan_map[0]; i++)
812         grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
813     if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
814                            s->chan_map[0], grouping)) < 0)
815         goto fail;
816     s->psypp = ff_psy_preprocess_init(avctx);
817     s->coder = &ff_aac_coders[s->options.aac_coder];
818
819     if (HAVE_MIPSDSPR1)
820         ff_aac_coder_init_mips(s);
821
822     s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
823
824     ff_aac_tableinit();
825
826     for (i = 0; i < 428; i++)
827         ff_aac_pow34sf_tab[i] = sqrt(ff_aac_pow2sf_tab[i] * sqrt(ff_aac_pow2sf_tab[i]));
828
829     avctx->initial_padding = 1024;
830     ff_af_queue_init(avctx, &s->afq);
831
832     return 0;
833 fail:
834     aac_encode_end(avctx);
835     return ret;
836 }
837
838 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
839 static const AVOption aacenc_options[] = {
840     {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), AV_OPT_TYPE_INT, {.i64 = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},
841         {"auto",     "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
842         {"ms_off",   "Disable Mid/Side coding", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
843         {"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"},
844     {"aac_coder", "", offsetof(AACEncContext, options.aac_coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "aac_coder"},
845         {"faac",     "FAAC-inspired method",      0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAAC},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
846         {"anmr",     "ANMR method",               0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
847         {"twoloop",  "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
848         {"fast",     "Constant quantizer",        0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST},    INT_MIN, INT_MAX, AACENC_FLAGS, "aac_coder"},
849     {"aac_pns", "Perceptual Noise Substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AACENC_FLAGS, "aac_pns"},
850         {"disable",  "Disable PNS", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_pns"},
851         {"enable",   "Enable PNS (Proof of concept)",  0, AV_OPT_TYPE_CONST, {.i64 =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "aac_pns"},
852     {NULL}
853 };
854
855 static const AVClass aacenc_class = {
856     "AAC encoder",
857     av_default_item_name,
858     aacenc_options,
859     LIBAVUTIL_VERSION_INT,
860 };
861
862 /* duplicated from avpriv_mpeg4audio_sample_rates to avoid shared build
863  * failures */
864 static const int mpeg4audio_sample_rates[16] = {
865     96000, 88200, 64000, 48000, 44100, 32000,
866     24000, 22050, 16000, 12000, 11025, 8000, 7350
867 };
868
869 AVCodec ff_aac_encoder = {
870     .name           = "aac",
871     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
872     .type           = AVMEDIA_TYPE_AUDIO,
873     .id             = AV_CODEC_ID_AAC,
874     .priv_data_size = sizeof(AACEncContext),
875     .init           = aac_encode_init,
876     .encode2        = aac_encode_frame,
877     .close          = aac_encode_end,
878     .supported_samplerates = mpeg4audio_sample_rates,
879     .capabilities   = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY |
880                       CODEC_CAP_EXPERIMENTAL,
881     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
882                                                      AV_SAMPLE_FMT_NONE },
883     .priv_class     = &aacenc_class,
884 };