Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * AAC Spectral Band Replication decoding functions
  3.  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
  4.  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
  5.  *
  6.  * Fixed point code
  7.  * Copyright (c) 2013
  8.  *      MIPS Technologies, Inc., California.
  9.  *
  10.  * This file is part of FFmpeg.
  11.  *
  12.  * FFmpeg is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU Lesser General Public
  14.  * License as published by the Free Software Foundation; either
  15.  * version 2.1 of the License, or (at your option) any later version.
  16.  *
  17.  * FFmpeg is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20.  * Lesser General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Lesser General Public
  23.  * License along with FFmpeg; if not, write to the Free Software
  24.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  25.  */
  26.  
  27. /**
  28.  * @file
  29.  * AAC Spectral Band Replication decoding functions
  30.  * @author Robert Swain ( rob opendot cl )
  31.  * @author Stanislav Ocovaj ( stanislav.ocovaj@imgtec.com )
  32.  * @author Zoran Basaric ( zoran.basaric@imgtec.com )
  33.  */
  34.  
  35. av_cold void AAC_RENAME(ff_aac_sbr_init)(void)
  36. {
  37.     static const struct {
  38.         const void *sbr_codes, *sbr_bits;
  39.         const unsigned int table_size, elem_size;
  40.     } sbr_tmp[] = {
  41.         SBR_VLC_ROW(t_huffman_env_1_5dB),
  42.         SBR_VLC_ROW(f_huffman_env_1_5dB),
  43.         SBR_VLC_ROW(t_huffman_env_bal_1_5dB),
  44.         SBR_VLC_ROW(f_huffman_env_bal_1_5dB),
  45.         SBR_VLC_ROW(t_huffman_env_3_0dB),
  46.         SBR_VLC_ROW(f_huffman_env_3_0dB),
  47.         SBR_VLC_ROW(t_huffman_env_bal_3_0dB),
  48.         SBR_VLC_ROW(f_huffman_env_bal_3_0dB),
  49.         SBR_VLC_ROW(t_huffman_noise_3_0dB),
  50.         SBR_VLC_ROW(t_huffman_noise_bal_3_0dB),
  51.     };
  52.  
  53.     // SBR VLC table initialization
  54.     SBR_INIT_VLC_STATIC(0, 1098);
  55.     SBR_INIT_VLC_STATIC(1, 1092);
  56.     SBR_INIT_VLC_STATIC(2, 768);
  57.     SBR_INIT_VLC_STATIC(3, 1026);
  58.     SBR_INIT_VLC_STATIC(4, 1058);
  59.     SBR_INIT_VLC_STATIC(5, 1052);
  60.     SBR_INIT_VLC_STATIC(6, 544);
  61.     SBR_INIT_VLC_STATIC(7, 544);
  62.     SBR_INIT_VLC_STATIC(8, 592);
  63.     SBR_INIT_VLC_STATIC(9, 512);
  64.  
  65.     aacsbr_tableinit();
  66.  
  67.     AAC_RENAME(ff_ps_init)();
  68. }
  69.  
  70. /** Places SBR in pure upsampling mode. */
  71. static void sbr_turnoff(SpectralBandReplication *sbr) {
  72.     sbr->start = 0;
  73.     sbr->ready_for_dequant = 0;
  74.     // Init defults used in pure upsampling mode
  75.     sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
  76.     sbr->m[1] = 0;
  77.     // Reset values for first SBR header
  78.     sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
  79.     memset(&sbr->spectrum_params, -1, sizeof(SpectrumParameters));
  80. }
  81.  
  82. av_cold void AAC_RENAME(ff_aac_sbr_ctx_init)(AACContext *ac, SpectralBandReplication *sbr)
  83. {
  84.     if(sbr->mdct.mdct_bits)
  85.         return;
  86.     sbr->kx[0] = sbr->kx[1];
  87.     sbr_turnoff(sbr);
  88.     sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
  89.     sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
  90.     /* SBR requires samples to be scaled to +/-32768.0 to work correctly.
  91.      * mdct scale factors are adjusted to scale up from +/-1.0 at analysis
  92.      * and scale back down at synthesis. */
  93.     AAC_RENAME_32(ff_mdct_init)(&sbr->mdct,     7, 1, 1.0 / (64 * 32768.0));
  94.     AAC_RENAME_32(ff_mdct_init)(&sbr->mdct_ana, 7, 1, -2.0 * 32768.0);
  95.     AAC_RENAME(ff_ps_ctx_init)(&sbr->ps);
  96.     AAC_RENAME(ff_sbrdsp_init)(&sbr->dsp);
  97.     aacsbr_func_ptr_init(&sbr->c);
  98. }
  99.  
  100. av_cold void AAC_RENAME(ff_aac_sbr_ctx_close)(SpectralBandReplication *sbr)
  101. {
  102.     AAC_RENAME_32(ff_mdct_end)(&sbr->mdct);
  103.     AAC_RENAME_32(ff_mdct_end)(&sbr->mdct_ana);
  104. }
  105.  
  106. static int qsort_comparison_function_int16(const void *a, const void *b)
  107. {
  108.     return *(const int16_t *)a - *(const int16_t *)b;
  109. }
  110.  
  111. static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
  112. {
  113.     int i;
  114.     for (i = 0; i <= last_el; i++)
  115.         if (table[i] == needle)
  116.             return 1;
  117.     return 0;
  118. }
  119.  
  120. /// Limiter Frequency Band Table (14496-3 sp04 p198)
  121. static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
  122. {
  123.     int k;
  124.     if (sbr->bs_limiter_bands > 0) {
  125.         static const INTFLOAT bands_warped[3] = { Q23(1.32715174233856803909f),   //2^(0.49/1.2)
  126.                                                Q23(1.18509277094158210129f),   //2^(0.49/2)
  127.                                                Q23(1.11987160404675912501f) }; //2^(0.49/3)
  128.         const INTFLOAT lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
  129.         int16_t patch_borders[7];
  130.         uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
  131.  
  132.         patch_borders[0] = sbr->kx[1];
  133.         for (k = 1; k <= sbr->num_patches; k++)
  134.             patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
  135.  
  136.         memcpy(sbr->f_tablelim, sbr->f_tablelow,
  137.                (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
  138.         if (sbr->num_patches > 1)
  139.             memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
  140.                    (sbr->num_patches - 1) * sizeof(patch_borders[0]));
  141.  
  142.         qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
  143.               sizeof(sbr->f_tablelim[0]),
  144.               qsort_comparison_function_int16);
  145.  
  146.         sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
  147.         while (out < sbr->f_tablelim + sbr->n_lim) {
  148. #if USE_FIXED
  149.             if ((*in << 23) >= *out * lim_bands_per_octave_warped) {
  150. #else
  151.             if (*in >= *out * lim_bands_per_octave_warped) {
  152. #endif /* USE_FIXED */
  153.                 *++out = *in++;
  154.             } else if (*in == *out ||
  155.                 !in_table_int16(patch_borders, sbr->num_patches, *in)) {
  156.                 in++;
  157.                 sbr->n_lim--;
  158.             } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
  159.                 *out = *in++;
  160.                 sbr->n_lim--;
  161.             } else {
  162.                 *++out = *in++;
  163.             }
  164.         }
  165.     } else {
  166.         sbr->f_tablelim[0] = sbr->f_tablelow[0];
  167.         sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
  168.         sbr->n_lim = 1;
  169.     }
  170. }
  171.  
  172. static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
  173. {
  174.     unsigned int cnt = get_bits_count(gb);
  175.     uint8_t bs_header_extra_1;
  176.     uint8_t bs_header_extra_2;
  177.     int old_bs_limiter_bands = sbr->bs_limiter_bands;
  178.     SpectrumParameters old_spectrum_params;
  179.  
  180.     sbr->start = 1;
  181.     sbr->ready_for_dequant = 0;
  182.  
  183.     // Save last spectrum parameters variables to compare to new ones
  184.     memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
  185.  
  186.     sbr->bs_amp_res_header              = get_bits1(gb);
  187.     sbr->spectrum_params.bs_start_freq  = get_bits(gb, 4);
  188.     sbr->spectrum_params.bs_stop_freq   = get_bits(gb, 4);
  189.     sbr->spectrum_params.bs_xover_band  = get_bits(gb, 3);
  190.                                           skip_bits(gb, 2); // bs_reserved
  191.  
  192.     bs_header_extra_1 = get_bits1(gb);
  193.     bs_header_extra_2 = get_bits1(gb);
  194.  
  195.     if (bs_header_extra_1) {
  196.         sbr->spectrum_params.bs_freq_scale  = get_bits(gb, 2);
  197.         sbr->spectrum_params.bs_alter_scale = get_bits1(gb);
  198.         sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2);
  199.     } else {
  200.         sbr->spectrum_params.bs_freq_scale  = 2;
  201.         sbr->spectrum_params.bs_alter_scale = 1;
  202.         sbr->spectrum_params.bs_noise_bands = 2;
  203.     }
  204.  
  205.     // Check if spectrum parameters changed
  206.     if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
  207.         sbr->reset = 1;
  208.  
  209.     if (bs_header_extra_2) {
  210.         sbr->bs_limiter_bands  = get_bits(gb, 2);
  211.         sbr->bs_limiter_gains  = get_bits(gb, 2);
  212.         sbr->bs_interpol_freq  = get_bits1(gb);
  213.         sbr->bs_smoothing_mode = get_bits1(gb);
  214.     } else {
  215.         sbr->bs_limiter_bands  = 2;
  216.         sbr->bs_limiter_gains  = 2;
  217.         sbr->bs_interpol_freq  = 1;
  218.         sbr->bs_smoothing_mode = 1;
  219.     }
  220.  
  221.     if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
  222.         sbr_make_f_tablelim(sbr);
  223.  
  224.     return get_bits_count(gb) - cnt;
  225. }
  226.  
  227. static int array_min_int16(const int16_t *array, int nel)
  228. {
  229.     int i, min = array[0];
  230.     for (i = 1; i < nel; i++)
  231.         min = FFMIN(array[i], min);
  232.     return min;
  233. }
  234.  
  235. static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
  236. {
  237.     // Requirements (14496-3 sp04 p205)
  238.     if (n_master <= 0) {
  239.         av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
  240.         return -1;
  241.     }
  242.     if (bs_xover_band >= n_master) {
  243.         av_log(avctx, AV_LOG_ERROR,
  244.                "Invalid bitstream, crossover band index beyond array bounds: %d\n",
  245.                bs_xover_band);
  246.         return -1;
  247.     }
  248.     return 0;
  249. }
  250.  
  251. /// Master Frequency Band Table (14496-3 sp04 p194)
  252. static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
  253.                              SpectrumParameters *spectrum)
  254. {
  255.     unsigned int temp, max_qmf_subbands = 0;
  256.     unsigned int start_min, stop_min;
  257.     int k;
  258.     const int8_t *sbr_offset_ptr;
  259.     int16_t stop_dk[13];
  260.  
  261.     if (sbr->sample_rate < 32000) {
  262.         temp = 3000;
  263.     } else if (sbr->sample_rate < 64000) {
  264.         temp = 4000;
  265.     } else
  266.         temp = 5000;
  267.  
  268.     switch (sbr->sample_rate) {
  269.     case 16000:
  270.         sbr_offset_ptr = sbr_offset[0];
  271.         break;
  272.     case 22050:
  273.         sbr_offset_ptr = sbr_offset[1];
  274.         break;
  275.     case 24000:
  276.         sbr_offset_ptr = sbr_offset[2];
  277.         break;
  278.     case 32000:
  279.         sbr_offset_ptr = sbr_offset[3];
  280.         break;
  281.     case 44100: case 48000: case 64000:
  282.         sbr_offset_ptr = sbr_offset[4];
  283.         break;
  284.     case 88200: case 96000: case 128000: case 176400: case 192000:
  285.         sbr_offset_ptr = sbr_offset[5];
  286.         break;
  287.     default:
  288.         av_log(ac->avctx, AV_LOG_ERROR,
  289.                "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
  290.         return -1;
  291.     }
  292.  
  293.     start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
  294.     stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
  295.  
  296.     sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
  297.  
  298.     if (spectrum->bs_stop_freq < 14) {
  299.         sbr->k[2] = stop_min;
  300.         make_bands(stop_dk, stop_min, 64, 13);
  301.         qsort(stop_dk, 13, sizeof(stop_dk[0]), qsort_comparison_function_int16);
  302.         for (k = 0; k < spectrum->bs_stop_freq; k++)
  303.             sbr->k[2] += stop_dk[k];
  304.     } else if (spectrum->bs_stop_freq == 14) {
  305.         sbr->k[2] = 2*sbr->k[0];
  306.     } else if (spectrum->bs_stop_freq == 15) {
  307.         sbr->k[2] = 3*sbr->k[0];
  308.     } else {
  309.         av_log(ac->avctx, AV_LOG_ERROR,
  310.                "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
  311.         return -1;
  312.     }
  313.     sbr->k[2] = FFMIN(64, sbr->k[2]);
  314.  
  315.     // Requirements (14496-3 sp04 p205)
  316.     if (sbr->sample_rate <= 32000) {
  317.         max_qmf_subbands = 48;
  318.     } else if (sbr->sample_rate == 44100) {
  319.         max_qmf_subbands = 35;
  320.     } else if (sbr->sample_rate >= 48000)
  321.         max_qmf_subbands = 32;
  322.     else
  323.         av_assert0(0);
  324.  
  325.     if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
  326.         av_log(ac->avctx, AV_LOG_ERROR,
  327.                "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
  328.         return -1;
  329.     }
  330.  
  331.     if (!spectrum->bs_freq_scale) {
  332.         int dk, k2diff;
  333.  
  334.         dk = spectrum->bs_alter_scale + 1;
  335.         sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
  336.         if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
  337.             return -1;
  338.  
  339.         for (k = 1; k <= sbr->n_master; k++)
  340.             sbr->f_master[k] = dk;
  341.  
  342.         k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
  343.         if (k2diff < 0) {
  344.             sbr->f_master[1]--;
  345.             sbr->f_master[2]-= (k2diff < -1);
  346.         } else if (k2diff) {
  347.             sbr->f_master[sbr->n_master]++;
  348.         }
  349.  
  350.         sbr->f_master[0] = sbr->k[0];
  351.         for (k = 1; k <= sbr->n_master; k++)
  352.             sbr->f_master[k] += sbr->f_master[k - 1];
  353.  
  354.     } else {
  355.         int half_bands = 7 - spectrum->bs_freq_scale;      // bs_freq_scale  = {1,2,3}
  356.         int two_regions, num_bands_0;
  357.         int vdk0_max, vdk1_min;
  358.         int16_t vk0[49];
  359. #if USE_FIXED
  360.         int tmp, nz = 0;
  361. #endif /* USE_FIXED */
  362.  
  363.         if (49 * sbr->k[2] > 110 * sbr->k[0]) {
  364.             two_regions = 1;
  365.             sbr->k[1] = 2 * sbr->k[0];
  366.         } else {
  367.             two_regions = 0;
  368.             sbr->k[1] = sbr->k[2];
  369.         }
  370.  
  371. #if USE_FIXED
  372.         tmp = (sbr->k[1] << 23) / sbr->k[0];
  373.         while (tmp < 0x40000000) {
  374.           tmp <<= 1;
  375.           nz++;
  376.         }
  377.         tmp = fixed_log(tmp - 0x80000000);
  378.         tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
  379.         tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
  380.         num_bands_0 = ((tmp + 0x400000) >> 23) * 2;
  381. #else
  382.         num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
  383. #endif /* USE_FIXED */
  384.  
  385.         if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
  386.             av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
  387.             return -1;
  388.         }
  389.  
  390.         vk0[0] = 0;
  391.  
  392.         make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
  393.  
  394.         qsort(vk0 + 1, num_bands_0, sizeof(vk0[1]), qsort_comparison_function_int16);
  395.         vdk0_max = vk0[num_bands_0];
  396.  
  397.         vk0[0] = sbr->k[0];
  398.         for (k = 1; k <= num_bands_0; k++) {
  399.             if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
  400.                 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
  401.                 return -1;
  402.             }
  403.             vk0[k] += vk0[k-1];
  404.         }
  405.  
  406.         if (two_regions) {
  407.             int16_t vk1[49];
  408. #if USE_FIXED
  409.             int num_bands_1;
  410.  
  411.             tmp = (sbr->k[2] << 23) / sbr->k[1];
  412.             nz = 0;
  413.             while (tmp < 0x40000000) {
  414.               tmp <<= 1;
  415.               nz++;
  416.             }
  417.             tmp = fixed_log(tmp - 0x80000000);
  418.             tmp = (int)(((int64_t)tmp * CONST_RECIP_LN2 + 0x20000000) >> 30);
  419.             tmp = (((tmp + 0x80) >> 8) + ((8 - nz) << 23)) * half_bands;
  420.             if (spectrum->bs_alter_scale)
  421.                 tmp = (int)(((int64_t)tmp * CONST_076923 + 0x40000000) >> 31);
  422.             num_bands_1 = ((tmp + 0x400000) >> 23) * 2;
  423. #else
  424.             float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
  425.                                                      : 1.0f; // bs_alter_scale = {0,1}
  426.             int num_bands_1 = lrintf(half_bands * invwarp *
  427.                                      log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
  428. #endif /* USE_FIXED */
  429.             make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
  430.  
  431.             vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
  432.  
  433.             if (vdk1_min < vdk0_max) {
  434.                 int change;
  435.                 qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
  436.                 change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
  437.                 vk1[1]           += change;
  438.                 vk1[num_bands_1] -= change;
  439.             }
  440.  
  441.             qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
  442.  
  443.             vk1[0] = sbr->k[1];
  444.             for (k = 1; k <= num_bands_1; k++) {
  445.                 if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
  446.                     av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
  447.                     return -1;
  448.                 }
  449.                 vk1[k] += vk1[k-1];
  450.             }
  451.  
  452.             sbr->n_master = num_bands_0 + num_bands_1;
  453.             if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
  454.                 return -1;
  455.             memcpy(&sbr->f_master[0],               vk0,
  456.                    (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
  457.             memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
  458.                     num_bands_1      * sizeof(sbr->f_master[0]));
  459.  
  460.         } else {
  461.             sbr->n_master = num_bands_0;
  462.             if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
  463.                 return -1;
  464.             memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
  465.         }
  466.     }
  467.  
  468.     return 0;
  469. }
  470.  
  471. /// High Frequency Generation - Patch Construction (14496-3 sp04 p216 fig. 4.46)
  472. static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
  473. {
  474.     int i, k, last_k = -1, last_msb = -1, sb = 0;
  475.     int msb = sbr->k[0];
  476.     int usb = sbr->kx[1];
  477.     int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
  478.  
  479.     sbr->num_patches = 0;
  480.  
  481.     if (goal_sb < sbr->kx[1] + sbr->m[1]) {
  482.         for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
  483.     } else
  484.         k = sbr->n_master;
  485.  
  486.     do {
  487.         int odd = 0;
  488.         if (k == last_k && msb == last_msb) {
  489.             av_log(ac->avctx, AV_LOG_ERROR, "patch construction failed\n");
  490.             return AVERROR_INVALIDDATA;
  491.         }
  492.         last_k = k;
  493.         last_msb = msb;
  494.         for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
  495.             sb = sbr->f_master[i];
  496.             odd = (sb + sbr->k[0]) & 1;
  497.         }
  498.  
  499.         // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
  500.         // After this check the final number of patches can still be six which is
  501.         // illegal however the Coding Technologies decoder check stream has a final
  502.         // count of 6 patches
  503.         if (sbr->num_patches > 5) {
  504.             av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
  505.             return -1;
  506.         }
  507.  
  508.         sbr->patch_num_subbands[sbr->num_patches]  = FFMAX(sb - usb, 0);
  509.         sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
  510.  
  511.         if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
  512.             usb = sb;
  513.             msb = sb;
  514.             sbr->num_patches++;
  515.         } else
  516.             msb = sbr->kx[1];
  517.  
  518.         if (sbr->f_master[k] - sb < 3)
  519.             k = sbr->n_master;
  520.     } while (sb != sbr->kx[1] + sbr->m[1]);
  521.  
  522.     if (sbr->num_patches > 1 &&
  523.         sbr->patch_num_subbands[sbr->num_patches - 1] < 3)
  524.         sbr->num_patches--;
  525.  
  526.     return 0;
  527. }
  528.  
  529. /// Derived Frequency Band Tables (14496-3 sp04 p197)
  530. static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
  531. {
  532.     int k, temp;
  533. #if USE_FIXED
  534.     int nz = 0;
  535. #endif /* USE_FIXED */
  536.  
  537.     sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
  538.     sbr->n[0] = (sbr->n[1] + 1) >> 1;
  539.  
  540.     memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
  541.            (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
  542.     sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
  543.     sbr->kx[1] = sbr->f_tablehigh[0];
  544.  
  545.     // Requirements (14496-3 sp04 p205)
  546.     if (sbr->kx[1] + sbr->m[1] > 64) {
  547.         av_log(ac->avctx, AV_LOG_ERROR,
  548.                "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
  549.         return -1;
  550.     }
  551.     if (sbr->kx[1] > 32) {
  552.         av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
  553.         return -1;
  554.     }
  555.  
  556.     sbr->f_tablelow[0] = sbr->f_tablehigh[0];
  557.     temp = sbr->n[1] & 1;
  558.     for (k = 1; k <= sbr->n[0]; k++)
  559.         sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
  560. #if USE_FIXED
  561.     temp = (sbr->k[2] << 23) / sbr->kx[1];
  562.     while (temp < 0x40000000) {
  563.         temp <<= 1;
  564.         nz++;
  565.     }
  566.     temp = fixed_log(temp - 0x80000000);
  567.     temp = (int)(((int64_t)temp * CONST_RECIP_LN2 + 0x20000000) >> 30);
  568.     temp = (((temp + 0x80) >> 8) + ((8 - nz) << 23)) * sbr->spectrum_params.bs_noise_bands;
  569.  
  570.     sbr->n_q = (temp + 0x400000) >> 23;
  571.     if (sbr->n_q < 1)
  572.         sbr->n_q = 1;
  573. #else
  574.     sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *
  575.                                log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
  576. #endif /* USE_FIXED */
  577.  
  578.     if (sbr->n_q > 5) {
  579.         av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
  580.         return -1;
  581.     }
  582.  
  583.     sbr->f_tablenoise[0] = sbr->f_tablelow[0];
  584.     temp = 0;
  585.     for (k = 1; k <= sbr->n_q; k++) {
  586.         temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
  587.         sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
  588.     }
  589.  
  590.     if (sbr_hf_calc_npatches(ac, sbr) < 0)
  591.         return -1;
  592.  
  593.     sbr_make_f_tablelim(sbr);
  594.  
  595.     sbr->data[0].f_indexnoise = 0;
  596.     sbr->data[1].f_indexnoise = 0;
  597.  
  598.     return 0;
  599. }
  600.  
  601. static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,
  602.                                               int elements)
  603. {
  604.     int i;
  605.     for (i = 0; i < elements; i++) {
  606.         vec[i] = get_bits1(gb);
  607.     }
  608. }
  609.  
  610. /** ceil(log2(index+1)) */
  611. static const int8_t ceil_log2[] = {
  612.     0, 1, 2, 2, 3, 3,
  613. };
  614.  
  615. static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
  616.                          GetBitContext *gb, SBRData *ch_data)
  617. {
  618.     int i;
  619.     int bs_pointer = 0;
  620.     // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
  621.     int abs_bord_trail = 16;
  622.     int num_rel_lead, num_rel_trail;
  623.     unsigned bs_num_env_old = ch_data->bs_num_env;
  624.  
  625.     ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
  626.     ch_data->bs_amp_res = sbr->bs_amp_res_header;
  627.     ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
  628.  
  629.     switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
  630.     case FIXFIX:
  631.         ch_data->bs_num_env                 = 1 << get_bits(gb, 2);
  632.         num_rel_lead                        = ch_data->bs_num_env - 1;
  633.         if (ch_data->bs_num_env == 1)
  634.             ch_data->bs_amp_res = 0;
  635.  
  636.         if (ch_data->bs_num_env > 4) {
  637.             av_log(ac->avctx, AV_LOG_ERROR,
  638.                    "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
  639.                    ch_data->bs_num_env);
  640.             return -1;
  641.         }
  642.  
  643.         ch_data->t_env[0]                   = 0;
  644.         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
  645.  
  646.         abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
  647.                    ch_data->bs_num_env;
  648.         for (i = 0; i < num_rel_lead; i++)
  649.             ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
  650.  
  651.         ch_data->bs_freq_res[1] = get_bits1(gb);
  652.         for (i = 1; i < ch_data->bs_num_env; i++)
  653.             ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
  654.         break;
  655.     case FIXVAR:
  656.         abs_bord_trail                     += get_bits(gb, 2);
  657.         num_rel_trail                       = get_bits(gb, 2);
  658.         ch_data->bs_num_env                 = num_rel_trail + 1;
  659.         ch_data->t_env[0]                   = 0;
  660.         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
  661.  
  662.         for (i = 0; i < num_rel_trail; i++)
  663.             ch_data->t_env[ch_data->bs_num_env - 1 - i] =
  664.                 ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
  665.  
  666.         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
  667.  
  668.         for (i = 0; i < ch_data->bs_num_env; i++)
  669.             ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
  670.         break;
  671.     case VARFIX:
  672.         ch_data->t_env[0]                   = get_bits(gb, 2);
  673.         num_rel_lead                        = get_bits(gb, 2);
  674.         ch_data->bs_num_env                 = num_rel_lead + 1;
  675.         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
  676.  
  677.         for (i = 0; i < num_rel_lead; i++)
  678.             ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
  679.  
  680.         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
  681.  
  682.         get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
  683.         break;
  684.     case VARVAR:
  685.         ch_data->t_env[0]                   = get_bits(gb, 2);
  686.         abs_bord_trail                     += get_bits(gb, 2);
  687.         num_rel_lead                        = get_bits(gb, 2);
  688.         num_rel_trail                       = get_bits(gb, 2);
  689.         ch_data->bs_num_env                 = num_rel_lead + num_rel_trail + 1;
  690.  
  691.         if (ch_data->bs_num_env > 5) {
  692.             av_log(ac->avctx, AV_LOG_ERROR,
  693.                    "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
  694.                    ch_data->bs_num_env);
  695.             return -1;
  696.         }
  697.  
  698.         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
  699.  
  700.         for (i = 0; i < num_rel_lead; i++)
  701.             ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
  702.         for (i = 0; i < num_rel_trail; i++)
  703.             ch_data->t_env[ch_data->bs_num_env - 1 - i] =
  704.                 ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
  705.  
  706.         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
  707.  
  708.         get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
  709.         break;
  710.     }
  711.  
  712.     av_assert0(bs_pointer >= 0);
  713.     if (bs_pointer > ch_data->bs_num_env + 1) {
  714.         av_log(ac->avctx, AV_LOG_ERROR,
  715.                "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
  716.                bs_pointer);
  717.         return -1;
  718.     }
  719.  
  720.     for (i = 1; i <= ch_data->bs_num_env; i++) {
  721.         if (ch_data->t_env[i-1] >= ch_data->t_env[i]) {
  722.             av_log(ac->avctx, AV_LOG_ERROR, "Not strictly monotone time borders\n");
  723.             return -1;
  724.         }
  725.     }
  726.  
  727.     ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
  728.  
  729.     ch_data->t_q[0]                     = ch_data->t_env[0];
  730.     ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
  731.     if (ch_data->bs_num_noise > 1) {
  732.         int idx;
  733.         if (ch_data->bs_frame_class == FIXFIX) {
  734.             idx = ch_data->bs_num_env >> 1;
  735.         } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
  736.             idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
  737.         } else { // VARFIX
  738.             if (!bs_pointer)
  739.                 idx = 1;
  740.             else if (bs_pointer == 1)
  741.                 idx = ch_data->bs_num_env - 1;
  742.             else // bs_pointer > 1
  743.                 idx = bs_pointer - 1;
  744.         }
  745.         ch_data->t_q[1] = ch_data->t_env[idx];
  746.     }
  747.  
  748.     ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
  749.     ch_data->e_a[1] = -1;
  750.     if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
  751.         ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
  752.     } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
  753.         ch_data->e_a[1] = bs_pointer - 1;
  754.  
  755.     return 0;
  756. }
  757.  
  758. static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
  759.     //These variables are saved from the previous frame rather than copied
  760.     dst->bs_freq_res[0]    = dst->bs_freq_res[dst->bs_num_env];
  761.     dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
  762.     dst->e_a[0]            = -(dst->e_a[1] != dst->bs_num_env);
  763.  
  764.     //These variables are read from the bitstream and therefore copied
  765.     memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
  766.     memcpy(dst->t_env,         src->t_env,         sizeof(dst->t_env));
  767.     memcpy(dst->t_q,           src->t_q,           sizeof(dst->t_q));
  768.     dst->bs_num_env        = src->bs_num_env;
  769.     dst->bs_amp_res        = src->bs_amp_res;
  770.     dst->bs_num_noise      = src->bs_num_noise;
  771.     dst->bs_frame_class    = src->bs_frame_class;
  772.     dst->e_a[1]            = src->e_a[1];
  773. }
  774.  
  775. /// Read how the envelope and noise floor data is delta coded
  776. static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
  777.                           SBRData *ch_data)
  778. {
  779.     get_bits1_vector(gb, ch_data->bs_df_env,   ch_data->bs_num_env);
  780.     get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
  781. }
  782.  
  783. /// Read inverse filtering data
  784. static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
  785.                           SBRData *ch_data)
  786. {
  787.     int i;
  788.  
  789.     memcpy(ch_data->bs_invf_mode[1], ch_data->bs_invf_mode[0], 5 * sizeof(uint8_t));
  790.     for (i = 0; i < sbr->n_q; i++)
  791.         ch_data->bs_invf_mode[0][i] = get_bits(gb, 2);
  792. }
  793.  
  794. static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
  795.                               SBRData *ch_data, int ch)
  796. {
  797.     int bits;
  798.     int i, j, k;
  799.     VLC_TYPE (*t_huff)[2], (*f_huff)[2];
  800.     int t_lav, f_lav;
  801.     const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
  802.     const int odd = sbr->n[1] & 1;
  803.  
  804.     if (sbr->bs_coupling && ch) {
  805.         if (ch_data->bs_amp_res) {
  806.             bits   = 5;
  807.             t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_3_0DB].table;
  808.             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_BAL_3_0DB];
  809.             f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
  810.             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_3_0DB];
  811.         } else {
  812.             bits   = 6;
  813.             t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_1_5DB].table;
  814.             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_BAL_1_5DB];
  815.             f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_1_5DB].table;
  816.             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_1_5DB];
  817.         }
  818.     } else {
  819.         if (ch_data->bs_amp_res) {
  820.             bits   = 6;
  821.             t_huff = vlc_sbr[T_HUFFMAN_ENV_3_0DB].table;
  822.             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_3_0DB];
  823.             f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
  824.             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_3_0DB];
  825.         } else {
  826.             bits   = 7;
  827.             t_huff = vlc_sbr[T_HUFFMAN_ENV_1_5DB].table;
  828.             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_1_5DB];
  829.             f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table;
  830.             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_1_5DB];
  831.         }
  832.     }
  833.  
  834. #if USE_FIXED
  835.     for (i = 0; i < ch_data->bs_num_env; i++) {
  836.         if (ch_data->bs_df_env[i]) {
  837.             // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
  838.             if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
  839.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
  840.                     ch_data->env_facs[i + 1][j].mant = ch_data->env_facs[i][j].mant + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  841.             } else if (ch_data->bs_freq_res[i + 1]) {
  842.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
  843.                     k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
  844.                     ch_data->env_facs[i + 1][j].mant = ch_data->env_facs[i][k].mant + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  845.                 }
  846.             } else {
  847.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
  848.                     k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
  849.                     ch_data->env_facs[i + 1][j].mant = ch_data->env_facs[i][k].mant + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  850.                 }
  851.             }
  852.         } else {
  853.             ch_data->env_facs[i + 1][0].mant = delta * get_bits(gb, bits); // bs_env_start_value_balance
  854.             for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
  855.                 ch_data->env_facs[i + 1][j].mant = ch_data->env_facs[i + 1][j - 1].mant + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav);
  856.         }
  857.     }
  858. #else
  859.     for (i = 0; i < ch_data->bs_num_env; i++) {
  860.         if (ch_data->bs_df_env[i]) {
  861.             // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
  862.             if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
  863.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
  864.                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  865.             } else if (ch_data->bs_freq_res[i + 1]) {
  866.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
  867.                     k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
  868.                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  869.                 }
  870.             } else {
  871.                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
  872.                     k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
  873.                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
  874.                 }
  875.             }
  876.         } else {
  877.             ch_data->env_facs[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
  878.             for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
  879.                 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);
  880.         }
  881.     }
  882. #endif /* USE_FIXED */
  883.  
  884.     //assign 0th elements of env_facs from last elements
  885.     memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env],
  886.            sizeof(ch_data->env_facs[0]));
  887. }
  888.  
  889. static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb,
  890.                            SBRData *ch_data, int ch)
  891. {
  892.     int i, j;
  893.     VLC_TYPE (*t_huff)[2], (*f_huff)[2];
  894.     int t_lav, f_lav;
  895.     int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
  896.  
  897.     if (sbr->bs_coupling && ch) {
  898.         t_huff = vlc_sbr[T_HUFFMAN_NOISE_BAL_3_0DB].table;
  899.         t_lav  = vlc_sbr_lav[T_HUFFMAN_NOISE_BAL_3_0DB];
  900.         f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
  901.         f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_3_0DB];
  902.     } else {
  903.         t_huff = vlc_sbr[T_HUFFMAN_NOISE_3_0DB].table;
  904.         t_lav  = vlc_sbr_lav[T_HUFFMAN_NOISE_3_0DB];
  905.         f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
  906.         f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_3_0DB];
  907.     }
  908.  
  909. #if USE_FIXED
  910.     for (i = 0; i < ch_data->bs_num_noise; i++) {
  911.         if (ch_data->bs_df_noise[i]) {
  912.             for (j = 0; j < sbr->n_q; j++)
  913.                 ch_data->noise_facs[i + 1][j].mant = ch_data->noise_facs[i][j].mant + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav);
  914.         } else {
  915.             ch_data->noise_facs[i + 1][0].mant = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
  916.             for (j = 1; j < sbr->n_q; j++)
  917.                 ch_data->noise_facs[i + 1][j].mant = ch_data->noise_facs[i + 1][j - 1].mant + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav);
  918.         }
  919.     }
  920. #else
  921.     for (i = 0; i < ch_data->bs_num_noise; i++) {
  922.         if (ch_data->bs_df_noise[i]) {
  923.             for (j = 0; j < sbr->n_q; j++)
  924.                 ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav);
  925.         } else {
  926.             ch_data->noise_facs[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
  927.             for (j = 1; j < sbr->n_q; j++)
  928.                 ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i + 1][j - 1] + delta * (get_vlc2(gb, f_huff, 9, 3) - f_lav);
  929.         }
  930.     }
  931. #endif /* USE_FIXED */
  932.  
  933.     //assign 0th elements of noise_facs from last elements
  934.     memcpy(ch_data->noise_facs[0], ch_data->noise_facs[ch_data->bs_num_noise],
  935.            sizeof(ch_data->noise_facs[0]));
  936. }
  937.  
  938. static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
  939.                                GetBitContext *gb,
  940.                                int bs_extension_id, int *num_bits_left)
  941. {
  942.     switch (bs_extension_id) {
  943.     case EXTENSION_ID_PS:
  944.         if (!ac->oc[1].m4ac.ps) {
  945.             av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
  946.             skip_bits_long(gb, *num_bits_left); // bs_fill_bits
  947.             *num_bits_left = 0;
  948.         } else {
  949. #if 1
  950.             *num_bits_left -= AAC_RENAME(ff_ps_read_data)(ac->avctx, gb, &sbr->ps, *num_bits_left);
  951.             ac->avctx->profile = FF_PROFILE_AAC_HE_V2;
  952. #else
  953.             avpriv_report_missing_feature(ac->avctx, "Parametric Stereo");
  954.             skip_bits_long(gb, *num_bits_left); // bs_fill_bits
  955.             *num_bits_left = 0;
  956. #endif
  957.         }
  958.         break;
  959.     default:
  960.         // some files contain 0-padding
  961.         if (bs_extension_id || *num_bits_left > 16 || show_bits(gb, *num_bits_left))
  962.             avpriv_request_sample(ac->avctx, "Reserved SBR extensions");
  963.         skip_bits_long(gb, *num_bits_left); // bs_fill_bits
  964.         *num_bits_left = 0;
  965.         break;
  966.     }
  967. }
  968.  
  969. static int read_sbr_single_channel_element(AACContext *ac,
  970.                                             SpectralBandReplication *sbr,
  971.                                             GetBitContext *gb)
  972. {
  973.     if (get_bits1(gb)) // bs_data_extra
  974.         skip_bits(gb, 4); // bs_reserved
  975.  
  976.     if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
  977.         return -1;
  978.     read_sbr_dtdf(sbr, gb, &sbr->data[0]);
  979.     read_sbr_invf(sbr, gb, &sbr->data[0]);
  980.     read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
  981.     read_sbr_noise(sbr, gb, &sbr->data[0], 0);
  982.  
  983.     if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
  984.         get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
  985.  
  986.     return 0;
  987. }
  988.  
  989. static int read_sbr_channel_pair_element(AACContext *ac,
  990.                                           SpectralBandReplication *sbr,
  991.                                           GetBitContext *gb)
  992. {
  993.     if (get_bits1(gb))    // bs_data_extra
  994.         skip_bits(gb, 8); // bs_reserved
  995.  
  996.     if ((sbr->bs_coupling = get_bits1(gb))) {
  997.         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
  998.             return -1;
  999.         copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
  1000.         read_sbr_dtdf(sbr, gb, &sbr->data[0]);
  1001.         read_sbr_dtdf(sbr, gb, &sbr->data[1]);
  1002.         read_sbr_invf(sbr, gb, &sbr->data[0]);
  1003.         memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
  1004.         memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
  1005.         read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
  1006.         read_sbr_noise(sbr, gb, &sbr->data[0], 0);
  1007.         read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
  1008.         read_sbr_noise(sbr, gb, &sbr->data[1], 1);
  1009.     } else {
  1010.         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
  1011.             read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
  1012.             return -1;
  1013.         read_sbr_dtdf(sbr, gb, &sbr->data[0]);
  1014.         read_sbr_dtdf(sbr, gb, &sbr->data[1]);
  1015.         read_sbr_invf(sbr, gb, &sbr->data[0]);
  1016.         read_sbr_invf(sbr, gb, &sbr->data[1]);
  1017.         read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
  1018.         read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
  1019.         read_sbr_noise(sbr, gb, &sbr->data[0], 0);
  1020.         read_sbr_noise(sbr, gb, &sbr->data[1], 1);
  1021.     }
  1022.  
  1023.     if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
  1024.         get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
  1025.     if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
  1026.         get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
  1027.  
  1028.     return 0;
  1029. }
  1030.  
  1031. static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
  1032.                                   GetBitContext *gb, int id_aac)
  1033. {
  1034.     unsigned int cnt = get_bits_count(gb);
  1035.  
  1036.     sbr->id_aac = id_aac;
  1037.     sbr->ready_for_dequant = 1;
  1038.  
  1039.     if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
  1040.         if (read_sbr_single_channel_element(ac, sbr, gb)) {
  1041.             sbr_turnoff(sbr);
  1042.             return get_bits_count(gb) - cnt;
  1043.         }
  1044.     } else if (id_aac == TYPE_CPE) {
  1045.         if (read_sbr_channel_pair_element(ac, sbr, gb)) {
  1046.             sbr_turnoff(sbr);
  1047.             return get_bits_count(gb) - cnt;
  1048.         }
  1049.     } else {
  1050.         av_log(ac->avctx, AV_LOG_ERROR,
  1051.             "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
  1052.         sbr_turnoff(sbr);
  1053.         return get_bits_count(gb) - cnt;
  1054.     }
  1055.     if (get_bits1(gb)) { // bs_extended_data
  1056.         int num_bits_left = get_bits(gb, 4); // bs_extension_size
  1057.         if (num_bits_left == 15)
  1058.             num_bits_left += get_bits(gb, 8); // bs_esc_count
  1059.  
  1060.         num_bits_left <<= 3;
  1061.         while (num_bits_left > 7) {
  1062.             num_bits_left -= 2;
  1063.             read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
  1064.         }
  1065.         if (num_bits_left < 0) {
  1066.             av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
  1067.         }
  1068.         if (num_bits_left > 0)
  1069.             skip_bits(gb, num_bits_left);
  1070.     }
  1071.  
  1072.     return get_bits_count(gb) - cnt;
  1073. }
  1074.  
  1075. static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
  1076. {
  1077.     int err;
  1078.     err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
  1079.     if (err >= 0)
  1080.         err = sbr_make_f_derived(ac, sbr);
  1081.     if (err < 0) {
  1082.         av_log(ac->avctx, AV_LOG_ERROR,
  1083.                "SBR reset failed. Switching SBR to pure upsampling mode.\n");
  1084.         sbr_turnoff(sbr);
  1085.     }
  1086. }
  1087.  
  1088. /**
  1089.  * Decode Spectral Band Replication extension data; reference: table 4.55.
  1090.  *
  1091.  * @param   crc flag indicating the presence of CRC checksum
  1092.  * @param   cnt length of TYPE_FIL syntactic element in bytes
  1093.  *
  1094.  * @return  Returns number of bytes consumed from the TYPE_FIL element.
  1095.  */
  1096. int AAC_RENAME(ff_decode_sbr_extension)(AACContext *ac, SpectralBandReplication *sbr,
  1097.                             GetBitContext *gb_host, int crc, int cnt, int id_aac)
  1098. {
  1099.     unsigned int num_sbr_bits = 0, num_align_bits;
  1100.     unsigned bytes_read;
  1101.     GetBitContext gbc = *gb_host, *gb = &gbc;
  1102.     skip_bits_long(gb_host, cnt*8 - 4);
  1103.  
  1104.     sbr->reset = 0;
  1105.  
  1106.     if (!sbr->sample_rate)
  1107.         sbr->sample_rate = 2 * ac->oc[1].m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
  1108.     if (!ac->oc[1].m4ac.ext_sample_rate)
  1109.         ac->oc[1].m4ac.ext_sample_rate = 2 * ac->oc[1].m4ac.sample_rate;
  1110.  
  1111.     if (crc) {
  1112.         skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
  1113.         num_sbr_bits += 10;
  1114.     }
  1115.  
  1116.     //Save some state from the previous frame.
  1117.     sbr->kx[0] = sbr->kx[1];
  1118.     sbr->m[0] = sbr->m[1];
  1119.     sbr->kx_and_m_pushed = 1;
  1120.  
  1121.     num_sbr_bits++;
  1122.     if (get_bits1(gb)) // bs_header_flag
  1123.         num_sbr_bits += read_sbr_header(sbr, gb);
  1124.  
  1125.     if (sbr->reset)
  1126.         sbr_reset(ac, sbr);
  1127.  
  1128.     if (sbr->start)
  1129.         num_sbr_bits  += read_sbr_data(ac, sbr, gb, id_aac);
  1130.  
  1131.     num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
  1132.     bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
  1133.  
  1134.     if (bytes_read > cnt) {
  1135.         av_log(ac->avctx, AV_LOG_ERROR,
  1136.                "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
  1137.     }
  1138.     return cnt;
  1139. }
  1140.  
  1141. /**
  1142.  * Analysis QMF Bank (14496-3 sp04 p206)
  1143.  *
  1144.  * @param   x       pointer to the beginning of the first sample window
  1145.  * @param   W       array of complex-valued samples split into subbands
  1146.  */
  1147. #ifndef sbr_qmf_analysis
  1148. #if USE_FIXED
  1149. static void sbr_qmf_analysis(AVFixedDSPContext *dsp, FFTContext *mdct,
  1150. #else
  1151. static void sbr_qmf_analysis(AVFloatDSPContext *dsp, FFTContext *mdct,
  1152. #endif /* USE_FIXED */
  1153.                              SBRDSPContext *sbrdsp, const INTFLOAT *in, INTFLOAT *x,
  1154.                              INTFLOAT z[320], INTFLOAT W[2][32][32][2], int buf_idx)
  1155. {
  1156.     int i;
  1157. #if USE_FIXED
  1158.     int j;
  1159. #endif
  1160.     memcpy(x    , x+1024, (320-32)*sizeof(x[0]));
  1161.     memcpy(x+288, in,         1024*sizeof(x[0]));
  1162.     for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
  1163.                                // are not supported
  1164.         dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
  1165.         sbrdsp->sum64x5(z);
  1166.         sbrdsp->qmf_pre_shuffle(z);
  1167. #if USE_FIXED
  1168.         for (j = 64; j < 128; j++) {
  1169.             if (z[j] > 1<<24) {
  1170.                 av_log(NULL, AV_LOG_WARNING,
  1171.                        "sbr_qmf_analysis: value %09d too large, setting to %09d\n",
  1172.                        z[j], 1<<24);
  1173.                 z[j] = 1<<24;
  1174.             } else if (z[j] < -(1<<24)) {
  1175.                 av_log(NULL, AV_LOG_WARNING,
  1176.                        "sbr_qmf_analysis: value %09d too small, setting to %09d\n",
  1177.                        z[j], -(1<<24));
  1178.                 z[j] = -(1<<24);
  1179.             }
  1180.         }
  1181. #endif
  1182.         mdct->imdct_half(mdct, z, z+64);
  1183.         sbrdsp->qmf_post_shuffle(W[buf_idx][i], z);
  1184.         x += 32;
  1185.     }
  1186. }
  1187. #endif
  1188.  
  1189. /**
  1190.  * Synthesis QMF Bank (14496-3 sp04 p206) and Downsampled Synthesis QMF Bank
  1191.  * (14496-3 sp04 p206)
  1192.  */
  1193. #ifndef sbr_qmf_synthesis
  1194. static void sbr_qmf_synthesis(FFTContext *mdct,
  1195. #if USE_FIXED
  1196.                               SBRDSPContext *sbrdsp, AVFixedDSPContext *dsp,
  1197. #else
  1198.                               SBRDSPContext *sbrdsp, AVFloatDSPContext *dsp,
  1199. #endif /* USE_FIXED */
  1200.                               INTFLOAT *out, INTFLOAT X[2][38][64],
  1201.                               INTFLOAT mdct_buf[2][64],
  1202.                               INTFLOAT *v0, int *v_off, const unsigned int div)
  1203. {
  1204.     int i, n;
  1205.     const INTFLOAT *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
  1206.     const int step = 128 >> div;
  1207.     INTFLOAT *v;
  1208.     for (i = 0; i < 32; i++) {
  1209.         if (*v_off < step) {
  1210.             int saved_samples = (1280 - 128) >> div;
  1211.             memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(INTFLOAT));
  1212.             *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - step;
  1213.         } else {
  1214.             *v_off -= step;
  1215.         }
  1216.         v = v0 + *v_off;
  1217.         if (div) {
  1218.             for (n = 0; n < 32; n++) {
  1219.                 X[0][i][   n] = -X[0][i][n];
  1220.                 X[0][i][32+n] =  X[1][i][31-n];
  1221.             }
  1222.             mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
  1223.             sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
  1224.         } else {
  1225.             sbrdsp->neg_odd_64(X[1][i]);
  1226.             mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
  1227.             mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
  1228.             sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
  1229.         }
  1230.         dsp->vector_fmul    (out, v                , sbr_qmf_window                       , 64 >> div);
  1231.         dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out   , 64 >> div);
  1232.         dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out   , 64 >> div);
  1233.         dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out   , 64 >> div);
  1234.         dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out   , 64 >> div);
  1235.         dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out   , 64 >> div);
  1236.         dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out   , 64 >> div);
  1237.         dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out   , 64 >> div);
  1238.         dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out   , 64 >> div);
  1239.         dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out   , 64 >> div);
  1240.         out += 64 >> div;
  1241.     }
  1242. }
  1243. #endif
  1244.  
  1245. /// Generate the subband filtered lowband
  1246. static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr,
  1247.                       INTFLOAT X_low[32][40][2], const INTFLOAT W[2][32][32][2],
  1248.                       int buf_idx)
  1249. {
  1250.     int i, k;
  1251.     const int t_HFGen = 8;
  1252.     const int i_f = 32;
  1253.     memset(X_low, 0, 32*sizeof(*X_low));
  1254.     for (k = 0; k < sbr->kx[1]; k++) {
  1255.         for (i = t_HFGen; i < i_f + t_HFGen; i++) {
  1256.             X_low[k][i][0] = W[buf_idx][i - t_HFGen][k][0];
  1257.             X_low[k][i][1] = W[buf_idx][i - t_HFGen][k][1];
  1258.         }
  1259.     }
  1260.     buf_idx = 1-buf_idx;
  1261.     for (k = 0; k < sbr->kx[0]; k++) {
  1262.         for (i = 0; i < t_HFGen; i++) {
  1263.             X_low[k][i][0] = W[buf_idx][i + i_f - t_HFGen][k][0];
  1264.             X_low[k][i][1] = W[buf_idx][i + i_f - t_HFGen][k][1];
  1265.         }
  1266.     }
  1267.     return 0;
  1268. }
  1269.  
  1270. /// High Frequency Generator (14496-3 sp04 p215)
  1271. static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
  1272.                       INTFLOAT X_high[64][40][2], const INTFLOAT X_low[32][40][2],
  1273.                       const INTFLOAT (*alpha0)[2], const INTFLOAT (*alpha1)[2],
  1274.                       const INTFLOAT bw_array[5], const uint8_t *t_env,
  1275.                       int bs_num_env)
  1276. {
  1277.     int j, x;
  1278.     int g = 0;
  1279.     int k = sbr->kx[1];
  1280.     for (j = 0; j < sbr->num_patches; j++) {
  1281.         for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
  1282.             const int p = sbr->patch_start_subband[j] + x;
  1283.             while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
  1284.                 g++;
  1285.             g--;
  1286.  
  1287.             if (g < 0) {
  1288.                 av_log(ac->avctx, AV_LOG_ERROR,
  1289.                        "ERROR : no subband found for frequency %d\n", k);
  1290.                 return -1;
  1291.             }
  1292.  
  1293.             sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
  1294.                             X_low[p]  + ENVELOPE_ADJUSTMENT_OFFSET,
  1295.                             alpha0[p], alpha1[p], bw_array[g],
  1296.                             2 * t_env[0], 2 * t_env[bs_num_env]);
  1297.         }
  1298.     }
  1299.     if (k < sbr->m[1] + sbr->kx[1])
  1300.         memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
  1301.  
  1302.     return 0;
  1303. }
  1304.  
  1305. /// Generate the subband filtered lowband
  1306. static int sbr_x_gen(SpectralBandReplication *sbr, INTFLOAT X[2][38][64],
  1307.                      const INTFLOAT Y0[38][64][2], const INTFLOAT Y1[38][64][2],
  1308.                      const INTFLOAT X_low[32][40][2], int ch)
  1309. {
  1310.     int k, i;
  1311.     const int i_f = 32;
  1312.     const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
  1313.     memset(X, 0, 2*sizeof(*X));
  1314.     for (k = 0; k < sbr->kx[0]; k++) {
  1315.         for (i = 0; i < i_Temp; i++) {
  1316.             X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
  1317.             X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
  1318.         }
  1319.     }
  1320.     for (; k < sbr->kx[0] + sbr->m[0]; k++) {
  1321.         for (i = 0; i < i_Temp; i++) {
  1322.             X[0][i][k] = Y0[i + i_f][k][0];
  1323.             X[1][i][k] = Y0[i + i_f][k][1];
  1324.         }
  1325.     }
  1326.  
  1327.     for (k = 0; k < sbr->kx[1]; k++) {
  1328.         for (i = i_Temp; i < 38; i++) {
  1329.             X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
  1330.             X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
  1331.         }
  1332.     }
  1333.     for (; k < sbr->kx[1] + sbr->m[1]; k++) {
  1334.         for (i = i_Temp; i < i_f; i++) {
  1335.             X[0][i][k] = Y1[i][k][0];
  1336.             X[1][i][k] = Y1[i][k][1];
  1337.         }
  1338.     }
  1339.     return 0;
  1340. }
  1341.  
  1342. /** High Frequency Adjustment (14496-3 sp04 p217) and Mapping
  1343.  * (14496-3 sp04 p217)
  1344.  */
  1345. static int sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
  1346.                         SBRData *ch_data, int e_a[2])
  1347. {
  1348.     int e, i, m;
  1349.  
  1350.     memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
  1351.     for (e = 0; e < ch_data->bs_num_env; e++) {
  1352.         const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
  1353.         uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
  1354.         int k;
  1355.  
  1356.         if (sbr->kx[1] != table[0]) {
  1357.             av_log(ac->avctx, AV_LOG_ERROR, "kx != f_table{high,low}[0]. "
  1358.                    "Derived frequency tables were not regenerated.\n");
  1359.             sbr_turnoff(sbr);
  1360.             return AVERROR_BUG;
  1361.         }
  1362.         for (i = 0; i < ilim; i++)
  1363.             for (m = table[i]; m < table[i + 1]; m++)
  1364.                 sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
  1365.  
  1366.         // ch_data->bs_num_noise > 1 => 2 noise floors
  1367.         k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
  1368.         for (i = 0; i < sbr->n_q; i++)
  1369.             for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
  1370.                 sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
  1371.  
  1372.         for (i = 0; i < sbr->n[1]; i++) {
  1373.             if (ch_data->bs_add_harmonic_flag) {
  1374.                 const unsigned int m_midpoint =
  1375.                     (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
  1376.  
  1377.                 ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
  1378.                     (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
  1379.             }
  1380.         }
  1381.  
  1382.         for (i = 0; i < ilim; i++) {
  1383.             int additional_sinusoid_present = 0;
  1384.             for (m = table[i]; m < table[i + 1]; m++) {
  1385.                 if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
  1386.                     additional_sinusoid_present = 1;
  1387.                     break;
  1388.                 }
  1389.             }
  1390.             memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
  1391.                    (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
  1392.         }
  1393.     }
  1394.  
  1395.     memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
  1396.     return 0;
  1397. }
  1398.  
  1399. /// Estimation of current envelope (14496-3 sp04 p218)
  1400. static void sbr_env_estimate(AAC_FLOAT (*e_curr)[48], INTFLOAT X_high[64][40][2],
  1401.                              SpectralBandReplication *sbr, SBRData *ch_data)
  1402. {
  1403.     int e, m;
  1404.     int kx1 = sbr->kx[1];
  1405.  
  1406.     if (sbr->bs_interpol_freq) {
  1407.         for (e = 0; e < ch_data->bs_num_env; e++) {
  1408. #if USE_FIXED
  1409.             const SoftFloat recip_env_size = av_int2sf(0x20000000 / (ch_data->t_env[e + 1] - ch_data->t_env[e]), 30);
  1410. #else
  1411.             const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
  1412. #endif /* USE_FIXED */
  1413.             int ilb = ch_data->t_env[e]     * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
  1414.             int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
  1415.  
  1416.             for (m = 0; m < sbr->m[1]; m++) {
  1417.                 AAC_FLOAT sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
  1418. #if USE_FIXED
  1419.                 e_curr[e][m] = av_mul_sf(sum, recip_env_size);
  1420. #else
  1421.                 e_curr[e][m] = sum * recip_env_size;
  1422. #endif /* USE_FIXED */
  1423.             }
  1424.         }
  1425.     } else {
  1426.         int k, p;
  1427.  
  1428.         for (e = 0; e < ch_data->bs_num_env; e++) {
  1429.             const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
  1430.             int ilb = ch_data->t_env[e]     * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
  1431.             int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
  1432.             const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
  1433.  
  1434.             for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
  1435. #if USE_FIXED
  1436.                 SoftFloat sum = FLOAT_0;
  1437.                 const SoftFloat den = av_int2sf(0x20000000 / (env_size * (table[p + 1] - table[p])), 29);
  1438.                 for (k = table[p]; k < table[p + 1]; k++) {
  1439.                     sum = av_add_sf(sum, sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb));
  1440.                 }
  1441.                 sum = av_mul_sf(sum, den);
  1442. #else
  1443.                 float sum = 0.0f;
  1444.                 const int den = env_size * (table[p + 1] - table[p]);
  1445.  
  1446.                 for (k = table[p]; k < table[p + 1]; k++) {
  1447.                     sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb);
  1448.                 }
  1449.                 sum /= den;
  1450. #endif /* USE_FIXED */
  1451.                 for (k = table[p]; k < table[p + 1]; k++) {
  1452.                     e_curr[e][k - kx1] = sum;
  1453.                 }
  1454.             }
  1455.         }
  1456.     }
  1457. }
  1458.  
  1459. void AAC_RENAME(ff_sbr_apply)(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
  1460.                   INTFLOAT* L, INTFLOAT* R)
  1461. {
  1462.     int downsampled = ac->oc[1].m4ac.ext_sample_rate < sbr->sample_rate;
  1463.     int ch;
  1464.     int nch = (id_aac == TYPE_CPE) ? 2 : 1;
  1465.     int err;
  1466.  
  1467.     if (id_aac != sbr->id_aac) {
  1468.         av_log(ac->avctx, AV_LOG_ERROR,
  1469.             "element type mismatch %d != %d\n", id_aac, sbr->id_aac);
  1470.         sbr_turnoff(sbr);
  1471.     }
  1472.  
  1473.     if (sbr->start && !sbr->ready_for_dequant) {
  1474.         av_log(ac->avctx, AV_LOG_ERROR,
  1475.                "No quantized data read for sbr_dequant.\n");
  1476.         sbr_turnoff(sbr);
  1477.     }
  1478.  
  1479.     if (!sbr->kx_and_m_pushed) {
  1480.         sbr->kx[0] = sbr->kx[1];
  1481.         sbr->m[0] = sbr->m[1];
  1482.     } else {
  1483.         sbr->kx_and_m_pushed = 0;
  1484.     }
  1485.  
  1486.     if (sbr->start) {
  1487.         sbr_dequant(sbr, id_aac);
  1488.         sbr->ready_for_dequant = 0;
  1489.     }
  1490.     for (ch = 0; ch < nch; ch++) {
  1491.         /* decode channel */
  1492.         sbr_qmf_analysis(ac->fdsp, &sbr->mdct_ana, &sbr->dsp, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
  1493.                          (INTFLOAT*)sbr->qmf_filter_scratch,
  1494.                          sbr->data[ch].W, sbr->data[ch].Ypos);
  1495.         sbr->c.sbr_lf_gen(ac, sbr, sbr->X_low,
  1496.                           (const INTFLOAT (*)[32][32][2]) sbr->data[ch].W,
  1497.                           sbr->data[ch].Ypos);
  1498.         sbr->data[ch].Ypos ^= 1;
  1499.         if (sbr->start) {
  1500.             sbr->c.sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1,
  1501.                                          (const INTFLOAT (*)[40][2]) sbr->X_low, sbr->k[0]);
  1502.             sbr_chirp(sbr, &sbr->data[ch]);
  1503.             av_assert0(sbr->data[ch].bs_num_env > 0);
  1504.             sbr_hf_gen(ac, sbr, sbr->X_high,
  1505.                        (const INTFLOAT (*)[40][2]) sbr->X_low,
  1506.                        (const INTFLOAT (*)[2]) sbr->alpha0,
  1507.                        (const INTFLOAT (*)[2]) sbr->alpha1,
  1508.                        sbr->data[ch].bw_array, sbr->data[ch].t_env,
  1509.                        sbr->data[ch].bs_num_env);
  1510.  
  1511.             // hf_adj
  1512.             err = sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
  1513.             if (!err) {
  1514.                 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
  1515.                 sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
  1516.                 sbr->c.sbr_hf_assemble(sbr->data[ch].Y[sbr->data[ch].Ypos],
  1517.                                 (const INTFLOAT (*)[40][2]) sbr->X_high,
  1518.                                 sbr, &sbr->data[ch],
  1519.                                 sbr->data[ch].e_a);
  1520.             }
  1521.         }
  1522.  
  1523.         /* synthesis */
  1524.         sbr->c.sbr_x_gen(sbr, sbr->X[ch],
  1525.                   (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[1-sbr->data[ch].Ypos],
  1526.                   (const INTFLOAT (*)[64][2]) sbr->data[ch].Y[  sbr->data[ch].Ypos],
  1527.                   (const INTFLOAT (*)[40][2]) sbr->X_low, ch);
  1528.     }
  1529.  
  1530.     if (ac->oc[1].m4ac.ps == 1) {
  1531.         if (sbr->ps.start) {
  1532.             AAC_RENAME(ff_ps_apply)(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
  1533.         } else {
  1534.             memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
  1535.         }
  1536.         nch = 2;
  1537.     }
  1538.  
  1539.     sbr_qmf_synthesis(&sbr->mdct, &sbr->dsp, ac->fdsp,
  1540.                       L, sbr->X[0], sbr->qmf_filter_scratch,
  1541.                       sbr->data[0].synthesis_filterbank_samples,
  1542.                       &sbr->data[0].synthesis_filterbank_samples_offset,
  1543.                       downsampled);
  1544.     if (nch == 2)
  1545.         sbr_qmf_synthesis(&sbr->mdct, &sbr->dsp, ac->fdsp,
  1546.                           R, sbr->X[1], sbr->qmf_filter_scratch,
  1547.                           sbr->data[1].synthesis_filterbank_samples,
  1548.                           &sbr->data[1].synthesis_filterbank_samples_offset,
  1549.                           downsampled);
  1550. }
  1551.  
  1552. static void aacsbr_func_ptr_init(AACSBRContext *c)
  1553. {
  1554.     c->sbr_lf_gen            = sbr_lf_gen;
  1555.     c->sbr_hf_assemble       = sbr_hf_assemble;
  1556.     c->sbr_x_gen             = sbr_x_gen;
  1557.     c->sbr_hf_inverse_filter = sbr_hf_inverse_filter;
  1558.  
  1559. #if !USE_FIXED
  1560.     if(ARCH_MIPS)
  1561.         ff_aacsbr_func_ptr_init_mips(c);
  1562. #endif
  1563. }
  1564.