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/mem.h"
37 #include "libavutil/opt.h"
38 #include "avcodec.h"
39 #include "codec_internal.h"
40 #include "encode.h"
41 #include "put_bits.h"
42 #include "mpeg4audio.h"
43 #include "sinewin.h"
44 #include "profiles.h"
45 #include "version.h"
46 
47 #include "aac.h"
48 #include "aactab.h"
49 #include "aacenc.h"
50 #include "aacenctab.h"
51 #include "aacenc_utils.h"
52 
53 #include "psymodel.h"
54 
55 /**
56  * List of PCE (Program Configuration Element) for the channel layouts listed
57  * in channel_layout.h
58  *
59  * For those wishing in the future to add other layouts:
60  *
61  * - num_ele: number of elements in each group of front, side, back, lfe channels
62  * (an element is of type SCE (single channel), CPE (channel pair) for
63  * the first 3 groups; and is LFE for LFE group).
64  *
65  * - pairing: 0 for an SCE element or 1 for a CPE; does not apply to LFE group
66  *
67  * - index: there are three independent indices for SCE, CPE and LFE;
68  * they are incremented irrespective of the group to which the element belongs;
69  * they are not reset when going from one group to another
70  *
71  * Example: for 7.0 channel layout,
72  * .pairing = { { 1, 0 }, { 1 }, { 1 }, }, (3 CPE and 1 SCE in front group)
73  * .index = { { 0, 0 }, { 1 }, { 2 }, },
74  * (index is 0 for the single SCE but goes from 0 to 2 for the CPEs)
75  *
76  * The index order impacts the channel ordering. But is otherwise arbitrary
77  * (the sequence could have been 2, 0, 1 instead of 0, 1, 2).
78  *
79  * Spec allows for discontinuous indices, e.g. if one has a total of two SCE,
80  * SCE.0 SCE.15 is OK per spec; BUT it won't be decoded by our AAC decoder
81  * which at this time requires that indices fully cover some range starting
82  * from 0 (SCE.1 SCE.0 is OK but not SCE.0 SCE.15).
83  *
84  * - config_map: total number of elements and their types. Beware, the way the
85  * types are ordered impacts the final channel ordering.
86  *
87  * - reorder_map: reorders the channels.
88  *
89  */
90 static const AACPCEInfo aac_pce_configs[] = {
91  {
93  .num_ele = { 1, 0, 0, 0 },
94  .pairing = { { 0 }, },
95  .index = { { 0 }, },
96  .config_map = { 1, TYPE_SCE, },
97  .reorder_map = { 0 },
98  },
99  {
100  .layout = AV_CHANNEL_LAYOUT_STEREO,
101  .num_ele = { 1, 0, 0, 0 },
102  .pairing = { { 1 }, },
103  .index = { { 0 }, },
104  .config_map = { 1, TYPE_CPE, },
105  .reorder_map = { 0, 1 },
106  },
107  {
108  .layout = AV_CHANNEL_LAYOUT_2POINT1,
109  .num_ele = { 1, 0, 0, 1 },
110  .pairing = { { 1 }, },
111  .index = { { 0 },{ 0 },{ 0 },{ 0 } },
112  .config_map = { 2, TYPE_CPE, TYPE_LFE },
113  .reorder_map = { 0, 1, 2 },
114  },
115  {
116  .layout = AV_CHANNEL_LAYOUT_2_1,
117  .num_ele = { 1, 0, 1, 0 },
118  .pairing = { { 1 },{ 0 },{ 0 } },
119  .index = { { 0 },{ 0 },{ 0 }, },
120  .config_map = { 2, TYPE_CPE, TYPE_SCE },
121  .reorder_map = { 0, 1, 2 },
122  },
123  {
124  .layout = AV_CHANNEL_LAYOUT_SURROUND,
125  .num_ele = { 2, 0, 0, 0 },
126  .pairing = { { 1, 0 }, },
127  .index = { { 0, 0 }, },
128  .config_map = { 2, TYPE_CPE, TYPE_SCE, },
129  .reorder_map = { 0, 1, 2 },
130  },
131  {
132  .layout = AV_CHANNEL_LAYOUT_3POINT1,
133  .num_ele = { 2, 0, 0, 1 },
134  .pairing = { { 1, 0 }, },
135  .index = { { 0, 0 }, { 0 }, { 0 }, { 0 }, },
136  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_LFE },
137  .reorder_map = { 0, 1, 2, 3 },
138  },
139  {
140  .layout = AV_CHANNEL_LAYOUT_4POINT0,
141  .num_ele = { 2, 0, 1, 0 },
142  .pairing = { { 1, 0 }, { 0 }, { 0 }, },
143  .index = { { 0, 0 }, { 0 }, { 1 } },
144  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_SCE },
145  .reorder_map = { 0, 1, 2, 3 },
146  },
147  {
148  .layout = AV_CHANNEL_LAYOUT_4POINT1,
149  .num_ele = { 2, 1, 1, 0 },
150  .pairing = { { 1, 0 }, { 0 }, { 0 }, },
151  .index = { { 0, 0 }, { 1 }, { 2 }, { 0 } },
152  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_SCE },
153  .reorder_map = { 0, 1, 2, 3, 4 },
154  },
155  {
156  .layout = AV_CHANNEL_LAYOUT_2_2,
157  .num_ele = { 1, 1, 0, 0 },
158  .pairing = { { 1 }, { 1 }, },
159  .index = { { 0 }, { 1 }, },
160  .config_map = { 2, TYPE_CPE, TYPE_CPE },
161  .reorder_map = { 0, 1, 2, 3 },
162  },
163  {
164  .layout = AV_CHANNEL_LAYOUT_QUAD,
165  .num_ele = { 1, 0, 1, 0 },
166  .pairing = { { 1 }, { 0 }, { 1 }, },
167  .index = { { 0 }, { 0 }, { 1 } },
168  .config_map = { 2, TYPE_CPE, TYPE_CPE },
169  .reorder_map = { 0, 1, 2, 3 },
170  },
171  {
172  .layout = AV_CHANNEL_LAYOUT_5POINT0,
173  .num_ele = { 2, 1, 0, 0 },
174  .pairing = { { 1, 0 }, { 1 }, },
175  .index = { { 0, 0 }, { 1 } },
176  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_CPE },
177  .reorder_map = { 0, 1, 2, 3, 4 },
178  },
179  {
180  .layout = AV_CHANNEL_LAYOUT_5POINT1,
181  .num_ele = { 2, 1, 1, 0 },
182  .pairing = { { 1, 0 }, { 0 }, { 1 }, },
183  .index = { { 0, 0 }, { 1 }, { 1 } },
184  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE },
185  .reorder_map = { 0, 1, 2, 3, 4, 5 },
186  },
187  {
189  .num_ele = { 2, 0, 1, 0 },
190  .pairing = { { 1, 0 }, { 0 }, { 1 } },
191  .index = { { 0, 0 }, { 0 }, { 1 } },
192  .config_map = { 3, TYPE_CPE, TYPE_SCE, TYPE_CPE },
193  .reorder_map = { 0, 1, 2, 3, 4 },
194  },
195  {
197  .num_ele = { 2, 1, 1, 0 },
198  .pairing = { { 1, 0 }, { 0 }, { 1 }, },
199  .index = { { 0, 0 }, { 1 }, { 1 } },
200  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE },
201  .reorder_map = { 0, 1, 2, 3, 4, 5 },
202  },
203  {
204  .layout = AV_CHANNEL_LAYOUT_6POINT0,
205  .num_ele = { 2, 1, 1, 0 },
206  .pairing = { { 1, 0 }, { 1 }, { 0 }, },
207  .index = { { 0, 0 }, { 1 }, { 1 } },
208  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
209  .reorder_map = { 0, 1, 2, 3, 4, 5 },
210  },
211  {
213  .num_ele = { 2, 1, 0, 0 },
214  .pairing = { { 1, 1 }, { 1 } },
215  .index = { { 1, 0 }, { 2 }, },
216  .config_map = { 3, TYPE_CPE, TYPE_CPE, TYPE_CPE, },
217  .reorder_map = { 0, 1, 2, 3, 4, 5 },
218  },
219  {
220  .layout = AV_CHANNEL_LAYOUT_HEXAGONAL,
221  .num_ele = { 2, 0, 2, 0 },
222  .pairing = { { 1, 0 },{ 0 },{ 1, 0 }, },
223  .index = { { 0, 0 },{ 0 },{ 1, 1 } },
224  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE, },
225  .reorder_map = { 0, 1, 2, 3, 4, 5 },
226  },
227  {
228  .layout = AV_CHANNEL_LAYOUT_6POINT1,
229  .num_ele = { 2, 1, 2, 0 },
230  .pairing = { { 1, 0 },{ 0 },{ 1, 0 }, },
231  .index = { { 0, 0 },{ 1 },{ 1, 2 } },
232  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
233  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
234  },
235  {
237  .num_ele = { 2, 1, 2, 0 },
238  .pairing = { { 1, 0 }, { 0 }, { 1, 0 }, },
239  .index = { { 0, 0 }, { 1 }, { 1, 2 } },
240  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
241  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
242  },
243  {
245  .num_ele = { 2, 1, 2, 0 },
246  .pairing = { { 1, 0 }, { 0 }, { 1, 0 }, },
247  .index = { { 0, 0 }, { 1 }, { 1, 2 } },
248  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
249  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
250  },
251  {
252  .layout = AV_CHANNEL_LAYOUT_7POINT0,
253  .num_ele = { 2, 1, 1, 0 },
254  .pairing = { { 1, 0 }, { 1 }, { 1 }, },
255  .index = { { 0, 0 }, { 1 }, { 2 }, },
256  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
257  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
258  },
259  {
261  .num_ele = { 2, 1, 1, 0 },
262  .pairing = { { 1, 0 }, { 1 }, { 1 }, },
263  .index = { { 0, 0 }, { 1 }, { 2 }, },
264  .config_map = { 4, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
265  .reorder_map = { 0, 1, 2, 3, 4, 5, 6 },
266  },
267  {
268  .layout = AV_CHANNEL_LAYOUT_7POINT1,
269  .num_ele = { 2, 1, 2, 0 },
270  .pairing = { { 1, 0 }, { 0 }, { 1, 1 }, },
271  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
272  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
273  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
274  },
275  {
277  .num_ele = { 2, 1, 2, 0 },
278  .pairing = { { 1, 0 }, { 0 },{ 1, 1 }, },
279  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
280  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
281  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
282  },
283  {
285  .num_ele = { 2, 1, 2, 0 },
286  .pairing = { { 1, 0 }, { 0 }, { 1, 1 }, },
287  .index = { { 0, 0 }, { 1 }, { 1, 2 }, { 0 } },
288  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_SCE, TYPE_CPE, TYPE_CPE },
289  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
290  },
291  {
292  .layout = AV_CHANNEL_LAYOUT_OCTAGONAL,
293  .num_ele = { 2, 1, 2, 0 },
294  .pairing = { { 1, 0 }, { 1 }, { 1, 0 }, },
295  .index = { { 0, 0 }, { 1 }, { 2, 1 } },
296  .config_map = { 5, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_SCE },
297  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7 },
298  },
299  { /* Meant for order 2/mixed ambisonics */
300  .layout = { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = 9,
302  .num_ele = { 2, 2, 2, 0 },
303  .pairing = { { 1, 0 }, { 1, 0 }, { 1, 0 }, },
304  .index = { { 0, 0 }, { 1, 1 }, { 2, 2 } },
305  .config_map = { 6, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
306  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8 },
307  },
308  { /* Meant for order 2/mixed ambisonics */
309  .layout = { .order = AV_CHANNEL_ORDER_NATIVE, .nb_channels = 10,
312  .num_ele = { 2, 2, 2, 0 },
313  .pairing = { { 1, 1 }, { 1, 0 }, { 1, 0 }, },
314  .index = { { 0, 1 }, { 2, 0 }, { 3, 1 } },
315  .config_map = { 6, TYPE_CPE, TYPE_CPE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
316  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 },
317  },
318  {
320  .num_ele = { 4, 2, 4, 0 },
321  .pairing = { { 1, 0, 1, 0 }, { 1, 1 }, { 1, 0, 1, 0 }, },
322  .index = { { 0, 0, 1, 1 }, { 2, 3 }, { 4, 2, 5, 3 } },
324  .reorder_map = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
325  },
326 };
327 
328 static void put_pce(PutBitContext *pb, AVCodecContext *avctx)
329 {
330  int i, j;
331  AACEncContext *s = avctx->priv_data;
332  AACPCEInfo *pce = &s->pce;
333  const int bitexact = avctx->flags & AV_CODEC_FLAG_BITEXACT;
334  const char *aux_data = bitexact ? "Lavc" : LIBAVCODEC_IDENT;
335 
336  put_bits(pb, 4, 0);
337 
338  put_bits(pb, 2, avctx->profile);
339  put_bits(pb, 4, s->samplerate_index);
340 
341  put_bits(pb, 4, pce->num_ele[0]); /* Front */
342  put_bits(pb, 4, pce->num_ele[1]); /* Side */
343  put_bits(pb, 4, pce->num_ele[2]); /* Back */
344  put_bits(pb, 2, pce->num_ele[3]); /* LFE */
345  put_bits(pb, 3, 0); /* Assoc data */
346  put_bits(pb, 4, 0); /* CCs */
347 
348  put_bits(pb, 1, 0); /* Stereo mixdown */
349  put_bits(pb, 1, 0); /* Mono mixdown */
350  put_bits(pb, 1, 0); /* Something else */
351 
352  for (i = 0; i < 4; i++) {
353  for (j = 0; j < pce->num_ele[i]; j++) {
354  if (i < 3)
355  put_bits(pb, 1, pce->pairing[i][j]);
356  put_bits(pb, 4, pce->index[i][j]);
357  }
358  }
359 
360  align_put_bits(pb);
361  put_bits(pb, 8, strlen(aux_data));
362  ff_put_string(pb, aux_data, 0);
363 }
364 
365 /**
366  * Make AAC audio config object.
367  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
368  */
370 {
371  PutBitContext pb;
372  AACEncContext *s = avctx->priv_data;
373  int channels = (!s->needs_pce)*(s->channels - (s->channels == 8 ? 1 : 0));
374  const int max_size = 32;
375 
376  avctx->extradata = av_mallocz(max_size);
377  if (!avctx->extradata)
378  return AVERROR(ENOMEM);
379 
380  init_put_bits(&pb, avctx->extradata, max_size);
381  put_bits(&pb, 5, s->profile+1); //profile
382  put_bits(&pb, 4, s->samplerate_index); //sample rate index
383  put_bits(&pb, 4, channels);
384  //GASpecificConfig
385  put_bits(&pb, 1, 0); //frame length - 1024 samples
386  put_bits(&pb, 1, 0); //does not depend on core coder
387  put_bits(&pb, 1, 0); //is not extension
388  if (s->needs_pce)
389  put_pce(&pb, avctx);
390 
391  //Explicitly Mark SBR absent
392  put_bits(&pb, 11, 0x2b7); //sync extension
393  put_bits(&pb, 5, AOT_SBR);
394  put_bits(&pb, 1, 0);
395  flush_put_bits(&pb);
396  avctx->extradata_size = put_bytes_output(&pb);
397 
398  return 0;
399 }
400 
402 {
403  ++s->quantize_band_cost_cache_generation;
404  if (s->quantize_band_cost_cache_generation == 0) {
405  memset(s->quantize_band_cost_cache, 0, sizeof(s->quantize_band_cost_cache));
406  s->quantize_band_cost_cache_generation = 1;
407  }
408 }
409 
410 #define WINDOW_FUNC(type) \
411 static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
412  SingleChannelElement *sce, \
413  const float *audio)
414 
415 WINDOW_FUNC(only_long)
416 {
417  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
418  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
419  float *out = sce->ret_buf;
420 
421  fdsp->vector_fmul (out, audio, lwindow, 1024);
422  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
423 }
424 
425 WINDOW_FUNC(long_start)
426 {
427  const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
428  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
429  float *out = sce->ret_buf;
430 
431  fdsp->vector_fmul(out, audio, lwindow, 1024);
432  memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
433  fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
434  memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
435 }
436 
437 WINDOW_FUNC(long_stop)
438 {
439  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
440  const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
441  float *out = sce->ret_buf;
442 
443  memset(out, 0, sizeof(out[0]) * 448);
444  fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
445  memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
446  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
447 }
448 
449 WINDOW_FUNC(eight_short)
450 {
451  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
452  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
453  const float *in = audio + 448;
454  float *out = sce->ret_buf;
455  int w;
456 
457  for (w = 0; w < 8; w++) {
458  fdsp->vector_fmul (out, in, w ? pwindow : swindow, 128);
459  out += 128;
460  in += 128;
461  fdsp->vector_fmul_reverse(out, in, swindow, 128);
462  out += 128;
463  }
464 }
465 
466 static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
468  const float *audio) = {
469  [ONLY_LONG_SEQUENCE] = apply_only_long_window,
470  [LONG_START_SEQUENCE] = apply_long_start_window,
471  [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
472  [LONG_STOP_SEQUENCE] = apply_long_stop_window
473 };
474 
476  float *audio)
477 {
478  int i;
479  float *output = sce->ret_buf;
480 
481  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
482 
484  s->mdct1024_fn(s->mdct1024, sce->coeffs, output, sizeof(float));
485  else
486  for (i = 0; i < 1024; i += 128)
487  s->mdct128_fn(s->mdct128, &sce->coeffs[i], output + i*2, sizeof(float));
488  memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
489  memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
490 }
491 
492 /**
493  * Encode ics_info element.
494  * @see Table 4.6 (syntax of ics_info)
495  */
497 {
498  int w;
499 
500  put_bits(&s->pb, 1, 0); // ics_reserved bit
501  put_bits(&s->pb, 2, info->window_sequence[0]);
502  put_bits(&s->pb, 1, info->use_kb_window[0]);
503  if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
504  put_bits(&s->pb, 6, info->max_sfb);
505  put_bits(&s->pb, 1, !!info->predictor_present);
506  } else {
507  put_bits(&s->pb, 4, info->max_sfb);
508  for (w = 1; w < 8; w++)
509  put_bits(&s->pb, 1, !info->group_len[w]);
510  }
511 }
512 
513 /**
514  * Encode MS data.
515  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
516  */
518 {
519  int i, w;
520 
521  put_bits(pb, 2, cpe->ms_mode);
522  if (cpe->ms_mode == 1)
523  for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
524  for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
525  put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
526 }
527 
528 /**
529  * Produce integer coefficients from scalefactors provided by the model.
530  */
531 static void adjust_frame_information(ChannelElement *cpe, int chans)
532 {
533  int i, w, w2, g, ch;
534  int maxsfb, cmaxsfb;
535 
536  for (ch = 0; ch < chans; ch++) {
537  IndividualChannelStream *ics = &cpe->ch[ch].ics;
538  maxsfb = 0;
539  cpe->ch[ch].pulse.num_pulse = 0;
540  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
541  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
542  for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
543  ;
544  maxsfb = FFMAX(maxsfb, cmaxsfb);
545  }
546  }
547  ics->max_sfb = maxsfb;
548 
549  //adjust zero bands for window groups
550  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
551  for (g = 0; g < ics->max_sfb; g++) {
552  i = 1;
553  for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
554  if (!cpe->ch[ch].zeroes[w2*16 + g]) {
555  i = 0;
556  break;
557  }
558  }
559  cpe->ch[ch].zeroes[w*16 + g] = i;
560  }
561  }
562  }
563 
564  if (chans > 1 && cpe->common_window) {
565  IndividualChannelStream *ics0 = &cpe->ch[0].ics;
566  IndividualChannelStream *ics1 = &cpe->ch[1].ics;
567  int msc = 0;
568  ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
569  ics1->max_sfb = ics0->max_sfb;
570  for (w = 0; w < ics0->num_windows*16; w += 16)
571  for (i = 0; i < ics0->max_sfb; i++)
572  if (cpe->ms_mask[w+i])
573  msc++;
574  if (msc == 0 || ics0->max_sfb == 0)
575  cpe->ms_mode = 0;
576  else
577  cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
578  }
579 }
580 
582 {
583  int w, w2, g, i;
584  IndividualChannelStream *ics = &cpe->ch[0].ics;
585  if (!cpe->common_window)
586  return;
587  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
588  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
589  int start = (w+w2) * 128;
590  for (g = 0; g < ics->num_swb; g++) {
591  int p = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
592  float scale = cpe->ch[0].is_ener[w*16+g];
593  if (!cpe->is_mask[w*16 + g]) {
594  start += ics->swb_sizes[g];
595  continue;
596  }
597  if (cpe->ms_mask[w*16 + g])
598  p *= -1;
599  for (i = 0; i < ics->swb_sizes[g]; i++) {
600  float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
601  cpe->ch[0].coeffs[start+i] = sum;
602  cpe->ch[1].coeffs[start+i] = 0.0f;
603  }
604  start += ics->swb_sizes[g];
605  }
606  }
607  }
608 }
609 
611 {
612  int w, w2, g, i;
613  IndividualChannelStream *ics = &cpe->ch[0].ics;
614  if (!cpe->common_window)
615  return;
616  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
617  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
618  int start = (w+w2) * 128;
619  for (g = 0; g < ics->num_swb; g++) {
620  /* ms_mask can be used for other purposes in PNS and I/S,
621  * so must not apply M/S if any band uses either, even if
622  * ms_mask is set.
623  */
624  if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
625  || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
626  || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
627  start += ics->swb_sizes[g];
628  continue;
629  }
630  for (i = 0; i < ics->swb_sizes[g]; i++) {
631  float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
632  float R = L - cpe->ch[1].coeffs[start+i];
633  cpe->ch[0].coeffs[start+i] = L;
634  cpe->ch[1].coeffs[start+i] = R;
635  }
636  start += ics->swb_sizes[g];
637  }
638  }
639  }
640 }
641 
642 /**
643  * Encode scalefactor band coding type.
644  */
646 {
647  int w;
648 
649  if (s->coder->set_special_band_scalefactors)
650  s->coder->set_special_band_scalefactors(s, sce);
651 
652  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
653  s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
654 }
655 
656 /**
657  * Encode scalefactors.
658  */
661 {
662  int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
663  int off_is = 0, noise_flag = 1;
664  int i, w;
665 
666  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
667  for (i = 0; i < sce->ics.max_sfb; i++) {
668  if (!sce->zeroes[w*16 + i]) {
669  if (sce->band_type[w*16 + i] == NOISE_BT) {
670  diff = sce->sf_idx[w*16 + i] - off_pns;
671  off_pns = sce->sf_idx[w*16 + i];
672  if (noise_flag-- > 0) {
674  continue;
675  }
676  } else if (sce->band_type[w*16 + i] == INTENSITY_BT ||
677  sce->band_type[w*16 + i] == INTENSITY_BT2) {
678  diff = sce->sf_idx[w*16 + i] - off_is;
679  off_is = sce->sf_idx[w*16 + i];
680  } else {
681  diff = sce->sf_idx[w*16 + i] - off_sf;
682  off_sf = sce->sf_idx[w*16 + i];
683  }
685  av_assert0(diff >= 0 && diff <= 120);
687  }
688  }
689  }
690 }
691 
692 /**
693  * Encode pulse data.
694  */
695 static void encode_pulses(AACEncContext *s, Pulse *pulse)
696 {
697  int i;
698 
699  put_bits(&s->pb, 1, !!pulse->num_pulse);
700  if (!pulse->num_pulse)
701  return;
702 
703  put_bits(&s->pb, 2, pulse->num_pulse - 1);
704  put_bits(&s->pb, 6, pulse->start);
705  for (i = 0; i < pulse->num_pulse; i++) {
706  put_bits(&s->pb, 5, pulse->pos[i]);
707  put_bits(&s->pb, 4, pulse->amp[i]);
708  }
709 }
710 
711 /**
712  * Encode spectral coefficients processed by psychoacoustic model.
713  */
715 {
716  int start, i, w, w2;
717 
718  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
719  start = 0;
720  for (i = 0; i < sce->ics.max_sfb; i++) {
721  if (sce->zeroes[w*16 + i]) {
722  start += sce->ics.swb_sizes[i];
723  continue;
724  }
725  for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
726  s->coder->quantize_and_encode_band(s, &s->pb,
727  &sce->coeffs[start + w2*128],
728  NULL, sce->ics.swb_sizes[i],
729  sce->sf_idx[w*16 + i],
730  sce->band_type[w*16 + i],
731  s->lambda,
732  sce->ics.window_clipping[w]);
733  }
734  start += sce->ics.swb_sizes[i];
735  }
736  }
737 }
738 
739 /**
740  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
741  */
743 {
744  int start, i, j, w;
745 
746  if (sce->ics.clip_avoidance_factor < 1.0f) {
747  for (w = 0; w < sce->ics.num_windows; w++) {
748  start = 0;
749  for (i = 0; i < sce->ics.max_sfb; i++) {
750  float *swb_coeffs = &sce->coeffs[start + w*128];
751  for (j = 0; j < sce->ics.swb_sizes[i]; j++)
752  swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
753  start += sce->ics.swb_sizes[i];
754  }
755  }
756  }
757 }
758 
759 /**
760  * Encode one channel of audio data.
761  */
764  int common_window)
765 {
766  put_bits(&s->pb, 8, sce->sf_idx[0]);
767  if (!common_window) {
768  put_ics_info(s, &sce->ics);
769  if (s->coder->encode_main_pred)
770  s->coder->encode_main_pred(s, sce);
771  if (s->coder->encode_ltp_info)
772  s->coder->encode_ltp_info(s, sce, 0);
773  }
774  encode_band_info(s, sce);
775  encode_scale_factors(avctx, s, sce);
776  encode_pulses(s, &sce->pulse);
777  put_bits(&s->pb, 1, !!sce->tns.present);
778  if (s->coder->encode_tns_info)
779  s->coder->encode_tns_info(s, sce);
780  put_bits(&s->pb, 1, 0); //ssr
782  return 0;
783 }
784 
785 /**
786  * Write some auxiliary information about the created AAC file.
787  */
788 static void put_bitstream_info(AACEncContext *s, const char *name)
789 {
790  int i, namelen, padbits;
791 
792  namelen = strlen(name) + 2;
793  put_bits(&s->pb, 3, TYPE_FIL);
794  put_bits(&s->pb, 4, FFMIN(namelen, 15));
795  if (namelen >= 15)
796  put_bits(&s->pb, 8, namelen - 14);
797  put_bits(&s->pb, 4, 0); //extension type - filler
798  padbits = -put_bits_count(&s->pb) & 7;
799  align_put_bits(&s->pb);
800  for (i = 0; i < namelen - 2; i++)
801  put_bits(&s->pb, 8, name[i]);
802  put_bits(&s->pb, 12 - padbits, 0);
803 }
804 
805 /*
806  * Copy input samples.
807  * Channels are reordered from libavcodec's default order to AAC order.
808  */
810 {
811  int ch;
812  int end = 2048 + (frame ? frame->nb_samples : 0);
813  const uint8_t *channel_map = s->reorder_map;
814 
815  /* copy and remap input samples */
816  for (ch = 0; ch < s->channels; ch++) {
817  /* copy last 1024 samples of previous frame to the start of the current frame */
818  memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
819 
820  /* copy new samples and zero any remaining samples */
821  if (frame) {
822  memcpy(&s->planar_samples[ch][2048],
823  frame->extended_data[channel_map[ch]],
824  frame->nb_samples * sizeof(s->planar_samples[0][0]));
825  }
826  memset(&s->planar_samples[ch][end], 0,
827  (3072 - end) * sizeof(s->planar_samples[0][0]));
828  }
829 }
830 
831 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
832  const AVFrame *frame, int *got_packet_ptr)
833 {
834  AACEncContext *s = avctx->priv_data;
835  float **samples = s->planar_samples, *samples2, *la, *overlap;
836  ChannelElement *cpe;
839  int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
840  int target_bits, rate_bits, too_many_bits, too_few_bits;
841  int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
842  int chan_el_counter[4];
844 
845  /* add current frame to queue */
846  if (frame) {
847  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
848  return ret;
849  } else {
850  if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
851  return 0;
852  }
853 
855  if (s->psypp)
856  ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
857 
858  if (!avctx->frame_num)
859  return 0;
860 
861  start_ch = 0;
862  for (i = 0; i < s->chan_map[0]; i++) {
863  FFPsyWindowInfo* wi = windows + start_ch;
864  tag = s->chan_map[i+1];
865  chans = tag == TYPE_CPE ? 2 : 1;
866  cpe = &s->cpe[i];
867  for (ch = 0; ch < chans; ch++) {
868  int k;
869  float clip_avoidance_factor;
870  sce = &cpe->ch[ch];
871  ics = &sce->ics;
872  s->cur_channel = start_ch + ch;
873  overlap = &samples[s->cur_channel][0];
874  samples2 = overlap + 1024;
875  la = samples2 + (448+64);
876  if (!frame)
877  la = NULL;
878  if (tag == TYPE_LFE) {
879  wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
880  wi[ch].window_shape = 0;
881  wi[ch].num_windows = 1;
882  wi[ch].grouping[0] = 1;
883  wi[ch].clipping[0] = 0;
884 
885  /* Only the lowest 12 coefficients are used in a LFE channel.
886  * The expression below results in only the bottom 8 coefficients
887  * being used for 11.025kHz to 16kHz sample rates.
888  */
889  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
890  } else {
891  wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
892  ics->window_sequence[0]);
893  }
894  ics->window_sequence[1] = ics->window_sequence[0];
895  ics->window_sequence[0] = wi[ch].window_type[0];
896  ics->use_kb_window[1] = ics->use_kb_window[0];
897  ics->use_kb_window[0] = wi[ch].window_shape;
898  ics->num_windows = wi[ch].num_windows;
899  ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
900  ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
901  ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);
902  ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
903  ff_swb_offset_128 [s->samplerate_index]:
904  ff_swb_offset_1024[s->samplerate_index];
905  ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
906  ff_tns_max_bands_128 [s->samplerate_index]:
907  ff_tns_max_bands_1024[s->samplerate_index];
908 
909  for (w = 0; w < ics->num_windows; w++)
910  ics->group_len[w] = wi[ch].grouping[w];
911 
912  /* Calculate input sample maximums and evaluate clipping risk */
913  clip_avoidance_factor = 0.0f;
914  for (w = 0; w < ics->num_windows; w++) {
915  const float *wbuf = overlap + w * 128;
916  const int wlen = 2048 / ics->num_windows;
917  float max = 0;
918  int j;
919  /* mdct input is 2 * output */
920  for (j = 0; j < wlen; j++)
921  max = FFMAX(max, fabsf(wbuf[j]));
922  wi[ch].clipping[w] = max;
923  }
924  for (w = 0; w < ics->num_windows; w++) {
925  if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
926  ics->window_clipping[w] = 1;
927  clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
928  } else {
929  ics->window_clipping[w] = 0;
930  }
931  }
932  if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
933  ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
934  } else {
935  ics->clip_avoidance_factor = 1.0f;
936  }
937 
938  apply_window_and_mdct(s, sce, overlap);
939 
940  if (s->options.ltp && s->coder->update_ltp) {
941  s->coder->update_ltp(s, sce);
942  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
943  s->mdct1024_fn(s->mdct1024, sce->lcoeffs, sce->ret_buf, sizeof(float));
944  }
945 
946  for (k = 0; k < 1024; k++) {
947  if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
948  av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
949  return AVERROR(EINVAL);
950  }
951  }
952  avoid_clipping(s, sce);
953  }
954  start_ch += chans;
955  }
956  if ((ret = ff_alloc_packet(avctx, avpkt, 8192 * s->channels)) < 0)
957  return ret;
958  frame_bits = its = 0;
959  do {
960  init_put_bits(&s->pb, avpkt->data, avpkt->size);
961 
962  if ((avctx->frame_num & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
964  start_ch = 0;
965  target_bits = 0;
966  memset(chan_el_counter, 0, sizeof(chan_el_counter));
967  for (i = 0; i < s->chan_map[0]; i++) {
968  FFPsyWindowInfo* wi = windows + start_ch;
969  const float *coeffs[2];
970  tag = s->chan_map[i+1];
971  chans = tag == TYPE_CPE ? 2 : 1;
972  cpe = &s->cpe[i];
973  cpe->common_window = 0;
974  memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
975  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
976  put_bits(&s->pb, 3, tag);
977  put_bits(&s->pb, 4, chan_el_counter[tag]++);
978  for (ch = 0; ch < chans; ch++) {
979  sce = &cpe->ch[ch];
980  coeffs[ch] = sce->coeffs;
981  sce->ics.predictor_present = 0;
982  sce->ics.ltp.present = 0;
983  memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
984  memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
985  memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
986  for (w = 0; w < 128; w++)
987  if (sce->band_type[w] > RESERVED_BT)
988  sce->band_type[w] = 0;
989  }
990  s->psy.bitres.alloc = -1;
991  s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
992  s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
993  if (s->psy.bitres.alloc > 0) {
994  /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
995  target_bits += s->psy.bitres.alloc
996  * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
997  s->psy.bitres.alloc /= chans;
998  }
999  s->cur_type = tag;
1000  for (ch = 0; ch < chans; ch++) {
1001  s->cur_channel = start_ch + ch;
1002  if (s->options.pns && s->coder->mark_pns)
1003  s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
1004  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
1005  }
1006  if (chans > 1
1007  && wi[0].window_type[0] == wi[1].window_type[0]
1008  && wi[0].window_shape == wi[1].window_shape) {
1009 
1010  cpe->common_window = 1;
1011  for (w = 0; w < wi[0].num_windows; w++) {
1012  if (wi[0].grouping[w] != wi[1].grouping[w]) {
1013  cpe->common_window = 0;
1014  break;
1015  }
1016  }
1017  }
1018  for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
1019  sce = &cpe->ch[ch];
1020  s->cur_channel = start_ch + ch;
1021  if (s->options.tns && s->coder->search_for_tns)
1022  s->coder->search_for_tns(s, sce);
1023  if (s->options.tns && s->coder->apply_tns_filt)
1024  s->coder->apply_tns_filt(s, sce);
1025  if (sce->tns.present)
1026  tns_mode = 1;
1027  if (s->options.pns && s->coder->search_for_pns)
1028  s->coder->search_for_pns(s, avctx, sce);
1029  }
1030  s->cur_channel = start_ch;
1031  if (s->options.intensity_stereo) { /* Intensity Stereo */
1032  if (s->coder->search_for_is)
1033  s->coder->search_for_is(s, avctx, cpe);
1034  if (cpe->is_mode) is_mode = 1;
1036  }
1037  if (s->options.pred) { /* Prediction */
1038  for (ch = 0; ch < chans; ch++) {
1039  sce = &cpe->ch[ch];
1040  s->cur_channel = start_ch + ch;
1041  if (s->options.pred && s->coder->search_for_pred)
1042  s->coder->search_for_pred(s, sce);
1043  if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
1044  }
1045  if (s->coder->adjust_common_pred)
1046  s->coder->adjust_common_pred(s, cpe);
1047  for (ch = 0; ch < chans; ch++) {
1048  sce = &cpe->ch[ch];
1049  s->cur_channel = start_ch + ch;
1050  if (s->options.pred && s->coder->apply_main_pred)
1051  s->coder->apply_main_pred(s, sce);
1052  }
1053  s->cur_channel = start_ch;
1054  }
1055  if (s->options.mid_side) { /* Mid/Side stereo */
1056  if (s->options.mid_side == -1 && s->coder->search_for_ms)
1057  s->coder->search_for_ms(s, cpe);
1058  else if (cpe->common_window)
1059  memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
1060  apply_mid_side_stereo(cpe);
1061  }
1062  adjust_frame_information(cpe, chans);
1063  if (s->options.ltp) { /* LTP */
1064  for (ch = 0; ch < chans; ch++) {
1065  sce = &cpe->ch[ch];
1066  s->cur_channel = start_ch + ch;
1067  if (s->coder->search_for_ltp)
1068  s->coder->search_for_ltp(s, sce, cpe->common_window);
1069  if (sce->ics.ltp.present) pred_mode = 1;
1070  }
1071  s->cur_channel = start_ch;
1072  if (s->coder->adjust_common_ltp)
1073  s->coder->adjust_common_ltp(s, cpe);
1074  }
1075  if (chans == 2) {
1076  put_bits(&s->pb, 1, cpe->common_window);
1077  if (cpe->common_window) {
1078  put_ics_info(s, &cpe->ch[0].ics);
1079  if (s->coder->encode_main_pred)
1080  s->coder->encode_main_pred(s, &cpe->ch[0]);
1081  if (s->coder->encode_ltp_info)
1082  s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
1083  encode_ms_info(&s->pb, cpe);
1084  if (cpe->ms_mode) ms_mode = 1;
1085  }
1086  }
1087  for (ch = 0; ch < chans; ch++) {
1088  s->cur_channel = start_ch + ch;
1089  encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
1090  }
1091  start_ch += chans;
1092  }
1093 
1094  if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
1095  /* When using a constant Q-scale, don't mess with lambda */
1096  break;
1097  }
1098 
1099  /* rate control stuff
1100  * allow between the nominal bitrate, and what psy's bit reservoir says to target
1101  * but drift towards the nominal bitrate always
1102  */
1103  frame_bits = put_bits_count(&s->pb);
1104  rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
1105  rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
1106  too_many_bits = FFMAX(target_bits, rate_bits);
1107  too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
1108  too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
1109 
1110  /* When strict bit-rate control is demanded */
1111  if (avctx->bit_rate_tolerance == 0) {
1112  if (rate_bits < frame_bits) {
1113  float ratio = ((float)rate_bits) / frame_bits;
1114  s->lambda *= FFMIN(0.9f, ratio);
1115  continue;
1116  }
1117  /* reset lambda when solution is found */
1118  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1119  break;
1120  }
1121 
1122  /* When using ABR, be strict (but only for increasing) */
1123  too_few_bits = too_few_bits - too_few_bits/8;
1124  too_many_bits = too_many_bits + too_many_bits/2;
1125 
1126  if ( its == 0 /* for steady-state Q-scale tracking */
1127  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
1128  || frame_bits >= 6144 * s->channels - 3 )
1129  {
1130  float ratio = ((float)rate_bits) / frame_bits;
1131 
1132  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
1133  /*
1134  * This path is for steady-state Q-scale tracking
1135  * When frame bits fall within the stable range, we still need to adjust
1136  * lambda to maintain it like so in a stable fashion (large jumps in lambda
1137  * create artifacts and should be avoided), but slowly
1138  */
1139  ratio = sqrtf(sqrtf(ratio));
1140  ratio = av_clipf(ratio, 0.9f, 1.1f);
1141  } else {
1142  /* Not so fast though */
1143  ratio = sqrtf(ratio);
1144  }
1145  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
1146 
1147  /* Keep iterating if we must reduce and lambda is in the sky */
1148  if (ratio > 0.9f && ratio < 1.1f) {
1149  break;
1150  } else {
1151  if (is_mode || ms_mode || tns_mode || pred_mode) {
1152  for (i = 0; i < s->chan_map[0]; i++) {
1153  // Must restore coeffs
1154  chans = tag == TYPE_CPE ? 2 : 1;
1155  cpe = &s->cpe[i];
1156  for (ch = 0; ch < chans; ch++)
1157  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
1158  }
1159  }
1160  its++;
1161  }
1162  } else {
1163  break;
1164  }
1165  } while (1);
1166 
1167  if (s->options.ltp && s->coder->ltp_insert_new_frame)
1168  s->coder->ltp_insert_new_frame(s);
1169 
1170  put_bits(&s->pb, 3, TYPE_END);
1171  flush_put_bits(&s->pb);
1172 
1173  s->last_frame_pb_count = put_bits_count(&s->pb);
1174  avpkt->size = put_bytes_output(&s->pb);
1175 
1176  s->lambda_sum += s->lambda;
1177  s->lambda_count++;
1178 
1179  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
1180  &avpkt->duration);
1181 
1182  *got_packet_ptr = 1;
1183  return 0;
1184 }
1185 
1187 {
1188  AACEncContext *s = avctx->priv_data;
1189 
1190  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
1191 
1192  av_tx_uninit(&s->mdct1024);
1193  av_tx_uninit(&s->mdct128);
1194  ff_psy_end(&s->psy);
1195  ff_lpc_end(&s->lpc);
1196  if (s->psypp)
1197  ff_psy_preprocess_end(s->psypp);
1198  av_freep(&s->buffer.samples);
1199  av_freep(&s->cpe);
1200  av_freep(&s->fdsp);
1201  ff_af_queue_close(&s->afq);
1202  return 0;
1203 }
1204 
1206 {
1207  int ret = 0;
1208  float scale = 32768.0f;
1209 
1211  if (!s->fdsp)
1212  return AVERROR(ENOMEM);
1213 
1214  if ((ret = av_tx_init(&s->mdct1024, &s->mdct1024_fn, AV_TX_FLOAT_MDCT, 0,
1215  1024, &scale, 0)) < 0)
1216  return ret;
1217  if ((ret = av_tx_init(&s->mdct128, &s->mdct128_fn, AV_TX_FLOAT_MDCT, 0,
1218  128, &scale, 0)) < 0)
1219  return ret;
1220 
1221  return 0;
1222 }
1223 
1225 {
1226  int ch;
1227  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
1228  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
1229  return AVERROR(ENOMEM);
1230 
1231  for(ch = 0; ch < s->channels; ch++)
1232  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
1233 
1234  return 0;
1235 }
1236 
1238 {
1239  AACEncContext *s = avctx->priv_data;
1240  int i, ret = 0;
1241  const uint8_t *sizes[2];
1242  uint8_t grouping[AAC_MAX_CHANNELS];
1243  int lengths[2];
1244 
1245  /* Constants */
1246  s->last_frame_pb_count = 0;
1247  avctx->frame_size = 1024;
1248  avctx->initial_padding = 1024;
1249  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1250 
1251  /* Channel map and unspecified bitrate guessing */
1252  s->channels = avctx->ch_layout.nb_channels;
1253 
1254  s->needs_pce = 1;
1255  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
1257  s->needs_pce = s->options.pce;
1258  break;
1259  }
1260  }
1261 
1262  if (s->needs_pce) {
1263  char buf[64];
1264  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
1266  break;
1267  av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
1268  if (i == FF_ARRAY_ELEMS(aac_pce_configs)) {
1269  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout \"%s\"\n", buf);
1270  return AVERROR(EINVAL);
1271  }
1272  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
1273  s->pce = aac_pce_configs[i];
1274  s->reorder_map = s->pce.reorder_map;
1275  s->chan_map = s->pce.config_map;
1276  } else {
1277  s->reorder_map = aac_chan_maps[s->channels - 1];
1278  s->chan_map = aac_chan_configs[s->channels - 1];
1279  }
1280 
1281  if (!avctx->bit_rate) {
1282  for (i = 1; i <= s->chan_map[0]; i++) {
1283  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
1284  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
1285  69000 ; /* SCE */
1286  }
1287  }
1288 
1289  /* Samplerate */
1290  for (i = 0; i < 16; i++)
1291  if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
1292  break;
1293  s->samplerate_index = i;
1294  ERROR_IF(s->samplerate_index == 16 ||
1295  s->samplerate_index >= ff_aac_swb_size_1024_len ||
1296  s->samplerate_index >= ff_aac_swb_size_128_len,
1297  "Unsupported sample rate %d\n", avctx->sample_rate);
1298 
1299  /* Bitrate limiting */
1300  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1301  "Too many bits %f > %d per frame requested, clamping to max\n",
1302  1024.0 * avctx->bit_rate / avctx->sample_rate,
1303  6144 * s->channels);
1304  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1305  avctx->bit_rate);
1306 
1307  /* Profile and option setting */
1308  avctx->profile = avctx->profile == AV_PROFILE_UNKNOWN ? AV_PROFILE_AAC_LOW :
1309  avctx->profile;
1310  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1311  if (avctx->profile == aacenc_profiles[i])
1312  break;
1313  if (avctx->profile == AV_PROFILE_MPEG2_AAC_LOW) {
1314  avctx->profile = AV_PROFILE_AAC_LOW;
1315  ERROR_IF(s->options.pred,
1316  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1317  ERROR_IF(s->options.ltp,
1318  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1319  WARN_IF(s->options.pns,
1320  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1321  s->options.pns = 0;
1322  } else if (avctx->profile == AV_PROFILE_AAC_LTP) {
1323  s->options.ltp = 1;
1324  ERROR_IF(s->options.pred,
1325  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1326  } else if (avctx->profile == AV_PROFILE_AAC_MAIN) {
1327  s->options.pred = 1;
1328  ERROR_IF(s->options.ltp,
1329  "LTP prediction unavailable in the \"aac_main\" profile\n");
1330  } else if (s->options.ltp) {
1331  avctx->profile = AV_PROFILE_AAC_LTP;
1332  WARN_IF(1,
1333  "Chainging profile to \"aac_ltp\"\n");
1334  ERROR_IF(s->options.pred,
1335  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1336  } else if (s->options.pred) {
1337  avctx->profile = AV_PROFILE_AAC_MAIN;
1338  WARN_IF(1,
1339  "Chainging profile to \"aac_main\"\n");
1340  ERROR_IF(s->options.ltp,
1341  "LTP prediction unavailable in the \"aac_main\" profile\n");
1342  }
1343  s->profile = avctx->profile;
1344 
1345  /* Coder limitations */
1346  s->coder = &ff_aac_coders[s->options.coder];
1347  if (s->options.coder == AAC_CODER_ANMR) {
1349  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
1350  s->options.intensity_stereo = 0;
1351  s->options.pns = 0;
1352  }
1354  "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
1355 
1356  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1357  if (s->channels > 3)
1358  s->options.mid_side = 0;
1359 
1360  // Initialize static tables
1362 
1363  if ((ret = dsp_init(avctx, s)) < 0)
1364  return ret;
1365 
1366  if ((ret = alloc_buffers(avctx, s)) < 0)
1367  return ret;
1368 
1369  if ((ret = put_audio_specific_config(avctx)))
1370  return ret;
1371 
1372  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1373  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1374  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1375  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1376  for (i = 0; i < s->chan_map[0]; i++)
1377  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1378  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1379  s->chan_map[0], grouping)) < 0)
1380  return ret;
1381  s->psypp = ff_psy_preprocess_init(avctx);
1383  s->random_state = 0x1f2e3d4c;
1384 
1385  ff_aacenc_dsp_init(&s->aacdsp);
1386 
1387  ff_af_queue_init(avctx, &s->afq);
1388 
1389  return 0;
1390 }
1391 
1392 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1393 static const AVOption aacenc_options[] = {
1394  {"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"},
1395  {"anmr", "ANMR method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1396  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1397  {"fast", "Default fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1398  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1399  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1400  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1401  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1402  {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1403  {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1404  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1406  {NULL}
1407 };
1408 
1409 static const AVClass aacenc_class = {
1410  .class_name = "AAC encoder",
1411  .item_name = av_default_item_name,
1412  .option = aacenc_options,
1413  .version = LIBAVUTIL_VERSION_INT,
1414 };
1415 
1417  { "b", "0" },
1418  { NULL }
1419 };
1420 
1422  .p.name = "aac",
1423  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
1424  .p.type = AVMEDIA_TYPE_AUDIO,
1425  .p.id = AV_CODEC_ID_AAC,
1426  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1428  .priv_data_size = sizeof(AACEncContext),
1429  .init = aac_encode_init,
1431  .close = aac_encode_end,
1432  .defaults = aac_encode_defaults,
1433  .p.supported_samplerates = ff_mpeg4audio_sample_rates,
1434  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1435  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1437  .p.priv_class = &aacenc_class,
1438 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
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:1409
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:788
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:55
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:809
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: aacenc.c:1237
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:339
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:374
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
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:524
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:645
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:126
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:542
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:903
encode_spectral_coeffs
static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
Encode spectral coefficients processed by psychoacoustic model.
Definition: aacenc.c:714
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:410
avoid_clipping
static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
Downscale spectral coefficients for near-clipping windows to avoid artifacts.
Definition: aacenc.c:742
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
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:610
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:328
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:295
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:531
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:645
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:128
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:1224
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:52
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:271
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:695
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:364
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:831
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:366
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:525
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:659
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:475
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:165
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:581
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:295
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:801
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:90
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:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:517
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:1393
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
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:466
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:256
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:1392
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:1416
tag
uint32_t tag
Definition: movenc.c:1787
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
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:1421
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:517
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:762
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:369
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:496
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
mem.h
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:1186
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
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:29
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:1205
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:62
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:401
AACPCEInfo::layout
AVChannelLayout layout
Definition: aacenc.h:187
aacenc.h