Merge remote-tracking branch 'qatar/master'

* qatar/master:
  aacenc: Fix LONG_START windowing.
  aacenc: Fix a bug where deinterleaved samples were stored in the wrong place.
  avplay: use the correct array size for stride.
  lavc: extend doxy for avcodec_alloc_context3().
  APIchanges: mention avcodec_alloc_context()/2/3
  avcodec_align_dimensions2: set only 4 linesizes, not AV_NUM_DATA_POINTERS.
  aacsbr: ARM NEON optimised sbrdsp functions
  aacsbr: align some arrays
  aacsbr: move some simdable loops to function pointers
  cosmetics: Remove extra newlines at EOF

Conflicts:
	libavcodec/utils.c
	libavfilter/formats.c
	libavutil/mem.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>

1 files changed, 51 insertions, 136 deletions

diff --git a/libavcodec/aacsbr.c b/libavcodec/aacsbr.c
index 2f457b61cc..71bd2ceda5 100644
--- a/libavcodec/aacsbr.c
+++ b/libavcodec/aacsbr.c
@@ -32,6 +32,7 @@
 #include "aacsbrdata.h"
 #include "fft.h"
 #include "aacps.h"
+#include "sbrdsp.h"
 #include "libavutil/libm.h"
 #include "libavutil/avassert.h"
 
@@ -144,6 +145,7 @@ av_cold void ff_aac_sbr_ctx_init(AACContext *ac, SpectralBandReplication *sbr)
     ff_mdct_init(&sbr->mdct,     7, 1, 1.0 / (64 * mdct_scale));
     ff_mdct_init(&sbr->mdct_ana, 7, 1, -2.0 * mdct_scale);
     ff_ps_ctx_init(&sbr->ps);
+    ff_sbrdsp_init(&sbr->dsp);
 }
 
 av_cold void ff_aac_sbr_ctx_close(SpectralBandReplication *sbr)
@@ -1143,33 +1145,21 @@ static void sbr_dequant(SpectralBandReplication *sbr, int id_aac)
  * @param   x       pointer to the beginning of the first sample window
  * @param   W       array of complex-valued samples split into subbands
  */
-static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in, float *x,
+static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct,
+                             SBRDSPContext *sbrdsp, const float *in, float *x,
                              float z[320], float W[2][32][32][2])
 {
-    int i, k;
+    int i;
     memcpy(W[0], W[1], sizeof(W[0]));
     memcpy(x    , x+1024, (320-32)*sizeof(x[0]));
     memcpy(x+288, in,         1024*sizeof(x[0]));
     for (i = 0; i < 32; i++) { // numTimeSlots*RATE = 16*2 as 960 sample frames
                                // are not supported
         dsp->vector_fmul_reverse(z, sbr_qmf_window_ds, x, 320);
-        for (k = 0; k < 64; k++) {
-            float f = z[k] + z[k + 64] + z[k + 128] + z[k + 192] + z[k + 256];
-            z[k] = f;
-        }
-        //Shuffle to IMDCT
-        z[64] = z[0];
-        for (k = 1; k < 32; k++) {
-            z[64+2*k-1] =  z[   k];
-            z[64+2*k  ] = -z[64-k];
-        }
-        z[64+63] = z[32];
-
+        sbrdsp->sum64x5(z);
+        sbrdsp->qmf_pre_shuffle(z);
         mdct->imdct_half(mdct, z, z+64);
-        for (k = 0; k < 32; k++) {
-            W[1][i][k][0] = -z[63-k];
-            W[1][i][k][1] = z[k];
-        }
+        sbrdsp->qmf_post_shuffle(W[1][i], z);
         x += 32;
     }
 }
@@ -1179,6 +1169,7 @@ static void sbr_qmf_analysis(DSPContext *dsp, FFTContext *mdct, const float *in,
  * (14496-3 sp04 p206)
  */
 static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
+                              SBRDSPContext *sbrdsp,
                               float *out, float X[2][38][64],
                               float mdct_buf[2][64],
                               float *v0, int *v_off, const unsigned int div)
@@ -1202,20 +1193,12 @@ static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
                 X[0][i][32+n] =  X[1][i][31-n];
             }
             mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
-            for (n = 0; n < 32; n++) {
-                v[     n] =  mdct_buf[0][63 - 2*n];
-                v[63 - n] = -mdct_buf[0][62 - 2*n];
-            }
+            sbrdsp->qmf_deint_neg(v, mdct_buf[0]);
         } else {
-            for (n = 1; n < 64; n+=2) {
-                X[1][i][n] = -X[1][i][n];
-            }
+            sbrdsp->neg_odd_64(X[1][i]);
             mdct->imdct_half(mdct, mdct_buf[0], X[0][i]);
             mdct->imdct_half(mdct, mdct_buf[1], X[1][i]);
-            for (n = 0; n < 64; n++) {
-                v[      n] = -mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
-                v[127 - n] =  mdct_buf[0][63 -   n] + mdct_buf[1][  n    ];
-            }
+            sbrdsp->qmf_deint_bfly(v, mdct_buf[1], mdct_buf[0]);
         }
         dsp->vector_fmul_add(out, v                , sbr_qmf_window               , zero64, 64 >> div);
         dsp->vector_fmul_add(out, v + ( 192 >> div), sbr_qmf_window + ( 64 >> div), out   , 64 >> div);
@@ -1231,45 +1214,20 @@ static void sbr_qmf_synthesis(DSPContext *dsp, FFTContext *mdct,
     }
 }
 
-static void autocorrelate(const float x[40][2], float phi[3][2][2], int lag)
-{
-    int i;
-    float real_sum = 0.0f;
-    float imag_sum = 0.0f;
-    if (lag) {
-        for (i = 1; i < 38; i++) {
-            real_sum += x[i][0] * x[i+lag][0] + x[i][1] * x[i+lag][1];
-            imag_sum += x[i][0] * x[i+lag][1] - x[i][1] * x[i+lag][0];
-        }
-        phi[2-lag][1][0] = real_sum + x[ 0][0] * x[lag][0] + x[ 0][1] * x[lag][1];
-        phi[2-lag][1][1] = imag_sum + x[ 0][0] * x[lag][1] - x[ 0][1] * x[lag][0];
-        if (lag == 1) {
-            phi[0][0][0] = real_sum + x[38][0] * x[39][0] + x[38][1] * x[39][1];
-            phi[0][0][1] = imag_sum + x[38][0] * x[39][1] - x[38][1] * x[39][0];
-        }
-    } else {
-        for (i = 1; i < 38; i++) {
-            real_sum += x[i][0] * x[i][0] + x[i][1] * x[i][1];
-        }
-        phi[2][1][0] = real_sum + x[ 0][0] * x[ 0][0] + x[ 0][1] * x[ 0][1];
-        phi[1][0][0] = real_sum + x[38][0] * x[38][0] + x[38][1] * x[38][1];
-    }
-}
-
 /** High Frequency Generation (14496-3 sp04 p214+) and Inverse Filtering
  * (14496-3 sp04 p214)
  * Warning: This routine does not seem numerically stable.
  */
-static void sbr_hf_inverse_filter(float (*alpha0)[2], float (*alpha1)[2],
+static void sbr_hf_inverse_filter(SBRDSPContext *dsp,
+                                  float (*alpha0)[2], float (*alpha1)[2],
                                   const float X_low[32][40][2], int k0)
 {
     int k;
     for (k = 0; k < k0; k++) {
-        float phi[3][2][2], dk;
+        LOCAL_ALIGNED_16(float, phi, [3], [2][2]);
+        float dk;
 
-        autocorrelate(X_low[k], phi, 0);
-        autocorrelate(X_low[k], phi, 1);
-        autocorrelate(X_low[k], phi, 2);
+        dsp->autocorrelate(X_low[k], phi);
 
         dk =  phi[2][1][0] * phi[1][0][0] -
              (phi[1][1][0] * phi[1][1][0] + phi[1][1][1] * phi[1][1][1]) / 1.000001f;
@@ -1365,12 +1323,11 @@ static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
                       const float bw_array[5], const uint8_t *t_env,
                       int bs_num_env)
 {
-    int i, j, x;
+    int j, x;
     int g = 0;
     int k = sbr->kx[1];
     for (j = 0; j < sbr->num_patches; j++) {
         for (x = 0; x < sbr->patch_num_subbands[j]; x++, k++) {
-            float alpha[4];
             const int p = sbr->patch_start_subband[j] + x;
             while (g <= sbr->n_q && k >= sbr->f_tablenoise[g])
                 g++;
@@ -1382,26 +1339,10 @@ static int sbr_hf_gen(AACContext *ac, SpectralBandReplication *sbr,
                 return -1;
             }
 
-            alpha[0] = alpha1[p][0] * bw_array[g] * bw_array[g];
-            alpha[1] = alpha1[p][1] * bw_array[g] * bw_array[g];
-            alpha[2] = alpha0[p][0] * bw_array[g];
-            alpha[3] = alpha0[p][1] * bw_array[g];
-
-            for (i = 2 * t_env[0]; i < 2 * t_env[bs_num_env]; i++) {
-                const int idx = i + ENVELOPE_ADJUSTMENT_OFFSET;
-                X_high[k][idx][0] =
-                    X_low[p][idx - 2][0] * alpha[0] -
-                    X_low[p][idx - 2][1] * alpha[1] +
-                    X_low[p][idx - 1][0] * alpha[2] -
-                    X_low[p][idx - 1][1] * alpha[3] +
-                    X_low[p][idx][0];
-                X_high[k][idx][1] =
-                    X_low[p][idx - 2][1] * alpha[0] +
-                    X_low[p][idx - 2][0] * alpha[1] +
-                    X_low[p][idx - 1][1] * alpha[2] +
-                    X_low[p][idx - 1][0] * alpha[3] +
-                    X_low[p][idx][1];
-            }
+            sbr->dsp.hf_gen(X_high[k] + ENVELOPE_ADJUSTMENT_OFFSET,
+                            X_low[p]  + ENVELOPE_ADJUSTMENT_OFFSET,
+                            alpha0[p], alpha1[p], bw_array[g],
+                            2 * t_env[0], 2 * t_env[bs_num_env]);
         }
     }
     if (k < sbr->m[1] + sbr->kx[1])
@@ -1502,7 +1443,8 @@ static void sbr_mapping(AACContext *ac, SpectralBandReplication *sbr,
 static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
                              SpectralBandReplication *sbr, SBRData *ch_data)
 {
-    int e, i, m;
+    int e, m;
+    int kx1 = sbr->kx[1];
 
     if (sbr->bs_interpol_freq) {
         for (e = 0; e < ch_data->bs_num_env; e++) {
@@ -1511,12 +1453,7 @@ static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
             int iub = ch_data->t_env[e + 1] * 2 + ENVELOPE_ADJUSTMENT_OFFSET;
 
             for (m = 0; m < sbr->m[1]; m++) {
-                float sum = 0.0f;
-
-                for (i = ilb; i < iub; i++) {
-                    sum += X_high[m + sbr->kx[1]][i][0] * X_high[m + sbr->kx[1]][i][0] +
-                           X_high[m + sbr->kx[1]][i][1] * X_high[m + sbr->kx[1]][i][1];
-                }
+                float sum = sbr->dsp.sum_square(X_high[m+kx1] + ilb, iub - ilb);
                 e_curr[e][m] = sum * recip_env_size;
             }
         }
@@ -1534,14 +1471,11 @@ static void sbr_env_estimate(float (*e_curr)[48], float X_high[64][40][2],
                 const int den = env_size * (table[p + 1] - table[p]);
 
                 for (k = table[p]; k < table[p + 1]; k++) {
-                    for (i = ilb; i < iub; i++) {
-                        sum += X_high[k][i][0] * X_high[k][i][0] +
-                               X_high[k][i][1] * X_high[k][i][1];
-                    }
+                    sum += sbr->dsp.sum_square(X_high[k] + ilb, iub - ilb);
                 }
                 sum /= den;
                 for (k = table[p]; k < table[p + 1]; k++) {
-                    e_curr[e][k - sbr->kx[1]] = sum;
+                    e_curr[e][k - kx1] = sum;
                 }
             }
         }
@@ -1652,55 +1586,35 @@ static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2]
     for (e = 0; e < ch_data->bs_num_env; e++) {
         for (i = 2 * ch_data->t_env[e]; i < 2 * ch_data->t_env[e + 1]; i++) {
             int phi_sign = (1 - 2*(kx & 1));
+            LOCAL_ALIGNED_16(float, g_filt_tab, [48]);
+            LOCAL_ALIGNED_16(float, q_filt_tab, [48]);
+            float *g_filt, *q_filt;
 
             if (h_SL && e != e_a[0] && e != e_a[1]) {
+                g_filt = g_filt_tab;
+                q_filt = q_filt_tab;
                 for (m = 0; m < m_max; m++) {
                     const int idx1 = i + h_SL;
-                    float g_filt = 0.0f;
-                    for (j = 0; j <= h_SL; j++)
-                        g_filt += g_temp[idx1 - j][m] * h_smooth[j];
-                    Y[1][i][m + kx][0] =
-                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
-                    Y[1][i][m + kx][1] =
-                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
+                    g_filt[m] = 0.0f;
+                    q_filt[m] = 0.0f;
+                    for (j = 0; j <= h_SL; j++) {
+                        g_filt[m] += g_temp[idx1 - j][m] * h_smooth[j];
+                        q_filt[m] += q_temp[idx1 - j][m] * h_smooth[j];
+                    }
                 }
             } else {
-                for (m = 0; m < m_max; m++) {
-                    const float g_filt = g_temp[i + h_SL][m];
-                    Y[1][i][m + kx][0] =
-                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][0] * g_filt;
-                    Y[1][i][m + kx][1] =
-                        X_high[m + kx][i + ENVELOPE_ADJUSTMENT_OFFSET][1] * g_filt;
-                }
+                g_filt = g_temp[i + h_SL];
+                q_filt = q_temp[i];
             }
 
+            sbr->dsp.hf_g_filt(Y[1][i] + kx, X_high + kx, g_filt, m_max,
+                               i + ENVELOPE_ADJUSTMENT_OFFSET);
+
             if (e != e_a[0] && e != e_a[1]) {
-                for (m = 0; m < m_max; m++) {
-                    indexnoise = (indexnoise + 1) & 0x1ff;
-                    if (sbr->s_m[e][m]) {
-                        Y[1][i][m + kx][0] +=
-                            sbr->s_m[e][m] * phi[0][indexsine];
-                        Y[1][i][m + kx][1] +=
-                            sbr->s_m[e][m] * (phi[1][indexsine] * phi_sign);
-                    } else {
-                        float q_filt;
-                        if (h_SL) {
-                            const int idx1 = i + h_SL;
-                            q_filt = 0.0f;
-                            for (j = 0; j <= h_SL; j++)
-                                q_filt += q_temp[idx1 - j][m] * h_smooth[j];
-                        } else {
-                            q_filt = q_temp[i][m];
-                        }
-                        Y[1][i][m + kx][0] +=
-                            q_filt * sbr_noise_table[indexnoise][0];
-                        Y[1][i][m + kx][1] +=
-                            q_filt * sbr_noise_table[indexnoise][1];
-                    }
-                    phi_sign = -phi_sign;
-                }
+                sbr->dsp.hf_apply_noise[indexsine](Y[1][i] + kx, sbr->s_m[e],
+                                                   q_filt, indexnoise,
+                                                   kx, m_max);
             } else {
-                indexnoise = (indexnoise + m_max) & 0x1ff;
                 for (m = 0; m < m_max; m++) {
                     Y[1][i][m + kx][0] +=
                         sbr->s_m[e][m] * phi[0][indexsine];
@@ -1709,6 +1623,7 @@ static void sbr_hf_assemble(float Y[2][38][64][2], const float X_high[64][40][2]
                     phi_sign = -phi_sign;
                 }
             }
+            indexnoise = (indexnoise + m_max) & 0x1ff;
             indexsine = (indexsine + 1) & 3;
         }
     }
@@ -1728,12 +1643,12 @@ void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
     }
     for (ch = 0; ch < nch; ch++) {
         /* decode channel */
-        sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
+        sbr_qmf_analysis(&ac->dsp, &sbr->mdct_ana, &sbr->dsp, ch ? R : L, sbr->data[ch].analysis_filterbank_samples,
                          (float*)sbr->qmf_filter_scratch,
                          sbr->data[ch].W);
         sbr_lf_gen(ac, sbr, sbr->X_low, sbr->data[ch].W);
         if (sbr->start) {
-            sbr_hf_inverse_filter(sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
+            sbr_hf_inverse_filter(&sbr->dsp, sbr->alpha0, sbr->alpha1, sbr->X_low, sbr->k[0]);
             sbr_chirp(sbr, &sbr->data[ch]);
             sbr_hf_gen(ac, sbr, sbr->X_high, sbr->X_low, sbr->alpha0, sbr->alpha1,
                        sbr->data[ch].bw_array, sbr->data[ch].t_env,
@@ -1760,12 +1675,12 @@ void ff_sbr_apply(AACContext *ac, SpectralBandReplication *sbr, int id_aac,
         nch = 2;
     }
 
-    sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, L, sbr->X[0], sbr->qmf_filter_scratch,
+    sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, L, sbr->X[0], sbr->qmf_filter_scratch,
                       sbr->data[0].synthesis_filterbank_samples,
                       &sbr->data[0].synthesis_filterbank_samples_offset,
                       downsampled);
     if (nch == 2)
-        sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, R, sbr->X[1], sbr->qmf_filter_scratch,
+        sbr_qmf_synthesis(&ac->dsp, &sbr->mdct, &sbr->dsp, R, sbr->X[1], sbr->qmf_filter_scratch,
                           sbr->data[1].synthesis_filterbank_samples,
                           &sbr->data[1].synthesis_filterbank_samples_offset,
                           downsampled);