Libav
|
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 }