From bc4b1b25c84d4772aee0c1e62f11469e9eb1a63d Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 11:34:14 -0700 Subject: [PATCH 1/6] fix(r3d): enhance RED SDK initialization diagnostics and user search paths - Add user directory search paths for RED Redistributable libraries: - macOS: ~/Library/Application Support/OpenUTV/RED - Linux: ~/.local/share/openutv/red - Windows: %APPDATA%/OpenUTV/RED - Ensure R3DSDK::FinalizeSdk() is called upon any non-OK InitializeSdk() return - Provide detailed warning logs including enum descriptions when InitializeSdk fails - Explicitly warn if ISLibraryVersionMismatch (6) is encountered - Fix MovieIO preloader error logging to report filename instead of cleared string Signed-off-by: Michael Oliver --- src/lib/image/MovieRED/MovieRED.cpp | 82 +++++++++++++++++++++++++++++ src/lib/image/TwkMovie/MovieIO.cpp | 2 +- 2 files changed, 83 insertions(+), 1 deletion(-) diff --git a/src/lib/image/MovieRED/MovieRED.cpp b/src/lib/image/MovieRED/MovieRED.cpp index ebaae0d6..325230e2 100644 --- a/src/lib/image/MovieRED/MovieRED.cpp +++ b/src/lib/image/MovieRED/MovieRED.cpp @@ -62,6 +62,59 @@ namespace TwkMovie return ::stat(path.c_str(), &st) == 0; } + static const char* initializeStatusString(R3DSDK::InitializeStatus st) + { + switch (st) + { + case R3DSDK::ISInitializeOK: + return "OK"; + case R3DSDK::ISLibraryNotLoaded: + return "Library not loaded"; + case R3DSDK::ISR3DSDKLibraryNotFound: + return "R3DSDK library not found"; + case R3DSDK::ISRedCudaLibraryNotFound: + return "RedCuda library not found"; + case R3DSDK::ISRedOpenCLLibraryNotFound: + return "RedOpenCL library not found"; + case R3DSDK::ISR3DDecoderLibraryNotFound: + return "R3DDecoder library not found"; + case R3DSDK::ISRedMetalLibraryNotFound: + return "RedMetal library not found"; + case R3DSDK::ISLibraryVersionMismatch: + return "Library version mismatch (SDK and dynamic library versions must match)"; + case R3DSDK::ISInvalidR3DSDKLibrary: + return "Invalid R3DSDK library"; + case R3DSDK::ISInvalidRedCudaLibrary: + return "Invalid RedCuda library"; + case R3DSDK::ISInvalidRedOpenCLLibrary: + return "Invalid RedOpenCL library"; + case R3DSDK::ISInvalidR3DDecoderLibrary: + return "Invalid R3DDecoder library"; + case R3DSDK::ISInvalidRedMetalLibrary: + return "Invalid RedMetal library"; + case R3DSDK::ISRedCudaLibraryInitializeFailed: + return "RedCuda initialization failed"; + case R3DSDK::ISRedOpenCLLibraryInitializeFailed: + return "RedOpenCL initialization failed"; + case R3DSDK::ISR3DDecoderLibraryInitializeFailed: + return "R3DDecoder initialization failed"; + case R3DSDK::ISR3DSDKLibraryInitializeFailed: + return "R3DSDK library initialization failed"; + case R3DSDK::ISRedMetalLibraryInitializeFailed: + return "RedMetal initialization failed"; + case R3DSDK::ISInvalidPath: + return "Invalid path"; + case R3DSDK::ISInternalError: + return "Internal error"; + case R3DSDK::ISMetalNotAvailable: + return "Metal not available"; + case R3DSDK::ISCudaNotAvailable: + return "CUDA not available"; + default: + return "Unknown status"; + } + } + static bool ensureREDInitialized() { std::lock_guard lock(s_redInitMutex); @@ -75,6 +128,21 @@ namespace TwkMovie if (const char* envPath = getenv("R3DSDK_DIR")) searchDirs.push_back(envPath); + if (const char* home = getenv("HOME")) + { +#if defined(__APPLE__) + searchDirs.push_back(std::string(home) + "/Library/Application Support/OpenUTV/RED"); +#elif defined(__linux__) + searchDirs.push_back(std::string(home) + "/.local/share/openutv/red"); +#endif + } +#if defined(_WIN32) + if (const char* appData = getenv("APPDATA")) + { + searchDirs.push_back(std::string(appData) + "\\OpenUTV\\RED"); + } +#endif + #if defined(__APPLE__) char execPath[1024]; uint32_t size = sizeof(execPath); @@ -145,6 +213,7 @@ namespace TwkMovie R3DSDK::InitializeStatus st = R3DSDK::InitializeSdk(dir.c_str(), options); if (st != R3DSDK::ISInitializeOK && options != OPTION_RED_NONE) { + R3DSDK::FinalizeSdk(); st = R3DSDK::InitializeSdk(dir.c_str(), OPTION_RED_NONE); options = OPTION_RED_NONE; } @@ -161,6 +230,19 @@ namespace TwkMovie #endif return true; } + else + { + std::cerr << "WARNING: Found RED dynamic library in " << dir << ", but InitializeSdk failed (" << st << ": " + << initializeStatusString(st) << ")" << std::endl; + if (st == R3DSDK::ISLibraryVersionMismatch) + { + std::cerr << "WARNING: OpenUTV was built against R3D SDK 9.2.1. The dynamic library in '" << dir + << "' is an incompatible version. " + << "Set RED_SDK_PATH or place R3D SDK 9.2.1 Redistributable libraries in application search paths." + << std::endl; + } + R3DSDK::FinalizeSdk(); + } } } diff --git a/src/lib/image/TwkMovie/MovieIO.cpp b/src/lib/image/TwkMovie/MovieIO.cpp index 1766188d..f56433eb 100644 --- a/src/lib/image/TwkMovie/MovieIO.cpp +++ b/src/lib/image/TwkMovie/MovieIO.cpp @@ -291,7 +291,7 @@ namespace TwkMovie } else { - std::cerr << "PRELOADER READ ERROR: " << reader->filename() << std::endl; + std::cerr << "PRELOADER READ ERROR: " << filename << std::endl; } return movieReader; From da0bf9cd7d4aa6b3f24877ad4aafbb7604d282c2 Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 11:46:04 -0700 Subject: [PATCH 2/6] feat(r3d): probe dynamic RED library version and provide actionable user notifications - Add cross-platform probeREDLibraryVersion() using LoadLibrary/dlopen to query RED_LIB_MAJOR_VERSION, RED_LIB_MINOR_VERSION, and RED_MINIMUM_MINOR_VERSION - Explicitly notify user if installed RED PLAYER is older than required (9.2.1+) with a prompt to update RED PLAYER from red.com/downloads - Inform user if installed RED PLAYER is newer (such as 9.3.0) with ABI mismatch - Surface detailed diagnostics directly into MovieRED preloadOpen IOException Signed-off-by: Michael Oliver --- src/lib/image/MovieRED/MovieRED.cpp | 115 ++++++++++++++++++++++++++-- 1 file changed, 108 insertions(+), 7 deletions(-) diff --git a/src/lib/image/MovieRED/MovieRED.cpp b/src/lib/image/MovieRED/MovieRED.cpp index 325230e2..ebea7a88 100644 --- a/src/lib/image/MovieRED/MovieRED.cpp +++ b/src/lib/image/MovieRED/MovieRED.cpp @@ -35,10 +35,12 @@ #include #if defined(__APPLE__) +#include #include #elif defined(_WIN32) #include #elif defined(__linux__) +#include #include #endif @@ -115,6 +117,69 @@ namespace TwkMovie } } + struct REDLibVersion + { + bool valid = false; + unsigned int major = 0; + unsigned int minor = 0; + unsigned int patch = 0; + unsigned int minMajor = 0; + unsigned int minMinor = 0; + }; + + static REDLibVersion probeREDLibraryVersion(const std::string& libraryPath) + { + REDLibVersion v; +#if defined(_WIN32) + HMODULE handle = LoadLibraryExA(libraryPath.c_str(), NULL, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS); + if (!handle) + handle = LoadLibraryA(libraryPath.c_str()); + if (handle) + { + typedef unsigned int (*VersionFn)(); + VersionFn fnMajor = (VersionFn)GetProcAddress(handle, "RED_LIB_MAJOR_VERSION"); + VersionFn fnMinor = (VersionFn)GetProcAddress(handle, "RED_LIB_MINOR_VERSION"); + VersionFn fnPatch = (VersionFn)GetProcAddress(handle, "RED_LIB_PATCH_VERSION"); + VersionFn fnMinMajor = (VersionFn)GetProcAddress(handle, "RED_MINIMUM_MAJOR_VERSION"); + VersionFn fnMinMinor = (VersionFn)GetProcAddress(handle, "RED_MINIMUM_MINOR_VERSION"); + if (fnMajor && fnMinor) + { + v.valid = true; + v.major = fnMajor(); + v.minor = fnMinor(); + v.patch = fnPatch ? fnPatch() : 0; + v.minMajor = fnMinMajor ? fnMinMajor() : 0; + v.minMinor = fnMinMinor ? fnMinMinor() : 0; + } + FreeLibrary(handle); + } +#else + void* handle = dlopen(libraryPath.c_str(), RTLD_LAZY | RTLD_LOCAL); + if (handle) + { + typedef unsigned int (*VersionFn)(); + VersionFn fnMajor = (VersionFn)dlsym(handle, "RED_LIB_MAJOR_VERSION"); + VersionFn fnMinor = (VersionFn)dlsym(handle, "RED_LIB_MINOR_VERSION"); + VersionFn fnPatch = (VersionFn)dlsym(handle, "RED_LIB_PATCH_VERSION"); + VersionFn fnMinMajor = (VersionFn)dlsym(handle, "RED_MINIMUM_MAJOR_VERSION"); + VersionFn fnMinMinor = (VersionFn)dlsym(handle, "RED_MINIMUM_MINOR_VERSION"); + if (fnMajor && fnMinor) + { + v.valid = true; + v.major = fnMajor(); + v.minor = fnMinor(); + v.patch = fnPatch ? fnPatch() : 0; + v.minMajor = fnMinMajor ? fnMinMajor() : 0; + v.minMinor = fnMinMinor ? fnMinMinor() : 0; + } + dlclose(handle); + } +#endif + return v; + } + + static std::string s_lastREDInitError; + static bool ensureREDInitialized() { std::lock_guard lock(s_redInitMutex); @@ -205,6 +270,20 @@ namespace TwkMovie std::string fullPath = dir + "/" + targetLib; if (fileExists(fullPath)) { + REDLibVersion ver = probeREDLibraryVersion(fullPath); + if (ver.valid) + { + if (ver.major < 9 || (ver.major == 9 && ver.minor < 2)) + { + std::string msg = + "Found RED dynamic library in '" + dir + "' (version " + std::to_string(ver.major) + "." + + std::to_string(ver.minor) + "." + std::to_string(ver.patch) + + "), which is older than required (9.2.1+). Please update RED PLAYER from https://www.red.com/downloads."; + std::cerr << "WARNING: " << msg << std::endl; + s_lastREDInitError = msg; + } + } + #if defined(__APPLE__) unsigned int options = OPTION_RED_METAL; #else @@ -228,18 +307,32 @@ namespace TwkMovie REDMetalGpu::init(dir.c_str()); } #endif + s_lastREDInitError.clear(); return true; } else { std::cerr << "WARNING: Found RED dynamic library in " << dir << ", but InitializeSdk failed (" << st << ": " << initializeStatusString(st) << ")" << std::endl; - if (st == R3DSDK::ISLibraryVersionMismatch) + if (st == R3DSDK::ISLibraryVersionMismatch || st == R3DSDK::ISInvalidR3DSDKLibrary) { - std::cerr << "WARNING: OpenUTV was built against R3D SDK 9.2.1. The dynamic library in '" << dir - << "' is an incompatible version. " - << "Set RED_SDK_PATH or place R3D SDK 9.2.1 Redistributable libraries in application search paths." - << std::endl; + if (ver.valid && (ver.major > 9 || (ver.major == 9 && ver.minor > 2))) + { + std::string msg = + "Installed RED library in '" + dir + "' is version " + std::to_string(ver.major) + "." + + std::to_string(ver.minor) + "." + std::to_string(ver.patch) + + " (newer than UTV's R3D SDK 9.2.1). Dynamic ABI mismatch detected. " + "Please place R3D SDK 9.2.1 Redistributables in application search paths or set RED_SDK_PATH."; + std::cerr << "WARNING: " << msg << std::endl; + s_lastREDInitError = msg; + } + else + { + std::cerr << "WARNING: OpenUTV was built against R3D SDK 9.2.1. The dynamic library in '" << dir + << "' is an incompatible version. " + << "Set RED_SDK_PATH or place R3D SDK 9.2.1 Redistributable libraries in application search paths." + << std::endl; + } } R3DSDK::FinalizeSdk(); } @@ -325,8 +418,16 @@ namespace TwkMovie { if (!ensureREDInitialized()) { - TWK_THROW_STREAM(IOException, "Cannot open RED file: RED dynamic libraries (REDR3D) not found. " - "Please install RED PLAYER from https://www.red.com/downloads or set RED_SDK_PATH."); + std::string err = "Cannot open RED file: Compatible RED dynamic libraries (REDR3D) not found."; + if (!s_lastREDInitError.empty()) + { + err += " " + s_lastREDInitError; + } + else + { + err += " Please install RED PLAYER from https://www.red.com/downloads or set RED_SDK_PATH."; + } + TWK_THROW_STREAM(IOException, err); } m_filename = filename; From 801fafab0304214738fc21e9fc7c0f24cb87343e Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 12:19:04 -0700 Subject: [PATCH 3/6] ci: restore ditto archive packaging for macOS and archives for Windows/Linux - Restore ditto -c -k --keepParent to ensure macOS .app bundle integrity and structure - Restore zip/tar.gz packaging for Windows and Linux artifacts Signed-off-by: Michael Oliver --- .github/workflows/branch-build.yml | 31 +++++++++++++++++++++++++----- 1 file changed, 26 insertions(+), 5 deletions(-) diff --git a/.github/workflows/branch-build.yml b/.github/workflows/branch-build.yml index ff34993d..ecfa35a7 100644 --- a/.github/workflows/branch-build.yml +++ b/.github/workflows/branch-build.yml @@ -122,17 +122,22 @@ jobs: path: ~/.ccache key: ${{ runner.os }}-ccache-${{ github.sha }} - - name: Sign Ad-Hoc App + - name: Package Ad-Hoc Signed App run: | python3 "${PWD}/src/build/sanitize_homebrew_links.py" "_build/stage/app/UTV.app" || true codesign --force --deep --sign - "_build/stage/app/UTV.app" + mkdir -p _dist + SHORT_SHA=$(git rev-parse --short=7 HEAD) + SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr '/' '-') + cd _build/stage/app + ditto -c -k --keepParent UTV.app "${GITHUB_WORKSPACE}/_dist/UTV-${SAFE_BRANCH}-${SHORT_SHA}-macOS-arm64.zip" shell: bash - name: Upload macOS Branch Artifact uses: actions/upload-artifact@v7 with: name: UTV-macOS-arm64 - path: _build/stage/app/UTV.app + path: _dist/*.zip retention-days: 5 build-windows: @@ -162,16 +167,21 @@ jobs: with: version: 'dev' - - name: Stage Windows Branch Directory + - name: Package Windows Branch Archive shell: powershell run: | + $ShortSha = git rev-parse --short=7 HEAD + $SafeBranch = "${{ github.ref_name }}".Replace("/", "-") + $ZipName = "UTV-$SafeBranch-$ShortSha-windows-x64.zip" + New-Item -ItemType Directory -Force -Path "_dist" | Out-Null Rename-Item -Path "_install" -NewName "utv-windows-x64" + Compress-Archive -Path "utv-windows-x64" -DestinationPath "_dist\$ZipName" -CompressionLevel Optimal - name: Upload Windows Branch Artifact uses: actions/upload-artifact@v7 with: name: UTV-windows-x64 - path: utv-windows-x64 + path: _dist/*.zip retention-days: 5 build-linux: @@ -255,11 +265,22 @@ jobs: path: ~/.ccache key: ${{ runner.os }}-ccache-${{ github.sha }} + - name: Package Linux Branch Archive + if: success() + run: | + mkdir -p _dist + SHORT_SHA=$(git rev-parse --short=7 HEAD) + SAFE_BRANCH=$(echo "${{ github.ref_name }}" | tr '/' '-') + if [ -d "_build/stage/app" ]; then + tar -czf "_dist/UTV-${SAFE_BRANCH}-${SHORT_SHA}-linux-x64.tar.gz" -C _build/stage/app . + fi + shell: bash + - name: Upload Linux Branch Artifact if: success() uses: actions/upload-artifact@v7 with: name: UTV-linux-x64 - path: _build/stage/app + path: _dist/*.tar.gz retention-days: 5 From c6752facb57dba6b2ea3ca6f48f48343c22fbdbd Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 12:49:11 -0700 Subject: [PATCH 4/6] feat(r3d): group controls under Image > RED and auto-enable GPU acceleration when supported Signed-off-by: Michael Oliver --- .../rv-packages/r3d_settings/r3d_settings.py | 116 ++++++++++++++++-- 1 file changed, 107 insertions(+), 9 deletions(-) diff --git a/src/plugins/rv-packages/r3d_settings/r3d_settings.py b/src/plugins/rv-packages/r3d_settings/r3d_settings.py index ceebfbd5..60e182b6 100644 --- a/src/plugins/rv-packages/r3d_settings/r3d_settings.py +++ b/src/plugins/rv-packages/r3d_settings/r3d_settings.py @@ -3,27 +3,124 @@ # SPDX-License-Identifier: Apache-2.0 # +import ctypes +import os +import sys + from rv import commands as rvc from rv import extra_commands as rve from rv import rvtypes as rvt +_gpu_supported_cache = None + + +def isGPUSupported(): + """ + Check whether hardware-accelerated RED GPU debayering is supported on this system. + Returns True if supported, False otherwise. + """ + global _gpu_supported_cache + if _gpu_supported_cache is not None: + return _gpu_supported_cache + + if sys.platform != "darwin": + # Currently, hardware RED debayering in MovieRED is Metal-accelerated on macOS. + # CUDA / OpenCL debayering on Windows/Linux will be detected here once enabled. + _gpu_supported_cache = False + return False + + # 1. Check for Metal hardware capability via Metal framework + try: + metal = ctypes.cdll.LoadLibrary("/System/Library/Frameworks/Metal.framework/Metal") + metal.MTLCreateSystemDefaultDevice.restype = ctypes.c_void_p + dev = metal.MTLCreateSystemDefaultDevice() + if not dev: + _gpu_supported_cache = False + return False + except Exception: + _gpu_supported_cache = False + return False + + # 2. Check for REDMetal dynamic library in known search paths + search_dirs = [] + if os.environ.get("RED_SDK_PATH"): + search_dirs.append(os.environ["RED_SDK_PATH"]) + if os.environ.get("R3DSDK_DIR"): + search_dirs.append(os.environ["R3DSDK_DIR"]) + + try: + exe_dir = os.path.dirname(os.path.abspath(sys.executable)) + search_dirs.append(exe_dir) + search_dirs.append(os.path.join(exe_dir, "..", "PlugIns", "MovieFormats")) + search_dirs.append(os.path.join(exe_dir, "..", "Frameworks")) + search_dirs.append(os.path.join(exe_dir, "..", "lib")) + except Exception: + pass + + home = os.path.expanduser("~") + search_dirs.append(os.path.join(home, "Library", "Application Support", "OpenUTV", "RED")) + search_dirs.append(os.path.join(home, "Library", "Application Support", "RED")) + search_dirs.append(os.path.join(home, ".local", "share", "openutv", "red")) + + search_dirs.extend( + [ + "/Applications/REDCINE-X Professional/RED PLAYER.app/Contents/MacOS", + "/Applications/REDCINE-X Professional/REDCINE-X PRO.app/Contents/MacOS", + "/Applications/RED PLAYER.app/Contents/MacOS", + "/Applications/REDCINE-X PRO/REDCINE-X PRO.app/Contents/MacOS", + "/Applications/REDCINE-X PRO/REDCINE-X PRO.app/Contents/Frameworks", + "/Library/Application Support/RED", + "/usr/local/lib", + "/opt/homebrew/lib", + ] + ) + + for d in search_dirs: + dylib_path = os.path.join(d, "REDMetal.dylib") + if os.path.isfile(dylib_path): + _gpu_supported_cache = True + return True + + _gpu_supported_cache = False + return False + + class R3DSettingsMinorMode(rvt.MinorMode): """ MinorMode providing interactive multi-resolution wavelet decoding - and GPU acceleration controls for RED R3D media. + and GPU acceleration controls for RED R3D media under Image > RED. """ def __init__(self): super().__init__() + # Out-of-the-box automatic GPU acceleration configuration: + # If the host system supports RED GPU debayering and the setting has not + # yet been configured, enable it by default for the best playback performance. + if isGPUSupported(): + try: + configured = bool(rvc.readSettings("R3D", "gpu_acceleration_configured", False)) + if not configured: + rvc.writeSettings("R3D", "gpu_acceleration", True) + rvc.writeSettings("R3D", "gpu_acceleration_configured", True) + except Exception: + pass + menu = [ ( "Image", [ ( - "RED (R3D) Wavelet Resolution", + "RED", [ + ( + "GPU Acceleration", + self.toggleGPU, + None, + self.gpuState, + ), + ("_", None), ( "Full Resolution (1:1)", lambda e: self.setResolution("full"), @@ -48,13 +145,6 @@ def __init__(self): None, lambda: self.resolutionState("eighth"), ), - ("_", None), - ( - "GPU Acceleration", - self.toggleGPU, - None, - self.gpuState, - ), ], ) ], @@ -95,15 +185,21 @@ def resolutionState(self, res): return rvc.UncheckedMenuState def isGPUEnabled(self): + if not isGPUSupported(): + return False try: return bool(rvc.readSettings("R3D", "gpu_acceleration", True)) except Exception: return True def toggleGPU(self, event=None): + if not isGPUSupported(): + rve.displayFeedback("RED GPU Acceleration: Not supported on this system", 3.0) + return try: new_val = not self.isGPUEnabled() rvc.writeSettings("R3D", "gpu_acceleration", new_val) + rvc.writeSettings("R3D", "gpu_acceleration_configured", True) self._reloadR3DSources() rvc.reload() state_str = "Enabled" if new_val else "Disabled" @@ -112,6 +208,8 @@ def toggleGPU(self, event=None): print(f"ERROR: Failed to toggle RED GPU acceleration: {e}") def gpuState(self): + if not isGPUSupported(): + return rvc.DisabledMenuState if self.isGPUEnabled(): return rvc.CheckedMenuState return rvc.UncheckedMenuState From de7ced7bd271000b99dd3136afe950f66a1e06fa Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 12:57:52 -0700 Subject: [PATCH 5/6] feat(r3d): add cross-platform OpenCL GPU debayering for Windows and Linux Signed-off-by: Michael Oliver --- src/lib/image/MovieRED/CL/cl.h | 987 +++++++++++ src/lib/image/MovieRED/CL/cl_platform.h | 1552 +++++++++++++++++ src/lib/image/MovieRED/CL/opencl.h | 54 + src/lib/image/MovieRED/CMakeLists.txt | 2 +- src/lib/image/MovieRED/MovieRED.cpp | 19 +- src/lib/image/MovieRED/MovieRED/MovieREDGpu.h | 33 + .../image/MovieRED/MovieRED/MovieREDOpenCL.h | 33 + src/lib/image/MovieRED/MovieREDGpu.cpp | 71 + src/lib/image/MovieRED/MovieREDOpenCL.cpp | 464 +++++ .../rv-packages/r3d_settings/r3d_settings.py | 77 +- 10 files changed, 3259 insertions(+), 33 deletions(-) create mode 100644 src/lib/image/MovieRED/CL/cl.h create mode 100644 src/lib/image/MovieRED/CL/cl_platform.h create mode 100644 src/lib/image/MovieRED/CL/opencl.h create mode 100644 src/lib/image/MovieRED/MovieRED/MovieREDGpu.h create mode 100644 src/lib/image/MovieRED/MovieRED/MovieREDOpenCL.h create mode 100644 src/lib/image/MovieRED/MovieREDGpu.cpp create mode 100644 src/lib/image/MovieRED/MovieREDOpenCL.cpp diff --git a/src/lib/image/MovieRED/CL/cl.h b/src/lib/image/MovieRED/CL/cl.h new file mode 100644 index 00000000..65975bf0 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl.h @@ -0,0 +1,987 @@ +/******************************************************************************* + * Copyright (c) 2011 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +#ifndef __OPENCL_CL_H +#define __OPENCL_CL_H + +#ifdef __APPLE__ +#include +#else +#include +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + + /******************************************************************************/ + + typedef struct _cl_platform_id* cl_platform_id; + typedef struct _cl_device_id* cl_device_id; + typedef struct _cl_context* cl_context; + typedef struct _cl_command_queue* cl_command_queue; + typedef struct _cl_mem* cl_mem; + typedef struct _cl_program* cl_program; + typedef struct _cl_kernel* cl_kernel; + typedef struct _cl_event* cl_event; + typedef struct _cl_sampler* cl_sampler; + + typedef cl_uint + cl_bool; /* WARNING! Unlike cl_ types in cl_platform.h, cl_bool is not guaranteed to be the same size as the bool in kernels. */ + typedef cl_ulong cl_bitfield; + typedef cl_bitfield cl_device_type; + typedef cl_uint cl_platform_info; + typedef cl_uint cl_device_info; + typedef cl_bitfield cl_device_fp_config; + typedef cl_uint cl_device_mem_cache_type; + typedef cl_uint cl_device_local_mem_type; + typedef cl_bitfield cl_device_exec_capabilities; + typedef cl_bitfield cl_command_queue_properties; + typedef intptr_t cl_device_partition_property; + typedef cl_bitfield cl_device_affinity_domain; + + typedef intptr_t cl_context_properties; + typedef cl_uint cl_context_info; + typedef cl_uint cl_command_queue_info; + typedef cl_uint cl_channel_order; + typedef cl_uint cl_channel_type; + typedef cl_bitfield cl_mem_flags; + typedef cl_uint cl_mem_object_type; + typedef cl_uint cl_mem_info; + typedef cl_bitfield cl_mem_migration_flags; + typedef cl_uint cl_image_info; + typedef cl_uint cl_buffer_create_type; + typedef cl_uint cl_addressing_mode; + typedef cl_uint cl_filter_mode; + typedef cl_uint cl_sampler_info; + typedef cl_bitfield cl_map_flags; + typedef cl_uint cl_program_info; + typedef cl_uint cl_program_build_info; + typedef cl_uint cl_program_binary_type; + typedef cl_int cl_build_status; + typedef cl_uint cl_kernel_info; + typedef cl_uint cl_kernel_arg_info; + typedef cl_uint cl_kernel_arg_address_qualifier; + typedef cl_uint cl_kernel_arg_access_qualifier; + typedef cl_bitfield cl_kernel_arg_type_qualifier; + typedef cl_uint cl_kernel_work_group_info; + typedef cl_uint cl_event_info; + typedef cl_uint cl_command_type; + typedef cl_uint cl_profiling_info; + + typedef struct _cl_image_format + { + cl_channel_order image_channel_order; + cl_channel_type image_channel_data_type; + } cl_image_format; + + typedef struct _cl_image_desc + { + cl_mem_object_type image_type; + size_t image_width; + size_t image_height; + size_t image_depth; + size_t image_array_size; + size_t image_row_pitch; + size_t image_slice_pitch; + cl_uint num_mip_levels; + cl_uint num_samples; + cl_mem buffer; + } cl_image_desc; + + typedef struct _cl_buffer_region + { + size_t origin; + size_t size; + } cl_buffer_region; + +/******************************************************************************/ + +/* Error Codes */ +#define CL_SUCCESS 0 +#define CL_DEVICE_NOT_FOUND -1 +#define CL_DEVICE_NOT_AVAILABLE -2 +#define CL_COMPILER_NOT_AVAILABLE -3 +#define CL_MEM_OBJECT_ALLOCATION_FAILURE -4 +#define CL_OUT_OF_RESOURCES -5 +#define CL_OUT_OF_HOST_MEMORY -6 +#define CL_PROFILING_INFO_NOT_AVAILABLE -7 +#define CL_MEM_COPY_OVERLAP -8 +#define CL_IMAGE_FORMAT_MISMATCH -9 +#define CL_IMAGE_FORMAT_NOT_SUPPORTED -10 +#define CL_BUILD_PROGRAM_FAILURE -11 +#define CL_MAP_FAILURE -12 +#define CL_MISALIGNED_SUB_BUFFER_OFFSET -13 +#define CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST -14 +#define CL_COMPILE_PROGRAM_FAILURE -15 +#define CL_LINKER_NOT_AVAILABLE -16 +#define CL_LINK_PROGRAM_FAILURE -17 +#define CL_DEVICE_PARTITION_FAILED -18 +#define CL_KERNEL_ARG_INFO_NOT_AVAILABLE -19 + +#define CL_INVALID_VALUE -30 +#define CL_INVALID_DEVICE_TYPE -31 +#define CL_INVALID_PLATFORM -32 +#define CL_INVALID_DEVICE -33 +#define CL_INVALID_CONTEXT -34 +#define CL_INVALID_QUEUE_PROPERTIES -35 +#define CL_INVALID_COMMAND_QUEUE -36 +#define CL_INVALID_HOST_PTR -37 +#define CL_INVALID_MEM_OBJECT -38 +#define CL_INVALID_IMAGE_FORMAT_DESCRIPTOR -39 +#define CL_INVALID_IMAGE_SIZE -40 +#define CL_INVALID_SAMPLER -41 +#define CL_INVALID_BINARY -42 +#define CL_INVALID_BUILD_OPTIONS -43 +#define CL_INVALID_PROGRAM -44 +#define CL_INVALID_PROGRAM_EXECUTABLE -45 +#define CL_INVALID_KERNEL_NAME -46 +#define CL_INVALID_KERNEL_DEFINITION -47 +#define CL_INVALID_KERNEL -48 +#define CL_INVALID_ARG_INDEX -49 +#define CL_INVALID_ARG_VALUE -50 +#define CL_INVALID_ARG_SIZE -51 +#define CL_INVALID_KERNEL_ARGS -52 +#define CL_INVALID_WORK_DIMENSION -53 +#define CL_INVALID_WORK_GROUP_SIZE -54 +#define CL_INVALID_WORK_ITEM_SIZE -55 +#define CL_INVALID_GLOBAL_OFFSET -56 +#define CL_INVALID_EVENT_WAIT_LIST -57 +#define CL_INVALID_EVENT -58 +#define CL_INVALID_OPERATION -59 +#define CL_INVALID_GL_OBJECT -60 +#define CL_INVALID_BUFFER_SIZE -61 +#define CL_INVALID_MIP_LEVEL -62 +#define CL_INVALID_GLOBAL_WORK_SIZE -63 +#define CL_INVALID_PROPERTY -64 +#define CL_INVALID_IMAGE_DESCRIPTOR -65 +#define CL_INVALID_COMPILER_OPTIONS -66 +#define CL_INVALID_LINKER_OPTIONS -67 +#define CL_INVALID_DEVICE_PARTITION_COUNT -68 + +/* OpenCL Version */ +#define CL_VERSION_1_0 1 +#define CL_VERSION_1_1 1 +#define CL_VERSION_1_2 1 + +/* cl_bool */ +#define CL_FALSE 0 +#define CL_TRUE 1 +#define CL_BLOCKING CL_TRUE +#define CL_NON_BLOCKING CL_FALSE + +/* cl_platform_info */ +#define CL_PLATFORM_PROFILE 0x0900 +#define CL_PLATFORM_VERSION 0x0901 +#define CL_PLATFORM_NAME 0x0902 +#define CL_PLATFORM_VENDOR 0x0903 +#define CL_PLATFORM_EXTENSIONS 0x0904 + +/* cl_device_type - bitfield */ +#define CL_DEVICE_TYPE_DEFAULT (1 << 0) +#define CL_DEVICE_TYPE_CPU (1 << 1) +#define CL_DEVICE_TYPE_GPU (1 << 2) +#define CL_DEVICE_TYPE_ACCELERATOR (1 << 3) +#define CL_DEVICE_TYPE_CUSTOM (1 << 4) +// +#if defined(WITH_HSA_BACKEND) +#define CL_DEVICE_TYPE_FSA (1 << 5) +#endif +// +#define CL_DEVICE_TYPE_ALL 0xFFFFFFFF + +/* cl_device_info */ +#define CL_DEVICE_TYPE 0x1000 +#define CL_DEVICE_VENDOR_ID 0x1001 +#define CL_DEVICE_MAX_COMPUTE_UNITS 0x1002 +#define CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS 0x1003 +#define CL_DEVICE_MAX_WORK_GROUP_SIZE 0x1004 +#define CL_DEVICE_MAX_WORK_ITEM_SIZES 0x1005 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR 0x1006 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT 0x1007 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT 0x1008 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG 0x1009 +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT 0x100A +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE 0x100B +#define CL_DEVICE_MAX_CLOCK_FREQUENCY 0x100C +#define CL_DEVICE_ADDRESS_BITS 0x100D +#define CL_DEVICE_MAX_READ_IMAGE_ARGS 0x100E +#define CL_DEVICE_MAX_WRITE_IMAGE_ARGS 0x100F +#define CL_DEVICE_MAX_MEM_ALLOC_SIZE 0x1010 +#define CL_DEVICE_IMAGE2D_MAX_WIDTH 0x1011 +#define CL_DEVICE_IMAGE2D_MAX_HEIGHT 0x1012 +#define CL_DEVICE_IMAGE3D_MAX_WIDTH 0x1013 +#define CL_DEVICE_IMAGE3D_MAX_HEIGHT 0x1014 +#define CL_DEVICE_IMAGE3D_MAX_DEPTH 0x1015 +#define CL_DEVICE_IMAGE_SUPPORT 0x1016 +#define CL_DEVICE_MAX_PARAMETER_SIZE 0x1017 +#define CL_DEVICE_MAX_SAMPLERS 0x1018 +#define CL_DEVICE_MEM_BASE_ADDR_ALIGN 0x1019 +#define CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE 0x101A +#define CL_DEVICE_SINGLE_FP_CONFIG 0x101B +#define CL_DEVICE_GLOBAL_MEM_CACHE_TYPE 0x101C +#define CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE 0x101D +#define CL_DEVICE_GLOBAL_MEM_CACHE_SIZE 0x101E +#define CL_DEVICE_GLOBAL_MEM_SIZE 0x101F +#define CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE 0x1020 +#define CL_DEVICE_MAX_CONSTANT_ARGS 0x1021 +#define CL_DEVICE_LOCAL_MEM_TYPE 0x1022 +#define CL_DEVICE_LOCAL_MEM_SIZE 0x1023 +#define CL_DEVICE_ERROR_CORRECTION_SUPPORT 0x1024 +#define CL_DEVICE_PROFILING_TIMER_RESOLUTION 0x1025 +#define CL_DEVICE_ENDIAN_LITTLE 0x1026 +#define CL_DEVICE_AVAILABLE 0x1027 +#define CL_DEVICE_COMPILER_AVAILABLE 0x1028 +#define CL_DEVICE_EXECUTION_CAPABILITIES 0x1029 +#define CL_DEVICE_QUEUE_PROPERTIES 0x102A +#define CL_DEVICE_NAME 0x102B +#define CL_DEVICE_VENDOR 0x102C +#define CL_DRIVER_VERSION 0x102D +#define CL_DEVICE_PROFILE 0x102E +#define CL_DEVICE_VERSION 0x102F +#define CL_DEVICE_EXTENSIONS 0x1030 +#define CL_DEVICE_PLATFORM 0x1031 +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 +/* 0x1033 reserved for CL_DEVICE_HALF_FP_CONFIG */ +#define CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF 0x1034 +#define CL_DEVICE_HOST_UNIFIED_MEMORY 0x1035 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR 0x1036 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT 0x1037 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_INT 0x1038 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG 0x1039 +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT 0x103A +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE 0x103B +#define CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF 0x103C +#define CL_DEVICE_OPENCL_C_VERSION 0x103D +#define CL_DEVICE_LINKER_AVAILABLE 0x103E +#define CL_DEVICE_BUILT_IN_KERNELS 0x103F +#define CL_DEVICE_IMAGE_MAX_BUFFER_SIZE 0x1040 +#define CL_DEVICE_IMAGE_MAX_ARRAY_SIZE 0x1041 +#define CL_DEVICE_PARENT_DEVICE 0x1042 +#define CL_DEVICE_PARTITION_MAX_SUB_DEVICES 0x1043 +#define CL_DEVICE_PARTITION_PROPERTIES 0x1044 +#define CL_DEVICE_PARTITION_AFFINITY_DOMAIN 0x1045 +#define CL_DEVICE_PARTITION_TYPE 0x1046 +#define CL_DEVICE_REFERENCE_COUNT 0x1047 +#define CL_DEVICE_PREFERRED_INTEROP_USER_SYNC 0x1048 +#define CL_DEVICE_PRINTF_BUFFER_SIZE 0x1049 + +/* cl_device_fp_config - bitfield */ +#define CL_FP_DENORM (1 << 0) +#define CL_FP_INF_NAN (1 << 1) +#define CL_FP_ROUND_TO_NEAREST (1 << 2) +#define CL_FP_ROUND_TO_ZERO (1 << 3) +#define CL_FP_ROUND_TO_INF (1 << 4) +#define CL_FP_FMA (1 << 5) +#define CL_FP_SOFT_FLOAT (1 << 6) +#define CL_FP_CORRECTLY_ROUNDED_DIVIDE_SQRT (1 << 7) + +/* cl_device_mem_cache_type */ +#define CL_NONE 0x0 +#define CL_READ_ONLY_CACHE 0x1 +#define CL_READ_WRITE_CACHE 0x2 + +/* cl_device_local_mem_type */ +#define CL_LOCAL 0x1 +#define CL_GLOBAL 0x2 + +/* cl_device_exec_capabilities - bitfield */ +#define CL_EXEC_KERNEL (1 << 0) +#define CL_EXEC_NATIVE_KERNEL (1 << 1) + +/* cl_command_queue_properties - bitfield */ +#define CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE (1 << 0) +#define CL_QUEUE_PROFILING_ENABLE (1 << 1) + +/* cl_context_info */ +#define CL_CONTEXT_REFERENCE_COUNT 0x1080 +#define CL_CONTEXT_DEVICES 0x1081 +#define CL_CONTEXT_PROPERTIES 0x1082 +#define CL_CONTEXT_NUM_DEVICES 0x1083 + +/* cl_context_properties */ +#define CL_CONTEXT_PLATFORM 0x1084 +#define CL_CONTEXT_INTEROP_USER_SYNC 0x1085 + +/* cl_device_partition_property */ +#define CL_DEVICE_PARTITION_EQUALLY 0x1086 +#define CL_DEVICE_PARTITION_BY_COUNTS 0x1087 +#define CL_DEVICE_PARTITION_BY_COUNTS_LIST_END 0x0 +#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN 0x1088 + +/* cl_device_affinity_domain */ +#define CL_DEVICE_AFFINITY_DOMAIN_NUMA (1 << 0) +#define CL_DEVICE_AFFINITY_DOMAIN_L4_CACHE (1 << 1) +#define CL_DEVICE_AFFINITY_DOMAIN_L3_CACHE (1 << 2) +#define CL_DEVICE_AFFINITY_DOMAIN_L2_CACHE (1 << 3) +#define CL_DEVICE_AFFINITY_DOMAIN_L1_CACHE (1 << 4) +#define CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE (1 << 5) + +/* cl_command_queue_info */ +#define CL_QUEUE_CONTEXT 0x1090 +#define CL_QUEUE_DEVICE 0x1091 +#define CL_QUEUE_REFERENCE_COUNT 0x1092 +#define CL_QUEUE_PROPERTIES 0x1093 + +/* cl_mem_flags - bitfield */ +#define CL_MEM_READ_WRITE (1 << 0) +#define CL_MEM_WRITE_ONLY (1 << 1) +#define CL_MEM_READ_ONLY (1 << 2) +#define CL_MEM_USE_HOST_PTR (1 << 3) +#define CL_MEM_ALLOC_HOST_PTR (1 << 4) +#define CL_MEM_COPY_HOST_PTR (1 << 5) +// reserved (1 << 6) +#define CL_MEM_HOST_WRITE_ONLY (1 << 7) +#define CL_MEM_HOST_READ_ONLY (1 << 8) +#define CL_MEM_HOST_NO_ACCESS (1 << 9) + +/* cl_mem_migration_flags - bitfield */ +#define CL_MIGRATE_MEM_OBJECT_HOST (1 << 0) +#define CL_MIGRATE_MEM_OBJECT_CONTENT_UNDEFINED (1 << 1) + +/* cl_channel_order */ +#define CL_R 0x10B0 +#define CL_A 0x10B1 +#define CL_RG 0x10B2 +#define CL_RA 0x10B3 +#define CL_RGB 0x10B4 +#define CL_RGBA 0x10B5 +#define CL_BGRA 0x10B6 +#define CL_ARGB 0x10B7 +#define CL_INTENSITY 0x10B8 +#define CL_LUMINANCE 0x10B9 +#define CL_Rx 0x10BA +#define CL_RGx 0x10BB +#define CL_RGBx 0x10BC + +/* cl_channel_type */ +#define CL_SNORM_INT8 0x10D0 +#define CL_SNORM_INT16 0x10D1 +#define CL_UNORM_INT8 0x10D2 +#define CL_UNORM_INT16 0x10D3 +#define CL_UNORM_SHORT_565 0x10D4 +#define CL_UNORM_SHORT_555 0x10D5 +#define CL_UNORM_INT_101010 0x10D6 +#define CL_SIGNED_INT8 0x10D7 +#define CL_SIGNED_INT16 0x10D8 +#define CL_SIGNED_INT32 0x10D9 +#define CL_UNSIGNED_INT8 0x10DA +#define CL_UNSIGNED_INT16 0x10DB +#define CL_UNSIGNED_INT32 0x10DC +#define CL_HALF_FLOAT 0x10DD +#define CL_FLOAT 0x10DE + +/* cl_mem_object_type */ +#define CL_MEM_OBJECT_BUFFER 0x10F0 +#define CL_MEM_OBJECT_IMAGE2D 0x10F1 +#define CL_MEM_OBJECT_IMAGE3D 0x10F2 +#define CL_MEM_OBJECT_IMAGE2D_ARRAY 0x10F3 +#define CL_MEM_OBJECT_IMAGE1D 0x10F4 +#define CL_MEM_OBJECT_IMAGE1D_ARRAY 0x10F5 +#define CL_MEM_OBJECT_IMAGE1D_BUFFER 0x10F6 + +/* cl_mem_info */ +#define CL_MEM_TYPE 0x1100 +#define CL_MEM_FLAGS 0x1101 +#define CL_MEM_SIZE 0x1102 +#define CL_MEM_HOST_PTR 0x1103 +#define CL_MEM_MAP_COUNT 0x1104 +#define CL_MEM_REFERENCE_COUNT 0x1105 +#define CL_MEM_CONTEXT 0x1106 +#define CL_MEM_ASSOCIATED_MEMOBJECT 0x1107 +#define CL_MEM_OFFSET 0x1108 + +/* cl_image_info */ +#define CL_IMAGE_FORMAT 0x1110 +#define CL_IMAGE_ELEMENT_SIZE 0x1111 +#define CL_IMAGE_ROW_PITCH 0x1112 +#define CL_IMAGE_SLICE_PITCH 0x1113 +#define CL_IMAGE_WIDTH 0x1114 +#define CL_IMAGE_HEIGHT 0x1115 +#define CL_IMAGE_DEPTH 0x1116 +#define CL_IMAGE_ARRAY_SIZE 0x1117 +#define CL_IMAGE_BUFFER 0x1118 +#define CL_IMAGE_NUM_MIP_LEVELS 0x1119 +#define CL_IMAGE_NUM_SAMPLES 0x111A + +/* cl_addressing_mode */ +#define CL_ADDRESS_NONE 0x1130 +#define CL_ADDRESS_CLAMP_TO_EDGE 0x1131 +#define CL_ADDRESS_CLAMP 0x1132 +#define CL_ADDRESS_REPEAT 0x1133 +#define CL_ADDRESS_MIRRORED_REPEAT 0x1134 + +/* cl_filter_mode */ +#define CL_FILTER_NEAREST 0x1140 +#define CL_FILTER_LINEAR 0x1141 + +/* cl_sampler_info */ +#define CL_SAMPLER_REFERENCE_COUNT 0x1150 +#define CL_SAMPLER_CONTEXT 0x1151 +#define CL_SAMPLER_NORMALIZED_COORDS 0x1152 +#define CL_SAMPLER_ADDRESSING_MODE 0x1153 +#define CL_SAMPLER_FILTER_MODE 0x1154 + +/* cl_map_flags - bitfield */ +#define CL_MAP_READ (1 << 0) +#define CL_MAP_WRITE (1 << 1) +#define CL_MAP_WRITE_INVALIDATE_REGION (1 << 2) + +/* cl_program_info */ +#define CL_PROGRAM_REFERENCE_COUNT 0x1160 +#define CL_PROGRAM_CONTEXT 0x1161 +#define CL_PROGRAM_NUM_DEVICES 0x1162 +#define CL_PROGRAM_DEVICES 0x1163 +#define CL_PROGRAM_SOURCE 0x1164 +#define CL_PROGRAM_BINARY_SIZES 0x1165 +#define CL_PROGRAM_BINARIES 0x1166 +#define CL_PROGRAM_NUM_KERNELS 0x1167 +#define CL_PROGRAM_KERNEL_NAMES 0x1168 + +/* cl_program_build_info */ +#define CL_PROGRAM_BUILD_STATUS 0x1181 +#define CL_PROGRAM_BUILD_OPTIONS 0x1182 +#define CL_PROGRAM_BUILD_LOG 0x1183 +#define CL_PROGRAM_BINARY_TYPE 0x1184 + +/* cl_program_binary_type */ +#define CL_PROGRAM_BINARY_TYPE_NONE 0x0 +#define CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT 0x1 +#define CL_PROGRAM_BINARY_TYPE_LIBRARY 0x2 +#define CL_PROGRAM_BINARY_TYPE_EXECUTABLE 0x4 + +/* cl_build_status */ +#define CL_BUILD_SUCCESS 0 +#define CL_BUILD_NONE -1 +#define CL_BUILD_ERROR -2 +#define CL_BUILD_IN_PROGRESS -3 + +/* cl_kernel_info */ +#define CL_KERNEL_FUNCTION_NAME 0x1190 +#define CL_KERNEL_NUM_ARGS 0x1191 +#define CL_KERNEL_REFERENCE_COUNT 0x1192 +#define CL_KERNEL_CONTEXT 0x1193 +#define CL_KERNEL_PROGRAM 0x1194 +#define CL_KERNEL_ATTRIBUTES 0x1195 + +/* cl_kernel_arg_info */ +#define CL_KERNEL_ARG_ADDRESS_QUALIFIER 0x1196 +#define CL_KERNEL_ARG_ACCESS_QUALIFIER 0x1197 +#define CL_KERNEL_ARG_TYPE_NAME 0x1198 +#define CL_KERNEL_ARG_TYPE_QUALIFIER 0x1199 +#define CL_KERNEL_ARG_NAME 0x119A + +/* cl_kernel_arg_address_qualifier */ +#define CL_KERNEL_ARG_ADDRESS_GLOBAL 0x119B +#define CL_KERNEL_ARG_ADDRESS_LOCAL 0x119C +#define CL_KERNEL_ARG_ADDRESS_CONSTANT 0x119D +#define CL_KERNEL_ARG_ADDRESS_PRIVATE 0x119E + +/* cl_kernel_arg_access_qualifier */ +#define CL_KERNEL_ARG_ACCESS_READ_ONLY 0x11A0 +#define CL_KERNEL_ARG_ACCESS_WRITE_ONLY 0x11A1 +#define CL_KERNEL_ARG_ACCESS_READ_WRITE 0x11A2 +#define CL_KERNEL_ARG_ACCESS_NONE 0x11A3 + +/* cl_kernel_arg_type_qualifer */ +#define CL_KERNEL_ARG_TYPE_NONE 0 +#define CL_KERNEL_ARG_TYPE_CONST (1 << 0) +#define CL_KERNEL_ARG_TYPE_RESTRICT (1 << 1) +#define CL_KERNEL_ARG_TYPE_VOLATILE (1 << 2) + +/* cl_kernel_work_group_info */ +#define CL_KERNEL_WORK_GROUP_SIZE 0x11B0 +#define CL_KERNEL_COMPILE_WORK_GROUP_SIZE 0x11B1 +#define CL_KERNEL_LOCAL_MEM_SIZE 0x11B2 +#define CL_KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE 0x11B3 +#define CL_KERNEL_PRIVATE_MEM_SIZE 0x11B4 +#define CL_KERNEL_GLOBAL_WORK_SIZE 0x11B5 + +/* cl_event_info */ +#define CL_EVENT_COMMAND_QUEUE 0x11D0 +#define CL_EVENT_COMMAND_TYPE 0x11D1 +#define CL_EVENT_REFERENCE_COUNT 0x11D2 +#define CL_EVENT_COMMAND_EXECUTION_STATUS 0x11D3 +#define CL_EVENT_CONTEXT 0x11D4 + +/* cl_command_type */ +#define CL_COMMAND_NDRANGE_KERNEL 0x11F0 +#define CL_COMMAND_TASK 0x11F1 +#define CL_COMMAND_NATIVE_KERNEL 0x11F2 +#define CL_COMMAND_READ_BUFFER 0x11F3 +#define CL_COMMAND_WRITE_BUFFER 0x11F4 +#define CL_COMMAND_COPY_BUFFER 0x11F5 +#define CL_COMMAND_READ_IMAGE 0x11F6 +#define CL_COMMAND_WRITE_IMAGE 0x11F7 +#define CL_COMMAND_COPY_IMAGE 0x11F8 +#define CL_COMMAND_COPY_IMAGE_TO_BUFFER 0x11F9 +#define CL_COMMAND_COPY_BUFFER_TO_IMAGE 0x11FA +#define CL_COMMAND_MAP_BUFFER 0x11FB +#define CL_COMMAND_MAP_IMAGE 0x11FC +#define CL_COMMAND_UNMAP_MEM_OBJECT 0x11FD +#define CL_COMMAND_MARKER 0x11FE +#define CL_COMMAND_ACQUIRE_GL_OBJECTS 0x11FF +#define CL_COMMAND_RELEASE_GL_OBJECTS 0x1200 +#define CL_COMMAND_READ_BUFFER_RECT 0x1201 +#define CL_COMMAND_WRITE_BUFFER_RECT 0x1202 +#define CL_COMMAND_COPY_BUFFER_RECT 0x1203 +#define CL_COMMAND_USER 0x1204 +#define CL_COMMAND_BARRIER 0x1205 +#define CL_COMMAND_MIGRATE_MEM_OBJECTS 0x1206 +#define CL_COMMAND_FILL_BUFFER 0x1207 +#define CL_COMMAND_FILL_IMAGE 0x1208 + +/* command execution status */ +#define CL_COMPLETE 0x0 +#define CL_RUNNING 0x1 +#define CL_SUBMITTED 0x2 +#define CL_QUEUED 0x3 + +/* cl_buffer_create_type */ +#define CL_BUFFER_CREATE_TYPE_REGION 0x1220 + +/* cl_profiling_info */ +#define CL_PROFILING_COMMAND_QUEUED 0x1280 +#define CL_PROFILING_COMMAND_SUBMIT 0x1281 +#define CL_PROFILING_COMMAND_START 0x1282 +#define CL_PROFILING_COMMAND_END 0x1283 + + /********************************************************************************************************/ + + /* Platform API */ + extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs(cl_uint /* num_entries */, cl_platform_id* /* platforms */, + cl_uint* /* num_platforms */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo(cl_platform_id /* platform */, cl_platform_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Device APIs */ + extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs(cl_platform_id /* platform */, cl_device_type /* device_type */, + cl_uint /* num_entries */, cl_device_id* /* devices */, + cl_uint* /* num_devices */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo(cl_device_id /* device */, cl_device_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices(cl_device_id /* in_device */, + const cl_device_partition_property* /* properties */, + cl_uint /* num_devices */, cl_device_id* /* out_devices */, + cl_uint* /* num_devices_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice(cl_device_id /* device */) CL_API_SUFFIX__VERSION_1_2; + + /* Context APIs */ + extern CL_API_ENTRY cl_context CL_API_CALL clCreateContext(const cl_context_properties* /* properties */, cl_uint /* num_devices */, + const cl_device_id* /* devices */, + void(CL_CALLBACK* /* pfn_notify */)(const char*, const void*, size_t, void*), + void* /* user_data */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_context CL_API_CALL + clCreateContextFromType(const cl_context_properties* /* properties */, cl_device_type /* device_type */, + void(CL_CALLBACK* /* pfn_notify*/)(const char*, const void*, size_t, void*), void* /* user_data */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseContext(cl_context /* context */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo(cl_context /* context */, cl_context_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Command Queue APIs */ + extern CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context /* context */, cl_device_id /* device */, + cl_command_queue_properties /* properties */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo(cl_command_queue /* command_queue */, + cl_command_queue_info /* param_name */, size_t /* param_value_size */, + void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Memory Object APIs */ + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer(cl_context /* context */, cl_mem_flags /* flags */, size_t /* size */, + void* /* host_ptr */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer(cl_mem /* buffer */, cl_mem_flags /* flags */, + cl_buffer_create_type /* buffer_create_type */, + const void* /* buffer_create_info */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateImage(cl_context /* context */, cl_mem_flags /* flags */, + const cl_image_format* /* image_format */, const cl_image_desc* /* image_desc */, + void* /* host_ptr */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject(cl_mem /* memobj */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats(cl_context /* context */, cl_mem_flags /* flags */, + cl_mem_object_type /* image_type */, cl_uint /* num_entries */, + cl_image_format* /* image_formats */, + cl_uint* /* num_image_formats */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo(cl_mem /* memobj */, cl_mem_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo(cl_mem /* image */, cl_image_info /* param_name */, size_t /* param_value_size */, + void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback(cl_mem /* memobj */, + void(CL_CALLBACK* /*pfn_notify*/)(cl_mem /* memobj */, + void* /*user_data*/), + void* /*user_data */) CL_API_SUFFIX__VERSION_1_1; + + /* Sampler APIs */ + extern CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler(cl_context /* context */, cl_bool /* normalized_coords */, + cl_addressing_mode /* addressing_mode */, cl_filter_mode /* filter_mode */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler(cl_sampler /* sampler */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo(cl_sampler /* sampler */, cl_sampler_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Program Object APIs */ + extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource(cl_context /* context */, cl_uint /* count */, + const char** /* strings */, const size_t* /* lengths */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary(cl_context /* context */, cl_uint /* num_devices */, + const cl_device_id* /* device_list */, const size_t* /* lengths */, + const unsigned char** /* binaries */, cl_int* /* binary_status */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels(cl_context /* context */, cl_uint /* num_devices */, + const cl_device_id* /* device_list */, + const char* /* kernel_names */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram(cl_program /* program */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clBuildProgram(cl_program /* program */, cl_uint /* num_devices */, + const cl_device_id* /* device_list */, const char* /* options */, + void(CL_CALLBACK* /* pfn_notify */)(cl_program /* program */, + void* /* user_data */), + void* /* user_data */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL + clCompileProgram(cl_program /* program */, cl_uint /* num_devices */, const cl_device_id* /* device_list */, const char* /* options */, + cl_uint /* num_input_headers */, const cl_program* /* input_headers */, const char** /* header_include_names */, + void(CL_CALLBACK* /* pfn_notify */)(cl_program /* program */, void* /* user_data */), + void* /* user_data */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_program CL_API_CALL clLinkProgram(cl_context /* context */, cl_uint /* num_devices */, + const cl_device_id* /* device_list */, const char* /* options */, + cl_uint /* num_input_programs */, const cl_program* /* input_programs */, + void(CL_CALLBACK* /* pfn_notify */)(cl_program /* program */, + void* /* user_data */), + void* /* user_data */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler(cl_platform_id /* platform */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo(cl_program /* program */, cl_program_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo(cl_program /* program */, cl_device_id /* device */, + cl_program_build_info /* param_name */, size_t /* param_value_size */, + void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Kernel Object APIs */ + extern CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel(cl_program /* program */, const char* /* kernel_name */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram(cl_program /* program */, cl_uint /* num_kernels */, + cl_kernel* /* kernels */, + cl_uint* /* num_kernels_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel(cl_kernel /* kernel */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg(cl_kernel /* kernel */, cl_uint /* arg_index */, size_t /* arg_size */, + const void* /* arg_value */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo(cl_kernel /* kernel */, cl_kernel_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo(cl_kernel /* kernel */, cl_uint /* arg_indx */, + cl_kernel_arg_info /* param_name */, size_t /* param_value_size */, + void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo(cl_kernel /* kernel */, cl_device_id /* device */, + cl_kernel_work_group_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Event Object APIs */ + extern CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents(cl_uint /* num_events */, + const cl_event* /* event_list */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo(cl_event /* event */, cl_event_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent(cl_context /* context */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent(cl_event /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus(cl_event /* event */, + cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback(cl_event /* event */, cl_int /* command_exec_callback_type */, + void(CL_CALLBACK* /* pfn_notify */)(cl_event, cl_int, void*), + void* /* user_data */) CL_API_SUFFIX__VERSION_1_1; + + /* Profiling APIs */ + extern CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo(cl_event /* event */, cl_profiling_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + /* Flush and Finish APIs */ + extern CL_API_ENTRY cl_int CL_API_CALL clFlush(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clFinish(cl_command_queue /* command_queue */) CL_API_SUFFIX__VERSION_1_0; + + /* Enqueued Commands APIs */ + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, + cl_bool /* blocking_read */, size_t /* offset */, size_t /* size */, + void* /* ptr */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect( + cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_read */, const size_t* /* buffer_offset */, + const size_t* /* host_offset */, const size_t* /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, + size_t /* host_row_pitch */, size_t /* host_slice_pitch */, void* /* ptr */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, + cl_bool /* blocking_write */, size_t /* offset */, size_t /* size */, + const void* /* ptr */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect( + cl_command_queue /* command_queue */, cl_mem /* buffer */, cl_bool /* blocking_write */, const size_t* /* buffer_offset */, + const size_t* /* host_offset */, const size_t* /* region */, size_t /* buffer_row_pitch */, size_t /* buffer_slice_pitch */, + size_t /* host_row_pitch */, size_t /* host_slice_pitch */, const void* /* ptr */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, + const void* /* pattern */, size_t /* pattern_size */, size_t /* offset */, + size_t /* size */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, + cl_mem /* dst_buffer */, size_t /* src_offset */, size_t /* dst_offset */, + size_t /* size */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect( + cl_command_queue /* command_queue */, cl_mem /* src_buffer */, cl_mem /* dst_buffer */, const size_t* /* src_origin */, + const size_t* /* dst_origin */, const size_t* /* region */, size_t /* src_row_pitch */, size_t /* src_slice_pitch */, + size_t /* dst_row_pitch */, size_t /* dst_slice_pitch */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue /* command_queue */, cl_mem /* image */, + cl_bool /* blocking_read */, const size_t* /* origin[3] */, + const size_t* /* region[3] */, size_t /* row_pitch */, + size_t /* slice_pitch */, void* /* ptr */, + cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue /* command_queue */, cl_mem /* image */, + cl_bool /* blocking_write */, const size_t* /* origin[3] */, + const size_t* /* region[3] */, size_t /* input_row_pitch */, + size_t /* input_slice_pitch */, const void* /* ptr */, + cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue /* command_queue */, cl_mem /* image */, + const void* /* fill_color */, const size_t* /* origin[3] */, + const size_t* /* region[3] */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue /* command_queue */, cl_mem /* src_image */, + cl_mem /* dst_image */, const size_t* /* src_origin[3] */, + const size_t* /* dst_origin[3] */, const size_t* /* region[3] */, + cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue /* command_queue */, cl_mem /* src_image */, + cl_mem /* dst_buffer */, const size_t* /* src_origin[3] */, + const size_t* /* region[3] */, size_t /* dst_offset */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue /* command_queue */, cl_mem /* src_buffer */, + cl_mem /* dst_image */, size_t /* src_offset */, + const size_t* /* dst_origin[3] */, const size_t* /* region[3] */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer(cl_command_queue /* command_queue */, cl_mem /* buffer */, + cl_bool /* blocking_map */, cl_map_flags /* map_flags */, size_t /* offset */, + size_t /* size */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, cl_event* /* event */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage(cl_command_queue /* command_queue */, cl_mem /* image */, + cl_bool /* blocking_map */, cl_map_flags /* map_flags */, + const size_t* /* origin[3] */, const size_t* /* region[3] */, + size_t* /* image_row_pitch */, size_t* /* image_slice_pitch */, + cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */, + cl_event* /* event */, cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject(cl_command_queue /* command_queue */, cl_mem /* memobj */, + void* /* mapped_ptr */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects(cl_command_queue /* command_queue */, cl_uint /* num_mem_objects */, + const cl_mem* /* mem_objects */, cl_mem_migration_flags /* flags */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel(cl_command_queue /* command_queue */, cl_kernel /* kernel */, + cl_uint /* work_dim */, const size_t* /* global_work_offset */, + const size_t* /* global_work_size */, const size_t* /* local_work_size */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask(cl_command_queue /* command_queue */, cl_kernel /* kernel */, + cl_uint /* num_events_in_wait_list */, const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel( + cl_command_queue /* command_queue */, void(CL_CALLBACK* /*user_func*/)(void*), void* /* args */, size_t /* cb_args */, + cl_uint /* num_mem_objects */, const cl_mem* /* mem_list */, const void** /* args_mem_loc */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList(cl_command_queue /* command_queue */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList(cl_command_queue /* command_queue */, + cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_int CL_API_CALL clSetPrintfCallback(cl_context /* context */, + void(CL_CALLBACK* /* pfn_notify */)(cl_context /* program */, + cl_uint /*printf_data_len */, + char* /* printf_data_ptr */, + void* /* user_data */), + void* /* user_data */) CL_API_SUFFIX__VERSION_1_2; + + /* Extension function access + * + * Returns the extension function address for the given function name, + * or NULL if a valid function can not be found. The client must + * check to make sure the address is not NULL, before using or + * calling the returned function address. + */ + extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id /* platform */, + const char* /* func_name */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress(const char* /* func_name */); + +#ifdef CL_USE_DEPRECATED_OPENCL_1_0_APIS + // #warning CL_USE_DEPRECATED_OPENCL_1_0_APIS is defined. These APIs are unsupported and untested in OpenCL 1.1! + /* + * WARNING: + * This API introduces mutable state into the OpenCL implementation. It has been REMOVED + * to better facilitate thread safety. The 1.0 API is not thread safe. It is not tested by the + * OpenCL 1.1 conformance test, and consequently may not work or may not work dependably. + * It is likely to be non-performant. Use of this API is not advised. Use at your own risk. + * + * Software developers previously relying on this API are instructed to set the command queue + * properties when creating the queue, instead. + */ + extern CL_API_ENTRY cl_int CL_API_CALL + clSetCommandQueueProperty(cl_command_queue /* command_queue */, cl_command_queue_properties /* properties */, cl_bool /* enable */, + cl_command_queue_properties* /* old_properties */) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_0_APIS */ + +#ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D(cl_context /* context */, cl_mem_flags /* flags */, + const cl_image_format* /* image_format */, size_t /* image_width */, + size_t /* image_height */, size_t /* image_row_pitch */, void* /* host_ptr */, + cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D(cl_context /* context */, cl_mem_flags /* flags */, + const cl_image_format* /* image_format */, size_t /* image_width */, + size_t /* image_height */, size_t /* image_depth */, + size_t /* image_row_pitch */, size_t /* image_slice_pitch */, + void* /* host_ptr */, + cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker(cl_command_queue /* command_queue */, + cl_event* /* event */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents(cl_command_queue /* command_queue */, cl_uint /* num_events */, + const cl_event* /* event_list */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier(cl_command_queue /* command_queue */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + +#endif /* CL_USE_DEPRECATED_OPENCL_1_2_APIS */ + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_H */ diff --git a/src/lib/image/MovieRED/CL/cl_platform.h b/src/lib/image/MovieRED/CL/cl_platform.h new file mode 100644 index 00000000..cad39050 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_platform.h @@ -0,0 +1,1552 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 14829 $ on $Date: 2011-05-26 08:22:50 -0700 (Thu, 26 May 2011) $ */ + +#ifndef __CL_PLATFORM_H +#define __CL_PLATFORM_H + +#ifdef __APPLE__ +/* Contains #defines for AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER below */ +#include +#endif + +#if !defined(_WIN32) || !defined(_MSC_VER) +#include +#endif /* !_WIN32 */ +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if defined(_WIN32) || defined(__CYGWIN__) +#define CL_API_ENTRY +#define CL_API_CALL __stdcall +#define CL_CALLBACK __stdcall +#else +#define CL_API_ENTRY +#define CL_API_CALL +#define CL_CALLBACK +#endif + +#ifdef __APPLE__ +#define CL_EXTENSION_WEAK_LINK __attribute__((weak_import)) +#define CL_API_SUFFIX__VERSION_1_0 AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER +#define CL_EXT_SUFFIX__VERSION_1_0 CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER +#define CL_API_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK +#define CL_EXT_SUFFIX__VERSION_1_1 CL_EXTENSION_WEAK_LINK +#define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED CL_EXTENSION_WEAK_LINK AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER +#else +#define CL_EXTENSION_WEAK_LINK +#define CL_API_SUFFIX__VERSION_1_0 +#define CL_EXT_SUFFIX__VERSION_1_0 +#define CL_API_SUFFIX__VERSION_1_1 +#define CL_EXT_SUFFIX__VERSION_1_1 +#define CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED +#define CL_API_SUFFIX__VERSION_1_2 +#define CL_EXT_SUFFIX__VERSION_1_2 +#define CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED +#endif + +#if (defined(_WIN32) && defined(_MSC_VER)) + + /* scalar types */ + typedef signed __int8 cl_char; + typedef unsigned __int8 cl_uchar; + typedef signed __int16 cl_short; + typedef unsigned __int16 cl_ushort; + typedef signed __int32 cl_int; + typedef unsigned __int32 cl_uint; + typedef signed __int64 cl_long; + typedef unsigned __int64 cl_ulong; + typedef unsigned __int16 cl_half; +#else /* !_WIN32 */ +typedef int8_t cl_char; +typedef uint8_t cl_uchar; +typedef int16_t cl_short; +typedef uint16_t cl_ushort; +typedef int32_t cl_int; +typedef uint32_t cl_uint; +typedef int64_t cl_long; +typedef uint64_t cl_ulong; +typedef uint16_t cl_half; +#endif /* !_WIN32 */ + typedef float cl_float; + typedef double cl_double; + +#define CL_CHAR_BIT 8 +#define CL_SCHAR_MAX 127 +#define CL_SCHAR_MIN (-127 - 1) +#define CL_CHAR_MAX CL_SCHAR_MAX +#define CL_CHAR_MIN CL_SCHAR_MIN +#define CL_UCHAR_MAX 255 +#define CL_SHRT_MAX 32767 +#define CL_SHRT_MIN (-32767 - 1) +#define CL_USHRT_MAX 65535 +#define CL_INT_MAX 2147483647 +#define CL_INT_MIN (-2147483647 - 1) +#define CL_UINT_MAX 0xffffffffU +#define CL_LONG_MAX ((cl_long)0x7FFFFFFFFFFFFFFFLL) +#define CL_LONG_MIN ((cl_long) - 0x7FFFFFFFFFFFFFFFLL - 1LL) +#define CL_ULONG_MAX ((cl_ulong)0xFFFFFFFFFFFFFFFFULL) + +#define CL_FLT_DIG 6 +#define CL_FLT_MANT_DIG 24 +#define CL_FLT_MAX_10_EXP +38 +#define CL_FLT_MAX_EXP +128 +#define CL_FLT_MIN_10_EXP -37 +#define CL_FLT_MIN_EXP -125 +#define CL_FLT_RADIX 2 +#define CL_FLT_MAX FLT_MAX +#define CL_FLT_MIN FLT_MIN +#define CL_FLT_EPSILON FLT_EPSILON + +#define CL_DBL_DIG 15 +#define CL_DBL_MANT_DIG 53 +#define CL_DBL_MAX_10_EXP +308 +#define CL_DBL_MAX_EXP +1024 +#define CL_DBL_MIN_10_EXP -307 +#define CL_DBL_MIN_EXP -1021 +#define CL_DBL_RADIX 2 +#define CL_DBL_MAX DBL_MAX +#define CL_DBL_MIN DBL_MIN +#define CL_DBL_EPSILON DBL_EPSILON + +#define CL_M_E 2.718281828459045090796 +#define CL_M_LOG2E 1.442695040888963387005 +#define CL_M_LOG10E 0.434294481903251816668 +#define CL_M_LN2 0.693147180559945286227 +#define CL_M_LN10 2.302585092994045901094 +#define CL_M_PI 3.141592653589793115998 +#define CL_M_PI_2 1.570796326794896557999 +#define CL_M_PI_4 0.785398163397448278999 +#define CL_M_1_PI 0.318309886183790691216 +#define CL_M_2_PI 0.636619772367581382433 +#define CL_M_2_SQRTPI 1.128379167095512558561 +#define CL_M_SQRT2 1.414213562373095145475 +#define CL_M_SQRT1_2 0.707106781186547572737 + +#define CL_M_E_F 2.71828174591064f +#define CL_M_LOG2E_F 1.44269502162933f +#define CL_M_LOG10E_F 0.43429449200630f +#define CL_M_LN2_F 0.69314718246460f +#define CL_M_LN10_F 2.30258512496948f +#define CL_M_PI_F 3.14159274101257f +#define CL_M_PI_2_F 1.57079637050629f +#define CL_M_PI_4_F 0.78539818525314f +#define CL_M_1_PI_F 0.31830987334251f +#define CL_M_2_PI_F 0.63661974668503f +#define CL_M_2_SQRTPI_F 1.12837922573090f +#define CL_M_SQRT2_F 1.41421353816986f +#define CL_M_SQRT1_2_F 0.70710676908493f + +#define CL_NAN (CL_INFINITY - CL_INFINITY) +#define CL_HUGE_VALF ((cl_float)1e50) +#define CL_HUGE_VAL ((cl_double)1e500) +#define CL_MAXFLOAT CL_FLT_MAX +#define CL_INFINITY CL_HUGE_VALF + +#include + + /* Mirror types to GL types. Mirror types allow us to avoid deciding which headers to load based on whether we are using GL or GLES + * here. */ + typedef unsigned int cl_GLuint; + typedef int cl_GLint; + typedef unsigned int cl_GLenum; + +/* + * Vector types + * + * Note: OpenCL requires that all types be naturally aligned. + * This means that vector types must be naturally aligned. + * For example, a vector of four floats must be aligned to + * a 16 byte boundary (calculated as 4 * the natural 4-byte + * alignment of the float). The alignment qualifiers here + * will only function properly if your compiler supports them + * and if you don't actively work to defeat them. For example, + * in order for a cl_float4 to be 16 byte aligned in a struct, + * the start of the struct must itself be 16-byte aligned. + * + * Maintaining proper alignment is the user's responsibility. + */ + +/* Define basic vector types */ +#if defined(__VEC__) +#include /* may be omitted depending on compiler. AltiVec spec provides no way to detect whether the header is required. */ + typedef vector unsigned char __cl_uchar16; + typedef vector signed char __cl_char16; + typedef vector unsigned short __cl_ushort8; + typedef vector signed short __cl_short8; + typedef vector unsigned int __cl_uint4; + typedef vector signed int __cl_int4; + typedef vector float __cl_float4; +#define __CL_UCHAR16__ 1 +#define __CL_CHAR16__ 1 +#define __CL_USHORT8__ 1 +#define __CL_SHORT8__ 1 +#define __CL_UINT4__ 1 +#define __CL_INT4__ 1 +#define __CL_FLOAT4__ 1 +#endif + +#if defined(__SSE__) +#if defined(__MINGW64__) +#include +#else +#include +#endif +#if defined(__GNUC__) && !defined(__ICC) + typedef float __cl_float4 __attribute__((vector_size(16))); +#else + typedef __m128 __cl_float4; +#endif +#define __CL_FLOAT4__ 1 +#endif + +#if defined(__SSE2__) +#if defined(__MINGW64__) +#include +#else +#include +#endif +#if defined(__GNUC__) && !defined(__ICC) + typedef cl_uchar __cl_uchar16 __attribute__((vector_size(16))); + typedef cl_char __cl_char16 __attribute__((vector_size(16))); + typedef cl_ushort __cl_ushort8 __attribute__((vector_size(16))); + typedef cl_short __cl_short8 __attribute__((vector_size(16))); + typedef cl_uint __cl_uint4 __attribute__((vector_size(16))); + typedef cl_int __cl_int4 __attribute__((vector_size(16))); + typedef cl_ulong __cl_ulong2 __attribute__((vector_size(16))); + typedef cl_long __cl_long2 __attribute__((vector_size(16))); + typedef cl_double __cl_double2 __attribute__((vector_size(16))); +#else + typedef __m128i __cl_uchar16; + typedef __m128i __cl_char16; + typedef __m128i __cl_ushort8; + typedef __m128i __cl_short8; + typedef __m128i __cl_uint4; + typedef __m128i __cl_int4; + typedef __m128i __cl_ulong2; + typedef __m128i __cl_long2; + typedef __m128d __cl_double2; +#endif +#define __CL_UCHAR16__ 1 +#define __CL_CHAR16__ 1 +#define __CL_USHORT8__ 1 +#define __CL_SHORT8__ 1 +#define __CL_INT4__ 1 +#define __CL_UINT4__ 1 +#define __CL_ULONG2__ 1 +#define __CL_LONG2__ 1 +#define __CL_DOUBLE2__ 1 +#endif + +#if defined(__MMX__) +#include +#if defined(__GNUC__) && !defined(__ICC) + typedef cl_uchar __cl_uchar8 __attribute__((vector_size(8))); + typedef cl_char __cl_char8 __attribute__((vector_size(8))); + typedef cl_ushort __cl_ushort4 __attribute__((vector_size(8))); + typedef cl_short __cl_short4 __attribute__((vector_size(8))); + typedef cl_uint __cl_uint2 __attribute__((vector_size(8))); + typedef cl_int __cl_int2 __attribute__((vector_size(8))); + typedef cl_ulong __cl_ulong1 __attribute__((vector_size(8))); + typedef cl_long __cl_long1 __attribute__((vector_size(8))); + typedef cl_float __cl_float2 __attribute__((vector_size(8))); +#else + typedef __m64 __cl_uchar8; + typedef __m64 __cl_char8; + typedef __m64 __cl_ushort4; + typedef __m64 __cl_short4; + typedef __m64 __cl_uint2; + typedef __m64 __cl_int2; + typedef __m64 __cl_ulong1; + typedef __m64 __cl_long1; + typedef __m64 __cl_float2; +#endif +#define __CL_UCHAR8__ 1 +#define __CL_CHAR8__ 1 +#define __CL_USHORT4__ 1 +#define __CL_SHORT4__ 1 +#define __CL_INT2__ 1 +#define __CL_UINT2__ 1 +#define __CL_ULONG1__ 1 +#define __CL_LONG1__ 1 +#define __CL_FLOAT2__ 1 +#endif + +#if defined(__AVX__) +#if defined(__MINGW64__) +#include +#else +#include +#endif +#if defined(__GNUC__) && !defined(__ICC) + typedef cl_float __cl_float8 __attribute__((vector_size(32))); + typedef cl_double __cl_double4 __attribute__((vector_size(32))); +#else + typedef __m256 __cl_float8; + typedef __m256d __cl_double4; +#endif +#define __CL_FLOAT8__ 1 +#define __CL_DOUBLE4__ 1 +#endif + +/* Define alignment keys */ +#if (defined(__GNUC__) || defined(__IBMC__)) +#define CL_ALIGNED(_x) __attribute__((aligned(_x))) +#elif defined(_WIN32) && (_MSC_VER) +/* Alignment keys neutered on windows because MSVC can't swallow function arguments with alignment requirements */ +/* http://msdn.microsoft.com/en-us/library/373ak2y1%28VS.71%29.aspx */ +/* #include */ +/* #define CL_ALIGNED(_x) _CRT_ALIGN(_x) */ +#define CL_ALIGNED(_x) +#else +#warning Need to implement some method to align data here +#define CL_ALIGNED(_x) +#endif + +/* Indicate whether .xyzw, .s0123 and .hi.lo are supported */ +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) +/* .xyzw and .s0123...{f|F} are supported */ +#define CL_HAS_NAMED_VECTOR_FIELDS 1 +/* .hi and .lo are supported */ +#define CL_HAS_HI_LO_VECTOR_FIELDS 1 +#endif + + /* Define cl_vector types */ + + /* ---- cl_charn ---- */ + typedef union + { + cl_char CL_ALIGNED(2) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_char x, y; + }; + + __extension__ struct + { + cl_char s0, s1; + }; + + __extension__ struct + { + cl_char lo, hi; + }; +#endif +#if defined(__CL_CHAR2__) + __cl_char2 v2; +#endif + } cl_char2; + + typedef union + { + cl_char CL_ALIGNED(4) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_char x, y, z, w; + }; + + __extension__ struct + { + cl_char s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_char2 lo, hi; + }; +#endif +#if defined(__CL_CHAR2__) + __cl_char2 v2[2]; +#endif +#if defined(__CL_CHAR4__) + __cl_char4 v4; +#endif + } cl_char4; + + /* cl_char3 is identical in size, alignment and behavior to cl_char4. See section 6.1.5. */ + typedef cl_char4 cl_char3; + + typedef union + { + cl_char CL_ALIGNED(8) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_char x, y, z, w; + }; + + __extension__ struct + { + cl_char s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_char4 lo, hi; + }; +#endif +#if defined(__CL_CHAR2__) + __cl_char2 v2[4]; +#endif +#if defined(__CL_CHAR4__) + __cl_char4 v4[2]; +#endif +#if defined(__CL_CHAR8__) + __cl_char8 v8; +#endif + } cl_char8; + + typedef union + { + cl_char CL_ALIGNED(16) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_char x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_char s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_char8 lo, hi; + }; +#endif +#if defined(__CL_CHAR2__) + __cl_char2 v2[8]; +#endif +#if defined(__CL_CHAR4__) + __cl_char4 v4[4]; +#endif +#if defined(__CL_CHAR8__) + __cl_char8 v8[2]; +#endif +#if defined(__CL_CHAR16__) + __cl_char16 v16; +#endif + } cl_char16; + + /* ---- cl_ucharn ---- */ + typedef union + { + cl_uchar CL_ALIGNED(2) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uchar x, y; + }; + + __extension__ struct + { + cl_uchar s0, s1; + }; + + __extension__ struct + { + cl_uchar lo, hi; + }; +#endif +#if defined(__cl_uchar2__) + __cl_uchar2 v2; +#endif + } cl_uchar2; + + typedef union + { + cl_uchar CL_ALIGNED(4) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uchar x, y, z, w; + }; + + __extension__ struct + { + cl_uchar s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_uchar2 lo, hi; + }; +#endif +#if defined(__CL_UCHAR2__) + __cl_uchar2 v2[2]; +#endif +#if defined(__CL_UCHAR4__) + __cl_uchar4 v4; +#endif + } cl_uchar4; + + /* cl_uchar3 is identical in size, alignment and behavior to cl_uchar4. See section 6.1.5. */ + typedef cl_uchar4 cl_uchar3; + + typedef union + { + cl_uchar CL_ALIGNED(8) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uchar x, y, z, w; + }; + + __extension__ struct + { + cl_uchar s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_uchar4 lo, hi; + }; +#endif +#if defined(__CL_UCHAR2__) + __cl_uchar2 v2[4]; +#endif +#if defined(__CL_UCHAR4__) + __cl_uchar4 v4[2]; +#endif +#if defined(__CL_UCHAR8__) + __cl_uchar8 v8; +#endif + } cl_uchar8; + + typedef union + { + cl_uchar CL_ALIGNED(16) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uchar x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_uchar s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_uchar8 lo, hi; + }; +#endif +#if defined(__CL_UCHAR2__) + __cl_uchar2 v2[8]; +#endif +#if defined(__CL_UCHAR4__) + __cl_uchar4 v4[4]; +#endif +#if defined(__CL_UCHAR8__) + __cl_uchar8 v8[2]; +#endif +#if defined(__CL_UCHAR16__) + __cl_uchar16 v16; +#endif + } cl_uchar16; + + /* ---- cl_shortn ---- */ + typedef union + { + cl_short CL_ALIGNED(4) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_short x, y; + }; + + __extension__ struct + { + cl_short s0, s1; + }; + + __extension__ struct + { + cl_short lo, hi; + }; +#endif +#if defined(__CL_SHORT2__) + __cl_short2 v2; +#endif + } cl_short2; + + typedef union + { + cl_short CL_ALIGNED(8) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_short x, y, z, w; + }; + + __extension__ struct + { + cl_short s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_short2 lo, hi; + }; +#endif +#if defined(__CL_SHORT2__) + __cl_short2 v2[2]; +#endif +#if defined(__CL_SHORT4__) + __cl_short4 v4; +#endif + } cl_short4; + + /* cl_short3 is identical in size, alignment and behavior to cl_short4. See section 6.1.5. */ + typedef cl_short4 cl_short3; + + typedef union + { + cl_short CL_ALIGNED(16) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_short x, y, z, w; + }; + + __extension__ struct + { + cl_short s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_short4 lo, hi; + }; +#endif +#if defined(__CL_SHORT2__) + __cl_short2 v2[4]; +#endif +#if defined(__CL_SHORT4__) + __cl_short4 v4[2]; +#endif +#if defined(__CL_SHORT8__) + __cl_short8 v8; +#endif + } cl_short8; + + typedef union + { + cl_short CL_ALIGNED(32) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_short x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_short s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_short8 lo, hi; + }; +#endif +#if defined(__CL_SHORT2__) + __cl_short2 v2[8]; +#endif +#if defined(__CL_SHORT4__) + __cl_short4 v4[4]; +#endif +#if defined(__CL_SHORT8__) + __cl_short8 v8[2]; +#endif +#if defined(__CL_SHORT16__) + __cl_short16 v16; +#endif + } cl_short16; + + /* ---- cl_ushortn ---- */ + typedef union + { + cl_ushort CL_ALIGNED(4) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ushort x, y; + }; + + __extension__ struct + { + cl_ushort s0, s1; + }; + + __extension__ struct + { + cl_ushort lo, hi; + }; +#endif +#if defined(__CL_USHORT2__) + __cl_ushort2 v2; +#endif + } cl_ushort2; + + typedef union + { + cl_ushort CL_ALIGNED(8) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ushort x, y, z, w; + }; + + __extension__ struct + { + cl_ushort s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_ushort2 lo, hi; + }; +#endif +#if defined(__CL_USHORT2__) + __cl_ushort2 v2[2]; +#endif +#if defined(__CL_USHORT4__) + __cl_ushort4 v4; +#endif + } cl_ushort4; + + /* cl_ushort3 is identical in size, alignment and behavior to cl_ushort4. See section 6.1.5. */ + typedef cl_ushort4 cl_ushort3; + + typedef union + { + cl_ushort CL_ALIGNED(16) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ushort x, y, z, w; + }; + + __extension__ struct + { + cl_ushort s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_ushort4 lo, hi; + }; +#endif +#if defined(__CL_USHORT2__) + __cl_ushort2 v2[4]; +#endif +#if defined(__CL_USHORT4__) + __cl_ushort4 v4[2]; +#endif +#if defined(__CL_USHORT8__) + __cl_ushort8 v8; +#endif + } cl_ushort8; + + typedef union + { + cl_ushort CL_ALIGNED(32) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ushort x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_ushort s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_ushort8 lo, hi; + }; +#endif +#if defined(__CL_USHORT2__) + __cl_ushort2 v2[8]; +#endif +#if defined(__CL_USHORT4__) + __cl_ushort4 v4[4]; +#endif +#if defined(__CL_USHORT8__) + __cl_ushort8 v8[2]; +#endif +#if defined(__CL_USHORT16__) + __cl_ushort16 v16; +#endif + } cl_ushort16; + + /* ---- cl_intn ---- */ + typedef union + { + cl_int CL_ALIGNED(8) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_int x, y; + }; + + __extension__ struct + { + cl_int s0, s1; + }; + + __extension__ struct + { + cl_int lo, hi; + }; +#endif +#if defined(__CL_INT2__) + __cl_int2 v2; +#endif + } cl_int2; + + typedef union + { + cl_int CL_ALIGNED(16) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_int x, y, z, w; + }; + + __extension__ struct + { + cl_int s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_int2 lo, hi; + }; +#endif +#if defined(__CL_INT2__) + __cl_int2 v2[2]; +#endif +#if defined(__CL_INT4__) + __cl_int4 v4; +#endif + } cl_int4; + + /* cl_int3 is identical in size, alignment and behavior to cl_int4. See section 6.1.5. */ + typedef cl_int4 cl_int3; + + typedef union + { + cl_int CL_ALIGNED(32) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_int x, y, z, w; + }; + + __extension__ struct + { + cl_int s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_int4 lo, hi; + }; +#endif +#if defined(__CL_INT2__) + __cl_int2 v2[4]; +#endif +#if defined(__CL_INT4__) + __cl_int4 v4[2]; +#endif +#if defined(__CL_INT8__) + __cl_int8 v8; +#endif + } cl_int8; + + typedef union + { + cl_int CL_ALIGNED(64) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_int x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_int s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_int8 lo, hi; + }; +#endif +#if defined(__CL_INT2__) + __cl_int2 v2[8]; +#endif +#if defined(__CL_INT4__) + __cl_int4 v4[4]; +#endif +#if defined(__CL_INT8__) + __cl_int8 v8[2]; +#endif +#if defined(__CL_INT16__) + __cl_int16 v16; +#endif + } cl_int16; + + /* ---- cl_uintn ---- */ + typedef union + { + cl_uint CL_ALIGNED(8) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uint x, y; + }; + + __extension__ struct + { + cl_uint s0, s1; + }; + + __extension__ struct + { + cl_uint lo, hi; + }; +#endif +#if defined(__CL_UINT2__) + __cl_uint2 v2; +#endif + } cl_uint2; + + typedef union + { + cl_uint CL_ALIGNED(16) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uint x, y, z, w; + }; + + __extension__ struct + { + cl_uint s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_uint2 lo, hi; + }; +#endif +#if defined(__CL_UINT2__) + __cl_uint2 v2[2]; +#endif +#if defined(__CL_UINT4__) + __cl_uint4 v4; +#endif + } cl_uint4; + + /* cl_uint3 is identical in size, alignment and behavior to cl_uint4. See section 6.1.5. */ + typedef cl_uint4 cl_uint3; + + typedef union + { + cl_uint CL_ALIGNED(32) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uint x, y, z, w; + }; + + __extension__ struct + { + cl_uint s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_uint4 lo, hi; + }; +#endif +#if defined(__CL_UINT2__) + __cl_uint2 v2[4]; +#endif +#if defined(__CL_UINT4__) + __cl_uint4 v4[2]; +#endif +#if defined(__CL_UINT8__) + __cl_uint8 v8; +#endif + } cl_uint8; + + typedef union + { + cl_uint CL_ALIGNED(64) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_uint x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_uint s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_uint8 lo, hi; + }; +#endif +#if defined(__CL_UINT2__) + __cl_uint2 v2[8]; +#endif +#if defined(__CL_UINT4__) + __cl_uint4 v4[4]; +#endif +#if defined(__CL_UINT8__) + __cl_uint8 v8[2]; +#endif +#if defined(__CL_UINT16__) + __cl_uint16 v16; +#endif + } cl_uint16; + + /* ---- cl_longn ---- */ + typedef union + { + cl_long CL_ALIGNED(16) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_long x, y; + }; + + __extension__ struct + { + cl_long s0, s1; + }; + + __extension__ struct + { + cl_long lo, hi; + }; +#endif +#if defined(__CL_LONG2__) + __cl_long2 v2; +#endif + } cl_long2; + + typedef union + { + cl_long CL_ALIGNED(32) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_long x, y, z, w; + }; + + __extension__ struct + { + cl_long s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_long2 lo, hi; + }; +#endif +#if defined(__CL_LONG2__) + __cl_long2 v2[2]; +#endif +#if defined(__CL_LONG4__) + __cl_long4 v4; +#endif + } cl_long4; + + /* cl_long3 is identical in size, alignment and behavior to cl_long4. See section 6.1.5. */ + typedef cl_long4 cl_long3; + + typedef union + { + cl_long CL_ALIGNED(64) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_long x, y, z, w; + }; + + __extension__ struct + { + cl_long s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_long4 lo, hi; + }; +#endif +#if defined(__CL_LONG2__) + __cl_long2 v2[4]; +#endif +#if defined(__CL_LONG4__) + __cl_long4 v4[2]; +#endif +#if defined(__CL_LONG8__) + __cl_long8 v8; +#endif + } cl_long8; + + typedef union + { + cl_long CL_ALIGNED(128) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_long x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_long s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_long8 lo, hi; + }; +#endif +#if defined(__CL_LONG2__) + __cl_long2 v2[8]; +#endif +#if defined(__CL_LONG4__) + __cl_long4 v4[4]; +#endif +#if defined(__CL_LONG8__) + __cl_long8 v8[2]; +#endif +#if defined(__CL_LONG16__) + __cl_long16 v16; +#endif + } cl_long16; + + /* ---- cl_ulongn ---- */ + typedef union + { + cl_ulong CL_ALIGNED(16) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ulong x, y; + }; + + __extension__ struct + { + cl_ulong s0, s1; + }; + + __extension__ struct + { + cl_ulong lo, hi; + }; +#endif +#if defined(__CL_ULONG2__) + __cl_ulong2 v2; +#endif + } cl_ulong2; + + typedef union + { + cl_ulong CL_ALIGNED(32) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ulong x, y, z, w; + }; + + __extension__ struct + { + cl_ulong s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_ulong2 lo, hi; + }; +#endif +#if defined(__CL_ULONG2__) + __cl_ulong2 v2[2]; +#endif +#if defined(__CL_ULONG4__) + __cl_ulong4 v4; +#endif + } cl_ulong4; + + /* cl_ulong3 is identical in size, alignment and behavior to cl_ulong4. See section 6.1.5. */ + typedef cl_ulong4 cl_ulong3; + + typedef union + { + cl_ulong CL_ALIGNED(64) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ulong x, y, z, w; + }; + + __extension__ struct + { + cl_ulong s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_ulong4 lo, hi; + }; +#endif +#if defined(__CL_ULONG2__) + __cl_ulong2 v2[4]; +#endif +#if defined(__CL_ULONG4__) + __cl_ulong4 v4[2]; +#endif +#if defined(__CL_ULONG8__) + __cl_ulong8 v8; +#endif + } cl_ulong8; + + typedef union + { + cl_ulong CL_ALIGNED(128) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_ulong x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_ulong s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_ulong8 lo, hi; + }; +#endif +#if defined(__CL_ULONG2__) + __cl_ulong2 v2[8]; +#endif +#if defined(__CL_ULONG4__) + __cl_ulong4 v4[4]; +#endif +#if defined(__CL_ULONG8__) + __cl_ulong8 v8[2]; +#endif +#if defined(__CL_ULONG16__) + __cl_ulong16 v16; +#endif + } cl_ulong16; + + /* --- cl_floatn ---- */ + + typedef union + { + cl_float CL_ALIGNED(8) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_float x, y; + }; + + __extension__ struct + { + cl_float s0, s1; + }; + + __extension__ struct + { + cl_float lo, hi; + }; +#endif +#if defined(__CL_FLOAT2__) + __cl_float2 v2; +#endif + } cl_float2; + + typedef union + { + cl_float CL_ALIGNED(16) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_float x, y, z, w; + }; + + __extension__ struct + { + cl_float s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_float2 lo, hi; + }; +#endif +#if defined(__CL_FLOAT2__) + __cl_float2 v2[2]; +#endif +#if defined(__CL_FLOAT4__) + __cl_float4 v4; +#endif + } cl_float4; + + /* cl_float3 is identical in size, alignment and behavior to cl_float4. See section 6.1.5. */ + typedef cl_float4 cl_float3; + + typedef union + { + cl_float CL_ALIGNED(32) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_float x, y, z, w; + }; + + __extension__ struct + { + cl_float s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_float4 lo, hi; + }; +#endif +#if defined(__CL_FLOAT2__) + __cl_float2 v2[4]; +#endif +#if defined(__CL_FLOAT4__) + __cl_float4 v4[2]; +#endif +#if defined(__CL_FLOAT8__) + __cl_float8 v8; +#endif + } cl_float8; + + typedef union + { + cl_float CL_ALIGNED(64) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_float x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_float s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_float8 lo, hi; + }; +#endif +#if defined(__CL_FLOAT2__) + __cl_float2 v2[8]; +#endif +#if defined(__CL_FLOAT4__) + __cl_float4 v4[4]; +#endif +#if defined(__CL_FLOAT8__) + __cl_float8 v8[2]; +#endif +#if defined(__CL_FLOAT16__) + __cl_float16 v16; +#endif + } cl_float16; + + /* --- cl_doublen ---- */ + + typedef union + { + cl_double CL_ALIGNED(16) s[2]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_double x, y; + }; + + __extension__ struct + { + cl_double s0, s1; + }; + + __extension__ struct + { + cl_double lo, hi; + }; +#endif +#if defined(__CL_DOUBLE2__) + __cl_double2 v2; +#endif + } cl_double2; + + typedef union + { + cl_double CL_ALIGNED(32) s[4]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_double x, y, z, w; + }; + + __extension__ struct + { + cl_double s0, s1, s2, s3; + }; + + __extension__ struct + { + cl_double2 lo, hi; + }; +#endif +#if defined(__CL_DOUBLE2__) + __cl_double2 v2[2]; +#endif +#if defined(__CL_DOUBLE4__) + __cl_double4 v4; +#endif + } cl_double4; + + /* cl_double3 is identical in size, alignment and behavior to cl_double4. See section 6.1.5. */ + typedef cl_double4 cl_double3; + + typedef union + { + cl_double CL_ALIGNED(64) s[8]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_double x, y, z, w; + }; + + __extension__ struct + { + cl_double s0, s1, s2, s3, s4, s5, s6, s7; + }; + + __extension__ struct + { + cl_double4 lo, hi; + }; +#endif +#if defined(__CL_DOUBLE2__) + __cl_double2 v2[4]; +#endif +#if defined(__CL_DOUBLE4__) + __cl_double4 v4[2]; +#endif +#if defined(__CL_DOUBLE8__) + __cl_double8 v8; +#endif + } cl_double8; + + typedef union + { + cl_double CL_ALIGNED(128) s[16]; +#if (defined(__GNUC__) || defined(__IBMC__)) && !defined(__STRICT_ANSI__) + __extension__ struct + { + cl_double x, y, z, w, __spacer4, __spacer5, __spacer6, __spacer7, __spacer8, __spacer9, sa, sb, sc, sd, se, sf; + }; + + __extension__ struct + { + cl_double s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, sA, sB, sC, sD, sE, sF; + }; + + __extension__ struct + { + cl_double8 lo, hi; + }; +#endif +#if defined(__CL_DOUBLE2__) + __cl_double2 v2[8]; +#endif +#if defined(__CL_DOUBLE4__) + __cl_double4 v4[4]; +#endif +#if defined(__CL_DOUBLE8__) + __cl_double8 v8[2]; +#endif +#if defined(__CL_DOUBLE16__) + __cl_double16 v16; +#endif + } cl_double16; + +/* Macro to facilitate debugging + * Usage: + * Place CL_PROGRAM_STRING_DEBUG_INFO on the line before the first line of your source. + * The first line ends with: CL_PROGRAM_STRING_BEGIN \" + * Each line thereafter of OpenCL C source must end with: \n\ + * The last line ends in "; + * + * Example: + * + * const char *my_program = CL_PROGRAM_STRING_BEGIN "\ + * kernel void foo( int a, float * b ) \n\ + * { \n\ + * // my comment \n\ + * *b[ get_global_id(0)] = a; \n\ + * } \n\ + * "; + * + * This should correctly set up the line, (column) and file information for your source + * string so you can do source level debugging. + */ +#define __CL_STRINGIFY(_x) #_x +#define _CL_STRINGIFY(_x) __CL_STRINGIFY(_x) +#define CL_PROGRAM_STRING_DEBUG_INFO "#line " _CL_STRINGIFY(__LINE__) " \"" __FILE__ "\" \n\n" + +#ifdef __cplusplus +} +#endif + +#endif /* __CL_PLATFORM_H */ diff --git a/src/lib/image/MovieRED/CL/opencl.h b/src/lib/image/MovieRED/CL/opencl.h new file mode 100644 index 00000000..bffb4f73 --- /dev/null +++ b/src/lib/image/MovieRED/CL/opencl.h @@ -0,0 +1,54 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */ + +#ifndef __OPENCL_H +#define __OPENCL_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __APPLE__ + +#include +#include +#include +#include + +#else + +#include +#include +#include +#include + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_H */ diff --git a/src/lib/image/MovieRED/CMakeLists.txt b/src/lib/image/MovieRED/CMakeLists.txt index 86cf5bdc..c5709267 100644 --- a/src/lib/image/MovieRED/CMakeLists.txt +++ b/src/lib/image/MovieRED/CMakeLists.txt @@ -9,7 +9,7 @@ SET(_target ) SET(_sources - MovieRED.cpp + MovieRED.cpp MovieREDGpu.cpp MovieREDOpenCL.cpp ) FIND_PACKAGE( diff --git a/src/lib/image/MovieRED/MovieRED.cpp b/src/lib/image/MovieRED/MovieRED.cpp index ebea7a88..f4b78deb 100644 --- a/src/lib/image/MovieRED/MovieRED.cpp +++ b/src/lib/image/MovieRED/MovieRED.cpp @@ -14,9 +14,7 @@ #include #include -#if defined(__APPLE__) -#include -#endif +#include #include #include @@ -287,7 +285,7 @@ namespace TwkMovie #if defined(__APPLE__) unsigned int options = OPTION_RED_METAL; #else - unsigned int options = OPTION_RED_NONE; + unsigned int options = OPTION_RED_OPENCL; #endif R3DSDK::InitializeStatus st = R3DSDK::InitializeSdk(dir.c_str(), options); if (st != R3DSDK::ISInitializeOK && options != OPTION_RED_NONE) @@ -301,12 +299,10 @@ namespace TwkMovie { s_redInitialized = true; std::cout << "INFO: Initialized RED SDK from " << dir << ": " << R3DSDK::GetSdkVersion() << std::endl; -#if defined(__APPLE__) - if (options & OPTION_RED_METAL) + if (options != OPTION_RED_NONE) { - REDMetalGpu::init(dir.c_str()); + REDGpu::init(dir.c_str()); } -#endif s_lastREDInitError.clear(); return true; } @@ -784,13 +780,10 @@ namespace TwkMovie R3DSDK::Metadata frameMeta; bool decodedOnGpu = false; -#if defined(__APPLE__) - if (m_impl->useGpu && REDMetalGpu::isAvailable() && pixelFormat != RGBA8) + if (m_impl->useGpu && REDGpu::isAvailable() && pixelFormat != RGBA8) { - decodedOnGpu = - REDMetalGpu::debayerFrame(m_impl->clip.get(), videoFrameNo, jobMode, jobPixelType, imgBuffer, memNeeded, &frameMeta); + decodedOnGpu = REDGpu::debayerFrame(m_impl->clip.get(), videoFrameNo, jobMode, jobPixelType, imgBuffer, memNeeded, &frameMeta); } -#endif if (!decodedOnGpu) { diff --git a/src/lib/image/MovieRED/MovieRED/MovieREDGpu.h b/src/lib/image/MovieRED/MovieRED/MovieREDGpu.h new file mode 100644 index 00000000..8802e228 --- /dev/null +++ b/src/lib/image/MovieRED/MovieRED/MovieREDGpu.h @@ -0,0 +1,33 @@ +//****************************************************************************** +// Copyright (c) 2026 Makai Systems and OpenUTV Contributors. All rights reserved. +// +// SPDX-License-Identifier: Apache-2.0 +// +//****************************************************************************** + +#ifndef __MovieRED__MovieREDGpu__h__ +#define __MovieRED__MovieREDGpu__h__ + +#include +#include + +namespace R3DSDK +{ + class Clip; + class Metadata; +} // namespace R3DSDK + +namespace TwkMovie +{ + namespace REDGpu + { + bool isAvailable(); + bool init(const char* libPath); + void shutdown(); + bool debayerFrame(R3DSDK::Clip* clip, size_t frameNo, uint32_t decodeMode, uint32_t pixelType, unsigned char* outBuffer, + size_t outBufferSize, R3DSDK::Metadata* outFrameMetadata = nullptr); + const char* backendName(); + } // namespace REDGpu +} // namespace TwkMovie + +#endif // __MovieRED__MovieREDGpu__h__ diff --git a/src/lib/image/MovieRED/MovieRED/MovieREDOpenCL.h b/src/lib/image/MovieRED/MovieRED/MovieREDOpenCL.h new file mode 100644 index 00000000..c110414e --- /dev/null +++ b/src/lib/image/MovieRED/MovieRED/MovieREDOpenCL.h @@ -0,0 +1,33 @@ +//****************************************************************************** +// Copyright (c) 2026 Makai Systems and OpenUTV Contributors. All rights reserved. +// +// SPDX-License-Identifier: Apache-2.0 +// +//****************************************************************************** + +#ifndef __MovieRED__MovieREDOpenCL__h__ +#define __MovieRED__MovieREDOpenCL__h__ + +#include +#include + +namespace R3DSDK +{ + class Clip; + class Metadata; +} // namespace R3DSDK + +namespace TwkMovie +{ + namespace REDOpenCLGpu + { + bool isAvailable(); + bool init(const char* libPath); + void shutdown(); + bool debayerFrame(R3DSDK::Clip* clip, size_t frameNo, uint32_t decodeMode, uint32_t pixelType, unsigned char* outBuffer, + size_t outBufferSize, R3DSDK::Metadata* outFrameMetadata = nullptr); + const char* deviceName(); + } // namespace REDOpenCLGpu +} // namespace TwkMovie + +#endif // __MovieRED__MovieREDOpenCL__h__ diff --git a/src/lib/image/MovieRED/MovieREDGpu.cpp b/src/lib/image/MovieRED/MovieREDGpu.cpp new file mode 100644 index 00000000..8355ffd2 --- /dev/null +++ b/src/lib/image/MovieRED/MovieREDGpu.cpp @@ -0,0 +1,71 @@ +//****************************************************************************** +// Copyright (c) 2026 Makai Systems and OpenUTV Contributors. All rights reserved. +// +// SPDX-License-Identifier: Apache-2.0 +// +//****************************************************************************** + +#include +#if defined(__APPLE__) +#include +#endif +#include + +namespace TwkMovie +{ + namespace REDGpu + { + bool isAvailable() + { +#if defined(__APPLE__) + if (REDMetalGpu::isAvailable()) + return true; +#endif + return REDOpenCLGpu::isAvailable(); + } + + bool init(const char* libPath) + { +#if defined(__APPLE__) + if (REDMetalGpu::init(libPath)) + return true; +#endif + return REDOpenCLGpu::init(libPath); + } + + void shutdown() + { +#if defined(__APPLE__) + REDMetalGpu::shutdown(); +#endif + REDOpenCLGpu::shutdown(); + } + + bool debayerFrame(R3DSDK::Clip* clip, size_t frameNo, uint32_t decodeMode, uint32_t pixelType, unsigned char* outBuffer, + size_t outBufferSize, R3DSDK::Metadata* outFrameMetadata) + { +#if defined(__APPLE__) + if (REDMetalGpu::isAvailable()) + { + return REDMetalGpu::debayerFrame(clip, frameNo, decodeMode, pixelType, outBuffer, outBufferSize, outFrameMetadata); + } +#endif + if (REDOpenCLGpu::isAvailable()) + { + return REDOpenCLGpu::debayerFrame(clip, frameNo, decodeMode, pixelType, outBuffer, outBufferSize, outFrameMetadata); + } + return false; + } + + const char* backendName() + { +#if defined(__APPLE__) + if (REDMetalGpu::isAvailable()) + return "Metal"; +#endif + if (REDOpenCLGpu::isAvailable()) + return "OpenCL"; + return "None"; + } + } // namespace REDGpu +} // namespace TwkMovie diff --git a/src/lib/image/MovieRED/MovieREDOpenCL.cpp b/src/lib/image/MovieRED/MovieREDOpenCL.cpp new file mode 100644 index 00000000..fb713f70 --- /dev/null +++ b/src/lib/image/MovieRED/MovieREDOpenCL.cpp @@ -0,0 +1,464 @@ +//****************************************************************************** +// Copyright (c) 2026 Makai Systems and OpenUTV Contributors. All rights reserved. +// +// SPDX-License-Identifier: Apache-2.0 +// +//****************************************************************************** + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#if defined(_WIN32) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif +#include +#else +#include +#endif + +namespace TwkMovie +{ + namespace REDOpenCLGpu + { + static std::mutex s_openclMutex; + static bool s_initialized = false; + static std::string s_deviceName; + +#if defined(_WIN32) + static HMODULE s_clModule = NULL; +#else + static void* s_clModule = nullptr; +#endif + + static R3DSDK::EXT_OCLAPI_1_1 s_api; + static cl_context s_context = nullptr; + static cl_command_queue s_queue = nullptr; + static R3DSDK::REDCL* s_redcl = nullptr; + static R3DSDK::AsyncDecoder* s_asyncDecoder = nullptr; + + // Persistent host and device buffers + static unsigned char* s_rawHostBufferBase = nullptr; + static unsigned char* s_rawHostBuffer = nullptr; + static size_t s_rawHostSize = 0; + + static cl_mem s_rawDeviceBuffer = nullptr; + static size_t s_rawDeviceBufferSize = 0; + + static cl_mem s_outDeviceBuffer = nullptr; + static size_t s_outDeviceBufferSize = 0; + + struct FrameCallbackSync + { + std::mutex mtx; + std::condition_variable cv; + bool done = false; + R3DSDK::DecodeStatus status = R3DSDK::DSOutputBufferInvalid; + }; + + static void* loadSymbol(const char* name) + { + if (!s_clModule) + return nullptr; +#if defined(_WIN32) + return reinterpret_cast(GetProcAddress(s_clModule, name)); +#else + return dlsym(s_clModule, name); +#endif + } + + static void ensureHostBuffer(size_t sizeNeeded) + { + if (s_rawHostSize >= sizeNeeded && s_rawHostBuffer) + return; + + if (s_rawHostBufferBase) + { + free(s_rawHostBufferBase); + s_rawHostBufferBase = nullptr; + s_rawHostBuffer = nullptr; + s_rawHostSize = 0; + } + + size_t allocSize = sizeNeeded + 32; + s_rawHostBufferBase = static_cast(malloc(allocSize)); + if (!s_rawHostBufferBase) + return; + + uintptr_t ptr = reinterpret_cast(s_rawHostBufferBase); + size_t offset = (16U - (ptr % 16U)) % 16U; + s_rawHostBuffer = s_rawHostBufferBase + offset; + s_rawHostSize = sizeNeeded; + } + + bool isAvailable() { return s_initialized && (s_redcl != nullptr) && (s_asyncDecoder != nullptr); } + + const char* deviceName() { return s_deviceName.c_str(); } + + bool init(const char* /*libPath*/) + { + std::lock_guard lock(s_openclMutex); + if (s_initialized) + return true; + + // 1. Load system OpenCL library dynamically +#if defined(_WIN32) + s_clModule = LoadLibraryA("OpenCL.dll"); +#elif defined(__APPLE__) + s_clModule = dlopen("/System/Library/Frameworks/OpenCL.framework/OpenCL", RTLD_NOW | RTLD_LOCAL); +#else + s_clModule = dlopen("libOpenCL.so.1", RTLD_NOW | RTLD_LOCAL); + if (!s_clModule) + s_clModule = dlopen("libOpenCL.so", RTLD_NOW | RTLD_LOCAL); +#endif + + if (!s_clModule) + return false; + + // 2. Resolve required OpenCL API functions into s_api struct +#define RESOLVE_CL(fn) \ + s_api.fn = reinterpret_cast(loadSymbol(#fn)); \ + if (!s_api.fn) \ + { \ + return false; \ + } + + RESOLVE_CL(clSetKernelArg); + RESOLVE_CL(clFlush); + RESOLVE_CL(clFinish); + RESOLVE_CL(clEnqueueCopyImage); + RESOLVE_CL(clCreateContext); + RESOLVE_CL(clCreateCommandQueue); + RESOLVE_CL(clCreateSampler); + RESOLVE_CL(clCreateKernel); + RESOLVE_CL(clCreateBuffer); + RESOLVE_CL(clCreateProgramWithSource); + RESOLVE_CL(clCreateProgramWithBinary); + RESOLVE_CL(clReleaseEvent); + RESOLVE_CL(clReleaseSampler); + RESOLVE_CL(clReleaseKernel); + RESOLVE_CL(clReleaseMemObject); + RESOLVE_CL(clReleaseProgram); + RESOLVE_CL(clReleaseContext); + RESOLVE_CL(clReleaseCommandQueue); + RESOLVE_CL(clGetPlatformInfo); + RESOLVE_CL(clGetDeviceIDs); + RESOLVE_CL(clGetPlatformIDs); + RESOLVE_CL(clGetDeviceInfo); + RESOLVE_CL(clGetContextInfo); + RESOLVE_CL(clGetImageInfo); + RESOLVE_CL(clGetProgramBuildInfo); + RESOLVE_CL(clGetProgramInfo); + RESOLVE_CL(clGetKernelWorkGroupInfo); + RESOLVE_CL(clBuildProgram); + RESOLVE_CL(clEnqueueWriteBuffer); + RESOLVE_CL(clEnqueueReadBuffer); + RESOLVE_CL(clEnqueueCopyBuffer); + RESOLVE_CL(clEnqueueCopyBufferToImage); + RESOLVE_CL(clEnqueueWriteImage); + RESOLVE_CL(clEnqueueNDRangeKernel); + RESOLVE_CL(clEnqueueMapBuffer); + RESOLVE_CL(clEnqueueUnmapMemObject); + RESOLVE_CL(clWaitForEvents); + RESOLVE_CL(clEnqueueBarrier); + RESOLVE_CL(clEnqueueMarker); + RESOLVE_CL(clCreateImage2D); + RESOLVE_CL(clSetMemObjectDestructorCallback); + RESOLVE_CL(clCreateSubBuffer); +#undef RESOLVE_CL + + // 3. Query GPU device + cl_uint numPlatforms = 0; + if (s_api.clGetPlatformIDs(0, nullptr, &numPlatforms) != CL_SUCCESS || numPlatforms == 0) + return false; + + std::vector platforms(numPlatforms); + if (s_api.clGetPlatformIDs(numPlatforms, platforms.data(), nullptr) != CL_SUCCESS) + return false; + + cl_device_id gpuDevice = nullptr; + for (cl_uint i = 0; i < numPlatforms && !gpuDevice; ++i) + { + cl_uint numDevices = 0; + if (s_api.clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_GPU, 0, nullptr, &numDevices) == CL_SUCCESS && numDevices > 0) + { + std::vector devices(numDevices); + if (s_api.clGetDeviceIDs(platforms[i], CL_DEVICE_TYPE_GPU, numDevices, devices.data(), nullptr) == CL_SUCCESS) + { + gpuDevice = devices[0]; + } + } + } + + if (!gpuDevice) + return false; + + char devNameBuf[256] = {0}; + s_api.clGetDeviceInfo(gpuDevice, CL_DEVICE_NAME, sizeof(devNameBuf) - 1, devNameBuf, nullptr); + s_deviceName = devNameBuf; + + cl_int clerr = 0; + s_context = s_api.clCreateContext(nullptr, 1, &gpuDevice, nullptr, nullptr, &clerr); + if (clerr != CL_SUCCESS || !s_context) + return false; + + s_queue = s_api.clCreateCommandQueue(s_context, gpuDevice, 0, &clerr); + if (clerr != CL_SUCCESS || !s_queue) + { + s_api.clReleaseContext(s_context); + s_context = nullptr; + return false; + } + + try + { + s_redcl = new R3DSDK::REDCL(s_api, ""); + } + catch (const std::exception& e) + { + std::cerr << "REDOpenCL: Exception creating REDCL: " << e.what() << std::endl; + s_api.clReleaseCommandQueue(s_queue); + s_api.clReleaseContext(s_context); + s_queue = nullptr; + s_context = nullptr; + return false; + } + + R3DSDK::REDCL::Status status = s_redcl->checkCompatibility(s_context, s_queue, clerr); + if (status != R3DSDK::REDCL::Status_Ok) + { + std::cerr << "REDOpenCL: Device compatibility check failed on " << s_deviceName << " (status: " << status + << ", clerr: " << clerr << ")" << std::endl; + delete s_redcl; + s_redcl = nullptr; + s_api.clReleaseCommandQueue(s_queue); + s_api.clReleaseContext(s_context); + s_queue = nullptr; + s_context = nullptr; + return false; + } + + try + { + s_asyncDecoder = new R3DSDK::AsyncDecoder(); + } + catch (const std::exception& e) + { + std::cerr << "REDOpenCL: Failed to initialize AsyncDecoder: " << e.what() << std::endl; + delete s_redcl; + s_redcl = nullptr; + s_api.clReleaseCommandQueue(s_queue); + s_api.clReleaseContext(s_context); + s_queue = nullptr; + s_context = nullptr; + return false; + } + + s_initialized = true; + std::cout << "INFO: Initialized REDOpenCL GPU debayering on " << s_deviceName << std::endl; + return true; + } + + void shutdown() + { + std::lock_guard lock(s_openclMutex); + if (s_asyncDecoder) + { + s_asyncDecoder->Close(); + delete s_asyncDecoder; + s_asyncDecoder = nullptr; + } + + if (s_redcl) + { + delete s_redcl; + s_redcl = nullptr; + } + + if (s_rawDeviceBuffer && s_api.clReleaseMemObject) + { + s_api.clReleaseMemObject(s_rawDeviceBuffer); + s_rawDeviceBuffer = nullptr; + s_rawDeviceBufferSize = 0; + } + + if (s_outDeviceBuffer && s_api.clReleaseMemObject) + { + s_api.clReleaseMemObject(s_outDeviceBuffer); + s_outDeviceBuffer = nullptr; + s_outDeviceBufferSize = 0; + } + + if (s_rawHostBufferBase) + { + free(s_rawHostBufferBase); + s_rawHostBufferBase = nullptr; + s_rawHostBuffer = nullptr; + s_rawHostSize = 0; + } + + if (s_queue && s_api.clReleaseCommandQueue) + { + s_api.clReleaseCommandQueue(s_queue); + s_queue = nullptr; + } + + if (s_context && s_api.clReleaseContext) + { + s_api.clReleaseContext(s_context); + s_context = nullptr; + } + +#if defined(_WIN32) + if (s_clModule) + { + FreeLibrary(s_clModule); + s_clModule = NULL; + } +#else + if (s_clModule) + { + dlclose(s_clModule); + s_clModule = nullptr; + } +#endif + s_initialized = false; + } + + bool debayerFrame(R3DSDK::Clip* clip, size_t frameNo, uint32_t decodeMode, uint32_t pixelType, unsigned char* outBuffer, + size_t outBufferSize, R3DSDK::Metadata* outFrameMetadata) + { + if (!isAvailable() || !clip || !outBuffer) + return false; + + std::lock_guard lock(s_openclMutex); + + R3DSDK::VideoDecodeMode vmode = static_cast(decodeMode); + R3DSDK::VideoPixelType vpixel = static_cast(pixelType); + + R3DSDK::AsyncDecompressJob decompressJob; + decompressJob.Clip = clip; + decompressJob.Mode = vmode; + decompressJob.VideoTrackNo = 0; + decompressJob.VideoFrameNo = frameNo; + decompressJob.OutputFrameMetadata = outFrameMetadata; + + size_t rawSize = R3DSDK::AsyncDecoder::GetSizeBufferNeeded(decompressJob); + if (rawSize == 0) + return false; + + ensureHostBuffer(rawSize); + if (!s_rawHostBuffer) + return false; + + decompressJob.OutputBuffer = s_rawHostBuffer; + decompressJob.OutputBufferSize = rawSize; + + FrameCallbackSync syncCtx; + decompressJob.PrivateData = &syncCtx; + decompressJob.Callback = [](R3DSDK::AsyncDecompressJob* item, R3DSDK::DecodeStatus status) + { + if (item && item->PrivateData) + { + auto* ctx = static_cast(item->PrivateData); + std::lock_guard lk(ctx->mtx); + ctx->status = status; + ctx->done = true; + ctx->cv.notify_one(); + } + }; + + R3DSDK::DecodeStatus dstatus = s_asyncDecoder->DecodeForGpuSdk(decompressJob); + if (dstatus != R3DSDK::DSDecodeOK) + return false; + + { + std::unique_lock lk(syncCtx.mtx); + syncCtx.cv.wait(lk, [&] { return syncCtx.done; }); + } + + if (syncCtx.status != R3DSDK::DSDecodeOK) + return false; + + // Ensure raw OpenCL device buffer + cl_int clerr = 0; + if (!s_rawDeviceBuffer || s_rawDeviceBufferSize < rawSize) + { + if (s_rawDeviceBuffer) + s_api.clReleaseMemObject(s_rawDeviceBuffer); + s_rawDeviceBuffer = s_api.clCreateBuffer(s_context, CL_MEM_READ_ONLY, rawSize, nullptr, &clerr); + if (clerr != CL_SUCCESS || !s_rawDeviceBuffer) + return false; + s_rawDeviceBufferSize = rawSize; + } + + clerr = s_api.clEnqueueWriteBuffer(s_queue, s_rawDeviceBuffer, CL_TRUE, 0, rawSize, s_rawHostBuffer, 0, nullptr, nullptr); + if (clerr != CL_SUCCESS) + return false; + + R3DSDK::DebayerOpenCLJob* debayerJob = s_redcl->createDebayerJob(); + if (!debayerJob) + return false; + + debayerJob->imageProcessingSettings = new R3DSDK::ImageProcessingSettings(); + clip->GetDefaultImageProcessingSettings(*(debayerJob->imageProcessingSettings)); + debayerJob->mode = vmode; + debayerJob->pixelType = vpixel; + debayerJob->raw_host_mem = s_rawHostBuffer; + debayerJob->raw_device_mem = s_rawDeviceBuffer; + + size_t resultSize = R3DSDK::DebayerOpenCLJob::ResultFrameSize(*debayerJob); + if (resultSize == 0) + { + delete debayerJob->imageProcessingSettings; + s_redcl->releaseDebayerJob(debayerJob); + return false; + } + + // Ensure output OpenCL device buffer + if (!s_outDeviceBuffer || s_outDeviceBufferSize < resultSize) + { + if (s_outDeviceBuffer) + s_api.clReleaseMemObject(s_outDeviceBuffer); + s_outDeviceBuffer = s_api.clCreateBuffer(s_context, CL_MEM_WRITE_ONLY, resultSize, nullptr, &clerr); + if (clerr != CL_SUCCESS || !s_outDeviceBuffer) + { + delete debayerJob->imageProcessingSettings; + s_redcl->releaseDebayerJob(debayerJob); + return false; + } + s_outDeviceBufferSize = resultSize; + } + + debayerJob->output_device_mem = s_outDeviceBuffer; + debayerJob->output_device_mem_size = resultSize; + + R3DSDK::REDCL::Status status = s_redcl->process(s_context, s_queue, debayerJob, clerr); + bool success = (status == R3DSDK::REDCL::Status_Ok); + + if (success) + { + size_t copyBytes = std::min(outBufferSize, resultSize); + clerr = s_api.clEnqueueReadBuffer(s_queue, s_outDeviceBuffer, CL_TRUE, 0, copyBytes, outBuffer, 0, nullptr, nullptr); + if (clerr != CL_SUCCESS) + success = false; + } + + delete debayerJob->imageProcessingSettings; + s_redcl->releaseDebayerJob(debayerJob); + return success; + } + + } // namespace REDOpenCLGpu +} // namespace TwkMovie diff --git a/src/plugins/rv-packages/r3d_settings/r3d_settings.py b/src/plugins/rv-packages/r3d_settings/r3d_settings.py index 60e182b6..a077cc1d 100644 --- a/src/plugins/rv-packages/r3d_settings/r3d_settings.py +++ b/src/plugins/rv-packages/r3d_settings/r3d_settings.py @@ -18,31 +18,59 @@ def isGPUSupported(): """ Check whether hardware-accelerated RED GPU debayering is supported on this system. + Supports Apple Metal on macOS and OpenCL on Windows, Linux, and macOS. Returns True if supported, False otherwise. """ global _gpu_supported_cache if _gpu_supported_cache is not None: return _gpu_supported_cache - if sys.platform != "darwin": - # Currently, hardware RED debayering in MovieRED is Metal-accelerated on macOS. - # CUDA / OpenCL debayering on Windows/Linux will be detected here once enabled. - _gpu_supported_cache = False - return False + # 1. Check for hardware GPU framework/driver capability + has_gpu_runtime = False + if sys.platform == "darwin": + try: + metal = ctypes.cdll.LoadLibrary("/System/Library/Frameworks/Metal.framework/Metal") + metal.MTLCreateSystemDefaultDevice.restype = ctypes.c_void_p + dev = metal.MTLCreateSystemDefaultDevice() + if dev: + has_gpu_runtime = True + except Exception: + pass + + if not has_gpu_runtime: + # Check OpenCL across Windows, Linux, and macOS + opencl_names = [] + if sys.platform == "win32": + opencl_names = ["OpenCL.dll"] + elif sys.platform == "darwin": + opencl_names = ["/System/Library/Frameworks/OpenCL.framework/OpenCL"] + else: + opencl_names = ["libOpenCL.so.1", "libOpenCL.so"] + + for name in opencl_names: + try: + ctypes.cdll.LoadLibrary(name) + has_gpu_runtime = True + break + except Exception: + pass - # 1. Check for Metal hardware capability via Metal framework - try: - metal = ctypes.cdll.LoadLibrary("/System/Library/Frameworks/Metal.framework/Metal") - metal.MTLCreateSystemDefaultDevice.restype = ctypes.c_void_p - dev = metal.MTLCreateSystemDefaultDevice() - if not dev: - _gpu_supported_cache = False - return False - except Exception: + if not has_gpu_runtime: _gpu_supported_cache = False return False - # 2. Check for REDMetal dynamic library in known search paths + # 2. Check for matching RED dynamic GPU library in known search paths + # macOS: REDMetal.dylib or REDOpenCL.dylib + # Windows: REDOpenCL-x64.dll or REDCuda-x64.dll + # Linux: REDOpenCL-x64.so or REDCuda-x64.so + target_gpu_libs = [] + if sys.platform == "darwin": + target_gpu_libs = ["REDMetal.dylib", "REDOpenCL.dylib"] + elif sys.platform == "win32": + target_gpu_libs = ["REDOpenCL-x64.dll", "REDCuda-x64.dll"] + else: + target_gpu_libs = ["REDOpenCL-x64.so", "REDCuda-x64.so"] + search_dirs = [] if os.environ.get("RED_SDK_PATH"): search_dirs.append(os.environ["RED_SDK_PATH"]) @@ -53,6 +81,7 @@ def isGPUSupported(): exe_dir = os.path.dirname(os.path.abspath(sys.executable)) search_dirs.append(exe_dir) search_dirs.append(os.path.join(exe_dir, "..", "PlugIns", "MovieFormats")) + search_dirs.append(os.path.join(exe_dir, "PlugIns", "MovieFormats")) search_dirs.append(os.path.join(exe_dir, "..", "Frameworks")) search_dirs.append(os.path.join(exe_dir, "..", "lib")) except Exception: @@ -62,6 +91,8 @@ def isGPUSupported(): search_dirs.append(os.path.join(home, "Library", "Application Support", "OpenUTV", "RED")) search_dirs.append(os.path.join(home, "Library", "Application Support", "RED")) search_dirs.append(os.path.join(home, ".local", "share", "openutv", "red")) + if os.environ.get("APPDATA"): + search_dirs.append(os.path.join(os.environ["APPDATA"], "OpenUTV", "RED")) search_dirs.extend( [ @@ -73,14 +104,22 @@ def isGPUSupported(): "/Library/Application Support/RED", "/usr/local/lib", "/opt/homebrew/lib", + "C:/Program Files/RED/RED PLAYER", + "C:/Program Files/RED DIGITAL CINEMA/REDCINE-X PRO", + "C:/Program Files/RED DIGITAL CINEMA/RED PLAYER", + "C:/Program Files/RED/REDCINE-X PRO", + "C:/Program Files/RED Digital Cinema", + "/usr/local/lib", + "/opt/red", ] ) for d in search_dirs: - dylib_path = os.path.join(d, "REDMetal.dylib") - if os.path.isfile(dylib_path): - _gpu_supported_cache = True - return True + for lib in target_gpu_libs: + dylib_path = os.path.join(d, lib) + if os.path.isfile(dylib_path): + _gpu_supported_cache = True + return True _gpu_supported_cache = False return False From f7a5da9022ff2badfbfbc645ff8fb22d87602b3c Mon Sep 17 00:00:00 2001 From: Michael Oliver Date: Fri, 25 Sep 2026 13:19:08 -0700 Subject: [PATCH 6/6] fix(r3d): include complete Khronos OpenCL headers and include cl.h directly Signed-off-by: Michael Oliver --- src/lib/image/MovieRED/CL/cl_d3d10.h | 108 ++++++++ src/lib/image/MovieRED/CL/cl_d3d11.h | 108 ++++++++ src/lib/image/MovieRED/CL/cl_ext.h | 316 ++++++++++++++++++++++ src/lib/image/MovieRED/CL/cl_gl.h | 129 +++++++++ src/lib/image/MovieRED/CL/cl_gl_ext.h | 68 +++++ src/lib/image/MovieRED/MovieREDOpenCL.cpp | 2 +- 6 files changed, 730 insertions(+), 1 deletion(-) create mode 100644 src/lib/image/MovieRED/CL/cl_d3d10.h create mode 100644 src/lib/image/MovieRED/CL/cl_d3d11.h create mode 100644 src/lib/image/MovieRED/CL/cl_ext.h create mode 100644 src/lib/image/MovieRED/CL/cl_gl.h create mode 100644 src/lib/image/MovieRED/CL/cl_gl_ext.h diff --git a/src/lib/image/MovieRED/CL/cl_d3d10.h b/src/lib/image/MovieRED/CL/cl_d3d10.h new file mode 100644 index 00000000..93dea973 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_d3d10.h @@ -0,0 +1,108 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */ + +#ifndef __OPENCL_CL_D3D10_H +#define __OPENCL_CL_D3D10_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************************************** + * cl_khr_d3d10_sharing */ +#define cl_khr_d3d10_sharing 1 + + typedef cl_uint cl_d3d10_device_source_khr; + typedef cl_uint cl_d3d10_device_set_khr; + +/******************************************************************************/ + +// Error Codes +#define CL_INVALID_D3D10_DEVICE_KHR -1002 +#define CL_INVALID_D3D10_RESOURCE_KHR -1003 +#define CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR -1004 +#define CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR -1005 + +// cl_d3d10_device_source_nv +#define CL_D3D10_DEVICE_KHR 0x4010 +#define CL_D3D10_DXGI_ADAPTER_KHR 0x4011 + +// cl_d3d10_device_set_nv +#define CL_PREFERRED_DEVICES_FOR_D3D10_KHR 0x4012 +#define CL_ALL_DEVICES_FOR_D3D10_KHR 0x4013 + +// cl_context_info +#define CL_CONTEXT_D3D10_DEVICE_KHR 0x4014 +#define CL_CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR 0x402C + +// cl_mem_info +#define CL_MEM_D3D10_RESOURCE_KHR 0x4015 + +// cl_image_info +#define CL_IMAGE_D3D10_SUBRESOURCE_KHR 0x4016 + +// cl_command_type +#define CL_COMMAND_ACQUIRE_D3D10_OBJECTS_KHR 0x4017 +#define CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR 0x4018 + + /******************************************************************************/ + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clGetDeviceIDsFromD3D10KHR_fn)(cl_platform_id platform, + cl_d3d10_device_source_khr d3d_device_source, void* d3d_object, + cl_d3d10_device_set_khr d3d_device_set, cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D10BufferKHR_fn)(cl_context context, cl_mem_flags flags, ID3D10Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D10Texture2DKHR_fn)(cl_context context, cl_mem_flags flags, + ID3D10Texture2D* resource, UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D10Texture3DKHR_fn)(cl_context context, cl_mem_flags flags, + ID3D10Texture3D* resource, UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueAcquireD3D10ObjectsKHR_fn)(cl_command_queue command_queue, cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueReleaseD3D10ObjectsKHR_fn)(cl_command_queue command_queue, cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + +#ifdef __cplusplus +} +#endif + +#endif // __OPENCL_CL_D3D10_H diff --git a/src/lib/image/MovieRED/CL/cl_d3d11.h b/src/lib/image/MovieRED/CL/cl_d3d11.h new file mode 100644 index 00000000..251318f9 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_d3d11.h @@ -0,0 +1,108 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 11708 $ on $Date: 2010-06-13 23:36:24 -0700 (Sun, 13 Jun 2010) $ */ + +#ifndef __OPENCL_CL_D3D11_H +#define __OPENCL_CL_D3D11_H + +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +/****************************************************************************** + * cl_khr_d3d11_sharing */ +#define cl_khr_d3d11_sharing 1 + + typedef cl_uint cl_d3d11_device_source_khr; + typedef cl_uint cl_d3d11_device_set_khr; + +/******************************************************************************/ + +// Error Codes +#define CL_INVALID_D3D11_DEVICE_KHR -1006 +#define CL_INVALID_D3D11_RESOURCE_KHR -1007 +#define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR -1008 +#define CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR -1009 + +// cl_d3d11_device_source +#define CL_D3D11_DEVICE_KHR 0x4019 +#define CL_D3D11_DXGI_ADAPTER_KHR 0x401A + +// cl_d3d11_device_set +#define CL_PREFERRED_DEVICES_FOR_D3D11_KHR 0x401B +#define CL_ALL_DEVICES_FOR_D3D11_KHR 0x401C + +// cl_context_info +#define CL_CONTEXT_D3D11_DEVICE_KHR 0x401D +#define CL_CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR 0x402D + +// cl_mem_info +#define CL_MEM_D3D11_RESOURCE_KHR 0x401E + +// cl_image_info +#define CL_IMAGE_D3D11_SUBRESOURCE_KHR 0x401F + +// cl_command_type +#define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_KHR 0x4020 +#define CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR 0x4021 + + /******************************************************************************/ + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clGetDeviceIDsFromD3D11KHR_fn)(cl_platform_id platform, + cl_d3d11_device_source_khr d3d_device_source, void* d3d_object, + cl_d3d11_device_set_khr d3d_device_set, cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D11BufferKHR_fn)(cl_context context, cl_mem_flags flags, ID3D11Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D11Texture2DKHR_fn)(cl_context context, cl_mem_flags flags, + ID3D11Texture2D* resource, UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_mem(CL_API_CALL* clCreateFromD3D11Texture3DKHR_fn)(cl_context context, cl_mem_flags flags, + ID3D11Texture3D* resource, UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueAcquireD3D11ObjectsKHR_fn)(cl_command_queue command_queue, cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueReleaseD3D11ObjectsKHR_fn)(cl_command_queue command_queue, cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +#ifdef __cplusplus +} +#endif + +#endif // __OPENCL_CL_D3D11_H diff --git a/src/lib/image/MovieRED/CL/cl_ext.h b/src/lib/image/MovieRED/CL/cl_ext.h new file mode 100644 index 00000000..0c49a724 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_ext.h @@ -0,0 +1,316 @@ +/******************************************************************************* + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + ******************************************************************************/ + +/* $Revision: 14835 $ on $Date: 2011-05-26 11:32:00 -0700 (Thu, 26 May 2011) $ */ + +/* cl_ext.h contains OpenCL extensions which don't have external */ +/* (OpenGL, D3D) dependencies. */ + +#ifndef __CL_EXT_H +#define __CL_EXT_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __APPLE__ +#include +#include +#else +#include +#endif + +/* cl_khr_fp64 extension - no extension #define since it has no functions */ +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 + +/* cl_khr_fp16 extension - no extension #define since it has no functions */ +#define CL_DEVICE_HALF_FP_CONFIG 0x1033 + +/* Memory object destruction + * + * Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR + * + * Registers a user callback function that will be called when the memory object is deleted and its resources + * freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback + * stack associated with memobj. The registered user callback functions are called in the reverse order in + * which they were registered. The user callback functions are called and then the memory object is deleted + * and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be + * notified when the memory referenced by host_ptr, specified when the memory object is created and used as + * the storage bits for the memory object, can be reused or freed. + * + * The application may not call CL api's with the cl_mem object passed to the pfn_notify. + * + * Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) + * before using. + */ +#define cl_APPLE_SetMemObjectDestructor 1 + cl_int CL_API_ENTRY clSetMemObjectDestructorAPPLE(cl_mem /* memobj */, + void (* /*pfn_notify*/)(cl_mem /* memobj */, void* /*user_data*/), + void* /*user_data */) CL_EXT_SUFFIX__VERSION_1_0; + +/* Context Logging Functions + * + * The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext(). + * Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) + * before using. + * + * clLogMessagesToSystemLog fowards on all log messages to the Apple System Logger + */ +#define cl_APPLE_ContextLoggingFunctions 1 + extern void CL_API_ENTRY clLogMessagesToSystemLogAPPLE(const char* /* errstr */, const void* /* private_info */, size_t /* cb */, + void* /* user_data */) CL_EXT_SUFFIX__VERSION_1_0; + + /* clLogMessagesToStdout sends all log messages to the file descriptor stdout */ + extern void CL_API_ENTRY clLogMessagesToStdoutAPPLE(const char* /* errstr */, const void* /* private_info */, size_t /* cb */, + void* /* user_data */) CL_EXT_SUFFIX__VERSION_1_0; + + /* clLogMessagesToStderr sends all log messages to the file descriptor stderr */ + extern void CL_API_ENTRY clLogMessagesToStderrAPPLE(const char* /* errstr */, const void* /* private_info */, size_t /* cb */, + void* /* user_data */) CL_EXT_SUFFIX__VERSION_1_0; + +/************************ + * cl_khr_icd extension * + ************************/ +#define cl_khr_icd 1 + +/* cl_platform_info */ +#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 + +/* Additional Error Codes */ +#define CL_PLATFORM_NOT_FOUND_KHR -1001 + + extern CL_API_ENTRY cl_int CL_API_CALL clIcdGetPlatformIDsKHR(cl_uint /* num_entries */, cl_platform_id* /* platforms */, + cl_uint* /* num_platforms */); + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clIcdGetPlatformIDsKHR_fn)(cl_uint /* num_entries */, cl_platform_id* /* platforms */, + cl_uint* /* num_platforms */); + +/****************************************** + * cl_nv_device_attribute_query extension * + ******************************************/ +/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */ +#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 +#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 +#define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002 +#define CL_DEVICE_WARP_SIZE_NV 0x4003 +#define CL_DEVICE_GPU_OVERLAP_NV 0x4004 +#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005 +#define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006 + +/********************************* + * cl_amd_device_memory_flags * + *********************************/ +#define cl_amd_device_memory_flags 1 + +#define CL_MEM_USE_PERSISTENT_MEM_AMD (1 << 6) // Alloc from GPU's CPU visible heap + +/* cl_device_info */ +#define CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT 0x4032 + +/********************************* + * cl_amd_device_attribute_query * + *********************************/ +#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036 +#define CL_DEVICE_TOPOLOGY_AMD 0x4037 +#define CL_DEVICE_BOARD_NAME_AMD 0x4038 +#define CL_DEVICE_GLOBAL_FREE_MEMORY_AMD 0x4039 +#define CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD 0x4040 +#define CL_DEVICE_SIMD_WIDTH_AMD 0x4041 +#define CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD 0x4042 +#define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043 +#define CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD 0x4044 +#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD 0x4045 +#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD 0x4046 +#define CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD 0x4047 +#define CL_DEVICE_LOCAL_MEM_BANKS_AMD 0x4048 + + typedef union + { + struct + { + cl_uint type; + cl_uint data[5]; + } raw; + + struct + { + cl_uint type; + cl_char unused[17]; + cl_char bus; + cl_char device; + cl_char function; + } pcie; + } cl_device_topology_amd; + +#define CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD 1 + +// +/*************************** + * cl_amd_command_intercept * + ***************************/ +#define CL_CONTEXT_COMMAND_INTERCEPT_CALLBACK_AMD 0x403D +#define CL_QUEUE_COMMAND_INTERCEPT_ENABLE_AMD (1ull << 63) + + typedef cl_int(CL_CALLBACK* intercept_callback_fn)(cl_event, cl_int*); + +/************************** + * cl_amd_command_queue_info * + **************************/ +#define CL_QUEUE_THREAD_HANDLE_AMD 0x403E + +// + +/************************** + * cl_amd_offline_devices * + **************************/ +#define CL_CONTEXT_OFFLINE_DEVICES_AMD 0x403F + +#ifdef CL_VERSION_1_1 + /*********************************** + * cl_ext_device_fission extension * + ***********************************/ +#define cl_ext_device_fission 1 + + extern CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT(cl_device_id /*device*/) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clReleaseDeviceEXT_fn)(cl_device_id /*device*/) CL_EXT_SUFFIX__VERSION_1_1; + + extern CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT(cl_device_id /*device*/) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clRetainDeviceEXT_fn)(cl_device_id /*device*/) CL_EXT_SUFFIX__VERSION_1_1; + + typedef cl_ulong cl_device_partition_property_ext; + extern CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT(cl_device_id /*in_device*/, + const cl_device_partition_property_ext* /* properties */, + cl_uint /*num_entries*/, cl_device_id* /*out_devices*/, + cl_uint* /*num_devices*/) CL_EXT_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clCreateSubDevicesEXT_fn)(cl_device_id /*in_device*/, + const cl_device_partition_property_ext* /* properties */, + cl_uint /*num_entries*/, cl_device_id* /*out_devices*/, + cl_uint* /*num_devices*/) CL_EXT_SUFFIX__VERSION_1_1; + +/* cl_device_partition_property_ext */ +#define CL_DEVICE_PARTITION_EQUALLY_EXT 0x4050 +#define CL_DEVICE_PARTITION_BY_COUNTS_EXT 0x4051 +#define CL_DEVICE_PARTITION_BY_NAMES_EXT 0x4052 +#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT 0x4053 + +/* clDeviceGetInfo selectors */ +#define CL_DEVICE_PARENT_DEVICE_EXT 0x4054 +#define CL_DEVICE_PARTITION_TYPES_EXT 0x4055 +#define CL_DEVICE_AFFINITY_DOMAINS_EXT 0x4056 +#define CL_DEVICE_REFERENCE_COUNT_EXT 0x4057 +#define CL_DEVICE_PARTITION_STYLE_EXT 0x4058 + +/* error codes */ +#define CL_DEVICE_PARTITION_FAILED_EXT -1057 +#define CL_INVALID_PARTITION_COUNT_EXT -1058 +#define CL_INVALID_PARTITION_NAME_EXT -1059 + +/* CL_AFFINITY_DOMAINs */ +#define CL_AFFINITY_DOMAIN_L1_CACHE_EXT 0x1 +#define CL_AFFINITY_DOMAIN_L2_CACHE_EXT 0x2 +#define CL_AFFINITY_DOMAIN_L3_CACHE_EXT 0x3 +#define CL_AFFINITY_DOMAIN_L4_CACHE_EXT 0x4 +#define CL_AFFINITY_DOMAIN_NUMA_EXT 0x10 +#define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT 0x100 + +/* cl_device_partition_property_ext list terminators */ +#define CL_PROPERTIES_LIST_END_EXT ((cl_device_partition_property_ext)0) +#define CL_PARTITION_BY_COUNTS_LIST_END_EXT ((cl_device_partition_property_ext)0) +#define CL_PARTITION_BY_NAMES_LIST_END_EXT ((cl_device_partition_property_ext)0 - 1) + +/* cl_ext_atomic_counters_32 and cl_ext_atomic_counters_64 extensions + * no extension #define since they have no functions + */ +#define CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT 0x4032 + + // +/************************* + * cl_amd_object_metadata * + **************************/ +#define cl_amd_object_metadata 1 + + typedef size_t cl_key_amd; + +#define CL_INVALID_OBJECT_AMD 0x403A +#define CL_INVALID_KEY_AMD 0x403B +#define CL_PLATFORM_MAX_KEYS_AMD 0x403C + + typedef CL_API_ENTRY cl_key_amd(CL_API_CALL* clCreateKeyAMD_fn)(cl_platform_id /* platform */, + void(CL_CALLBACK* /* destructor */)(void* /* old_value */), + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clObjectGetValueForKeyAMD_fn)(void* /* object */, cl_key_amd /* key */, + void** /* ret_val */) CL_API_SUFFIX__VERSION_1_1; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clObjectSetValueForKeyAMD_fn)(void* /* object */, cl_key_amd /* key */, + void* /* value */) CL_API_SUFFIX__VERSION_1_1; +// +#endif /* CL_VERSION_1_1 */ + +#ifdef CL_VERSION_1_2 +/******************************** + * cl_amd_bus_addressable_memory * + ********************************/ + +/* cl_mem flag - bitfield */ +#define CL_MEM_BUS_ADDRESSABLE_AMD (1 << 30) +#define CL_MEM_EXTERNAL_PHYSICAL_AMD (1 << 31) + +#define CL_COMMAND_WAIT_SIGNAL_AMD 0x4080 +#define CL_COMMAND_WRITE_SIGNAL_AMD 0x4081 +#define CL_COMMAND_MAKE_BUFFERS_RESIDENT_AMD 0x4082 + + typedef struct + { + cl_ulong surface_bus_address; + cl_ulong marker_bus_address; + } cl_bus_address_amd; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueWaitSignalAMD_fn)(cl_command_queue /*command_queue*/, cl_mem /*mem_object*/, + cl_uint /*value*/, cl_uint /*num_events*/, + const cl_event* /*event_wait_list*/, + cl_event* /*event*/) CL_EXT_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueWriteSignalAMD_fn)(cl_command_queue /*command_queue*/, cl_mem /*mem_object*/, + cl_uint /*value*/, cl_ulong /*offset*/, cl_uint /*num_events*/, + const cl_event* /*event_list*/, + cl_event* /*event*/) CL_EXT_SUFFIX__VERSION_1_2; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clEnqueueMakeBuffersResidentAMD_fn)(cl_command_queue /*command_queue*/, + cl_uint /*num_mem_objs*/, cl_mem* /*mem_objects*/, + cl_bool /*blocking_make_resident*/, + cl_bus_address_amd* /*bus_addresses*/, + cl_uint /*num_events*/, const cl_event* /*event_list*/, + cl_event* /*event*/) CL_EXT_SUFFIX__VERSION_1_2; + +#endif /* CL_VERSION_1_2 */ + +#ifdef __cplusplus +} +#endif + +#endif /* __CL_EXT_H */ diff --git a/src/lib/image/MovieRED/CL/cl_gl.h b/src/lib/image/MovieRED/CL/cl_gl.h new file mode 100644 index 00000000..a84a9555 --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_gl.h @@ -0,0 +1,129 @@ +/********************************************************************************** + * Copyright (c) 2011 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +#ifndef __OPENCL_CL_GL_H +#define __OPENCL_CL_GL_H + +#ifdef __APPLE__ +#include +#else +#include +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef cl_uint cl_gl_object_type; + typedef cl_uint cl_gl_texture_info; + typedef cl_uint cl_gl_platform_info; + typedef struct __GLsync* cl_GLsync; + +/* cl_gl_object_type = 0x2000 - 0x200F enum values are currently taken */ +#define CL_GL_OBJECT_BUFFER 0x2000 +#define CL_GL_OBJECT_TEXTURE2D 0x2001 +#define CL_GL_OBJECT_TEXTURE3D 0x2002 +#define CL_GL_OBJECT_RENDERBUFFER 0x2003 +#define CL_GL_OBJECT_TEXTURE2D_ARRAY 0x200E +#define CL_GL_OBJECT_TEXTURE1D 0x200F +#define CL_GL_OBJECT_TEXTURE1D_ARRAY 0x2010 +#define CL_GL_OBJECT_TEXTURE_BUFFER 0x2011 + +/* cl_gl_texture_info */ +#define CL_GL_TEXTURE_TARGET 0x2004 +#define CL_GL_MIPMAP_LEVEL 0x2005 + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer(cl_context /* context */, cl_mem_flags /* flags */, cl_GLuint /* bufobj */, + int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture(cl_context /* context */, cl_mem_flags /* flags */, cl_GLenum /* target */, + cl_GLint /* miplevel */, cl_GLuint /* texture */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_2; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer(cl_context /* context */, cl_mem_flags /* flags */, + cl_GLuint /* renderbuffer */, + cl_int* /* errcode_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo(cl_mem /* memobj */, cl_gl_object_type* /* gl_object_type */, + cl_GLuint* /* gl_object_name */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo(cl_mem /* memobj */, cl_gl_texture_info /* param_name */, + size_t /* param_value_size */, void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects(cl_command_queue /* command_queue */, cl_uint /* num_objects */, + const cl_mem* /* mem_objects */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + + extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects(cl_command_queue /* command_queue */, cl_uint /* num_objects */, + const cl_mem* /* mem_objects */, cl_uint /* num_events_in_wait_list */, + const cl_event* /* event_wait_list */, + cl_event* /* event */) CL_API_SUFFIX__VERSION_1_0; + +#ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS + // #warning CL_USE_DEPRECATED_OPENCL_1_1_APIS is defined. These APIs are unsupported and untested in OpenCL 1.2! + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D(cl_context /* context */, cl_mem_flags /* flags */, + cl_GLenum /* target */, cl_GLint /* miplevel */, cl_GLuint /* texture */, + cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; + + extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D(cl_context /* context */, cl_mem_flags /* flags */, + cl_GLenum /* target */, cl_GLint /* miplevel */, cl_GLuint /* texture */, + cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; +#endif /* CL_USE_DEPRECATED_OPENCL_1_2_APIS */ + + /* cl_khr_gl_sharing extension */ + +#define cl_khr_gl_sharing 1 + + typedef cl_uint cl_gl_context_info; + +/* Additional Error Codes */ +#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000 + +/* cl_gl_context_info */ +#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006 +#define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007 + +/* Additional cl_context_properties */ +#define CL_GL_CONTEXT_KHR 0x2008 +#define CL_EGL_DISPLAY_KHR 0x2009 +#define CL_GLX_DISPLAY_KHR 0x200A +#define CL_WGL_HDC_KHR 0x200B +#define CL_CGL_SHAREGROUP_KHR 0x200C + + extern CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR(const cl_context_properties* /* properties */, + cl_gl_context_info /* param_name */, size_t /* param_value_size */, + void* /* param_value */, + size_t* /* param_value_size_ret */) CL_API_SUFFIX__VERSION_1_0; + + typedef CL_API_ENTRY cl_int(CL_API_CALL* clGetGLContextInfoKHR_fn)(const cl_context_properties* properties, + cl_gl_context_info param_name, size_t param_value_size, + void* param_value, size_t* param_value_size_ret); + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_GL_H */ diff --git a/src/lib/image/MovieRED/CL/cl_gl_ext.h b/src/lib/image/MovieRED/CL/cl_gl_ext.h new file mode 100644 index 00000000..90601a4e --- /dev/null +++ b/src/lib/image/MovieRED/CL/cl_gl_ext.h @@ -0,0 +1,68 @@ +/********************************************************************************** + * Copyright (c) 2008-2010 The Khronos Group Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and/or associated documentation files (the + * "Materials"), to deal in the Materials without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Materials, and to + * permit persons to whom the Materials are furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Materials. + * + * THE MATERIALS ARE 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. + **********************************************************************************/ + +/* $Revision: 14826 $ on $Date: 2011-05-26 07:40:43 -0700 (Thu, 26 May 2011) $ */ + +/* cl_gl_ext.h contains vendor (non-KHR) OpenCL extensions which have */ +/* OpenGL dependencies. */ + +#ifndef __OPENCL_CL_GL_EXT_H +#define __OPENCL_CL_GL_EXT_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __APPLE__ +#include +#else +#include +#endif + +/* + * For each extension, follow this template + * cl_VEN_extname extension */ +/* #define cl_VEN_extname 1 + * ... define new types, if any + * ... define new tokens, if any + * ... define new APIs, if any + * + * If you need GLtypes here, mirror them with a cl_GLtype, rather than including a GL header + * This allows us to avoid having to decide whether to include GL headers or GLES here. + */ + +/* + * cl_khr_gl_event extension + * See section 9.9 in the OpenCL 1.1 spec for more information + */ +#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D + + extern CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(cl_context /* context */, cl_GLsync /* cl_GLsync */, + cl_int* /* errcode_ret */) CL_EXT_SUFFIX__VERSION_1_1; + +#ifdef __cplusplus +} +#endif + +#endif /* __OPENCL_CL_GL_EXT_H */ diff --git a/src/lib/image/MovieRED/MovieREDOpenCL.cpp b/src/lib/image/MovieRED/MovieREDOpenCL.cpp index fb713f70..73a7cc4d 100644 --- a/src/lib/image/MovieRED/MovieREDOpenCL.cpp +++ b/src/lib/image/MovieRED/MovieREDOpenCL.cpp @@ -6,7 +6,7 @@ //****************************************************************************** #include -#include +#include #include #include