Skip to content

F
ffmpeg.wasm-core
Commit 78e65cd7 authored by Alex Converse's avatar Alex Converse
Browse files
Options

Merge the AAC encoder from SoC svn. It is still considered experimental. 

Originally committed as revision 19375 to svn://svn.ffmpeg.org/ffmpeg/trunk
parent 5e039e1b
Hide whitespace changes
Inline Side-by-side
Showing with 1992 additions and 115 deletions
Changelog
View file @ 78e65cd7
......@@ -27,6 +27,7 @@ version <next>:
- Electronic Arts Madcow decoder
- DivX (XSUB) subtitle encoder
- nonfree libamr support for AMR-NB/WB decoding/encoding removed
- Experimental AAC encoder
......
libavcodec/Makefile
View file @ 78e65cd7
......@@ -36,6 +36,7 @@ OBJS-$(CONFIG_VDPAU) += vdpau.o
# decoders/encoders/hardware accelerators
OBJS-$(CONFIG_AAC_DECODER) += aac.o aactab.o mpeg4audio.o aac_parser.o aac_ac3_parser.o
OBJS-$(CONFIG_AAC_ENCODER) += aacenc.o aaccoder.o aacpsy.o aactab.o psymodel.o iirfilter.o mdct.o fft.o mpeg4audio.o
OBJS-$(CONFIG_AASC_DECODER) += aasc.o msrledec.o
OBJS-$(CONFIG_AC3_DECODER) += eac3dec.o ac3dec.o ac3tab.o ac3dec_data.o ac3.o
OBJS-$(CONFIG_AC3_ENCODER) += ac3enc.o ac3tab.o ac3.o
......
libavcodec/aac.h
View file @ 78e65cd7
......@@ -116,6 +116,12 @@ typedef struct {
#define MAX_PREDICTORS 672
#define SCALE_DIV_512 36 ///< scalefactor difference that corresponds to scale difference in 512 times
#define SCALE_ONE_POS 140 ///< scalefactor index that corresponds to scale=1.0
#define SCALE_MAX_POS 255 ///< scalefactor index maximum value
#define SCALE_MAX_DIFF 60 ///< maximum scalefactor difference allowed by standard
#define SCALE_DIFF_ZERO 60 ///< codebook index corresponding to zero scalefactor indices difference
/**
* Individual Channel Stream
*/
......@@ -126,6 +132,7 @@ typedef struct {
int num_window_groups;
uint8_t group_len[8];
const uint16_t *swb_offset; ///< table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular window
const uint8_t *swb_sizes; ///< table of scalefactor band sizes for a particular window
int num_swb; ///< number of scalefactor window bands
int num_windows;
int tns_max_bands;
......@@ -165,6 +172,7 @@ typedef struct {
typedef struct {
int num_pulse;
int start;
int pos[4];
int amp[4];
} Pulse;
......@@ -189,11 +197,14 @@ typedef struct {
typedef struct {
IndividualChannelStream ics;
TemporalNoiseShaping tns;
enum BandType band_type[120]; ///< band types
Pulse pulse;
enum BandType band_type[128]; ///< band types
int band_type_run_end[120]; ///< band type run end points
float sf[120]; ///< scalefactors
int sf_idx[128]; ///< scalefactor indices (used by encoder)
uint8_t zeroes[128]; ///< band is not coded (used by encoder)
DECLARE_ALIGNED_16(float, coeffs[1024]); ///< coefficients for IMDCT
DECLARE_ALIGNED_16(float, saved[512]); ///< overlap
DECLARE_ALIGNED_16(float, saved[1024]); ///< overlap
DECLARE_ALIGNED_16(float, ret[1024]); ///< PCM output
PredictorState predictor_state[MAX_PREDICTORS];
} SingleChannelElement;
......@@ -203,7 +214,9 @@ typedef struct {
*/
typedef struct {
// CPE specific
uint8_t ms_mask[120]; ///< Set if mid/side stereo is used for each scalefactor window band
int common_window; ///< Set if channels share a common 'IndividualChannelStream' in bitstream.
int ms_mode; ///< Signals mid/side stereo flags coding mode (used by encoder)
uint8_t ms_mask[128]; ///< Set if mid/side stereo is used for each scalefactor window band
// shared
SingleChannelElement ch[2];
// CCE specific
......
libavcodec/aaccoder.c 0 → 100644
View file @ 78e65cd7
/*
* AAC coefficients encoder
* Copyright (C) 2008-2009 Konstantin Shishkov
*
* 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 libavcodec/aaccoder.c
* AAC coefficients encoder
*/
/***********************************
* TODOs:
* speedup quantizer selection
* add sane pulse detection
***********************************/
#include "avcodec.h"
#include "put_bits.h"
#include "aac.h"
#include "aacenc.h"
#include "aactab.h"
/** bits needed to code codebook run value for long windows */
static const uint8_t run_value_bits_long[64] = {
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
};
/** bits needed to code codebook run value for short windows */
static const uint8_t run_value_bits_short[16] = {
3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
};
static const uint8_t* run_value_bits[2] = {
run_value_bits_long, run_value_bits_short
};
/**
* Quantize one coefficient.
* @return absolute value of the quantized coefficient
* @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
*/
static av_always_inline int quant(float coef, const float Q)
{
return pow(coef * Q, 0.75) + 0.4054;
}
static void quantize_bands(int (*out)[2], const float *in, const float *scaled, int size, float Q34, int is_signed, int maxval)
{
int i;
double qc;
for (i = 0; i < size; i++) {
qc = scaled[i] * Q34;
out[i][0] = (int)FFMIN((int)qc, maxval);
out[i][1] = (int)FFMIN((int)(qc + 0.4054), maxval);
if (is_signed && in[i] < 0.0f) {
out[i][0] = -out[i][0];
out[i][1] = -out[i][1];
}
}
}
static void abs_pow34_v(float *out, const float* in, const int size)
{
#ifndef USE_REALLY_FULL_SEARCH
int i;
for (i = 0; i < size; i++) {
out[i] = pow(fabsf(in[i]), 0.75);
}
#endif /* USE_REALLY_FULL_SEARCH */
}
static av_always_inline int quant2(float coef, const float Q)
{
return pow(coef * Q, 0.75);
}
static const uint8_t aac_cb_range [12] = {0, 3, 3, 3, 3, 9, 9, 8, 8, 13, 13, 17};
static const uint8_t aac_cb_maxval[12] = {0, 1, 1, 2, 2, 4, 4, 7, 7, 12, 12, 16};
/**
* Calculate rate distortion cost for quantizing with given codebook
*
* @return quantization distortion
*/
static float quantize_band_cost(struct AACEncContext *s, const float *in, const float *scaled, int size, int scale_idx, int cb,
const float lambda, const float uplim, int *bits)
{
const float IQ = ff_aac_pow2sf_tab[200 + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
const float Q = ff_aac_pow2sf_tab[200 - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
const float CLIPPED_ESCAPE = 165140.0f*IQ;
int i, j, k;
float cost = 0;
const int dim = cb < FIRST_PAIR_BT ? 4 : 2;
int resbits = 0;
#ifndef USE_REALLY_FULL_SEARCH
const float Q34 = pow(Q, 0.75);
const int range = aac_cb_range[cb];
const int maxval = aac_cb_maxval[cb];
int offs[4];
#endif /* USE_REALLY_FULL_SEARCH */
if(!cb){
for(i = 0; i < size; i++)
cost += in[i]*in[i]*lambda;
return cost;
}
#ifndef USE_REALLY_FULL_SEARCH
offs[0] = 1;
for(i = 1; i < dim; i++)
offs[i] = offs[i-1]*range;
quantize_bands(s->qcoefs, in, scaled, size, Q34, !IS_CODEBOOK_UNSIGNED(cb), maxval);
#endif /* USE_REALLY_FULL_SEARCH */
for(i = 0; i < size; i += dim){
float mincost;
int minidx = 0;
int minbits = 0;
const float *vec;
#ifndef USE_REALLY_FULL_SEARCH
int (*quants)[2] = &s->qcoefs[i];
mincost = 0.0f;
for(j = 0; j < dim; j++){
mincost += in[i+j]*in[i+j]*lambda;
}
minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
minbits = ff_aac_spectral_bits[cb-1][minidx];
mincost += minbits;
for(j = 0; j < (1<<dim); j++){
float rd = 0.0f;
int curbits;
int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
int same = 0;
for(k = 0; k < dim; k++){
if((j & (1 << k)) && quants[k][0] == quants[k][1]){
same = 1;
break;
}
}
if(same)
continue;
for(k = 0; k < dim; k++)
curidx += quants[k][!!(j & (1 << k))] * offs[dim - 1 - k];
curbits = ff_aac_spectral_bits[cb-1][curidx];
vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
#else
mincost = INFINITY;
vec = ff_aac_codebook_vectors[cb-1];
for(j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim){
float rd = 0.0f;
int curbits = ff_aac_spectral_bits[cb-1][j];
#endif /* USE_REALLY_FULL_SEARCH */
if(IS_CODEBOOK_UNSIGNED(cb)){
for(k = 0; k < dim; k++){
float t = fabsf(in[i+k]);
float di;
//do not code with escape sequence small values
if(vec[k] == 64.0f && t < 39.0f*IQ){
rd = INFINITY;
break;
}
if(vec[k] == 64.0f){//FIXME: slow
if (t >= CLIPPED_ESCAPE) {
di = t - CLIPPED_ESCAPE;
curbits += 21;
}else{
int c = av_clip(quant(t, Q), 0, 8191);
di = t - c*cbrt(c)*IQ;
curbits += av_log2(c)*2 - 4 + 1;
}
}else{
di = t - vec[k]*IQ;
}
if(vec[k] != 0.0f)
curbits++;
rd += di*di*lambda;
}
}else{
for(k = 0; k < dim; k++){
float di = in[i+k] - vec[k]*IQ;
rd += di*di*lambda;
}
}
rd += curbits;
if(rd < mincost){
mincost = rd;
minidx = j;
minbits = curbits;
}
}
cost += mincost;
resbits += minbits;
if(cost >= uplim)
return uplim;
}
if(bits)
*bits = resbits;
return cost;
}
static void quantize_and_encode_band(struct AACEncContext *s, PutBitContext *pb, const float *in, int size,
int scale_idx, int cb, const float lambda)
{
const float IQ = ff_aac_pow2sf_tab[200 + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
const float Q = ff_aac_pow2sf_tab[200 - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
const float CLIPPED_ESCAPE = 165140.0f*IQ;
const int dim = (cb < FIRST_PAIR_BT) ? 4 : 2;
int i, j, k;
#ifndef USE_REALLY_FULL_SEARCH
const float Q34 = pow(Q, 0.75);
const int range = aac_cb_range[cb];
const int maxval = aac_cb_maxval[cb];
int offs[4];
float *scaled = s->scoefs;
#endif /* USE_REALLY_FULL_SEARCH */
//START_TIMER
if(!cb)
return;
#ifndef USE_REALLY_FULL_SEARCH
offs[0] = 1;
for(i = 1; i < dim; i++)
offs[i] = offs[i-1]*range;
abs_pow34_v(scaled, in, size);
quantize_bands(s->qcoefs, in, scaled, size, Q34, !IS_CODEBOOK_UNSIGNED(cb), maxval);
#endif /* USE_REALLY_FULL_SEARCH */
for(i = 0; i < size; i += dim){
float mincost;
int minidx = 0;
int minbits = 0;
const float *vec;
#ifndef USE_REALLY_FULL_SEARCH
int (*quants)[2] = &s->qcoefs[i];
mincost = 0.0f;
for(j = 0; j < dim; j++){
mincost += in[i+j]*in[i+j]*lambda;
}
minidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
minbits = ff_aac_spectral_bits[cb-1][minidx];
mincost += minbits;
for(j = 0; j < (1<<dim); j++){
float rd = 0.0f;
int curbits;
int curidx = IS_CODEBOOK_UNSIGNED(cb) ? 0 : 40;
int same = 0;
for(k = 0; k < dim; k++){
if((j & (1 << k)) && quants[k][0] == quants[k][1]){
same = 1;
break;
}
}
if(same)
continue;
for(k = 0; k < dim; k++)
curidx += quants[k][!!(j & (1 << k))] * offs[dim - 1 - k];
curbits = ff_aac_spectral_bits[cb-1][curidx];
vec = &ff_aac_codebook_vectors[cb-1][curidx*dim];
#else
vec = ff_aac_codebook_vectors[cb-1];
mincost = INFINITY;
for(j = 0; j < ff_aac_spectral_sizes[cb-1]; j++, vec += dim){
float rd = 0.0f;
int curbits = ff_aac_spectral_bits[cb-1][j];
int curidx = j;
#endif /* USE_REALLY_FULL_SEARCH */
if(IS_CODEBOOK_UNSIGNED(cb)){
for(k = 0; k < dim; k++){
float t = fabsf(in[i+k]);
float di;
//do not code with escape sequence small values
if(vec[k] == 64.0f && t < 39.0f*IQ){
rd = INFINITY;
break;
}
if(vec[k] == 64.0f){//FIXME: slow
if (t >= CLIPPED_ESCAPE) {
di = t - CLIPPED_ESCAPE;
curbits += 21;
}else{
int c = av_clip(quant(t, Q), 0, 8191);
di = t - c*cbrt(c)*IQ;
curbits += av_log2(c)*2 - 4 + 1;
}
}else{
di = t - vec[k]*IQ;
}
if(vec[k] != 0.0f)
curbits++;
rd += di*di*lambda;
}
}else{
for(k = 0; k < dim; k++){
float di = in[i+k] - vec[k]*IQ;
rd += di*di*lambda;
}
}
rd += curbits;
if(rd < mincost){
mincost = rd;
minidx = curidx;
minbits = curbits;
}
}
put_bits(pb, ff_aac_spectral_bits[cb-1][minidx], ff_aac_spectral_codes[cb-1][minidx]);
if(IS_CODEBOOK_UNSIGNED(cb))
for(j = 0; j < dim; j++)
if(ff_aac_codebook_vectors[cb-1][minidx*dim+j] != 0.0f)
put_bits(pb, 1, in[i+j] < 0.0f);
if(cb == ESC_BT){
for(j = 0; j < 2; j++){
if(ff_aac_codebook_vectors[cb-1][minidx*2+j] == 64.0f){
int coef = av_clip(quant(fabsf(in[i+j]), Q), 0, 8191);
int len = av_log2(coef);
put_bits(pb, len - 4 + 1, (1 << (len - 4 + 1)) - 2);
put_bits(pb, len, coef & ((1 << len) - 1));
}
}
}
}
//STOP_TIMER("quantize_and_encode")
}
/**
* structure used in optimal codebook search
*/
typedef struct BandCodingPath {
int prev_idx; ///< pointer to the previous path point
int codebook; ///< codebook for coding band run
float cost; ///< path cost
int run;
} BandCodingPath;
/**
* Encode band info for single window group bands.
*/
static void encode_window_bands_info(AACEncContext *s, SingleChannelElement *sce,
int win, int group_len, const float lambda)
{
BandCodingPath path[120][12];
int w, swb, cb, start, start2, size;
int i, j;
const int max_sfb = sce->ics.max_sfb;
const int run_bits = sce->ics.num_windows == 1 ? 5 : 3;
const int run_esc = (1 << run_bits) - 1;
int idx, ppos, count;
int stackrun[120], stackcb[120], stack_len;
float next_minrd = INFINITY;
int next_mincb = 0;
abs_pow34_v(s->scoefs, sce->coeffs, 1024);
start = win*128;
for(cb = 0; cb < 12; cb++){
path[0][cb].cost = 0.0f;
path[0][cb].prev_idx = -1;
path[0][cb].run = 0;
}
for(swb = 0; swb < max_sfb; swb++){
start2 = start;
size = sce->ics.swb_sizes[swb];
if(sce->zeroes[win*16 + swb]){
for(cb = 0; cb < 12; cb++){
path[swb+1][cb].prev_idx = cb;
path[swb+1][cb].cost = path[swb][cb].cost;
path[swb+1][cb].run = path[swb][cb].run + 1;
}
}else{
float minrd = next_minrd;
int mincb = next_mincb;
next_minrd = INFINITY;
next_mincb = 0;
for(cb = 0; cb < 12; cb++){
float cost_stay_here, cost_get_here;
float rd = 0.0f;
for(w = 0; w < group_len; w++){
FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(win+w)*16+swb];
rd += quantize_band_cost(s, sce->coeffs + start + w*128,
s->scoefs + start + w*128, size,
sce->sf_idx[(win+w)*16+swb], cb,
lambda / band->threshold, INFINITY, NULL);
}
cost_stay_here = path[swb][cb].cost + rd;
cost_get_here = minrd + rd + run_bits + 4;
if( run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run]
!= run_value_bits[sce->ics.num_windows == 8][path[swb][cb].run+1])
cost_stay_here += run_bits;
if (cost_get_here < cost_stay_here) {
path[swb+1][cb].prev_idx = mincb;
path[swb+1][cb].cost = cost_get_here;
path[swb+1][cb].run = 1;
} else {
path[swb+1][cb].prev_idx = cb;
path[swb+1][cb].cost = cost_stay_here;
path[swb+1][cb].run = path[swb][cb].run + 1;
}
if (path[swb+1][cb].cost < next_minrd) {
next_minrd = path[swb+1][cb].cost;
next_mincb = cb;
}
}
}
start += sce->ics.swb_sizes[swb];
}
//convert resulting path from backward-linked list
stack_len = 0;
idx = 0;
for(cb = 1; cb < 12; cb++){
if(path[max_sfb][cb].cost < path[max_sfb][idx].cost)
idx = cb;
}
ppos = max_sfb;
while(ppos > 0){
cb = idx;
stackrun[stack_len] = path[ppos][cb].run;
stackcb [stack_len] = cb;
idx = path[ppos-path[ppos][cb].run+1][cb].prev_idx;
ppos -= path[ppos][cb].run;
stack_len++;
}
//perform actual band info encoding
start = 0;
for(i = stack_len - 1; i >= 0; i--){
put_bits(&s->pb, 4, stackcb[i]);
count = stackrun[i];
memset(sce->zeroes + win*16 + start, !stackcb[i], count);
//XXX: memset when band_type is also uint8_t
for(j = 0; j < count; j++){
sce->band_type[win*16 + start] = stackcb[i];
start++;
}
while(count >= run_esc){
put_bits(&s->pb, run_bits, run_esc);
count -= run_esc;
}
put_bits(&s->pb, run_bits, count);
}
}
static void encode_window_bands_info_fixed(AACEncContext *s, SingleChannelElement *sce,
int win, int group_len, const float lambda)
{
encode_window_bands_info(s, sce, win, group_len, 1.0f);
}
typedef struct TrellisPath {
float cost;
int prev;
int min_val;
int max_val;
} TrellisPath;
static void search_for_quantizers_anmr(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce, const float lambda)
{
int q, w, w2, g, start = 0;
int i;
int idx;
TrellisPath paths[256*121];
int bandaddr[121];
int minq;
float mincost;
for(i = 0; i < 256; i++){
paths[i].cost = 0.0f;
paths[i].prev = -1;
paths[i].min_val = i;
paths[i].max_val = i;
}
for(i = 256; i < 256*121; i++){
paths[i].cost = INFINITY;
paths[i].prev = -2;
paths[i].min_val = INT_MAX;
paths[i].max_val = 0;
}
idx = 256;
abs_pow34_v(s->scoefs, sce->coeffs, 1024);
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
const float *coefs = sce->coeffs + start;
float qmin, qmax;
int nz = 0;
bandaddr[idx >> 8] = w*16+g;
qmin = INT_MAX;
qmax = 0.0f;
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
if(band->energy <= band->threshold || band->threshold == 0.0f){
sce->zeroes[(w+w2)*16+g] = 1;
continue;
}
sce->zeroes[(w+w2)*16+g] = 0;
nz = 1;
for(i = 0; i < sce->ics.swb_sizes[g]; i++){
float t = fabsf(coefs[w2*128+i]);
if(t > 0.0f) qmin = fminf(qmin, t);
qmax = fmaxf(qmax, t);
}
}
if(nz){
int minscale, maxscale;
float minrd = INFINITY;
//minimum scalefactor index is when minimum nonzero coefficient after quantizing is not clipped
minscale = av_clip_uint8(log2(qmin)*4 - 69 + SCALE_ONE_POS - SCALE_DIV_512);
//maximum scalefactor index is when maximum coefficient after quantizing is still not zero
maxscale = av_clip_uint8(log2(qmax)*4 + 6 + SCALE_ONE_POS - SCALE_DIV_512);
for(q = minscale; q < maxscale; q++){
float dists[12], dist;
memset(dists, 0, sizeof(dists));
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
int cb;
for(cb = 0; cb <= ESC_BT; cb++){
dists[cb] += quantize_band_cost(s, coefs + w2*128, s->scoefs + start + w2*128, sce->ics.swb_sizes[g],
q, cb, lambda / band->threshold, INFINITY, NULL);
}
}
dist = dists[0];
for(i = 1; i <= ESC_BT; i++)
dist = fminf(dist, dists[i]);
minrd = fminf(minrd, dist);
for(i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++){
float cost;
int minv, maxv;
if(isinf(paths[idx - 256 + i].cost))
continue;
cost = paths[idx - 256 + i].cost + dist
+ ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
minv = FFMIN(paths[idx - 256 + i].min_val, q);
maxv = FFMAX(paths[idx - 256 + i].max_val, q);
if(cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF){
paths[idx + q].cost = cost;
paths[idx + q].prev = idx - 256 + i;
paths[idx + q].min_val = minv;
paths[idx + q].max_val = maxv;
}
}
}
}else{
for(q = 0; q < 256; q++){
if(!isinf(paths[idx - 256 + q].cost)){
paths[idx + q].cost = paths[idx - 256 + q].cost + 1;
paths[idx + q].prev = idx - 256 + q;
paths[idx + q].min_val = FFMIN(paths[idx - 256 + q].min_val, q);
paths[idx + q].max_val = FFMAX(paths[idx - 256 + q].max_val, q);
continue;
}
for(i = FFMAX(q - SCALE_MAX_DIFF, 0); i < FFMIN(q + SCALE_MAX_DIFF, 256); i++){
float cost;
int minv, maxv;
if(isinf(paths[idx - 256 + i].cost))
continue;
cost = paths[idx - 256 + i].cost + ff_aac_scalefactor_bits[q - i + SCALE_DIFF_ZERO];
minv = FFMIN(paths[idx - 256 + i].min_val, q);
maxv = FFMAX(paths[idx - 256 + i].max_val, q);
if(cost < paths[idx + q].cost && maxv-minv < SCALE_MAX_DIFF){
paths[idx + q].cost = cost;
paths[idx + q].prev = idx - 256 + i;
paths[idx + q].min_val = minv;
paths[idx + q].max_val = maxv;
}
}
}
}
sce->zeroes[w*16+g] = !nz;
start += sce->ics.swb_sizes[g];
idx += 256;
}
}
idx -= 256;
mincost = paths[idx].cost;
minq = idx;
for(i = 1; i < 256; i++){
if(paths[idx + i].cost < mincost){
mincost = paths[idx + i].cost;
minq = idx + i;
}
}
while(minq >= 256){
sce->sf_idx[bandaddr[minq>>8]] = minq & 0xFF;
minq = paths[minq].prev;
}
//set the same quantizers inside window groups
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
for(g = 0; g < sce->ics.num_swb; g++)
for(w2 = 1; w2 < sce->ics.group_len[w]; w2++)
sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
}
/**
* two-loop quantizers search taken from ISO 13818-7 Appendix C
*/
static void search_for_quantizers_twoloop(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce, const float lambda)
{
int start = 0, i, w, w2, g;
int destbits = avctx->bit_rate * 1024.0 / avctx->sample_rate / avctx->channels;
float dists[128], uplims[128];
int fflag, minscaler;
int its = 0;
int allz = 0;
float minthr = INFINITY;
//XXX: some heuristic to determine initial quantizers will reduce search time
memset(dists, 0, sizeof(dists));
//determine zero bands and upper limits
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
for(g = 0; g < sce->ics.num_swb; g++){
int nz = 0;
float uplim = 0.0f;
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
uplim += band->threshold;
if(band->energy <= band->threshold || band->threshold == 0.0f){
sce->zeroes[(w+w2)*16+g] = 1;
continue;
}
nz = 1;
}
uplims[w*16+g] = uplim *512;
sce->zeroes[w*16+g] = !nz;
if(nz)
minthr = fminf(minthr, uplim);
allz = FFMAX(allz, nz);
}
}
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
for(g = 0; g < sce->ics.num_swb; g++){
if(sce->zeroes[w*16+g]){
sce->sf_idx[w*16+g] = SCALE_ONE_POS;
continue;
}
sce->sf_idx[w*16+g] = SCALE_ONE_POS + fminf(log2(uplims[w*16+g]/minthr)*4,59);
}
}
if(!allz)
return;
abs_pow34_v(s->scoefs, sce->coeffs, 1024);
//perform two-loop search
//outer loop - improve quality
do{
int tbits, qstep;
minscaler = sce->sf_idx[0];
//inner loop - quantize spectrum to fit into given number of bits
qstep = its ? 1 : 32;
do{
int prev = -1;
tbits = 0;
fflag = 0;
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
const float *coefs = sce->coeffs + start;
const float *scaled = s->scoefs + start;
int bits = 0;
int cb;
float mindist = INFINITY;
int minbits = 0;
if(sce->zeroes[w*16+g] || sce->sf_idx[w*16+g] >= 218)
continue;
minscaler = FFMIN(minscaler, sce->sf_idx[w*16+g]);
for(cb = 0; cb <= ESC_BT; cb++){
float dist = 0.0f;
int bb = 0;
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
int b;
dist += quantize_band_cost(s, coefs + w2*128,
scaled + w2*128,
sce->ics.swb_sizes[g],
sce->sf_idx[w*16+g],
ESC_BT,
1.0,
INFINITY,
&b);
bb += b;
}
if(dist < mindist){
mindist = dist;
minbits = bb;
}
}
dists[w*16+g] = mindist - minbits;
bits = minbits;
if(prev != -1){
bits += ff_aac_scalefactor_bits[sce->sf_idx[w*16+g] - prev + SCALE_DIFF_ZERO];
}
tbits += bits;
start += sce->ics.swb_sizes[g];
prev = sce->sf_idx[w*16+g];
}
}
if(tbits > destbits){
for(i = 0; i < 128; i++){
if(sce->sf_idx[i] < 218 - qstep){
sce->sf_idx[i] += qstep;
}
}
}else{
for(i = 0; i < 128; i++){
if(sce->sf_idx[i] > 60 - qstep){
sce->sf_idx[i] -= qstep;
}
}
}
qstep >>= 1;
if(!qstep && tbits > destbits*1.02)
qstep = 1;
if(sce->sf_idx[0] >= 217)break;
}while(qstep);
fflag = 0;
minscaler = av_clip(minscaler, 60, 255 - SCALE_MAX_DIFF);
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
int prevsc = sce->sf_idx[w*16+g];
if(dists[w*16+g] > uplims[w*16+g] && sce->sf_idx[w*16+g] > 60)
sce->sf_idx[w*16+g]--;
sce->sf_idx[w*16+g] = av_clip(sce->sf_idx[w*16+g], minscaler, minscaler + SCALE_MAX_DIFF);
sce->sf_idx[w*16+g] = FFMIN(sce->sf_idx[w*16+g], 219);
if(sce->sf_idx[w*16+g] != prevsc)
fflag = 1;
}
}
its++;
}while(fflag && its < 10);
}
static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce, const float lambda)
{
int start = 0, i, w, w2, g;
float uplim[128], maxq[128];
int minq, maxsf;
float distfact = ((sce->ics.num_windows > 1) ? 85.80 : 147.84) / lambda;
int last = 0, lastband = 0, curband = 0;
float avg_energy = 0.0;
if(sce->ics.num_windows == 1){
start = 0;
for(i = 0; i < 1024; i++){
if(i - start >= sce->ics.swb_sizes[curband]){
start += sce->ics.swb_sizes[curband];
curband++;
}
if(sce->coeffs[i]){
avg_energy += sce->coeffs[i] * sce->coeffs[i];
last = i;
lastband = curband;
}
}
}else{
for(w = 0; w < 8; w++){
const float *coeffs = sce->coeffs + w*128;
start = 0;
for(i = 0; i < 128; i++){
if(i - start >= sce->ics.swb_sizes[curband]){
start += sce->ics.swb_sizes[curband];
curband++;
}
if(coeffs[i]){
avg_energy += coeffs[i] * coeffs[i];
last = FFMAX(last, i);
lastband = FFMAX(lastband, curband);
}
}
}
}
last++;
avg_energy /= last;
if(avg_energy == 0.0f){
for(i = 0; i < FF_ARRAY_ELEMS(sce->sf_idx); i++)
sce->sf_idx[i] = SCALE_ONE_POS;
return;
}
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
float *coefs = sce->coeffs + start;
const int size = sce->ics.swb_sizes[g];
int start2 = start, end2 = start + size, peakpos = start;
float maxval = -1, thr = 0.0f, t;
maxq[w*16+g] = 0.0f;
if(g > lastband){
maxq[w*16+g] = 0.0f;
start += size;
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++)
memset(coefs + w2*128, 0, sizeof(coefs[0])*size);
continue;
}
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
for(i = 0; i < size; i++){
float t = coefs[w2*128+i]*coefs[w2*128+i];
maxq[w*16+g] = fmaxf(maxq[w*16+g], fabsf(coefs[w2*128 + i]));
thr += t;
if(sce->ics.num_windows == 1 && maxval < t){
maxval = t;
peakpos = start+i;
}
}
}
if(sce->ics.num_windows == 1){
start2 = FFMAX(peakpos - 2, start2);
end2 = FFMIN(peakpos + 3, end2);
}else{
start2 -= start;
end2 -= start;
}
start += size;
thr = pow(thr / (avg_energy * (end2 - start2)), 0.3 + 0.1*(lastband - g) / lastband);
t = 1.0 - (1.0 * start2 / last);
uplim[w*16+g] = distfact / (1.4 * thr + t*t*t + 0.075);
}
}
memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
abs_pow34_v(s->scoefs, sce->coeffs, 1024);
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
const float *coefs = sce->coeffs + start;
const float *scaled = s->scoefs + start;
const int size = sce->ics.swb_sizes[g];
int scf, prev_scf, step;
int min_scf = 0, max_scf = 255;
float curdiff;
if(maxq[w*16+g] < 21.544){
sce->zeroes[w*16+g] = 1;
start += size;
continue;
}
sce->zeroes[w*16+g] = 0;
scf = prev_scf = av_clip(SCALE_ONE_POS - SCALE_DIV_512 - log2(1/maxq[w*16+g])*16/3, 60, 218);
step = 16;
for(;;){
float dist = 0.0f;
int quant_max;
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
int b;
dist += quantize_band_cost(s, coefs + w2*128,
scaled + w2*128,
sce->ics.swb_sizes[g],
scf,
ESC_BT,
1.0,
INFINITY,
&b);
dist -= b;
}
dist *= 1.0f/512.0f;
quant_max = quant(maxq[w*16+g], ff_aac_pow2sf_tab[200 - scf + SCALE_ONE_POS - SCALE_DIV_512]);
if(quant_max >= 8191){ // too much, return to the previous quantizer
sce->sf_idx[w*16+g] = prev_scf;
break;
}
prev_scf = scf;
curdiff = fabsf(dist - uplim[w*16+g]);
if(curdiff == 0.0f)
step = 0;
else
step = fabsf(log2(curdiff));
if(dist > uplim[w*16+g])
step = -step;
if(FFABS(step) <= 1 || (step > 0 && scf >= max_scf) || (step < 0 && scf <= min_scf)){
sce->sf_idx[w*16+g] = scf;
break;
}
scf += step;
if(step > 0)
min_scf = scf;
else
max_scf = scf;
}
start += size;
}
}
minq = sce->sf_idx[0] ? sce->sf_idx[0] : INT_MAX;
for(i = 1; i < 128; i++){
if(!sce->sf_idx[i])
sce->sf_idx[i] = sce->sf_idx[i-1];
else
minq = FFMIN(minq, sce->sf_idx[i]);
}
if(minq == INT_MAX) minq = 0;
minq = FFMIN(minq, SCALE_MAX_POS);
maxsf = FFMIN(minq + SCALE_MAX_DIFF, SCALE_MAX_POS);
for(i = 126; i >= 0; i--){
if(!sce->sf_idx[i])
sce->sf_idx[i] = sce->sf_idx[i+1];
sce->sf_idx[i] = av_clip(sce->sf_idx[i], minq, maxsf);
}
}
static void search_for_quantizers_fast(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce, const float lambda)
{
int start = 0, i, w, w2, g;
int minq = 255;
memset(sce->sf_idx, 0, sizeof(sce->sf_idx));
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = w*128;
for(g = 0; g < sce->ics.num_swb; g++){
for(w2 = 0; w2 < sce->ics.group_len[w]; w2++){
FFPsyBand *band = &s->psy.psy_bands[s->cur_channel*PSY_MAX_BANDS+(w+w2)*16+g];
if(band->energy <= band->threshold){
sce->sf_idx[(w+w2)*16+g] = 218;
sce->zeroes[(w+w2)*16+g] = 1;
}else{
sce->sf_idx[(w+w2)*16+g] = av_clip(SCALE_ONE_POS - SCALE_DIV_512 + log2(band->threshold), 80, 218);
sce->zeroes[(w+w2)*16+g] = 0;
}
minq = FFMIN(minq, sce->sf_idx[(w+w2)*16+g]);
}
}
}
for(i = 0; i < 128; i++){
sce->sf_idx[i] = 140;//av_clip(sce->sf_idx[i], minq, minq + SCALE_MAX_DIFF - 1);
}
//set the same quantizers inside window groups
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w])
for(g = 0; g < sce->ics.num_swb; g++)
for(w2 = 1; w2 < sce->ics.group_len[w]; w2++)
sce->sf_idx[(w+w2)*16+g] = sce->sf_idx[w*16+g];
}
static void search_for_ms(AACEncContext *s, ChannelElement *cpe, const float lambda)
{
int start = 0, i, w, w2, g;
float M[128], S[128];
float *L34 = s->scoefs, *R34 = s->scoefs + 128, *M34 = s->scoefs + 128*2, *S34 = s->scoefs + 128*3;
SingleChannelElement *sce0 = &cpe->ch[0];
SingleChannelElement *sce1 = &cpe->ch[1];
if(!cpe->common_window)
return;
for(w = 0; w < sce0->ics.num_windows; w += sce0->ics.group_len[w]){
for(g = 0; g < sce0->ics.num_swb; g++){
if(!cpe->ch[0].zeroes[w*16+g] && !cpe->ch[1].zeroes[w*16+g]){
float dist1 = 0.0f, dist2 = 0.0f;
for(w2 = 0; w2 < sce0->ics.group_len[w]; w2++){
FFPsyBand *band0 = &s->psy.psy_bands[(s->cur_channel+0)*PSY_MAX_BANDS+(w+w2)*16+g];
FFPsyBand *band1 = &s->psy.psy_bands[(s->cur_channel+1)*PSY_MAX_BANDS+(w+w2)*16+g];
float minthr = fminf(band0->threshold, band1->threshold);
float maxthr = fmaxf(band0->threshold, band1->threshold);
for(i = 0; i < sce0->ics.swb_sizes[g]; i++){
M[i] = (sce0->coeffs[start+w2*128+i]
+ sce1->coeffs[start+w2*128+i])*0.5;
S[i] = sce0->coeffs[start+w2*128+i]
- sce1->coeffs[start+w2*128+i];
}
abs_pow34_v(L34, sce0->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
abs_pow34_v(R34, sce1->coeffs+start+w2*128, sce0->ics.swb_sizes[g]);
abs_pow34_v(M34, M, sce0->ics.swb_sizes[g]);
abs_pow34_v(S34, S, sce0->ics.swb_sizes[g]);
dist1 += quantize_band_cost(s, sce0->coeffs + start + w2*128,
L34,
sce0->ics.swb_sizes[g],
sce0->sf_idx[(w+w2)*16+g],
sce0->band_type[(w+w2)*16+g],
lambda / band0->threshold, INFINITY, NULL);
dist1 += quantize_band_cost(s, sce1->coeffs + start + w2*128,
R34,
sce1->ics.swb_sizes[g],
sce1->sf_idx[(w+w2)*16+g],
sce1->band_type[(w+w2)*16+g],
lambda / band1->threshold, INFINITY, NULL);
dist2 += quantize_band_cost(s, M,
M34,
sce0->ics.swb_sizes[g],
sce0->sf_idx[(w+w2)*16+g],
sce0->band_type[(w+w2)*16+g],
lambda / maxthr, INFINITY, NULL);
dist2 += quantize_band_cost(s, S,
S34,
sce1->ics.swb_sizes[g],
sce1->sf_idx[(w+w2)*16+g],
sce1->band_type[(w+w2)*16+g],
lambda / minthr, INFINITY, NULL);
}
cpe->ms_mask[w*16+g] = dist2 < dist1;
}
start += sce0->ics.swb_sizes[g];
}
}
}
AACCoefficientsEncoder ff_aac_coders[] = {
{
search_for_quantizers_faac,
encode_window_bands_info_fixed,
quantize_and_encode_band,
// search_for_ms,
},
{
search_for_quantizers_anmr,
encode_window_bands_info,
quantize_and_encode_band,
// search_for_ms,
},
{
search_for_quantizers_twoloop,
encode_window_bands_info,
quantize_and_encode_band,
// search_for_ms,
},
{
search_for_quantizers_fast,
encode_window_bands_info,
quantize_and_encode_band,
// search_for_ms,
},
};
libavcodec/aacenc.c
View file @ 78e65cd7
......@@ -26,19 +26,20 @@
/***********************************
* TODOs:
* psy model selection with some option
* add sane pulse detection
* add temporal noise shaping
***********************************/
#include "avcodec.h"
#include "get_bits.h"
#include "put_bits.h"
#include "dsputil.h"
#include "mpeg4audio.h"
#include "aacpsy.h"
#include "aac.h"
#include "aactab.h"
#include "aacenc.h"
#include "psymodel.h"
static const uint8_t swb_size_1024_96[] = {
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8,
......@@ -83,7 +84,7 @@ static const uint8_t swb_size_1024_8[] = {
32, 36, 36, 40, 44, 48, 52, 56, 60, 64, 80
};
static const uint8_t * const swb_size_1024[] = {
static const uint8_t *swb_size_1024[] = {
swb_size_1024_96, swb_size_1024_96, swb_size_1024_64,
swb_size_1024_48, swb_size_1024_48, swb_size_1024_32,
swb_size_1024_24, swb_size_1024_24, swb_size_1024_16,
......@@ -110,7 +111,7 @@ static const uint8_t swb_size_128_8[] = {
4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 12, 16, 20, 20
};
static const uint8_t * const swb_size_128[] = {
static const uint8_t *swb_size_128[] = {
/* the last entry on the following row is swb_size_128_64 but is a
duplicate of swb_size_128_96 */
swb_size_128_96, swb_size_128_96, swb_size_128_96,
......@@ -119,23 +120,6 @@ static const uint8_t * const swb_size_128[] = {
swb_size_128_16, swb_size_128_16, swb_size_128_8
};
/** bits needed to code codebook run value for long windows */
static const uint8_t run_value_bits_long[64] = {
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 15
};
/** bits needed to code codebook run value for short windows */
static const uint8_t run_value_bits_short[16] = {
3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 9
};
static const uint8_t* const run_value_bits[2] = {
run_value_bits_long, run_value_bits_short
};
/** default channel configurations */
static const uint8_t aac_chan_configs[6][5] = {
{1, TYPE_SCE}, // 1 channel - single channel element
......@@ -146,33 +130,6 @@ static const uint8_t aac_chan_configs[6][5] = {
{4, TYPE_SCE, TYPE_CPE, TYPE_CPE, TYPE_LFE}, // 6 channels - front center + stereo + back stereo + LFE
};
/**
* structure used in optimal codebook search
*/
typedef struct BandCodingPath {
int prev_idx; ///< pointer to the previous path point
int codebook; ///< codebook for coding band run
int bits; ///< number of bit needed to code given number of bands
} BandCodingPath;
/**
* AAC encoder context
*/
typedef struct {
PutBitContext pb;
MDCTContext mdct1024; ///< long (1024 samples) frame transform context
MDCTContext mdct128; ///< short (128 samples) frame transform context
DSPContext dsp;
DECLARE_ALIGNED_16(FFTSample, output[2048]); ///< temporary buffer for MDCT input coefficients
int16_t* samples; ///< saved preprocessed input
int samplerate_index; ///< MPEG-4 samplerate index
ChannelElement *cpe; ///< channel elements
AACPsyContext psy; ///< psychoacoustic model context
int last_frame;
} AACEncContext;
/**
* Make AAC audio config object.
* @see 1.6.2.1 "Syntax - AudioSpecificConfig"
......@@ -197,6 +154,8 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
int i;
const uint8_t *sizes[2];
int lengths[2];
avctx->frame_size = 1024;
......@@ -224,25 +183,90 @@ static av_cold int aac_encode_init(AVCodecContext *avctx)
s->samples = av_malloc(2 * 1024 * avctx->channels * sizeof(s->samples[0]));
s->cpe = av_mallocz(sizeof(ChannelElement) * aac_chan_configs[avctx->channels-1][0]);
if(ff_aac_psy_init(&s->psy, avctx, AAC_PSY_3GPP,
aac_chan_configs[avctx->channels-1][0], 0,
swb_size_1024[i], ff_aac_num_swb_1024[i], swb_size_128[i], ff_aac_num_swb_128[i]) < 0){
av_log(avctx, AV_LOG_ERROR, "Cannot initialize selected model.\n");
return -1;
}
avctx->extradata = av_malloc(2);
avctx->extradata_size = 2;
put_audio_specific_config(avctx);
sizes[0] = swb_size_1024[i];
sizes[1] = swb_size_128[i];
lengths[0] = ff_aac_num_swb_1024[i];
lengths[1] = ff_aac_num_swb_128[i];
ff_psy_init(&s->psy, avctx, 2, sizes, lengths);
s->psypp = ff_psy_preprocess_init(avctx);
s->coder = &ff_aac_coders[0];
s->lambda = avctx->global_quality ? avctx->global_quality : 120;
#if !CONFIG_HARDCODED_TABLES
for (i = 0; i < 428; i++)
ff_aac_pow2sf_tab[i] = pow(2, (i - 200)/4.);
#endif /* CONFIG_HARDCODED_TABLES */
if (avctx->channels > 5)
av_log(avctx, AV_LOG_ERROR, "This encoder does not yet enforce the restrictions on LFEs. "
"The output will most likely be an illegal bitstream.\n");
return 0;
}
static void apply_window_and_mdct(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce, short *audio, int channel)
{
int i, j, k;
const float * lwindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
const float * swindow = sce->ics.use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
const float * pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
memcpy(s->output, sce->saved, sizeof(float)*1024);
if(sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE){
memset(s->output, 0, sizeof(s->output[0]) * 448);
for(i = 448; i < 576; i++)
s->output[i] = sce->saved[i] * pwindow[i - 448];
for(i = 576; i < 704; i++)
s->output[i] = sce->saved[i];
}
if(sce->ics.window_sequence[0] != LONG_START_SEQUENCE){
j = channel;
for (i = 0; i < 1024; i++, j += avctx->channels){
s->output[i+1024] = audio[j] * lwindow[1024 - i - 1];
sce->saved[i] = audio[j] * lwindow[i];
}
}else{
j = channel;
for(i = 0; i < 448; i++, j += avctx->channels)
s->output[i+1024] = audio[j];
for(i = 448; i < 576; i++, j += avctx->channels)
s->output[i+1024] = audio[j] * swindow[576 - i - 1];
memset(s->output+1024+576, 0, sizeof(s->output[0]) * 448);
j = channel;
for(i = 0; i < 1024; i++, j += avctx->channels)
sce->saved[i] = audio[j];
}
ff_mdct_calc(&s->mdct1024, sce->coeffs, s->output);
}else{
j = channel;
for (k = 0; k < 1024; k += 128) {
for(i = 448 + k; i < 448 + k + 256; i++)
s->output[i - 448 - k] = (i < 1024)
? sce->saved[i]
: audio[channel + (i-1024)*avctx->channels];
s->dsp.vector_fmul (s->output, k ? swindow : pwindow, 128);
s->dsp.vector_fmul_reverse(s->output+128, s->output+128, swindow, 128);
ff_mdct_calc(&s->mdct128, sce->coeffs + k, s->output);
}
j = channel;
for(i = 0; i < 1024; i++, j += avctx->channels)
sce->saved[i] = audio[j];
}
}
/**
* Encode ics_info element.
* @see Table 4.6 (syntax of ics_info)
*/
static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
{
int i;
int w;
put_bits(&s->pb, 1, 0); // ics_reserved bit
put_bits(&s->pb, 2, info->window_sequence[0]);
......@@ -252,27 +276,118 @@ static void put_ics_info(AACEncContext *s, IndividualChannelStream *info)
put_bits(&s->pb, 1, 0); // no prediction
}else{
put_bits(&s->pb, 4, info->max_sfb);
for(i = 1; i < info->num_windows; i++)
put_bits(&s->pb, 1, info->group_len[i]);
for(w = 1; w < 8; w++){
put_bits(&s->pb, 1, !info->group_len[w]);
}
}
}
/**
* Calculate the number of bits needed to code all coefficient signs in current band.
* Encode MS data.
* @see 4.6.8.1 "Joint Coding - M/S Stereo"
*/
static int calculate_band_sign_bits(AACEncContext *s, SingleChannelElement *sce,
int group_len, int start, int size)
static void encode_ms_info(PutBitContext *pb, ChannelElement *cpe)
{
int bits = 0;
int i, w;
for(w = 0; w < group_len; w++){
for(i = 0; i < size; i++){
if(sce->icoefs[start + i])
bits++;
put_bits(pb, 2, cpe->ms_mode);
if(cpe->ms_mode == 1){
for(w = 0; w < cpe->ch[0].ics.num_windows; w += cpe->ch[0].ics.group_len[w]){
for(i = 0; i < cpe->ch[0].ics.max_sfb; i++)
put_bits(pb, 1, cpe->ms_mask[w*16 + i]);
}
}
}
/**
* Produce integer coefficients from scalefactors provided by the model.
*/
static void adjust_frame_information(AACEncContext *apc, ChannelElement *cpe, int chans)
{
int i, w, w2, g, ch;
int start, sum, maxsfb, cmaxsfb;
for(ch = 0; ch < chans; ch++){
IndividualChannelStream *ics = &cpe->ch[ch].ics;
start = 0;
maxsfb = 0;
cpe->ch[ch].pulse.num_pulse = 0;
for(w = 0; w < ics->num_windows*16; w += 16){
for(g = 0; g < ics->num_swb; g++){
sum = 0;
//apply M/S
if(!ch && cpe->ms_mask[w + g]){
for(i = 0; i < ics->swb_sizes[g]; i++){
cpe->ch[0].coeffs[start+i] = (cpe->ch[0].coeffs[start+i] + cpe->ch[1].coeffs[start+i]) / 2.0;
cpe->ch[1].coeffs[start+i] = cpe->ch[0].coeffs[start+i] - cpe->ch[1].coeffs[start+i];
}
}
start += ics->swb_sizes[g];
}
for(cmaxsfb = ics->num_swb; cmaxsfb > 0 && cpe->ch[ch].zeroes[w+cmaxsfb-1]; cmaxsfb--);
maxsfb = FFMAX(maxsfb, cmaxsfb);
}
ics->max_sfb = maxsfb;
//adjust zero bands for window groups
for(w = 0; w < ics->num_windows; w += ics->group_len[w]){
for(g = 0; g < ics->max_sfb; g++){
i = 1;
for(w2 = w; w2 < w + ics->group_len[w]; w2++){
if(!cpe->ch[ch].zeroes[w2*16 + g]){
i = 0;
break;
}
}
cpe->ch[ch].zeroes[w*16 + g] = i;
}
}
}
if(chans > 1 && cpe->common_window){
IndividualChannelStream *ics0 = &cpe->ch[0].ics;
IndividualChannelStream *ics1 = &cpe->ch[1].ics;
int msc = 0;
ics0->max_sfb = FFMAX(ics0->max_sfb, ics1->max_sfb);
ics1->max_sfb = ics0->max_sfb;
for(w = 0; w < ics0->num_windows*16; w += 16)
for(i = 0; i < ics0->max_sfb; i++)
if(cpe->ms_mask[w+i]) msc++;
if(msc == 0 || ics0->max_sfb == 0) cpe->ms_mode = 0;
else cpe->ms_mode = msc < ics0->max_sfb ? 1 : 2;
}
}
/**
* Encode scalefactor band coding type.
*/
static void encode_band_info(AACEncContext *s, SingleChannelElement *sce)
{
int w;
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
s->coder->encode_window_bands_info(s, sce, w, sce->ics.group_len[w], s->lambda);
}
}
/**
* Encode scalefactors.
*/
static void encode_scale_factors(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce)
{
int off = sce->sf_idx[0], diff;
int i, w;
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
for(i = 0; i < sce->ics.max_sfb; i++){
if(!sce->zeroes[w*16 + i]){
diff = sce->sf_idx[w*16 + i] - off + SCALE_DIFF_ZERO;
if(diff < 0 || diff > 120) av_log(avctx, AV_LOG_ERROR, "Scalefactor difference is too big to be coded\n");
off = sce->sf_idx[w*16 + i];
put_bits(&s->pb, ff_aac_scalefactor_bits[diff], ff_aac_scalefactor_code[diff]);
}
}
start += 128;
}
return bits;
}
/**
......@@ -298,27 +413,43 @@ static void encode_pulses(AACEncContext *s, Pulse *pulse)
*/
static void encode_spectral_coeffs(AACEncContext *s, SingleChannelElement *sce)
{
int start, i, w, w2, wg;
int start, i, w, w2;
w = 0;
for(wg = 0; wg < sce->ics.num_window_groups; wg++){
for(w = 0; w < sce->ics.num_windows; w += sce->ics.group_len[w]){
start = 0;
for(i = 0; i < sce->ics.max_sfb; i++){
if(sce->zeroes[w*16 + i]){
start += sce->ics.swb_sizes[i];
continue;
}
for(w2 = w; w2 < w + sce->ics.group_len[wg]; w2++){
encode_band_coeffs(s, sce, start + w2*128,
sce->ics.swb_sizes[i],
sce->band_type[w*16 + i]);
for(w2 = w; w2 < w + sce->ics.group_len[w]; w2++){
s->coder->quantize_and_encode_band(s, &s->pb, sce->coeffs + start + w2*128,
sce->ics.swb_sizes[i],
sce->sf_idx[w*16 + i],
sce->band_type[w*16 + i],
s->lambda);
}
start += sce->ics.swb_sizes[i];
}
w += sce->ics.group_len[wg];
}
}
/**
* Encode one channel of audio data.
*/
static int encode_individual_channel(AVCodecContext *avctx, AACEncContext *s, SingleChannelElement *sce, int common_window)
{
put_bits(&s->pb, 8, sce->sf_idx[0]);
if(!common_window) put_ics_info(s, &sce->ics);
encode_band_info(s, sce);
encode_scale_factors(avctx, s, sce);
encode_pulses(s, &sce->pulse);
put_bits(&s->pb, 1, 0); //tns
put_bits(&s->pb, 1, 0); //ssr
encode_spectral_coeffs(s, sce);
return 0;
}
/**
* Write some auxiliary information about the created AAC file.
*/
......@@ -339,13 +470,130 @@ static void put_bitstream_info(AVCodecContext *avctx, AACEncContext *s, const ch
put_bits(&s->pb, 12 - padbits, 0);
}
static int aac_encode_frame(AVCodecContext *avctx,
uint8_t *frame, int buf_size, void *data)
{
AACEncContext *s = avctx->priv_data;
int16_t *samples = s->samples, *samples2, *la;
ChannelElement *cpe;
int i, j, chans, tag, start_ch;
const uint8_t *chan_map = aac_chan_configs[avctx->channels-1];
int chan_el_counter[4];
if(s->last_frame)
return 0;
if(data){
if(!s->psypp){
memcpy(s->samples + 1024 * avctx->channels, data, 1024 * avctx->channels * sizeof(s->samples[0]));
}else{
start_ch = 0;
samples2 = s->samples + 1024 * avctx->channels;
for(i = 0; i < chan_map[0]; i++){
tag = chan_map[i+1];
chans = tag == TYPE_CPE ? 2 : 1;
ff_psy_preprocess(s->psypp, (uint16_t*)data + start_ch, samples2 + start_ch, start_ch, chans);
start_ch += chans;
}
}
}
if(!avctx->frame_number){
memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0]));
return 0;
}
init_put_bits(&s->pb, frame, buf_size*8);
if((avctx->frame_number & 0xFF)==1 && !(avctx->flags & CODEC_FLAG_BITEXACT)){
put_bitstream_info(avctx, s, LIBAVCODEC_IDENT);
}
start_ch = 0;
memset(chan_el_counter, 0, sizeof(chan_el_counter));
for(i = 0; i < chan_map[0]; i++){
FFPsyWindowInfo wi[2];
tag = chan_map[i+1];
chans = tag == TYPE_CPE ? 2 : 1;
cpe = &s->cpe[i];
samples2 = samples + start_ch;
la = samples2 + 1024 * avctx->channels + start_ch;
if(!data) la = NULL;
for(j = 0; j < chans; j++){
IndividualChannelStream *ics = &cpe->ch[j].ics;
int k;
wi[j] = ff_psy_suggest_window(&s->psy, samples2, la, start_ch + j, ics->window_sequence[0]);
ics->window_sequence[1] = ics->window_sequence[0];
ics->window_sequence[0] = wi[j].window_type[0];
ics->use_kb_window[1] = ics->use_kb_window[0];
ics->use_kb_window[0] = wi[j].window_shape;
ics->num_windows = wi[j].num_windows;
ics->swb_sizes = s->psy.bands [ics->num_windows == 8];
ics->num_swb = s->psy.num_bands[ics->num_windows == 8];
for(k = 0; k < ics->num_windows; k++)
ics->group_len[k] = wi[j].grouping[k];
s->cur_channel = start_ch + j;
apply_window_and_mdct(avctx, s, &cpe->ch[j], samples2, j);
s->coder->search_for_quantizers(avctx, s, &cpe->ch[j], s->lambda);
}
cpe->common_window = 0;
if(chans > 1
&& wi[0].window_type[0] == wi[1].window_type[0]
&& wi[0].window_shape == wi[1].window_shape){
cpe->common_window = 1;
for(j = 0; j < wi[0].num_windows; j++){
if(wi[0].grouping[j] != wi[1].grouping[j]){
cpe->common_window = 0;
break;
}
}
}
if(cpe->common_window && s->coder->search_for_ms)
s->coder->search_for_ms(s, cpe, s->lambda);
adjust_frame_information(s, cpe, chans);
put_bits(&s->pb, 3, tag);
put_bits(&s->pb, 4, chan_el_counter[tag]++);
if(chans == 2){
put_bits(&s->pb, 1, cpe->common_window);
if(cpe->common_window){
put_ics_info(s, &cpe->ch[0].ics);
encode_ms_info(&s->pb, cpe);
}
}
for(j = 0; j < chans; j++){
s->cur_channel = start_ch + j;
ff_psy_set_band_info(&s->psy, s->cur_channel, cpe->ch[j].coeffs, &wi[j]);
encode_individual_channel(avctx, s, &cpe->ch[j], cpe->common_window);
}
start_ch += chans;
}
put_bits(&s->pb, 3, TYPE_END);
flush_put_bits(&s->pb);
avctx->frame_bits = put_bits_count(&s->pb);
// rate control stuff
if(!(avctx->flags & CODEC_FLAG_QSCALE)){
float ratio = avctx->bit_rate * 1024.0f / avctx->sample_rate / avctx->frame_bits;
s->lambda *= ratio;
}
if (avctx->frame_bits > 6144*avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "input buffer violation %d > %d.\n", avctx->frame_bits, 6144*avctx->channels);
}
if(!data)
s->last_frame = 1;
memcpy(s->samples, s->samples + 1024 * avctx->channels, 1024 * avctx->channels * sizeof(s->samples[0]));
return put_bits_count(&s->pb)>>3;
}
static av_cold int aac_encode_end(AVCodecContext *avctx)
{
AACEncContext *s = avctx->priv_data;
ff_mdct_end(&s->mdct1024);
ff_mdct_end(&s->mdct128);
ff_aac_psy_end(&s->psy);
ff_psy_end(&s->psy);
ff_psy_preprocess_end(s->psypp);
av_freep(&s->samples);
av_freep(&s->cpe);
return 0;
......
libavcodec/aacenc.h 0 → 100644
View file @ 78e65cd7
/*
* AAC encoder
* Copyright (C) 2008 Konstantin Shishkov
*
* 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
*/
#ifndef AVCODEC_AACENC_H
#define AVCODEC_AACENC_H
#include "avcodec.h"
#include "put_bits.h"
#include "dsputil.h"
#include "aac.h"
#include "psymodel.h"
struct AACEncContext;
typedef struct AACCoefficientsEncoder{
void (*search_for_quantizers)(AVCodecContext *avctx, struct AACEncContext *s,
SingleChannelElement *sce, const float lambda);
void (*encode_window_bands_info)(struct AACEncContext *s, SingleChannelElement *sce,
int win, int group_len, const float lambda);
void (*quantize_and_encode_band)(struct AACEncContext *s, PutBitContext *pb, const float *in, int size,
int scale_idx, int cb, const float lambda);
void (*search_for_ms)(struct AACEncContext *s, ChannelElement *cpe, const float lambda);
}AACCoefficientsEncoder;
extern AACCoefficientsEncoder ff_aac_coders[];
/**
* AAC encoder context
*/
typedef struct AACEncContext {
PutBitContext pb;
MDCTContext mdct1024; ///< long (1024 samples) frame transform context
MDCTContext mdct128; ///< short (128 samples) frame transform context
DSPContext dsp;
DECLARE_ALIGNED_16(FFTSample, output[2048]); ///< temporary buffer for MDCT input coefficients
int16_t* samples; ///< saved preprocessed input
int samplerate_index; ///< MPEG-4 samplerate index
ChannelElement *cpe; ///< channel elements
FFPsyContext psy;
struct FFPsyPreprocessContext* psypp;
AACCoefficientsEncoder *coder;
int cur_channel;
int last_frame;
float lambda;
DECLARE_ALIGNED_16(int, qcoefs[96][2]); ///< quantized coefficients
DECLARE_ALIGNED_16(float, scoefs[1024]); ///< scaled coefficients
} AACEncContext;
#endif /* AVCODEC_AACENC_H */
libavcodec/aacpsy.c
View file @ 78e65cd7
......@@ -25,54 +25,25 @@
*/
#include "avcodec.h"
#include "aacpsy.h"
#include "aactab.h"
#include "psymodel.h"
/***********************************
* TODOs:
* General:
* better audio preprocessing (add DC highpass filter?)
* more psy models
* maybe improve coefficient quantization function in some way
*
* 3GPP-based psy model:
* thresholds linearization after their modifications for attaining given bitrate
* try other bitrate controlling mechanism (maybe use ratecontrol.c?)
* control quality for quality-based output
**********************************/
/**
* Quantize one coefficient.
* @return absolute value of the quantized coefficient
* @see 3GPP TS26.403 5.6.2 "Scalefactor determination"
*/
static av_always_inline int quant(float coef, const float Q)
{
return av_clip((int)(pow(fabsf(coef) * Q, 0.75) + 0.4054), 0, 8191);
}
static inline float get_approximate_quant_error(float *c, int size, int scale_idx)
{
int i;
int q;
float coef, unquant, sum = 0.0f;
const float Q = ff_aac_pow2sf_tab[200 - scale_idx + SCALE_ONE_POS - SCALE_DIV_512];
const float IQ = ff_aac_pow2sf_tab[200 + scale_idx - SCALE_ONE_POS + SCALE_DIV_512];
for(i = 0; i < size; i++){
coef = fabs(c[i]);
q = quant(c[i], Q);
unquant = (q * cbrt(q)) * IQ;
sum += (coef - unquant) * (coef - unquant);
}
return sum;
}
/**
* constants for 3GPP AAC psychoacoustic model
* @{
*/
#define PSY_3GPP_SPREAD_LOW 1.5f // spreading factor for ascending threshold spreading (15 dB/Bark)
#define PSY_3GPP_SPREAD_HI 3.0f // spreading factor for descending threshold spreading (30 dB/Bark)
#define PSY_3GPP_RPEMIN 0.01f
#define PSY_3GPP_RPELEV 2.0f
/**
* @}
*/
......@@ -83,8 +54,24 @@ static inline float get_approximate_quant_error(float *c, int size, int scale_id
typedef struct Psy3gppBand{
float energy; ///< band energy
float ffac; ///< form factor
float thr; ///< energy threshold
float min_snr; ///< minimal SNR
float thr_quiet; ///< threshold in quiet
}Psy3gppBand;
/**
* single/pair channel context for psychoacoustic model
*/
typedef struct Psy3gppChannel{
Psy3gppBand band[128]; ///< bands information
Psy3gppBand prev_band[128]; ///< bands information from the previous frame
float win_energy; ///< sliding average of channel energy
float iir_state[2]; ///< hi-pass IIR filter state
uint8_t next_grouping; ///< stored grouping scheme for the next frame (in case of 8 short window sequence)
enum WindowSequence next_window_seq; ///< window sequence to be used in the next frame
}Psy3gppChannel;
/**
* psychoacoustic model frame type-dependent coefficients
*/
......@@ -95,10 +82,241 @@ typedef struct Psy3gppCoeffs{
float spread_hi [64]; ///< spreading factor for high-to-low threshold spreading in long frame
}Psy3gppCoeffs;
/**
* 3GPP TS26.403-inspired psychoacoustic model specific data
*/
typedef struct Psy3gppContext{
Psy3gppCoeffs psy_coef[2];
Psy3gppChannel *ch;
}Psy3gppContext;
/**
* Calculate Bark value for given line.
*/
static inline float calc_bark(float f)
static av_cold float calc_bark(float f)
{
return 13.3f * atanf(0.00076f * f) + 3.5f * atanf((f / 7500.0f) * (f / 7500.0f));
}
#define ATH_ADD 4
/**
* Calculate ATH value for given frequency.
* Borrowed from Lame.
*/
static av_cold float ath(float f, float add)
{
f /= 1000.0f;
return 3.64 * pow(f, -0.8)
- 6.8 * exp(-0.6 * (f - 3.4) * (f - 3.4))
+ 6.0 * exp(-0.15 * (f - 8.7) * (f - 8.7))
+ (0.6 + 0.04 * add) * 0.001 * f * f * f * f;
}
static av_cold int psy_3gpp_init(FFPsyContext *ctx){
Psy3gppContext *pctx;
float barks[1024];
int i, j, g, start;
float prev, minscale, minath;
ctx->model_priv_data = av_mallocz(sizeof(Psy3gppContext));
pctx = (Psy3gppContext*) ctx->model_priv_data;
for(i = 0; i < 1024; i++)
barks[i] = calc_bark(i * ctx->avctx->sample_rate / 2048.0);
minath = ath(3410, ATH_ADD);
for(j = 0; j < 2; j++){
Psy3gppCoeffs *coeffs = &pctx->psy_coef[j];
i = 0;
prev = 0.0;
for(g = 0; g < ctx->num_bands[j]; g++){
i += ctx->bands[j][g];
coeffs->barks[g] = (barks[i - 1] + prev) / 2.0;
prev = barks[i - 1];
}
for(g = 0; g < ctx->num_bands[j] - 1; g++){
coeffs->spread_low[g] = pow(10.0, -(coeffs->barks[g+1] - coeffs->barks[g]) * PSY_3GPP_SPREAD_LOW);
coeffs->spread_hi [g] = pow(10.0, -(coeffs->barks[g+1] - coeffs->barks[g]) * PSY_3GPP_SPREAD_HI);
}
start = 0;
for(g = 0; g < ctx->num_bands[j]; g++){
minscale = ath(ctx->avctx->sample_rate * start / 1024.0, ATH_ADD);
for(i = 1; i < ctx->bands[j][g]; i++){
minscale = fminf(minscale, ath(ctx->avctx->sample_rate * (start + i) / 1024.0 / 2.0, ATH_ADD));
}
coeffs->ath[g] = minscale - minath;
start += ctx->bands[j][g];
}
}
pctx->ch = av_mallocz(sizeof(Psy3gppChannel) * ctx->avctx->channels);
return 0;
}
/**
* IIR filter used in block switching decision
*/
static float iir_filter(int in, float state[2])
{
float ret;
ret = 0.7548f * (in - state[0]) + 0.5095f * state[1];
state[0] = in;
state[1] = ret;
return ret;
}
/**
* window grouping information stored as bits (0 - new group, 1 - group continues)
*/
static const uint8_t window_grouping[9] = {
0xB6, 0x6C, 0xD8, 0xB2, 0x66, 0xC6, 0x96, 0x36, 0x36
};
/**
* Tell encoder which window types to use.
* @see 3GPP TS26.403 5.4.1 "Blockswitching"
*/
static FFPsyWindowInfo psy_3gpp_window(FFPsyContext *ctx,
const int16_t *audio, const int16_t *la,
int channel, int prev_type)
{
int i, j;
int br = ctx->avctx->bit_rate / ctx->avctx->channels;
int attack_ratio = br <= 16000 ? 18 : 10;
Psy3gppContext *pctx = (Psy3gppContext*) ctx->model_priv_data;
Psy3gppChannel *pch = &pctx->ch[channel];
uint8_t grouping = 0;
FFPsyWindowInfo wi;
memset(&wi, 0, sizeof(wi));
if(la){
float s[8], v;
int switch_to_eight = 0;
float sum = 0.0, sum2 = 0.0;
int attack_n = 0;
for(i = 0; i < 8; i++){
for(j = 0; j < 128; j++){
v = iir_filter(audio[(i*128+j)*ctx->avctx->channels], pch->iir_state);
sum += v*v;
}
s[i] = sum;
sum2 += sum;
}
for(i = 0; i < 8; i++){
if(s[i] > pch->win_energy * attack_ratio){
attack_n = i + 1;
switch_to_eight = 1;
break;
}
}
pch->win_energy = pch->win_energy*7/8 + sum2/64;
wi.window_type[1] = prev_type;
switch(prev_type){
case ONLY_LONG_SEQUENCE:
wi.window_type[0] = switch_to_eight ? LONG_START_SEQUENCE : ONLY_LONG_SEQUENCE;
break;
case LONG_START_SEQUENCE:
wi.window_type[0] = EIGHT_SHORT_SEQUENCE;
grouping = pch->next_grouping;
break;
case LONG_STOP_SEQUENCE:
wi.window_type[0] = ONLY_LONG_SEQUENCE;
break;
case EIGHT_SHORT_SEQUENCE:
wi.window_type[0] = switch_to_eight ? EIGHT_SHORT_SEQUENCE : LONG_STOP_SEQUENCE;
grouping = switch_to_eight ? pch->next_grouping : 0;
break;
}
pch->next_grouping = window_grouping[attack_n];
}else{
for(i = 0; i < 3; i++)
wi.window_type[i] = prev_type;
grouping = (prev_type == EIGHT_SHORT_SEQUENCE) ? window_grouping[0] : 0;
}
wi.window_shape = 1;
if(wi.window_type[0] != EIGHT_SHORT_SEQUENCE){
wi.num_windows = 1;
wi.grouping[0] = 1;
}else{
int lastgrp = 0;
wi.num_windows = 8;
for(i = 0; i < 8; i++){
if(!((grouping >> i) & 1))
lastgrp = i;
wi.grouping[lastgrp]++;
}
}
return wi;
}
/**
* Calculate band thresholds as suggested in 3GPP TS26.403
*/
static void psy_3gpp_analyze(FFPsyContext *ctx, int channel, const float *coefs,
FFPsyWindowInfo *wi)
{
Psy3gppContext *pctx = (Psy3gppContext*) ctx->model_priv_data;
Psy3gppChannel *pch = &pctx->ch[channel];
int start = 0;
int i, w, g;
const int num_bands = ctx->num_bands[wi->num_windows == 8];
const uint8_t* band_sizes = ctx->bands[wi->num_windows == 8];
Psy3gppCoeffs *coeffs = &pctx->psy_coef[wi->num_windows == 8];
//calculate energies, initial thresholds and related values - 5.4.2 "Threshold Calculation"
for(w = 0; w < wi->num_windows*16; w += 16){
for(g = 0; g < num_bands; g++){
Psy3gppBand *band = &pch->band[w+g];
band->energy = 0.0f;
for(i = 0; i < band_sizes[g]; i++)
band->energy += coefs[start+i] * coefs[start+i];
band->energy *= 1.0f / (512*512);
band->thr = band->energy * 0.001258925f;
start += band_sizes[g];
ctx->psy_bands[channel*PSY_MAX_BANDS+w+g].energy = band->energy;
}
}
//modify thresholds - spread, threshold in quiet - 5.4.3 "Spreaded Energy Calculation"
for(w = 0; w < wi->num_windows*16; w += 16){
Psy3gppBand *band = &pch->band[w];
for(g = 1; g < num_bands; g++){
band[g].thr = FFMAX(band[g].thr, band[g-1].thr * coeffs->spread_low[g-1]);
}
for(g = num_bands - 2; g >= 0; g--){
band[g].thr = FFMAX(band[g].thr, band[g+1].thr * coeffs->spread_hi [g]);
}
for(g = 0; g < num_bands; g++){
band[g].thr_quiet = FFMAX(band[g].thr, coeffs->ath[g]);
if(wi->num_windows != 8 && wi->window_type[1] != EIGHT_SHORT_SEQUENCE){
band[g].thr_quiet = fmaxf(PSY_3GPP_RPEMIN*band[g].thr_quiet,
fminf(band[g].thr_quiet,
PSY_3GPP_RPELEV*pch->prev_band[w+g].thr_quiet));
}
band[g].thr = FFMAX(band[g].thr, band[g].thr_quiet * 0.25);
ctx->psy_bands[channel*PSY_MAX_BANDS+w+g].threshold = band[g].thr;
}
}
memcpy(pch->prev_band, pch->band, sizeof(pch->band));
}
static av_cold void psy_3gpp_end(FFPsyContext *apc)
{
Psy3gppContext *pctx = (Psy3gppContext*) apc->model_priv_data;
av_freep(&pctx->ch);
av_freep(&apc->model_priv_data);
}
const FFPsyModel ff_aac_psy_model =
{
.name = "3GPP TS 26.403-inspired model",
.init = psy_3gpp_init,
.window = psy_3gpp_window,
.analyze = psy_3gpp_analyze,
.end = psy_3gpp_end,
};
libavcodec/allcodecs.c
View file @ 78e65cd7
......@@ -195,7 +195,7 @@ void avcodec_register_all(void)
REGISTER_ENCDEC (ZMBV, zmbv);
/* audio codecs */
REGISTER_DECODER (AAC, aac);
REGISTER_ENCDEC (AAC, aac);
REGISTER_ENCDEC (AC3, ac3);
REGISTER_ENCDEC (ALAC, alac);
REGISTER_DECODER (APE, ape);
......
libavcodec/psymodel.c 0 → 100644
View file @ 78e65cd7
/*
* audio encoder psychoacoustic model
* Copyright (C) 2008 Konstantin Shishkov
*
* 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 "avcodec.h"
#include "psymodel.h"
#include "iirfilter.h"
extern const FFPsyModel ff_aac_psy_model;
av_cold int ff_psy_init(FFPsyContext *ctx, AVCodecContext *avctx,
int num_lens,
const uint8_t **bands, const int* num_bands)
{
ctx->avctx = avctx;
ctx->psy_bands = av_mallocz(sizeof(FFPsyBand) * PSY_MAX_BANDS * avctx->channels);
ctx->bands = av_malloc (sizeof(ctx->bands[0]) * num_lens);
ctx->num_bands = av_malloc (sizeof(ctx->num_bands[0]) * num_lens);
memcpy(ctx->bands, bands, sizeof(ctx->bands[0]) * num_lens);
memcpy(ctx->num_bands, num_bands, sizeof(ctx->num_bands[0]) * num_lens);
switch(ctx->avctx->codec_id){
case CODEC_ID_AAC:
ctx->model = &ff_aac_psy_model;
break;
}
if(ctx->model->init)
return ctx->model->init(ctx);
return 0;
}
FFPsyWindowInfo ff_psy_suggest_window(FFPsyContext *ctx,
const int16_t *audio, const int16_t *la,
int channel, int prev_type)
{
return ctx->model->window(ctx, audio, la, channel, prev_type);
}
void ff_psy_set_band_info(FFPsyContext *ctx, int channel,
const float *coeffs, FFPsyWindowInfo *wi)
{
ctx->model->analyze(ctx, channel, coeffs, wi);
}
av_cold void ff_psy_end(FFPsyContext *ctx)
{
if(ctx->model->end)
ctx->model->end(ctx);
av_freep(&ctx->bands);
av_freep(&ctx->num_bands);
av_freep(&ctx->psy_bands);
}
typedef struct FFPsyPreprocessContext{
AVCodecContext *avctx;
float stereo_att;
struct FFIIRFilterCoeffs *fcoeffs;
struct FFIIRFilterState **fstate;
}FFPsyPreprocessContext;
#define FILT_ORDER 4
av_cold struct FFPsyPreprocessContext* ff_psy_preprocess_init(AVCodecContext *avctx)
{
FFPsyPreprocessContext *ctx;
int i;
float cutoff_coeff;
ctx = av_mallocz(sizeof(FFPsyPreprocessContext));
ctx->avctx = avctx;
if(avctx->flags & CODEC_FLAG_QSCALE)
cutoff_coeff = 1.0f / av_clip(1 + avctx->global_quality / FF_QUALITY_SCALE, 1, 8);
else
cutoff_coeff = avctx->bit_rate / (4.0f * avctx->sample_rate * avctx->channels);
ctx->fcoeffs = ff_iir_filter_init_coeffs(FF_FILTER_TYPE_BUTTERWORTH, FF_FILTER_MODE_LOWPASS,
FILT_ORDER, cutoff_coeff, 0.0, 0.0);
if(ctx->fcoeffs){
ctx->fstate = av_mallocz(sizeof(ctx->fstate[0]) * avctx->channels);
for(i = 0; i < avctx->channels; i++)
ctx->fstate[i] = ff_iir_filter_init_state(FILT_ORDER);
}
return ctx;
}
void ff_psy_preprocess(struct FFPsyPreprocessContext *ctx,
const int16_t *audio, int16_t *dest,
int tag, int channels)
{
int ch, i;
if(ctx->fstate){
for(ch = 0; ch < channels; ch++){
ff_iir_filter(ctx->fcoeffs, ctx->fstate[tag+ch], ctx->avctx->frame_size,
audio + ch, ctx->avctx->channels,
dest + ch, ctx->avctx->channels);
}
}else{
for(ch = 0; ch < channels; ch++){
for(i = 0; i < ctx->avctx->frame_size; i++)
dest[i*ctx->avctx->channels + ch] = audio[i*ctx->avctx->channels + ch];
}
}
}
av_cold void ff_psy_preprocess_end(struct FFPsyPreprocessContext *ctx)
{
int i;
ff_iir_filter_free_coeffs(ctx->fcoeffs);
if (ctx->fstate)
for (i = 0; i < ctx->avctx->channels; i++)
ff_iir_filter_free_state(ctx->fstate[i]);
av_freep(&ctx->fstate);
}
libavcodec/psymodel.h 0 → 100644
View file @ 78e65cd7
/*
* audio encoder psychoacoustic model
* Copyright (C) 2008 Konstantin Shishkov
*
* 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
*/
#ifndef AVCODEC_PSYMODEL_H
#define AVCODEC_PSYMODEL_H
#include "avcodec.h"
/** maximum possible number of bands */
#define PSY_MAX_BANDS 128
/**
* single band psychoacoustic information
*/
typedef struct FFPsyBand{
int bits;
float energy;
float threshold;
float distortion;
float perceptual_weight;
}FFPsyBand;
/**
* windowing related information
*/
typedef struct FFPsyWindowInfo{
int window_type[3]; ///< window type (short/long/transitional, etc.) - current, previous and next
int window_shape; ///< window shape (sine/KBD/whatever)
int num_windows; ///< number of windows in a frame
int grouping[8]; ///< window grouping (for e.g. AAC)
int *window_sizes; ///< sequence of window sizes inside one frame (for eg. WMA)
}FFPsyWindowInfo;
/**
* context used by psychoacoustic model
*/
typedef struct FFPsyContext{
AVCodecContext *avctx; ///< encoder context
const struct FFPsyModel *model; ///< encoder-specific model functions
FFPsyBand *psy_bands; ///< frame bands information
uint8_t **bands; ///< scalefactor band sizes for possible frame sizes
int *num_bands; ///< number of scalefactor bands for possible frame sizes
int num_lens; ///< number of scalefactor band sets
void* model_priv_data; ///< psychoacoustic model implementation private data
}FFPsyContext;
/**
* codec-specific psychoacoustic model implementation
*/
typedef struct FFPsyModel {
const char *name;
int (*init) (FFPsyContext *apc);
FFPsyWindowInfo (*window)(FFPsyContext *ctx, const int16_t *audio, const int16_t *la, int channel, int prev_type);
void (*analyze)(FFPsyContext *ctx, int channel, const float *coeffs, FFPsyWindowInfo *wi);
void (*end) (FFPsyContext *apc);
}FFPsyModel;
/**
* Initialize psychoacoustic model.
*
* @param ctx model context
* @param avctx codec context
* @param num_lens number of possible frame lengths
* @param bands scalefactor band lengths for all frame lengths
* @param num_bands number of scalefactor bands for all frame lengths
*
* @return zero if successful, a negative value if not
*/
av_cold int ff_psy_init(FFPsyContext *ctx, AVCodecContext *avctx,
int num_lens,
const uint8_t **bands, const int* num_bands);
/**
* Suggest window sequence for channel.
*
* @param ctx model context
* @param audio samples for the current frame
* @param la lookahead samples (NULL when unavailable)
* @param channel number of channel element to analyze
* @param prev_type previous window type
*
* @return suggested window information in a structure
*/
FFPsyWindowInfo ff_psy_suggest_window(FFPsyContext *ctx,
const int16_t *audio, const int16_t *la,
int channel, int prev_type);
/**
* Perform psychoacoustic analysis and set band info (threshold, energy).
*
* @param ctx model context
* @param channel audio channel number
* @param coeffs pointer to the transformed coefficients
* @param wi window information
*/
void ff_psy_set_band_info(FFPsyContext *ctx, int channel, const float *coeffs,
FFPsyWindowInfo *wi);
/**
* Cleanup model context at the end.
*
* @param ctx model context
*/
av_cold void ff_psy_end(FFPsyContext *ctx);
/**************************************************************************
* Audio preprocessing stuff. *
* This should be moved into some audio filter eventually. *
**************************************************************************/
struct FFPsyPreprocessContext;
/**
* psychoacoustic model audio preprocessing initialization
*/
av_cold struct FFPsyPreprocessContext* ff_psy_preprocess_init(AVCodecContext *avctx);
/**
* Preprocess several channel in audio frame in order to compress it better.
*
* @param ctx preprocessing context
* @param audio samples to preprocess
* @param dest place to put filtered samples
* @param tag channel number
* @param channels number of channel to preprocess (some additional work may be done on stereo pair)
*/
void ff_psy_preprocess(struct FFPsyPreprocessContext *ctx,
const int16_t *audio, int16_t *dest,
int tag, int channels);
/**
* Cleanup audio preprocessing module.
*/
av_cold void ff_psy_preprocess_end(struct FFPsyPreprocessContext *ctx);
#endif /* AVCODEC_PSYMODEL_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment