Mercurial > mplayer.hg

comparison libfaad2/sbr_fbt.c @ 13453:6d50ef45a058

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update FAAD to a 2.1 beta CVS snapshot from 2004.07.12. patch by adland <adland123 at yahoo dot com>
author diego
date Fri, 24 Sep 2004 17:31:36 +0000
parents d81145997036
children 2ae5ab4331ca
comparison
equal deleted inserted replaced
13452:c364b7c13dd8 13453:6d50ef45a058
21 ** 21 **
22 ** Commercial non-GPL licensing of this software is possible. 22 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com. 23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
24 ** 24 **
25 ** Initially modified for use with MPlayer by Arpad Gereöffy on 2003/08/30 25 ** Initially modified for use with MPlayer by Arpad Gereöffy on 2003/08/30
26 ** $Id: sbr_fbt.c,v 1.3 2004/06/02 22:59:03 diego Exp $ 26 ** $Id: sbr_fbt.c,v 1.4 2004/06/23 13:50:51 diego Exp $
27 ** detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/ 27 ** detailed CVS changelog at http://www.mplayerhq.hu/cgi-bin/cvsweb.cgi/main/
28 **/ 28 **/
29 29
30 /* Calculate frequency band tables */ 30 /* Calculate frequency band tables */
31 31
224 vDk[k] = dk; 224 vDk[k] = dk;
225 225
226 if (k2Diff) 226 if (k2Diff)
227 { 227 {
228 incr = (k2Diff > 0) ? -1 : 1; 228 incr = (k2Diff > 0) ? -1 : 1;
229 k = (k2Diff > 0) ? (nrBands-1) : 0; 229 k = (uint8_t) ((k2Diff > 0) ? (nrBands-1) : 0);
230 230
231 while (k2Diff != 0) 231 while (k2Diff != 0)
232 { 232 {
233 vDk[k] -= incr; 233 vDk[k] -= incr;
234 k += incr; 234 k += incr;
236 } 236 }
237 } 237 }
238 238
239 sbr->f_master[0] = k0; 239 sbr->f_master[0] = k0;
240 for (k = 1; k <= nrBands; k++) 240 for (k = 1; k <= nrBands; k++)
241 sbr->f_master[k] = sbr->f_master[k-1] + vDk[k-1]; 241 sbr->f_master[k] = (uint8_t)(sbr->f_master[k-1] + vDk[k-1]);
242 242
243 sbr->N_master = nrBands; 243 sbr->N_master = (uint8_t)nrBands;
244 sbr->N_master = min(sbr->N_master, 64); 244 sbr->N_master = (min(sbr->N_master, 64));
245 245
246 #if 0 246 #if 0
247 printf("f_master[%d]: ", nrBands); 247 printf("f_master[%d]: ", nrBands);
248 for (k = 0; k <= nrBands; k++) 248 for (k = 0; k <= nrBands; k++)
249 { 249 {
355 int32_t vDk0[64] = {0}, vDk1[64] = {0}; 355 int32_t vDk0[64] = {0}, vDk1[64] = {0};
356 int32_t vk0[64] = {0}, vk1[64] = {0}; 356 int32_t vk0[64] = {0}, vk1[64] = {0};
357 uint8_t temp1[] = { 6, 5, 4 }; 357 uint8_t temp1[] = { 6, 5, 4 };
358 real_t q, qk; 358 real_t q, qk;
359 int32_t A_1; 359 int32_t A_1;
360 #ifdef FIXED_POINT
361 real_t rk2, rk0;
362 #endif
360 363
361 /* mft only defined for k2 > k0 */ 364 /* mft only defined for k2 > k0 */
362 if (k2 <= k0) 365 if (k2 <= k0)
363 { 366 {
364 sbr->N_master = 0; 367 sbr->N_master = 0;
366 } 369 }
367 370
368 bands = temp1[bs_freq_scale-1]; 371 bands = temp1[bs_freq_scale-1];
369 372
370 #ifdef FIXED_POINT 373 #ifdef FIXED_POINT
371 if (REAL_CONST(k2) > MUL_R(REAL_CONST(k0),REAL_CONST(2.2449))) 374 rk0 = (real_t)k0 << REAL_BITS;
375 rk2 = (real_t)k2 << REAL_BITS;
376 if (rk2 > MUL_C(rk0, COEF_CONST(2.2449)))
372 #else 377 #else
373 if ((float)k2/(float)k0 > 2.2449) 378 if ((float)k2/(float)k0 > 2.2449)
374 #endif 379 #endif
375 { 380 {
376 twoRegions = 1; 381 twoRegions = 1;
378 } else { 383 } else {
379 twoRegions = 0; 384 twoRegions = 0;
380 k1 = k2; 385 k1 = k2;
381 } 386 }
382 387
383 nrBand0 = 2 * find_bands(0, bands, k0, k1); 388 nrBand0 = (uint8_t)(2 * find_bands(0, bands, k0, k1));
384 nrBand0 = min(nrBand0, 63); 389 nrBand0 = min(nrBand0, 63);
385 if (nrBand0 <= 0) 390 if (nrBand0 <= 0)
386 return 1; 391 return 1;
387 392
388 q = find_initial_power(nrBand0, k0, k1); 393 q = find_initial_power(nrBand0, k0, k1);
394 #ifdef FIXED_POINT
395 qk = (real_t)k0 << REAL_BITS;
396 //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
397 A_1 = k0;
398 #else
389 qk = REAL_CONST(k0); 399 qk = REAL_CONST(k0);
390 #ifdef FIXED_POINT
391 A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
392 #else
393 A_1 = (int32_t)(qk + .5); 400 A_1 = (int32_t)(qk + .5);
394 #endif 401 #endif
395 for (k = 0; k <= nrBand0; k++) 402 for (k = 0; k <= nrBand0; k++)
396 { 403 {
397 int32_t A_0 = A_1; 404 int32_t A_0 = A_1;
417 } 424 }
418 425
419 if (!twoRegions) 426 if (!twoRegions)
420 { 427 {
421 for (k = 0; k <= nrBand0; k++) 428 for (k = 0; k <= nrBand0; k++)
422 sbr->f_master[k] = vk0[k]; 429 sbr->f_master[k] = (uint8_t) vk0[k];
423 430
424 sbr->N_master = nrBand0; 431 sbr->N_master = nrBand0;
425 sbr->N_master = min(sbr->N_master, 64); 432 sbr->N_master = min(sbr->N_master, 64);
426 return 0; 433 return 0;
427 } 434 }
428 435
429 nrBand1 = 2 * find_bands(1 /* warped */, bands, k1, k2); 436 nrBand1 = (uint8_t)(2 * find_bands(1 /* warped */, bands, k1, k2));
430 nrBand1 = min(nrBand1, 63); 437 nrBand1 = min(nrBand1, 63);
431 438
432 q = find_initial_power(nrBand1, k1, k2); 439 q = find_initial_power(nrBand1, k1, k2);
440 #ifdef FIXED_POINT
441 qk = (real_t)k1 << REAL_BITS;
442 //A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
443 A_1 = k1;
444 #else
433 qk = REAL_CONST(k1); 445 qk = REAL_CONST(k1);
434 #ifdef FIXED_POINT
435 A_1 = (int32_t)((qk + REAL_CONST(0.5)) >> REAL_BITS);
436 #else
437 A_1 = (int32_t)(qk + .5); 446 A_1 = (int32_t)(qk + .5);
438 #endif 447 #endif
439 for (k = 0; k <= nrBand1 - 1; k++) 448 for (k = 0; k <= nrBand1 - 1; k++)
440 { 449 {
441 int32_t A_0 = A_1; 450 int32_t A_0 = A_1;
472 481
473 sbr->N_master = nrBand0 + nrBand1; 482 sbr->N_master = nrBand0 + nrBand1;
474 sbr->N_master = min(sbr->N_master, 64); 483 sbr->N_master = min(sbr->N_master, 64);
475 for (k = 0; k <= nrBand0; k++) 484 for (k = 0; k <= nrBand0; k++)
476 { 485 {
477 sbr->f_master[k] = vk0[k]; 486 sbr->f_master[k] = (uint8_t) vk0[k];
478 } 487 }
479 for (k = nrBand0 + 1; k <= sbr->N_master; k++) 488 for (k = nrBand0 + 1; k <= sbr->N_master; k++)
480 { 489 {
481 sbr->f_master[k] = vk1[k - nrBand0]; 490 sbr->f_master[k] = (uint8_t) vk1[k - nrBand0];
482 } 491 }
483 492
484 #if 0 493 #if 0
485 printf("f_master[%d]: ", sbr->N_master); 494 printf("f_master[%d]: ", sbr->N_master);
486 for (k = 0; k <= sbr->N_master; k++) 495 for (k = 0; k <= sbr->N_master; k++)
527 for (k = 0; k <= sbr->N_low; k++) 536 for (k = 0; k <= sbr->N_low; k++)
528 { 537 {
529 if (k == 0) 538 if (k == 0)
530 i = 0; 539 i = 0;
531 else 540 else
532 i = 2*k - minus; 541 i = (uint8_t)(2*k - minus);
533 sbr->f_table_res[LO_RES][k] = sbr->f_table_res[HI_RES][i]; 542 sbr->f_table_res[LO_RES][k] = sbr->f_table_res[HI_RES][i];
534 } 543 }
535 544
536 #if 0 545 #if 0
546 printf("bs_freq_scale: %d\n", sbr->bs_freq_scale);
547 printf("bs_limiter_bands: %d\n", sbr->bs_limiter_bands);
537 printf("f_table_res[HI_RES][%d]: ", sbr->N_high); 548 printf("f_table_res[HI_RES][%d]: ", sbr->N_high);
538 for (k = 0; k <= sbr->N_high; k++) 549 for (k = 0; k <= sbr->N_high; k++)
539 { 550 {
540 printf("%d ", sbr->f_table_res[HI_RES][k]); 551 printf("%d ", sbr->f_table_res[HI_RES][k]);
541 } 552 }
556 sbr->N_Q = 1; 567 sbr->N_Q = 1;
557 } else { 568 } else {
558 #if 0 569 #if 0
559 sbr->N_Q = max(1, (int32_t)(sbr->bs_noise_bands*(log(k2/(float)sbr->kx)/log(2.0)) + 0.5)); 570 sbr->N_Q = max(1, (int32_t)(sbr->bs_noise_bands*(log(k2/(float)sbr->kx)/log(2.0)) + 0.5));
560 #else 571 #else
561 sbr->N_Q = max(1, find_bands(0, sbr->bs_noise_bands, sbr->kx, k2)); 572 sbr->N_Q = (uint8_t)(max(1, find_bands(0, sbr->bs_noise_bands, sbr->kx, k2)));
562 #endif 573 #endif
563 sbr->N_Q = min(5, sbr->N_Q); 574 sbr->N_Q = min(5, sbr->N_Q);
564 } 575 }
565 576
566 for (k = 0; k <= sbr->N_Q; k++) 577 for (k = 0; k <= sbr->N_Q; k++)
592 603
593 #if 0 604 #if 0
594 printf("f_table_noise[%d]: ", sbr->N_Q); 605 printf("f_table_noise[%d]: ", sbr->N_Q);
595 for (k = 0; k <= sbr->N_Q; k++) 606 for (k = 0; k <= sbr->N_Q; k++)
596 { 607 {
597 printf("%d ", sbr->f_table_noise[k]); 608 printf("%d ", sbr->f_table_noise[k] - sbr->kx);
598 } 609 }
599 printf("\n"); 610 printf("\n");
600 #endif 611 #endif
601 612
602 return 0; 613 return 0;
611 { 622 {
612 #if 0 623 #if 0
613 static const real_t limiterBandsPerOctave[] = { REAL_CONST(1.2), 624 static const real_t limiterBandsPerOctave[] = { REAL_CONST(1.2),
614 REAL_CONST(2), REAL_CONST(3) }; 625 REAL_CONST(2), REAL_CONST(3) };
615 #else 626 #else
616 static const real_t limiterBandsCompare[] = { REAL_CONST(1.328125), 627 static const real_t limiterBandsCompare[] = { REAL_CONST(1.327152),
617 REAL_CONST(1.1875), REAL_CONST(1.125) }; 628 REAL_CONST(1.185093), REAL_CONST(1.119872) };
618 #endif 629 #endif
619 uint8_t k, s; 630 uint8_t k, s;
620 int8_t nrLim; 631 int8_t nrLim;
621 #if 0 632 #if 0
622 real_t limBands; 633 real_t limBands;
623 #endif 634 #endif
624 635
625 sbr->f_table_lim[0][0] = sbr->f_table_res[LO_RES][0] - sbr->kx; 636 sbr->f_table_lim[0][0] = sbr->f_table_res[LO_RES][0] - sbr->kx;
626 sbr->f_table_lim[0][1] = sbr->f_table_res[LO_RES][sbr->N_low] - sbr->kx; 637 sbr->f_table_lim[0][1] = sbr->f_table_res[LO_RES][sbr->N_low] - sbr->kx;
627 sbr->N_L[0] = 1; 638 sbr->N_L[0] = 1;
639
640 #if 0
641 printf("f_table_lim[%d][%d]: ", 0, sbr->N_L[0]);
642 for (k = 0; k <= sbr->N_L[0]; k++)
643 {
644 printf("%d ", sbr->f_table_lim[0][k]);
645 }
646 printf("\n");
647 #endif
628 648
629 for (s = 1; s < 4; s++) 649 for (s = 1; s < 4; s++)
630 { 650 {
631 int32_t limTable[100 /*TODO*/] = {0}; 651 int32_t limTable[100 /*TODO*/] = {0};
632 uint8_t patchBorders[64/*??*/] = {0}; 652 uint8_t patchBorders[64/*??*/] = {0};
664 real_t nOctaves; 684 real_t nOctaves;
665 685
666 if (limTable[k-1] != 0) 686 if (limTable[k-1] != 0)
667 #if 0 687 #if 0
668 nOctaves = REAL_CONST(log((float)limTable[k]/(float)limTable[k-1])/log(2.0)); 688 nOctaves = REAL_CONST(log((float)limTable[k]/(float)limTable[k-1])/log(2.0));
669 #endif 689 #else
670 #ifdef FIXED_POINT 690 #ifdef FIXED_POINT
671 nOctaves = SBR_DIV(REAL_CONST(limTable[k]),REAL_CONST(limTable[k-1])); 691 nOctaves = DIV_R((limTable[k]<<REAL_BITS),REAL_CONST(limTable[k-1]));
672 #else 692 #else
673 nOctaves = (real_t)limTable[k]/(real_t)limTable[k-1]; 693 nOctaves = (real_t)limTable[k]/(real_t)limTable[k-1];
694 #endif
674 #endif 695 #endif
675 else 696 else
676 nOctaves = 0; 697 nOctaves = 0;
677 698
678 #if 0 699 #if 0
679 if ((MUL(nOctaves,limBands)) < REAL_CONST(0.49)) 700 if ((MUL_R(nOctaves,limBands)) < REAL_CONST(0.49))
680 #else 701 #else
681 if (nOctaves < limiterBandsCompare[s - 1]) 702 if (nOctaves < limiterBandsCompare[s - 1])
682 #endif 703 #endif
683 { 704 {
684 uint8_t i; 705 uint8_t i;