@scrypted/libav 1.0.170 → 1.0.171

package/opus/celt/arm/celt_mdct_ne10.c

@@ -1,258 +0,0 @@
-/* Copyright (c) 2015 Xiph.Org Foundation
-   Written by Viswanath Puttagunta */
-/**
-   @file celt_mdct_ne10.c
-   @brief ARM Neon optimizations for mdct using NE10 library
- */
-
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifndef SKIP_CONFIG_H
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#endif
-
-#include "kiss_fft.h"
-#include "_kiss_fft_guts.h"
-#include "mdct.h"
-#include "stack_alloc.h"
-
-void clt_mdct_forward_neon(const mdct_lookup *l,
-                           kiss_fft_scalar *in,
-                           kiss_fft_scalar * OPUS_RESTRICT out,
-                           const opus_val16 *window,
-                           int overlap, int shift, int stride, int arch)
-{
-   int i;
-   int N, N2, N4;
-   VARDECL(kiss_fft_scalar, f);
-   VARDECL(kiss_fft_cpx, f2);
-   const kiss_fft_state *st = l->kfft[shift];
-   const kiss_twiddle_scalar *trig;
-
-   SAVE_STACK;
-
-   N = l->n;
-   trig = l->trig;
-   for (i=0;i<shift;i++)
-   {
-      N >>= 1;
-      trig += N;
-   }
-   N2 = N>>1;
-   N4 = N>>2;
-
-   ALLOC(f, N2, kiss_fft_scalar);
-   ALLOC(f2, N4, kiss_fft_cpx);
-
-   /* Consider the input to be composed of four blocks: [a, b, c, d] */
-   /* Window, shuffle, fold */
-   {
-      /* Temp pointers to make it really clear to the compiler what we're doing */
-      const kiss_fft_scalar * OPUS_RESTRICT xp1 = in+(overlap>>1);
-      const kiss_fft_scalar * OPUS_RESTRICT xp2 = in+N2-1+(overlap>>1);
-      kiss_fft_scalar * OPUS_RESTRICT yp = f;
-      const opus_val16 * OPUS_RESTRICT wp1 = window+(overlap>>1);
-      const opus_val16 * OPUS_RESTRICT wp2 = window+(overlap>>1)-1;
-      for(i=0;i<((overlap+3)>>2);i++)
-      {
-         /* Real part arranged as -d-cR, Imag part arranged as -b+aR*/
-         *yp++ = MULT16_32_Q15(*wp2, xp1[N2]) + MULT16_32_Q15(*wp1,*xp2);
-         *yp++ = MULT16_32_Q15(*wp1, *xp1)    - MULT16_32_Q15(*wp2, xp2[-N2]);
-         xp1+=2;
-         xp2-=2;
-         wp1+=2;
-         wp2-=2;
-      }
-      wp1 = window;
-      wp2 = window+overlap-1;
-      for(;i<N4-((overlap+3)>>2);i++)
-      {
-         /* Real part arranged as a-bR, Imag part arranged as -c-dR */
-         *yp++ = *xp2;
-         *yp++ = *xp1;
-         xp1+=2;
-         xp2-=2;
-      }
-      for(;i<N4;i++)
-      {
-         /* Real part arranged as a-bR, Imag part arranged as -c-dR */
-         *yp++ =  -MULT16_32_Q15(*wp1, xp1[-N2]) + MULT16_32_Q15(*wp2, *xp2);
-         *yp++ = MULT16_32_Q15(*wp2, *xp1)     + MULT16_32_Q15(*wp1, xp2[N2]);
-         xp1+=2;
-         xp2-=2;
-         wp1+=2;
-         wp2-=2;
-      }
-   }
-   /* Pre-rotation */
-   {
-      kiss_fft_scalar * OPUS_RESTRICT yp = f;
-      const kiss_twiddle_scalar *t = &trig[0];
-      for(i=0;i<N4;i++)
-      {
-         kiss_fft_cpx yc;
-         kiss_twiddle_scalar t0, t1;
-         kiss_fft_scalar re, im, yr, yi;
-         t0 = t[i];
-         t1 = t[N4+i];
-         re = *yp++;
-         im = *yp++;
-         yr = S_MUL(re,t0)  -  S_MUL(im,t1);
-         yi = S_MUL(im,t0)  +  S_MUL(re,t1);
-         yc.r = yr;
-         yc.i = yi;
-         f2[i] = yc;
-      }
-   }
-
-   opus_fft(st, f2, (kiss_fft_cpx *)f, arch);
-
-   /* Post-rotate */
-   {
-      /* Temp pointers to make it really clear to the compiler what we're doing */
-      const kiss_fft_cpx * OPUS_RESTRICT fp = (kiss_fft_cpx *)f;
-      kiss_fft_scalar * OPUS_RESTRICT yp1 = out;
-      kiss_fft_scalar * OPUS_RESTRICT yp2 = out+stride*(N2-1);
-      const kiss_twiddle_scalar *t = &trig[0];
-      /* Temp pointers to make it really clear to the compiler what we're doing */
-      for(i=0;i<N4;i++)
-      {
-         kiss_fft_scalar yr, yi;
-         yr = S_MUL(fp->i,t[N4+i]) - S_MUL(fp->r,t[i]);
-         yi = S_MUL(fp->r,t[N4+i]) + S_MUL(fp->i,t[i]);
-         *yp1 = yr;
-         *yp2 = yi;
-         fp++;
-         yp1 += 2*stride;
-         yp2 -= 2*stride;
-      }
-   }
-   RESTORE_STACK;
-}
-
-void clt_mdct_backward_neon(const mdct_lookup *l,
-                            kiss_fft_scalar *in,
-                            kiss_fft_scalar * OPUS_RESTRICT out,
-                            const opus_val16 * OPUS_RESTRICT window,
-                            int overlap, int shift, int stride, int arch)
-{
-   int i;
-   int N, N2, N4;
-   VARDECL(kiss_fft_scalar, f);
-   const kiss_twiddle_scalar *trig;
-   const kiss_fft_state *st = l->kfft[shift];
-
-   N = l->n;
-   trig = l->trig;
-   for (i=0;i<shift;i++)
-   {
-      N >>= 1;
-      trig += N;
-   }
-   N2 = N>>1;
-   N4 = N>>2;
-
-   ALLOC(f, N2, kiss_fft_scalar);
-
-   /* Pre-rotate */
-   {
-      /* Temp pointers to make it really clear to the compiler what we're doing */
-      const kiss_fft_scalar * OPUS_RESTRICT xp1 = in;
-      const kiss_fft_scalar * OPUS_RESTRICT xp2 = in+stride*(N2-1);
-      kiss_fft_scalar * OPUS_RESTRICT yp = f;
-      const kiss_twiddle_scalar * OPUS_RESTRICT t = &trig[0];
-      for(i=0;i<N4;i++)
-      {
-         kiss_fft_scalar yr, yi;
-         yr = S_MUL(*xp2, t[i]) + S_MUL(*xp1, t[N4+i]);
-         yi = S_MUL(*xp1, t[i]) - S_MUL(*xp2, t[N4+i]);
-         yp[2*i] = yr;
-         yp[2*i+1] = yi;
-         xp1+=2*stride;
-         xp2-=2*stride;
-      }
-   }
-
-   opus_ifft(st, (kiss_fft_cpx *)f, (kiss_fft_cpx*)(out+(overlap>>1)), arch);
-
-   /* Post-rotate and de-shuffle from both ends of the buffer at once to make
-      it in-place. */
-   {
-      kiss_fft_scalar * yp0 = out+(overlap>>1);
-      kiss_fft_scalar * yp1 = out+(overlap>>1)+N2-2;
-      const kiss_twiddle_scalar *t = &trig[0];
-      /* Loop to (N4+1)>>1 to handle odd N4. When N4 is odd, the
-         middle pair will be computed twice. */
-      for(i=0;i<(N4+1)>>1;i++)
-      {
-         kiss_fft_scalar re, im, yr, yi;
-         kiss_twiddle_scalar t0, t1;
-         re = yp0[0];
-         im = yp0[1];
-         t0 = t[i];
-         t1 = t[N4+i];
-         /* We'd scale up by 2 here, but instead it's done when mixing the windows */
-         yr = S_MUL(re,t0) + S_MUL(im,t1);
-         yi = S_MUL(re,t1) - S_MUL(im,t0);
-         re = yp1[0];
-         im = yp1[1];
-         yp0[0] = yr;
-         yp1[1] = yi;
-
-         t0 = t[(N4-i-1)];
-         t1 = t[(N2-i-1)];
-         /* We'd scale up by 2 here, but instead it's done when mixing the windows */
-         yr = S_MUL(re,t0) + S_MUL(im,t1);
-         yi = S_MUL(re,t1) - S_MUL(im,t0);
-         yp1[0] = yr;
-         yp0[1] = yi;
-         yp0 += 2;
-         yp1 -= 2;
-      }
-   }
-
-   /* Mirror on both sides for TDAC */
-   {
-      kiss_fft_scalar * OPUS_RESTRICT xp1 = out+overlap-1;
-      kiss_fft_scalar * OPUS_RESTRICT yp1 = out;
-      const opus_val16 * OPUS_RESTRICT wp1 = window;
-      const opus_val16 * OPUS_RESTRICT wp2 = window+overlap-1;
-
-      for(i = 0; i < overlap/2; i++)
-      {
-         kiss_fft_scalar x1, x2;
-         x1 = *xp1;
-         x2 = *yp1;
-         *yp1++ = MULT16_32_Q15(*wp2, x2) - MULT16_32_Q15(*wp1, x1);
-         *xp1-- = MULT16_32_Q15(*wp1, x2) + MULT16_32_Q15(*wp2, x1);
-         wp1++;
-         wp2--;
-      }
-   }
-   RESTORE_STACK;
-}

package/opus/celt/arm/celt_neon_intr.c

@@ -1,272 +0,0 @@
-/* Copyright (c) 2014-2015 Xiph.Org Foundation
-   Written by Viswanath Puttagunta */
-/**
-   @file celt_neon_intr.c
-   @brief ARM Neon Intrinsic optimizations for celt
- */
-
-/*
-   Redistribution and use in source and binary forms, with or without
-   modification, are permitted provided that the following conditions
-   are met:
-
-   - Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-   - Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <arm_neon.h>
-#include "../pitch.h"
-
-#if defined(FIXED_POINT)
-#include <string.h>
-
-void xcorr_kernel_neon_fixed(const opus_val16 * x, const opus_val16 * y, opus_val32 sum[4], int len)
-{
-   int j;
-   int32x4_t a = vld1q_s32(sum);
-   /* Load y[0...3] */
-   /* This requires len>0 to always be valid (which we assert in the C code). */
-   int16x4_t y0 = vld1_s16(y);
-   y += 4;
-
-   /* This loop loads one y value more than we actually need.
-      Therefore we have to stop as soon as there are 8 or fewer samples left
-       (instead of 7), to avoid reading past the end of the array. */
-   for (j = 0; j + 8 < len; j += 8)
-   {
-      /* Load x[0...7] */
-      int16x8_t xx = vld1q_s16(x);
-      int16x4_t x0 = vget_low_s16(xx);
-      int16x4_t x4 = vget_high_s16(xx);
-      /* Load y[4...11] */
-      int16x8_t yy = vld1q_s16(y);
-      int16x4_t y4 = vget_low_s16(yy);
-      int16x4_t y8 = vget_high_s16(yy);
-      int32x4_t a0 = vmlal_lane_s16(a, y0, x0, 0);
-      int32x4_t a1 = vmlal_lane_s16(a0, y4, x4, 0);
-
-      int16x4_t y1 = vext_s16(y0, y4, 1);
-      int16x4_t y5 = vext_s16(y4, y8, 1);
-      int32x4_t a2 = vmlal_lane_s16(a1, y1, x0, 1);
-      int32x4_t a3 = vmlal_lane_s16(a2, y5, x4, 1);
-
-      int16x4_t y2 = vext_s16(y0, y4, 2);
-      int16x4_t y6 = vext_s16(y4, y8, 2);
-      int32x4_t a4 = vmlal_lane_s16(a3, y2, x0, 2);
-      int32x4_t a5 = vmlal_lane_s16(a4, y6, x4, 2);
-
-      int16x4_t y3 = vext_s16(y0, y4, 3);
-      int16x4_t y7 = vext_s16(y4, y8, 3);
-      int32x4_t a6 = vmlal_lane_s16(a5, y3, x0, 3);
-      int32x4_t a7 = vmlal_lane_s16(a6, y7, x4, 3);
-
-      y0 = y8;
-      a = a7;
-      x += 8;
-      y += 8;
-   }
-   if (j + 4 < len) {
-      /* Load x[0...3] */
-      int16x4_t x0 = vld1_s16(x);
-      /* Load y[4...7] */
-      int16x4_t y4 = vld1_s16(y);
-      int32x4_t a0 = vmlal_lane_s16(a, y0, x0, 0);
-      int16x4_t y1 = vext_s16(y0, y4, 1);
-      int32x4_t a1 = vmlal_lane_s16(a0, y1, x0, 1);
-      int16x4_t y2 = vext_s16(y0, y4, 2);
-      int32x4_t a2 = vmlal_lane_s16(a1, y2, x0, 2);
-      int16x4_t y3 = vext_s16(y0, y4, 3);
-      int32x4_t a3 = vmlal_lane_s16(a2, y3, x0, 3);
-      y0 = y4;
-      a = a3;
-      x += 4;
-      y += 4;
-      j += 4;
-   }
-   if (j + 2 < len) {
-      /* Load x[0...1] */
-      int16x4x2_t xx = vld2_dup_s16(x);
-      int16x4_t x0 = xx.val[0];
-      int16x4_t x1 = xx.val[1];
-      /* Load y[4...5].
-         We would like to use vld1_dup_s32(), but casting the pointer would
-          break strict aliasing rules and potentially have alignment issues.
-         Fortunately the compiler seems capable of translating this memcpy()
-          and vdup_n_s32() into the equivalent vld1_dup_s32().*/
-      int32_t yy;
-      memcpy(&yy, y, sizeof(yy));
-      int16x4_t y4 = vreinterpret_s16_s32(vdup_n_s32(yy));
-      int32x4_t a0 = vmlal_s16(a, y0, x0);
-      int16x4_t y1 = vext_s16(y0, y4, 1);
-      /* Replace bottom copy of {y[5], y[4]} in y4 with {y[3], y[2]} from y0,
-          using VSRI instead of VEXT, since it's a data-processing
-          instruction. */
-      y0 = vreinterpret_s16_s64(vsri_n_s64(vreinterpret_s64_s16(y4),
-       vreinterpret_s64_s16(y0), 32));
-      int32x4_t a1 = vmlal_s16(a0, y1, x1);
-      a = a1;
-      x += 2;
-      y += 2;
-      j += 2;
-   }
-   if (j + 1 < len) {
-      /* Load next x. */
-      int16x4_t x0 = vld1_dup_s16(x);
-      int32x4_t a0 = vmlal_s16(a, y0, x0);
-      /* Load last y. */
-      int16x4_t y4 = vld1_dup_s16(y);
-      y0 = vreinterpret_s16_s64(vsri_n_s64(vreinterpret_s64_s16(y4),
-       vreinterpret_s64_s16(y0), 16));
-      a = a0;
-      x++;
-   }
-   /* Load last x. */
-   int16x4_t x0 = vld1_dup_s16(x);
-   int32x4_t a0 = vmlal_s16(a, y0, x0);
-   vst1q_s32(sum, a0);
-}
-
-#else
-
-#if defined(__ARM_FEATURE_FMA) && defined(__ARM_ARCH_ISA_A64)
-/* If we can, force the compiler to use an FMA instruction rather than break
- *    vmlaq_f32() into fmul/fadd. */
-#ifdef vmlaq_lane_f32
-#undef vmlaq_lane_f32
-#endif
-#define vmlaq_lane_f32(a,b,c,lane) vfmaq_lane_f32(a,b,c,lane)
-#endif
-
-
-/*
- * Function: xcorr_kernel_neon_float
- * ---------------------------------
- * Computes 4 correlation values and stores them in sum[4]
- */
-static void xcorr_kernel_neon_float(const float32_t *x, const float32_t *y,
-      float32_t sum[4], int len) {
-   float32x4_t YY[3];
-   float32x4_t YEXT[3];
-   float32x4_t XX[2];
-   float32x2_t XX_2;
-   float32x4_t SUMM;
-   const float32_t *xi = x;
-   const float32_t *yi = y;
-
-   celt_assert(len>0);
-
-   YY[0] = vld1q_f32(yi);
-   SUMM = vdupq_n_f32(0);
-
-   /* Consume 8 elements in x vector and 12 elements in y
-    * vector. However, the 12'th element never really gets
-    * touched in this loop. So, if len == 8, then we only
-    * must access y[0] to y[10]. y[11] must not be accessed
-    * hence make sure len > 8 and not len >= 8
-    */
-   while (len > 8) {
-      yi += 4;
-      YY[1] = vld1q_f32(yi);
-      yi += 4;
-      YY[2] = vld1q_f32(yi);
-
-      XX[0] = vld1q_f32(xi);
-      xi += 4;
-      XX[1] = vld1q_f32(xi);
-      xi += 4;
-
-      SUMM = vmlaq_lane_f32(SUMM, YY[0], vget_low_f32(XX[0]), 0);
-      YEXT[0] = vextq_f32(YY[0], YY[1], 1);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[0], vget_low_f32(XX[0]), 1);
-      YEXT[1] = vextq_f32(YY[0], YY[1], 2);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[1], vget_high_f32(XX[0]), 0);
-      YEXT[2] = vextq_f32(YY[0], YY[1], 3);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[2], vget_high_f32(XX[0]), 1);
-
-      SUMM = vmlaq_lane_f32(SUMM, YY[1], vget_low_f32(XX[1]), 0);
-      YEXT[0] = vextq_f32(YY[1], YY[2], 1);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[0], vget_low_f32(XX[1]), 1);
-      YEXT[1] = vextq_f32(YY[1], YY[2], 2);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[1], vget_high_f32(XX[1]), 0);
-      YEXT[2] = vextq_f32(YY[1], YY[2], 3);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[2], vget_high_f32(XX[1]), 1);
-
-      YY[0] = YY[2];
-      len -= 8;
-   }
-
-   /* Consume 4 elements in x vector and 8 elements in y
-    * vector. However, the 8'th element in y never really gets
-    * touched in this loop. So, if len == 4, then we only
-    * must access y[0] to y[6]. y[7] must not be accessed
-    * hence make sure len>4 and not len>=4
-    */
-   if (len > 4) {
-      yi += 4;
-      YY[1] = vld1q_f32(yi);
-
-      XX[0] = vld1q_f32(xi);
-      xi += 4;
-
-      SUMM = vmlaq_lane_f32(SUMM, YY[0], vget_low_f32(XX[0]), 0);
-      YEXT[0] = vextq_f32(YY[0], YY[1], 1);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[0], vget_low_f32(XX[0]), 1);
-      YEXT[1] = vextq_f32(YY[0], YY[1], 2);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[1], vget_high_f32(XX[0]), 0);
-      YEXT[2] = vextq_f32(YY[0], YY[1], 3);
-      SUMM = vmlaq_lane_f32(SUMM, YEXT[2], vget_high_f32(XX[0]), 1);
-
-      YY[0] = YY[1];
-      len -= 4;
-   }
-
-   while (--len > 0) {
-      XX_2 = vld1_dup_f32(xi++);
-      SUMM = vmlaq_lane_f32(SUMM, YY[0], XX_2, 0);
-      YY[0]= vld1q_f32(++yi);
-   }
-
-   XX_2 = vld1_dup_f32(xi);
-   SUMM = vmlaq_lane_f32(SUMM, YY[0], XX_2, 0);
-
-   vst1q_f32(sum, SUMM);
-}
-
-void celt_pitch_xcorr_float_neon(const opus_val16 *_x, const opus_val16 *_y,
-                        opus_val32 *xcorr, int len, int max_pitch, int arch) {
-   int i;
-   (void)arch;
-   celt_assert(max_pitch > 0);
-   celt_sig_assert((((unsigned char *)_x-(unsigned char *)NULL)&3)==0);
-
-   for (i = 0; i < (max_pitch-3); i += 4) {
-      xcorr_kernel_neon_float((const float32_t *)_x, (const float32_t *)_y+i,
-            (float32_t *)xcorr+i, len);
-   }
-
-   /* In case max_pitch isn't a multiple of 4, do non-unrolled version. */
-   for (; i < max_pitch; i++) {
-      xcorr[i] = celt_inner_prod_neon(_x, _y+i, len);
-   }
-}
-#endif