Add Kiss FFT to RNNoise

Adding the original kiss_fft.h/.c files which have initially been excluded
when RNNoise was added to 3pp.

Bug: webrtc:9076
Change-Id: I488dafe9bcfab91cdba04e61a57dad4510699aab
Reviewed-on: https://chromium-review.googlesource.com/980994Reviewed-by: Tom Sepez <tsepez@chromium.org>
Commit-Queue: Ale Bzk <alessiob@chromium.org>
Cr-Commit-Position: refs/heads/master@{#546780}

third_party/rnnoise/README.chromium

@@ -14,4 +14,8 @@ RNNoise is a noise suppression library based on a recurrent neural network.
 The library is used for speech processing in WebRTC.
 
 Local Modifications:
-Only retaining rnn.c, rnn_data.c, tansig_table.h from src/ and COPYING.
+Only retaining COPYING and from src/ the following files:
+- kiss_fft.c, kiss_fft.h, _kiss_fft_guts.h
+- rnn.c
+- rnn_data.c
+- tansig_table.h

third_party/rnnoise/src/_kiss_fft_guts.h

+/*Copyright (c) 2003-2004, Mark Borgerding
+
+  All rights reserved.
+
+  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 THIRD_PARTY_RNNOISE_SRC__KISS_FFT_GUTS_H_
+#define THIRD_PARTY_RNNOISE_SRC__KISS_FFT_GUTS_H_
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+
+/* kiss_fft.h
+   defines kiss_fft_scalar as either short or a float type
+   and defines
+   typedef struct { kiss_fft_scalar r; kiss_fft_scalar i; }kiss_fft_cpx; */
+#include "kiss_fft.h"
+
+/*
+  Explanation of macros dealing with complex math:
+
+   C_MUL(m,a,b)         : m = a*b
+   C_FIXDIV( c , div )  : if a fixed point impl., c /= div. noop otherwise
+   C_SUB( res, a,b)     : res = a - b
+   C_SUBFROM( res , a)  : res -= a
+   C_ADDTO( res , a)    : res += a
+ * */
+#ifdef FIXED_POINT
+// #include "arch.h"
+
+#define SAMP_MAX 2147483647
+#define TWID_MAX 32767
+#define TRIG_UPSCALE 1
+
+#define SAMP_MIN -SAMP_MAX
+
+#define S_MUL(a, b) MULT16_32_Q15(b, a)
+
+#define C_MUL(m, a, b)                                             \
+  do {                                                             \
+    (m).r = SUB32_ovflw(S_MUL((a).r, (b).r), S_MUL((a).i, (b).i)); \
+    (m).i = ADD32_ovflw(S_MUL((a).r, (b).i), S_MUL((a).i, (b).r)); \
+  } while (0)
+
+#define C_MULC(m, a, b)                                            \
+  do {                                                             \
+    (m).r = ADD32_ovflw(S_MUL((a).r, (b).r), S_MUL((a).i, (b).i)); \
+    (m).i = SUB32_ovflw(S_MUL((a).i, (b).r), S_MUL((a).r, (b).i)); \
+  } while (0)
+
+#define C_MULBYSCALAR(c, s)  \
+  do {                       \
+    (c).r = S_MUL((c).r, s); \
+    (c).i = S_MUL((c).i, s); \
+  } while (0)
+
+#define DIVSCALAR(x, k) (x) = S_MUL(x, (TWID_MAX - ((k) >> 1)) / (k) + 1)
+
+#define C_FIXDIV(c, div)   \
+  do {                     \
+    DIVSCALAR((c).r, div); \
+    DIVSCALAR((c).i, div); \
+  } while (0)
+
+#define C_ADD(res, a, b)                 \
+  do {                                   \
+    (res).r = ADD32_ovflw((a).r, (b).r); \
+    (res).i = ADD32_ovflw((a).i, (b).i); \
+  } while (0)
+#define C_SUB(res, a, b)                 \
+  do {                                   \
+    (res).r = SUB32_ovflw((a).r, (b).r); \
+    (res).i = SUB32_ovflw((a).i, (b).i); \
+  } while (0)
+#define C_ADDTO(res, a)                    \
+  do {                                     \
+    (res).r = ADD32_ovflw((res).r, (a).r); \
+    (res).i = ADD32_ovflw((res).i, (a).i); \
+  } while (0)
+
+#define C_SUBFROM(res, a)                  \
+  do {                                     \
+    (res).r = ADD32_ovflw((res).r, (a).r); \
+    (res).i = SUB32_ovflw((res).i, (a).i); \
+  } while (0)
+
+// #if defined(OPUS_ARM_INLINE_ASM)
+// #include "arm/kiss_fft_armv4.h"
+// #endif
+
+// #if defined(OPUS_ARM_INLINE_EDSP)
+// #include "arm/kiss_fft_armv5e.h"
+// #endif
+// #if defined(MIPSr1_ASM)
+// #include "mips/kiss_fft_mipsr1.h"
+// #endif
+
+#else /* not FIXED_POINT*/
+
+#define S_MUL(a, b) ((a) * (b))
+#define C_MUL(m, a, b)                     \
+  do {                                     \
+    (m).r = (a).r * (b).r - (a).i * (b).i; \
+    (m).i = (a).r * (b).i + (a).i * (b).r; \
+  } while (0)
+#define C_MULC(m, a, b)                    \
+  do {                                     \
+    (m).r = (a).r * (b).r + (a).i * (b).i; \
+    (m).i = (a).i * (b).r - (a).r * (b).i; \
+  } while (0)
+
+#define C_MUL4(m, a, b) C_MUL(m, a, b)
+
+#define C_FIXDIV(c, div) /* NOOP */
+#define C_MULBYSCALAR(c, s) \
+  do {                      \
+    (c).r *= (s);           \
+    (c).i *= (s);           \
+  } while (0)
+#endif
+
+#ifndef CHECK_OVERFLOW_OP
+#define CHECK_OVERFLOW_OP(a, op, b) /* noop */
+#endif
+
+#ifndef C_ADD
+#define C_ADD(res, a, b)               \
+  do {                                 \
+    CHECK_OVERFLOW_OP((a).r, +, (b).r) \
+    CHECK_OVERFLOW_OP((a).i, +, (b).i) \
+    (res).r = (a).r + (b).r;           \
+    (res).i = (a).i + (b).i;           \
+  } while (0)
+#define C_SUB(res, a, b)               \
+  do {                                 \
+    CHECK_OVERFLOW_OP((a).r, -, (b).r) \
+    CHECK_OVERFLOW_OP((a).i, -, (b).i) \
+    (res).r = (a).r - (b).r;           \
+    (res).i = (a).i - (b).i;           \
+  } while (0)
+#define C_ADDTO(res, a)                  \
+  do {                                   \
+    CHECK_OVERFLOW_OP((res).r, +, (a).r) \
+    CHECK_OVERFLOW_OP((res).i, +, (a).i) \
+    (res).r += (a).r;                    \
+    (res).i += (a).i;                    \
+  } while (0)
+
+#define C_SUBFROM(res, a)                \
+  do {                                   \
+    CHECK_OVERFLOW_OP((res).r, -, (a).r) \
+    CHECK_OVERFLOW_OP((res).i, -, (a).i) \
+    (res).r -= (a).r;                    \
+    (res).i -= (a).i;                    \
+  } while (0)
+#endif /* C_ADD defined */
+
+#ifdef FIXED_POINT
+/*#  define KISS_FFT_COS(phase)
+TRIG_UPSCALE*floor(MIN(32767,MAX(-32767,.5+32768 * cos (phase)))) #  define
+KISS_FFT_SIN(phase)  TRIG_UPSCALE*floor(MIN(32767,MAX(-32767,.5+32768 * sin
+(phase))))*/
+#define KISS_FFT_COS(phase) floor(.5 + TWID_MAX * cos(phase))
+#define KISS_FFT_SIN(phase) floor(.5 + TWID_MAX * sin(phase))
+#define HALF_OF(x) ((x) >> 1)
+#elif defined(USE_SIMD)
+#define KISS_FFT_COS(phase) _mm_set1_ps(cos(phase))
+#define KISS_FFT_SIN(phase) _mm_set1_ps(sin(phase))
+#define HALF_OF(x) ((x)*_mm_set1_ps(.5f))
+#else
+#define KISS_FFT_COS(phase) (kiss_fft_scalar) cos(phase)
+#define KISS_FFT_SIN(phase) (kiss_fft_scalar) sin(phase)
+#define HALF_OF(x) ((x)*.5f)
+#endif
+
+#define kf_cexp(x, phase)         \
+  do {                            \
+    (x)->r = KISS_FFT_COS(phase); \
+    (x)->i = KISS_FFT_SIN(phase); \
+  } while (0)
+
+#define kf_cexp2(x, phase)                                \
+  do {                                                    \
+    (x)->r = TRIG_UPSCALE * celt_cos_norm((phase));       \
+    (x)->i = TRIG_UPSCALE * celt_cos_norm((phase)-32768); \
+  } while (0)
+
+#endif  // THIRD_PARTY_RNNOISE_SRC__KISS_FFT_GUTS_H_

third_party/rnnoise/src/kiss_fft.h

+/*Copyright (c) 2003-2004, Mark Borgerding
+  Lots of modifications by Jean-Marc Valin
+  Copyright (c) 2005-2007, Xiph.Org Foundation
+  Copyright (c) 2008,      Xiph.Org Foundation, CSIRO
+
+  All rights reserved.
+
+  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 THIRD_PARTY_RNNOISE_SRC_KISS_FFT_H_
+#define THIRD_PARTY_RNNOISE_SRC_KISS_FFT_H_
+
+#include <math.h>
+#include <stdlib.h>
+#include "arch.h"
+
+#include <stdlib.h>
+#define opus_alloc(x) malloc(x)
+#define opus_free(x) free(x)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef USE_SIMD
+#include <xmmintrin.h>
+#define kiss_fft_scalar __m128
+#define KISS_FFT_MALLOC(nbytes) memalign(16, nbytes)
+#else
+#define KISS_FFT_MALLOC opus_alloc
+#endif
+
+#ifdef FIXED_POINT
+#include "arch.h"
+
+#define kiss_fft_scalar opus_int32
+#define kiss_twiddle_scalar opus_int16
+
+#else
+#ifndef kiss_fft_scalar
+/*  default is float */
+#define kiss_fft_scalar float
+#define kiss_twiddle_scalar float
+#define KF_SUFFIX _celt_single
+#endif
+#endif
+
+typedef struct {
+  kiss_fft_scalar r;
+  kiss_fft_scalar i;
+} kiss_fft_cpx;
+
+typedef struct {
+  kiss_twiddle_scalar r;
+  kiss_twiddle_scalar i;
+} kiss_twiddle_cpx;
+
+#define MAXFACTORS 8
+/* e.g. an fft of length 128 has 4 factors
+ as far as kissfft is concerned
+ 4*4*4*2
+ */
+
+typedef struct arch_fft_state {
+  int is_supported;
+  void* priv;
+} arch_fft_state;
+
+typedef struct kiss_fft_state {
+  int nfft;
+  opus_val16 scale;
+#ifdef FIXED_POINT
+  int scale_shift;
+#endif
+  int shift;
+  opus_int16 factors[2 * MAXFACTORS];
+  const opus_int16* bitrev;
+  const kiss_twiddle_cpx* twiddles;
+  arch_fft_state* arch_fft;
+} kiss_fft_state;
+
+// #if defined(HAVE_ARM_NE10)
+// #include "arm/fft_arm.h"
+// #endif
+
+/*typedef struct kiss_fft_state* kiss_fft_cfg;*/
+
+/**
+ *  opus_fft_alloc
+ *
+ *  Initialize a FFT (or IFFT) algorithm's cfg/state buffer.
+ *
+ *  typical usage:      kiss_fft_cfg mycfg=opus_fft_alloc(1024,0,NULL,NULL);
+ *
+ *  The return value from fft_alloc is a cfg buffer used internally
+ *  by the fft routine or NULL.
+ *
+ *  If lenmem is NULL, then opus_fft_alloc will allocate a cfg buffer using
+ * malloc. The returned value should be free()d when done to avoid memory leaks.
+ *
+ *  The state can be placed in a user supplied buffer 'mem':
+ *  If lenmem is not NULL and mem is not NULL and *lenmem is large enough,
+ *      then the function places the cfg in mem and the size used in *lenmem
+ *      and returns mem.
+ *
+ *  If lenmem is not NULL and ( mem is NULL or *lenmem is not large enough),
+ *      then the function returns NULL and places the minimum cfg
+ *      buffer size in *lenmem.
+ * */
+
+kiss_fft_state* opus_fft_alloc_twiddles(int nfft,
+                                        void* mem,
+                                        size_t* lenmem,
+                                        const kiss_fft_state* base,
+                                        int arch);
+
+kiss_fft_state* opus_fft_alloc(int nfft, void* mem, size_t* lenmem, int arch);
+
+/**
+ * opus_fft(cfg,in_out_buf)
+ *
+ * Perform an FFT on a complex input buffer.
+ * for a forward FFT,
+ * fin should be  f[0] , f[1] , ... ,f[nfft-1]
+ * fout will be   F[0] , F[1] , ... ,F[nfft-1]
+ * Note that each element is complex and can be accessed like
+    f[k].r and f[k].i
+ * */
+void opus_fft_c(const kiss_fft_state* cfg,
+                const kiss_fft_cpx* fin,
+                kiss_fft_cpx* fout);
+void opus_ifft_c(const kiss_fft_state* cfg,
+                 const kiss_fft_cpx* fin,
+                 kiss_fft_cpx* fout);
+
+void opus_fft_impl(const kiss_fft_state* st, kiss_fft_cpx* fout);
+void opus_ifft_impl(const kiss_fft_state* st, kiss_fft_cpx* fout);
+
+void opus_fft_free(const kiss_fft_state* cfg, int arch);
+
+void opus_fft_free_arch_c(kiss_fft_state* st);
+int opus_fft_alloc_arch_c(kiss_fft_state* st);
+
+#if !defined(OVERRIDE_OPUS_FFT)
+/* Is run-time CPU detection enabled on this platform? */
+#if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10))
+
+extern int (*const OPUS_FFT_ALLOC_ARCH_IMPL[OPUS_ARCHMASK + 1])(
+    kiss_fft_state* st);
+
+#define opus_fft_alloc_arch(_st, arch) \
+  ((*OPUS_FFT_ALLOC_ARCH_IMPL[(arch)&OPUS_ARCHMASK])(_st))
+
+extern void (*const OPUS_FFT_FREE_ARCH_IMPL[OPUS_ARCHMASK + 1])(
+    kiss_fft_state* st);
+#define opus_fft_free_arch(_st, arch) \
+  ((*OPUS_FFT_FREE_ARCH_IMPL[(arch)&OPUS_ARCHMASK])(_st))
+
+extern void (*const OPUS_FFT[OPUS_ARCHMASK + 1])(const kiss_fft_state* cfg,
+                                                 const kiss_fft_cpx* fin,
+                                                 kiss_fft_cpx* fout);
+#define opus_fft(_cfg, _fin, _fout, arch) \
+  ((*OPUS_FFT[(arch)&OPUS_ARCHMASK])(_cfg, _fin, _fout))
+
+extern void (*const OPUS_IFFT[OPUS_ARCHMASK + 1])(const kiss_fft_state* cfg,
+                                                  const kiss_fft_cpx* fin,
+                                                  kiss_fft_cpx* fout);
+#define opus_ifft(_cfg, _fin, _fout, arch) \
+  ((*OPUS_IFFT[(arch)&OPUS_ARCHMASK])(_cfg, _fin, _fout))
+
+#else /* else for if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10)) */
+
+#define opus_fft_alloc_arch(_st, arch) \
+  ((void)(arch), opus_fft_alloc_arch_c(_st))
+
+#define opus_fft_free_arch(_st, arch) ((void)(arch), opus_fft_free_arch_c(_st))
+
+#define opus_fft(_cfg, _fin, _fout, arch) \
+  ((void)(arch), opus_fft_c(_cfg, _fin, _fout))
+
+#define opus_ifft(_cfg, _fin, _fout, arch) \
+  ((void)(arch), opus_ifft_c(_cfg, _fin, _fout))
+
+#endif /* end if defined(OPUS_HAVE_RTCD) && (defined(HAVE_ARM_NE10)) */
+#endif /* end if !defined(OVERRIDE_OPUS_FFT) */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // THIRD_PARTY_RNNOISE_SRC_KISS_FFT_H_