ood-ports-lbsd/graphics/ffmpeg/patches/patch-libavcodec_aacenc_tns_c

$OpenBSD: patch-libavcodec_aacenc_tns_c,v 1.7 2016/01/22 07:05:01 ajacoutot Exp $

aacenc_tns: redo coefficient quantization and decision making

aacenc_tns: encode coefficients directly and reenable compression

aacenc_tns: fix coefficient compression condition

aacenc_tns: add moving average filter for LTP

aacenc_tns: disable coefficient compression by default

aacenc_tns: simplify encoding function

aacenc_tns: rework TNS descision logic

aacenc_ltp: use an AR filter for LTP encoding as well

aacenc_tns: tune and reduce artifacts

aacenc_tns: use 4 bits for short windows

AAC encoder: TNS fixes on short windows

libavcodec/aacenc_tnc.c: remove unused variable w2

AAC encoder: check for NaNs/inf in TNS gain

--- libavcodec/aacenc_tns.c.orig	Wed Jan 13 15:27:48 2016
+++ libavcodec/aacenc_tns.c	Thu Jan 21 05:58:54 2016
@@ -25,62 +25,79 @@
  * @author Rostislav Pehlivanov ( atomnuker gmail com )
  */
 
+#include "libavutil/libm.h"
 #include "aacenc.h"
 #include "aacenc_tns.h"
 #include "aactab.h"
 #include "aacenc_utils.h"
 #include "aacenc_quantization.h"
 
+/* Could be set to 3 to save an additional bit at the cost of little quality */
+#define TNS_Q_BITS 4
+
+/* Coefficient resolution in short windows */
+#define TNS_Q_BITS_IS8 4
+
+/* We really need the bits we save here elsewhere */
+#define TNS_ENABLE_COEF_COMPRESSION
+
+/* TNS will only be used if the LPC gain is within these margins */
+#define TNS_GAIN_THRESHOLD_LOW      1.4f
+#define TNS_GAIN_THRESHOLD_HIGH     1.16f*TNS_GAIN_THRESHOLD_LOW
+
+static inline int compress_coeffs(int *coef, int order, int c_bits)
+{
+    int i;
+    const int low_idx   = c_bits ?  4 : 2;
+    const int shift_val = c_bits ?  8 : 4;
+    const int high_idx  = c_bits ? 11 : 5;
+#ifndef TNS_ENABLE_COEF_COMPRESSION
+    return 0;
+#endif /* TNS_ENABLE_COEF_COMPRESSION */
+    for (i = 0; i < order; i++)
+        if (coef[i] >= low_idx && coef[i] <= high_idx)
+            return 0;
+    for (i = 0; i < order; i++)
+        coef[i] -= (coef[i] > high_idx) ? shift_val : 0;
+    return 1;
+}
+
 /**
  * Encode TNS data.
- * Coefficient compression saves a single bit per coefficient.
+ * Coefficient compression is simply not lossless as it should be
+ * on any decoder tested and as such is not active.
  */
 void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
 {
-    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;
+    int i, w, filt, coef_compress = 0, coef_len;
+    const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
+    const int c_bits = is8 ? TNS_Q_BITS_IS8 == 4 : TNS_Q_BITS == 4;
 
     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 (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 = 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);
-                    }
-                }
-            }
+        if (!tns->n_filt[i])
+            continue;
+        put_bits(&s->pb, 1, c_bits);
+        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])
+                continue;
+            put_bits(&s->pb, 1, tns->direction[i][filt]);
+            coef_compress = compress_coeffs(tns->coef_idx[i][filt],
+                                            tns->order[i][filt], c_bits);
+            put_bits(&s->pb, 1, coef_compress);
+            coef_len = c_bits + 3 - coef_compress;
+            for (w = 0; w < tns->order[i][filt]; w++)
+                put_bits(&s->pb, coef_len, tns->coef_idx[i][filt][w]);
         }
     }
 }
 
-static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order)
-{
-    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] = 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];
-    }
-}
-
 /* Apply TNS filter */
 void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)
 {
@@ -114,81 +131,85 @@ void ff_aac_apply_tns(AACEncContext *s, SingleChannelE
             }
             start += w * 128;
 
-            // ar filter
-            for (m = 0; m < size; m++, start += inc)
-                for (i = 1; i <= FFMIN(m, order); i++)
+            /* 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];
+                }
+            }
         }
     }
 }
 
+/*
+ * c_bits - 1 if 4 bit coefficients, 0 if 3 bit coefficients
+ */
+static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
+                                  int c_bits)
+{
+    int i;
+    const float *quant_arr = tns_tmp2_map[c_bits];
+    for (i = 0; i < order; i++) {
+        idx[i] = quant_array_idx(coef[i], quant_arr, c_bits ? 16 : 8);
+        lpc[i] = quant_arr[idx[i]];
+    }
+}
+
+/*
+ * 3 bits per coefficient with 8 short windows
+ */
 void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)
 {
     TemporalNoiseShaping *tns = &sce->tns;
-    int w, w2, g, count = 0;
+    int w, g, count = 0;
+    double gain, coefs[MAX_LPC_ORDER];
     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 c_bits = is8 ? TNS_Q_BITS_IS8 == 4 : TNS_Q_BITS == 4;
+    const int sfb_start = av_clip(tns_min_sfb[is8][s->samplerate_index], 0, mmm);
+    const int sfb_end   = av_clip(sce->ics.num_swb, 0, mmm);
     const int order = is8 ? 7 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
+    const int slant = sce->ics.window_sequence[0] == LONG_STOP_SEQUENCE  ? 1 :
+                      sce->ics.window_sequence[0] == LONG_START_SEQUENCE ? 0 : 2;
+    const int sfb_len = sfb_end - sfb_start;
+    const int coef_len = sce->ics.swb_offset[sfb_end] - sce->ics.swb_offset[sfb_start];
 
-    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);
+    if (coef_len <= 0 || sfb_len <= 0) {
+        sce->tns.present = 0;
+        return;
+    }
 
     for (w = 0; w < sce->ics.num_windows; w++) {
-        float e_ratio = 0.0f, threshold = 0.0f, spread = 0.0f, en[2] = {0.0, 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];
+        float en[2] = {0.0f, 0.0f};
+        int oc_start = 0, os_start = 0;
+        int coef_start = sce->ics.swb_offset[sfb_start];
 
-        for (g = 0;  g < sce->ics.num_swb; g++) {
-            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[1] += band->energy;
-                else
-                    en[0] += band->energy;
-                threshold += band->threshold;
-                spread += band->spread;
-            }
+        for (g = sfb_start; g < sce->ics.num_swb && g <= sfb_end; g++) {
+            FFPsyBand *band = &s->psy.ch[s->cur_channel].psy_bands[w*16+g];
+            if (g > sfb_start + (sfb_len/2))
+                en[1] += band->energy;
+            else
+                en[0] += band->energy;
         }
 
-        if (coef_len <= 0 || (sfb_end - sfb_start) <= 0)
-            continue;
-        else
-            e_ratio = en[0]/en[1];
-
         /* LPC */
-        gain = ff_lpc_calc_ref_coefs_f(&s->lpc, &sce->coeffs[coef_start],
+        gain = ff_lpc_calc_ref_coefs_f(&s->lpc, &sce->coeffs[w*128 + coef_start],
                                        coef_len, order, coefs);
 
-        if (gain > TNS_GAIN_THRESHOLD_LOW && gain < TNS_GAIN_THRESHOLD_HIGH &&
-            (en[0]+en[1]) > TNS_GAIN_THRESHOLD_LOW*threshold &&
-            spread < TNS_SPREAD_THRESHOLD && order) {
-            if (is8 || order < 2 || (e_ratio > TNS_E_RATIO_LOW && e_ratio < TNS_E_RATIO_HIGH)) {
-                tns->n_filt[w] = 1;
-                for (g = 0; g < tns->n_filt[w]; g++) {
-                    tns->length[w][g] = sfb_end - sfb_start;
-                    tns->direction[w][g] = en[0] < en[1];
-                    tns->order[w][g] = order;
-                    quantize_coefs(coefs, tns->coef_idx[w][g], tns->coef[w][g],
-                                   order);
-                }
-            } else {  /* 2 filters due to energy disbalance */
-                tns->n_filt[w] = 2;
-                for (g = 0; g < tns->n_filt[w]; g++) {
-                    tns->direction[w][g] = en[g] < en[!g];
-                    tns->order[w][g] = !g ? order/2 : order - tns->order[w][g-1];
-                    tns->length[w][g] = !g ? (sfb_end - sfb_start)/2 : \
-                                    (sfb_end - sfb_start) - tns->length[w][g-1];
-                    quantize_coefs(&coefs[!g ? 0 : order - tns->order[w][g-1]],
-                                   tns->coef_idx[w][g], tns->coef[w][g],
-                                   tns->order[w][g]);
-                }
-            }
-            count++;
+        if (!order || !isfinite(gain) || gain < TNS_GAIN_THRESHOLD_LOW || gain > TNS_GAIN_THRESHOLD_HIGH)
+            continue;
+
+        tns->n_filt[w] = is8 ? 1 : order != TNS_MAX_ORDER ? 2 : 3;
+        for (g = 0; g < tns->n_filt[w]; g++) {
+            tns->direction[w][g] = slant != 2 ? slant : en[g] < en[!g];
+            tns->order[w][g] = g < tns->n_filt[w] ? order/tns->n_filt[w] : order - oc_start;
+            tns->length[w][g] = g < tns->n_filt[w] ? sfb_len/tns->n_filt[w] : sfb_len - os_start;
+            quantize_coefs(&coefs[oc_start], tns->coef_idx[w][g], tns->coef[w][g],
+                            tns->order[w][g], c_bits);
+            oc_start += tns->order[w][g];
+            os_start += tns->length[w][g];
         }
+        count++;
     }
-
     sce->tns.present = !!count;
 }