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