Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

avcodec/opus: Rename opus.c->opus_celt.c, opus_celt.c->opusdec_celt.c

Browse Source 
Since commit 4fc2531fff opus.c
contains only the celt stuff shared between decoder and encoder.
meanwhile, opus_celt.c is decoder-only. So the new names
reflect the actual content better than the current ones.

Reviewed-by: Lynne <dev@lynne.ee>
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
pull/388/head
Andreas Rheinhardt 2 years ago
parent 4486ff9242
commit 8320e236c1
4 changed files with 977 additions and 977 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      libavcodec/Makefile
  2. 484
      libavcodec/opus.c
  3. 876
      libavcodec/opus_celt.c
  4. 586
      libavcodec/opusdec_celt.c

8
libavcodec/Makefile
Unescape View File

@ -554,11 +554,11 @@ OBJS-$(CONFIG_NELLYMOSER_ENCODER) += nellymoserenc.o nellymoser.o
OBJS-$(CONFIG_NOTCHLC_DECODER) += notchlc.o OBJS-$(CONFIG_NOTCHLC_DECODER) += notchlc.o
OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o OBJS-$(CONFIG_NUV_DECODER) += nuv.o rtjpeg.o
OBJS-$(CONFIG_ON2AVC_DECODER) += on2avc.o on2avcdata.o OBJS-$(CONFIG_ON2AVC_DECODER) += on2avc.o on2avcdata.o
OBJS-$(CONFIG_OPUS_DECODER) += opusdec.o opus.o opus_celt.o opus_rc.o \ OBJS-$(CONFIG_OPUS_DECODER) += opusdec.o opusdec_celt.o opus_celt.o \
opus_pvq.o opus_silk.o opustab.o vorbis_data.o \ opus_pvq.o opus_silk.o opustab.o vorbis_data.o \
opusdsp.o opus_parse.o opusdsp.o opus_parse.o opus_rc.o
OBJS-$(CONFIG_OPUS_ENCODER) += opusenc.o opus.o opus_rc.o opustab.o opus_pvq.o \ OBJS-$(CONFIG_OPUS_ENCODER) += opusenc.o opusenc_psy.o opus_celt.o \
opusenc_psy.o opus_pvq.o opus_rc.o opustab.o
OBJS-$(CONFIG_PAF_AUDIO_DECODER) += pafaudio.o OBJS-$(CONFIG_PAF_AUDIO_DECODER) += pafaudio.o
OBJS-$(CONFIG_PAF_VIDEO_DECODER) += pafvideo.o OBJS-$(CONFIG_PAF_VIDEO_DECODER) += pafvideo.o
OBJS-$(CONFIG_PAM_DECODER) += pnmdec.o pnm.o OBJS-$(CONFIG_PAM_DECODER) += pnmdec.o pnm.o

484
libavcodec/opus.c
Unescape View File

@ -1,484 +0,0 @@
/*
* Copyright (c) 2012 Andrew D'Addesio
* Copyright (c) 2013-2014 Mozilla Corporation
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdint.h>
#include "opus_celt.h"
#include "opus_pvq.h"
#include "opustab.h"
void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
{
float lowband_scratch[8 * 22];
float norm1[2 * 8 * 100];
float *norm2 = norm1 + 8 * 100;
int totalbits = (f->framebits << 3) - f->anticollapse_needed;
int update_lowband = 1;
int lowband_offset = 0;
int i, j;
for (i = f->start_band; i < f->end_band; i++) {
uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
int band_offset = ff_celt_freq_bands[i] << f->size;
int band_size = ff_celt_freq_range[i] << f->size;
float *X = f->block[0].coeffs + band_offset;
float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL;
float *norm_loc1, *norm_loc2;
int consumed = opus_rc_tell_frac(rc);
int effective_lowband = -1;
int b = 0;
/* Compute how many bits we want to allocate to this band */
if (i != f->start_band)
f->remaining -= consumed;
f->remaining2 = totalbits - consumed - 1;
if (i <= f->coded_bands - 1) {
int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i);
b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14);
}
if ((ff_celt_freq_bands[i] - ff_celt_freq_range[i] >= ff_celt_freq_bands[f->start_band] ||
i == f->start_band + 1) && (update_lowband || lowband_offset == 0))
lowband_offset = i;
if (i == f->start_band + 1) {
/* Special Hybrid Folding (RFC 8251 section 9). Copy the first band into
the second to ensure the second band never has to use the LCG. */
int count = (ff_celt_freq_range[i] - ff_celt_freq_range[i-1]) << f->size;
memcpy(&norm1[band_offset], &norm1[band_offset - count], count * sizeof(float));
if (f->channels == 2)
memcpy(&norm2[band_offset], &norm2[band_offset - count], count * sizeof(float));
}
/* Get a conservative estimate of the collapse_mask's for the bands we're
going to be folding from. */
if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE ||
f->blocks > 1 || f->tf_change[i] < 0)) {
int foldstart, foldend;
/* This ensures we never repeat spectral content within one band */
effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band],
ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]);
foldstart = lowband_offset;
while (ff_celt_freq_bands[--foldstart] > effective_lowband);
foldend = lowband_offset - 1;
while (++foldend < i && ff_celt_freq_bands[foldend] < effective_lowband + ff_celt_freq_range[i]);
cm[0] = cm[1] = 0;
for (j = foldstart; j < foldend; j++) {
cm[0] |= f->block[0].collapse_masks[j];
cm[1] |= f->block[f->channels - 1].collapse_masks[j];
}
}
if (f->dual_stereo && i == f->intensity_stereo) {
/* Switch off dual stereo to do intensity */
f->dual_stereo = 0;
for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++)
norm1[j] = (norm1[j] + norm2[j]) / 2;
}
norm_loc1 = effective_lowband != -1 ? norm1 + (effective_lowband << f->size) : NULL;
norm_loc2 = effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL;
if (f->dual_stereo) {
cm[0] = f->pvq->quant_band(f->pvq, f, rc, i, X, NULL, band_size, b >> 1,
f->blocks, norm_loc1, f->size,
norm1 + band_offset, 0, 1.0f,
lowband_scratch, cm[0]);
cm[1] = f->pvq->quant_band(f->pvq, f, rc, i, Y, NULL, band_size, b >> 1,
f->blocks, norm_loc2, f->size,
norm2 + band_offset, 0, 1.0f,
lowband_scratch, cm[1]);
} else {
cm[0] = f->pvq->quant_band(f->pvq, f, rc, i, X, Y, band_size, b >> 0,
f->blocks, norm_loc1, f->size,
norm1 + band_offset, 0, 1.0f,
lowband_scratch, cm[0] | cm[1]);
cm[1] = cm[0];
}
f->block[0].collapse_masks[i] = (uint8_t)cm[0];
f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1];
f->remaining += f->pulses[i] + consumed;
/* Update the folding position only as long as we have 1 bit/sample depth */
update_lowband = (b > band_size << 3);
}
}
#define NORMC(bits) ((bits) << (f->channels - 1) << f->size >> 2)
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
{
int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
int skip_startband = f->start_band;
int skip_bit = 0;
int intensitystereo_bit = 0;
int dualstereo_bit = 0;
int dynalloc = 6;
int extrabits = 0;
int boost[CELT_MAX_BANDS] = { 0 };
int trim_offset[CELT_MAX_BANDS];
int threshold[CELT_MAX_BANDS];
int bits1[CELT_MAX_BANDS];
int bits2[CELT_MAX_BANDS];
/* Spread */
if (opus_rc_tell(rc) + 4 <= f->framebits) {
if (encode)
ff_opus_rc_enc_cdf(rc, f->spread, ff_celt_model_spread);
else
f->spread = ff_opus_rc_dec_cdf(rc, ff_celt_model_spread);
} else {
f->spread = CELT_SPREAD_NORMAL;
}
/* Initialize static allocation caps */
for (i = 0; i < CELT_MAX_BANDS; i++)
f->caps[i] = NORMC((ff_celt_static_caps[f->size][f->channels - 1][i] + 64) * ff_celt_freq_range[i]);
/* Band boosts */
tbits_8ths = f->framebits << 3;
for (i = f->start_band; i < f->end_band; i++) {
int quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
int b_dynalloc = dynalloc;
int boost_amount = f->alloc_boost[i];
quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < f->caps[i]) {
int is_boost;
if (encode) {
is_boost = boost_amount--;
ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
} else {
is_boost = ff_opus_rc_dec_log(rc, b_dynalloc);
}
if (!is_boost)
break;
boost[i] += quanta;
tbits_8ths -= quanta;
b_dynalloc = 1;
}
if (boost[i])
dynalloc = FFMAX(dynalloc - 1, 2);
}
/* Allocation trim */
if (!encode)
f->alloc_trim = 5;
if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
if (encode)
ff_opus_rc_enc_cdf(rc, f->alloc_trim, ff_celt_model_alloc_trim);
else
f->alloc_trim = ff_opus_rc_dec_cdf(rc, ff_celt_model_alloc_trim);
/* Anti-collapse bit reservation */
tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
f->anticollapse_needed = 0;
if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
f->anticollapse_needed = 1 << 3;
tbits_8ths -= f->anticollapse_needed;
/* Band skip bit reservation */
if (tbits_8ths >= 1 << 3)
skip_bit = 1 << 3;
tbits_8ths -= skip_bit;
/* Intensity/dual stereo bit reservation */
if (f->channels == 2) {
intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
if (intensitystereo_bit <= tbits_8ths) {
tbits_8ths -= intensitystereo_bit;
if (tbits_8ths >= 1 << 3) {
dualstereo_bit = 1 << 3;
tbits_8ths -= 1 << 3;
}
} else {
intensitystereo_bit = 0;
}
}
/* Trim offsets */
for (i = f->start_band; i < f->end_band; i++) {
int trim = f->alloc_trim - 5 - f->size;
int band = ff_celt_freq_range[i] * (f->end_band - i - 1);
int duration = f->size + 3;
int scale = duration + f->channels - 1;
/* PVQ minimum allocation threshold, below this value the band is
* skipped */
threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
f->channels << 3);
trim_offset[i] = trim * (band << scale) >> 6;
if (ff_celt_freq_range[i] << f->size == 1)
trim_offset[i] -= f->channels << 3;
}
/* Bisection */
low = 1;
high = CELT_VECTORS - 1;
while (low <= high) {
int center = (low + high) >> 1;
done = total = 0;
for (i = f->end_band - 1; i >= f->start_band; i--) {
bandbits = NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]);
if (bandbits)
bandbits = FFMAX(bandbits + trim_offset[i], 0);
bandbits += boost[i];
if (bandbits >= threshold[i] || done) {
done = 1;
total += FFMIN(bandbits, f->caps[i]);
} else if (bandbits >= f->channels << 3) {
total += f->channels << 3;
}
}
if (total > tbits_8ths)
high = center - 1;
else
low = center + 1;
}
high = low--;
/* Bisection */
for (i = f->start_band; i < f->end_band; i++) {
bits1[i] = NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]);
bits2[i] = high >= CELT_VECTORS ? f->caps[i] :
NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[high][i]);
if (bits1[i])
bits1[i] = FFMAX(bits1[i] + trim_offset[i], 0);
if (bits2[i])
bits2[i] = FFMAX(bits2[i] + trim_offset[i], 0);
if (low)
bits1[i] += boost[i];
bits2[i] += boost[i];
if (boost[i])
skip_startband = i;
bits2[i] = FFMAX(bits2[i] - bits1[i], 0);
}
/* Bisection */
low = 0;
high = 1 << CELT_ALLOC_STEPS;
for (i = 0; i < CELT_ALLOC_STEPS; i++) {
int center = (low + high) >> 1;
done = total = 0;
for (j = f->end_band - 1; j >= f->start_band; j--) {
bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
if (bandbits >= threshold[j] || done) {
done = 1;
total += FFMIN(bandbits, f->caps[j]);
} else if (bandbits >= f->channels << 3)
total += f->channels << 3;
}
if (total > tbits_8ths)
high = center;
else
low = center;
}
/* Bisection */
done = total = 0;
for (i = f->end_band - 1; i >= f->start_band; i--) {
bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
if (bandbits >= threshold[i] || done)
done = 1;
else
bandbits = (bandbits >= f->channels << 3) ?
f->channels << 3 : 0;
bandbits = FFMIN(bandbits, f->caps[i]);
f->pulses[i] = bandbits;
total += bandbits;
}
/* Band skipping */
for (f->coded_bands = f->end_band; ; f->coded_bands--) {
int allocation;
j = f->coded_bands - 1;
if (j == skip_startband) {
/* all remaining bands are not skipped */
tbits_8ths += skip_bit;
break;
}
/* determine the number of bits available for coding "do not skip" markers */
remaining = tbits_8ths - total;
bandbits = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
remaining -= bandbits * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
allocation = f->pulses[j] + bandbits * ff_celt_freq_range[j];
allocation += FFMAX(remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]), 0);
/* a "do not skip" marker is only coded if the allocation is
* above the chosen threshold */
if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
int do_not_skip;
if (encode) {
do_not_skip = f->coded_bands <= f->skip_band_floor;
ff_opus_rc_enc_log(rc, do_not_skip, 1);
} else {
do_not_skip = ff_opus_rc_dec_log(rc, 1);
}
if (do_not_skip)
break;
total += 1 << 3;
allocation -= 1 << 3;
}
/* the band is skipped, so reclaim its bits */
total -= f->pulses[j];
if (intensitystereo_bit) {
total -= intensitystereo_bit;
intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
total += intensitystereo_bit;
}
total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
}
/* IS start band */
if (encode) {
if (intensitystereo_bit) {
f->intensity_stereo = FFMIN(f->intensity_stereo, f->coded_bands);
ff_opus_rc_enc_uint(rc, f->intensity_stereo, f->coded_bands + 1 - f->start_band);
}
} else {
f->intensity_stereo = f->dual_stereo = 0;
if (intensitystereo_bit)
f->intensity_stereo = f->start_band + ff_opus_rc_dec_uint(rc, f->coded_bands + 1 - f->start_band);
}
/* DS flag */
if (f->intensity_stereo <= f->start_band)
tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
else if (dualstereo_bit)
if (encode)
ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
else
f->dual_stereo = ff_opus_rc_dec_log(rc, 1);
/* Supply the remaining bits in this frame to lower bands */
remaining = tbits_8ths - total;
bandbits = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
for (i = f->start_band; i < f->coded_bands; i++) {
const int bits = FFMIN(remaining, ff_celt_freq_range[i]);
f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
remaining -= bits;
}
/* Finally determine the allocation */
for (i = f->start_band; i < f->coded_bands; i++) {
int N = ff_celt_freq_range[i] << f->size;
int prev_extra = extrabits;
f->pulses[i] += extrabits;
if (N > 1) {
int dof; /* degrees of freedom */
int temp; /* dof * channels * log(dof) */
int fine_bits;
int max_bits;
int offset; /* fine energy quantization offset, i.e.
* extra bits assigned over the standard
* totalbits/dof */
extrabits = FFMAX(f->pulses[i] - f->caps[i], 0);
f->pulses[i] -= extrabits;
/* intensity stereo makes use of an extra degree of freedom */
dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
if (N == 2) /* dof=2 is the only case that doesn't fit the model */
offset += dof << 1;
/* grant an additional bias for the first and second pulses */
if (f->pulses[i] + offset < 2 * (dof << 3))
offset += temp >> 2;
else if (f->pulses[i] + offset < 3 * (dof << 3))
offset += temp >> 3;
fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
max_bits = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
max_bits = FFMAX(max_bits, 0);
f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
/* If fine_bits was rounded down or capped,
* give priority for the final fine energy pass */
f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
/* the remaining bits are assigned to PVQ */
f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
} else {
/* all bits go to fine energy except for the sign bit */
extrabits = FFMAX(f->pulses[i] - (f->channels << 3), 0);
f->pulses[i] -= extrabits;
f->fine_bits[i] = 0;
f->fine_priority[i] = 1;
}
/* hand back a limited number of extra fine energy bits to this band */
if (extrabits > 0) {
int fineextra = FFMIN(extrabits >> (f->channels + 2),
CELT_MAX_FINE_BITS - f->fine_bits[i]);
f->fine_bits[i] += fineextra;
fineextra <<= f->channels + 2;
f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
extrabits -= fineextra;
}
}
f->remaining = extrabits;
/* skipped bands dedicate all of their bits for fine energy */
for (; i < f->end_band; i++) {
f->fine_bits[i] = f->pulses[i] >> (f->channels - 1) >> 3;
f->pulses[i] = 0;
f->fine_priority[i] = f->fine_bits[i] < 1;
}
}

876
libavcodec/opus_celt.c
Unescape View File

@ -1,7 +1,6 @@
/* /*
* Copyright (c) 2012 Andrew D'Addesio * Copyright (c) 2012 Andrew D'Addesio
* Copyright (c) 2013-2014 Mozilla Corporation * Copyright (c) 2013-2014 Mozilla Corporation
* Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
* *
* This file is part of FFmpeg. * This file is part of FFmpeg.
* *
@ -20,567 +19,466 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
/** #include <stdint.h>
* @file
* Opus CELT decoder
*/
#include <float.h>
#include "opus_celt.h" #include "opus_celt.h"
#include "opustab.h"
#include "opus_pvq.h" #include "opus_pvq.h"
#include "opustab.h"
/* Use the 2D z-transform to apply prediction in both the time domain (alpha) void ff_celt_quant_bands(CeltFrame *f, OpusRangeCoder *rc)
* and the frequency domain (beta) */
static void celt_decode_coarse_energy(CeltFrame *f, OpusRangeCoder *rc)
{ {
int i, j; float lowband_scratch[8 * 22];
float prev[2] = { 0 }; float norm1[2 * 8 * 100];
float alpha = ff_celt_alpha_coef[f->size]; float *norm2 = norm1 + 8 * 100;
float beta = ff_celt_beta_coef[f->size];
const uint8_t *model = ff_celt_coarse_energy_dist[f->size][0];
/* intra frame */
if (opus_rc_tell(rc) + 3 <= f->framebits && ff_opus_rc_dec_log(rc, 3)) {
alpha = 0.0f;
beta = 1.0f - (4915.0f/32768.0f);
model = ff_celt_coarse_energy_dist[f->size][1];
}
for (i = 0; i < CELT_MAX_BANDS; i++) { int totalbits = (f->framebits << 3) - f->anticollapse_needed;
for (j = 0; j < f->channels; j++) {
CeltBlock *block = &f->block[j];
float value;
int available;
if (i < f->start_band || i >= f->end_band) { int update_lowband = 1;
block->energy[i] = 0.0; int lowband_offset = 0;
continue;
}
available = f->framebits - opus_rc_tell(rc); int i, j;
if (available >= 15) {
/* decode using a Laplace distribution */
int k = FFMIN(i, 20) << 1;
value = ff_opus_rc_dec_laplace(rc, model[k] << 7, model[k+1] << 6);
} else if (available >= 2) {
int x = ff_opus_rc_dec_cdf(rc, ff_celt_model_energy_small);
value = (x>>1) ^ -(x&1);
} else if (available >= 1) {
value = -(float)ff_opus_rc_dec_log(rc, 1);
} else value = -1;
block->energy[i] = FFMAX(-9.0f, block->energy[i]) * alpha + prev[j] + value;
prev[j] += beta * value;
}
}
}
static void celt_decode_fine_energy(CeltFrame *f, OpusRangeCoder *rc)
{
int i;
for (i = f->start_band; i < f->end_band; i++) { for (i = f->start_band; i < f->end_band; i++) {
int j; uint32_t cm[2] = { (1 << f->blocks) - 1, (1 << f->blocks) - 1 };
if (!f->fine_bits[i]) int band_offset = ff_celt_freq_bands[i] << f->size;
continue; int band_size = ff_celt_freq_range[i] << f->size;
float *X = f->block[0].coeffs + band_offset;
for (j = 0; j < f->channels; j++) { float *Y = (f->channels == 2) ? f->block[1].coeffs + band_offset : NULL;
CeltBlock *block = &f->block[j]; float *norm_loc1, *norm_loc2;
int q2;
float offset; int consumed = opus_rc_tell_frac(rc);
q2 = ff_opus_rc_get_raw(rc, f->fine_bits[i]); int effective_lowband = -1;
offset = (q2 + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f - 0.5f; int b = 0;
block->energy[i] += offset;
/* Compute how many bits we want to allocate to this band */
if (i != f->start_band)
f->remaining -= consumed;
f->remaining2 = totalbits - consumed - 1;
if (i <= f->coded_bands - 1) {
int curr_balance = f->remaining / FFMIN(3, f->coded_bands-i);
b = av_clip_uintp2(FFMIN(f->remaining2 + 1, f->pulses[i] + curr_balance), 14);
} }
}
}
static void celt_decode_final_energy(CeltFrame *f, OpusRangeCoder *rc) if ((ff_celt_freq_bands[i] - ff_celt_freq_range[i] >= ff_celt_freq_bands[f->start_band] ||
{ i == f->start_band + 1) && (update_lowband || lowband_offset == 0))
int priority, i, j; lowband_offset = i;
int bits_left = f->framebits - opus_rc_tell(rc);
for (priority = 0; priority < 2; priority++) {
for (i = f->start_band; i < f->end_band && bits_left >= f->channels; i++) {
if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
continue;
for (j = 0; j < f->channels; j++) {
int q2;
float offset;
q2 = ff_opus_rc_get_raw(rc, 1);
offset = (q2 - 0.5f) * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
f->block[j].energy[i] += offset;
bits_left--;
}
}
}
}
static void celt_decode_tf_changes(CeltFrame *f, OpusRangeCoder *rc) if (i == f->start_band + 1) {
{ /* Special Hybrid Folding (RFC 8251 section 9). Copy the first band into
int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit; the second to ensure the second band never has to use the LCG. */
int consumed, bits = f->transient ? 2 : 4; int count = (ff_celt_freq_range[i] - ff_celt_freq_range[i-1]) << f->size;
consumed = opus_rc_tell(rc); memcpy(&norm1[band_offset], &norm1[band_offset - count], count * sizeof(float));
tf_select_bit = (f->size != 0 && consumed+bits+1 <= f->framebits);
for (i = f->start_band; i < f->end_band; i++) { if (f->channels == 2)
if (consumed+bits+tf_select_bit <= f->framebits) { memcpy(&norm2[band_offset], &norm2[band_offset - count], count * sizeof(float));
diff ^= ff_opus_rc_dec_log(rc, bits);
consumed = opus_rc_tell(rc);
tf_changed |= diff;
} }
f->tf_change[i] = diff;
bits = f->transient ? 4 : 5;
}
if (tf_select_bit && ff_celt_tf_select[f->size][f->transient][0][tf_changed] != /* Get a conservative estimate of the collapse_mask's for the bands we're
ff_celt_tf_select[f->size][f->transient][1][tf_changed]) going to be folding from. */
tf_select = ff_opus_rc_dec_log(rc, 1); if (lowband_offset != 0 && (f->spread != CELT_SPREAD_AGGRESSIVE ||
f->blocks > 1 || f->tf_change[i] < 0)) {
int foldstart, foldend;
/* This ensures we never repeat spectral content within one band */
effective_lowband = FFMAX(ff_celt_freq_bands[f->start_band],
ff_celt_freq_bands[lowband_offset] - ff_celt_freq_range[i]);
foldstart = lowband_offset;
while (ff_celt_freq_bands[--foldstart] > effective_lowband);
foldend = lowband_offset - 1;
while (++foldend < i && ff_celt_freq_bands[foldend] < effective_lowband + ff_celt_freq_range[i]);
cm[0] = cm[1] = 0;
for (j = foldstart; j < foldend; j++) {
cm[0] |= f->block[0].collapse_masks[j];
cm[1] |= f->block[f->channels - 1].collapse_masks[j];
}
}
for (i = f->start_band; i < f->end_band; i++) { if (f->dual_stereo && i == f->intensity_stereo) {
f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]]; /* Switch off dual stereo to do intensity */
} f->dual_stereo = 0;
} for (j = ff_celt_freq_bands[f->start_band] << f->size; j < band_offset; j++)
norm1[j] = (norm1[j] + norm2[j]) / 2;
}
static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data) norm_loc1 = effective_lowband != -1 ? norm1 + (effective_lowband << f->size) : NULL;
{ norm_loc2 = effective_lowband != -1 ? norm2 + (effective_lowband << f->size) : NULL;
int i, j;
for (i = f->start_band; i < f->end_band; i++) { if (f->dual_stereo) {
float *dst = data + (ff_celt_freq_bands[i] << f->size); cm[0] = f->pvq->quant_band(f->pvq, f, rc, i, X, NULL, band_size, b >> 1,
float log_norm = block->energy[i] + ff_celt_mean_energy[i]; f->blocks, norm_loc1, f->size,
float norm = exp2f(FFMIN(log_norm, 32.0f)); norm1 + band_offset, 0, 1.0f,
lowband_scratch, cm[0]);
for (j = 0; j < ff_celt_freq_range[i] << f->size; j++) cm[1] = f->pvq->quant_band(f->pvq, f, rc, i, Y, NULL, band_size, b >> 1,
dst[j] *= norm; f->blocks, norm_loc2, f->size,
} norm2 + band_offset, 0, 1.0f,
} lowband_scratch, cm[1]);
} else {
cm[0] = f->pvq->quant_band(f->pvq, f, rc, i, X, Y, band_size, b >> 0,
f->blocks, norm_loc1, f->size,
norm1 + band_offset, 0, 1.0f,
lowband_scratch, cm[0] | cm[1]);
cm[1] = cm[0];
}
static void celt_postfilter_apply_transition(CeltBlock *block, float *data) f->block[0].collapse_masks[i] = (uint8_t)cm[0];
{ f->block[f->channels - 1].collapse_masks[i] = (uint8_t)cm[1];
const int T0 = block->pf_period_old; f->remaining += f->pulses[i] + consumed;
const int T1 = block->pf_period;
/* Update the folding position only as long as we have 1 bit/sample depth */
float g00, g01, g02; update_lowband = (b > band_size << 3);
float g10, g11, g12;
float x0, x1, x2, x3, x4;
int i;
if (block->pf_gains[0] == 0.0 &&
block->pf_gains_old[0] == 0.0)
return;
g00 = block->pf_gains_old[0];
g01 = block->pf_gains_old[1];
g02 = block->pf_gains_old[2];
g10 = block->pf_gains[0];
g11 = block->pf_gains[1];
g12 = block->pf_gains[2];
x1 = data[-T1 + 1];
x2 = data[-T1];
x3 = data[-T1 - 1];
x4 = data[-T1 - 2];
for (i = 0; i < CELT_OVERLAP; i++) {
float w = ff_celt_window2[i];
x0 = data[i - T1 + 2];
data[i] += (1.0 - w) * g00 * data[i - T0] +
(1.0 - w) * g01 * (data[i - T0 - 1] + data[i - T0 + 1]) +
(1.0 - w) * g02 * (data[i - T0 - 2] + data[i - T0 + 2]) +
w * g10 * x2 +
w * g11 * (x1 + x3) +
w * g12 * (x0 + x4);
x4 = x3;
x3 = x2;
x2 = x1;
x1 = x0;
} }
} }
static void celt_postfilter(CeltFrame *f, CeltBlock *block) #define NORMC(bits) ((bits) << (f->channels - 1) << f->size >> 2)
void ff_celt_bitalloc(CeltFrame *f, OpusRangeCoder *rc, int encode)
{ {
int len = f->blocksize * f->blocks; int i, j, low, high, total, done, bandbits, remaining, tbits_8ths;
const int filter_len = len - 2 * CELT_OVERLAP; int skip_startband = f->start_band;
int skip_bit = 0;
int intensitystereo_bit = 0;
int dualstereo_bit = 0;
int dynalloc = 6;
int extrabits = 0;
int boost[CELT_MAX_BANDS] = { 0 };
int trim_offset[CELT_MAX_BANDS];
int threshold[CELT_MAX_BANDS];
int bits1[CELT_MAX_BANDS];
int bits2[CELT_MAX_BANDS];
/* Spread */
if (opus_rc_tell(rc) + 4 <= f->framebits) {
if (encode)
ff_opus_rc_enc_cdf(rc, f->spread, ff_celt_model_spread);
else
f->spread = ff_opus_rc_dec_cdf(rc, ff_celt_model_spread);
} else {
f->spread = CELT_SPREAD_NORMAL;
}
celt_postfilter_apply_transition(block, block->buf + 1024); /* Initialize static allocation caps */
for (i = 0; i < CELT_MAX_BANDS; i++)
f->caps[i] = NORMC((ff_celt_static_caps[f->size][f->channels - 1][i] + 64) * ff_celt_freq_range[i]);
block->pf_period_old = block->pf_period; /* Band boosts */
memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains)); tbits_8ths = f->framebits << 3;
for (i = f->start_band; i < f->end_band; i++) {
int quanta = ff_celt_freq_range[i] << (f->channels - 1) << f->size;
int b_dynalloc = dynalloc;
int boost_amount = f->alloc_boost[i];
quanta = FFMIN(quanta << 3, FFMAX(6 << 3, quanta));
while (opus_rc_tell_frac(rc) + (b_dynalloc << 3) < tbits_8ths && boost[i] < f->caps[i]) {
int is_boost;
if (encode) {
is_boost = boost_amount--;
ff_opus_rc_enc_log(rc, is_boost, b_dynalloc);
} else {
is_boost = ff_opus_rc_dec_log(rc, b_dynalloc);
}
block->pf_period = block->pf_period_new; if (!is_boost)
memcpy(block->pf_gains, block->pf_gains_new, sizeof(block->pf_gains)); break;
if (len > CELT_OVERLAP) { boost[i] += quanta;
celt_postfilter_apply_transition(block, block->buf + 1024 + CELT_OVERLAP); tbits_8ths -= quanta;
if (block->pf_gains[0] > FLT_EPSILON && filter_len > 0) b_dynalloc = 1;
f->opusdsp.postfilter(block->buf + 1024 + 2 * CELT_OVERLAP, }
block->pf_period, block->pf_gains,
filter_len);
block->pf_period_old = block->pf_period; if (boost[i])
memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains)); dynalloc = FFMAX(dynalloc - 1, 2);
} }
memmove(block->buf, block->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float)); /* Allocation trim */
} if (!encode)
f->alloc_trim = 5;
static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed) if (opus_rc_tell_frac(rc) + (6 << 3) <= tbits_8ths)
{ if (encode)
int i; ff_opus_rc_enc_cdf(rc, f->alloc_trim, ff_celt_model_alloc_trim);
else
memset(f->block[0].pf_gains_new, 0, sizeof(f->block[0].pf_gains_new)); f->alloc_trim = ff_opus_rc_dec_cdf(rc, ff_celt_model_alloc_trim);
memset(f->block[1].pf_gains_new, 0, sizeof(f->block[1].pf_gains_new));
/* Anti-collapse bit reservation */
if (f->start_band == 0 && consumed + 16 <= f->framebits) { tbits_8ths = (f->framebits << 3) - opus_rc_tell_frac(rc) - 1;
int has_postfilter = ff_opus_rc_dec_log(rc, 1); f->anticollapse_needed = 0;
if (has_postfilter) { if (f->transient && f->size >= 2 && tbits_8ths >= ((f->size + 2) << 3))
float gain; f->anticollapse_needed = 1 << 3;
int tapset, octave, period; tbits_8ths -= f->anticollapse_needed;
octave = ff_opus_rc_dec_uint(rc, 6); /* Band skip bit reservation */
period = (16 << octave) + ff_opus_rc_get_raw(rc, 4 + octave) - 1; if (tbits_8ths >= 1 << 3)
gain = 0.09375f * (ff_opus_rc_get_raw(rc, 3) + 1); skip_bit = 1 << 3;
tapset = (opus_rc_tell(rc) + 2 <= f->framebits) ? tbits_8ths -= skip_bit;
ff_opus_rc_dec_cdf(rc, ff_celt_model_tapset) : 0;
/* Intensity/dual stereo bit reservation */
for (i = 0; i < 2; i++) { if (f->channels == 2) {
CeltBlock *block = &f->block[i]; intensitystereo_bit = ff_celt_log2_frac[f->end_band - f->start_band];
if (intensitystereo_bit <= tbits_8ths) {
block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD); tbits_8ths -= intensitystereo_bit;
block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0]; if (tbits_8ths >= 1 << 3) {
block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1]; dualstereo_bit = 1 << 3;
block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2]; tbits_8ths -= 1 << 3;
} }
} else {
intensitystereo_bit = 0;
} }
consumed = opus_rc_tell(rc);
} }
return consumed; /* Trim offsets */
}
static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
{
int i, j, k;
for (i = f->start_band; i < f->end_band; i++) { for (i = f->start_band; i < f->end_band; i++) {
int renormalize = 0; int trim = f->alloc_trim - 5 - f->size;
float *xptr; int band = ff_celt_freq_range[i] * (f->end_band - i - 1);
float prev[2]; int duration = f->size + 3;
float Ediff, r; int scale = duration + f->channels - 1;
float thresh, sqrt_1;
int depth;
/* depth in 1/8 bits */
depth = (1 + f->pulses[i]) / (ff_celt_freq_range[i] << f->size);
thresh = exp2f(-1.0 - 0.125f * depth);
sqrt_1 = 1.0f / sqrtf(ff_celt_freq_range[i] << f->size);
xptr = X + (ff_celt_freq_bands[i] << f->size);
prev[0] = block->prev_energy[0][i];
prev[1] = block->prev_energy[1][i];
if (f->channels == 1) {
CeltBlock *block1 = &f->block[1];
prev[0] = FFMAX(prev[0], block1->prev_energy[0][i]);
prev[1] = FFMAX(prev[1], block1->prev_energy[1][i]);
}
Ediff = block->energy[i] - FFMIN(prev[0], prev[1]);
Ediff = FFMAX(0, Ediff);
/* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
short blocks don't have the same energy as long */
r = exp2f(1 - Ediff);
if (f->size == 3)
r *= M_SQRT2;
r = FFMIN(thresh, r) * sqrt_1;
for (k = 0; k < 1 << f->size; k++) {
/* Detect collapse */
if (!(block->collapse_masks[i] & 1 << k)) {
/* Fill with noise */
for (j = 0; j < ff_celt_freq_range[i]; j++)
xptr[(j << f->size) + k] = (celt_rng(f) & 0x8000) ? r : -r;
renormalize = 1;
}
}
/* We just added some energy, so we need to renormalize */ /* PVQ minimum allocation threshold, below this value the band is
if (renormalize) * skipped */
celt_renormalize_vector(xptr, ff_celt_freq_range[i] << f->size, 1.0f); threshold[i] = FFMAX(3 * ff_celt_freq_range[i] << duration >> 4,
} f->channels << 3);
}
int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc, trim_offset[i] = trim * (band << scale) >> 6;
float **output, int channels, int frame_size,
int start_band, int end_band)
{
int i, j, downmix = 0;
int consumed; // bits of entropy consumed thus far for this frame
AVTXContext *imdct;
av_tx_fn imdct_fn;
if (channels != 1 && channels != 2) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
channels);
return AVERROR_INVALIDDATA;
}
if (start_band < 0 || start_band > end_band || end_band > CELT_MAX_BANDS) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
start_band, end_band);
return AVERROR_INVALIDDATA;
}
f->silence = 0; if (ff_celt_freq_range[i] << f->size == 1)
f->transient = 0; trim_offset[i] -= f->channels << 3;
f->anticollapse = 0;
f->flushed = 0;
f->channels = channels;
f->start_band = start_band;
f->end_band = end_band;
f->framebits = rc->rb.bytes * 8;
f->size = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
if (f->size > CELT_MAX_LOG_BLOCKS ||
frame_size != CELT_SHORT_BLOCKSIZE * (1 << f->size)) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
frame_size);
return AVERROR_INVALIDDATA;
} }
if (!f->output_channels) /* Bisection */
f->output_channels = channels; low = 1;
high = CELT_VECTORS - 1;
while (low <= high) {
int center = (low + high) >> 1;
done = total = 0;
for (i = f->end_band - 1; i >= f->start_band; i--) {
bandbits = NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[center][i]);
if (bandbits)
bandbits = FFMAX(bandbits + trim_offset[i], 0);
bandbits += boost[i];
if (bandbits >= threshold[i] || done) {
done = 1;
total += FFMIN(bandbits, f->caps[i]);
} else if (bandbits >= f->channels << 3) {
total += f->channels << 3;
}
}
for (i = 0; i < f->channels; i++) { if (total > tbits_8ths)
memset(f->block[i].coeffs, 0, sizeof(f->block[i].coeffs)); high = center - 1;
memset(f->block[i].collapse_masks, 0, sizeof(f->block[i].collapse_masks)); else
low = center + 1;
} }
high = low--;
consumed = opus_rc_tell(rc); /* Bisection */
for (i = f->start_band; i < f->end_band; i++) {
/* obtain silence flag */ bits1[i] = NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[low][i]);
if (consumed >= f->framebits) bits2[i] = high >= CELT_VECTORS ? f->caps[i] :
f->silence = 1; NORMC(ff_celt_freq_range[i] * ff_celt_static_alloc[high][i]);
else if (consumed == 1)
f->silence = ff_opus_rc_dec_log(rc, 15); if (bits1[i])
bits1[i] = FFMAX(bits1[i] + trim_offset[i], 0);
if (bits2[i])
if (f->silence) { bits2[i] = FFMAX(bits2[i] + trim_offset[i], 0);
consumed = f->framebits;
rc->total_bits += f->framebits - opus_rc_tell(rc); if (low)
bits1[i] += boost[i];
bits2[i] += boost[i];
if (boost[i])
skip_startband = i;
bits2[i] = FFMAX(bits2[i] - bits1[i], 0);
} }
/* obtain post-filter options */ /* Bisection */
consumed = parse_postfilter(f, rc, consumed); low = 0;
high = 1 << CELT_ALLOC_STEPS;
/* obtain transient flag */ for (i = 0; i < CELT_ALLOC_STEPS; i++) {
if (f->size != 0 && consumed+3 <= f->framebits) int center = (low + high) >> 1;
f->transient = ff_opus_rc_dec_log(rc, 3); done = total = 0;
f->blocks = f->transient ? 1 << f->size : 1; for (j = f->end_band - 1; j >= f->start_band; j--) {
f->blocksize = frame_size / f->blocks; bandbits = bits1[j] + (center * bits2[j] >> CELT_ALLOC_STEPS);
imdct = f->tx[f->transient ? 0 : f->size]; if (bandbits >= threshold[j] || done) {
imdct_fn = f->tx_fn[f->transient ? 0 : f->size]; done = 1;
total += FFMIN(bandbits, f->caps[j]);
if (channels == 1) { } else if (bandbits >= f->channels << 3)
for (i = 0; i < CELT_MAX_BANDS; i++) total += f->channels << 3;
f->block[0].energy[i] = FFMAX(f->block[0].energy[i], f->block[1].energy[i]); }
if (total > tbits_8ths)
high = center;
else
low = center;
} }
celt_decode_coarse_energy(f, rc); /* Bisection */
celt_decode_tf_changes (f, rc); done = total = 0;
ff_celt_bitalloc (f, rc, 0); for (i = f->end_band - 1; i >= f->start_band; i--) {
celt_decode_fine_energy (f, rc); bandbits = bits1[i] + (low * bits2[i] >> CELT_ALLOC_STEPS);
ff_celt_quant_bands (f, rc);
if (f->anticollapse_needed)
f->anticollapse = ff_opus_rc_get_raw(rc, 1);
celt_decode_final_energy(f, rc);
/* apply anti-collapse processing and denormalization to
* each coded channel */
for (i = 0; i < f->channels; i++) {
CeltBlock *block = &f->block[i];
if (f->anticollapse) if (bandbits >= threshold[i] || done)
process_anticollapse(f, block, f->block[i].coeffs); done = 1;
else
bandbits = (bandbits >= f->channels << 3) ?
f->channels << 3 : 0;
celt_denormalize(f, block, f->block[i].coeffs); bandbits = FFMIN(bandbits, f->caps[i]);
f->pulses[i] = bandbits;
total += bandbits;
} }
/* stereo -> mono downmix */ /* Band skipping */
if (f->output_channels < f->channels) { for (f->coded_bands = f->end_band; ; f->coded_bands--) {
f->dsp->vector_fmac_scalar(f->block[0].coeffs, f->block[1].coeffs, 1.0, FFALIGN(frame_size, 16)); int allocation;
downmix = 1; j = f->coded_bands - 1;
} else if (f->output_channels > f->channels)
memcpy(f->block[1].coeffs, f->block[0].coeffs, frame_size * sizeof(float));
if (f->silence) { if (j == skip_startband) {
for (i = 0; i < 2; i++) { /* all remaining bands are not skipped */
CeltBlock *block = &f->block[i]; tbits_8ths += skip_bit;
break;
for (j = 0; j < FF_ARRAY_ELEMS(block->energy); j++)
block->energy[j] = CELT_ENERGY_SILENCE;
} }
memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
memset(f->block[1].coeffs, 0, sizeof(f->block[1].coeffs));
}
/* transform and output for each output channel */ /* determine the number of bits available for coding "do not skip" markers */
for (i = 0; i < f->output_channels; i++) { remaining = tbits_8ths - total;
CeltBlock *block = &f->block[i]; bandbits = remaining / (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
remaining -= bandbits * (ff_celt_freq_bands[j+1] - ff_celt_freq_bands[f->start_band]);
allocation = f->pulses[j] + bandbits * ff_celt_freq_range[j];
allocation += FFMAX(remaining - (ff_celt_freq_bands[j] - ff_celt_freq_bands[f->start_band]), 0);
/* a "do not skip" marker is only coded if the allocation is
* above the chosen threshold */
if (allocation >= FFMAX(threshold[j], (f->channels + 1) << 3)) {
int do_not_skip;
if (encode) {
do_not_skip = f->coded_bands <= f->skip_band_floor;
ff_opus_rc_enc_log(rc, do_not_skip, 1);
} else {
do_not_skip = ff_opus_rc_dec_log(rc, 1);
}
/* iMDCT and overlap-add */ if (do_not_skip)
for (j = 0; j < f->blocks; j++) { break;
float *dst = block->buf + 1024 + j * f->blocksize;
imdct_fn(imdct, dst + CELT_OVERLAP / 2, f->block[i].coeffs + j, total += 1 << 3;
sizeof(float)*f->blocks); allocation -= 1 << 3;
f->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
ff_celt_window, CELT_OVERLAP / 2);
} }
if (downmix) /* the band is skipped, so reclaim its bits */
f->dsp->vector_fmul_scalar(&block->buf[1024], &block->buf[1024], 0.5f, frame_size); total -= f->pulses[j];
if (intensitystereo_bit) {
/* postfilter */ total -= intensitystereo_bit;
celt_postfilter(f, block); intensitystereo_bit = ff_celt_log2_frac[j - f->start_band];
total += intensitystereo_bit;
/* deemphasis */
block->emph_coeff = f->opusdsp.deemphasis(output[i],
&block->buf[1024 - frame_size],
block->emph_coeff, frame_size);
}
if (channels == 1)
memcpy(f->block[1].energy, f->block[0].energy, sizeof(f->block[0].energy));
for (i = 0; i < 2; i++ ) {
CeltBlock *block = &f->block[i];
if (!f->transient) {
memcpy(block->prev_energy[1], block->prev_energy[0], sizeof(block->prev_energy[0]));
memcpy(block->prev_energy[0], block->energy, sizeof(block->prev_energy[0]));
} else {
for (j = 0; j < CELT_MAX_BANDS; j++)
block->prev_energy[0][j] = FFMIN(block->prev_energy[0][j], block->energy[j]);
} }
for (j = 0; j < f->start_band; j++) { total += f->pulses[j] = (allocation >= f->channels << 3) ? f->channels << 3 : 0;
block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
block->energy[j] = 0.0;
}
for (j = f->end_band; j < CELT_MAX_BANDS; j++) {
block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
block->energy[j] = 0.0;
}
} }
f->seed = rc->range; /* IS start band */
if (encode) {
return 0; if (intensitystereo_bit) {
} f->intensity_stereo = FFMIN(f->intensity_stereo, f->coded_bands);
ff_opus_rc_enc_uint(rc, f->intensity_stereo, f->coded_bands + 1 - f->start_band);
void ff_celt_flush(CeltFrame *f) }
{ } else {
int i, j; f->intensity_stereo = f->dual_stereo = 0;
if (intensitystereo_bit)
if (f->flushed) f->intensity_stereo = f->start_band + ff_opus_rc_dec_uint(rc, f->coded_bands + 1 - f->start_band);
return;
for (i = 0; i < 2; i++) {
CeltBlock *block = &f->block[i];
for (j = 0; j < CELT_MAX_BANDS; j++)
block->prev_energy[0][j] = block->prev_energy[1][j] = CELT_ENERGY_SILENCE;
memset(block->energy, 0, sizeof(block->energy));
memset(block->buf, 0, sizeof(block->buf));
memset(block->pf_gains, 0, sizeof(block->pf_gains));
memset(block->pf_gains_old, 0, sizeof(block->pf_gains_old));
memset(block->pf_gains_new, 0, sizeof(block->pf_gains_new));
/* libopus uses CELT_EMPH_COEFF on init, but 0 is better since there's
* a lesser discontinuity when seeking.
* The deemphasis functions differ from libopus in that they require
* an initial state divided by the coefficient. */
block->emph_coeff = 0.0f / CELT_EMPH_COEFF;
} }
f->seed = 0;
f->flushed = 1;
}
void ff_celt_free(CeltFrame **f)
{
CeltFrame *frm = *f;
int i;
if (!frm) /* DS flag */
return; if (f->intensity_stereo <= f->start_band)
tbits_8ths += dualstereo_bit; /* no intensity stereo means no dual stereo */
for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++) else if (dualstereo_bit)
av_tx_uninit(&frm->tx[i]); if (encode)
ff_opus_rc_enc_log(rc, f->dual_stereo, 1);
ff_celt_pvq_uninit(&frm->pvq); else
f->dual_stereo = ff_opus_rc_dec_log(rc, 1);
av_freep(&frm->dsp);
av_freep(f); /* Supply the remaining bits in this frame to lower bands */
} remaining = tbits_8ths - total;
bandbits = remaining / (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels, remaining -= bandbits * (ff_celt_freq_bands[f->coded_bands] - ff_celt_freq_bands[f->start_band]);
int apply_phase_inv) for (i = f->start_band; i < f->coded_bands; i++) {
{ const int bits = FFMIN(remaining, ff_celt_freq_range[i]);
CeltFrame *frm; f->pulses[i] += bits + bandbits * ff_celt_freq_range[i];
int i, ret; remaining -= bits;
if (output_channels != 1 && output_channels != 2) {
av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
output_channels);
return AVERROR(EINVAL);
} }
frm = av_mallocz(sizeof(*frm)); /* Finally determine the allocation */
if (!frm) for (i = f->start_band; i < f->coded_bands; i++) {
return AVERROR(ENOMEM); int N = ff_celt_freq_range[i] << f->size;
int prev_extra = extrabits;
f->pulses[i] += extrabits;
if (N > 1) {
int dof; /* degrees of freedom */
int temp; /* dof * channels * log(dof) */
int fine_bits;
int max_bits;
int offset; /* fine energy quantization offset, i.e.
* extra bits assigned over the standard
* totalbits/dof */
extrabits = FFMAX(f->pulses[i] - f->caps[i], 0);
f->pulses[i] -= extrabits;
/* intensity stereo makes use of an extra degree of freedom */
dof = N * f->channels + (f->channels == 2 && N > 2 && !f->dual_stereo && i < f->intensity_stereo);
temp = dof * (ff_celt_log_freq_range[i] + (f->size << 3));
offset = (temp >> 1) - dof * CELT_FINE_OFFSET;
if (N == 2) /* dof=2 is the only case that doesn't fit the model */
offset += dof << 1;
/* grant an additional bias for the first and second pulses */
if (f->pulses[i] + offset < 2 * (dof << 3))
offset += temp >> 2;
else if (f->pulses[i] + offset < 3 * (dof << 3))
offset += temp >> 3;
fine_bits = (f->pulses[i] + offset + (dof << 2)) / (dof << 3);
max_bits = FFMIN((f->pulses[i] >> 3) >> (f->channels - 1), CELT_MAX_FINE_BITS);
max_bits = FFMAX(max_bits, 0);
f->fine_bits[i] = av_clip(fine_bits, 0, max_bits);
/* If fine_bits was rounded down or capped,
* give priority for the final fine energy pass */
f->fine_priority[i] = (f->fine_bits[i] * (dof << 3) >= f->pulses[i] + offset);
/* the remaining bits are assigned to PVQ */
f->pulses[i] -= f->fine_bits[i] << (f->channels - 1) << 3;
} else {
/* all bits go to fine energy except for the sign bit */
extrabits = FFMAX(f->pulses[i] - (f->channels << 3), 0);
f->pulses[i] -= extrabits;
f->fine_bits[i] = 0;
f->fine_priority[i] = 1;
}
frm->avctx = avctx; /* hand back a limited number of extra fine energy bits to this band */
frm->output_channels = output_channels; if (extrabits > 0) {
frm->apply_phase_inv = apply_phase_inv; int fineextra = FFMIN(extrabits >> (f->channels + 2),
CELT_MAX_FINE_BITS - f->fine_bits[i]);
f->fine_bits[i] += fineextra;
for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++) { fineextra <<= f->channels + 2;
const float scale = -1.0f/32768; f->fine_priority[i] = (fineextra >= extrabits - prev_extra);
if ((ret = av_tx_init(&frm->tx[i], &frm->tx_fn[i], AV_TX_FLOAT_MDCT, 1, 15 << (i + 3), &scale, 0)) < 0) extrabits -= fineextra;
goto fail; }
} }
f->remaining = extrabits;
if ((ret = ff_celt_pvq_init(&frm->pvq, 0)) < 0) /* skipped bands dedicate all of their bits for fine energy */
goto fail; for (; i < f->end_band; i++) {
f->fine_bits[i] = f->pulses[i] >> (f->channels - 1) >> 3;
frm->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT); f->pulses[i] = 0;
if (!frm->dsp) { f->fine_priority[i] = f->fine_bits[i] < 1;
ret = AVERROR(ENOMEM);
goto fail;
} }
ff_opus_dsp_init(&frm->opusdsp);
ff_celt_flush(frm);
*f = frm;
return 0;
fail:
ff_celt_free(&frm);
return ret;
} }

586
libavcodec/opusdec_celt.c
Unescape View File

@ -0,0 +1,586 @@
/*
* Copyright (c) 2012 Andrew D'Addesio
* Copyright (c) 2013-2014 Mozilla Corporation
* Copyright (c) 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* Opus CELT decoder
*/
#include <float.h>
#include "opus_celt.h"
#include "opustab.h"
#include "opus_pvq.h"
/* Use the 2D z-transform to apply prediction in both the time domain (alpha)
* and the frequency domain (beta) */
static void celt_decode_coarse_energy(CeltFrame *f, OpusRangeCoder *rc)
{
int i, j;
float prev[2] = { 0 };
float alpha = ff_celt_alpha_coef[f->size];
float beta = ff_celt_beta_coef[f->size];
const uint8_t *model = ff_celt_coarse_energy_dist[f->size][0];
/* intra frame */
if (opus_rc_tell(rc) + 3 <= f->framebits && ff_opus_rc_dec_log(rc, 3)) {
alpha = 0.0f;
beta = 1.0f - (4915.0f/32768.0f);
model = ff_celt_coarse_energy_dist[f->size][1];
}
for (i = 0; i < CELT_MAX_BANDS; i++) {
for (j = 0; j < f->channels; j++) {
CeltBlock *block = &f->block[j];
float value;
int available;
if (i < f->start_band || i >= f->end_band) {
block->energy[i] = 0.0;
continue;
}
available = f->framebits - opus_rc_tell(rc);
if (available >= 15) {
/* decode using a Laplace distribution */
int k = FFMIN(i, 20) << 1;
value = ff_opus_rc_dec_laplace(rc, model[k] << 7, model[k+1] << 6);
} else if (available >= 2) {
int x = ff_opus_rc_dec_cdf(rc, ff_celt_model_energy_small);
value = (x>>1) ^ -(x&1);
} else if (available >= 1) {
value = -(float)ff_opus_rc_dec_log(rc, 1);
} else value = -1;
block->energy[i] = FFMAX(-9.0f, block->energy[i]) * alpha + prev[j] + value;
prev[j] += beta * value;
}
}
}
static void celt_decode_fine_energy(CeltFrame *f, OpusRangeCoder *rc)
{
int i;
for (i = f->start_band; i < f->end_band; i++) {
int j;
if (!f->fine_bits[i])
continue;
for (j = 0; j < f->channels; j++) {
CeltBlock *block = &f->block[j];
int q2;
float offset;
q2 = ff_opus_rc_get_raw(rc, f->fine_bits[i]);
offset = (q2 + 0.5f) * (1 << (14 - f->fine_bits[i])) / 16384.0f - 0.5f;
block->energy[i] += offset;
}
}
}
static void celt_decode_final_energy(CeltFrame *f, OpusRangeCoder *rc)
{
int priority, i, j;
int bits_left = f->framebits - opus_rc_tell(rc);
for (priority = 0; priority < 2; priority++) {
for (i = f->start_band; i < f->end_band && bits_left >= f->channels; i++) {
if (f->fine_priority[i] != priority || f->fine_bits[i] >= CELT_MAX_FINE_BITS)
continue;
for (j = 0; j < f->channels; j++) {
int q2;
float offset;
q2 = ff_opus_rc_get_raw(rc, 1);
offset = (q2 - 0.5f) * (1 << (14 - f->fine_bits[i] - 1)) / 16384.0f;
f->block[j].energy[i] += offset;
bits_left--;
}
}
}
}
static void celt_decode_tf_changes(CeltFrame *f, OpusRangeCoder *rc)
{
int i, diff = 0, tf_select = 0, tf_changed = 0, tf_select_bit;
int consumed, bits = f->transient ? 2 : 4;
consumed = opus_rc_tell(rc);
tf_select_bit = (f->size != 0 && consumed+bits+1 <= f->framebits);
for (i = f->start_band; i < f->end_band; i++) {
if (consumed+bits+tf_select_bit <= f->framebits) {
diff ^= ff_opus_rc_dec_log(rc, bits);
consumed = opus_rc_tell(rc);
tf_changed |= diff;
}
f->tf_change[i] = diff;
bits = f->transient ? 4 : 5;
}
if (tf_select_bit && ff_celt_tf_select[f->size][f->transient][0][tf_changed] !=
ff_celt_tf_select[f->size][f->transient][1][tf_changed])
tf_select = ff_opus_rc_dec_log(rc, 1);
for (i = f->start_band; i < f->end_band; i++) {
f->tf_change[i] = ff_celt_tf_select[f->size][f->transient][tf_select][f->tf_change[i]];
}
}
static void celt_denormalize(CeltFrame *f, CeltBlock *block, float *data)
{
int i, j;
for (i = f->start_band; i < f->end_band; i++) {
float *dst = data + (ff_celt_freq_bands[i] << f->size);
float log_norm = block->energy[i] + ff_celt_mean_energy[i];
float norm = exp2f(FFMIN(log_norm, 32.0f));
for (j = 0; j < ff_celt_freq_range[i] << f->size; j++)
dst[j] *= norm;
}
}
static void celt_postfilter_apply_transition(CeltBlock *block, float *data)
{
const int T0 = block->pf_period_old;
const int T1 = block->pf_period;
float g00, g01, g02;
float g10, g11, g12;
float x0, x1, x2, x3, x4;
int i;
if (block->pf_gains[0] == 0.0 &&
block->pf_gains_old[0] == 0.0)
return;
g00 = block->pf_gains_old[0];
g01 = block->pf_gains_old[1];
g02 = block->pf_gains_old[2];
g10 = block->pf_gains[0];
g11 = block->pf_gains[1];
g12 = block->pf_gains[2];
x1 = data[-T1 + 1];
x2 = data[-T1];
x3 = data[-T1 - 1];
x4 = data[-T1 - 2];
for (i = 0; i < CELT_OVERLAP; i++) {
float w = ff_celt_window2[i];
x0 = data[i - T1 + 2];
data[i] += (1.0 - w) * g00 * data[i - T0] +
(1.0 - w) * g01 * (data[i - T0 - 1] + data[i - T0 + 1]) +
(1.0 - w) * g02 * (data[i - T0 - 2] + data[i - T0 + 2]) +
w * g10 * x2 +
w * g11 * (x1 + x3) +
w * g12 * (x0 + x4);
x4 = x3;
x3 = x2;
x2 = x1;
x1 = x0;
}
}
static void celt_postfilter(CeltFrame *f, CeltBlock *block)
{
int len = f->blocksize * f->blocks;
const int filter_len = len - 2 * CELT_OVERLAP;
celt_postfilter_apply_transition(block, block->buf + 1024);
block->pf_period_old = block->pf_period;
memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
block->pf_period = block->pf_period_new;
memcpy(block->pf_gains, block->pf_gains_new, sizeof(block->pf_gains));
if (len > CELT_OVERLAP) {
celt_postfilter_apply_transition(block, block->buf + 1024 + CELT_OVERLAP);
if (block->pf_gains[0] > FLT_EPSILON && filter_len > 0)
f->opusdsp.postfilter(block->buf + 1024 + 2 * CELT_OVERLAP,
block->pf_period, block->pf_gains,
filter_len);
block->pf_period_old = block->pf_period;
memcpy(block->pf_gains_old, block->pf_gains, sizeof(block->pf_gains));
}
memmove(block->buf, block->buf + len, (1024 + CELT_OVERLAP / 2) * sizeof(float));
}
static int parse_postfilter(CeltFrame *f, OpusRangeCoder *rc, int consumed)
{
int i;
memset(f->block[0].pf_gains_new, 0, sizeof(f->block[0].pf_gains_new));
memset(f->block[1].pf_gains_new, 0, sizeof(f->block[1].pf_gains_new));
if (f->start_band == 0 && consumed + 16 <= f->framebits) {
int has_postfilter = ff_opus_rc_dec_log(rc, 1);
if (has_postfilter) {
float gain;
int tapset, octave, period;
octave = ff_opus_rc_dec_uint(rc, 6);
period = (16 << octave) + ff_opus_rc_get_raw(rc, 4 + octave) - 1;
gain = 0.09375f * (ff_opus_rc_get_raw(rc, 3) + 1);
tapset = (opus_rc_tell(rc) + 2 <= f->framebits) ?
ff_opus_rc_dec_cdf(rc, ff_celt_model_tapset) : 0;
for (i = 0; i < 2; i++) {
CeltBlock *block = &f->block[i];
block->pf_period_new = FFMAX(period, CELT_POSTFILTER_MINPERIOD);
block->pf_gains_new[0] = gain * ff_celt_postfilter_taps[tapset][0];
block->pf_gains_new[1] = gain * ff_celt_postfilter_taps[tapset][1];
block->pf_gains_new[2] = gain * ff_celt_postfilter_taps[tapset][2];
}
}
consumed = opus_rc_tell(rc);
}
return consumed;
}
static void process_anticollapse(CeltFrame *f, CeltBlock *block, float *X)
{
int i, j, k;
for (i = f->start_band; i < f->end_band; i++) {
int renormalize = 0;
float *xptr;
float prev[2];
float Ediff, r;
float thresh, sqrt_1;
int depth;
/* depth in 1/8 bits */
depth = (1 + f->pulses[i]) / (ff_celt_freq_range[i] << f->size);
thresh = exp2f(-1.0 - 0.125f * depth);
sqrt_1 = 1.0f / sqrtf(ff_celt_freq_range[i] << f->size);
xptr = X + (ff_celt_freq_bands[i] << f->size);
prev[0] = block->prev_energy[0][i];
prev[1] = block->prev_energy[1][i];
if (f->channels == 1) {
CeltBlock *block1 = &f->block[1];
prev[0] = FFMAX(prev[0], block1->prev_energy[0][i]);
prev[1] = FFMAX(prev[1], block1->prev_energy[1][i]);
}
Ediff = block->energy[i] - FFMIN(prev[0], prev[1]);
Ediff = FFMAX(0, Ediff);
/* r needs to be multiplied by 2 or 2*sqrt(2) depending on LM because
short blocks don't have the same energy as long */
r = exp2f(1 - Ediff);
if (f->size == 3)
r *= M_SQRT2;
r = FFMIN(thresh, r) * sqrt_1;
for (k = 0; k < 1 << f->size; k++) {
/* Detect collapse */
if (!(block->collapse_masks[i] & 1 << k)) {
/* Fill with noise */
for (j = 0; j < ff_celt_freq_range[i]; j++)
xptr[(j << f->size) + k] = (celt_rng(f) & 0x8000) ? r : -r;
renormalize = 1;
}
}
/* We just added some energy, so we need to renormalize */
if (renormalize)
celt_renormalize_vector(xptr, ff_celt_freq_range[i] << f->size, 1.0f);
}
}
int ff_celt_decode_frame(CeltFrame *f, OpusRangeCoder *rc,
float **output, int channels, int frame_size,
int start_band, int end_band)
{
int i, j, downmix = 0;
int consumed; // bits of entropy consumed thus far for this frame
AVTXContext *imdct;
av_tx_fn imdct_fn;
if (channels != 1 && channels != 2) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid number of coded channels: %d\n",
channels);
return AVERROR_INVALIDDATA;
}
if (start_band < 0 || start_band > end_band || end_band > CELT_MAX_BANDS) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid start/end band: %d %d\n",
start_band, end_band);
return AVERROR_INVALIDDATA;
}
f->silence = 0;
f->transient = 0;
f->anticollapse = 0;
f->flushed = 0;
f->channels = channels;
f->start_band = start_band;
f->end_band = end_band;
f->framebits = rc->rb.bytes * 8;
f->size = av_log2(frame_size / CELT_SHORT_BLOCKSIZE);
if (f->size > CELT_MAX_LOG_BLOCKS ||
frame_size != CELT_SHORT_BLOCKSIZE * (1 << f->size)) {
av_log(f->avctx, AV_LOG_ERROR, "Invalid CELT frame size: %d\n",
frame_size);
return AVERROR_INVALIDDATA;
}
if (!f->output_channels)
f->output_channels = channels;
for (i = 0; i < f->channels; i++) {
memset(f->block[i].coeffs, 0, sizeof(f->block[i].coeffs));
memset(f->block[i].collapse_masks, 0, sizeof(f->block[i].collapse_masks));
}
consumed = opus_rc_tell(rc);
/* obtain silence flag */
if (consumed >= f->framebits)
f->silence = 1;
else if (consumed == 1)
f->silence = ff_opus_rc_dec_log(rc, 15);
if (f->silence) {
consumed = f->framebits;
rc->total_bits += f->framebits - opus_rc_tell(rc);
}
/* obtain post-filter options */
consumed = parse_postfilter(f, rc, consumed);
/* obtain transient flag */
if (f->size != 0 && consumed+3 <= f->framebits)
f->transient = ff_opus_rc_dec_log(rc, 3);
f->blocks = f->transient ? 1 << f->size : 1;
f->blocksize = frame_size / f->blocks;
imdct = f->tx[f->transient ? 0 : f->size];
imdct_fn = f->tx_fn[f->transient ? 0 : f->size];
if (channels == 1) {
for (i = 0; i < CELT_MAX_BANDS; i++)
f->block[0].energy[i] = FFMAX(f->block[0].energy[i], f->block[1].energy[i]);
}
celt_decode_coarse_energy(f, rc);
celt_decode_tf_changes (f, rc);
ff_celt_bitalloc (f, rc, 0);
celt_decode_fine_energy (f, rc);
ff_celt_quant_bands (f, rc);
if (f->anticollapse_needed)
f->anticollapse = ff_opus_rc_get_raw(rc, 1);
celt_decode_final_energy(f, rc);
/* apply anti-collapse processing and denormalization to
* each coded channel */
for (i = 0; i < f->channels; i++) {
CeltBlock *block = &f->block[i];
if (f->anticollapse)
process_anticollapse(f, block, f->block[i].coeffs);
celt_denormalize(f, block, f->block[i].coeffs);
}
/* stereo -> mono downmix */
if (f->output_channels < f->channels) {
f->dsp->vector_fmac_scalar(f->block[0].coeffs, f->block[1].coeffs, 1.0, FFALIGN(frame_size, 16));
downmix = 1;
} else if (f->output_channels > f->channels)
memcpy(f->block[1].coeffs, f->block[0].coeffs, frame_size * sizeof(float));
if (f->silence) {
for (i = 0; i < 2; i++) {
CeltBlock *block = &f->block[i];
for (j = 0; j < FF_ARRAY_ELEMS(block->energy); j++)
block->energy[j] = CELT_ENERGY_SILENCE;
}
memset(f->block[0].coeffs, 0, sizeof(f->block[0].coeffs));
memset(f->block[1].coeffs, 0, sizeof(f->block[1].coeffs));
}
/* transform and output for each output channel */
for (i = 0; i < f->output_channels; i++) {
CeltBlock *block = &f->block[i];
/* iMDCT and overlap-add */
for (j = 0; j < f->blocks; j++) {
float *dst = block->buf + 1024 + j * f->blocksize;
imdct_fn(imdct, dst + CELT_OVERLAP / 2, f->block[i].coeffs + j,
sizeof(float)*f->blocks);
f->dsp->vector_fmul_window(dst, dst, dst + CELT_OVERLAP / 2,
ff_celt_window, CELT_OVERLAP / 2);
}
if (downmix)
f->dsp->vector_fmul_scalar(&block->buf[1024], &block->buf[1024], 0.5f, frame_size);
/* postfilter */
celt_postfilter(f, block);
/* deemphasis */
block->emph_coeff = f->opusdsp.deemphasis(output[i],
&block->buf[1024 - frame_size],
block->emph_coeff, frame_size);
}
if (channels == 1)
memcpy(f->block[1].energy, f->block[0].energy, sizeof(f->block[0].energy));
for (i = 0; i < 2; i++ ) {
CeltBlock *block = &f->block[i];
if (!f->transient) {
memcpy(block->prev_energy[1], block->prev_energy[0], sizeof(block->prev_energy[0]));
memcpy(block->prev_energy[0], block->energy, sizeof(block->prev_energy[0]));
} else {
for (j = 0; j < CELT_MAX_BANDS; j++)
block->prev_energy[0][j] = FFMIN(block->prev_energy[0][j], block->energy[j]);
}
for (j = 0; j < f->start_band; j++) {
block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
block->energy[j] = 0.0;
}
for (j = f->end_band; j < CELT_MAX_BANDS; j++) {
block->prev_energy[0][j] = CELT_ENERGY_SILENCE;
block->energy[j] = 0.0;
}
}
f->seed = rc->range;
return 0;
}
void ff_celt_flush(CeltFrame *f)
{
int i, j;
if (f->flushed)
return;
for (i = 0; i < 2; i++) {
CeltBlock *block = &f->block[i];
for (j = 0; j < CELT_MAX_BANDS; j++)
block->prev_energy[0][j] = block->prev_energy[1][j] = CELT_ENERGY_SILENCE;
memset(block->energy, 0, sizeof(block->energy));
memset(block->buf, 0, sizeof(block->buf));
memset(block->pf_gains, 0, sizeof(block->pf_gains));
memset(block->pf_gains_old, 0, sizeof(block->pf_gains_old));
memset(block->pf_gains_new, 0, sizeof(block->pf_gains_new));
/* libopus uses CELT_EMPH_COEFF on init, but 0 is better since there's
* a lesser discontinuity when seeking.
* The deemphasis functions differ from libopus in that they require
* an initial state divided by the coefficient. */
block->emph_coeff = 0.0f / CELT_EMPH_COEFF;
}
f->seed = 0;
f->flushed = 1;
}
void ff_celt_free(CeltFrame **f)
{
CeltFrame *frm = *f;
int i;
if (!frm)
return;
for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++)
av_tx_uninit(&frm->tx[i]);
ff_celt_pvq_uninit(&frm->pvq);
av_freep(&frm->dsp);
av_freep(f);
}
int ff_celt_init(AVCodecContext *avctx, CeltFrame **f, int output_channels,
int apply_phase_inv)
{
CeltFrame *frm;
int i, ret;
if (output_channels != 1 && output_channels != 2) {
av_log(avctx, AV_LOG_ERROR, "Invalid number of output channels: %d\n",
output_channels);
return AVERROR(EINVAL);
}
frm = av_mallocz(sizeof(*frm));
if (!frm)
return AVERROR(ENOMEM);
frm->avctx = avctx;
frm->output_channels = output_channels;
frm->apply_phase_inv = apply_phase_inv;
for (i = 0; i < FF_ARRAY_ELEMS(frm->tx); i++) {
const float scale = -1.0f/32768;
if ((ret = av_tx_init(&frm->tx[i], &frm->tx_fn[i], AV_TX_FLOAT_MDCT, 1, 15 << (i + 3), &scale, 0)) < 0)
goto fail;
}
if ((ret = ff_celt_pvq_init(&frm->pvq, 0)) < 0)
goto fail;
frm->dsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
if (!frm->dsp) {
ret = AVERROR(ENOMEM);
goto fail;
}
ff_opus_dsp_init(&frm->opusdsp);
ff_celt_flush(frm);
*f = frm;
return 0;
fail:
ff_celt_free(&frm);
return ret;
}
Write Preview
Loading…
Cancel
Save