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

package/third-party/include/opencv2/core/utils/allocator_stats.hpp

@@ -0,0 +1,31 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_ALLOCATOR_STATS_HPP
+#define OPENCV_CORE_ALLOCATOR_STATS_HPP
+
+#include "../cvdef.h"
+
+namespace cv {
+namespace utils {
+
+class AllocatorStatisticsInterface {
+protected:
+  AllocatorStatisticsInterface() {}
+  virtual ~AllocatorStatisticsInterface() {}
+
+public:
+  virtual uint64_t getCurrentUsage() const = 0;
+  virtual uint64_t getTotalUsage() const = 0;
+  virtual uint64_t getNumberOfAllocations() const = 0;
+  virtual uint64_t getPeakUsage() const = 0;
+
+  /** set peak usage = current usage */
+  virtual void resetPeakUsage() = 0;
+};
+
+} // namespace utils
+} // namespace cv
+
+#endif // OPENCV_CORE_ALLOCATOR_STATS_HPP

package/third-party/include/opencv2/core/utils/allocator_stats.impl.hpp

@@ -0,0 +1,111 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP
+#define OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP
+
+#include "./allocator_stats.hpp"
+
+// #define OPENCV_DISABLE_ALLOCATOR_STATS
+
+#include <atomic>
+
+#ifndef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE
+#if defined(__GNUC__) &&                                                       \
+    ((defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__ == 4) ||               \
+     (defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) &&                           \
+      !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)))
+#define OPENCV_ALLOCATOR_STATS_COUNTER_TYPE int
+#endif
+#endif
+
+#ifndef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE
+#define OPENCV_ALLOCATOR_STATS_COUNTER_TYPE long long
+#endif
+
+namespace cv {
+namespace utils {
+
+#ifdef CV__ALLOCATOR_STATS_LOG
+namespace {
+#endif
+
+class AllocatorStatistics : public AllocatorStatisticsInterface {
+#ifdef OPENCV_DISABLE_ALLOCATOR_STATS
+
+public:
+  AllocatorStatistics() {}
+  ~AllocatorStatistics() CV_OVERRIDE {}
+
+  uint64_t getCurrentUsage() const CV_OVERRIDE { return 0; }
+  uint64_t getTotalUsage() const CV_OVERRIDE { return 0; }
+  uint64_t getNumberOfAllocations() const CV_OVERRIDE { return 0; }
+  uint64_t getPeakUsage() const CV_OVERRIDE { return 0; }
+
+  /** set peak usage = current usage */
+  void resetPeakUsage() CV_OVERRIDE {};
+
+  void onAllocate(size_t /*sz*/) {}
+  void onFree(size_t /*sz*/) {}
+
+#else
+
+protected:
+  typedef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE counter_t;
+  std::atomic<counter_t> curr, total, total_allocs, peak;
+
+public:
+  AllocatorStatistics() {}
+  ~AllocatorStatistics() CV_OVERRIDE {}
+
+  uint64_t getCurrentUsage() const CV_OVERRIDE { return (uint64_t)curr.load(); }
+  uint64_t getTotalUsage() const CV_OVERRIDE { return (uint64_t)total.load(); }
+  uint64_t getNumberOfAllocations() const CV_OVERRIDE {
+    return (uint64_t)total_allocs.load();
+  }
+  uint64_t getPeakUsage() const CV_OVERRIDE { return (uint64_t)peak.load(); }
+
+  /** set peak usage = current usage */
+  void resetPeakUsage() CV_OVERRIDE { peak.store(curr.load()); }
+
+  // Controller interface
+  void onAllocate(size_t sz) {
+#ifdef CV__ALLOCATOR_STATS_LOG
+    CV__ALLOCATOR_STATS_LOG(cv::format("allocate: %lld (curr=%lld)",
+                                       (long long int)sz,
+                                       (long long int)curr.load()));
+#endif
+
+    counter_t new_curr = curr.fetch_add((counter_t)sz) + (counter_t)sz;
+
+    // peak = std::max((uint64_t)peak, new_curr);
+    auto prev_peak = peak.load();
+    while (prev_peak < new_curr) {
+      if (peak.compare_exchange_weak(prev_peak, new_curr))
+        break;
+    }
+    // end of peak = max(...)
+
+    total += (counter_t)sz;
+    total_allocs++;
+  }
+  void onFree(size_t sz) {
+#ifdef CV__ALLOCATOR_STATS_LOG
+    CV__ALLOCATOR_STATS_LOG(cv::format("free: %lld (curr=%lld)",
+                                       (long long int)sz,
+                                       (long long int)curr.load()));
+#endif
+    curr -= (counter_t)sz;
+  }
+#endif // OPENCV_DISABLE_ALLOCATOR_STATS
+};
+
+#ifdef CV__ALLOCATOR_STATS_LOG
+} // namespace
+#endif
+
+} // namespace utils
+} // namespace cv
+
+#endif // OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP

package/third-party/include/opencv2/core/utils/filesystem.hpp

@@ -0,0 +1,91 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_UTILS_FILESYSTEM_HPP
+#define OPENCV_UTILS_FILESYSTEM_HPP
+
+namespace cv {
+namespace utils {
+namespace fs {
+
+CV_EXPORTS bool exists(const cv::String &path);
+CV_EXPORTS bool isDirectory(const cv::String &path);
+
+CV_EXPORTS void remove_all(const cv::String &path);
+
+CV_EXPORTS cv::String getcwd();
+
+/** @brief Converts path p to a canonical absolute path
+ * Symlinks are processed if there is support for them on running platform.
+ *
+ * @param path input path. Target file/directory should exist.
+ */
+CV_EXPORTS cv::String canonical(const cv::String &path);
+
+/** Join path components */
+CV_EXPORTS cv::String join(const cv::String &base, const cv::String &path);
+
+/** Get parent directory */
+CV_EXPORTS cv::String getParent(const cv::String &path);
+CV_EXPORTS std::wstring getParent(const std::wstring &path);
+
+/**
+ * Generate a list of all files that match the globbing pattern.
+ *
+ * Result entries are prefixed by base directory path.
+ *
+ * @param directory base directory
+ * @param pattern filter pattern (based on '*'/'?' symbols). Use empty string to
+ * disable filtering and return all results
+ * @param[out] result result of globing.
+ * @param recursive scan nested directories too
+ * @param includeDirectories include directories into results list
+ */
+CV_EXPORTS void glob(const cv::String &directory, const cv::String &pattern,
+                     CV_OUT std::vector<cv::String> &result,
+                     bool recursive = false, bool includeDirectories = false);
+
+/**
+ * Generate a list of all files that match the globbing pattern.
+ *
+ * @param directory base directory
+ * @param pattern filter pattern (based on '*'/'?' symbols). Use empty string to
+ * disable filtering and return all results
+ * @param[out] result globbing result with relative paths from base directory
+ * @param recursive scan nested directories too
+ * @param includeDirectories include directories into results list
+ */
+CV_EXPORTS void glob_relative(const cv::String &directory,
+                              const cv::String &pattern,
+                              CV_OUT std::vector<cv::String> &result,
+                              bool recursive = false,
+                              bool includeDirectories = false);
+
+CV_EXPORTS bool createDirectory(const cv::String &path);
+CV_EXPORTS bool createDirectories(const cv::String &path);
+
+#if defined(__OPENCV_BUILD) || defined(BUILD_PLUGIN)
+// TODO
+// CV_EXPORTS cv::String getTempDirectory();
+
+/**
+ * @brief Returns directory to store OpenCV cache files
+ * Create sub-directory in common OpenCV cache directory if it doesn't exist.
+ * @param sub_directory_name name of sub-directory. NULL or "" value asks to
+ * return root cache directory.
+ * @param configuration_name optional name of configuration parameter name which
+ * overrides default behavior.
+ * @return Path to cache directory. Returns empty string if cache directories
+ * support is not available. Returns "disabled" if cache disabled by user.
+ */
+CV_EXPORTS cv::String getCacheDirectory(const char *sub_directory_name,
+                                        const char *configuration_name = NULL);
+
+#endif
+
+} // namespace fs
+} // namespace utils
+} // namespace cv
+
+#endif // OPENCV_UTILS_FILESYSTEM_HPP

package/third-party/include/opencv2/core/utils/fp_control_utils.hpp

@@ -0,0 +1,70 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_CORE_FP_CONTROL_UTILS_HPP
+#define OPENCV_CORE_FP_CONTROL_UTILS_HPP
+
+namespace cv {
+
+namespace details {
+
+struct FPDenormalsModeState {
+  uint32_t reserved[16]; // 64-bytes
+}; // FPDenormalsModeState
+
+CV_EXPORTS void setFPDenormalsIgnoreHint(bool ignore,
+                                         CV_OUT FPDenormalsModeState &state);
+CV_EXPORTS int saveFPDenormalsState(CV_OUT FPDenormalsModeState &state);
+CV_EXPORTS bool restoreFPDenormalsState(const FPDenormalsModeState &state);
+
+class FPDenormalsIgnoreHintScope {
+public:
+  inline explicit FPDenormalsIgnoreHintScope(bool ignore = true) {
+    details::setFPDenormalsIgnoreHint(ignore, saved_state);
+  }
+
+  inline explicit FPDenormalsIgnoreHintScope(
+      const FPDenormalsModeState &state) {
+    details::saveFPDenormalsState(saved_state);
+    details::restoreFPDenormalsState(state);
+  }
+
+  inline ~FPDenormalsIgnoreHintScope() {
+    details::restoreFPDenormalsState(saved_state);
+  }
+
+protected:
+  FPDenormalsModeState saved_state;
+}; // FPDenormalsIgnoreHintScope
+
+class FPDenormalsIgnoreHintScopeNOOP {
+public:
+  inline FPDenormalsIgnoreHintScopeNOOP(bool ignore = true) {
+    CV_UNUSED(ignore);
+  }
+  inline FPDenormalsIgnoreHintScopeNOOP(const FPDenormalsModeState &state) {
+    CV_UNUSED(state);
+  }
+  inline ~FPDenormalsIgnoreHintScopeNOOP() {}
+}; // FPDenormalsIgnoreHintScopeNOOP
+
+} // namespace details
+
+// Should depend on target compilation architecture only
+// Note: previously added archs should NOT be removed to preserve ABI
+// compatibility
+#if defined(OPENCV_SUPPORTS_FP_DENORMALS_HINT)
+  // preserve configuration overloading through ports
+#elif defined(__i386__) || defined(__x86_64__) || defined(_M_X64) ||           \
+    defined(_X86_)
+typedef details::FPDenormalsIgnoreHintScope FPDenormalsIgnoreHintScope;
+#define OPENCV_SUPPORTS_FP_DENORMALS_HINT 1
+#else
+#define OPENCV_SUPPORTS_FP_DENORMALS_HINT 0
+typedef details::FPDenormalsIgnoreHintScopeNOOP FPDenormalsIgnoreHintScope;
+#endif
+
+} // namespace cv
+
+#endif // OPENCV_CORE_FP_CONTROL_UTILS_HPP

package/third-party/include/opencv2/core/utils/instrumentation.hpp

@@ -0,0 +1,127 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_UTILS_INSTR_HPP
+#define OPENCV_UTILS_INSTR_HPP
+
+#include <opencv2/core/utility.hpp>
+#include <opencv2/core/utils/tls.hpp>
+
+namespace cv {
+
+//! @addtogroup core_utils
+//! @{
+
+#ifdef CV_COLLECT_IMPL_DATA
+CV_EXPORTS void
+setImpl(int flags); // set implementation flags and reset storage arrays
+CV_EXPORTS void
+addImpl(int flag,
+        const char *func =
+            0); // add implementation and function name to storage arrays
+// Get stored implementation flags and functions names arrays
+// Each implementation entry correspond to function name entry, so you can find
+// which implementation was executed in which function
+CV_EXPORTS int getImpl(std::vector<int> &impl, std::vector<String> &funName);
+
+CV_EXPORTS bool useCollection(); // return implementation collection state
+CV_EXPORTS void
+setUseCollection(bool flag); // set implementation collection state
+
+#define CV_IMPL_PLAIN 0x01 // native CPU OpenCV implementation
+#define CV_IMPL_OCL 0x02   // OpenCL implementation
+#define CV_IMPL_IPP 0x04   // IPP implementation
+#define CV_IMPL_MT 0x10    // multithreaded implementation
+
+#undef CV_IMPL_ADD
+#define CV_IMPL_ADD(impl)                                                      \
+  if (cv::useCollection()) {                                                   \
+    cv::addImpl(impl, CV_Func);                                                \
+  }
+#endif
+
+// Instrumentation external interface
+namespace instr {
+
+#if !defined OPENCV_ABI_CHECK
+
+enum TYPE {
+  TYPE_GENERAL = 0, // OpenCV API function, e.g. exported function
+  TYPE_MARKER,      // Information marker
+  TYPE_WRAPPER,     // Wrapper function for implementation
+  TYPE_FUN,         // Simple function call
+};
+
+enum IMPL {
+  IMPL_PLAIN = 0,
+  IMPL_IPP,
+  IMPL_OPENCL,
+};
+
+struct NodeDataTls {
+  NodeDataTls() { m_ticksTotal = 0; }
+  uint64 m_ticksTotal;
+};
+
+class CV_EXPORTS NodeData {
+public:
+  NodeData(const char *funName = 0, const char *fileName = NULL,
+           int lineNum = 0, void *retAddress = NULL, bool alwaysExpand = false,
+           cv::instr::TYPE instrType = TYPE_GENERAL,
+           cv::instr::IMPL implType = IMPL_PLAIN);
+  NodeData(NodeData &ref);
+  ~NodeData();
+  NodeData &operator=(const NodeData &);
+
+  cv::String m_funName;
+  cv::instr::TYPE m_instrType;
+  cv::instr::IMPL m_implType;
+  const char *m_fileName;
+  int m_lineNum;
+  void *m_retAddress;
+  bool m_alwaysExpand;
+  bool m_funError;
+
+  volatile int m_counter;
+  volatile uint64 m_ticksTotal;
+  TLSDataAccumulator<NodeDataTls> m_tls;
+  int m_threads;
+
+  // No synchronization
+  double getTotalMs() const {
+    return ((double)m_ticksTotal / cv::getTickFrequency()) * 1000;
+  }
+  double getMeanMs() const {
+    return (((double)m_ticksTotal / m_counter) / cv::getTickFrequency()) * 1000;
+  }
+};
+bool operator==(const NodeData &lhs, const NodeData &rhs);
+
+typedef Node<NodeData> InstrNode;
+
+CV_EXPORTS InstrNode *getTrace();
+
+#endif // !defined OPENCV_ABI_CHECK
+
+CV_EXPORTS bool useInstrumentation();
+CV_EXPORTS void setUseInstrumentation(bool flag);
+CV_EXPORTS void resetTrace();
+
+enum FLAGS {
+  FLAGS_NONE = 0,
+  FLAGS_MAPPING = 0x01,
+  FLAGS_EXPAND_SAME_NAMES = 0x02,
+};
+
+CV_EXPORTS void setFlags(FLAGS modeFlags);
+static inline void setFlags(int modeFlags) { setFlags((FLAGS)modeFlags); }
+CV_EXPORTS FLAGS getFlags();
+
+} // namespace instr
+
+//! @}
+
+} // namespace cv
+
+#endif // OPENCV_UTILS_TLS_HPP

package/third-party/include/opencv2/core/utils/logger.defines.hpp

@@ -0,0 +1,50 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level
+// directory of this distribution and at http://opencv.org/license.html.
+
+#ifndef OPENCV_LOGGER_DEFINES_HPP
+#define OPENCV_LOGGER_DEFINES_HPP
+
+//! @addtogroup core_logging
+//! @{
+
+// Supported logging levels and their semantic
+#define CV_LOG_LEVEL_SILENT 0 //!< for using in setLogLevel() call
+#define CV_LOG_LEVEL_FATAL                                                     \
+  1 //!< Fatal (critical) error (unrecoverable internal error)
+#define CV_LOG_LEVEL_ERROR 2 //!< Error message
+#define CV_LOG_LEVEL_WARN 3  //!< Warning message
+#define CV_LOG_LEVEL_INFO 4  //!< Info message
+#define CV_LOG_LEVEL_DEBUG                                                     \
+  5 //!< Debug message. Disabled in the "Release" build.
+#define CV_LOG_LEVEL_VERBOSE                                                   \
+  6 //!< Verbose (trace) messages. Requires verbosity level. Disabled in the
+    //!< "Release" build.
+
+namespace cv {
+namespace utils {
+namespace logging {
+
+//! Supported logging levels and their semantic
+enum LogLevel {
+  LOG_LEVEL_SILENT = 0, //!< for using in setLogVevel() call
+  LOG_LEVEL_FATAL =
+      1, //!< Fatal (critical) error (unrecoverable internal error)
+  LOG_LEVEL_ERROR = 2,   //!< Error message
+  LOG_LEVEL_WARNING = 3, //!< Warning message
+  LOG_LEVEL_INFO = 4,    //!< Info message
+  LOG_LEVEL_DEBUG = 5,   //!< Debug message. Disabled in the "Release" build.
+  LOG_LEVEL_VERBOSE = 6, //!< Verbose (trace) messages. Requires verbosity
+                         //!< level. Disabled in the "Release" build.
+#ifndef CV_DOXYGEN
+  ENUM_LOG_LEVEL_FORCE_INT = INT_MAX
+#endif
+};
+
+} // namespace logging
+} // namespace utils
+} // namespace cv
+
+//! @}
+
+#endif // OPENCV_LOGGER_DEFINES_HPP