FFmpeg: libavcodec/aacenc.c Source File

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 
33 #include "libavutil/channel_layout.h"
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  {
92  .layout = AV_CHANNEL_LAYOUT_MONO,
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  {
188  .layout = AV_CHANNEL_LAYOUT_5POINT0_BACK,
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  {
196  .layout = AV_CHANNEL_LAYOUT_5POINT1_BACK,
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  {
212  .layout = AV_CHANNEL_LAYOUT_6POINT0_FRONT,
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  {
236  .layout = AV_CHANNEL_LAYOUT_6POINT1_BACK,
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  {
244  .layout = AV_CHANNEL_LAYOUT_6POINT1_FRONT,
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  {
260  .layout = AV_CHANNEL_LAYOUT_7POINT0_FRONT,
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  {
276  .layout = AV_CHANNEL_LAYOUT_7POINT1_WIDE,
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  {
284  .layout = AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK,
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,
301  .u.mask = AV_CH_LAYOUT_OCTAGONAL | AV_CH_TOP_CENTER },
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,
310  .u.mask = AV_CH_LAYOUT_6POINT0_FRONT | AV_CH_BACK_CENTER |
311  AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT | AV_CH_TOP_CENTER },
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  {
319  .layout = AV_CHANNEL_LAYOUT_HEXADECAGONAL,
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 } },
323  .config_map = { 10, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_CPE, TYPE_SCE, TYPE_CPE, TYPE_SCE },
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  */
369  static int put_audio_specific_config(AVCodecContext *avctx)
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 
401  void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
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,
467  SingleChannelElement *sce,
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 
475  static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce,
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 
483  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE)
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  */
496  static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
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, 0); /* No 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  */
517  static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
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 
579  static void apply_intensity_stereo(ChannelElement *cpe)
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 
608  static void apply_mid_side_stereo(ChannelElement *cpe)
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  */
643  static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
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  */
657  static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s,
658  SingleChannelElement *sce)
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) {
671  put_bits(&s->pb, NOISE_PRE_BITS, diff + NOISE_PRE);
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  }
682  diff += SCALE_DIFF_ZERO;
683  av_assert0(diff >= 0 && diff <= 120);
684  put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
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  */
712  static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
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  */
740  static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
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  */
760  static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s,
761  SingleChannelElement *sce,
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  encode_band_info(s, sce);
768  encode_scale_factors(avctx, s, sce);
769  encode_pulses(s, &sce->pulse);
770  put_bits(&s->pb, 1, !!sce->tns.present);
771  if (s->coder->encode_tns_info)
772  s->coder->encode_tns_info(s, sce);
773  put_bits(&s->pb, 1, 0); //ssr
774  encode_spectral_coeffs(s, sce);
775  return 0;
776 }
777 
778 /**
779  * Write some auxiliary information about the created AAC file.
780  */
781  static void put_bitstream_info(AACEncContext *s, const char *name)
782 {
783  int i, namelen, padbits;
784 
785  namelen = strlen(name) + 2;
786  put_bits(&s->pb, 3, TYPE_FIL);
787  put_bits(&s->pb, 4, FFMIN(namelen, 15));
788  if (namelen >= 15)
789  put_bits(&s->pb, 8, namelen - 14);
790  put_bits(&s->pb, 4, 0); //extension type - filler
791  padbits = -put_bits_count(&s->pb) & 7;
792  align_put_bits(&s->pb);
793  for (i = 0; i < namelen - 2; i++)
794  put_bits(&s->pb, 8, name[i]);
795  put_bits(&s->pb, 12 - padbits, 0);
796 }
797 
798 /*
799  * Copy input samples.
800  * Channels are reordered from libavcodec's default order to AAC order.
801  */
802  static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
803 {
804  int ch;
805  int end = 2048 + (frame ? frame->nb_samples : 0);
806  const uint8_t *channel_map = s->reorder_map;
807 
808  /* copy and remap input samples */
809  for (ch = 0; ch < s->channels; ch++) {
810  /* copy last 1024 samples of previous frame to the start of the current frame */
811  memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
812 
813  /* copy new samples and zero any remaining samples */
814  if (frame) {
815  memcpy(&s->planar_samples[ch][2048],
816  frame->extended_data[channel_map[ch]],
817  frame->nb_samples * sizeof(s->planar_samples[0][0]));
818  }
819  memset(&s->planar_samples[ch][end], 0,
820  (3072 - end) * sizeof(s->planar_samples[0][0]));
821  }
822 }
823 
824  static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
825  const AVFrame *frame, int *got_packet_ptr)
826 {
827  AACEncContext *s = avctx->priv_data;
828  float **samples = s->planar_samples, *samples2, *la, *overlap;
829  ChannelElement *cpe;
830  SingleChannelElement *sce;
831  IndividualChannelStream *ics;
832  int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
833  int target_bits, rate_bits, too_many_bits, too_few_bits;
834  int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
835  int chan_el_counter[4];
836  FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
837 
838  /* add current frame to queue */
839  if (frame) {
840  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
841  return ret;
842  } else {
843  if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
844  return 0;
845  }
846 
847  copy_input_samples(s, frame);
848 
849  if (!avctx->frame_num)
850  return 0;
851 
852  start_ch = 0;
853  for (i = 0; i < s->chan_map[0]; i++) {
854  FFPsyWindowInfo* wi = windows + start_ch;
855  tag = s->chan_map[i+1];
856  chans = tag == TYPE_CPE ? 2 : 1;
857  cpe = &s->cpe[i];
858  for (ch = 0; ch < chans; ch++) {
859  int k;
860  float clip_avoidance_factor;
861  sce = &cpe->ch[ch];
862  ics = &sce->ics;
863  s->cur_channel = start_ch + ch;
864  overlap = &samples[s->cur_channel][0];
865  samples2 = overlap + 1024;
866  la = samples2 + (448+64);
867  if (!frame)
868  la = NULL;
869  if (tag == TYPE_LFE) {
870  wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
871  wi[ch].window_shape = 0;
872  wi[ch].num_windows = 1;
873  wi[ch].grouping[0] = 1;
874  wi[ch].clipping[0] = 0;
875 
876  /* Only the lowest 12 coefficients are used in a LFE channel.
877  * The expression below results in only the bottom 8 coefficients
878  * being used for 11.025kHz to 16kHz sample rates.
879  */
880  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
881  } else {
882  wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
883  ics->window_sequence[0]);
884  }
885  ics->window_sequence[1] = ics->window_sequence[0];
886  ics->window_sequence[0] = wi[ch].window_type[0];
887  ics->use_kb_window[1] = ics->use_kb_window[0];
888  ics->use_kb_window[0] = wi[ch].window_shape;
889  ics->num_windows = wi[ch].num_windows;
890  ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
891  ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
892  ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);
893  ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
894  ff_swb_offset_128 [s->samplerate_index]:
895  ff_swb_offset_1024[s->samplerate_index];
896  ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
897  ff_tns_max_bands_128 [s->samplerate_index]:
898  ff_tns_max_bands_1024[s->samplerate_index];
899 
900  for (w = 0; w < ics->num_windows; w++)
901  ics->group_len[w] = wi[ch].grouping[w];
902 
903  /* Calculate input sample maximums and evaluate clipping risk */
904  clip_avoidance_factor = 0.0f;
905  for (w = 0; w < ics->num_windows; w++) {
906  const float *wbuf = overlap + w * 128;
907  const int wlen = 2048 / ics->num_windows;
908  float max = 0;
909  int j;
910  /* mdct input is 2 * output */
911  for (j = 0; j < wlen; j++)
912  max = FFMAX(max, fabsf(wbuf[j]));
913  wi[ch].clipping[w] = max;
914  }
915  for (w = 0; w < ics->num_windows; w++) {
916  if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
917  ics->window_clipping[w] = 1;
918  clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
919  } else {
920  ics->window_clipping[w] = 0;
921  }
922  }
923  if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
924  ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
925  } else {
926  ics->clip_avoidance_factor = 1.0f;
927  }
928 
929  apply_window_and_mdct(s, sce, overlap);
930 
931  for (k = 0; k < 1024; k++) {
932  if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
933  av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
934  return AVERROR(EINVAL);
935  }
936  }
937  avoid_clipping(s, sce);
938  }
939  start_ch += chans;
940  }
941  if ((ret = ff_alloc_packet(avctx, avpkt, 8192 * s->channels)) < 0)
942  return ret;
943  frame_bits = its = 0;
944  do {
945  init_put_bits(&s->pb, avpkt->data, avpkt->size);
946 
947  if ((avctx->frame_num & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
948  put_bitstream_info(s, LIBAVCODEC_IDENT);
949  start_ch = 0;
950  target_bits = 0;
951  memset(chan_el_counter, 0, sizeof(chan_el_counter));
952  for (i = 0; i < s->chan_map[0]; i++) {
953  FFPsyWindowInfo* wi = windows + start_ch;
954  const float *coeffs[2];
955  tag = s->chan_map[i+1];
956  chans = tag == TYPE_CPE ? 2 : 1;
957  cpe = &s->cpe[i];
958  cpe->common_window = 0;
959  memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
960  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
961  put_bits(&s->pb, 3, tag);
962  put_bits(&s->pb, 4, chan_el_counter[tag]++);
963  for (ch = 0; ch < chans; ch++) {
964  sce = &cpe->ch[ch];
965  coeffs[ch] = sce->coeffs;
966  memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
967  for (w = 0; w < 128; w++)
968  if (sce->band_type[w] > RESERVED_BT)
969  sce->band_type[w] = 0;
970  }
971  s->psy.bitres.alloc = -1;
972  s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
973  s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
974  if (s->psy.bitres.alloc > 0) {
975  /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
976  target_bits += s->psy.bitres.alloc
977  * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
978  s->psy.bitres.alloc /= chans;
979  }
980  s->cur_type = tag;
981  for (ch = 0; ch < chans; ch++) {
982  s->cur_channel = start_ch + ch;
983  if (s->options.pns && s->coder->mark_pns)
984  s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
985  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
986  }
987  if (chans > 1
988  && wi[0].window_type[0] == wi[1].window_type[0]
989  && wi[0].window_shape == wi[1].window_shape) {
990 
991  cpe->common_window = 1;
992  for (w = 0; w < wi[0].num_windows; w++) {
993  if (wi[0].grouping[w] != wi[1].grouping[w]) {
994  cpe->common_window = 0;
995  break;
996  }
997  }
998  }
999  for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
1000  sce = &cpe->ch[ch];
1001  s->cur_channel = start_ch + ch;
1002  if (s->options.tns && s->coder->search_for_tns)
1003  s->coder->search_for_tns(s, sce);
1004  if (s->options.tns && s->coder->apply_tns_filt)
1005  s->coder->apply_tns_filt(s, sce);
1006  if (sce->tns.present)
1007  tns_mode = 1;
1008  if (s->options.pns && s->coder->search_for_pns)
1009  s->coder->search_for_pns(s, avctx, sce);
1010  }
1011  s->cur_channel = start_ch;
1012  if (s->options.intensity_stereo) { /* Intensity Stereo */
1013  if (s->coder->search_for_is)
1014  s->coder->search_for_is(s, avctx, cpe);
1015  if (cpe->is_mode) is_mode = 1;
1016  apply_intensity_stereo(cpe);
1017  }
1018  if (s->options.mid_side) { /* Mid/Side stereo */
1019  if (s->options.mid_side == -1 && s->coder->search_for_ms)
1020  s->coder->search_for_ms(s, cpe);
1021  else if (cpe->common_window)
1022  memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
1023  apply_mid_side_stereo(cpe);
1024  }
1025  adjust_frame_information(cpe, chans);
1026  if (chans == 2) {
1027  put_bits(&s->pb, 1, cpe->common_window);
1028  if (cpe->common_window) {
1029  put_ics_info(s, &cpe->ch[0].ics);
1030  encode_ms_info(&s->pb, cpe);
1031  if (cpe->ms_mode) ms_mode = 1;
1032  }
1033  }
1034  for (ch = 0; ch < chans; ch++) {
1035  s->cur_channel = start_ch + ch;
1036  encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
1037  }
1038  start_ch += chans;
1039  }
1040 
1041  if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
1042  /* When using a constant Q-scale, don't mess with lambda */
1043  break;
1044  }
1045 
1046  /* rate control stuff
1047  * allow between the nominal bitrate, and what psy's bit reservoir says to target
1048  * but drift towards the nominal bitrate always
1049  */
1050  frame_bits = put_bits_count(&s->pb);
1051  rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
1052  rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
1053  too_many_bits = FFMAX(target_bits, rate_bits);
1054  too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
1055  too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
1056 
1057  /* When strict bit-rate control is demanded */
1058  if (avctx->bit_rate_tolerance == 0) {
1059  if (rate_bits < frame_bits) {
1060  float ratio = ((float)rate_bits) / frame_bits;
1061  s->lambda *= FFMIN(0.9f, ratio);
1062  continue;
1063  }
1064  /* reset lambda when solution is found */
1065  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1066  break;
1067  }
1068 
1069  /* When using ABR, be strict (but only for increasing) */
1070  too_few_bits = too_few_bits - too_few_bits/8;
1071  too_many_bits = too_many_bits + too_many_bits/2;
1072 
1073  if ( its == 0 /* for steady-state Q-scale tracking */
1074  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
1075  || frame_bits >= 6144 * s->channels - 3 )
1076  {
1077  float ratio = ((float)rate_bits) / frame_bits;
1078 
1079  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
1080  /*
1081  * This path is for steady-state Q-scale tracking
1082  * When frame bits fall within the stable range, we still need to adjust
1083  * lambda to maintain it like so in a stable fashion (large jumps in lambda
1084  * create artifacts and should be avoided), but slowly
1085  */
1086  ratio = sqrtf(sqrtf(ratio));
1087  ratio = av_clipf(ratio, 0.9f, 1.1f);
1088  } else {
1089  /* Not so fast though */
1090  ratio = sqrtf(ratio);
1091  }
1092  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
1093 
1094  /* Keep iterating if we must reduce and lambda is in the sky */
1095  if (ratio > 0.9f && ratio < 1.1f) {
1096  break;
1097  } else {
1098  if (is_mode || ms_mode || tns_mode || pred_mode) {
1099  for (i = 0; i < s->chan_map[0]; i++) {
1100  // Must restore coeffs
1101  chans = tag == TYPE_CPE ? 2 : 1;
1102  cpe = &s->cpe[i];
1103  for (ch = 0; ch < chans; ch++)
1104  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
1105  }
1106  }
1107  its++;
1108  }
1109  } else {
1110  break;
1111  }
1112  } while (1);
1113 
1114  put_bits(&s->pb, 3, TYPE_END);
1115  flush_put_bits(&s->pb);
1116 
1117  s->last_frame_pb_count = put_bits_count(&s->pb);
1118  avpkt->size = put_bytes_output(&s->pb);
1119 
1120  s->lambda_sum += s->lambda;
1121  s->lambda_count++;
1122 
1123  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
1124  &avpkt->duration);
1125 
1126  avpkt->flags |= AV_PKT_FLAG_KEY;
1127 
1128  *got_packet_ptr = 1;
1129  return 0;
1130 }
1131 
1132  static av_cold int aac_encode_end(AVCodecContext *avctx)
1133 {
1134  AACEncContext *s = avctx->priv_data;
1135 
1136  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
1137 
1138  av_tx_uninit(&s->mdct1024);
1139  av_tx_uninit(&s->mdct128);
1140  ff_psy_end(&s->psy);
1141  ff_lpc_end(&s->lpc);
1142  av_freep(&s->buffer.samples);
1143  av_freep(&s->cpe);
1144  av_freep(&s->fdsp);
1145  ff_af_queue_close(&s->afq);
1146  return 0;
1147 }
1148 
1149  static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
1150 {
1151  int ret = 0;
1152  float scale = 32768.0f;
1153 
1154  s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
1155  if (!s->fdsp)
1156  return AVERROR(ENOMEM);
1157 
1158  if ((ret = av_tx_init(&s->mdct1024, &s->mdct1024_fn, AV_TX_FLOAT_MDCT, 0,
1159  1024, &scale, 0)) < 0)
1160  return ret;
1161  if ((ret = av_tx_init(&s->mdct128, &s->mdct128_fn, AV_TX_FLOAT_MDCT, 0,
1162  128, &scale, 0)) < 0)
1163  return ret;
1164 
1165  return 0;
1166 }
1167 
1168  static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
1169 {
1170  int ch;
1171  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
1172  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
1173  return AVERROR(ENOMEM);
1174 
1175  for(ch = 0; ch < s->channels; ch++)
1176  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
1177 
1178  return 0;
1179 }
1180 
1181  static av_cold int aac_encode_init(AVCodecContext *avctx)
1182 {
1183  AACEncContext *s = avctx->priv_data;
1184  int i, ret = 0;
1185  const uint8_t *sizes[2];
1186  uint8_t grouping[AAC_MAX_CHANNELS];
1187  int lengths[2];
1188 
1189  /* Constants */
1190  s->last_frame_pb_count = 0;
1191  avctx->frame_size = 1024;
1192  avctx->initial_padding = 1024;
1193  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
1194 
1195  /* Channel map and unspecified bitrate guessing */
1196  s->channels = avctx->ch_layout.nb_channels;
1197 
1198  s->needs_pce = 1;
1199  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
1200  if (!av_channel_layout_compare(&avctx->ch_layout, &aac_normal_chan_layouts[i])) {
1201  s->needs_pce = s->options.pce;
1202  break;
1203  }
1204  }
1205 
1206  if (s->needs_pce) {
1207  char buf[64];
1208  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
1209  if (!av_channel_layout_compare(&avctx->ch_layout, &aac_pce_configs[i].layout))
1210  break;
1211  av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
1212  if (i == FF_ARRAY_ELEMS(aac_pce_configs)) {
1213  av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout \"%s\"\n", buf);
1214  return AVERROR(EINVAL);
1215  }
1216  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
1217  s->pce = aac_pce_configs[i];
1218  s->reorder_map = s->pce.reorder_map;
1219  s->chan_map = s->pce.config_map;
1220  } else {
1221  s->reorder_map = aac_chan_maps[s->channels - 1];
1222  s->chan_map = aac_chan_configs[s->channels - 1];
1223  }
1224 
1225  if (!avctx->bit_rate) {
1226  for (i = 1; i <= s->chan_map[0]; i++) {
1227  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
1228  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
1229  69000 ; /* SCE */
1230  }
1231  }
1232 
1233  /* Samplerate */
1234  for (int i = 0;; i++) {
1235  av_assert1(i < 13);
1236  if (avctx->sample_rate == ff_mpeg4audio_sample_rates[i]) {
1237  s->samplerate_index = i;
1238  break;
1239  }
1240  }
1241 
1242  /* Bitrate limiting */
1243  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1244  "Too many bits %f > %d per frame requested, clamping to max\n",
1245  1024.0 * avctx->bit_rate / avctx->sample_rate,
1246  6144 * s->channels);
1247  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1248  avctx->bit_rate);
1249 
1250  /* Profile and option setting */
1251  avctx->profile = avctx->profile == AV_PROFILE_UNKNOWN ? AV_PROFILE_AAC_LOW :
1252  avctx->profile;
1253  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1254  if (avctx->profile == aacenc_profiles[i])
1255  break;
1256  ERROR_IF(i == FF_ARRAY_ELEMS(aacenc_profiles), "Profile not supported!\n");
1257  if (avctx->profile == AV_PROFILE_MPEG2_AAC_LOW) {
1258  avctx->profile = AV_PROFILE_AAC_LOW;
1259  WARN_IF(s->options.pns,
1260  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1261  s->options.pns = 0;
1262  }
1263  s->profile = avctx->profile;
1264 
1265  /* Coder limitations */
1266  s->coder = &ff_aac_coders[s->options.coder];
1267 
1268  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1269  if (s->channels > 3)
1270  s->options.mid_side = 0;
1271 
1272  // Initialize static tables
1273  ff_aac_float_common_init();
1274 
1275  if ((ret = dsp_init(avctx, s)) < 0)
1276  return ret;
1277 
1278  if ((ret = alloc_buffers(avctx, s)) < 0)
1279  return ret;
1280 
1281  if ((ret = put_audio_specific_config(avctx)))
1282  return ret;
1283 
1284  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1285  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1286  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1287  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1288  for (i = 0; i < s->chan_map[0]; i++)
1289  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1290  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1291  s->chan_map[0], grouping)) < 0)
1292  return ret;
1293  ff_lpc_init(&s->lpc, 2*avctx->frame_size, TNS_MAX_ORDER, FF_LPC_TYPE_LEVINSON);
1294  s->random_state = 0x1f2e3d4c;
1295 
1296  ff_aacenc_dsp_init(&s->aacdsp);
1297 
1298  ff_af_queue_init(avctx, &s->afq);
1299 
1300  return 0;
1301 }
1302 
1303  #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1304  static const AVOption aacenc_options[] = {
1305  {"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"},
1306  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1307  {"fast", "Fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, .unit = "coder"},
1308  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1309  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1310  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1311  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1312  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1313  FF_AAC_PROFILE_OPTS
1314  {NULL}
1315 };
1316 
1317  static const AVClass aacenc_class = {
1318  .class_name = "AAC encoder",
1319  .item_name = av_default_item_name,
1320  .option = aacenc_options,
1321  .version = LIBAVUTIL_VERSION_INT,
1322 };
1323 
1324  static const FFCodecDefault aac_encode_defaults[] = {
1325  { "b", "0" },
1326  { NULL }
1327 };
1328 
1329  const FFCodec ff_aac_encoder = {
1330  .p.name = "aac",
1331  CODEC_LONG_NAME("AAC (Advanced Audio Coding)"),
1332  .p.type = AVMEDIA_TYPE_AUDIO,
1333  .p.id = AV_CODEC_ID_AAC,
1334  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1335  AV_CODEC_CAP_SMALL_LAST_FRAME,
1336  .priv_data_size = sizeof(AACEncContext),
1337  .init = aac_encode_init,
1338  FF_CODEC_ENCODE_CB(aac_encode_frame),
1339  .close = aac_encode_end,
1340  .defaults = aac_encode_defaults,
1341  CODEC_SAMPLERATES_ARRAY(ff_mpeg4audio_sample_rates),
1342  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1343  CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),
1344  .p.priv_class = &aacenc_class,
1345 };
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:1051
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:66
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:1990
AV_CHANNEL_LAYOUT_OCTAGONAL
#define AV_CHANNEL_LAYOUT_OCTAGONAL
Definition: channel_layout.h:422
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:1317
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:781
ff_aac_kbd_short_128
float ff_aac_kbd_short_128[128]
libm.h
SingleChannelElement::pulse
Pulse pulse
Definition: aacenc.h:110
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:445
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:395
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:99
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
AV_CHANNEL_LAYOUT_4POINT1
#define AV_CHANNEL_LAYOUT_4POINT1
Definition: channel_layout.h:401
aacenctab.h
AV_CHANNEL_LAYOUT_HEXAGONAL
#define AV_CHANNEL_LAYOUT_HEXAGONAL
Definition: channel_layout.h:411
copy_input_samples
static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
Definition: aacenc.c:802
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: aacenc.c:1181
aacenc_profiles
static const int aacenc_profiles[]
Definition: aacenctab.h:125
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:213
int64_t
long long int64_t
Definition: coverity.c:34
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:226
SingleChannelElement::zeroes
uint8_t zeroes[128]
band is not coded
Definition: aacenc.h:114
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:340
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:402
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:224
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:588
ff_aac_coders
const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]
Definition: aaccoder.c:843
AVOption
AVOption.
Definition: opt.h:429
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:77
TemporalNoiseShaping::present
int present
Definition: aacdec.h:185
AV_CH_LAYOUT_6POINT0_FRONT
#define AV_CH_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:232
FFCodec
Definition: codec_internal.h:127
version.h
FFPsyWindowInfo::window_shape
int window_shape
window shape (sine/KBD/whatever)
Definition: psymodel.h:79
float.h
aac_chan_configs
static const uint8_t aac_chan_configs[AAC_MAX_CHANNELS][6]
default channel configurations
Definition: aacenctab.h:58
AAC_CODER_NB
@ AAC_CODER_NB
Definition: aacenc.h:48
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:606
max
#define max(a, b)
Definition: cuda_runtime.h:33
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:329
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aacdec.h:266
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:643
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1940
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:1974
AAC_CODER_FAST
@ AAC_CODER_FAST
Definition: aacenc.h:46
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aacdec.h:171
AV_CHANNEL_LAYOUT_7POINT1_WIDE
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE
Definition: channel_layout.h:418
WINDOW_FUNC
#define WINDOW_FUNC(type)
Definition: aacenc.c:410
SingleChannelElement::coeffs
float coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aacenc.h:119
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:131
mpeg4audio.h
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
SingleChannelElement::ret_buf
float ret_buf[2048]
PCM output buffer.
Definition: aacenc.h:120
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:396
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:41
ChannelElement::ms_mode
int ms_mode
Signals mid/side stereo flags coding mode.
Definition: aacenc.h:130
AV_CH_BACK_LEFT
#define AV_CH_BACK_LEFT
Definition: channel_layout.h:179
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1096
IndividualChannelStream::window_clipping
uint8_t window_clipping[8]
set if a certain window is near clipping
Definition: aacdec.h:178
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:488
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:1209
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:77
Pulse::start
int start
Definition: aac.h:101
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:359
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:414
AACPCEInfo::num_ele
int num_ele[4]
front, side, back, lfe
Definition: aacenc.h:170
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aacdec.h:211
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:398
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:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:106
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:88
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:653
AV_CHANNEL_LAYOUT_4POINT0
#define AV_CHANNEL_LAYOUT_4POINT0
Definition: channel_layout.h:400
float
float
Definition: af_crystalizer.c:122
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
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, respectively.
Definition: tx.h:68
AV_CHANNEL_LAYOUT_7POINT1
#define AV_CHANNEL_LAYOUT_7POINT1
Definition: channel_layout.h:417
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:1217
IndividualChannelStream::swb_sizes
const uint8_t * swb_sizes
table of scalefactor band sizes for a particular window
Definition: aacenc.h:83
g
const char * g
Definition: vf_curves.c:128
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
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:406
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:41
alloc_buffers
static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1168
channels
channels
Definition: aptx.h:31
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:162
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:332
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:72
if
if(ret)
Definition: filter_design.txt:179
ff_af_queue_close
av_cold void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
#define AV_CHANNEL_LAYOUT_7POINT1_WIDE_BACK
Definition: channel_layout.h:419
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:76
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:47
AV_CH_TOP_CENTER
#define AV_CH_TOP_CENTER
Definition: channel_layout.h:186
ChannelElement::is_mask
uint8_t is_mask[128]
Set if intensity stereo is used.
Definition: aacenc.h:133
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:61
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:116
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aacdec.h:165
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:169
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
profiles.h
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:365
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aacdec.h:264
options
Definition: swscale.c:43
aac.h
aactab.h
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:122
TNS_MAX_ORDER
#define TNS_MAX_ORDER
Definition: aac.h:36
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices
Definition: aacenc.h:113
float_dsp.h
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:461
aac_encode_frame
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: aacenc.c:824
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:200
AACPCEInfo
Definition: aacenc.h:168
FFPsyWindowInfo::clipping
float clipping[8]
maximum absolute normalized intensity in the given window for clip avoidance
Definition: psymodel.h:82
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aacdec.h:164
f
f
Definition: af_crystalizer.c:122
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:550
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:1900
AVPacket::size
int size
Definition: packet.h:589
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:424
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:24
AAC_CODER_TWOLOOP
@ AAC_CODER_TWOLOOP
Definition: aacenc.h:45
AV_CHANNEL_LAYOUT_6POINT0
#define AV_CHANNEL_LAYOUT_6POINT0
Definition: channel_layout.h:408
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:166
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:129
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:172
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:125
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:594
CODEC_SAMPLEFMTS
#define CODEC_SAMPLEFMTS(...)
Definition: codec_internal.h:386
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aacdec.h:214
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:809
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:221
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:28
AV_CHANNEL_LAYOUT_HEXADECAGONAL
#define AV_CHANNEL_LAYOUT_HEXADECAGONAL
Definition: channel_layout.h:430
AV_CHANNEL_LAYOUT_6POINT1_BACK
#define AV_CHANNEL_LAYOUT_6POINT1_BACK
Definition: channel_layout.h:413
AV_CH_LAYOUT_OCTAGONAL
#define AV_CH_LAYOUT_OCTAGONAL
Definition: channel_layout.h:245
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:210
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:581
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:90
IndividualChannelStream::num_windows
int num_windows
Definition: aacdec.h:172
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
aacenc_options
static const AVOption aacenc_options[]
Definition: aacenc.c:1304
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:403
SingleChannelElement::pcoeffs
float pcoeffs[1024]
coefficients for IMDCT, pristine
Definition: aacenc.h:118
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:63
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aacdec.h:260
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:170
AV_CHANNEL_LAYOUT_7POINT0_FRONT
#define AV_CHANNEL_LAYOUT_7POINT0_FRONT
Definition: channel_layout.h:416
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:171
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
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:183
AV_CHANNEL_LAYOUT_3POINT1
#define AV_CHANNEL_LAYOUT_3POINT1
Definition: channel_layout.h:399
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:43
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:179
TYPE_SCE
@ TYPE_SCE
Definition: aac.h:40
AACENC_FLAGS
#define AACENC_FLAGS
Definition: aacenc.c:1303
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aacdec.h:173
avcodec.h
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:1878
aac_encode_defaults
static const FFCodecDefault aac_encode_defaults[]
Definition: aacenc.c:1324
tag
uint32_t tag
Definition: movenc.c:1995
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:81
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:265
ff_aac_encoder
const FFCodec ff_aac_encoder
Definition: aacenc.c:1329
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:415
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
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aacdec.h:213
AACEncContext
AAC encoder context.
Definition: aacenc.h:180
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:397
AVCodecContext
main external API structure.
Definition: avcodec.h:431
channel_layout.h
CODEC_SAMPLERATES_ARRAY
#define CODEC_SAMPLERATES_ARRAY(array)
Definition: codec_internal.h:384
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
ff_aac_swb_size_1024
const uint8_t *const ff_aac_swb_size_1024[]
Definition: aacenctab.c:97
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aacdec.h:184
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1618
AOT_SBR
@ AOT_SBR
Y Spectral Band Replication.
Definition: mpeg4audio.h:77
L
#define L(x)
Definition: vpx_arith.h:36
AV_CHANNEL_LAYOUT_6POINT0_FRONT
#define AV_CHANNEL_LAYOUT_6POINT0_FRONT
Definition: channel_layout.h:409
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:131
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
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:30
ff_aac_swb_size_128
const uint8_t *const ff_aac_swb_size_128[]
Definition: aacenctab.c:89
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:322
aac_encode_end
static av_cold int aac_encode_end(AVCodecContext *avctx)
Definition: aacenc.c:1132
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:153
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:29
AVPacket
This structure stores compressed data.
Definition: packet.h:565
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
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:407
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aacdec.h:163
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:412
AV_CH_BACK_RIGHT
#define AV_CH_BACK_RIGHT
Definition: channel_layout.h:180
dsp_init
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:1149
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:404
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:405
put_bits.h
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aacdec.h:168
psymodel.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
ff_aacenc_dsp_init
static void ff_aacenc_dsp_init(AACEncDSPContext *s)
Definition: aacencdsp.h:61
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:61
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:46
FFPsyWindowInfo::num_windows
int num_windows
number of windows in a frame
Definition: psymodel.h:80
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:181
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:169
aacenc.h
Generated on Wed Nov 19 2025 19:21:43 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /