FFmpeg: libavcodec/aacsbr_fixed.c Source File

FFmpeg

[フレーム]

libavcodec

aacsbr_fixed.c

Go to the documentation of this file.

1 /*

3 * MIPS Technologies, Inc., California.

4 *

5 * Redistribution and use in source and binary forms, with or without

6 * modification, are permitted provided that the following conditions

7 * are met:

8 * 1. Redistributions of source code must retain the above copyright

9 * notice, this list of conditions and the following disclaimer.

10 * 2. Redistributions in binary form must reproduce the above copyright

11 * notice, this list of conditions and the following disclaimer in the

12 * documentation and/or other materials provided with the distribution.

13 * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its

14 * contributors may be used to endorse or promote products derived from

15 * this software without specific prior written permission.

16 *

17 * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND

18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

20 * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE

21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

27 * SUCH DAMAGE.

28 *

29 * AAC Spectral Band Replication decoding functions (fixed-point)

32 *

33 * This file is part of FFmpeg.

34 *

35 * FFmpeg is free software; you can redistribute it and/or

36 * modify it under the terms of the GNU Lesser General Public

37 * License as published by the Free Software Foundation; either

38 * version 2.1 of the License, or (at your option) any later version.

39 *

40 * FFmpeg is distributed in the hope that it will be useful,

41 * but WITHOUT ANY WARRANTY; without even the implied warranty of

42 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

43 * Lesser General Public License for more details.

44 *

45 * You should have received a copy of the GNU Lesser General Public

46 * License along with FFmpeg; if not, write to the Free Software

47 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

48 */

50 /**

51 * @file

52 * AAC Spectral Band Replication decoding functions (fixed-point)

53 * Note: Rounding-to-nearest used unless otherwise stated

54 * @author Robert Swain ( rob opendot cl )

55 * @author Stanislav Ocovaj ( stanislav.ocovaj imgtec com )

56 */

57 #define USE_FIXED 1

59 #include "aac.h"

60 #include "sbr.h"

61 #include "aacsbr.h"

62 #include "aacsbrdata.h"

63 #include "fft.h"

64 #include "aacps.h"

65 #include "sbrdsp.h"

66 #include "libavutil/internal.h"

67 #include "libavutil/libm.h"

68 #include "libavutil/avassert.h"

70 #include <stdint.h>

71 #include <float.h>

72 #include <math.h>

74 static VLC vlc_sbr[10];

75 static void aacsbr_func_ptr_init(AACSBRContext *c);

76 static const int CONST_LN2 = Q31(0.6931471806/256); // ln(2)/256

77 static const int CONST_RECIP_LN2 = Q31(0.7213475204); // 0.5/ln(2)

78 static const int CONST_076923 = Q31(0.76923076923076923077f);

80 static const int fixed_log_table[10] =

81 {

82 Q31(1.0/2), Q31(1.0/3), Q31(1.0/4), Q31(1.0/5), Q31(1.0/6),

83 Q31(1.0/7), Q31(1.0/8), Q31(1.0/9), Q31(1.0/10), Q31(1.0/11)

84 };

86 static int fixed_log(int x)

87 {

88 int i, ret, xpow, tmp;

90 ret = x;

91 xpow = x;

92 for (i=0; i<10; i+=2){

93 xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);

94 tmp = (int)(((int64_t)xpow * fixed_log_table[i] + 0x40000000) >> 31);

95 ret -= tmp;

97 xpow = (int)(((int64_t)xpow * x + 0x40000000) >> 31);

98 tmp = (int)(((int64_t)xpow * fixed_log_table[i+1] + 0x40000000) >> 31);

99 ret += tmp;

100 }

101

102 return ret;

103 }

104

105 static const int fixed_exp_table[7] =

106 {

107 Q31(1.0/2), Q31(1.0/6), Q31(1.0/24), Q31(1.0/120),

108 Q31(1.0/720), Q31(1.0/5040), Q31(1.0/40320)

109 };

110

111 static int fixed_exp(int x)

112 {

113 int i, ret, xpow, tmp;

114

115 ret = 0x800000 + x;

116 xpow = x;

117 for (i=0; i<7; i++){

118 xpow = (int)(((int64_t)xpow * x + 0x400000) >> 23);

119 tmp = (int)(((int64_t)xpow * fixed_exp_table[i] + 0x40000000) >> 31);

120 ret += tmp;

121 }

122

123 return ret;

124 }

125

126 static void make_bands(int16_t* bands, int start, int stop, int num_bands)

127 {

128 int k, previous, present;

129 int base, prod, nz = 0;

130

131 base = (stop << 23) / start;

132 while (base < 0x40000000){

133 base <<= 1;

134 nz++;

135 }

136 base = fixed_log(base - 0x80000000);

137 base = (((base + 0x80) >> 8) + (8-nz)*CONST_LN2) / num_bands;

138 base = fixed_exp(base);

139

140 previous = start;

141 prod = start << 23;

142

143 for (k = 0; k < num_bands-1; k++) {

144 prod = (int)(((int64_t)prod * base + 0x400000) >> 23);

145 present = (prod + 0x400000) >> 23;

146 bands[k] = present - previous;

147 previous = present;

148 }

149 bands[num_bands-1] = stop - previous;

150 }

151

152 /// Dequantization and stereo decoding (14496-3 sp04 p203)

153 static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)

154 {

155 int k, e;

156 int ch;

157

158 if (id_aac == TYPE_CPE && sbr->bs_coupling) {

159 int alpha = sbr->data[0].bs_amp_res ? 2 : 1;

160 int pan_offset = sbr->data[0].bs_amp_res ? 12 : 24;

161 for (e = 1; e <= sbr->data[0].bs_num_env; e++) {

162 for (k = 0; k < sbr->n[sbr->data[0].bs_freq_res[e]]; k++) {

163 SoftFloat temp1, temp2, fac;

164

165 temp1.exp = sbr->data[0].env_facs_q[e][k] * alpha + 14;

166 if (temp1.exp & 1)

167 temp1.mant = 759250125;

168 else

169 temp1.mant = 0x20000000;

170 temp1.exp = (temp1.exp >> 1) + 1;

171 if (temp1.exp > 66) { // temp1 > 1E20

172 av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");

173 temp1 = FLOAT_1;

174 }

175

176 temp2.exp = (pan_offset - sbr->data[1].env_facs_q[e][k]) * alpha;

177 if (temp2.exp & 1)

178 temp2.mant = 759250125;

179 else

180 temp2.mant = 0x20000000;

181 temp2.exp = (temp2.exp >> 1) + 1;

182 fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));

183 sbr->data[0].env_facs[e][k] = fac;

184 sbr->data[1].env_facs[e][k] = av_mul_sf(fac, temp2);

185 }

186 }

187 for (e = 1; e <= sbr->data[0].bs_num_noise; e++) {

188 for (k = 0; k < sbr->n_q; k++) {

189 SoftFloat temp1, temp2, fac;

190

191 temp1.exp = NOISE_FLOOR_OFFSET - \

192 sbr->data[0].noise_facs_q[e][k] + 2;

193 temp1.mant = 0x20000000;

194 av_assert0(temp1.exp <= 66);

195 temp2.exp = 12 - sbr->data[1].noise_facs_q[e][k] + 1;

196 temp2.mant = 0x20000000;

197 fac = av_div_sf(temp1, av_add_sf(FLOAT_1, temp2));

198 sbr->data[0].noise_facs[e][k] = fac;

199 sbr->data[1].noise_facs[e][k] = av_mul_sf(fac, temp2);

200 }

201 }

202 } else { // SCE or one non-coupled CPE

203 for (ch = 0; ch < (id_aac == TYPE_CPE) + 1; ch++) {

204 int alpha = sbr->data[ch].bs_amp_res ? 2 : 1;

205 for (e = 1; e <= sbr->data[ch].bs_num_env; e++)

206 for (k = 0; k < sbr->n[sbr->data[ch].bs_freq_res[e]]; k++){

207 SoftFloat temp1;

208

209 temp1.exp = alpha * sbr->data[ch].env_facs_q[e][k] + 12;

210 if (temp1.exp & 1)

211 temp1.mant = 759250125;

212 else

213 temp1.mant = 0x20000000;

214 temp1.exp = (temp1.exp >> 1) + 1;

215 if (temp1.exp > 66) { // temp1 > 1E20

216 av_log(NULL, AV_LOG_ERROR, "envelope scalefactor overflow in dequant\n");

217 temp1 = FLOAT_1;

218 }

219 sbr->data[ch].env_facs[e][k] = temp1;

220 }

221 for (e = 1; e <= sbr->data[ch].bs_num_noise; e++)

222 for (k = 0; k < sbr->n_q; k++){

223 sbr->data[ch].noise_facs[e][k].exp = NOISE_FLOOR_OFFSET - \

224 sbr->data[ch].noise_facs_q[e][k] + 1;

225 sbr->data[ch].noise_facs[e][k].mant = 0x20000000;

226 }

227 }

228 }

229 }

230

231 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering

232 * (14496-3 sp04 p214)

233 * Warning: This routine does not seem numerically stable.

234 */

235 static void sbr_hf_inverse_filter(SBRDSPContext *dsp,

236 int (*alpha0)[2], int (*alpha1)[2],

237 const int X_low[32][40][2], int k0)

238 {

239 int k;

240 int shift, round;

241

242 for (k = 0; k < k0; k++) {

243 SoftFloat phi[3][2][2];

244 SoftFloat a00, a01, a10, a11;

245 SoftFloat dk;

246

247 dsp->autocorrelate(X_low[k], phi);

248

249 dk = av_sub_sf(av_mul_sf(phi[2][1][0], phi[1][0][0]),

250 av_mul_sf(av_add_sf(av_mul_sf(phi[1][1][0], phi[1][1][0]),

251 av_mul_sf(phi[1][1][1], phi[1][1][1])), FLOAT_0999999));

252

253 if (!dk.mant) {

254 a10 = FLOAT_0;

255 a11 = FLOAT_0;

256 } else {

257 SoftFloat temp_real, temp_im;

258 temp_real = av_sub_sf(av_sub_sf(av_mul_sf(phi[0][0][0], phi[1][1][0]),

259 av_mul_sf(phi[0][0][1], phi[1][1][1])),

260 av_mul_sf(phi[0][1][0], phi[1][0][0]));

261 temp_im = av_sub_sf(av_add_sf(av_mul_sf(phi[0][0][0], phi[1][1][1]),

262 av_mul_sf(phi[0][0][1], phi[1][1][0])),

263 av_mul_sf(phi[0][1][1], phi[1][0][0]));

264

265 a10 = av_div_sf(temp_real, dk);

266 a11 = av_div_sf(temp_im, dk);

267 }

268

269 if (!phi[1][0][0].mant) {

270 a00 = FLOAT_0;

271 a01 = FLOAT_0;

272 } else {

273 SoftFloat temp_real, temp_im;

274 temp_real = av_add_sf(phi[0][0][0],

275 av_add_sf(av_mul_sf(a10, phi[1][1][0]),

276 av_mul_sf(a11, phi[1][1][1])));

277 temp_im = av_add_sf(phi[0][0][1],

278 av_sub_sf(av_mul_sf(a11, phi[1][1][0]),

279 av_mul_sf(a10, phi[1][1][1])));

280

281 temp_real.mant = -temp_real.mant;

282 temp_im.mant = -temp_im.mant;

283 a00 = av_div_sf(temp_real, phi[1][0][0]);

284 a01 = av_div_sf(temp_im, phi[1][0][0]);

285 }

286

287 shift = a00.exp;

288 if (shift >= 3)

289 alpha0[k][0] = 0x7fffffff;

290 else if (shift <= -30)

291 alpha0[k][0] = 0;

292 else {

293 shift = 1-shift;

294 if (shift <= 0)

295 alpha0[k][0] = a00.mant * (1<<-shift);

296 else {

297 round = 1 << (shift-1);

298 alpha0[k][0] = (a00.mant + round) >> shift;

299 }

300 }

301

302 shift = a01.exp;

303 if (shift >= 3)

304 alpha0[k][1] = 0x7fffffff;

305 else if (shift <= -30)

306 alpha0[k][1] = 0;

307 else {

308 shift = 1-shift;

309 if (shift <= 0)

310 alpha0[k][1] = a01.mant * (1<<-shift);

311 else {

312 round = 1 << (shift-1);

313 alpha0[k][1] = (a01.mant + round) >> shift;

314 }

315 }

316 shift = a10.exp;

317 if (shift >= 3)

318 alpha1[k][0] = 0x7fffffff;

319 else if (shift <= -30)

320 alpha1[k][0] = 0;

321 else {

322 shift = 1-shift;

323 if (shift <= 0)

324 alpha1[k][0] = a10.mant * (1<<-shift);

325 else {

326 round = 1 << (shift-1);

327 alpha1[k][0] = (a10.mant + round) >> shift;

328 }

329 }

330

331 shift = a11.exp;

332 if (shift >= 3)

333 alpha1[k][1] = 0x7fffffff;

334 else if (shift <= -30)

335 alpha1[k][1] = 0;

336 else {

337 shift = 1-shift;

338 if (shift <= 0)

339 alpha1[k][1] = a11.mant * (1<<-shift);

340 else {

341 round = 1 << (shift-1);

342 alpha1[k][1] = (a11.mant + round) >> shift;

343 }

344 }

345

346 shift = (int)(((int64_t)(alpha1[k][0]>>1) * (alpha1[k][0]>>1) + \

347 (int64_t)(alpha1[k][1]>>1) * (alpha1[k][1]>>1) + \

348 0x40000000) >> 31);

349 if (shift >= 0x20000000){

350 alpha1[k][0] = 0;

351 alpha1[k][1] = 0;

352 alpha0[k][0] = 0;

353 alpha0[k][1] = 0;

354 }

355

356 shift = (int)(((int64_t)(alpha0[k][0]>>1) * (alpha0[k][0]>>1) + \

357 (int64_t)(alpha0[k][1]>>1) * (alpha0[k][1]>>1) + \

358 0x40000000) >> 31);

359 if (shift >= 0x20000000){

360 alpha1[k][0] = 0;

361 alpha1[k][1] = 0;

362 alpha0[k][0] = 0;

363 alpha0[k][1] = 0;

364 }

365 }

366 }

367

368 /// Chirp Factors (14496-3 sp04 p214)

369 static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)

370 {

371 int i;

372 int new_bw;

373 static const int bw_tab[] = { 0, 1610612736, 1932735283, 2104533975 };

374 int64_t accu;

375

376 for (i = 0; i < sbr->n_q; i++) {

377 if (ch_data->bs_invf_mode[0][i] + ch_data->bs_invf_mode[1][i] == 1)

378 new_bw = 1288490189;

379 else

380 new_bw = bw_tab[ch_data->bs_invf_mode[0][i]];

381

382 if (new_bw < ch_data->bw_array[i]){

383 accu = (int64_t)new_bw * 1610612736;

384 accu += (int64_t)ch_data->bw_array[i] * 0x20000000;

385 new_bw = (int)((accu + 0x40000000) >> 31);

386 } else {

387 accu = (int64_t)new_bw * 1946157056;

388 accu += (int64_t)ch_data->bw_array[i] * 201326592;

389 new_bw = (int)((accu + 0x40000000) >> 31);

390 }

391 ch_data->bw_array[i] = new_bw < 0x2000000 ? 0 : new_bw;

392 }

393 }

394

395 /**

396 * Calculation of levels of additional HF signal components (14496-3 sp04 p219)

397 * and Calculation of gain (14496-3 sp04 p219)

398 */

399 static void sbr_gain_calc(AACContext *ac, SpectralBandReplication *sbr,

400 SBRData *ch_data, const int e_a[2])

401 {

402 int e, k, m;

403 // max gain limits : -3dB, 0dB, 3dB, inf dB (limiter off)

404 static const SoftFloat limgain[4] = { { 760155524, 0 }, { 0x20000000, 1 },

405 { 758351638, 1 }, { 625000000, 34 } };

406

407 for (e = 0; e < ch_data->bs_num_env; e++) {

408 int delta = !((e == e_a[1]) || (e == e_a[0]));

409 for (k = 0; k < sbr->n_lim; k++) {

410 SoftFloat gain_boost, gain_max;

411 SoftFloat sum[2];

412 sum[0] = sum[1] = FLOAT_0;

413 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

414 const SoftFloat temp = av_div_sf(sbr->e_origmapped[e][m],

415 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]));

416 sbr->q_m[e][m] = av_sqrt_sf(av_mul_sf(temp, sbr->q_mapped[e][m]));

417 sbr->s_m[e][m] = av_sqrt_sf(av_mul_sf(temp, av_int2sf(ch_data->s_indexmapped[e + 1][m], 0)));

418 if (!sbr->s_mapped[e][m]) {

419 if (delta) {

420 sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],

421 av_mul_sf(av_add_sf(FLOAT_1, sbr->e_curr[e][m]),

422 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));

423 } else {

424 sbr->gain[e][m] = av_sqrt_sf(av_div_sf(sbr->e_origmapped[e][m],

425 av_add_sf(FLOAT_1, sbr->e_curr[e][m])));

426 }

427 } else {

428 sbr->gain[e][m] = av_sqrt_sf(

429 av_div_sf(

430 av_mul_sf(sbr->e_origmapped[e][m], sbr->q_mapped[e][m]),

431 av_mul_sf(

432 av_add_sf(FLOAT_1, sbr->e_curr[e][m]),

433 av_add_sf(FLOAT_1, sbr->q_mapped[e][m]))));

434 }

435 sbr->gain[e][m] = av_add_sf(sbr->gain[e][m], FLOAT_MIN);

436 }

437 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

438 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);

439 sum[1] = av_add_sf(sum[1], sbr->e_curr[e][m]);

440 }

441 gain_max = av_mul_sf(limgain[sbr->bs_limiter_gains],

442 av_sqrt_sf(

443 av_div_sf(

444 av_add_sf(FLOAT_EPSILON, sum[0]),

445 av_add_sf(FLOAT_EPSILON, sum[1]))));

446 if (av_gt_sf(gain_max, FLOAT_100000))

447 gain_max = FLOAT_100000;

448 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

449 SoftFloat q_m_max = av_div_sf(

450 av_mul_sf(sbr->q_m[e][m], gain_max),

451 sbr->gain[e][m]);

452 if (av_gt_sf(sbr->q_m[e][m], q_m_max))

453 sbr->q_m[e][m] = q_m_max;

454 if (av_gt_sf(sbr->gain[e][m], gain_max))

455 sbr->gain[e][m] = gain_max;

456 }

457 sum[0] = sum[1] = FLOAT_0;

458 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

459 sum[0] = av_add_sf(sum[0], sbr->e_origmapped[e][m]);

460 sum[1] = av_add_sf(sum[1],

461 av_mul_sf(

462 av_mul_sf(sbr->e_curr[e][m],

463 sbr->gain[e][m]),

464 sbr->gain[e][m]));

465 sum[1] = av_add_sf(sum[1],

466 av_mul_sf(sbr->s_m[e][m], sbr->s_m[e][m]));

467 if (delta && !sbr->s_m[e][m].mant)

468 sum[1] = av_add_sf(sum[1],

469 av_mul_sf(sbr->q_m[e][m], sbr->q_m[e][m]));

470 }

471 gain_boost = av_sqrt_sf(

472 av_div_sf(

473 av_add_sf(FLOAT_EPSILON, sum[0]),

474 av_add_sf(FLOAT_EPSILON, sum[1])));

475 if (av_gt_sf(gain_boost, FLOAT_1584893192))

476 gain_boost = FLOAT_1584893192;

477

478 for (m = sbr->f_tablelim[k] - sbr->kx[1]; m < sbr->f_tablelim[k + 1] - sbr->kx[1]; m++) {

479 sbr->gain[e][m] = av_mul_sf(sbr->gain[e][m], gain_boost);

480 sbr->q_m[e][m] = av_mul_sf(sbr->q_m[e][m], gain_boost);

481 sbr->s_m[e][m] = av_mul_sf(sbr->s_m[e][m], gain_boost);

482 }

483 }

484 }

485 }

486

487 /// Assembling HF Signals (14496-3 sp04 p220)

488 static void sbr_hf_assemble(int Y1[38][64][2],

489 const int X_high[64][40][2],

490 SpectralBandReplication *sbr, SBRData *ch_data,

491 const int e_a[2])

492 {

493 int e, i, j, m;

494 const int h_SL = 4 * !sbr->bs_smoothing_mode;

495 const int kx = sbr->kx[1];

496 const int m_max = sbr->m[1];

497 static const SoftFloat h_smooth[5] = {

498 { 715827883, -1 },

499 { 647472402, -1 },

500 { 937030863, -2 },

501 { 989249804, -3 },

502 { 546843842, -4 },

503 };

504 SoftFloat (*g_temp)[48] = ch_data->g_temp, (*q_temp)[48] = ch_data->q_temp;

505 int indexnoise = ch_data->f_indexnoise;

506 int indexsine = ch_data->f_indexsine;

507

508 if (sbr->reset) {

509 for (i = 0; i < h_SL; i++) {

510 memcpy(g_temp[i + 2*ch_data->t_env[0]], sbr->gain[0], m_max * sizeof(sbr->gain[0][0]));

511 memcpy(q_temp[i + 2*ch_data->t_env[0]], sbr->q_m[0], m_max * sizeof(sbr->q_m[0][0]));

512 }

513 } else if (h_SL) {

514 for (i = 0; i < 4; i++) {

515 memcpy(g_temp[i + 2 * ch_data->t_env[0]],

516 g_temp[i + 2 * ch_data->t_env_num_env_old],

517 sizeof(g_temp[0]));

518 memcpy(q_temp[i + 2 * ch_data->t_env[0]],

519 q_temp[i + 2 * ch_data->t_env_num_env_old],

520 sizeof(q_temp[0]));

521 }

522 }

523

524 for (e = 0; e < ch_data->bs_num_env; e++) {

525 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {

526 memcpy(g_temp[h_SL + i], sbr->gain[e], m_max * sizeof(sbr->gain[0][0]));

527 memcpy(q_temp[h_SL + i], sbr->q_m[e], m_max * sizeof(sbr->q_m[0][0]));

528 }

529 }

530

531 for (e = 0; e < ch_data->bs_num_env; e++) {

532 for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {

533 SoftFloat g_filt_tab[48];

534 SoftFloat q_filt_tab[48];

535 SoftFloat *g_filt, *q_filt;

536

537 if (h_SL && e != e_a[0] && e != e_a[1]) {

538 g_filt = g_filt_tab;

539 q_filt = q_filt_tab;

540 for (m = 0; m < m_max; m++) {

541 const int idx1 = i + h_SL;

542 g_filt[m].mant = g_filt[m].exp = 0;

543 q_filt[m].mant = q_filt[m].exp = 0;

544 for (j = 0; j <= h_SL; j++) {

545 g_filt[m] = av_add_sf(g_filt[m],

546 av_mul_sf(g_temp[idx1 - j][m],

547 h_smooth[j]));

548 q_filt[m] = av_add_sf(q_filt[m],

549 av_mul_sf(q_temp[idx1 - j][m],

550 h_smooth[j]));

551 }

552 }

553 } else {

554 g_filt = g_temp[i + h_SL];

555 q_filt = q_temp[i];

556 }

557

558 sbr->dsp.hf_g_filt(Y1[i] + kx, X_high + kx, g_filt, m_max,

559 i + ENVELOPE_ADJUSTMENT_OFFSET);

560

561 if (e != e_a[0] && e != e_a[1]) {

562 sbr->dsp.hf_apply_noise[indexsine](Y1[i] + kx, sbr->s_m[e],

563 q_filt, indexnoise,

564 kx, m_max);

565 } else {

566 int idx = indexsine&1;

567 int A = (1-((indexsine+(kx & 1))&2));

568 int B = (A^(-idx)) + idx;

569 unsigned *out = &Y1[i][kx][idx];

570 int shift;

571 unsigned round;

572

573 SoftFloat *in = sbr->s_m[e];

574 for (m = 0; m+1 < m_max; m+=2) {

575 int shift2;

576 shift = 22 - in[m ].exp;

577 shift2= 22 - in[m+1].exp;

578 if (shift < 1 || shift2 < 1) {

579 av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d,%d\n", shift, shift2);

580 return;

581 }

582 if (shift < 32) {

583 round = 1 << (shift-1);

584 out[2*m ] += (int)(in[m ].mant * A + round) >> shift;

585 }

586

587 if (shift2 < 32) {

588 round = 1 << (shift2-1);

589 out[2*m+2] += (int)(in[m+1].mant * B + round) >> shift2;

590 }

591 }

592 if(m_max&1)

593 {

594 shift = 22 - in[m ].exp;

595 if (shift < 1) {

596 av_log(NULL, AV_LOG_ERROR, "Overflow in sbr_hf_assemble, shift=%d\n", shift);

597 return;

598 } else if (shift < 32) {

599 round = 1 << (shift-1);

600 out[2*m ] += (int)(in[m ].mant * A + round) >> shift;

601 }

602 }

603 }

604 indexnoise = (indexnoise + m_max) & 0x1ff;

605 indexsine = (indexsine + 1) & 3;

606 }

607 }

608 ch_data->f_indexnoise = indexnoise;

609 ch_data->f_indexsine = indexsine;

610 }

611

612 #include "aacsbr_template.c"

SpectralBandReplication::bs_coupling

unsigned bs_coupling

Definition: sbr.h:159

SpectralBandReplication::data

SBRData data[2]

Definition: sbr.h:169

SpectralBandReplication::bs_limiter_gains

unsigned bs_limiter_gains

Definition: sbr.h:155

libm.h

SBRDSPContext

Definition: sbrdsp.h:28

out

FILE * out

Definition: movenc.c:54

SpectralBandReplication::e_origmapped

AAC_FLOAT e_origmapped[7][48]

Dequantized envelope scalefactors, remapped.

Definition: sbr.h:201

FLOAT_EPSILON

static const SoftFloat FLOAT_EPSILON

A small value.

Definition: softfloat.h:42

SBRData::env_facs

AAC_FLOAT env_facs[6][48]

Definition: sbr.h:103

aacsbr_func_ptr_init

static void aacsbr_func_ptr_init(AACSBRContext *c)

aacsbr.h

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

SpectralBandReplication::m

AAC_SIGNE m[2]

M' and M respectively, M is the number of QMF subbands that use SBR.

Definition: sbr.h:165

av_sub_sf

static av_const SoftFloat av_sub_sf(SoftFloat a, SoftFloat b)

Definition: softfloat.h:173

SpectralBandReplication::q_m

AAC_FLOAT q_m[7][48]

Amplitude adjusted noise scalefactors.

Definition: sbr.h:209

SBRData::t_env_num_env_old

uint8_t t_env_num_env_old

Envelope time border of the last envelope of the previous frame.

Definition: sbr.h:110

SoftFloat::mant

int32_t mant

Definition: softfloat.h:35

base

uint8_t base

Definition: vp3data.h:141

float.h

SBRData::t_env

uint8_t t_env[8]

Envelope time borders.

Definition: sbr.h:108

sbr_chirp

static void sbr_chirp(SpectralBandReplication *sbr, SBRData *ch_data)

Chirp Factors (14496-3 sp04 p214)

Definition: aacsbr_fixed.c:369

FLOAT_1

static const SoftFloat FLOAT_1

1.0

Definition: softfloat.h:41

sbr.h

#define A(x)

Definition: vp56_arith.h:28

av_gt_sf

static av_const int av_gt_sf(SoftFloat a, SoftFloat b)

Compares two SoftFloats.

Definition: softfloat.h:150

aacps.h

av_sqrt_sf

static av_always_inline SoftFloat av_sqrt_sf(SoftFloat val)

Rounding-to-nearest used.

Definition: softfloat.h:207

av_div_sf

static av_const SoftFloat av_div_sf(SoftFloat a, SoftFloat b)

b has to be normalized and not zero.

Definition: softfloat.h:116

sbr_hf_assemble

static void sbr_hf_assemble(int Y1[38][64][2], const int X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2])

Assembling HF Signals (14496-3 sp04 p220)

Definition: aacsbr_fixed.c:488

TYPE_CPE

@ TYPE_CPE

Definition: aac.h:59

SpectralBandReplication::reset

int reset

Definition: sbr.h:147

SBRData::noise_facs

AAC_FLOAT noise_facs[3][5]

Definition: sbr.h:106

sbr_hf_inverse_filter

static void sbr_hf_inverse_filter(SBRDSPContext *dsp, int(*alpha0)[2], int(*alpha1)[2], const int X_low[32][40][2], int k0)

High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering (14496-3 sp04 p214) Warning: Thi...

Definition: aacsbr_fixed.c:235

avassert.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FLOAT_MIN

static const SoftFloat FLOAT_MIN

Definition: softfloat.h:46

SBRData::bs_num_noise

AAC_SIGNE bs_num_noise

Definition: sbr.h:74

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

NOISE_FLOOR_OFFSET

#define NOISE_FLOOR_OFFSET

Definition: aacsbr.h:37

SBRData::g_temp

AAC_FLOAT g_temp[42][48]

Definition: sbr.h:98

SBRDSPContext::autocorrelate

void(* autocorrelate)(const INTFLOAT x[40][2], AAC_FLOAT phi[3][2][2])

Definition: sbrdsp.h:36

vlc_sbr

static VLC vlc_sbr[10]

Definition: aacsbr_fixed.c:74

bands

static const float bands[]

Definition: af_superequalizer.c:56

SpectralBandReplication::s_m

AAC_FLOAT s_m[7][48]

Sinusoidal levels.

Definition: sbr.h:211

SpectralBandReplication::n_lim

AAC_SIGNE n_lim

Number of limiter bands.

Definition: sbr.h:176

SBRData::env_facs_q

uint8_t env_facs_q[6][48]

Envelope scalefactors.

Definition: sbr.h:102

NULL

#define NULL

Definition: coverity.c:32

FLOAT_0

static const SoftFloat FLOAT_0

0.0

Definition: softfloat.h:39

SBRData::f_indexnoise

unsigned f_indexnoise

Definition: sbr.h:113

SpectralBandReplication::f_tablelim

uint16_t f_tablelim[30]

Frequency borders for the limiter.

Definition: sbr.h:186

AACSBRContext

aacsbr functions pointers

Definition: sbr.h:123

fixed_log

static int fixed_log(int x)

Definition: aacsbr_fixed.c:86

aac.h

SBRDSPContext::hf_g_filt

void(* hf_g_filt)(INTFLOAT(*Y)[2], const INTFLOAT(*X_high)[40][2], const AAC_FLOAT *g_filt, int m_max, intptr_t ixh)

Definition: sbrdsp.h:40

SoftFloat::exp

int32_t exp

Definition: softfloat.h:36

SpectralBandReplication::n

AAC_SIGNE n[2]

N_Low and N_High respectively, the number of frequency bands for low and high resolution.

Definition: sbr.h:172

SBRData::bs_num_env

AAC_SIGNE bs_num_env

Definition: sbr.h:72

SBRData::bs_amp_res

unsigned bs_amp_res

Definition: sbr.h:79

SBRData::s_indexmapped

uint8_t s_indexmapped[8][48]

Definition: sbr.h:100

SpectralBandReplication::bs_smoothing_mode

unsigned bs_smoothing_mode

Definition: sbr.h:157

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

Definition: af_crystalizer.c:122

FLOAT_0999999

static const SoftFloat FLOAT_0999999

0.999999

Definition: softfloat.h:45

FLOAT_1584893192

static const SoftFloat FLOAT_1584893192

1.584893192 (10^.2)

Definition: softfloat.h:43

FLOAT_100000

static const SoftFloat FLOAT_100000