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 (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
542  ;
543  maxsfb = FFMAX(maxsfb, cmaxsfb);
544  }
545  ics->max_sfb = maxsfb;
546 
547  //adjust zero bands for window groups
548  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
549  for (g = 0; g < ics->max_sfb; g++) {
550  i = 1;
551  for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
552  if (!cpe->ch[ch].zeroes[w2*16 + g]) {
553  i = 0;
554  break;
555  }
556  }
557  cpe->ch[ch].zeroes[w*16 + g] = i;
558  }
559  }
560  }
561 
562  if (chans > 1 && cpe->common_window) {
563  IndividualChannelStream *ics0 = &cpe->ch[0].ics;
564  IndividualChannelStream *ics1 = &cpe->ch[1].ics;
565  int msc = 0;
566  ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
567  ics1->max_sfb = ics0->max_sfb;
568  for (w = 0; w < ics0->num_windows*16; w += 16)
569  for (i = 0; i < ics0->max_sfb; i++)
570  if (cpe->ms_mask[w+i])
571  msc++;
572  if (msc == 0 || ics0->max_sfb == 0)
573  cpe->ms_mode = 0;
574  else
575  cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
576  }
577 }
578 
580 {
581  int w, w2, g, i;
582  IndividualChannelStream *ics = &cpe->ch[0].ics;
583  if (!cpe->common_window)
584  return;
585  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
586  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
587  int start = (w+w2) * 128;
588  for (g = 0; g < ics->num_swb; g++) {
589  int p = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
590  float scale = cpe->ch[0].is_ener[w*16+g];
591  if (!cpe->is_mask[w*16 + g]) {
592  start += ics->swb_sizes[g];
593  continue;
594  }
595  if (cpe->ms_mask[w*16 + g])
596  p *= -1;
597  for (i = 0; i < ics->swb_sizes[g]; i++) {
598  float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
599  cpe->ch[0].coeffs[start+i] = sum;
600  cpe->ch[1].coeffs[start+i] = 0.0f;
601  }
602  start += ics->swb_sizes[g];
603  }
604  }
605  }
606 }
607 
609 {
610  int w, w2, g, i;
611  IndividualChannelStream *ics = &cpe->ch[0].ics;
612  if (!cpe->common_window)
613  return;
614  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
615  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
616  int start = (w+w2) * 128;
617  for (g = 0; g < ics->num_swb; g++) {
618  /* ms_mask can be used for other purposes in PNS and I/S,
619  * so must not apply M/S if any band uses either, even if
620  * ms_mask is set.
621  */
622  if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
623  || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
624  || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
625  start += ics->swb_sizes[g];
626  continue;
627  }
628  for (i = 0; i < ics->swb_sizes[g]; i++) {
629  float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
630  float R = L - cpe->ch[1].coeffs[start+i];
631  cpe->ch[0].coeffs[start+i] = L;
632  cpe->ch[1].coeffs[start+i] = R;
633  }
634  start += ics->swb_sizes[g];
635  }
636  }
637  }
638 }
639 
640 /**
641  * Encode scalefactor band coding type.
642  */
644 {
645  int w;
646 
647  if (s->coder->set_special_band_scalefactors)
648  s->coder->set_special_band_scalefactors(s, sce);
649 
650  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
651  s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
652 }
653 
654 /**
655  * Encode scalefactors.
656  */
659 {
660  int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
661  int off_is = 0, noise_flag = 1;
662  int i, w;
663 
664  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
665  for (i = 0; i < sce->ics.max_sfb; i++) {
666  if (!sce->zeroes[w*16 + i]) {
667  if (sce->band_type[w*16 + i] == NOISE_BT) {
668  diff = sce->sf_idx[w*16 + i] - off_pns;
669  off_pns = sce->sf_idx[w*16 + i];
670  if (noise_flag-- > 0) {
672  continue;
673  }
674  } else if (sce->band_type[w*16 + i] == INTENSITY_BT ||
675  sce->band_type[w*16 + i] == INTENSITY_BT2) {
676  diff = sce->sf_idx[w*16 + i] - off_is;
677  off_is = sce->sf_idx[w*16 + i];
678  } else {
679  diff = sce->sf_idx[w*16 + i] - off_sf;
680  off_sf = sce->sf_idx[w*16 + i];
681  }
683  av_assert0(diff >= 0 && diff <= 120);
685  }
686  }
687  }
688 }
689 
690 /**
691  * Encode pulse data.
692  */
693 static void encode_pulses(AACEncContext *s, Pulse *pulse)
694 {
695  int i;
696 
697  put_bits(&s->pb, 1, !!pulse->num_pulse);
698  if (!pulse->num_pulse)
699  return;
700 
701  put_bits(&s->pb, 2, pulse->num_pulse - 1);
702  put_bits(&s->pb, 6, pulse->start);
703  for (i = 0; i < pulse->num_pulse; i++) {
704  put_bits(&s->pb, 5, pulse->pos[i]);
705  put_bits(&s->pb, 4, pulse->amp[i]);
706  }
707 }
708 
709 /**
710  * Encode spectral coefficients processed by psychoacoustic model.
711  */
713 {
714  int start, i, w, w2;
715 
716  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
717  start = 0;
718  for (i = 0; i < sce->ics.max_sfb; i++) {
719  if (sce->zeroes[w*16 + i]) {
720  start += sce->ics.swb_sizes[i];
721  continue;
722  }
723  for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
724  s->coder->quantize_and_encode_band(s, &s->pb,
725  &sce->coeffs[start + w2*128],
726  NULL, sce->ics.swb_sizes[i],
727  sce->sf_idx[w*16 + i],
728  sce->band_type[w*16 + i],
729  s->lambda,
730  sce->ics.window_clipping[w]);
731  }
732  start += sce->ics.swb_sizes[i];
733  }
734  }
735 }
736 
737 /**
738  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
739  */
741 {
742  int start, i, j, w;
743 
744  if (sce->ics.clip_avoidance_factor < 1.0f) {
745  for (w = 0; w < sce->ics.num_windows; w++) {
746  start = 0;
747  for (i = 0; i < sce->ics.max_sfb; i++) {
748  float *swb_coeffs = &sce->coeffs[start + w*128];
749  for (j = 0; j < sce->ics.swb_sizes[i]; j++)
750  swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
751  start += sce->ics.swb_sizes[i];
752  }
753  }
754  }
755 }
756 
757 /**
758  * Encode one channel of audio data.
759  */
762  int common_window)
763 {
764  put_bits(&s->pb, 8, sce->sf_idx[0]);
765  if (!common_window) {
766  put_ics_info(s, &sce->ics);
767  if (s->coder->encode_main_pred)
768  s->coder->encode_main_pred(s, sce);
769  if (s->coder->encode_ltp_info)
770  s->coder->encode_ltp_info(s, sce, 0);
771  }
772  encode_band_info(s, sce);
773  encode_scale_factors(avctx, s, sce);
774  encode_pulses(s, &sce->pulse);
775  put_bits(&s->pb, 1, !!sce->tns.present);
776  if (s->coder->encode_tns_info)
777  s->coder->encode_tns_info(s, sce);
778  put_bits(&s->pb, 1, 0); //ssr
780  return 0;
781 }
782 
783 /**
784  * Write some auxiliary information about the created AAC file.
785  */
786 static void put_bitstream_info(AACEncContext *s, const char *name)
787 {
788  int i, namelen, padbits;
789 
790  namelen = strlen(name) + 2;
791  put_bits(&s->pb, 3, TYPE_FIL);
792  put_bits(&s->pb, 4, FFMIN(namelen, 15));
793  if (namelen >= 15)
794  put_bits(&s->pb, 8, namelen - 14);
795  put_bits(&s->pb, 4, 0); //extension type - filler
796  padbits = -put_bits_count(&s->pb) & 7;
797  align_put_bits(&s->pb);
798  for (i = 0; i < namelen - 2; i++)
799  put_bits(&s->pb, 8, name[i]);
800  put_bits(&s->pb, 12 - padbits, 0);
801 }
802 
803 /*
804  * Copy input samples.
805  * Channels are reordered from libavcodec's default order to AAC order.
806  */
808 {
809  int ch;
810  int end = 2048 + (frame ? frame->nb_samples : 0);
811  const uint8_t *channel_map = s->reorder_map;
812 
813  /* copy and remap input samples */
814  for (ch = 0; ch < s->channels; ch++) {
815  /* copy last 1024 samples of previous frame to the start of the current frame */
816  memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
817 
818  /* copy new samples and zero any remaining samples */
819  if (frame) {
820  memcpy(&s->planar_samples[ch][2048],
821  frame->extended_data[channel_map[ch]],
822  frame->nb_samples * sizeof(s->planar_samples[0][0]));
823  }
824  memset(&s->planar_samples[ch][end], 0,
825  (3072 - end) * sizeof(s->planar_samples[0][0]));
826  }
827 }
828 
829 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
830  const AVFrame *frame, int *got_packet_ptr)
831 {
832  AACEncContext *s = avctx->priv_data;
833  float **samples = s->planar_samples, *samples2, *la, *overlap;
834  ChannelElement *cpe;
837  int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
838  int target_bits, rate_bits, too_many_bits, too_few_bits;
839  int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
840  int chan_el_counter[4];
842 
843  /* add current frame to queue */
844  if (frame) {
845  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
846  return ret;
847  } else {
848  if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
849  return 0;
850  }
851 
853  if (s->psypp)
854  ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
855 
856  if (!avctx->frame_num)
857  return 0;
858 
859  start_ch = 0;
860  for (i = 0; i < s->chan_map[0]; i++) {
861  FFPsyWindowInfo* wi = windows + start_ch;
862  tag = s->chan_map[i+1];
863  chans = tag == TYPE_CPE ? 2 : 1;
864  cpe = &s->cpe[i];
865  for (ch = 0; ch < chans; ch++) {
866  int k;
867  float clip_avoidance_factor;
868  sce = &cpe->ch[ch];
869  ics = &sce->ics;
870  s->cur_channel = start_ch + ch;
871  overlap = &samples[s->cur_channel][0];
872  samples2 = overlap + 1024;
873  la = samples2 + (448+64);
874  if (!frame)
875  la = NULL;
876  if (tag == TYPE_LFE) {
877  wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
878  wi[ch].window_shape = 0;
879  wi[ch].num_windows = 1;
880  wi[ch].grouping[0] = 1;
881  wi[ch].clipping[0] = 0;
882 
883  /* Only the lowest 12 coefficients are used in a LFE channel.
884  * The expression below results in only the bottom 8 coefficients
885  * being used for 11.025kHz to 16kHz sample rates.
886  */
887  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
888  } else {
889  wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
890  ics->window_sequence[0]);
891  }
892  ics->window_sequence[1] = ics->window_sequence[0];
893  ics->window_sequence[0] = wi[ch].window_type[0];
894  ics->use_kb_window[1] = ics->use_kb_window[0];
895  ics->use_kb_window[0] = wi[ch].window_shape;
896  ics->num_windows = wi[ch].num_windows;
897  ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
898  ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
899  ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);
900  ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
901  ff_swb_offset_128 [s->samplerate_index]:
902  ff_swb_offset_1024[s->samplerate_index];
903  ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
904  ff_tns_max_bands_128 [s->samplerate_index]:
905  ff_tns_max_bands_1024[s->samplerate_index];
906 
907  for (w = 0; w < ics->num_windows; w++)
908  ics->group_len[w] = wi[ch].grouping[w];
909 
910  /* Calculate input sample maximums and evaluate clipping risk */
911  clip_avoidance_factor = 0.0f;
912  for (w = 0; w < ics->num_windows; w++) {
913  const float *wbuf = overlap + w * 128;
914  const int wlen = 2048 / ics->num_windows;
915  float max = 0;
916  int j;
917  /* mdct input is 2 * output */
918  for (j = 0; j < wlen; j++)
919  max = FFMAX(max, fabsf(wbuf[j]));
920  wi[ch].clipping[w] = max;
921  }
922  for (w = 0; w < ics->num_windows; w++) {
923  if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
924  ics->window_clipping[w] = 1;
925  clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
926  } else {
927  ics->window_clipping[w] = 0;
928  }
929  }
930  if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
931  ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
932  } else {
933  ics->clip_avoidance_factor = 1.0f;
934  }
935 
936  apply_window_and_mdct(s, sce, overlap);
937 
938  if (s->options.ltp && s->coder->update_ltp) {
939  s->coder->update_ltp(s, sce);
940  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
941  s->mdct1024_fn(s->mdct1024, sce->lcoeffs, sce->ret_buf, sizeof(float));
942  }
943 
944  for (k = 0; k < 1024; k++) {
945  if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
946  av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
947  return AVERROR(EINVAL);
948  }
949  }
950  avoid_clipping(s, sce);
951  }
952  start_ch += chans;
953  }
954  if ((ret = ff_alloc_packet(avctx, avpkt, 8192 * s->channels)) < 0)
955  return ret;
956  frame_bits = its = 0;
957  do {
958  init_put_bits(&s->pb, avpkt->data, avpkt->size);
959 
960  if ((avctx->frame_num & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
962  start_ch = 0;
963  target_bits = 0;
964  memset(chan_el_counter, 0, sizeof(chan_el_counter));
965  for (i = 0; i < s->chan_map[0]; i++) {
966  FFPsyWindowInfo* wi = windows + start_ch;
967  const float *coeffs[2];
968  tag = s->chan_map[i+1];
969  chans = tag == TYPE_CPE ? 2 : 1;
970  cpe = &s->cpe[i];
971  cpe->common_window = 0;
972  memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
973  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
974  put_bits(&s->pb, 3, tag);
975  put_bits(&s->pb, 4, chan_el_counter[tag]++);
976  for (ch = 0; ch < chans; ch++) {
977  sce = &cpe->ch[ch];
978  coeffs[ch] = sce->coeffs;
979  sce->ics.predictor_present = 0;
980  sce->ics.ltp.present = 0;
981  memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
982  memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
983  memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
984  for (w = 0; w < 128; w++)
985  if (sce->band_type[w] > RESERVED_BT)
986  sce->band_type[w] = 0;
987  }
988  s->psy.bitres.alloc = -1;
989  s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
990  s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
991  if (s->psy.bitres.alloc > 0) {
992  /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
993  target_bits += s->psy.bitres.alloc
994  * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
995  s->psy.bitres.alloc /= chans;
996  }
997  s->cur_type = tag;
998  for (ch = 0; ch < chans; ch++) {
999  s->cur_channel = start_ch + ch;
1000  if (s->options.pns && s->coder->mark_pns)
1001  s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
1002  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
1003  }
1004  if (chans > 1
1005  && wi[0].window_type[0] == wi[1].window_type[0]
1006  && wi[0].window_shape == wi[1].window_shape) {
1007 
1008  cpe->common_window = 1;
1009  for (w = 0; w < wi[0].num_windows; w++) {
1010  if (wi[0].grouping[w] != wi[1].grouping[w]) {
1011  cpe->common_window = 0;
1012  break;
1013  }
1014  }
1015  }
1016  for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
1017  sce = &cpe->ch[ch];
1018  s->cur_channel = start_ch + ch;
1019  if (s->options.tns && s->coder->search_for_tns)
1020  s->coder->search_for_tns(s, sce);
1021  if (s->options.tns && s->coder->apply_tns_filt)
1022  s->coder->apply_tns_filt(s, sce);
1023  if (sce->tns.present)
1024  tns_mode = 1;
1025  if (s->options.pns && s->coder->search_for_pns)
1026  s->coder->search_for_pns(s, avctx, sce);
1027  }
1028  s->cur_channel = start_ch;
1029  if (s->options.intensity_stereo) { /* Intensity Stereo */
1030  if (s->coder->search_for_is)
1031  s->coder->search_for_is(s, avctx, cpe);
1032  if (cpe->is_mode) is_mode = 1;
1034  }
1035  if (s->options.pred) { /* Prediction */
1036  for (ch = 0; ch < chans; ch++) {
1037  sce = &cpe->ch[ch];
1038  s->cur_channel = start_ch + ch;
1039  if (s->options.pred && s->coder->search_for_pred)
1040  s->coder->search_for_pred(s, sce);
1041  if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
1042  }
1043  if (s->coder->adjust_common_pred)
1044  s->coder->adjust_common_pred(s, cpe);
1045  for (ch = 0; ch < chans; ch++) {
1046  sce = &cpe->ch[ch];
1047  s->cur_channel = start_ch + ch;
1048  if (s->options.pred && s->coder->apply_main_pred)
1049  s->coder->apply_main_pred(s, sce);
1050  }
1051  s->cur_channel = start_ch;
1052  }
1053  if (s->options.mid_side) { /* Mid/Side stereo */
1054  if (s->options.mid_side == -1 && s->coder->search_for_ms)
1055  s->coder->search_for_ms(s, cpe);
1056  else if (cpe->common_window)
1057  memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
1058  apply_mid_side_stereo(cpe);
1059  }
1060  adjust_frame_information(cpe, chans);
1061  if (s->options.ltp) { /* LTP */
1062  for (ch = 0; ch < chans; ch++) {
1063  sce = &cpe->ch[ch];
1064  s->cur_channel = start_ch + ch;
1065  if (s->coder->search_for_ltp)
1066  s->coder->search_for_ltp(s, sce, cpe->common_window);
1067  if (sce->ics.ltp.present) pred_mode = 1;
1068  }
1069  s->cur_channel = start_ch;
1070  if (s->coder->adjust_common_ltp)
1071  s->coder->adjust_common_ltp(s, cpe);
1072  }
1073  if (chans == 2) {
1074  put_bits(&s->pb, 1, cpe->common_window);
1075  if (cpe->common_window) {
1076  put_ics_info(s, &cpe->ch[0].ics);
1077  if (s->coder->encode_main_pred)
1078  s->coder->encode_main_pred(s, &cpe->ch[0]);
1079  if (s->coder->encode_ltp_info)
1080  s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
1081  encode_ms_info(&s->pb, cpe);
1082  if (cpe->ms_mode) ms_mode = 1;
1083  }
1084  }
1085  for (ch = 0; ch < chans; ch++) {
1086  s->cur_channel = start_ch + ch;
1087  encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
1088  }
1089  start_ch += chans;
1090  }
1091 
1092  if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
1093  /* When using a constant Q-scale, don't mess with lambda */
1094  break;
1095  }
1096 
1097  /* rate control stuff
1098  * allow between the nominal bitrate, and what psy's bit reservoir says to target
1099  * but drift towards the nominal bitrate always
1100  */
1101  frame_bits = put_bits_count(&s->pb);
1102  rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
1103  rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
1104  too_many_bits = FFMAX(target_bits, rate_bits);
1105  too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
1106  too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
1107 
1108  /* When strict bit-rate control is demanded */
1109  if (avctx->bit_rate_tolerance == 0) {
1110  if (rate_bits < frame_bits) {
1111  float ratio = ((float)rate_bits) / frame_bits;
1112  s->lambda *= FFMIN(0.9f, ratio);
1113  continue;
1114  }
1115  /* reset lambda when solution is found */
1116  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1117  break;
1118  }
1119 
1120  /* When using ABR, be strict (but only for increasing) */
1121  too_few_bits = too_few_bits - too_few_bits/8;
1122  too_many_bits = too_many_bits + too_many_bits/2;
1123 
1124  if ( its == 0 /* for steady-state Q-scale tracking */
1125  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
1126  || frame_bits >= 6144 * s->channels - 3 )
1127  {
1128  float ratio = ((float)rate_bits) / frame_bits;
1129 
1130  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
1131  /*
1132  * This path is for steady-state Q-scale tracking
1133  * When frame bits fall within the stable range, we still need to adjust
1134  * lambda to maintain it like so in a stable fashion (large jumps in lambda
1135  * create artifacts and should be avoided), but slowly
1136  */
1137  ratio = sqrtf(sqrtf(ratio));
1138  ratio = av_clipf(ratio, 0.9f, 1.1f);
1139  } else {
1140  /* Not so fast though */
1141  ratio = sqrtf(ratio);
1142  }
1143  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
1144 
1145  /* Keep iterating if we must reduce and lambda is in the sky */
1146  if (ratio > 0.9f && ratio < 1.1f) {
1147  break;
1148  } else {
1149  if (is_mode || ms_mode || tns_mode || pred_mode) {
1150  for (i = 0; i < s->chan_map[0]; i++) {
1151  // Must restore coeffs
1152  chans = tag == TYPE_CPE ? 2 : 1;
1153  cpe = &s->cpe[i];
1154  for (ch = 0; ch < chans; ch++)
1155  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
1156  }
1157  }
1158  its++;
1159  }
1160  } else {
1161  break;
1162  }
1163  } while (1);
1164 
1165  if (s->options.ltp && s->coder->ltp_insert_new_frame)
1166  s->coder->ltp_insert_new_frame(s);
1167 
1168  put_bits(&s->pb, 3, TYPE_END);
1169  flush_put_bits(&s->pb);
1170 
1171  s->last_frame_pb_count = put_bits_count(&s->pb);
1172  avpkt->size = put_bytes_output(&s->pb);
1173 
1174  s->lambda_sum += s->lambda;
1175  s->lambda_count++;
1176 
1177  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
1178  &avpkt->duration);
1179 
1180  *got_packet_ptr = 1;
1181  return 0;
1182 }
1183 
1185 {
1186  AACEncContext *s = avctx->priv_data;
1187 
1188  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
1189 
1190  av_tx_uninit(&s->mdct1024);
1191  av_tx_uninit(&s->mdct128);
1192  ff_psy_end(&s->psy);
1193  ff_lpc_end(&s->lpc);
1194  if (s->psypp)
1195  ff_psy_preprocess_end(s->psypp);
1196  av_freep(&s->buffer.samples);
1197  av_freep(&s->cpe);
1198  av_freep(&s->fdsp);
1199  ff_af_queue_close(&s->afq);
1200  return 0;
1201 }
1202 
1204 {
1205  int ret = 0;
1206  float scale = 32768.0f;
1207 
1209  if (!s->fdsp)
1210  return AVERROR(ENOMEM);
1211 
1212  if ((ret = av_tx_init(&s->mdct1024, &s->mdct1024_fn, AV_TX_FLOAT_MDCT, 0,
1213  1024, &scale, 0)) < 0)
1214  return ret;
1215  if ((ret = av_tx_init(&s->mdct128, &s->mdct128_fn, AV_TX_FLOAT_MDCT, 0,
1216  128, &scale, 0)) < 0)
1217  return ret;
1218 
1219  return 0;
1220 }
1221 
1223 {
1224  int ch;
1225  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
1226  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
1227  return AVERROR(ENOMEM);
1228 
1229  for(ch = 0; ch < s->channels; ch++)
1230  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
1231 
1232  return 0;
1233 }
1234 
1236 {
1237  AACEncContext *s = avctx->priv_data;
1238  int i, ret = 0;
1239  const uint8_t *sizes[2];
1240  uint8_t grouping[AAC_MAX_CHANNELS];
1241  int lengths[2];
1242 
1243  /* Constants */
1244  s->last_frame_pb_count = 0;
1245  avctx->frame_size = 1024;
1246  avctx->initial_padding = 1024;
1247  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1248 
1249  /* Channel map and unspecified bitrate guessing */
1250  s->channels = avctx->ch_layout.nb_channels;
1251 
1252  s->needs_pce = 1;
1253  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
1255  s->needs_pce = s->options.pce;
1256  break;
1257  }
1258  }
1259 
1260  if (s->needs_pce) {
1261  char buf[64];
1262  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
1264  break;
1265  av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
1266  if (i == FF_ARRAY_ELEMS(aac_pce_configs)) {
1267  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout \"%s\"\n", buf);
1268  return AVERROR(EINVAL);
1269  }
1270  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
1271  s->pce = aac_pce_configs[i];
1272  s->reorder_map = s->pce.reorder_map;
1273  s->chan_map = s->pce.config_map;
1274  } else {
1275  s->reorder_map = aac_chan_maps[s->channels - 1];
1276  s->chan_map = aac_chan_configs[s->channels - 1];
1277  }
1278 
1279  if (!avctx->bit_rate) {
1280  for (i = 1; i <= s->chan_map[0]; i++) {
1281  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
1282  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
1283  69000 ; /* SCE */
1284  }
1285  }
1286 
1287  /* Samplerate */
1288  for (i = 0; i < 16; i++)
1289  if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i])
1290  break;
1291  s->samplerate_index = i;
1292  ERROR_IF(s->samplerate_index == 16 ||
1293  s->samplerate_index >= ff_aac_swb_size_1024_len ||
1294  s->samplerate_index >= ff_aac_swb_size_128_len,
1295  "Unsupported sample rate %d\n", avctx->sample_rate);
1296 
1297  /* Bitrate limiting */
1298  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1299  "Too many bits %f > %d per frame requested, clamping to max\n",
1300  1024.0 * avctx->bit_rate / avctx->sample_rate,
1301  6144 * s->channels);
1302  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1303  avctx->bit_rate);
1304 
1305  /* Profile and option setting */
1306  avctx->profile = avctx->profile == AV_PROFILE_UNKNOWN ? AV_PROFILE_AAC_LOW :
1307  avctx->profile;
1308  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1309  if (avctx->profile == aacenc_profiles[i])
1310  break;
1311  if (avctx->profile == AV_PROFILE_MPEG2_AAC_LOW) {
1312  avctx->profile = AV_PROFILE_AAC_LOW;
1313  ERROR_IF(s->options.pred,
1314  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1315  ERROR_IF(s->options.ltp,
1316  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1317  WARN_IF(s->options.pns,
1318  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1319  s->options.pns = 0;
1320  } else if (avctx->profile == AV_PROFILE_AAC_LTP) {
1321  s->options.ltp = 1;
1322  ERROR_IF(s->options.pred,
1323  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1324  } else if (avctx->profile == AV_PROFILE_AAC_MAIN) {
1325  s->options.pred = 1;
1326  ERROR_IF(s->options.ltp,
1327  "LTP prediction unavailable in the \"aac_main\" profile\n");
1328  } else if (s->options.ltp) {
1329  avctx->profile = AV_PROFILE_AAC_LTP;
1330  WARN_IF(1,
1331  "Chainging profile to \"aac_ltp\"\n");
1332  ERROR_IF(s->options.pred,
1333  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1334  } else if (s->options.pred) {
1335  avctx->profile = AV_PROFILE_AAC_MAIN;
1336  WARN_IF(1,
1337  "Chainging profile to \"aac_main\"\n");
1338  ERROR_IF(s->options.ltp,
1339  "LTP prediction unavailable in the \"aac_main\" profile\n");
1340  }
1341  s->profile = avctx->profile;
1342 
1343  /* Coder limitations */
1344  s->coder = &ff_aac_coders[s->options.coder];
1345  if (s->options.coder == AAC_CODER_ANMR) {
1347  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
1348  s->options.intensity_stereo = 0;
1349  s->options.pns = 0;
1350  }
1352  "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
1353 
1354  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1355  if (s->channels > 3)
1356  s->options.mid_side = 0;
1357 
1358  // Initialize static tables
1360 
1361  if ((ret = dsp_init(avctx, s)) < 0)
1362  return ret;
1363 
1364  if ((ret = alloc_buffers(avctx, s)) < 0)
1365  return ret;
1366 
1367  if ((ret = put_audio_specific_config(avctx)))
1368  return ret;
1369 
1370  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1371  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1372  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1373  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1374  for (i = 0; i < s->chan_map[0]; i++)
1375  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1376  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1377  s->chan_map[0], grouping)) < 0)
1378  return ret;
1379  s->psypp = ff_psy_preprocess_init(avctx);
1381  s->random_state = 0x1f2e3d4c;
1382 
1383  ff_aacenc_dsp_init(&s->aacdsp);
1384 
1385  ff_af_queue_init(avctx, &s->afq);
1386 
1387  return 0;
1388 }
1389 
1390 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1391 static const AVOption aacenc_options[] = {
1392  {"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"},
1393  {"anmr", "ANMR method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1394  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1395  {"fast", "Default fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1396  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1397  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1398  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1399  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1400  {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1401  {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1402  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1404  {NULL}
1405 };
1406 
1407 static const AVClass aacenc_class = {
1408  .class_name = "AAC encoder",
1409  .item_name = av_default_item_name,
1410  .option = aacenc_options,
1411  .version = LIBAVUTIL_VERSION_INT,
1412 };
1413 
1415  { "b", "0" },
1416  { NULL }
1417 };
1418 
1420  .p.name = "aac",
1421  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
1422  .p.type = AVMEDIA_TYPE_AUDIO,
1423  .p.id = AV_CODEC_ID_AAC,
1424  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1426  .priv_data_size = sizeof(AACEncContext),
1427  .init = aac_encode_init,
1429  .close = aac_encode_end,
1430  .defaults = aac_encode_defaults,
1431  .p.supported_samplerates = ff_mpeg4audio_sample_rates,
1432  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1433  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1435  .p.priv_class = &aacenc_class,
1436 };
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:142
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:1407
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:786
ff_aac_kbd_short_128
float ff_aac_kbd_short_128[128]
libm.h
SingleChannelElement::pulse
Pulse pulse
Definition: aacenc.h:130
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:46
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:807
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: aacenc.c:1235
aacenc_profiles
static const int aacenc_profiles[]
Definition: aacenctab.h:127
Pulse::num_pulse
int num_pulse
Definition: aac.h:100
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:134
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:341
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:92
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:357
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:643
AV_PROFILE_MPEG2_AAC_LOW
#define AV_PROFILE_MPEG2_AAC_LOW
Definition: defs.h:76
TemporalNoiseShaping::present
int present
Definition: aacdec.h:120
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:174
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:712
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:106
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
SingleChannelElement::coeffs
float coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacenc.h:139
avoid_clipping
static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
Downscale spectral coefficients for near-clipping windows to avoid artifacts.
Definition: aacenc.c:740
FFCodecDefault
Definition: codec_internal.h:96
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
mpeg4audio.h
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
SingleChannelElement::ret_buf
float ret_buf[2048]
PCM output buffer.
Definition: aacenc.h:140
apply_mid_side_stereo
static void apply_mid_side_stereo(ChannelElement *cpe)
Definition: aacenc.c:608
AV_CHANNEL_LAYOUT_2POINT1
#define AV_CHANNEL_LAYOUT_2POINT1
Definition: channel_layout.h:380
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
ChannelElement::ms_mode
int ms_mode
Signals mid/side stereo flags coding mode.
Definition: aacenc.h:153
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:113
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
Pulse::amp
int amp[4]
Definition: aac.h:103
Pulse::pos
int pos[4]
Definition: aac.h:102
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:101
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:202
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:146
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:108
SingleChannelElement::ltp_state
float ltp_state[3072]
time signal for LTP
Definition: aacenc.h:141
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:71
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
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:98
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:62
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:72
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:1222
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:89
channel_map
static const uint8_t channel_map[8][8]
Definition: atrac3plusdec.c:52
IndividualChannelStream
Individual Channel Stream.
Definition: aacdec.h:98
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:91
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:95
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:73
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:156
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:693
SingleChannelElement::is_ener
float is_ener[128]
Intensity stereo pos.
Definition: aacenc.h:136
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aacdec.h:101
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:366
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aacdec.h:172
aac.h
aactab.h
IndividualChannelStream::predictor_present
int predictor_present
Definition: aacdec.h:109
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:36
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices
Definition: aacenc.h:133
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:829
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:196
AACPCEInfo
Definition: aacenc.h:200
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:100
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:60
TYPE_END
@ TYPE_END
Definition: aac.h:47
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:657
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:152
sinewin.h
apply_intensity_stereo
static void apply_intensity_stereo(ChannelElement *cpe)
Definition: aacenc.c:579
AACPCEInfo::index
int index[4][8]
front, side, back, lfe
Definition: aacenc.h:204
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:148
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:145
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:107
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:1391
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:138
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:63
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:169
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:105
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:203
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:96
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:43
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:40
AACENC_FLAGS
#define AACENC_FLAGS
Definition: aacenc.c:1390
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aacdec.h:108
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2031
aac_encode_defaults
static const FFCodecDefault aac_encode_defaults[]
Definition: aacenc.c:1414
tag
uint32_t tag
Definition: movenc.c:1788
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:1419
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:70
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:61
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:147
AACEncContext
AAC encoder context.
Definition: aacenc.h:212
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:760
NOISE_OFFSET
#define NOISE_OFFSET
subtracted from global gain, used as offset for the preamble
Definition: aac.h:97
ERROR_IF
#define ERROR_IF(cond,...)
Definition: aacenc_utils.h:244
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aacdec.h:112
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:245
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aacdec.h:119
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1640
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:154
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:1184
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:261
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:99
Pulse
Definition: aac.h:99
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
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
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:1203
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:388
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aacdec.h:104
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:103
psymodel.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:254
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:201
aacenc.h