FFmpeg
aacenc.c
Go to the documentation of this file.
1 /*
2  * AAC encoder
3  * Copyright (C) 2008 Konstantin Shishkov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * AAC encoder
25  */
26 
27 /***********************************
28  * TODOs:
29  * add sane pulse detection
30  ***********************************/
31 #include <float.h>
32 
34 #include "libavutil/libm.h"
35 #include "libavutil/float_dsp.h"
36 #include "libavutil/opt.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "encode.h"
40 #include "put_bits.h"
41 #include "mpeg4audio.h"
42 #include "sinewin.h"
43 #include "profiles.h"
44 #include "version.h"
45 
46 #include "aac.h"
47 #include "aactab.h"
48 #include "aacenc.h"
49 #include "aacenctab.h"
50 #include "aacenc_utils.h"
51 
52 #include "psymodel.h"
53 
54 /**
55  * List of PCE (Program Configuration Element) for the channel layouts listed
56  * in channel_layout.h
57  *
58  * For those wishing in the future to add other layouts:
59  *
60  * - num_ele: number of elements in each group of front, side, back, lfe channels
61  * (an element is of type SCE (single channel), CPE (channel pair) for
62  * the first 3 groups; and is LFE for LFE group).
63  *
64  * - pairing: 0 for an SCE element or 1 for a CPE; does not apply to LFE group
65  *
66  * - index: there are three independent indices for SCE, CPE and LFE;
67  * they are incremented irrespective of the group to which the element belongs;
68  * they are not reset when going from one group to another
69  *
70  * Example: for 7.0 channel layout,
71  * .pairing = { { 1, 0 }, { 1 }, { 1 }, }, (3 CPE and 1 SCE in front group)
72  * .index = { { 0, 0 }, { 1 }, { 2 }, },
73  * (index is 0 for the single SCE but goes from 0 to 2 for the CPEs)
74  *
75  * The index order impacts the channel ordering. But is otherwise arbitrary
76  * (the sequence could have been 2, 0, 1 instead of 0, 1, 2).
77  *
78  * Spec allows for discontinuous indices, e.g. if one has a total of two SCE,
79  * SCE.0 SCE.15 is OK per spec; BUT it won't be decoded by our AAC decoder
80  * which at this time requires that indices fully cover some range starting
81  * from 0 (SCE.1 SCE.0 is OK but not SCE.0 SCE.15).
82  *
83  * - config_map: total number of elements and their types. Beware, the way the
84  * types are ordered impacts the final channel ordering.
85  *
86  * - reorder_map: reorders the channels.
87  *
88  */
89 static const AACPCEInfo aac_pce_configs[] = {
90  {
92  .num_ele = { 1, 0, 0, 0 },
93  .pairing = { { 0 }, },
94  .index = { { 0 }, },
95  .config_map = { 1, TYPE_SCE, },
96  .reorder_map = { 0 },
97  },
98  {
99  .layout = AV_CHANNEL_LAYOUT_STEREO,
100  .num_ele = { 1, 0, 0, 0 },
101  .pairing = { { 1 }, },
102  .index = { { 0 }, },
103  .config_map = { 1, TYPE_CPE, },
104  .reorder_map = { 0, 1 },
105  },
106  {
107  .layout = AV_CHANNEL_LAYOUT_2POINT1,
108  .num_ele = { 1, 0, 0, 1 },
109  .pairing = { { 1 }, },
110  .index = { { 0 },{ 0 },{ 0 },{ 0 } },
111  .config_map = { 2, TYPE_CPE, TYPE_LFE },
112  .reorder_map = { 0, 1, 2 },
113  },
114  {
115  .layout = AV_CHANNEL_LAYOUT_2_1,
116  .num_ele = { 1, 0, 1, 0 },
117  .pairing = { { 1 },{ 0 },{ 0 } },
118  .index = { { 0 },{ 0 },{ 0 }, },
119  .config_map = { 2, TYPE_CPE, TYPE_SCE },
120  .reorder_map = { 0, 1, 2 },
121  },
122  {
123  .layout = AV_CHANNEL_LAYOUT_SURROUND,
124  .num_ele = { 2, 0, 0, 0 },
125  .pairing = { { 1, 0 }, },
126  .index = { { 0, 0 }, },
127  .config_map = { 2, TYPE_CPE, TYPE_SCE, },
128  .reorder_map = { 0, 1, 2 },
129  },
130  {
131  .layout = AV_CHANNEL_LAYOUT_3POINT1,
132  .num_ele = { 2, 0, 0, 1 },
133  .pairing = { { 1, 0 }, },
134  .index = { { 0, 0 }, { 0 }, { 0 }, { 0 }, },
135  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_LFE },
136  .reorder_map = { 0, 1, 2, 3 },
137  },
138  {
139  .layout = AV_CHANNEL_LAYOUT_4POINT0,
140  .num_ele = { 2, 0, 1, 0 },
141  .pairing = { { 1, 0 }, { 0 }, { 0 }, },
142  .index = { { 0, 0 }, { 0 }, { 1 } },
143  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_SCE },
144  .reorder_map = { 0, 1, 2, 3 },
145  },
146  {
147  .layout = AV_CHANNEL_LAYOUT_4POINT1,
148  .num_ele = { 2, 1, 1, 0 },
149  .pairing = { { 1, 0 }, { 0 }, { 0 }, },
150  .index = { { 0, 0 }, { 1 }, { 2 }, { 0 } },
151  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_SCE },
152  .reorder_map = { 0, 1, 2, 3, 4 },
153  },
154  {
155  .layout = AV_CHANNEL_LAYOUT_2_2,
156  .num_ele = { 1, 1, 0, 0 },
157  .pairing = { { 1 }, { 1 }, },
158  .index = { { 0 }, { 1 }, },
159  .config_map = { 2, TYPE_CPE, TYPE_CPE },
160  .reorder_map = { 0, 1, 2, 3 },
161  },
162  {
163  .layout = AV_CHANNEL_LAYOUT_QUAD,
164  .num_ele = { 1, 0, 1, 0 },
165  .pairing = { { 1 }, { 0 }, { 1 }, },
166  .index = { { 0 }, { 0 }, { 1 } },
167  .config_map = { 2, TYPE_CPE, TYPE_CPE },
168  .reorder_map = { 0, 1, 2, 3 },
169  },
170  {
171  .layout = AV_CHANNEL_LAYOUT_5POINT0,
172  .num_ele = { 2, 1, 0, 0 },
173  .pairing = { { 1, 0 }, { 1 }, },
174  .index = { { 0, 0 }, { 1 } },
175  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_CPE },
176  .reorder_map = { 0, 1, 2, 3, 4 },
177  },
178  {
179  .layout = AV_CHANNEL_LAYOUT_5POINT1,
180  .num_ele = { 2, 1, 1, 0 },
181  .pairing = { { 1, 0 }, { 0 }, { 1 }, },
182  .index = { { 0, 0 }, { 1 }, { 1 } },
183  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE },
184  .reorder_map = { 0, 1, 2, 3, 4, 5 },
185  },
186  {
188  .num_ele = { 2, 0, 1, 0 },
189  .pairing = { { 1, 0 }, { 0 }, { 1 } },
190  .index = { { 0, 0 }, { 0 }, { 1 } },
191  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_CPE },
192  .reorder_map = { 0, 1, 2, 3, 4 },
193  },
194  {
196  .num_ele = { 2, 1, 1, 0 },
197  .pairing = { { 1, 0 }, { 0 }, { 1 }, },
198  .index = { { 0, 0 }, { 1 }, { 1 } },
199  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE },
200  .reorder_map = { 0, 1, 2, 3, 4, 5 },
201  },
202  {
203  .layout = AV_CHANNEL_LAYOUT_6POINT0,
204  .num_ele = { 2, 1, 1, 0 },
205  .pairing = { { 1, 0 }, { 1 }, { 0 }, },
206  .index = { { 0, 0 }, { 1 }, { 1 } },
207  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
208  .reorder_map = { 0, 1, 2, 3, 4, 5 },
209  },
210  {
212  .num_ele = { 2, 1, 0, 0 },
213  .pairing = { { 1, 1 }, { 1 } },
214  .index = { { 1, 0 }, { 2 }, },
215  .config_map = { 3, TYPE_CPE, TYPE_CPE, TYPE_CPE, },
216  .reorder_map = { 0, 1, 2, 3, 4, 5 },
217  },
218  {
219  .layout = AV_CHANNEL_LAYOUT_HEXAGONAL,
220  .num_ele = { 2, 0, 2, 0 },
221  .pairing = { { 1, 0 },{ 0 },{ 1, 0 }, },
222  .index = { { 0, 0 },{ 0 },{ 1, 1 } },
223  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE, },
224  .reorder_map = { 0, 1, 2, 3, 4, 5 },
225  },
226  {
227  .layout = AV_CHANNEL_LAYOUT_6POINT1,
228  .num_ele = { 2, 1, 2, 0 },
229  .pairing = { { 1, 0 },{ 0 },{ 1, 0 }, },
230  .index = { { 0, 0 },{ 1 },{ 1, 2 } },
231  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
232  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
233  },
234  {
236  .num_ele = { 2, 1, 2, 0 },
237  .pairing = { { 1, 0 }, { 0 }, { 1, 0 }, },
238  .index = { { 0, 0 }, { 1 }, { 1, 2 } },
239  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
240  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
241  },
242  {
244  .num_ele = { 2, 1, 2, 0 },
245  .pairing = { { 1, 0 }, { 0 }, { 1, 0 }, },
246  .index = { { 0, 0 }, { 1 }, { 1, 2 } },
247  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
248  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
249  },
250  {
251  .layout = AV_CHANNEL_LAYOUT_7POINT0,
252  .num_ele = { 2, 1, 1, 0 },
253  .pairing = { { 1, 0 }, { 1 }, { 1 }, },
254  .index = { { 0, 0 }, { 1 }, { 2 }, },
255  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
256  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
257  },
258  {
260  .num_ele = { 2, 1, 1, 0 },
261  .pairing = { { 1, 0 }, { 1 }, { 1 }, },
262  .index = { { 0, 0 }, { 1 }, { 2 }, },
263  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
264  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
265  },
266  {
267  .layout = AV_CHANNEL_LAYOUT_7POINT1,
268  .num_ele = { 2, 1, 2, 0 },
269  .pairing = { { 1, 0 }, { 0 }, { 1, 1 }, },
270  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
271  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
272  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
273  },
274  {
276  .num_ele = { 2, 1, 2, 0 },
277  .pairing = { { 1, 0 }, { 0 },{ 1, 1 }, },
278  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
279  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
280  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
281  },
282  {
284  .num_ele = { 2, 1, 2, 0 },
285  .pairing = { { 1, 0 }, { 0 }, { 1, 1 }, },
286  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
287  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
288  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
289  },
290  {
291  .layout = AV_CHANNEL_LAYOUT_OCTAGONAL,
292  .num_ele = { 2, 1, 2, 0 },
293  .pairing = { { 1, 0 }, { 1 }, { 1, 0 }, },
294  .index = { { 0, 0 }, { 1 }, { 2, 1 } },
295  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_SCE },
296  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
297  },
298  { /* Meant for order 2/mixed ambisonics */
299  .layout = { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = 9,
301  .num_ele = { 2, 2, 2, 0 },
302  .pairing = { { 1, 0 }, { 1, 0 }, { 1, 0 }, },
303  .index = { { 0, 0 }, { 1, 1 }, { 2, 2 } },
304  .config_map = { 6, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
305  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8 },
306  },
307  { /* Meant for order 2/mixed ambisonics */
308  .layout = { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = 10,
311  .num_ele = { 2, 2, 2, 0 },
312  .pairing = { { 1, 1 }, { 1, 0 }, { 1, 0 }, },
313  .index = { { 0, 1 }, { 2, 0 }, { 3, 1 } },
314  .config_map = { 6, TYPE_CPE, TYPE_CPE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
315  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
316  },
317  {
319  .num_ele = { 4, 2, 4, 0 },
320  .pairing = { { 1, 0, 1, 0 }, { 1, 1 }, { 1, 0, 1, 0 }, },
321  .index = { { 0, 0, 1, 1 }, { 2, 3 }, { 4, 2, 5, 3 } },
323  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
324  },
325 };
326 
327 static void put_pce(PutBitContext *pb, AVCodecContext *avctx)
328 {
329  int i, j;
330  AACEncContext *s = avctx->priv_data;
331  AACPCEInfo *pce = &s->pce;
332  const int bitexact = avctx->flags & AV_CODEC_FLAG_BITEXACT;
333  const char *aux_data = bitexact ? "Lavc" : LIBAVCODEC_IDENT;
334 
335  put_bits(pb, 4, 0);
336 
337  put_bits(pb, 2, avctx->profile);
338  put_bits(pb, 4, s->samplerate_index);
339 
340  put_bits(pb, 4, pce->num_ele[0]); /* Front */
341  put_bits(pb, 4, pce->num_ele[1]); /* Side */
342  put_bits(pb, 4, pce->num_ele[2]); /* Back */
343  put_bits(pb, 2, pce->num_ele[3]); /* LFE */
344  put_bits(pb, 3, 0); /* Assoc data */
345  put_bits(pb, 4, 0); /* CCs */
346 
347  put_bits(pb, 1, 0); /* Stereo mixdown */
348  put_bits(pb, 1, 0); /* Mono mixdown */
349  put_bits(pb, 1, 0); /* Something else */
350 
351  for (i = 0; i < 4; i++) {
352  for (j = 0; j < pce->num_ele[i]; j++) {
353  if (i < 3)
354  put_bits(pb, 1, pce->pairing[i][j]);
355  put_bits(pb, 4, pce->index[i][j]);
356  }
357  }
358 
359  align_put_bits(pb);
360  put_bits(pb, 8, strlen(aux_data));
361  ff_put_string(pb, aux_data, 0);
362 }
363 
364 /**
365  * Make AAC audio config object.
366  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
367  */
369 {
370  PutBitContext pb;
371  AACEncContext *s = avctx->priv_data;
372  int channels = (!s->needs_pce)*(s->channels - (s->channels == 8 ? 1 : 0));
373  const int max_size = 32;
374 
375  avctx->extradata = av_mallocz(max_size);
376  if (!avctx->extradata)
377  return AVERROR(ENOMEM);
378 
379  init_put_bits(&pb, avctx->extradata, max_size);
380  put_bits(&pb, 5, s->profile+1); //profile
381  put_bits(&pb, 4, s->samplerate_index); //sample rate index
382  put_bits(&pb, 4, channels);
383  //GASpecificConfig
384  put_bits(&pb, 1, 0); //frame length - 1024 samples
385  put_bits(&pb, 1, 0); //does not depend on core coder
386  put_bits(&pb, 1, 0); //is not extension
387  if (s->needs_pce)
388  put_pce(&pb, avctx);
389 
390  //Explicitly Mark SBR absent
391  put_bits(&pb, 11, 0x2b7); //sync extension
392  put_bits(&pb, 5, AOT_SBR);
393  put_bits(&pb, 1, 0);
394  flush_put_bits(&pb);
395  avctx->extradata_size = put_bytes_output(&pb);
396 
397  return 0;
398 }
399 
401 {
402  ++s->quantize_band_cost_cache_generation;
403  if (s->quantize_band_cost_cache_generation == 0) {
404  memset(s->quantize_band_cost_cache, 0, sizeof(s->quantize_band_cost_cache));
405  s->quantize_band_cost_cache_generation = 1;
406  }
407 }
408 
409 #define WINDOW_FUNC(type) \
410 static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
411  SingleChannelElement *sce, \
412  const float *audio)
413 
414 WINDOW_FUNC(only_long)
415 {
416  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
417  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
418  float *out = sce->ret_buf;
419 
420  fdsp->vector_fmul (out, audio, lwindow, 1024);
421  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
422 }
423 
424 WINDOW_FUNC(long_start)
425 {
426  const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
427  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
428  float *out = sce->ret_buf;
429 
430  fdsp->vector_fmul(out, audio, lwindow, 1024);
431  memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
432  fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
433  memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
434 }
435 
436 WINDOW_FUNC(long_stop)
437 {
438  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
439  const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
440  float *out = sce->ret_buf;
441 
442  memset(out, 0, sizeof(out[0]) * 448);
443  fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
444  memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
445  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
446 }
447 
448 WINDOW_FUNC(eight_short)
449 {
450  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
451  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
452  const float *in = audio + 448;
453  float *out = sce->ret_buf;
454  int w;
455 
456  for (w = 0; w < 8; w++) {
457  fdsp->vector_fmul (out, in, w ? pwindow : swindow, 128);
458  out += 128;
459  in += 128;
460  fdsp->vector_fmul_reverse(out, in, swindow, 128);
461  out += 128;
462  }
463 }
464 
465 static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
467  const float *audio) = {
468  [ONLY_LONG_SEQUENCE] = apply_only_long_window,
469  [LONG_START_SEQUENCE] = apply_long_start_window,
470  [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
471  [LONG_STOP_SEQUENCE] = apply_long_stop_window
472 };
473 
475  float *audio)
476 {
477  int i;
478  const float *output = sce->ret_buf;
479 
480  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
481 
483  s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
484  else
485  for (i = 0; i < 1024; i += 128)
486  s->mdct128.mdct_calc(&s->mdct128, &sce->coeffs[i], output + i*2);
487  memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
488  memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
489 }
490 
491 /**
492  * Encode ics_info element.
493  * @see Table 4.6 (syntax of ics_info)
494  */
496 {
497  int w;
498 
499  put_bits(&s->pb, 1, 0); // ics_reserved bit
500  put_bits(&s->pb, 2, info->window_sequence[0]);
501  put_bits(&s->pb, 1, info->use_kb_window[0]);
502  if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
503  put_bits(&s->pb, 6, info->max_sfb);
504  put_bits(&s->pb, 1, !!info->predictor_present);
505  } else {
506  put_bits(&s->pb, 4, info->max_sfb);
507  for (w = 1; w < 8; w++)
508  put_bits(&s->pb, 1, !info->group_len[w]);
509  }
510 }
511 
512 /**
513  * Encode MS data.
514  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
515  */
517 {
518  int i, w;
519 
520  put_bits(pb, 2, cpe->ms_mode);
521  if (cpe->ms_mode == 1)
522  for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
523  for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
524  put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
525 }
526 
527 /**
528  * Produce integer coefficients from scalefactors provided by the model.
529  */
530 static void adjust_frame_information(ChannelElement *cpe, int chans)
531 {
532  int i, w, w2, g, ch;
533  int maxsfb, cmaxsfb;
534 
535  for (ch = 0; ch < chans; ch++) {
536  IndividualChannelStream *ics = &cpe->ch[ch].ics;
537  maxsfb = 0;
538  cpe->ch[ch].pulse.num_pulse = 0;
539  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
540  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
541  for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
542  ;
543  maxsfb = FFMAX(maxsfb, cmaxsfb);
544  }
545  }
546  ics->max_sfb = maxsfb;
547 
548  //adjust zero bands for window groups
549  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
550  for (g = 0; g < ics->max_sfb; g++) {
551  i = 1;
552  for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
553  if (!cpe->ch[ch].zeroes[w2*16 + g]) {
554  i = 0;
555  break;
556  }
557  }
558  cpe->ch[ch].zeroes[w*16 + g] = i;
559  }
560  }
561  }
562 
563  if (chans > 1 && cpe->common_window) {
564  IndividualChannelStream *ics0 = &cpe->ch[0].ics;
565  IndividualChannelStream *ics1 = &cpe->ch[1].ics;
566  int msc = 0;
567  ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
568  ics1->max_sfb = ics0->max_sfb;
569  for (w = 0; w < ics0->num_windows*16; w += 16)
570  for (i = 0; i < ics0->max_sfb; i++)
571  if (cpe->ms_mask[w+i])
572  msc++;
573  if (msc == 0 || ics0->max_sfb == 0)
574  cpe->ms_mode = 0;
575  else
576  cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
577  }
578 }
579 
581 {
582  int w, w2, g, i;
583  IndividualChannelStream *ics = &cpe->ch[0].ics;
584  if (!cpe->common_window)
585  return;
586  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
587  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
588  int start = (w+w2) * 128;
589  for (g = 0; g < ics->num_swb; g++) {
590  int p = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
591  float scale = cpe->ch[0].is_ener[w*16+g];
592  if (!cpe->is_mask[w*16 + g]) {
593  start += ics->swb_sizes[g];
594  continue;
595  }
596  if (cpe->ms_mask[w*16 + g])
597  p *= -1;
598  for (i = 0; i < ics->swb_sizes[g]; i++) {
599  float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
600  cpe->ch[0].coeffs[start+i] = sum;
601  cpe->ch[1].coeffs[start+i] = 0.0f;
602  }
603  start += ics->swb_sizes[g];
604  }
605  }
606  }
607 }
608 
610 {
611  int w, w2, g, i;
612  IndividualChannelStream *ics = &cpe->ch[0].ics;
613  if (!cpe->common_window)
614  return;
615  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
616  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
617  int start = (w+w2) * 128;
618  for (g = 0; g < ics->num_swb; g++) {
619  /* ms_mask can be used for other purposes in PNS and I/S,
620  * so must not apply M/S if any band uses either, even if
621  * ms_mask is set.
622  */
623  if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
624  || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
625  || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
626  start += ics->swb_sizes[g];
627  continue;
628  }
629  for (i = 0; i < ics->swb_sizes[g]; i++) {
630  float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
631  float R = L - cpe->ch[1].coeffs[start+i];
632  cpe->ch[0].coeffs[start+i] = L;
633  cpe->ch[1].coeffs[start+i] = R;
634  }
635  start += ics->swb_sizes[g];
636  }
637  }
638  }
639 }
640 
641 /**
642  * Encode scalefactor band coding type.
643  */
645 {
646  int w;
647 
648  if (s->coder->set_special_band_scalefactors)
649  s->coder->set_special_band_scalefactors(s, sce);
650 
651  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
652  s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
653 }
654 
655 /**
656  * Encode scalefactors.
657  */
660 {
661  int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
662  int off_is = 0, noise_flag = 1;
663  int i, w;
664 
665  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
666  for (i = 0; i < sce->ics.max_sfb; i++) {
667  if (!sce->zeroes[w*16 + i]) {
668  if (sce->band_type[w*16 + i] == NOISE_BT) {
669  diff = sce->sf_idx[w*16 + i] - off_pns;
670  off_pns = sce->sf_idx[w*16 + i];
671  if (noise_flag-- > 0) {
673  continue;
674  }
675  } else if (sce->band_type[w*16 + i] == INTENSITY_BT ||
676  sce->band_type[w*16 + i] == INTENSITY_BT2) {
677  diff = sce->sf_idx[w*16 + i] - off_is;
678  off_is = sce->sf_idx[w*16 + i];
679  } else {
680  diff = sce->sf_idx[w*16 + i] - off_sf;
681  off_sf = sce->sf_idx[w*16 + i];
682  }
684  av_assert0(diff >= 0 && diff <= 120);
686  }
687  }
688  }
689 }
690 
691 /**
692  * Encode pulse data.
693  */
694 static void encode_pulses(AACEncContext *s, Pulse *pulse)
695 {
696  int i;
697 
698  put_bits(&s->pb, 1, !!pulse->num_pulse);
699  if (!pulse->num_pulse)
700  return;
701 
702  put_bits(&s->pb, 2, pulse->num_pulse - 1);
703  put_bits(&s->pb, 6, pulse->start);
704  for (i = 0; i < pulse->num_pulse; i++) {
705  put_bits(&s->pb, 5, pulse->pos[i]);
706  put_bits(&s->pb, 4, pulse->amp[i]);
707  }
708 }
709 
710 /**
711  * Encode spectral coefficients processed by psychoacoustic model.
712  */
714 {
715  int start, i, w, w2;
716 
717  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
718  start = 0;
719  for (i = 0; i < sce->ics.max_sfb; i++) {
720  if (sce->zeroes[w*16 + i]) {
721  start += sce->ics.swb_sizes[i];
722  continue;
723  }
724  for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
725  s->coder->quantize_and_encode_band(s, &s->pb,
726  &sce->coeffs[start + w2*128],
727  NULL, sce->ics.swb_sizes[i],
728  sce->sf_idx[w*16 + i],
729  sce->band_type[w*16 + i],
730  s->lambda,
731  sce->ics.window_clipping[w]);
732  }
733  start += sce->ics.swb_sizes[i];
734  }
735  }
736 }
737 
738 /**
739  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
740  */
742 {
743  int start, i, j, w;
744 
745  if (sce->ics.clip_avoidance_factor < 1.0f) {
746  for (w = 0; w < sce->ics.num_windows; w++) {
747  start = 0;
748  for (i = 0; i < sce->ics.max_sfb; i++) {
749  float *swb_coeffs = &sce->coeffs[start + w*128];
750  for (j = 0; j < sce->ics.swb_sizes[i]; j++)
751  swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
752  start += sce->ics.swb_sizes[i];
753  }
754  }
755  }
756 }
757 
758 /**
759  * Encode one channel of audio data.
760  */
763  int common_window)
764 {
765  put_bits(&s->pb, 8, sce->sf_idx[0]);
766  if (!common_window) {
767  put_ics_info(s, &sce->ics);
768  if (s->coder->encode_main_pred)
769  s->coder->encode_main_pred(s, sce);
770  if (s->coder->encode_ltp_info)
771  s->coder->encode_ltp_info(s, sce, 0);
772  }
773  encode_band_info(s, sce);
774  encode_scale_factors(avctx, s, sce);
775  encode_pulses(s, &sce->pulse);
776  put_bits(&s->pb, 1, !!sce->tns.present);
777  if (s->coder->encode_tns_info)
778  s->coder->encode_tns_info(s, sce);
779  put_bits(&s->pb, 1, 0); //ssr
781  return 0;
782 }
783 
784 /**
785  * Write some auxiliary information about the created AAC file.
786  */
787 static void put_bitstream_info(AACEncContext *s, const char *name)
788 {
789  int i, namelen, padbits;
790 
791  namelen = strlen(name) + 2;
792  put_bits(&s->pb, 3, TYPE_FIL);
793  put_bits(&s->pb, 4, FFMIN(namelen, 15));
794  if (namelen >= 15)
795  put_bits(&s->pb, 8, namelen - 14);
796  put_bits(&s->pb, 4, 0); //extension type - filler
797  padbits = -put_bits_count(&s->pb) & 7;
798  align_put_bits(&s->pb);
799  for (i = 0; i < namelen - 2; i++)
800  put_bits(&s->pb, 8, name[i]);
801  put_bits(&s->pb, 12 - padbits, 0);
802 }
803 
804 /*
805  * Copy input samples.
806  * Channels are reordered from libavcodec's default order to AAC order.
807  */
809 {
810  int ch;
811  int end = 2048 + (frame ? frame->nb_samples : 0);
812  const uint8_t *channel_map = s->reorder_map;
813 
814  /* copy and remap input samples */
815  for (ch = 0; ch < s->channels; ch++) {
816  /* copy last 1024 samples of previous frame to the start of the current frame */
817  memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
818 
819  /* copy new samples and zero any remaining samples */
820  if (frame) {
821  memcpy(&s->planar_samples[ch][2048],
822  frame->extended_data[channel_map[ch]],
823  frame->nb_samples * sizeof(s->planar_samples[0][0]));
824  }
825  memset(&s->planar_samples[ch][end], 0,
826  (3072 - end) * sizeof(s->planar_samples[0][0]));
827  }
828 }
829 
830 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
831  const AVFrame *frame, int *got_packet_ptr)
832 {
833  AACEncContext *s = avctx->priv_data;
834  float **samples = s->planar_samples, *samples2, *la, *overlap;
835  ChannelElement *cpe;
838  int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
839  int target_bits, rate_bits, too_many_bits, too_few_bits;
840  int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
841  int chan_el_counter[4];
843 
844  /* add current frame to queue */
845  if (frame) {
846  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
847  return ret;
848  } else {
849  if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
850  return 0;
851  }
852 
854  if (s->psypp)
855  ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
856 
857  if (!avctx->frame_number)
858  return 0;
859 
860  start_ch = 0;
861  for (i = 0; i < s->chan_map[0]; i++) {
862  FFPsyWindowInfo* wi = windows + start_ch;
863  tag = s->chan_map[i+1];
864  chans = tag == TYPE_CPE ? 2 : 1;
865  cpe = &s->cpe[i];
866  for (ch = 0; ch < chans; ch++) {
867  int k;
868  float clip_avoidance_factor;
869  sce = &cpe->ch[ch];
870  ics = &sce->ics;
871  s->cur_channel = start_ch + ch;
872  overlap = &samples[s->cur_channel][0];
873  samples2 = overlap + 1024;
874  la = samples2 + (448+64);
875  if (!frame)
876  la = NULL;
877  if (tag == TYPE_LFE) {
878  wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
879  wi[ch].window_shape = 0;
880  wi[ch].num_windows = 1;
881  wi[ch].grouping[0] = 1;
882  wi[ch].clipping[0] = 0;
883 
884  /* Only the lowest 12 coefficients are used in a LFE channel.
885  * The expression below results in only the bottom 8 coefficients
886  * being used for 11.025kHz to 16kHz sample rates.
887  */
888  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
889  } else {
890  wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
891  ics->window_sequence[0]);
892  }
893  ics->window_sequence[1] = ics->window_sequence[0];
894  ics->window_sequence[0] = wi[ch].window_type[0];
895  ics->use_kb_window[1] = ics->use_kb_window[0];
896  ics->use_kb_window[0] = wi[ch].window_shape;
897  ics->num_windows = wi[ch].num_windows;
898  ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
899  ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
900  ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);
901  ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
902  ff_swb_offset_128 [s->samplerate_index]:
903  ff_swb_offset_1024[s->samplerate_index];
904  ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
905  ff_tns_max_bands_128 [s->samplerate_index]:
906  ff_tns_max_bands_1024[s->samplerate_index];
907 
908  for (w = 0; w < ics->num_windows; w++)
909  ics->group_len[w] = wi[ch].grouping[w];
910 
911  /* Calculate input sample maximums and evaluate clipping risk */
912  clip_avoidance_factor = 0.0f;
913  for (w = 0; w < ics->num_windows; w++) {
914  const float *wbuf = overlap + w * 128;
915  const int wlen = 2048 / ics->num_windows;
916  float max = 0;
917  int j;
918  /* mdct input is 2 * output */
919  for (j = 0; j < wlen; j++)
920  max = FFMAX(max, fabsf(wbuf[j]));
921  wi[ch].clipping[w] = max;
922  }
923  for (w = 0; w < ics->num_windows; w++) {
924  if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
925  ics->window_clipping[w] = 1;
926  clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
927  } else {
928  ics->window_clipping[w] = 0;
929  }
930  }
931  if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
932  ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
933  } else {
934  ics->clip_avoidance_factor = 1.0f;
935  }
936 
937  apply_window_and_mdct(s, sce, overlap);
938 
939  if (s->options.ltp && s->coder->update_ltp) {
940  s->coder->update_ltp(s, sce);
941  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
942  s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);
943  }
944 
945  for (k = 0; k < 1024; k++) {
946  if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
947  av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
948  return AVERROR(EINVAL);
949  }
950  }
951  avoid_clipping(s, sce);
952  }
953  start_ch += chans;
954  }
955  if ((ret = ff_alloc_packet(avctx, avpkt, 8192 * s->channels)) < 0)
956  return ret;
957  frame_bits = its = 0;
958  do {
959  init_put_bits(&s->pb, avpkt->data, avpkt->size);
960 
961  if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
963  start_ch = 0;
964  target_bits = 0;
965  memset(chan_el_counter, 0, sizeof(chan_el_counter));
966  for (i = 0; i < s->chan_map[0]; i++) {
967  FFPsyWindowInfo* wi = windows + start_ch;
968  const float *coeffs[2];
969  tag = s->chan_map[i+1];
970  chans = tag == TYPE_CPE ? 2 : 1;
971  cpe = &s->cpe[i];
972  cpe->common_window = 0;
973  memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
974  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
975  put_bits(&s->pb, 3, tag);
976  put_bits(&s->pb, 4, chan_el_counter[tag]++);
977  for (ch = 0; ch < chans; ch++) {
978  sce = &cpe->ch[ch];
979  coeffs[ch] = sce->coeffs;
980  sce->ics.predictor_present = 0;
981  sce->ics.ltp.present = 0;
982  memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
983  memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
984  memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
985  for (w = 0; w < 128; w++)
986  if (sce->band_type[w] > RESERVED_BT)
987  sce->band_type[w] = 0;
988  }
989  s->psy.bitres.alloc = -1;
990  s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
991  s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
992  if (s->psy.bitres.alloc > 0) {
993  /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
994  target_bits += s->psy.bitres.alloc
995  * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
996  s->psy.bitres.alloc /= chans;
997  }
998  s->cur_type = tag;
999  for (ch = 0; ch < chans; ch++) {
1000  s->cur_channel = start_ch + ch;
1001  if (s->options.pns && s->coder->mark_pns)
1002  s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
1003  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
1004  }
1005  if (chans > 1
1006  && wi[0].window_type[0] == wi[1].window_type[0]
1007  && wi[0].window_shape == wi[1].window_shape) {
1008 
1009  cpe->common_window = 1;
1010  for (w = 0; w < wi[0].num_windows; w++) {
1011  if (wi[0].grouping[w] != wi[1].grouping[w]) {
1012  cpe->common_window = 0;
1013  break;
1014  }
1015  }
1016  }
1017  for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
1018  sce = &cpe->ch[ch];
1019  s->cur_channel = start_ch + ch;
1020  if (s->options.tns && s->coder->search_for_tns)
1021  s->coder->search_for_tns(s, sce);
1022  if (s->options.tns && s->coder->apply_tns_filt)
1023  s->coder->apply_tns_filt(s, sce);
1024  if (sce->tns.present)
1025  tns_mode = 1;
1026  if (s->options.pns && s->coder->search_for_pns)
1027  s->coder->search_for_pns(s, avctx, sce);
1028  }
1029  s->cur_channel = start_ch;
1030  if (s->options.intensity_stereo) { /* Intensity Stereo */
1031  if (s->coder->search_for_is)
1032  s->coder->search_for_is(s, avctx, cpe);
1033  if (cpe->is_mode) is_mode = 1;
1035  }
1036  if (s->options.pred) { /* Prediction */
1037  for (ch = 0; ch < chans; ch++) {
1038  sce = &cpe->ch[ch];
1039  s->cur_channel = start_ch + ch;
1040  if (s->options.pred && s->coder->search_for_pred)
1041  s->coder->search_for_pred(s, sce);
1042  if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
1043  }
1044  if (s->coder->adjust_common_pred)
1045  s->coder->adjust_common_pred(s, cpe);
1046  for (ch = 0; ch < chans; ch++) {
1047  sce = &cpe->ch[ch];
1048  s->cur_channel = start_ch + ch;
1049  if (s->options.pred && s->coder->apply_main_pred)
1050  s->coder->apply_main_pred(s, sce);
1051  }
1052  s->cur_channel = start_ch;
1053  }
1054  if (s->options.mid_side) { /* Mid/Side stereo */
1055  if (s->options.mid_side == -1 && s->coder->search_for_ms)
1056  s->coder->search_for_ms(s, cpe);
1057  else if (cpe->common_window)
1058  memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
1059  apply_mid_side_stereo(cpe);
1060  }
1061  adjust_frame_information(cpe, chans);
1062  if (s->options.ltp) { /* LTP */
1063  for (ch = 0; ch < chans; ch++) {
1064  sce = &cpe->ch[ch];
1065  s->cur_channel = start_ch + ch;
1066  if (s->coder->search_for_ltp)
1067  s->coder->search_for_ltp(s, sce, cpe->common_window);
1068  if (sce->ics.ltp.present) pred_mode = 1;
1069  }
1070  s->cur_channel = start_ch;
1071  if (s->coder->adjust_common_ltp)
1072  s->coder->adjust_common_ltp(s, cpe);
1073  }
1074  if (chans == 2) {
1075  put_bits(&s->pb, 1, cpe->common_window);
1076  if (cpe->common_window) {
1077  put_ics_info(s, &cpe->ch[0].ics);
1078  if (s->coder->encode_main_pred)
1079  s->coder->encode_main_pred(s, &cpe->ch[0]);
1080  if (s->coder->encode_ltp_info)
1081  s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
1082  encode_ms_info(&s->pb, cpe);
1083  if (cpe->ms_mode) ms_mode = 1;
1084  }
1085  }
1086  for (ch = 0; ch < chans; ch++) {
1087  s->cur_channel = start_ch + ch;
1088  encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
1089  }
1090  start_ch += chans;
1091  }
1092 
1093  if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
1094  /* When using a constant Q-scale, don't mess with lambda */
1095  break;
1096  }
1097 
1098  /* rate control stuff
1099  * allow between the nominal bitrate, and what psy's bit reservoir says to target
1100  * but drift towards the nominal bitrate always
1101  */
1102  frame_bits = put_bits_count(&s->pb);
1103  rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
1104  rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
1105  too_many_bits = FFMAX(target_bits, rate_bits);
1106  too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
1107  too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
1108 
1109  /* When using ABR, be strict (but only for increasing) */
1110  too_few_bits = too_few_bits - too_few_bits/8;
1111  too_many_bits = too_many_bits + too_many_bits/2;
1112 
1113  if ( its == 0 /* for steady-state Q-scale tracking */
1114  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
1115  || frame_bits >= 6144 * s->channels - 3 )
1116  {
1117  float ratio = ((float)rate_bits) / frame_bits;
1118 
1119  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
1120  /*
1121  * This path is for steady-state Q-scale tracking
1122  * When frame bits fall within the stable range, we still need to adjust
1123  * lambda to maintain it like so in a stable fashion (large jumps in lambda
1124  * create artifacts and should be avoided), but slowly
1125  */
1126  ratio = sqrtf(sqrtf(ratio));
1127  ratio = av_clipf(ratio, 0.9f, 1.1f);
1128  } else {
1129  /* Not so fast though */
1130  ratio = sqrtf(ratio);
1131  }
1132  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
1133 
1134  /* Keep iterating if we must reduce and lambda is in the sky */
1135  if (ratio > 0.9f && ratio < 1.1f) {
1136  break;
1137  } else {
1138  if (is_mode || ms_mode || tns_mode || pred_mode) {
1139  for (i = 0; i < s->chan_map[0]; i++) {
1140  // Must restore coeffs
1141  chans = tag == TYPE_CPE ? 2 : 1;
1142  cpe = &s->cpe[i];
1143  for (ch = 0; ch < chans; ch++)
1144  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
1145  }
1146  }
1147  its++;
1148  }
1149  } else {
1150  break;
1151  }
1152  } while (1);
1153 
1154  if (s->options.ltp && s->coder->ltp_insert_new_frame)
1155  s->coder->ltp_insert_new_frame(s);
1156 
1157  put_bits(&s->pb, 3, TYPE_END);
1158  flush_put_bits(&s->pb);
1159 
1160  s->last_frame_pb_count = put_bits_count(&s->pb);
1161  avpkt->size = put_bytes_output(&s->pb);
1162 
1163  s->lambda_sum += s->lambda;
1164  s->lambda_count++;
1165 
1166  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
1167  &avpkt->duration);
1168 
1169  *got_packet_ptr = 1;
1170  return 0;
1171 }
1172 
1174 {
1175  AACEncContext *s = avctx->priv_data;
1176 
1177  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
1178 
1179  ff_mdct_end(&s->mdct1024);
1180  ff_mdct_end(&s->mdct128);
1181  ff_psy_end(&s->psy);
1182  ff_lpc_end(&s->lpc);
1183  if (s->psypp)
1184  ff_psy_preprocess_end(s->psypp);
1185  av_freep(&s->buffer.samples);
1186  av_freep(&s->cpe);
1187  av_freep(&s->fdsp);
1188  ff_af_queue_close(&s->afq);
1189  return 0;
1190 }
1191 
1193 {
1194  int ret = 0;
1195 
1197  if (!s->fdsp)
1198  return AVERROR(ENOMEM);
1199 
1200  // window init
1202 
1203  if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
1204  return ret;
1205  if ((ret = ff_mdct_init(&s->mdct128, 8, 0, 32768.0)) < 0)
1206  return ret;
1207 
1208  return 0;
1209 }
1210 
1212 {
1213  int ch;
1214  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
1215  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
1216  return AVERROR(ENOMEM);
1217 
1218  for(ch = 0; ch < s->channels; ch++)
1219  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
1220 
1221  return 0;
1222 }
1223 
1225 {
1226  AACEncContext *s = avctx->priv_data;
1227  int i, ret = 0;
1228  const uint8_t *sizes[2];
1229  uint8_t grouping[AAC_MAX_CHANNELS];
1230  int lengths[2];
1231 
1232  /* Constants */
1233  s->last_frame_pb_count = 0;
1234  avctx->frame_size = 1024;
1235  avctx->initial_padding = 1024;
1236  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1237 
1238  /* Channel map and unspecified bitrate guessing */
1239  s->channels = avctx->ch_layout.nb_channels;
1240 
1241  s->needs_pce = 1;
1242  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
1244  s->needs_pce = s->options.pce;
1245  break;
1246  }
1247  }
1248 
1249  if (s->needs_pce) {
1250  char buf[64];
1251  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
1253  break;
1254  av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
1255  if (i == FF_ARRAY_ELEMS(aac_pce_configs)) {
1256  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout \"%s\"\n", buf);
1257  return AVERROR(EINVAL);
1258  }
1259  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
1260  s->pce = aac_pce_configs[i];
1261  s->reorder_map = s->pce.reorder_map;
1262  s->chan_map = s->pce.config_map;
1263  } else {
1264  s->reorder_map = aac_chan_maps[s->channels - 1];
1265  s->chan_map = aac_chan_configs[s->channels - 1];
1266  }
1267 
1268  if (!avctx->bit_rate) {
1269  for (i = 1; i <= s->chan_map[0]; i++) {
1270  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
1271  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
1272  69000 ; /* SCE */
1273  }
1274  }
1275 
1276  /* Samplerate */
1277  for (i = 0; i < 16; i++)
1278  if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
1279  break;
1280  s->samplerate_index = i;
1281  ERROR_IF(s->samplerate_index == 16 ||
1282  s->samplerate_index >= ff_aac_swb_size_1024_len ||
1283  s->samplerate_index >= ff_aac_swb_size_128_len,
1284  "Unsupported sample rate %d\n", avctx->sample_rate);
1285 
1286  /* Bitrate limiting */
1287  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1288  "Too many bits %f > %d per frame requested, clamping to max\n",
1289  1024.0 * avctx->bit_rate / avctx->sample_rate,
1290  6144 * s->channels);
1291  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1292  avctx->bit_rate);
1293 
1294  /* Profile and option setting */
1295  avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
1296  avctx->profile;
1297  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1298  if (avctx->profile == aacenc_profiles[i])
1299  break;
1300  if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
1301  avctx->profile = FF_PROFILE_AAC_LOW;
1302  ERROR_IF(s->options.pred,
1303  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1304  ERROR_IF(s->options.ltp,
1305  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1306  WARN_IF(s->options.pns,
1307  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1308  s->options.pns = 0;
1309  } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
1310  s->options.ltp = 1;
1311  ERROR_IF(s->options.pred,
1312  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1313  } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
1314  s->options.pred = 1;
1315  ERROR_IF(s->options.ltp,
1316  "LTP prediction unavailable in the \"aac_main\" profile\n");
1317  } else if (s->options.ltp) {
1318  avctx->profile = FF_PROFILE_AAC_LTP;
1319  WARN_IF(1,
1320  "Chainging profile to \"aac_ltp\"\n");
1321  ERROR_IF(s->options.pred,
1322  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1323  } else if (s->options.pred) {
1324  avctx->profile = FF_PROFILE_AAC_MAIN;
1325  WARN_IF(1,
1326  "Chainging profile to \"aac_main\"\n");
1327  ERROR_IF(s->options.ltp,
1328  "LTP prediction unavailable in the \"aac_main\" profile\n");
1329  }
1330  s->profile = avctx->profile;
1331 
1332  /* Coder limitations */
1333  s->coder = &ff_aac_coders[s->options.coder];
1334  if (s->options.coder == AAC_CODER_ANMR) {
1336  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
1337  s->options.intensity_stereo = 0;
1338  s->options.pns = 0;
1339  }
1341  "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
1342 
1343  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1344  if (s->channels > 3)
1345  s->options.mid_side = 0;
1346 
1347  if ((ret = dsp_init(avctx, s)) < 0)
1348  return ret;
1349 
1350  if ((ret = alloc_buffers(avctx, s)) < 0)
1351  return ret;
1352 
1353  if ((ret = put_audio_specific_config(avctx)))
1354  return ret;
1355 
1356  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1357  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1358  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1359  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1360  for (i = 0; i < s->chan_map[0]; i++)
1361  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1362  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1363  s->chan_map[0], grouping)) < 0)
1364  return ret;
1365  s->psypp = ff_psy_preprocess_init(avctx);
1367  s->random_state = 0x1f2e3d4c;
1368 
1369  s->abs_pow34 = abs_pow34_v;
1370  s->quant_bands = quantize_bands;
1371 
1372 #if ARCH_X86
1374 #endif
1375 
1376 #if HAVE_MIPSDSP
1378 #endif
1379 
1380  ff_af_queue_init(avctx, &s->afq);
1381  ff_aac_tableinit();
1382 
1383  return 0;
1384 }
1385 
1386 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1387 static const AVOption aacenc_options[] = {
1388  {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "coder"},
1389  {"anmr", "ANMR method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1390  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1391  {"fast", "Default fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1392  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1393  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1394  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1395  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1396  {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1397  {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1398  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1400  {NULL}
1401 };
1402 
1403 static const AVClass aacenc_class = {
1404  .class_name = "AAC encoder",
1405  .item_name = av_default_item_name,
1406  .option = aacenc_options,
1407  .version = LIBAVUTIL_VERSION_INT,
1408 };
1409 
1411  { "b", "0" },
1412  { NULL }
1413 };
1414 
1416  .p.name = "aac",
1417  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
1418  .p.type = AVMEDIA_TYPE_AUDIO,
1419  .p.id = AV_CODEC_ID_AAC,
1420  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1422  .priv_data_size = sizeof(AACEncContext),
1423  .init = aac_encode_init,
1425  .close = aac_encode_end,
1426  .defaults = aac_encode_defaults,
1427  .p.supported_samplerates = ff_mpeg4audio_sample_rates,
1428  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1429  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1431  .p.priv_class = &aacenc_class,
1432 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:97
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1035
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:1425
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
aacenc_class
static const AVClass aacenc_class
Definition: aacenc.c:1403
AV_CHANNEL_LAYOUT_2POINT1
#define AV_CHANNEL_LAYOUT_2POINT1
Definition: channel_layout.h:358
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
put_bitstream_info
static void put_bitstream_info(AACEncContext *s, const char *name)
Write some auxiliary information about the created AAC file.
Definition: aacenc.c:787
ff_aac_kbd_short_128
float ff_aac_kbd_short_128[128]
libm.h
SingleChannelElement::pulse
Pulse pulse
Definition: aac.h:252
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:413
TYPE_FIL
@ TYPE_FIL
Definition: aac.h:64
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
out
FILE * out
Definition: movenc.c:54
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1007
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
aacenctab.h
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:367
abs_pow34_v
static void abs_pow34_v(float *out, const float *in, const int size)
Definition: aacenc_utils.h:40
copy_input_samples
static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
Definition: aacenc.c:808
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: aacenc.c:1224
aacenc_profiles
static const int aacenc_profiles[]
Definition: aacenctab.h:126
Pulse::num_pulse
int num_pulse
Definition: aac.h:226
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:216
AV_CHANNEL_LAYOUT_4POINT1
#define AV_CHANNEL_LAYOUT_4POINT1
Definition: channel_layout.h:363
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
FF_PROFILE_AAC_MAIN
#define FF_PROFILE_AAC_MAIN
Definition: avcodec.h:1554
SingleChannelElement::zeroes
uint8_t zeroes[128]
band is not coded (used by encoder)
Definition: aac.h:258
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
AV_CHANNEL_LAYOUT_6POINT1
#define AV_CHANNEL_LAYOUT_6POINT1
Definition: channel_layout.h:373
ff_lpc_init
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
Definition: lpc.c:307
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
WARN_IF
#define WARN_IF(cond,...)
Definition: aacenc_utils.h:274
w
uint8_t w
Definition: llviddspenc.c:38
R
#define R
Definition: huffyuvdsp.h:34
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_aac_coders
const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]
Definition: aaccoder.c:1119
AV_CHANNEL_LAYOUT_4POINT0
#define AV_CHANNEL_LAYOUT_4POINT0
Definition: channel_layout.h:362
AVOption
AVOption.
Definition: opt.h:251
encode.h
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:154
FF_PROFILE_AAC_LTP
#define FF_PROFILE_AAC_LTP
Definition: avcodec.h:1557
encode_band_info
static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
Encode scalefactor band coding type.
Definition: aacenc.c:644
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:356
AV_CHANNEL_LAYOUT_7POINT1_WIDE
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE
Definition: channel_layout.h:379
TemporalNoiseShaping::present
int present
Definition: aac.h:200
AV_CH_LAYOUT_6POINT0_FRONT
#define AV_CH_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:219
FFCodec
Definition: codec_internal.h:119
version.h
FFPsyWindowInfo::window_shape
int window_shape
window shape (sine/KBD/whatever)
Definition: psymodel.h:79
float.h
aac_chan_configs
static const uint8_t aac_chan_configs[AAC_MAX_CHANNELS][6]
default channel configurations
Definition: aacenctab.h:59
AAC_CODER_NB
@ AAC_CODER_NB
Definition: aacenc.h:43
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aac.h:169
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:357
SingleChannelElement::pcoeffs
INTFLOAT pcoeffs[1024]
coefficients for IMDCT, pristine
Definition: aac.h:262
max
#define max(a, b)
Definition: cuda_runtime.h:33
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:303
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1387
AV_CHANNEL_LAYOUT_6POINT0
#define AV_CHANNEL_LAYOUT_6POINT0
Definition: channel_layout.h:370
encode_spectral_coeffs
static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
Encode spectral coefficients processed by psychoacoustic model.
Definition: aacenc.c:713
ff_tns_max_bands_1024
const uint8_t ff_tns_max_bands_1024[]
Definition: aactab.c:1413
AAC_CODER_FAST
@ AAC_CODER_FAST
Definition: aacenc.h:41
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:366
init
static int init
Definition: av_tx.c:47
AV_CHANNEL_LAYOUT_7POINT0
#define AV_CHANNEL_LAYOUT_7POINT0
Definition: channel_layout.h:376
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aac.h:184
WINDOW_FUNC
#define WINDOW_FUNC(type)
Definition: aacenc.c:409
avoid_clipping
static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
Downscale spectral coefficients for near-clipping windows to avoid artifacts.
Definition: aacenc.c:741
FFCodecDefault
Definition: codec_internal.h:89
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
mpeg4audio.h
AV_CHANNEL_LAYOUT_HEXAGONAL
#define AV_CHANNEL_LAYOUT_HEXAGONAL
Definition: channel_layout.h:372
SingleChannelElement::ret_buf
INTFLOAT ret_buf[2048]
PCM output buffer.
Definition: aac.h:265
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2059
FF_PROFILE_MPEG2_AAC_LOW
#define FF_PROFILE_MPEG2_AAC_LOW
Definition: avcodec.h:1562
apply_mid_side_stereo
static void apply_mid_side_stereo(ChannelElement *cpe)
Definition: aacenc.c:609
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:59
ChannelElement::ms_mode
int ms_mode
Signals mid/side stereo flags coding mode (used by encoder)
Definition: aac.h:280
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:162
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1726
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:360
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
Pulse::amp
int amp[4]
Definition: aac.h:229
Pulse::pos
int pos[4]
Definition: aac.h:228
put_pce
static void put_pce(PutBitContext *pb, AVCodecContext *avctx)
Definition: aacenc.c:327
ff_psy_end
av_cold void ff_psy_end(FFPsyContext *ctx)
Cleanup model context at the end.
Definition: psymodel.c:83
Pulse::start
int start
Definition: aac.h:227
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:288
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aac.h:191
AACPCEInfo::num_ele
int num_ele[4]
front, side, back, lfe
Definition: aacenc.h:98
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:250
FFPsyWindowInfo
windowing related information
Definition: psymodel.h:77
adjust_frame_information
static void adjust_frame_information(ChannelElement *cpe, int chans)
Produce integer coefficients from scalefactors provided by the model.
Definition: aacenc.c:530
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:364
IndividualChannelStream::clip_avoidance_factor
float clip_avoidance_factor
set if any window is near clipping to the necessary atennuation factor to avoid it
Definition: aac.h:193
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:112
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:500
NOISE_BT
@ NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:89
s
#define s(width, name)
Definition: cbs_vp9.c:256
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:263
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:464
IndividualChannelStream::swb_sizes
const uint8_t * swb_sizes
table of scalefactor band sizes for a particular window
Definition: aac.h:183
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:80
info
MIPS optimizations info
Definition: mips.txt:2
AV_CHANNEL_LAYOUT_6POINT0_FRONT
#define AV_CHANNEL_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:371
INTENSITY_BT2
@ INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:90
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aac.h:180
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1551
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
alloc_buffers
static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1211
ff_aac_swb_size_128_len
const int ff_aac_swb_size_128_len
Definition: aacenctab.c:107
channels
channels
Definition: aptx.h:31
LongTermPrediction::present
int8_t present
Definition: aac.h:165
ff_put_string
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:39
IndividualChannelStream
Individual Channel Stream.
Definition: aac.h:175
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:153
NAN
#define NAN
Definition: mathematics.h:64
NOISE_PRE
#define NOISE_PRE
preamble for NOISE_BT, put in bitstream with the first noise band
Definition: aac.h:157
PutBitContext
Definition: put_bits.h:50
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aac.h:182
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
ff_aac_tableinit
void ff_aac_tableinit(void)
Definition: aactab.c:3347
aac_chan_maps
static const uint8_t aac_chan_maps[AAC_MAX_CHANNELS][AAC_MAX_CHANNELS]
Table to remap channels from libavcodec's default order to AAC order.
Definition: aacenctab.h:73
if
if(ret)
Definition: filter_design.txt:179
INTENSITY_BT
@ INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:91
FFPsyWindowInfo::window_type
int window_type[3]
window type (short/long/transitional, etc.) - current, previous and next
Definition: psymodel.h:78
AAC_MAX_CHANNELS
#define AAC_MAX_CHANNELS
Definition: aacenctab.h:40
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
aac_normal_chan_layouts
static const AVChannelLayout aac_normal_chan_layouts[7]
Definition: aacenctab.h:48
AV_CH_TOP_CENTER
#define AV_CH_TOP_CENTER
Definition: channel_layout.h:169
ChannelElement::is_mask
uint8_t is_mask[128]
Set if intensity stereo is used (used by encoder)
Definition: aac.h:283
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:57
ff_aac_swb_size_1024_len
const int ff_aac_swb_size_1024_len
Definition: aacenctab.c:108
encode_pulses
static void encode_pulses(AACEncContext *s, Pulse *pulse)
Encode pulse data.
Definition: aacenc.c:694
SingleChannelElement::is_ener
float is_ener[128]
Intensity stereo pos (used by encoder)
Definition: aac.h:260
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:80
AV_CHANNEL_LAYOUT_6POINT1_FRONT
#define AV_CHANNEL_LAYOUT_6POINT1_FRONT
Definition: channel_layout.h:375
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:448
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:930
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:330
aac.h
aactab.h
IndividualChannelStream::predictor_present
int predictor_present
Definition: aac.h:187
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:378
FFPsyWindowInfo::grouping
int grouping[8]
window grouping (for e.g. AAC)
Definition: psymodel.h:81
av_clipf
av_clipf
Definition: af_crystalizer.c:122
TNS_MAX_ORDER
#define TNS_MAX_ORDER
Definition: aac.h:52
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices (used by encoder)
Definition: aac.h:257
float_dsp.h
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:435
aac_encode_frame
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: aacenc.c:830
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:111
AACPCEInfo
Definition: aacenc.h:96
FFPsyWindowInfo::clipping
float clipping[8]
maximum absolute normalized intensity in the given window for clip avoidance
Definition: psymodel.h:82
options
const OptionDef options[]
SingleChannelElement::lcoeffs
AAC_FLOAT lcoeffs[1024]
MDCT of LTP coefficients (used by encoder)
Definition: aac.h:267
AAC_CODER_ANMR
@ AAC_CODER_ANMR
Definition: aacenc.h:39
f
f
Definition: af_crystalizer.c:122
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aac.h:285
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1355
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:78
TYPE_END
@ TYPE_END
Definition: aac.h:65
quantize_bands
static void quantize_bands(int *out, const float *in, const float *scaled, int size, int is_signed, int maxval, const float Q34, const float rounding)
Definition: aacenc_utils.h:65
ff_aac_float_common_init
void ff_aac_float_common_init(void)
FF_PROFILE_AAC_LOW
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:1555
encode_scale_factors
static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce)
Encode scalefactors.
Definition: aacenc.c:658
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_CHANNEL_LAYOUT_2_1
#define AV_CHANNEL_LAYOUT_2_1
Definition: channel_layout.h:359
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:155
apply_window_and_mdct
static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce, float *audio)
Definition: aacenc.c:474
AV_CHANNEL_LAYOUT_OCTAGONAL
#define AV_CHANNEL_LAYOUT_OCTAGONAL
Definition: channel_layout.h:381
AVFloatDSPContext
Definition: float_dsp.h:24
AAC_CODER_TWOLOOP
@ AAC_CODER_TWOLOOP
Definition: aacenc.h:40
ff_aac_coder_init_mips
void ff_aac_coder_init_mips(AACEncContext *c)
Definition: aaccoder_mips.c:2484
ChannelElement::common_window
int common_window
Set if channels share a common 'IndividualChannelStream' in bitstream.
Definition: aac.h:279
sinewin.h
apply_intensity_stereo
static void apply_intensity_stereo(ChannelElement *cpe)
Definition: aacenc.c:580
AACPCEInfo::index
int index[4][8]
front, side, back, lfe
Definition: aacenc.h:100
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aac.h:282
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
ff_psy_init
av_cold int ff_psy_init(FFPsyContext *ctx, AVCodecContext *avctx, int num_lens, const uint8_t **bands, const int *num_bands, int num_groups, const uint8_t *group_map)
Initialize psychoacoustic model.
Definition: psymodel.c:31
AV_CHANNEL_LAYOUT_3POINT1
#define AV_CHANNEL_LAYOUT_3POINT1
Definition: channel_layout.h:361
AV_CH_LAYOUT_OCTAGONAL
#define AV_CH_LAYOUT_OCTAGONAL
Definition: channel_layout.h:229
aac_pce_configs
static const AACPCEInfo aac_pce_configs[]
List of PCE (Program Configuration Element) for the channel layouts listed in channel_layout....
Definition: aacenc.c:89
AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
Definition: channel_layout.h:380
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:249
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
IndividualChannelStream::num_windows
int num_windows
Definition: aac.h:185
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:499
aacenc_options
static const AVOption aacenc_options[]
Definition: aacenc.c:1387
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:81
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:276
apply_window
static void(*const apply_window[4])(AVFloatDSPContext *fdsp, SingleChannelElement *sce, const float *audio)
Definition: aacenc.c:465
AACPCEInfo::pairing
int pairing[3][8]
front, side, back
Definition: aacenc.h:99
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:158
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:166
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:61
ff_psy_preprocess_init
av_cold struct FFPsyPreprocessContext * ff_psy_preprocess_init(AVCodecContext *avctx)
psychoacoustic model audio preprocessing initialization
Definition: psymodel.c:103
ff_aac_kbd_long_1024
float ff_aac_kbd_long_1024[1024]
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_aac_dsp_init_x86
void ff_aac_dsp_init_x86(AACEncContext *s)
Definition: aacencdsp_init.c:35
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:58
AACENC_FLAGS
#define AACENC_FLAGS
Definition: aacenc.c:1386
AV_CHANNEL_LAYOUT_7POINT0_FRONT
#define AV_CHANNEL_LAYOUT_7POINT0_FRONT
Definition: channel_layout.h:377
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aac.h:186
avcodec.h
aac_encode_defaults
static const FFCodecDefault aac_encode_defaults[]
Definition: aacenc.c:1410
tag
uint32_t tag
Definition: movenc.c:1646
ret
ret
Definition: filter_design.txt:187
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:64
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_aac_encoder
const FFCodec ff_aac_encoder
Definition: aacenc.c:1415
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1310
encode_ms_info
static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
Encode MS data.
Definition: aacenc.c:516
AV_CHANNEL_LAYOUT_6POINT1_BACK
#define AV_CHANNEL_LAYOUT_6POINT1_BACK
Definition: channel_layout.h:374
RESERVED_BT
@ RESERVED_BT
Band types following are encoded differently from others.
Definition: aac.h:88
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:79
ff_psy_preprocess
void ff_psy_preprocess(struct FFPsyPreprocessContext *ctx, float **audio, int channels)
Preprocess several channel in audio frame in order to compress it better.
Definition: psymodel.c:139
CLIP_AVOIDANCE_FACTOR
#define CLIP_AVOIDANCE_FACTOR
Definition: aac.h:55
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:368
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aac.h:251
AACEncContext
AAC encoder context.
Definition: aacenc.h:108
AVCodecContext
main external API structure.
Definition: avcodec.h:398
channel_layout.h
encode_individual_channel
static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, int common_window)
Encode one channel of audio data.
Definition: aacenc.c:761
NOISE_OFFSET
#define NOISE_OFFSET
subtracted from global gain, used as offset for the preamble
Definition: aac.h:159
ERROR_IF
#define ERROR_IF(cond,...)
Definition: aacenc_utils.h:268
ff_aac_swb_size_1024
const uint8_t *const ff_aac_swb_size_1024[]
Definition: aacenctab.c:99
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aac.h:177
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aac.h:199
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1550
AOT_SBR
@ AOT_SBR
Y Spectral Band Replication.
Definition: mpeg4audio.h:80
L
#define L(x)
Definition: vpx_arith.h:36
put_audio_specific_config
static int put_audio_specific_config(AVCodecContext *avctx)
Make AAC audio config object.
Definition: aacenc.c:368
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:82
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ChannelElement::is_mode
uint8_t is_mode
Set if any bands have been encoded using intensity stereo (used by encoder)
Definition: aac.h:281
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:776
put_ics_info
static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
Encode ics_info element.
Definition: aacenc.c:495
ff_mpeg4audio_sample_rates
const int ff_mpeg4audio_sample_rates[16]
Definition: mpeg4audio_sample_rates.h:26
ff_aac_swb_size_128
const uint8_t *const ff_aac_swb_size_128[]
Definition: aacenctab.c:91
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:288
aac_encode_end
static av_cold int aac_encode_end(AVCodecContext *avctx)
Definition: aacenc.c:1173
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1046
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AV_CHANNEL_LAYOUT_HEXADECAGONAL
#define AV_CHANNEL_LAYOUT_HEXADECAGONAL
Definition: channel_layout.h:382
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:28
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
IndividualChannelStream::window_clipping
uint8_t window_clipping[8]
set if a certain window is near clipping
Definition: aac.h:192
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:176
Pulse
Definition: aac.h:225
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
SingleChannelElement::ltp_state
INTFLOAT ltp_state[3072]
time signal for LTP
Definition: aac.h:266
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:163
dsp_init
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1192
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aac.h:181
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:365
ff_psy_preprocess_end
av_cold void ff_psy_preprocess_end(struct FFPsyPreprocessContext *ctx)
Cleanup audio preprocessing module.
Definition: psymodel.c:152
aacenc_utils.h
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:369
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:87
put_bits.h
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aac.h:253
psymodel.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aac.h:178
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:35
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:48
FFPsyWindowInfo::num_windows
int num_windows
number of windows in a frame
Definition: psymodel.h:80
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:92
ff_quantize_band_cost_cache_init
void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
Definition: aacenc.c:400
AACPCEInfo::layout
AVChannelLayout layout
Definition: aacenc.h:97
aacenc.h