FFmpeg: libavcodec/opus/enc.c Source File

FFmpeg

[フレーム]

enc.c

Go to the documentation of this file.

1 /*

2 * Opus 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 #include <float.h>

24 #include "encode.h"

25 #include "enc.h"

26 #include "pvq.h"

27 #include "enc_psy.h"

28 #include "tab.h"

30 #include "libavutil/channel_layout.h"

31 #include "libavutil/float_dsp.h"

32 #include "libavutil/mem.h"

33 #include "libavutil/mem_internal.h"

34 #include "libavutil/opt.h"

35 #include "bytestream.h"

36 #include "audio_frame_queue.h"

37 #include "codec_internal.h"

39 typedef struct OpusEncContext {

40 AVClass *av_class;

41 OpusEncOptions options;

42 OpusPsyContext psyctx;

43 AVCodecContext *avctx;

44 AudioFrameQueue afq;

45 AVFloatDSPContext *dsp;

46 AVTXContext *tx[CELT_BLOCK_NB];

47 av_tx_fn tx_fn[CELT_BLOCK_NB];

48 CeltPVQ *pvq;

49 struct FFBufQueue bufqueue;

51 uint8_t enc_id[64];

52 int enc_id_bits;

54 OpusPacketInfo packet;

56 int channels;

58 CeltFrame *frame;

59 OpusRangeCoder *rc;

61 /* Actual energy the decoder will have */

62 float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS];

64 DECLARE_ALIGNED(32, float, scratch)[2048];

65 } OpusEncContext;

67 static void opus_write_extradata(AVCodecContext *avctx)

68 {

69 uint8_t *bs = avctx->extradata;

71 bytestream_put_buffer(&bs, "OpusHead", 8);

72 bytestream_put_byte (&bs, 0x1);

73 bytestream_put_byte (&bs, avctx->ch_layout.nb_channels);

74 bytestream_put_le16 (&bs, avctx->initial_padding);

75 bytestream_put_le32 (&bs, avctx->sample_rate);

76 bytestream_put_le16 (&bs, 0x0);

77 bytestream_put_byte (&bs, 0x0); /* Default layout */

78 }

80 static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)

81 {

82 int tmp = 0x0, extended_toc = 0;

83 static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = {

84 /* Silk Hybrid Celt Layer */

85 /* NB MB WB SWB FB NB MB WB SWB FB NB MB WB SWB FB Bandwidth */

86 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } }, /* 2.5 ms */

87 { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } }, /* 5 ms */

88 { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } }, /* 10 ms */

89 { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } }, /* 20 ms */

90 { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 40 ms */

91 { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 60 ms */

92 };

93 int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];

94 *fsize_needed = 0;

95 if (!cfg)

96 return 1;

97 if (s->packet.frames == 2) { /* 2 packets */

98 if (s->frame[0].framebits == s->frame[1].framebits) { /* same size */

99 tmp = 0x1;

100 } else { /* different size */

101 tmp = 0x2;

102 *fsize_needed = 1; /* put frame sizes in the packet */

103 }

104 } else if (s->packet.frames > 2) {

105 tmp = 0x3;

106 extended_toc = 1;

107 }

108 tmp |= (s->channels > 1) << 2; /* Stereo or mono */

109 tmp |= (cfg - 1) << 3; /* codec configuration */

110 *toc++ = tmp;

111 if (extended_toc) {

112 for (int i = 0; i < (s->packet.frames - 1); i++)

113 *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);

114 tmp = (*fsize_needed) << 7; /* vbr flag */

115 tmp |= (0) << 6; /* padding flag */

116 tmp |= s->packet.frames;

117 *toc++ = tmp;

118 }

119 *size = 1 + extended_toc;

120 return 0;

121 }

122

123 static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)

124 {

125 AVFrame *cur = NULL;

126 const int subframesize = s->avctx->frame_size;

127 int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;

128

129 cur = ff_bufqueue_get(&s->bufqueue);

130

131 for (int ch = 0; ch < f->channels; ch++) {

132 CeltBlock *b = &f->block[ch];

133 const void *input = cur->extended_data[ch];

134 size_t bps = av_get_bytes_per_sample(cur->format);

135 memcpy(b->overlap, input, bps*cur->nb_samples);

136 }

137

138 av_frame_free(&cur);

139

140 for (int sf = 0; sf < subframes; sf++) {

141 if (sf != (subframes - 1))

142 cur = ff_bufqueue_get(&s->bufqueue);

143 else

144 cur = ff_bufqueue_peek(&s->bufqueue, 0);

145

146 for (int ch = 0; ch < f->channels; ch++) {

147 CeltBlock *b = &f->block[ch];

148 const void *input = cur->extended_data[ch];

149 const size_t bps = av_get_bytes_per_sample(cur->format);

150 const size_t left = (subframesize - cur->nb_samples)*bps;

151 const size_t len = FFMIN(subframesize, cur->nb_samples)*bps;

152 memcpy(&b->samples[sf*subframesize], input, len);

153 memset(&b->samples[cur->nb_samples], 0, left);

154 }

155

156 /* Last frame isn't popped off and freed yet - we need it for overlap */

157 if (sf != (subframes - 1))

158 av_frame_free(&cur);

159 }

160 }

161

162 /* Apply the pre emphasis filter */

163 static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)

164 {

165 const int subframesize = s->avctx->frame_size;

166 const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;

167 const float c = ff_opus_deemph_weights[0];

168

169 /* Filter overlap */

170 for (int ch = 0; ch < f->channels; ch++) {

171 CeltBlock *b = &f->block[ch];

172 float m = b->emph_coeff;

173 for (int i = 0; i < CELT_OVERLAP; i++) {

174 float sample = b->overlap[i];

175 b->overlap[i] = sample - m;

176 m = sample * c;

177 }

178 b->emph_coeff = m;

179 }

180

181 /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */

182 for (int sf = 0; sf < subframes; sf++) {

183 for (int ch = 0; ch < f->channels; ch++) {

184 CeltBlock *b = &f->block[ch];

185 float m = b->emph_coeff;

186 for (int i = 0; i < subframesize; i++) {

187 float sample = b->samples[sf*subframesize + i];

188 b->samples[sf*subframesize + i] = sample - m;

189 m = sample * c;

190 }

191 if (sf != (subframes - 1))

192 b->emph_coeff = m;

193 }

194 }

195 }

196

197 /* Create the window and do the mdct */

198 static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)

199 {

200 float *win = s->scratch, *temp = s->scratch + 1920;

201

202 if (f->transient) {

203 for (int ch = 0; ch < f->channels; ch++) {

204 CeltBlock *b = &f->block[ch];

205 float *src1 = b->overlap;

206 for (int t = 0; t < f->blocks; t++) {

207 float *src2 = &b->samples[CELT_OVERLAP*t];

208 s->dsp->vector_fmul(win, src1, ff_celt_window, 128);

209 s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,

210 ff_celt_window_padded, 128);

211 src1 = src2;

212 s->tx_fn[0](s->tx[0], b->coeffs + t, win, sizeof(float)*f->blocks);

213 }

214 }

215 } else {

216 int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);

217 int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;

218 memset(win, 0, wlen*sizeof(float));

219 for (int ch = 0; ch < f->channels; ch++) {

220 CeltBlock *b = &f->block[ch];

221

222 /* Overlap */

223 s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);

224 memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));

225

226 /* Samples, flat top window */

227 memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));

228

229 /* Samples, windowed */

230 s->dsp->vector_fmul_reverse(temp, b->samples + rwin,

231 ff_celt_window_padded, 128);

232 memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));

233

234 s->tx_fn[f->size](s->tx[f->size], b->coeffs, win, sizeof(float));

235 }

236 }

237

238 for (int ch = 0; ch < f->channels; ch++) {

239 CeltBlock *block = &f->block[ch];

240 for (int i = 0; i < CELT_MAX_BANDS; i++) {

241 float ener = 0.0f;

242 int band_offset = ff_celt_freq_bands[i] << f->size;

243 int band_size = ff_celt_freq_range[i] << f->size;

244 float *coeffs = &block->coeffs[band_offset];

245

246 for (int j = 0; j < band_size; j++)

247 ener += coeffs[j]*coeffs[j];

248

249 block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;

250 ener = 1.0f/block->lin_energy[i];

251

252 for (int j = 0; j < band_size; j++)

253 coeffs[j] *= ener;

254

255 block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];

256

257 /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */

258 block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);

259 }

260 }

261 }

262

263 static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)

264 {

265 int tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;

266 int bits = f->transient ? 2 : 4;

267

268 tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));

269

270 for (int i = f->start_band; i < f->end_band; i++) {

271 if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {

272 const int tbit = (diff ^ 1) == f->tf_change[i];

273 ff_opus_rc_enc_log(rc, tbit, bits);

274 diff ^= tbit;

275 tf_changed |= diff;

276 }

277 bits = f->transient ? 4 : 5;

278 }

279

280 if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=

281 ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {

282 ff_opus_rc_enc_log(rc, f->tf_select, 1);

283 tf_select = f->tf_select;

284 }

285

286 for (int i = f->start_band; i < f->end_band; i++)

287 f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];

288 }

289

290 static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)

291 {

292 float gain = f->pf_gain;

293 int txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;

294

295 ff_opus_rc_enc_log(rc, f->pfilter, 1);

296 if (!f->pfilter)

297 return;

298

299 /* Octave */

300 txval = FFMIN(octave, 6);

301 ff_opus_rc_enc_uint(rc, txval, 6);

302 octave = txval;

303 /* Period */

304 txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);

305 ff_opus_rc_put_raw(rc, period, 4 + octave);

306 period = txval + (16 << octave) - 1;

307 /* Gain */

308 txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);

309 ff_opus_rc_put_raw(rc, txval, 3);

310 gain = 0.09375f * (txval + 1);

311 /* Tapset */

312 if ((opus_rc_tell(rc) + 2) <= f->framebits)

313 ff_opus_rc_enc_cdf(rc, tapset, ff_celt_model_tapset);

314 else

315 tapset = 0;

316 /* Finally create the coeffs */

317 for (int i = 0; i < 2; i++) {

318 CeltBlock *block = &f->block[i];

319

320 block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);

321 block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];

322 block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];

323 block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];

324 }

325 }

326

327 static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f,

328 float last_energy[][CELT_MAX_BANDS], int intra)

329 {

330 float alpha, beta, prev[2] = { 0, 0 };

331 const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];

332

333 /* Inter is really just differential coding */

334 if (opus_rc_tell(rc) + 3 <= f->framebits)

335 ff_opus_rc_enc_log(rc, intra, 3);

336 else

337 intra = 0;

338

339 if (intra) {

340 alpha = 0.0f;

341 beta = 1.0f - (4915.0f/32768.0f);

342 } else {

343 alpha = ff_celt_alpha_coef[f->size];

344 beta = ff_celt_beta_coef[f->size];

345 }

346

347 for (int i = f->start_band; i < f->end_band; i++) {

348 for (int ch = 0; ch < f->channels; ch++) {

349 CeltBlock *block = &f->block[ch];

350 const int left = f->framebits - opus_rc_tell(rc);

351 const float last = FFMAX(-9.0f, last_energy[ch][i]);

352 float diff = block->energy[i] - prev[ch] - last*alpha;

353 int q_en = lrintf(diff);

354 if (left >= 15) {

355 ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);

356 } else if (left >= 2) {

357 q_en = av_clip(q_en, -1, 1);

358 ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);

359 } else if (left >= 1) {

360 q_en = av_clip(q_en, -1, 0);

361 ff_opus_rc_enc_log(rc, (q_en & 1), 1);

362 } else q_en = -1;

363

364 block->error_energy[i] = q_en - diff;

365 prev[ch] += beta * q_en;

366 }

367 }

368 }

369

370 static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc,

371 float last_energy[][CELT_MAX_BANDS])

372 {

373 uint32_t inter, intra;

374 OPUS_RC_CHECKPOINT_SPAWN(rc);

375

376 exp_quant_coarse(rc, f, last_energy, 1);

377 intra = OPUS_RC_CHECKPOINT_BITS(rc);

378

379 OPUS_RC_CHECKPOINT_ROLLBACK(rc);

380

381 exp_quant_coarse(rc, f, last_energy, 0);

382 inter = OPUS_RC_CHECKPOINT_BITS(rc);

383

384 if (inter > intra) { /* Unlikely */

385 OPUS_RC_CHECKPOINT_ROLLBACK(rc);

386 exp_quant_coarse(rc, f, last_energy, 1);

387 }

388 }

389

390 static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)

391 {

392 for (int i = f->start_band; i < f->end_band; i++) {

393 if (!f->fine_bits[i])

394 continue;

395 for (int ch = 0; ch < f->channels; ch++) {

396 CeltBlock *block = &f->block[ch];

397 int quant, lim = (1 << f->fine_bits[i]);

398 float offset, diff = 0.5f - block->error_energy[i];

399 quant = av_clip(floor(diff*lim), 0, lim - 1);

400 ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);

401 offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);

402 block->error_energy[i] -= offset;

403 }

404 }

405 }

406

407 static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)

408 {

409 for (int priority = 0; priority < 2; priority++) {

410 for (int i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {

411 if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)

412 continue;

413 for (int ch = 0; ch < f->channels; ch++) {

414 CeltBlock *block = &f->block[ch];

415 const float err = block->error_energy[i];

416 const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;

417 const int sign = FFABS(err + offset) < FFABS(err - offset);

418 ff_opus_rc_put_raw(rc, sign, 1);

419 block->error_energy[i] -= offset*(1 - 2*sign);

420 }

421 }

422 }

423 }

424

425 static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc,

426 CeltFrame *f, int index)

427 {

428 ff_opus_rc_enc_init(rc);

429

430 ff_opus_psy_celt_frame_init(&s->psyctx, f, index);

431

432 celt_frame_setup_input(s, f);

433

434 if (f->silence) {

435 if (f->framebits >= 16)

436 ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit signalling) */

437 for (int ch = 0; ch < s->channels; ch++)

438 memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);

439 return;

440 }

441

442 /* Filters */

443 celt_apply_preemph_filter(s, f);

444 if (f->pfilter) {

445 ff_opus_rc_enc_log(rc, 0, 15);

446 celt_enc_quant_pfilter(rc, f);

447 }

448

449 /* Transform */

450 celt_frame_mdct(s, f);

451

452 /* Need to handle transient/non-transient switches at any point during analysis */

453 while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))

454 celt_frame_mdct(s, f);

455

456 ff_opus_rc_enc_init(rc);

457

458 /* Silence */

459 ff_opus_rc_enc_log(rc, 0, 15);

460

461 /* Pitch filter */

462 if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)

463 celt_enc_quant_pfilter(rc, f);

464

465 /* Transient flag */

466 if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)

467 ff_opus_rc_enc_log(rc, f->transient, 3);

468

469 /* Main encoding */

470 celt_quant_coarse (f, rc, s->last_quantized_energy);

471 celt_enc_tf (f, rc);

472 ff_celt_bitalloc (f, rc, 1);

473 celt_quant_fine (f, rc);

474 ff_celt_quant_bands(f, rc);

475

476 /* Anticollapse bit */

477 if (f->anticollapse_needed)

478 ff_opus_rc_put_raw(rc, f->anticollapse, 1);

479

480 /* Final per-band energy adjustments from leftover bits */

481 celt_quant_final(s, rc, f);

482

483 for (int ch = 0; ch < f->channels; ch++) {

484 CeltBlock *block = &f->block[ch];

485 for (int i = 0; i < CELT_MAX_BANDS; i++)

486 s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];

487 }

488 }

489

490 static inline int write_opuslacing(uint8_t *dst, int v)

491 {

492 dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);

493 dst[1] = v - dst[0] >> 2;

494 return 1 + (v >= 252);

495 }

496

497 static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)

498 {

499 int offset, fsize_needed;

500

501 /* Write toc */

502 opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);

503

504 /* Frame sizes if needed */

505 if (fsize_needed) {

506 for (int i = 0; i < s->packet.frames - 1; i++) {

507 offset += write_opuslacing(avpkt->data + offset,

508 s->frame[i].framebits >> 3);

509 }

510 }

511

512 /* Packets */

513 for (int i = 0; i < s->packet.frames; i++) {

514 ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,

515 s->frame[i].framebits >> 3);

516 offset += s->frame[i].framebits >> 3;

517 }

518

519 avpkt->size = offset;

520 }

521

522 /* Used as overlap for the first frame and padding for the last encoded packet */

523 static AVFrame *spawn_empty_frame(OpusEncContext *s)

524 {

525 AVFrame *f = av_frame_alloc();

526 int ret;

527 if (!f)

528 return NULL;

529 f->format = s->avctx->sample_fmt;

530 f->nb_samples = s->avctx->frame_size;

531 ret = av_channel_layout_copy(&f->ch_layout, &s->avctx->ch_layout);

532 if (ret < 0) {

533 av_frame_free(&f);

534 return NULL;

535 }

536 if (av_frame_get_buffer(f, 4)) {

537 av_frame_free(&f);

538 return NULL;

539 }

540 for (int i = 0; i < s->channels; i++) {

541 size_t bps = av_get_bytes_per_sample(f->format);

542 memset(f->extended_data[i], 0, bps*f->nb_samples);

543 }

544 return f;

545 }

546

547 static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

548 const AVFrame *frame, int *got_packet_ptr)

549 {

550 OpusEncContext *s = avctx->priv_data;

551 int ret, frame_size, alloc_size = 0;

552

553 if (frame) { /* Add new frame to queue */

554 if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)

555 return ret;

556 ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));

557 } else {

558 ff_opus_psy_signal_eof(&s->psyctx);

559 if (!s->afq.remaining_samples || !avctx->frame_num)

560 return 0; /* We've been flushed and there's nothing left to encode */

561 }

562

563 /* Run the psychoacoustic system */

564 if (ff_opus_psy_process(&s->psyctx, &s->packet))

565 return 0;

566

567 frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);

568

569 if (!frame) {

570 /* This can go negative, that's not a problem, we only pad if positive */

571 int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;

572 /* Pad with empty 2.5 ms frames to whatever framesize was decided,

573 * this should only happen at the very last flush frame. The frames

574 * allocated here will be freed (because they have no other references)

575 * after they get used by celt_frame_setup_input() */

576 for (int i = 0; i < pad_empty; i++) {

577 AVFrame *empty = spawn_empty_frame(s);

578 if (!empty)

579 return AVERROR(ENOMEM);

580 ff_bufqueue_add(avctx, &s->bufqueue, empty);

581 }

582 }

583

584 for (int i = 0; i < s->packet.frames; i++) {

585 celt_encode_frame(s, &s->rc[i], &s->frame[i], i);

586 alloc_size += s->frame[i].framebits >> 3;

587 }

588

589 /* Worst case toc + the frame lengths if needed */

590 alloc_size += 2 + s->packet.frames*2;

591

592 if ((ret = ff_alloc_packet(avctx, avpkt, alloc_size)) < 0)

593 return ret;

594

595 /* Assemble packet */

596 opus_packet_assembler(s, avpkt);

597

598 /* Update the psychoacoustic system */

599 ff_opus_psy_postencode_update(&s->psyctx, s->frame);

600

601 /* Remove samples from queue and skip if needed */

602 ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);

603 if (s->packet.frames*frame_size > avpkt->duration) {

604 uint8_t *side = av_packet_new_side_data(avpkt, AV_PKT_DATA_SKIP_SAMPLES, 10);

605 if (!side)

606 return AVERROR(ENOMEM);

607 AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);

608 }

609

610 *got_packet_ptr = 1;

611

612 return 0;

613 }

614

615 static av_cold int opus_encode_end(AVCodecContext *avctx)

616 {

617 OpusEncContext *s = avctx->priv_data;

618

619 for (int i = 0; i < CELT_BLOCK_NB; i++)

620 av_tx_uninit(&s->tx[i]);

621

622 ff_celt_pvq_uninit(&s->pvq);

623 av_freep(&s->dsp);

624 av_freep(&s->frame);

625 av_freep(&s->rc);

626 ff_af_queue_close(&s->afq);

627 ff_opus_psy_end(&s->psyctx);

628 ff_bufqueue_discard_all(&s->bufqueue);

629

630 return 0;

631 }

632

633 static av_cold int opus_encode_init(AVCodecContext *avctx)

634 {

635 int ret, max_frames;

636 OpusEncContext *s = avctx->priv_data;

637

638 s->avctx = avctx;

639 s->channels = avctx->ch_layout.nb_channels;

640

641 /* Opus allows us to change the framesize on each packet (and each packet may

642 * have multiple frames in it) but we can't change the codec's frame size on

643 * runtime, so fix it to the lowest possible number of samples and use a queue

644 * to accumulate AVFrames until we have enough to encode whatever the encoder

645 * decides is the best */

646 avctx->frame_size = 120;

647 /* Initial padding will change if SILK is ever supported */

648 avctx->initial_padding = 120;

649

650 if (!avctx->bit_rate) {

651 int coupled = ff_opus_default_coupled_streams[s->channels - 1];

652 avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);

653 } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {

654 int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);

655 av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",

656 avctx->bit_rate/1000, clipped_rate/1000);

657 avctx->bit_rate = clipped_rate;

658 }

659

660 /* Extradata */

661 avctx->extradata_size = 19;

662 avctx->extradata = av_malloc(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);

663 if (!avctx->extradata)

664 return AVERROR(ENOMEM);

665 opus_write_extradata(avctx);

666

667 ff_af_queue_init(avctx, &s->afq);

668

669 if ((ret = ff_celt_pvq_init(&s->pvq, 1)) < 0)

670 return ret;

671

672 if (!(s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT)))

673 return AVERROR(ENOMEM);

674

675 /* I have no idea why a base scaling factor of 68 works, could be the twiddles */

676 for (int i = 0; i < CELT_BLOCK_NB; i++) {

677 const float scale = 68 << (CELT_BLOCK_NB - 1 - i);

678 if ((ret = av_tx_init(&s->tx[i], &s->tx_fn[i], AV_TX_FLOAT_MDCT, 0, 15 << (i + 3), &scale, 0)))

679 return AVERROR(ENOMEM);

680 }

681

682 /* Zero out previous energy (matters for inter first frame) */

683 for (int ch = 0; ch < s->channels; ch++)

684 memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);

685

686 /* Allocate an empty frame to use as overlap for the first frame of audio */

687 ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));

688 if (!ff_bufqueue_peek(&s->bufqueue, 0))

689 return AVERROR(ENOMEM);

690

691 if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))

692 return ret;

693

694 /* Frame structs and range coder buffers */

695 max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);

696 s->frame = av_malloc(max_frames*sizeof(CeltFrame));

697 if (!s->frame)

698 return AVERROR(ENOMEM);

699 s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));

700 if (!s->rc)

701 return AVERROR(ENOMEM);

702

703 for (int i = 0; i < max_frames; i++) {

704 s->frame[i].dsp = s->dsp;

705 s->frame[i].avctx = s->avctx;

706 s->frame[i].seed = 0;

707 s->frame[i].pvq = s->pvq;

708 s->frame[i].apply_phase_inv = s->options.apply_phase_inv;

709 s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;

710 }

711

712 return 0;

713 }

714

715 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM

716 static const AVOption opusenc_options[] = {

717 { "opus_delay", "Maximum delay in milliseconds", offsetof(OpusEncContext, options.max_delay_ms), AV_OPT_TYPE_FLOAT, { .dbl = OPUS_MAX_LOOKAHEAD }, 2.5f, OPUS_MAX_LOOKAHEAD, OPUSENC_FLAGS, .unit = "max_delay_ms" },

718 { "apply_phase_inv", "Apply intensity stereo phase inversion", offsetof(OpusEncContext, options.apply_phase_inv), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, OPUSENC_FLAGS, .unit = "apply_phase_inv" },

719 { NULL },

720 };

721

722 static const AVClass opusenc_class = {

723 .class_name = "Opus encoder",

724 .item_name = av_default_item_name,

725 .option = opusenc_options,

726 .version = LIBAVUTIL_VERSION_INT,

727 };

728

729 static const FFCodecDefault opusenc_defaults[] = {

730 { "b", "0" },

731 { "compression_level", "10" },

732 { NULL },

733 };

734

735 const FFCodec ff_opus_encoder = {

736 .p.name = "opus",

737 CODEC_LONG_NAME("Opus"),

738 .p.type = AVMEDIA_TYPE_AUDIO,

739 .p.id = AV_CODEC_ID_OPUS,

740 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |

741 AV_CODEC_CAP_SMALL_LAST_FRAME | AV_CODEC_CAP_EXPERIMENTAL,

742 .defaults = opusenc_defaults,

743 .p.priv_class = &opusenc_class,

744 .priv_data_size = sizeof(OpusEncContext),

745 .init = opus_encode_init,

746 FF_CODEC_ENCODE_CB(opus_encode_frame),

747 .close = opus_encode_end,

748 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

749 CODEC_SAMPLERATES(48000),

750 CODEC_CH_LAYOUTS(AV_CHANNEL_LAYOUT_MONO, AV_CHANNEL_LAYOUT_STEREO),

751 CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_FLTP),

752 };

ff_celt_window_padded

const float ff_celt_window_padded[136]

Definition: tab.c:1098

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1051

AV_SAMPLE_FMT_FLTP

@ AV_SAMPLE_FMT_FLTP

float, planar

Definition: samplefmt.h:66

OpusEncContext::av_class

AVClass * av_class

Definition: enc.c:40

celt_quant_fine

static void celt_quant_fine(CeltFrame *f, OpusRangeCoder *rc)

Definition: enc.c:390

av_clip

#define av_clip

Definition: common.h:100

opus_encode_init

static av_cold int opus_encode_init(AVCodecContext *avctx)

Definition: enc.c:633

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

CELT_MAX_BANDS

#define CELT_MAX_BANDS

Definition: celt.h:43

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

AV_WL32

#define AV_WL32(p, v)

Definition: intreadwrite.h:422

opus_packet_assembler

static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)

Definition: enc.c:497

mem_internal.h

ff_af_queue_remove

void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)

Remove frame(s) from the queue.

Definition: audio_frame_queue.c:75

av_frame_get_buffer

int av_frame_get_buffer(AVFrame *frame, int align)

Allocate new buffer(s) for audio or video data.

Definition: frame.c:206

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:395

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1024

CELT_ENERGY_SILENCE

#define CELT_ENERGY_SILENCE

Definition: celt.h:53

log2f

#define log2f(x)

Definition: libm.h:411

opusenc_options

static const AVOption opusenc_options[]

Definition: enc.c:716

opus_rc_tell

static av_always_inline uint32_t opus_rc_tell(const OpusRangeCoder *rc)

CELT: estimate bits of entropy that have thus far been consumed for the current CELT frame,...

Definition: rc.h:62

src1

const pixel * src1

Definition: h264pred_template.c:420

AVTXContext

Definition: tx_priv.h:235

int64_t

long long int64_t

Definition: coverity.c:34

ff_af_queue_init

av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)

Initialize AudioFrameQueue.

Definition: audio_frame_queue.c:28

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

opusenc_class

static const AVClass opusenc_class

Definition: enc.c:722

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

CELT_BLOCK_NB

@ CELT_BLOCK_NB

Definition: celt.h:68

ff_celt_model_energy_small

#define ff_celt_model_energy_small

Definition: tab.h:127

AVPacket::data

uint8_t * data

Definition: packet.h:558

AVOption

AVOption.

Definition: opt.h:429

encode.h

#define b

Definition: input.c:42

CELT_MAX_FINE_BITS

#define CELT_MAX_FINE_BITS

Definition: celt.h:48

FFCodec

Definition: codec_internal.h:127

celt_enc_tf

static void celt_enc_tf(CeltFrame *f, OpusRangeCoder *rc)

Definition: enc.c:263

float.h

opus_gen_toc

static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)

Definition: enc.c:80

ff_opus_rc_enc_laplace

void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)

Definition: rc.c:314

AVPacket::duration

int64_t duration

Duration of this packet in AVStream->time_base units, 0 if unknown.

Definition: packet.h:576

OpusEncContext::options

OpusEncOptions options

Definition: enc.c:41

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

ff_opus_deemph_weights

const float ff_opus_deemph_weights[]

Definition: tab.c:1163

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

ceilf

static __device__ float ceilf(float a)

Definition: cuda_runtime.h:175

av_tx_init

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)

Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...

Definition: tx.c:903

OPUS_RC_CHECKPOINT_SPAWN

#define OPUS_RC_CHECKPOINT_SPAWN(rc)

Definition: rc.h:117

ff_bufqueue_get

static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)

Get the first buffer from the queue and remove it.

Definition: bufferqueue.h:98

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

CeltBlock

Definition: celt.h:71

win

static float win(SuperEqualizerContext *s, float n, int N)

Definition: af_superequalizer.c:119

CeltPVQ

Definition: pvq.h:37

ff_opus_rc_enc_init

void ff_opus_rc_enc_init(OpusRangeCoder *rc)

Definition: rc.c:402

ff_opus_psy_postencode_update

void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f)

Definition: enc_psy.c:480

FFCodecDefault

Definition: codec_internal.h:96

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

ff_opus_rc_enc_end

void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)

Definition: rc.c:360

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

audio_frame_queue.h

AVCodecContext::initial_padding

int initial_padding

Audio only.

Definition: avcodec.h:1096

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:488

OpusEncContext::frame

CeltFrame * frame

Definition: enc.c:58

OPUS_MAX_LOOKAHEAD

#define OPUS_MAX_LOOKAHEAD

Definition: enc.h:32

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:358

ff_af_queue_add

int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)

Add a frame to the queue.

Definition: audio_frame_queue.c:44

ff_celt_model_tapset

const uint16_t ff_celt_model_tapset[]

Definition: tab.c:754

ff_opus_psy_signal_eof

void ff_opus_psy_signal_eof(OpusPsyContext *s)

Definition: enc_psy.c:590

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

quant

static const uint8_t quant[64]

Definition: vmixdec.c:71

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

OpusEncContext::afq

AudioFrameQueue afq

Definition: enc.c:44

AV_CODEC_CAP_EXPERIMENTAL

#define AV_CODEC_CAP_EXPERIMENTAL

Codec is experimental and is thus avoided in favor of non experimental encoders.

Definition: codec.h:87

av_cold

#define av_cold

Definition: attributes.h:106

ff_celt_postfilter_taps

const float ff_celt_postfilter_taps[3][3]

Definition: tab.c:1092

av_tx_fn

void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)

Function pointer to a function to perform the transform.

Definition: tx.h:151

celt_frame_mdct

static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)

Definition: enc.c:198

float

Definition: af_crystalizer.c:122

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

AV_TX_FLOAT_MDCT

@ AV_TX_FLOAT_MDCT

Standard MDCT with a sample data type of float, double or int32_t, respectively.

Definition: tx.h:68

OpusEncContext::rc

OpusRangeCoder * rc

Definition: enc.c:59

OpusEncContext::scratch

float scratch[2048]

Definition: enc.c:64

#define s(width, name)

Definition: cbs_vp9.c:198

floor

static __device__ float floor(float a)

Definition: cuda_runtime.h:173

frame_size

int frame_size

Definition: mxfenc.c:2474

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:201

pvq.h

bits

uint8_t bits

Definition: vp3data.h:128

AudioFrameQueue

Definition: audio_frame_queue.h:32

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

Create a new frame that references the same data as src.

Definition: frame.c:483

ff_celt_pvq_uninit

void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)

Definition: pvq.c:927

OPUS_BLOCK_SIZE

#define OPUS_BLOCK_SIZE(x)

Definition: enc.h:39

opus_encode_end

static av_cold int opus_encode_end(AVCodecContext *avctx)

Definition: enc.c:615

OpusPsyContext

Definition: enc_psy.h:52

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:74

ff_af_queue_close

av_cold void ff_af_queue_close(AudioFrameQueue *afq)

Close AudioFrameQueue.

Definition: audio_frame_queue.c:36

OPUS_MODE_NB

@ OPUS_MODE_NB

Definition: opus.h:46

OpusPacketInfo

Definition: enc.h:48

CODEC_CH_LAYOUTS

#define CODEC_CH_LAYOUTS(...)

Definition: codec_internal.h:379

ff_celt_tf_select

const int8_t ff_celt_tf_select[4][2][2][2]

Definition: tab.c:776

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

OPUS_BANDWITH_NB

@ OPUS_BANDWITH_NB

Definition: opus.h:56

celt_quant_coarse

static void celt_quant_coarse(CeltFrame *f, OpusRangeCoder *rc, float last_energy[][CELT_MAX_BANDS])

Definition: enc.c:370

ff_celt_freq_range

const uint8_t ff_celt_freq_range[]

Definition: tab.c:766

OpusEncContext::packet

OpusPacketInfo packet

Definition: enc.c:54

ff_opus_psy_end

av_cold int ff_opus_psy_end(OpusPsyContext *s)

Definition: enc_psy.c:595

period

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without period

Definition: writing_filters.txt:89

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:481

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

ff_bufqueue_discard_all

static void ff_bufqueue_discard_all(struct FFBufQueue *queue)

Unref and remove all buffers from the queue.

Definition: bufferqueue.h:111

options

Definition: swscale.c:43

sqrtf

static __device__ float sqrtf(float a)

Definition: cuda_runtime.h:184

CELT_POSTFILTER_MINPERIOD

#define CELT_POSTFILTER_MINPERIOD

Definition: celt.h:52

enc_psy.h

ff_opus_psy_celt_frame_init

void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)

Definition: enc_psy.c:258

ff_celt_coarse_energy_dist

const uint8_t ff_celt_coarse_energy_dist[4][2][42]

Definition: tab.c:802

celt_enc_quant_pfilter

static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)

Definition: enc.c:290

index

int index

Definition: gxfenc.c:90

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

opusenc_defaults

static const FFCodecDefault opusenc_defaults[]

Definition: enc.c:729

float_dsp.h

opus_encode_frame

static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Definition: enc.c:547

OpusEncContext::channels

int channels

Definition: enc.c:56

ff_celt_beta_coef

const float ff_celt_beta_coef[]

Definition: tab.c:798

Definition: af_crystalizer.c:122

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

enc.h

AVPacket::size

int size

Definition: packet.h:559

ff_opus_default_coupled_streams

const uint8_t ff_opus_default_coupled_streams[]

Definition: tab.c:27

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:104

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

ff_celt_window

static const float *const ff_celt_window

Definition: tab.h:162

exp_quant_coarse

static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS], int intra)

Definition: enc.c:327

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

bps

unsigned bps

Definition: movenc.c:1958

sample

#define sample

Definition: flacdsp_template.c:44

size

int size

Definition: twinvq_data.h:10344

OpusEncContext::enc_id

uint8_t enc_id[64]

Definition: enc.c:51

OpusRangeCoder

Definition: rc.h:41

ff_opus_encoder

const FFCodec ff_opus_encoder

Definition: enc.c:735

OpusEncContext::psyctx

OpusPsyContext psyctx

Definition: enc.c:42

AV_CODEC_ID_OPUS

@ AV_CODEC_ID_OPUS

Definition: codec_id.h:519

AVFloatDSPContext

Definition: float_dsp.h:24

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...

Definition: frame.h:514

ff_opus_psy_process

int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)

Definition: enc_psy.c:227

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:166

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

ff_bufqueue_add

static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)

Add a buffer to the queue.

Definition: bufferqueue.h:71

OpusEncContext

Definition: enc.c:39

CODEC_SAMPLEFMTS

#define CODEC_SAMPLEFMTS(...)

Definition: codec_internal.h:385

ff_opus_psy_celt_frame_process

int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)

Definition: enc_psy.c:459

ff_celt_quant_bands

void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)

Definition: celt.c:28

input

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input

Definition: filter_design.txt:172

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

celt_apply_preemph_filter

static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)

Definition: enc.c:163

AV_OPT_TYPE_FLOAT

@ AV_OPT_TYPE_FLOAT

Underlying C type is float.

Definition: opt.h:271

OpusEncContext::last_quantized_energy

float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]

Definition: enc.c:62

bytestream_put_buffer

static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)

Definition: bytestream.h:372

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:507

tab.h

lrintf

#define lrintf(x)

Definition: libm_mips.h:72

ff_bufqueue_peek

static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)

Get a buffer from the queue without altering it.

Definition: bufferqueue.h:87

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

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:551

celt_encode_frame

static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)

Definition: enc.c:425

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:108

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

FFBufQueue

Structure holding the queue.

Definition: bufferqueue.h:49

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:488

src2

const pixel * src2

Definition: h264pred_template.c:421

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

write_opuslacing

static int write_opuslacing(uint8_t *dst, int v)

Definition: enc.c:490

len

int len

Definition: vorbis_enc_data.h:426

spawn_empty_frame

static AVFrame * spawn_empty_frame(OpusEncContext *s)

Definition: enc.c:523

opus_write_extradata

static void opus_write_extradata(AVCodecContext *avctx)

Definition: enc.c:67

OpusEncContext::tx

AVTXContext * tx[CELT_BLOCK_NB]

Definition: enc.c:46

ff_opus_rc_enc_cdf

void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)

Definition: rc.c:109

AVCodecContext::frame_num

int64_t frame_num

Frame counter, set by libavcodec.

Definition: avcodec.h:1878

ret

Definition: filter_design.txt:187

OpusEncContext::avctx

AVCodecContext * avctx

Definition: enc.c:43

ff_celt_bitalloc

void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)

Definition: celt.c:137

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:81

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

CELT_OVERLAP

#define CELT_OVERLAP

Definition: celt.h:40

celt_quant_final

static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)

Definition: enc.c:407

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

OpusEncContext::enc_id_bits

int enc_id_bits

Definition: enc.c:52

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

AVCodecContext

main external API structure.

Definition: avcodec.h:431

ff_celt_alpha_coef

const float ff_celt_alpha_coef[]

Definition: tab.c:794

channel_layout.h

av_packet_new_side_data

uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)

Allocate new information of a packet.

Definition: packet.c:232

celt_frame_setup_input

static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)

Definition: enc.c:123

OpusEncContext::tx_fn

av_tx_fn tx_fn[CELT_BLOCK_NB]

Definition: enc.c:47

temp

else temp

Definition: vf_mcdeint.c:271

AV_PKT_DATA_SKIP_SAMPLES

@ AV_PKT_DATA_SKIP_SAMPLES

Recommends skipping the specified number of samples.

Definition: packet.h:153

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: codec.h:76

av_channel_layout_copy

int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)

Make a copy of a channel layout.

Definition: channel_layout.c:449

ff_celt_mean_energy

const float ff_celt_mean_energy[]

Definition: tab.c:786

OPUS_MAX_CHANNELS

#define OPUS_MAX_CHANNELS

Definition: enc.h:34

mem.h

AV_CODEC_FLAG_BITEXACT

#define AV_CODEC_FLAG_BITEXACT

Use only bitexact stuff (except (I)DCT).

Definition: avcodec.h:322

AV_CHANNEL_LAYOUT_MONO

#define AV_CHANNEL_LAYOUT_MONO

Definition: channel_layout.h:394

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:273

OpusEncOptions

Definition: enc.h:43

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

alpha

static const int16_t alpha[]

Definition: ilbcdata.h:55

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:458

AVPacket

This structure stores compressed data.

Definition: packet.h:535

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Underlying C type is int.

Definition: opt.h:327

OpusEncContext::pvq

CeltPVQ * pvq

Definition: enc.c:48

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

avpriv_float_dsp_alloc

av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)

Allocate a float DSP context.

Definition: float_dsp.c:135

ff_celt_pvq_init

int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)

Definition: pvq.c:907

ff_opus_rc_put_raw

void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)

CELT: write 0 - 31 bits to the rawbits buffer.

Definition: rc.c:161

bytestream.h

block

The exact code depends on how similar the blocks are and how related they are to the block

Definition: filter_design.txt:207

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

OPUS_RC_CHECKPOINT_ROLLBACK

#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)

Definition: rc.h:124

ff_celt_freq_bands

const uint8_t ff_celt_freq_bands[]

Definition: tab.c:762

ff_opus_psy_init

av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)

Definition: enc_psy.c:516

OpusEncContext::bufqueue

struct FFBufQueue bufqueue

Definition: enc.c:49

AV_CODEC_CAP_SMALL_LAST_FRAME

#define AV_CODEC_CAP_SMALL_LAST_FRAME

Codec can be fed a final frame with a smaller size.

Definition: codec.h:81

ff_opus_rc_enc_log

void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)

Definition: rc.c:131

ff_alloc_packet

int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)

Check AVPacket size and allocate data.

Definition: encode.c:60

ff_opus_rc_enc_uint

void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)

CELT: write a uniformly distributed integer.

Definition: rc.c:204

OPUS_RC_CHECKPOINT_BITS

#define OPUS_RC_CHECKPOINT_BITS(rc)

Definition: rc.h:121

OPUSENC_FLAGS

#define OPUSENC_FLAGS

Definition: enc.c:715

CODEC_SAMPLERATES

#define CODEC_SAMPLERATES(...)

Definition: codec_internal.h:382

CeltFrame

Definition: celt.h:98

OpusEncContext::dsp

AVFloatDSPContext * dsp

Definition: enc.c:45

Generated on Sat Oct 18 2025 19:22:31 for FFmpeg by doxygen 1.8.17