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