FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
opusenc.c
Go to the documentation of this file.
1 /*
2  * Opus encoder
3  * Copyright (c) 2017 Rostislav Pehlivanov <atomnuker@gmail.com>
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  */
21 
22 #include "opusenc.h"
23 #include "opus_pvq.h"
24 #include "opusenc_psy.h"
25 #include "opustab.h"
26 
27 #include "libavutil/float_dsp.h"
28 #include "libavutil/opt.h"
29 #include "internal.h"
30 #include "bytestream.h"
31 #include "audio_frame_queue.h"
32 
33 typedef struct OpusEncContext {
43 
46 
48 
49  int channels;
50 
53 
54  /* Actual energy the decoder will have */
56 
57  DECLARE_ALIGNED(32, float, scratch)[2048];
59 
61 {
62  uint8_t *bs = avctx->extradata;
63 
64  bytestream_put_buffer(&bs, "OpusHead", 8);
65  bytestream_put_byte (&bs, 0x1);
66  bytestream_put_byte (&bs, avctx->channels);
67  bytestream_put_le16 (&bs, avctx->initial_padding);
68  bytestream_put_le32 (&bs, avctx->sample_rate);
69  bytestream_put_le16 (&bs, 0x0);
70  bytestream_put_byte (&bs, 0x0); /* Default layout */
71 }
72 
73 static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
74 {
75  int i, tmp = 0x0, extended_toc = 0;
76  static const int toc_cfg[][OPUS_MODE_NB][OPUS_BANDWITH_NB] = {
77  /* Silk Hybrid Celt Layer */
78  /* NB MB WB SWB FB NB MB WB SWB FB NB MB WB SWB FB Bandwidth */
79  { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 17, 0, 21, 25, 29 } }, /* 2.5 ms */
80  { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 18, 0, 22, 26, 30 } }, /* 5 ms */
81  { { 1, 5, 9, 0, 0 }, { 0, 0, 0, 13, 15 }, { 19, 0, 23, 27, 31 } }, /* 10 ms */
82  { { 2, 6, 10, 0, 0 }, { 0, 0, 0, 14, 16 }, { 20, 0, 24, 28, 32 } }, /* 20 ms */
83  { { 3, 7, 11, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 40 ms */
84  { { 4, 8, 12, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }, /* 60 ms */
85  };
86  int cfg = toc_cfg[s->packet.framesize][s->packet.mode][s->packet.bandwidth];
87  *fsize_needed = 0;
88  if (!cfg)
89  return 1;
90  if (s->packet.frames == 2) { /* 2 packets */
91  if (s->frame[0].framebits == s->frame[1].framebits) { /* same size */
92  tmp = 0x1;
93  } else { /* different size */
94  tmp = 0x2;
95  *fsize_needed = 1; /* put frame sizes in the packet */
96  }
97  } else if (s->packet.frames > 2) {
98  tmp = 0x3;
99  extended_toc = 1;
100  }
101  tmp |= (s->channels > 1) << 2; /* Stereo or mono */
102  tmp |= (cfg - 1) << 3; /* codec configuration */
103  *toc++ = tmp;
104  if (extended_toc) {
105  for (i = 0; i < (s->packet.frames - 1); i++)
106  *fsize_needed |= (s->frame[i].framebits != s->frame[i + 1].framebits);
107  tmp = (*fsize_needed) << 7; /* vbr flag */
108  tmp |= (0) << 6; /* padding flag */
109  tmp |= s->packet.frames;
110  *toc++ = tmp;
111  }
112  *size = 1 + extended_toc;
113  return 0;
114 }
115 
117 {
118  int sf, ch;
119  AVFrame *cur = NULL;
120  const int subframesize = s->avctx->frame_size;
121  int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
122 
123  cur = ff_bufqueue_get(&s->bufqueue);
124 
125  for (ch = 0; ch < f->channels; ch++) {
126  CeltBlock *b = &f->block[ch];
127  const void *input = cur->extended_data[ch];
128  size_t bps = av_get_bytes_per_sample(cur->format);
129  memcpy(b->overlap, input, bps*cur->nb_samples);
130  }
131 
132  av_frame_free(&cur);
133 
134  for (sf = 0; sf < subframes; sf++) {
135  if (sf != (subframes - 1))
136  cur = ff_bufqueue_get(&s->bufqueue);
137  else
138  cur = ff_bufqueue_peek(&s->bufqueue, 0);
139 
140  for (ch = 0; ch < f->channels; ch++) {
141  CeltBlock *b = &f->block[ch];
142  const void *input = cur->extended_data[ch];
143  const size_t bps = av_get_bytes_per_sample(cur->format);
144  const size_t left = (subframesize - cur->nb_samples)*bps;
145  const size_t len = FFMIN(subframesize, cur->nb_samples)*bps;
146  memcpy(&b->samples[sf*subframesize], input, len);
147  memset(&b->samples[cur->nb_samples], 0, left);
148  }
149 
150  /* Last frame isn't popped off and freed yet - we need it for overlap */
151  if (sf != (subframes - 1))
152  av_frame_free(&cur);
153  }
154 }
155 
156 /* Apply the pre emphasis filter */
158 {
159  int i, sf, ch;
160  const int subframesize = s->avctx->frame_size;
161  const int subframes = OPUS_BLOCK_SIZE(s->packet.framesize) / subframesize;
162 
163  /* Filter overlap */
164  for (ch = 0; ch < f->channels; ch++) {
165  CeltBlock *b = &f->block[ch];
166  float m = b->emph_coeff;
167  for (i = 0; i < CELT_OVERLAP; i++) {
168  float sample = b->overlap[i];
169  b->overlap[i] = sample - m;
170  m = sample * CELT_EMPH_COEFF;
171  }
172  b->emph_coeff = m;
173  }
174 
175  /* Filter the samples but do not update the last subframe's coeff - overlap ^^^ */
176  for (sf = 0; sf < subframes; sf++) {
177  for (ch = 0; ch < f->channels; ch++) {
178  CeltBlock *b = &f->block[ch];
179  float m = b->emph_coeff;
180  for (i = 0; i < subframesize; i++) {
181  float sample = b->samples[sf*subframesize + i];
182  b->samples[sf*subframesize + i] = sample - m;
183  m = sample * CELT_EMPH_COEFF;
184  }
185  if (sf != (subframes - 1))
186  b->emph_coeff = m;
187  }
188  }
189 }
190 
191 /* Create the window and do the mdct */
193 {
194  int i, j, t, ch;
195  float *win = s->scratch, *temp = s->scratch + 1920;
196 
197  if (f->transient) {
198  for (ch = 0; ch < f->channels; ch++) {
199  CeltBlock *b = &f->block[ch];
200  float *src1 = b->overlap;
201  for (t = 0; t < f->blocks; t++) {
202  float *src2 = &b->samples[CELT_OVERLAP*t];
203  s->dsp->vector_fmul(win, src1, ff_celt_window, 128);
204  s->dsp->vector_fmul_reverse(&win[CELT_OVERLAP], src2,
205  ff_celt_window - 8, 128);
206  src1 = src2;
207  s->mdct[0]->mdct(s->mdct[0], b->coeffs + t, win, f->blocks);
208  }
209  }
210  } else {
211  int blk_len = OPUS_BLOCK_SIZE(f->size), wlen = OPUS_BLOCK_SIZE(f->size + 1);
212  int rwin = blk_len - CELT_OVERLAP, lap_dst = (wlen - blk_len - CELT_OVERLAP) >> 1;
213  memset(win, 0, wlen*sizeof(float));
214  for (ch = 0; ch < f->channels; ch++) {
215  CeltBlock *b = &f->block[ch];
216 
217  /* Overlap */
218  s->dsp->vector_fmul(temp, b->overlap, ff_celt_window, 128);
219  memcpy(win + lap_dst, temp, CELT_OVERLAP*sizeof(float));
220 
221  /* Samples, flat top window */
222  memcpy(&win[lap_dst + CELT_OVERLAP], b->samples, rwin*sizeof(float));
223 
224  /* Samples, windowed */
225  s->dsp->vector_fmul_reverse(temp, b->samples + rwin,
226  ff_celt_window - 8, 128);
227  memcpy(win + lap_dst + blk_len, temp, CELT_OVERLAP*sizeof(float));
228 
229  s->mdct[f->size]->mdct(s->mdct[f->size], b->coeffs, win, 1);
230  }
231  }
232 
233  for (ch = 0; ch < f->channels; ch++) {
234  CeltBlock *block = &f->block[ch];
235  for (i = 0; i < CELT_MAX_BANDS; i++) {
236  float ener = 0.0f;
237  int band_offset = ff_celt_freq_bands[i] << f->size;
238  int band_size = ff_celt_freq_range[i] << f->size;
239  float *coeffs = &block->coeffs[band_offset];
240 
241  for (j = 0; j < band_size; j++)
242  ener += coeffs[j]*coeffs[j];
243 
244  block->lin_energy[i] = sqrtf(ener) + FLT_EPSILON;
245  ener = 1.0f/block->lin_energy[i];
246 
247  for (j = 0; j < band_size; j++)
248  coeffs[j] *= ener;
249 
250  block->energy[i] = log2f(block->lin_energy[i]) - ff_celt_mean_energy[i];
251 
252  /* CELT_ENERGY_SILENCE is what the decoder uses and its not -infinity */
253  block->energy[i] = FFMAX(block->energy[i], CELT_ENERGY_SILENCE);
254  }
255  }
256 }
257 
259 {
260  int i, tf_select = 0, diff = 0, tf_changed = 0, tf_select_needed;
261  int bits = f->transient ? 2 : 4;
262 
263  tf_select_needed = ((f->size && (opus_rc_tell(rc) + bits + 1) <= f->framebits));
264 
265  for (i = f->start_band; i < f->end_band; i++) {
266  if ((opus_rc_tell(rc) + bits + tf_select_needed) <= f->framebits) {
267  const int tbit = (diff ^ 1) == f->tf_change[i];
268  ff_opus_rc_enc_log(rc, tbit, bits);
269  diff ^= tbit;
270  tf_changed |= diff;
271  }
272  bits = f->transient ? 4 : 5;
273  }
274 
275  if (tf_select_needed && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
276  ff_celt_tf_select[f->size][f->transient][1][tf_changed]) {
277  ff_opus_rc_enc_log(rc, f->tf_select, 1);
278  tf_select = f->tf_select;
279  }
280 
281  for (i = f->start_band; i < f->end_band; i++)
282  f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
283 }
284 
286 {
287  int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
288  int skip_startband = f->start_band;
289  int skip_bit = 0;
290  int intensitystereo_bit = 0;
291  int dualstereo_bit = 0;
292  int dynalloc = 6;
293  int extrabits = 0;
294 
295  int *cap = f->caps;
296  int boost[CELT_MAX_BANDS];
297  int trim_offset[CELT_MAX_BANDS];
298  int threshold[CELT_MAX_BANDS];
299  int bits1[CELT_MAX_BANDS];
300  int bits2[CELT_MAX_BANDS];
301 
302  /* Tell the spread to the decoder */
303  if (opus_rc_tell(rc) + 4 <= f->framebits)
305  else
307 
308  /* Generate static allocation caps */
309  for (i = 0; i < CELT_MAX_BANDS; i++) {
310  cap[i] = (ff_celt_static_caps[f->size][f->channels - 1][i] + 64)
311  * ff_celt_freq_range[i] << (f->channels - 1) << f->size >> 2;
312  }
313 
314  /* Band boosts */
315  tbits_8ths = f->framebits << 3;
316  for (i = f->start_band; i < f->end_band; i++) {
317  int quanta, b_dynalloc, boost_amount = f->alloc_boost[i];
318 
319  boost[i] = 0;
320 
321  quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
322  quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
323  b_dynalloc = dynalloc;
324 
325  while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < cap[i]) {
326  int is_boost = boost_amount--;
327 
328  ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
329  if (!is_boost)
330  break;
331 
332  boost[i] += quanta;
333  tbits_8ths -= quanta;
334 
335  b_dynalloc = 1;
336  }
337 
338  if (boost[i])
339  dynalloc = FFMAX(2, dynalloc - 1);
340  }
341 
342  /* Put allocation trim */
343  if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
345 
346  /* Anti-collapse bit reservation */
347  tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
348  f->anticollapse_needed = 0;
349  if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
350  f->anticollapse_needed = 1 << 3;
351  tbits_8ths -= f->anticollapse_needed;
352 
353  /* Band skip bit reservation */
354  if (tbits_8ths >= 1 << 3)
355  skip_bit = 1 << 3;
356  tbits_8ths -= skip_bit;
357 
358  /* Intensity/dual stereo bit reservation */
359  if (f->channels == 2) {
360  intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
361  if (intensitystereo_bit <= tbits_8ths) {
362  tbits_8ths -= intensitystereo_bit;
363  if (tbits_8ths >= 1 << 3) {
364  dualstereo_bit = 1 << 3;
365  tbits_8ths -= 1 << 3;
366  }
367  } else {
368  intensitystereo_bit = 0;
369  }
370  }
371 
372  /* Trim offsets */
373  for (i = f->start_band; i < f->end_band; i++) {
374  int trim = f->alloc_trim - 5 - f->size;
375  int band = ff_celt_freq_range[i] * (f->end_band - i - 1);
376  int duration = f->size + 3;
377  int scale = duration + f->channels - 1;
378 
379  /* PVQ minimum allocation threshold, below this value the band is
380  * skipped */
381  threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
382  f->channels << 3);
383 
384  trim_offset[i] = trim * (band << scale) >> 6;
385 
386  if (ff_celt_freq_range[i] << f->size == 1)
387  trim_offset[i] -= f->channels << 3;
388  }
389 
390  /* Bisection */
391  low = 1;
392  high = CELT_VECTORS - 1;
393  while (low <= high) {
394  int center = (low + high) >> 1;
395  done = total = 0;
396 
397  for (i = f->end_band - 1; i >= f->start_band; i--) {
398  bandbits = ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]
399  << (f->channels - 1) << f->size >> 2;
400 
401  if (bandbits)
402  bandbits = FFMAX(0, bandbits + trim_offset[i]);
403  bandbits += boost[i];
404 
405  if (bandbits >= threshold[i] || done) {
406  done = 1;
407  total += FFMIN(bandbits, cap[i]);
408  } else if (bandbits >= f->channels << 3)
409  total += f->channels << 3;
410  }
411 
412  if (total > tbits_8ths)
413  high = center - 1;
414  else
415  low = center + 1;
416  }
417  high = low--;
418 
419  /* Bisection */
420  for (i = f->start_band; i < f->end_band; i++) {
421  bits1[i] = ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]
422  << (f->channels - 1) << f->size >> 2;
423  bits2[i] = high >= CELT_VECTORS ? cap[i] :
425  << (f->channels - 1) << f->size >> 2;
426 
427  if (bits1[i])
428  bits1[i] = FFMAX(0, bits1[i] + trim_offset[i]);
429  if (bits2[i])
430  bits2[i] = FFMAX(0, bits2[i] + trim_offset[i]);
431  if (low)
432  bits1[i] += boost[i];
433  bits2[i] += boost[i];
434 
435  if (boost[i])
436  skip_startband = i;
437  bits2[i] = FFMAX(0, bits2[i] - bits1[i]);
438  }
439 
440  /* Bisection */
441  low = 0;
442  high = 1 << CELT_ALLOC_STEPS;
443  for (i = 0; i < CELT_ALLOC_STEPS; i++) {
444  int center = (low + high) >> 1;
445  done = total = 0;
446 
447  for (j = f->end_band - 1; j >= f->start_band; j--) {
448  bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
449 
450  if (bandbits >= threshold[j] || done) {
451  done = 1;
452  total += FFMIN(bandbits, cap[j]);
453  } else if (bandbits >= f->channels << 3)
454  total += f->channels << 3;
455  }
456  if (total > tbits_8ths)
457  high = center;
458  else
459  low = center;
460  }
461 
462  /* Bisection */
463  done = total = 0;
464  for (i = f->end_band - 1; i >= f->start_band; i--) {
465  bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
466 
467  if (bandbits >= threshold[i] || done)
468  done = 1;
469  else
470  bandbits = (bandbits >= f->channels << 3) ?
471  f->channels << 3 : 0;
472 
473  bandbits = FFMIN(bandbits, cap[i]);
474  f->pulses[i] = bandbits;
475  total += bandbits;
476  }
477 
478  /* Band skipping */
479  for (f->coded_bands = f->end_band; ; f->coded_bands--) {
480  int allocation;
481  j = f->coded_bands - 1;
482 
483  if (j == skip_startband) {
484  /* all remaining bands are not skipped */
485  tbits_8ths += skip_bit;
486  break;
487  }
488 
489  /* determine the number of bits available for coding "do not skip" markers */
490  remaining = tbits_8ths - total;
491  bandbits = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
492  remaining -= bandbits * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
493  allocation = f->pulses[j] + bandbits * ff_celt_freq_range[j]
494  + FFMAX(0, remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]));
495 
496  /* a "do not skip" marker is only coded if the allocation is
497  above the chosen threshold */
498  if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
499  const int do_not_skip = f->coded_bands <= f->skip_band_floor;
500  ff_opus_rc_enc_log(rc, do_not_skip, 1);
501  if (do_not_skip)
502  break;
503 
504  total += 1 << 3;
505  allocation -= 1 << 3;
506  }
507 
508  /* the band is skipped, so reclaim its bits */
509  total -= f->pulses[j];
510  if (intensitystereo_bit) {
511  total -= intensitystereo_bit;
512  intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
513  total += intensitystereo_bit;
514  }
515 
516  total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
517  }
518 
519  /* Encode stereo flags */
520  if (intensitystereo_bit) {
523  }
524  if (f->intensity_stereo <= f->start_band)
525  tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
526  else if (dualstereo_bit)
527  ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
528 
529  /* Supply the remaining bits in this frame to lower bands */
530  remaining = tbits_8ths - total;
531  bandbits = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
532  remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
533  for (i = f->start_band; i < f->coded_bands; i++) {
534  int bits = FFMIN(remaining, ff_celt_freq_range[i]);
535 
536  f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
537  remaining -= bits;
538  }
539 
540  /* Finally determine the allocation */
541  for (i = f->start_band; i < f->coded_bands; i++) {
542  int N = ff_celt_freq_range[i] << f->size;
543  int prev_extra = extrabits;
544  f->pulses[i] += extrabits;
545 
546  if (N > 1) {
547  int dof; // degrees of freedom
548  int temp; // dof * channels * log(dof)
549  int offset; // fine energy quantization offset, i.e.
550  // extra bits assigned over the standard
551  // totalbits/dof
552  int fine_bits, max_bits;
553 
554  extrabits = FFMAX(0, f->pulses[i] - cap[i]);
555  f->pulses[i] -= extrabits;
556 
557  /* intensity stereo makes use of an extra degree of freedom */
558  dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
559  temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
560  offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
561  if (N == 2) /* dof=2 is the only case that doesn't fit the model */
562  offset += dof << 1;
563 
564  /* grant an additional bias for the first and second pulses */
565  if (f->pulses[i] + offset < 2 * (dof << 3))
566  offset += temp >> 2;
567  else if (f->pulses[i] + offset < 3 * (dof << 3))
568  offset += temp >> 3;
569 
570  fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
571  max_bits = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
572 
573  max_bits = FFMAX(max_bits, 0);
574 
575  f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
576 
577  /* if fine_bits was rounded down or capped,
578  give priority for the final fine energy pass */
579  f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
580 
581  /* the remaining bits are assigned to PVQ */
582  f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
583  } else {
584  /* all bits go to fine energy except for the sign bit */
585  extrabits = FFMAX(0, f->pulses[i] - (f->channels << 3));
586  f->pulses[i] -= extrabits;
587  f->fine_bits[i] = 0;
588  f->fine_priority[i] = 1;
589  }
590 
591  /* hand back a limited number of extra fine energy bits to this band */
592  if (extrabits > 0) {
593  int fineextra = FFMIN(extrabits >> (f->channels + 2),
594  CELT_MAX_FINE_BITS - f->fine_bits[i]);
595  f->fine_bits[i] += fineextra;
596 
597  fineextra <<= f->channels + 2;
598  f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
599  extrabits -= fineextra;
600  }
601  }
602  f->remaining = extrabits;
603 
604  /* skipped bands dedicate all of their bits for fine energy */
605  for (; i < f->end_band; i++) {
606  f->fine_bits[i] = f->pulses[i] >> (f->channels - 1) >> 3;
607  f->pulses[i] = 0;
608  f->fine_priority[i] = f->fine_bits[i] < 1;
609  }
610 }
611 
613 {
614  float gain = f->pf_gain;
615  int i, txval, octave = f->pf_octave, period = f->pf_period, tapset = f->pf_tapset;
616 
617  ff_opus_rc_enc_log(rc, f->pfilter, 1);
618  if (!f->pfilter)
619  return;
620 
621  /* Octave */
622  txval = FFMIN(octave, 6);
623  ff_opus_rc_enc_uint(rc, txval, 6);
624  octave = txval;
625  /* Period */
626  txval = av_clip(period - (16 << octave) + 1, 0, (1 << (4 + octave)) - 1);
627  ff_opus_rc_put_raw(rc, period, 4 + octave);
628  period = txval + (16 << octave) - 1;
629  /* Gain */
630  txval = FFMIN(((int)(gain / 0.09375f)) - 1, 7);
631  ff_opus_rc_put_raw(rc, txval, 3);
632  gain = 0.09375f * (txval + 1);
633  /* Tapset */
634  if ((opus_rc_tell(rc) + 2) <= f->framebits)
636  else
637  tapset = 0;
638  /* Finally create the coeffs */
639  for (i = 0; i < 2; i++) {
640  CeltBlock *block = &f->block[i];
641 
643  block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
644  block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
645  block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
646  }
647 }
648 
650  float last_energy[][CELT_MAX_BANDS], int intra)
651 {
652  int i, ch;
653  float alpha, beta, prev[2] = { 0, 0 };
654  const uint8_t *pmod = ff_celt_coarse_energy_dist[f->size][intra];
655 
656  /* Inter is really just differential coding */
657  if (opus_rc_tell(rc) + 3 <= f->framebits)
658  ff_opus_rc_enc_log(rc, intra, 3);
659  else
660  intra = 0;
661 
662  if (intra) {
663  alpha = 0.0f;
664  beta = 1.0f - (4915.0f/32768.0f);
665  } else {
666  alpha = ff_celt_alpha_coef[f->size];
667  beta = ff_celt_beta_coef[f->size];
668  }
669 
670  for (i = f->start_band; i < f->end_band; i++) {
671  for (ch = 0; ch < f->channels; ch++) {
672  CeltBlock *block = &f->block[ch];
673  const int left = f->framebits - opus_rc_tell(rc);
674  const float last = FFMAX(-9.0f, last_energy[ch][i]);
675  float diff = block->energy[i] - prev[ch] - last*alpha;
676  int q_en = lrintf(diff);
677  if (left >= 15) {
678  ff_opus_rc_enc_laplace(rc, &q_en, pmod[i << 1] << 7, pmod[(i << 1) + 1] << 6);
679  } else if (left >= 2) {
680  q_en = av_clip(q_en, -1, 1);
681  ff_opus_rc_enc_cdf(rc, 2*q_en + 3*(q_en < 0), ff_celt_model_energy_small);
682  } else if (left >= 1) {
683  q_en = av_clip(q_en, -1, 0);
684  ff_opus_rc_enc_log(rc, (q_en & 1), 1);
685  } else q_en = -1;
686 
687  block->error_energy[i] = q_en - diff;
688  prev[ch] += beta * q_en;
689  }
690  }
691 }
692 
694  float last_energy[][CELT_MAX_BANDS])
695 {
696  uint32_t inter, intra;
698 
699  exp_quant_coarse(rc, f, last_energy, 1);
700  intra = OPUS_RC_CHECKPOINT_BITS(rc);
701 
703 
704  exp_quant_coarse(rc, f, last_energy, 0);
705  inter = OPUS_RC_CHECKPOINT_BITS(rc);
706 
707  if (inter > intra) { /* Unlikely */
709  exp_quant_coarse(rc, f, last_energy, 1);
710  }
711 }
712 
714 {
715  int i, ch;
716  for (i = f->start_band; i < f->end_band; i++) {
717  if (!f->fine_bits[i])
718  continue;
719  for (ch = 0; ch < f->channels; ch++) {
720  CeltBlock *block = &f->block[ch];
721  int quant, lim = (1 << f->fine_bits[i]);
722  float offset, diff = 0.5f - block->error_energy[i];
723  quant = av_clip(floor(diff*lim), 0, lim - 1);
724  ff_opus_rc_put_raw(rc, quant, f->fine_bits[i]);
725  offset = 0.5f - ((quant + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f);
726  block->error_energy[i] -= offset;
727  }
728  }
729 }
730 
732 {
733  int i, ch, priority;
734  for (priority = 0; priority < 2; priority++) {
735  for (i = f->start_band; i < f->end_band && (f->framebits - opus_rc_tell(rc)) >= f->channels; i++) {
736  if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
737  continue;
738  for (ch = 0; ch < f->channels; ch++) {
739  CeltBlock *block = &f->block[ch];
740  const float err = block->error_energy[i];
741  const float offset = 0.5f * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
742  const int sign = FFABS(err + offset) < FFABS(err - offset);
743  ff_opus_rc_put_raw(rc, sign, 1);
744  block->error_energy[i] -= offset*(1 - 2*sign);
745  }
746  }
747  }
748 }
749 
751 {
752  float lowband_scratch[8 * 22];
753  float norm[2 * 8 * 100];
754 
755  int totalbits = (f->framebits << 3) - f->anticollapse_needed;
756 
757  int update_lowband = 1;
758  int lowband_offset = 0;
759 
760  int i, j;
761 
762  for (i = f->start_band; i < f->end_band; i++) {
763  uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
764  int band_offset = ff_celt_freq_bands[i] << f->size;
765  int band_size = ff_celt_freq_range[i] << f->size;
766  float *X = f->block[0].coeffs + band_offset;
767  float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL;
768 
769  int consumed = opus_rc_tell_frac(rc);
770  float *norm2 = norm + 8 * 100;
771  int effective_lowband = -1;
772  int b = 0;
773 
774  /* Compute how many bits we want to allocate to this band */
775  if (i != f->start_band)
776  f->remaining -= consumed;
777  f->remaining2 = totalbits - consumed - 1;
778  if (i <= f->coded_bands - 1) {
779  int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i);
780  b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14);
781  }
782 
784  (update_lowband || lowband_offset == 0))
785  lowband_offset = i;
786 
787  /* Get a conservative estimate of the collapse_mask's for the bands we're
788  going to be folding from. */
789  if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE ||
790  f->blocks > 1 || f->tf_change[i] < 0)) {
791  int foldstart, foldend;
792 
793  /* This ensures we never repeat spectral content within one band */
794  effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band],
795  ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]);
796  foldstart = lowband_offset;
797  while (ff_celt_freq_bands[--foldstart] > effective_lowband);
798  foldend = lowband_offset - 1;
799  while (ff_celt_freq_bands[++foldend] < effective_lowband + ff_celt_freq_range[i]);
800 
801  cm[0] = cm[1] = 0;
802  for (j = foldstart; j < foldend; j++) {
803  cm[0] |= f->block[0].collapse_masks[j];
804  cm[1] |= f->block[f->channels - 1].collapse_masks[j];
805  }
806  }
807 
808  if (f->dual_stereo && i == f->intensity_stereo) {
809  /* Switch off dual stereo to do intensity */
810  f->dual_stereo = 0;
811  for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++)
812  norm[j] = (norm[j] + norm2[j]) / 2;
813  }
814 
815  if (f->dual_stereo) {
816  cm[0] = f->pvq->encode_band(f->pvq, f, rc, i, X, NULL, band_size, b / 2, f->blocks,
817  effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
818  norm + band_offset, 0, 1.0f, lowband_scratch, cm[0]);
819 
820  cm[1] = f->pvq->encode_band(f->pvq, f, rc, i, Y, NULL, band_size, b / 2, f->blocks,
821  effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL, f->size,
822  norm2 + band_offset, 0, 1.0f, lowband_scratch, cm[1]);
823  } else {
824  cm[0] = f->pvq->encode_band(f->pvq, f, rc, i, X, Y, band_size, b, f->blocks,
825  effective_lowband != -1 ? norm + (effective_lowband << f->size) : NULL, f->size,
826  norm + band_offset, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
827  cm[1] = cm[0];
828  }
829 
830  f->block[0].collapse_masks[i] = (uint8_t)cm[0];
831  f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1];
832  f->remaining += f->pulses[i] + consumed;
833 
834  /* Update the folding position only as long as we have 1 bit/sample depth */
835  update_lowband = (b > band_size << 3);
836  }
837 }
838 
840  CeltFrame *f, int index)
841 {
842  int i, ch;
843 
845 
846  ff_opus_psy_celt_frame_init(&s->psyctx, f, index);
847 
849 
850  if (f->silence) {
851  if (f->framebits >= 16)
852  ff_opus_rc_enc_log(rc, 1, 15); /* Silence (if using explicit singalling) */
853  for (ch = 0; ch < s->channels; ch++)
854  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
855  return;
856  }
857 
858  /* Filters */
860  if (f->pfilter) {
861  ff_opus_rc_enc_log(rc, 0, 15);
862  celt_enc_quant_pfilter(rc, f);
863  }
864 
865  /* Transform */
866  celt_frame_mdct(s, f);
867 
868  /* Need to handle transient/non-transient switches at any point during analysis */
869  while (ff_opus_psy_celt_frame_process(&s->psyctx, f, index))
870  celt_frame_mdct(s, f);
871 
873 
874  /* Silence */
875  ff_opus_rc_enc_log(rc, 0, 15);
876 
877  /* Pitch filter */
878  if (!f->start_band && opus_rc_tell(rc) + 16 <= f->framebits)
879  celt_enc_quant_pfilter(rc, f);
880 
881  /* Transient flag */
882  if (f->size && opus_rc_tell(rc) + 3 <= f->framebits)
883  ff_opus_rc_enc_log(rc, f->transient, 3);
884 
885  /* Main encoding */
887  celt_enc_tf (rc, f);
888  ff_celt_enc_bitalloc(rc, f);
889  celt_quant_fine (rc, f);
890  celt_quant_bands (rc, f);
891 
892  /* Anticollapse bit */
893  if (f->anticollapse_needed)
894  ff_opus_rc_put_raw(rc, f->anticollapse, 1);
895 
896  /* Final per-band energy adjustments from leftover bits */
897  celt_quant_final(s, rc, f);
898 
899  for (ch = 0; ch < f->channels; ch++) {
900  CeltBlock *block = &f->block[ch];
901  for (i = 0; i < CELT_MAX_BANDS; i++)
902  s->last_quantized_energy[ch][i] = block->energy[i] + block->error_energy[i];
903  }
904 }
905 
906 static inline int write_opuslacing(uint8_t *dst, int v)
907 {
908  dst[0] = FFMIN(v - FFALIGN(v - 255, 4), v);
909  dst[1] = v - dst[0] >> 2;
910  return 1 + (v >= 252);
911 }
912 
914 {
915  int i, offset, fsize_needed;
916 
917  /* Write toc */
918  opus_gen_toc(s, avpkt->data, &offset, &fsize_needed);
919 
920  /* Frame sizes if needed */
921  if (fsize_needed) {
922  for (i = 0; i < s->packet.frames - 1; i++) {
923  offset += write_opuslacing(avpkt->data + offset,
924  s->frame[i].framebits >> 3);
925  }
926  }
927 
928  /* Packets */
929  for (i = 0; i < s->packet.frames; i++) {
930  ff_opus_rc_enc_end(&s->rc[i], avpkt->data + offset,
931  s->frame[i].framebits >> 3);
932  offset += s->frame[i].framebits >> 3;
933  }
934 
935  avpkt->size = offset;
936 }
937 
938 /* Used as overlap for the first frame and padding for the last encoded packet */
940 {
941  int i;
942  AVFrame *f = av_frame_alloc();
943  if (!f)
944  return NULL;
945  f->format = s->avctx->sample_fmt;
946  f->nb_samples = s->avctx->frame_size;
948  if (av_frame_get_buffer(f, 4)) {
949  av_frame_free(&f);
950  return NULL;
951  }
952  for (i = 0; i < s->channels; i++) {
953  size_t bps = av_get_bytes_per_sample(f->format);
954  memset(f->extended_data[i], 0, bps*f->nb_samples);
955  }
956  return f;
957 }
958 
959 static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
960  const AVFrame *frame, int *got_packet_ptr)
961 {
962  OpusEncContext *s = avctx->priv_data;
963  int i, ret, frame_size, alloc_size = 0;
964 
965  if (frame) { /* Add new frame to queue */
966  if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
967  return ret;
968  ff_bufqueue_add(avctx, &s->bufqueue, av_frame_clone(frame));
969  } else {
971  if (!s->afq.remaining_samples)
972  return 0; /* We've been flushed and there's nothing left to encode */
973  }
974 
975  /* Run the psychoacoustic system */
976  if (ff_opus_psy_process(&s->psyctx, &s->packet))
977  return 0;
978 
979  frame_size = OPUS_BLOCK_SIZE(s->packet.framesize);
980 
981  if (!frame) {
982  /* This can go negative, that's not a problem, we only pad if positive */
983  int pad_empty = s->packet.frames*(frame_size/s->avctx->frame_size) - s->bufqueue.available + 1;
984  /* Pad with empty 2.5 ms frames to whatever framesize was decided,
985  * this should only happen at the very last flush frame. The frames
986  * allocated here will be freed (because they have no other references)
987  * after they get used by celt_frame_setup_input() */
988  for (i = 0; i < pad_empty; i++) {
989  AVFrame *empty = spawn_empty_frame(s);
990  if (!empty)
991  return AVERROR(ENOMEM);
992  ff_bufqueue_add(avctx, &s->bufqueue, empty);
993  }
994  }
995 
996  for (i = 0; i < s->packet.frames; i++) {
997  celt_encode_frame(s, &s->rc[i], &s->frame[i], i);
998  alloc_size += s->frame[i].framebits >> 3;
999  }
1000 
1001  /* Worst case toc + the frame lengths if needed */
1002  alloc_size += 2 + s->packet.frames*2;
1003 
1004  if ((ret = ff_alloc_packet2(avctx, avpkt, alloc_size, 0)) < 0)
1005  return ret;
1006 
1007  /* Assemble packet */
1008  opus_packet_assembler(s, avpkt);
1009 
1010  /* Update the psychoacoustic system */
1012 
1013  /* Remove samples from queue and skip if needed */
1014  ff_af_queue_remove(&s->afq, s->packet.frames*frame_size, &avpkt->pts, &avpkt->duration);
1015  if (s->packet.frames*frame_size > avpkt->duration) {
1017  if (!side)
1018  return AVERROR(ENOMEM);
1019  AV_WL32(&side[4], s->packet.frames*frame_size - avpkt->duration + 120);
1020  }
1021 
1022  *got_packet_ptr = 1;
1023 
1024  return 0;
1025 }
1026 
1028 {
1029  int i;
1030  OpusEncContext *s = avctx->priv_data;
1031 
1032  for (i = 0; i < CELT_BLOCK_NB; i++)
1033  ff_mdct15_uninit(&s->mdct[i]);
1034 
1035  ff_celt_pvq_uninit(&s->pvq);
1036  av_freep(&s->dsp);
1037  av_freep(&s->frame);
1038  av_freep(&s->rc);
1039  ff_af_queue_close(&s->afq);
1040  ff_opus_psy_end(&s->psyctx);
1042  av_freep(&avctx->extradata);
1043 
1044  return 0;
1045 }
1046 
1048 {
1049  int i, ch, ret, max_frames;
1050  OpusEncContext *s = avctx->priv_data;
1051 
1052  s->avctx = avctx;
1053  s->channels = avctx->channels;
1054 
1055  /* Opus allows us to change the framesize on each packet (and each packet may
1056  * have multiple frames in it) but we can't change the codec's frame size on
1057  * runtime, so fix it to the lowest possible number of samples and use a queue
1058  * to accumulate AVFrames until we have enough to encode whatever the encoder
1059  * decides is the best */
1060  avctx->frame_size = 120;
1061  /* Initial padding will change if SILK is ever supported */
1062  avctx->initial_padding = 120;
1063 
1064  if (!avctx->bit_rate) {
1065  int coupled = ff_opus_default_coupled_streams[s->channels - 1];
1066  avctx->bit_rate = coupled*(96000) + (s->channels - coupled*2)*(48000);
1067  } else if (avctx->bit_rate < 6000 || avctx->bit_rate > 255000 * s->channels) {
1068  int64_t clipped_rate = av_clip(avctx->bit_rate, 6000, 255000 * s->channels);
1069  av_log(avctx, AV_LOG_ERROR, "Unsupported bitrate %"PRId64" kbps, clipping to %"PRId64" kbps\n",
1070  avctx->bit_rate/1000, clipped_rate/1000);
1071  avctx->bit_rate = clipped_rate;
1072  }
1073 
1074  /* Extradata */
1075  avctx->extradata_size = 19;
1077  if (!avctx->extradata)
1078  return AVERROR(ENOMEM);
1079  opus_write_extradata(avctx);
1080 
1081  ff_af_queue_init(avctx, &s->afq);
1082 
1083  if ((ret = ff_celt_pvq_init(&s->pvq)) < 0)
1084  return ret;
1085 
1087  return AVERROR(ENOMEM);
1088 
1089  /* I have no idea why a base scaling factor of 68 works, could be the twiddles */
1090  for (i = 0; i < CELT_BLOCK_NB; i++)
1091  if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
1092  return AVERROR(ENOMEM);
1093 
1094  /* Zero out previous energy (matters for inter first frame) */
1095  for (ch = 0; ch < s->channels; ch++)
1096  memset(s->last_quantized_energy[ch], 0.0f, sizeof(float)*CELT_MAX_BANDS);
1097 
1098  /* Allocate an empty frame to use as overlap for the first frame of audio */
1099  ff_bufqueue_add(avctx, &s->bufqueue, spawn_empty_frame(s));
1100  if (!ff_bufqueue_peek(&s->bufqueue, 0))
1101  return AVERROR(ENOMEM);
1102 
1103  if ((ret = ff_opus_psy_init(&s->psyctx, s->avctx, &s->bufqueue, &s->options)))
1104  return ret;
1105 
1106  /* Frame structs and range coder buffers */
1107  max_frames = ceilf(FFMIN(s->options.max_delay_ms, 120.0f)/2.5f);
1108  s->frame = av_malloc(max_frames*sizeof(CeltFrame));
1109  if (!s->frame)
1110  return AVERROR(ENOMEM);
1111  s->rc = av_malloc(max_frames*sizeof(OpusRangeCoder));
1112  if (!s->rc)
1113  return AVERROR(ENOMEM);
1114 
1115  for (i = 0; i < max_frames; i++) {
1116  s->frame[i].dsp = s->dsp;
1117  s->frame[i].avctx = s->avctx;
1118  s->frame[i].seed = 0;
1119  s->frame[i].pvq = s->pvq;
1120  s->frame[i].block[0].emph_coeff = s->frame[i].block[1].emph_coeff = 0.0f;
1121  }
1122 
1123  return 0;
1124 }
1125 
1126 #define OPUSENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1127 static const AVOption opusenc_options[] = {
1128  { "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, "max_delay_ms" },
1129  { NULL },
1130 };
1131 
1132 static const AVClass opusenc_class = {
1133  .class_name = "Opus encoder",
1134  .item_name = av_default_item_name,
1135  .option = opusenc_options,
1136  .version = LIBAVUTIL_VERSION_INT,
1137 };
1138 
1140  { "b", "0" },
1141  { "compression_level", "10" },
1142  { NULL },
1143 };
1144 
1146  .name = "opus",
1147  .long_name = NULL_IF_CONFIG_SMALL("Opus"),
1148  .type = AVMEDIA_TYPE_AUDIO,
1149  .id = AV_CODEC_ID_OPUS,
1150  .defaults = opusenc_defaults,
1151  .priv_class = &opusenc_class,
1152  .priv_data_size = sizeof(OpusEncContext),
1154  .encode2 = opus_encode_frame,
1155  .close = opus_encode_end,
1158  .supported_samplerates = (const int []){ 48000, 0 },
1159  .channel_layouts = (const uint64_t []){ AV_CH_LAYOUT_MONO,
1160  AV_CH_LAYOUT_STEREO, 0 },
1161  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_FLTP,
1163 };
int channels
Definition: opus_celt.h:99
float max_delay_ms
Definition: opusenc.h:44
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
static AVFrame * ff_bufqueue_get(struct FFBufQueue *queue)
Get the first buffer from the queue and remove it.
Definition: bufferqueue.h:98
void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:204
float, planar
Definition: samplefmt.h:69
void ff_af_queue_remove(AudioFrameQueue *afq, int nb_samples, int64_t *pts, int64_t *duration)
Remove frame(s) from the queue.
#define NULL
Definition: coverity.c:32
int anticollapse
Definition: opus_celt.h:116
static av_cold int opus_encode_init(AVCodecContext *avctx)
Definition: opusenc.c:1047
enum OpusBandwidth bandwidth
Definition: opusenc.h:49
const char * s
Definition: avisynth_c.h:768
#define OPUS_RC_CHECKPOINT_SPAWN(rc)
Definition: opus_rc.h:116
CeltFrame * frame
Definition: opusenc.c:51
static void celt_quant_bands(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:750
static float alpha(float a)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
static const AVCodecDefault opusenc_defaults[]
Definition: opusenc.c:1139
AVOption.
Definition: opt.h:246
int framebits
Definition: opus_celt.h:130
static const AVOption opusenc_options[]
Definition: opusenc.c:1127
const uint8_t ff_celt_coarse_energy_dist[4][2][42]
Definition: opustab.c:803
static AVFrame * spawn_empty_frame(OpusEncContext *s)
Definition: opusenc.c:939
const uint8_t ff_celt_log_freq_range[]
Definition: opustab.c:771
void ff_opus_rc_enc_init(OpusRangeCoder *rc)
Definition: opus_rc.c:402
int remaining2
Definition: opus_celt.h:132
float coeffs[CELT_MAX_FRAME_SIZE]
Definition: opus_celt.h:75
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1826
#define LIBAVUTIL_VERSION_INT
Definition: version.h:86
static void opus_packet_assembler(OpusEncContext *s, AVPacket *avpkt)
Definition: opusenc.c:913
else temp
Definition: vf_mcdeint.c:256
static float win(SuperEqualizerContext *s, float n, int N)
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const uint8_t ff_celt_freq_bands[]
Definition: opustab.c:763
int size
Definition: avcodec.h:1680
const char * b
Definition: vf_curves.c:113
static void celt_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS])
Definition: opusenc.c:693
float pf_gains_new[3]
Definition: opus_celt.h:83
static av_cold int opus_encode_end(AVCodecContext *avctx)
Definition: opusenc.c:1027
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:1057
void ff_opus_rc_enc_log(OpusRangeCoder *rc, int val, uint32_t bits)
Definition: opus_rc.c:131
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:154
const float ff_celt_postfilter_taps[3][3]
Definition: opustab.c:1093
#define AV_CH_LAYOUT_STEREO
#define sample
AVCodec.
Definition: avcodec.h:3739
int pf_period
Definition: opus_celt.h:125
void ff_celt_enc_bitalloc(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:285
void ff_opus_rc_enc_uint(OpusRangeCoder *rc, uint32_t val, uint32_t size)
CELT: write a uniformly distributed integer.
Definition: opus_rc.c:204
int pf_period_new
Definition: opus_celt.h:82
Structure holding the queue.
Definition: bufferqueue.h:49
#define OPUSENC_FLAGS
Definition: opusenc.c:1126
static int16_t block[64]
Definition: dct.c:115
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:72
#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: avcodec.h:1027
int fine_priority[CELT_MAX_BANDS]
Definition: opus_celt.h:135
CeltBlock block[2]
Definition: opus_celt.h:97
static void exp_quant_coarse(OpusRangeCoder *rc, CeltFrame *f, float last_energy[][CELT_MAX_BANDS], int intra)
Definition: opusenc.c:649
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
CeltPVQ * pvq
Definition: opusenc.c:41
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
uint8_t bits
Definition: crc.c:296
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2531
uint8_t
#define av_cold
Definition: attributes.h:82
AVCodec ff_opus_encoder
Definition: opusenc.c:1145
#define CELT_OVERLAP
Definition: opus.h:42
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
const float * ff_celt_window
Definition: opustab.c:1130
int silence
Definition: opus_celt.h:114
AVOptions.
#define Y
Definition: vf_boxblur.c:76
av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
Initialize AudioFrameQueue.
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1697
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(constuint8_t *) pi-0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(constint16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(constint32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(constint64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64,*(constint64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(constfloat *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(constdouble *) pi *(INT64_C(1)<< 63)))#defineFMT_PAIR_FUNC(out, in) staticconv_func_type *constfmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64),};staticvoidcpy1(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, len);}staticvoidcpy2(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 2 *len);}staticvoidcpy4(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 4 *len);}staticvoidcpy8(uint8_t **dst, constuint8_t **src, intlen){memcpy(*dst,*src, 8 *len);}AudioConvert *swri_audio_convert_alloc(enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, constint *ch_map, intflags){AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) returnNULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) returnNULL;if(channels==1){in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);}ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map){switch(av_get_bytes_per_sample(in_fmt)){case1:ctx->simd_f=cpy1;break;case2:ctx->simd_f=cpy2;break;case4:ctx->simd_f=cpy4;break;case8:ctx->simd_f=cpy8;break;}}if(HAVE_X86ASM &&1) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);returnctx;}voidswri_audio_convert_free(AudioConvert **ctx){av_freep(ctx);}intswri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, intlen){intch;intoff=0;constintos=(out->planar?1:out->ch_count)*out->bps;unsignedmisaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask){intplanes=in->planar?in->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;}if(ctx->out_simd_align_mask){intplanes=out->planar?out->ch_count:1;unsignedm=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;}if(ctx->simd_f &&!ctx->ch_map &&!misaligned){off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){if(out->planar==in->planar){intplanes=out->planar?out->ch_count:1;for(ch=0;ch< planes;ch++){ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
#define OPUS_MAX_LOOKAHEAD
Definition: opusenc.h:32
AudioFrameQueue afq
Definition: opusenc.c:38
#define CELT_VECTORS
Definition: opus_celt.h:36
QUANT_FN * encode_band
Definition: opus_pvq.h:42
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1876
int av_cold ff_celt_pvq_init(CeltPVQ **pvq)
Definition: opus_pvq.c:940
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
Definition: opusenc_psy.c:173
int64_t duration
Definition: movenc.c:63
av_cold int ff_mdct15_init(MDCT15Context **ps, int inverse, int N, double scale)
Definition: mdct15.c:247
#define CELT_POSTFILTER_MINPERIOD
Definition: opus_celt.h:44
#define N
Definition: vf_pp7.c:73
static AVFrame * frame
static void celt_enc_tf(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:258
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:104
uint8_t * data
Definition: avcodec.h:1679
int dual_stereo
Definition: opus_celt.h:118
static const uint8_t bits2[81]
Definition: aactab.c:140
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:400
enum OpusMode mode
Definition: opusenc.h:48
#define lrintf(x)
Definition: libm_mips.h:70
ptrdiff_t size
Definition: opengl_enc.c:101
int coded_bands
Definition: opus_celt.h:105
float lin_energy[CELT_MAX_BANDS]
Definition: opus_celt.h:67
int skip_band_floor
Definition: opus_celt.h:108
const OptionDef options[]
Definition: ffserver.c:3948
#define FFALIGN(x, a)
Definition: macros.h:48
static int opus_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: opusenc.c:959
#define av_log(a,...)
#define cm
Definition: dvbsubdec.c:37
int end_band
Definition: opus_celt.h:104
float samples[FFALIGN(CELT_MAX_FRAME_SIZE, 16)]
Definition: opus_celt.h:79
const uint8_t ff_celt_log2_frac[]
Definition: opustab.c:925
int alloc_boost[CELT_MAX_BANDS]
Definition: opus_celt.h:111
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:127
void(* vector_fmul)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats and store the result in a vector of floats...
Definition: float_dsp.h:38
av_default_item_name
#define OPUS_BLOCK_SIZE(x)
Definition: opusenc.h:39
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
int start_band
Definition: opus_celt.h:103
#define CELT_EMPH_COEFF
Definition: opus_celt.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:179
OpusEncOptions options
Definition: opusenc.c:35
int initial_padding
Audio only.
Definition: avcodec.h:3451
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
Definition: opus_rc.h:123
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1856
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
Definition: opusenc_psy.c:461
int tf_change[CELT_MAX_BANDS]
Definition: opus_celt.h:137
const char * name
Name of the codec implementation.
Definition: avcodec.h:3746
float emph_coeff
Definition: opus_celt.h:89
int pulses[CELT_MAX_BANDS]
Definition: opus_celt.h:136
static int opus_gen_toc(OpusEncContext *s, uint8_t *toc, int *size, int *fsize_needed)
Definition: opusenc.c:73
int pfilter
Definition: opus_celt.h:107
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
int ff_af_queue_add(AudioFrameQueue *afq, const AVFrame *f)
Add a frame to the queue.
#define FFMAX(a, b)
Definition: common.h:94
static void celt_frame_mdct(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:192
int anticollapse_needed
Definition: opus_celt.h:115
int fine_bits[CELT_MAX_BANDS]
Definition: opus_celt.h:134
float pf_gain
Definition: opus_celt.h:127
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2574
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:379
AVCodecContext * avctx
Definition: opus_celt.h:94
uint32_t seed
Definition: opus_celt.h:120
int caps[CELT_MAX_BANDS]
Definition: opus_celt.h:133
const int8_t ff_celt_tf_select[4][2][2][2]
Definition: opustab.c:777
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:929
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1032
int enc_id_bits
Definition: opusenc.c:45
uint8_t enc_id[64]
Definition: opusenc.c:44
#define FFMIN(a, b)
Definition: common.h:96
#define OPUS_RC_CHECKPOINT_BITS(rc)
Definition: opus_rc.h:120
MDCT15Context * mdct[CELT_BLOCK_NB]
Definition: opusenc.c:40
static void celt_frame_setup_input(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:116
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int blocks
Definition: opus_celt.h:112
int transient
Definition: opus_celt.h:106
#define CELT_FINE_OFFSET
Definition: opus_celt.h:38
float error_energy[CELT_MAX_BANDS]
Definition: opus_celt.h:68
static void ff_bufqueue_discard_all(struct FFBufQueue *queue)
Unref and remove all buffers from the queue.
Definition: bufferqueue.h:111
const uint8_t ff_celt_freq_range[]
Definition: opustab.c:767
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:492
const uint8_t ff_opus_default_coupled_streams[]
Definition: opustab.c:25
void ff_opus_rc_enc_cdf(OpusRangeCoder *rc, int val, const uint16_t *cdf)
Definition: opus_rc.c:109
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
AVCodecContext * avctx
Definition: opusenc.c:37
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2543
const uint8_t ff_celt_static_caps[4][2][21]
Definition: opustab.c:861
struct FFBufQueue bufqueue
Definition: opusenc.c:42
#define src1
Definition: h264pred.c:139
int frame_size
Definition: mxfenc.c:1896
static void celt_encode_frame(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f, int index)
Definition: opusenc.c:839
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
#define CELT_MAX_BANDS
Definition: opus.h:45
unsigned short available
number of available buffers
Definition: bufferqueue.h:52
int sample_rate
samples per second
Definition: avcodec.h:2523
int pf_tapset
Definition: opus_celt.h:126
const uint16_t ff_celt_model_spread[]
Definition: opustab.c:755
main external API structure.
Definition: avcodec.h:1761
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: opus_rc.h:61
#define CELT_MAX_FINE_BITS
Definition: opus_celt.h:39
float scratch[2048]
Definition: opusenc.c:57
AVFloatDSPContext * dsp
Definition: opus_celt.h:96
int extradata_size
Definition: avcodec.h:1877
void ff_opus_rc_enc_laplace(OpusRangeCoder *rc, int *value, uint32_t symbol, int decay)
Definition: opus_rc.c:314
static int write_opuslacing(uint8_t *dst, int v)
Definition: opusenc.c:906
OpusPsyContext psyctx
Definition: opusenc.c:36
Describe the class of an AVClass context structure.
Definition: log.h:67
void ff_opus_psy_signal_eof(OpusPsyContext *s)
Definition: opusenc_psy.c:533
int index
Definition: gxfenc.c:89
const uint8_t ff_celt_static_alloc[11][21]
Definition: opustab.c:847
#define CELT_ENERGY_SILENCE
Definition: opus_celt.h:45
static void opus_write_extradata(AVCodecContext *avctx)
Definition: opusenc.c:60
Recommmends skipping the specified number of samples.
Definition: avcodec.h:1521
av_cold int ff_opus_psy_end(OpusPsyContext *s)
Definition: opusenc_psy.c:538
CeltPVQ * pvq
Definition: opus_celt.h:98
AVClass * av_class
Definition: opusenc.c:34
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
Definition: opusenc_psy.c:424
const uint16_t ff_celt_model_energy_small[]
Definition: opustab.c:761
const uint8_t * quant
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:283
#define OPUS_MAX_CHANNELS
Definition: opusenc.h:34
AVFloatDSPContext * dsp
Definition: opusenc.c:39
int framesize
Definition: opusenc.h:50
const uint16_t ff_celt_model_alloc_trim[]
Definition: opustab.c:757
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
int channels
Definition: opusenc.c:49
int remaining
Definition: opus_celt.h:131
float energy[CELT_MAX_BANDS]
Definition: opus_celt.h:66
OpusPacketInfo packet
Definition: opusenc.c:47
static const AVClass opusenc_class
Definition: opusenc.c:1132
static void celt_quant_final(OpusEncContext *s, OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:731
const float ff_celt_beta_coef[]
Definition: opustab.c:799
void ff_opus_rc_put_raw(OpusRangeCoder *rc, uint32_t val, uint32_t count)
CELT: write 0 - 31 bits to the rawbits buffer.
Definition: opus_rc.c:161
common internal api header.
if(ret< 0)
Definition: vf_mcdeint.c:279
#define log2f(x)
Definition: libm.h:409
static void celt_quant_fine(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:713
void ff_opus_rc_enc_end(OpusRangeCoder *rc, uint8_t *dst, int size)
Definition: opus_rc.c:360
#define CELT_ALLOC_STEPS
Definition: opus_celt.h:37
unsigned bps
Definition: movenc.c:1410
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:368
enum CeltSpread spread
Definition: opus_celt.h:121
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:777
av_cold void ff_mdct15_uninit(MDCT15Context **ps)
Definition: mdct15.c:43
void * priv_data
Definition: avcodec.h:1803
float last_quantized_energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc.c:55
int tf_select
Definition: opus_celt.h:109
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static const int16_t coeffs[]
int len
int channels
number of audio channels
Definition: avcodec.h:2524
const float ff_celt_alpha_coef[]
Definition: opustab.c:795
void ff_af_queue_close(AudioFrameQueue *afq)
Close AudioFrameQueue.
const float ff_celt_mean_energy[]
Definition: opustab.c:787
static void celt_enc_quant_pfilter(OpusRangeCoder *rc, CeltFrame *f)
Definition: opusenc.c:612
OpusRangeCoder * rc
Definition: opusenc.c:52
#define av_freep(p)
static void ff_bufqueue_add(void *log, struct FFBufQueue *queue, AVFrame *buf)
Add a buffer to the queue.
Definition: bufferqueue.h:71
enum CeltBlockSize size
Definition: opus_celt.h:102
int alloc_trim
Definition: opus_celt.h:110
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:248
#define AV_CH_LAYOUT_MONO
void(* mdct)(struct MDCT15Context *s, float *dst, const float *src, ptrdiff_t stride)
Definition: mdct15.h:49
uint8_t collapse_masks[CELT_MAX_BANDS]
Definition: opus_celt.h:71
This structure stores compressed data.
Definition: avcodec.h:1656
const uint16_t ff_celt_model_tapset[]
Definition: opustab.c:753
static void celt_apply_preemph_filter(OpusEncContext *s, CeltFrame *f)
Definition: opusenc.c:157
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:267
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1672
for(j=16;j >0;--j)
int pf_octave
Definition: opus_celt.h:124
float overlap[FFALIGN(CELT_OVERLAP, 16)]
Definition: opus_celt.h:78
void av_cold ff_celt_pvq_uninit(CeltPVQ **pvq)
Definition: opus_pvq.c:959
int intensity_stereo
Definition: opus_celt.h:117
static const uint8_t bits1[81]
Definition: aactab.c:117
#define AV_WL32(p, v)
Definition: intreadwrite.h:431
static av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)
Definition: opus_rc.h:66
static AVFrame * ff_bufqueue_peek(struct FFBufQueue *queue, unsigned index)
Get a buffer from the queue without altering it.
Definition: bufferqueue.h:87
static uint8_t tmp[11]
Definition: aes_ctr.c:26