react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/common/pfft/pfft.h

@@ -0,0 +1,185 @@
+/* Copyright (c) 2013  Julien Pommier ( pommier@modartt.com )
+
+   Based on original fortran 77 code from FFTPACKv4 from NETLIB,
+   authored by Dr Paul Swarztrauber of NCAR, in 1985.
+
+   As confirmed by the NCAR fftpack software curators, the following
+   FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
+   released under the same terms.
+
+   FFTPACK license:
+
+   http://www.cisl.ucar.edu/css/software/fftpack5/ftpk.html
+
+   Copyright (c) 2004 the University Corporation for Atmospheric
+   Research ("UCAR"). All rights reserved. Developed by NCAR's
+   Computational and Information Systems Laboratory, UCAR,
+   www.cisl.ucar.edu.
+
+   Redistribution and use of the Software in source and binary forms,
+   with or without modification, is permitted provided that the
+   following conditions are met:
+
+   - Neither the names of NCAR's Computational and Information Systems
+   Laboratory, the University Corporation for Atmospheric Research,
+   nor the names of its sponsors or contributors may be used to
+   endorse or promote products derived from this Software without
+   specific prior written permission.
+
+   - Redistributions of source code must retain the above copyright
+   notices, this list of conditions, and the disclaimer below.
+
+   - Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions, and the disclaimer below in the
+   documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+   HOLDERS BE LIABLE FOR ANY CLAIM, INDIRECT, INCIDENTAL, SPECIAL,
+   EXEMPLARY, OR CONSEQUENTIAL DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+   SOFTWARE.
+*/
+
+/*
+  PFFFT : a Pretty Fast FFT.
+
+  This is basically an adaptation of the single precision fftpack
+  (v4) as found on netlib taking advantage of SIMD instruction found
+  on cpus such as intel x86 (SSE1), powerpc (Altivec), and arm (NEON).
+
+  For architectures where no SIMD instruction is available, the code
+  falls back to a scalar version.
+
+  Restrictions:
+
+  - 1D transforms only, with 32-bit single precision.
+
+  - supports only transforms for inputs of length N of the form
+  N=(2^a)*(3^b)*(5^c), a >= 5, b >=0, c >= 0 (32, 48, 64, 96, 128,
+  144, 160, etc are all acceptable lengths). Performance is best for
+  128<=N<=8192.
+
+  - all (float*) pointers in the functions below are expected to
+  have an "simd-compatible" alignment, that is 16 bytes on x86 and
+  powerpc CPUs.
+
+  You can allocate such buffers with the functions
+  pffft_aligned_malloc / pffft_aligned_free (or with stuff like
+  posix_memalign..)
+
+*/
+
+#pragma once
+
+#include <stddef.h> // for size_t
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+   Opaque struct holding internal stuff (precomputed twiddle factors)
+   this struct can be shared by many threads as it contains only
+   read-only data.
+*/
+typedef struct PFFFT_Setup PFFFT_Setup;
+
+/** Direction of the transform */
+typedef enum { PFFFT_FORWARD, PFFFT_BACKWARD } pffft_direction_t;
+
+/** Type of transform */
+typedef enum { PFFFT_REAL, PFFFT_COMPLEX } pffft_transform_t;
+
+/**
+  Prepare for performing transforms of size N -- the returned
+  PFFFT_Setup structure is read-only so it can safely be shared by
+  multiple concurrent threads.
+
+  Will return NULL if N is not suitable (too large / no decomposable with simple
+  integer factors..)
+*/
+PFFFT_Setup *pffft_new_setup(int N, pffft_transform_t transform);
+void pffft_destroy_setup(PFFFT_Setup *);
+/**
+  Perform a Fourier transform , The z-domain data is stored in the
+  most efficient order for transforming it back, or using it for
+  convolution. If you need to have its content sorted in the
+  "usual" way, that is as an array of interleaved complex numbers,
+  either use pffft_transform_ordered , or call pffft_zreorder after
+  the forward fft, and before the backward fft.
+
+  Transforms are not scaled: PFFFT_BACKWARD(PFFFT_FORWARD(x)) = N*x.
+  Typically you will want to scale the backward transform by 1/N.
+
+  The 'work' pointer should point to an area of N (2*N for complex
+  fft) floats, properly aligned. If 'work' is NULL, then stack will
+  be used instead (this is probably the best strategy for small
+  FFTs, say for N < 16384).
+
+  input and output may alias.
+*/
+void pffft_transform(PFFFT_Setup *setup, const float *input, float *output,
+                     float *work, pffft_direction_t direction);
+
+/**
+  Similar to pffft_transform, but makes sure that the output is
+  ordered as expected (interleaved complex numbers).  This is
+  similar to calling pffft_transform and then pffft_zreorder.
+
+  input and output may alias.
+*/
+void pffft_transform_ordered(PFFFT_Setup *setup, const float *input,
+                             float *output, float *work,
+                             pffft_direction_t direction);
+
+/**
+  call pffft_zreorder(.., PFFFT_FORWARD) after pffft_transform(...,
+  PFFFT_FORWARD) if you want to have the frequency components in
+  the correct "canonical" order, as interleaved complex numbers.
+
+  (for real transforms, both 0-frequency and half frequency
+  components, which are real, are assembled in the first entry as
+  F(0)+i*F(n/2+1). Note that the original fftpack did place
+  F(n/2+1) at the end of the arrays).
+
+  input and output should not alias.
+*/
+void pffft_zreorder(PFFFT_Setup *setup, const float *input, float *output,
+                    pffft_direction_t direction);
+
+/**
+  Perform a multiplication of the frequency components of dft_a and
+  dft_b and accumulate them into dft_ab. The arrays should have
+  been obtained with pffft_transform(.., PFFFT_FORWARD) and should
+  *not* have been reordered with pffft_zreorder (otherwise just
+  perform the operation yourself as the dft coefs are stored as
+  interleaved complex numbers).
+
+  the operation performed is: dft_ab += (dft_a * fdt_b)*scaling
+
+  The dft_a, dft_b and dft_ab pointers may alias.
+*/
+void pffft_zconvolve_accumulate(PFFFT_Setup *setup, const float *dft_a,
+                                const float *dft_b, float *dft_ab,
+                                float scaling);
+
+/**
+  the float buffers must have the correct alignment (16-byte boundary
+  on intel and powerpc). This function may be used to obtain such
+  correctly aligned buffers.
+*/
+void *pffft_aligned_malloc(size_t nb_bytes);
+void pffft_aligned_free(void *);
+
+/** return 4 or 1 wether support SSE/Altivec instructions was enable when
+ * building pffft.c */
+int pffft_simd_size(void);
+
+#ifdef __cplusplus
+}
+#endif

package/common/rnexecutorch/Log.h

@@ -0,0 +1,489 @@
+#pragma once
+#include <cstdint>
+#include <exception>
+#include <filesystem>
+#include <ios>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <string>
+#include <system_error>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <variant>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#endif
+#ifdef __APPLE__
+#include <os/log.h>
+#endif
+
+namespace low_level_log_implementation {
+
+using namespace std::string_literals;
+
+namespace concepts {
+template <typename T>
+concept Iterable = requires(const T &t) {
+  { std::begin(t) } -> std::input_or_output_iterator;
+  { std::end(t) } -> std::input_or_output_iterator;
+};
+
+template <typename T>
+concept FrontAccessible = requires(T t) {
+  { t.front() };
+  requires !std::is_void_v<decltype(t.front())>;
+};
+
+template <typename T>
+concept TopAccessible = requires(T t) {
+  { t.top() };
+  requires !std::is_void_v<decltype(t.top())>;
+};
+
+template <typename T>
+concept HasPop = requires(T t) {
+  { t.pop() };
+};
+
+template <typename T>
+concept HasEmpty = requires(const T &t) {
+  { t.empty() } -> std::same_as<bool>;
+};
+
+// These two below are needed apart from TopAccessible and FrontAccessible
+// to guarantee that correct templated is matched
+template <typename T>
+concept ReadOnlySequencableFront = requires(const T &t) {
+  { t.front() } -> std::same_as<const typename T::value_type &>;
+} && HasEmpty<T> && !Iterable<T>;
+
+template <typename T>
+concept ReadOnlySequencableTop = requires(const T &t) {
+  { t.top() } -> std::same_as<const typename T::value_type &>;
+} && HasEmpty<T> && !Iterable<T>;
+
+template <typename T>
+concept ReadOnlySequencable =
+    ReadOnlySequencableFront<T> || ReadOnlySequencableTop<T>;
+
+template <typename T>
+concept MutableSequencable = ReadOnlySequencable<T> && HasPop<T>;
+
+template <typename T>
+concept Streamable = requires(std::ostream &os, const T &t) {
+  { os << t } -> std::convertible_to<std::ostream &>;
+};
+
+template <typename T>
+concept SmartPointer = requires(const T &a) {
+  *a;
+  { a ? true : false } -> std::convertible_to<bool>;
+} && !std::is_pointer_v<T>; // Ensure that it's not a raw pointer
+
+template <typename T>
+concept WeakPointer = requires(const T &a) {
+  {
+    a.lock()
+  } -> std::convertible_to<
+      std::shared_ptr<typename T::element_type>>; // Verifies if a.lock() can
+                                                  // convert to std::shared_ptr
+};
+
+template <typename T>
+concept Fallback =
+    !Iterable<T> && !Streamable<T> && !SmartPointer<T> && !WeakPointer<T> &&
+    !ReadOnlySequencable<T> && !MutableSequencable<T>;
+
+} // namespace concepts
+
+template <typename T>
+  requires concepts::Streamable<T> && (!concepts::SmartPointer<T>)
+void printElement(std::ostream &os, const T &value);
+
+template <typename T, typename U>
+void printElement(std::ostream &os, const std::pair<T, U> &p);
+
+template <std::size_t N>
+void printElement(std::ostream &os, const char (&array)[N]);
+
+template <typename T, std::size_t N>
+void printElement(std::ostream &os, T (&array)[N]);
+
+template <typename T>
+  requires concepts::Iterable<T> && (!concepts::Streamable<T>)
+void printElement(std::ostream &os, const T &container);
+
+template <typename T> void printSequencable(std::ostream &os, T &&container);
+
+template <typename T>
+  requires concepts::ReadOnlySequencable<T>
+void printElement(std::ostream &os, const T &container);
+
+template <typename T>
+  requires concepts::MutableSequencable<T>
+void printElement(std::ostream &os, T &&container);
+
+template <typename... Args>
+void printElement(std::ostream &os, const std::tuple<Args...> &tpl);
+
+template <concepts::SmartPointer SP>
+void printElement(std::ostream &os, const SP &ptr);
+
+template <concepts::WeakPointer WP>
+void printElement(std::ostream &os, const WP &ptr);
+
+template <typename T>
+void printElement(std::ostream &os, const std::optional<T> &opt);
+
+template <typename... Ts>
+void printElement(std::ostream &os, const std::variant<Ts...> &var);
+
+void printElement(std::ostream &os, const std::exception_ptr &exPtr);
+
+void printElement(std::ostream &os, const std::filesystem::path &path);
+
+void printElement(std::ostream &os,
+                  const std::filesystem::directory_iterator &dir_it);
+
+template <concepts::Fallback UnsupportedArg>
+void printElement(std::ostream &os, const UnsupportedArg &value);
+
+void printElement(std::ostream &os, const std::error_code &ec);
+
+template <typename T>
+  requires concepts::Streamable<T> && (!concepts::SmartPointer<T>)
+void printElement(std::ostream &os, const T &value) {
+  os << value;
+}
+
+template <typename T, typename U>
+void printElement(std::ostream &os, const std::pair<T, U> &p) {
+  os << "(";
+  printElement(os, p.first);
+  os << ", ";
+  printElement(os, p.second);
+  os << ")";
+}
+
+template <std::size_t N>
+void printElement(std::ostream &os, const char (&array)[N]) {
+  // Treats the input as a string up to length N, drop null termination
+  if (N > 1) {
+    os << std::string_view(array, N - 1);
+  }
+}
+
+// A special function for C-style arrays deducing size via template
+template <typename T, std::size_t N>
+void printElement(std::ostream &os, T (&array)[N]) {
+  os << "[";
+  for (std::size_t i = 0; i < N; ++i) {
+    if (i > 0) {
+      os << ", ";
+    }
+    printElement(os, array[i]);
+  }
+  os << "]";
+}
+
+template <typename T>
+  requires concepts::Iterable<T> && (!concepts::Streamable<T>)
+void printElement(std::ostream &os, const T &container) {
+  os << "[";
+  auto it = std::begin(container);
+  if (it != std::end(container)) {
+    printElement(os, *it++);
+    for (; it != std::end(container); ++it) {
+      os << ", ";
+      printElement(os, *it);
+    }
+  }
+  os << "]";
+}
+
+template <typename T> void printSequencable(std::ostream &os, T &&container) {
+  os << "[";
+  bool isFirst = true;
+
+  auto printElementLambda = [&isFirst, &os](auto &&element) {
+    if (!isFirst) {
+      os << ", ";
+    }
+    low_level_log_implementation::printElement(
+        os, std::forward<decltype(element)>(element));
+    isFirst = false;
+  };
+
+  while (!container.empty()) {
+    if constexpr (concepts::FrontAccessible<T>) {
+      printElementLambda(container.front());
+    } else if constexpr (concepts::TopAccessible<T>) {
+      printElementLambda(container.top());
+    }
+    container.pop();
+  }
+
+  os << "]";
+}
+
+template <typename T>
+  requires concepts::ReadOnlySequencable<T>
+void printElement(std::ostream &os, const T &container) {
+  T tempContainer = container; // Make a copy to preserve original container
+  printSequencable(
+      os, std::move(tempContainer)); // Use std::move since tempContainer won't
+                                     // be used again
+}
+
+template <typename T>
+  requires concepts::MutableSequencable<T>
+void printElement(std::ostream &os, T &&container) {
+  printSequencable(os, std::forward<T>(container));
+}
+
+template <typename... Args>
+void printElement(std::ostream &os, const std::tuple<Args...> &tpl) {
+  os << "<";
+  std::apply(
+      [&os](const auto &...args) {
+        // Counter to apply commas correctly
+        std::size_t count = 0;
+        std::size_t total = sizeof...(args);
+
+        (
+            [&] {
+              printElement(os, args);
+              if (++count < total) {
+                os << ", ";
+              }
+            }(),
+            ...);
+      },
+      tpl);
+  os << ">";
+}
+
+template <concepts::SmartPointer SP>
+void printElement(std::ostream &os, const SP &ptr) {
+  if (ptr) {
+    printElement(os, *ptr);
+  } else {
+    os << "nullptr";
+  }
+}
+
+template <concepts::WeakPointer WP>
+void printElement(std::ostream &os, const WP &ptr) {
+  auto sp = ptr.lock();
+  if (sp) {
+    printElement(os, *sp);
+  } else {
+    os << "expired";
+  }
+}
+
+template <typename T>
+void printElement(std::ostream &os, const std::optional<T> &opt) {
+  if (opt) {
+    os << "Optional(";
+    printElement(os, *opt);
+    os << ")";
+  } else {
+    os << "nullopt";
+  }
+}
+
+template <typename... Ts>
+void printElement(std::ostream &os, const std::variant<Ts...> &var) {
+  std::visit(
+      [&os](const auto &value) {
+        os << "Variant(";
+        printElement(os, value);
+        os << ")";
+      },
+      var);
+}
+
+inline void printElement(std::ostream &os, const std::error_code &ec) {
+  os << "ErrorCode(" << ec.value() << ", " << ec.category().name() << ")";
+}
+
+inline void printElement(std::ostream &os, const std::exception_ptr &exPtr) {
+  if (exPtr) {
+    try {
+      std::rethrow_exception(exPtr);
+    } catch (const std::exception &ex) {
+      os << "ExceptionPtr(\"" << ex.what() << "\")";
+    } catch (...) {
+      os << "ExceptionPtr(non-standard exception)";
+    }
+  } else {
+    os << "nullptr";
+  }
+}
+
+inline void printElement(std::ostream &os, const std::filesystem::path &path) {
+  os << "Path(" << path << ")";
+}
+
+inline void
+printElement(std::ostream &os,
+             const std::filesystem::directory_iterator &dirIterator) {
+  os << "Directory[";
+  bool first = true;
+  for (const auto &entry : dirIterator) {
+    if (!first) {
+      os << ", ";
+    }
+    os << entry.path().filename(); // Ensuring only filename is captured
+    first = false;
+  }
+  os << "]";
+}
+
+// Fallback
+template <concepts::Fallback UnsupportedArg>
+void printElement(std::ostream &os, const UnsupportedArg &value) {
+  const auto *typeName = typeid(UnsupportedArg).name();
+  throw std::runtime_error(
+      "Type "s + std::string(typeName) +
+      "neither supports << operator for std::ostream nor is supported "
+      "out-of-the-box in logging functionality."s);
+}
+
+} // namespace low_level_log_implementation
+
+namespace rnexecutorch {
+
+/**
+ * @enum LogLevel
+ * @brief Represents various levels of logging severity.
+ *
+ * This `enum class` is used to specify the severity of a log message. This
+ * helps in filtering logs according to their importance and can be crucial for
+ * debugging and monitoring applications.
+ */
+enum class LOG_LEVEL : uint8_t {
+  Info,  /**< Informational messages that highlight the progress of the
+            application. */
+  Error, /**< Error events of considerable importance that will prevent normal
+            program execution. */
+  Debug  /**< Detailed information, typically of interest only when diagnosing
+            problems. */
+};
+
+namespace high_level_log_implementation {
+
+#ifdef __ANDROID__
+inline android_LogPriority androidLogLevel(LOG_LEVEL logLevel) {
+  switch (logLevel) {
+  case LOG_LEVEL::Info:
+    return ANDROID_LOG_INFO;
+  case LOG_LEVEL::Error:
+    return ANDROID_LOG_ERROR;
+  case LOG_LEVEL::Debug:
+    return ANDROID_LOG_DEBUG;
+  default:
+    return ANDROID_LOG_DEFAULT;
+  }
+}
+
+inline void handleAndroidLog(LOG_LEVEL logLevel, const char *buffer) {
+  __android_log_print(androidLogLevel(logLevel), "RnExecutorch", "%s", buffer);
+}
+#endif
+
+#ifdef __APPLE__
+inline void handleIosLog(LOG_LEVEL logLevel, const char *buffer) {
+  switch (logLevel) {
+  case LOG_LEVEL::Info:
+    os_log_info(OS_LOG_DEFAULT, "%{public}s", buffer);
+    return;
+  case LOG_LEVEL::Error:
+    os_log_error(OS_LOG_DEFAULT, "%{public}s", buffer);
+    return;
+  case LOG_LEVEL::Debug:
+    os_log_debug(OS_LOG_DEFAULT, "%{public}s", buffer);
+    return;
+  }
+}
+#endif
+
+inline std::string getBuffer(const std::string &logMessage,
+                             std::size_t maxLogMessageSize) {
+  if (logMessage.size() > maxLogMessageSize) {
+    return logMessage.substr(0, maxLogMessageSize) + "...";
+  }
+  return logMessage;
+}
+
+inline std::ostringstream createConfiguredOutputStream() {
+  std::ostringstream oss;
+  oss << std::boolalpha;
+  return oss;
+}
+
+} // namespace high_level_log_implementation
+
+/**
+ * @brief Logs given data on a console
+ * @details
+ * The function takes logging level and variety of data types:
+ * - Every data type that implements `operator<<` for `std::ostream`
+ * - All STL constainers available in C++20
+ * - Static arrays
+ * - Smart pointers, `std::variant`, and `std::optional`
+ * - `std::tuple` and `std::pair`
+ * - `std::error_code` and `std::exception_ptr`
+ * - `std::filesystem::path` and `std::filesystem::directory_iterator`
+ * - Every combination for mentioned above like `std::vector<std::set<int>>`
+ *
+ * You can manipulate size of the log message. By default it is set to 1024
+ * characters. To change this, specify the template argument like so:
+ * @code{.cpp}
+ * log<2048>(LOG_LEVEL::Info, longMsg);
+ * @endcode
+ * @param logLevel logging level - one of `LOG_LEVEL` enum class value: `Info`,
+ * `Error`, and `Debug`.
+ * @tparam Args Data to be logged.
+ * @tparam MaxLogSize Maximal size of log in characters.
+ * @par Returns
+ *    Nothing.
+ */
+template <std::size_t MaxLogSize = 1024, typename... Args>
+void log(LOG_LEVEL logLevel, Args &&...args) {
+  auto oss = high_level_log_implementation::createConfiguredOutputStream();
+  auto space = [&oss](auto &&arg) {
+    low_level_log_implementation::printElement(
+        oss, std::forward<decltype(arg)>(arg));
+    oss << ' ';
+  };
+
+  (..., space(std::forward<Args>(args)));
+
+  // Remove the extra space after the last element
+  std::string output = oss.str();
+  if (!output.empty()) {
+    output.pop_back();
+  }
+
+  const auto buffer =
+      high_level_log_implementation::getBuffer(output, MaxLogSize);
+  const auto *cStyleBuffer = buffer.c_str();
+
+#ifdef __ANDROID__
+  high_level_log_implementation::handleAndroidLog(logLevel, cStyleBuffer);
+#elif defined(__APPLE__)
+  high_level_log_implementation::handleIosLog(logLevel, cStyleBuffer);
+#else
+  // Default log to cout if none of the above platforms
+  std::cout << cStyleBuffer << '\n';
+#endif
+}
+
+} // namespace rnexecutorch