git.sesse.net Git - ffmpeg/blob - libavcodec/opusenc_psy.c

   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_psy.h"
  23 #include "opus_pvq.h"
  24 #include "opustab.h"
  25 #include "mdct15.h"
  26 #include "libavutil/qsort.h"
  27
  28 static float pvq_band_cost(CeltPVQ *pvq, CeltFrame *f, OpusRangeCoder *rc, int band,
  29                            float *bits, float lambda)
  30 {
  31     int i, b = 0;
  32     uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
  33     const int band_size = ff_celt_freq_range[band] << f->size;
  34     float buf[176 * 2], lowband_scratch[176], norm1[176], norm2[176];
  35     float dist, cost, err_x = 0.0f, err_y = 0.0f;
  36     float *X = buf;
  37     float *X_orig = f->block[0].coeffs + (ff_celt_freq_bands[band] << f->size);
  38     float *Y = (f->channels == 2) ? &buf[176] : NULL;
  39     float *Y_orig = f->block[1].coeffs + (ff_celt_freq_bands[band] << f->size);
  40     OPUS_RC_CHECKPOINT_SPAWN(rc);
  41
  42     memcpy(X, X_orig, band_size*sizeof(float));
  43     if (Y)
  44         memcpy(Y, Y_orig, band_size*sizeof(float));
  45
  46     f->remaining2 = ((f->framebits << 3) - f->anticollapse_needed) - opus_rc_tell_frac(rc) - 1;
  47     if (band <= f->coded_bands - 1) {
  48         int curr_balance = f->remaining / FFMIN(3, f->coded_bands - band);
  49         b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[band] + curr_balance), 14);
  50     }
  51
  52     if (f->dual_stereo) {
  53         pvq->quant_band(pvq, f, rc, band, X, NULL, band_size, b / 2, f->blocks, NULL,
  54                         f->size, norm1, 0, 1.0f, lowband_scratch, cm[0]);
  55
  56         pvq->quant_band(pvq, f, rc, band, Y, NULL, band_size, b / 2, f->blocks, NULL,
  57                         f->size, norm2, 0, 1.0f, lowband_scratch, cm[1]);
  58     } else {
  59         pvq->quant_band(pvq, f, rc, band, X, Y, band_size, b, f->blocks, NULL, f->size,
  60                         norm1, 0, 1.0f, lowband_scratch, cm[0] | cm[1]);
  61     }
  62
  63     for (i = 0; i < band_size; i++) {
  64         err_x += (X[i] - X_orig[i])*(X[i] - X_orig[i]);
  65         if (Y)
  66             err_y += (Y[i] - Y_orig[i])*(Y[i] - Y_orig[i]);
  67     }
  68
  69     dist = sqrtf(err_x) + sqrtf(err_y);
  70     cost = OPUS_RC_CHECKPOINT_BITS(rc)/8.0f;
  71     *bits += cost;
  72
  73     OPUS_RC_CHECKPOINT_ROLLBACK(rc);
  74
  75     return lambda*dist*cost;
  76 }
  77
  78 /* Populate metrics without taking into consideration neighbouring steps */
  79 static void step_collect_psy_metrics(OpusPsyContext *s, int index)
  80 {
  81     int silence = 0, ch, i, j;
  82     OpusPsyStep *st = s->steps[index];
  83
  84     st->index = index;
  85
  86     for (ch = 0; ch < s->avctx->channels; ch++) {
  87         const int lap_size = (1 << s->bsize_analysis);
  88         for (i = 1; i <= FFMIN(lap_size, index); i++) {
  89             const int offset = i*120;
  90             AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index - i);
  91             memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
  92         }
  93         for (i = 0; i < lap_size; i++) {
  94             const int offset = i*120 + lap_size;
  95             AVFrame *cur = ff_bufqueue_peek(s->bufqueue, index + i);
  96             memcpy(&s->scratch[offset], cur->extended_data[ch], cur->nb_samples*sizeof(float));
  97         }
  98
  99         s->dsp->vector_fmul(s->scratch, s->scratch, s->window[s->bsize_analysis],
 100                             (OPUS_BLOCK_SIZE(s->bsize_analysis) << 1));
 101
 102         s->mdct[s->bsize_analysis]->mdct(s->mdct[s->bsize_analysis], st->coeffs[ch], s->scratch, 1);
 103
 104         for (i = 0; i < CELT_MAX_BANDS; i++)
 105             st->bands[ch][i] = &st->coeffs[ch][ff_celt_freq_bands[i] << s->bsize_analysis];
 106     }
 107
 108     for (ch = 0; ch < s->avctx->channels; ch++) {
 109         for (i = 0; i < CELT_MAX_BANDS; i++) {
 110             float avg_c_s, energy = 0.0f, dist_dev = 0.0f;
 111             const int range = ff_celt_freq_range[i] << s->bsize_analysis;
 112             const float *coeffs = st->bands[ch][i];
 113             for (j = 0; j < range; j++)
 114                 energy += coeffs[j]*coeffs[j];
 115
 116             st->energy[ch][i] += sqrtf(energy);
 117             silence |= !!st->energy[ch][i];
 118             avg_c_s = energy / range;
 119
 120             for (j = 0; j < range; j++) {
 121                 const float c_s = coeffs[j]*coeffs[j];
 122                 dist_dev += (avg_c_s - c_s)*(avg_c_s - c_s);
 123             }
 124
 125             st->tone[ch][i] += sqrtf(dist_dev);
 126         }
 127     }
 128
 129     st->silence = !silence;
 130
 131     if (s->avctx->channels > 1) {
 132         for (i = 0; i < CELT_MAX_BANDS; i++) {
 133             float incompat = 0.0f;
 134             const float *coeffs1 = st->bands[0][i];
 135             const float *coeffs2 = st->bands[1][i];
 136             const int range = ff_celt_freq_range[i] << s->bsize_analysis;
 137             for (j = 0; j < range; j++)
 138                 incompat += (coeffs1[j] - coeffs2[j])*(coeffs1[j] - coeffs2[j]);
 139             st->stereo[i] = sqrtf(incompat);
 140         }
 141     }
 142
 143     for (ch = 0; ch < s->avctx->channels; ch++) {
 144         for (i = 0; i < CELT_MAX_BANDS; i++) {
 145             OpusBandExcitation *ex = &s->ex[ch][i];
 146             float bp_e = bessel_filter(&s->bfilter_lo[ch][i], st->energy[ch][i]);
 147             bp_e = bessel_filter(&s->bfilter_hi[ch][i], bp_e);
 148             bp_e *= bp_e;
 149             if (bp_e > ex->excitation) {
 150                 st->change_amp[ch][i] = bp_e - ex->excitation;
 151                 st->total_change += st->change_amp[ch][i];
 152                 ex->excitation = ex->excitation_init = bp_e;
 153                 ex->excitation_dist = 0.0f;
 154             }
 155             if (ex->excitation > 0.0f) {
 156                 ex->excitation -= av_clipf((1/expf(ex->excitation_dist)), ex->excitation_init/20, ex->excitation_init/1.09);
 157                 ex->excitation = FFMAX(ex->excitation, 0.0f);
 158                 ex->excitation_dist += 1.0f;
 159             }
 160         }
 161     }
 162 }
 163
 164 static void search_for_change_points(OpusPsyContext *s, float tgt_change,
 165                                      int offset_s, int offset_e, int resolution,
 166                                      int level)
 167 {
 168     int i;
 169     float c_change = 0.0f;
 170     if ((offset_e - offset_s) <= resolution)
 171         return;
 172     for (i = offset_s; i < offset_e; i++) {
 173         c_change += s->steps[i]->total_change;
 174         if (c_change > tgt_change)
 175             break;
 176     }
 177     if (i == offset_e)
 178         return;
 179     search_for_change_points(s, tgt_change / 2.0f, offset_s, i + 0, resolution, level + 1);
 180     s->inflection_points[s->inflection_points_count++] = i;
 181     search_for_change_points(s, tgt_change / 2.0f, i + 1, offset_e, resolution, level + 1);
 182 }
 183
 184 static int flush_silent_frames(OpusPsyContext *s)
 185 {
 186     int fsize, silent_frames;
 187
 188     for (silent_frames = 0; silent_frames < s->buffered_steps; silent_frames++)
 189         if (!s->steps[silent_frames]->silence)
 190             break;
 191     if (--silent_frames < 0)
 192         return 0;
 193
 194     for (fsize = CELT_BLOCK_960; fsize > CELT_BLOCK_120; fsize--) {
 195         if ((1 << fsize) > silent_frames)
 196             continue;
 197         s->p.frames = FFMIN(silent_frames / (1 << fsize), 48 >> fsize);
 198         s->p.framesize = fsize;
 199         return 1;
 200     }
 201
 202     return 0;
 203 }
 204
 205 /* Main function which decides frame size and frames per current packet */
 206 static void psy_output_groups(OpusPsyContext *s)
 207 {
 208     int max_delay_samples = (s->options->max_delay_ms*s->avctx->sample_rate)/1000;
 209     int max_bsize = FFMIN(OPUS_SAMPLES_TO_BLOCK_SIZE(max_delay_samples), CELT_BLOCK_960);
 210
 211     /* These don't change for now */
 212     s->p.mode      = OPUS_MODE_CELT;
 213     s->p.bandwidth = OPUS_BANDWIDTH_FULLBAND;
 214
 215     /* Flush silent frames ASAP */
 216     if (s->steps[0]->silence && flush_silent_frames(s))
 217         return;
 218
 219     s->p.framesize = FFMIN(max_bsize, CELT_BLOCK_960);
 220     s->p.frames    = 1;
 221 }
 222
 223 int ff_opus_psy_process(OpusPsyContext *s, OpusPacketInfo *p)
 224 {
 225     int i;
 226     float total_energy_change = 0.0f;
 227
 228     if (s->buffered_steps < s->max_steps && !s->eof) {
 229         const int awin = (1 << s->bsize_analysis);
 230         if (++s->steps_to_process >= awin) {
 231             step_collect_psy_metrics(s, s->buffered_steps - awin + 1);
 232             s->steps_to_process = 0;
 233         }
 234         if ((++s->buffered_steps) < s->max_steps)
 235             return 1;
 236     }
 237
 238     for (i = 0; i < s->buffered_steps; i++)
 239         total_energy_change += s->steps[i]->total_change;
 240
 241     search_for_change_points(s, total_energy_change / 2.0f, 0,
 242                              s->buffered_steps, 1, 0);
 243
 244     psy_output_groups(s);
 245
 246     p->frames    = s->p.frames;
 247     p->framesize = s->p.framesize;
 248     p->mode      = s->p.mode;
 249     p->bandwidth = s->p.bandwidth;
 250
 251     return 0;
 252 }
 253
 254 void ff_opus_psy_celt_frame_init(OpusPsyContext *s, CeltFrame *f, int index)
 255 {
 256     int i, neighbouring_points = 0, start_offset = 0;
 257     int radius = (1 << s->p.framesize), step_offset = radius*index;
 258     int silence = 1;
 259
 260     f->start_band = (s->p.mode == OPUS_MODE_HYBRID) ? 17 : 0;
 261     f->end_band   = ff_celt_band_end[s->p.bandwidth];
 262     f->channels   = s->avctx->channels;
 263     f->size       = s->p.framesize;
 264
 265     for (i = 0; i < (1 << f->size); i++)
 266         silence &= s->steps[index*(1 << f->size) + i]->silence;
 267
 268     f->silence = silence;
 269     if (f->silence) {
 270         f->framebits = 0; /* Otherwise the silence flag eats up 16(!) bits */
 271         return;
 272     }
 273
 274     for (i = 0; i < s->inflection_points_count; i++) {
 275         if (s->inflection_points[i] >= step_offset) {
 276             start_offset = i;
 277             break;
 278         }
 279     }
 280
 281     for (i = start_offset; i < FFMIN(radius, s->inflection_points_count - start_offset); i++) {
 282         if (s->inflection_points[i] < (step_offset + radius)) {
 283             neighbouring_points++;
 284         }
 285     }
 286
 287     /* Transient flagging */
 288     f->transient = neighbouring_points > 0;
 289     f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
 290
 291     /* Some sane defaults */
 292     f->pfilter   = 0;
 293     f->pf_gain   = 0.5f;
 294     f->pf_octave = 2;
 295     f->pf_period = 1;
 296     f->pf_tapset = 2;
 297
 298     /* More sane defaults */
 299     f->tf_select = 0;
 300     f->anticollapse = 1;
 301     f->alloc_trim = 5;
 302     f->skip_band_floor = f->end_band;
 303     f->intensity_stereo = f->end_band;
 304     f->dual_stereo = 0;
 305     f->spread = CELT_SPREAD_NORMAL;
 306     memset(f->tf_change, 0, sizeof(int)*CELT_MAX_BANDS);
 307     memset(f->alloc_boost, 0, sizeof(int)*CELT_MAX_BANDS);
 308 }
 309
 310 static void celt_gauge_psy_weight(OpusPsyContext *s, OpusPsyStep **start,
 311                                   CeltFrame *f_out)
 312 {
 313     int i, f, ch;
 314     int frame_size = OPUS_BLOCK_SIZE(s->p.framesize);
 315     float rate, frame_bits = 0;
 316
 317     /* Used for the global ROTATE flag */
 318     float tonal = 0.0f;
 319
 320     /* Pseudo-weights */
 321     float band_score[CELT_MAX_BANDS] = { 0 };
 322     float max_score = 1.0f;
 323
 324     /* Pass one - one loop around each band, computing unquant stuff */
 325     for (i = 0; i < CELT_MAX_BANDS; i++) {
 326         float weight = 0.0f;
 327         float tonal_contrib = 0.0f;
 328         for (f = 0; f < (1 << s->p.framesize); f++) {
 329             weight = start[f]->stereo[i];
 330             for (ch = 0; ch < s->avctx->channels; ch++) {
 331                 weight += start[f]->change_amp[ch][i] + start[f]->tone[ch][i] + start[f]->energy[ch][i];
 332                 tonal_contrib += start[f]->tone[ch][i];
 333             }
 334         }
 335         tonal += tonal_contrib;
 336         band_score[i] = weight;
 337     }
 338
 339     tonal /= (float)CELT_MAX_BANDS;
 340
 341     for (i = 0; i < CELT_MAX_BANDS; i++) {
 342         if (band_score[i] > max_score)
 343             max_score = band_score[i];
 344     }
 345
 346     for (i = 0; i < CELT_MAX_BANDS; i++) {
 347         f_out->alloc_boost[i] = (int)((band_score[i]/max_score)*3.0f);
 348         frame_bits += band_score[i]*8.0f;
 349     }
 350
 351     tonal /= 1333136.0f;
 352     f_out->spread = av_clip_uintp2(lrintf(tonal), 2);
 353
 354     rate = ((float)s->avctx->bit_rate) + frame_bits*frame_size*16;
 355     rate *= s->lambda;
 356     rate /= s->avctx->sample_rate/frame_size;
 357
 358     f_out->framebits = lrintf(rate);
 359     f_out->framebits = FFMIN(f_out->framebits, OPUS_MAX_PACKET_SIZE*8);
 360     f_out->framebits = FFALIGN(f_out->framebits, 8);
 361 }
 362
 363 static int bands_dist(OpusPsyContext *s, CeltFrame *f, float *total_dist)
 364 {
 365     int i, tdist = 0.0f;
 366     OpusRangeCoder dump;
 367
 368     ff_opus_rc_enc_init(&dump);
 369     ff_celt_bitalloc(f, &dump, 1);
 370
 371     for (i = 0; i < CELT_MAX_BANDS; i++) {
 372         float bits = 0.0f;
 373         float dist = pvq_band_cost(f->pvq, f, &dump, i, &bits, s->lambda);
 374         tdist += dist;
 375     }
 376
 377     *total_dist = tdist;
 378
 379     return 0;
 380 }
 381
 382 static void celt_search_for_dual_stereo(OpusPsyContext *s, CeltFrame *f)
 383 {
 384     float td1, td2;
 385     f->dual_stereo = 0;
 386
 387     if (s->avctx->channels < 2)
 388         return;
 389
 390     bands_dist(s, f, &td1);
 391     f->dual_stereo = 1;
 392     bands_dist(s, f, &td2);
 393
 394     f->dual_stereo = td2 < td1;
 395     s->dual_stereo_used += td2 < td1;
 396 }
 397
 398 static void celt_search_for_intensity(OpusPsyContext *s, CeltFrame *f)
 399 {
 400     int i, best_band = CELT_MAX_BANDS - 1;
 401     float dist, best_dist = FLT_MAX;
 402
 403     if (s->avctx->channels < 2)
 404         return;
 405
 406     /* TODO: fix, make some heuristic up here using the lambda value */
 407     float end_band = 0;
 408
 409     for (i = f->end_band; i >= end_band; i--) {
 410         f->intensity_stereo = i;
 411         bands_dist(s, f, &dist);
 412         if (best_dist > dist) {
 413             best_dist = dist;
 414             best_band = i;
 415         }
 416     }
 417
 418     f->intensity_stereo = best_band;
 419     s->avg_is_band = (s->avg_is_band + f->intensity_stereo)/2.0f;
 420 }
 421
 422 static int celt_search_for_tf(OpusPsyContext *s, OpusPsyStep **start, CeltFrame *f)
 423 {
 424     int i, j, k, cway, config[2][CELT_MAX_BANDS] = { { 0 } };
 425     float score[2] = { 0 };
 426
 427     for (cway = 0; cway < 2; cway++) {
 428         int mag[2];
 429         int base = f->transient ? 120 : 960;
 430
 431         for (i = 0; i < 2; i++) {
 432             int c = ff_celt_tf_select[f->size][f->transient][cway][i];
 433             mag[i] = c < 0 ? base >> FFABS(c) : base << FFABS(c);
 434         }
 435
 436         for (i = 0; i < CELT_MAX_BANDS; i++) {
 437             float iscore0 = 0.0f;
 438             float iscore1 = 0.0f;
 439             for (j = 0; j < (1 << f->size); j++) {
 440                 for (k = 0; k < s->avctx->channels; k++) {
 441                     iscore0 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[0];
 442                     iscore1 += start[j]->tone[k][i]*start[j]->change_amp[k][i]/mag[1];
 443                 }
 444             }
 445             config[cway][i] = FFABS(iscore0 - 1.0f) < FFABS(iscore1 - 1.0f);
 446             score[cway] += config[cway][i] ? iscore1 : iscore0;
 447         }
 448     }
 449
 450     f->tf_select = score[0] < score[1];
 451     memcpy(f->tf_change, config[f->tf_select], sizeof(int)*CELT_MAX_BANDS);
 452
 453     return 0;
 454 }
 455
 456 int ff_opus_psy_celt_frame_process(OpusPsyContext *s, CeltFrame *f, int index)
 457 {
 458     int start_transient_flag = f->transient;
 459     OpusPsyStep **start = &s->steps[index * (1 << s->p.framesize)];
 460
 461     if (f->silence)
 462         return 0;
 463
 464     celt_gauge_psy_weight(s, start, f);
 465     celt_search_for_intensity(s, f);
 466     celt_search_for_dual_stereo(s, f);
 467     celt_search_for_tf(s, start, f);
 468
 469     if (f->transient != start_transient_flag) {
 470         f->blocks = f->transient ? OPUS_BLOCK_SIZE(s->p.framesize)/CELT_OVERLAP : 1;
 471         s->redo_analysis = 1;
 472         return 1;
 473     }
 474
 475     s->redo_analysis = 0;
 476
 477     return 0;
 478 }
 479
 480 void ff_opus_psy_postencode_update(OpusPsyContext *s, CeltFrame *f, OpusRangeCoder *rc)
 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->cs_num = 0;
 511     s->steps_to_process = 0;
 512     s->buffered_steps -= steps_out;
 513     s->total_packets_out += s->p.frames;
 514     s->inflection_points_count = 0;
 515 }
 516
 517 av_cold int ff_opus_psy_init(OpusPsyContext *s, AVCodecContext *avctx,
 518                              struct FFBufQueue *bufqueue, OpusEncOptions *options)
 519 {
 520     int i, ch, ret;
 521
 522     s->redo_analysis = 0;
 523     s->lambda = 1.0f;
 524     s->options = options;
 525     s->avctx = avctx;
 526     s->bufqueue = bufqueue;
 527     s->max_steps = ceilf(s->options->max_delay_ms/2.5f);
 528     s->bsize_analysis = CELT_BLOCK_960;
 529     s->avg_is_band = CELT_MAX_BANDS - 1;
 530     s->inflection_points_count = 0;
 531
 532     s->inflection_points = av_mallocz(sizeof(*s->inflection_points)*s->max_steps);
 533     if (!s->inflection_points) {
 534         ret = AVERROR(ENOMEM);
 535         goto fail;
 536     }
 537
 538     s->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
 539     if (!s->dsp) {
 540         ret = AVERROR(ENOMEM);
 541         goto fail;
 542     }
 543
 544     for (ch = 0; ch < s->avctx->channels; ch++) {
 545         for (i = 0; i < CELT_MAX_BANDS; i++) {
 546             bessel_init(&s->bfilter_hi[ch][i], 1.0f, 19.0f, 100.0f, 1);
 547             bessel_init(&s->bfilter_lo[ch][i], 1.0f, 20.0f, 100.0f, 0);
 548         }
 549     }
 550
 551     for (i = 0; i < s->max_steps; i++) {
 552         s->steps[i] = av_mallocz(sizeof(OpusPsyStep));
 553         if (!s->steps[i]) {
 554             ret = AVERROR(ENOMEM);
 555             goto fail;
 556         }
 557     }
 558
 559     for (i = 0; i < CELT_BLOCK_NB; i++) {
 560         float tmp;
 561         const int len = OPUS_BLOCK_SIZE(i);
 562         s->window[i] = av_malloc(2*len*sizeof(float));
 563         if (!s->window[i]) {
 564             ret = AVERROR(ENOMEM);
 565             goto fail;
 566         }
 567         generate_window_func(s->window[i], 2*len, WFUNC_SINE, &tmp);
 568         if ((ret = ff_mdct15_init(&s->mdct[i], 0, i + 3, 68 << (CELT_BLOCK_NB - 1 - i))))
 569             goto fail;
 570     }
 571
 572     return 0;
 573
 574 fail:
 575     av_freep(&s->inflection_points);
 576     av_freep(&s->dsp);
 577
 578     for (i = 0; i < CELT_BLOCK_NB; i++) {
 579         ff_mdct15_uninit(&s->mdct[i]);
 580         av_freep(&s->window[i]);
 581     }
 582
 583     for (i = 0; i < s->max_steps; i++)
 584         av_freep(&s->steps[i]);
 585
 586     return ret;
 587 }
 588
 589 void ff_opus_psy_signal_eof(OpusPsyContext *s)
 590 {
 591     s->eof = 1;
 592 }
 593
 594 av_cold int ff_opus_psy_end(OpusPsyContext *s)
 595 {
 596     int i;
 597
 598     av_freep(&s->inflection_points);
 599     av_freep(&s->dsp);
 600
 601     for (i = 0; i < CELT_BLOCK_NB; i++) {
 602         ff_mdct15_uninit(&s->mdct[i]);
 603         av_freep(&s->window[i]);
 604     }
 605
 606     for (i = 0; i < s->max_steps; i++)
 607         av_freep(&s->steps[i]);
 608
 609     av_log(s->avctx, AV_LOG_INFO, "Average Intensity Stereo band: %0.1f\n", s->avg_is_band);
 610     av_log(s->avctx, AV_LOG_INFO, "Dual Stereo used: %0.2f%%\n", ((float)s->dual_stereo_used/s->total_packets_out)*100.0f);
 611
 612     return 0;
 613 }