• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/aacsbr.c

Go to the documentation of this file.
00001 /*
00002  * AAC Spectral Band Replication decoding functions
00003  * Copyright (c) 2008-2009 Robert Swain ( rob opendot cl )
00004  * Copyright (c) 2009-2010 Alex Converse <alex.converse@gmail.com>
00005  *
00006  * This file is part of FFmpeg.
00007  *
00008  * FFmpeg is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * FFmpeg is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with FFmpeg; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00029 #include "aac.h"
00030 #include "sbr.h"
00031 #include "aacsbr.h"
00032 #include "aacsbrdata.h"
00033 #include "fft.h"
00034 #include "aacps.h"
00035 
00036 #include <stdint.h>
00037 #include <float.h>
00038 
00039 #define ENVELOPE_ADJUSTMENT_OFFSET 2
00040 #define NOISE_FLOOR_OFFSET 6.0f
00041 
00045 enum {
00046     T_HUFFMAN_ENV_1_5DB,
00047     F_HUFFMAN_ENV_1_5DB,
00048     T_HUFFMAN_ENV_BAL_1_5DB,
00049     F_HUFFMAN_ENV_BAL_1_5DB,
00050     T_HUFFMAN_ENV_3_0DB,
00051     F_HUFFMAN_ENV_3_0DB,
00052     T_HUFFMAN_ENV_BAL_3_0DB,
00053     F_HUFFMAN_ENV_BAL_3_0DB,
00054     T_HUFFMAN_NOISE_3_0DB,
00055     T_HUFFMAN_NOISE_BAL_3_0DB,
00056 };
00057 
00061 enum {
00062     FIXFIX,
00063     FIXVAR,
00064     VARFIX,
00065     VARVAR,
00066 };
00067 
00068 enum {
00069     EXTENSION_ID_PS = 2,
00070 };
00071 
00072 static VLC vlc_sbr[10];
00073 static const int8_t vlc_sbr_lav[10] =
00074     { 60, 60, 24, 24, 31, 31, 12, 12, 31, 12 };
00075 static const DECLARE_ALIGNED(16, float, zero64)[64];
00076 
00077 #define SBR_INIT_VLC_STATIC(num, size) \
00078     INIT_VLC_STATIC(&vlc_sbr[num], 9, sbr_tmp[num].table_size / sbr_tmp[num].elem_size,     \
00079                     sbr_tmp[num].sbr_bits ,                      1,                      1, \
00080                     sbr_tmp[num].sbr_codes, sbr_tmp[num].elem_size, sbr_tmp[num].elem_size, \
00081                     size)
00082 
00083 #define SBR_VLC_ROW(name) \
00084     { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }
00085 
00086 av_cold void ff_aac_sbr_init(void)
00087 {
00088     int n;
00089     static const struct {
00090         const void *sbr_codes, *sbr_bits;
00091         const unsigned int table_size, elem_size;
00092     } sbr_tmp[] = {
00093         SBR_VLC_ROW(t_huffman_env_1_5dB),
00094         SBR_VLC_ROW(f_huffman_env_1_5dB),
00095         SBR_VLC_ROW(t_huffman_env_bal_1_5dB),
00096         SBR_VLC_ROW(f_huffman_env_bal_1_5dB),
00097         SBR_VLC_ROW(t_huffman_env_3_0dB),
00098         SBR_VLC_ROW(f_huffman_env_3_0dB),
00099         SBR_VLC_ROW(t_huffman_env_bal_3_0dB),
00100         SBR_VLC_ROW(f_huffman_env_bal_3_0dB),
00101         SBR_VLC_ROW(t_huffman_noise_3_0dB),
00102         SBR_VLC_ROW(t_huffman_noise_bal_3_0dB),
00103     };
00104 
00105     // SBR VLC table initialization
00106     SBR_INIT_VLC_STATIC(0, 1098);
00107     SBR_INIT_VLC_STATIC(1, 1092);
00108     SBR_INIT_VLC_STATIC(2, 768);
00109     SBR_INIT_VLC_STATIC(3, 1026);
00110     SBR_INIT_VLC_STATIC(4, 1058);
00111     SBR_INIT_VLC_STATIC(5, 1052);
00112     SBR_INIT_VLC_STATIC(6, 544);
00113     SBR_INIT_VLC_STATIC(7, 544);
00114     SBR_INIT_VLC_STATIC(8, 592);
00115     SBR_INIT_VLC_STATIC(9, 512);
00116 
00117     for (n = 1; n < 320; n++)
00118         sbr_qmf_window_us[320 + n] = sbr_qmf_window_us[320 - n];
00119     sbr_qmf_window_us[384] = -sbr_qmf_window_us[384];
00120     sbr_qmf_window_us[512] = -sbr_qmf_window_us[512];
00121 
00122     for (n = 0; n < 320; n++)
00123         sbr_qmf_window_ds[n] = sbr_qmf_window_us[2*n];
00124 
00125     ff_ps_init();
00126 }
00127 
00128 av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)
00129 {
00130     sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
00131     sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
00132     sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
00133     sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
00134     ff_mdct_init(&sbr->mdct, 7, 1, 1.0/64);
00135     ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0);
00136     ff_ps_ctx_init(&sbr->ps);
00137 }
00138 
00139 av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
00140 {
00141     ff_mdct_end(&sbr->mdct);
00142     ff_mdct_end(&sbr->mdct_ana);
00143 }
00144 
00145 static int qsort_comparison_function_int16(const void *a, const void *b)
00146 {
00147     return *(const int16_t *)a - *(const int16_t *)b;
00148 }
00149 
00150 static inline int in_table_int16(const int16_t *table, int last_el, int16_t needle)
00151 {
00152     int i;
00153     for (i = 0; i <= last_el; i++)
00154         if (table[i] == needle)
00155             return 1;
00156     return 0;
00157 }
00158 
00160 static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
00161 {
00162     int k;
00163     if (sbr->bs_limiter_bands > 0) {
00164         static const float bands_warped[3] = { 1.32715174233856803909f,   //2^(0.49/1.2)
00165                                                1.18509277094158210129f,   //2^(0.49/2)
00166                                                1.11987160404675912501f }; //2^(0.49/3)
00167         const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
00168         int16_t patch_borders[7];
00169         uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
00170 
00171         patch_borders[0] = sbr->kx[1];
00172         for (k = 1; k <= sbr->num_patches; k++)
00173             patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
00174 
00175         memcpy(sbr->f_tablelim, sbr->f_tablelow,
00176                (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
00177         if (sbr->num_patches > 1)
00178             memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
00179                    (sbr->num_patches - 1) * sizeof(patch_borders[0]));
00180 
00181         qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
00182               sizeof(sbr->f_tablelim[0]),
00183               qsort_comparison_function_int16);
00184 
00185         sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
00186         while (out < sbr->f_tablelim + sbr->n_lim) {
00187             if (*in >= *out * lim_bands_per_octave_warped) {
00188                 *++out = *in++;
00189             } else if (*in == *out ||
00190                 !in_table_int16(patch_borders, sbr->num_patches, *in)) {
00191                 in++;
00192                 sbr->n_lim--;
00193             } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
00194                 *out = *in++;
00195                 sbr->n_lim--;
00196             } else {
00197                 *++out = *in++;
00198             }
00199         }
00200     } else {
00201         sbr->f_tablelim[0] = sbr->f_tablelow[0];
00202         sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
00203         sbr->n_lim = 1;
00204     }
00205 }
00206 
00207 static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
00208 {
00209     unsigned int cnt = get_bits_count(gb);
00210     uint8_t bs_header_extra_1;
00211     uint8_t bs_header_extra_2;
00212     int old_bs_limiter_bands = sbr->bs_limiter_bands;
00213     SpectrumParameters old_spectrum_params;
00214 
00215     sbr->start = 1;
00216 
00217     // Save last spectrum parameters variables to compare to new ones
00218     memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
00219 
00220     sbr->bs_amp_res_header              = get_bits1(gb);
00221     sbr->spectrum_params.bs_start_freq  = get_bits(gb, 4);
00222     sbr->spectrum_params.bs_stop_freq   = get_bits(gb, 4);
00223     sbr->spectrum_params.bs_xover_band  = get_bits(gb, 3);
00224                                           skip_bits(gb, 2); // bs_reserved
00225 
00226     bs_header_extra_1 = get_bits1(gb);
00227     bs_header_extra_2 = get_bits1(gb);
00228 
00229     if (bs_header_extra_1) {
00230         sbr->spectrum_params.bs_freq_scale  = get_bits(gb, 2);
00231         sbr->spectrum_params.bs_alter_scale = get_bits1(gb);
00232         sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2);
00233     } else {
00234         sbr->spectrum_params.bs_freq_scale  = 2;
00235         sbr->spectrum_params.bs_alter_scale = 1;
00236         sbr->spectrum_params.bs_noise_bands = 2;
00237     }
00238 
00239     // Check if spectrum parameters changed
00240     if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
00241         sbr->reset = 1;
00242 
00243     if (bs_header_extra_2) {
00244         sbr->bs_limiter_bands  = get_bits(gb, 2);
00245         sbr->bs_limiter_gains  = get_bits(gb, 2);
00246         sbr->bs_interpol_freq  = get_bits1(gb);
00247         sbr->bs_smoothing_mode = get_bits1(gb);
00248     } else {
00249         sbr->bs_limiter_bands  = 2;
00250         sbr->bs_limiter_gains  = 2;
00251         sbr->bs_interpol_freq  = 1;
00252         sbr->bs_smoothing_mode = 1;
00253     }
00254 
00255     if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
00256         sbr_make_f_tablelim(sbr);
00257 
00258     return get_bits_count(gb) - cnt;
00259 }
00260 
00261 static int array_min_int16(const int16_t *array, int nel)
00262 {
00263     int i, min = array[0];
00264     for (i = 1; i < nel; i++)
00265         min = FFMIN(array[i], min);
00266     return min;
00267 }
00268 
00269 static void make_bands(int16_t* bands, int start, int stop, int num_bands)
00270 {
00271     int k, previous, present;
00272     float base, prod;
00273 
00274     base = powf((float)stop / start, 1.0f / num_bands);
00275     prod = start;
00276     previous = start;
00277 
00278     for (k = 0; k < num_bands-1; k++) {
00279         prod *= base;
00280         present  = lrintf(prod);
00281         bands[k] = present - previous;
00282         previous = present;
00283     }
00284     bands[num_bands-1] = stop - previous;
00285 }
00286 
00287 static int check_n_master(AVCodecContext *avctx, int n_master, int bs_xover_band)
00288 {
00289     // Requirements (14496-3 sp04 p205)
00290     if (n_master <= 0) {
00291         av_log(avctx, AV_LOG_ERROR, "Invalid n_master: %d\n", n_master);
00292         return -1;
00293     }
00294     if (bs_xover_band >= n_master) {
00295         av_log(avctx, AV_LOG_ERROR,
00296                "Invalid bitstream, crossover band index beyond array bounds: %d\n",
00297                bs_xover_band);
00298         return -1;
00299     }
00300     return 0;
00301 }
00302 
00304 static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
00305                              SpectrumParameters *spectrum)
00306 {
00307     unsigned int temp, max_qmf_subbands;
00308     unsigned int start_min, stop_min;
00309     int k;
00310     const int8_t *sbr_offset_ptr;
00311     int16_t stop_dk[13];
00312 
00313     if (sbr->sample_rate < 32000) {
00314         temp = 3000;
00315     } else if (sbr->sample_rate < 64000) {
00316         temp = 4000;
00317     } else
00318         temp = 5000;
00319 
00320     start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
00321     stop_min  = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
00322 
00323     switch (sbr->sample_rate) {
00324     case 16000:
00325         sbr_offset_ptr = sbr_offset[0];
00326         break;
00327     case 22050:
00328         sbr_offset_ptr = sbr_offset[1];
00329         break;
00330     case 24000:
00331         sbr_offset_ptr = sbr_offset[2];
00332         break;
00333     case 32000:
00334         sbr_offset_ptr = sbr_offset[3];
00335         break;
00336     case 44100: case 48000: case 64000:
00337         sbr_offset_ptr = sbr_offset[4];
00338         break;
00339     case 88200: case 96000: case 128000: case 176400: case 192000:
00340         sbr_offset_ptr = sbr_offset[5];
00341         break;
00342     default:
00343         av_log(ac->avctx, AV_LOG_ERROR,
00344                "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
00345         return -1;
00346     }
00347 
00348     sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
00349 
00350     if (spectrum->bs_stop_freq < 14) {
00351         sbr->k[2] = stop_min;
00352         make_bands(stop_dk, stop_min, 64, 13);
00353         qsort(stop_dk, 13, sizeof(stop_dk[0]), qsort_comparison_function_int16);
00354         for (k = 0; k < spectrum->bs_stop_freq; k++)
00355             sbr->k[2] += stop_dk[k];
00356     } else if (spectrum->bs_stop_freq == 14) {
00357         sbr->k[2] = 2*sbr->k[0];
00358     } else if (spectrum->bs_stop_freq == 15) {
00359         sbr->k[2] = 3*sbr->k[0];
00360     } else {
00361         av_log(ac->avctx, AV_LOG_ERROR,
00362                "Invalid bs_stop_freq: %d\n", spectrum->bs_stop_freq);
00363         return -1;
00364     }
00365     sbr->k[2] = FFMIN(64, sbr->k[2]);
00366 
00367     // Requirements (14496-3 sp04 p205)
00368     if (sbr->sample_rate <= 32000) {
00369         max_qmf_subbands = 48;
00370     } else if (sbr->sample_rate == 44100) {
00371         max_qmf_subbands = 35;
00372     } else if (sbr->sample_rate >= 48000)
00373         max_qmf_subbands = 32;
00374 
00375     if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
00376         av_log(ac->avctx, AV_LOG_ERROR,
00377                "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
00378         return -1;
00379     }
00380 
00381     if (!spectrum->bs_freq_scale) {
00382         int dk, k2diff;
00383 
00384         dk = spectrum->bs_alter_scale + 1;
00385         sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
00386         if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
00387             return -1;
00388 
00389         for (k = 1; k <= sbr->n_master; k++)
00390             sbr->f_master[k] = dk;
00391 
00392         k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
00393         if (k2diff < 0) {
00394             sbr->f_master[1]--;
00395             sbr->f_master[2]-= (k2diff < 1);
00396         } else if (k2diff) {
00397             sbr->f_master[sbr->n_master]++;
00398         }
00399 
00400         sbr->f_master[0] = sbr->k[0];
00401         for (k = 1; k <= sbr->n_master; k++)
00402             sbr->f_master[k] += sbr->f_master[k - 1];
00403 
00404     } else {
00405         int half_bands = 7 - spectrum->bs_freq_scale;      // bs_freq_scale  = {1,2,3}
00406         int two_regions, num_bands_0;
00407         int vdk0_max, vdk1_min;
00408         int16_t vk0[49];
00409 
00410         if (49 * sbr->k[2] > 110 * sbr->k[0]) {
00411             two_regions = 1;
00412             sbr->k[1] = 2 * sbr->k[0];
00413         } else {
00414             two_regions = 0;
00415             sbr->k[1] = sbr->k[2];
00416         }
00417 
00418         num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
00419 
00420         if (num_bands_0 <= 0) { // Requirements (14496-3 sp04 p205)
00421             av_log(ac->avctx, AV_LOG_ERROR, "Invalid num_bands_0: %d\n", num_bands_0);
00422             return -1;
00423         }
00424 
00425         vk0[0] = 0;
00426 
00427         make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
00428 
00429         qsort(vk0 + 1, num_bands_0, sizeof(vk0[1]), qsort_comparison_function_int16);
00430         vdk0_max = vk0[num_bands_0];
00431 
00432         vk0[0] = sbr->k[0];
00433         for (k = 1; k <= num_bands_0; k++) {
00434             if (vk0[k] <= 0) { // Requirements (14496-3 sp04 p205)
00435                 av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk0[%d]: %d\n", k, vk0[k]);
00436                 return -1;
00437             }
00438             vk0[k] += vk0[k-1];
00439         }
00440 
00441         if (two_regions) {
00442             int16_t vk1[49];
00443             float invwarp = spectrum->bs_alter_scale ? 0.76923076923076923077f
00444                                                      : 1.0f; // bs_alter_scale = {0,1}
00445             int num_bands_1 = lrintf(half_bands * invwarp *
00446                                      log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
00447 
00448             make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
00449 
00450             vdk1_min = array_min_int16(vk1 + 1, num_bands_1);
00451 
00452             if (vdk1_min < vdk0_max) {
00453                 int change;
00454                 qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
00455                 change = FFMIN(vdk0_max - vk1[1], (vk1[num_bands_1] - vk1[1]) >> 1);
00456                 vk1[1]           += change;
00457                 vk1[num_bands_1] -= change;
00458             }
00459 
00460             qsort(vk1 + 1, num_bands_1, sizeof(vk1[1]), qsort_comparison_function_int16);
00461 
00462             vk1[0] = sbr->k[1];
00463             for (k = 1; k <= num_bands_1; k++) {
00464                 if (vk1[k] <= 0) { // Requirements (14496-3 sp04 p205)
00465                     av_log(ac->avctx, AV_LOG_ERROR, "Invalid vDk1[%d]: %d\n", k, vk1[k]);
00466                     return -1;
00467                 }
00468                 vk1[k] += vk1[k-1];
00469             }
00470 
00471             sbr->n_master = num_bands_0 + num_bands_1;
00472             if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
00473                 return -1;
00474             memcpy(&sbr->f_master[0],               vk0,
00475                    (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
00476             memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
00477                     num_bands_1      * sizeof(sbr->f_master[0]));
00478 
00479         } else {
00480             sbr->n_master = num_bands_0;
00481             if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
00482                 return -1;
00483             memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
00484         }
00485     }
00486 
00487     return 0;
00488 }
00489 
00491 static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
00492 {
00493     int i, k, sb = 0;
00494     int msb = sbr->k[0];
00495     int usb = sbr->kx[1];
00496     int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
00497 
00498     sbr->num_patches = 0;
00499 
00500     if (goal_sb < sbr->kx[1] + sbr->m[1]) {
00501         for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
00502     } else
00503         k = sbr->n_master;
00504 
00505     do {
00506         int odd = 0;
00507         for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
00508             sb = sbr->f_master[i];
00509             odd = (sb + sbr->k[0]) & 1;
00510         }
00511 
00512         // Requirements (14496-3 sp04 p205) sets the maximum number of patches to 5.
00513         // After this check the final number of patches can still be six which is
00514         // illegal however the Coding Technologies decoder check stream has a final
00515         // count of 6 patches
00516         if (sbr->num_patches > 5) {
00517             av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
00518             return -1;
00519         }
00520 
00521         sbr->patch_num_subbands[sbr->num_patches]  = FFMAX(sb - usb, 0);
00522         sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
00523 
00524         if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
00525             usb = sb;
00526             msb = sb;
00527             sbr->num_patches++;
00528         } else
00529             msb = sbr->kx[1];
00530 
00531         if (sbr->f_master[k] - sb < 3)
00532             k = sbr->n_master;
00533     } while (sb != sbr->kx[1] + sbr->m[1]);
00534 
00535     if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
00536         sbr->num_patches--;
00537 
00538     return 0;
00539 }
00540 
00542 static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
00543 {
00544     int k, temp;
00545 
00546     sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
00547     sbr->n[0] = (sbr->n[1] + 1) >> 1;
00548 
00549     memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
00550            (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
00551     sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
00552     sbr->kx[1] = sbr->f_tablehigh[0];
00553 
00554     // Requirements (14496-3 sp04 p205)
00555     if (sbr->kx[1] + sbr->m[1] > 64) {
00556         av_log(ac->avctx, AV_LOG_ERROR,
00557                "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
00558         return -1;
00559     }
00560     if (sbr->kx[1] > 32) {
00561         av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
00562         return -1;
00563     }
00564 
00565     sbr->f_tablelow[0] = sbr->f_tablehigh[0];
00566     temp = sbr->n[1] & 1;
00567     for (k = 1; k <= sbr->n[0]; k++)
00568         sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
00569 
00570     sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *
00571                                log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
00572     if (sbr->n_q > 5) {
00573         av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
00574         return -1;
00575     }
00576 
00577     sbr->f_tablenoise[0] = sbr->f_tablelow[0];
00578     temp = 0;
00579     for (k = 1; k <= sbr->n_q; k++) {
00580         temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
00581         sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
00582     }
00583 
00584     if (sbr_hf_calc_npatches(ac, sbr) < 0)
00585         return -1;
00586 
00587     sbr_make_f_tablelim(sbr);
00588 
00589     sbr->data[0].f_indexnoise = 0;
00590     sbr->data[1].f_indexnoise = 0;
00591 
00592     return 0;
00593 }
00594 
00595 static av_always_inline void get_bits1_vector(GetBitContext *gb, uint8_t *vec,
00596                                               int elements)
00597 {
00598     int i;
00599     for (i = 0; i < elements; i++) {
00600         vec[i] = get_bits1(gb);
00601     }
00602 }
00603 
00605 static const int8_t ceil_log2[] = {
00606     0, 1, 2, 2, 3, 3,
00607 };
00608 
00609 static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
00610                          GetBitContext *gb, SBRData *ch_data)
00611 {
00612     int i;
00613     unsigned bs_pointer = 0;
00614     // frameLengthFlag ? 15 : 16; 960 sample length frames unsupported; this value is numTimeSlots
00615     int abs_bord_trail = 16;
00616     int num_rel_lead, num_rel_trail;
00617     unsigned bs_num_env_old = ch_data->bs_num_env;
00618 
00619     ch_data->bs_freq_res[0] = ch_data->bs_freq_res[ch_data->bs_num_env];
00620     ch_data->bs_amp_res = sbr->bs_amp_res_header;
00621     ch_data->t_env_num_env_old = ch_data->t_env[bs_num_env_old];
00622 
00623     switch (ch_data->bs_frame_class = get_bits(gb, 2)) {
00624     case FIXFIX:
00625         ch_data->bs_num_env                 = 1 << get_bits(gb, 2);
00626         num_rel_lead                        = ch_data->bs_num_env - 1;
00627         if (ch_data->bs_num_env == 1)
00628             ch_data->bs_amp_res = 0;
00629 
00630         if (ch_data->bs_num_env > 4) {
00631             av_log(ac->avctx, AV_LOG_ERROR,
00632                    "Invalid bitstream, too many SBR envelopes in FIXFIX type SBR frame: %d\n",
00633                    ch_data->bs_num_env);
00634             return -1;
00635         }
00636 
00637         ch_data->t_env[0]                   = 0;
00638         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
00639 
00640         abs_bord_trail = (abs_bord_trail + (ch_data->bs_num_env >> 1)) /
00641                    ch_data->bs_num_env;
00642         for (i = 0; i < num_rel_lead; i++)
00643             ch_data->t_env[i + 1] = ch_data->t_env[i] + abs_bord_trail;
00644 
00645         ch_data->bs_freq_res[1] = get_bits1(gb);
00646         for (i = 1; i < ch_data->bs_num_env; i++)
00647             ch_data->bs_freq_res[i + 1] = ch_data->bs_freq_res[1];
00648         break;
00649     case FIXVAR:
00650         abs_bord_trail                     += get_bits(gb, 2);
00651         num_rel_trail                       = get_bits(gb, 2);
00652         ch_data->bs_num_env                 = num_rel_trail + 1;
00653         ch_data->t_env[0]                   = 0;
00654         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
00655 
00656         for (i = 0; i < num_rel_trail; i++)
00657             ch_data->t_env[ch_data->bs_num_env - 1 - i] =
00658                 ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
00659 
00660         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
00661 
00662         for (i = 0; i < ch_data->bs_num_env; i++)
00663             ch_data->bs_freq_res[ch_data->bs_num_env - i] = get_bits1(gb);
00664         break;
00665     case VARFIX:
00666         ch_data->t_env[0]                   = get_bits(gb, 2);
00667         num_rel_lead                        = get_bits(gb, 2);
00668         ch_data->bs_num_env                 = num_rel_lead + 1;
00669         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
00670 
00671         for (i = 0; i < num_rel_lead; i++)
00672             ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
00673 
00674         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
00675 
00676         get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
00677         break;
00678     case VARVAR:
00679         ch_data->t_env[0]                   = get_bits(gb, 2);
00680         abs_bord_trail                     += get_bits(gb, 2);
00681         num_rel_lead                        = get_bits(gb, 2);
00682         num_rel_trail                       = get_bits(gb, 2);
00683         ch_data->bs_num_env                 = num_rel_lead + num_rel_trail + 1;
00684 
00685         if (ch_data->bs_num_env > 5) {
00686             av_log(ac->avctx, AV_LOG_ERROR,
00687                    "Invalid bitstream, too many SBR envelopes in VARVAR type SBR frame: %d\n",
00688                    ch_data->bs_num_env);
00689             return -1;
00690         }
00691 
00692         ch_data->t_env[ch_data->bs_num_env] = abs_bord_trail;
00693 
00694         for (i = 0; i < num_rel_lead; i++)
00695             ch_data->t_env[i + 1] = ch_data->t_env[i] + 2 * get_bits(gb, 2) + 2;
00696         for (i = 0; i < num_rel_trail; i++)
00697             ch_data->t_env[ch_data->bs_num_env - 1 - i] =
00698                 ch_data->t_env[ch_data->bs_num_env - i] - 2 * get_bits(gb, 2) - 2;
00699 
00700         bs_pointer = get_bits(gb, ceil_log2[ch_data->bs_num_env]);
00701 
00702         get_bits1_vector(gb, ch_data->bs_freq_res + 1, ch_data->bs_num_env);
00703         break;
00704     }
00705 
00706     if (bs_pointer > ch_data->bs_num_env + 1) {
00707         av_log(ac->avctx, AV_LOG_ERROR,
00708                "Invalid bitstream, bs_pointer points to a middle noise border outside the time borders table: %d\n",
00709                bs_pointer);
00710         return -1;
00711     }
00712 
00713     for (i = 1; i <= ch_data->bs_num_env; i++) {
00714         if (ch_data->t_env[i-1] > ch_data->t_env[i]) {
00715             av_log(ac->avctx, AV_LOG_ERROR, "Non monotone time borders\n");
00716             return -1;
00717         }
00718     }
00719 
00720     ch_data->bs_num_noise = (ch_data->bs_num_env > 1) + 1;
00721 
00722     ch_data->t_q[0]                     = ch_data->t_env[0];
00723     ch_data->t_q[ch_data->bs_num_noise] = ch_data->t_env[ch_data->bs_num_env];
00724     if (ch_data->bs_num_noise > 1) {
00725         unsigned int idx;
00726         if (ch_data->bs_frame_class == FIXFIX) {
00727             idx = ch_data->bs_num_env >> 1;
00728         } else if (ch_data->bs_frame_class & 1) { // FIXVAR or VARVAR
00729             idx = ch_data->bs_num_env - FFMAX(bs_pointer - 1, 1);
00730         } else { // VARFIX
00731             if (!bs_pointer)
00732                 idx = 1;
00733             else if (bs_pointer == 1)
00734                 idx = ch_data->bs_num_env - 1;
00735             else // bs_pointer > 1
00736                 idx = bs_pointer - 1;
00737         }
00738         ch_data->t_q[1] = ch_data->t_env[idx];
00739     }
00740 
00741     ch_data->e_a[0] = -(ch_data->e_a[1] != bs_num_env_old); // l_APrev
00742     ch_data->e_a[1] = -1;
00743     if ((ch_data->bs_frame_class & 1) && bs_pointer) { // FIXVAR or VARVAR and bs_pointer != 0
00744         ch_data->e_a[1] = ch_data->bs_num_env + 1 - bs_pointer;
00745     } else if ((ch_data->bs_frame_class == 2) && (bs_pointer > 1)) // VARFIX and bs_pointer > 1
00746         ch_data->e_a[1] = bs_pointer - 1;
00747 
00748     return 0;
00749 }
00750 
00751 static void copy_sbr_grid(SBRData *dst, const SBRData *src) {
00752     //These variables are saved from the previous frame rather than copied
00753     dst->bs_freq_res[0]    = dst->bs_freq_res[dst->bs_num_env];
00754     dst->t_env_num_env_old = dst->t_env[dst->bs_num_env];
00755     dst->e_a[0]            = -(dst->e_a[1] != dst->bs_num_env);
00756 
00757     //These variables are read from the bitstream and therefore copied
00758     memcpy(dst->bs_freq_res+1, src->bs_freq_res+1, sizeof(dst->bs_freq_res)-sizeof(*dst->bs_freq_res));
00759     memcpy(dst->t_env,         src->t_env,         sizeof(dst->t_env));
00760     memcpy(dst->t_q,           src->t_q,           sizeof(dst->t_q));
00761     dst->bs_num_env        = src->bs_num_env;
00762     dst->bs_amp_res        = src->bs_amp_res;
00763     dst->bs_num_noise      = src->bs_num_noise;
00764     dst->bs_frame_class    = src->bs_frame_class;
00765     dst->e_a[1]            = src->e_a[1];
00766 }
00767 
00769 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
00770                           SBRData *ch_data)
00771 {
00772     get_bits1_vector(gb, ch_data->bs_df_env,   ch_data->bs_num_env);
00773     get_bits1_vector(gb, ch_data->bs_df_noise, ch_data->bs_num_noise);
00774 }
00775 
00777 static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
00778                           SBRData *ch_data)
00779 {
00780     int i;
00781 
00782     memcpy(ch_data->bs_invf_mode[1], ch_data->bs_invf_mode[0], 5 * sizeof(uint8_t));
00783     for (i = 0; i < sbr->n_q; i++)
00784         ch_data->bs_invf_mode[0][i] = get_bits(gb, 2);
00785 }
00786 
00787 static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
00788                               SBRData *ch_data, int ch)
00789 {
00790     int bits;
00791     int i, j, k;
00792     VLC_TYPE (*t_huff)[2], (*f_huff)[2];
00793     int t_lav, f_lav;
00794     const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
00795     const int odd = sbr->n[1] & 1;
00796 
00797     if (sbr->bs_coupling && ch) {
00798         if (ch_data->bs_amp_res) {
00799             bits   = 5;
00800             t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_3_0DB].table;
00801             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_BAL_3_0DB];
00802             f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
00803             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_3_0DB];
00804         } else {
00805             bits   = 6;
00806             t_huff = vlc_sbr[T_HUFFMAN_ENV_BAL_1_5DB].table;
00807             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_BAL_1_5DB];
00808             f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_1_5DB].table;
00809             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_1_5DB];
00810         }
00811     } else {
00812         if (ch_data->bs_amp_res) {
00813             bits   = 6;
00814             t_huff = vlc_sbr[T_HUFFMAN_ENV_3_0DB].table;
00815             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_3_0DB];
00816             f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
00817             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_3_0DB];
00818         } else {
00819             bits   = 7;
00820             t_huff = vlc_sbr[T_HUFFMAN_ENV_1_5DB].table;
00821             t_lav  = vlc_sbr_lav[T_HUFFMAN_ENV_1_5DB];
00822             f_huff = vlc_sbr[F_HUFFMAN_ENV_1_5DB].table;
00823             f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_1_5DB];
00824         }
00825     }
00826 
00827     for (i = 0; i < ch_data->bs_num_env; i++) {
00828         if (ch_data->bs_df_env[i]) {
00829             // bs_freq_res[0] == bs_freq_res[bs_num_env] from prev frame
00830             if (ch_data->bs_freq_res[i + 1] == ch_data->bs_freq_res[i]) {
00831                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
00832                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
00833             } else if (ch_data->bs_freq_res[i + 1]) {
00834                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
00835                     k = (j + odd) >> 1; // find k such that f_tablelow[k] <= f_tablehigh[j] < f_tablelow[k + 1]
00836                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
00837                 }
00838             } else {
00839                 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
00840                     k = j ? 2*j - odd : 0; // find k such that f_tablehigh[k] == f_tablelow[j]
00841                     ch_data->env_facs[i + 1][j] = ch_data->env_facs[i][k] + delta * (get_vlc2(gb, t_huff, 9, 3) - t_lav);
00842                 }
00843             }
00844         } else {
00845             ch_data->env_facs[i + 1][0] = delta * get_bits(gb, bits); // bs_env_start_value_balance
00846             for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
00847                 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);
00848         }
00849     }
00850 
00851     //assign 0th elements of env_facs from last elements
00852     memcpy(ch_data->env_facs[0], ch_data->env_facs[ch_data->bs_num_env],
00853            sizeof(ch_data->env_facs[0]));
00854 }
00855 
00856 static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb,
00857                            SBRData *ch_data, int ch)
00858 {
00859     int i, j;
00860     VLC_TYPE (*t_huff)[2], (*f_huff)[2];
00861     int t_lav, f_lav;
00862     int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
00863 
00864     if (sbr->bs_coupling && ch) {
00865         t_huff = vlc_sbr[T_HUFFMAN_NOISE_BAL_3_0DB].table;
00866         t_lav  = vlc_sbr_lav[T_HUFFMAN_NOISE_BAL_3_0DB];
00867         f_huff = vlc_sbr[F_HUFFMAN_ENV_BAL_3_0DB].table;
00868         f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_BAL_3_0DB];
00869     } else {
00870         t_huff = vlc_sbr[T_HUFFMAN_NOISE_3_0DB].table;
00871         t_lav  = vlc_sbr_lav[T_HUFFMAN_NOISE_3_0DB];
00872         f_huff = vlc_sbr[F_HUFFMAN_ENV_3_0DB].table;
00873         f_lav  = vlc_sbr_lav[F_HUFFMAN_ENV_3_0DB];
00874     }
00875 
00876     for (i = 0; i < ch_data->bs_num_noise; i++) {
00877         if (ch_data->bs_df_noise[i]) {
00878             for (j = 0; j < sbr->n_q; j++)
00879                 ch_data->noise_facs[i + 1][j] = ch_data->noise_facs[i][j] + delta * (get_vlc2(gb, t_huff, 9, 2) - t_lav);
00880         } else {
00881             ch_data->noise_facs[i + 1][0] = delta * get_bits(gb, 5); // bs_noise_start_value_balance or bs_noise_start_value_level
00882             for (j = 1; j < sbr->n_q; j++)
00883                 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);
00884         }
00885     }
00886 
00887     //assign 0th elements of noise_facs from last elements
00888     memcpy(ch_data->noise_facs[0], ch_data->noise_facs[ch_data->bs_num_noise],
00889            sizeof(ch_data->noise_facs[0]));
00890 }
00891 
00892 static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
00893                                GetBitContext *gb,
00894                                int bs_extension_id, int *num_bits_left)
00895 {
00896     switch (bs_extension_id) {
00897     case EXTENSION_ID_PS:
00898         if (!ac->m4ac.ps) {
00899             av_log(ac->avctx, AV_LOG_ERROR, "Parametric Stereo signaled to be not-present but was found in the bitstream.\n");
00900             skip_bits_long(gb, *num_bits_left); // bs_fill_bits
00901             *num_bits_left = 0;
00902         } else {
00903 #if 1
00904             *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);
00905 #else
00906             av_log_missing_feature(ac->avctx, "Parametric Stereo is", 0);
00907             skip_bits_long(gb, *num_bits_left); // bs_fill_bits
00908             *num_bits_left = 0;
00909 #endif
00910         }
00911         break;
00912     default:
00913         av_log_missing_feature(ac->avctx, "Reserved SBR extensions are", 1);
00914         skip_bits_long(gb, *num_bits_left); // bs_fill_bits
00915         *num_bits_left = 0;
00916         break;
00917     }
00918 }
00919 
00920 static int read_sbr_single_channel_element(AACContext *ac,
00921                                             SpectralBandReplication *sbr,
00922                                             GetBitContext *gb)
00923 {
00924     if (get_bits1(gb)) // bs_data_extra
00925         skip_bits(gb, 4); // bs_reserved
00926 
00927     if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
00928         return -1;
00929     read_sbr_dtdf(sbr, gb, &sbr->data[0]);
00930     read_sbr_invf(sbr, gb, &sbr->data[0]);
00931     read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
00932     read_sbr_noise(sbr, gb, &sbr->data[0], 0);
00933 
00934     if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
00935         get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
00936 
00937     return 0;
00938 }
00939 
00940 static int read_sbr_channel_pair_element(AACContext *ac,
00941                                           SpectralBandReplication *sbr,
00942                                           GetBitContext *gb)
00943 {
00944     if (get_bits1(gb))    // bs_data_extra
00945         skip_bits(gb, 8); // bs_reserved
00946 
00947     if ((sbr->bs_coupling = get_bits1(gb))) {
00948         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
00949             return -1;
00950         copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
00951         read_sbr_dtdf(sbr, gb, &sbr->data[0]);
00952         read_sbr_dtdf(sbr, gb, &sbr->data[1]);
00953         read_sbr_invf(sbr, gb, &sbr->data[0]);
00954         memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
00955         memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
00956         read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
00957         read_sbr_noise(sbr, gb, &sbr->data[0], 0);
00958         read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
00959         read_sbr_noise(sbr, gb, &sbr->data[1], 1);
00960     } else {
00961         if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
00962             read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
00963             return -1;
00964         read_sbr_dtdf(sbr, gb, &sbr->data[0]);
00965         read_sbr_dtdf(sbr, gb, &sbr->data[1]);
00966         read_sbr_invf(sbr, gb, &sbr->data[0]);
00967         read_sbr_invf(sbr, gb, &sbr->data[1]);
00968         read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
00969         read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
00970         read_sbr_noise(sbr, gb, &sbr->data[0], 0);
00971         read_sbr_noise(sbr, gb, &sbr->data[1], 1);
00972     }
00973 
00974     if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
00975         get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
00976     if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
00977         get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
00978 
00979     return 0;
00980 }
00981 
00982 static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
00983                                   GetBitContext *gb, int id_aac)
00984 {
00985     unsigned int cnt = get_bits_count(gb);
00986 
00987     if (id_aac == TYPE_SCE || id_aac == TYPE_CCE) {
00988         if (read_sbr_single_channel_element(ac, sbr, gb)) {
00989             sbr->start = 0;
00990             return get_bits_count(gb) - cnt;
00991         }
00992     } else if (id_aac == TYPE_CPE) {
00993         if (read_sbr_channel_pair_element(ac, sbr, gb)) {
00994             sbr->start = 0;
00995             return get_bits_count(gb) - cnt;
00996         }
00997     } else {
00998         av_log(ac->avctx, AV_LOG_ERROR,
00999             "Invalid bitstream - cannot apply SBR to element type %d\n", id_aac);
01000         sbr->start = 0;
01001         return get_bits_count(gb) - cnt;
01002     }
01003     if (get_bits1(gb)) { // bs_extended_data
01004         int num_bits_left = get_bits(gb, 4); // bs_extension_size
01005         if (num_bits_left == 15)
01006             num_bits_left += get_bits(gb, 8); // bs_esc_count
01007 
01008         num_bits_left <<= 3;
01009         while (num_bits_left > 7) {
01010             num_bits_left -= 2;
01011             read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
01012         }
01013         if (num_bits_left < 0) {
01014             av_log(ac->avctx, AV_LOG_ERROR, "SBR Extension over read.\n");
01015         }
01016         if (num_bits_left > 0)
01017             skip_bits(gb, num_bits_left);
01018     }
01019 
01020     return get_bits_count(gb) - cnt;
01021 }
01022 
01023 static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
01024 {
01025     int err;
01026     err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
01027     if (err >= 0)
01028         err = sbr_make_f_derived(ac, sbr);
01029     if (err < 0) {
01030         av_log(ac->avctx, AV_LOG_ERROR,
01031                "SBR reset failed. Switching SBR to pure upsampling mode.\n");
01032         sbr->start = 0;
01033     }
01034 }
01035 
01044 int ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
01045                             GetBitContext *gb_host, int crc, int cnt, int id_aac)
01046 {
01047     unsigned int num_sbr_bits = 0, num_align_bits;
01048     unsigned bytes_read;
01049     GetBitContext gbc = *gb_host, *gb = &gbc;
01050     skip_bits_long(gb_host, cnt*8 - 4);
01051 
01052     sbr->reset = 0;
01053 
01054     if (!sbr->sample_rate)
01055         sbr->sample_rate = 2 * ac->m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
01056     if (!ac->m4ac.ext_sample_rate)
01057         ac->m4ac.ext_sample_rate = 2 * ac->m4ac.sample_rate;
01058 
01059     if (crc) {
01060         skip_bits(gb, 10); // bs_sbr_crc_bits; TODO - implement CRC check
01061         num_sbr_bits += 10;
01062     }
01063 
01064     //Save some state from the previous frame.
01065     sbr->kx[0] = sbr->kx[1];
01066     sbr->m[0] = sbr->m[1];
01067 
01068     num_sbr_bits++;
01069     if (get_bits1(gb)) // bs_header_flag
01070         num_sbr_bits += read_sbr_header(sbr, gb);
01071 
01072     if (sbr->reset)
01073         sbr_reset(ac, sbr);
01074 
01075     if (sbr->start)
01076         num_sbr_bits  += read_sbr_data(ac, sbr, gb, id_aac);
01077 
01078     num_align_bits = ((cnt << 3) - 4 - num_sbr_bits) & 7;
01079     bytes_read = ((num_sbr_bits + num_align_bits + 4) >> 3);
01080 
01081     if (bytes_read > cnt) {
01082         av_log(ac->avctx, AV_LOG_ERROR,
01083                "Expected to read %d SBR bytes actually read %d.\n", cnt, bytes_read);
01084     }
01085     return cnt;
01086 }
01087 
01089 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
01090 {
01091     int k, e;
01092     int ch;
01093 
01094     if (id_aac == TYPE_CPE && sbr->bs_coupling) {
01095         float alpha      = sbr->data[0].bs_amp_res ?  1.0f :  0.5f;
01096         float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f;
01097         for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
01098             for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
01099                 float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f);
01100                 float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha);
01101                 float fac   = temp1 / (1.0f + temp2);
01102                 sbr->data[0].env_facs[e][k] = fac;
01103                 sbr->data[1].env_facs[e][k] = fac * temp2;
01104             }
01105         }
01106         for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
01107             for (k = 0; k < sbr->n_q; k++) {
01108                 float temp1 = exp2f(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs[e][k] + 1);
01109                 float temp2 = exp2f(12 - sbr->data[1].noise_facs[e][k]);
01110                 float fac   = temp1 / (1.0f + temp2);
01111                 sbr->data[0].noise_facs[e][k] = fac;
01112                 sbr->data[1].noise_facs[e][k] = fac * temp2;
01113             }
01114         }
01115     } else { // SCE or one non-coupled CPE
01116         for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {
01117             float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f;
01118             for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
01119                 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++)
01120                     sbr->data[ch].env_facs[e][k] =
01121                         exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f);
01122             for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
01123                 for (k = 0; k < sbr->n_q; k++)
01124                     sbr->data[ch].noise_facs[e][k] =
01125                         exp2f(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs[e][k]);
01126         }
01127     }
01128 }
01129 
01136 static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in, float *x,
01137                              float z[320], float W[2][32][32][2],
01138                              float scale)
01139 {
01140     int i, k;
01141     memcpy(W[0], W[1], sizeof(W[0]));
01142     memcpy(x    , x+1024, (320-32)*sizeof(x[0]));
01143     if (scale != 1.0f)
01144         dsp->vector_fmul_scalar(x+288, in, scale, 1024);
01145     else
01146         memcpy(x+288, in, 1024*sizeof(*x));
01147     for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
01148                                // are not supported
01149         dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
01150         for (k = 0; k < 64; k++) {
01151             float f = z[k] + z[k + 64] + z[k + 128] + z[k + 192] + z[k + 256];
01152             z[k] = f;
01153         }
01154         //Shuffle to IMDCT
01155         z[64] = z[0];
01156         for (k = 1; k < 32; k++) {
01157             z[64+2*k-1] =  z[   k];
01158             z[64+2*k  ] = -z[64-k];
01159         }
01160         z[64+63] = z[32];
01161 
01162         ff_imdct_half(mdct, z, z+64);
01163         for (k = 0; k < 32; k++) {
01164             W[1][i][k][0] = -z[63-k];
01165             W[1][i][k][1] = z[k];
01166         }
01167         x += 32;
01168     }
01169 }
01170 
01175 static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
01176                               float *out, float X[2][38][64],
01177                               float mdct_buf[2][64],
01178                               float *v0, int *v_off, const unsigned int div,
01179                               float bias, float scale)
01180 {
01181     int i, n;
01182     const float *sbr_qmf_window = div ? sbr_qmf_window_ds : sbr_qmf_window_us;
01183     int scale_and_bias = scale != 1.0f || bias != 0.0f;
01184     float *v;
01185     for (i = 0; i < 32; i++) {
01186         if (*v_off == 0) {
01187             int saved_samples = (1280 - 128) >> div;
01188             memcpy(&v0[SBR_SYNTHESIS_BUF_SIZE - saved_samples], v0, saved_samples * sizeof(float));
01189             *v_off = SBR_SYNTHESIS_BUF_SIZE - saved_samples - (128 >> div);
01190         } else {
01191             *v_off -= 128 >> div;
01192         }
01193         v = v0 + *v_off;
01194         if (div) {
01195             for (n = 0; n < 32; n++) {
01196                 X[0][i][   n] = -X[0][i][n];
01197                 X[0][i][32+n] =  X[1][i][31-n];
01198             }
01199             ff_imdct_half(mdct, mdct_buf[0], X[0][i]);
01200             for (n = 0; n < 32; n++) {
01201                 v[     n] =  mdct_buf[0][63 - 2*n];
01202                 v[63 - n] = -mdct_buf[0][62 - 2*n];
01203             }
01204         } else {
01205             for (n = 1; n < 64; n+=2) {
01206                 X[1][i][n] = -X[1][i][n];
01207             }
01208             ff_imdct_half(mdct, mdct_buf[0], X[0][i]);
01209             ff_imdct_half(mdct, mdct_buf[1], X[1][i]);
01210             for (n = 0; n < 64; n++) {
01211                 v[      n] = -mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
01212                 v[127 - n] =  mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
01213             }
01214         }
01215         dsp->vector_fmul_add(out, v                , sbr_qmf_window               , zero64, 64 >> div);
01216         dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out   , 64 >> div);
01217         dsp->vector_fmul_add(out, v + ( 256 >> div), sbr_qmf_window + (128 >> div), out   , 64 >> div);
01218         dsp->vector_fmul_add(out, v + ( 448 >> div), sbr_qmf_window + (192 >> div), out   , 64 >> div);
01219         dsp->vector_fmul_add(out, v + ( 512 >> div), sbr_qmf_window + (256 >> div), out   , 64 >> div);
01220         dsp->vector_fmul_add(out, v + ( 704 >> div), sbr_qmf_window + (320 >> div), out   , 64 >> div);
01221         dsp->vector_fmul_add(out, v + ( 768 >> div), sbr_qmf_window + (384 >> div), out   , 64 >> div);
01222         dsp->vector_fmul_add(out, v + ( 960 >> div), sbr_qmf_window + (448 >> div), out   , 64 >> div);
01223         dsp->vector_fmul_add(out, v + (1024 >> div), sbr_qmf_window + (512 >> div), out   , 64 >> div);
01224         dsp->vector_fmul_add(out, v + (1216 >> div), sbr_qmf_window + (576 >> div), out   , 64 >> div);
01225         if (scale_and_bias)
01226             for (n = 0; n < 64 >> div; n++)
01227                 out[n] = out[n] * scale + bias;
01228         out += 64 >> div;
01229     }
01230 }
01231 
01232 static void autocorrelate(const float x[40][2], float phi[3][2][2], int lag)
01233 {
01234     int i;
01235     float real_sum = 0.0f;
01236     float imag_sum = 0.0f;
01237     if (lag) {
01238         for (i = 1; i < 38; i++) {
01239             real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
01240             imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
01241         }
01242         phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
01243         phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
01244         if (lag == 1) {
01245             phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
01246             phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
01247         }
01248     } else {
01249         for (i = 1; i < 38; i++) {
01250             real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
01251         }
01252         phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
01253         phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
01254     }
01255 }
01256 
01261 static void sbr_hf_inverse_filter(float (*alpha0)[2], float (*alpha1)[2],
01262                                   const float X_low[32][40][2], int k0)
01263 {
01264     int k;
01265     for (k = 0; k < k0; k++) {
01266         float phi[3][2][2], dk;
01267 
01268         autocorrelate(X_low[k], phi, 0);
01269         autocorrelate(X_low[k], phi, 1);
01270         autocorrelate(X_low[k], phi, 2);
01271 
01272         dk =  phi[2][1][0] * phi[1][0][0] -
01273              (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
01274 
01275         if (!dk) {
01276             alpha1[k][0] = 0;
01277             alpha1[k][1] = 0;
01278         } else {
01279             float temp_real, temp_im;
01280             temp_real = phi[0][0][0] * phi[1][1][0] -
01281                         phi[0][0][1] * phi[1][1][1] -
01282                         phi[0][1][0] * phi[1][0][0];
01283             temp_im   = phi[0][0][0] * phi[1][1][1] +
01284                         phi[0][0][1] * phi[1][1][0] -
01285                         phi[0][1][1] * phi[1][0][0];
01286 
01287             alpha1[k][0] = temp_real / dk;
01288             alpha1[k][1] = temp_im   / dk;
01289         }
01290 
01291         if (!phi[1][0][0]) {
01292             alpha0[k][0] = 0;
01293             alpha0[k][1] = 0;
01294         } else {
01295             float temp_real, temp_im;
01296             temp_real = phi[0][0][0] + alpha1[k][0] * phi[1][1][0] +
01297                                        alpha1[k][1] * phi[1][1][1];
01298             temp_im   = phi[0][0][1] + alpha1[k][1] * phi[1][1][0] -
01299                                        alpha1[k][0] * phi[1][1][1];
01300 
01301             alpha0[k][0] = -temp_real / phi[1][0][0];
01302             alpha0[k][1] = -temp_im   / phi[1][0][0];
01303         }
01304 
01305         if (alpha1[k][0] * alpha1[k][0] + alpha1[k][1] * alpha1[k][1] >= 16.0f ||
01306            alpha0[k][0] * alpha0[k][0] + alpha0[k][1] * alpha0[k][1] >= 16.0f) {
01307             alpha1[k][0] = 0;
01308             alpha1[k][1] = 0;
01309             alpha0[k][0] = 0;
01310             alpha0[k][1] = 0;
01311         }
01312     }
01313 }
01314 
01316 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
01317 {
01318     int i;
01319     float new_bw;
01320     static const float bw_tab[] = { 0.0f, 0.75f, 0.9f, 0.98f };
01321 
01322     for (i = 0; i < sbr->n_q; i++) {
01323         if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1) {
01324             new_bw = 0.6f;
01325         } else
01326             new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];
01327 
01328         if (new_bw < ch_data->bw_array[i]) {
01329             new_bw = 0.75f    * new_bw + 0.25f    * ch_data->bw_array[i];
01330         } else
01331             new_bw = 0.90625f * new_bw + 0.09375f * ch_data->bw_array[i];
01332         ch_data->bw_array[i] = new_bw < 0.015625f ? 0.0f : new_bw;
01333     }
01334 }
01335 
01337 static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr,
01338                       float X_low[32][40][2], const float W[2][32][32][2])
01339 {
01340     int i, k;
01341     const int t_HFGen = 8;
01342     const int i_f = 32;
01343     memset(X_low, 0, 32*sizeof(*X_low));
01344     for (k = 0; k < sbr->kx[1]; k++) {
01345         for (i = t_HFGen; i < i_f + t_HFGen; i++) {
01346             X_low[k][i][0] = W[1][i - t_HFGen][k][0];
01347             X_low[k][i][1] = W[1][i - t_HFGen][k][1];
01348         }
01349     }
01350     for (k = 0; k < sbr->kx[0]; k++) {
01351         for (i = 0; i < t_HFGen; i++) {
01352             X_low[k][i][0] = W[0][i + i_f - t_HFGen][k][0];
01353             X_low[k][i][1] = W[0][i + i_f - t_HFGen][k][1];
01354         }
01355     }
01356     return 0;
01357 }
01358 
01360 static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
01361                       float X_high[64][40][2], const float X_low[32][40][2],
01362                       const float (*alpha0)[2], const float (*alpha1)[2],
01363                       const float bw_array[5], const uint8_t *t_env,
01364                       int bs_num_env)
01365 {
01366     int i, j, x;
01367     int g = 0;
01368     int k = sbr->kx[1];
01369     for (j = 0; j < sbr->num_patches; j++) {
01370         for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
01371             float alpha[4];
01372             const int p = sbr->patch_start_subband[j] + x;
01373             while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
01374                 g++;
01375             g--;
01376 
01377             if (g < 0) {
01378                 av_log(ac->avctx, AV_LOG_ERROR,
01379                        "ERROR : no subband found for frequency %d\n", k);
01380                 return -1;
01381             }
01382 
01383             alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g];
01384             alpha[1] = alpha1[p][1] * bw_array[g] * bw_array[g];
01385             alpha[2] = alpha0[p][0] * bw_array[g];
01386             alpha[3] = alpha0[p][1] * bw_array[g];
01387 
01388             for (i = 2 * t_env[0]; i < 2 * t_env[bs_num_env]; i++) {
01389                 const int idx = i + ENVELOPE_ADJUSTMENT_OFFSET;
01390                 X_high[k][idx][0] =
01391                     X_low[p][idx - 2][0] * alpha[0] -
01392                     X_low[p][idx - 2][1] * alpha[1] +
01393                     X_low[p][idx - 1][0] * alpha[2] -
01394                     X_low[p][idx - 1][1] * alpha[3] +
01395                     X_low[p][idx][0];
01396                 X_high[k][idx][1] =
01397                     X_low[p][idx - 2][1] * alpha[0] +
01398                     X_low[p][idx - 2][0] * alpha[1] +
01399                     X_low[p][idx - 1][1] * alpha[2] +
01400                     X_low[p][idx - 1][0] * alpha[3] +
01401                     X_low[p][idx][1];
01402             }
01403         }
01404     }
01405     if (k < sbr->m[1] + sbr->kx[1])
01406         memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
01407 
01408     return 0;
01409 }
01410 
01412 static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],
01413                      const float X_low[32][40][2], const float Y[2][38][64][2],
01414                      int ch)
01415 {
01416     int k, i;
01417     const int i_f = 32;
01418     const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
01419     memset(X, 0, 2*sizeof(*X));
01420     for (k = 0; k < sbr->kx[0]; k++) {
01421         for (i = 0; i < i_Temp; i++) {
01422             X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
01423             X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
01424         }
01425     }
01426     for (; k < sbr->kx[0] + sbr->m[0]; k++) {
01427         for (i = 0; i < i_Temp; i++) {
01428             X[0][i][k] = Y[0][i + i_f][k][0];
01429             X[1][i][k] = Y[0][i + i_f][k][1];
01430         }
01431     }
01432 
01433     for (k = 0; k < sbr->kx[1]; k++) {
01434         for (i = i_Temp; i < 38; i++) {
01435             X[0][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][0];
01436             X[1][i][k] = X_low[k][i + ENVELOPE_ADJUSTMENT_OFFSET][1];
01437         }
01438     }
01439     for (; k < sbr->kx[1] + sbr->m[1]; k++) {
01440         for (i = i_Temp; i < i_f; i++) {
01441             X[0][i][k] = Y[1][i][k][0];
01442             X[1][i][k] = Y[1][i][k][1];
01443         }
01444     }
01445     return 0;
01446 }
01447 
01451 static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
01452                         SBRData *ch_data, int e_a[2])
01453 {
01454     int e, i, m;
01455 
01456     memset(ch_data->s_indexmapped[1], 0, 7*sizeof(ch_data->s_indexmapped[1]));
01457     for (e = 0; e < ch_data->bs_num_env; e++) {
01458         const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
01459         uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
01460         int k;
01461 
01462         for (i = 0; i < ilim; i++)
01463             for (m = table[i]; m < table[i + 1]; m++)
01464                 sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
01465 
01466         // ch_data->bs_num_noise > 1 => 2 noise floors
01467         k = (ch_data->bs_num_noise > 1) && (ch_data->t_env[e] >= ch_data->t_q[1]);
01468         for (i = 0; i < sbr->n_q; i++)
01469             for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
01470                 sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
01471 
01472         for (i = 0; i < sbr->n[1]; i++) {
01473             if (ch_data->bs_add_harmonic_flag) {
01474                 const unsigned int m_midpoint =
01475                     (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
01476 
01477                 ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
01478                     (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
01479             }
01480         }
01481 
01482         for (i = 0; i < ilim; i++) {
01483             int additional_sinusoid_present = 0;
01484             for (m = table[i]; m < table[i + 1]; m++) {
01485                 if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
01486                     additional_sinusoid_present = 1;
01487                     break;
01488                 }
01489             }
01490             memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
01491                    (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
01492         }
01493     }
01494 
01495     memcpy(ch_data->s_indexmapped[0], ch_data->s_indexmapped[ch_data->bs_num_env], sizeof(ch_data->s_indexmapped[0]));
01496 }
01497 
01499 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
01500                              SpectralBandReplication *sbr, SBRData *ch_data)
01501 {
01502     int e, i, m;
01503 
01504     if (sbr->bs_interpol_freq) {
01505         for (e = 0; e < ch_data->bs_num_env; e++) {
01506             const float recip_env_size = 0.5f / (ch_data->t_env[e + 1] - ch_data->t_env[e]);
01507             int ilb = ch_data->t_env[e]     * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
01508             int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
01509 
01510             for (m = 0; m < sbr->m[1]; m++) {
01511                 float sum = 0.0f;
01512 
01513                 for (i = ilb; i < iub; i++) {
01514                     sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
01515                            X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
01516                 }
01517                 e_curr[e][m] = sum * recip_env_size;
01518             }
01519         }
01520     } else {
01521         int k, p;
01522 
01523         for (e = 0; e < ch_data->bs_num_env; e++) {
01524             const int env_size = 2 * (ch_data->t_env[e + 1] - ch_data->t_env[e]);
01525             int ilb = ch_data->t_env[e]     * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
01526             int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
01527             const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
01528 
01529             for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
01530                 float sum = 0.0f;
01531                 const int den = env_size * (table[p + 1] - table[p]);
01532 
01533                 for (k = table[p]; k < table[p + 1]; k++) {
01534                     for (i = ilb; i < iub; i++) {
01535                         sum += X_high[k][i][0] * X_high[k][i][0] +
01536                                X_high[k][i][1] * X_high[k][i][1];
01537                     }
01538                 }
01539                 sum /= den;
01540                 for (k = table[p]; k < table[p + 1]; k++) {
01541                     e_curr[e][k - sbr->kx[1]] = sum;
01542                 }
01543             }
01544         }
01545     }
01546 }
01547 
01552 static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
01553                           SBRData *ch_data, const int e_a[2])
01554 {
01555     int e, k, m;
01556     // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)
01557     static const float limgain[4] = { 0.70795, 1.0, 1.41254, 10000000000 };
01558 
01559     for (e = 0; e < ch_data->bs_num_env; e++) {
01560         int delta = !((e == e_a[1]) || (e == e_a[0]));
01561         for (k = 0; k < sbr->n_lim; k++) {
01562             float gain_boost, gain_max;
01563             float sum[2] = { 0.0f, 0.0f };
01564             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
01565                 const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
01566                 sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
01567                 sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
01568                 if (!sbr->s_mapped[e][m]) {
01569                     sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
01570                                             ((1.0f + sbr->e_curr[e][m]) *
01571                                              (1.0f + sbr->q_mapped[e][m] * delta)));
01572                 } else {
01573                     sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
01574                                             ((1.0f + sbr->e_curr[e][m]) *
01575                                              (1.0f + sbr->q_mapped[e][m])));
01576                 }
01577             }
01578             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
01579                 sum[0] += sbr->e_origmapped[e][m];
01580                 sum[1] += sbr->e_curr[e][m];
01581             }
01582             gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
01583             gain_max = FFMIN(100000, gain_max);
01584             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
01585                 float q_m_max   = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
01586                 sbr->q_m[e][m]  = FFMIN(sbr->q_m[e][m], q_m_max);
01587                 sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
01588             }
01589             sum[0] = sum[1] = 0.0f;
01590             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
01591                 sum[0] += sbr->e_origmapped[e][m];
01592                 sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
01593                           + sbr->s_m[e][m] * sbr->s_m[e][m]
01594                           + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
01595             }
01596             gain_boost = sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
01597             gain_boost = FFMIN(1.584893192, gain_boost);
01598             for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
01599                 sbr->gain[e][m] *= gain_boost;
01600                 sbr->q_m[e][m]  *= gain_boost;
01601                 sbr->s_m[e][m]  *= gain_boost;
01602             }
01603         }
01604     }
01605 }
01606 
01608 static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2],
01609                             SpectralBandReplication *sbr, SBRData *ch_data,
01610                             const int e_a[2])
01611 {
01612     int e, i, j, m;
01613     const int h_SL = 4 * !sbr->bs_smoothing_mode;
01614     const int kx = sbr->kx[1];
01615     const int m_max = sbr->m[1];
01616     static const float h_smooth[5] = {
01617         0.33333333333333,
01618         0.30150283239582,
01619         0.21816949906249,
01620         0.11516383427084,
01621         0.03183050093751,
01622     };
01623     static const int8_t phi[2][4] = {
01624         {  1,  0, -1,  0}, // real
01625         {  0,  1,  0, -1}, // imaginary
01626     };
01627     float (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;
01628     int indexnoise = ch_data->f_indexnoise;
01629     int indexsine  = ch_data->f_indexsine;
01630     memcpy(Y[0], Y[1], sizeof(Y[0]));
01631 
01632     if (sbr->reset) {
01633         for (i = 0; i < h_SL; i++) {
01634             memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
01635             memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0],  m_max * sizeof(sbr->q_m[0][0]));
01636         }
01637     } else if (h_SL) {
01638         memcpy(g_temp[2*ch_data->t_env[0]], g_temp[2*ch_data->t_env_num_env_old], 4*sizeof(g_temp[0]));
01639         memcpy(q_temp[2*ch_data->t_env[0]], q_temp[2*ch_data->t_env_num_env_old], 4*sizeof(q_temp[0]));
01640     }
01641 
01642     for (e = 0; e < ch_data->bs_num_env; e++) {
01643         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
01644             memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
01645             memcpy(q_temp[h_SL + i], sbr->q_m[e],  m_max * sizeof(sbr->q_m[0][0]));
01646         }
01647     }
01648 
01649     for (e = 0; e < ch_data->bs_num_env; e++) {
01650         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
01651             int phi_sign = (1 - 2*(kx & 1));
01652 
01653             if (h_SL && e != e_a[0] && e != e_a[1]) {
01654                 for (m = 0; m < m_max; m++) {
01655                     const int idx1 = i + h_SL;
01656                     float g_filt = 0.0f;
01657                     for (j = 0; j <= h_SL; j++)
01658                         g_filt += g_temp[idx1 - j][m] * h_smooth[j];
01659                     Y[1][i][m + kx][0] =
01660                         X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
01661                     Y[1][i][m + kx][1] =
01662                         X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
01663                 }
01664             } else {
01665                 for (m = 0; m < m_max; m++) {
01666                     const float g_filt = g_temp[i + h_SL][m];
01667                     Y[1][i][m + kx][0] =
01668                         X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
01669                     Y[1][i][m + kx][1] =
01670                         X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
01671                 }
01672             }
01673 
01674             if (e != e_a[0] && e != e_a[1]) {
01675                 for (m = 0; m < m_max; m++) {
01676                     indexnoise = (indexnoise + 1) & 0x1ff;
01677                     if (sbr->s_m[e][m]) {
01678                         Y[1][i][m + kx][0] +=
01679                             sbr->s_m[e][m] * phi[0][indexsine];
01680                         Y[1][i][m + kx][1] +=
01681                             sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
01682                     } else {
01683                         float q_filt;
01684                         if (h_SL) {
01685                             const int idx1 = i + h_SL;
01686                             q_filt = 0.0f;
01687                             for (j = 0; j <= h_SL; j++)
01688                                 q_filt += q_temp[idx1 - j][m] * h_smooth[j];
01689                         } else {
01690                             q_filt = q_temp[i][m];
01691                         }
01692                         Y[1][i][m + kx][0] +=
01693                             q_filt * sbr_noise_table[indexnoise][0];
01694                         Y[1][i][m + kx][1] +=
01695                             q_filt * sbr_noise_table[indexnoise][1];
01696                     }
01697                     phi_sign = -phi_sign;
01698                 }
01699             } else {
01700                 indexnoise = (indexnoise + m_max) & 0x1ff;
01701                 for (m = 0; m < m_max; m++) {
01702                     Y[1][i][m + kx][0] +=
01703                         sbr->s_m[e][m] * phi[0][indexsine];
01704                     Y[1][i][m + kx][1] +=
01705                         sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
01706                     phi_sign = -phi_sign;
01707                 }
01708             }
01709             indexsine = (indexsine + 1) & 3;
01710         }
01711     }
01712     ch_data->f_indexnoise = indexnoise;
01713     ch_data->f_indexsine  = indexsine;
01714 }
01715 
01716 void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
01717                   float* L, float* R)
01718 {
01719     int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
01720     int ch;
01721     int nch = (id_aac == TYPE_CPE) ? 2 : 1;
01722 
01723     if (sbr->start) {
01724         sbr_dequant(sbr, id_aac);
01725     }
01726     for (ch = 0; ch < nch; ch++) {
01727         /* decode channel */
01728         sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
01729                          (float*)sbr->qmf_filter_scratch,
01730                          sbr->data[ch].W, 1/(-1024 * ac->sf_scale));
01731         sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
01732         if (sbr->start) {
01733             sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
01734             sbr_chirp(sbr, &sbr->data[ch]);
01735             sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
01736                        sbr->data[ch].bw_array, sbr->data[ch].t_env,
01737                        sbr->data[ch].bs_num_env);
01738 
01739             // hf_adj
01740             sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
01741             sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
01742             sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
01743             sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
01744                             sbr->data[ch].e_a);
01745         }
01746 
01747         /* synthesis */
01748         sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
01749     }
01750 
01751     if (ac->m4ac.ps == 1) {
01752         if (sbr->ps.start) {
01753             ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
01754         } else {
01755             memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
01756         }
01757         nch = 2;
01758     }
01759 
01760     sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
01761                       sbr->data[0].synthesis_filterbank_samples,
01762                       &sbr->data[0].synthesis_filterbank_samples_offset,
01763                       downsampled,
01764                       ac->add_bias, -1024 * ac->sf_scale);
01765     if (nch == 2)
01766         sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
01767                           sbr->data[1].synthesis_filterbank_samples,
01768                           &sbr->data[1].synthesis_filterbank_samples_offset,
01769                           downsampled,
01770                           ac->add_bias, -1024 * ac->sf_scale);
01771 }

Generated on Fri Sep 16 2011 17:17:33 for FFmpeg by  doxygen 1.7.1