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 */ 44static 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 */ 52static 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 56static const uint8_t *run_value_bits[2] = { 57 run_value_bits_long, run_value_bits_short 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 */ 66static 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 72static 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 86static 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 97static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17}; 98static 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 */ 105static 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) 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) \ 211static 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 223QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO, 1, 0, 0, 0) 224QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0) 225QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0) 226QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0) 227QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0) 228QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC, 0, 1, 1, 1) 229 230static 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 257static 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 266static 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) 269{ 270 quantize_and_encode_band_cost(s, pb, in, NULL, size, scale_idx, cb, lambda, 271 INFINITY, NULL); 272} 273 274static 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 285static 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)); 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 */ 303typedef struct BandCodingPath { 304 int prev_idx; ///< pointer to the previous path point 305 float cost; ///< path cost 306 int run; 307} BandCodingPath; 308 309/** 310 * Encode band info for single window group bands. 311 */ 312static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce, 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 413static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce, 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. */ 537static 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. */ 542static 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 546typedef 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 554static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s, 555 SingleChannelElement *sce, 556 const float lambda) 557{ 558 int q, w, w2, g, start = 0; 559 int i, j; 560 int idx; 561 TrellisPath paths[TRELLIS_STAGES][TRELLIS_STATES]; 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 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; 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 */ 707static void search_for_quantizers_twoloop(AVCodecContext *avctx, 708 AACEncContext *s, 709 SingleChannelElement *sce, 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 fflag = 0; 780 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { 781 start = w*128; 782 for (g = 0; g < sce->ics.num_swb; g++) { 783 const float *coefs = sce->coeffs + start; 784 const float *scaled = s->scoefs + start; 785 int bits = 0; 786 int cb; 787 float dist = 0.0f; 788 789 if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) { 790 start += sce->ics.swb_sizes[g]; 791 continue; 792 } 793 minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]); 794 cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]); 795 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) { 796 int b; 797 dist += quantize_band_cost(s, coefs + w2*128, 798 scaled + w2*128, 799 sce->ics.swb_sizes[g], 800 sce->sf_idx[w*16+g], 801 cb, 802 1.0f, 803 INFINITY, 804 &b); 805 bits += b; 806 } 807 dists[w*16+g] = dist - bits; 808 if (prev != -1) { 809 bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO]; 810 } 811 tbits += bits; 812 start += sce->ics.swb_sizes[g]; 813 prev = sce->sf_idx[w*16+g]; 814 } 815 } 816 if (tbits > destbits) { 817 for (i = 0; i < 128; i++) 818 if (sce->sf_idx[i] < 218 - qstep) 819 sce->sf_idx[i] += qstep; 820 } else { 821 for (i = 0; i < 128; i++) 822 if (sce->sf_idx[i] > 60 - qstep) 823 sce->sf_idx[i] -= qstep; 824 } 825 qstep >>= 1; 826 if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217) 827 qstep = 1; 828 } while (qstep); 829 830 fflag = 0; 831 minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF); 832 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { 833 for (g = 0; g < sce->ics.num_swb; g++) { 834 int prevsc = sce->sf_idx[w*16+g]; 835 if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) { 836 if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1)) 837 sce->sf_idx[w*16+g]--; 838 else //Try to make sure there is some energy in every band 839 sce->sf_idx[w*16+g]-=2; 840 } 841 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF); 842 sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219); 843 if (sce->sf_idx[w*16+g] != prevsc) 844 fflag = 1; 845 sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]); 846 } 847 } 848 its++; 849 } while (fflag && its < 10); 850} 851 852static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s, 853 SingleChannelElement *sce, 854 const float lambda) 855{ 856 int start = 0, i, w, w2, g; 857 float uplim[128], maxq[128]; 858 int minq, maxsf; 859 float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda; 860 int last = 0, lastband = 0, curband = 0; 861 float avg_energy = 0.0; 862 if (sce->ics.num_windows == 1) { 863 start = 0; 864 for (i = 0; i < 1024; i++) { 865 if (i - start >= sce->ics.swb_sizes[curband]) { 866 start += sce->ics.swb_sizes[curband]; 867 curband++; 868 } 869 if (sce->coeffs[i]) { 870 avg_energy += sce->coeffs[i] * sce->coeffs[i]; 871 last = i; 872 lastband = curband; 873 } 874 } 875 } else { 876 for (w = 0; w < 8; w++) { 877 const float *coeffs = sce->coeffs + w*128; 878 curband = start = 0; 879 for (i = 0; i < 128; i++) { 880 if (i - start >= sce->ics.swb_sizes[curband]) { 881 start += sce->ics.swb_sizes[curband]; 882 curband++; 883 } 884 if (coeffs[i]) { 885 avg_energy += coeffs[i] * coeffs[i]; 886 last = FFMAX(last, i); 887 lastband = FFMAX(lastband, curband); 888 } 889 } 890 } 891 } 892 last++; 893 avg_energy /= last; 894 if (avg_energy == 0.0f) { 895 for (i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++) 896 sce->sf_idx[i] = SCALE_ONE_POS; 897 return; 898 } 899 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { 900 start = w*128; 901 for (g = 0; g < sce->ics.num_swb; g++) { 902 float *coefs = sce->coeffs + start; 903 const int size = sce->ics.swb_sizes[g]; 904 int start2 = start, end2 = start + size, peakpos = start; 905 float maxval = -1, thr = 0.0f, t; 906 maxq[w*16+g] = 0.0f; 907 if (g > lastband) { 908 maxq[w*16+g] = 0.0f; 909 start += size; 910 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) 911 memset(coefs + w2*128, 0, sizeof(coefs[0])*size); 912 continue; 913 } 914 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) { 915 for (i = 0; i < size; i++) { 916 float t = coefs[w2*128+i]*coefs[w2*128+i]; 917 maxq[w*16+g] = FFMAX(maxq[w*16+g], fabsf(coefs[w2*128 + i])); 918 thr += t; 919 if (sce->ics.num_windows == 1 && maxval < t) { 920 maxval = t; 921 peakpos = start+i; 922 } 923 } 924 } 925 if (sce->ics.num_windows == 1) { 926 start2 = FFMAX(peakpos - 2, start2); 927 end2 = FFMIN(peakpos + 3, end2); 928 } else { 929 start2 -= start; 930 end2 -= start; 931 } 932 start += size; 933 thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband); 934 t = 1.0 - (1.0 * start2 / last); 935 uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075); 936 } 937 } 938 memset(sce->sf_idx, 0, sizeof(sce->sf_idx)); 939 abs_pow34_v(s->scoefs, sce->coeffs, 1024); 940 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { 941 start = w*128; 942 for (g = 0; g < sce->ics.num_swb; g++) { 943 const float *coefs = sce->coeffs + start; 944 const float *scaled = s->scoefs + start; 945 const int size = sce->ics.swb_sizes[g]; 946 int scf, prev_scf, step; 947 int min_scf = -1, max_scf = 256; 948 float curdiff; 949 if (maxq[w*16+g] < 21.544) { 950 sce->zeroes[w*16+g] = 1; 951 start += size; 952 continue; 953 } 954 sce->zeroes[w*16+g] = 0; 955 scf = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2f(1/maxq[w*16+g])*16/3, 60, 218); 956 step = 16; 957 for (;;) { 958 float dist = 0.0f; 959 int quant_max; 960 961 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) { 962 int b; 963 dist += quantize_band_cost(s, coefs + w2*128, 964 scaled + w2*128, 965 sce->ics.swb_sizes[g], 966 scf, 967 ESC_BT, 968 lambda, 969 INFINITY, 970 &b); 971 dist -= b; 972 } 973 dist *= 1.0f / 512.0f / lambda; 974 quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[POW_SF2_ZERO - scf + SCALE_ONE_POS - SCALE_DIV_512]); 975 if (quant_max >= 8191) { // too much, return to the previous quantizer 976 sce->sf_idx[w*16+g] = prev_scf; 977 break; 978 } 979 prev_scf = scf; 980 curdiff = fabsf(dist - uplim[w*16+g]); 981 if (curdiff <= 1.0f) 982 step = 0; 983 else 984 step = log2f(curdiff); 985 if (dist > uplim[w*16+g]) 986 step = -step; 987 scf += step; 988 scf = av_clip_uint8(scf); 989 step = scf - prev_scf; 990 if (FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)) { 991 sce->sf_idx[w*16+g] = av_clip(scf, min_scf, max_scf); 992 break; 993 } 994 if (step > 0) 995 min_scf = prev_scf; 996 else 997 max_scf = prev_scf; 998 } 999 start += size; 1000 } 1001 } 1002 minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX; 1003 for (i = 1; i < 128; i++) { 1004 if (!sce->sf_idx[i]) 1005 sce->sf_idx[i] = sce->sf_idx[i-1]; 1006 else 1007 minq = FFMIN(minq, sce->sf_idx[i]); 1008 } 1009 if (minq == INT_MAX) 1010 minq = 0; 1011 minq = FFMIN(minq, SCALE_MAX_POS); 1012 maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS); 1013 for (i = 126; i >= 0; i--) { 1014 if (!sce->sf_idx[i]) 1015 sce->sf_idx[i] = sce->sf_idx[i+1]; 1016 sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf); 1017 } 1018} 1019 1020static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s, 1021 SingleChannelElement *sce, 1022 const float lambda) 1023{ 1024 int i, w, w2, g; 1025 int minq = 255; 1026 1027 memset(sce->sf_idx, 0, sizeof(sce->sf_idx)); 1028 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) { 1029 for (g = 0; g < sce->ics.num_swb; g++) { 1030 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) { 1031 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g]; 1032 if (band->energy <= band->threshold) { 1033 sce->sf_idx[(w+w2)*16+g] = 218; 1034 sce->zeroes[(w+w2)*16+g] = 1; 1035 } else { 1036 sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2f(band->threshold), 80, 218); 1037 sce->zeroes[(w+w2)*16+g] = 0; 1038 } 1039 minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]); 1040 } 1041 } 1042 } 1043 for (i = 0; i < 128; i++) { 1044 sce->sf_idx[i] = 140; 1045 //av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1); 1046 } 1047 //set the same quantizers inside window groups 1048 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) 1049 for (g = 0; g < sce->ics.num_swb; g++) 1050 for (w2 = 1; w2 < sce->ics.group_len[w]; w2++) 1051 sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g]; 1052} 1053 1054static void search_for_ms(AACEncContext *s, ChannelElement *cpe, 1055 const float lambda) 1056{ 1057 int start = 0, i, w, w2, g; 1058 float M[128], S[128]; 1059 float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3; 1060 SingleChannelElement *sce0 = &cpe->ch[0]; 1061 SingleChannelElement *sce1 = &cpe->ch[1]; 1062 if (!cpe->common_window) 1063 return; 1064 for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) { 1065 for (g = 0; g < sce0->ics.num_swb; g++) { 1066 if (!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]) { 1067 float dist1 = 0.0f, dist2 = 0.0f; 1068 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) { 1069 FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g]; 1070 FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g]; 1071 float minthr = FFMIN(band0->threshold, band1->threshold); 1072 float maxthr = FFMAX(band0->threshold, band1->threshold); 1073 for (i = 0; i < sce0->ics.swb_sizes[g]; i++) { 1074 M[i] = (sce0->coeffs[start+w2*128+i] 1075 + sce1->coeffs[start+w2*128+i]) * 0.5; 1076 S[i] = M[i] 1077 - sce1->coeffs[start+w2*128+i]; 1078 } 1079 abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]); 1080 abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]); 1081 abs_pow34_v(M34, M, sce0->ics.swb_sizes[g]); 1082 abs_pow34_v(S34, S, sce0->ics.swb_sizes[g]); 1083 dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128, 1084 L34, 1085 sce0->ics.swb_sizes[g], 1086 sce0->sf_idx[(w+w2)*16+g], 1087 sce0->band_type[(w+w2)*16+g], 1088 lambda / band0->threshold, INFINITY, NULL); 1089 dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128, 1090 R34, 1091 sce1->ics.swb_sizes[g], 1092 sce1->sf_idx[(w+w2)*16+g], 1093 sce1->band_type[(w+w2)*16+g], 1094 lambda / band1->threshold, INFINITY, NULL); 1095 dist2 += quantize_band_cost(s, M, 1096 M34, 1097 sce0->ics.swb_sizes[g], 1098 sce0->sf_idx[(w+w2)*16+g], 1099 sce0->band_type[(w+w2)*16+g], 1100 lambda / maxthr, INFINITY, NULL); 1101 dist2 += quantize_band_cost(s, S, 1102 S34, 1103 sce1->ics.swb_sizes[g], 1104 sce1->sf_idx[(w+w2)*16+g], 1105 sce1->band_type[(w+w2)*16+g], 1106 lambda / minthr, INFINITY, NULL); 1107 } 1108 cpe->ms_mask[w*16+g] = dist2 < dist1; 1109 } 1110 start += sce0->ics.swb_sizes[g]; 1111 } 1112 } 1113} 1114 1115AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = { 1116 [AAC_CODER_FAAC] = { 1117 search_for_quantizers_faac, 1118 encode_window_bands_info, 1119 quantize_and_encode_band, 1120 search_for_ms, 1121 }, 1122 [AAC_CODER_ANMR] = { 1123 search_for_quantizers_anmr, 1124 encode_window_bands_info, 1125 quantize_and_encode_band, 1126 search_for_ms, 1127 }, 1128 [AAC_CODER_TWOLOOP] = { 1129 search_for_quantizers_twoloop, 1130 codebook_trellis_rate, 1131 quantize_and_encode_band, 1132 search_for_ms, 1133 }, 1134 [AAC_CODER_FAST] = { 1135 search_for_quantizers_fast, 1136 encode_window_bands_info, 1137 quantize_and_encode_band, 1138 search_for_ms, 1139 }, 1140}; 1141