Lines Matching defs:sbr
30 #include "sbr.h"
129 av_cold void ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
132 sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
133 sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
134 sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
135 sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
140 ff_mdct_init(&sbr->mdct, 7, 1, 1.0 / (64 * mdct_scale));
141 ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * mdct_scale);
142 ff_ps_ctx_init(&sbr->ps);
145 av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
147 ff_mdct_end(&sbr->mdct);
148 ff_mdct_end(&sbr->mdct_ana);
166 static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
169 if (sbr->bs_limiter_bands > 0) {
173 const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
175 uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
177 patch_borders[0] = sbr->kx[1];
178 for (k = 1; k <= sbr->num_patches; k++)
179 patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
181 memcpy(sbr->f_tablelim, sbr->f_tablelow,
182 (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
183 if (sbr->num_patches > 1)
184 memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
185 (sbr->num_patches - 1) * sizeof(patch_borders[0]));
187 qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
188 sizeof(sbr->f_tablelim[0]),
191 sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
192 while (out < sbr->f_tablelim + sbr->n_lim) {
196 !in_table_int16(patch_borders, sbr->num_patches, *in)) {
198 sbr->n_lim--;
199 } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
201 sbr->n_lim--;
207 sbr->f_tablelim[0] = sbr->f_tablelow[0];
208 sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
209 sbr->n_lim = 1;
213 static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
218 int old_bs_limiter_bands = sbr->bs_limiter_bands;
221 sbr->start = 1;
224 memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
226 sbr->bs_amp_res_header = get_bits1(gb);
227 sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
228 sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
229 sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
236 sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2);
237 sbr->spectrum_params.bs_alter_scale = get_bits1(gb);
238 sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2);
240 sbr->spectrum_params.bs_freq_scale = 2;
241 sbr->spectrum_params.bs_alter_scale = 1;
242 sbr->spectrum_params.bs_noise_bands = 2;
246 if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
247 sbr->reset = 1;
250 sbr->bs_limiter_bands = get_bits(gb, 2);
251 sbr->bs_limiter_gains = get_bits(gb, 2);
252 sbr->bs_interpol_freq = get_bits1(gb);
253 sbr->bs_smoothing_mode = get_bits1(gb);
255 sbr->bs_limiter_bands = 2;
256 sbr->bs_limiter_gains = 2;
257 sbr->bs_interpol_freq = 1;
258 sbr->bs_smoothing_mode = 1;
261 if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
262 sbr_make_f_tablelim(sbr);
310 static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
319 if (sbr->sample_rate < 32000) {
321 } else if (sbr->sample_rate < 64000) {
326 start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
327 stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
329 switch (sbr->sample_rate) {
350 "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
354 sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
357 sbr->k[2] = stop_min;
361 sbr->k[2] += stop_dk[k];
363 sbr->k[2] = 2*sbr->k[0];
365 sbr->k[2] = 3*sbr->k[0];
371 sbr->k[2] = FFMIN(64, sbr->k[2]);
374 if (sbr->sample_rate <= 32000) {
376 } else if (sbr->sample_rate == 44100) {
378 } else if (sbr->sample_rate >= 48000)
381 if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
383 "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
391 sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
392 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
395 for (k = 1; k <= sbr->n_master; k++)
396 sbr->f_master[k] = dk;
398 k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
400 sbr->f_master[1]--;
401 sbr->f_master[2]-= (k2diff < -1);
403 sbr->f_master[sbr->n_master]++;
406 sbr->f_master[0] = sbr->k[0];
407 for (k = 1; k <= sbr->n_master; k++)
408 sbr->f_master[k] += sbr->f_master[k - 1];
416 if (49 * sbr->k[2] > 110 * sbr->k[0]) {
418 sbr->k[1] = 2 * sbr->k[0];
421 sbr->k[1] = sbr->k[2];
424 num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
433 make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
438 vk0[0] = sbr->k[0];
452 log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
454 make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
468 vk1[0] = sbr->k[1];
477 sbr->n_master = num_bands_0 + num_bands_1;
478 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
480 memcpy(&sbr->f_master[0], vk0,
481 (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
482 memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
483 num_bands_1 * sizeof(sbr->f_master[0]));
486 sbr->n_master = num_bands_0;
487 if (check_n_master(ac->avctx, sbr->n_master, sbr->spectrum_params.bs_xover_band))
489 memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
497 static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
500 int msb = sbr->k[0];
501 int usb = sbr->kx[1];
502 int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
504 sbr->num_patches = 0;
506 if (goal_sb < sbr->kx[1] + sbr->m[1]) {
507 for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
509 k = sbr->n_master;
513 for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
514 sb = sbr->f_master[i];
515 odd = (sb + sbr->k[0]) & 1;
522 if (sbr->num_patches > 5) {
523 av_log(ac->avctx, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
527 sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
528 sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
530 if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
533 sbr->num_patches++;
535 msb = sbr->kx[1];
537 if (sbr->f_master[k] - sb < 3)
538 k = sbr->n_master;
539 } while (sb != sbr->kx[1] + sbr->m[1]);
541 if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
542 sbr->num_patches--;
548 static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
552 sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
553 sbr->n[0] = (sbr->n[1] + 1) >> 1;
555 memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
556 (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
557 sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
558 sbr->kx[1] = sbr->f_tablehigh[0];
561 if (sbr->kx[1] + sbr->m[1] > 64) {
563 "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
566 if (sbr->kx[1] > 32) {
567 av_log(ac->avctx, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
571 sbr->f_tablelow[0] = sbr->f_tablehigh[0];
572 temp = sbr->n[1] & 1;
573 for (k = 1; k <= sbr->n[0]; k++)
574 sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
576 sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *
577 log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
578 if (sbr->n_q > 5) {
579 av_log(ac->avctx, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
583 sbr->f_tablenoise[0] = sbr->f_tablelow[0];
585 for (k = 1; k <= sbr->n_q; k++) {
586 temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
587 sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
590 if (sbr_hf_calc_npatches(ac, sbr) < 0)
593 sbr_make_f_tablelim(sbr);
595 sbr->data[0].f_indexnoise = 0;
596 sbr->data[1].f_indexnoise = 0;
615 static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
626 ch_data->bs_amp_res = sbr->bs_amp_res_header;
775 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
783 static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
789 for (i = 0; i < sbr->n_q; i++)
793 static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
800 const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
801 const int odd = sbr->n[1] & 1;
803 if (sbr->bs_coupling && ch) {
837 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
840 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
845 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
852 for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
862 static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb,
868 int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
870 if (sbr->bs_coupling && ch) {
884 for (j = 0; j < sbr->n_q; j++)
888 for (j = 1; j < sbr->n_q; j++)
898 static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
910 *num_bits_left -= ff_ps_read_data(ac->avctx, gb, &sbr->ps, *num_bits_left);
927 SpectralBandReplication *sbr,
933 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
935 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
936 read_sbr_invf(sbr, gb, &sbr->data[0]);
937 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
938 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
940 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
941 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
947 SpectralBandReplication *sbr,
953 if ((sbr->bs_coupling = get_bits1(gb))) {
954 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
956 copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
957 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
958 read_sbr_dtdf(sbr, gb, &sbr->data[1]);
959 read_sbr_invf(sbr, gb, &sbr->data[0]);
960 memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
961 memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
962 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
963 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
964 read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
965 read_sbr_noise(sbr, gb, &sbr->data[1], 1);
967 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
968 read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
970 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
971 read_sbr_dtdf(sbr, gb, &sbr->data[1]);
972 read_sbr_invf(sbr, gb, &sbr->data[0]);
973 read_sbr_invf(sbr, gb, &sbr->data[1]);
974 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
975 read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
976 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
977 read_sbr_noise(sbr, gb, &sbr->data[1], 1);
980 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
981 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
982 if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
983 get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
988 static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
994 if (read_sbr_single_channel_element(ac, sbr, gb)) {
995 sbr->start = 0;
999 if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1000 sbr->start = 0;
1006 sbr->start = 0;
1017 read_sbr_extension(ac, sbr, gb, get_bits(gb, 2), &num_bits_left); // bs_extension_id
1029 static void sbr_reset(AACContext *ac, SpectralBandReplication *sbr)
1032 err = sbr_make_f_master(ac, sbr, &sbr->spectrum_params);
1034 err = sbr_make_f_derived(ac, sbr);
1038 sbr->start = 0;
1050 int ff_decode_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
1058 sbr->reset = 0;
1060 if (!sbr->sample_rate)
1061 sbr->sample_rate = 2 * ac->m4ac.sample_rate; //TODO use the nominal sample rate for arbitrary sample rate support
1071 sbr->kx[0] = sbr->kx[1];
1072 sbr->m[0] = sbr->m[1];
1076 num_sbr_bits += read_sbr_header(sbr, gb);
1078 if (sbr->reset)
1079 sbr_reset(ac, sbr);
1081 if (sbr->start)
1082 num_sbr_bits += read_sbr_data(ac, sbr, gb, id_aac);
1095 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
1100 if (id_aac == TYPE_CPE && sbr->bs_coupling) {
1101 float alpha = sbr->data[0].bs_amp_res ? 1.0f : 0.5f;
1102 float pan_offset = sbr->data[0].bs_amp_res ? 12.0f : 24.0f;
1103 for (e = 1; e <= sbr->data[0].bs_num_env; e++) {
1104 for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {
1105 float temp1 = exp2f(sbr->data[0].env_facs[e][k] * alpha + 7.0f);
1106 float temp2 = exp2f((pan_offset - sbr->data[1].env_facs[e][k]) * alpha);
1108 sbr->data[0].env_facs[e][k] = fac;
1109 sbr->data[1].env_facs[e][k] = fac * temp2;
1112 for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {
1113 for (k = 0; k < sbr->n_q; k++) {
1114 float temp1 = exp2f(NOISE_FLOOR_OFFSET - sbr->data[0].noise_facs[e][k] + 1);
1115 float temp2 = exp2f(12 - sbr->data[1].noise_facs[e][k]);
1117 sbr->data[0].noise_facs[e][k] = fac;
1118 sbr->data[1].noise_facs[e][k] = fac * temp2;
1123 float alpha = sbr->data[ch].bs_amp_res ? 1.0f : 0.5f;
1124 for (e = 1; e <= sbr->data[ch].bs_num_env; e++)
1125 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++)
1126 sbr->data[ch].env_facs[e][k] =
1127 exp2f(alpha * sbr->data[ch].env_facs[e][k] + 6.0f);
1128 for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)
1129 for (k = 0; k < sbr->n_q; k++)
1130 sbr->data[ch].noise_facs[e][k] =
1131 exp2f(NOISE_FLOOR_OFFSET - sbr->data[ch].noise_facs[e][k]);
1314 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
1320 for (i = 0; i < sbr->n_q; i++) {
1335 static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr,
1342 for (k = 0; k < sbr->kx[1]; k++) {
1348 for (k = 0; k < sbr->kx[0]; k++) {
1358 static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
1366 int k = sbr->kx[1];
1367 for (j = 0; j < sbr->num_patches; j++) {
1368 for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1370 const int p = sbr->patch_start_subband[j] + x;
1371 while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1403 if (k < sbr->m[1] + sbr->kx[1])
1404 memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1410 static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][38][64],
1416 const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1418 for (k = 0; k < sbr->kx[0]; k++) {
1424 for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1431 for (k = 0; k < sbr->kx[1]; k++) {
1437 for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1449 static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
1456 const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1457 uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1462 sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1466 for (i = 0; i < sbr->n_q; i++)
1467 for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1468 sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1470 for (i = 0; i < sbr->n[1]; i++) {
1473 (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1475 ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1476 (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1483 if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1488 memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1489 (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1498 SpectralBandReplication *sbr, SBRData *ch_data)
1502 if (sbr->bs_interpol_freq) {
1508 for (m = 0; m < sbr->m[1]; m++) {
1512 sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
1513 X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
1525 const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1527 for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
1539 e_curr[e][k - sbr->kx[1]] = sum;
1550 static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
1559 for (k = 0; k < sbr->n_lim; k++) {
1562 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1563 const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
1564 sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
1565 sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
1566 if (!sbr->s_mapped[e][m]) {
1567 sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
1568 ((1.0f + sbr->e_curr[e][m]) *
1569 (1.0f + sbr->q_mapped[e][m] * delta)));
1571 sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
1572 ((1.0f + sbr->e_curr[e][m]) *
1573 (1.0f + sbr->q_mapped[e][m])));
1576 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1577 sum[0] += sbr->e_origmapped[e][m];
1578 sum[1] += sbr->e_curr[e][m];
1580 gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1582 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1583 float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
1584 sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
1585 sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
1588 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1589 sum[0] += sbr->e_origmapped[e][m];
1590 sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
1591 + sbr->s_m[e][m] * sbr->s_m[e][m]
1592 + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
1596 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1597 sbr->gain[e][m] *= gain_boost;
1598 sbr->q_m[e][m] *= gain_boost;
1599 sbr->s_m[e][m] *= gain_boost;
1607 SpectralBandReplication *sbr, SBRData *ch_data,
1611 const int h_SL = 4 * !sbr->bs_smoothing_mode;
1612 const int kx = sbr->kx[1];
1613 const int m_max = sbr->m[1];
1630 if (sbr->reset) {
1632 memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
1633 memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
1642 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
1643 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
1675 if (sbr->s_m[e][m]) {
1677 sbr->s_m[e][m] * phi[0][indexsine];
1679 sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1701 sbr->s_m[e][m] * phi[0][indexsine];
1703 sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1714 void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
1717 int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
1721 if (sbr->start) {
1722 sbr_dequant(sbr, id_aac);
1726 sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1727 (float*)sbr->qmf_filter_scratch,
1728 sbr->data[ch].W);
1729 sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
1730 if (sbr->start) {
1731 sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
1732 sbr_chirp(sbr, &sbr->data[ch]);
1733 sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
1734 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1735 sbr->data[ch].bs_num_env);
1738 sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1739 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1740 sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1741 sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
1742 sbr->data[ch].e_a);
1746 sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
1750 if (sbr->ps.start) {
1751 ff_ps_apply(ac->avctx, &sbr->ps, sbr->X[0], sbr->X[1], sbr->kx[1] + sbr->m[1]);
1753 memcpy(sbr->X[1], sbr->X[0], sizeof(sbr->X[0]));
1758 sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
1759 sbr->data[0].synthesis_filterbank_samples,
1760 &sbr->data[0].synthesis_filterbank_samples_offset,
1763 sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
1764 sbr->data[1].synthesis_filterbank_samples,
1765 &sbr->data[1].synthesis_filterbank_samples_offset,