FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 #include "libavutil/mathematics.h"
37 #include "avcodec.h"
38 #include "put_bits.h"
39 #include "aac.h"
40 #include "aacenc.h"
41 #include "aactab.h"
42 
43 /** bits needed to code codebook run value for long windows */
44 static const uint8_t run_value_bits_long[64] = {
45  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
46  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10,
47  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
48  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
49 };
50 
51 /** bits needed to code codebook run value for short windows */
52 static const uint8_t run_value_bits_short[16] = {
53  3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
54 };
55 
56 static const uint8_t *run_value_bits[2] = {
58 };
59 
60 
61 /**
62  * Quantize one coefficient.
63  * @return absolute value of the quantized coefficient
64  * @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
65  */
66 static av_always_inline int quant(float coef, const float Q)
67 {
68  float a = coef * Q;
69  return sqrtf(a * sqrtf(a)) + 0.4054;
70 }
71 
72 static void quantize_bands(int *out, const float *in, const float *scaled,
73  int size, float Q34, int is_signed, int maxval)
74 {
75  int i;
76  double qc;
77  for (i = 0; i < size; i++) {
78  qc = scaled[i] * Q34;
79  out[i] = (int)FFMIN(qc + 0.4054, (double)maxval);
80  if (is_signed && in[i] < 0.0f) {
81  out[i] = -out[i];
82  }
83  }
84 }
85 
86 static void abs_pow34_v(float *out, const float *in, const int size)
87 {
88 #ifndef USE_REALLY_FULL_SEARCH
89  int i;
90  for (i = 0; i < size; i++) {
91  float a = fabsf(in[i]);
92  out[i] = sqrtf(a * sqrtf(a));
93  }
94 #endif /* USE_REALLY_FULL_SEARCH */
95 }
96 
97 static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17};
98 static const uint8_t aac_cb_maxval[12] = {0, 1, 1, 2, 2, 4, 4, 7, 7, 12, 12, 16};
99 
100 /**
101  * Calculate rate distortion cost for quantizing with given codebook
102  *
103  * @return quantization distortion
104  */
106  struct AACEncContext *s,
107  PutBitContext *pb, const float *in,
108  const float *scaled, int size, int scale_idx,
109  int cb, const float lambda, const float uplim,
110  int *bits, int BT_ZERO, int BT_UNSIGNED,
111  int BT_PAIR, int BT_ESC)
112 {
113  const int q_idx = POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512;
114  const float Q = ff_aac_pow2sf_tab [q_idx];
115  const float Q34 = ff_aac_pow34sf_tab[q_idx];
116  const float IQ = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
117  const float CLIPPED_ESCAPE = 165140.0f*IQ;
118  int i, j;
119  float cost = 0;
120  const int dim = BT_PAIR ? 2 : 4;
121  int resbits = 0;
122  const int range = aac_cb_range[cb];
123  const int maxval = aac_cb_maxval[cb];
124  int off;
125 
126  if (BT_ZERO) {
127  for (i = 0; i < size; i++)
128  cost += in[i]*in[i];
129  if (bits)
130  *bits = 0;
131  return cost * lambda;
132  }
133  if (!scaled) {
134  abs_pow34_v(s->scoefs, in, size);
135  scaled = s->scoefs;
136  }
137  quantize_bands(s->qcoefs, in, scaled, size, Q34, !BT_UNSIGNED, maxval);
138  if (BT_UNSIGNED) {
139  off = 0;
140  } else {
141  off = maxval;
142  }
143  for (i = 0; i < size; i += dim) {
144  const float *vec;
145  int *quants = s->qcoefs + i;
146  int curidx = 0;
147  int curbits;
148  float rd = 0.0f;
149  for (j = 0; j < dim; j++) {
150  curidx *= range;
151  curidx += quants[j] + off;
152  }
153  curbits = ff_aac_spectral_bits[cb-1][curidx];
154  vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
155  if (BT_UNSIGNED) {
156  for (j = 0; j < dim; j++) {
157  float t = fabsf(in[i+j]);
158  float di;
159  if (BT_ESC && vec[j] == 64.0f) { //FIXME: slow
160  if (t >= CLIPPED_ESCAPE) {
161  di = t - CLIPPED_ESCAPE;
162  curbits += 21;
163  } else {
164  int c = av_clip(quant(t, Q), 0, 8191);
165  di = t - c*cbrtf(c)*IQ;
166  curbits += av_log2(c)*2 - 4 + 1;
167  }
168  } else {
169  di = t - vec[j]*IQ;
170  }
171  if (vec[j] != 0.0f)
172  curbits++;
173  rd += di*di;
174  }
175  } else {
176  for (j = 0; j < dim; j++) {
177  float di = in[i+j] - vec[j]*IQ;
178  rd += di*di;
179  }
180  }
181  cost += rd * lambda + curbits;
182  resbits += curbits;
183  if (cost >= uplim)
184  return uplim;
185  if (pb) {
186  put_bits(pb, ff_aac_spectral_bits[cb-1][curidx], ff_aac_spectral_codes[cb-1][curidx]);
187  if (BT_UNSIGNED)
188  for (j = 0; j < dim; j++)
189  if (ff_aac_codebook_vectors[cb-1][curidx*dim+j] != 0.0f)
190  put_bits(pb, 1, in[i+j] < 0.0f);
191  if (BT_ESC) {
192  for (j = 0; j < 2; j++) {
193  if (ff_aac_codebook_vectors[cb-1][curidx*2+j] == 64.0f) {
194  int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
195  int len = av_log2(coef);
196 
197  put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
198  put_bits(pb, len, coef & ((1 << len) - 1));
199  }
200  }
201  }
202  }
203  }
204 
205  if (bits)
206  *bits = resbits;
207  return cost;
208 }
209 
210 #define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC) \
211 static float quantize_and_encode_band_cost_ ## NAME( \
212  struct AACEncContext *s, \
213  PutBitContext *pb, const float *in, \
214  const float *scaled, int size, int scale_idx, \
215  int cb, const float lambda, const float uplim, \
216  int *bits) { \
217  return quantize_and_encode_band_cost_template( \
218  s, pb, in, scaled, size, scale_idx, \
219  BT_ESC ? ESC_BT : cb, lambda, uplim, bits, \
220  BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC); \
221 }
222 
223 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO, 1, 0, 0, 0)
224 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0)
225 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0)
226 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0)
227 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0)
228 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC, 0, 1, 1, 1)
229 
230 static float (*const quantize_and_encode_band_cost_arr[])(
231  struct AACEncContext *s,
232  PutBitContext *pb, const float *in,
233  const float *scaled, int size, int scale_idx,
234  int cb, const float lambda, const float uplim,
235  int *bits) = {
236  quantize_and_encode_band_cost_ZERO,
237  quantize_and_encode_band_cost_SQUAD,
238  quantize_and_encode_band_cost_SQUAD,
239  quantize_and_encode_band_cost_UQUAD,
240  quantize_and_encode_band_cost_UQUAD,
241  quantize_and_encode_band_cost_SPAIR,
242  quantize_and_encode_band_cost_SPAIR,
243  quantize_and_encode_band_cost_UPAIR,
244  quantize_and_encode_band_cost_UPAIR,
245  quantize_and_encode_band_cost_UPAIR,
246  quantize_and_encode_band_cost_UPAIR,
247  quantize_and_encode_band_cost_ESC,
248 };
249 
250 #define quantize_and_encode_band_cost( \
251  s, pb, in, scaled, size, scale_idx, cb, \
252  lambda, uplim, bits) \
253  quantize_and_encode_band_cost_arr[cb]( \
254  s, pb, in, scaled, size, scale_idx, cb, \
255  lambda, uplim, bits)
256 
257 static float quantize_band_cost(struct AACEncContext *s, const float *in,
258  const float *scaled, int size, int scale_idx,
259  int cb, const float lambda, const float uplim,
260  int *bits)
261 {
262  return quantize_and_encode_band_cost(s, NULL, in, scaled, size, scale_idx,
263  cb, lambda, uplim, bits);
264 }
265 
267  const float *in, int size, int scale_idx,
268  int cb, const float lambda)
269 {
270  quantize_and_encode_band_cost(s, pb, in, NULL, size, scale_idx, cb, lambda,
271  INFINITY, NULL);
272 }
273 
274 static float find_max_val(int group_len, int swb_size, const float *scaled) {
275  float maxval = 0.0f;
276  int w2, i;
277  for (w2 = 0; w2 < group_len; w2++) {
278  for (i = 0; i < swb_size; i++) {
279  maxval = FFMAX(maxval, scaled[w2*128+i]);
280  }
281  }
282  return maxval;
283 }
284 
285 static int find_min_book(float maxval, int sf) {
287  float Q34 = sqrtf(Q * sqrtf(Q));
288  int qmaxval, cb;
289  qmaxval = maxval * Q34 + 0.4054f;
290  if (qmaxval == 0) cb = 0;
291  else if (qmaxval == 1) cb = 1;
292  else if (qmaxval == 2) cb = 3;
293  else if (qmaxval <= 4) cb = 5;
294  else if (qmaxval <= 7) cb = 7;
295  else if (qmaxval <= 12) cb = 9;
296  else cb = 11;
297  return cb;
298 }
299 
300 /**
301  * structure used in optimal codebook search
302  */
303 typedef struct BandCodingPath {
304  int prev_idx; ///< pointer to the previous path point
305  float cost; ///< path cost
306  int run;
308 
309 /**
310  * Encode band info for single window group bands.
311  */
313  int win, int group_len, const float lambda)
314 {
315  BandCodingPath path[120][12];
316  int w, swb, cb, start, size;
317  int i, j;
318  const int max_sfb = sce->ics.max_sfb;
319  const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
320  const int run_esc = (1 << run_bits) - 1;
321  int idx, ppos, count;
322  int stackrun[120], stackcb[120], stack_len;
323  float next_minrd = INFINITY;
324  int next_mincb = 0;
325 
326  abs_pow34_v(s->scoefs, sce->coeffs, 1024);
327  start = win*128;
328  for (cb = 0; cb < 12; cb++) {
329  path[0][cb].cost = 0.0f;
330  path[0][cb].prev_idx = -1;
331  path[0][cb].run = 0;
332  }
333  for (swb = 0; swb < max_sfb; swb++) {
334  size = sce->ics.swb_sizes[swb];
335  if (sce->zeroes[win*16 + swb]) {
336  for (cb = 0; cb < 12; cb++) {
337  path[swb+1][cb].prev_idx = cb;
338  path[swb+1][cb].cost = path[swb][cb].cost;
339  path[swb+1][cb].run = path[swb][cb].run + 1;
340  }
341  } else {
342  float minrd = next_minrd;
343  int mincb = next_mincb;
344  next_minrd = INFINITY;
345  next_mincb = 0;
346  for (cb = 0; cb < 12; cb++) {
347  float cost_stay_here, cost_get_here;
348  float rd = 0.0f;
349  for (w = 0; w < group_len; w++) {
350  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(win+w)*16+swb];
351  rd += quantize_band_cost(s, sce->coeffs + start + w*128,
352  s->scoefs + start + w*128, size,
353  sce->sf_idx[(win+w)*16+swb], cb,
354  lambda / band->threshold, INFINITY, NULL);
355  }
356  cost_stay_here = path[swb][cb].cost + rd;
357  cost_get_here = minrd + rd + run_bits + 4;
358  if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
359  != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
360  cost_stay_here += run_bits;
361  if (cost_get_here < cost_stay_here) {
362  path[swb+1][cb].prev_idx = mincb;
363  path[swb+1][cb].cost = cost_get_here;
364  path[swb+1][cb].run = 1;
365  } else {
366  path[swb+1][cb].prev_idx = cb;
367  path[swb+1][cb].cost = cost_stay_here;
368  path[swb+1][cb].run = path[swb][cb].run + 1;
369  }
370  if (path[swb+1][cb].cost < next_minrd) {
371  next_minrd = path[swb+1][cb].cost;
372  next_mincb = cb;
373  }
374  }
375  }
376  start += sce->ics.swb_sizes[swb];
377  }
378 
379  //convert resulting path from backward-linked list
380  stack_len = 0;
381  idx = 0;
382  for (cb = 1; cb < 12; cb++)
383  if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
384  idx = cb;
385  ppos = max_sfb;
386  while (ppos > 0) {
387  cb = idx;
388  stackrun[stack_len] = path[ppos][cb].run;
389  stackcb [stack_len] = cb;
390  idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
391  ppos -= path[ppos][cb].run;
392  stack_len++;
393  }
394  //perform actual band info encoding
395  start = 0;
396  for (i = stack_len - 1; i >= 0; i--) {
397  put_bits(&s->pb, 4, stackcb[i]);
398  count = stackrun[i];
399  memset(sce->zeroes + win*16 + start, !stackcb[i], count);
400  //XXX: memset when band_type is also uint8_t
401  for (j = 0; j < count; j++) {
402  sce->band_type[win*16 + start] = stackcb[i];
403  start++;
404  }
405  while (count >= run_esc) {
406  put_bits(&s->pb, run_bits, run_esc);
407  count -= run_esc;
408  }
409  put_bits(&s->pb, run_bits, count);
410  }
411 }
412 
414  int win, int group_len, const float lambda)
415 {
416  BandCodingPath path[120][12];
417  int w, swb, cb, start, size;
418  int i, j;
419  const int max_sfb = sce->ics.max_sfb;
420  const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
421  const int run_esc = (1 << run_bits) - 1;
422  int idx, ppos, count;
423  int stackrun[120], stackcb[120], stack_len;
424  float next_minbits = INFINITY;
425  int next_mincb = 0;
426 
427  abs_pow34_v(s->scoefs, sce->coeffs, 1024);
428  start = win*128;
429  for (cb = 0; cb < 12; cb++) {
430  path[0][cb].cost = run_bits+4;
431  path[0][cb].prev_idx = -1;
432  path[0][cb].run = 0;
433  }
434  for (swb = 0; swb < max_sfb; swb++) {
435  size = sce->ics.swb_sizes[swb];
436  if (sce->zeroes[win*16 + swb]) {
437  float cost_stay_here = path[swb][0].cost;
438  float cost_get_here = next_minbits + run_bits + 4;
439  if ( run_value_bits[sce->ics.num_windows == 8][path[swb][0].run]
440  != run_value_bits[sce->ics.num_windows == 8][path[swb][0].run+1])
441  cost_stay_here += run_bits;
442  if (cost_get_here < cost_stay_here) {
443  path[swb+1][0].prev_idx = next_mincb;
444  path[swb+1][0].cost = cost_get_here;
445  path[swb+1][0].run = 1;
446  } else {
447  path[swb+1][0].prev_idx = 0;
448  path[swb+1][0].cost = cost_stay_here;
449  path[swb+1][0].run = path[swb][0].run + 1;
450  }
451  next_minbits = path[swb+1][0].cost;
452  next_mincb = 0;
453  for (cb = 1; cb < 12; cb++) {
454  path[swb+1][cb].cost = 61450;
455  path[swb+1][cb].prev_idx = -1;
456  path[swb+1][cb].run = 0;
457  }
458  } else {
459  float minbits = next_minbits;
460  int mincb = next_mincb;
461  int startcb = sce->band_type[win*16+swb];
462  next_minbits = INFINITY;
463  next_mincb = 0;
464  for (cb = 0; cb < startcb; cb++) {
465  path[swb+1][cb].cost = 61450;
466  path[swb+1][cb].prev_idx = -1;
467  path[swb+1][cb].run = 0;
468  }
469  for (cb = startcb; cb < 12; cb++) {
470  float cost_stay_here, cost_get_here;
471  float bits = 0.0f;
472  for (w = 0; w < group_len; w++) {
473  bits += quantize_band_cost(s, sce->coeffs + start + w*128,
474  s->scoefs + start + w*128, size,
475  sce->sf_idx[(win+w)*16+swb], cb,
476  0, INFINITY, NULL);
477  }
478  cost_stay_here = path[swb][cb].cost + bits;
479  cost_get_here = minbits + bits + run_bits + 4;
480  if ( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
481  != run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
482  cost_stay_here += run_bits;
483  if (cost_get_here < cost_stay_here) {
484  path[swb+1][cb].prev_idx = mincb;
485  path[swb+1][cb].cost = cost_get_here;
486  path[swb+1][cb].run = 1;
487  } else {
488  path[swb+1][cb].prev_idx = cb;
489  path[swb+1][cb].cost = cost_stay_here;
490  path[swb+1][cb].run = path[swb][cb].run + 1;
491  }
492  if (path[swb+1][cb].cost < next_minbits) {
493  next_minbits = path[swb+1][cb].cost;
494  next_mincb = cb;
495  }
496  }
497  }
498  start += sce->ics.swb_sizes[swb];
499  }
500 
501  //convert resulting path from backward-linked list
502  stack_len = 0;
503  idx = 0;
504  for (cb = 1; cb < 12; cb++)
505  if (path[max_sfb][cb].cost < path[max_sfb][idx].cost)
506  idx = cb;
507  ppos = max_sfb;
508  while (ppos > 0) {
509  av_assert1(idx >= 0);
510  cb = idx;
511  stackrun[stack_len] = path[ppos][cb].run;
512  stackcb [stack_len] = cb;
513  idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
514  ppos -= path[ppos][cb].run;
515  stack_len++;
516  }
517  //perform actual band info encoding
518  start = 0;
519  for (i = stack_len - 1; i >= 0; i--) {
520  put_bits(&s->pb, 4, stackcb[i]);
521  count = stackrun[i];
522  memset(sce->zeroes + win*16 + start, !stackcb[i], count);
523  //XXX: memset when band_type is also uint8_t
524  for (j = 0; j < count; j++) {
525  sce->band_type[win*16 + start] = stackcb[i];
526  start++;
527  }
528  while (count >= run_esc) {
529  put_bits(&s->pb, run_bits, run_esc);
530  count -= run_esc;
531  }
532  put_bits(&s->pb, run_bits, count);
533  }
534 }
535 
536 /** Return the minimum scalefactor where the quantized coef does not clip. */
537 static av_always_inline uint8_t coef2minsf(float coef) {
538  return av_clip_uint8(log2f(coef)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
539 }
540 
541 /** Return the maximum scalefactor where the quantized coef is not zero. */
542 static av_always_inline uint8_t coef2maxsf(float coef) {
543  return av_clip_uint8(log2f(coef)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512);
544 }
545 
546 typedef struct TrellisPath {
547  float cost;
548  int prev;
549 } TrellisPath;
550 
551 #define TRELLIS_STAGES 121
552 #define TRELLIS_STATES (SCALE_MAX_DIFF+1)
553 
556  const float lambda)
557 {
558  int q, w, w2, g, start = 0;
559  int i, j;
560  int idx;
562  int bandaddr[TRELLIS_STAGES];
563  int minq;
564  float mincost;
565  float q0f = FLT_MAX, q1f = 0.0f, qnrgf = 0.0f;
566  int q0, q1, qcnt = 0;
567 
568  for (i = 0; i < 1024; i++) {
569  float t = fabsf(sce->coeffs[i]);
570  if (t > 0.0f) {
571  q0f = FFMIN(q0f, t);
572  q1f = FFMAX(q1f, t);
573  qnrgf += t*t;
574  qcnt++;
575  }
576  }
577 
578  if (!qcnt) {
579  memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
580  memset(sce->zeroes, 1, sizeof(sce->zeroes));
581  return;
582  }
583 
584  //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
585  q0 = coef2minsf(q0f);
586  //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
587  q1 = coef2maxsf(q1f);
588  if (q1 - q0 > 60) {
589  int q0low = q0;
590  int q1high = q1;
591  //minimum scalefactor index is when maximum nonzero coefficient after quantizing is not clipped
592  int qnrg = av_clip_uint8(log2f(sqrtf(qnrgf/qcnt))*4 - 31 + SCALE_ONE_POS - SCALE_DIV_512);
593  q1 = qnrg + 30;
594  q0 = qnrg - 30;
595  if (q0 < q0low) {
596  q1 += q0low - q0;
597  q0 = q0low;
598  } else if (q1 > q1high) {
599  q0 -= q1 - q1high;
600  q1 = q1high;
601  }
602  }
603 
604  for (i = 0; i < TRELLIS_STATES; i++) {
605  paths[0][i].cost = 0.0f;
606  paths[0][i].prev = -1;
607  }
608  for (j = 1; j < TRELLIS_STAGES; j++) {
609  for (i = 0; i < TRELLIS_STATES; i++) {
610  paths[j][i].cost = INFINITY;
611  paths[j][i].prev = -2;
612  }
613  }
614  idx = 1;
615  abs_pow34_v(s->scoefs, sce->coeffs, 1024);
616  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
617  start = w*128;
618  for (g = 0; g < sce->ics.num_swb; g++) {
619  const float *coefs = sce->coeffs + start;
620  float qmin, qmax;
621  int nz = 0;
622 
623  bandaddr[idx] = w * 16 + g;
624  qmin = INT_MAX;
625  qmax = 0.0f;
626  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
627  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
628  if (band->energy <= band->threshold || band->threshold == 0.0f) {
629  sce->zeroes[(w+w2)*16+g] = 1;
630  continue;
631  }
632  sce->zeroes[(w+w2)*16+g] = 0;
633  nz = 1;
634  for (i = 0; i < sce->ics.swb_sizes[g]; i++) {
635  float t = fabsf(coefs[w2*128+i]);
636  if (t > 0.0f)
637  qmin = FFMIN(qmin, t);
638  qmax = FFMAX(qmax, t);
639  }
640  }
641  if (nz) {
642  int minscale, maxscale;
643  float minrd = INFINITY;
644  float maxval;
645  //minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
646  minscale = coef2minsf(qmin);
647  //maximum scalefactor index is when maximum coefficient after quantizing is still not zero
648  maxscale = coef2maxsf(qmax);
649  minscale = av_clip(minscale - q0, 0, TRELLIS_STATES - 1);
650  maxscale = av_clip(maxscale - q0, 0, TRELLIS_STATES);
651  maxval = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], s->scoefs+start);
652  for (q = minscale; q < maxscale; q++) {
653  float dist = 0;
654  int cb = find_min_book(maxval, sce->sf_idx[w*16+g]);
655  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
656  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
657  dist += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],
658  q + q0, cb, lambda / band->threshold, INFINITY, NULL);
659  }
660  minrd = FFMIN(minrd, dist);
661 
662  for (i = 0; i < q1 - q0; i++) {
663  float cost;
664  cost = paths[idx - 1][i].cost + dist
666  if (cost < paths[idx][q].cost) {
667  paths[idx][q].cost = cost;
668  paths[idx][q].prev = i;
669  }
670  }
671  }
672  } else {
673  for (q = 0; q < q1 - q0; q++) {
674  paths[idx][q].cost = paths[idx - 1][q].cost + 1;
675  paths[idx][q].prev = q;
676  }
677  }
678  sce->zeroes[w*16+g] = !nz;
679  start += sce->ics.swb_sizes[g];
680  idx++;
681  }
682  }
683  idx--;
684  mincost = paths[idx][0].cost;
685  minq = 0;
686  for (i = 1; i < TRELLIS_STATES; i++) {
687  if (paths[idx][i].cost < mincost) {
688  mincost = paths[idx][i].cost;
689  minq = i;
690  }
691  }
692  while (idx) {
693  sce->sf_idx[bandaddr[idx]] = minq + q0;
694  minq = paths[idx][minq].prev;
695  idx--;
696  }
697  //set the same quantizers inside window groups
698  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
699  for (g = 0; g < sce->ics.num_swb; g++)
700  for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
701  sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
702 }
703 
704 /**
705  * two-loop quantizers search taken from ISO 13818-7 Appendix C
706  */
708  AACEncContext *s,
710  const float lambda)
711 {
712  int start = 0, i, w, w2, g;
713  int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels * (lambda / 120.f);
714  float dists[128] = { 0 }, uplims[128];
715  float maxvals[128];
716  int fflag, minscaler;
717  int its = 0;
718  int allz = 0;
719  float minthr = INFINITY;
720 
721  // for values above this the decoder might end up in an endless loop
722  // due to always having more bits than what can be encoded.
723  destbits = FFMIN(destbits, 5800);
724  //XXX: some heuristic to determine initial quantizers will reduce search time
725  //determine zero bands and upper limits
726  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
727  for (g = 0; g < sce->ics.num_swb; g++) {
728  int nz = 0;
729  float uplim = 0.0f;
730  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
731  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
732  uplim += band->threshold;
733  if (band->energy <= band->threshold || band->threshold == 0.0f) {
734  sce->zeroes[(w+w2)*16+g] = 1;
735  continue;
736  }
737  nz = 1;
738  }
739  uplims[w*16+g] = uplim *512;
740  sce->zeroes[w*16+g] = !nz;
741  if (nz)
742  minthr = FFMIN(minthr, uplim);
743  allz |= nz;
744  }
745  }
746  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
747  for (g = 0; g < sce->ics.num_swb; g++) {
748  if (sce->zeroes[w*16+g]) {
749  sce->sf_idx[w*16+g] = SCALE_ONE_POS;
750  continue;
751  }
752  sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);
753  }
754  }
755 
756  if (!allz)
757  return;
758  abs_pow34_v(s->scoefs, sce->coeffs, 1024);
759 
760  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
761  start = w*128;
762  for (g = 0; g < sce->ics.num_swb; g++) {
763  const float *scaled = s->scoefs + start;
764  maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);
765  start += sce->ics.swb_sizes[g];
766  }
767  }
768 
769  //perform two-loop search
770  //outer loop - improve quality
771  do {
772  int tbits, qstep;
773  minscaler = sce->sf_idx[0];
774  //inner loop - quantize spectrum to fit into given number of bits
775  qstep = its ? 1 : 32;
776  do {
777  int prev = -1;
778  tbits = 0;
779  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
780  start = w*128;
781  for (g = 0; g < sce->ics.num_swb; g++) {
782  const float *coefs = sce->coeffs + start;
783  const float *scaled = s->scoefs + start;
784  int bits = 0;
785  int cb;
786  float dist = 0.0f;
787 
788  if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {
789  start += sce->ics.swb_sizes[g];
790  continue;
791  }
792  minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
793  cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
794  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
795  int b;
796  dist += quantize_band_cost(s, coefs + w2*128,
797  scaled + w2*128,
798  sce->ics.swb_sizes[g],
799  sce->sf_idx[w*16+g],
800  cb,
801  1.0f,
802  INFINITY,
803  &b);
804  bits += b;
805  }
806  dists[w*16+g] = dist - bits;
807  if (prev != -1) {
808  bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
809  }
810  tbits += bits;
811  start += sce->ics.swb_sizes[g];
812  prev = sce->sf_idx[w*16+g];
813  }
814  }
815  if (tbits > destbits) {
816  for (i = 0; i < 128; i++)
817  if (sce->sf_idx[i] < 218 - qstep)
818  sce->sf_idx[i] += qstep;
819  } else {
820  for (i = 0; i < 128; i++)
821  if (sce->sf_idx[i] > 60 - qstep)
822  sce->sf_idx[i] -= qstep;
823  }
824  qstep >>= 1;
825  if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)
826  qstep = 1;
827  } while (qstep);
828 
829  fflag = 0;
830  minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
831  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
832  for (g = 0; g < sce->ics.num_swb; g++) {
833  int prevsc = sce->sf_idx[w*16+g];
834  if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {
835  if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))
836  sce->sf_idx[w*16+g]--;
837  else //Try to make sure there is some energy in every band
838  sce->sf_idx[w*16+g]-=2;
839  }
840  sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
841  sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);
842  if (sce->sf_idx[w*16+g] != prevsc)
843  fflag = 1;
844  sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);
845  }
846  }
847  its++;
848  } while (fflag && its < 10);
849 }
850 
853  const float lambda)
854 {
855  int start = 0, i, w, w2, g;
856  float uplim[128], maxq[128];
857  int minq, maxsf;
858  float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
859  int last = 0, lastband = 0, curband = 0;
860  float avg_energy = 0.0;
861  if (sce->ics.num_windows == 1) {
862  start = 0;
863  for (i = 0; i < 1024; i++) {
864  if (i - start >= sce->ics.swb_sizes[curband]) {
865  start += sce->ics.swb_sizes[curband];
866  curband++;
867  }
868  if (sce->coeffs[i]) {
869  avg_energy += sce->coeffs[i] * sce->coeffs[i];
870  last = i;
871  lastband = curband;
872  }
873  }
874  } else {
875  for (w = 0; w < 8; w++) {
876  const float *coeffs = sce->coeffs + w*128;
877  curband = start = 0;
878  for (i = 0; i < 128; i++) {
879  if (i - start >= sce->ics.swb_sizes[curband]) {
880  start += sce->ics.swb_sizes[curband];
881  curband++;
882  }
883  if (coeffs[i]) {
884  avg_energy += coeffs[i] * coeffs[i];
885  last = FFMAX(last, i);
886  lastband = FFMAX(lastband, curband);
887  }
888  }
889  }
890  }
891  last++;
892  avg_energy /= last;
893  if (avg_energy == 0.0f) {
894  for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
895  sce->sf_idx[i] = SCALE_ONE_POS;
896  return;
897  }
898  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
899  start = w*128;
900  for (g = 0; g < sce->ics.num_swb; g++) {
901  float *coefs = sce->coeffs + start;
902  const int size = sce->ics.swb_sizes[g];
903  int start2 = start, end2 = start + size, peakpos = start;
904  float maxval = -1, thr = 0.0f, t;
905  maxq[w*16+g] = 0.0f;
906  if (g > lastband) {
907  maxq[w*16+g] = 0.0f;
908  start += size;
909  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++)
910  memset(coefs + w2*128, 0, sizeof(coefs[0])*size);
911  continue;
912  }
913  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
914  for (i = 0; i < size; i++) {
915  float t = coefs[w2*128+i]*coefs[w2*128+i];
916  maxq[w*16+g] = FFMAX(maxq[w*16+g], fabsf(coefs[w2*128 + i]));
917  thr += t;
918  if (sce->ics.num_windows == 1 && maxval < t) {
919  maxval = t;
920  peakpos = start+i;
921  }
922  }
923  }
924  if (sce->ics.num_windows == 1) {
925  start2 = FFMAX(peakpos - 2, start2);
926  end2 = FFMIN(peakpos + 3, end2);
927  } else {
928  start2 -= start;
929  end2 -= start;
930  }
931  start += size;
932  thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);
933  t = 1.0 - (1.0 * start2 / last);
934  uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075);
935  }
936  }
937  memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
938  abs_pow34_v(s->scoefs, sce->coeffs, 1024);
939  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
940  start = w*128;
941  for (g = 0; g < sce->ics.num_swb; g++) {
942  const float *coefs = sce->coeffs + start;
943  const float *scaled = s->scoefs + start;
944  const int size = sce->ics.swb_sizes[g];
945  int scf, prev_scf, step;
946  int min_scf = -1, max_scf = 256;
947  float curdiff;
948  if (maxq[w*16+g] < 21.544) {
949  sce->zeroes[w*16+g] = 1;
950  start += size;
951  continue;
952  }
953  sce->zeroes[w*16+g] = 0;
954  scf = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2f(1/maxq[w*16+g])*16/3, 60, 218);
955  for (;;) {
956  float dist = 0.0f;
957  int quant_max;
958 
959  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
960  int b;
961  dist += quantize_band_cost(s, coefs + w2*128,
962  scaled + w2*128,
963  sce->ics.swb_sizes[g],
964  scf,
965  ESC_BT,
966  lambda,
967  INFINITY,
968  &b);
969  dist -= b;
970  }
971  dist *= 1.0f / 512.0f / lambda;
972  quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[POW_SF2_ZERO - scf + SCALE_ONE_POS - SCALE_DIV_512]);
973  if (quant_max >= 8191) { // too much, return to the previous quantizer
974  sce->sf_idx[w*16+g] = prev_scf;
975  break;
976  }
977  prev_scf = scf;
978  curdiff = fabsf(dist - uplim[w*16+g]);
979  if (curdiff <= 1.0f)
980  step = 0;
981  else
982  step = log2f(curdiff);
983  if (dist > uplim[w*16+g])
984  step = -step;
985  scf += step;
986  scf = av_clip_uint8(scf);
987  step = scf - prev_scf;
988  if (FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)) {
989  sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf);
990  break;
991  }
992  if (step > 0)
993  min_scf = prev_scf;
994  else
995  max_scf = prev_scf;
996  }
997  start += size;
998  }
999  }
1000  minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
1001  for (i = 1; i < 128; i++) {
1002  if (!sce->sf_idx[i])
1003  sce->sf_idx[i] = sce->sf_idx[i-1];
1004  else
1005  minq = FFMIN(minq, sce->sf_idx[i]);
1006  }
1007  if (minq == INT_MAX)
1008  minq = 0;
1009  minq = FFMIN(minq, SCALE_MAX_POS);
1010  maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
1011  for (i = 126; i >= 0; i--) {
1012  if (!sce->sf_idx[i])
1013  sce->sf_idx[i] = sce->sf_idx[i+1];
1014  sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
1015  }
1016 }
1017 
1019  SingleChannelElement *sce,
1020  const float lambda)
1021 {
1022  int i, w, w2, g;
1023  int minq = 255;
1024 
1025  memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
1026  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {
1027  for (g = 0; g < sce->ics.num_swb; g++) {
1028  for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
1029  FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
1030  if (band->energy <= band->threshold) {
1031  sce->sf_idx[(w+w2)*16+g] = 218;
1032  sce->zeroes[(w+w2)*16+g] = 1;
1033  } else {
1034  sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold), 80, 218);
1035  sce->zeroes[(w+w2)*16+g] = 0;
1036  }
1037  minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);
1038  }
1039  }
1040  }
1041  for (i = 0; i < 128; i++) {
1042  sce->sf_idx[i] = 140;
1043  //av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
1044  }
1045  //set the same quantizers inside window groups
1046  for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
1047  for (g = 0; g < sce->ics.num_swb; g++)
1048  for (w2 = 1; w2 < sce->ics.group_len[w]; w2++)
1049  sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
1050 }
1051 
1053  const float lambda)
1054 {
1055  int start = 0, i, w, w2, g;
1056  float M[128], S[128];
1057  float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;
1058  SingleChannelElement *sce0 = &cpe->ch[0];
1059  SingleChannelElement *sce1 = &cpe->ch[1];
1060  if (!cpe->common_window)
1061  return;
1062  for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {
1063  for (g = 0; g < sce0->ics.num_swb; g++) {
1064  if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) {
1065  float dist1 = 0.0f, dist2 = 0.0f;
1066  for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {
1067  FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];
1068  FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];
1069  float minthr = FFMIN(band0->threshold, band1->threshold);
1070  float maxthr = FFMAX(band0->threshold, band1->threshold);
1071  for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {
1072  M[i] = (sce0->coeffs[start+w2*128+i]
1073  + sce1->coeffs[start+w2*128+i]) * 0.5;
1074  S[i] = M[i]
1075  - sce1->coeffs[start+w2*128+i];
1076  }
1077  abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
1078  abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
1079  abs_pow34_v(M34, M, sce0->ics.swb_sizes[g]);
1080  abs_pow34_v(S34, S, sce0->ics.swb_sizes[g]);
1081  dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,
1082  L34,
1083  sce0->ics.swb_sizes[g],
1084  sce0->sf_idx[(w+w2)*16+g],
1085  sce0->band_type[(w+w2)*16+g],
1086  lambda / band0->threshold, INFINITY, NULL);
1087  dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,
1088  R34,
1089  sce1->ics.swb_sizes[g],
1090  sce1->sf_idx[(w+w2)*16+g],
1091  sce1->band_type[(w+w2)*16+g],
1092  lambda / band1->threshold, INFINITY, NULL);
1093  dist2 += quantize_band_cost(s, M,
1094  M34,
1095  sce0->ics.swb_sizes[g],
1096  sce0->sf_idx[(w+w2)*16+g],
1097  sce0->band_type[(w+w2)*16+g],
1098  lambda / maxthr, INFINITY, NULL);
1099  dist2 += quantize_band_cost(s, S,
1100  S34,
1101  sce1->ics.swb_sizes[g],
1102  sce1->sf_idx[(w+w2)*16+g],
1103  sce1->band_type[(w+w2)*16+g],
1104  lambda / minthr, INFINITY, NULL);
1105  }
1106  cpe->ms_mask[w*16+g] = dist2 < dist1;
1107  }
1108  start += sce0->ics.swb_sizes[g];
1109  }
1110  }
1111 }
1112 
1114  [AAC_CODER_FAAC] = {
1118  search_for_ms,
1119  },
1120  [AAC_CODER_ANMR] = {
1124  search_for_ms,
1125  },
1126  [AAC_CODER_TWOLOOP] = {
1130  search_for_ms,
1131  },
1132  [AAC_CODER_FAST] = {
1136  search_for_ms,
1137  },
1138 };