FFmpeg: libavcodec/aacpsy.c Source File

FFmpeg
aacpsy.c
Go to the documentation of this file.
1 /*
2  * AAC encoder psychoacoustic model
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 psychoacoustic model
25  */
26 
27 #include "libavutil/attributes.h"
28 #include "libavutil/ffmath.h"
29 #include "libavutil/mem.h"
30 
31 #include "avcodec.h"
32 #include "aac.h"
33 #include "psymodel.h"
34 
35 /***********************************
36  * TODOs:
37  * try other bitrate controlling mechanism (maybe use ratecontrol.c?)
38  * control quality for quality-based output
39  **********************************/
40 
41 /**
42  * constants for 3GPP AAC psychoacoustic model
43  * @{
44  */
45  #define PSY_3GPP_THR_SPREAD_HI 1.5f // spreading factor for low-to-hi threshold spreading (15 dB/Bark)
46  #define PSY_3GPP_THR_SPREAD_LOW 3.0f // spreading factor for hi-to-low threshold spreading (30 dB/Bark)
47 /* spreading factor for low-to-hi energy spreading, long block, > 22kbps/channel (20dB/Bark) */
48  #define PSY_3GPP_EN_SPREAD_HI_L1 2.0f
49 /* spreading factor for low-to-hi energy spreading, long block, <= 22kbps/channel (15dB/Bark) */
50  #define PSY_3GPP_EN_SPREAD_HI_L2 1.5f
51 /* spreading factor for low-to-hi energy spreading, short block (15 dB/Bark) */
52  #define PSY_3GPP_EN_SPREAD_HI_S 1.5f
53 /* spreading factor for hi-to-low energy spreading, long block (30dB/Bark) */
54  #define PSY_3GPP_EN_SPREAD_LOW_L 3.0f
55 /* spreading factor for hi-to-low energy spreading, short block (20dB/Bark) */
56  #define PSY_3GPP_EN_SPREAD_LOW_S 2.0f
57 
58  #define PSY_3GPP_RPEMIN 0.01f
59  #define PSY_3GPP_RPELEV 2.0f
60 
61  #define PSY_3GPP_C1 3.0f /* log2(8) */
62  #define PSY_3GPP_C2 1.3219281f /* log2(2.5) */
63  #define PSY_3GPP_C3 0.55935729f /* 1 - C2 / C1 */
64 
65  #define PSY_SNR_1DB 7.9432821e-1f /* -1dB */
66  #define PSY_SNR_25DB 3.1622776e-3f /* -25dB */
67 
68  #define PSY_3GPP_SAVE_SLOPE_L -0.46666667f
69  #define PSY_3GPP_SAVE_SLOPE_S -0.36363637f
70  #define PSY_3GPP_SAVE_ADD_L -0.84285712f
71  #define PSY_3GPP_SAVE_ADD_S -0.75f
72  #define PSY_3GPP_SPEND_SLOPE_L 0.66666669f
73  #define PSY_3GPP_SPEND_SLOPE_S 0.81818181f
74  #define PSY_3GPP_SPEND_ADD_L -0.35f
75  #define PSY_3GPP_SPEND_ADD_S -0.26111111f
76  #define PSY_3GPP_CLIP_LO_L 0.2f
77  #define PSY_3GPP_CLIP_LO_S 0.2f
78  #define PSY_3GPP_CLIP_HI_L 0.95f
79  #define PSY_3GPP_CLIP_HI_S 0.75f
80 
81  #define PSY_3GPP_AH_THR_LONG 0.5f
82  #define PSY_3GPP_AH_THR_SHORT 0.63f
83 
84  #define PSY_PE_FORGET_SLOPE 511
85 
86 enum {
87   PSY_3GPP_AH_NONE,
88   PSY_3GPP_AH_INACTIVE,
89   PSY_3GPP_AH_ACTIVE
90 };
91 
92  #define PSY_3GPP_BITS_TO_PE(bits) ((bits) * 1.18f)
93  #define PSY_3GPP_PE_TO_BITS(bits) ((bits) / 1.18f)
94 
95 /* LAME psy model constants */
96  #define PSY_LAME_FIR_LEN 21 ///< LAME psy model FIR order
97  #define AAC_BLOCK_SIZE_LONG 1024 ///< long block size
98  #define AAC_BLOCK_SIZE_SHORT 128 ///< short block size
99  #define AAC_NUM_BLOCKS_SHORT 8 ///< number of blocks in a short sequence
100  #define PSY_LAME_NUM_SUBBLOCKS 3 ///< Number of sub-blocks in each short block
101 
102 /**
103  * @}
104  */
105 
106 /**
107  * information for single band used by 3GPP TS26.403-inspired psychoacoustic model
108  */
109  typedef struct AacPsyBand{
110   float energy; ///< band energy
111   float thr; ///< energy threshold
112   float thr_quiet; ///< threshold in quiet
113   float nz_lines; ///< number of non-zero spectral lines
114   float active_lines; ///< number of active spectral lines
115   float pe; ///< perceptual entropy
116   float pe_const; ///< constant part of the PE calculation
117   float norm_fac; ///< normalization factor for linearization
118   int avoid_holes; ///< hole avoidance flag
119 }AacPsyBand;
120 
121 /**
122  * single/pair channel context for psychoacoustic model
123  */
124  typedef struct AacPsyChannel{
125   AacPsyBand band[128]; ///< bands information
126   AacPsyBand prev_band[128]; ///< bands information from the previous frame
127 
128   float win_energy; ///< sliding average of channel energy
129   float iir_state[2]; ///< hi-pass IIR filter state
130   uint8_t next_grouping; ///< stored grouping scheme for the next frame (in case of 8 short window sequence)
131   enum WindowSequence next_window_seq; ///< window sequence to be used in the next frame
132  /* LAME psy model specific members */
133   float attack_threshold; ///< attack threshold for this channel
134   float prev_energy_subshort[AAC_NUM_BLOCKS_SHORT * PSY_LAME_NUM_SUBBLOCKS];
135   int prev_attack; ///< attack value for the last short block in the previous sequence
136 }AacPsyChannel;
137 
138 /**
139  * psychoacoustic model frame type-dependent coefficients
140  */
141  typedef struct AacPsyCoeffs{
142   float ath; ///< absolute threshold of hearing per bands
143   float barks; ///< Bark value for each spectral band in long frame
144   float spread_low[2]; ///< spreading factor for low-to-high threshold spreading in long frame
145   float spread_hi [2]; ///< spreading factor for high-to-low threshold spreading in long frame
146   float min_snr; ///< minimal SNR
147 }AacPsyCoeffs;
148 
149 /**
150  * 3GPP TS26.403-inspired psychoacoustic model specific data
151  */
152  typedef struct AacPsyContext{
153   int chan_bitrate; ///< bitrate per channel
154   int frame_bits; ///< average bits per frame
155   int fill_level; ///< bit reservoir fill level
156  struct {
157   float min; ///< minimum allowed PE for bit factor calculation
158   float max; ///< maximum allowed PE for bit factor calculation
159   float previous; ///< allowed PE of the previous frame
160   float correction; ///< PE correction factor
161  } pe;
162   AacPsyCoeffs psy_coef[2][64];
163   AacPsyChannel *ch;
164   float global_quality; ///< normalized global quality taken from avctx
165 }AacPsyContext;
166 
167 /**
168  * LAME psy model preset struct
169  */
170  typedef struct PsyLamePreset {
171   int quality; ///< Quality to map the rest of the vaules to.
172  /* This is overloaded to be both kbps per channel in ABR mode, and
173  * requested quality in constant quality mode.
174  */
175   float st_lrm; ///< short threshold for L, R, and M channels
176 } PsyLamePreset;
177 
178 /**
179  * LAME psy model preset table for ABR
180  */
181  static const PsyLamePreset psy_abr_map[] = {
182 /* TODO: Tuning. These were taken from LAME. */
183 /* kbps/ch st_lrm */
184  { 8, 6.60},
185  { 16, 6.60},
186  { 24, 6.60},
187  { 32, 6.60},
188  { 40, 6.60},
189  { 48, 6.60},
190  { 56, 6.60},
191  { 64, 6.40},
192  { 80, 6.00},
193  { 96, 5.60},
194  {112, 5.20},
195  {128, 5.20},
196  {160, 5.20}
197 };
198 
199 /**
200 * LAME psy model preset table for constant quality
201 */
202  static const PsyLamePreset psy_vbr_map[] = {
203 /* vbr_q st_lrm */
204  { 0, 4.20},
205  { 1, 4.20},
206  { 2, 4.20},
207  { 3, 4.20},
208  { 4, 4.20},
209  { 5, 4.20},
210  { 6, 4.20},
211  { 7, 4.20},
212  { 8, 4.20},
213  { 9, 4.20},
214  {10, 4.20}
215 };
216 
217 /**
218  * LAME psy model FIR coefficient table
219  */
220  static const float psy_fir_coeffs[] = {
221  -8.65163e-18 * 2, -0.00851586 * 2, -6.74764e-18 * 2, 0.0209036 * 2,
222  -3.36639e-17 * 2, -0.0438162 * 2, -1.54175e-17 * 2, 0.0931738 * 2,
223  -5.52212e-17 * 2, -0.313819 * 2
224 };
225 
226 /**
227  * Calculate the ABR attack threshold from the above LAME psymodel table.
228  */
229  static float lame_calc_attack_threshold(int bitrate)
230 {
231  /* Assume max bitrate to start with */
232  int lower_range = 12, upper_range = 12;
233  int lower_range_kbps = psy_abr_map[12].quality;
234  int upper_range_kbps = psy_abr_map[12].quality;
235  int i;
236 
237  /* Determine which bitrates the value specified falls between.
238  * If the loop ends without breaking our above assumption of 320kbps was correct.
239  */
240  for (i = 1; i < 13; i++) {
241  if (FFMAX(bitrate, psy_abr_map[i].quality) != bitrate) {
242  upper_range = i;
243  upper_range_kbps = psy_abr_map[i ].quality;
244  lower_range = i - 1;
245  lower_range_kbps = psy_abr_map[i - 1].quality;
246  break; /* Upper range found */
247  }
248  }
249 
250  /* Determine which range the value specified is closer to */
251  if ((upper_range_kbps - bitrate) > (bitrate - lower_range_kbps))
252  return psy_abr_map[lower_range].st_lrm;
253  return psy_abr_map[upper_range].st_lrm;
254 }
255 
256 /**
257  * LAME psy model specific initialization
258  */
259  static av_cold void lame_window_init(AacPsyContext *ctx, AVCodecContext *avctx)
260 {
261  int i, j;
262 
263  for (i = 0; i < avctx->ch_layout.nb_channels; i++) {
264  AacPsyChannel *pch = &ctx->ch[i];
265 
266  if (avctx->flags & AV_CODEC_FLAG_QSCALE)
267  pch->attack_threshold = psy_vbr_map[av_clip(avctx->global_quality / FF_QP2LAMBDA, 0, 10)].st_lrm;
268  else
269  pch->attack_threshold = lame_calc_attack_threshold(avctx->bit_rate / avctx->ch_layout.nb_channels / 1000);
270 
271  for (j = 0; j < AAC_NUM_BLOCKS_SHORT * PSY_LAME_NUM_SUBBLOCKS; j++)
272  pch->prev_energy_subshort[j] = 10.0f;
273  }
274 }
275 
276 /**
277  * Calculate Bark value for given line.
278  */
279  static av_cold float calc_bark(float f)
280 {
281  return 13.3f * atanf(0.00076f * f) + 3.5f * atanf((f / 7500.0f) * (f / 7500.0f));
282 }
283 
284  #define ATH_ADD 4
285 /**
286  * Calculate ATH value for given frequency.
287  * Borrowed from Lame.
288  */
289  static av_cold float ath(float f, float add)
290 {
291  f /= 1000.0f;
292  return 3.64 * pow(f, -0.8)
293  - 6.8 * exp(-0.6 * (f - 3.4) * (f - 3.4))
294  + 6.0 * exp(-0.15 * (f - 8.7) * (f - 8.7))
295  + (0.6 + 0.04 * add) * 0.001 * f * f * f * f;
296 }
297 
298  static av_cold int psy_3gpp_init(FFPsyContext *ctx) {
299  AacPsyContext *pctx;
300  float bark;
301  int i, j, g, start;
302  float prev, minscale, minath, minsnr, pe_min;
303  int chan_bitrate = ctx->avctx->bit_rate / ((ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : ctx->avctx->ch_layout.nb_channels);
304 
305  const int bandwidth = ctx->cutoff ? ctx->cutoff : AAC_CUTOFF(ctx->avctx);
306  const float num_bark = calc_bark((float)bandwidth);
307 
308  if (bandwidth <= 0)
309  return AVERROR(EINVAL);
310 
311  ctx->model_priv_data = av_mallocz(sizeof(AacPsyContext));
312  if (!ctx->model_priv_data)
313  return AVERROR(ENOMEM);
314  pctx = ctx->model_priv_data;
315  pctx->global_quality = (ctx->avctx->global_quality ? ctx->avctx->global_quality : 120) * 0.01f;
316 
317  if (ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) {
318  /* Use the target average bitrate to compute spread parameters */
319  chan_bitrate = (int)(chan_bitrate / 120.0 * (ctx->avctx->global_quality ? ctx->avctx->global_quality : 120));
320  }
321 
322  pctx->chan_bitrate = chan_bitrate;
323  pctx->frame_bits = FFMIN(2560, chan_bitrate * AAC_BLOCK_SIZE_LONG / ctx->avctx->sample_rate);
324  pctx->pe.min = 8.0f * AAC_BLOCK_SIZE_LONG * bandwidth / (ctx->avctx->sample_rate * 2.0f);
325  pctx->pe.max = 12.0f * AAC_BLOCK_SIZE_LONG * bandwidth / (ctx->avctx->sample_rate * 2.0f);
326  ctx->bitres.size = 6144 - pctx->frame_bits;
327  ctx->bitres.size -= ctx->bitres.size % 8;
328  pctx->fill_level = ctx->bitres.size;
329  minath = ath(3410 - 0.733 * ATH_ADD, ATH_ADD);
330  for (j = 0; j < 2; j++) {
331  AacPsyCoeffs *coeffs = pctx->psy_coef[j];
332  const uint8_t *band_sizes = ctx->bands[j];
333  float line_to_frequency = ctx->avctx->sample_rate / (j ? 256.f : 2048.0f);
334  float avg_chan_bits = chan_bitrate * (j ? 128.0f : 1024.0f) / ctx->avctx->sample_rate;
335  /* reference encoder uses 2.4% here instead of 60% like the spec says */
336  float bark_pe = 0.024f * PSY_3GPP_BITS_TO_PE(avg_chan_bits) / num_bark;
337  float en_spread_low = j ? PSY_3GPP_EN_SPREAD_LOW_S : PSY_3GPP_EN_SPREAD_LOW_L;
338  /* High energy spreading for long blocks <= 22kbps/channel and short blocks are the same. */
339  float en_spread_hi = (j || (chan_bitrate <= 22.0f)) ? PSY_3GPP_EN_SPREAD_HI_S : PSY_3GPP_EN_SPREAD_HI_L1;
340 
341  i = 0;
342  prev = 0.0;
343  for (g = 0; g < ctx->num_bands[j]; g++) {
344  i += band_sizes[g];
345  bark = calc_bark((i-1) * line_to_frequency);
346  coeffs[g].barks = (bark + prev) / 2.0;
347  prev = bark;
348  }
349  for (g = 0; g < ctx->num_bands[j] - 1; g++) {
350  AacPsyCoeffs *coeff = &coeffs[g];
351  float bark_width = coeffs[g+1].barks - coeffs->barks;
352  coeff->spread_low[0] = ff_exp10(-bark_width * PSY_3GPP_THR_SPREAD_LOW);
353  coeff->spread_hi [0] = ff_exp10(-bark_width * PSY_3GPP_THR_SPREAD_HI);
354  coeff->spread_low[1] = ff_exp10(-bark_width * en_spread_low);
355  coeff->spread_hi [1] = ff_exp10(-bark_width * en_spread_hi);
356  pe_min = bark_pe * bark_width;
357  minsnr = exp2(pe_min / band_sizes[g]) - 1.5f;
358  coeff->min_snr = av_clipf(1.0f / minsnr, PSY_SNR_25DB, PSY_SNR_1DB);
359  }
360  start = 0;
361  for (g = 0; g < ctx->num_bands[j]; g++) {
362  minscale = ath(start * line_to_frequency, ATH_ADD);
363  for (i = 1; i < band_sizes[g]; i++)
364  minscale = FFMIN(minscale, ath((start + i) * line_to_frequency, ATH_ADD));
365  coeffs[g].ath = minscale - minath;
366  start += band_sizes[g];
367  }
368  }
369 
370  pctx->ch = av_calloc(ctx->avctx->ch_layout.nb_channels, sizeof(*pctx->ch));
371  if (!pctx->ch) {
372  av_freep(&ctx->model_priv_data);
373  return AVERROR(ENOMEM);
374  }
375 
376  lame_window_init(pctx, ctx->avctx);
377 
378  return 0;
379 }
380 
381 /**
382  * IIR filter used in block switching decision
383  */
384  static float iir_filter(int in, float state[2])
385 {
386  float ret;
387 
388  ret = 0.7548f * (in - state[0]) + 0.5095f * state[1];
389  state[0] = in;
390  state[1] = ret;
391  return ret;
392 }
393 
394 /**
395  * window grouping information stored as bits (0 - new group, 1 - group continues)
396  */
397  static const uint8_t window_grouping[9] = {
398  0xB6, 0x6C, 0xD8, 0xB2, 0x66, 0xC6, 0x96, 0x36, 0x36
399 };
400 
401 /**
402  * Tell encoder which window types to use.
403  * @see 3GPP TS26.403 5.4.1 "Blockswitching"
404  */
405  static av_unused FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx,
406  const int16_t *audio,
407  const int16_t *la,
408  int channel, int prev_type)
409 {
410  int i, j;
411  int br = ((AacPsyContext*)ctx->model_priv_data)->chan_bitrate;
412  int attack_ratio = br <= 16000 ? 18 : 10;
413  AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data;
414  AacPsyChannel *pch = &pctx->ch[channel];
415  uint8_t grouping = 0;
416  int next_type = pch->next_window_seq;
417  FFPsyWindowInfo wi = { { 0 } };
418 
419  if (la) {
420  float s[8], v;
421  int switch_to_eight = 0;
422  float sum = 0.0, sum2 = 0.0;
423  int attack_n = 0;
424  int stay_short = 0;
425  for (i = 0; i < 8; i++) {
426  for (j = 0; j < 128; j++) {
427  v = iir_filter(la[i*128+j], pch->iir_state);
428  sum += v*v;
429  }
430  s[i] = sum;
431  sum2 += sum;
432  }
433  for (i = 0; i < 8; i++) {
434  if (s[i] > pch->win_energy * attack_ratio) {
435  attack_n = i + 1;
436  switch_to_eight = 1;
437  break;
438  }
439  }
440  pch->win_energy = pch->win_energy*7/8 + sum2/64;
441 
442  wi.window_type[1] = prev_type;
443  switch (prev_type) {
444  case ONLY_LONG_SEQUENCE:
445  wi.window_type[0] = switch_to_eight ? LONG_START_SEQUENCE : ONLY_LONG_SEQUENCE;
446  next_type = switch_to_eight ? EIGHT_SHORT_SEQUENCE : ONLY_LONG_SEQUENCE;
447  break;
448  case LONG_START_SEQUENCE:
449  wi.window_type[0] = EIGHT_SHORT_SEQUENCE;
450  grouping = pch->next_grouping;
451  next_type = switch_to_eight ? EIGHT_SHORT_SEQUENCE : LONG_STOP_SEQUENCE;
452  break;
453  case LONG_STOP_SEQUENCE:
454  wi.window_type[0] = switch_to_eight ? LONG_START_SEQUENCE : ONLY_LONG_SEQUENCE;
455  next_type = switch_to_eight ? EIGHT_SHORT_SEQUENCE : ONLY_LONG_SEQUENCE;
456  break;
457  case EIGHT_SHORT_SEQUENCE:
458  stay_short = next_type == EIGHT_SHORT_SEQUENCE || switch_to_eight;
459  wi.window_type[0] = stay_short ? EIGHT_SHORT_SEQUENCE : LONG_STOP_SEQUENCE;
460  grouping = next_type == EIGHT_SHORT_SEQUENCE ? pch->next_grouping : 0;
461  next_type = switch_to_eight ? EIGHT_SHORT_SEQUENCE : LONG_STOP_SEQUENCE;
462  break;
463  }
464 
465  pch->next_grouping = window_grouping[attack_n];
466  pch->next_window_seq = next_type;
467  } else {
468  for (i = 0; i < 3; i++)
469  wi.window_type[i] = prev_type;
470  grouping = (prev_type == EIGHT_SHORT_SEQUENCE) ? window_grouping[0] : 0;
471  }
472 
473  wi.window_shape = 1;
474  if (wi.window_type[0] != EIGHT_SHORT_SEQUENCE) {
475  wi.num_windows = 1;
476  wi.grouping[0] = 1;
477  } else {
478  int lastgrp = 0;
479  wi.num_windows = 8;
480  for (i = 0; i < 8; i++) {
481  if (!((grouping >> i) & 1))
482  lastgrp = i;
483  wi.grouping[lastgrp]++;
484  }
485  }
486 
487  return wi;
488 }
489 
490 /* 5.6.1.2 "Calculation of Bit Demand" */
491  static int calc_bit_demand(AacPsyContext *ctx, float pe, int bits, int size,
492  int short_window)
493 {
494  const float bitsave_slope = short_window ? PSY_3GPP_SAVE_SLOPE_S : PSY_3GPP_SAVE_SLOPE_L;
495  const float bitsave_add = short_window ? PSY_3GPP_SAVE_ADD_S : PSY_3GPP_SAVE_ADD_L;
496  const float bitspend_slope = short_window ? PSY_3GPP_SPEND_SLOPE_S : PSY_3GPP_SPEND_SLOPE_L;
497  const float bitspend_add = short_window ? PSY_3GPP_SPEND_ADD_S : PSY_3GPP_SPEND_ADD_L;
498  const float clip_low = short_window ? PSY_3GPP_CLIP_LO_S : PSY_3GPP_CLIP_LO_L;
499  const float clip_high = short_window ? PSY_3GPP_CLIP_HI_S : PSY_3GPP_CLIP_HI_L;
500  float clipped_pe, bit_save, bit_spend, bit_factor, fill_level, forgetful_min_pe;
501 
502  ctx->fill_level += ctx->frame_bits - bits;
503  ctx->fill_level = av_clip(ctx->fill_level, 0, size);
504  fill_level = av_clipf((float)ctx->fill_level / size, clip_low, clip_high);
505  clipped_pe = av_clipf(pe, ctx->pe.min, ctx->pe.max);
506  bit_save = (fill_level + bitsave_add) * bitsave_slope;
507  assert(bit_save <= 0.3f && bit_save >= -0.05000001f);
508  bit_spend = (fill_level + bitspend_add) * bitspend_slope;
509  assert(bit_spend <= 0.5f && bit_spend >= -0.1f);
510  /* The bit factor graph in the spec is obviously incorrect.
511  * bit_spend + ((bit_spend - bit_spend))...
512  * The reference encoder subtracts everything from 1, but also seems incorrect.
513  * 1 - bit_save + ((bit_spend + bit_save))...
514  * Hopefully below is correct.
515  */
516  bit_factor = 1.0f - bit_save + ((bit_spend - bit_save) / (ctx->pe.max - ctx->pe.min)) * (clipped_pe - ctx->pe.min);
517  /* NOTE: The reference encoder attempts to center pe max/min around the current pe.
518  * Here we do that by slowly forgetting pe.min when pe stays in a range that makes
519  * it unlikely (ie: above the mean)
520  */
521  ctx->pe.max = FFMAX(pe, ctx->pe.max);
522  forgetful_min_pe = ((ctx->pe.min * PSY_PE_FORGET_SLOPE)
523  + FFMAX(ctx->pe.min, pe * (pe / ctx->pe.max))) / (PSY_PE_FORGET_SLOPE + 1);
524  ctx->pe.min = FFMIN(pe, forgetful_min_pe);
525 
526  /* NOTE: allocate a minimum of 1/8th average frame bits, to avoid
527  * reservoir starvation from producing zero-bit frames
528  */
529  return FFMIN(
530  ctx->frame_bits * bit_factor,
531  FFMAX(ctx->frame_bits + size - bits, ctx->frame_bits / 8));
532 }
533 
534  static float calc_pe_3gpp(AacPsyBand *band)
535 {
536  float pe, a;
537 
538  band->pe = 0.0f;
539  band->pe_const = 0.0f;
540  band->active_lines = 0.0f;
541  if (band->energy > band->thr) {
542  a = log2f(band->energy);
543  pe = a - log2f(band->thr);
544  band->active_lines = band->nz_lines;
545  if (pe < PSY_3GPP_C1) {
546  pe = pe * PSY_3GPP_C3 + PSY_3GPP_C2;
547  a = a * PSY_3GPP_C3 + PSY_3GPP_C2;
548  band->active_lines *= PSY_3GPP_C3;
549  }
550  band->pe = pe * band->nz_lines;
551  band->pe_const = a * band->nz_lines;
552  }
553 
554  return band->pe;
555 }
556 
557  static float calc_reduction_3gpp(float a, float desired_pe, float pe,
558  float active_lines)
559 {
560  float thr_avg, reduction;
561 
562  if(active_lines == 0.0)
563  return 0;
564 
565  thr_avg = exp2f((a - pe) / (4.0f * active_lines));
566  reduction = exp2f((a - desired_pe) / (4.0f * active_lines)) - thr_avg;
567 
568  return FFMAX(reduction, 0.0f);
569 }
570 
571  static float calc_reduced_thr_3gpp(AacPsyBand *band, float min_snr,
572  float reduction)
573 {
574  float thr = band->thr;
575 
576  if (band->energy > thr) {
577  thr = sqrtf(thr);
578  thr = sqrtf(thr) + reduction;
579  thr *= thr;
580  thr *= thr;
581 
582  /* This deviates from the 3GPP spec to match the reference encoder.
583  * It performs min(thr_reduced, max(thr, energy/min_snr)) only for bands
584  * that have hole avoidance on (active or inactive). It always reduces the
585  * threshold of bands with hole avoidance off.
586  */
587  if (thr > band->energy * min_snr && band->avoid_holes != PSY_3GPP_AH_NONE) {
588  thr = FFMAX(band->thr, band->energy * min_snr);
589  band->avoid_holes = PSY_3GPP_AH_ACTIVE;
590  }
591  }
592 
593  return thr;
594 }
595 
596 #ifndef calc_thr_3gpp
597  static void calc_thr_3gpp(const FFPsyWindowInfo *wi, const int num_bands, AacPsyChannel *pch,
598  const uint8_t *band_sizes, const float *coefs, const int cutoff)
599 {
600  int i, w, g;
601  int start = 0, wstart = 0;
602  for (w = 0; w < wi->num_windows*16; w += 16) {
603  wstart = 0;
604  for (g = 0; g < num_bands; g++) {
605  AacPsyBand *band = &pch->band[w+g];
606 
607  float form_factor = 0.0f;
608  float Temp;
609  band->energy = 0.0f;
610  if (wstart < cutoff) {
611  for (i = 0; i < band_sizes[g]; i++) {
612  band->energy += coefs[start+i] * coefs[start+i];
613  form_factor += sqrtf(fabs(coefs[start+i]));
614  }
615  }
616  Temp = band->energy > 0 ? sqrtf((float)band_sizes[g] / band->energy) : 0;
617  band->thr = band->energy * 0.001258925f;
618  band->nz_lines = form_factor * sqrtf(Temp);
619 
620  start += band_sizes[g];
621  wstart += band_sizes[g];
622  }
623  }
624 }
625 #endif /* calc_thr_3gpp */
626 
627 #ifndef psy_hp_filter
628  static void psy_hp_filter(const float *firbuf, float *hpfsmpl, const float *psy_fir_coeffs)
629 {
630  int i, j;
631  for (i = 0; i < AAC_BLOCK_SIZE_LONG; i++) {
632  float sum1, sum2;
633  sum1 = firbuf[i + (PSY_LAME_FIR_LEN - 1) / 2];
634  sum2 = 0.0;
635  for (j = 0; j < ((PSY_LAME_FIR_LEN - 1) / 2) - 1; j += 2) {
636  sum1 += psy_fir_coeffs[j] * (firbuf[i + j] + firbuf[i + PSY_LAME_FIR_LEN - j]);
637  sum2 += psy_fir_coeffs[j + 1] * (firbuf[i + j + 1] + firbuf[i + PSY_LAME_FIR_LEN - j - 1]);
638  }
639  /* NOTE: The LAME psymodel expects it's input in the range -32768 to 32768.
640  * Tuning this for normalized floats would be difficult. */
641  hpfsmpl[i] = (sum1 + sum2) * 32768.0f;
642  }
643 }
644 #endif /* psy_hp_filter */
645 
646 /**
647  * Calculate band thresholds as suggested in 3GPP TS26.403
648  */
649  static void psy_3gpp_analyze_channel(FFPsyContext *ctx, int channel,
650  const float *coefs, const FFPsyWindowInfo *wi)
651 {
652  AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data;
653  AacPsyChannel *pch = &pctx->ch[channel];
654  int i, w, g;
655  float desired_bits, desired_pe, delta_pe, reduction= NAN, spread_en[128] = {0};
656  float a = 0.0f, active_lines = 0.0f, norm_fac = 0.0f;
657  float pe = pctx->chan_bitrate > 32000 ? 0.0f : FFMAX(50.0f, 100.0f - pctx->chan_bitrate * 100.0f / 32000.0f);
658  const int num_bands = ctx->num_bands[wi->num_windows == 8];
659  const uint8_t *band_sizes = ctx->bands[wi->num_windows == 8];
660  AacPsyCoeffs *coeffs = pctx->psy_coef[wi->num_windows == 8];
661  const float avoid_hole_thr = wi->num_windows == 8 ? PSY_3GPP_AH_THR_SHORT : PSY_3GPP_AH_THR_LONG;
662  const int bandwidth = ctx->cutoff ? ctx->cutoff : AAC_CUTOFF(ctx->avctx);
663  const int cutoff = bandwidth * 2048 / wi->num_windows / ctx->avctx->sample_rate;
664 
665  //calculate energies, initial thresholds and related values - 5.4.2 "Threshold Calculation"
666  calc_thr_3gpp(wi, num_bands, pch, band_sizes, coefs, cutoff);
667 
668  //modify thresholds and energies - spread, threshold in quiet, pre-echo control
669  for (w = 0; w < wi->num_windows*16; w += 16) {
670  AacPsyBand *bands = &pch->band[w];
671 
672  /* 5.4.2.3 "Spreading" & 5.4.3 "Spread Energy Calculation" */
673  spread_en[0] = bands[0].energy;
674  for (g = 1; g < num_bands; g++) {
675  bands[g].thr = FFMAX(bands[g].thr, bands[g-1].thr * coeffs[g].spread_hi[0]);
676  spread_en[w+g] = FFMAX(bands[g].energy, spread_en[w+g-1] * coeffs[g].spread_hi[1]);
677  }
678  for (g = num_bands - 2; g >= 0; g--) {
679  bands[g].thr = FFMAX(bands[g].thr, bands[g+1].thr * coeffs[g].spread_low[0]);
680  spread_en[w+g] = FFMAX(spread_en[w+g], spread_en[w+g+1] * coeffs[g].spread_low[1]);
681  }
682  //5.4.2.4 "Threshold in quiet"
683  for (g = 0; g < num_bands; g++) {
684  AacPsyBand *band = &bands[g];
685 
686  band->thr_quiet = band->thr = FFMAX(band->thr, coeffs[g].ath);
687  //5.4.2.5 "Pre-echo control"
688  if (!(wi->window_type[0] == LONG_STOP_SEQUENCE || (!w && wi->window_type[1] == LONG_START_SEQUENCE)))
689  band->thr = FFMAX(PSY_3GPP_RPEMIN*band->thr, FFMIN(band->thr,
690  PSY_3GPP_RPELEV*pch->prev_band[w+g].thr_quiet));
691 
692  /* 5.6.1.3.1 "Preparatory steps of the perceptual entropy calculation" */
693  pe += calc_pe_3gpp(band);
694  a += band->pe_const;
695  active_lines += band->active_lines;
696 
697  /* 5.6.1.3.3 "Selection of the bands for avoidance of holes" */
698  if (spread_en[w+g] * avoid_hole_thr > band->energy || coeffs[g].min_snr > 1.0f)
699  band->avoid_holes = PSY_3GPP_AH_NONE;
700  else
701  band->avoid_holes = PSY_3GPP_AH_INACTIVE;
702  }
703  }
704 
705  /* 5.6.1.3.2 "Calculation of the desired perceptual entropy" */
706  ctx->ch[channel].entropy = pe;
707  if (ctx->avctx->flags & AV_CODEC_FLAG_QSCALE) {
708  /* (2.5 * 120) achieves almost transparent rate, and we want to give
709  * ample room downwards, so we make that equivalent to QSCALE=2.4
710  */
711  desired_pe = pe * (ctx->avctx->global_quality ? ctx->avctx->global_quality : 120) / (2 * 2.5f * 120.0f);
712  desired_bits = FFMIN(2560, PSY_3GPP_PE_TO_BITS(desired_pe));
713  desired_pe = PSY_3GPP_BITS_TO_PE(desired_bits); // reflect clipping
714 
715  /* PE slope smoothing */
716  if (ctx->bitres.bits > 0) {
717  desired_bits = FFMIN(2560, PSY_3GPP_PE_TO_BITS(desired_pe));
718  desired_pe = PSY_3GPP_BITS_TO_PE(desired_bits); // reflect clipping
719  }
720 
721  pctx->pe.max = FFMAX(pe, pctx->pe.max);
722  pctx->pe.min = FFMIN(pe, pctx->pe.min);
723  } else {
724  desired_bits = calc_bit_demand(pctx, pe, ctx->bitres.bits, ctx->bitres.size, wi->num_windows == 8);
725  desired_pe = PSY_3GPP_BITS_TO_PE(desired_bits);
726 
727  /* NOTE: PE correction is kept simple. During initial testing it had very
728  * little effect on the final bitrate. Probably a good idea to come
729  * back and do more testing later.
730  */
731  if (ctx->bitres.bits > 0)
732  desired_pe *= av_clipf(pctx->pe.previous / PSY_3GPP_BITS_TO_PE(ctx->bitres.bits),
733  0.85f, 1.15f);
734  }
735  pctx->pe.previous = PSY_3GPP_BITS_TO_PE(desired_bits);
736  ctx->bitres.alloc = desired_bits;
737 
738  if (desired_pe < pe) {
739  /* 5.6.1.3.4 "First Estimation of the reduction value" */
740  for (w = 0; w < wi->num_windows*16; w += 16) {
741  reduction = calc_reduction_3gpp(a, desired_pe, pe, active_lines);
742  pe = 0.0f;
743  a = 0.0f;
744  active_lines = 0.0f;
745  for (g = 0; g < num_bands; g++) {
746  AacPsyBand *band = &pch->band[w+g];
747 
748  band->thr = calc_reduced_thr_3gpp(band, coeffs[g].min_snr, reduction);
749  /* recalculate PE */
750  pe += calc_pe_3gpp(band);
751  a += band->pe_const;
752  active_lines += band->active_lines;
753  }
754  }
755 
756  /* 5.6.1.3.5 "Second Estimation of the reduction value" */
757  for (i = 0; i < 2; i++) {
758  float pe_no_ah = 0.0f, desired_pe_no_ah;
759  active_lines = a = 0.0f;
760  for (w = 0; w < wi->num_windows*16; w += 16) {
761  for (g = 0; g < num_bands; g++) {
762  AacPsyBand *band = &pch->band[w+g];
763 
764  if (band->avoid_holes != PSY_3GPP_AH_ACTIVE) {
765  pe_no_ah += band->pe;
766  a += band->pe_const;
767  active_lines += band->active_lines;
768  }
769  }
770  }
771  desired_pe_no_ah = FFMAX(desired_pe - (pe - pe_no_ah), 0.0f);
772  if (active_lines > 0.0f)
773  reduction = calc_reduction_3gpp(a, desired_pe_no_ah, pe_no_ah, active_lines);
774 
775  pe = 0.0f;
776  for (w = 0; w < wi->num_windows*16; w += 16) {
777  for (g = 0; g < num_bands; g++) {
778  AacPsyBand *band = &pch->band[w+g];
779 
780  if (active_lines > 0.0f)
781  band->thr = calc_reduced_thr_3gpp(band, coeffs[g].min_snr, reduction);
782  pe += calc_pe_3gpp(band);
783  if (band->thr > 0.0f)
784  band->norm_fac = band->active_lines / band->thr;
785  else
786  band->norm_fac = 0.0f;
787  norm_fac += band->norm_fac;
788  }
789  }
790  delta_pe = desired_pe - pe;
791  if (fabs(delta_pe) > 0.05f * desired_pe)
792  break;
793  }
794 
795  if (pe < 1.15f * desired_pe) {
796  /* 6.6.1.3.6 "Final threshold modification by linearization" */
797  norm_fac = norm_fac ? 1.0f / norm_fac : 0;
798  for (w = 0; w < wi->num_windows*16; w += 16) {
799  for (g = 0; g < num_bands; g++) {
800  AacPsyBand *band = &pch->band[w+g];
801 
802  if (band->active_lines > 0.5f) {
803  float delta_sfb_pe = band->norm_fac * norm_fac * delta_pe;
804  float thr = band->thr;
805 
806  thr *= exp2f(delta_sfb_pe / band->active_lines);
807  if (thr > coeffs[g].min_snr * band->energy && band->avoid_holes == PSY_3GPP_AH_INACTIVE)
808  thr = FFMAX(band->thr, coeffs[g].min_snr * band->energy);
809  band->thr = thr;
810  }
811  }
812  }
813  } else {
814  /* 5.6.1.3.7 "Further perceptual entropy reduction" */
815  g = num_bands;
816  while (pe > desired_pe && g--) {
817  for (w = 0; w < wi->num_windows*16; w+= 16) {
818  AacPsyBand *band = &pch->band[w+g];
819  if (band->avoid_holes != PSY_3GPP_AH_NONE && coeffs[g].min_snr < PSY_SNR_1DB) {
820  coeffs[g].min_snr = PSY_SNR_1DB;
821  band->thr = band->energy * PSY_SNR_1DB;
822  pe += band->active_lines * 1.5f - band->pe;
823  }
824  }
825  }
826  /* TODO: allow more holes (unused without mid/side) */
827  }
828  }
829 
830  for (w = 0; w < wi->num_windows*16; w += 16) {
831  for (g = 0; g < num_bands; g++) {
832  AacPsyBand *band = &pch->band[w+g];
833  FFPsyBand *psy_band = &ctx->ch[channel].psy_bands[w+g];
834 
835  psy_band->threshold = band->thr;
836  psy_band->energy = band->energy;
837  psy_band->spread = band->active_lines * 2.0f / band_sizes[g];
838  psy_band->bits = PSY_3GPP_PE_TO_BITS(band->pe);
839  }
840  }
841 
842  memcpy(pch->prev_band, pch->band, sizeof(pch->band));
843 }
844 
845  static void psy_3gpp_analyze(FFPsyContext *ctx, int channel,
846  const float **coeffs, const FFPsyWindowInfo *wi)
847 {
848  int ch;
849  FFPsyChannelGroup *group = ff_psy_find_group(ctx, channel);
850 
851  for (ch = 0; ch < group->num_ch; ch++)
852  psy_3gpp_analyze_channel(ctx, channel + ch, coeffs[ch], &wi[ch]);
853 }
854 
855  static av_cold void psy_3gpp_end(FFPsyContext *apc)
856 {
857  AacPsyContext *pctx = (AacPsyContext*) apc->model_priv_data;
858  if (pctx)
859  av_freep(&pctx->ch);
860  av_freep(&apc->model_priv_data);
861 }
862 
863  static void lame_apply_block_type(AacPsyChannel *ctx, FFPsyWindowInfo *wi, int uselongblock)
864 {
865  int blocktype = ONLY_LONG_SEQUENCE;
866  if (uselongblock) {
867  if (ctx->next_window_seq == EIGHT_SHORT_SEQUENCE)
868  blocktype = LONG_STOP_SEQUENCE;
869  } else {
870  blocktype = EIGHT_SHORT_SEQUENCE;
871  if (ctx->next_window_seq == ONLY_LONG_SEQUENCE)
872  ctx->next_window_seq = LONG_START_SEQUENCE;
873  if (ctx->next_window_seq == LONG_STOP_SEQUENCE)
874  ctx->next_window_seq = EIGHT_SHORT_SEQUENCE;
875  }
876 
877  wi->window_type[0] = ctx->next_window_seq;
878  ctx->next_window_seq = blocktype;
879 }
880 
881  static FFPsyWindowInfo psy_lame_window(FFPsyContext *ctx, const float *audio,
882  const float *la, int channel, int prev_type)
883 {
884  AacPsyContext *pctx = (AacPsyContext*) ctx->model_priv_data;
885  AacPsyChannel *pch = &pctx->ch[channel];
886  int grouping = 0;
887  int uselongblock = 1;
888  int attacks[AAC_NUM_BLOCKS_SHORT + 1] = { 0 };
889  int i;
890  FFPsyWindowInfo wi = { { 0 } };
891 
892  if (la) {
893  float hpfsmpl[AAC_BLOCK_SIZE_LONG];
894  const float *pf = hpfsmpl;
895  float attack_intensity[(AAC_NUM_BLOCKS_SHORT + 1) * PSY_LAME_NUM_SUBBLOCKS];
896  float energy_subshort[(AAC_NUM_BLOCKS_SHORT + 1) * PSY_LAME_NUM_SUBBLOCKS];
897  float energy_short[AAC_NUM_BLOCKS_SHORT + 1] = { 0 };
898  const float *firbuf = la + (AAC_BLOCK_SIZE_SHORT/4 - PSY_LAME_FIR_LEN);
899  int att_sum = 0;
900 
901  /* LAME comment: apply high pass filter of fs/4 */
902  psy_hp_filter(firbuf, hpfsmpl, psy_fir_coeffs);
903 
904  /* Calculate the energies of each sub-shortblock */
905  for (i = 0; i < PSY_LAME_NUM_SUBBLOCKS; i++) {
906  energy_subshort[i] = pch->prev_energy_subshort[i + ((AAC_NUM_BLOCKS_SHORT - 1) * PSY_LAME_NUM_SUBBLOCKS)];
907  assert(pch->prev_energy_subshort[i + ((AAC_NUM_BLOCKS_SHORT - 2) * PSY_LAME_NUM_SUBBLOCKS + 1)] > 0);
908  attack_intensity[i] = energy_subshort[i] / pch->prev_energy_subshort[i + ((AAC_NUM_BLOCKS_SHORT - 2) * PSY_LAME_NUM_SUBBLOCKS + 1)];
909  energy_short[0] += energy_subshort[i];
910  }
911 
912  for (i = 0; i < AAC_NUM_BLOCKS_SHORT * PSY_LAME_NUM_SUBBLOCKS; i++) {
913  const float *const pfe = pf + AAC_BLOCK_SIZE_LONG / (AAC_NUM_BLOCKS_SHORT * PSY_LAME_NUM_SUBBLOCKS);
914  float p = 1.0f;
915  for (; pf < pfe; pf++)
916  p = FFMAX(p, fabsf(*pf));
917  pch->prev_energy_subshort[i] = energy_subshort[i + PSY_LAME_NUM_SUBBLOCKS] = p;
918  energy_short[1 + i / PSY_LAME_NUM_SUBBLOCKS] += p;
919  /* NOTE: The indexes below are [i + 3 - 2] in the LAME source.
920  * Obviously the 3 and 2 have some significance, or this would be just [i + 1]
921  * (which is what we use here). What the 3 stands for is ambiguous, as it is both
922  * number of short blocks, and the number of sub-short blocks.
923  * It seems that LAME is comparing each sub-block to sub-block + 1 in the
924  * previous block.
925  */
926  if (p > energy_subshort[i + 1])
927  p = p / energy_subshort[i + 1];
928  else if (energy_subshort[i + 1] > p * 10.0f)
929  p = energy_subshort[i + 1] / (p * 10.0f);
930  else
931  p = 0.0;
932  attack_intensity[i + PSY_LAME_NUM_SUBBLOCKS] = p;
933  }
934 
935  /* compare energy between sub-short blocks */
936  for (i = 0; i < (AAC_NUM_BLOCKS_SHORT + 1) * PSY_LAME_NUM_SUBBLOCKS; i++)
937  if (!attacks[i / PSY_LAME_NUM_SUBBLOCKS])
938  if (attack_intensity[i] > pch->attack_threshold)
939  attacks[i / PSY_LAME_NUM_SUBBLOCKS] = (i % PSY_LAME_NUM_SUBBLOCKS) + 1;
940 
941  /* should have energy change between short blocks, in order to avoid periodic signals */
942  /* Good samples to show the effect are Trumpet test songs */
943  /* GB: tuned (1) to avoid too many short blocks for test sample TRUMPET */
944  /* RH: tuned (2) to let enough short blocks through for test sample FSOL and SNAPS */
945  for (i = 1; i < AAC_NUM_BLOCKS_SHORT + 1; i++) {
946  const float u = energy_short[i - 1];
947  const float v = energy_short[i];
948  const float m = FFMAX(u, v);
949  if (m < 40000) { /* (2) */
950  if (u < 1.7f * v && v < 1.7f * u) { /* (1) */
951  if (i == 1 && attacks[0] < attacks[i])
952  attacks[0] = 0;
953  attacks[i] = 0;
954  }
955  }
956  att_sum += attacks[i];
957  }
958 
959  if (attacks[0] <= pch->prev_attack)
960  attacks[0] = 0;
961 
962  att_sum += attacks[0];
963  /* 3 below indicates the previous attack happened in the last sub-block of the previous sequence */
964  if (pch->prev_attack == 3 || att_sum) {
965  uselongblock = 0;
966 
967  for (i = 1; i < AAC_NUM_BLOCKS_SHORT + 1; i++)
968  if (attacks[i] && attacks[i-1])
969  attacks[i] = 0;
970  }
971  } else {
972  /* We have no lookahead info, so just use same type as the previous sequence. */
973  uselongblock = !(prev_type == EIGHT_SHORT_SEQUENCE);
974  }
975 
976  lame_apply_block_type(pch, &wi, uselongblock);
977 
978  wi.window_type[1] = prev_type;
979  if (wi.window_type[0] != EIGHT_SHORT_SEQUENCE) {
980 
981  wi.num_windows = 1;
982  wi.grouping[0] = 1;
983  if (wi.window_type[0] == LONG_START_SEQUENCE)
984  wi.window_shape = 0;
985  else
986  wi.window_shape = 1;
987 
988  } else {
989  int lastgrp = 0;
990 
991  wi.num_windows = 8;
992  wi.window_shape = 0;
993  for (i = 0; i < 8; i++) {
994  if (!((pch->next_grouping >> i) & 1))
995  lastgrp = i;
996  wi.grouping[lastgrp]++;
997  }
998  }
999 
1000  /* Determine grouping, based on the location of the first attack, and save for
1001  * the next frame.
1002  * FIXME: Move this to analysis.
1003  * TODO: Tune groupings depending on attack location
1004  * TODO: Handle more than one attack in a group
1005  */
1006  for (i = 0; i < 9; i++) {
1007  if (attacks[i]) {
1008  grouping = i;
1009  break;
1010  }
1011  }
1012  pch->next_grouping = window_grouping[grouping];
1013 
1014  pch->prev_attack = attacks[8];
1015 
1016  return wi;
1017 }
1018 
1019  const FFPsyModel ff_aac_psy_model =
1020 {
1021  .name = "3GPP TS 26.403-inspired model",
1022  .init = psy_3gpp_init,
1023  .window = psy_lame_window,
1024  .analyze = psy_3gpp_analyze,
1025  .end = psy_3gpp_end,
1026 };
AacPsyCoeffs::spread_low
float spread_low[2]
spreading factor for low-to-high threshold spreading in long frame
Definition: aacpsy.c:144
ff_exp10
static av_always_inline double ff_exp10(double x)
Compute 10^x for floating point values.
Definition: ffmath.h:42
av_clip
#define av_clip
Definition: common.h:100
psy_3gpp_init
static av_cold int psy_3gpp_init(FFPsyContext *ctx)
Definition: aacpsy.c:298
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
psy_3gpp_window
static av_unused FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx, const int16_t *audio, const int16_t *la, int channel, int prev_type)
Tell encoder which window types to use.
Definition: aacpsy.c:405
lame_calc_attack_threshold
static float lame_calc_attack_threshold(int bitrate)
Calculate the ABR attack threshold from the above LAME psymodel table.
Definition: aacpsy.c:229
FFPsyModel::name
const char * name
Definition: psymodel.h:115
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:251
PSY_PE_FORGET_SLOPE
#define PSY_PE_FORGET_SLOPE
Definition: aacpsy.c:84
psy_lame_window
static FFPsyWindowInfo psy_lame_window(FFPsyContext *ctx, const float *audio, const float *la, int channel, int prev_type)
Definition: aacpsy.c:881
log2f
#define log2f(x)
Definition: libm.h:409
AacPsyBand::thr
float thr
energy threshold
Definition: aacpsy.c:111
calc_thr_3gpp
static void calc_thr_3gpp(const FFPsyWindowInfo *wi, const int num_bands, AacPsyChannel *pch, const uint8_t *band_sizes, const float *coefs, const int cutoff)
Definition: aacpsy.c:597
PSY_3GPP_PE_TO_BITS
#define PSY_3GPP_PE_TO_BITS(bits)
Definition: aacpsy.c:93
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
calc_bark
static av_cold float calc_bark(float f)
Calculate Bark value for given line.
Definition: aacpsy.c:279
AacPsyBand::nz_lines
float nz_lines
number of non-zero spectral lines
Definition: aacpsy.c:113
PSY_3GPP_AH_INACTIVE
@ PSY_3GPP_AH_INACTIVE
Definition: aacpsy.c:88
av_unused
#define av_unused
Definition: attributes.h:131
PSY_3GPP_CLIP_LO_S
#define PSY_3GPP_CLIP_LO_S
Definition: aacpsy.c:77
w
uint8_t w
Definition: llviddspenc.c:38
PSY_3GPP_AH_THR_LONG
#define PSY_3GPP_AH_THR_LONG
Definition: aacpsy.c:81
FFPsyWindowInfo::window_shape
int window_shape
window shape (sine/KBD/whatever)
Definition: psymodel.h:79
PSY_SNR_1DB
#define PSY_SNR_1DB
Definition: aacpsy.c:65
calc_pe_3gpp
static float calc_pe_3gpp(AacPsyBand *band)
Definition: aacpsy.c:534
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AacPsyContext::min
float min
minimum allowed PE for bit factor calculation
Definition: aacpsy.c:157
PSY_3GPP_SPEND_SLOPE_L
#define PSY_3GPP_SPEND_SLOPE_L
Definition: aacpsy.c:72
PSY_3GPP_THR_SPREAD_HI
#define PSY_3GPP_THR_SPREAD_HI
constants for 3GPP AAC psychoacoustic model
Definition: aacpsy.c:45
AacPsyContext::fill_level
int fill_level
bit reservoir fill level
Definition: aacpsy.c:155
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
AacPsyCoeffs::spread_hi
float spread_hi[2]
spreading factor for high-to-low threshold spreading in long frame
Definition: aacpsy.c:145
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
lame_apply_block_type
static void lame_apply_block_type(AacPsyChannel *ctx, FFPsyWindowInfo *wi, int uselongblock)
Definition: aacpsy.c:863
AacPsyCoeffs
psychoacoustic model frame type-dependent coefficients
Definition: aacpsy.c:141
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
lame_window_init
static av_cold void lame_window_init(AacPsyContext *ctx, AVCodecContext *avctx)
LAME psy model specific initialization.
Definition: aacpsy.c:259
PsyLamePreset::st_lrm
float st_lrm
short threshold for L, R, and M channels
Definition: aacpsy.c:175
PSY_3GPP_EN_SPREAD_HI_S
#define PSY_3GPP_EN_SPREAD_HI_S
Definition: aacpsy.c:52
PSY_3GPP_SPEND_ADD_L
#define PSY_3GPP_SPEND_ADD_L
Definition: aacpsy.c:74
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
AacPsyCoeffs::barks
float barks
Bark value for each spectral band in long frame.
Definition: aacpsy.c:143
AacPsyChannel::prev_energy_subshort
float prev_energy_subshort[AAC_NUM_BLOCKS_SHORT *PSY_LAME_NUM_SUBBLOCKS]
Definition: aacpsy.c:134
fabsf
static __device__ float fabsf(float a)
Definition: cuda_runtime.h:181
FFPsyWindowInfo
windowing related information
Definition: psymodel.h:77
ATH_ADD
#define ATH_ADD
Definition: aacpsy.c:284
AVFormatContext::bit_rate
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1429
AacPsyContext::previous
float previous
allowed PE of the previous frame
Definition: aacpsy.c:159
ff_aac_psy_model
const FFPsyModel ff_aac_psy_model
Definition: aacpsy.c:1019
AacPsyContext::ch
AacPsyChannel * ch
Definition: aacpsy.c:163
av_cold
#define av_cold
Definition: attributes.h:90
FFPsyChannelGroup::num_ch
uint8_t num_ch
number of channels in this group
Definition: psymodel.h:70
PsyLamePreset
LAME psy model preset struct.
Definition: aacpsy.c:170
PSY_3GPP_CLIP_HI_S
#define PSY_3GPP_CLIP_HI_S
Definition: aacpsy.c:79
s
#define s(width, name)
Definition: cbs_vp9.c:198
AacPsyBand
information for single band used by 3GPP TS26.403-inspired psychoacoustic model
Definition: aacpsy.c:109
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1249
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1438
bitrate
int64_t bitrate
Definition: av1_levels.c:47
g
const char * g
Definition: vf_curves.c:128
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:62
PsyLamePreset::quality
int quality
Quality to map the rest of the vaules to.
Definition: aacpsy.c:171
AacPsyBand::pe_const
float pe_const
constant part of the PE calculation
Definition: aacpsy.c:116
bits
uint8_t bits
Definition: vp3data.h:128
AacPsyContext
3GPP TS26.403-inspired psychoacoustic model specific data
Definition: aacpsy.c:152
PSY_3GPP_AH_NONE
@ PSY_3GPP_AH_NONE
Definition: aacpsy.c:87
AacPsyCoeffs::min_snr
float min_snr
minimal SNR
Definition: aacpsy.c:146
ctx
AVFormatContext * ctx
Definition: movenc.c:49
exp2f
#define exp2f(x)
Definition: libm.h:293
calc_reduction_3gpp
static float calc_reduction_3gpp(float a, float desired_pe, float pe, float active_lines)
Definition: aacpsy.c:557
window_grouping
static const uint8_t window_grouping[9]
window grouping information stored as bits (0 - new group, 1 - group continues)
Definition: aacpsy.c:397
AAC_BLOCK_SIZE_SHORT
#define AAC_BLOCK_SIZE_SHORT
short block size
Definition: aacpsy.c:98
bands
static const float bands[]
Definition: af_superequalizer.c:56
PSY_3GPP_AH_ACTIVE
@ PSY_3GPP_AH_ACTIVE
Definition: aacpsy.c:89
ath
static av_cold float ath(float f, float add)
Calculate ATH value for given frequency.
Definition: aacpsy.c:289
calc_bit_demand
static int calc_bit_demand(AacPsyContext *ctx, float pe, int bits, int size, int short_window)
Definition: aacpsy.c:491
NAN
#define NAN
Definition: mathematics.h:115
PSY_3GPP_AH_THR_SHORT
#define PSY_3GPP_AH_THR_SHORT
Definition: aacpsy.c:82
psy_hp_filter
static void psy_hp_filter(const float *firbuf, float *hpfsmpl, const float *psy_fir_coeffs)
Definition: aacpsy.c:628
if
if(ret)
Definition: filter_design.txt:179
iir_filter
static float iir_filter(int in, float state[2])
IIR filter used in block switching decision.
Definition: aacpsy.c:384
psy_vbr_map
static const PsyLamePreset psy_vbr_map[]
LAME psy model preset table for constant quality.
Definition: aacpsy.c:202
AAC_CUTOFF
#define AAC_CUTOFF(s)
Definition: psymodel.h:41
FFPsyWindowInfo::window_type
int window_type[3]
window type (short/long/transitional, etc.) - current, previous and next
Definition: psymodel.h:78
FFPsyBand::bits
int bits
Definition: psymodel.h:51
fabs
static __device__ float fabs(float a)
Definition: cuda_runtime.h:182
AacPsyContext::pe
struct AacPsyContext::@34 pe
PSY_3GPP_RPEMIN
#define PSY_3GPP_RPEMIN
Definition: aacpsy.c:58
psy_abr_map
static const PsyLamePreset psy_abr_map[]
LAME psy model preset table for ABR.
Definition: aacpsy.c:181
PSY_3GPP_C1
#define PSY_3GPP_C1
Definition: aacpsy.c:61
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
psy_3gpp_end
static av_cold void psy_3gpp_end(FFPsyContext *apc)
Definition: aacpsy.c:855
PSY_3GPP_BITS_TO_PE
#define PSY_3GPP_BITS_TO_PE(bits)
Definition: aacpsy.c:92
FFPsyBand
single band psychoacoustic information
Definition: psymodel.h:50
aac.h
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
FFPsyWindowInfo::grouping
int grouping[8]
window grouping (for e.g. AAC)
Definition: psymodel.h:81
av_clipf
av_clipf
Definition: af_crystalizer.c:122
AacPsyContext::max
float max
maximum allowed PE for bit factor calculation
Definition: aacpsy.c:158
exp
int8_t exp
Definition: eval.c:73
AacPsyChannel::iir_state
float iir_state[2]
hi-pass IIR filter state
Definition: aacpsy.c:129
AacPsyContext::psy_coef
AacPsyCoeffs psy_coef[2][64]
Definition: aacpsy.c:162
AacPsyBand::thr_quiet
float thr_quiet
threshold in quiet
Definition: aacpsy.c:112
AAC_BLOCK_SIZE_LONG
#define AAC_BLOCK_SIZE_LONG
long block size
Definition: aacpsy.c:97
f
f
Definition: af_crystalizer.c:122
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:60
AacPsyChannel::band
AacPsyBand band[128]
bands information
Definition: aacpsy.c:125
size
int size
Definition: twinvq_data.h:10344
calc_reduced_thr_3gpp
static float calc_reduced_thr_3gpp(AacPsyBand *band, float min_snr, float reduction)
Definition: aacpsy.c:571
AacPsyCoeffs::ath
float ath
absolute threshold of hearing per bands
Definition: aacpsy.c:142
AacPsyBand::active_lines
float active_lines
number of active spectral lines
Definition: aacpsy.c:114
AAC_NUM_BLOCKS_SHORT
#define AAC_NUM_BLOCKS_SHORT
number of blocks in a short sequence
Definition: aacpsy.c:99
PSY_LAME_FIR_LEN
#define PSY_LAME_FIR_LEN
LAME psy model FIR order.
Definition: aacpsy.c:96
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
PSY_3GPP_CLIP_LO_L
#define PSY_3GPP_CLIP_LO_L
Definition: aacpsy.c:76
attributes.h
AacPsyBand::avoid_holes
int avoid_holes
hole avoidance flag
Definition: aacpsy.c:118
PSY_3GPP_THR_SPREAD_LOW
#define PSY_3GPP_THR_SPREAD_LOW
Definition: aacpsy.c:46
PSY_3GPP_SAVE_ADD_S
#define PSY_3GPP_SAVE_ADD_S
Definition: aacpsy.c:71
PSY_3GPP_SPEND_ADD_S
#define PSY_3GPP_SPEND_ADD_S
Definition: aacpsy.c:75
psy_fir_coeffs
static const float psy_fir_coeffs[]
LAME psy model FIR coefficient table.
Definition: aacpsy.c:220
AacPsyChannel::attack_threshold
float attack_threshold
attack threshold for this channel
Definition: aacpsy.c:133
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AacPsyBand::norm_fac
float norm_fac
normalization factor for linearization
Definition: aacpsy.c:117
FFPsyBand::threshold
float threshold
Definition: psymodel.h:53
PSY_3GPP_CLIP_HI_L
#define PSY_3GPP_CLIP_HI_L
Definition: aacpsy.c:78
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:63
atanf
#define atanf(x)
Definition: libm.h:40
exp2
#define exp2(x)
Definition: libm.h:288
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
PSY_3GPP_RPELEV
#define PSY_3GPP_RPELEV
Definition: aacpsy.c:59
AacPsyBand::pe
float pe
perceptual entropy
Definition: aacpsy.c:115
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
AacPsyBand::energy
float energy
band energy
Definition: aacpsy.c:110
avcodec.h
FFPsyChannelGroup
psychoacoustic information for an arbitrary group of channels
Definition: psymodel.h:68
AacPsyChannel::next_window_seq
enum WindowSequence next_window_seq
window sequence to be used in the next frame
Definition: aacpsy.c:131
AacPsyChannel::win_energy
float win_energy
sliding average of channel energy
Definition: aacpsy.c:128
ret
ret
Definition: filter_design.txt:187
AacPsyChannel
single/pair channel context for psychoacoustic model
Definition: aacpsy.c:124
AacPsyContext::correction
float correction
PE correction factor.
Definition: aacpsy.c:160
FFPsyContext::model_priv_data
void * model_priv_data
psychoacoustic model implementation private data
Definition: psymodel.h:108
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:61
PSY_3GPP_SAVE_SLOPE_S
#define PSY_3GPP_SAVE_SLOPE_S
Definition: aacpsy.c:69
PSY_3GPP_EN_SPREAD_HI_L1
#define PSY_3GPP_EN_SPREAD_HI_L1
Definition: aacpsy.c:48
AacPsyChannel::next_grouping
uint8_t next_grouping
stored grouping scheme for the next frame (in case of 8 short window sequence)
Definition: aacpsy.c:130
FFPsyBand::energy
float energy
Definition: psymodel.h:52
AVCodecContext
main external API structure.
Definition: avcodec.h:451
PSY_LAME_NUM_SUBBLOCKS
#define PSY_LAME_NUM_SUBBLOCKS
Number of sub-blocks in each short block.
Definition: aacpsy.c:100
PSY_SNR_25DB
#define PSY_SNR_25DB
Definition: aacpsy.c:66
AacPsyContext::global_quality
float global_quality
normalized global quality taken from avctx
Definition: aacpsy.c:164
psy_3gpp_analyze_channel
static void psy_3gpp_analyze_channel(FFPsyContext *ctx, int channel, const float *coefs, const FFPsyWindowInfo *wi)
Calculate band thresholds as suggested in 3GPP TS26.403.
Definition: aacpsy.c:649
FFPsyModel
codec-specific psychoacoustic model implementation
Definition: psymodel.h:114
AacPsyContext::frame_bits
int frame_bits
average bits per frame
Definition: aacpsy.c:154
ffmath.h
ff_psy_find_group
FFPsyChannelGroup * ff_psy_find_group(FFPsyContext *ctx, int channel)
Determine what group a channel belongs to.
Definition: psymodel.c:73
psy_3gpp_analyze
static void psy_3gpp_analyze(FFPsyContext *ctx, int channel, const float **coeffs, const FFPsyWindowInfo *wi)
Definition: aacpsy.c:845
PSY_3GPP_C3
#define PSY_3GPP_C3
Definition: aacpsy.c:63
mem.h
PSY_3GPP_EN_SPREAD_LOW_L
#define PSY_3GPP_EN_SPREAD_LOW_L
Definition: aacpsy.c:54
AacPsyContext::chan_bitrate
int chan_bitrate
bitrate per channel
Definition: aacpsy.c:153
state
static struct @454 state
PSY_3GPP_SAVE_SLOPE_L
#define PSY_3GPP_SAVE_SLOPE_L
Definition: aacpsy.c:68
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
PSY_3GPP_C2
#define PSY_3GPP_C2
Definition: aacpsy.c:62
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:80
PSY_3GPP_SPEND_SLOPE_S
#define PSY_3GPP_SPEND_SLOPE_S
Definition: aacpsy.c:73
WindowSequence
WindowSequence
Definition: aac.h:59
FFPsyBand::spread
float spread
Definition: psymodel.h:54
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
PSY_3GPP_EN_SPREAD_LOW_S
#define PSY_3GPP_EN_SPREAD_LOW_S
Definition: aacpsy.c:56
AacPsyChannel::prev_attack
int prev_attack
attack value for the last short block in the previous sequence
Definition: aacpsy.c:135
FFPsyContext
context used by psychoacoustic model
Definition: psymodel.h:89
AacPsyChannel::prev_band
AacPsyBand prev_band[128]
bands information from the previous frame
Definition: aacpsy.c:126
psymodel.h
channel
channel
Definition: ebur128.h:39
FFPsyWindowInfo::num_windows
int num_windows
number of windows in a frame
Definition: psymodel.h:80
PSY_3GPP_SAVE_ADD_L
#define PSY_3GPP_SAVE_ADD_L
Definition: aacpsy.c:70
Generated on Fri Aug 22 2025 13:58:06 for FFmpeg by   doxygen 1.8.17

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