Merge commit 'a1a143adb0fd11c474221431417cff25db7d920f'
[ffmpeg.git] / libavcodec / aacenc_tns.c
index 815b4e3..2ffe1f8 100644 (file)
  * @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"
 
-/*
- * Shifts the values as well if compression is possible.
- */
+/* 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, res = 0;
+    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)
-            res++;
-    if (res == order)
-        for (i = 0; i < order; i++)
-            coef[i] -= (coef[i] > high_idx) ? shift_val : 0;
-    return res == order;
+        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)
 {
-    int i, w, filt, coef_len, coef_compress = 0;
-    const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
     TemporalNoiseShaping *tns = &sce->tns;
-    const int c_bits = is8 ? TNS_Q_BITS_SHORT == 4 : TNS_Q_BITS == 4;
+    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, 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]) {
-                    coef_compress = compress_coeffs(tns->coef_idx[i][filt],
-                                                    tns->order[i][filt], c_bits);
-                    put_bits(&s->pb, 1, !!tns->direction[i][filt]);
-                    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]);
-                }
-            }
+        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]);
         }
     }
 }
@@ -117,10 +131,12 @@ void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)
             }
             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];
+                }
+            }
         }
     }
 }
@@ -134,7 +150,7 @@ static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
     int i;
     const float *quant_arr = tns_tmp2_map[c_bits];
     for (i = 0; i < order; i++) {
-        idx[i] = quant_array_idx((float)coef[i], quant_arr, c_bits ? 16 : 8);
+        idx[i] = quant_array_idx(coef[i], quant_arr, c_bits ? 16 : 8);
         lpc[i] = quant_arr[idx[i]];
     }
 }
@@ -145,75 +161,55 @@ static inline void quantize_coefs(double *coef, int *idx, float *lpc, int order,
 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_SHORT == 4 : TNS_Q_BITS == 4;
-
-    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);
+    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];
+
+    if (coef_len <= 0 || sfb_len <= 0) {
+        sce->tns.present = 0;
+        return;
+    }
 
     for (w = 0; w < sce->ics.num_windows; w++) {
-        int use_tns;
-        int order = is8 ? 5 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
-        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 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};
-
-        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;
-            }
+        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 = 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;
-
         /* 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 (!order || gain < TNS_GAIN_THRESHOLD_LOW || gain > TNS_GAIN_THRESHOLD_HIGH)
-            use_tns = 0;
-        else if ((en[0]+en[1]) < TNS_GAIN_THRESHOLD_LOW*threshold || spread < TNS_SPREAD_THRESHOLD)
-            use_tns = 0;
-        else
-            use_tns = 1;
-
-        if (use_tns) {
-            e_ratio = en[0]/en[1];
-            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, c_bits);
-                }
-            } 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], c_bits);
-                }
-            }
-            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;
 }