2 * AAC coefficients encoder
3 * Copyright (C) 2008-2009 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
24 * AAC coefficients encoder
27 /***********************************
29 * speedup quantizer selection
30 * add sane pulse detection
31 ***********************************/
33 #include "libavutil/libm.h" // brought forward to work around cygwin header breakage
36 #include "libavutil/mathematics.h"
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
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
56 static const uint8_t * const run_value_bits
[2] = {
57 run_value_bits_long
, run_value_bits_short
62 * Quantize one coefficient.
63 * @return absolute value of the quantized coefficient
64 * @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
66 static av_always_inline
int quant(float coef
, const float Q
)
69 return sqrtf(a
* sqrtf(a
)) + 0.4054;
72 static void quantize_bands(int *out
, const float *in
, const float *scaled
,
73 int size
, float Q34
, int is_signed
, int maxval
)
77 for (i
= 0; i
< size
; i
++) {
79 out
[i
] = (int)FFMIN(qc
+ 0.4054, (double)maxval
);
80 if (is_signed
&& in
[i
] < 0.0f
) {
86 static void abs_pow34_v(float *out
, const float *in
, const int size
)
88 #ifndef USE_REALLY_FULL_SEARCH
90 for (i
= 0; i
< size
; i
++) {
91 float a
= fabsf(in
[i
]);
92 out
[i
] = sqrtf(a
* sqrtf(a
));
94 #endif /* USE_REALLY_FULL_SEARCH */
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};
101 * Calculate rate distortion cost for quantizing with given codebook
103 * @return quantization distortion
105 static av_always_inline
float quantize_and_encode_band_cost_template(
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
)
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
;
120 const int dim
= BT_PAIR
? 2 : 4;
122 const int range
= aac_cb_range
[cb
];
123 const int maxval
= aac_cb_maxval
[cb
];
127 for (i
= 0; i
< size
; i
++)
131 return cost
* lambda
;
134 abs_pow34_v(s
->scoefs
, in
, size
);
137 quantize_bands(s
->qcoefs
, in
, scaled
, size
, Q34
, !BT_UNSIGNED
, maxval
);
143 for (i
= 0; i
< size
; i
+= dim
) {
145 int *quants
= s
->qcoefs
+ i
;
149 for (j
= 0; j
< dim
; j
++) {
151 curidx
+= quants
[j
] + off
;
153 curbits
= ff_aac_spectral_bits
[cb
-1][curidx
];
154 vec
= &ff_aac_codebook_vectors
[cb
-1][curidx
*dim
];
156 for (j
= 0; j
< dim
; j
++) {
157 float t
= fabsf(in
[i
+j
]);
159 if (BT_ESC
&& vec
[j
] == 64.0f
) { //FIXME: slow
160 if (t
>= CLIPPED_ESCAPE
) {
161 di
= t
- CLIPPED_ESCAPE
;
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;
176 for (j
= 0; j
< dim
; j
++) {
177 float di
= in
[i
+j
] - vec
[j
]*IQ
;
181 cost
+= rd
* lambda
+ curbits
;
186 put_bits(pb
, ff_aac_spectral_bits
[cb
-1][curidx
], ff_aac_spectral_codes
[cb
-1][curidx
]);
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
);
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
);
197 put_bits(pb
, len
- 4 + 1, (1 << (len
- 4 + 1)) - 2);
198 put_bits(pb
, len
, coef
& ((1 << len
) - 1));
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, \
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); \
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)
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
,
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
,
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, \
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
,
262 return quantize_and_encode_band_cost(s
, NULL
, in
, scaled
, size
, scale_idx
,
263 cb
, lambda
, uplim
, bits
);
266 static void quantize_and_encode_band(struct AACEncContext
*s
, PutBitContext
*pb
,
267 const float *in
, int size
, int scale_idx
,
268 int cb
, const float lambda
)
270 quantize_and_encode_band_cost(s
, pb
, in
, NULL
, size
, scale_idx
, cb
, lambda
,
274 static float find_max_val(int group_len
, int swb_size
, const float *scaled
) {
277 for (w2
= 0; w2
< group_len
; w2
++) {
278 for (i
= 0; i
< swb_size
; i
++) {
279 maxval
= FFMAX(maxval
, scaled
[w2
*128+i
]);
285 static int find_min_book(float maxval
, int sf
) {
286 float Q
= ff_aac_pow2sf_tab
[POW_SF2_ZERO
- sf
+ SCALE_ONE_POS
- SCALE_DIV_512
];
287 float Q34
= sqrtf(Q
* sqrtf(Q
));
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;
301 * structure used in optimal codebook search
303 typedef struct BandCodingPath
{
304 int prev_idx
; ///< pointer to the previous path point
305 float cost
; ///< path cost
310 * Encode band info for single window group bands.
312 static void encode_window_bands_info(AACEncContext
*s
, SingleChannelElement
*sce
,
313 int win
, int group_len
, const float lambda
)
315 BandCodingPath path
[120][12];
316 int w
, swb
, cb
, start
, size
;
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
;
326 abs_pow34_v(s
->scoefs
, sce
->coeffs
, 1024);
328 for (cb
= 0; cb
< 12; cb
++) {
329 path
[0][cb
].cost
= 0.0f
;
330 path
[0][cb
].prev_idx
= -1;
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;
342 float minrd
= next_minrd
;
343 int mincb
= next_mincb
;
344 next_minrd
= INFINITY
;
346 for (cb
= 0; cb
< 12; cb
++) {
347 float cost_stay_here
, cost_get_here
;
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
);
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;
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;
370 if (path
[swb
+1][cb
].cost
< next_minrd
) {
371 next_minrd
= path
[swb
+1][cb
].cost
;
376 start
+= sce
->ics
.swb_sizes
[swb
];
379 //convert resulting path from backward-linked list
382 for (cb
= 1; cb
< 12; cb
++)
383 if (path
[max_sfb
][cb
].cost
< path
[max_sfb
][idx
].cost
)
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
;
394 //perform actual band info encoding
396 for (i
= stack_len
- 1; i
>= 0; i
--) {
397 put_bits(&s
->pb
, 4, stackcb
[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
];
405 while (count
>= run_esc
) {
406 put_bits(&s
->pb
, run_bits
, run_esc
);
409 put_bits(&s
->pb
, run_bits
, count
);
413 static void codebook_trellis_rate(AACEncContext
*s
, SingleChannelElement
*sce
,
414 int win
, int group_len
, const float lambda
)
416 BandCodingPath path
[120][12];
417 int w
, swb
, cb
, start
, size
;
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
;
427 abs_pow34_v(s
->scoefs
, sce
->coeffs
, 1024);
429 for (cb
= 0; cb
< 12; cb
++) {
430 path
[0][cb
].cost
= run_bits
+4;
431 path
[0][cb
].prev_idx
= -1;
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;
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;
451 next_minbits
= path
[swb
+1][0].cost
;
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;
459 float minbits
= next_minbits
;
460 int mincb
= next_mincb
;
461 int startcb
= sce
->band_type
[win
*16+swb
];
462 next_minbits
= INFINITY
;
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;
469 for (cb
= startcb
; cb
< 12; cb
++) {
470 float cost_stay_here
, cost_get_here
;
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
,
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;
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;
492 if (path
[swb
+1][cb
].cost
< next_minbits
) {
493 next_minbits
= path
[swb
+1][cb
].cost
;
498 start
+= sce
->ics
.swb_sizes
[swb
];
501 //convert resulting path from backward-linked list
504 for (cb
= 1; cb
< 12; cb
++)
505 if (path
[max_sfb
][cb
].cost
< path
[max_sfb
][idx
].cost
)
509 av_assert1(idx
>= 0);
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
;
517 //perform actual band info encoding
519 for (i
= stack_len
- 1; i
>= 0; i
--) {
520 put_bits(&s
->pb
, 4, stackcb
[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
];
528 while (count
>= run_esc
) {
529 put_bits(&s
->pb
, run_bits
, run_esc
);
532 put_bits(&s
->pb
, run_bits
, count
);
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
);
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
);
546 typedef struct TrellisPath
{
551 #define TRELLIS_STAGES 121
552 #define TRELLIS_STATES (SCALE_MAX_DIFF+1)
554 static void search_for_quantizers_anmr(AVCodecContext
*avctx
, AACEncContext
*s
,
555 SingleChannelElement
*sce
,
558 int q
, w
, w2
, g
, start
= 0;
561 TrellisPath paths
[TRELLIS_STAGES
][TRELLIS_STATES
];
562 int bandaddr
[TRELLIS_STAGES
];
565 float q0f
= FLT_MAX
, q1f
= 0.0f
, qnrgf
= 0.0f
;
566 int q0
, q1
, qcnt
= 0;
568 for (i
= 0; i
< 1024; i
++) {
569 float t
= fabsf(sce
->coeffs
[i
]);
579 memset(sce
->sf_idx
, 0, sizeof(sce
->sf_idx
));
580 memset(sce
->zeroes
, 1, sizeof(sce
->zeroes
));
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
);
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
);
598 } else if (q1
> q1high
) {
604 for (i
= 0; i
< TRELLIS_STATES
; i
++) {
605 paths
[0][i
].cost
= 0.0f
;
606 paths
[0][i
].prev
= -1;
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;
615 abs_pow34_v(s
->scoefs
, sce
->coeffs
, 1024);
616 for (w
= 0; w
< sce
->ics
.num_windows
; w
+= sce
->ics
.group_len
[w
]) {
618 for (g
= 0; g
< sce
->ics
.num_swb
; g
++) {
619 const float *coefs
= sce
->coeffs
+ start
;
623 bandaddr
[idx
] = w
* 16 + g
;
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;
632 sce
->zeroes
[(w
+w2
)*16+g
] = 0;
634 for (i
= 0; i
< sce
->ics
.swb_sizes
[g
]; i
++) {
635 float t
= fabsf(coefs
[w2
*128+i
]);
637 qmin
= FFMIN(qmin
, t
);
638 qmax
= FFMAX(qmax
, t
);
642 int minscale
, maxscale
;
643 float minrd
= INFINITY
;
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
++) {
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
);
660 minrd
= FFMIN(minrd
, dist
);
662 for (i
= 0; i
< q1
- q0
; i
++) {
664 cost
= paths
[idx
- 1][i
].cost
+ dist
665 + ff_aac_scalefactor_bits
[q
- i
+ SCALE_DIFF_ZERO
];
666 if (cost
< paths
[idx
][q
].cost
) {
667 paths
[idx
][q
].cost
= cost
;
668 paths
[idx
][q
].prev
= i
;
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
;
678 sce
->zeroes
[w
*16+g
] = !nz
;
679 start
+= sce
->ics
.swb_sizes
[g
];
684 mincost
= paths
[idx
][0].cost
;
686 for (i
= 1; i
< TRELLIS_STATES
; i
++) {
687 if (paths
[idx
][i
].cost
< mincost
) {
688 mincost
= paths
[idx
][i
].cost
;
693 sce
->sf_idx
[bandaddr
[idx
]] = minq
+ q0
;
694 minq
= paths
[idx
][minq
].prev
;
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
];
705 * two-loop quantizers search taken from ISO 13818-7 Appendix C
707 static void search_for_quantizers_twoloop(AVCodecContext
*avctx
,
709 SingleChannelElement
*sce
,
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];
716 int fflag
, minscaler
;
719 float minthr
= INFINITY
;
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
++) {
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;
739 uplims
[w
*16+g
] = uplim
*512;
740 sce
->zeroes
[w
*16+g
] = !nz
;
742 minthr
= FFMIN(minthr
, uplim
);
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
;
752 sce
->sf_idx
[w
*16+g
] = SCALE_ONE_POS
+ FFMIN(log2f(uplims
[w
*16+g
]/minthr
)*4,59);
758 abs_pow34_v(s
->scoefs
, sce
->coeffs
, 1024);
760 for (w
= 0; w
< sce
->ics
.num_windows
; w
+= sce
->ics
.group_len
[w
]) {
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
];
769 //perform two-loop search
770 //outer loop - improve quality
773 minscaler
= sce
->sf_idx
[0];
774 //inner loop - quantize spectrum to fit into given number of bits
775 qstep
= its
? 1 : 32;
779 for (w
= 0; w
< sce
->ics
.num_windows
; w
+= sce
->ics
.group_len
[w
]) {
781 for (g
= 0; g
< sce
->ics
.num_swb
; g
++) {
782 const float *coefs
= sce
->coeffs
+ start
;
783 const float *scaled
= s
->scoefs
+ start
;
788 if (sce
->zeroes
[w
*16+g
] || sce
->sf_idx
[w
*16+g
] >= 218) {
789 start
+= sce
->ics
.swb_sizes
[g
];
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
++) {
796 dist
+= quantize_band_cost(s
, coefs
+ w2
*128,
798 sce
->ics
.swb_sizes
[g
],
806 dists
[w
*16+g
] = dist
- bits
;
808 bits
+= ff_aac_scalefactor_bits
[sce
->sf_idx
[w
*16+g
] - prev
+ SCALE_DIFF_ZERO
];
811 start
+= sce
->ics
.swb_sizes
[g
];
812 prev
= sce
->sf_idx
[w
*16+g
];
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
;
820 for (i
= 0; i
< 128; i
++)
821 if (sce
->sf_idx
[i
] > 60 - qstep
)
822 sce
->sf_idx
[i
] -= qstep
;
825 if (!qstep
&& tbits
> destbits
*1.02 && sce
->sf_idx
[0] < 217)
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;
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
)
844 sce
->band_type
[w
*16+g
] = find_min_book(maxvals
[w
*16+g
], sce
->sf_idx
[w
*16+g
]);
848 } while (fflag
&& its
< 10);
851 static void search_for_quantizers_faac(AVCodecContext
*avctx
, AACEncContext
*s
,
852 SingleChannelElement
*sce
,
855 int start
= 0, i
, w
, w2
, g
;
856 float uplim
[128], maxq
[128];
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) {
863 for (i
= 0; i
< 1024; i
++) {
864 if (i
- start
>= sce
->ics
.swb_sizes
[curband
]) {
865 start
+= sce
->ics
.swb_sizes
[curband
];
868 if (sce
->coeffs
[i
]) {
869 avg_energy
+= sce
->coeffs
[i
] * sce
->coeffs
[i
];
875 for (w
= 0; w
< 8; w
++) {
876 const float *coeffs
= sce
->coeffs
+ w
*128;
878 for (i
= 0; i
< 128; i
++) {
879 if (i
- start
>= sce
->ics
.swb_sizes
[curband
]) {
880 start
+= sce
->ics
.swb_sizes
[curband
];
884 avg_energy
+= coeffs
[i
] * coeffs
[i
];
885 last
= FFMAX(last
, i
);
886 lastband
= FFMAX(lastband
, curband
);
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
;
898 for (w
= 0; w
< sce
->ics
.num_windows
; w
+= sce
->ics
.group_len
[w
]) {
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
;
909 for (w2
= 0; w2
< sce
->ics
.group_len
[w
]; w2
++)
910 memset(coefs
+ w2
*128, 0, sizeof(coefs
[0])*size
);
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
]));
918 if (sce
->ics
.num_windows
== 1 && maxval
< t
) {
924 if (sce
->ics
.num_windows
== 1) {
925 start2
= FFMAX(peakpos
- 2, start2
);
926 end2
= FFMIN(peakpos
+ 3, end2
);
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);
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
]) {
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;
948 if (maxq
[w
*16+g
] < 21.544) {
949 sce
->zeroes
[w
*16+g
] = 1;
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);
959 for (w2
= 0; w2
< sce
->ics
.group_len
[w
]; w2
++) {
961 dist
+= quantize_band_cost(s
, coefs
+ w2
*128,
963 sce
->ics
.swb_sizes
[g
],
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
;
978 curdiff
= fabsf(dist
- uplim
[w
*16+g
]);
982 step
= log2f(curdiff
);
983 if (dist
> uplim
[w
*16+g
])
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
);
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];
1005 minq
= FFMIN(minq
, sce
->sf_idx
[i
]);
1007 if (minq
== INT_MAX
)
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
);
1018 static void search_for_quantizers_fast(AVCodecContext
*avctx
, AACEncContext
*s
,
1019 SingleChannelElement
*sce
,
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;
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;
1037 minq
= FFMIN(minq
, sce
->sf_idx
[(w
+w2
)*16+g
]);
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);
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
];
1052 static void search_for_ms(AACEncContext
*s
, ChannelElement
*cpe
,
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
)
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;
1075 - sce1
->coeffs
[start
+w2
*128+i
];
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,
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,
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
,
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
,
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
);
1106 cpe
->ms_mask
[w
*16+g
] = dist2
< dist1
;
1108 start
+= sce0
->ics
.swb_sizes
[g
];
1113 AACCoefficientsEncoder ff_aac_coders
[AAC_CODER_NB
] = {
1114 [AAC_CODER_FAAC
] = {
1115 search_for_quantizers_faac
,
1116 encode_window_bands_info
,
1117 quantize_and_encode_band
,
1120 [AAC_CODER_ANMR
] = {
1121 search_for_quantizers_anmr
,
1122 encode_window_bands_info
,
1123 quantize_and_encode_band
,
1126 [AAC_CODER_TWOLOOP
] = {
1127 search_for_quantizers_twoloop
,
1128 codebook_trellis_rate
,
1129 quantize_and_encode_band
,
1132 [AAC_CODER_FAST
] = {
1133 search_for_quantizers_fast
,
1134 encode_window_bands_info
,
1135 quantize_and_encode_band
,