FFmpeg  4.3
aaccoder.c
Go to the documentation of this file.
1 /*
2  * AAC coefficients encoder
3  * Copyright (C) 2008-2009 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 coefficients encoder
25  */
26 
27 /***********************************
28  * TODOs:
29  * speedup quantizer selection
30  * add sane pulse detection
31  ***********************************/
32 
33 #include "libavutil/libm.h" // brought forward to work around cygwin header breakage
34 
35 #include <float.h>
36 
37 #include "libavutil/mathematics.h"
38 #include "mathops.h"
39 #include "avcodec.h"
40 #include "put_bits.h"
41 #include "aac.h"
42 #include "aacenc.h"
43 #include "aactab.h"
44 #include "aacenctab.h"
45 #include "aacenc_utils.h"
46 #include "aacenc_quantization.h"
47 
48 #include "aacenc_is.h"
49 #include "aacenc_tns.h"
50 #include "aacenc_ltp.h"
51 #include "aacenc_pred.h"
52 
54 
55 /* Parameter of f(x) = a*(lambda/100), defines the maximum fourier spread
56  * beyond which no PNS is used (since the SFBs contain tone rather than noise) */
57 #define NOISE_SPREAD_THRESHOLD 0.9f
58 
59 /* Parameter of f(x) = a*(100/lambda), defines how much PNS is allowed to
60  * replace low energy non zero bands */
61 #define NOISE_LAMBDA_REPLACE 1.948f
62 
64 
65 /**
66  * structure used in optimal codebook search
67  */
68 typedef struct BandCodingPath {
69  int prev_idx; ///< pointer to the previous path point
70  float cost; ///< path cost
71  int run;
73 
74 /**
75  * Encode band info for single window group bands.
76  */
78  int win, int group_len, const float lambda)
79 {
80  BandCodingPath path[120][CB_TOT_ALL];
81  int w, swb, cb, start, size;
82  int i, j;
83  const int max_sfb = sce->ics.max_sfb;
84  const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
85  const int run_esc = (1 << run_bits) - 1;
86  int idx, ppos, count;
87  int stackrun[120], stackcb[120], stack_len;
88  float next_minrd = INFINITY;
89  int next_mincb = 0;
90 
91  s->abs_pow34(s->scoefs, sce->coeffs, 1024);
92  start = win*128;
93  for (cb = 0; cb < CB_TOT_ALL; cb++) {
94  path[0][cb].cost = 0.0f;
95  path[0][cb].prev_idx = -1;
96  path[0][cb].run = 0;
97  }
98  for (swb = 0; swb < max_sfb; swb++) {
99  size = sce->ics.swb_sizes[swb];
100  if (sce->zeroes[win*16 + swb]) {
101  for (cb = 0; cb < CB_TOT_ALL; cb++) {
102  path[swb+1][cb].prev_idx = cb;
103  path[swb+1][cb].cost = path[swb][cb].cost;
104  path[swb+1][cb].run = path[swb][cb].run + 1;
105  }
106  } else {
107  float minrd = next_minrd;
108  int mincb = next_mincb;
109  next_minrd = INFINITY;
110  next_mincb = 0;
111  for (cb = 0; cb < CB_TOT_ALL; cb++) {
112  float cost_stay_here, cost_get_here;
113  float rd = 0.0f;
114  if (cb >= 12 && sce->band_type[win*16+swb] < aac_cb_out_map[cb] ||
115  cb < aac_cb_in_map[sce->band_type[win*16+swb]] && sce->band_type[win*16+swb] > aac_cb_out_map[cb]) {
116  path[swb+1][cb].prev_idx = -1;
117  path[swb+1][cb].cost = INFINITY;
118  path[swb+1][cb].run = path[swb][cb].run + 1;
119  continue;
120  }
121  for (w = 0; w < group_len; w++) {
122  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(win+w)*16+swb];
123  rd += quantize_band_cost(s, &sce->coeffs[start + w*128],
124  &s->scoefs[start + w*128], size,
125  sce->sf_idx[(win+w)*16+swb], aac_cb_out_map[cb],
126  lambda / band->threshold, INFINITY, NULL, NULL, 0);
127  }
128  cost_stay_here = path[swb][cb].cost + rd;
129  cost_get_here = minrd + rd + run_bits + 4;
130  if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
131  != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
132  cost_stay_here += run_bits;
133  if (cost_get_here < cost_stay_here) {
134  path[swb+1][cb].prev_idx = mincb;
135  path[swb+1][cb].cost = cost_get_here;
136  path[swb+1][cb].run = 1;
137  } else {
138  path[swb+1][cb].prev_idx = cb;
139  path[swb+1][cb].cost = cost_stay_here;
140  path[swb+1][cb].run = path[swb][cb].run + 1;
141  }
142  if (path[swb+1][cb].cost < next_minrd) {
143  next_minrd = path[swb+1][cb].cost;
144  next_mincb = cb;
145  }
146  }
147  }
148  start += sce->ics.swb_sizes[swb];
149  }
150 
151  //convert resulting path from backward-linked list
152  stack_len = 0;
153  idx = 0;
154  for (cb = 1; cb < CB_TOT_ALL; cb++)
155  if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
156  idx = cb;
157  ppos = max_sfb;
158  while (ppos > 0) {
159  av_assert1(idx >= 0);
160  cb = idx;
161  stackrun[stack_len] = path[ppos][cb].run;
162  stackcb [stack_len] = cb;
163  idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
164  ppos -= path[ppos][cb].run;
165  stack_len++;
166  }
167  //perform actual band info encoding
168  start = 0;
169  for (i = stack_len - 1; i >= 0; i--) {
170  cb = aac_cb_out_map[stackcb[i]];
171  put_bits(&s->pb, 4, cb);
172  count = stackrun[i];
173  memset(sce->zeroes + win*16 + start, !cb, count);
174  //XXX: memset when band_type is also uint8_t
175  for (j = 0; j < count; j++) {
176  sce->band_type[win*16 + start] = cb;
177  start++;
178  }
179  while (count >= run_esc) {
180  put_bits(&s->pb, run_bits, run_esc);
181  count -= run_esc;
182  }
183  put_bits(&s->pb, run_bits, count);
184  }
185 }
186 
187 
188 typedef struct TrellisPath {
189  float cost;
190  int prev;
191 } TrellisPath;
192 
193 #define TRELLIS_STAGES 121
194 #define TRELLIS_STATES (SCALE_MAX_DIFF+1)
195 
197 {
198  int w, g;
199  int prevscaler_n = -255, prevscaler_i = 0;
200  int bands = 0;
201 
202  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
203  for (g = 0; g < sce->ics.num_swb; g++) {
204  if (sce->zeroes[w*16+g])
205  continue;
206  if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {
207  sce->sf_idx[w*16+g] = av_clip(roundf(log2f(sce->is_ener[w*16+g])*2), -155, 100);
208  bands++;
209  } else if (sce->band_type[w*16+g] == NOISE_BT) {
210  sce->sf_idx[w*16+g] = av_clip(3+ceilf(log2f(sce->pns_ener[w*16+g])*2), -100, 155);
211  if (prevscaler_n == -255)
212  prevscaler_n = sce->sf_idx[w*16+g];
213  bands++;
214  }
215  }
216  }
217 
218  if (!bands)
219  return;
220 
221  /* Clip the scalefactor indices */
222  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
223  for (g = 0; g < sce->ics.num_swb; g++) {
224  if (sce->zeroes[w*16+g])
225  continue;
226  if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {
227  sce->sf_idx[w*16+g] = prevscaler_i = av_clip(sce->sf_idx[w*16+g], prevscaler_i - SCALE_MAX_DIFF, prevscaler_i + SCALE_MAX_DIFF);
228  } else if (sce->band_type[w*16+g] == NOISE_BT) {
229  sce->sf_idx[w*16+g] = prevscaler_n = av_clip(sce->sf_idx[w*16+g], prevscaler_n - SCALE_MAX_DIFF, prevscaler_n + SCALE_MAX_DIFF);
230  }
231  }
232  }
233 }
234 
237  const float lambda)
238 {
239  int q, w, w2, g, start = 0;
240  int i, j;
241  int idx;
243  int bandaddr[TRELLIS_STAGES];
244  int minq;
245  float mincost;
246  float q0f = FLT_MAX, q1f = 0.0f, qnrgf = 0.0f;
247  int q0, q1, qcnt = 0;
248 
249  for (i = 0; i < 1024; i++) {
250  float t = fabsf(sce->coeffs[i]);
251  if (t > 0.0f) {
252  q0f = FFMIN(q0f, t);
253  q1f = FFMAX(q1f, t);
254  qnrgf += t*t;
255  qcnt++;
256  }
257  }
258 
259  if (!qcnt) {
260  memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
261  memset(sce->zeroes, 1, sizeof(sce->zeroes));
262  return;
263  }
264 
265  //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
266  q0 = av_clip(coef2minsf(q0f), 0, SCALE_MAX_POS-1);
267  //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
268  q1 = av_clip(coef2maxsf(q1f), 1, SCALE_MAX_POS);
269  if (q1 - q0 > 60) {
270  int q0low = q0;
271  int q1high = q1;
272  //minimum scalefactor index is when maximum nonzero coefficient after quantizing is not clipped
273  int qnrg = av_clip_uint8(log2f(sqrtf(qnrgf/qcnt))*4 - 31 + SCALE_ONE_POS - SCALE_DIV_512);
274  q1 = qnrg + 30;
275  q0 = qnrg - 30;
276  if (q0 < q0low) {
277  q1 += q0low - q0;
278  q0 = q0low;
279  } else if (q1 > q1high) {
280  q0 -= q1 - q1high;
281  q1 = q1high;
282  }
283  }
284  // q0 == q1 isn't really a legal situation
285  if (q0 == q1) {
286  // the following is indirect but guarantees q1 != q0 && q1 near q0
287  q1 = av_clip(q0+1, 1, SCALE_MAX_POS);
288  q0 = av_clip(q1-1, 0, SCALE_MAX_POS - 1);
289  }
290 
291  for (i = 0; i < TRELLIS_STATES; i++) {
292  paths[0][i].cost = 0.0f;
293  paths[0][i].prev = -1;
294  }
295  for (j = 1; j < TRELLIS_STAGES; j++) {
296  for (i = 0; i < TRELLIS_STATES; i++) {
297  paths[j][i].cost = INFINITY;
298  paths[j][i].prev = -2;
299  }
300  }
301  idx = 1;
302  s->abs_pow34(s->scoefs, sce->coeffs, 1024);
303  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
304  start = w*128;
305  for (g = 0; g < sce->ics.num_swb; g++) {
306  const float *coefs = &sce->coeffs[start];
307  float qmin, qmax;
308  int nz = 0;
309 
310  bandaddr[idx] = w * 16 + g;
311  qmin = INT_MAX;
312  qmax = 0.0f;
313  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
314  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
315  if (band->energy <= band->threshold || band->threshold == 0.0f) {
316  sce->zeroes[(w+w2)*16+g] = 1;
317  continue;
318  }
319  sce->zeroes[(w+w2)*16+g] = 0;
320  nz = 1;
321  for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
322  float t = fabsf(coefs[w2*128+i]);
323  if (t > 0.0f)
324  qmin = FFMIN(qmin, t);
325  qmax = FFMAX(qmax, t);
326  }
327  }
328  if (nz) {
329  int minscale, maxscale;
330  float minrd = INFINITY;
331  float maxval;
332  //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
333  minscale = coef2minsf(qmin);
334  //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
335  maxscale = coef2maxsf(qmax);
336  minscale = av_clip(minscale - q0, 0, TRELLIS_STATES - 1);
337  maxscale = av_clip(maxscale - q0, 0, TRELLIS_STATES);
338  if (minscale == maxscale) {
339  maxscale = av_clip(minscale+1, 1, TRELLIS_STATES);
340  minscale = av_clip(maxscale-1, 0, TRELLIS_STATES - 1);
341  }
342  maxval = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], s->scoefs+start);
343  for (q = minscale; q < maxscale; q++) {
344  float dist = 0;
345  int cb = find_min_book(maxval, sce->sf_idx[w*16+g]);
346  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
347  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
348  dist += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],
349  q + q0, cb, lambda / band->threshold, INFINITY, NULL, NULL, 0);
350  }
351  minrd = FFMIN(minrd, dist);
352 
353  for (i = 0; i < q1 - q0; i++) {
354  float cost;
355  cost = paths[idx - 1][i].cost + dist
357  if (cost < paths[idx][q].cost) {
358  paths[idx][q].cost = cost;
359  paths[idx][q].prev = i;
360  }
361  }
362  }
363  } else {
364  for (q = 0; q < q1 - q0; q++) {
365  paths[idx][q].cost = paths[idx - 1][q].cost + 1;
366  paths[idx][q].prev = q;
367  }
368  }
369  sce->zeroes[w*16+g] = !nz;
370  start += sce->ics.swb_sizes[g];
371  idx++;
372  }
373  }
374  idx--;
375  mincost = paths[idx][0].cost;
376  minq = 0;
377  for (i = 1; i < TRELLIS_STATES; i++) {
378  if (paths[idx][i].cost < mincost) {
379  mincost = paths[idx][i].cost;
380  minq = i;
381  }
382  }
383  while (idx) {
384  sce->sf_idx[bandaddr[idx]] = minq + q0;
385  minq = FFMAX(paths[idx][minq].prev, 0);
386  idx--;
387  }
388  //set the same quantizers inside window groups
389  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
390  for (g = 0; g < sce->ics.num_swb; g++)
391  for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
392  sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
393 }
394 
397  const float lambda)
398 {
399  int start = 0, i, w, w2, g;
400  int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);
401  float dists[128] = { 0 }, uplims[128] = { 0 };
402  float maxvals[128];
403  int fflag, minscaler;
404  int its = 0;
405  int allz = 0;
406  float minthr = INFINITY;
407 
408  // for values above this the decoder might end up in an endless loop
409  // due to always having more bits than what can be encoded.
410  destbits = FFMIN(destbits, 5800);
411  //some heuristic to determine initial quantizers will reduce search time
412  //determine zero bands and upper limits
413  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
414  start = 0;
415  for (g = 0; g < sce->ics.num_swb; g++) {
416  int nz = 0;
417  float uplim = 0.0f, energy = 0.0f;
418  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
419  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
420  uplim += band->threshold;
421  energy += band->energy;
422  if (band->energy <= band->threshold || band->threshold == 0.0f) {
423  sce->zeroes[(w+w2)*16+g] = 1;
424  continue;
425  }
426  nz = 1;
427  }
428  uplims[w*16+g] = uplim *512;
429  sce->band_type[w*16+g] = 0;
430  sce->zeroes[w*16+g] = !nz;
431  if (nz)
432  minthr = FFMIN(minthr, uplim);
433  allz |= nz;
434  start += sce->ics.swb_sizes[g];
435  }
436  }
437  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
438  for (g = 0; g < sce->ics.num_swb; g++) {
439  if (sce->zeroes[w*16+g]) {
440  sce->sf_idx[w*16+g] = SCALE_ONE_POS;
441  continue;
442  }
443  sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);
444  }
445  }
446 
447  if (!allz)
448  return;
449  s->abs_pow34(s->scoefs, sce->coeffs, 1024);
451 
452  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
453  start = w*128;
454  for (g = 0; g < sce->ics.num_swb; g++) {
455  const float *scaled = s->scoefs + start;
456  maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);
457  start += sce->ics.swb_sizes[g];
458  }
459  }
460 
461  //perform two-loop search
462  //outer loop - improve quality
463  do {
464  int tbits, qstep;
465  minscaler = sce->sf_idx[0];
466  //inner loop - quantize spectrum to fit into given number of bits
467  qstep = its ? 1 : 32;
468  do {
469  int prev = -1;
470  tbits = 0;
471  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
472  start = w*128;
473  for (g = 0; g < sce->ics.num_swb; g++) {
474  const float *coefs = sce->coeffs + start;
475  const float *scaled = s->scoefs + start;
476  int bits = 0;
477  int cb;
478  float dist = 0.0f;
479 
480  if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {
481  start += sce->ics.swb_sizes[g];
482  continue;
483  }
484  minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
485  cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
486  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
487  int b;
488  dist += quantize_band_cost_cached(s, w + w2, g,
489  coefs + w2*128,
490  scaled + w2*128,
491  sce->ics.swb_sizes[g],
492  sce->sf_idx[w*16+g],
493  cb, 1.0f, INFINITY,
494  &b, NULL, 0);
495  bits += b;
496  }
497  dists[w*16+g] = dist - bits;
498  if (prev != -1) {
499  bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
500  }
501  tbits += bits;
502  start += sce->ics.swb_sizes[g];
503  prev = sce->sf_idx[w*16+g];
504  }
505  }
506  if (tbits > destbits) {
507  for (i = 0; i < 128; i++)
508  if (sce->sf_idx[i] < 218 - qstep)
509  sce->sf_idx[i] += qstep;
510  } else {
511  for (i = 0; i < 128; i++)
512  if (sce->sf_idx[i] > 60 - qstep)
513  sce->sf_idx[i] -= qstep;
514  }
515  qstep >>= 1;
516  if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)
517  qstep = 1;
518  } while (qstep);
519 
520  fflag = 0;
521  minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
522 
523  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
524  for (g = 0; g < sce->ics.num_swb; g++) {
525  int prevsc = sce->sf_idx[w*16+g];
526  if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {
527  if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))
528  sce->sf_idx[w*16+g]--;
529  else //Try to make sure there is some energy in every band
530  sce->sf_idx[w*16+g]-=2;
531  }
532  sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
533  sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);
534  if (sce->sf_idx[w*16+g] != prevsc)
535  fflag = 1;
536  sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
537  }
538  }
539  its++;
540  } while (fflag && its < 10);
541 }
542 
544 {
545  FFPsyBand *band;
546  int w, g, w2, i;
547  int wlen = 1024 / sce->ics.num_windows;
548  int bandwidth, cutoff;
549  float *PNS = &s->scoefs[0*128], *PNS34 = &s->scoefs[1*128];
550  float *NOR34 = &s->scoefs[3*128];
551  uint8_t nextband[128];
552  const float lambda = s->lambda;
553  const float freq_mult = avctx->sample_rate*0.5f/wlen;
554  const float thr_mult = NOISE_LAMBDA_REPLACE*(100.0f/lambda);
555  const float spread_threshold = FFMIN(0.75f, NOISE_SPREAD_THRESHOLD*FFMAX(0.5f, lambda/100.f));
556  const float dist_bias = av_clipf(4.f * 120 / lambda, 0.25f, 4.0f);
557  const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);
558 
559  int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate
560  / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
561  * (lambda / 120.f);
562 
563  /** Keep this in sync with twoloop's cutoff selection */
564  float rate_bandwidth_multiplier = 1.5f;
565  int prev = -1000, prev_sf = -1;
566  int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)
567  ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)
568  : (avctx->bit_rate / avctx->channels);
569 
570  frame_bit_rate *= 1.15f;
571 
572  if (avctx->cutoff > 0) {
573  bandwidth = avctx->cutoff;
574  } else {
575  bandwidth = FFMAX(3000, AAC_CUTOFF_FROM_BITRATE(frame_bit_rate, 1, avctx->sample_rate));
576  }
577 
578  cutoff = bandwidth * 2 * wlen / avctx->sample_rate;
579 
580  memcpy(sce->band_alt, sce->band_type, sizeof(sce->band_type));
581  ff_init_nextband_map(sce, nextband);
582  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
583  int wstart = w*128;
584  for (g = 0; g < sce->ics.num_swb; g++) {
585  int noise_sfi;
586  float dist1 = 0.0f, dist2 = 0.0f, noise_amp;
587  float pns_energy = 0.0f, pns_tgt_energy, energy_ratio, dist_thresh;
588  float sfb_energy = 0.0f, threshold = 0.0f, spread = 2.0f;
589  float min_energy = -1.0f, max_energy = 0.0f;
590  const int start = wstart+sce->ics.swb_offset[g];
591  const float freq = (start-wstart)*freq_mult;
592  const float freq_boost = FFMAX(0.88f*freq/NOISE_LOW_LIMIT, 1.0f);
593  if (freq < NOISE_LOW_LIMIT || (start-wstart) >= cutoff) {
594  if (!sce->zeroes[w*16+g])
595  prev_sf = sce->sf_idx[w*16+g];
596  continue;
597  }
598  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
599  band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
600  sfb_energy += band->energy;
601  spread = FFMIN(spread, band->spread);
602  threshold += band->threshold;
603  if (!w2) {
604  min_energy = max_energy = band->energy;
605  } else {
606  min_energy = FFMIN(min_energy, band->energy);
607  max_energy = FFMAX(max_energy, band->energy);
608  }
609  }
610 
611  /* Ramps down at ~8000Hz and loosens the dist threshold */
612  dist_thresh = av_clipf(2.5f*NOISE_LOW_LIMIT/freq, 0.5f, 2.5f) * dist_bias;
613 
614  /* PNS is acceptable when all of these are true:
615  * 1. high spread energy (noise-like band)
616  * 2. near-threshold energy (high PE means the random nature of PNS content will be noticed)
617  * 3. on short window groups, all windows have similar energy (variations in energy would be destroyed by PNS)
618  *
619  * At this stage, point 2 is relaxed for zeroed bands near the noise threshold (hole avoidance is more important)
620  */
621  if ((!sce->zeroes[w*16+g] && !ff_sfdelta_can_remove_band(sce, nextband, prev_sf, w*16+g)) ||
622  ((sce->zeroes[w*16+g] || !sce->band_alt[w*16+g]) && sfb_energy < threshold*sqrtf(1.0f/freq_boost)) || spread < spread_threshold ||
623  (!sce->zeroes[w*16+g] && sce->band_alt[w*16+g] && sfb_energy > threshold*thr_mult*freq_boost) ||
624  min_energy < pns_transient_energy_r * max_energy ) {
625  sce->pns_ener[w*16+g] = sfb_energy;
626  if (!sce->zeroes[w*16+g])
627  prev_sf = sce->sf_idx[w*16+g];
628  continue;
629  }
630 
631  pns_tgt_energy = sfb_energy*FFMIN(1.0f, spread*spread);
632  noise_sfi = av_clip(roundf(log2f(pns_tgt_energy)*2), -100, 155); /* Quantize */
633  noise_amp = -ff_aac_pow2sf_tab[noise_sfi + POW_SF2_ZERO]; /* Dequantize */
634  if (prev != -1000) {
635  int noise_sfdiff = noise_sfi - prev + SCALE_DIFF_ZERO;
636  if (noise_sfdiff < 0 || noise_sfdiff > 2*SCALE_MAX_DIFF) {
637  if (!sce->zeroes[w*16+g])
638  prev_sf = sce->sf_idx[w*16+g];
639  continue;
640  }
641  }
642  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
643  float band_energy, scale, pns_senergy;
644  const int start_c = (w+w2)*128+sce->ics.swb_offset[g];
645  band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
646  for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
647  s->random_state = lcg_random(s->random_state);
648  PNS[i] = s->random_state;
649  }
650  band_energy = s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);
651  scale = noise_amp/sqrtf(band_energy);
652  s->fdsp->vector_fmul_scalar(PNS, PNS, scale, sce->ics.swb_sizes[g]);
653  pns_senergy = s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);
654  pns_energy += pns_senergy;
655  s->abs_pow34(NOR34, &sce->coeffs[start_c], sce->ics.swb_sizes[g]);
656  s->abs_pow34(PNS34, PNS, sce->ics.swb_sizes[g]);
657  dist1 += quantize_band_cost(s, &sce->coeffs[start_c],
658  NOR34,
659  sce->ics.swb_sizes[g],
660  sce->sf_idx[(w+w2)*16+g],
661  sce->band_alt[(w+w2)*16+g],
662  lambda/band->threshold, INFINITY, NULL, NULL, 0);
663  /* Estimate rd on average as 5 bits for SF, 4 for the CB, plus spread energy * lambda/thr */
664  dist2 += band->energy/(band->spread*band->spread)*lambda*dist_thresh/band->threshold;
665  }
666  if (g && sce->band_type[w*16+g-1] == NOISE_BT) {
667  dist2 += 5;
668  } else {
669  dist2 += 9;
670  }
671  energy_ratio = pns_tgt_energy/pns_energy; /* Compensates for quantization error */
672  sce->pns_ener[w*16+g] = energy_ratio*pns_tgt_energy;
673  if (sce->zeroes[w*16+g] || !sce->band_alt[w*16+g] || (energy_ratio > 0.85f && energy_ratio < 1.25f && dist2 < dist1)) {
674  sce->band_type[w*16+g] = NOISE_BT;
675  sce->zeroes[w*16+g] = 0;
676  prev = noise_sfi;
677  } else {
678  if (!sce->zeroes[w*16+g])
679  prev_sf = sce->sf_idx[w*16+g];
680  }
681  }
682  }
683 }
684 
686 {
687  FFPsyBand *band;
688  int w, g, w2;
689  int wlen = 1024 / sce->ics.num_windows;
690  int bandwidth, cutoff;
691  const float lambda = s->lambda;
692  const float freq_mult = avctx->sample_rate*0.5f/wlen;
693  const float spread_threshold = FFMIN(0.75f, NOISE_SPREAD_THRESHOLD*FFMAX(0.5f, lambda/100.f));
694  const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);
695 
696  int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate
697  / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->channels)
698  * (lambda / 120.f);
699 
700  /** Keep this in sync with twoloop's cutoff selection */
701  float rate_bandwidth_multiplier = 1.5f;
702  int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)
703  ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)
704  : (avctx->bit_rate / avctx->channels);
705 
706  frame_bit_rate *= 1.15f;
707 
708  if (avctx->cutoff > 0) {
709  bandwidth = avctx->cutoff;
710  } else {
711  bandwidth = FFMAX(3000, AAC_CUTOFF_FROM_BITRATE(frame_bit_rate, 1, avctx->sample_rate));
712  }
713 
714  cutoff = bandwidth * 2 * wlen / avctx->sample_rate;
715 
716  memcpy(sce->band_alt, sce->band_type, sizeof(sce->band_type));
717  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
718  for (g = 0; g < sce->ics.num_swb; g++) {
719  float sfb_energy = 0.0f, threshold = 0.0f, spread = 2.0f;
720  float min_energy = -1.0f, max_energy = 0.0f;
721  const int start = sce->ics.swb_offset[g];
722  const float freq = start*freq_mult;
723  const float freq_boost = FFMAX(0.88f*freq/NOISE_LOW_LIMIT, 1.0f);
724  if (freq < NOISE_LOW_LIMIT || start >= cutoff) {
725  sce->can_pns[w*16+g] = 0;
726  continue;
727  }
728  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
729  band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
730  sfb_energy += band->energy;
731  spread = FFMIN(spread, band->spread);
732  threshold += band->threshold;
733  if (!w2) {
734  min_energy = max_energy = band->energy;
735  } else {
736  min_energy = FFMIN(min_energy, band->energy);
737  max_energy = FFMAX(max_energy, band->energy);
738  }
739  }
740 
741  /* PNS is acceptable when all of these are true:
742  * 1. high spread energy (noise-like band)
743  * 2. near-threshold energy (high PE means the random nature of PNS content will be noticed)
744  * 3. on short window groups, all windows have similar energy (variations in energy would be destroyed by PNS)
745  */
746  sce->pns_ener[w*16+g] = sfb_energy;
747  if (sfb_energy < threshold*sqrtf(1.5f/freq_boost) || spread < spread_threshold || min_energy < pns_transient_energy_r * max_energy) {
748  sce->can_pns[w*16+g] = 0;
749  } else {
750  sce->can_pns[w*16+g] = 1;
751  }
752  }
753  }
754 }
755 
757 {
758  int start = 0, i, w, w2, g, sid_sf_boost, prev_mid, prev_side;
759  uint8_t nextband0[128], nextband1[128];
760  float *M = s->scoefs + 128*0, *S = s->scoefs + 128*1;
761  float *L34 = s->scoefs + 128*2, *R34 = s->scoefs + 128*3;
762  float *M34 = s->scoefs + 128*4, *S34 = s->scoefs + 128*5;
763  const float lambda = s->lambda;
764  const float mslambda = FFMIN(1.0f, lambda / 120.f);
765  SingleChannelElement *sce0 = &cpe->ch[0];
766  SingleChannelElement *sce1 = &cpe->ch[1];
767  if (!cpe->common_window)
768  return;
769 
770  /** Scout out next nonzero bands */
771  ff_init_nextband_map(sce0, nextband0);
772  ff_init_nextband_map(sce1, nextband1);
773 
774  prev_mid = sce0->sf_idx[0];
775  prev_side = sce1->sf_idx[0];
776  for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
777  start = 0;
778  for (g = 0; g < sce0->ics.num_swb; g++) {
779  float bmax = bval2bmax(g * 17.0f / sce0->ics.num_swb) / 0.0045f;
780  if (!cpe->is_mask[w*16+g])
781  cpe->ms_mask[w*16+g] = 0;
782  if (!sce0->zeroes[w*16+g] && !sce1->zeroes[w*16+g] && !cpe->is_mask[w*16+g]) {
783  float Mmax = 0.0f, Smax = 0.0f;
784 
785  /* Must compute mid/side SF and book for the whole window group */
786  for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
787  for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
788  M[i] = (sce0->coeffs[start+(w+w2)*128+i]
789  + sce1->coeffs[start+(w+w2)*128+i]) * 0.5;
790  S[i] = M[i]
791  - sce1->coeffs[start+(w+w2)*128+i];
792  }
793  s->abs_pow34(M34, M, sce0->ics.swb_sizes[g]);
794  s->abs_pow34(S34, S, sce0->ics.swb_sizes[g]);
795  for (i = 0; i < sce0->ics.swb_sizes[g]; i++ ) {
796  Mmax = FFMAX(Mmax, M34[i]);
797  Smax = FFMAX(Smax, S34[i]);
798  }
799  }
800 
801  for (sid_sf_boost = 0; sid_sf_boost < 4; sid_sf_boost++) {
802  float dist1 = 0.0f, dist2 = 0.0f;
803  int B0 = 0, B1 = 0;
804  int minidx;
805  int mididx, sididx;
806  int midcb, sidcb;
807 
808  minidx = FFMIN(sce0->sf_idx[w*16+g], sce1->sf_idx[w*16+g]);
809  mididx = av_clip(minidx, 0, SCALE_MAX_POS - SCALE_DIV_512);
810  sididx = av_clip(minidx - sid_sf_boost * 3, 0, SCALE_MAX_POS - SCALE_DIV_512);
811  if (sce0->band_type[w*16+g] != NOISE_BT && sce1->band_type[w*16+g] != NOISE_BT
812  && ( !ff_sfdelta_can_replace(sce0, nextband0, prev_mid, mididx, w*16+g)
813  || !ff_sfdelta_can_replace(sce1, nextband1, prev_side, sididx, w*16+g))) {
814  /* scalefactor range violation, bad stuff, will decrease quality unacceptably */
815  continue;
816  }
817 
818  midcb = find_min_book(Mmax, mididx);
819  sidcb = find_min_book(Smax, sididx);
820 
821  /* No CB can be zero */
822  midcb = FFMAX(1,midcb);
823  sidcb = FFMAX(1,sidcb);
824 
825  for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
826  FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];
827  FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];
828  float minthr = FFMIN(band0->threshold, band1->threshold);
829  int b1,b2,b3,b4;
830  for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
831  M[i] = (sce0->coeffs[start+(w+w2)*128+i]
832  + sce1->coeffs[start+(w+w2)*128+i]) * 0.5;
833  S[i] = M[i]
834  - sce1->coeffs[start+(w+w2)*128+i];
835  }
836 
837  s->abs_pow34(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);
838  s->abs_pow34(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);
839  s->abs_pow34(M34, M, sce0->ics.swb_sizes[g]);
840  s->abs_pow34(S34, S, sce0->ics.swb_sizes[g]);
841  dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],
842  L34,
843  sce0->ics.swb_sizes[g],
844  sce0->sf_idx[w*16+g],
845  sce0->band_type[w*16+g],
846  lambda / band0->threshold, INFINITY, &b1, NULL, 0);
847  dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],
848  R34,
849  sce1->ics.swb_sizes[g],
850  sce1->sf_idx[w*16+g],
851  sce1->band_type[w*16+g],
852  lambda / band1->threshold, INFINITY, &b2, NULL, 0);
853  dist2 += quantize_band_cost(s, M,
854  M34,
855  sce0->ics.swb_sizes[g],
856  mididx,
857  midcb,
858  lambda / minthr, INFINITY, &b3, NULL, 0);
859  dist2 += quantize_band_cost(s, S,
860  S34,
861  sce1->ics.swb_sizes[g],
862  sididx,
863  sidcb,
864  mslambda / (minthr * bmax), INFINITY, &b4, NULL, 0);
865  B0 += b1+b2;
866  B1 += b3+b4;
867  dist1 -= b1+b2;
868  dist2 -= b3+b4;
869  }
870  cpe->ms_mask[w*16+g] = dist2 <= dist1 && B1 < B0;
871  if (cpe->ms_mask[w*16+g]) {
872  if (sce0->band_type[w*16+g] != NOISE_BT && sce1->band_type[w*16+g] != NOISE_BT) {
873  sce0->sf_idx[w*16+g] = mididx;
874  sce1->sf_idx[w*16+g] = sididx;
875  sce0->band_type[w*16+g] = midcb;
876  sce1->band_type[w*16+g] = sidcb;
877  } else if ((sce0->band_type[w*16+g] != NOISE_BT) ^ (sce1->band_type[w*16+g] != NOISE_BT)) {
878  /* ms_mask unneeded, and it confuses some decoders */
879  cpe->ms_mask[w*16+g] = 0;
880  }
881  break;
882  } else if (B1 > B0) {
883  /* More boost won't fix this */
884  break;
885  }
886  }
887  }
888  if (!sce0->zeroes[w*16+g] && sce0->band_type[w*16+g] < RESERVED_BT)
889  prev_mid = sce0->sf_idx[w*16+g];
890  if (!sce1->zeroes[w*16+g] && !cpe->is_mask[w*16+g] && sce1->band_type[w*16+g] < RESERVED_BT)
891  prev_side = sce1->sf_idx[w*16+g];
892  start += sce0->ics.swb_sizes[g];
893  }
894  }
895 }
896 
898  [AAC_CODER_ANMR] = {
913  mark_pns,
919  },
920  [AAC_CODER_TWOLOOP] = {
935  mark_pns,
941  },
942  [AAC_CODER_FAST] = {
957  mark_pns,
963  },
964 };
M
#define M(a, b)
Definition: vp3dsp.c:45
SingleChannelElement::band_alt
enum BandType band_alt[128]
alternative band type (used by encoder)
Definition: aac.h:253
q1
static const uint8_t q1[256]
Definition: twofish.c:96
lcg_random
static av_always_inline int lcg_random(unsigned previous_val)
linear congruential pseudorandom number generator
Definition: aacdec_template.c:1063
INFINITY
#define INFINITY
Definition: mathematics.h:67
SingleChannelElement::can_pns
uint8_t can_pns[128]
band is allowed to PNS (informative)
Definition: aac.h:258
libm.h
B1
#define B1
Definition: faandct.c:41
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1186
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
aacenctab.h
log2f
#define log2f(x)
Definition: libm.h:409
CB_TOT_ALL
#define CB_TOT_ALL
Total number of codebooks, including special ones.
Definition: aacenctab.h:37
ff_aac_update_ltp
void ff_aac_update_ltp(AACEncContext *s, SingleChannelElement *sce)
Process LTP parameters.
Definition: aacenc_ltp.c:117
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
SingleChannelElement::zeroes
uint8_t zeroes[128]
band is not coded (used by encoder)
Definition: aac.h:257
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
aacenc_ltp.h
bval2bmax
static av_always_inline float bval2bmax(float b)
approximates exp10f(-3.0f*(0.5f + 0.5f * cosf(FFMIN(b,15.5f) / 15.5f)))
Definition: aacenc_utils.h:188
ff_aac_coders
const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]
Definition: aaccoder.c:897
B0
#define B0
Definition: faandct.c:40
b
#define b
Definition: input.c:41
float.h
AAC_CODER_NB
@ AAC_CODER_NB
Definition: aacenc.h:40
mathematics.h
ff_sfdelta_can_remove_band
static int ff_sfdelta_can_remove_band(const SingleChannelElement *sce, const uint8_t *nextband, int prev_sf, int band)
Definition: aacenc_utils.h:232
search_for_ms
static void search_for_ms(AACEncContext *s, ChannelElement *cpe)
Definition: aaccoder.c:756
roundf
static av_always_inline av_const float roundf(float x)
Definition: libm.h:451
coef2maxsf
static uint8_t coef2maxsf(float coef)
Return the maximum scalefactor where the quantized coef is not zero.
Definition: aacenc_utils.h:163
SCALE_MAX_POS
#define SCALE_MAX_POS
scalefactor index maximum value
Definition: aac.h:150
AAC_CODER_FAST
@ AAC_CODER_FAST
Definition: aacenc.h:38
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
S
#define S(s, c, i)
Definition: flacdsp_template.c:46
IndividualChannelStream::num_swb
int num_swb
number of scalefactor window bands
Definition: aac.h:183
b1
static double b1(void *priv, double x, double y)
Definition: vf_xfade.c:1332
SCALE_DIV_512
#define SCALE_DIV_512
scalefactor difference that corresponds to scale difference in 512 times
Definition: aac.h:148
ff_sfdelta_can_replace
static int ff_sfdelta_can_replace(const SingleChannelElement *sce, const uint8_t *nextband, int prev_sf, int new_sf, int band)
Definition: aacenc_utils.h:246
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
POW_SF2_ZERO
#define POW_SF2_ZERO
ff_aac_pow2sf_tab index corresponding to pow(2, 0);
Definition: aac.h:154
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:249
search_for_pns
static void search_for_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)
Definition: aaccoder.c:543
NOISE_BT
@ NOISE_BT
Spectral data are scaled white noise not coded in the bitstream.
Definition: aac.h:87
b3
static double b3(void *priv, double x, double y)
Definition: vf_xfade.c:1334
s
#define s(width, name)
Definition: cbs_vp9.c:257
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:262
ff_aac_apply_main_pred
void ff_aac_apply_main_pred(AACEncContext *s, SingleChannelElement *sce)
Definition: aacenc_pred.c:119
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
INTENSITY_BT2
@ INTENSITY_BT2
Scalefactor data are intensity stereo positions (out of phase).
Definition: aac.h:88
bits
uint8_t bits
Definition: vp3data.h:202
IndividualChannelStream::group_len
uint8_t group_len[8]
Definition: aac.h:179
search_for_quantizers_fast
static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda)
Definition: aaccoder.c:395
ff_aac_encode_ltp_info
void ff_aac_encode_ltp_info(AACEncContext *s, SingleChannelElement *sce, int common_window)
Encode LTP data.
Definition: aacenc_ltp.c:35
mark_pns
static void mark_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)
Definition: aaccoder.c:685
bands
static const float bands[]
Definition: af_superequalizer.c:56
SCALE_DIFF_ZERO
#define SCALE_DIFF_ZERO
codebook index corresponding to zero scalefactor indices difference
Definition: aac.h:152
f
#define f(width, name)
Definition: cbs_vp9.c:255
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
q0
static const uint8_t q0[256]
Definition: twofish.c:77
quantize_band_cost_cached
static float quantize_band_cost_cached(struct AACEncContext *s, int w, int g, const float *in, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy, int rtz)
Definition: aacenc_quantization_misc.h:31
TrellisPath
Definition: aaccoder.c:188
INTENSITY_BT
@ INTENSITY_BT
Scalefactor data are intensity stereo positions (in phase).
Definition: aac.h:89
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
SingleChannelElement::is_ener
float is_ener[128]
Intensity stereo pos (used by encoder)
Definition: aac.h:259
aacenc_quantization.h
codebook_trellis_rate
static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce, int win, int group_len, const float lambda)
Definition: aaccoder_trellis.h:59
ff_aac_apply_tns
void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)
Definition: aacenc_tns.c:102
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:576
mathops.h
FFPsyBand
single band psychoacoustic information
Definition: psymodel.h:50
aac.h
aactab.h
ff_aac_encode_tns_info
void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
Encode TNS data.
Definition: aacenc_tns.c:70
ff_init_nextband_map
static void ff_init_nextband_map(const SingleChannelElement *sce, uint8_t *nextband)
Definition: aacenc_utils.h:199
aaccoder_twoloop.h
run_value_bits
static const uint8_t *const run_value_bits[2]
Definition: aacenctab.h:116
SingleChannelElement::sf_idx
int sf_idx[128]
scalefactor indices (used by encoder)
Definition: aac.h:256
ff_aac_ltp_insert_new_frame
void ff_aac_ltp_insert_new_frame(AACEncContext *s)
Definition: aacenc_ltp.c:53
ff_aac_scalefactor_bits
const uint8_t ff_aac_scalefactor_bits[121]
Definition: aactab.c:92
coef2minsf
static uint8_t coef2minsf(float coef)
Return the minimum scalefactor where the quantized coef does not clip.
Definition: aacenc_utils.h:157
aac_cb_out_map
static const uint8_t aac_cb_out_map[CB_TOT_ALL]
Map to convert values from BandCodingPath index to a codebook index.
Definition: aacenctab.h:121
AAC_CODER_ANMR
@ AAC_CODER_ANMR
Definition: aacenc.h:36
ChannelElement::ch
SingleChannelElement ch[2]
Definition: aac.h:284
ff_aac_adjust_common_pred
void ff_aac_adjust_common_pred(AACEncContext *s, ChannelElement *cpe)
Definition: aacenc_pred.c:151
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
NOISE_SPREAD_THRESHOLD
#define NOISE_SPREAD_THRESHOLD
Definition: aaccoder.c:57
size
int size
Definition: twinvq_data.h:11134
run_bits
static const uint8_t run_bits[7][16]
Definition: h264_cavlc.c:229
AAC_CODER_TWOLOOP
@ AAC_CODER_TWOLOOP
Definition: aacenc.h:37
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:1333
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
ff_aac_adjust_common_ltp
void ff_aac_adjust_common_ltp(AACEncContext *s, ChannelElement *cpe)
Definition: aacenc_ltp.c:130
search_for_quantizers_twoloop
static void search_for_quantizers_twoloop(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda)
two-loop quantizers search taken from ISO 13818-7 Appendix C
Definition: aaccoder_twoloop.h:67
ChannelElement::ms_mask
uint8_t ms_mask[128]
Set if mid/side stereo is used for each scalefactor window band.
Definition: aac.h:281
SCALE_MAX_DIFF
#define SCALE_MAX_DIFF
maximum scalefactor difference allowed by standard
Definition: aac.h:151
SingleChannelElement::pns_ener
float pns_ener[128]
Noise energy values (used by encoder)
Definition: aac.h:260
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1187
AAC_CUTOFF_FROM_BITRATE
#define AAC_CUTOFF_FROM_BITRATE(bit_rate, channels, sample_rate)
Definition: psymodel.h:35
aacenc_is.h
search_for_quantizers_anmr
static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda)
Definition: aaccoder.c:235
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:269
IndividualChannelStream::num_windows
int num_windows
Definition: aac.h:184
SCALE_ONE_POS
#define SCALE_ONE_POS
scalefactor index that corresponds to scale=1.0
Definition: aac.h:149
find_min_book
static int find_min_book(float maxval, int sf)
Definition: aacenc_utils.h:92
aac_cb_in_map
static const uint8_t aac_cb_in_map[CB_TOT_ALL+1]
Inverse map to convert from codebooks to BandCodingPath indices.
Definition: aacenctab.h:123
FFPsyBand::threshold
float threshold
Definition: psymodel.h:53
ff_aac_search_for_tns
void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)
Definition: aacenc_tns.c:161
ChannelElement
channel element - generic struct for SCE/CPE/CCE/LFE
Definition: aac.h:275
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1230
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
uint8_t
uint8_t
Definition: audio_convert.c:194
TrellisPath::prev
int prev
Definition: aaccoder.c:190
set_special_band_scalefactors
static void set_special_band_scalefactors(AACEncContext *s, SingleChannelElement *sce)
Definition: aaccoder.c:196
NOISE_LOW_LIMIT
#define NOISE_LOW_LIMIT
This file contains a template for the twoloop coder function.
Definition: aaccoder_twoloop.h:54
AACCoefficientsEncoder
Definition: aacenc.h:56
ff_aac_search_for_is
void ff_aac_search_for_is(AACEncContext *s, AVCodecContext *avctx, ChannelElement *cpe)
Definition: aacenc_is.c:98
avcodec.h
TRELLIS_STAGES
#define TRELLIS_STAGES
Definition: aaccoder.c:193
BandCodingPath
structure used in optimal codebook search
Definition: aaccoder.c:68
w
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
Definition: fate.txt:150
RESERVED_BT
@ RESERVED_BT
Band types following are encoded differently from others.
Definition: aac.h:86
AACEncContext
AAC encoder context.
Definition: aacenc.h:376
FFPsyBand::energy
float energy
Definition: psymodel.h:52
AVCodecContext
main external API structure.
Definition: avcodec.h:526
aacenc_pred.h
ff_aac_pow2sf_tab
float ff_aac_pow2sf_tab[428]
Definition: aactab.c:35
quantize_and_encode_band
static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb, const float *in, float *out, int size, int scale_idx, int cb, const float lambda, int rtz)
Definition: aacenc_quantization.h:273
ff_aac_encode_main_pred
void ff_aac_encode_main_pred(AACEncContext *s, SingleChannelElement *sce)
Encoder predictors data.
Definition: aacenc_pred.c:332
encode_window_bands_info
static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce, int win, int group_len, const float lambda)
Encode band info for single window group bands.
Definition: aaccoder.c:77
aacenc_tns.h
find_max_val
static float find_max_val(int group_len, int swb_size, const float *scaled)
Definition: aacenc_utils.h:80
BandCodingPath::prev_idx
int prev_idx
pointer to the previous path point
Definition: aaccoder.c:69
ff_aac_search_for_pred
void ff_aac_search_for_pred(AACEncContext *s, SingleChannelElement *sce)
Definition: aacenc_pred.c:233
TRELLIS_STATES
#define TRELLIS_STATES
Definition: aaccoder.c:194
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:175
ff_aac_search_for_ltp
void ff_aac_search_for_ltp(AACEncContext *s, SingleChannelElement *sce, int common_window)
Mark LTP sfb's.
Definition: aacenc_ltp.c:159
TrellisPath::cost
float cost
Definition: aaccoder.c:189
quantize_band_cost
static float quantize_band_cost(struct AACEncContext *s, const float *in, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy, int rtz)
Definition: aacenc_quantization.h:250
FFPsyBand::spread
float spread
Definition: psymodel.h:54
aacenc_utils.h
put_bits.h
SingleChannelElement::band_type
enum BandType band_type[128]
band types
Definition: aac.h:252
BandCodingPath::run
int run
Definition: aaccoder.c:71
ff_quantize_band_cost_cache_init
void ff_quantize_band_cost_cache_init(struct AACEncContext *s)
Definition: aacenc.c:127
aaccoder_trellis.h
NOISE_LAMBDA_REPLACE
#define NOISE_LAMBDA_REPLACE
Definition: aaccoder.c:61
aacenc.h
BandCodingPath::cost
float cost
path cost
Definition: aaccoder.c:70