Mercurial > libavcodec.hg
comparison aacsbr.c @ 11446:806dc446061d libavcodec
aacsbr: Make the previous value of bs_num_env local to read_sbr_data().
author | alexc |
---|---|
date | Tue, 09 Mar 2010 20:46:41 +0000 |
parents | bf53d3860a0d |
children | 826c8ee54ae9 |
comparison
equal
deleted
inserted
replaced
11445:bf53d3860a0d | 11446:806dc446061d |
---|---|
621 unsigned bs_pointer; | 621 unsigned bs_pointer; |
622 int abs_bord_lead = 0; | 622 int abs_bord_lead = 0; |
623 // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots | 623 // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots |
624 int abs_bord_trail = 16; | 624 int abs_bord_trail = 16; |
625 int num_rel_lead, num_rel_trail; | 625 int num_rel_lead, num_rel_trail; |
626 unsigned bs_num_env_old = ch_data->bs_num_env; | |
626 uint8_t bs_rel_bord[2][3]; | 627 uint8_t bs_rel_bord[2][3]; |
627 | 628 |
628 ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env[1]]; | 629 ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env]; |
629 ch_data->bs_num_env[0] = ch_data->bs_num_env[1]; | |
630 ch_data->bs_amp_res = sbr->bs_amp_res_header; | 630 ch_data->bs_amp_res = sbr->bs_amp_res_header; |
631 | 631 |
632 switch (ch_data->bs_frame_class = get_bits(gb, 2)) { | 632 switch (ch_data->bs_frame_class = get_bits(gb, 2)) { |
633 case FIXFIX: | 633 case FIXFIX: |
634 ch_data->bs_num_env[1] = 1 << get_bits(gb, 2); | 634 ch_data->bs_num_env = 1 << get_bits(gb, 2); |
635 num_rel_lead = ch_data->bs_num_env[1] - 1; | 635 num_rel_lead = ch_data->bs_num_env - 1; |
636 if (ch_data->bs_num_env[1] == 1) | 636 if (ch_data->bs_num_env == 1) |
637 ch_data->bs_amp_res = 0; | 637 ch_data->bs_amp_res = 0; |
638 | 638 |
639 if (ch_data->bs_num_env[1] > 4) { | 639 if (ch_data->bs_num_env > 4) { |
640 av_log(ac->avccontext, AV_LOG_ERROR, | 640 av_log(ac->avccontext, AV_LOG_ERROR, |
641 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n", | 641 "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n", |
642 ch_data->bs_num_env[1]); | 642 ch_data->bs_num_env); |
643 return -1; | 643 return -1; |
644 } | 644 } |
645 | 645 |
646 bs_pointer = 0; | 646 bs_pointer = 0; |
647 | 647 |
648 ch_data->bs_freq_res[1] = get_bits1(gb); | 648 ch_data->bs_freq_res[1] = get_bits1(gb); |
649 for (i = 1; i < ch_data->bs_num_env[1]; i++) | 649 for (i = 1; i < ch_data->bs_num_env; i++) |
650 ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1]; | 650 ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1]; |
651 break; | 651 break; |
652 case FIXVAR: | 652 case FIXVAR: |
653 abs_bord_trail += get_bits(gb, 2); | 653 abs_bord_trail += get_bits(gb, 2); |
654 num_rel_trail = get_bits(gb, 2); | 654 num_rel_trail = get_bits(gb, 2); |
655 num_rel_lead = 0; | 655 num_rel_lead = 0; |
656 ch_data->bs_num_env[1] = num_rel_trail + 1; | 656 ch_data->bs_num_env = num_rel_trail + 1; |
657 | 657 |
658 for (i = 0; i < num_rel_trail; i++) | 658 for (i = 0; i < num_rel_trail; i++) |
659 bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2; | 659 bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2; |
660 | 660 |
661 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]); | 661 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
662 | 662 |
663 for (i = 0; i < ch_data->bs_num_env[1]; i++) | 663 for (i = 0; i < ch_data->bs_num_env; i++) |
664 ch_data->bs_freq_res[ch_data->bs_num_env[1] - i] = get_bits1(gb); | 664 ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb); |
665 break; | 665 break; |
666 case VARFIX: | 666 case VARFIX: |
667 abs_bord_lead = get_bits(gb, 2); | 667 abs_bord_lead = get_bits(gb, 2); |
668 num_rel_lead = get_bits(gb, 2); | 668 num_rel_lead = get_bits(gb, 2); |
669 ch_data->bs_num_env[1] = num_rel_lead + 1; | 669 ch_data->bs_num_env = num_rel_lead + 1; |
670 | 670 |
671 for (i = 0; i < num_rel_lead; i++) | 671 for (i = 0; i < num_rel_lead; i++) |
672 bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2; | 672 bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2; |
673 | 673 |
674 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]); | 674 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
675 | 675 |
676 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env[1]); | 676 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); |
677 break; | 677 break; |
678 case VARVAR: | 678 case VARVAR: |
679 abs_bord_lead = get_bits(gb, 2); | 679 abs_bord_lead = get_bits(gb, 2); |
680 abs_bord_trail += get_bits(gb, 2); | 680 abs_bord_trail += get_bits(gb, 2); |
681 num_rel_lead = get_bits(gb, 2); | 681 num_rel_lead = get_bits(gb, 2); |
682 num_rel_trail = get_bits(gb, 2); | 682 num_rel_trail = get_bits(gb, 2); |
683 ch_data->bs_num_env[1] = num_rel_lead + num_rel_trail + 1; | 683 ch_data->bs_num_env = num_rel_lead + num_rel_trail + 1; |
684 | 684 |
685 if (ch_data->bs_num_env[1] > 5) { | 685 if (ch_data->bs_num_env > 5) { |
686 av_log(ac->avccontext, AV_LOG_ERROR, | 686 av_log(ac->avccontext, AV_LOG_ERROR, |
687 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n", | 687 "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n", |
688 ch_data->bs_num_env[1]); | 688 ch_data->bs_num_env); |
689 return -1; | 689 return -1; |
690 } | 690 } |
691 | 691 |
692 for (i = 0; i < num_rel_lead; i++) | 692 for (i = 0; i < num_rel_lead; i++) |
693 bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2; | 693 bs_rel_bord[0][i] = 2 * get_bits(gb, 2) + 2; |
694 for (i = 0; i < num_rel_trail; i++) | 694 for (i = 0; i < num_rel_trail; i++) |
695 bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2; | 695 bs_rel_bord[1][i] = 2 * get_bits(gb, 2) + 2; |
696 | 696 |
697 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env[1]]); | 697 bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]); |
698 | 698 |
699 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env[1]); | 699 get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env); |
700 break; | 700 break; |
701 } | 701 } |
702 | 702 |
703 if (bs_pointer > ch_data->bs_num_env[1] + 1) { | 703 if (bs_pointer > ch_data->bs_num_env + 1) { |
704 av_log(ac->avccontext, AV_LOG_ERROR, | 704 av_log(ac->avccontext, AV_LOG_ERROR, |
705 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n", | 705 "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n", |
706 bs_pointer); | 706 bs_pointer); |
707 return -1; | 707 return -1; |
708 } | 708 } |
709 | 709 |
710 ch_data->t_env_num_env_old = ch_data->t_env[ch_data->bs_num_env[0]]; | 710 ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old]; |
711 ch_data->t_env[0] = abs_bord_lead; | 711 ch_data->t_env[0] = abs_bord_lead; |
712 ch_data->t_env[ch_data->bs_num_env[1]] = abs_bord_trail; | 712 ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail; |
713 | 713 |
714 if (ch_data->bs_frame_class == FIXFIX) { | 714 if (ch_data->bs_frame_class == FIXFIX) { |
715 int temp = (abs_bord_trail + (ch_data->bs_num_env[1] >> 1)) / | 715 int temp = (abs_bord_trail + (ch_data->bs_num_env >> 1)) / |
716 ch_data->bs_num_env[1]; | 716 ch_data->bs_num_env; |
717 for (i = 0; i < num_rel_lead; i++) | 717 for (i = 0; i < num_rel_lead; i++) |
718 ch_data->t_env[i + 1] = ch_data->t_env[i] + temp; | 718 ch_data->t_env[i + 1] = ch_data->t_env[i] + temp; |
719 } else if (ch_data->bs_frame_class > 1) { // VARFIX or VARVAR | 719 } else if (ch_data->bs_frame_class > 1) { // VARFIX or VARVAR |
720 for (i = 0; i < num_rel_lead; i++) | 720 for (i = 0; i < num_rel_lead; i++) |
721 ch_data->t_env[i + 1] = ch_data->t_env[i] + bs_rel_bord[0][i]; | 721 ch_data->t_env[i + 1] = ch_data->t_env[i] + bs_rel_bord[0][i]; |
722 } | 722 } |
723 | 723 |
724 if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR | 724 if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR |
725 for (i = ch_data->bs_num_env[1] - 1; i > num_rel_lead; i--) | 725 for (i = ch_data->bs_num_env - 1; i > num_rel_lead; i--) |
726 ch_data->t_env[i] = ch_data->t_env[i + 1] - | 726 ch_data->t_env[i] = ch_data->t_env[i + 1] - |
727 bs_rel_bord[1][ch_data->bs_num_env[1] - 1 - i]; | 727 bs_rel_bord[1][ch_data->bs_num_env - 1 - i]; |
728 } | 728 } |
729 | 729 |
730 ch_data->bs_num_noise = (ch_data->bs_num_env[1] > 1) + 1; | 730 ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1; |
731 | 731 |
732 ch_data->t_q[0] = ch_data->t_env[0]; | 732 ch_data->t_q[0] = ch_data->t_env[0]; |
733 if (ch_data->bs_num_noise > 1) { | 733 if (ch_data->bs_num_noise > 1) { |
734 unsigned int idx; | 734 unsigned int idx; |
735 if (ch_data->bs_frame_class == FIXFIX) { | 735 if (ch_data->bs_frame_class == FIXFIX) { |
736 idx = ch_data->bs_num_env[1] >> 1; | 736 idx = ch_data->bs_num_env >> 1; |
737 } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR | 737 } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR |
738 idx = ch_data->bs_num_env[1] - FFMAX(bs_pointer - 1, 1); | 738 idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1); |
739 } else { // VARFIX | 739 } else { // VARFIX |
740 if (!bs_pointer) | 740 if (!bs_pointer) |
741 idx = 1; | 741 idx = 1; |
742 else if (bs_pointer == 1) | 742 else if (bs_pointer == 1) |
743 idx = ch_data->bs_num_env[1] - 1; | 743 idx = ch_data->bs_num_env - 1; |
744 else // bs_pointer > 1 | 744 else // bs_pointer > 1 |
745 idx = bs_pointer - 1; | 745 idx = bs_pointer - 1; |
746 } | 746 } |
747 ch_data->t_q[1] = ch_data->t_env[idx]; | 747 ch_data->t_q[1] = ch_data->t_env[idx]; |
748 ch_data->t_q[2] = ch_data->t_env[ch_data->bs_num_env[1]]; | 748 ch_data->t_q[2] = ch_data->t_env[ch_data->bs_num_env]; |
749 } else | 749 } else |
750 ch_data->t_q[1] = ch_data->t_env[ch_data->bs_num_env[1]]; | 750 ch_data->t_q[1] = ch_data->t_env[ch_data->bs_num_env]; |
751 | 751 |
752 ch_data->e_a[0] = -(ch_data->e_a[1] != ch_data->bs_num_env[0]); // l_APrev | 752 ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev |
753 ch_data->e_a[1] = -1; | 753 ch_data->e_a[1] = -1; |
754 if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0 | 754 if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0 |
755 ch_data->e_a[1] = ch_data->bs_num_env[1] + 1 - bs_pointer; | 755 ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer; |
756 } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1 | 756 } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1 |
757 ch_data->e_a[1] = bs_pointer - 1; | 757 ch_data->e_a[1] = bs_pointer - 1; |
758 | 758 |
759 return 0; | 759 return 0; |
760 } | 760 } |
761 | 761 |
762 static void copy_sbr_grid(SBRData *dst, const SBRData *src) { | 762 static void copy_sbr_grid(SBRData *dst, const SBRData *src) { |
763 //These variables are saved from the previous frame rather than copied | 763 //These variables are saved from the previous frame rather than copied |
764 dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env[1]]; | 764 dst->bs_freq_res[0] = dst->bs_freq_res[dst->bs_num_env]; |
765 dst->bs_num_env[0] = dst->bs_num_env[1]; | 765 dst->t_env_num_env_old = dst->t_env[dst->bs_num_env]; |
766 dst->t_env_num_env_old = dst->t_env[dst->bs_num_env[0]]; | 766 dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env); |
767 dst->e_a[0] = -(dst->e_a[1] != dst->bs_num_env[0]); | |
768 | 767 |
769 //These variables are read from the bitstream and therefore copied | 768 //These variables are read from the bitstream and therefore copied |
770 memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res)); | 769 memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res)); |
771 memcpy(dst->bs_num_env+1, src->bs_num_env+1, sizeof(dst->bs_num_env)- sizeof(*dst->bs_num_env)); | |
772 memcpy(dst->t_env, src->t_env, sizeof(dst->t_env)); | 770 memcpy(dst->t_env, src->t_env, sizeof(dst->t_env)); |
773 memcpy(dst->t_q, src->t_q, sizeof(dst->t_q)); | 771 memcpy(dst->t_q, src->t_q, sizeof(dst->t_q)); |
772 dst->bs_num_env = src->bs_num_env; | |
774 dst->bs_amp_res = src->bs_amp_res; | 773 dst->bs_amp_res = src->bs_amp_res; |
775 dst->bs_num_noise = src->bs_num_noise; | 774 dst->bs_num_noise = src->bs_num_noise; |
776 dst->bs_frame_class = src->bs_frame_class; | 775 dst->bs_frame_class = src->bs_frame_class; |
777 dst->e_a[1] = src->e_a[1]; | 776 dst->e_a[1] = src->e_a[1]; |
778 } | 777 } |
779 | 778 |
780 /// Read how the envelope and noise floor data is delta coded | 779 /// Read how the envelope and noise floor data is delta coded |
781 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, | 780 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb, |
782 SBRData *ch_data) | 781 SBRData *ch_data) |
783 { | 782 { |
784 get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env[1]); | 783 get_bits1_vector(gb, ch_data->bs_df_env, ch_data->bs_num_env); |
785 get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise); | 784 get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise); |
786 } | 785 } |
787 | 786 |
788 /// Read inverse filtering data | 787 /// Read inverse filtering data |
789 static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, | 788 static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb, |
834 f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table; | 833 f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table; |
835 f_lav = vlc_sbr_lav[F_HUFFMAN_ENV_1_5DB]; | 834 f_lav = vlc_sbr_lav[F_HUFFMAN_ENV_1_5DB]; |
836 } | 835 } |
837 } | 836 } |
838 | 837 |
839 for (i = 0; i < ch_data->bs_num_env[1]; i++) { | 838 for (i = 0; i < ch_data->bs_num_env; i++) { |
840 if (ch_data->bs_df_env[i]) { | 839 if (ch_data->bs_df_env[i]) { |
841 // bs_freq_res[0] == bs_freq_res[bs_num_env[1]] from prev frame | 840 // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame |
842 if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) { | 841 if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) { |
843 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) | 842 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) |
844 ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav); | 843 ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav); |
845 } else if (ch_data->bs_freq_res[i + 1]) { | 844 } else if (ch_data->bs_freq_res[i + 1]) { |
846 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) { | 845 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) { |
859 ch_data->env_facs[i + 1][j] = ch_data->env_facs[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav); | 858 ch_data->env_facs[i + 1][j] = ch_data->env_facs[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav); |
860 } | 859 } |
861 } | 860 } |
862 | 861 |
863 //assign 0th elements of env_facs from last elements | 862 //assign 0th elements of env_facs from last elements |
864 memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env[1]], | 863 memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env], |
865 sizeof(ch_data->env_facs[0])); | 864 sizeof(ch_data->env_facs[0])); |
866 } | 865 } |
867 | 866 |
868 static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb, | 867 static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb, |
869 SBRData *ch_data, int ch) | 868 SBRData *ch_data, int ch) |
1094 int ch; | 1093 int ch; |
1095 | 1094 |
1096 if (id_aac == TYPE_CPE && sbr->bs_coupling) { | 1095 if (id_aac == TYPE_CPE && sbr->bs_coupling) { |
1097 float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f; | 1096 float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f; |
1098 float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f; | 1097 float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f; |
1099 for (e = 1; e <= sbr->data[0].bs_num_env[1]; e++) { | 1098 for (e = 1; e <= sbr->data[0].bs_num_env; e++) { |
1100 for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) { | 1099 for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) { |
1101 float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f); | 1100 float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f); |
1102 float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha); | 1101 float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha); |
1103 float fac = temp1 / (1.0f + temp2); | 1102 float fac = temp1 / (1.0f + temp2); |
1104 sbr->data[0].env_facs[e][k] = fac; | 1103 sbr->data[0].env_facs[e][k] = fac; |
1115 } | 1114 } |
1116 } | 1115 } |
1117 } else { // SCE or one non-coupled CPE | 1116 } else { // SCE or one non-coupled CPE |
1118 for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) { | 1117 for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) { |
1119 float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f; | 1118 float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f; |
1120 for (e = 1; e <= sbr->data[ch].bs_num_env[1]; e++) | 1119 for (e = 1; e <= sbr->data[ch].bs_num_env; e++) |
1121 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++) | 1120 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++) |
1122 sbr->data[ch].env_facs[e][k] = | 1121 sbr->data[ch].env_facs[e][k] = |
1123 exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f); | 1122 exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f); |
1124 for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) | 1123 for (e = 1; e <= sbr->data[ch].bs_num_noise; e++) |
1125 for (k = 0; k < sbr->n_q; k++) | 1124 for (k = 0; k < sbr->n_q; k++) |
1454 SBRData *ch_data, int e_a[2]) | 1453 SBRData *ch_data, int e_a[2]) |
1455 { | 1454 { |
1456 int e, i, m; | 1455 int e, i, m; |
1457 | 1456 |
1458 memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1])); | 1457 memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1])); |
1459 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1458 for (e = 0; e < ch_data->bs_num_env; e++) { |
1460 const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]]; | 1459 const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]]; |
1461 uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; | 1460 uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; |
1462 int k; | 1461 int k; |
1463 | 1462 |
1464 for (i = 0; i < ilim; i++) | 1463 for (i = 0; i < ilim; i++) |
1492 memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present, | 1491 memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present, |
1493 (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0])); | 1492 (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0])); |
1494 } | 1493 } |
1495 } | 1494 } |
1496 | 1495 |
1497 memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env[1]], sizeof(ch_data->s_indexmapped[0])); | 1496 memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0])); |
1498 } | 1497 } |
1499 | 1498 |
1500 /// Estimation of current envelope (14496-3 sp04 p218) | 1499 /// Estimation of current envelope (14496-3 sp04 p218) |
1501 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2], | 1500 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2], |
1502 SpectralBandReplication *sbr, SBRData *ch_data) | 1501 SpectralBandReplication *sbr, SBRData *ch_data) |
1503 { | 1502 { |
1504 int e, i, m; | 1503 int e, i, m; |
1505 | 1504 |
1506 if (sbr->bs_interpol_freq) { | 1505 if (sbr->bs_interpol_freq) { |
1507 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1506 for (e = 0; e < ch_data->bs_num_env; e++) { |
1508 const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]); | 1507 const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]); |
1509 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; | 1508 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1510 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; | 1509 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1511 | 1510 |
1512 for (m = 0; m < sbr->m[1]; m++) { | 1511 for (m = 0; m < sbr->m[1]; m++) { |
1520 } | 1519 } |
1521 } | 1520 } |
1522 } else { | 1521 } else { |
1523 int k, p; | 1522 int k, p; |
1524 | 1523 |
1525 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1524 for (e = 0; e < ch_data->bs_num_env; e++) { |
1526 const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]); | 1525 const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]); |
1527 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; | 1526 int ilb = ch_data->t_env[e] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1528 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; | 1527 int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET; |
1529 const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; | 1528 const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow; |
1530 | 1529 |
1556 { | 1555 { |
1557 int e, k, m; | 1556 int e, k, m; |
1558 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off) | 1557 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off) |
1559 static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 }; | 1558 static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 }; |
1560 | 1559 |
1561 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1560 for (e = 0; e < ch_data->bs_num_env; e++) { |
1562 int delta = !((e == e_a[1]) || (e == e_a[0])); | 1561 int delta = !((e == e_a[1]) || (e == e_a[0])); |
1563 for (k = 0; k < sbr->n_lim; k++) { | 1562 for (k = 0; k < sbr->n_lim; k++) { |
1564 float gain_boost, gain_max; | 1563 float gain_boost, gain_max; |
1565 float sum[2] = { 0.0f, 0.0f }; | 1564 float sum[2] = { 0.0f, 0.0f }; |
1566 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { | 1565 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) { |
1639 } else if (h_SL) { | 1638 } else if (h_SL) { |
1640 memcpy(g_temp[2*ch_data->t_env[0]], g_temp[2*ch_data->t_env_num_env_old], 4*sizeof(g_temp[0])); | 1639 memcpy(g_temp[2*ch_data->t_env[0]], g_temp[2*ch_data->t_env_num_env_old], 4*sizeof(g_temp[0])); |
1641 memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0])); | 1640 memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0])); |
1642 } | 1641 } |
1643 | 1642 |
1644 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1643 for (e = 0; e < ch_data->bs_num_env; e++) { |
1645 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { | 1644 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { |
1646 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0])); | 1645 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0])); |
1647 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0])); | 1646 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0])); |
1648 } | 1647 } |
1649 } | 1648 } |
1650 | 1649 |
1651 for (e = 0; e < ch_data->bs_num_env[1]; e++) { | 1650 for (e = 0; e < ch_data->bs_num_env; e++) { |
1652 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { | 1651 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) { |
1653 int phi_sign = (1 - 2*(kx & 1)); | 1652 int phi_sign = (1 - 2*(kx & 1)); |
1654 | 1653 |
1655 if (h_SL && e != e_a[0] && e != e_a[1]) { | 1654 if (h_SL && e != e_a[0] && e != e_a[1]) { |
1656 for (m = 0; m < m_max; m++) { | 1655 for (m = 0; m < m_max; m++) { |
1735 if (sbr->start) { | 1734 if (sbr->start) { |
1736 sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]); | 1735 sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]); |
1737 sbr_chirp(sbr, &sbr->data[ch]); | 1736 sbr_chirp(sbr, &sbr->data[ch]); |
1738 sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1, | 1737 sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1, |
1739 sbr->data[ch].bw_array, sbr->data[ch].t_env, | 1738 sbr->data[ch].bw_array, sbr->data[ch].t_env, |
1740 sbr->data[ch].bs_num_env[1]); | 1739 sbr->data[ch].bs_num_env); |
1741 | 1740 |
1742 // hf_adj | 1741 // hf_adj |
1743 sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); | 1742 sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); |
1744 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]); | 1743 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]); |
1745 sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); | 1744 sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a); |