FFmpeg
opusenc_psy.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 <float.h>
23 
24 #include "libavutil/mem.h"
25 #include "opusenc_psy.h"
26 #include "opus_celt.h"
27 #include "opus_pvq.h"
28 #include "opustab.h"
30 
31 static float pvq_band_cost(CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc, int band,
32  float *bits, float lambda)
33 {
34  int i, b = 0;
35  uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
36  const int band_size = ff_celt_freq_range[band] << f->size;
37  float buf[176 * 2], lowband_scratch[176], norm1[176], norm2[176];
38  float dist, cost, err_x = 0.0f, err_y = 0.0f;
39  float *X = buf;
40  float *X_orig = f->block[0].coeffs + (ff_celt_freq_bands[band] << f->size);
41  float *Y = (f->channels == 2) ? &buf[176] : NULL;
42  float *Y_orig = f->block[1].coeffs + (ff_celt_freq_bands[band] << f->size);
44 
45  memcpy(X, X_orig, band_size*sizeof(float));
46  if (Y)
47  memcpy(Y, Y_orig, band_size*sizeof(float));
48 
49  f->remaining2 = ((f->framebits << 3) - f->anticollapse_needed) - opus_rc_tell_frac(rc) - 1;
50  if (band <= f->coded_bands - 1) {
51  int curr_balance = f->remaining / FFMIN(3, f->coded_bands - band);
52  b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[band] + curr_balance), 14);
53  }
54 
55  if (f->dual_stereo) {
56  pvq->quant_band(pvq, f, rc, band, X, NULL, band_size, b / 2, f->blocks, NULL,
57  f->size, norm1, 0, 1.0f, lowband_scratch, cm[0]);
58 
59  pvq->quant_band(pvq, f, rc, band, Y, NULL, band_size, b / 2, f->blocks, NULL,
60  f->size, norm2, 0, 1.0f, lowband_scratch, cm[1]);
61  } else {
62  pvq->quant_band(pvq, f, rc, band, X, Y, band_size, b, f->blocks, NULL, f->size,
63  norm1, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
64  }
65 
66  for (i = 0; i < band_size; i++) {
67  err_x += (X[i] - X_orig[i])*(X[i] - X_orig[i]);
68  if (Y)
69  err_y += (Y[i] - Y_orig[i])*(Y[i] - Y_orig[i]);
70  }
71 
72  dist = sqrtf(err_x) + sqrtf(err_y);
73  cost = OPUS_RC_CHECKPOINT_BITS(rc)/8.0f;
74  *bits += cost;
75 
77 
78  return lambda*dist*cost;
79 }
80 
81 /* Populate metrics without taking into consideration neighbouring steps */
83 {
84  int silence = 0, ch, i, j;
85  OpusPsyStep *st = s->steps[index];
86 
87  st->index = index;
88 
89  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
90  const int lap_size = (1 << s->bsize_analysis);
91  for (i = 1; i <= FFMIN(lap_size, index); i++) {
92  const int offset = i*120;
93  AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index - i);
94  memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
95  }
96  for (i = 0; i < lap_size; i++) {
97  const int offset = i*120 + lap_size;
98  AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index + i);
99  memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
100  }
101 
102  s->dsp->vector_fmul(s->scratch, s->scratch, s->window[s->bsize_analysis],
103  (OPUS_BLOCK_SIZE(s->bsize_analysis) << 1));
104 
105  s->mdct_fn[s->bsize_analysis](s->mdct[s->bsize_analysis], st->coeffs[ch],
106  s->scratch, sizeof(float));
107 
108  for (i = 0; i < CELT_MAX_BANDS; i++)
109  st->bands[ch][i] = &st->coeffs[ch][ff_celt_freq_bands[i] << s->bsize_analysis];
110  }
111 
112  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
113  for (i = 0; i < CELT_MAX_BANDS; i++) {
114  float avg_c_s, energy = 0.0f, dist_dev = 0.0f;
115  const int range = ff_celt_freq_range[i] << s->bsize_analysis;
116  const float *coeffs = st->bands[ch][i];
117  for (j = 0; j < range; j++)
118  energy += coeffs[j]*coeffs[j];
119 
120  st->energy[ch][i] += sqrtf(energy);
121  silence |= !!st->energy[ch][i];
122  avg_c_s = energy / range;
123 
124  for (j = 0; j < range; j++) {
125  const float c_s = coeffs[j]*coeffs[j];
126  dist_dev += (avg_c_s - c_s)*(avg_c_s - c_s);
127  }
128 
129  st->tone[ch][i] += sqrtf(dist_dev);
130  }
131  }
132 
133  st->silence = !silence;
134 
135  if (s->avctx->ch_layout.nb_channels > 1) {
136  for (i = 0; i < CELT_MAX_BANDS; i++) {
137  float incompat = 0.0f;
138  const float *coeffs1 = st->bands[0][i];
139  const float *coeffs2 = st->bands[1][i];
140  const int range = ff_celt_freq_range[i] << s->bsize_analysis;
141  for (j = 0; j < range; j++)
142  incompat += (coeffs1[j] - coeffs2[j])*(coeffs1[j] - coeffs2[j]);
143  st->stereo[i] = sqrtf(incompat);
144  }
145  }
146 
147  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
148  for (i = 0; i < CELT_MAX_BANDS; i++) {
149  OpusBandExcitation *ex = &s->ex[ch][i];
150  float bp_e = bessel_filter(&s->bfilter_lo[ch][i], st->energy[ch][i]);
151  bp_e = bessel_filter(&s->bfilter_hi[ch][i], bp_e);
152  bp_e *= bp_e;
153  if (bp_e > ex->excitation) {
154  st->change_amp[ch][i] = bp_e - ex->excitation;
155  st->total_change += st->change_amp[ch][i];
156  ex->excitation = ex->excitation_init = bp_e;
157  ex->excitation_dist = 0.0f;
158  }
159  if (ex->excitation > 0.0f) {
160  ex->excitation -= av_clipf((1/expf(ex->excitation_dist)), ex->excitation_init/20, ex->excitation_init/1.09);
161  ex->excitation = FFMAX(ex->excitation, 0.0f);
162  ex->excitation_dist += 1.0f;
163  }
164  }
165  }
166 }
167 
168 static void search_for_change_points(OpusPsyContext *s, float tgt_change,
169  int offset_s, int offset_e, int resolution,
170  int level)
171 {
172  int i;
173  float c_change = 0.0f;
174  if ((offset_e - offset_s) <= resolution)
175  return;
176  for (i = offset_s; i < offset_e; i++) {
177  c_change += s->steps[i]->total_change;
178  if (c_change > tgt_change)
179  break;
180  }
181  if (i == offset_e)
182  return;
183  search_for_change_points(s, tgt_change / 2.0f, offset_s, i + 0, resolution, level + 1);
184  s->inflection_points[s->inflection_points_count++] = i;
185  search_for_change_points(s, tgt_change / 2.0f, i + 1, offset_e, resolution, level + 1);
186 }
187 
189 {
190  int fsize, silent_frames;
191 
192  for (silent_frames = 0; silent_frames < s->buffered_steps; silent_frames++)
193  if (!s->steps[silent_frames]->silence)
194  break;
195  if (--silent_frames < 0)
196  return 0;
197 
199  if ((1 << fsize) > silent_frames)
200  continue;
201  s->p.frames = FFMIN(silent_frames / (1 << fsize), 48 >> fsize);
202  s->p.framesize = fsize;
203  return 1;
204  }
205 
206  return 0;
207 }
208 
209 /* Main function which decides frame size and frames per current packet */
211 {
212  int max_delay_samples = (s->options->max_delay_ms*s->avctx->sample_rate)/1000;
213  int max_bsize = FFMIN(OPUS_SAMPLES_TO_BLOCK_SIZE(max_delay_samples), CELT_BLOCK_960);
214 
215  /* These don't change for now */
216  s->p.mode = OPUS_MODE_CELT;
217  s->p.bandwidth = OPUS_BANDWIDTH_FULLBAND;
218 
219  /* Flush silent frames ASAP */
220  if (s->steps[0]->silence && flush_silent_frames(s))
221  return;
222 
223  s->p.framesize = FFMIN(max_bsize, CELT_BLOCK_960);
224  s->p.frames = 1;
225 }
226 
228 {
229  int i;
230  float total_energy_change = 0.0f;
231 
232  if (s->buffered_steps < s->max_steps && !s->eof) {
233  const int awin = (1 << s->bsize_analysis);
234  if (++s->steps_to_process >= awin) {
235  step_collect_psy_metrics(s, s->buffered_steps - awin + 1);
236  s->steps_to_process = 0;
237  }
238  if ((++s->buffered_steps) < s->max_steps)
239  return 1;
240  }
241 
242  for (i = 0; i < s->buffered_steps; i++)
243  total_energy_change += s->steps[i]->total_change;
244 
245  search_for_change_points(s, total_energy_change / 2.0f, 0,
246  s->buffered_steps, 1, 0);
247 
249 
250  p->frames = s->p.frames;
251  p->framesize = s->p.framesize;
252  p->mode = s->p.mode;
253  p->bandwidth = s->p.bandwidth;
254 
255  return 0;
256 }
257 
259 {
260  int i, neighbouring_points = 0, start_offset = 0;
261  int radius = (1 << s->p.framesize), step_offset = radius*index;
262  int silence = 1;
263 
264  f->start_band = (s->p.mode == OPUS_MODE_HYBRID) ? 17 : 0;
265  f->end_band = ff_celt_band_end[s->p.bandwidth];
266  f->channels = s->avctx->ch_layout.nb_channels;
267  f->size = s->p.framesize;
268 
269  for (i = 0; i < (1 << f->size); i++)
270  silence &= s->steps[index*(1 << f->size) + i]->silence;
271 
272  f->silence = silence;
273  if (f->silence) {
274  f->framebits = 0; /* Otherwise the silence flag eats up 16(!) bits */
275  return;
276  }
277 
278  for (i = 0; i < s->inflection_points_count; i++) {
279  if (s->inflection_points[i] >= step_offset) {
280  start_offset = i;
281  break;
282  }
283  }
284 
285  for (i = start_offset; i < FFMIN(radius, s->inflection_points_count - start_offset); i++) {
286  if (s->inflection_points[i] < (step_offset + radius)) {
287  neighbouring_points++;
288  }
289  }
290 
291  /* Transient flagging */
292  f->transient = neighbouring_points > 0;
293  f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
294 
295  /* Some sane defaults */
296  f->pfilter = 0;
297  f->pf_gain = 0.5f;
298  f->pf_octave = 2;
299  f->pf_period = 1;
300  f->pf_tapset = 2;
301 
302  /* More sane defaults */
303  f->tf_select = 0;
304  f->anticollapse = 1;
305  f->alloc_trim = 5;
306  f->skip_band_floor = f->end_band;
307  f->intensity_stereo = f->end_band;
308  f->dual_stereo = 0;
309  f->spread = CELT_SPREAD_NORMAL;
310  memset(f->tf_change, 0, sizeof(int)*CELT_MAX_BANDS);
311  memset(f->alloc_boost, 0, sizeof(int)*CELT_MAX_BANDS);
312 }
313 
315  CeltFrame *f_out)
316 {
317  int i, f, ch;
318  int frame_size = OPUS_BLOCK_SIZE(s->p.framesize);
319  float rate, frame_bits = 0;
320 
321  /* Used for the global ROTATE flag */
322  float tonal = 0.0f;
323 
324  /* Pseudo-weights */
325  float band_score[CELT_MAX_BANDS] = { 0 };
326  float max_score = 1.0f;
327 
328  /* Pass one - one loop around each band, computing unquant stuff */
329  for (i = 0; i < CELT_MAX_BANDS; i++) {
330  float weight = 0.0f;
331  float tonal_contrib = 0.0f;
332  for (f = 0; f < (1 << s->p.framesize); f++) {
333  weight = start[f]->stereo[i];
334  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
335  weight += start[f]->change_amp[ch][i] + start[f]->tone[ch][i] + start[f]->energy[ch][i];
336  tonal_contrib += start[f]->tone[ch][i];
337  }
338  }
339  tonal += tonal_contrib;
340  band_score[i] = weight;
341  }
342 
343  tonal /= (float)CELT_MAX_BANDS;
344 
345  for (i = 0; i < CELT_MAX_BANDS; i++) {
346  if (band_score[i] > max_score)
347  max_score = band_score[i];
348  }
349 
350  for (i = 0; i < CELT_MAX_BANDS; i++) {
351  f_out->alloc_boost[i] = (int)((band_score[i]/max_score)*3.0f);
352  frame_bits += band_score[i]*8.0f;
353  }
354 
355  tonal /= 1333136.0f;
356  f_out->spread = av_clip_uintp2(lrintf(tonal), 2);
357 
358  rate = ((float)s->avctx->bit_rate) + frame_bits*frame_size*16;
359  rate *= s->lambda;
360  rate /= s->avctx->sample_rate/frame_size;
361 
362  f_out->framebits = lrintf(rate);
363  f_out->framebits = FFMIN(f_out->framebits, OPUS_MAX_FRAME_SIZE * 8);
364  f_out->framebits = FFALIGN(f_out->framebits, 8);
365 }
366 
367 static int bands_dist(OpusPsyContext *s, CeltFrame *f, float *total_dist)
368 {
369  int i, tdist = 0.0f;
370  OpusRangeCoder dump;
371 
372  ff_opus_rc_enc_init(&dump);
373  ff_celt_bitalloc(f, &dump, 1);
374 
375  for (i = 0; i < CELT_MAX_BANDS; i++) {
376  float bits = 0.0f;
377  float dist = pvq_band_cost(f->pvq, f, &dump, i, &bits, s->lambda);
378  tdist += dist;
379  }
380 
381  *total_dist = tdist;
382 
383  return 0;
384 }
385 
387 {
388  float td1, td2;
389  f->dual_stereo = 0;
390 
391  if (s->avctx->ch_layout.nb_channels < 2)
392  return;
393 
394  bands_dist(s, f, &td1);
395  f->dual_stereo = 1;
396  bands_dist(s, f, &td2);
397 
398  f->dual_stereo = td2 < td1;
399  s->dual_stereo_used += td2 < td1;
400 }
401 
403 {
404  int i, best_band = CELT_MAX_BANDS - 1;
405  float dist, best_dist = FLT_MAX;
406  /* TODO: fix, make some heuristic up here using the lambda value */
407  float end_band = 0;
408 
409  if (s->avctx->ch_layout.nb_channels < 2)
410  return;
411 
412  for (i = f->end_band; i >= end_band; i--) {
413  f->intensity_stereo = i;
414  bands_dist(s, f, &dist);
415  if (best_dist > dist) {
416  best_dist = dist;
417  best_band = i;
418  }
419  }
420 
421  f->intensity_stereo = best_band;
422  s->avg_is_band = (s->avg_is_band + f->intensity_stereo)/2.0f;
423 }
424 
426 {
427  int i, j, k, cway, config[2][CELT_MAX_BANDS] = { { 0 } };
428  float score[2] = { 0 };
429 
430  for (cway = 0; cway < 2; cway++) {
431  int mag[2];
432  int base = f->transient ? 120 : 960;
433 
434  for (i = 0; i < 2; i++) {
435  int c = ff_celt_tf_select[f->size][f->transient][cway][i];
436  mag[i] = c < 0 ? base >> FFABS(c) : base << FFABS(c);
437  }
438 
439  for (i = 0; i < CELT_MAX_BANDS; i++) {
440  float iscore0 = 0.0f;
441  float iscore1 = 0.0f;
442  for (j = 0; j < (1 << f->size); j++) {
443  for (k = 0; k < s->avctx->ch_layout.nb_channels; k++) {
444  iscore0 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[0];
445  iscore1 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[1];
446  }
447  }
448  config[cway][i] = FFABS(iscore0 - 1.0f) < FFABS(iscore1 - 1.0f);
449  score[cway] += config[cway][i] ? iscore1 : iscore0;
450  }
451  }
452 
453  f->tf_select = score[0] < score[1];
454  memcpy(f->tf_change, config[f->tf_select], sizeof(int)*CELT_MAX_BANDS);
455 
456  return 0;
457 }
458 
460 {
461  int start_transient_flag = f->transient;
462  OpusPsyStep **start = &s->steps[index * (1 << s->p.framesize)];
463 
464  if (f->silence)
465  return 0;
466 
467  celt_gauge_psy_weight(s, start, f);
470  celt_search_for_tf(s, start, f);
471 
472  if (f->transient != start_transient_flag) {
473  f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
474  return 1;
475  }
476 
477  return 0;
478 }
479 
481 {
482  int i, frame_size = OPUS_BLOCK_SIZE(s->p.framesize);
483  int steps_out = s->p.frames*(frame_size/120);
484  void *tmp[FF_BUFQUEUE_SIZE];
485  float ideal_fbits;
486 
487  for (i = 0; i < steps_out; i++)
488  memset(s->steps[i], 0, sizeof(OpusPsyStep));
489 
490  for (i = 0; i < s->max_steps; i++)
491  tmp[i] = s->steps[i];
492 
493  for (i = 0; i < s->max_steps; i++) {
494  const int i_new = i - steps_out;
495  s->steps[i_new < 0 ? s->max_steps + i_new : i_new] = tmp[i];
496  }
497 
498  for (i = steps_out; i < s->buffered_steps; i++)
499  s->steps[i]->index -= steps_out;
500 
501  ideal_fbits = s->avctx->bit_rate/(s->avctx->sample_rate/frame_size);
502 
503  for (i = 0; i < s->p.frames; i++) {
504  s->avg_is_band += f[i].intensity_stereo;
505  s->lambda *= ideal_fbits / f[i].framebits;
506  }
507 
508  s->avg_is_band /= (s->p.frames + 1);
509 
510  s->steps_to_process = 0;
511  s->buffered_steps -= steps_out;
512  s->total_packets_out += s->p.frames;
513  s->inflection_points_count = 0;
514 }
515 
517  struct FFBufQueue *bufqueue, OpusEncOptions *options)
518 {
519  int i, ch, ret;
520 
521  s->lambda = 1.0f;
522  s->options = options;
523  s->avctx = avctx;
524  s->bufqueue = bufqueue;
525  s->max_steps = ceilf(s->options->max_delay_ms/2.5f);
526  s->bsize_analysis = CELT_BLOCK_960;
527  s->avg_is_band = CELT_MAX_BANDS - 1;
528  s->inflection_points_count = 0;
529 
530  s->inflection_points = av_mallocz(sizeof(*s->inflection_points)*s->max_steps);
531  if (!s->inflection_points) {
532  ret = AVERROR(ENOMEM);
533  goto fail;
534  }
535 
537  if (!s->dsp) {
538  ret = AVERROR(ENOMEM);
539  goto fail;
540  }
541 
542  for (ch = 0; ch < s->avctx->ch_layout.nb_channels; ch++) {
543  for (i = 0; i < CELT_MAX_BANDS; i++) {
544  bessel_init(&s->bfilter_hi[ch][i], 1.0f, 19.0f, 100.0f, 1);
545  bessel_init(&s->bfilter_lo[ch][i], 1.0f, 20.0f, 100.0f, 0);
546  }
547  }
548 
549  for (i = 0; i < s->max_steps; i++) {
550  s->steps[i] = av_mallocz(sizeof(OpusPsyStep));
551  if (!s->steps[i]) {
552  ret = AVERROR(ENOMEM);
553  goto fail;
554  }
555  }
556 
557  for (i = 0; i < CELT_BLOCK_NB; i++) {
558  float tmp;
559  const int len = OPUS_BLOCK_SIZE(i);
560  const float scale = 68 << (CELT_BLOCK_NB - 1 - i);
561  s->window[i] = av_malloc(2*len*sizeof(float));
562  if (!s->window[i]) {
563  ret = AVERROR(ENOMEM);
564  goto fail;
565  }
566  generate_window_func(s->window[i], 2*len, WFUNC_SINE, &tmp);
567  ret = av_tx_init(&s->mdct[i], &s->mdct_fn[i], AV_TX_FLOAT_MDCT,
568  0, 15 << (i + 3), &scale, 0);
569  if (ret < 0)
570  goto fail;
571  }
572 
573  return 0;
574 
575 fail:
576  av_freep(&s->inflection_points);
577  av_freep(&s->dsp);
578 
579  for (i = 0; i < CELT_BLOCK_NB; i++) {
580  av_tx_uninit(&s->mdct[i]);
581  av_freep(&s->window[i]);
582  }
583 
584  for (i = 0; i < s->max_steps; i++)
585  av_freep(&s->steps[i]);
586 
587  return ret;
588 }
589 
591 {
592  s->eof = 1;
593 }
594 
596 {
597  int i;
598 
599  av_freep(&s->inflection_points);
600  av_freep(&s->dsp);
601 
602  for (i = 0; i < CELT_BLOCK_NB; i++) {
603  av_tx_uninit(&s->mdct[i]);
604  av_freep(&s->window[i]);
605  }
606 
607  for (i = 0; i < s->max_steps; i++)
608  av_freep(&s->steps[i]);
609 
610  av_log(s->avctx, AV_LOG_INFO, "Average Intensity Stereo band: %0.1f\n", s->avg_is_band);
611  av_log(s->avctx, AV_LOG_INFO, "Dual Stereo used: %0.2f%%\n", ((float)s->dual_stereo_used/s->total_packets_out)*100.0f);
612 
613  return 0;
614 }
OpusPsyStep::stereo
float stereo[CELT_MAX_BANDS]
Definition: opusenc_psy.h:38
ff_opus_psy_process
int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
Definition: opusenc_psy.c:227
level
uint8_t level
Definition: svq3.c:205
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
ff_celt_freq_bands
const uint8_t ff_celt_freq_bands[]
Definition: opustab.c:768
OpusBandExcitation::excitation
float excitation
Definition: opusenc_psy.h:47
ff_opus_psy_celt_frame_init
void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:258
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:124
OPUS_MAX_FRAME_SIZE
#define OPUS_MAX_FRAME_SIZE
Definition: opus.h:28
celt_search_for_dual_stereo
static void celt_search_for_dual_stereo(OpusPsyContext *s, CeltFrame *f)
Definition: opusenc_psy.c:386
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
OpusBandExcitation::excitation_init
float excitation_init
Definition: opusenc_psy.h:49
FF_BUFQUEUE_SIZE
#define FF_BUFQUEUE_SIZE
Definition: audiotoolboxenc.c:25
CeltFrame::spread
enum CeltSpread spread
Definition: opus_celt.h:129
OpusPacketInfo::frames
int frames
Definition: opusenc.h:52
OpusPacketInfo::bandwidth
enum OpusBandwidth bandwidth
Definition: opusenc.h:50
b
#define b
Definition: input.c:41
OPUS_RC_CHECKPOINT_SPAWN
#define OPUS_RC_CHECKPOINT_SPAWN(rc)
Definition: opus_rc.h:115
expf
#define expf(x)
Definition: libm.h:283
base
uint8_t base
Definition: vp3data.h:128
float.h
OpusPsyStep::silence
int silence
Definition: opusenc_psy.h:35
OPUS_BANDWIDTH_FULLBAND
@ OPUS_BANDWIDTH_FULLBAND
Definition: opus.h:54
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
CeltFrame::framebits
int framebits
Definition: opus_celt.h:138
CELT_BLOCK_960
@ CELT_BLOCK_960
Definition: opus_celt.h:65
OpusPsyStep::coeffs
float coeffs[OPUS_MAX_CHANNELS][OPUS_BLOCK_SIZE(CELT_BLOCK_960)]
Definition: opusenc_psy.h:43
tf_sess_config.config
config
Definition: tf_sess_config.py:33
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
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
CeltPVQ
Definition: opus_pvq.h:37
celt_search_for_tf
static int celt_search_for_tf(OpusPsyContext *s, OpusPsyStep **start, CeltFrame *f)
Definition: opusenc_psy.c:425
fail
#define fail()
Definition: checkasm.h:185
resolution
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit it is converted to planar bit YUV Two sets of converters exist for this the other leaves the full chroma resolution
Definition: swscale.txt:54
OpusPsyStep::change_amp
float change_amp[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc_psy.h:39
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
ff_opus_psy_end
av_cold int ff_opus_psy_end(OpusPsyContext *s)
Definition: opusenc_psy.c:595
CELT_BLOCK_120
@ CELT_BLOCK_120
Definition: opus_celt.h:62
bessel_init
static int bessel_init(FFBesselFilter *s, float n, float f0, float fs, int highpass)
Definition: opusenc_utils.h:72
psy_output_groups
static void psy_output_groups(OpusPsyContext *s)
Definition: opusenc_psy.c:210
OpusPacketInfo::mode
enum OpusMode mode
Definition: opusenc.h:49
av_cold
#define av_cold
Definition: attributes.h:90
OPUS_BLOCK_SIZE
#define OPUS_BLOCK_SIZE(x)
Definition: opusenc.h:39
CeltPVQ::quant_band
QUANT_FN * quant_band
Definition: opus_pvq.h:42
float
float
Definition: af_crystalizer.c:121
ff_celt_band_end
const uint8_t ff_celt_band_end[]
Definition: opustab.c:29
AV_TX_FLOAT_MDCT
@ AV_TX_FLOAT_MDCT
Standard MDCT with a sample data type of float, double or int32_t, respecively.
Definition: tx.h:68
OpusPsyStep
Definition: opusenc_psy.h:33
s
#define s(width, name)
Definition: cbs_vp9.c:198
frame_size
int frame_size
Definition: mxfenc.c:2424
CELT_SPREAD_NORMAL
@ CELT_SPREAD_NORMAL
Definition: opus_celt.h:57
ff_opus_psy_celt_frame_process
int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
Definition: opusenc_psy.c:459
bits
uint8_t bits
Definition: vp3data.h:128
CeltFrame::alloc_boost
int alloc_boost[CELT_MAX_BANDS]
Definition: opus_celt.h:119
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:29
OpusPsyContext
Definition: opusenc_psy.h: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
OpusBandExcitation::excitation_dist
float excitation_dist
Definition: opusenc_psy.h:48
OpusPacketInfo
Definition: opusenc.h:48
OPUS_MODE_CELT
@ OPUS_MODE_CELT
Definition: opus.h:44
bands_dist
static int bands_dist(OpusPsyContext *s, CeltFrame *f, float *total_dist)
Definition: opusenc_psy.c:367
NULL
#define NULL
Definition: coverity.c:32
OpusPsyStep::total_change
float total_change
Definition: opusenc_psy.h:40
sqrtf
static __device__ float sqrtf(float a)
Definition: cuda_runtime.h:184
generate_window_func
static void generate_window_func(float *lut, int N, int win_func, float *overlap)
Definition: window_func.h:63
X
@ X
Definition: vf_addroi.c:27
av_clipf
av_clipf
Definition: af_crystalizer.c:121
ff_celt_freq_range
const uint8_t ff_celt_freq_range[]
Definition: opustab.c:772
celt_gauge_psy_weight
static void celt_gauge_psy_weight(OpusPsyContext *s, OpusPsyStep **start, CeltFrame *f_out)
Definition: opusenc_psy.c:314
index
int index
Definition: gxfenc.c:90
c
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
weight
static int weight(int i, int blen, int offset)
Definition: diracdec.c:1563
ff_opus_psy_postencode_update
void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f)
Definition: opusenc_psy.c:480
options
const OptionDef options[]
CELT_OVERLAP
#define CELT_OVERLAP
Definition: opus_celt.h:39
OpusPsyStep::bands
float * bands[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc_psy.h:42
opustab.h
OpusPsyStep::index
int index
Definition: opusenc_psy.h:34
CELT_MAX_BANDS
#define CELT_MAX_BANDS
Definition: opus_celt.h:42
f
f
Definition: af_crystalizer.c:121
ff_opus_rc_enc_init
void ff_opus_rc_enc_init(OpusRangeCoder *rc)
Definition: opus_rc.c:402
opus_pvq.h
opusenc_psy.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
OpusPsyStep::tone
float tone[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc_psy.h:37
OpusRangeCoder
Definition: opus_rc.h:39
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
ff_celt_tf_select
const int8_t ff_celt_tf_select[4][2][2][2]
Definition: opustab.c:782
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
Y
#define Y
Definition: boxblur.h:37
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
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
pvq_band_cost
static float pvq_band_cost(CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc, int band, float *bits, float lambda)
Definition: opusenc_psy.c:31
AVFrame::nb_samples
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:454
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
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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:435
opus_celt.h
OPUS_MODE_HYBRID
@ OPUS_MODE_HYBRID
Definition: opus.h:43
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_opus_psy_signal_eof
void ff_opus_psy_signal_eof(OpusPsyContext *s)
Definition: opusenc_psy.c:590
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
OpusPsyStep::energy
float energy[OPUS_MAX_CHANNELS][CELT_MAX_BANDS]
Definition: opusenc_psy.h:36
len
int len
Definition: vorbis_enc_data.h:426
opus_rc_tell_frac
static av_always_inline uint32_t opus_rc_tell_frac(const OpusRangeCoder *rc)
Definition: opus_rc.h:65
ff_celt_bitalloc
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
Definition: opus_celt.c:137
ret
ret
Definition: filter_design.txt:187
window_func.h
AVCodecContext
main external API structure.
Definition: avcodec.h:445
WFUNC_SINE
@ WFUNC_SINE
Definition: window_func.h:31
OpusPacketInfo::framesize
int framesize
Definition: opusenc.h:51
bessel_filter
static float bessel_filter(FFBesselFilter *s, float x)
Definition: opusenc_utils.h:79
cm
#define cm
Definition: dvbsubdec.c:40
OpusBandExcitation
Definition: opusenc_psy.h:46
mem.h
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
search_for_change_points
static void search_for_change_points(OpusPsyContext *s, float tgt_change, int offset_s, int offset_e, int resolution, int level)
Definition: opusenc_psy.c:168
ff_opus_psy_init
av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx, struct FFBufQueue *bufqueue, OpusEncOptions *options)
Definition: opusenc_psy.c:516
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:291
OpusEncOptions
Definition: opusenc.h:43
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:146
step_collect_psy_metrics
static void step_collect_psy_metrics(OpusPsyContext *s, int index)
Definition: opusenc_psy.c:82
CELT_BLOCK_NB
@ CELT_BLOCK_NB
Definition: opus_celt.h:67
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
celt_search_for_intensity
static void celt_search_for_intensity(OpusPsyContext *s, CeltFrame *f)
Definition: opusenc_psy.c:402
flush_silent_frames
static int flush_silent_frames(OpusPsyContext *s)
Definition: opusenc_psy.c:188
OPUS_RC_CHECKPOINT_BITS
#define OPUS_RC_CHECKPOINT_BITS(rc)
Definition: opus_rc.h:119
OPUS_RC_CHECKPOINT_ROLLBACK
#define OPUS_RC_CHECKPOINT_ROLLBACK(rc)
Definition: opus_rc.h:122
int
int
Definition: ffmpeg_filter.c:424
OPUS_SAMPLES_TO_BLOCK_SIZE
#define OPUS_SAMPLES_TO_BLOCK_SIZE(x)
Definition: opusenc.h:41
CeltFrame
Definition: opus_celt.h:97