node-native-win-utils 1.4.0 → 2.1.0

package/include/opencv2/core/ocl_genbase.hpp

@@ -1,69 +0,0 @@
-/*M///////////////////////////////////////////////////////////////////////////////////////
-//
-//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
-//
-//  By downloading, copying, installing or using the software you agree to this license.
-//  If you do not agree to this license, do not download, install,
-//  copy or use the software.
-//
-//
-//                           License Agreement
-//                For Open Source Computer Vision Library
-//
-// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
-// Third party copyrights are property of their respective owners.
-//
-// Redistribution and use in source and binary forms, with or without modification,
-// are permitted provided that the following conditions are met:
-//
-//   * Redistribution's of source code must retain the above copyright notice,
-//     this list of conditions and the following disclaimer.
-//
-//   * Redistribution's in binary form must reproduce the above copyright notice,
-//     this list of conditions and the following disclaimer in the documentation
-//     and/or other materials provided with the distribution.
-//
-//   * The name of the copyright holders may not be used to endorse or promote products
-//     derived from this software without specific prior written permission.
-//
-// This software is provided by the copyright holders and contributors "as is" and
-// any express or implied warranties, including, but not limited to, the implied
-// warranties of merchantability and fitness for a particular purpose are disclaimed.
-// In no event shall the OpenCV Foundation or contributors be liable for any direct,
-// indirect, incidental, special, exemplary, or consequential damages
-// (including, but not limited to, procurement of substitute goods or services;
-// loss of use, data, or profits; or business interruption) however caused
-// and on any theory of liability, whether in contract, strict liability,
-// or tort (including negligence or otherwise) arising in any way out of
-// the use of this software, even if advised of the possibility of such damage.
-//
-//M*/
-
-#ifndef OPENCV_OPENCL_GENBASE_HPP
-#define OPENCV_OPENCL_GENBASE_HPP
-
-//! @cond IGNORED
-
-namespace cv {
-namespace ocl {
-
-class ProgramSource;
-
-namespace internal {
-
-struct CV_EXPORTS ProgramEntry
-{
-    const char* module;
-    const char* name;
-    const char* programCode;
-    const char* programHash;
-    ProgramSource* pProgramSource;
-
-    operator ProgramSource& () const;
-};
-
-} } } // namespace
-
-//! @endcond
-
-#endif

package/include/opencv2/core/opencl/ocl_defs.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.
-
-// Copyright (C) 2014, Advanced Micro Devices, Inc., all rights reserved.
-// Third party copyrights are property of their respective owners.
-
-#ifndef OPENCV_CORE_OPENCL_DEFS_HPP
-#define OPENCV_CORE_OPENCL_DEFS_HPP
-
-#include "opencv2/core/utility.hpp"
-#include "cvconfig.h"
-
-namespace cv { namespace ocl {
-#ifdef HAVE_OPENCL
-/// Call is similar to useOpenCL() but doesn't try to load OpenCL runtime or create OpenCL context
-CV_EXPORTS bool isOpenCLActivated();
-#else
-static inline bool isOpenCLActivated() { return false; }
-#endif
-}} // namespace
-
-
-//#define CV_OPENCL_RUN_ASSERT
-
-#ifdef HAVE_OPENCL
-
-#ifdef CV_OPENCL_RUN_VERBOSE
-#define CV_OCL_RUN_(condition, func, ...)                                   \
-    {                                                                       \
-        if (cv::ocl::isOpenCLActivated() && (condition) && func)            \
-        {                                                                   \
-            printf("%s: OpenCL implementation is running\n", CV_Func);      \
-            fflush(stdout);                                                 \
-            CV_IMPL_ADD(CV_IMPL_OCL);                                       \
-            return __VA_ARGS__;                                             \
-        }                                                                   \
-        else                                                                \
-        {                                                                   \
-            printf("%s: Plain implementation is running\n", CV_Func);       \
-            fflush(stdout);                                                 \
-        }                                                                   \
-    }
-#elif defined CV_OPENCL_RUN_ASSERT
-#define CV_OCL_RUN_(condition, func, ...)                                   \
-    {                                                                       \
-        if (cv::ocl::isOpenCLActivated() && (condition))                    \
-        {                                                                   \
-            if(func)                                                        \
-            {                                                               \
-                CV_IMPL_ADD(CV_IMPL_OCL);                                   \
-            }                                                               \
-            else                                                            \
-            {                                                               \
-                CV_Error(cv::Error::StsAssert, #func);                      \
-            }                                                               \
-            return __VA_ARGS__;                                             \
-        }                                                                   \
-    }
-#else
-#define CV_OCL_RUN_(condition, func, ...)                                   \
-try \
-{ \
-    if (cv::ocl::isOpenCLActivated() && (condition) && func)                \
-    {                                                                       \
-        CV_IMPL_ADD(CV_IMPL_OCL);                                           \
-        return __VA_ARGS__;                                                 \
-    } \
-} \
-catch (const cv::Exception& e) \
-{ \
-    CV_UNUSED(e); /* TODO: Add some logging here */ \
-}
-#endif
-
-#else
-#define CV_OCL_RUN_(condition, func, ...)
-#endif
-
-#define CV_OCL_RUN(condition, func) CV_OCL_RUN_(condition, func)
-
-#endif // OPENCV_CORE_OPENCL_DEFS_HPP

package/include/opencv2/core/opencl/opencl_info.hpp

@@ -1,212 +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.
-
-#include <iostream>
-
-#include <opencv2/core.hpp>
-#include <opencv2/core/ocl.hpp>
-
-#ifndef DUMP_CONFIG_PROPERTY
-#define DUMP_CONFIG_PROPERTY(...)
-#endif
-
-#ifndef DUMP_MESSAGE_STDOUT
-#define DUMP_MESSAGE_STDOUT(...) do { std::cout << __VA_ARGS__ << std::endl; } while (false)
-#endif
-
-namespace cv {
-
-namespace {
-static std::string bytesToStringRepr(size_t value)
-{
-    size_t b = value % 1024;
-    value /= 1024;
-
-    size_t kb = value % 1024;
-    value /= 1024;
-
-    size_t mb = value % 1024;
-    value /= 1024;
-
-    size_t gb = value;
-
-    std::ostringstream stream;
-
-    if (gb > 0)
-        stream << gb << " GB ";
-    if (mb > 0)
-        stream << mb << " MB ";
-    if (kb > 0)
-        stream << kb << " KB ";
-    if (b > 0)
-        stream << b << " B";
-
-    std::string s = stream.str();
-    if (s[s.size() - 1] == ' ')
-        s = s.substr(0, s.size() - 1);
-    return s;
-}
-
-static String getDeviceTypeString(const cv::ocl::Device& device)
-{
-    if (device.type() == cv::ocl::Device::TYPE_CPU) {
-        return "CPU";
-    }
-
-    if (device.type() == cv::ocl::Device::TYPE_GPU) {
-        if (device.hostUnifiedMemory()) {
-            return "iGPU";
-        } else {
-            return "dGPU";
-        }
-    }
-
-    return "unknown";
-}
-} // namespace
-
-static void dumpOpenCLInformation()
-{
-    using namespace cv::ocl;
-
-    try
-    {
-        if (!haveOpenCL() || !useOpenCL())
-        {
-            DUMP_MESSAGE_STDOUT("OpenCL is disabled");
-            DUMP_CONFIG_PROPERTY("cv_ocl", "disabled");
-            return;
-        }
-
-        std::vector<PlatformInfo> platforms;
-        cv::ocl::getPlatfomsInfo(platforms);
-        if (platforms.empty())
-        {
-            DUMP_MESSAGE_STDOUT("OpenCL is not available");
-            DUMP_CONFIG_PROPERTY("cv_ocl", "not available");
-            return;
-        }
-
-        DUMP_MESSAGE_STDOUT("OpenCL Platforms: ");
-        for (size_t i = 0; i < platforms.size(); i++)
-        {
-            const PlatformInfo* platform = &platforms[i];
-            DUMP_MESSAGE_STDOUT("    " << platform->name());
-            Device current_device;
-            for (int j = 0; j < platform->deviceNumber(); j++)
-            {
-                platform->getDevice(current_device, j);
-                String deviceTypeStr = getDeviceTypeString(current_device);
-                DUMP_MESSAGE_STDOUT( "        " << deviceTypeStr << ": " << current_device.name() << " (" << current_device.version() << ")");
-                DUMP_CONFIG_PROPERTY( cv::format("cv_ocl_platform_%d_device_%d", (int)i, j ),
-                    cv::format("(Platform=%s)(Type=%s)(Name=%s)(Version=%s)",
-                    platform->name().c_str(), deviceTypeStr.c_str(), current_device.name().c_str(), current_device.version().c_str()) );
-            }
-        }
-        const Device& device = Device::getDefault();
-        if (!device.available())
-            CV_Error(Error::OpenCLInitError, "OpenCL device is not available");
-
-        DUMP_MESSAGE_STDOUT("Current OpenCL device: ");
-
-        String deviceTypeStr = getDeviceTypeString(device);
-        DUMP_MESSAGE_STDOUT("    Type = " << deviceTypeStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceType", deviceTypeStr);
-
-        DUMP_MESSAGE_STDOUT("    Name = " << device.name());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceName", device.name());
-
-        DUMP_MESSAGE_STDOUT("    Version = " << device.version());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_deviceVersion", device.version());
-
-        DUMP_MESSAGE_STDOUT("    Driver version = " << device.driverVersion());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_driverVersion", device.driverVersion());
-
-        DUMP_MESSAGE_STDOUT("    Address bits = " << device.addressBits());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_addressBits", device.addressBits());
-
-        DUMP_MESSAGE_STDOUT("    Compute units = " << device.maxComputeUnits());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxComputeUnits", device.maxComputeUnits());
-
-        DUMP_MESSAGE_STDOUT("    Max work group size = " << device.maxWorkGroupSize());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxWorkGroupSize", device.maxWorkGroupSize());
-
-        std::string localMemorySizeStr = bytesToStringRepr(device.localMemSize());
-        DUMP_MESSAGE_STDOUT("    Local memory size = " << localMemorySizeStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_localMemSize", device.localMemSize());
-
-        std::string maxMemAllocSizeStr = bytesToStringRepr(device.maxMemAllocSize());
-        DUMP_MESSAGE_STDOUT("    Max memory allocation size = " << maxMemAllocSizeStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_maxMemAllocSize", device.maxMemAllocSize());
-
-        const char* doubleSupportStr = device.doubleFPConfig() > 0 ? "Yes" : "No";
-        DUMP_MESSAGE_STDOUT("    Double support = " << doubleSupportStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_haveDoubleSupport", device.doubleFPConfig() > 0);
-
-        const char* halfSupportStr = device.halfFPConfig() > 0 ? "Yes" : "No";
-        DUMP_MESSAGE_STDOUT("    Half support = " << halfSupportStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_haveHalfSupport", device.halfFPConfig() > 0);
-
-        const char* isUnifiedMemoryStr = device.hostUnifiedMemory() ? "Yes" : "No";
-        DUMP_MESSAGE_STDOUT("    Host unified memory = " << isUnifiedMemoryStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_hostUnifiedMemory", device.hostUnifiedMemory());
-
-        DUMP_MESSAGE_STDOUT("    Device extensions:");
-        String extensionsStr = device.extensions();
-        size_t pos = 0;
-        while (pos < extensionsStr.size())
-        {
-            size_t pos2 = extensionsStr.find(' ', pos);
-            if (pos2 == String::npos)
-                pos2 = extensionsStr.size();
-            if (pos2 > pos)
-            {
-                String extensionName = extensionsStr.substr(pos, pos2 - pos);
-                DUMP_MESSAGE_STDOUT("        " << extensionName);
-            }
-            pos = pos2 + 1;
-        }
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_extensions", extensionsStr);
-
-        const char* haveAmdBlasStr = haveAmdBlas() ? "Yes" : "No";
-        DUMP_MESSAGE_STDOUT("    Has AMD Blas = " << haveAmdBlasStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_AmdBlas", haveAmdBlas());
-
-        const char* haveAmdFftStr = haveAmdFft() ? "Yes" : "No";
-        DUMP_MESSAGE_STDOUT("    Has AMD Fft = " << haveAmdFftStr);
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_AmdFft", haveAmdFft());
-
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width char = " << device.preferredVectorWidthChar());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthChar", device.preferredVectorWidthChar());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width short = " << device.preferredVectorWidthShort());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthShort", device.preferredVectorWidthShort());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width int = " << device.preferredVectorWidthInt());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthInt", device.preferredVectorWidthInt());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width long = " << device.preferredVectorWidthLong());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthLong", device.preferredVectorWidthLong());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width float = " << device.preferredVectorWidthFloat());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthFloat", device.preferredVectorWidthFloat());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width double = " << device.preferredVectorWidthDouble());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthDouble", device.preferredVectorWidthDouble());
-
-        DUMP_MESSAGE_STDOUT("    Preferred vector width half = " << device.preferredVectorWidthHalf());
-        DUMP_CONFIG_PROPERTY("cv_ocl_current_preferredVectorWidthHalf", device.preferredVectorWidthHalf());
-    }
-    catch (...)
-    {
-        DUMP_MESSAGE_STDOUT("Exception. Can't dump OpenCL info");
-        DUMP_MESSAGE_STDOUT("OpenCL device not available");
-        DUMP_CONFIG_PROPERTY("cv_ocl", "not available");
-    }
-}
-#undef DUMP_MESSAGE_STDOUT
-#undef DUMP_CONFIG_PROPERTY
-
-} // namespace

package/include/opencv2/core/opencl/opencl_svm.hpp

@@ -1,81 +0,0 @@
-/* See LICENSE file in the root OpenCV directory */
-
-#ifndef OPENCV_CORE_OPENCL_SVM_HPP
-#define OPENCV_CORE_OPENCL_SVM_HPP
-
-//
-// Internal usage only (binary compatibility is not guaranteed)
-//
-#ifndef __OPENCV_BUILD
-#error Internal header file
-#endif
-
-#if defined(HAVE_OPENCL) && defined(HAVE_OPENCL_SVM)
-#include "runtime/opencl_core.hpp"
-#include "runtime/opencl_svm_20.hpp"
-#include "runtime/opencl_svm_hsa_extension.hpp"
-
-namespace cv { namespace ocl { namespace svm {
-
-struct SVMCapabilities
-{
-    enum Value
-    {
-        SVM_COARSE_GRAIN_BUFFER = (1 << 0),
-        SVM_FINE_GRAIN_BUFFER = (1 << 1),
-        SVM_FINE_GRAIN_SYSTEM = (1 << 2),
-        SVM_ATOMICS = (1 << 3),
-    };
-    int value_;
-
-    SVMCapabilities(int capabilities = 0) : value_(capabilities) { }
-    operator int() const { return value_; }
-
-    inline bool isNoSVMSupport() const { return value_ == 0; }
-    inline bool isSupportCoarseGrainBuffer() const { return (value_ & SVM_COARSE_GRAIN_BUFFER) != 0; }
-    inline bool isSupportFineGrainBuffer() const { return (value_ & SVM_FINE_GRAIN_BUFFER) != 0; }
-    inline bool isSupportFineGrainSystem() const { return (value_ & SVM_FINE_GRAIN_SYSTEM) != 0; }
-    inline bool isSupportAtomics() const { return (value_ & SVM_ATOMICS) != 0; }
-};
-
-CV_EXPORTS const SVMCapabilities getSVMCapabilitites(const ocl::Context& context);
-
-struct SVMFunctions
-{
-    clSVMAllocAMD_fn fn_clSVMAlloc;
-    clSVMFreeAMD_fn fn_clSVMFree;
-    clSetKernelArgSVMPointerAMD_fn fn_clSetKernelArgSVMPointer;
-    //clSetKernelExecInfoAMD_fn fn_clSetKernelExecInfo;
-    //clEnqueueSVMFreeAMD_fn fn_clEnqueueSVMFree;
-    clEnqueueSVMMemcpyAMD_fn fn_clEnqueueSVMMemcpy;
-    clEnqueueSVMMemFillAMD_fn fn_clEnqueueSVMMemFill;
-    clEnqueueSVMMapAMD_fn fn_clEnqueueSVMMap;
-    clEnqueueSVMUnmapAMD_fn fn_clEnqueueSVMUnmap;
-
-    inline SVMFunctions()
-        : fn_clSVMAlloc(NULL), fn_clSVMFree(NULL),
-          fn_clSetKernelArgSVMPointer(NULL), /*fn_clSetKernelExecInfo(NULL),*/
-          /*fn_clEnqueueSVMFree(NULL),*/ fn_clEnqueueSVMMemcpy(NULL), fn_clEnqueueSVMMemFill(NULL),
-          fn_clEnqueueSVMMap(NULL), fn_clEnqueueSVMUnmap(NULL)
-    {
-        // nothing
-    }
-
-    inline bool isValid() const
-    {
-        return fn_clSVMAlloc != NULL && fn_clSVMFree && fn_clSetKernelArgSVMPointer &&
-                /*fn_clSetKernelExecInfo && fn_clEnqueueSVMFree &&*/ fn_clEnqueueSVMMemcpy &&
-                fn_clEnqueueSVMMemFill && fn_clEnqueueSVMMap && fn_clEnqueueSVMUnmap;
-    }
-};
-
-// We should guarantee that SVMFunctions lifetime is not less than context's lifetime
-CV_EXPORTS const SVMFunctions* getSVMFunctions(const ocl::Context& context);
-
-CV_EXPORTS bool useSVM(UMatUsageFlags usageFlags);
-
-}}} //namespace cv::ocl::svm
-#endif
-
-#endif // OPENCV_CORE_OPENCL_SVM_HPP
-/* End of file. */