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  float *output = sce->ret_buf;
479 
480  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
481 
483  s->mdct1024_fn(s->mdct1024, sce->coeffs, output, sizeof(float));
484  else
485  for (i = 0; i < 1024; i += 128)
486  s->mdct128_fn(s->mdct128, &sce->coeffs[i], output + i*2, sizeof(float));
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],
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_num)
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_fn(s->mdct1024, sce->lcoeffs, sce->ret_buf, sizeof(float));
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_num & 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 strict bit-rate control is demanded */
1110  if (avctx->bit_rate_tolerance == 0) {
1111  if (rate_bits < frame_bits) {
1112  float ratio = ((float)rate_bits) / frame_bits;
1113  s->lambda *= FFMIN(0.9f, ratio);
1114  continue;
1115  }
1116  /* reset lambda when solution is found */
1117  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1118  break;
1119  }
1120 
1121  /* When using ABR, be strict (but only for increasing) */
1122  too_few_bits = too_few_bits - too_few_bits/8;
1123  too_many_bits = too_many_bits + too_many_bits/2;
1124 
1125  if ( its == 0 /* for steady-state Q-scale tracking */
1126  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
1127  || frame_bits >= 6144 * s->channels - 3 )
1128  {
1129  float ratio = ((float)rate_bits) / frame_bits;
1130 
1131  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
1132  /*
1133  * This path is for steady-state Q-scale tracking
1134  * When frame bits fall within the stable range, we still need to adjust
1135  * lambda to maintain it like so in a stable fashion (large jumps in lambda
1136  * create artifacts and should be avoided), but slowly
1137  */
1138  ratio = sqrtf(sqrtf(ratio));
1139  ratio = av_clipf(ratio, 0.9f, 1.1f);
1140  } else {
1141  /* Not so fast though */
1142  ratio = sqrtf(ratio);
1143  }
1144  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
1145 
1146  /* Keep iterating if we must reduce and lambda is in the sky */
1147  if (ratio > 0.9f && ratio < 1.1f) {
1148  break;
1149  } else {
1150  if (is_mode || ms_mode || tns_mode || pred_mode) {
1151  for (i = 0; i < s->chan_map[0]; i++) {
1152  // Must restore coeffs
1153  chans = tag == TYPE_CPE ? 2 : 1;
1154  cpe = &s->cpe[i];
1155  for (ch = 0; ch < chans; ch++)
1156  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
1157  }
1158  }
1159  its++;
1160  }
1161  } else {
1162  break;
1163  }
1164  } while (1);
1165 
1166  if (s->options.ltp && s->coder->ltp_insert_new_frame)
1167  s->coder->ltp_insert_new_frame(s);
1168 
1169  put_bits(&s->pb, 3, TYPE_END);
1170  flush_put_bits(&s->pb);
1171 
1172  s->last_frame_pb_count = put_bits_count(&s->pb);
1173  avpkt->size = put_bytes_output(&s->pb);
1174 
1175  s->lambda_sum += s->lambda;
1176  s->lambda_count++;
1177 
1178  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
1179  &avpkt->duration);
1180 
1181  *got_packet_ptr = 1;
1182  return 0;
1183 }
1184 
1186 {
1187  AACEncContext *s = avctx->priv_data;
1188 
1189  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
1190 
1191  av_tx_uninit(&s->mdct1024);
1192  av_tx_uninit(&s->mdct128);
1193  ff_psy_end(&s->psy);
1194  ff_lpc_end(&s->lpc);
1195  if (s->psypp)
1196  ff_psy_preprocess_end(s->psypp);
1197  av_freep(&s->buffer.samples);
1198  av_freep(&s->cpe);
1199  av_freep(&s->fdsp);
1200  ff_af_queue_close(&s->afq);
1201  return 0;
1202 }
1203 
1205 {
1206  int ret = 0;
1207  float scale = 32768.0f;
1208 
1210  if (!s->fdsp)
1211  return AVERROR(ENOMEM);
1212 
1213  if ((ret = av_tx_init(&s->mdct1024, &s->mdct1024_fn, AV_TX_FLOAT_MDCT, 0,
1214  1024, &scale, 0)) < 0)
1215  return ret;
1216  if ((ret = av_tx_init(&s->mdct128, &s->mdct128_fn, AV_TX_FLOAT_MDCT, 0,
1217  128, &scale, 0)) < 0)
1218  return ret;
1219 
1220  return 0;
1221 }
1222 
1224 {
1225  int ch;
1226  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
1227  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
1228  return AVERROR(ENOMEM);
1229 
1230  for(ch = 0; ch < s->channels; ch++)
1231  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
1232 
1233  return 0;
1234 }
1235 
1237 {
1238  AACEncContext *s = avctx->priv_data;
1239  int i, ret = 0;
1240  const uint8_t *sizes[2];
1241  uint8_t grouping[AAC_MAX_CHANNELS];
1242  int lengths[2];
1243 
1244  /* Constants */
1245  s->last_frame_pb_count = 0;
1246  avctx->frame_size = 1024;
1247  avctx->initial_padding = 1024;
1248  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1249 
1250  /* Channel map and unspecified bitrate guessing */
1251  s->channels = avctx->ch_layout.nb_channels;
1252 
1253  s->needs_pce = 1;
1254  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
1256  s->needs_pce = s->options.pce;
1257  break;
1258  }
1259  }
1260 
1261  if (s->needs_pce) {
1262  char buf[64];
1263  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
1265  break;
1266  av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
1267  if (i == FF_ARRAY_ELEMS(aac_pce_configs)) {
1268  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout \"%s\"\n", buf);
1269  return AVERROR(EINVAL);
1270  }
1271  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
1272  s->pce = aac_pce_configs[i];
1273  s->reorder_map = s->pce.reorder_map;
1274  s->chan_map = s->pce.config_map;
1275  } else {
1276  s->reorder_map = aac_chan_maps[s->channels - 1];
1277  s->chan_map = aac_chan_configs[s->channels - 1];
1278  }
1279 
1280  if (!avctx->bit_rate) {
1281  for (i = 1; i <= s->chan_map[0]; i++) {
1282  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
1283  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
1284  69000 ; /* SCE */
1285  }
1286  }
1287 
1288  /* Samplerate */
1289  for (i = 0; i < 16; i++)
1290  if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
1291  break;
1292  s->samplerate_index = i;
1293  ERROR_IF(s->samplerate_index == 16 ||
1294  s->samplerate_index >= ff_aac_swb_size_1024_len ||
1295  s->samplerate_index >= ff_aac_swb_size_128_len,
1296  "Unsupported sample rate %d\n", avctx->sample_rate);
1297 
1298  /* Bitrate limiting */
1299  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1300  "Too many bits %f > %d per frame requested, clamping to max\n",
1301  1024.0 * avctx->bit_rate / avctx->sample_rate,
1302  6144 * s->channels);
1303  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1304  avctx->bit_rate);
1305 
1306  /* Profile and option setting */
1307  avctx->profile = avctx->profile == AV_PROFILE_UNKNOWN ? AV_PROFILE_AAC_LOW :
1308  avctx->profile;
1309  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1310  if (avctx->profile == aacenc_profiles[i])
1311  break;
1312  if (avctx->profile == AV_PROFILE_MPEG2_AAC_LOW) {
1313  avctx->profile = AV_PROFILE_AAC_LOW;
1314  ERROR_IF(s->options.pred,
1315  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1316  ERROR_IF(s->options.ltp,
1317  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1318  WARN_IF(s->options.pns,
1319  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1320  s->options.pns = 0;
1321  } else if (avctx->profile == AV_PROFILE_AAC_LTP) {
1322  s->options.ltp = 1;
1323  ERROR_IF(s->options.pred,
1324  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1325  } else if (avctx->profile == AV_PROFILE_AAC_MAIN) {
1326  s->options.pred = 1;
1327  ERROR_IF(s->options.ltp,
1328  "LTP prediction unavailable in the \"aac_main\" profile\n");
1329  } else if (s->options.ltp) {
1330  avctx->profile = AV_PROFILE_AAC_LTP;
1331  WARN_IF(1,
1332  "Chainging profile to \"aac_ltp\"\n");
1333  ERROR_IF(s->options.pred,
1334  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1335  } else if (s->options.pred) {
1336  avctx->profile = AV_PROFILE_AAC_MAIN;
1337  WARN_IF(1,
1338  "Chainging profile to \"aac_main\"\n");
1339  ERROR_IF(s->options.ltp,
1340  "LTP prediction unavailable in the \"aac_main\" profile\n");
1341  }
1342  s->profile = avctx->profile;
1343 
1344  /* Coder limitations */
1345  s->coder = &ff_aac_coders[s->options.coder];
1346  if (s->options.coder == AAC_CODER_ANMR) {
1348  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
1349  s->options.intensity_stereo = 0;
1350  s->options.pns = 0;
1351  }
1353  "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
1354 
1355  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1356  if (s->channels > 3)
1357  s->options.mid_side = 0;
1358 
1359  // Initialize static tables
1361 
1362  if ((ret = dsp_init(avctx, s)) < 0)
1363  return ret;
1364 
1365  if ((ret = alloc_buffers(avctx, s)) < 0)
1366  return ret;
1367 
1368  if ((ret = put_audio_specific_config(avctx)))
1369  return ret;
1370 
1371  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1372  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1373  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1374  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1375  for (i = 0; i < s->chan_map[0]; i++)
1376  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1377  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1378  s->chan_map[0], grouping)) < 0)
1379  return ret;
1380  s->psypp = ff_psy_preprocess_init(avctx);
1382  s->random_state = 0x1f2e3d4c;
1383 
1384  ff_aacenc_dsp_init(&s->aacdsp);
1385 
1386  ff_af_queue_init(avctx, &s->afq);
1387 
1388  return 0;
1389 }
1390 
1391 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1392 static const AVOption aacenc_options[] = {
1393  {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, .unit = "coder"},
1394  {"anmr", "ANMR method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1395  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1396  {"fast", "Default fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1397  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1398  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1399  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1400  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1401  {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1402  {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1403  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1405  {NULL}
1406 };
1407 
1408 static const AVClass aacenc_class = {
1409  .class_name = "AAC encoder",
1410  .item_name = av_default_item_name,
1411  .option = aacenc_options,
1412  .version = LIBAVUTIL_VERSION_INT,
1413 };
1414 
1416  { "b", "0" },
1417  { NULL }
1418 };
1419 
1421  .p.name = "aac",
1422  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
1423  .p.type = AVMEDIA_TYPE_AUDIO,
1424  .p.id = AV_CODEC_ID_AAC,
1425  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1427  .priv_data_size = sizeof(AACEncContext),
1428  .init = aac_encode_init,
1430  .close = aac_encode_end,
1431  .defaults = aac_encode_defaults,
1432  .p.supported_samplerates = ff_mpeg4audio_sample_rates,
1433  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1434  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1436  .p.priv_class = &aacenc_class,
1437 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:88
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
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
SingleChannelElement::lcoeffs
float lcoeffs[1024]
MDCT of LTP coefficients.
Definition: aacenc.h:128
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:1503
AV_CHANNEL_LAYOUT_OCTAGONAL
#define AV_CHANNEL_LAYOUT_OCTAGONAL
Definition: channel_layout.h:405
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:1408
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: aacenc.h:116
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:420
TYPE_FIL
@ TYPE_FIL
Definition: aac.h:49
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
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:379
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:1050
AV_CHANNEL_LAYOUT_4POINT1
#define AV_CHANNEL_LAYOUT_4POINT1
Definition: channel_layout.h:385
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
aacenctab.h
AV_CHANNEL_LAYOUT_HEXAGONAL
#define AV_CHANNEL_LAYOUT_HEXAGONAL
Definition: channel_layout.h:395
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:1236
aacenc_profiles
static const int aacenc_profiles[]
Definition: aacenctab.h:127
Pulse::num_pulse
int num_pulse
Definition: aac.h:117
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
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
SingleChannelElement::zeroes
uint8_t zeroes[128]
band is not coded
Definition: aacenc.h:120
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
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:338
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:386
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aacdec.h:78
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:222
WARN_IF
#define WARN_IF(cond,...)
Definition: aacenc_utils.h:250
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:522
ff_aac_coders
const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]
Definition: aaccoder.c:1119
AVOption
AVOption.
Definition: opt.h:346
encode.h
R
#define R
Definition: huffyuv.h:44
encode_band_info
static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
Encode scalefactor band coding type.
Definition: aacenc.c:644
AV_PROFILE_MPEG2_AAC_LOW
#define AV_PROFILE_MPEG2_AAC_LOW
Definition: defs.h:76
TemporalNoiseShaping::present
int present
Definition: aacdec.h:106
AV_CH_LAYOUT_6POINT0_FRONT
#define AV_CH_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:219
FFCodec
Definition: codec_internal.h:127
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:60
AAC_CODER_NB
@ AAC_CODER_NB
Definition: aacenc.h:49
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
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:313
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aacdec.h:153
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1465
av_tx_init
av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)
Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...
Definition: tx.c:902
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:1491
AAC_CODER_FAST
@ AAC_CODER_FAST
Definition: aacenc.h:47
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aacdec.h:92
AV_CHANNEL_LAYOUT_7POINT1_WIDE
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE
Definition: channel_layout.h:402
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:97
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
mpeg4audio.h
SingleChannelElement::ret_buf
INTFLOAT ret_buf[2048]
PCM output buffer.
Definition: aacdec.h:139
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
apply_mid_side_stereo
static void apply_mid_side_stereo(ChannelElement *cpe)
Definition: aacenc.c:609
AV_CHANNEL_LAYOUT_2POINT1
#define AV_CHANNEL_LAYOUT_2POINT1
Definition: channel_layout.h:380
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:44
ChannelElement::ms_mode
int ms_mode
Signals mid/side stereo flags coding mode.
Definition: aacenc.h:139
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:172
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1122
IndividualChannelStream::window_clipping
uint8_t window_clipping[8]
set if a certain window is near clipping
Definition: aacdec.h:99
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
Pulse::amp
int amp[4]
Definition: aac.h:120
Pulse::pos
int pos[4]
Definition: aac.h:119
AVCodecContext::bit_rate_tolerance
int bit_rate_tolerance
number of bits the bitstream is allowed to diverge from the reference.
Definition: avcodec.h:1231
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:118
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
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
AV_CHANNEL_LAYOUT_6POINT1_FRONT
#define AV_CHANNEL_LAYOUT_6POINT1_FRONT
Definition: channel_layout.h:398
AACPCEInfo::num_ele
int num_ele[4]
front, side, back, lfe
Definition: aacenc.h:188
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:132
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:382
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_PROFILE_UNKNOWN
#define AV_PROFILE_UNKNOWN
Definition: defs.h:65
IndividualChannelStream::clip_avoidance_factor
float clip_avoidance_factor
set if any window is near clipping to the necessary atennuation factor to avoid it
Definition: aacenc.h:94
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:644
AV_CHANNEL_LAYOUT_4POINT0
#define AV_CHANNEL_LAYOUT_4POINT0
Definition: channel_layout.h:384
float
float
Definition: af_crystalizer.c:121
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:524
NOISE_BT
@ NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:74
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:401
s
#define s(width, name)
Definition: cbs_vp9.c:198
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacdec.h:137
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
AV_PROFILE_AAC_LTP
#define AV_PROFILE_AAC_LTP
Definition: defs.h:71
IndividualChannelStream::swb_sizes
const uint8_t * swb_sizes
table of scalefactor band sizes for a particular window
Definition: aacenc.h:84
g
const char * g
Definition: vf_curves.c:127
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:65
info
MIPS optimizations info
Definition: mips.txt:2
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:390
INTENSITY_BT2
@ INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:75
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
alloc_buffers
static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1223
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: aacdec.h:75
channel_map
static const uint8_t channel_map[8][8]
Definition: atrac3plusdec.c:51
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: aacdec.h:84
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:108
NAN
#define NAN
Definition: mathematics.h:115
NOISE_PRE
#define NOISE_PRE
preamble for NOISE_BT, put in bitstream with the first noise band
Definition: aac.h:112
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
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:74
if
if(ret)
Definition: filter_design.txt:179
AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
Definition: channel_layout.h:403
INTENSITY_BT
@ INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:76
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:41
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:49
AV_CH_TOP_CENTER
#define AV_CH_TOP_CENTER
Definition: channel_layout.h:179
ChannelElement::is_mask
uint8_t is_mask[128]
Set if intensity stereo is used.
Definition: aacenc.h:142
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:59
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.
Definition: aacenc.h:122
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aacdec.h:87
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:165
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:495
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
profiles.h
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:363
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aacdec.h:151
aac.h
aactab.h
IndividualChannelStream::predictor_present
int predictor_present
Definition: aacdec.h:95
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
FFPsyWindowInfo::grouping
int grouping[8]
window grouping (for e.g. AAC)
Definition: psymodel.h:81
av_clipf
av_clipf
Definition: af_crystalizer.c:121
TNS_MAX_ORDER
#define TNS_MAX_ORDER
Definition: aac.h:39
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices
Definition: aacenc.h:119
float_dsp.h
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:442
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:196
AACPCEInfo
Definition: aacenc.h:186
FFPsyWindowInfo::clipping
float clipping[8]
maximum absolute normalized intensity in the given window for clip avoidance
Definition: psymodel.h:82
options
const OptionDef options[]
AAC_CODER_ANMR
@ AAC_CODER_ANMR
Definition: aacenc.h:45
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aacdec.h:86
f
f
Definition: af_crystalizer.c:121
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1433
AVPacket::size
int size
Definition: packet.h:523
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: vvc_intra.c:291
codec_internal.h
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:63
TYPE_END
@ TYPE_END
Definition: aac.h:50
ff_aac_float_common_init
void ff_aac_float_common_init(void)
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_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
apply_window_and_mdct
static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce, float *audio)
Definition: aacenc.c:474
AVFloatDSPContext
Definition: float_dsp.h:22
AAC_CODER_TWOLOOP
@ AAC_CODER_TWOLOOP
Definition: aacenc.h:46
AV_CHANNEL_LAYOUT_6POINT0
#define AV_CHANNEL_LAYOUT_6POINT0
Definition: channel_layout.h:392
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
CLIP_AVOIDANCE_FACTOR
#define CLIP_AVOIDANCE_FACTOR
Definition: aacenc.h:42
ChannelElement::common_window
int common_window
Set if channels share a common 'IndividualChannelStream' in bitstream.
Definition: aacenc.h:138
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:190
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:118
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aacdec.h:134
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:294
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:800
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_HEXADECAGONAL
#define AV_CHANNEL_LAYOUT_HEXADECAGONAL
Definition: channel_layout.h:412
AV_CHANNEL_LAYOUT_6POINT1_BACK
#define AV_CHANNEL_LAYOUT_6POINT1_BACK
Definition: channel_layout.h:397
AV_CH_LAYOUT_OCTAGONAL
#define AV_CH_LAYOUT_OCTAGONAL
Definition: channel_layout.h:231
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
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:420
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aacdec.h:131
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
IndividualChannelStream::num_windows
int num_windows
Definition: aacdec.h:93
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:523
aacenc_options
static const AVOption aacenc_options[]
Definition: aacenc.c:1392
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:387
SingleChannelElement::pcoeffs
float pcoeffs[1024]
coefficients for IMDCT, pristine
Definition: aacenc.h:124
AVFrame::extended_data
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:401
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:66
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:148
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: aacdec.h:91
AV_CHANNEL_LAYOUT_7POINT0_FRONT
#define AV_CHANNEL_LAYOUT_7POINT0_FRONT
Definition: channel_layout.h:400
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:189
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:113
AV_CH_BACK_CENTER
#define AV_CH_BACK_CENTER
Definition: channel_layout.h:176
AV_CHANNEL_LAYOUT_3POINT1
#define AV_CHANNEL_LAYOUT_3POINT1
Definition: channel_layout.h:383
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:46
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:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:43
AACENC_FLAGS
#define AACENC_FLAGS
Definition: aacenc.c:1391
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aacdec.h:94
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2030
aac_encode_defaults
static const FFCodecDefault aac_encode_defaults[]
Definition: aacenc.c:1415
tag
uint32_t tag
Definition: movenc.c:1786
ret
ret
Definition: filter_design.txt:187
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:149
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
ff_aac_encoder
const FFCodec ff_aac_encoder
Definition: aacenc.c:1420
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1379
encode_ms_info
static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
Encode MS data.
Definition: aacenc.c:516
AV_CHANNEL_LAYOUT_7POINT0
#define AV_CHANNEL_LAYOUT_7POINT0
Definition: channel_layout.h:399
RESERVED_BT
@ RESERVED_BT
Band types following are encoded differently from others.
Definition: aac.h:73
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:64
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
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aacdec.h:133
AACEncContext
AAC encoder context.
Definition: aacenc.h:198
AV_PROFILE_AAC_LOW
#define AV_PROFILE_AAC_LOW
Definition: defs.h:69
AV_CHANNEL_LAYOUT_2_1
#define AV_CHANNEL_LAYOUT_2_1
Definition: channel_layout.h:381
AVCodecContext
main external API structure.
Definition: avcodec.h:445
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:114
ERROR_IF
#define ERROR_IF(cond,...)
Definition: aacenc_utils.h:244
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aacdec.h:98
ff_aac_swb_size_1024
const uint8_t *const ff_aac_swb_size_1024[]
Definition: aacenctab.c:99
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aacdec.h:105
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1639
AOT_SBR
@ AOT_SBR
Y Spectral Band Replication.
Definition: mpeg4audio.h:77
L
#define L(x)
Definition: vpx_arith.h:36
AV_PROFILE_AAC_MAIN
#define AV_PROFILE_AAC_MAIN
Definition: defs.h:68
AV_CHANNEL_LAYOUT_6POINT0_FRONT
#define AV_CHANNEL_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:393
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:76
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.
Definition: aacenc.h:140
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:342
aac_encode_end
static av_cold int aac_encode_end(AVCodecContext *avctx)
Definition: aacenc.c:1185
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:378
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:28
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:251
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
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:391
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aacdec.h:85
Pulse
Definition: aac.h:116
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CHANNEL_LAYOUT_6POINT1
#define AV_CHANNEL_LAYOUT_6POINT1
Definition: channel_layout.h:396
SingleChannelElement::ltp_state
INTFLOAT ltp_state[3072]
time signal for LTP
Definition: aacdec.h:140
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:173
dsp_init
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1204
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:388
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aacdec.h:90
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_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:81
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:389
put_bits.h
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aacdec.h:89
psymodel.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:244
ff_aacenc_dsp_init
static void ff_aacenc_dsp_init(AACEncDSPContext *s)
Definition: aacencdsp.h:60
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:46
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:177
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:187
aacenc.h