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/libm.h"
34 #include "libavutil/float_dsp.h"
35 #include "libavutil/opt.h"
36 #include "avcodec.h"
37 #include "encode.h"
38 #include "put_bits.h"
39 #include "internal.h"
40 #include "mpeg4audio.h"
41 #include "sinewin.h"
42 #include "profiles.h"
43 
44 #include "aac.h"
45 #include "aactab.h"
46 #include "aacenc.h"
47 #include "aacenctab.h"
48 #include "aacenc_utils.h"
49 
50 #include "psymodel.h"
51 
52 static void put_pce(PutBitContext *pb, AVCodecContext *avctx)
53 {
54  int i, j;
55  AACEncContext *s = avctx->priv_data;
56  AACPCEInfo *pce = &s->pce;
57  const int bitexact = avctx->flags & AV_CODEC_FLAG_BITEXACT;
58  const char *aux_data = bitexact ? "Lavc" : LIBAVCODEC_IDENT;
59 
60  put_bits(pb, 4, 0);
61 
62  put_bits(pb, 2, avctx->profile);
63  put_bits(pb, 4, s->samplerate_index);
64 
65  put_bits(pb, 4, pce->num_ele[0]); /* Front */
66  put_bits(pb, 4, pce->num_ele[1]); /* Side */
67  put_bits(pb, 4, pce->num_ele[2]); /* Back */
68  put_bits(pb, 2, pce->num_ele[3]); /* LFE */
69  put_bits(pb, 3, 0); /* Assoc data */
70  put_bits(pb, 4, 0); /* CCs */
71 
72  put_bits(pb, 1, 0); /* Stereo mixdown */
73  put_bits(pb, 1, 0); /* Mono mixdown */
74  put_bits(pb, 1, 0); /* Something else */
75 
76  for (i = 0; i < 4; i++) {
77  for (j = 0; j < pce->num_ele[i]; j++) {
78  if (i < 3)
79  put_bits(pb, 1, pce->pairing[i][j]);
80  put_bits(pb, 4, pce->index[i][j]);
81  }
82  }
83 
84  align_put_bits(pb);
85  put_bits(pb, 8, strlen(aux_data));
86  ff_put_string(pb, aux_data, 0);
87 }
88 
89 /**
90  * Make AAC audio config object.
91  * @see 1.6.2.1 "Syntax - AudioSpecificConfig"
92  */
94 {
95  PutBitContext pb;
96  AACEncContext *s = avctx->priv_data;
97  int channels = (!s->needs_pce)*(s->channels - (s->channels == 8 ? 1 : 0));
98  const int max_size = 32;
99 
100  avctx->extradata = av_mallocz(max_size);
101  if (!avctx->extradata)
102  return AVERROR(ENOMEM);
103 
104  init_put_bits(&pb, avctx->extradata, max_size);
105  put_bits(&pb, 5, s->profile+1); //profile
106  put_bits(&pb, 4, s->samplerate_index); //sample rate index
107  put_bits(&pb, 4, channels);
108  //GASpecificConfig
109  put_bits(&pb, 1, 0); //frame length - 1024 samples
110  put_bits(&pb, 1, 0); //does not depend on core coder
111  put_bits(&pb, 1, 0); //is not extension
112  if (s->needs_pce)
113  put_pce(&pb, avctx);
114 
115  //Explicitly Mark SBR absent
116  put_bits(&pb, 11, 0x2b7); //sync extension
117  put_bits(&pb, 5, AOT_SBR);
118  put_bits(&pb, 1, 0);
119  flush_put_bits(&pb);
120  avctx->extradata_size = put_bytes_output(&pb);
121 
122  return 0;
123 }
124 
126 {
127  ++s->quantize_band_cost_cache_generation;
128  if (s->quantize_band_cost_cache_generation == 0) {
129  memset(s->quantize_band_cost_cache, 0, sizeof(s->quantize_band_cost_cache));
130  s->quantize_band_cost_cache_generation = 1;
131  }
132 }
133 
134 #define WINDOW_FUNC(type) \
135 static void apply_ ##type ##_window(AVFloatDSPContext *fdsp, \
136  SingleChannelElement *sce, \
137  const float *audio)
138 
139 WINDOW_FUNC(only_long)
140 {
141  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
142  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
143  float *out = sce->ret_buf;
144 
145  fdsp->vector_fmul (out, audio, lwindow, 1024);
146  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, pwindow, 1024);
147 }
148 
149 WINDOW_FUNC(long_start)
150 {
151  const float *lwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
152  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
153  float *out = sce->ret_buf;
154 
155  fdsp->vector_fmul(out, audio, lwindow, 1024);
156  memcpy(out + 1024, audio + 1024, sizeof(out[0]) * 448);
157  fdsp->vector_fmul_reverse(out + 1024 + 448, audio + 1024 + 448, swindow, 128);
158  memset(out + 1024 + 576, 0, sizeof(out[0]) * 448);
159 }
160 
161 WINDOW_FUNC(long_stop)
162 {
163  const float *lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
164  const float *swindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
165  float *out = sce->ret_buf;
166 
167  memset(out, 0, sizeof(out[0]) * 448);
168  fdsp->vector_fmul(out + 448, audio + 448, swindow, 128);
169  memcpy(out + 576, audio + 576, sizeof(out[0]) * 448);
170  fdsp->vector_fmul_reverse(out + 1024, audio + 1024, lwindow, 1024);
171 }
172 
173 WINDOW_FUNC(eight_short)
174 {
175  const float *swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
176  const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
177  const float *in = audio + 448;
178  float *out = sce->ret_buf;
179  int w;
180 
181  for (w = 0; w < 8; w++) {
182  fdsp->vector_fmul (out, in, w ? pwindow : swindow, 128);
183  out += 128;
184  in += 128;
185  fdsp->vector_fmul_reverse(out, in, swindow, 128);
186  out += 128;
187  }
188 }
189 
190 static void (*const apply_window[4])(AVFloatDSPContext *fdsp,
192  const float *audio) = {
193  [ONLY_LONG_SEQUENCE] = apply_only_long_window,
194  [LONG_START_SEQUENCE] = apply_long_start_window,
195  [EIGHT_SHORT_SEQUENCE] = apply_eight_short_window,
196  [LONG_STOP_SEQUENCE] = apply_long_stop_window
197 };
198 
200  float *audio)
201 {
202  int i;
203  const float *output = sce->ret_buf;
204 
205  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, audio);
206 
208  s->mdct1024.mdct_calc(&s->mdct1024, sce->coeffs, output);
209  else
210  for (i = 0; i < 1024; i += 128)
211  s->mdct128.mdct_calc(&s->mdct128, &sce->coeffs[i], output + i*2);
212  memcpy(audio, audio + 1024, sizeof(audio[0]) * 1024);
213  memcpy(sce->pcoeffs, sce->coeffs, sizeof(sce->pcoeffs));
214 }
215 
216 /**
217  * Encode ics_info element.
218  * @see Table 4.6 (syntax of ics_info)
219  */
221 {
222  int w;
223 
224  put_bits(&s->pb, 1, 0); // ics_reserved bit
225  put_bits(&s->pb, 2, info->window_sequence[0]);
226  put_bits(&s->pb, 1, info->use_kb_window[0]);
227  if (info->window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
228  put_bits(&s->pb, 6, info->max_sfb);
229  put_bits(&s->pb, 1, !!info->predictor_present);
230  } else {
231  put_bits(&s->pb, 4, info->max_sfb);
232  for (w = 1; w < 8; w++)
233  put_bits(&s->pb, 1, !info->group_len[w]);
234  }
235 }
236 
237 /**
238  * Encode MS data.
239  * @see 4.6.8.1 "Joint Coding - M/S Stereo"
240  */
242 {
243  int i, w;
244 
245  put_bits(pb, 2, cpe->ms_mode);
246  if (cpe->ms_mode == 1)
247  for (w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w])
248  for (i = 0; i < cpe->ch[0].ics.max_sfb; i++)
249  put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
250 }
251 
252 /**
253  * Produce integer coefficients from scalefactors provided by the model.
254  */
255 static void adjust_frame_information(ChannelElement *cpe, int chans)
256 {
257  int i, w, w2, g, ch;
258  int maxsfb, cmaxsfb;
259 
260  for (ch = 0; ch < chans; ch++) {
261  IndividualChannelStream *ics = &cpe->ch[ch].ics;
262  maxsfb = 0;
263  cpe->ch[ch].pulse.num_pulse = 0;
264  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
265  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
266  for (cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w*16+cmaxsfb-1]; cmaxsfb--)
267  ;
268  maxsfb = FFMAX(maxsfb, cmaxsfb);
269  }
270  }
271  ics->max_sfb = maxsfb;
272 
273  //adjust zero bands for window groups
274  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
275  for (g = 0; g < ics->max_sfb; g++) {
276  i = 1;
277  for (w2 = w; w2 < w + ics->group_len[w]; w2++) {
278  if (!cpe->ch[ch].zeroes[w2*16 + g]) {
279  i = 0;
280  break;
281  }
282  }
283  cpe->ch[ch].zeroes[w*16 + g] = i;
284  }
285  }
286  }
287 
288  if (chans > 1 && cpe->common_window) {
289  IndividualChannelStream *ics0 = &cpe->ch[0].ics;
290  IndividualChannelStream *ics1 = &cpe->ch[1].ics;
291  int msc = 0;
292  ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
293  ics1->max_sfb = ics0->max_sfb;
294  for (w = 0; w < ics0->num_windows*16; w += 16)
295  for (i = 0; i < ics0->max_sfb; i++)
296  if (cpe->ms_mask[w+i])
297  msc++;
298  if (msc == 0 || ics0->max_sfb == 0)
299  cpe->ms_mode = 0;
300  else
301  cpe->ms_mode = msc < ics0->max_sfb * ics0->num_windows ? 1 : 2;
302  }
303 }
304 
306 {
307  int w, w2, g, i;
308  IndividualChannelStream *ics = &cpe->ch[0].ics;
309  if (!cpe->common_window)
310  return;
311  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
312  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
313  int start = (w+w2) * 128;
314  for (g = 0; g < ics->num_swb; g++) {
315  int p = -1 + 2 * (cpe->ch[1].band_type[w*16+g] - 14);
316  float scale = cpe->ch[0].is_ener[w*16+g];
317  if (!cpe->is_mask[w*16 + g]) {
318  start += ics->swb_sizes[g];
319  continue;
320  }
321  if (cpe->ms_mask[w*16 + g])
322  p *= -1;
323  for (i = 0; i < ics->swb_sizes[g]; i++) {
324  float sum = (cpe->ch[0].coeffs[start+i] + p*cpe->ch[1].coeffs[start+i])*scale;
325  cpe->ch[0].coeffs[start+i] = sum;
326  cpe->ch[1].coeffs[start+i] = 0.0f;
327  }
328  start += ics->swb_sizes[g];
329  }
330  }
331  }
332 }
333 
335 {
336  int w, w2, g, i;
337  IndividualChannelStream *ics = &cpe->ch[0].ics;
338  if (!cpe->common_window)
339  return;
340  for (w = 0; w < ics->num_windows; w += ics->group_len[w]) {
341  for (w2 = 0; w2 < ics->group_len[w]; w2++) {
342  int start = (w+w2) * 128;
343  for (g = 0; g < ics->num_swb; g++) {
344  /* ms_mask can be used for other purposes in PNS and I/S,
345  * so must not apply M/S if any band uses either, even if
346  * ms_mask is set.
347  */
348  if (!cpe->ms_mask[w*16 + g] || cpe->is_mask[w*16 + g]
349  || cpe->ch[0].band_type[w*16 + g] >= NOISE_BT
350  || cpe->ch[1].band_type[w*16 + g] >= NOISE_BT) {
351  start += ics->swb_sizes[g];
352  continue;
353  }
354  for (i = 0; i < ics->swb_sizes[g]; i++) {
355  float L = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) * 0.5f;
356  float R = L - cpe->ch[1].coeffs[start+i];
357  cpe->ch[0].coeffs[start+i] = L;
358  cpe->ch[1].coeffs[start+i] = R;
359  }
360  start += ics->swb_sizes[g];
361  }
362  }
363  }
364 }
365 
366 /**
367  * Encode scalefactor band coding type.
368  */
370 {
371  int w;
372 
373  if (s->coder->set_special_band_scalefactors)
374  s->coder->set_special_band_scalefactors(s, sce);
375 
376  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
377  s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
378 }
379 
380 /**
381  * Encode scalefactors.
382  */
385 {
386  int diff, off_sf = sce->sf_idx[0], off_pns = sce->sf_idx[0] - NOISE_OFFSET;
387  int off_is = 0, noise_flag = 1;
388  int i, w;
389 
390  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
391  for (i = 0; i < sce->ics.max_sfb; i++) {
392  if (!sce->zeroes[w*16 + i]) {
393  if (sce->band_type[w*16 + i] == NOISE_BT) {
394  diff = sce->sf_idx[w*16 + i] - off_pns;
395  off_pns = sce->sf_idx[w*16 + i];
396  if (noise_flag-- > 0) {
398  continue;
399  }
400  } else if (sce->band_type[w*16 + i] == INTENSITY_BT ||
401  sce->band_type[w*16 + i] == INTENSITY_BT2) {
402  diff = sce->sf_idx[w*16 + i] - off_is;
403  off_is = sce->sf_idx[w*16 + i];
404  } else {
405  diff = sce->sf_idx[w*16 + i] - off_sf;
406  off_sf = sce->sf_idx[w*16 + i];
407  }
409  av_assert0(diff >= 0 && diff <= 120);
411  }
412  }
413  }
414 }
415 
416 /**
417  * Encode pulse data.
418  */
419 static void encode_pulses(AACEncContext *s, Pulse *pulse)
420 {
421  int i;
422 
423  put_bits(&s->pb, 1, !!pulse->num_pulse);
424  if (!pulse->num_pulse)
425  return;
426 
427  put_bits(&s->pb, 2, pulse->num_pulse - 1);
428  put_bits(&s->pb, 6, pulse->start);
429  for (i = 0; i < pulse->num_pulse; i++) {
430  put_bits(&s->pb, 5, pulse->pos[i]);
431  put_bits(&s->pb, 4, pulse->amp[i]);
432  }
433 }
434 
435 /**
436  * Encode spectral coefficients processed by psychoacoustic model.
437  */
439 {
440  int start, i, w, w2;
441 
442  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
443  start = 0;
444  for (i = 0; i < sce->ics.max_sfb; i++) {
445  if (sce->zeroes[w*16 + i]) {
446  start += sce->ics.swb_sizes[i];
447  continue;
448  }
449  for (w2 = w; w2 < w + sce->ics.group_len[w]; w2++) {
450  s->coder->quantize_and_encode_band(s, &s->pb,
451  &sce->coeffs[start + w2*128],
452  NULL, sce->ics.swb_sizes[i],
453  sce->sf_idx[w*16 + i],
454  sce->band_type[w*16 + i],
455  s->lambda,
456  sce->ics.window_clipping[w]);
457  }
458  start += sce->ics.swb_sizes[i];
459  }
460  }
461 }
462 
463 /**
464  * Downscale spectral coefficients for near-clipping windows to avoid artifacts
465  */
467 {
468  int start, i, j, w;
469 
470  if (sce->ics.clip_avoidance_factor < 1.0f) {
471  for (w = 0; w < sce->ics.num_windows; w++) {
472  start = 0;
473  for (i = 0; i < sce->ics.max_sfb; i++) {
474  float *swb_coeffs = &sce->coeffs[start + w*128];
475  for (j = 0; j < sce->ics.swb_sizes[i]; j++)
476  swb_coeffs[j] *= sce->ics.clip_avoidance_factor;
477  start += sce->ics.swb_sizes[i];
478  }
479  }
480  }
481 }
482 
483 /**
484  * Encode one channel of audio data.
485  */
488  int common_window)
489 {
490  put_bits(&s->pb, 8, sce->sf_idx[0]);
491  if (!common_window) {
492  put_ics_info(s, &sce->ics);
493  if (s->coder->encode_main_pred)
494  s->coder->encode_main_pred(s, sce);
495  if (s->coder->encode_ltp_info)
496  s->coder->encode_ltp_info(s, sce, 0);
497  }
498  encode_band_info(s, sce);
499  encode_scale_factors(avctx, s, sce);
500  encode_pulses(s, &sce->pulse);
501  put_bits(&s->pb, 1, !!sce->tns.present);
502  if (s->coder->encode_tns_info)
503  s->coder->encode_tns_info(s, sce);
504  put_bits(&s->pb, 1, 0); //ssr
506  return 0;
507 }
508 
509 /**
510  * Write some auxiliary information about the created AAC file.
511  */
512 static void put_bitstream_info(AACEncContext *s, const char *name)
513 {
514  int i, namelen, padbits;
515 
516  namelen = strlen(name) + 2;
517  put_bits(&s->pb, 3, TYPE_FIL);
518  put_bits(&s->pb, 4, FFMIN(namelen, 15));
519  if (namelen >= 15)
520  put_bits(&s->pb, 8, namelen - 14);
521  put_bits(&s->pb, 4, 0); //extension type - filler
522  padbits = -put_bits_count(&s->pb) & 7;
523  align_put_bits(&s->pb);
524  for (i = 0; i < namelen - 2; i++)
525  put_bits(&s->pb, 8, name[i]);
526  put_bits(&s->pb, 12 - padbits, 0);
527 }
528 
529 /*
530  * Copy input samples.
531  * Channels are reordered from libavcodec's default order to AAC order.
532  */
534 {
535  int ch;
536  int end = 2048 + (frame ? frame->nb_samples : 0);
537  const uint8_t *channel_map = s->reorder_map;
538 
539  /* copy and remap input samples */
540  for (ch = 0; ch < s->channels; ch++) {
541  /* copy last 1024 samples of previous frame to the start of the current frame */
542  memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
543 
544  /* copy new samples and zero any remaining samples */
545  if (frame) {
546  memcpy(&s->planar_samples[ch][2048],
547  frame->extended_data[channel_map[ch]],
548  frame->nb_samples * sizeof(s->planar_samples[0][0]));
549  }
550  memset(&s->planar_samples[ch][end], 0,
551  (3072 - end) * sizeof(s->planar_samples[0][0]));
552  }
553 }
554 
555 static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
556  const AVFrame *frame, int *got_packet_ptr)
557 {
558  AACEncContext *s = avctx->priv_data;
559  float **samples = s->planar_samples, *samples2, *la, *overlap;
560  ChannelElement *cpe;
563  int i, its, ch, w, chans, tag, start_ch, ret, frame_bits;
564  int target_bits, rate_bits, too_many_bits, too_few_bits;
565  int ms_mode = 0, is_mode = 0, tns_mode = 0, pred_mode = 0;
566  int chan_el_counter[4];
568 
569  /* add current frame to queue */
570  if (frame) {
571  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
572  return ret;
573  } else {
574  if (!s->afq.remaining_samples || (!s->afq.frame_alloc && !s->afq.frame_count))
575  return 0;
576  }
577 
579  if (s->psypp)
580  ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
581 
582  if (!avctx->frame_number)
583  return 0;
584 
585  start_ch = 0;
586  for (i = 0; i < s->chan_map[0]; i++) {
587  FFPsyWindowInfo* wi = windows + start_ch;
588  tag = s->chan_map[i+1];
589  chans = tag == TYPE_CPE ? 2 : 1;
590  cpe = &s->cpe[i];
591  for (ch = 0; ch < chans; ch++) {
592  int k;
593  float clip_avoidance_factor;
594  sce = &cpe->ch[ch];
595  ics = &sce->ics;
596  s->cur_channel = start_ch + ch;
597  overlap = &samples[s->cur_channel][0];
598  samples2 = overlap + 1024;
599  la = samples2 + (448+64);
600  if (!frame)
601  la = NULL;
602  if (tag == TYPE_LFE) {
603  wi[ch].window_type[0] = wi[ch].window_type[1] = ONLY_LONG_SEQUENCE;
604  wi[ch].window_shape = 0;
605  wi[ch].num_windows = 1;
606  wi[ch].grouping[0] = 1;
607  wi[ch].clipping[0] = 0;
608 
609  /* Only the lowest 12 coefficients are used in a LFE channel.
610  * The expression below results in only the bottom 8 coefficients
611  * being used for 11.025kHz to 16kHz sample rates.
612  */
613  ics->num_swb = s->samplerate_index >= 8 ? 1 : 3;
614  } else {
615  wi[ch] = s->psy.model->window(&s->psy, samples2, la, s->cur_channel,
616  ics->window_sequence[0]);
617  }
618  ics->window_sequence[1] = ics->window_sequence[0];
619  ics->window_sequence[0] = wi[ch].window_type[0];
620  ics->use_kb_window[1] = ics->use_kb_window[0];
621  ics->use_kb_window[0] = wi[ch].window_shape;
622  ics->num_windows = wi[ch].num_windows;
623  ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
624  ics->num_swb = tag == TYPE_LFE ? ics->num_swb : s->psy.num_bands[ics->num_windows == 8];
625  ics->max_sfb = FFMIN(ics->max_sfb, ics->num_swb);
626  ics->swb_offset = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
627  ff_swb_offset_128 [s->samplerate_index]:
628  ff_swb_offset_1024[s->samplerate_index];
629  ics->tns_max_bands = wi[ch].window_type[0] == EIGHT_SHORT_SEQUENCE ?
630  ff_tns_max_bands_128 [s->samplerate_index]:
631  ff_tns_max_bands_1024[s->samplerate_index];
632 
633  for (w = 0; w < ics->num_windows; w++)
634  ics->group_len[w] = wi[ch].grouping[w];
635 
636  /* Calculate input sample maximums and evaluate clipping risk */
637  clip_avoidance_factor = 0.0f;
638  for (w = 0; w < ics->num_windows; w++) {
639  const float *wbuf = overlap + w * 128;
640  const int wlen = 2048 / ics->num_windows;
641  float max = 0;
642  int j;
643  /* mdct input is 2 * output */
644  for (j = 0; j < wlen; j++)
645  max = FFMAX(max, fabsf(wbuf[j]));
646  wi[ch].clipping[w] = max;
647  }
648  for (w = 0; w < ics->num_windows; w++) {
649  if (wi[ch].clipping[w] > CLIP_AVOIDANCE_FACTOR) {
650  ics->window_clipping[w] = 1;
651  clip_avoidance_factor = FFMAX(clip_avoidance_factor, wi[ch].clipping[w]);
652  } else {
653  ics->window_clipping[w] = 0;
654  }
655  }
656  if (clip_avoidance_factor > CLIP_AVOIDANCE_FACTOR) {
657  ics->clip_avoidance_factor = CLIP_AVOIDANCE_FACTOR / clip_avoidance_factor;
658  } else {
659  ics->clip_avoidance_factor = 1.0f;
660  }
661 
662  apply_window_and_mdct(s, sce, overlap);
663 
664  if (s->options.ltp && s->coder->update_ltp) {
665  s->coder->update_ltp(s, sce);
666  apply_window[sce->ics.window_sequence[0]](s->fdsp, sce, &sce->ltp_state[0]);
667  s->mdct1024.mdct_calc(&s->mdct1024, sce->lcoeffs, sce->ret_buf);
668  }
669 
670  for (k = 0; k < 1024; k++) {
671  if (!(fabs(cpe->ch[ch].coeffs[k]) < 1E16)) { // Ensure headroom for energy calculation
672  av_log(avctx, AV_LOG_ERROR, "Input contains (near) NaN/+-Inf\n");
673  return AVERROR(EINVAL);
674  }
675  }
676  avoid_clipping(s, sce);
677  }
678  start_ch += chans;
679  }
680  if ((ret = ff_alloc_packet(avctx, avpkt, 8192 * s->channels)) < 0)
681  return ret;
682  frame_bits = its = 0;
683  do {
684  init_put_bits(&s->pb, avpkt->data, avpkt->size);
685 
686  if ((avctx->frame_number & 0xFF)==1 && !(avctx->flags & AV_CODEC_FLAG_BITEXACT))
688  start_ch = 0;
689  target_bits = 0;
690  memset(chan_el_counter, 0, sizeof(chan_el_counter));
691  for (i = 0; i < s->chan_map[0]; i++) {
692  FFPsyWindowInfo* wi = windows + start_ch;
693  const float *coeffs[2];
694  tag = s->chan_map[i+1];
695  chans = tag == TYPE_CPE ? 2 : 1;
696  cpe = &s->cpe[i];
697  cpe->common_window = 0;
698  memset(cpe->is_mask, 0, sizeof(cpe->is_mask));
699  memset(cpe->ms_mask, 0, sizeof(cpe->ms_mask));
700  put_bits(&s->pb, 3, tag);
701  put_bits(&s->pb, 4, chan_el_counter[tag]++);
702  for (ch = 0; ch < chans; ch++) {
703  sce = &cpe->ch[ch];
704  coeffs[ch] = sce->coeffs;
705  sce->ics.predictor_present = 0;
706  sce->ics.ltp.present = 0;
707  memset(sce->ics.ltp.used, 0, sizeof(sce->ics.ltp.used));
708  memset(sce->ics.prediction_used, 0, sizeof(sce->ics.prediction_used));
709  memset(&sce->tns, 0, sizeof(TemporalNoiseShaping));
710  for (w = 0; w < 128; w++)
711  if (sce->band_type[w] > RESERVED_BT)
712  sce->band_type[w] = 0;
713  }
714  s->psy.bitres.alloc = -1;
715  s->psy.bitres.bits = s->last_frame_pb_count / s->channels;
716  s->psy.model->analyze(&s->psy, start_ch, coeffs, wi);
717  if (s->psy.bitres.alloc > 0) {
718  /* Lambda unused here on purpose, we need to take psy's unscaled allocation */
719  target_bits += s->psy.bitres.alloc
720  * (s->lambda / (avctx->global_quality ? avctx->global_quality : 120));
721  s->psy.bitres.alloc /= chans;
722  }
723  s->cur_type = tag;
724  for (ch = 0; ch < chans; ch++) {
725  s->cur_channel = start_ch + ch;
726  if (s->options.pns && s->coder->mark_pns)
727  s->coder->mark_pns(s, avctx, &cpe->ch[ch]);
728  s->coder->search_for_quantizers(avctx, s, &cpe->ch[ch], s->lambda);
729  }
730  if (chans > 1
731  && wi[0].window_type[0] == wi[1].window_type[0]
732  && wi[0].window_shape == wi[1].window_shape) {
733 
734  cpe->common_window = 1;
735  for (w = 0; w < wi[0].num_windows; w++) {
736  if (wi[0].grouping[w] != wi[1].grouping[w]) {
737  cpe->common_window = 0;
738  break;
739  }
740  }
741  }
742  for (ch = 0; ch < chans; ch++) { /* TNS and PNS */
743  sce = &cpe->ch[ch];
744  s->cur_channel = start_ch + ch;
745  if (s->options.tns && s->coder->search_for_tns)
746  s->coder->search_for_tns(s, sce);
747  if (s->options.tns && s->coder->apply_tns_filt)
748  s->coder->apply_tns_filt(s, sce);
749  if (sce->tns.present)
750  tns_mode = 1;
751  if (s->options.pns && s->coder->search_for_pns)
752  s->coder->search_for_pns(s, avctx, sce);
753  }
754  s->cur_channel = start_ch;
755  if (s->options.intensity_stereo) { /* Intensity Stereo */
756  if (s->coder->search_for_is)
757  s->coder->search_for_is(s, avctx, cpe);
758  if (cpe->is_mode) is_mode = 1;
760  }
761  if (s->options.pred) { /* Prediction */
762  for (ch = 0; ch < chans; ch++) {
763  sce = &cpe->ch[ch];
764  s->cur_channel = start_ch + ch;
765  if (s->options.pred && s->coder->search_for_pred)
766  s->coder->search_for_pred(s, sce);
767  if (cpe->ch[ch].ics.predictor_present) pred_mode = 1;
768  }
769  if (s->coder->adjust_common_pred)
770  s->coder->adjust_common_pred(s, cpe);
771  for (ch = 0; ch < chans; ch++) {
772  sce = &cpe->ch[ch];
773  s->cur_channel = start_ch + ch;
774  if (s->options.pred && s->coder->apply_main_pred)
775  s->coder->apply_main_pred(s, sce);
776  }
777  s->cur_channel = start_ch;
778  }
779  if (s->options.mid_side) { /* Mid/Side stereo */
780  if (s->options.mid_side == -1 && s->coder->search_for_ms)
781  s->coder->search_for_ms(s, cpe);
782  else if (cpe->common_window)
783  memset(cpe->ms_mask, 1, sizeof(cpe->ms_mask));
785  }
786  adjust_frame_information(cpe, chans);
787  if (s->options.ltp) { /* LTP */
788  for (ch = 0; ch < chans; ch++) {
789  sce = &cpe->ch[ch];
790  s->cur_channel = start_ch + ch;
791  if (s->coder->search_for_ltp)
792  s->coder->search_for_ltp(s, sce, cpe->common_window);
793  if (sce->ics.ltp.present) pred_mode = 1;
794  }
795  s->cur_channel = start_ch;
796  if (s->coder->adjust_common_ltp)
797  s->coder->adjust_common_ltp(s, cpe);
798  }
799  if (chans == 2) {
800  put_bits(&s->pb, 1, cpe->common_window);
801  if (cpe->common_window) {
802  put_ics_info(s, &cpe->ch[0].ics);
803  if (s->coder->encode_main_pred)
804  s->coder->encode_main_pred(s, &cpe->ch[0]);
805  if (s->coder->encode_ltp_info)
806  s->coder->encode_ltp_info(s, &cpe->ch[0], 1);
807  encode_ms_info(&s->pb, cpe);
808  if (cpe->ms_mode) ms_mode = 1;
809  }
810  }
811  for (ch = 0; ch < chans; ch++) {
812  s->cur_channel = start_ch + ch;
813  encode_individual_channel(avctx, s, &cpe->ch[ch], cpe->common_window);
814  }
815  start_ch += chans;
816  }
817 
818  if (avctx->flags & AV_CODEC_FLAG_QSCALE) {
819  /* When using a constant Q-scale, don't mess with lambda */
820  break;
821  }
822 
823  /* rate control stuff
824  * allow between the nominal bitrate, and what psy's bit reservoir says to target
825  * but drift towards the nominal bitrate always
826  */
827  frame_bits = put_bits_count(&s->pb);
828  rate_bits = avctx->bit_rate * 1024 / avctx->sample_rate;
829  rate_bits = FFMIN(rate_bits, 6144 * s->channels - 3);
830  too_many_bits = FFMAX(target_bits, rate_bits);
831  too_many_bits = FFMIN(too_many_bits, 6144 * s->channels - 3);
832  too_few_bits = FFMIN(FFMAX(rate_bits - rate_bits/4, target_bits), too_many_bits);
833 
834  /* When using ABR, be strict (but only for increasing) */
835  too_few_bits = too_few_bits - too_few_bits/8;
836  too_many_bits = too_many_bits + too_many_bits/2;
837 
838  if ( its == 0 /* for steady-state Q-scale tracking */
839  || (its < 5 && (frame_bits < too_few_bits || frame_bits > too_many_bits))
840  || frame_bits >= 6144 * s->channels - 3 )
841  {
842  float ratio = ((float)rate_bits) / frame_bits;
843 
844  if (frame_bits >= too_few_bits && frame_bits <= too_many_bits) {
845  /*
846  * This path is for steady-state Q-scale tracking
847  * When frame bits fall within the stable range, we still need to adjust
848  * lambda to maintain it like so in a stable fashion (large jumps in lambda
849  * create artifacts and should be avoided), but slowly
850  */
851  ratio = sqrtf(sqrtf(ratio));
852  ratio = av_clipf(ratio, 0.9f, 1.1f);
853  } else {
854  /* Not so fast though */
855  ratio = sqrtf(ratio);
856  }
857  s->lambda = av_clipf(s->lambda * ratio, FLT_EPSILON, 65536.f);
858 
859  /* Keep iterating if we must reduce and lambda is in the sky */
860  if (ratio > 0.9f && ratio < 1.1f) {
861  break;
862  } else {
863  if (is_mode || ms_mode || tns_mode || pred_mode) {
864  for (i = 0; i < s->chan_map[0]; i++) {
865  // Must restore coeffs
866  chans = tag == TYPE_CPE ? 2 : 1;
867  cpe = &s->cpe[i];
868  for (ch = 0; ch < chans; ch++)
869  memcpy(cpe->ch[ch].coeffs, cpe->ch[ch].pcoeffs, sizeof(cpe->ch[ch].coeffs));
870  }
871  }
872  its++;
873  }
874  } else {
875  break;
876  }
877  } while (1);
878 
879  if (s->options.ltp && s->coder->ltp_insert_new_frame)
880  s->coder->ltp_insert_new_frame(s);
881 
882  put_bits(&s->pb, 3, TYPE_END);
883  flush_put_bits(&s->pb);
884 
885  s->last_frame_pb_count = put_bits_count(&s->pb);
886  avpkt->size = put_bytes_output(&s->pb);
887 
888  s->lambda_sum += s->lambda;
889  s->lambda_count++;
890 
891  ff_af_queue_remove(&s->afq, avctx->frame_size, &avpkt->pts,
892  &avpkt->duration);
893 
894  *got_packet_ptr = 1;
895  return 0;
896 }
897 
899 {
900  AACEncContext *s = avctx->priv_data;
901 
902  av_log(avctx, AV_LOG_INFO, "Qavg: %.3f\n", s->lambda_count ? s->lambda_sum / s->lambda_count : NAN);
903 
904  ff_mdct_end(&s->mdct1024);
905  ff_mdct_end(&s->mdct128);
906  ff_psy_end(&s->psy);
907  ff_lpc_end(&s->lpc);
908  if (s->psypp)
909  ff_psy_preprocess_end(s->psypp);
910  av_freep(&s->buffer.samples);
911  av_freep(&s->cpe);
912  av_freep(&s->fdsp);
913  ff_af_queue_close(&s->afq);
914  return 0;
915 }
916 
918 {
919  int ret = 0;
920 
922  if (!s->fdsp)
923  return AVERROR(ENOMEM);
924 
925  // window init
927 
928  if ((ret = ff_mdct_init(&s->mdct1024, 11, 0, 32768.0)) < 0)
929  return ret;
930  if ((ret = ff_mdct_init(&s->mdct128, 8, 0, 32768.0)) < 0)
931  return ret;
932 
933  return 0;
934 }
935 
937 {
938  int ch;
939  if (!FF_ALLOCZ_TYPED_ARRAY(s->buffer.samples, s->channels * 3 * 1024) ||
940  !FF_ALLOCZ_TYPED_ARRAY(s->cpe, s->chan_map[0]))
941  return AVERROR(ENOMEM);
942 
943  for(ch = 0; ch < s->channels; ch++)
944  s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
945 
946  return 0;
947 }
948 
950 {
951  AACEncContext *s = avctx->priv_data;
952  int i, ret = 0;
953  const uint8_t *sizes[2];
954  uint8_t grouping[AAC_MAX_CHANNELS];
955  int lengths[2];
956 
957  /* Constants */
958  s->last_frame_pb_count = 0;
959  avctx->frame_size = 1024;
960  avctx->initial_padding = 1024;
961  s->lambda = avctx->global_quality > 0 ? avctx->global_quality : 120;
962 
963  /* Channel map and unspecified bitrate guessing */
964  s->channels = avctx->channels;
965 
966  s->needs_pce = 1;
967  for (i = 0; i < FF_ARRAY_ELEMS(aac_normal_chan_layouts); i++) {
968  if (avctx->channel_layout == aac_normal_chan_layouts[i]) {
969  s->needs_pce = s->options.pce;
970  break;
971  }
972  }
973 
974  if (s->needs_pce) {
975  char buf[64];
976  for (i = 0; i < FF_ARRAY_ELEMS(aac_pce_configs); i++)
977  if (avctx->channel_layout == aac_pce_configs[i].layout)
978  break;
979  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
980  ERROR_IF(i == FF_ARRAY_ELEMS(aac_pce_configs), "Unsupported channel layout \"%s\"\n", buf);
981  av_log(avctx, AV_LOG_INFO, "Using a PCE to encode channel layout \"%s\"\n", buf);
982  s->pce = aac_pce_configs[i];
983  s->reorder_map = s->pce.reorder_map;
984  s->chan_map = s->pce.config_map;
985  } else {
986  s->reorder_map = aac_chan_maps[s->channels - 1];
987  s->chan_map = aac_chan_configs[s->channels - 1];
988  }
989 
990  if (!avctx->bit_rate) {
991  for (i = 1; i <= s->chan_map[0]; i++) {
992  avctx->bit_rate += s->chan_map[i] == TYPE_CPE ? 128000 : /* Pair */
993  s->chan_map[i] == TYPE_LFE ? 16000 : /* LFE */
994  69000 ; /* SCE */
995  }
996  }
997 
998  /* Samplerate */
999  for (i = 0; i < 16; i++)
1001  break;
1002  s->samplerate_index = i;
1003  ERROR_IF(s->samplerate_index == 16 ||
1004  s->samplerate_index >= ff_aac_swb_size_1024_len ||
1005  s->samplerate_index >= ff_aac_swb_size_128_len,
1006  "Unsupported sample rate %d\n", avctx->sample_rate);
1007 
1008  /* Bitrate limiting */
1009  WARN_IF(1024.0 * avctx->bit_rate / avctx->sample_rate > 6144 * s->channels,
1010  "Too many bits %f > %d per frame requested, clamping to max\n",
1011  1024.0 * avctx->bit_rate / avctx->sample_rate,
1012  6144 * s->channels);
1013  avctx->bit_rate = (int64_t)FFMIN(6144 * s->channels / 1024.0 * avctx->sample_rate,
1014  avctx->bit_rate);
1015 
1016  /* Profile and option setting */
1017  avctx->profile = avctx->profile == FF_PROFILE_UNKNOWN ? FF_PROFILE_AAC_LOW :
1018  avctx->profile;
1019  for (i = 0; i < FF_ARRAY_ELEMS(aacenc_profiles); i++)
1020  if (avctx->profile == aacenc_profiles[i])
1021  break;
1022  if (avctx->profile == FF_PROFILE_MPEG2_AAC_LOW) {
1023  avctx->profile = FF_PROFILE_AAC_LOW;
1024  ERROR_IF(s->options.pred,
1025  "Main prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1026  ERROR_IF(s->options.ltp,
1027  "LTP prediction unavailable in the \"mpeg2_aac_low\" profile\n");
1028  WARN_IF(s->options.pns,
1029  "PNS unavailable in the \"mpeg2_aac_low\" profile, turning off\n");
1030  s->options.pns = 0;
1031  } else if (avctx->profile == FF_PROFILE_AAC_LTP) {
1032  s->options.ltp = 1;
1033  ERROR_IF(s->options.pred,
1034  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1035  } else if (avctx->profile == FF_PROFILE_AAC_MAIN) {
1036  s->options.pred = 1;
1037  ERROR_IF(s->options.ltp,
1038  "LTP prediction unavailable in the \"aac_main\" profile\n");
1039  } else if (s->options.ltp) {
1040  avctx->profile = FF_PROFILE_AAC_LTP;
1041  WARN_IF(1,
1042  "Chainging profile to \"aac_ltp\"\n");
1043  ERROR_IF(s->options.pred,
1044  "Main prediction unavailable in the \"aac_ltp\" profile\n");
1045  } else if (s->options.pred) {
1046  avctx->profile = FF_PROFILE_AAC_MAIN;
1047  WARN_IF(1,
1048  "Chainging profile to \"aac_main\"\n");
1049  ERROR_IF(s->options.ltp,
1050  "LTP prediction unavailable in the \"aac_main\" profile\n");
1051  }
1052  s->profile = avctx->profile;
1053 
1054  /* Coder limitations */
1055  s->coder = &ff_aac_coders[s->options.coder];
1056  if (s->options.coder == AAC_CODER_ANMR) {
1058  "The ANMR coder is considered experimental, add -strict -2 to enable!\n");
1059  s->options.intensity_stereo = 0;
1060  s->options.pns = 0;
1061  }
1063  "The LPT profile requires experimental compliance, add -strict -2 to enable!\n");
1064 
1065  /* M/S introduces horrible artifacts with multichannel files, this is temporary */
1066  if (s->channels > 3)
1067  s->options.mid_side = 0;
1068 
1069  if ((ret = dsp_init(avctx, s)) < 0)
1070  return ret;
1071 
1072  if ((ret = alloc_buffers(avctx, s)) < 0)
1073  return ret;
1074 
1075  if ((ret = put_audio_specific_config(avctx)))
1076  return ret;
1077 
1078  sizes[0] = ff_aac_swb_size_1024[s->samplerate_index];
1079  sizes[1] = ff_aac_swb_size_128[s->samplerate_index];
1080  lengths[0] = ff_aac_num_swb_1024[s->samplerate_index];
1081  lengths[1] = ff_aac_num_swb_128[s->samplerate_index];
1082  for (i = 0; i < s->chan_map[0]; i++)
1083  grouping[i] = s->chan_map[i + 1] == TYPE_CPE;
1084  if ((ret = ff_psy_init(&s->psy, avctx, 2, sizes, lengths,
1085  s->chan_map[0], grouping)) < 0)
1086  return ret;
1087  s->psypp = ff_psy_preprocess_init(avctx);
1089  s->random_state = 0x1f2e3d4c;
1090 
1091  s->abs_pow34 = abs_pow34_v;
1092  s->quant_bands = quantize_bands;
1093 
1094  if (ARCH_X86)
1096 
1097  if (HAVE_MIPSDSP)
1099 
1100  ff_af_queue_init(avctx, &s->afq);
1101  ff_aac_tableinit();
1102 
1103  return 0;
1104 }
1105 
1106 #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1107 static const AVOption aacenc_options[] = {
1108  {"aac_coder", "Coding algorithm", offsetof(AACEncContext, options.coder), AV_OPT_TYPE_INT, {.i64 = AAC_CODER_TWOLOOP}, 0, AAC_CODER_NB-1, AACENC_FLAGS, "coder"},
1109  {"anmr", "ANMR method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_ANMR}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1110  {"twoloop", "Two loop searching method", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_TWOLOOP}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1111  {"fast", "Default fast search", 0, AV_OPT_TYPE_CONST, {.i64 = AAC_CODER_FAST}, INT_MIN, INT_MAX, AACENC_FLAGS, "coder"},
1112  {"aac_ms", "Force M/S stereo coding", offsetof(AACEncContext, options.mid_side), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AACENC_FLAGS},
1113  {"aac_is", "Intensity stereo coding", offsetof(AACEncContext, options.intensity_stereo), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1114  {"aac_pns", "Perceptual noise substitution", offsetof(AACEncContext, options.pns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1115  {"aac_tns", "Temporal noise shaping", offsetof(AACEncContext, options.tns), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AACENC_FLAGS},
1116  {"aac_ltp", "Long term prediction", offsetof(AACEncContext, options.ltp), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1117  {"aac_pred", "AAC-Main prediction", offsetof(AACEncContext, options.pred), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1118  {"aac_pce", "Forces the use of PCEs", offsetof(AACEncContext, options.pce), AV_OPT_TYPE_BOOL, {.i64 = 0}, -1, 1, AACENC_FLAGS},
1120  {NULL}
1121 };
1122 
1123 static const AVClass aacenc_class = {
1124  .class_name = "AAC encoder",
1125  .item_name = av_default_item_name,
1126  .option = aacenc_options,
1127  .version = LIBAVUTIL_VERSION_INT,
1128 };
1129 
1131  { "b", "0" },
1132  { NULL }
1133 };
1134 
1136  .name = "aac",
1137  .long_name = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
1138  .type = AVMEDIA_TYPE_AUDIO,
1139  .id = AV_CODEC_ID_AAC,
1140  .priv_data_size = sizeof(AACEncContext),
1141  .init = aac_encode_init,
1142  .encode2 = aac_encode_frame,
1143  .close = aac_encode_end,
1145  .supported_samplerates = mpeg4audio_sample_rates,
1148  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1150  .priv_class = &aacenc_class,
1151 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:103
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1001
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
ff_tns_max_bands_128
const uint8_t ff_tns_max_bands_128[]
Definition: aactab.c:1425
aacenc_class
static const AVClass aacenc_class
Definition: aacenc.c:1123
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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:42
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1032
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:512
ff_aac_kbd_short_128
float ff_aac_kbd_short_128[128]
libm.h
SingleChannelElement::pulse
Pulse pulse
Definition: aac.h:252
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:412
TYPE_FIL
@ TYPE_FIL
Definition: aac.h:63
ff_af_queue_remove
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
Definition: audio_frame_queue.c:75
out
FILE * out
Definition: movenc.c:54
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1274
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:981
ff_af_queue_close
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
Definition: audio_frame_queue.c:36
aacenctab.h
abs_pow34_v
static void abs_pow34_v(float *out, const float *in, const int size)
Definition: aacenc_utils.h:40
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:953
copy_input_samples
static void copy_input_samples(AACEncContext *s, const AVFrame *frame)
Definition: aacenc.c:533
aac_encode_init
static av_cold int aac_encode_init(AVCodecContext *avctx)
Definition: aacenc.c:949
aacenc_profiles
static const int aacenc_profiles[]
Definition: aacenctab.h:132
Pulse::num_pulse
int num_pulse
Definition: aac.h:226
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:215
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
FF_PROFILE_AAC_MAIN
#define FF_PROFILE_AAC_MAIN
Definition: avcodec.h:1518
SingleChannelElement::zeroes
uint8_t zeroes[128]
band is not coded (used by encoder)
Definition: aac.h:258
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
ff_af_queue_init
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
Definition: audio_frame_queue.c:28
av_get_channel_layout_string
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Definition: channel_layout.c:217
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
WARN_IF
#define WARN_IF(cond,...)
Definition: aacenc_utils.h:274
w
uint8_t w
Definition: llviddspenc.c:39
R
#define R
Definition: huffyuvdsp.h:34
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
ff_aac_coders
const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]
Definition: aaccoder.c:897
AVOption
AVOption.
Definition: opt.h:248
encode.h
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
FF_PROFILE_AAC_LTP
#define FF_PROFILE_AAC_LTP
Definition: avcodec.h:1521
encode_band_info
static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
Encode scalefactor band coding type.
Definition: aacenc.c:369
TemporalNoiseShaping::present
int present
Definition: aac.h:200
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:42
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aac.h:169
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:383
SingleChannelElement::pcoeffs
INTFLOAT pcoeffs[1024]
coefficients for IMDCT, pristine
Definition: aac.h:262
max
#define max(a, b)
Definition: cuda_runtime.h:33
ff_swb_offset_128
const uint16_t *const ff_swb_offset_128[]
Definition: aactab.c:1387
AACPCEInfo::layout
int64_t layout
Definition: aacenc.h:96
encode_spectral_coeffs
static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
Encode spectral coefficients processed by psychoacoustic model.
Definition: aacenc.c:438
ff_tns_max_bands_1024
const uint8_t ff_tns_max_bands_1024[]
Definition: aactab.c:1413
AAC_CODER_FAST
@ AAC_CODER_FAST
Definition: aacenc.h:40
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aac.h:184
WINDOW_FUNC
#define WINDOW_FUNC(type)
Definition: aacenc.c:134
avoid_clipping
static void avoid_clipping(AACEncContext *s, SingleChannelElement *sce)
Downscale spectral coefficients for near-clipping windows to avoid artifacts.
Definition: aacenc.c:466
mpeg4audio.h
SingleChannelElement::ret_buf
INTFLOAT ret_buf[2048]
PCM output buffer.
Definition: aac.h:265
FF_PROFILE_MPEG2_AAC_LOW
#define FF_PROFILE_MPEG2_AAC_LOW
Definition: avcodec.h:1526
apply_mid_side_stereo
static void apply_mid_side_stereo(ChannelElement *cpe)
Definition: aacenc.c:334
TYPE_CPE
@ TYPE_CPE
Definition: aac.h:58
ChannelElement::ms_mode
int ms_mode
Signals mid/side stereo flags coding mode (used by encoder)
Definition: aac.h:280
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1690
defaults
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:464
Pulse::amp
int amp[4]
Definition: aac.h:229
Pulse::pos
int pos[4]
Definition: aac.h:228
put_pce
static void put_pce(PutBitContext *pb, AVCodecContext *avctx)
Definition: aacenc.c:52
ff_psy_end
av_cold void ff_psy_end(FFPsyContext *ctx)
Cleanup model context at the end.
Definition: psymodel.c:83
Pulse::start
int start
Definition: aac.h:227
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
ff_af_queue_add
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
Definition: audio_frame_queue.c:44
IndividualChannelStream::prediction_used
uint8_t prediction_used[41]
Definition: aac.h:191
AACPCEInfo::num_ele
int num_ele[4]
front, side, back, lfe
Definition: aacenc.h:97
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:250
FFPsyWindowInfo
windowing related information
Definition: psymodel.h:77
adjust_frame_information
static void adjust_frame_information(ChannelElement *cpe, int chans)
Produce integer coefficients from scalefactors provided by the model.
Definition: aacenc.c:255
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
IndividualChannelStream::clip_avoidance_factor
float clip_avoidance_factor
set if any window is near clipping to the necessary atennuation factor to avoid it
Definition: aac.h:193
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:486
NOISE_BT
@ NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:88
s
#define s(width, name)
Definition: cbs_vp9.c:257
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:263
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:450
IndividualChannelStream::swb_sizes
const uint8_t * swb_sizes
table of scalefactor band sizes for a particular window
Definition: aac.h:183
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:79
info
MIPS optimizations info
Definition: mips.txt:2
INTENSITY_BT2
@ INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:89
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aac.h:180
FF_PROFILE_UNKNOWN
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1515
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
aac_normal_chan_layouts
static const int64_t aac_normal_chan_layouts[7]
Definition: aacenctab.h:47
alloc_buffers
static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:936
ff_aac_swb_size_128_len
const int ff_aac_swb_size_128_len
Definition: aacenctab.c:107
channels
channels
Definition: aptx.h:33
LongTermPrediction::present
int8_t present
Definition: aac.h:165
ff_put_string
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:48
IndividualChannelStream
Individual Channel Stream.
Definition: aac.h:175
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:153
NAN
#define NAN
Definition: mathematics.h:64
f
#define f(width, name)
Definition: cbs_vp9.c:255
NOISE_PRE
#define NOISE_PRE
preamble for NOISE_BT, put in bitstream with the first noise band
Definition: aac.h:157
PutBitContext
Definition: put_bits.h:49
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aac.h:182
ff_aac_tableinit
void ff_aac_tableinit(void)
Definition: aactab.c:3347
aac_chan_maps
static const uint8_t aac_chan_maps[AAC_MAX_CHANNELS][AAC_MAX_CHANNELS]
Table to remap channels from libavcodec's default order to AAC order.
Definition: aacenctab.h:72
if
if(ret)
Definition: filter_design.txt:179
AVCodecDefault
Definition: internal.h:212
INTENSITY_BT
@ INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:90
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:39
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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.h:139
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
ChannelElement::is_mask
uint8_t is_mask[128]
Set if intensity stereo is used (used by encoder)
Definition: aac.h:283
NULL
#define NULL
Definition: coverity.c:32
sizes
static const int sizes[][2]
Definition: img2dec.c:53
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:419
SingleChannelElement::is_ener
float is_ener[128]
Intensity stereo pos (used by encoder)
Definition: aac.h:260
ff_aac_num_swb_128
const uint8_t ff_aac_num_swb_128[]
Definition: aactab.c:80
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:434
av_clipf
#define av_clipf
Definition: common.h:170
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
profiles.h
aac.h
aactab.h
IndividualChannelStream::predictor_present
int predictor_present
Definition: aac.h:187
FFPsyWindowInfo::grouping
int grouping[8]
window grouping (for e.g. AAC)
Definition: psymodel.h:81
TNS_MAX_ORDER
#define TNS_MAX_ORDER
Definition: aac.h:51
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices (used by encoder)
Definition: aac.h:257
float_dsp.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:424
aac_encode_frame
static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: aacenc.c:555
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:111
AACPCEInfo
Definition: aacenc.h:95
FFPsyWindowInfo::clipping
float clipping[8]
maximum absolute normalized intensity in the given window for clip avoidance
Definition: psymodel.h:82
options
const OptionDef options[]
SingleChannelElement::lcoeffs
AAC_FLOAT lcoeffs[1024]
MDCT of LTP coefficients (used by encoder)
Definition: aac.h:267
AAC_CODER_ANMR
@ AAC_CODER_ANMR
Definition: aacenc.h:38
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aac.h:285
ff_swb_offset_1024
const uint16_t *const ff_swb_offset_1024[]
Definition: aactab.c:1355
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:77
TYPE_END
@ TYPE_END
Definition: aac.h:64
quantize_bands
static void quantize_bands(int *out, const float *in, const float *scaled, int size, int is_signed, int maxval, const float Q34, const float rounding)
Definition: aacenc_utils.h:65
ff_aac_float_common_init
void ff_aac_float_common_init(void)
FF_PROFILE_AAC_LOW
#define FF_PROFILE_AAC_LOW
Definition: avcodec.h:1519
encode_scale_factors
static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce)
Encode scalefactors.
Definition: aacenc.c:383
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
apply_window_and_mdct
static void apply_window_and_mdct(AACEncContext *s, SingleChannelElement *sce, float *audio)
Definition: aacenc.c:199
AVFloatDSPContext
Definition: float_dsp.h:24
AAC_CODER_TWOLOOP
@ AAC_CODER_TWOLOOP
Definition: aacenc.h:39
ff_aac_coder_init_mips
void ff_aac_coder_init_mips(AACEncContext *c)
Definition: aaccoder_mips.c:2484
ChannelElement::common_window
int common_window
Set if channels share a common 'IndividualChannelStream' in bitstream.
Definition: aac.h:279
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
sinewin.h
apply_intensity_stereo
static void apply_intensity_stereo(ChannelElement *cpe)
Definition: aacenc.c:305
AACPCEInfo::index
int index[4][8]
front, side, back, lfe
Definition: aacenc.h:99
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aac.h:282
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:323
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:192
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:982
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
i
int i
Definition: input.c:407
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:249
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
IndividualChannelStream::num_windows
int num_windows
Definition: aac.h:185
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:485
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: internal.h:49
aacenc_options
static const AVOption aacenc_options[]
Definition: aacenc.c:1107
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:80
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:276
apply_window
static void(*const apply_window[4])(AVFloatDSPContext *fdsp, SingleChannelElement *sce, const float *audio)
Definition: aacenc.c:190
AACPCEInfo::pairing
int pairing[3][8]
front, side, back
Definition: aacenc.h:98
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
NOISE_PRE_BITS
#define NOISE_PRE_BITS
length of preamble
Definition: aac.h:158
TYPE_LFE
@ TYPE_LFE
Definition: aac.h:60
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:244
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
ff_aac_dsp_init_x86
void ff_aac_dsp_init_x86(AACEncContext *s)
Definition: aacencdsp_init.c:35
AACENC_FLAGS
#define AACENC_FLAGS
Definition: aacenc.c:1106
IndividualChannelStream::tns_max_bands
int tns_max_bands
Definition: aac.h:186
avcodec.h
tag
uint32_t tag
Definition: movenc.c:1594
ret
ret
Definition: filter_design.txt:187
ff_aac_num_swb_1024
const uint8_t ff_aac_num_swb_1024[]
Definition: aactab.c:64
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1269
encode_ms_info
static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
Encode MS data.
Definition: aacenc.c:241
RESERVED_BT
@ RESERVED_BT
Band types following are encoded differently from others.
Definition: aac.h:87
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:78
ff_psy_preprocess
void ff_psy_preprocess(struct FFPsyPreprocessContext *ctx, float **audio, int channels)
Preprocess several channel in audio frame in order to compress it better.
Definition: psymodel.c:139
CLIP_AVOIDANCE_FACTOR
#define CLIP_AVOIDANCE_FACTOR
Definition: aac.h:54
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aac.h:251
AACEncContext
AAC encoder context.
Definition: aacenc.h:378
L
#define L(x)
Definition: vp56_arith.h:36
AVCodecContext
main external API structure.
Definition: avcodec.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:486
NOISE_OFFSET
#define NOISE_OFFSET
subtracted from global gain, used as offset for the preamble
Definition: aac.h:159
ERROR_IF
#define ERROR_IF(cond,...)
Definition: aacenc_utils.h:268
ff_aac_swb_size_1024
const uint8_t *const ff_aac_swb_size_1024[]
Definition: aacenctab.c:99
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aac.h:177
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
TemporalNoiseShaping
Temporal Noise Shaping.
Definition: aac.h:199
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1514
AOT_SBR
@ AOT_SBR
Y Spectral Band Replication.
Definition: mpeg4audio.h:81
put_audio_specific_config
static int put_audio_specific_config(AVCodecContext *avctx)
Make AAC audio config object.
Definition: aacenc.c:93
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:77
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
ChannelElement::is_mode
uint8_t is_mode
Set if any bands have been encoded using intensity stereo (used by encoder)
Definition: aac.h:281
put_ics_info
static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
Encode ics_info element.
Definition: aacenc.c:220
ff_aac_swb_size_128
const uint8_t *const ff_aac_swb_size_128[]
Definition: aacenctab.c:91
aac_encode_defaults
static const AVCodecDefault aac_encode_defaults[]
Definition: aacenc.c:1130
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:273
avpriv_mpeg4audio_sample_rates
const int avpriv_mpeg4audio_sample_rates[16]
Definition: mpeg4audio.c:62
aac_encode_end
static av_cold int aac_encode_end(AVCodecContext *avctx)
Definition: aacenc.c:898
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1012
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
FF_AAC_PROFILE_OPTS
#define FF_AAC_PROFILE_OPTS
Definition: profiles.h:28
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:242
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
IndividualChannelStream::window_clipping
uint8_t window_clipping[8]
set if a certain window is near clipping
Definition: aac.h:192
mpeg4audio_sample_rates
static const int mpeg4audio_sample_rates[16]
Definition: aacenctab.h:85
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:176
Pulse
Definition: aac.h:225
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
SingleChannelElement::ltp_state
INTFLOAT ltp_state[3072]
time signal for LTP
Definition: aac.h:266
dsp_init
static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
Definition: aacenc.c:917
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aac.h:181
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:82
put_bits.h
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aac.h:253
psymodel.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aac.h:178
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:33
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:47
ff_aac_encoder
const AVCodec ff_aac_encoder
Definition: aacenc.c:1135
FFPsyWindowInfo::num_windows
int num_windows
number of windows in a frame
Definition: psymodel.h:80
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:301
ff_aac_scalefactor_code
const uint32_t ff_aac_scalefactor_code[121]
Definition: aactab.c:92
ff_quantize_band_cost_cache_init
void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
Definition: aacenc.c:125
aacenc.h