Merge commit 'a1a143adb0fd11c474221431417cff25db7d920f'
[ffmpeg.git] / libavcodec / aacenc_tns.c
index 3b6e835..2ffe1f8 100644 (file)
  * @author Rostislav Pehlivanov ( atomnuker gmail com )
  */
 
-#include <strings.h>
+#include "libavutil/libm.h"
 #include "aacenc.h"
 #include "aacenc_tns.h"
 #include "aactab.h"
 #include "aacenc_utils.h"
 #include "aacenc_quantization.h"
 
-static inline void conv_to_int32(int32_t *loc, float *samples, int num, float norm)
-{
-    int i;
-    for (i = 0; i < num; i++)
-        loc[i] = ceilf((samples[i]/norm)*INT32_MAX);
-}
+/* Could be set to 3 to save an additional bit at the cost of little quality */
+#define TNS_Q_BITS 4
 
-static inline void conv_to_float(float *arr, int32_t *cof, int num)
-{
-    int i;
-    for (i = 0; i < num; i++)
-        arr[i] = (float)cof[i]/INT32_MAX;
-}
+/* Coefficient resolution in short windows */
+#define TNS_Q_BITS_IS8 4
 
-/* Input: quantized 4 bit coef, output: 1 if first (MSB) 2 bits are the same */
-static inline int coef_test_compression(int coef)
-{
-    int tmp = coef >> 2;
-    int res = ff_ctz(tmp);
-    if (res > 1)
-        return 1;       /* ...00 ->  compressable    */
-    else if (res == 1)
-        return 0;       /* ...10 ->  uncompressable  */
-    else if (ff_ctz(tmp >> 1) > 0)
-        return 0;       /* ...0 1 -> uncompressable  */
-    else
-        return 1;       /* ...1 1 -> compressable    */
-}
+/* 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_coef(int *coefs, int num)
+static inline int compress_coeffs(int *coef, int order, int c_bits)
 {
-    int i, res = 0;
-    for (i = 0; i < num; i++)
-        res += coef_test_compression(coefs[i]);
-    return res == num ? 1 : 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)
+            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.
+ * Coefficient compression is simply not lossless as it should be
+ * on any decoder tested and as such is not active.
  */
-void encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
+void ff_aac_encode_tns_info(AACEncContext *s, SingleChannelElement *sce)
 {
-    int i, w, filt, coef_len, coef_compress;
-    const int coef_res = MAX_LPC_PRECISION == 4 ? 1 : 0;
+    TemporalNoiseShaping *tns = &sce->tns;
+    int i, w, filt, coef_compress = 0, coef_len;
     const int is8 = sce->ics.window_sequence[0] == EIGHT_SHORT_SEQUENCE;
-
-    put_bits(&s->pb, 1, !!sce->tns.present);
+    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 (sce->tns.n_filt[i]) {
-            put_bits(&s->pb, 1, !!coef_res);
-            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]);
-                    put_bits(&s->pb, 1, !!coef_compress);
-                    coef_len = coef_res + 3 - 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]);
-                }
-            }
+        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 int process_tns_coeffs(TemporalNoiseShaping *tns, float *tns_coefs_raw,
-                              int order, int w, int filt)
+/* Apply TNS filter */
+void ff_aac_apply_tns(AACEncContext *s, SingleChannelElement *sce)
 {
-    int i, j;
-    int *idx = tns->coef_idx[w][filt];
-    float *lpc = tns->coef[w][filt];
-    const int iqfac_p = ((1 << (MAX_LPC_PRECISION-1)) - 0.5)/(M_PI/2.0);
-    const int iqfac_m = ((1 << (MAX_LPC_PRECISION-1)) + 0.5)/(M_PI/2.0);
-    float temp[TNS_MAX_ORDER] = {0.0f}, out[TNS_MAX_ORDER] = {0.0f};
-
-    /* Quantization */
-    for (i = 0; i < order; i++) {
-        idx[i] = ceilf(asin(tns_coefs_raw[i])*((tns_coefs_raw[i] >= 0) ? iqfac_p : iqfac_m));
-        lpc[i] = 2*sin(idx[i]/((idx[i] >= 0) ? iqfac_p : iqfac_m));
-    }
-
-    /* Trim any coeff less than 0.1f from the end */
-    for (i = order; i > -1; i--) {
-        lpc[i] = (fabs(lpc[i]) > 0.1f) ? lpc[i] : 0.0f;
-        if (lpc[i] != 0.0 ) {
-            order = i;
-            break;
-        }
-    }
-
-    if (!order)
-        return 0;
+    TemporalNoiseShaping *tns = &sce->tns;
+    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 < 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];
+            if (order == 0)
+                continue;
+
+            // 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]) {
+                inc = -1;
+                start = end - 1;
+            } else {
+                inc = 1;
+            }
+            start += w * 128;
 
-    /* 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];
+            /* 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];
+                }
+            }
         }
-        out[i] = lpc[i-1];
     }
-    memcpy(lpc, out, TNS_MAX_ORDER*sizeof(float));
-
-    return order;
 }
 
-static void apply_tns_filter(float *out, float *in, int order, int direction,
-                             float *tns_coefs, int ltp_used, int w, int filt, int start_i, int len)
+/*
+ * 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, j, inc, start = start_i;
-    float tmp[TNS_MAX_ORDER+1];
-    if (direction) {
-        inc = -1;
-        start = (start + len) - 1;
-    } else {
-        inc = 1;
-    }
-    if (!ltp_used) {    /* AR filter */
-        for (i = 0; i < len; i++, start += inc)
-            out[i] = in[start];
-            for (j = 1; j <= FFMIN(i, order); j++)
-                out[i] += tns_coefs[j]*in[start - j*inc];
-    } else {            /* MA filter */
-        for (i = 0; i < len; i++, start += inc) {
-            tmp[0] = out[i] = in[start];
-            for (j = 1; j <= FFMIN(i, order); j++)
-                out[i] += tmp[j]*tns_coefs[j];
-            for (j = order; j > 0; j--)
-                tmp[j] = tmp[j - 1];
-        }
+    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]];
     }
 }
 
-void search_for_tns(AACEncContext *s, SingleChannelElement *sce)
+/*
+ * 3 bits per coefficient with 8 short windows
+ */
+void ff_aac_search_for_tns(AACEncContext *s, SingleChannelElement *sce)
 {
     TemporalNoiseShaping *tns = &sce->tns;
-    int w, g, order, sfb_start, sfb_len, coef_start, shift[MAX_LPC_ORDER], 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 tns_max_order = is8 ? 7 : s->profile == FF_PROFILE_AAC_LOW ? 12 : TNS_MAX_ORDER;
-    const float freq_mult = mpeg4audio_sample_rates[s->samplerate_index]/(1024.0f/sce->ics.num_windows)/2.0f;
-    float max_coef = 0.0f;
-
-    for (coef_start = 0; coef_start < 1024; coef_start++)
-        max_coef = FFMAX(max_coef, sce->pcoeffs[coef_start]);
+    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 filters = 1, start = 0, coef_len = 0;
-        int32_t conv_coeff[1024] = {0};
-        int32_t coefs_t[MAX_LPC_ORDER][MAX_LPC_ORDER] = {{0}};
-
-        /* Determine start sfb + coef - excludes anything below threshold */
-        for (g = 0;  g < sce->ics.num_swb; g++) {
-            if (start*freq_mult > TNS_LOW_LIMIT) {
-                sfb_start = w*16+g;
-                sfb_len   = (w+1)*16 + g - sfb_start;
-                coef_start = sce->ics.swb_offset[sfb_start];
-                coef_len  = sce->ics.swb_offset[sfb_start + sfb_len] - coef_start;
-                break;
-            }
-            start += sce->ics.swb_sizes[g];
+        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)
-            continue;
+        /* LPC */
+        gain = ff_lpc_calc_ref_coefs_f(&s->lpc, &sce->coeffs[w*128 + coef_start],
+                                       coef_len, order, coefs);
 
-        conv_to_int32(conv_coeff, &sce->pcoeffs[coef_start], coef_len, max_coef);
+        if (!order || !isfinite(gain) || gain < TNS_GAIN_THRESHOLD_LOW || gain > TNS_GAIN_THRESHOLD_HIGH)
+            continue;
 
-        /* LPC */
-        order = ff_lpc_calc_coefs(&s->lpc, conv_coeff, coef_len,
-                                  TNS_MIN_PRED_ORDER, tns_max_order,
-                                  32, coefs_t, shift,
-                                  FF_LPC_TYPE_LEVINSON, 10,
-                                  ORDER_METHOD_EST, MAX_LPC_SHIFT, 0) - 1;
-
-        /* Works surprisingly well, remember to tweak MAX_LPC_SHIFT if you want to play around with this */
-        if (shift[order] > 3) {
-            int direction = 0;
-            float tns_coefs_raw[TNS_MAX_ORDER];
-            tns->n_filt[w] = filters++;
-            conv_to_float(tns_coefs_raw, coefs_t[order], order);
-            for (g = 0; g < tns->n_filt[w]; g++) {
-                process_tns_coeffs(tns, tns_coefs_raw, order, w, g);
-                apply_tns_filter(&sce->coeffs[coef_start], sce->pcoeffs, order, direction, tns->coef[w][g],
-                                 sce->ics.ltp.present, w, g, coef_start, coef_len);
-                tns->order[w][g]     = order;
-                tns->length[w][g]    = sfb_len;
-                tns->direction[w][g] = direction;
-            }
-            count++;
+        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;
 }