diff --git a/libavcodec/aacenc.c b/libavcodec/aacenc.c
index 232eeda04fafd42101635d932f99d242a511f5a7..1a845be407446be284b49c8ae43359ecb8748274 100644
--- a/libavcodec/aacenc.c
+++ b/libavcodec/aacenc.c
@@ -611,7 +611,7 @@ static int aac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
if (s->options.tns && s->coder->search_for_tns)
s->coder->search_for_tns(s, sce);
if (s->options.tns && s->coder->apply_tns_filt)
- s->coder->apply_tns_filt(sce);
+ s->coder->apply_tns_filt(s, sce);
if (sce->tns.present)
tns_mode = 1;
}
diff --git a/libavcodec/aacenc.h b/libavcodec/aacenc.h
index 51dce8a0fd1a0b5456c1279b99c4b1eee7318771..2b7a62a146e09c61b88c741ef2b24597b337e3b7 100644
--- a/libavcodec/aacenc.h
+++ b/libavcodec/aacenc.h
@@ -63,7 +63,7 @@ typedef struct AACCoefficientsEncoder {
void (*encode_main_pred)(struct AACEncContext *s, SingleChannelElement *sce);
void (*adjust_common_prediction)(struct AACEncContext *s, ChannelElement *cpe);
void (*apply_main_pred)(struct AACEncContext *s, SingleChannelElement *sce);
- void (*apply_tns_filt)(SingleChannelElement *sce);
+ void (*apply_tns_filt)(struct AACEncContext *s, SingleChannelElement *sce);
void (*set_special_band_scalefactors)(struct AACEncContext *s, SingleChannelElement *sce);
void (*search_for_pns)(struct AACEncContext *s, AVCodecContext *avctx, SingleChannelElement *sce);
void (*search_for_tns)(struct AACEncContext *s, SingleChannelElement *sce);
diff --git a/libavcodec/aacenc_tns.c b/libavcodec/aacenc_tns.c
index d4d10e68ff2ec4c381391596ae3c4d4dd8c534d5..3c442e81d62129bdd14d7ffc1ac819c1238499ca 100644
--- a/libavcodec/aacenc_tns.c
+++ b/libavcodec/aacenc_tns.c
@@ -31,112 +31,80 @@
#include "aacenc_utils.h"
#include "aacenc_quantization.h"
-static inline int compress_coef(int *coefs, int num)
-{
- int i, c = 0;
- for (i = 0; i < num; i++)
- c += coefs[i] < 4 || coefs[i] > 11;
- return c == num;
-}
-
/**
* Encode TNS data.
* Coefficient compression saves a single bit per coefficient.
*/
void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
{
- int i, w, filt, coef_len, coef_compress;
+ uint8_t u_coef;
+ const uint8_t coef_res = TNS_Q_BITS == 4;
+ int i, w, filt, coef_len, coef_compress = 0;
const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
+ TemporalNoiseShaping *tns = &sce->tns;
if (!sce->tns.present)
return;
for (i = 0; i < sce->ics.num_windows; i++) {
put_bits(&s->pb, 2 - is8, sce->tns.n_filt[i]);
- if (sce->tns.n_filt[i]) {
- put_bits(&s->pb, 1, 1);
- for (filt = 0; filt < sce->tns.n_filt[i]; filt++) {
- put_bits(&s->pb, 6 - 2 * is8, sce->tns.length[i][filt]);
- put_bits(&s->pb, 5 - 2 * is8, sce->tns.order[i][filt]);
- if (sce->tns.order[i][filt]) {
- coef_compress = compress_coef(sce->tns.coef_idx[i][filt],
- sce->tns.order[i][filt]);
- put_bits(&s->pb, 1, !!sce->tns.direction[i][filt]);
+ if (tns->n_filt[i]) {
+ put_bits(&s->pb, 1, coef_res);
+ for (filt = 0; filt < tns->n_filt[i]; filt++) {
+ put_bits(&s->pb, 6 - 2 * is8, tns->length[i][filt]);
+ put_bits(&s->pb, 5 - 2 * is8, tns->order[i][filt]);
+ if (tns->order[i][filt]) {
+ put_bits(&s->pb, 1, !!tns->direction[i][filt]);
put_bits(&s->pb, 1, !!coef_compress);
- coef_len = 4 - coef_compress;
- for (w = 0; w < sce->tns.order[i][filt]; w++)
- put_bits(&s->pb, coef_len, sce->tns.coef_idx[i][filt][w]);
+ coef_len = coef_res + 3 - coef_compress;
+ for (w = 0; w < tns->order[i][filt]; w++) {
+ u_coef = (tns->coef_idx[i][filt][w])&(~(~0<<coef_len));
+ put_bits(&s->pb, coef_len, u_coef);
+ }
}
}
}
}
}
-static void process_tns_coeffs(TemporalNoiseShaping *tns, double *coef_raw,
- int *order_p, int w, int filt)
+static int quantize_coefs(double *coef, int *idx, float *lpc, int order)
{
- int i, j, order = *order_p;
- int *idx = tns->coef_idx[w][filt];
- float *lpc = tns->coef[w][filt];
- float temp[TNS_MAX_ORDER] = {0.0f}, out[TNS_MAX_ORDER] = {0.0f};
-
- if (!order)
- return;
-
- /* Not what the specs say, but it's better */
+ int i;
+ uint8_t u_coef;
+ const float *quant_arr = tns_tmp2_map[TNS_Q_BITS == 4];
+ const double iqfac_p = ((1 << (TNS_Q_BITS-1)) - 0.5)/(M_PI/2.0);
+ const double iqfac_m = ((1 << (TNS_Q_BITS-1)) + 0.5)/(M_PI/2.0);
for (i = 0; i < order; i++) {
- idx[i] = quant_array_idx(coef_raw[i], tns_tmp2_map_0_4, 16);
- lpc[i] = tns_tmp2_map_0_4[idx[i]];
- }
-
- /* Trim any coeff less than 0.1f from the end */
- for (i = order-1; i > -1; i--) {
- lpc[i] = (fabs(lpc[i]) > 0.1f) ? lpc[i] : 0.0f;
- if (lpc[i] != 0.0 ) {
- order = i;
- break;
- }
- }
- order = av_clip(order, 0, TNS_MAX_ORDER - 1);
- *order_p = order;
- if (!order)
- return;
-
- /* Step up procedure, convert to LPC coeffs */
- out[0] = 1.0f;
- for (i = 1; i <= order; i++) {
- for (j = 1; j < i; j++) {
- temp[j] = out[j] + lpc[i]*out[i-j];
- }
- for (j = 1; j <= i; j++) {
- out[j] = temp[j];
- }
- out[i] = lpc[i-1];
+ idx[i] = ceilf(asin(coef[i])*((coef[i] >= 0) ? iqfac_p : iqfac_m));
+ u_coef = (idx[i])&(~(~0<<TNS_Q_BITS));
+ lpc[i] = quant_arr[u_coef];
}
- memcpy(lpc, out, TNS_MAX_ORDER*sizeof(float));
+ return order;
}
/* Apply TNS filter */
-void ff_aac_apply_tns(SingleChannelElement *sce)
+void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)
{
- float *coef = sce->pcoeffs;
TemporalNoiseShaping *tns = &sce->tns;
- int w, filt, m, i;
- int bottom, top, order, start, end, size, inc;
- float *lpc, tmp[TNS_MAX_ORDER+1];
+ IndividualChannelStream *ics = &sce->ics;
+ int w, filt, m, i, top, order, bottom, start, end, size, inc;
+ const int mmm = FFMIN(ics->tns_max_bands, ics->max_sfb);
+ float lpc[TNS_MAX_ORDER];
- for (w = 0; w < sce->ics.num_windows; w++) {
- bottom = sce->ics.num_swb;
+ for (w = 0; w < ics->num_windows; w++) {
+ bottom = ics->num_swb;
for (filt = 0; filt < tns->n_filt[w]; filt++) {
top = bottom;
bottom = FFMAX(0, top - tns->length[w][filt]);
order = tns->order[w][filt];
- lpc = tns->coef[w][filt];
- if (!order)
+ if (order == 0)
continue;
- start = sce->ics.swb_offset[bottom];
- end = sce->ics.swb_offset[top];
+ // tns_decode_coef
+ compute_lpc_coefs(tns->coef[w][filt], order, lpc, 0, 0, 0);
+
+ start = ics->swb_offset[FFMIN(bottom, mmm)];
+ end = ics->swb_offset[FFMIN( top, mmm)];
if ((size = end - start) <= 0)
continue;
if (tns->direction[w][filt]) {
@@ -147,21 +115,10 @@ void ff_aac_apply_tns(SingleChannelElement *sce)
}
start += w * 128;
- if (!sce->ics.ltp.present) {
- // ar filter
- for (m = 0; m < size; m++, start += inc)
- for (i = 1; i <= FFMIN(m, order); i++)
- coef[start] += coef[start - i * inc]*lpc[i - 1];
- } else {
- // ma filter
- for (m = 0; m < size; m++, start += inc) {
- tmp[0] = coef[start];
- for (i = 1; i <= FFMIN(m, order); i++)
- coef[start] += tmp[i]*lpc[i - 1];
- for (i = order; i > 0; i--)
- tmp[i] = tmp[i - 1];
- }
- }
+ // ar filter
+ for (m = 0; m < size; m++, start += inc)
+ for (i = 1; i <= FFMIN(m, order); i++)
+ sce->coeffs[start] += lpc[i-1]*sce->pcoeffs[start - i*inc];
}
}
}
@@ -169,57 +126,53 @@ void ff_aac_apply_tns(SingleChannelElement *sce)
void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)
{
TemporalNoiseShaping *tns = &sce->tns;
- int w, g, w2, prev_end_sfb = 0, count = 0;
+ int w, w2, g, count = 0;
+ const int mmm = FFMIN(sce->ics.tns_max_bands, sce->ics.max_sfb);
const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
- const int tns_max_order = is8 ? 7 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
+ int order = is8 ? 7 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
+
+ int sfb_start = av_clip(tns_min_sfb[is8][s->samplerate_index], 0, mmm);
+ int sfb_end = av_clip(sce->ics.num_swb, 0, mmm);
for (w = 0; w < sce->ics.num_windows; w++) {
- int order = 0, filters = 1;
- int sfb_start = 0, sfb_len = 0;
- int coef_start = 0, coef_len = 0;
- float energy = 0.0f, threshold = 0.0f;
- double coefs[MAX_LPC_ORDER][MAX_LPC_ORDER] = {{0}};
+ float en_low = 0.0f, en_high = 0.0f, threshold = 0.0f, spread = 0.0f;
+ double gain = 0.0f, coefs[MAX_LPC_ORDER] = {0};
+
+ int coef_start = w*sce->ics.num_swb + sce->ics.swb_offset[sfb_start];
+ int coef_len = sce->ics.swb_offset[sfb_end] - sce->ics.swb_offset[sfb_start];
+
for (g = 0; g < sce->ics.num_swb; g++) {
- if (!sfb_start && w*16+g > TNS_LOW_LIMIT && w*16+g > prev_end_sfb) {
- sfb_start = w*16+g;
- coef_start = sce->ics.swb_offset[sfb_start];
- }
- if (sfb_start) {
- for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
- FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
- if (!sfb_len && band->energy < band->threshold*1.3f) {
- sfb_len = (w+w2)*16+g - sfb_start;
- prev_end_sfb = sfb_start + sfb_len;
- coef_len = sce->ics.swb_offset[sfb_start + sfb_len] - coef_start;
- break;
- }
- energy += band->energy;
- threshold += band->threshold;
- }
- if (!sfb_len) {
- sfb_len = (w+1)*16+g - sfb_start - 1;
- coef_len = sce->ics.swb_offset[sfb_start + sfb_len] - coef_start;
- }
+ if (w*16+g < sfb_start || w*16+g > sfb_end)
+ continue;
+ for (w2 = 0; w2 < sce->ics.group_len[w]; w2++) {
+ FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[(w+w2)*16+g];
+ if ((w+w2)*16+g > sfb_start + ((sfb_end - sfb_start)/2))
+ en_high += band->energy;
+ else
+ en_low += band->energy;
+ threshold += band->threshold;
+ spread += band->spread;
}
}
- if (sfb_len <= 0 || coef_len <= 0)
+ if (coef_len <= 0 || (sfb_end - sfb_start) <= 0)
continue;
- if (coef_start + coef_len >= 1024)
- coef_len = 1024 - coef_start;
/* LPC */
- order = ff_lpc_calc_levinson(&s->lpc, &sce->coeffs[coef_start], coef_len,
- coefs, 0, tns_max_order, ORDER_METHOD_LOG);
+ gain = ff_lpc_calc_ref_coefs_f(&s->lpc, &sce->coeffs[coef_start],
+ coef_len, order, coefs);
+
+ gain *= s->lambda/110.0f;
- if (energy > threshold) {
- int direction = 0;
- tns->n_filt[w] = filters++;
+ if (gain > TNS_GAIN_THRESHOLD_LOW && gain*0 < TNS_GAIN_THRESHOLD_HIGH &&
+ (en_low+en_high) > TNS_GAIN_THRESHOLD_LOW*threshold &&
+ spread > TNS_SPREAD_THRESHOLD) {
+ tns->n_filt[w] = 1;
for (g = 0; g < tns->n_filt[w]; g++) {
- process_tns_coeffs(tns, coefs[order], &order, w, g);
- tns->order[w][g] = order;
- tns->length[w][g] = sfb_len;
- tns->direction[w][g] = direction;
+ tns->length[w][g] = sfb_end - sfb_start;
+ tns->direction[w][g] = en_low < en_high && TNS_DIRECTION_VARY;
+ tns->order[w][g] = quantize_coefs(coefs, tns->coef_idx[w][g],
+ tns->coef[w][g], order);
}
count++;
}
diff --git a/libavcodec/aacenc_tns.h b/libavcodec/aacenc_tns.h
index 72c91239a38f74e7032d4560d047e81fff69f82d..812deeac8cafc5c7c0bbb75586beb726b583d889 100644
--- a/libavcodec/aacenc_tns.h
+++ b/libavcodec/aacenc_tns.h
@@ -30,11 +30,21 @@
#include "aacenc.h"
-/** Lower limit of TNS in SFBs **/
-#define TNS_LOW_LIMIT 24
+/* Could be set to 3 to save an additional bit at the cost of little quality */
+#define TNS_Q_BITS 4
+
+/* TNS will only be used if the LPC gain is within these margins */
+#define TNS_GAIN_THRESHOLD_LOW 1.395f
+#define TNS_GAIN_THRESHOLD_HIGH 11.19f
+
+/* Do not use TNS if the psy band spread is below this value */
+#define TNS_SPREAD_THRESHOLD 20.081512f
+
+/* Allows to reverse the filter direction if the band energy is uneven */
+#define TNS_DIRECTION_VARY 1
void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce);
-void ff_aac_apply_tns(SingleChannelElement *sce);
+void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce);
void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce);
#endif /* AVCODEC_AACENC_TNS_H */