static int cng_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AVFrame *frame = data;
CNGContext *p = avctx->priv_data;
int buf_size = avpkt->size;
int ret, i;
int16_t *buf_out;
float e = 1.0;
float scaling;
if (avpkt->size) {
int dbov = -avpkt->data[0];
p->target_energy = 1081109975 * ff_exp10(dbov / 10.0) * 0.75;
memset(p->target_refl_coef, 0, p->order * sizeof(*p->target_refl_coef));
for (i = 0; i < FFMIN(avpkt->size - 1, p->order); i++) {
p->target_refl_coef[i] = (avpkt->data[1 + i] - 127) / 128.0;
}
}
if (p->inited) {
p->energy = p->energy / 2 + p->target_energy / 2;
for (i = 0; i < p->order; i++)
p->refl_coef[i] = 0.6 *p->refl_coef[i] + 0.4 * p->target_refl_coef[i];
} else {
p->energy = p->target_energy;
memcpy(p->refl_coef, p->target_refl_coef, p->order * sizeof(*p->refl_coef));
p->inited = 1;
}
make_lpc_coefs(p->lpc_coef, p->refl_coef, p->order);
for (i = 0; i < p->order; i++)
e *= 1.0 - p->refl_coef[i]*p->refl_coef[i];
scaling = sqrt(e * p->energy / 1081109975);
for (i = 0; i < avctx->frame_size; i++) {
int r = (av_lfg_get(&p->lfg) & 0xffff) - 0x8000;
p->excitation[i] = scaling * r;
}
ff_celp_lp_synthesis_filterf(p->filter_out + p->order, p->lpc_coef,
p->excitation, avctx->frame_size, p->order);
frame->nb_samples = avctx->frame_size;
if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
return ret;
buf_out = (int16_t *)frame->data[0];
for (i = 0; i < avctx->frame_size; i++)
buf_out[i] = av_clip_int16(p->filter_out[i + p->order]);
memcpy(p->filter_out, p->filter_out + avctx->frame_size,
p->order * sizeof(*p->filter_out));
*got_frame_ptr = 1;
return buf_size;
}
// FIXME use for decoding too
static void init_exp(WMACodecContext *s, int ch, const int *exp_param)
{
int n;
const uint16_t *ptr;
float v, *q, max_scale, *q_end;
ptr = s->exponent_bands[s->frame_len_bits - s->block_len_bits];
q = s->exponents[ch];
q_end = q + s->block_len;
max_scale = 0;
while (q < q_end) {
/* XXX: use a table */
v = ff_exp10(*exp_param++ *(1.0 / 16.0));
max_scale = FFMAX(max_scale, v);
n = *ptr++;
do {
*q++ = v;
} while (--n);
}
s->max_exponent[ch] = max_scale;
}
static void read8_fft_bin(SpectrumSynthContext *s,
int x, int y, int f, int ch)
{
const int m_linesize = s->magnitude->linesize[0];
const int p_linesize = s->phase->linesize[0];
const uint8_t *m = (uint8_t *)(s->magnitude->data[0] + y * m_linesize);
const uint8_t *p = (uint8_t *)(s->phase->data[0] + y * p_linesize);
float magnitude, phase;
switch (s->scale) {
case LINEAR:
magnitude = m[x] / (double)UINT8_MAX;
break;
case LOG:
magnitude = ff_exp10(((m[x] / (double)UINT8_MAX) - 1.) * 6.);
break;
default:
av_assert0(0);
}
phase = ((p[x] / (double)UINT8_MAX) * 2. - 1.) * M_PI;
s->fft_data[ch][f].re = magnitude * cos(phase);
s->fft_data[ch][f].im = magnitude * sin(phase);
}
static int encode_block(WMACodecContext *s, float (*src_coefs)[BLOCK_MAX_SIZE],
int total_gain)
{
int v, bsize, ch, coef_nb_bits, parse_exponents;
float mdct_norm;
int nb_coefs[MAX_CHANNELS];
static const int fixed_exp[25] = {
20, 20, 20, 20, 20,
20, 20, 20, 20, 20,
20, 20, 20, 20, 20,
20, 20, 20, 20, 20,
20, 20, 20, 20, 20
};
// FIXME remove duplication relative to decoder
if (s->use_variable_block_len) {
av_assert0(0); // FIXME not implemented
} else {
/* fixed block len */
s->next_block_len_bits = s->frame_len_bits;
s->prev_block_len_bits = s->frame_len_bits;
s->block_len_bits = s->frame_len_bits;
}
s->block_len = 1 << s->block_len_bits;
// av_assert0((s->block_pos + s->block_len) <= s->frame_len);
bsize = s->frame_len_bits - s->block_len_bits;
// FIXME factor
v = s->coefs_end[bsize] - s->coefs_start;
for (ch = 0; ch < s->avctx->channels; ch++)
nb_coefs[ch] = v;
{
int n4 = s->block_len / 2;
mdct_norm = 1.0 / (float) n4;
if (s->version == 1)
mdct_norm *= sqrt(n4);
}
if (s->avctx->channels == 2)
put_bits(&s->pb, 1, !!s->ms_stereo);
for (ch = 0; ch < s->avctx->channels; ch++) {
// FIXME only set channel_coded when needed, instead of always
s->channel_coded[ch] = 1;
if (s->channel_coded[ch])
init_exp(s, ch, fixed_exp);
}
for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) {
WMACoef *coefs1;
float *coefs, *exponents, mult;
int i, n;
coefs1 = s->coefs1[ch];
exponents = s->exponents[ch];
mult = ff_exp10(total_gain * 0.05) / s->max_exponent[ch];
mult *= mdct_norm;
coefs = src_coefs[ch];
if (s->use_noise_coding && 0) {
av_assert0(0); // FIXME not implemented
} else {
coefs += s->coefs_start;
n = nb_coefs[ch];
for (i = 0; i < n; i++) {
double t = *coefs++ / (exponents[i] * mult);
if (t < -32768 || t > 32767)
return -1;
coefs1[i] = lrint(t);
}
}
}
}
v = 0;
for (ch = 0; ch < s->avctx->channels; ch++) {
int a = s->channel_coded[ch];
put_bits(&s->pb, 1, a);
v |= a;
}
if (!v)
return 1;
for (v = total_gain - 1; v >= 127; v -= 127)
put_bits(&s->pb, 7, 127);
put_bits(&s->pb, 7, v);
coef_nb_bits = ff_wma_total_gain_to_bits(total_gain);
if (s->use_noise_coding) {
for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) {
int i, n;
n = s->exponent_high_sizes[bsize];
for (i = 0; i < n; i++) {
put_bits(&s->pb, 1, s->high_band_coded[ch][i] = 0);
if (0)
nb_coefs[ch] -= s->exponent_high_bands[bsize][i];
}
}
}
}
parse_exponents = 1;
if (s->block_len_bits != s->frame_len_bits)
put_bits(&s->pb, 1, parse_exponents);
if (parse_exponents) {
for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) {
if (s->use_exp_vlc) {
encode_exp_vlc(s, ch, fixed_exp);
} else {
av_assert0(0); // FIXME not implemented
// encode_exp_lsp(s, ch);
}
}
}
} else
av_assert0(0); // FIXME not implemented
for (ch = 0; ch < s->avctx->channels; ch++) {
if (s->channel_coded[ch]) {
int run, tindex;
WMACoef *ptr, *eptr;
tindex = (ch == 1 && s->ms_stereo);
ptr = &s->coefs1[ch][0];
eptr = ptr + nb_coefs[ch];
run = 0;
for (; ptr < eptr; ptr++) {
if (*ptr) {
int level = *ptr;
int abs_level = FFABS(level);
int code = 0;
if (abs_level <= s->coef_vlcs[tindex]->max_level)
if (run < s->coef_vlcs[tindex]->levels[abs_level - 1])
code = run + s->int_table[tindex][abs_level - 1];
av_assert2(code < s->coef_vlcs[tindex]->n);
put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[code],
s->coef_vlcs[tindex]->huffcodes[code]);
if (code == 0) {
if (1 << coef_nb_bits <= abs_level)
return -1;
put_bits(&s->pb, coef_nb_bits, abs_level);
put_bits(&s->pb, s->frame_len_bits, run);
}
// FIXME the sign is flipped somewhere
put_bits(&s->pb, 1, level < 0);
run = 0;
} else
run++;
}
if (run)
put_bits(&s->pb, s->coef_vlcs[tindex]->huffbits[1],
s->coef_vlcs[tindex]->huffcodes[1]);
}
if (s->version == 1 && s->avctx->channels >= 2)
avpriv_align_put_bits(&s->pb);
}
return 0;
}
static int encode_init(AVCodecContext *avctx)
{
DCAEncContext *c = avctx->priv_data;
uint64_t layout = avctx->channel_layout;
int i, min_frame_bits;
c->fullband_channels = c->channels = avctx->channels;
c->lfe_channel = (avctx->channels == 3 || avctx->channels == 6);
c->band_interpolation = band_interpolation[1];
c->band_spectrum = band_spectrum[1];
c->worst_quantization_noise = -2047;
c->worst_noise_ever = -2047;
if (!layout) {
av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
"encoder will guess the layout, but it "
"might be incorrect.\n");
layout = av_get_default_channel_layout(avctx->channels);
}
switch (layout) {
case AV_CH_LAYOUT_MONO: c->channel_config = 0; break;
case AV_CH_LAYOUT_STEREO: c->channel_config = 2; break;
case AV_CH_LAYOUT_2_2: c->channel_config = 8; break;
case AV_CH_LAYOUT_5POINT0: c->channel_config = 9; break;
case AV_CH_LAYOUT_5POINT1: c->channel_config = 9; break;
default:
av_log(avctx, AV_LOG_ERROR, "Unsupported channel layout!\n");
return AVERROR_PATCHWELCOME;
}
if (c->lfe_channel) {
c->fullband_channels--;
c->channel_order_tab = ff_dca_channel_reorder_lfe[c->channel_config];
} else {
c->channel_order_tab = ff_dca_channel_reorder_nolfe[c->channel_config];
}
for (i = 0; i < 9; i++) {
if (sample_rates[i] == avctx->sample_rate)
break;
}
if (i == 9)
return AVERROR(EINVAL);
c->samplerate_index = i;
if (avctx->bit_rate < 32000 || avctx->bit_rate > 3840000) {
av_log(avctx, AV_LOG_ERROR, "Bit rate %"PRId64" not supported.", (int64_t)avctx->bit_rate);
return AVERROR(EINVAL);
}
for (i = 0; ff_dca_bit_rates[i] < avctx->bit_rate; i++)
;
c->bitrate_index = i;
c->frame_bits = FFALIGN((avctx->bit_rate * 512 + avctx->sample_rate - 1) / avctx->sample_rate, 32);
min_frame_bits = 132 + (493 + 28 * 32) * c->fullband_channels + c->lfe_channel * 72;
if (c->frame_bits < min_frame_bits || c->frame_bits > (DCA_MAX_FRAME_SIZE << 3))
return AVERROR(EINVAL);
c->frame_size = (c->frame_bits + 7) / 8;
avctx->frame_size = 32 * SUBBAND_SAMPLES;
if (!cos_table[0]) {
int j, k;
cos_table[0] = 0x7fffffff;
cos_table[512] = 0;
cos_table[1024] = -cos_table[0];
for (i = 1; i < 512; i++) {
cos_table[i] = (int32_t)(0x7fffffff * cos(M_PI * i / 1024));
cos_table[1024-i] = -cos_table[i];
cos_table[1024+i] = -cos_table[i];
cos_table[2048-i] = cos_table[i];
}
for (i = 0; i < 2048; i++) {
cb_to_level[i] = (int32_t)(0x7fffffff * ff_exp10(-0.005 * i));
}
for (k = 0; k < 32; k++) {
for (j = 0; j < 8; j++) {
lfe_fir_64i[64 * j + k] = (int32_t)(0xffffff800000ULL * ff_dca_lfe_fir_64[8 * k + j]);
lfe_fir_64i[64 * (7-j) + (63 - k)] = (int32_t)(0xffffff800000ULL * ff_dca_lfe_fir_64[8 * k + j]);
}
}
for (i = 0; i < 512; i++) {
band_interpolation[0][i] = (int32_t)(0x1000000000ULL * ff_dca_fir_32bands_perfect[i]);
band_interpolation[1][i] = (int32_t)(0x1000000000ULL * ff_dca_fir_32bands_nonperfect[i]);
}
for (i = 0; i < 9; i++) {
for (j = 0; j < AUBANDS; j++) {
for (k = 0; k < 256; k++) {
double freq = sample_rates[i] * (k + 0.5) / 512;
auf[i][j][k] = (int32_t)(10 * (hom(freq) + gammafilter(j, freq)));
}
}
}
for (i = 0; i < 256; i++) {
double add = 1 + ff_exp10(-0.01 * i);
cb_to_add[i] = (int32_t)(100 * log10(add));
}
for (j = 0; j < 8; j++) {
double accum = 0;
for (i = 0; i < 512; i++) {
double reconst = ff_dca_fir_32bands_perfect[i] * ((i & 64) ? (-1) : 1);
accum += reconst * cos(2 * M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
}
band_spectrum[0][j] = (int32_t)(200 * log10(accum));
}
for (j = 0; j < 8; j++) {
double accum = 0;
for (i = 0; i < 512; i++) {
double reconst = ff_dca_fir_32bands_nonperfect[i] * ((i & 64) ? (-1) : 1);
accum += reconst * cos(2 * M_PI * (i + 0.5 - 256) * (j + 0.5) / 512);
}
band_spectrum[1][j] = (int32_t)(200 * log10(accum));
}
}
return 0;
}
