FFmpeg: libavcodec/aaccoder.c Source File

FFmpeg

[フレーム]

libavcodec

aaccoder.c

Go to the documentation of this file.

1 /*

2 * AAC coefficients encoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * AAC coefficients encoder

25 */

27 /***********************************

28 * TODOs:

29 * speedup quantizer selection

30 * add sane pulse detection

31 ***********************************/

33 #include "libavutil/libm.h" // brought forward to work around cygwin header breakage

35 #include <float.h>

37 #include "libavutil/mathematics.h"

38 #include "mathops.h"

39 #include "avcodec.h"

40 #include "put_bits.h"

41 #include "aac.h"

42 #include "aacenc.h"

43 #include "aactab.h"

44 #include "aacenctab.h"

45 #include "aacenc_utils.h"

46 #include "aacenc_quantization.h"

48 #include "aacenc_is.h"

49 #include "aacenc_tns.h"

51 #include "libavcodec/aaccoder_twoloop.h"

53 /* Parameter of f(x) = a*(lambda/100), defines the maximum fourier spread

54 * beyond which no PNS is used (since the SFBs contain tone rather than noise) */

55 #define NOISE_SPREAD_THRESHOLD 0.9f

57 /* Parameter of f(x) = a*(100/lambda), defines how much PNS is allowed to

58 * replace low energy non zero bands */

59 #define NOISE_LAMBDA_REPLACE 1.948f

61 #include "libavcodec/aaccoder_trellis.h"

63 typedef float (*quantize_and_encode_band_func)(struct AACEncContext *s, PutBitContext *pb,

64 const float *in, float *quant, const float *scaled,

65 int size, int scale_idx, int cb,

66 const float lambda, const float uplim,

67 int *bits, float *energy);

69 /**

70 * Calculate rate distortion cost for quantizing with given codebook

71 *

72 * @return quantization distortion

73 */

74 static av_always_inline float quantize_and_encode_band_cost_template(

75 struct AACEncContext *s,

76 PutBitContext *pb, const float *in, float *out,

77 const float *scaled, int size, int scale_idx,

78 int cb, const float lambda, const float uplim,

79 int *bits, float *energy, int BT_ZERO, int BT_UNSIGNED,

80 int BT_PAIR, int BT_ESC, int BT_NOISE, int BT_STEREO,

81 const float ROUNDING)

82 {

83 const int q_idx = POW_SF2_ZERO - scale_idx + SCALE_ONE_POS - SCALE_DIV_512;

84 const float Q = ff_aac_pow2sf_tab [q_idx];

85 const float Q34 = ff_aac_pow34sf_tab[q_idx];

86 const float IQ = ff_aac_pow2sf_tab [POW_SF2_ZERO + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];

87 const float CLIPPED_ESCAPE = 165140.0f*IQ;

88 float cost = 0;

89 float qenergy = 0;

90 const int dim = BT_PAIR ? 2 : 4;

91 int resbits = 0;

92 int off;

94 if (BT_ZERO || BT_NOISE || BT_STEREO) {

95 for (int i = 0; i < size; i++)

96 cost += in[i]*in[i];

97 if (bits)

98 *bits = 0;

99 if (energy)

100 *energy = qenergy;

101 if (out) {

102 for (int i = 0; i < size; i += dim)

103 for (int j = 0; j < dim; j++)

104 out[i+j] = 0.0f;

105 }

106 return cost * lambda;

107 }

108 if (!scaled) {

109 s->aacdsp.abs_pow34(s->scoefs, in, size);

110 scaled = s->scoefs;

111 }

112 s->aacdsp.quant_bands(s->qcoefs, in, scaled, size, !BT_UNSIGNED, aac_cb_maxval[cb], Q34, ROUNDING);

113 if (BT_UNSIGNED) {

114 off = 0;

115 } else {

116 off = aac_cb_maxval[cb];

117 }

118 for (int i = 0; i < size; i += dim) {

119 const float *vec;

120 int *quants = s->qcoefs + i;

121 int curidx = 0;

122 int curbits;

123 float quantized, rd = 0.0f;

124 for (int j = 0; j < dim; j++) {

125 curidx *= aac_cb_range[cb];

126 curidx += quants[j] + off;

127 }

128 curbits = ff_aac_spectral_bits[cb-1][curidx];

129 vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];

130 if (BT_UNSIGNED) {

131 for (int j = 0; j < dim; j++) {

132 float t = fabsf(in[i+j]);

133 float di;

134 if (BT_ESC && vec[j] == 64.0f) { //FIXME: slow

135 if (t >= CLIPPED_ESCAPE) {

136 quantized = CLIPPED_ESCAPE;

137 curbits += 21;

138 } else {

139 int c = av_clip_uintp2(quant(t, Q, ROUNDING), 13);

140 quantized = c*cbrtf(c)*IQ;

141 curbits += av_log2(c)*2 - 4 + 1;

142 }

143 } else {

144 quantized = vec[j]*IQ;

145 }

146 di = t - quantized;

147 if (out)

148 out[i+j] = in[i+j] >= 0 ? quantized : -quantized;

149 if (vec[j] != 0.0f)

150 curbits++;

151 qenergy += quantized*quantized;

152 rd += di*di;

153 }

154 } else {

155 for (int j = 0; j < dim; j++) {

156 quantized = vec[j]*IQ;

157 qenergy += quantized*quantized;

158 if (out)

159 out[i+j] = quantized;

160 rd += (in[i+j] - quantized)*(in[i+j] - quantized);

161 }

162 }

163 cost += rd * lambda + curbits;

164 resbits += curbits;

165 if (cost >= uplim)

166 return uplim;

167 if (pb) {

168 put_bits(pb, ff_aac_spectral_bits[cb-1][curidx], ff_aac_spectral_codes[cb-1][curidx]);

169 if (BT_UNSIGNED)

170 for (int j = 0; j < dim; j++)

171 if (ff_aac_codebook_vectors[cb-1][curidx*dim+j] != 0.0f)

172 put_bits(pb, 1, in[i+j] < 0.0f);

173 if (BT_ESC) {

174 for (int j = 0; j < 2; j++) {

175 if (ff_aac_codebook_vectors[cb-1][curidx*2+j] == 64.0f) {

176 int coef = av_clip(quant(fabsf(in[i+j]), Q, ROUNDING), 16, (1 << 13) - 1);

177 int len = av_log2(coef);

178

179 put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);

180 put_sbits(pb, len, coef);

181 }

182 }

183 }

184 }

185 }

186

187 if (bits)

188 *bits = resbits;

189 if (energy)

190 *energy = qenergy;

191 return cost;

192 }

193

194 static inline float quantize_and_encode_band_cost_NONE(struct AACEncContext *s, PutBitContext *pb,

195 const float *in, float *quant, const float *scaled,

196 int size, int scale_idx, int cb,

197 const float lambda, const float uplim,

198 int *bits, float *energy) {

199 av_assert0(0);

200 return 0.0f;

201 }

202

203 #define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC, BT_NOISE, BT_STEREO, ROUNDING) \

204 static float quantize_and_encode_band_cost_ ## NAME( \

205 struct AACEncContext *s, \

206 PutBitContext *pb, const float *in, float *quant, \

207 const float *scaled, int size, int scale_idx, \

208 int cb, const float lambda, const float uplim, \

209 int *bits, float *energy) { \

210 return quantize_and_encode_band_cost_template( \

211 s, pb, in, quant, scaled, size, scale_idx, \

212 BT_ESC ? ESC_BT : cb, lambda, uplim, bits, energy, \

213 BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC, BT_NOISE, BT_STEREO, \

214 ROUNDING); \

215 }

216

217 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ZERO, 1, 0, 0, 0, 0, 0, ROUND_STANDARD)

218 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SQUAD, 0, 0, 0, 0, 0, 0, ROUND_STANDARD)

219 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UQUAD, 0, 1, 0, 0, 0, 0, ROUND_STANDARD)

220 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(SPAIR, 0, 0, 1, 0, 0, 0, ROUND_STANDARD)

221 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(UPAIR, 0, 1, 1, 0, 0, 0, ROUND_STANDARD)

222 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC, 0, 1, 1, 1, 0, 0, ROUND_STANDARD)

223 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(ESC_RTZ, 0, 1, 1, 1, 0, 0, ROUND_TO_ZERO)

224 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NOISE, 0, 0, 0, 0, 1, 0, ROUND_STANDARD)

225 QUANTIZE_AND_ENCODE_BAND_COST_FUNC(STEREO,0, 0, 0, 0, 0, 1, ROUND_STANDARD)

226

227 static const quantize_and_encode_band_func quantize_and_encode_band_cost_arr[] =

228 {

229 quantize_and_encode_band_cost_ZERO,

230 quantize_and_encode_band_cost_SQUAD,

231 quantize_and_encode_band_cost_SQUAD,

232 quantize_and_encode_band_cost_UQUAD,

233 quantize_and_encode_band_cost_UQUAD,

234 quantize_and_encode_band_cost_SPAIR,

235 quantize_and_encode_band_cost_SPAIR,

236 quantize_and_encode_band_cost_UPAIR,

237 quantize_and_encode_band_cost_UPAIR,

238 quantize_and_encode_band_cost_UPAIR,

239 quantize_and_encode_band_cost_UPAIR,

240 quantize_and_encode_band_cost_ESC,

241 quantize_and_encode_band_cost_NONE, /* CB 12 doesn't exist */

242 quantize_and_encode_band_cost_NOISE,

243 quantize_and_encode_band_cost_STEREO,

244 quantize_and_encode_band_cost_STEREO,

245 };

246

247 static const quantize_and_encode_band_func quantize_and_encode_band_cost_rtz_arr[] =

248 {

249 quantize_and_encode_band_cost_ZERO,

250 quantize_and_encode_band_cost_SQUAD,

251 quantize_and_encode_band_cost_SQUAD,

252 quantize_and_encode_band_cost_UQUAD,

253 quantize_and_encode_band_cost_UQUAD,

254 quantize_and_encode_band_cost_SPAIR,

255 quantize_and_encode_band_cost_SPAIR,

256 quantize_and_encode_band_cost_UPAIR,

257 quantize_and_encode_band_cost_UPAIR,

258 quantize_and_encode_band_cost_UPAIR,

259 quantize_and_encode_band_cost_UPAIR,

260 quantize_and_encode_band_cost_ESC_RTZ,

261 quantize_and_encode_band_cost_NONE, /* CB 12 doesn't exist */

262 quantize_and_encode_band_cost_NOISE,

263 quantize_and_encode_band_cost_STEREO,

264 quantize_and_encode_band_cost_STEREO,

265 };

266

267 float ff_quantize_and_encode_band_cost(struct AACEncContext *s, PutBitContext *pb,

268 const float *in, float *quant, const float *scaled,

269 int size, int scale_idx, int cb,

270 const float lambda, const float uplim,

271 int *bits, float *energy)

272 {

273 return quantize_and_encode_band_cost_arr[cb](s, pb, in, quant, scaled, size,

274 scale_idx, cb, lambda, uplim,

275 bits, energy);

276 }

277

278 static inline void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb,

279 const float *in, float *out, int size, int scale_idx,

280 int cb, const float lambda, int rtz)

281 {

282 (rtz ? quantize_and_encode_band_cost_rtz_arr : quantize_and_encode_band_cost_arr)[cb](s, pb, in, out, NULL, size, scale_idx, cb,

283 lambda, INFINITY, NULL, NULL);

284 }

285

286 /**

287 * structure used in optimal codebook search

288 */

289 typedef struct BandCodingPath {

290 int prev_idx; ///< pointer to the previous path point

291 float cost; ///< path cost

292 int run;

293 } BandCodingPath;

294

295 typedef struct TrellisPath {

296 float cost;

297 int prev;

298 } TrellisPath;

299

300 #define TRELLIS_STAGES 121

301 #define TRELLIS_STATES (SCALE_MAX_DIFF+1)

302

303 static void set_special_band_scalefactors(AACEncContext *s, SingleChannelElement *sce)

304 {

305 int w, g;

306 int prevscaler_n = -255, prevscaler_i = 0;

307 int bands = 0;

308

309 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

310 for (g = 0; g < sce->ics.num_swb; g++) {

311 if (sce->zeroes[w*16+g])

312 continue;

313 if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {

314 sce->sf_idx[w*16+g] = av_clip(roundf(log2f(sce->is_ener[w*16+g])*2), -155, 100);

315 bands++;

316 } else if (sce->band_type[w*16+g] == NOISE_BT) {

317 sce->sf_idx[w*16+g] = av_clip(3+ceilf(log2f(sce->pns_ener[w*16+g])*2), -100, 155);

318 if (prevscaler_n == -255)

319 prevscaler_n = sce->sf_idx[w*16+g];

320 bands++;

321 }

322 }

323 }

324

325 if (!bands)

326 return;

327

328 /* Clip the scalefactor indices */

329 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

330 for (g = 0; g < sce->ics.num_swb; g++) {

331 if (sce->zeroes[w*16+g])

332 continue;

333 if (sce->band_type[w*16+g] == INTENSITY_BT || sce->band_type[w*16+g] == INTENSITY_BT2) {

334 sce->sf_idx[w*16+g] = prevscaler_i = av_clip(sce->sf_idx[w*16+g], prevscaler_i - SCALE_MAX_DIFF, prevscaler_i + SCALE_MAX_DIFF);

335 } else if (sce->band_type[w*16+g] == NOISE_BT) {

336 sce->sf_idx[w*16+g] = prevscaler_n = av_clip(sce->sf_idx[w*16+g], prevscaler_n - SCALE_MAX_DIFF, prevscaler_n + SCALE_MAX_DIFF);

337 }

338 }

339 }

340 }

341

342 static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,

343 SingleChannelElement *sce,

344 const float lambda)

345 {

346 int start = 0, i, w, w2, g;

347 int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->ch_layout.nb_channels * (lambda / 120.f);

348 float dists[128] = { 0 }, uplims[128] = { 0 };

349 float maxvals[128];

350 int fflag, minscaler;

351 int its = 0;

352 int allz = 0;

353 float minthr = INFINITY;

354

355 // for values above this the decoder might end up in an endless loop

356 // due to always having more bits than what can be encoded.

357 destbits = FFMIN(destbits, 5800);

358 //some heuristic to determine initial quantizers will reduce search time

359 //determine zero bands and upper limits

360 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

361 start = 0;

362 for (g = 0; g < sce->ics.num_swb; g++) {

363 int nz = 0;

364 float uplim = 0.0f;

365 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

366 FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

367 uplim += band->threshold;

368 if (band->energy <= band->threshold || band->threshold == 0.0f) {

369 sce->zeroes[(w+w2)*16+g] = 1;

370 continue;

371 }

372 nz = 1;

373 }

374 uplims[w*16+g] = uplim *512;

375 sce->band_type[w*16+g] = 0;

376 sce->zeroes[w*16+g] = !nz;

377 if (nz)

378 minthr = FFMIN(minthr, uplim);

379 allz |= nz;

380 start += sce->ics.swb_sizes[g];

381 }

382 }

383 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

384 for (g = 0; g < sce->ics.num_swb; g++) {

385 if (sce->zeroes[w*16+g]) {

386 sce->sf_idx[w*16+g] = SCALE_ONE_POS;

387 continue;

388 }

389 sce->sf_idx[w*16+g] = SCALE_ONE_POS + FFMIN(log2f(uplims[w*16+g]/minthr)*4,59);

390 }

391 }

392

393 if (!allz)

394 return;

395 s->aacdsp.abs_pow34(s->scoefs, sce->coeffs, 1024);

396 ff_quantize_band_cost_cache_init(s);

397

398 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

399 start = w*128;

400 for (g = 0; g < sce->ics.num_swb; g++) {

401 const float *scaled = s->scoefs + start;

402 maxvals[w*16+g] = find_max_val(sce->ics.group_len[w], sce->ics.swb_sizes[g], scaled);

403 start += sce->ics.swb_sizes[g];

404 }

405 }

406

407 //perform two-loop search

408 //outer loop - improve quality

409 do {

410 int tbits, qstep;

411 minscaler = sce->sf_idx[0];

412 //inner loop - quantize spectrum to fit into given number of bits

413 qstep = its ? 1 : 32;

414 do {

415 int prev = -1;

416 tbits = 0;

417 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

418 start = w*128;

419 for (g = 0; g < sce->ics.num_swb; g++) {

420 const float *coefs = sce->coeffs + start;

421 const float *scaled = s->scoefs + start;

422 int bits = 0;

423 int cb;

424 float dist = 0.0f;

425

426 if (sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218) {

427 start += sce->ics.swb_sizes[g];

428 continue;

429 }

430 minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);

431 cb = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

432 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

433 int b;

434 dist += quantize_band_cost_cached(s, w + w2, g,

435 coefs + w2*128,

436 scaled + w2*128,

437 sce->ics.swb_sizes[g],

438 sce->sf_idx[w*16+g],

439 cb, 1.0f, INFINITY,

440 &b, NULL, 0);

441 bits += b;

442 }

443 dists[w*16+g] = dist - bits;

444 if (prev != -1) {

445 bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];

446 }

447 tbits += bits;

448 start += sce->ics.swb_sizes[g];

449 prev = sce->sf_idx[w*16+g];

450 }

451 }

452 if (tbits > destbits) {

453 for (i = 0; i < 128; i++)

454 if (sce->sf_idx[i] < 218 - qstep)

455 sce->sf_idx[i] += qstep;

456 } else {

457 for (i = 0; i < 128; i++)

458 if (sce->sf_idx[i] > 60 - qstep)

459 sce->sf_idx[i] -= qstep;

460 }

461 qstep >>= 1;

462 if (!qstep && tbits > destbits*1.02 && sce->sf_idx[0] < 217)

463 qstep = 1;

464 } while (qstep);

465

466 fflag = 0;

467 minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);

468

469 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

470 for (g = 0; g < sce->ics.num_swb; g++) {

471 int prevsc = sce->sf_idx[w*16+g];

472 if (dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60) {

473 if (find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]-1))

474 sce->sf_idx[w*16+g]--;

475 else //Try to make sure there is some energy in every band

476 sce->sf_idx[w*16+g]-=2;

477 }

478 sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);

479 sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);

480 if (sce->sf_idx[w*16+g] != prevsc)

481 fflag = 1;

482 sce->band_type[w*16+g] = find_min_book(maxvals[w*16+g], sce->sf_idx[w*16+g]);

483 }

484 }

485 its++;

486 } while (fflag && its < 10);

487 }

488

489 static void search_for_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)

490 {

491 FFPsyBand *band;

492 int w, g, w2, i;

493 int wlen = 1024 / sce->ics.num_windows;

494 int bandwidth, cutoff;

495 float *PNS = &s->scoefs[0*128], *PNS34 = &s->scoefs[1*128];

496 float *NOR34 = &s->scoefs[3*128];

497 uint8_t nextband[128];

498 const float lambda = s->lambda;

499 const float freq_mult = avctx->sample_rate*0.5f/wlen;

500 const float thr_mult = NOISE_LAMBDA_REPLACE*(100.0f/lambda);

501 const float spread_threshold = FFMIN(0.75f, NOISE_SPREAD_THRESHOLD*FFMAX(0.5f, lambda/100.f));

502 const float dist_bias = av_clipf(4.f * 120 / lambda, 0.25f, 4.0f);

503 const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);

504

505 int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate

506 / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->ch_layout.nb_channels)

507 * (lambda / 120.f);

508

509 /** Keep this in sync with twoloop's cutoff selection */

510 float rate_bandwidth_multiplier = 1.5f;

511 int prev = -1000, prev_sf = -1;

512 int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)

513 ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)

514 : (avctx->bit_rate / avctx->ch_layout.nb_channels);

515

516 frame_bit_rate *= 1.15f;

517

518 if (avctx->cutoff > 0) {

519 bandwidth = avctx->cutoff;

520 } else {

521 bandwidth = FFMAX(3000, AAC_CUTOFF_FROM_BITRATE(frame_bit_rate, 1, avctx->sample_rate));

522 }

523

524 cutoff = bandwidth * 2 * wlen / avctx->sample_rate;

525

526 memcpy(sce->band_alt, sce->band_type, sizeof(sce->band_type));

527 ff_init_nextband_map(sce, nextband);

528 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

529 int wstart = w*128;

530 for (g = 0; g < sce->ics.num_swb; g++) {

531 int noise_sfi;

532 float dist1 = 0.0f, dist2 = 0.0f, noise_amp;

533 float pns_energy = 0.0f, pns_tgt_energy, energy_ratio, dist_thresh;

534 float sfb_energy = 0.0f, threshold = 0.0f, spread = 2.0f;

535 float min_energy = -1.0f, max_energy = 0.0f;

536 const int start = wstart+sce->ics.swb_offset[g];

537 const float freq = (start-wstart)*freq_mult;

538 const float freq_boost = FFMAX(0.88f*freq/NOISE_LOW_LIMIT, 1.0f);

539 if (freq < NOISE_LOW_LIMIT || (start-wstart) >= cutoff) {

540 if (!sce->zeroes[w*16+g])

541 prev_sf = sce->sf_idx[w*16+g];

542 continue;

543 }

544 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

545 band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

546 sfb_energy += band->energy;

547 spread = FFMIN(spread, band->spread);

548 threshold += band->threshold;

549 if (!w2) {

550 min_energy = max_energy = band->energy;

551 } else {

552 min_energy = FFMIN(min_energy, band->energy);

553 max_energy = FFMAX(max_energy, band->energy);

554 }

555 }

556

557 /* Ramps down at ~8000Hz and loosens the dist threshold */

558 dist_thresh = av_clipf(2.5f*NOISE_LOW_LIMIT/freq, 0.5f, 2.5f) * dist_bias;

559

560 /* PNS is acceptable when all of these are true:

561 * 1. high spread energy (noise-like band)

562 * 2. near-threshold energy (high PE means the random nature of PNS content will be noticed)

563 * 3. on short window groups, all windows have similar energy (variations in energy would be destroyed by PNS)

564 *

565 * At this stage, point 2 is relaxed for zeroed bands near the noise threshold (hole avoidance is more important)

566 */

567 if ((!sce->zeroes[w*16+g] && !ff_sfdelta_can_remove_band(sce, nextband, prev_sf, w*16+g)) ||

568 ((sce->zeroes[w*16+g] || !sce->band_alt[w*16+g]) && sfb_energy < threshold*sqrtf(1.0f/freq_boost)) || spread < spread_threshold ||

569 (!sce->zeroes[w*16+g] && sce->band_alt[w*16+g] && sfb_energy > threshold*thr_mult*freq_boost) ||

570 min_energy < pns_transient_energy_r * max_energy ) {

571 sce->pns_ener[w*16+g] = sfb_energy;

572 if (!sce->zeroes[w*16+g])

573 prev_sf = sce->sf_idx[w*16+g];

574 continue;

575 }

576

577 pns_tgt_energy = sfb_energy*FFMIN(1.0f, spread*spread);

578 noise_sfi = av_clip(roundf(log2f(pns_tgt_energy)*2), -100, 155); /* Quantize */

579 noise_amp = -ff_aac_pow2sf_tab[noise_sfi + POW_SF2_ZERO]; /* Dequantize */

580 if (prev != -1000) {

581 int noise_sfdiff = noise_sfi - prev + SCALE_DIFF_ZERO;

582 if (noise_sfdiff < 0 || noise_sfdiff > 2*SCALE_MAX_DIFF) {

583 if (!sce->zeroes[w*16+g])

584 prev_sf = sce->sf_idx[w*16+g];

585 continue;

586 }

587 }

588 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

589 float band_energy, scale, pns_senergy;

590 const int start_c = (w+w2)*128+sce->ics.swb_offset[g];

591 band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

592 for (i = 0; i < sce->ics.swb_sizes[g]; i++) {

593 s->random_state = lcg_random(s->random_state);

594 PNS[i] = s->random_state;

595 }

596 band_energy = s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);

597 scale = noise_amp/sqrtf(band_energy);

598 s->fdsp->vector_fmul_scalar(PNS, PNS, scale, sce->ics.swb_sizes[g]);

599 pns_senergy = s->fdsp->scalarproduct_float(PNS, PNS, sce->ics.swb_sizes[g]);

600 pns_energy += pns_senergy;

601 s->aacdsp.abs_pow34(NOR34, &sce->coeffs[start_c], sce->ics.swb_sizes[g]);

602 s->aacdsp.abs_pow34(PNS34, PNS, sce->ics.swb_sizes[g]);

603 dist1 += quantize_band_cost(s, &sce->coeffs[start_c],

604 NOR34,

605 sce->ics.swb_sizes[g],

606 sce->sf_idx[(w+w2)*16+g],

607 sce->band_alt[(w+w2)*16+g],

608 lambda/band->threshold, INFINITY, NULL, NULL);

609 /* Estimate rd on average as 5 bits for SF, 4 for the CB, plus spread energy * lambda/thr */

610 dist2 += band->energy/(band->spread*band->spread)*lambda*dist_thresh/band->threshold;

611 }

612 if (g && sce->band_type[w*16+g-1] == NOISE_BT) {

613 dist2 += 5;

614 } else {

615 dist2 += 9;

616 }

617 energy_ratio = pns_tgt_energy/pns_energy; /* Compensates for quantization error */

618 sce->pns_ener[w*16+g] = energy_ratio*pns_tgt_energy;

619 if (sce->zeroes[w*16+g] || !sce->band_alt[w*16+g] || (energy_ratio > 0.85f && energy_ratio < 1.25f && dist2 < dist1)) {

620 sce->band_type[w*16+g] = NOISE_BT;

621 sce->zeroes[w*16+g] = 0;

622 prev = noise_sfi;

623 } else {

624 if (!sce->zeroes[w*16+g])

625 prev_sf = sce->sf_idx[w*16+g];

626 }

627 }

628 }

629 }

630

631 static void mark_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)

632 {

633 FFPsyBand *band;

634 int w, g, w2;

635 int wlen = 1024 / sce->ics.num_windows;

636 int bandwidth, cutoff;

637 const float lambda = s->lambda;

638 const float freq_mult = avctx->sample_rate*0.5f/wlen;

639 const float spread_threshold = FFMIN(0.75f, NOISE_SPREAD_THRESHOLD*FFMAX(0.5f, lambda/100.f));

640 const float pns_transient_energy_r = FFMIN(0.7f, lambda / 140.f);

641

642 int refbits = avctx->bit_rate * 1024.0 / avctx->sample_rate

643 / ((avctx->flags & AV_CODEC_FLAG_QSCALE) ? 2.0f : avctx->ch_layout.nb_channels)

644 * (lambda / 120.f);

645

646 /** Keep this in sync with twoloop's cutoff selection */

647 float rate_bandwidth_multiplier = 1.5f;

648 int frame_bit_rate = (avctx->flags & AV_CODEC_FLAG_QSCALE)

649 ? (refbits * rate_bandwidth_multiplier * avctx->sample_rate / 1024)

650 : (avctx->bit_rate / avctx->ch_layout.nb_channels);

651

652 frame_bit_rate *= 1.15f;

653

654 if (avctx->cutoff > 0) {

655 bandwidth = avctx->cutoff;

656 } else {

657 bandwidth = FFMAX(3000, AAC_CUTOFF_FROM_BITRATE(frame_bit_rate, 1, avctx->sample_rate));

658 }

659

660 cutoff = bandwidth * 2 * wlen / avctx->sample_rate;

661

662 memcpy(sce->band_alt, sce->band_type, sizeof(sce->band_type));

663 for (w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]) {

664 for (g = 0; g < sce->ics.num_swb; g++) {

665 float sfb_energy = 0.0f, threshold = 0.0f, spread = 2.0f;

666 float min_energy = -1.0f, max_energy = 0.0f;

667 const int start = sce->ics.swb_offset[g];

668 const float freq = start*freq_mult;

669 const float freq_boost = FFMAX(0.88f*freq/NOISE_LOW_LIMIT, 1.0f);

670 if (freq < NOISE_LOW_LIMIT || start >= cutoff) {

671 sce->can_pns[w*16+g] = 0;

672 continue;

673 }

674 for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {

675 band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];

676 sfb_energy += band->energy;

677 spread = FFMIN(spread, band->spread);

678 threshold += band->threshold;

679 if (!w2) {

680 min_energy = max_energy = band->energy;

681 } else {

682 min_energy = FFMIN(min_energy, band->energy);

683 max_energy = FFMAX(max_energy, band->energy);

684 }

685 }

686

687 /* PNS is acceptable when all of these are true:

688 * 1. high spread energy (noise-like band)

689 * 2. near-threshold energy (high PE means the random nature of PNS content will be noticed)

690 * 3. on short window groups, all windows have similar energy (variations in energy would be destroyed by PNS)

691 */

692 sce->pns_ener[w*16+g] = sfb_energy;

693 if (sfb_energy < threshold*sqrtf(1.5f/freq_boost) || spread < spread_threshold || min_energy < pns_transient_energy_r * max_energy) {

694 sce->can_pns[w*16+g] = 0;

695 } else {

696 sce->can_pns[w*16+g] = 1;

697 }

698 }

699 }

700 }

701

702 static void search_for_ms(AACEncContext *s, ChannelElement *cpe)

703 {

704 int start = 0, i, w, w2, g, sid_sf_boost, prev_mid, prev_side;

705 uint8_t nextband0[128], nextband1[128];

706 float *M = s->scoefs + 128*0, *S = s->scoefs + 128*1;

707 float *L34 = s->scoefs + 128*2, *R34 = s->scoefs + 128*3;

708 float *M34 = s->scoefs + 128*4, *S34 = s->scoefs + 128*5;

709 const float lambda = s->lambda;

710 const float mslambda = FFMIN(1.0f, lambda / 120.f);

711 SingleChannelElement *sce0 = &cpe->ch[0];

712 SingleChannelElement *sce1 = &cpe->ch[1];

713 if (!cpe->common_window)

714 return;

715

716 /** Scout out next nonzero bands */

717 ff_init_nextband_map(sce0, nextband0);

718 ff_init_nextband_map(sce1, nextband1);

719

720 prev_mid = sce0->sf_idx[0];

721 prev_side = sce1->sf_idx[0];

722 for (w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]) {

723 start = 0;

724 for (g = 0; g < sce0->ics.num_swb; g++) {

725 float bmax = bval2bmax(g * 17.0f / sce0->ics.num_swb) / 0.0045f;

726 if (!cpe->is_mask[w*16+g])

727 cpe->ms_mask[w*16+g] = 0;

728 if (!sce0->zeroes[w*16+g] && !sce1->zeroes[w*16+g] && !cpe->is_mask[w*16+g]) {

729 float Mmax = 0.0f, Smax = 0.0f;

730

731 /* Must compute mid/side SF and book for the whole window group */

732 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

733 for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {

734 M[i] = (sce0->coeffs[start+(w+w2)*128+i]

735 + sce1->coeffs[start+(w+w2)*128+i]) * 0.5;

736 S[i] = M[i]

737 - sce1->coeffs[start+(w+w2)*128+i];

738 }

739 s->aacdsp.abs_pow34(M34, M, sce0->ics.swb_sizes[g]);

740 s->aacdsp.abs_pow34(S34, S, sce0->ics.swb_sizes[g]);

741 for (i = 0; i < sce0->ics.swb_sizes[g]; i++ ) {

742 Mmax = FFMAX(Mmax, M34[i]);

743 Smax = FFMAX(Smax, S34[i]);

744 }

745 }

746

747 for (sid_sf_boost = 0; sid_sf_boost < 4; sid_sf_boost++) {

748 float dist1 = 0.0f, dist2 = 0.0f;

749 int B0 = 0, B1 = 0;

750 int minidx;

751 int mididx, sididx;

752 int midcb, sidcb;

753

754 minidx = FFMIN(sce0->sf_idx[w*16+g], sce1->sf_idx[w*16+g]);

755 mididx = av_clip(minidx, 0, SCALE_MAX_POS - SCALE_DIV_512);

756 sididx = av_clip(minidx - sid_sf_boost * 3, 0, SCALE_MAX_POS - SCALE_DIV_512);

757 if (sce0->band_type[w*16+g] != NOISE_BT && sce1->band_type[w*16+g] != NOISE_BT

758 && ( !ff_sfdelta_can_replace(sce0, nextband0, prev_mid, mididx, w*16+g)

759 || !ff_sfdelta_can_replace(sce1, nextband1, prev_side, sididx, w*16+g))) {

760 /* scalefactor range violation, bad stuff, will decrease quality unacceptably */

761 continue;

762 }

763

764 midcb = find_min_book(Mmax, mididx);

765 sidcb = find_min_book(Smax, sididx);

766

767 /* No CB can be zero */

768 midcb = FFMAX(1,midcb);

769 sidcb = FFMAX(1,sidcb);

770

771 for (w2 = 0; w2 < sce0->ics.group_len[w]; w2++) {

772 FFPsyBand *band0 = &s->psy.ch[s->cur_channel+0].psy_bands[(w+w2)*16+g];

773 FFPsyBand *band1 = &s->psy.ch[s->cur_channel+1].psy_bands[(w+w2)*16+g];

774 float minthr = FFMIN(band0->threshold, band1->threshold);

775 int b1,b2,b3,b4;

776 for (i = 0; i < sce0->ics.swb_sizes[g]; i++) {

777 M[i] = (sce0->coeffs[start+(w+w2)*128+i]

778 + sce1->coeffs[start+(w+w2)*128+i]) * 0.5;

779 S[i] = M[i]

780 - sce1->coeffs[start+(w+w2)*128+i];

781 }

782

783 s->aacdsp.abs_pow34(L34, sce0->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

784 s->aacdsp.abs_pow34(R34, sce1->coeffs+start+(w+w2)*128, sce0->ics.swb_sizes[g]);

785 s->aacdsp.abs_pow34(M34, M, sce0->ics.swb_sizes[g]);

786 s->aacdsp.abs_pow34(S34, S, sce0->ics.swb_sizes[g]);

787 dist1 += quantize_band_cost(s, &sce0->coeffs[start + (w+w2)*128],

788 L34,

789 sce0->ics.swb_sizes[g],

790 sce0->sf_idx[w*16+g],

791 sce0->band_type[w*16+g],

792 lambda / (band0->threshold + FLT_MIN), INFINITY, &b1, NULL);

793 dist1 += quantize_band_cost(s, &sce1->coeffs[start + (w+w2)*128],

794 R34,

795 sce1->ics.swb_sizes[g],

796 sce1->sf_idx[w*16+g],

797 sce1->band_type[w*16+g],

798 lambda / (band1->threshold + FLT_MIN), INFINITY, &b2, NULL);

799 dist2 += quantize_band_cost(s, M,

800 M34,

801 sce0->ics.swb_sizes[g],

802 mididx,

803 midcb,

804 lambda / (minthr + FLT_MIN), INFINITY, &b3, NULL);

805 dist2 += quantize_band_cost(s, S,

806 S34,

807 sce1->ics.swb_sizes[g],

808 sididx,

809 sidcb,

810 mslambda / (minthr * bmax + FLT_MIN), INFINITY, &b4, NULL);

811 B0 += b1+b2;

812 B1 += b3+b4;

813 dist1 -= b1+b2;

814 dist2 -= b3+b4;

815 }

816 cpe->ms_mask[w*16+g] = dist2 <= dist1 && B1 < B0;

817 if (cpe->ms_mask[w*16+g]) {

818 if (sce0->band_type[w*16+g] != NOISE_BT && sce1->band_type[w*16+g] != NOISE_BT) {

819 sce0->sf_idx[w*16+g] = mididx;

820 sce1->sf_idx[w*16+g] = sididx;

821 sce0->band_type[w*16+g] = midcb;

822 sce1->band_type[w*16+g] = sidcb;

823 } else if ((sce0->band_type[w*16+g] != NOISE_BT) ^ (sce1->band_type[w*16+g] != NOISE_BT)) {

824 /* ms_mask unneeded, and it confuses some decoders */

825 cpe->ms_mask[w*16+g] = 0;

826 }

827 break;

828 } else if (B1 > B0) {

829 /* More boost won't fix this */

830 break;

831 }

832 }

833 }

834 if (!sce0->zeroes[w*16+g] && sce0->band_type[w*16+g] < RESERVED_BT)

835 prev_mid = sce0->sf_idx[w*16+g];

836 if (!sce1->zeroes[w*16+g] && !cpe->is_mask[w*16+g] && sce1->band_type[w*16+g] < RESERVED_BT)

837 prev_side = sce1->sf_idx[w*16+g];

838 start += sce0->ics.swb_sizes[g];

839 }

840 }

841 }

842

843 const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB] = {

844 [AAC_CODER_TWOLOOP] = {

845 search_for_quantizers_twoloop,

846 codebook_trellis_rate,

847 quantize_and_encode_band,

848 ff_aac_encode_tns_info,

849 ff_aac_apply_tns,

850 set_special_band_scalefactors,

851 search_for_pns,

852 mark_pns,

853 ff_aac_search_for_tns,

854 search_for_ms,

855 ff_aac_search_for_is,

856 },

857 [AAC_CODER_FAST] = {

858 search_for_quantizers_fast,

859 codebook_trellis_rate,

860 quantize_and_encode_band,

861 ff_aac_encode_tns_info,

862 ff_aac_apply_tns,

863 set_special_band_scalefactors,

864 search_for_pns,

865 mark_pns,

866 ff_aac_search_for_tns,

867 search_for_ms,

868 ff_aac_search_for_is,

869 },

870 };

SingleChannelElement::band_alt

enum BandType band_alt[128]

alternative band type

Definition: aacenc.h:112

INFINITY

#define INFINITY

Definition: mathematics.h:118

av_clip

#define av_clip

Definition: common.h:100

SingleChannelElement::can_pns

uint8_t can_pns[128]

band is allowed to PNS (informative)

Definition: aacenc.h:115

quantize_and_encode_band_cost_template

static av_always_inline float quantize_and_encode_band_cost_template(struct AACEncContext *s, PutBitContext *pb, const float *in, float *out, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy, int BT_ZERO, int BT_UNSIGNED, int BT_PAIR, int BT_ESC, int BT_NOISE, int BT_STEREO, const float ROUNDING)

Calculate rate distortion cost for quantizing with given codebook.

Definition: aaccoder.c:74

libm.h

out

FILE * out

Definition: movenc.c:55

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1024

static double cb(void *priv, double x, double y)

Definition: vf_geq.c:247

aacenctab.h

log2f

#define log2f(x)

Definition: libm.h:411

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

AV_CODEC_FLAG_QSCALE

#define AV_CODEC_FLAG_QSCALE

Use fixed qscale.

Definition: avcodec.h:213

quantize_and_encode_band_cost_NONE

static float quantize_and_encode_band_cost_NONE(struct AACEncContext *s, PutBitContext *pb, const float *in, float *quant, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy)

Definition: aaccoder.c:194

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:291

SingleChannelElement::zeroes

uint8_t zeroes[128]

band is not coded

Definition: aacenc.h:114

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:224

uint8_t w

Definition: llviddspenc.c:38

bval2bmax

static av_always_inline float bval2bmax(float b)

approximates exp10f(-3.0f*(0.5f + 0.5f * cosf(FFMIN(b,15.5f) / 15.5f)))

Definition: aacenc_utils.h:164

ff_aac_coders

const AACCoefficientsEncoder ff_aac_coders[AAC_CODER_NB]

Definition: aaccoder.c:843

#define b

Definition: input.c:42

ROUND_TO_ZERO

#define ROUND_TO_ZERO

Definition: aacenc_utils.h:37

float.h

AAC_CODER_NB

@ AAC_CODER_NB

Definition: aacenc.h:48

STEREO

#define STEREO

Definition: cook.c:65

aac_cb_maxval

static const uint8_t aac_cb_maxval[12]

Definition: aacenctab.h:119

mathematics.h

ff_sfdelta_can_remove_band

static int ff_sfdelta_can_remove_band(const SingleChannelElement *sce, const uint8_t *nextband, int prev_sf, int band)

Definition: aacenc_utils.h:208

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

search_for_ms

static void search_for_ms(AACEncContext *s, ChannelElement *cpe)

Definition: aaccoder.c:702

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

ChannelElement::ch

SingleChannelElement ch[2]

Definition: aacdec.h:266

ceilf

static __device__ float ceilf(float a)

Definition: cuda_runtime.h:175

@ B1

Definition: mvs.c:532

roundf

static av_always_inline av_const float roundf(float x)

Definition: libm.h:453

SCALE_MAX_POS

#define SCALE_MAX_POS

scalefactor index maximum value

Definition: aac.h:89

AAC_CODER_FAST

@ AAC_CODER_FAST

Definition: aacenc.h:46

#define S(s, c, i)

Definition: flacdsp_template.c:46

IndividualChannelStream::num_swb

int num_swb

number of scalefactor window bands

Definition: aacdec.h:171

SingleChannelElement::coeffs

float coeffs[1024]

coefficients for IMDCT, maybe processed

Definition: aacenc.h:119

static double b1(void *priv, double x, double y)

Definition: vf_xfade.c:2034

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

SCALE_DIV_512

#define SCALE_DIV_512

scalefactor difference that corresponds to scale difference in 512 times

Definition: aac.h:87

ff_sfdelta_can_replace

static int ff_sfdelta_can_replace(const SingleChannelElement *sce, const uint8_t *nextband, int prev_sf, int new_sf, int band)

Definition: aacenc_utils.h:222

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

POW_SF2_ZERO

#define POW_SF2_ZERO

ff_aac_pow2sf_tab index corresponding to pow(2, 0);

Definition: aac.h:93

quantize_and_encode_band

static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb, const float *in, float *out, int size, int scale_idx, int cb, const float lambda, int rtz)

Definition: aaccoder.c:278

quantize_and_encode_band_cost_arr

static const quantize_and_encode_band_func quantize_and_encode_band_cost_arr[]

Definition: aaccoder.c:227

fabsf

static __device__ float fabsf(float a)

Definition: cuda_runtime.h:181

SingleChannelElement::ics

IndividualChannelStream ics

Definition: aacdec.h:211

#define Q(q)

quant

static const uint8_t quant[64]

Definition: vmixdec.c:71

QUANTIZE_AND_ENCODE_BAND_COST_FUNC

#define QUANTIZE_AND_ENCODE_BAND_COST_FUNC(NAME, BT_ZERO, BT_UNSIGNED, BT_PAIR, BT_ESC, BT_NOISE, BT_STEREO, ROUNDING)

Definition: aaccoder.c:203

float

Definition: af_crystalizer.c:122

search_for_pns

static void search_for_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)

Definition: aaccoder.c:489

NOISE_BT

@ NOISE_BT

Spectral data are scaled white noise not coded in the bitstream.

Definition: aac.h:71

static double b3(void *priv, double x, double y)

Definition: vf_xfade.c:2036

#define s(width, name)

Definition: cbs_vp9.c:198

ff_quantize_and_encode_band_cost

float ff_quantize_and_encode_band_cost(struct AACEncContext *s, PutBitContext *pb, const float *in, float *quant, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy)

Definition: aaccoder.c:267

IndividualChannelStream::swb_sizes

const uint8_t * swb_sizes

table of scalefactor band sizes for a particular window

Definition: aacenc.h:83

const char * g

Definition: vf_curves.c:128

INTENSITY_BT2

@ INTENSITY_BT2

Scalefactor data are intensity stereo positions (out of phase).

Definition: aac.h:72

bits

uint8_t bits

Definition: vp3data.h:128

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

search_for_quantizers_fast

static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda)

Definition: aaccoder.c:342

mark_pns

static void mark_pns(AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce)

Definition: aaccoder.c:631

bands

static const float bands[]

Definition: af_superequalizer.c:56

SCALE_DIFF_ZERO

#define SCALE_DIFF_ZERO

codebook index corresponding to zero scalefactor indices difference

Definition: aac.h:91

PutBitContext

Definition: put_bits.h:50

quantize_band_cost_cached

static float quantize_band_cost_cached(struct AACEncContext *s, int w, int g, const float *in, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy, int rtz)

Definition: aacenc_quantization_misc.h:31

TrellisPath

Definition: aaccoder.c:295

INTENSITY_BT

@ INTENSITY_BT

Scalefactor data are intensity stereo positions (in phase).

Definition: aac.h:73

ChannelElement::is_mask

uint8_t is_mask[128]

Set if intensity stereo is used.

Definition: aacenc.h:133

NULL

#define NULL

Definition: coverity.c:32

SingleChannelElement::is_ener

float is_ener[128]

Intensity stereo pos.

Definition: aacenc.h:116

aacenc_quantization.h

codebook_trellis_rate

static void codebook_trellis_rate(AACEncContext *s, SingleChannelElement *sce, int win, int group_len, const float lambda)

Definition: aaccoder_trellis.h:59

ff_aac_apply_tns

void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)

Definition: aacenc_tns.c:102

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:481

aac_cb_range

static const uint8_t aac_cb_range[12]

Definition: aacenctab.h:118

mathops.h

ChannelElement::ms_mask

uint8_t ms_mask[128]

Set if mid/side stereo is used for each scalefactor window band.

Definition: aacdec.h:264

FFPsyBand

single band psychoacoustic information

Definition: psymodel.h:50

aac.h

aactab.h

ff_aac_encode_tns_info

void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)

Encode TNS data.

Definition: aacenc_tns.c:70

sqrtf

static __device__ float sqrtf(float a)

Definition: cuda_runtime.h:184

ff_init_nextband_map

static void ff_init_nextband_map(const SingleChannelElement *sce, uint8_t *nextband)

Definition: aacenc_utils.h:175

av_clipf

Definition: af_crystalizer.c:122

aaccoder_twoloop.h

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

SingleChannelElement::sf_idx

int sf_idx[128]

scalefactor indices

Definition: aacenc.h:113

ff_aac_pow34sf_tab

float ff_aac_pow34sf_tab[428]

ff_aac_scalefactor_bits

const uint8_t ff_aac_scalefactor_bits[121]

Definition: aactab.c:200

Definition: af_crystalizer.c:122

NOISE_SPREAD_THRESHOLD

#define NOISE_SPREAD_THRESHOLD

Definition: aaccoder.c:55

size

int size

Definition: twinvq_data.h:10344

ff_aac_spectral_codes

const uint16_t *const ff_aac_spectral_codes[11]

Definition: aactab.c:525

ROUND_STANDARD

#define ROUND_STANDARD

Definition: aacenc_utils.h:36

AAC_CODER_TWOLOOP

@ AAC_CODER_TWOLOOP

Definition: aacenc.h:45

static double b2(void *priv, double x, double y)

Definition: vf_xfade.c:2035

ChannelElement::common_window

int common_window

Set if channels share a common 'IndividualChannelStream' in bitstream.

Definition: aacenc.h:129

search_for_quantizers_twoloop

static void search_for_quantizers_twoloop(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, const float lambda)

two-loop quantizers search taken from ISO 13818-7 Appendix C

Definition: aaccoder_twoloop.h:65

quantize_and_encode_band_cost_rtz_arr

static const quantize_and_encode_band_func quantize_and_encode_band_cost_rtz_arr[]

Definition: aaccoder.c:247

SingleChannelElement::band_type

enum BandType band_type[128]

band types

Definition: aacdec.h:214

SCALE_MAX_DIFF

#define SCALE_MAX_DIFF

maximum scalefactor difference allowed by standard

Definition: aac.h:90

SingleChannelElement::pns_ener

float pns_ener[128]

Noise energy values.

Definition: aacenc.h:117

ZERO

#define ZERO

Definition: aap_template.c:32

AAC_CUTOFF_FROM_BITRATE

#define AAC_CUTOFF_FROM_BITRATE(bit_rate, channels, sample_rate)

Definition: psymodel.h:35

aacenc_is.h

quantize_and_encode_band_func

float(* quantize_and_encode_band_func)(struct AACEncContext *s, PutBitContext *pb, const float *in, float *quant, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy)

Definition: aaccoder.c:63

SingleChannelElement

Single Channel Element - used for both SCE and LFE elements.

Definition: aacdec.h:210

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

IndividualChannelStream::num_windows

int num_windows

Definition: aacdec.h:172

SCALE_ONE_POS

#define SCALE_ONE_POS

scalefactor index that corresponds to scale=1.0

Definition: aac.h:88

find_min_book

static int find_min_book(float maxval, int sf)

Definition: aacenc_utils.h:68

FFPsyBand::threshold

float threshold

Definition: psymodel.h:53

ff_aac_search_for_tns

void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)

Definition: aacenc_tns.c:161

ChannelElement

channel element - generic struct for SCE/CPE/CCE/LFE

Definition: aacdec.h:260

IndividualChannelStream::swb_offset

const uint16_t * swb_offset

table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...

Definition: aacdec.h:170

AVCodecContext::cutoff

int cutoff

Audio cutoff bandwidth (0 means "automatic")

Definition: avcodec.h:1064

av_always_inline

#define av_always_inline

Definition: attributes.h:63

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

cbrtf

static av_always_inline float cbrtf(float x)

Definition: libm.h:63

TrellisPath::prev

int prev

Definition: aaccoder.c:297

set_special_band_scalefactors

static void set_special_band_scalefactors(AACEncContext *s, SingleChannelElement *sce)

Definition: aaccoder.c:303

ff_aac_codebook_vectors

const float *const ff_aac_codebook_vectors[]

Definition: aactab.c:1026

len

int len

Definition: vorbis_enc_data.h:426

NOISE_LOW_LIMIT

#define NOISE_LOW_LIMIT

This file contains a template for the twoloop coder function.

Definition: aaccoder_twoloop.h:54

AACCoefficientsEncoder

Definition: aacenc.h:140

ff_aac_search_for_is

void ff_aac_search_for_is(AACEncContext *s, AVCodecContext *avctx, ChannelElement *cpe)

Definition: aacenc_is.c:109

@ B0

Definition: mvs.c:531

avcodec.h

BandCodingPath

structure used in optimal codebook search

Definition: aaccoder.c:289

dim

int dim

Definition: vorbis_enc_data.h:425

ff_aac_spectral_bits

const uint8_t *const ff_aac_spectral_bits[11]

Definition: aactab.c:530

RESERVED_BT

@ RESERVED_BT

Band types following are encoded differently from others.

Definition: aac.h:70

AACEncContext

AAC encoder context.

Definition: aacenc.h:180

FFPsyBand::energy

float energy

Definition: psymodel.h:52

AVCodecContext

main external API structure.

Definition: avcodec.h:431

#define M(chr)

Definition: exr.c:178

aacenc_tns.h

quantize_band_cost

static float quantize_band_cost(struct AACEncContext *s, const float *in, const float *scaled, int size, int scale_idx, int cb, const float lambda, const float uplim, int *bits, float *energy)

Definition: aacenc_quantization.h:43

find_max_val

static float find_max_val(int group_len, int swb_size, const float *scaled)

Definition: aacenc_utils.h:56

lcg_random

static av_always_inline int lcg_random(unsigned previous_val)

linear congruential pseudorandom number generator

Definition: aacdec_proc_template.c:39

BandCodingPath::prev_idx

int prev_idx

pointer to the previous path point

Definition: aaccoder.c:290