xmos-ai-tools 1.3.2.dev80__py3-none-macosx_10_15_universal2.whl

xmos_ai_tools/runtime/include/signal/src/irfft.h

@@ -0,0 +1,84 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_IRFFT_H_
+#define SIGNAL_SRC_IRFFT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "signal/src/complex.h"
+
+// TODO(b/286250473): remove namespace once de-duped libraries
+namespace tflite {
+namespace tflm_signal {
+
+// IRFFT (Inverse Real Fast Fourier Transform)
+// IFFT for real valued time domain outputs.
+
+// 16-bit Integer input/output
+
+// Returns the size of the memory that an IRFFT of `fft_length` needs
+size_t IrfftInt16GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an IRFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  IrfftGetNeededMemory(fft_length). Fails if it isn't.
+void* IrfftInt16Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies IRFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see IRfftInit)
+// * `output` must be of size output
+void IrfftInt16Apply(void* state, const Complex<int16_t>* input,
+                     int16_t* output);
+
+// 32-bit Integer input/output
+
+// Returns the size of the memory that an IRFFT of `fft_length` needs
+size_t IrfftInt32GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an IRFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  IrfftGetNeededMemory(fft_length). Fails if it isn't.
+void* IrfftInt32Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies IRFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see IRfftInit)
+// * `output` must be of size output
+void IrfftInt32Apply(void* state, const Complex<int32_t>* input,
+                     int32_t* output);
+
+// Floating point input/output
+
+// Returns the size of the memory that an IRFFT of `fft_length` needs
+size_t IrfftFloatGetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an IRFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  IrfftGetNeededMemory(fft_length). Fails if it isn't.
+void* IrfftFloatInit(int32_t fft_length, void* state, size_t state_size);
+
+// Applies IRFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see IRfftInit)
+// * `output` must be of size output
+void IrfftFloatApply(void* state, const Complex<float>* input, float* output);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_SRC_IRFFT_H_

xmos_ai_tools/runtime/include/signal/src/kiss_fft_wrappers/kiss_fft_common.h

@@ -0,0 +1,49 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_COMMON_H_
+#define SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_COMMON_H_
+
+// This header file should be included in all variants of kiss_fft_$type.{h,cc}
+// so that their sub-included source files do not mistakenly wrap libc header
+// files within their kissfft_$type namespaces.
+// E.g., This header avoids kissfft_int16.h containing:
+//   namespace kiss_fft_int16 {
+//     #include "kiss_fft.h"
+//   }
+// where kiss_fft_.h contains:
+//   #include <math.h>
+//
+// TRICK: By including the following header files here, their preprocessor
+// header guards prevent them being re-defined inside of the kiss_fft_$type
+// namespaces declared within the kiss_fft_$type.{h,cc} sources.
+// Note that the original kiss_fft*.h files are untouched since they
+// may be used in libraries that include them directly.
+
+#include <limits.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef FIXED_POINT
+#include <sys/types.h>
+#endif
+
+#ifdef USE_SIMD
+#include <xmmintrin.h>
+#endif
+
+#endif  // SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_COMMON_H_

xmos_ai_tools/runtime/include/signal/src/kiss_fft_wrappers/kiss_fft_float.h

@@ -0,0 +1,31 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_FLOAT_H_
+#define SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_FLOAT_H_
+
+#include "signal/src/kiss_fft_wrappers/kiss_fft_common.h"
+
+// Wrap floating point kiss fft in its own namespace. Enables us to link an
+// application with different kiss fft resolutions
+// (16/32 bit integer, float, double) without getting a linker error.
+#undef FIXED_POINT
+namespace kiss_fft_float {
+#include "kiss_fft.h"
+#include "tools/kiss_fftr.h"
+}  // namespace kiss_fft_float
+#undef FIXED_POINT
+
+#endif  // SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_FLOAT_H_

xmos_ai_tools/runtime/include/signal/src/kiss_fft_wrappers/kiss_fft_int16.h

@@ -0,0 +1,30 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT16_H_
+#define SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT16_H_
+
+#include "signal/src/kiss_fft_wrappers/kiss_fft_common.h"
+// Wrap floating point kiss fft in its own namespace. Enables us to link an
+// application with different kiss fft resolutions
+// (16/32 bit integer, float, double) without getting a linker error.
+#define FIXED_POINT 16
+namespace kiss_fft_fixed16 {
+#include "kiss_fft.h"
+#include "tools/kiss_fftr.h"
+}  // namespace kiss_fft_fixed16
+#undef FIXED_POINT
+
+#endif  // SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT16_H_

xmos_ai_tools/runtime/include/signal/src/kiss_fft_wrappers/kiss_fft_int32.h

@@ -0,0 +1,31 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT32_H_
+#define SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT32_H_
+
+#include "signal/src/kiss_fft_wrappers/kiss_fft_common.h"
+
+// Wrap floating point kiss fft in its own namespace. Enables us to link an
+// application with different kiss fft resolutions
+// (16/32 bit integer, float, double) without getting a linker error.
+#define FIXED_POINT 32
+namespace kiss_fft_fixed32 {
+#include "kiss_fft.h"
+#include "tools/kiss_fftr.h"
+}  // namespace kiss_fft_fixed32
+#undef FIXED_POINT
+
+#endif  // SIGNAL_SRC_KISS_FFT_WRAPPERS_KISS_FFT_INT32_H_

xmos_ai_tools/runtime/include/signal/src/log.h

@@ -0,0 +1,30 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_LOG_H_
+#define SIGNAL_SRC_LOG_H_
+
+#include <stdint.h>
+
+namespace tflite {
+namespace tflm_signal {
+// TODO(b/286250473): remove namespace once de-duped libraries above
+
+// Natural logarithm of an integer. The result is multiplied by out_scale
+uint32_t Log32(uint32_t x, uint32_t out_scale);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+#endif  // SIGNAL_SRC_LOG_H_

xmos_ai_tools/runtime/include/signal/src/max_abs.h

@@ -0,0 +1,31 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_MAX_ABS_H_
+#define SIGNAL_SRC_MAX_ABS_H_
+
+#include <stdint.h>
+
+// TODO(b/286250473): remove namespace once de-duped libraries
+namespace tflite {
+namespace tflm_signal {
+
+// Returns the maximum absolute value of the `size` elements in `input`
+int16_t MaxAbs16(const int16_t* input, int size);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_SRC_MAX_ABS_H_

xmos_ai_tools/runtime/include/signal/src/msb.h

@@ -0,0 +1,32 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_MSB_H_
+#define SIGNAL_SRC_MSB_H_
+
+#include <stdint.h>
+
+namespace tflite {
+namespace tflm_signal {
+// TODO(b/286250473): remove namespace once de-duped libraries above
+
+// Index of the most significant bit
+uint32_t MostSignificantBit32(uint32_t x);
+uint32_t MostSignificantBit64(uint64_t x);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_SRC_MSB_H_

xmos_ai_tools/runtime/include/signal/src/overlap_add.h

@@ -0,0 +1,46 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef SIGNAL_SRC_OVERLAP_ADD_H_
+#define SIGNAL_SRC_OVERLAP_ADD_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+namespace tflm_signal {
+// Adds (with saturation) the contents of `input` to the contents of `buffer`,
+// both of size `input_size`, then copies the first `output_size` elements of
+// `buffer` to `output`, shifts the last `input_size`-`output_size` elements of
+// `buffer` to the beginning of `buffer` and fills the trailing `output_size`
+// samples in `buffer` with zeros.
+// input: {input[0] ... input[input_size-1]}
+// buffer: {buffer[0] ... buffer[input_size-1]}
+// After invocation:
+// output: {saturate(input[0] + buffer[0]),
+//          ... ,
+//          saturate(input[output_size-1] + buffer[output_size-1])}
+// buffer: {saturate(input[output_size] + buffer[output_size]),
+//          ...
+//          saturate(  input[input_size-output_size-1]
+//                   + buffer[input_size-output_size-1]),
+//          zeros(output_size)}
+void OverlapAdd(const int16_t* input, int16_t* buffer, int input_size,
+                int16_t* output, int output_size);
+
+// The same as the int16_t variant above, but without saturation
+void OverlapAdd(const float* input, float* buffer, int input_size,
+                float* output, int output_size);
+
+}  //  namespace tflm_signal
+#endif  // SIGNAL_SRC_OVERLAP_ADD_H_

xmos_ai_tools/runtime/include/signal/src/pcan_argc_fixed.h

@@ -0,0 +1,41 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_MICRO_KERNELS__SRC_PCAN_AGC_FIXED_H
+#define SIGNAL_MICRO_KERNELS__SRC_PCAN_AGC_FIXED_H
+#include <cstdint>
+
+#include "msb.h"
+#include "tensorflow/lite/kernels/internal/compatibility.h"
+
+namespace tflite {
+namespace tflm_signal {
+
+#define kPcanSnrBits 12
+#define kPcanOutputBits 6
+
+int16_t WideDynamicFunction(const uint32_t x, const int16_t* lut);
+
+uint32_t PcanShrink(const uint32_t x);
+
+void ApplyPcanAutoGainControlFixed(const int16_t* gain_lut, int32_t snr_shift,
+                                   const uint32_t* noise_estimate,
+                                   uint32_t* filterbank_output,
+                                   int num_channels);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_MICRO_KERNELS__PCAN_AGC_FIXED_H

xmos_ai_tools/runtime/include/signal/src/rfft.h

@@ -0,0 +1,85 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_RFFT_H_
+#define SIGNAL_SRC_RFFT_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "signal/src/complex.h"
+
+// TODO(b/286250473): remove namespace once de-duped libraries
+namespace tflm_signal {
+
+// RFFT (Real Fast Fourier Transform)
+// FFT for real valued time domain inputs.
+
+// 16-bit Integer input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftInt16GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftInt16Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftInt16Apply(void* state, const int16_t* input,
+                    Complex<int16_t>* output);
+
+// 32-bit Integer input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftInt32GetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftInt32Init(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftInt32Apply(void* state, const int32_t* input,
+                    Complex<int32_t>* output);
+
+// Floating point input/output
+
+// Returns the size of the memory that an RFFT of `fft_length` needs
+size_t RfftFloatGetNeededMemory(int32_t fft_length);
+
+// Initialize the state of an RFFT of `fft_length`
+// `state` points to an opaque state of size `state_size`, which
+//  must be greater or equal to the value returned by
+//  RfftGetNeededMemory(fft_length).
+// Return the value of `state` on success or nullptr on failure
+void* RfftFloatInit(int32_t fft_length, void* state, size_t state_size);
+
+// Applies RFFT to `input` and writes the result to `output`
+// * `input` must be of size `fft_length` elements (see RfftInit)
+// * `output` must be of size (`fft_length` * 2) + 1 elements
+void RfftFloatApply(void* state, const float* input, Complex<float>* output);
+
+}  // namespace tflm_signal
+
+#endif  // SIGNAL_SRC_RFFT_H_

xmos_ai_tools/runtime/include/signal/src/square_root.h

@@ -0,0 +1,32 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_SQUARE_ROOT_H_
+#define SIGNAL_SRC_SQUARE_ROOT_H_
+
+#include <stdint.h>
+
+namespace tflite {
+namespace tflm_signal {
+// TODO(b/286250473): remove namespace once de-duped libraries above
+
+// Square root
+uint16_t Sqrt32(uint32_t num);
+uint32_t Sqrt64(uint64_t num);
+
+}  // namespace tflm_signal
+}  // namespace tflite
+
+#endif  // SIGNAL_SRC_SQUARE_ROOT_H_

xmos_ai_tools/runtime/include/signal/src/window.h

@@ -0,0 +1,31 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef SIGNAL_SRC_WINDOW_H_
+#define SIGNAL_SRC_WINDOW_H_
+
+#include <stdint.h>
+
+namespace tflm_signal {
+
+// Applies a window function to an input signal
+//
+// * `input` and `window` must be both of size `size` elements and are
+//    multiplied element-by element.
+// * `shift` is a right shift to apply before writing the result to `output`.
+void ApplyWindow(const int16_t* input, const int16_t* window, int size,
+                 int shift, int16_t* output);
+}  // namespace tflm_signal
+#endif  // SIGNAL_SRC_WINDOW_H_

xmos_ai_tools/runtime/include/signal/testdata/fft_test_data.h

@@ -0,0 +1,48 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef SIGNAL_TESTDATA_FFT_TEST_DATA_H_
+#define SIGNAL_TESTDATA_FFT_TEST_DATA_H_
+
+#include <cstdint>
+
+namespace tflite {
+
+/* These arrays are generated using random data. They serve to detect changes
+ * in the kernels. They do not test correctness.
+ */
+extern const int16_t kRfftInt16Length512Input[];
+extern const int16_t kRfftInt16Length512Golden[];
+
+extern const int32_t kRfftInt32Length512Input[];
+extern const int32_t kRfftInt32Length512Golden[];
+
+extern const float kRfftFloatLength512Input[];
+extern const float kRfftFloatLength512Golden[];
+
+extern const int16_t kIrfftInt16Length512Input[];
+extern const int16_t kIrfftInt16Length512Golden[];
+
+extern const int32_t kIrfftInt32Length512Input[];
+extern const int32_t kIrfftInt32Length512Golden[];
+
+extern const float kIrfftFloatLength512Input[];
+extern const float kIrfftFloatLength512Golden[];
+
+extern const int16_t kFftAutoScaleLength512Input[];
+extern const int16_t kFftAutoScaleLength512Golden[];
+
+}  // namespace tflite
+
+#endif  // SIGNAL_TESTDATA_FFT_TEST_DATA_H_