Switch FFTS to linkotec branch for cross-arch support

diff --git a/lib/ffts/CMakeLists.txt b/lib/ffts/CMakeLists.txt
new file mode 100644
index 0000000..2028c03
--- /dev/null
+++ b/lib/ffts/CMakeLists.txt
@@ -0,0 +1,462 @@
+cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
+
+project(ffts C ASM)
+
+# TODO: to support AutoConfigure building, this should came from "template" file
+set(FFTS_MAJOR 0)
+set(FFTS_MINOR 9)
+set(FFTS_MICRO 0)
+
+set(FFTS_VERSION "ffts-${FFTS_MAJOR}.${FFTS_MINOR}.${FFTS_MICRO}")
+
+set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+
+# default build type is Debug which means no optimization
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "Release")
+endif(NOT CMAKE_BUILD_TYPE)
+
+# common options
+option(ENABLE_NEON
+  "Enables the use of NEON instructions." OFF
+)
+
+option(ENABLE_VFP
+  "Enables the use of VFP instructions." OFF
+)
+
+option(DISABLE_DYNAMIC_CODE
+  "Disables the use of dynamic machine code generation." OFF
+)
+
+option(GENERATE_POSITION_INDEPENDENT_CODE
+  "Generate position independent code" OFF
+)
+
+option(ENABLE_SHARED
+  "Enable building a shared library." OFF
+)
+
+option(ENABLE_STATIC
+  "Enable building a static library." ON
+)
+
+include(CheckCSourceCompiles)
+include(CheckCSourceRuns)
+include(CheckIncludeFile)
+
+# Ensure defined when building FFTS (as opposed to using it from
+# another project). Used to export functions from Windows DLL.
+add_definitions(-DFFTS_BUILD)
+
+# check existence of various headers
+check_include_file(malloc.h   HAVE_MALLOC_H)
+check_include_file(stdint.h   HAVE_STDINT_H)
+check_include_file(stdlib.h   HAVE_STDLIB_H)
+check_include_file(string.h   HAVE_STRING_H)
+check_include_file(sys/mman.h HAVE_SYS_MMAN_H)
+check_include_file(unistd.h   HAVE_UNISTD_H)
+
+if(HAVE_MALLOC_H)
+  add_definitions(-DHAVE_MALLOC_H)
+endif(HAVE_MALLOC_H)
+
+if(HAVE_STDINT_H)
+  add_definitions(-DHAVE_STDINT_H)
+endif(HAVE_STDINT_H)
+
+if(HAVE_STDLIB_H)
+  add_definitions(-DHAVE_STDLIB_H)
+endif(HAVE_STDLIB_H)
+
+if(HAVE_STRING_H)
+  add_definitions(-DHAVE_STRING_H)
+endif(HAVE_STRING_H)
+
+if(HAVE_SYS_MMAN_H)
+  add_definitions(-DHAVE_SYS_MMAN_H)
+endif(HAVE_SYS_MMAN_H)
+
+if(HAVE_UNISTD_H)
+  add_definitions(-DHAVE_UNISTD_H)
+endif(HAVE_UNISTD_H)
+
+# backup flags
+set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
+
+# Determinate if we are cross-compiling
+if(NOT CMAKE_CROSSCOMPILING)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "^arm")
+    # Determinate ARM architecture
+
+    # Try to execute quietly without messages
+    set(CMAKE_REQUIRED_QUIET 1)
+
+    # The test for ARM architecture
+    set(TEST_SOURCE_CODE "int main() { return 0; }")
+
+    # GCC documentation says "native" is only supported on Linux, but let's try
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -march=native")
+    check_c_source_runs("${TEST_SOURCE_CODE}" GCC_MARCH_NATIVE_FLAG_SUPPORTED)
+
+    if(NOT GCC_MARCH_NATIVE_FLAG_SUPPORTED)
+      # Fallback trying generic ARMv7
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -march=armv7-a")
+      check_c_source_runs("${TEST_SOURCE_CODE}" GCC_MARCH_ARMV7A_FLAG_SUPPORTED)
+
+      if(NOT GCC_MARCH_ARMV7A_FLAG_SUPPORTED)
+        # Fallback trying generic ARMv6
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -march=armv6")
+        check_c_source_runs("${TEST_SOURCE_CODE}" GCC_MARCH_ARMV6_FLAG_SUPPORTED)
+
+        if(NOT GCC_MARCH_ARMV6_FLAG_SUPPORTED)
+          message(WARNING "FFTS failed to determinate ARM architecture")
+          set(CMAKE_REQUIRED_FLAGS ${CMAKE_REQUIRED_FLAGS_SAVE})
+        else()
+          message("FFTS is build using 'march=armv6'")
+          set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -march=armv6")
+          set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv6")
+        endif(NOT GCC_MARCH_ARMV6_FLAG_SUPPORTED)
+      else()
+        message("FFTS is build using 'march=armv7-a'")
+        set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -march=armv7-a")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a")
+      endif(NOT GCC_MARCH_ARMV7A_FLAG_SUPPORTED)
+    else()
+       message("FFTS is build using 'march=native'")
+       set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -march=native")
+       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
+    endif(NOT GCC_MARCH_NATIVE_FLAG_SUPPORTED)
+
+    # Determinate what floating-point hardware (or hardware emulation) is available
+    set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
+
+    # The test for ARM NEON support
+    set(TEST_SOURCE_CODE "
+      #include <arm_neon.h>
+      int main()
+      {
+       float32x4_t v;
+       float zeros[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+       v = vld1q_f32(zeros);
+       return 0;
+      }"
+    )
+
+    # Test running with -mfpu=neon and -mfloat-abi=hard
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -mfpu=neon -mfloat-abi=hard")
+    check_c_source_runs("${TEST_SOURCE_CODE}" NEON_HARDFP_SUPPORTED)
+
+    if(NOT NEON_HARDFP_SUPPORTED)
+      # Test running with -mfpu=neon and -mfloat-abi=softfp
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -mfpu=neon -mfloat-abi=softfp")
+      check_c_source_runs("${TEST_SOURCE_CODE}" NEON_SOFTFP_SUPPORTED)
+      
+      if(NOT NEON_SOFTFP_SUPPORTED)
+        if(ENABLE_NEON)
+          message(FATAL_ERROR "FFTS cannot enable NEON on this platform")
+        endif(ENABLE_NEON)
+      else()
+        message("FFTS is using 'neon' FPU and 'softfp' float ABI")
+        set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -mfpu=neon -mfloat-abi=softfp")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon -mfloat-abi=softfp")
+        set(ENABLE_NEON ON)
+      endif(NOT NEON_SOFTFP_SUPPORTED)
+    else()
+      message("FFTS is using 'neon' FPU and 'hard' float ABI")
+      set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -mfpu=neon -mfloat-abi=hard")
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon -mfloat-abi=hard")
+      set(ENABLE_NEON ON)
+    endif(NOT NEON_HARDFP_SUPPORTED)
+
+    # Fallback using VFP if NEON is not supported
+    if(NOT NEON_HARDFP_SUPPORTED AND NOT NEON_SOFTFP_SUPPORTED)
+      # Test for ARM VFP support
+      set(TEST_SOURCE_CODE "
+        double sum(double a, double b)
+        {
+         return a + b;
+        }
+        int main()
+        {
+         double s1, s2, v1 = 1.0, v2 = 2.0, v3 = 1.0e-322;
+         s1 = sum(v1, v2);
+         s2 = sum(v3, v3);
+         return 0;
+        }"
+      )
+
+      # Test running with -mfpu=vfp
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -mfpu=vfp")
+      check_c_source_runs("${TEST_SOURCE_CODE}" VFP_SUPPORTED)
+
+      if(NOT VFP_SUPPORTED)
+        # Fallback using emulation if VFP is not supported
+        if(ENABLE_VFP)
+          message(FATAL_ERROR "FFTS cannot enable VFP on this platform")
+        endif(ENABLE_VFP)
+
+        message(WARNING "FFTS is using 'soft' FPU")
+      else()
+        message("FFTS is using 'vfp' FPU")
+        set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -mfpu=vfp")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=vfp")
+        set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
+        set(ENABLE_VFP ON)
+      endif(NOT VFP_SUPPORTED)
+
+      # Test running with -mfloat-abi=hard
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -mfloat-abi=hard")
+
+      # Use the same test as before
+      check_c_source_runs("${TEST_SOURCE_CODE}" HARDFP_SUPPORTED)
+
+      if(NOT HARDFP_SUPPORTED)
+        # Test running with -mfloat-abi=softfp
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -mfloat-abi=softfp")
+        check_c_source_runs("${TEST_SOURCE_CODE}" SOFTFP_SUPPORTED)
+
+        if(NOT SOFTFP_SUPPORTED)
+          # Most likely development libraries are missing
+          message(WARNING "FFTS is using 'soft' float ABI")
+        else()
+          message("FFTS is using 'softfp' float ABI")
+          set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -mfloat-abi=softfp")
+          set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=softfp")
+        endif(NOT SOFTFP_SUPPORTED)
+      else()
+        message("FFTS is using 'hard' float ABI")
+        set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -mfloat-abi=hard")
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfloat-abi=hard")
+      endif(NOT HARDFP_SUPPORTED)
+    endif(NOT NEON_HARDFP_SUPPORTED AND NOT NEON_SOFTFP_SUPPORTED)
+  else()
+    # enable SSE code generation
+    if(CMAKE_COMPILER_IS_GNUCC)
+      set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS_SAVE} -msse")
+    endif(CMAKE_COMPILER_IS_GNUCC)
+
+    # check if the platform has support for SSE intrinsics
+    check_include_file(xmmintrin.h HAVE_XMMINTRIN_H)
+    if(HAVE_XMMINTRIN_H)
+      add_definitions(-DHAVE_SSE)
+      set(CMAKE_REQUIRED_FLAGS_SAVE ${CMAKE_REQUIRED_FLAGS})
 ** Diff limit reached (max: 250 lines) **