Lines Matching defs:sbr
30 #include "sbr.h"
138 av_cold void ff_aac_sbr_ctx_init(SpectralBandReplication *sbr)
140 sbr->kx[0] = sbr->kx[1] = 32; //Typo in spec, kx' inits to 32
141 sbr->data[0].e_a[1] = sbr->data[1].e_a[1] = -1;
142 sbr->data[0].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
143 sbr->data[1].synthesis_filterbank_samples_offset = SBR_SYNTHESIS_BUF_SIZE - (1280 - 128);
144 ff_mdct_init(&sbr->mdct, 7, 1, 1.0/64);
145 ff_rdft_init(&sbr->rdft, 6, IDFT_R2C);
148 av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
150 ff_mdct_end(&sbr->mdct);
151 ff_rdft_end(&sbr->rdft);
169 static void sbr_make_f_tablelim(SpectralBandReplication *sbr)
172 if (sbr->bs_limiter_bands > 0) {
176 const float lim_bands_per_octave_warped = bands_warped[sbr->bs_limiter_bands - 1];
178 uint16_t *in = sbr->f_tablelim + 1, *out = sbr->f_tablelim;
180 patch_borders[0] = sbr->kx[1];
181 for (k = 1; k <= sbr->num_patches; k++)
182 patch_borders[k] = patch_borders[k-1] + sbr->patch_num_subbands[k-1];
184 memcpy(sbr->f_tablelim, sbr->f_tablelow,
185 (sbr->n[0] + 1) * sizeof(sbr->f_tablelow[0]));
186 if (sbr->num_patches > 1)
187 memcpy(sbr->f_tablelim + sbr->n[0] + 1, patch_borders + 1,
188 (sbr->num_patches - 1) * sizeof(patch_borders[0]));
190 qsort(sbr->f_tablelim, sbr->num_patches + sbr->n[0],
191 sizeof(sbr->f_tablelim[0]),
194 sbr->n_lim = sbr->n[0] + sbr->num_patches - 1;
195 while (out < sbr->f_tablelim + sbr->n_lim) {
199 !in_table_int16(patch_borders, sbr->num_patches, *in)) {
201 sbr->n_lim--;
202 } else if (!in_table_int16(patch_borders, sbr->num_patches, *out)) {
204 sbr->n_lim--;
210 sbr->f_tablelim[0] = sbr->f_tablelow[0];
211 sbr->f_tablelim[1] = sbr->f_tablelow[sbr->n[0]];
212 sbr->n_lim = 1;
216 static unsigned int read_sbr_header(SpectralBandReplication *sbr, GetBitContext *gb)
221 int old_bs_limiter_bands = sbr->bs_limiter_bands;
224 sbr->start = 1;
227 memcpy(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters));
229 sbr->bs_amp_res_header = get_bits1(gb);
230 sbr->spectrum_params.bs_start_freq = get_bits(gb, 4);
231 sbr->spectrum_params.bs_stop_freq = get_bits(gb, 4);
232 sbr->spectrum_params.bs_xover_band = get_bits(gb, 3);
239 sbr->spectrum_params.bs_freq_scale = get_bits(gb, 2);
240 sbr->spectrum_params.bs_alter_scale = get_bits1(gb);
241 sbr->spectrum_params.bs_noise_bands = get_bits(gb, 2);
243 sbr->spectrum_params.bs_freq_scale = 2;
244 sbr->spectrum_params.bs_alter_scale = 1;
245 sbr->spectrum_params.bs_noise_bands = 2;
249 if (memcmp(&old_spectrum_params, &sbr->spectrum_params, sizeof(SpectrumParameters)))
250 sbr->reset = 1;
253 sbr->bs_limiter_bands = get_bits(gb, 2);
254 sbr->bs_limiter_gains = get_bits(gb, 2);
255 sbr->bs_interpol_freq = get_bits1(gb);
256 sbr->bs_smoothing_mode = get_bits1(gb);
258 sbr->bs_limiter_bands = 2;
259 sbr->bs_limiter_gains = 2;
260 sbr->bs_interpol_freq = 1;
261 sbr->bs_smoothing_mode = 1;
264 if (sbr->bs_limiter_bands != old_bs_limiter_bands && !sbr->reset)
265 sbr_make_f_tablelim(sbr);
313 static int sbr_make_f_master(AACContext *ac, SpectralBandReplication *sbr,
322 if (sbr->sample_rate < 32000) {
324 } else if (sbr->sample_rate < 64000) {
329 start_min = ((temp << 7) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
330 stop_min = ((temp << 8) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
332 switch (sbr->sample_rate) {
353 "Unsupported sample rate for SBR: %d\n", sbr->sample_rate);
357 sbr->k[0] = start_min + sbr_offset_ptr[spectrum->bs_start_freq];
360 sbr->k[2] = stop_min;
364 sbr->k[2] += stop_dk[k];
366 sbr->k[2] = 2*sbr->k[0];
368 sbr->k[2] = 3*sbr->k[0];
374 sbr->k[2] = FFMIN(64, sbr->k[2]);
377 if (sbr->sample_rate <= 32000) {
379 } else if (sbr->sample_rate == 44100) {
381 } else if (sbr->sample_rate >= 48000)
384 if (sbr->k[2] - sbr->k[0] > max_qmf_subbands) {
386 "Invalid bitstream, too many QMF subbands: %d\n", sbr->k[2] - sbr->k[0]);
395 sbr->n_master = ((sbr->k[2] - sbr->k[0] + (dk&2)) >> dk) << 1;
396 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
399 for (k = 1; k <= sbr->n_master; k++)
400 sbr->f_master[k] = dk;
402 k2diff = sbr->k[2] - sbr->k[0] - sbr->n_master * dk;
404 sbr->f_master[1]--;
405 sbr->f_master[2]-= (k2diff < 1);
407 sbr->f_master[sbr->n_master]++;
410 sbr->f_master[0] = sbr->k[0];
411 for (k = 1; k <= sbr->n_master; k++)
412 sbr->f_master[k] += sbr->f_master[k - 1];
420 if (49 * sbr->k[2] > 110 * sbr->k[0]) {
422 sbr->k[1] = 2 * sbr->k[0];
425 sbr->k[1] = sbr->k[2];
428 num_bands_0 = lrintf(half_bands * log2f(sbr->k[1] / (float)sbr->k[0])) * 2;
437 make_bands(vk0+1, sbr->k[0], sbr->k[1], num_bands_0);
442 vk0[0] = sbr->k[0];
456 log2f(sbr->k[2] / (float)sbr->k[1])) * 2;
458 make_bands(vk1+1, sbr->k[1], sbr->k[2], num_bands_1);
472 vk1[0] = sbr->k[1];
481 sbr->n_master = num_bands_0 + num_bands_1;
482 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
484 memcpy(&sbr->f_master[0], vk0,
485 (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
486 memcpy(&sbr->f_master[num_bands_0 + 1], vk1 + 1,
487 num_bands_1 * sizeof(sbr->f_master[0]));
490 sbr->n_master = num_bands_0;
491 if (check_n_master(ac->avccontext, sbr->n_master, sbr->spectrum_params.bs_xover_band))
493 memcpy(sbr->f_master, vk0, (num_bands_0 + 1) * sizeof(sbr->f_master[0]));
501 static int sbr_hf_calc_npatches(AACContext *ac, SpectralBandReplication *sbr)
504 int msb = sbr->k[0];
505 int usb = sbr->kx[1];
506 int goal_sb = ((1000 << 11) + (sbr->sample_rate >> 1)) / sbr->sample_rate;
508 sbr->num_patches = 0;
510 if (goal_sb < sbr->kx[1] + sbr->m[1]) {
511 for (k = 0; sbr->f_master[k] < goal_sb; k++) ;
513 k = sbr->n_master;
517 for (i = k; i == k || sb > (sbr->k[0] - 1 + msb - odd); i--) {
518 sb = sbr->f_master[i];
519 odd = (sb + sbr->k[0]) & 1;
526 if (sbr->num_patches > 5) {
527 av_log(ac->avccontext, AV_LOG_ERROR, "Too many patches: %d\n", sbr->num_patches);
531 sbr->patch_num_subbands[sbr->num_patches] = FFMAX(sb - usb, 0);
532 sbr->patch_start_subband[sbr->num_patches] = sbr->k[0] - odd - sbr->patch_num_subbands[sbr->num_patches];
534 if (sbr->patch_num_subbands[sbr->num_patches] > 0) {
537 sbr->num_patches++;
539 msb = sbr->kx[1];
541 if (sbr->f_master[k] - sb < 3)
542 k = sbr->n_master;
543 } while (sb != sbr->kx[1] + sbr->m[1]);
545 if (sbr->patch_num_subbands[sbr->num_patches-1] < 3 && sbr->num_patches > 1)
546 sbr->num_patches--;
552 static int sbr_make_f_derived(AACContext *ac, SpectralBandReplication *sbr)
556 sbr->n[1] = sbr->n_master - sbr->spectrum_params.bs_xover_band;
557 sbr->n[0] = (sbr->n[1] + 1) >> 1;
559 memcpy(sbr->f_tablehigh, &sbr->f_master[sbr->spectrum_params.bs_xover_band],
560 (sbr->n[1] + 1) * sizeof(sbr->f_master[0]));
561 sbr->m[1] = sbr->f_tablehigh[sbr->n[1]] - sbr->f_tablehigh[0];
562 sbr->kx[1] = sbr->f_tablehigh[0];
565 if (sbr->kx[1] + sbr->m[1] > 64) {
567 "Stop frequency border too high: %d\n", sbr->kx[1] + sbr->m[1]);
570 if (sbr->kx[1] > 32) {
571 av_log(ac->avccontext, AV_LOG_ERROR, "Start frequency border too high: %d\n", sbr->kx[1]);
575 sbr->f_tablelow[0] = sbr->f_tablehigh[0];
576 temp = sbr->n[1] & 1;
577 for (k = 1; k <= sbr->n[0]; k++)
578 sbr->f_tablelow[k] = sbr->f_tablehigh[2 * k - temp];
580 sbr->n_q = FFMAX(1, lrintf(sbr->spectrum_params.bs_noise_bands *
581 log2f(sbr->k[2] / (float)sbr->kx[1]))); // 0 <= bs_noise_bands <= 3
582 if (sbr->n_q > 5) {
583 av_log(ac->avccontext, AV_LOG_ERROR, "Too many noise floor scale factors: %d\n", sbr->n_q);
587 sbr->f_tablenoise[0] = sbr->f_tablelow[0];
589 for (k = 1; k <= sbr->n_q; k++) {
590 temp += (sbr->n[0] - temp) / (sbr->n_q + 1 - k);
591 sbr->f_tablenoise[k] = sbr->f_tablelow[temp];
594 if (sbr_hf_calc_npatches(ac, sbr) < 0)
597 sbr_make_f_tablelim(sbr);
599 sbr->data[0].f_indexnoise = 0;
600 sbr->data[1].f_indexnoise = 0;
619 static int read_sbr_grid(AACContext *ac, SpectralBandReplication *sbr,
630 ch_data->bs_amp_res = sbr->bs_amp_res_header;
779 static void read_sbr_dtdf(SpectralBandReplication *sbr, GetBitContext *gb,
787 static void read_sbr_invf(SpectralBandReplication *sbr, GetBitContext *gb,
793 for (i = 0; i < sbr->n_q; i++)
797 static void read_sbr_envelope(SpectralBandReplication *sbr, GetBitContext *gb,
804 const int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
805 const int odd = sbr->n[1] & 1;
807 if (sbr->bs_coupling && ch) {
841 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
844 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
849 for (j = 0; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++) {
856 for (j = 1; j < sbr->n[ch_data->bs_freq_res[i + 1]]; j++)
866 static void read_sbr_noise(SpectralBandReplication *sbr, GetBitContext *gb,
872 int delta = (ch == 1 && sbr->bs_coupling == 1) + 1;
874 if (sbr->bs_coupling && ch) {
888 for (j = 0; j < sbr->n_q; j++)
892 for (j = 1; j < sbr->n_q; j++)
902 static void read_sbr_extension(AACContext *ac, SpectralBandReplication *sbr,
932 SpectralBandReplication *sbr,
938 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
940 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
941 read_sbr_invf(sbr, gb, &sbr->data[0]);
942 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
943 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
945 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
946 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
952 SpectralBandReplication *sbr,
958 if ((sbr->bs_coupling = get_bits1(gb))) {
959 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]))
961 copy_sbr_grid(&sbr->data[1], &sbr->data[0]);
962 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
963 read_sbr_dtdf(sbr, gb, &sbr->data[1]);
964 read_sbr_invf(sbr, gb, &sbr->data[0]);
965 memcpy(sbr->data[1].bs_invf_mode[1], sbr->data[1].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
966 memcpy(sbr->data[1].bs_invf_mode[0], sbr->data[0].bs_invf_mode[0], sizeof(sbr->data[1].bs_invf_mode[0]));
967 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
968 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
969 read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
970 read_sbr_noise(sbr, gb, &sbr->data[1], 1);
972 if (read_sbr_grid(ac, sbr, gb, &sbr->data[0]) ||
973 read_sbr_grid(ac, sbr, gb, &sbr->data[1]))
975 read_sbr_dtdf(sbr, gb, &sbr->data[0]);
976 read_sbr_dtdf(sbr, gb, &sbr->data[1]);
977 read_sbr_invf(sbr, gb, &sbr->data[0]);
978 read_sbr_invf(sbr, gb, &sbr->data[1]);
979 read_sbr_envelope(sbr, gb, &sbr->data[0], 0);
980 read_sbr_envelope(sbr, gb, &sbr->data[1], 1);
981 read_sbr_noise(sbr, gb, &sbr->data[0], 0);
982 read_sbr_noise(sbr, gb, &sbr->data[1], 1);
985 if ((sbr->data[0].bs_add_harmonic_flag = get_bits1(gb)))
986 get_bits1_vector(gb, sbr->data[0].bs_add_harmonic, sbr->n[1]);
987 if ((sbr->data[1].bs_add_harmonic_flag = get_bits1(gb)))
988 get_bits1_vector(gb, sbr->data[1].bs_add_harmonic, sbr->n[1]);
993 static unsigned int read_sbr_data(AACContext *ac, SpectralBandReplication *sbr,
999 if (read_sbr_single_channel_element(ac, sbr, gb)) {
1000 sbr->start = 0;
1004 if (read_sbr_channel_pair_element(ac, sbr, gb)) {
1005 sbr->start = 0;
1011 sbr->start = 0;
1022 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]);
1321 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)
1327 for (i = 0; i < sbr->n_q; i++) {
1342 static int sbr_lf_gen(AACContext *ac, SpectralBandReplication *sbr,
1349 for (k = 0; k < sbr->kx[1]; k++) {
1355 for (k = 0; k < sbr->kx[0]; k++) {
1365 static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
1373 int k = sbr->kx[1];
1374 for (j = 0; j < sbr->num_patches; j++) {
1375 for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
1377 const int p = sbr->patch_start_subband[j] + x;
1378 while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
1410 if (k < sbr->m[1] + sbr->kx[1])
1411 memset(X_high + k, 0, (sbr->m[1] + sbr->kx[1] - k) * sizeof(*X_high));
1417 static int sbr_x_gen(SpectralBandReplication *sbr, float X[2][32][64],
1423 const int i_Temp = FFMAX(2*sbr->data[ch].t_env_num_env_old - i_f, 0);
1425 for (k = 0; k < sbr->kx[0]; k++) {
1431 for (; k < sbr->kx[0] + sbr->m[0]; k++) {
1438 for (k = 0; k < sbr->kx[1]; k++) {
1444 for (; k < sbr->kx[1] + sbr->m[1]; k++) {
1456 static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
1463 const unsigned int ilim = sbr->n[ch_data->bs_freq_res[e + 1]];
1464 uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1469 sbr->e_origmapped[e][m - sbr->kx[1]] = ch_data->env_facs[e+1][i];
1473 for (i = 0; i < sbr->n_q; i++)
1474 for (m = sbr->f_tablenoise[i]; m < sbr->f_tablenoise[i + 1]; m++)
1475 sbr->q_mapped[e][m - sbr->kx[1]] = ch_data->noise_facs[k+1][i];
1477 for (i = 0; i < sbr->n[1]; i++) {
1480 (sbr->f_tablehigh[i] + sbr->f_tablehigh[i + 1]) >> 1;
1482 ch_data->s_indexmapped[e + 1][m_midpoint - sbr->kx[1]] = ch_data->bs_add_harmonic[i] *
1483 (e >= e_a[1] || (ch_data->s_indexmapped[0][m_midpoint - sbr->kx[1]] == 1));
1490 if (ch_data->s_indexmapped[e + 1][m - sbr->kx[1]]) {
1495 memset(&sbr->s_mapped[e][table[i] - sbr->kx[1]], additional_sinusoid_present,
1496 (table[i + 1] - table[i]) * sizeof(sbr->s_mapped[e][0]));
1505 SpectralBandReplication *sbr, SBRData *ch_data)
1509 if (sbr->bs_interpol_freq) {
1515 for (m = 0; m < sbr->m[1]; m++) {
1519 sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
1520 X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
1532 const uint16_t *table = ch_data->bs_freq_res[e + 1] ? sbr->f_tablehigh : sbr->f_tablelow;
1534 for (p = 0; p < sbr->n[ch_data->bs_freq_res[e + 1]]; p++) {
1546 e_curr[e][k - sbr->kx[1]] = sum;
1557 static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,
1566 for (k = 0; k < sbr->n_lim; k++) {
1569 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1570 const float temp = sbr->e_origmapped[e][m] / (1.0f + sbr->q_mapped[e][m]);
1571 sbr->q_m[e][m] = sqrtf(temp * sbr->q_mapped[e][m]);
1572 sbr->s_m[e][m] = sqrtf(temp * ch_data->s_indexmapped[e + 1][m]);
1573 if (!sbr->s_mapped[e][m]) {
1574 sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] /
1575 ((1.0f + sbr->e_curr[e][m]) *
1576 (1.0f + sbr->q_mapped[e][m] * delta)));
1578 sbr->gain[e][m] = sqrtf(sbr->e_origmapped[e][m] * sbr->q_mapped[e][m] /
1579 ((1.0f + sbr->e_curr[e][m]) *
1580 (1.0f + sbr->q_mapped[e][m])));
1583 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1584 sum[0] += sbr->e_origmapped[e][m];
1585 sum[1] += sbr->e_curr[e][m];
1587 gain_max = limgain[sbr->bs_limiter_gains] * sqrtf((FLT_EPSILON + sum[0]) / (FLT_EPSILON + sum[1]));
1589 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1590 float q_m_max = sbr->q_m[e][m] * gain_max / sbr->gain[e][m];
1591 sbr->q_m[e][m] = FFMIN(sbr->q_m[e][m], q_m_max);
1592 sbr->gain[e][m] = FFMIN(sbr->gain[e][m], gain_max);
1595 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1596 sum[0] += sbr->e_origmapped[e][m];
1597 sum[1] += sbr->e_curr[e][m] * sbr->gain[e][m] * sbr->gain[e][m]
1598 + sbr->s_m[e][m] * sbr->s_m[e][m]
1599 + (delta && !sbr->s_m[e][m]) * sbr->q_m[e][m] * sbr->q_m[e][m];
1603 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {
1604 sbr->gain[e][m] *= gain_boost;
1605 sbr->q_m[e][m] *= gain_boost;
1606 sbr->s_m[e][m] *= gain_boost;
1614 SpectralBandReplication *sbr, SBRData *ch_data,
1618 const int h_SL = 4 * !sbr->bs_smoothing_mode;
1619 const int kx = sbr->kx[1];
1620 const int m_max = sbr->m[1];
1637 if (sbr->reset) {
1639 memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));
1640 memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));
1649 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));
1650 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));
1682 if (sbr->s_m[e][m]) {
1684 sbr->s_m[e][m] * phi[0][indexsine];
1686 sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1708 sbr->s_m[e][m] * phi[0][indexsine];
1710 sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
1721 void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
1724 int downsampled = ac->m4ac.ext_sample_rate < sbr->sample_rate;
1728 if (sbr->start) {
1729 sbr_dequant(sbr, id_aac);
1733 sbr_qmf_analysis(&ac->dsp, &sbr->rdft, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
1734 (float*)sbr->qmf_filter_scratch,
1735 sbr->data[ch].W, 1/(-1024 * ac->sf_scale));
1736 sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
1737 if (sbr->start) {
1738 sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
1739 sbr_chirp(sbr, &sbr->data[ch]);
1740 sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
1741 sbr->data[ch].bw_array, sbr->data[ch].t_env,
1742 sbr->data[ch].bs_num_env);
1745 sbr_mapping(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1746 sbr_env_estimate(sbr->e_curr, sbr->X_high, sbr, &sbr->data[ch]);
1747 sbr_gain_calc(ac, sbr, &sbr->data[ch], sbr->data[ch].e_a);
1748 sbr_hf_assemble(sbr->data[ch].Y, sbr->X_high, sbr, &sbr->data[ch],
1749 sbr->data[ch].e_a);
1753 sbr_x_gen(sbr, sbr->X[ch], sbr->X_low, sbr->data[ch].Y, ch);
1755 sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
1756 sbr->data[0].synthesis_filterbank_samples,
1757 &sbr->data[0].synthesis_filterbank_samples_offset,
1761 sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
1762 sbr->data[1].synthesis_filterbank_samples,
1763 &sbr->data[1].synthesis_filterbank_samples_offset,