node-native-win-utils 1.4.0 → 2.1.0

package/include/opencv2/core/utils/allocator_stats.hpp

@@ -1,29 +0,0 @@
-// 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
-
-#endif // OPENCV_CORE_ALLOCATOR_STATS_HPP

package/include/opencv2/core/utils/allocator_stats.impl.hpp

@@ -1,158 +0,0 @@
-// 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
-
-#ifdef CV_CXX11
-
-#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
-
-#else  // CV_CXX11
-
-#ifndef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE
-#define OPENCV_ALLOCATOR_STATS_COUNTER_TYPE int  // CV_XADD supports int only
-#endif
-
-#endif  // CV_CXX11
-
-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*/) {}
-
-#elif defined(CV_CXX11)
-
-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;
-    }
-
-#else  // non C++11
-
-protected:
-    typedef OPENCV_ALLOCATOR_STATS_COUNTER_TYPE counter_t;
-    volatile counter_t curr, total, total_allocs, peak;  // overflow is possible, CV_XADD operates with 'int' only
-public:
-    AllocatorStatistics()
-        : curr(0), total(0), total_allocs(0), peak(0)
-    {}
-    ~AllocatorStatistics() CV_OVERRIDE {}
-
-    uint64_t getCurrentUsage() const CV_OVERRIDE { return (uint64_t)curr; }
-    uint64_t getTotalUsage() const CV_OVERRIDE { return (uint64_t)total; }
-    uint64_t getNumberOfAllocations() const CV_OVERRIDE { return (uint64_t)total_allocs; }
-    uint64_t getPeakUsage() const CV_OVERRIDE { return (uint64_t)peak; }
-
-    void resetPeakUsage() CV_OVERRIDE { peak = curr; }
-
-    // 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));
-#endif
-
-        counter_t new_curr = (counter_t)CV_XADD(&curr, (counter_t)sz) + (counter_t)sz;
-
-        peak = std::max((counter_t)peak, new_curr);  // non-thread safe
-
-        //CV_XADD(&total, (uint64_t)sz);  // overflow with int, non-reliable...
-        total += sz;
-
-        CV_XADD(&total_allocs, (counter_t)1);
-    }
-    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));
-#endif
-        CV_XADD(&curr, (counter_t)-sz);
-    }
-#endif
-};
-
-#ifdef CV__ALLOCATOR_STATS_LOG
-} // namespace
-#endif
-
-}} // namespace
-
-#endif // OPENCV_CORE_ALLOCATOR_STATS_IMPL_HPP

package/include/opencv2/core/utils/buffer_area.private.hpp

@@ -1,136 +0,0 @@
-// 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_BUFFER_AREA_HPP
-#define OPENCV_UTILS_BUFFER_AREA_HPP
-
-#include <opencv2/core/base.hpp>
-#include <opencv2/core/private.hpp>
-#include <opencv2/core/utility.hpp>
-#include <vector>
-
-namespace cv { namespace utils {
-
-//! @addtogroup core_utils
-//! @{
-
-/** @brief Manages memory block shared by muliple buffers.
-
-This class allows to allocate one large memory block and split it into several smaller
-non-overlapping buffers. In safe mode each buffer allocation will be performed independently,
-this mode allows dynamic memory access instrumentation using valgrind or memory sanitizer.
-
-Safe mode can be explicitly switched ON in constructor. It will also be enabled when compiling with
-memory sanitizer support or in runtime with the environment variable `OPENCV_BUFFER_AREA_ALWAYS_SAFE`.
-
-Example of usage:
-@code
-int * buf1 = 0;
-double * buf2 = 0;
-cv::util::BufferArea area;
-area.allocate(buf1, 200); // buf1 = new int[200];
-area.allocate(buf2, 1000, 64); // buf2 = new double[1000]; - aligned by 64
-area.commit();
-@endcode
-
-@note This class is considered private and should be used only in OpenCV itself. API can be changed.
-*/
-class CV_EXPORTS BufferArea
-{
-public:
-    /** @brief Class constructor.
-
-    @param safe Enable _safe_ operation mode, each allocation will be performed independently.
-    */
-    BufferArea(bool safe = false);
-
-    /** @brief Class destructor
-
-    All allocated memory well be freed. Each bound pointer will be reset to NULL.
-    */
-    ~BufferArea();
-
-    /** @brief Bind a pointer to local area.
-
-    BufferArea will store reference to the pointer and allocation parameters effectively owning the
-    pointer and allocated memory. This operation has the same parameters and does the same job
-    as the operator `new`, except allocation can be performed later during the BufferArea::commit call.
-
-    @param ptr Reference to a pointer of type T. Must be NULL
-    @param count Count of objects to be allocated, it has the same meaning as in the operator `new`.
-    @param alignment Alignment of allocated memory. same meaning as in the operator `new` (C++17).
-                     Must be divisible by sizeof(T). Must be power of two.
-
-    @note In safe mode allocation will be performed immediatly.
-    */
-    template <typename T>
-    void allocate(T*&ptr, size_t count, ushort alignment = sizeof(T))
-    {
-        CV_Assert(ptr == NULL);
-        CV_Assert(count > 0);
-        CV_Assert(alignment > 0);
-        CV_Assert(alignment % sizeof(T) == 0);
-        CV_Assert((alignment & (alignment - 1)) == 0);
-        allocate_((void**)(&ptr), static_cast<ushort>(sizeof(T)), count, alignment);
-#ifndef OPENCV_ENABLE_MEMORY_SANITIZER
-        if (safe)
-#endif
-            CV_Assert(ptr != NULL);
-    }
-
-    /** @brief Fill one of buffers with zeroes
-
-    @param ptr pointer to memory block previously added using BufferArea::allocate
-
-    BufferArea::commit must be called before using this method
-    */
-    template <typename T>
-    void zeroFill(T*&ptr)
-    {
-        CV_Assert(ptr);
-        zeroFill_((void**)&ptr);
-    }
-
-    /** @brief Fill all buffers with zeroes
-
-    BufferArea::commit must be called before using this method
-    */
-    void zeroFill();
-
-    /** @brief Allocate memory and initialize all bound pointers
-
-    Each pointer bound to the area with the BufferArea::allocate will be initialized and will be set
-    to point to a memory block with requested size and alignment.
-
-    @note Does nothing in safe mode as all allocations will be performed by BufferArea::allocate
-    */
-    void commit();
-
-    /** @brief Release all memory and unbind all pointers
-
-    All memory will be freed and all pointers will be reset to NULL and untied from the area allowing
-    to call `allocate` and `commit` again.
-    */
-    void release();
-
-private:
-    BufferArea(const BufferArea &); // = delete
-    BufferArea &operator=(const BufferArea &); // = delete
-    void allocate_(void **ptr, ushort type_size, size_t count, ushort alignment);
-    void zeroFill_(void **ptr);
-
-private:
-    class Block;
-    std::vector<Block> blocks;
-#ifndef OPENCV_ENABLE_MEMORY_SANITIZER
-    void * oneBuf;
-    size_t totalSize;
-    const bool safe;
-#endif
-};
-
-//! @}
-
-}} // cv::utils::
-
-#endif

package/include/opencv2/core/utils/configuration.private.hpp

@@ -1,22 +0,0 @@
-// 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_CONFIGURATION_PRIVATE_HPP
-#define OPENCV_CONFIGURATION_PRIVATE_HPP
-
-#include "opencv2/core/cvstd.hpp"
-#include <vector>
-#include <string>
-
-namespace cv { namespace utils {
-
-typedef std::vector<std::string> Paths;
-CV_EXPORTS bool getConfigurationParameterBool(const char* name, bool defaultValue);
-CV_EXPORTS size_t getConfigurationParameterSizeT(const char* name, size_t defaultValue);
-CV_EXPORTS cv::String getConfigurationParameterString(const char* name, const char* defaultValue);
-CV_EXPORTS Paths getConfigurationParameterPaths(const char* name, const Paths &defaultValue = Paths());
-
-}} // namespace
-
-#endif // OPENCV_CONFIGURATION_PRIVATE_HPP

package/include/opencv2/core/utils/filesystem.hpp

@@ -1,82 +0,0 @@
-// 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
-
-#endif // OPENCV_UTILS_FILESYSTEM_HPP

package/include/opencv2/core/utils/filesystem.private.hpp

@@ -1,66 +0,0 @@
-// 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_PRIVATE_HPP
-#define OPENCV_UTILS_FILESYSTEM_PRIVATE_HPP
-
-// TODO Move to CMake?
-#ifndef OPENCV_HAVE_FILESYSTEM_SUPPORT
-#  if defined(__EMSCRIPTEN__) || defined(__native_client__)
-     /* no support */
-#  elif defined WINRT || defined _WIN32_WCE
-     /* not supported */
-#  elif defined __ANDROID__ || defined __linux__ || defined _WIN32 || \
-        defined __FreeBSD__ || defined __bsdi__ || defined __HAIKU__
-#      define OPENCV_HAVE_FILESYSTEM_SUPPORT 1
-#  elif defined(__APPLE__)
-#    include <TargetConditionals.h>
-#    if (defined(TARGET_OS_OSX) && TARGET_OS_OSX) || (defined(TARGET_OS_IOS) && TARGET_OS_IOS)
-#      define OPENCV_HAVE_FILESYSTEM_SUPPORT 1 // OSX, iOS only
-#    endif
-#  else
-     /* unknown */
-#  endif
-#  ifndef OPENCV_HAVE_FILESYSTEM_SUPPORT
-#    define OPENCV_HAVE_FILESYSTEM_SUPPORT 0
-#  endif
-#endif
-
-#if OPENCV_HAVE_FILESYSTEM_SUPPORT
-namespace cv { namespace utils { namespace fs {
-
-/**
- * File-based lock object.
- *
- * Provides interprocess synchronization mechanism.
- * Platform dependent.
- *
- * Supports multiple readers / single writer access pattern (RW / readers-writer / shared-exclusive lock).
- *
- * File must exist.
- * File can't be re-used (for example, I/O operations via std::fstream is not safe)
- */
-class CV_EXPORTS FileLock {
-public:
-    explicit FileLock(const char* fname);
-    ~FileLock();
-
-    void lock(); //< acquire exclusive (writer) lock
-    void unlock(); //< release exclusive (writer) lock
-
-    void lock_shared(); //< acquire shareable (reader) lock
-    void unlock_shared(); //< release shareable (reader) lock
-
-    struct Impl;
-protected:
-    Impl* pImpl;
-
-private:
-    FileLock(const FileLock&); // disabled
-    FileLock& operator=(const FileLock&); // disabled
-};
-
-}}} // namespace
-#endif
-#endif // OPENCV_UTILS_FILESYSTEM_PRIVATE_HPP

package/include/opencv2/core/utils/fp_control.private.hpp

@@ -1,29 +0,0 @@
-// 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_PRIVATE_HPP
-#define OPENCV_CORE_FP_CONTROL_UTILS_PRIVATE_HPP
-
-#include "fp_control_utils.hpp"
-
-#if OPENCV_SUPPORTS_FP_DENORMALS_HINT == 0
-  // disabled
-#elif defined(OPENCV_IMPL_FP_HINTS)
-  // custom
-#elif defined(OPENCV_IMPL_FP_HINTS_X86)
-  // custom
-#elif defined(__SSE__) || defined(__SSE2__) || defined(_M_X64) || (defined(_M_IX86_FP) && _M_IX86_FP >= 1)
-  #include <xmmintrin.h>
-  #define OPENCV_IMPL_FP_HINTS_X86 1
-  #define OPENCV_IMPL_FP_HINTS 1
-#endif
-
-#ifndef OPENCV_IMPL_FP_HINTS
-#define OPENCV_IMPL_FP_HINTS 0
-#endif
-#ifndef OPENCV_IMPL_FP_HINTS_X86
-#define OPENCV_IMPL_FP_HINTS_X86 0
-#endif
-
-#endif // OPENCV_CORE_FP_CONTROL_UTILS_PRIVATE_HPP

package/include/opencv2/core/utils/fp_control_utils.hpp

@@ -1,69 +0,0 @@
-// 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