Dynamically load OpenCL on Windows with CLRun. There shouldn't be the need to make a separate build now or download a big SDK to link Dolphin.

If compilation fails, rebuild the whole solution as Visual Studio struggles with the not so complex project dependencies.
ATI users still need to install the Stream SDK as it's the only way to have an OpenCL driver.
NVidia users just have to install a recent driver (version 197 is tested and working).

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@5808 8ced0084-cf51-0410-be5f-012b33b47a6e

Externals/CLRun/clrun/CLRun.vcproj

@@ -0,0 +1,355 @@
+<?xml version="1.0" encoding="windows-1255"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="9,00"
+	Name="CLRun"
+	ProjectGUID="{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}"
+	RootNamespace="CLRun"
+	TargetFrameworkVersion="196613"
+	>
+	<Platforms>
+		<Platform
+			Name="Win32"
+		/>
+		<Platform
+			Name="x64"
+		/>
+	</Platforms>
+	<ToolFiles>
+	</ToolFiles>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				WarningLevel="3"
+				DebugInformationFormat="4"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Debug|x64"
+			OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
+				MinimalRebuild="true"
+				BasicRuntimeChecks="3"
+				RuntimeLibrary="1"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+		<Configuration
+			Name="Release|x64"
+			OutputDirectory="$(SolutionDir)\$(ConfigurationName)\$(PlatformName)"
+			IntermediateDirectory="$(PlatformName)\$(ConfigurationName)"
+			ConfigurationType="4"
+			CharacterSet="2"
+			WholeProgramOptimization="1"
+			>
+			<Tool
+				Name="VCPreBuildEventTool"
+			/>
+			<Tool
+				Name="VCCustomBuildTool"
+			/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"
+			/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"
+			/>
+			<Tool
+				Name="VCMIDLTool"
+				TargetEnvironment="3"
+			/>
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="2"
+				EnableIntrinsicFunctions="true"
+				AdditionalIncludeDirectories="..\include"
+				PreprocessorDefinitions="CLRUN_COMPILE;WIN32"
+				RuntimeLibrary="0"
+				EnableFunctionLevelLinking="true"
+				WarningLevel="3"
+				DebugInformationFormat="3"
+			/>
+			<Tool
+				Name="VCManagedResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCResourceCompilerTool"
+			/>
+			<Tool
+				Name="VCPreLinkEventTool"
+			/>
+			<Tool
+				Name="VCLibrarianTool"
+				IgnoreAllDefaultLibraries="false"
+			/>
+			<Tool
+				Name="VCALinkTool"
+			/>
+			<Tool
+				Name="VCXDCMakeTool"
+			/>
+			<Tool
+				Name="VCBscMakeTool"
+			/>
+			<Tool
+				Name="VCFxCopTool"
+			/>
+			<Tool
+				Name="VCPostBuildEventTool"
+			/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="Source Files"
+			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+			>
+			<File
+				RelativePath=".\clrun.c"
+				>
+			</File>
+			<File
+				RelativePath=".\dynamiclib.c"
+				>
+			</File>
+			<File
+				RelativePath=".\gencl.c"
+				>
+			</File>
+			<File
+				RelativePath=".\genclgl.c"
+				>
+			</File>
+		</Filter>
+		<Filter
+			Name="Header Files"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+			>
+			<File
+				RelativePath="..\include\clrun.h"
+				>
+			</File>
+			<File
+				RelativePath=".\dynamiclib.h"
+				>
+			</File>
+			<Filter
+				Name="OpenCL"
+				>
+				<File
+					RelativePath="..\include\CL\cl.h"
+					>
+				</File>
+				<File
+					RelativePath="..\include\CL\cl_gl.h"
+					>
+				</File>
+				<File
+					RelativePath="..\include\CL\cl_platform.h"
+					>
+				</File>
+			</Filter>
+		</Filter>
+		<Filter
+			Name="Resource Files"
+			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
+			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+			>
+			<File
+				RelativePath=".\generateClRun.pl"
+				>
+				<FileConfiguration
+					Name="Debug|Win32"
+					ExcludedFromBuild="true"
+					>
+					<Tool
+						Name="VCCustomBuildTool"
+					/>
+				</FileConfiguration>
+				<FileConfiguration
+					Name="Debug|x64"
+					ExcludedFromBuild="true"
+					>
+					<Tool
+						Name="VCCustomBuildTool"
+					/>
+				</FileConfiguration>
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>

Externals/CLRun/clrun/Makefile

@@ -0,0 +1,16 @@
+all: compile
+
+compile: genclrun gencl.c genclgl.c
+	gcc -Wall -c gencl.c -o gencl.o
+	gcc -Wall -c genclgl.c -o genclgl.o
+	gcc -Wall -c clrun.c -o clrun.o -I../include
+	gcc -Wall --shared dynamiclib.c clrun.o gencl.o genclgl.o -o libclrun.so -ldl
+		strip libclrun.so
+
+genclrun: ../include/CL/cl.h ../include/CL/cl_gl.h
+	./generateClRun.pl ../include/CL/cl.h > gencl.c
+	./generateClRun.pl ../include/CL/cl_gl.h > genclgl.c
+
+
+clean:
+	rm -rf *~ *.o

Externals/CLRun/clrun/clrun.c

@@ -0,0 +1,61 @@
+#include "clrun.h"
+#include "dynamiclib.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+int isCL = 0;
+
+// 0 means no opencl, 1 means opencl
+int clrInit() {
+	int ret = 0;
+	
+#ifdef _WIN32
+	const char *libname = "OpenCL.dll";
+#else
+	const char *libname = "libOpenCL.so";
+#endif
+
+	if((ret = loadLib(libname))) {
+		if(ret == -3) // No OpenCL
+			return 0;
+		else
+			return ret;
+	}
+
+	isCL = 1;
+	
+	// TODO: optimize by loading all functions here?
+
+	return 0;
+}
+
+int clrHasOpenCL() {
+	return isCL;
+}
+
+
+// Windows-specific DLL code
+#if defined _WIN32 && defined CLRUN_DYNAMICLIB
+HINSTANCE g_hInstance;
+
+BOOL APIENTRY DllMain(HINSTANCE hinstDLL,	// DLL module handle
+					  DWORD dwReason,		// reason called
+					  LPVOID lpvReserved)	// reserved
+{
+	switch (dwReason)
+	{
+	case DLL_PROCESS_ATTACH:
+		break; 
+
+	case DLL_PROCESS_DETACH:
+		break;
+	default:
+		break;
+	}
+
+	g_hInstance = hinstDLL;
+	return TRUE;
+}
+#endif

Externals/CLRun/clrun/dynamiclib.c

@@ -0,0 +1,63 @@
+#ifdef _WIN32
+#include <windows.h>
+HINSTANCE library = NULL;
+#else
+#include <dlfcn.h>
+#include <stdio.h>
+void *library = NULL;
+#endif
+#include <string.h>
+
+int loadLib(const char *filename) {
+	if (library)
+		return -1;
+
+	if (!filename || strlen(filename) == 0) 
+		return -2;
+
+#ifdef _WIN32
+	library = LoadLibrary(filename);
+#else
+	library = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
+#endif
+
+	if (!library)
+		return -3;
+
+	return 0;
+}
+
+int unloadLib()
+{
+    int retval;
+    if (!library)
+		return -1;
+
+#ifdef _WIN32
+    retval = FreeLibrary(library);
+#else
+    retval = dlclose(library);
+#endif
+
+    library = NULL;
+    return retval;
+}
+
+void *getFunction(const char *funcname) {
+	void* retval;
+
+	if (!library) {
+		return NULL;
+	}
+
+#ifdef _WIN32
+	retval = GetProcAddress(library, funcname);
+#else
+	retval = dlsym(library, funcname);
+#endif
+
+	if (!retval) 
+		return NULL;
+
+	return retval;
+}

Externals/CLRun/clrun/dynamiclib.h

@@ -0,0 +1,9 @@
+
+#ifndef __DYNAMIC_LIBRARY_H
+#define __DYNAMIC_LIBRARY_H
+
+int loadLib(const char *filename);
+int unloadLib();
+void *getFunction(const char *funcname);
+
+#endif

Externals/CLRun/clrun/gencl.c

@@ -0,0 +1,401 @@
+// Automatically generated by generateClRun.pl
+#include "dynamiclib.h"
+#include "../include/CL/cl.h"
+
+
+static cl_int (*clGetPlatformIDs_ptr)(cl_uint, cl_platform_id *, cl_uint *) = NULL;
+cl_int CL_API_CALL clGetPlatformIDs (cl_uint num_entries,cl_platform_id * platforms,cl_uint * num_platforms) {
+	if(!clGetPlatformIDs_ptr) clGetPlatformIDs_ptr = getFunction("clGetPlatformIDs");
+	return (*clGetPlatformIDs_ptr)(num_entries, platforms, num_platforms);
+}
+
+static cl_int (*clGetPlatformInfo_ptr)(cl_platform_id, cl_platform_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetPlatformInfo_ptr) clGetPlatformInfo_ptr = getFunction("clGetPlatformInfo");
+	return (*clGetPlatformInfo_ptr)(platform, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clGetDeviceIDs_ptr)(cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *) = NULL;
+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) {
+	if(!clGetDeviceIDs_ptr) clGetDeviceIDs_ptr = getFunction("clGetDeviceIDs");
+	return (*clGetDeviceIDs_ptr)(platform, device_type, num_entries, devices, num_devices);
+}
+
+static cl_int (*clGetDeviceInfo_ptr)(cl_device_id, cl_device_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetDeviceInfo_ptr) clGetDeviceInfo_ptr = getFunction("clGetDeviceInfo");
+	return (*clGetDeviceInfo_ptr)(device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_context (*clCreateContext_ptr)(const cl_context_properties *, cl_uint, const cl_device_id *, void (CL_CALLBACK *)(const char *, const void *, size_t, void *), void *, cl_int *) = NULL;
+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) {
+	if(!clCreateContext_ptr) clCreateContext_ptr = getFunction("clCreateContext");
+	return (*clCreateContext_ptr)(properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
+}
+
+static cl_context (*clCreateContextFromType_ptr)(const cl_context_properties *, cl_device_type, void (CL_CALLBACK *)(const char *, const void *, size_t, void *), void *, cl_int *) = NULL;
+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) {
+	if(!clCreateContextFromType_ptr) clCreateContextFromType_ptr = getFunction("clCreateContextFromType");
+	return (*clCreateContextFromType_ptr)(properties, device_type, pfn_notify, user_data, errcode_ret);
+}
+
+static cl_int (*clRetainContext_ptr)(cl_context) = NULL;
+cl_int CL_API_CALL clRetainContext (cl_context context) {
+	if(!clRetainContext_ptr) clRetainContext_ptr = getFunction("clRetainContext");
+	return (*clRetainContext_ptr)(context);
+}
+
+static cl_int (*clReleaseContext_ptr)(cl_context) = NULL;
+cl_int CL_API_CALL clReleaseContext (cl_context context) {
+	if(!clReleaseContext_ptr) clReleaseContext_ptr = getFunction("clReleaseContext");
+	return (*clReleaseContext_ptr)(context);
+}
+
+static cl_int (*clGetContextInfo_ptr)(cl_context, cl_context_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetContextInfo_ptr) clGetContextInfo_ptr = getFunction("clGetContextInfo");
+	return (*clGetContextInfo_ptr)(context, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_command_queue (*clCreateCommandQueue_ptr)(cl_context, cl_device_id, cl_command_queue_properties, cl_int *) = NULL;
+cl_command_queue CL_API_CALL clCreateCommandQueue (cl_context context,cl_device_id device,cl_command_queue_properties properties,cl_int * errcode_ret) {
+	if(!clCreateCommandQueue_ptr) clCreateCommandQueue_ptr = getFunction("clCreateCommandQueue");
+	return (*clCreateCommandQueue_ptr)(context, device, properties, errcode_ret);
+}
+
+static cl_int (*clRetainCommandQueue_ptr)(cl_command_queue) = NULL;
+cl_int CL_API_CALL clRetainCommandQueue (cl_command_queue command_queue) {
+	if(!clRetainCommandQueue_ptr) clRetainCommandQueue_ptr = getFunction("clRetainCommandQueue");
+	return (*clRetainCommandQueue_ptr)(command_queue);
+}
+
+static cl_int (*clReleaseCommandQueue_ptr)(cl_command_queue) = NULL;
+cl_int CL_API_CALL clReleaseCommandQueue (cl_command_queue command_queue) {
+	if(!clReleaseCommandQueue_ptr) clReleaseCommandQueue_ptr = getFunction("clReleaseCommandQueue");
+	return (*clReleaseCommandQueue_ptr)(command_queue);
+}
+
+static cl_int (*clGetCommandQueueInfo_ptr)(cl_command_queue, cl_command_queue_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetCommandQueueInfo_ptr) clGetCommandQueueInfo_ptr = getFunction("clGetCommandQueueInfo");
+	return (*clGetCommandQueueInfo_ptr)(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clSetCommandQueueProperty_ptr)(cl_command_queue, cl_command_queue_properties, cl_bool, cl_command_queue_properties *) = NULL;
+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) {
+	if(!clSetCommandQueueProperty_ptr) clSetCommandQueueProperty_ptr = getFunction("clSetCommandQueueProperty");
+	return (*clSetCommandQueueProperty_ptr)(command_queue, properties, enable, old_properties);
+}
+
+static cl_mem (*clCreateBuffer_ptr)(cl_context, cl_mem_flags, size_t, void *, cl_int *) = NULL;
+cl_mem CL_API_CALL clCreateBuffer (cl_context context,cl_mem_flags flags,size_t size,void * host_ptr,cl_int * errcode_ret) {
+	if(!clCreateBuffer_ptr) clCreateBuffer_ptr = getFunction("clCreateBuffer");
+	return (*clCreateBuffer_ptr)(context, flags, size, host_ptr, errcode_ret);
+}
+
+static cl_mem (*clCreateImage2D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, void *, cl_int *) = NULL;
+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) {
+	if(!clCreateImage2D_ptr) clCreateImage2D_ptr = getFunction("clCreateImage2D");
+	return (*clCreateImage2D_ptr)(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
+}
+
+static cl_mem (*clCreateImage3D_ptr)(cl_context, cl_mem_flags, const cl_image_format *, size_t, size_t, size_t, size_t, size_t, void *, cl_int *) = NULL;
+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) {
+	if(!clCreateImage3D_ptr) clCreateImage3D_ptr = getFunction("clCreateImage3D");
+	return (*clCreateImage3D_ptr)(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
+}
+
+static cl_int (*clRetainMemObject_ptr)(cl_mem) = NULL;
+cl_int CL_API_CALL clRetainMemObject (cl_mem memobj) {
+	if(!clRetainMemObject_ptr) clRetainMemObject_ptr = getFunction("clRetainMemObject");
+	return (*clRetainMemObject_ptr)(memobj);
+}
+
+static cl_int (*clReleaseMemObject_ptr)(cl_mem) = NULL;
+cl_int CL_API_CALL clReleaseMemObject (cl_mem memobj) {
+	if(!clReleaseMemObject_ptr) clReleaseMemObject_ptr = getFunction("clReleaseMemObject");
+	return (*clReleaseMemObject_ptr)(memobj);
+}
+
+static cl_int (*clGetSupportedImageFormats_ptr)(cl_context, cl_mem_flags, cl_mem_object_type, cl_uint, cl_image_format *, cl_uint *) = NULL;
+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) {
+	if(!clGetSupportedImageFormats_ptr) clGetSupportedImageFormats_ptr = getFunction("clGetSupportedImageFormats");
+	return (*clGetSupportedImageFormats_ptr)(context, flags, image_type, num_entries, image_formats, num_image_formats);
+}
+
+static cl_int (*clGetMemObjectInfo_ptr)(cl_mem, cl_mem_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetMemObjectInfo_ptr) clGetMemObjectInfo_ptr = getFunction("clGetMemObjectInfo");
+	return (*clGetMemObjectInfo_ptr)(memobj, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clGetImageInfo_ptr)(cl_mem, cl_image_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetImageInfo_ptr) clGetImageInfo_ptr = getFunction("clGetImageInfo");
+	return (*clGetImageInfo_ptr)(image, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_sampler (*clCreateSampler_ptr)(cl_context, cl_bool, cl_addressing_mode, cl_filter_mode, cl_int *) = NULL;
+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) {
+	if(!clCreateSampler_ptr) clCreateSampler_ptr = getFunction("clCreateSampler");
+	return (*clCreateSampler_ptr)(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
+}
+
+static cl_int (*clRetainSampler_ptr)(cl_sampler) = NULL;
+cl_int CL_API_CALL clRetainSampler (cl_sampler sampler) {
+	if(!clRetainSampler_ptr) clRetainSampler_ptr = getFunction("clRetainSampler");
+	return (*clRetainSampler_ptr)(sampler);
+}
+
+static cl_int (*clReleaseSampler_ptr)(cl_sampler) = NULL;
+cl_int CL_API_CALL clReleaseSampler (cl_sampler sampler) {
+	if(!clReleaseSampler_ptr) clReleaseSampler_ptr = getFunction("clReleaseSampler");
+	return (*clReleaseSampler_ptr)(sampler);
+}
+
+static cl_int (*clGetSamplerInfo_ptr)(cl_sampler, cl_sampler_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetSamplerInfo_ptr) clGetSamplerInfo_ptr = getFunction("clGetSamplerInfo");
+	return (*clGetSamplerInfo_ptr)(sampler, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_program (*clCreateProgramWithSource_ptr)(cl_context, cl_uint, const char **, const size_t *, cl_int *) = NULL;
+cl_program CL_API_CALL clCreateProgramWithSource (cl_context context,cl_uint count,const char ** strings,const size_t * lengths,cl_int * errcode_ret) {
+	if(!clCreateProgramWithSource_ptr) clCreateProgramWithSource_ptr = getFunction("clCreateProgramWithSource");
+	return (*clCreateProgramWithSource_ptr)(context, count, strings, lengths, errcode_ret);
+}
+
+static cl_program (*clCreateProgramWithBinary_ptr)(cl_context, cl_uint, const cl_device_id *, const size_t *, const unsigned char **, cl_int *, cl_int *) = NULL;
+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) {
+	if(!clCreateProgramWithBinary_ptr) clCreateProgramWithBinary_ptr = getFunction("clCreateProgramWithBinary");
+	return (*clCreateProgramWithBinary_ptr)(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
+}
+
+static cl_int (*clRetainProgram_ptr)(cl_program) = NULL;
+cl_int CL_API_CALL clRetainProgram (cl_program program) {
+	if(!clRetainProgram_ptr) clRetainProgram_ptr = getFunction("clRetainProgram");
+	return (*clRetainProgram_ptr)(program);
+}
+
+static cl_int (*clReleaseProgram_ptr)(cl_program) = NULL;
+cl_int CL_API_CALL clReleaseProgram (cl_program program) {
+	if(!clReleaseProgram_ptr) clReleaseProgram_ptr = getFunction("clReleaseProgram");
+	return (*clReleaseProgram_ptr)(program);
+}
+
+static cl_int (*clBuildProgram_ptr)(cl_program, cl_uint, const cl_device_id *, const char *, void (CL_CALLBACK *  /* pfn_notify */)(cl_program /* program */, void *), void *) = NULL;
+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 *),void * user_data) {
+	if(!clBuildProgram_ptr) clBuildProgram_ptr = getFunction("clBuildProgram");
+	return (*clBuildProgram_ptr)(program, num_devices, device_list, options, pfn_notify, user_data);
+}
+
+static cl_int (*clUnloadCompiler_ptr)(void) = NULL;
+cl_int CL_API_CALL clUnloadCompiler (void) {
+	if(!clUnloadCompiler_ptr) clUnloadCompiler_ptr = getFunction("clUnloadCompiler");
+	return (*clUnloadCompiler_ptr)();
+}
+
+static cl_int (*clGetProgramInfo_ptr)(cl_program, cl_program_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetProgramInfo_ptr) clGetProgramInfo_ptr = getFunction("clGetProgramInfo");
+	return (*clGetProgramInfo_ptr)(program, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clGetProgramBuildInfo_ptr)(cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetProgramBuildInfo_ptr) clGetProgramBuildInfo_ptr = getFunction("clGetProgramBuildInfo");
+	return (*clGetProgramBuildInfo_ptr)(program, device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_kernel (*clCreateKernel_ptr)(cl_program, const char *, cl_int *) = NULL;
+cl_kernel CL_API_CALL clCreateKernel (cl_program program,const char * kernel_name,cl_int * errcode_ret) {
+	if(!clCreateKernel_ptr) clCreateKernel_ptr = getFunction("clCreateKernel");
+	return (*clCreateKernel_ptr)(program, kernel_name, errcode_ret);
+}
+
+static cl_int (*clCreateKernelsInProgram_ptr)(cl_program, cl_uint, cl_kernel *, cl_uint *) = NULL;
+cl_int CL_API_CALL clCreateKernelsInProgram (cl_program program,cl_uint num_kernels,cl_kernel * kernels,cl_uint * num_kernels_ret) {
+	if(!clCreateKernelsInProgram_ptr) clCreateKernelsInProgram_ptr = getFunction("clCreateKernelsInProgram");
+	return (*clCreateKernelsInProgram_ptr)(program, num_kernels, kernels, num_kernels_ret);
+}
+
+static cl_int (*clRetainKernel_ptr)(cl_kernel) = NULL;
+cl_int CL_API_CALL clRetainKernel (cl_kernel kernel) {
+	if(!clRetainKernel_ptr) clRetainKernel_ptr = getFunction("clRetainKernel");
+	return (*clRetainKernel_ptr)(kernel);
+}
+
+static cl_int (*clReleaseKernel_ptr)(cl_kernel) = NULL;
+cl_int CL_API_CALL clReleaseKernel (cl_kernel kernel) {
+	if(!clReleaseKernel_ptr) clReleaseKernel_ptr = getFunction("clReleaseKernel");
+	return (*clReleaseKernel_ptr)(kernel);
+}
+
+static cl_int (*clSetKernelArg_ptr)(cl_kernel, cl_uint, size_t, const void *) = NULL;
+cl_int CL_API_CALL clSetKernelArg (cl_kernel kernel,cl_uint arg_index,size_t arg_size,const void * arg_value) {
+	if(!clSetKernelArg_ptr) clSetKernelArg_ptr = getFunction("clSetKernelArg");
+	return (*clSetKernelArg_ptr)(kernel, arg_index, arg_size, arg_value);
+}
+
+static cl_int (*clGetKernelInfo_ptr)(cl_kernel, cl_kernel_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetKernelInfo_ptr) clGetKernelInfo_ptr = getFunction("clGetKernelInfo");
+	return (*clGetKernelInfo_ptr)(kernel, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clGetKernelWorkGroupInfo_ptr)(cl_kernel, cl_device_id, cl_kernel_work_group_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetKernelWorkGroupInfo_ptr) clGetKernelWorkGroupInfo_ptr = getFunction("clGetKernelWorkGroupInfo");
+	return (*clGetKernelWorkGroupInfo_ptr)(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clWaitForEvents_ptr)(cl_uint, const cl_event *) = NULL;
+cl_int CL_API_CALL clWaitForEvents (cl_uint num_events,const cl_event * event_list) {
+	if(!clWaitForEvents_ptr) clWaitForEvents_ptr = getFunction("clWaitForEvents");
+	return (*clWaitForEvents_ptr)(num_events, event_list);
+}
+
+static cl_int (*clGetEventInfo_ptr)(cl_event, cl_event_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetEventInfo_ptr) clGetEventInfo_ptr = getFunction("clGetEventInfo");
+	return (*clGetEventInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clRetainEvent_ptr)(cl_event) = NULL;
+cl_int CL_API_CALL clRetainEvent (cl_event event) {
+	if(!clRetainEvent_ptr) clRetainEvent_ptr = getFunction("clRetainEvent");
+	return (*clRetainEvent_ptr)(event);
+}
+
+static cl_int (*clReleaseEvent_ptr)(cl_event) = NULL;
+cl_int CL_API_CALL clReleaseEvent (cl_event event) {
+	if(!clReleaseEvent_ptr) clReleaseEvent_ptr = getFunction("clReleaseEvent");
+	return (*clReleaseEvent_ptr)(event);
+}
+
+static cl_int (*clGetEventProfilingInfo_ptr)(cl_event, cl_profiling_info, size_t, void *, size_t *) = NULL;
+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) {
+	if(!clGetEventProfilingInfo_ptr) clGetEventProfilingInfo_ptr = getFunction("clGetEventProfilingInfo");
+	return (*clGetEventProfilingInfo_ptr)(event, param_name, param_value_size, param_value, param_value_size_ret);
+}
+
+static cl_int (*clFlush_ptr)(cl_command_queue) = NULL;
+cl_int CL_API_CALL clFlush (cl_command_queue command_queue) {
+	if(!clFlush_ptr) clFlush_ptr = getFunction("clFlush");
+	return (*clFlush_ptr)(command_queue);
+}
+
+static cl_int (*clFinish_ptr)(cl_command_queue) = NULL;
+cl_int CL_API_CALL clFinish (cl_command_queue command_queue) {
+	if(!clFinish_ptr) clFinish_ptr = getFunction("clFinish");
+	return (*clFinish_ptr)(command_queue);
+}
+
+static cl_int (*clEnqueueReadBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueReadBuffer (cl_command_queue command_queue,cl_mem buffer,cl_bool blocking_read,size_t offset,size_t cb,void * ptr,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueReadBuffer_ptr) clEnqueueReadBuffer_ptr = getFunction("clEnqueueReadBuffer");
+	return (*clEnqueueReadBuffer_ptr)(command_queue, buffer, blocking_read, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueWriteBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueWriteBuffer (cl_command_queue command_queue,cl_mem buffer,cl_bool blocking_write,size_t offset,size_t cb,const void * ptr,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueWriteBuffer_ptr) clEnqueueWriteBuffer_ptr = getFunction("clEnqueueWriteBuffer");
+	return (*clEnqueueWriteBuffer_ptr)(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueCopyBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, size_t, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
+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 cb,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueCopyBuffer_ptr) clEnqueueCopyBuffer_ptr = getFunction("clEnqueueCopyBuffer");
+	return (*clEnqueueCopyBuffer_ptr)(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueReadImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, void *, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueReadImage (cl_command_queue command_queue,cl_mem image,cl_bool blocking_read,const size_t * origin,const size_t * region,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) {
+	if(!clEnqueueReadImage_ptr) clEnqueueReadImage_ptr = getFunction("clEnqueueReadImage");
+	return (*clEnqueueReadImage_ptr)(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueWriteImage_ptr)(cl_command_queue, cl_mem, cl_bool, const size_t *, const size_t *, size_t, size_t, const void *, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueWriteImage (cl_command_queue command_queue,cl_mem image,cl_bool blocking_write,const size_t * origin,const size_t * region,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) {
+	if(!clEnqueueWriteImage_ptr) clEnqueueWriteImage_ptr = getFunction("clEnqueueWriteImage");
+	return (*clEnqueueWriteImage_ptr)(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueCopyImage_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueCopyImage (cl_command_queue command_queue,cl_mem src_image,cl_mem dst_image,const size_t * src_origin,const size_t * dst_origin,const size_t * region,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueCopyImage_ptr) clEnqueueCopyImage_ptr = getFunction("clEnqueueCopyImage");
+	return (*clEnqueueCopyImage_ptr)(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueCopyImageToBuffer_ptr)(cl_command_queue, cl_mem, cl_mem, const size_t *, const size_t *, size_t, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueCopyImageToBuffer (cl_command_queue command_queue,cl_mem src_image,cl_mem dst_buffer,const size_t * src_origin,const size_t * region,size_t dst_offset,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueCopyImageToBuffer_ptr) clEnqueueCopyImageToBuffer_ptr = getFunction("clEnqueueCopyImageToBuffer");
+	return (*clEnqueueCopyImageToBuffer_ptr)(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueCopyBufferToImage_ptr)(cl_command_queue, cl_mem, cl_mem, size_t, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
+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,const size_t * region,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event) {
+	if(!clEnqueueCopyBufferToImage_ptr) clEnqueueCopyBufferToImage_ptr = getFunction("clEnqueueCopyBufferToImage");
+	return (*clEnqueueCopyBufferToImage_ptr)(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+}
+
+static void * (*clEnqueueMapBuffer_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, size_t, size_t, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
+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 cb,cl_uint num_events_in_wait_list,const cl_event * event_wait_list,cl_event * event,cl_int * errcode_ret) {
+	if(!clEnqueueMapBuffer_ptr) clEnqueueMapBuffer_ptr = getFunction("clEnqueueMapBuffer");
+	return (*clEnqueueMapBuffer_ptr)(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, event, errcode_ret);
+}
+
+static void * (*clEnqueueMapImage_ptr)(cl_command_queue, cl_mem, cl_bool, cl_map_flags, const size_t *, const size_t *, size_t *, size_t *, cl_uint, const cl_event *, cl_event *, cl_int *) = NULL;
+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,const size_t * region,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) {
+	if(!clEnqueueMapImage_ptr) clEnqueueMapImage_ptr = getFunction("clEnqueueMapImage");
+	return (*clEnqueueMapImage_ptr)(command_queue, image, blocking_map, map_flags, origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret);
+}
+
+static cl_int (*clEnqueueUnmapMemObject_ptr)(cl_command_queue, cl_mem, void *, cl_uint, const cl_event *, cl_event *) = NULL;
+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) {
+	if(!clEnqueueUnmapMemObject_ptr) clEnqueueUnmapMemObject_ptr = getFunction("clEnqueueUnmapMemObject");
+	return (*clEnqueueUnmapMemObject_ptr)(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueNDRangeKernel_ptr)(cl_command_queue, cl_kernel, cl_uint, const size_t *, const size_t *, const size_t *, cl_uint, const cl_event *, cl_event *) = NULL;
+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) {
+	if(!clEnqueueNDRangeKernel_ptr) clEnqueueNDRangeKernel_ptr = getFunction("clEnqueueNDRangeKernel");
+	return (*clEnqueueNDRangeKernel_ptr)(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueTask_ptr)(cl_command_queue, cl_kernel, cl_uint, const cl_event *, cl_event *) = NULL;
+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) {
+	if(!clEnqueueTask_ptr) clEnqueueTask_ptr = getFunction("clEnqueueTask");
+	return (*clEnqueueTask_ptr)(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueNativeKernel_ptr)(cl_command_queue, void (*)(void *), void *, size_t, cl_uint, const cl_mem *, const void **, cl_uint, const cl_event *, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueNativeKernel (cl_command_queue command_queue,void (*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) {
+	if(!clEnqueueNativeKernel_ptr) clEnqueueNativeKernel_ptr = getFunction("clEnqueueNativeKernel");
+	return (*clEnqueueNativeKernel_ptr)(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event);
+}
+
+static cl_int (*clEnqueueMarker_ptr)(cl_command_queue, cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueMarker (cl_command_queue command_queue,cl_event * event) {
+	if(!clEnqueueMarker_ptr) clEnqueueMarker_ptr = getFunction("clEnqueueMarker");
+	return (*clEnqueueMarker_ptr)(command_queue, event);
+}
+
+static cl_int (*clEnqueueWaitForEvents_ptr)(cl_command_queue, cl_uint, const cl_event *) = NULL;
+cl_int CL_API_CALL clEnqueueWaitForEvents (cl_command_queue command_queue,cl_uint num_events,const cl_event * event_list) {
+	if(!clEnqueueWaitForEvents_ptr) clEnqueueWaitForEvents_ptr = getFunction("clEnqueueWaitForEvents");
+	return (*clEnqueueWaitForEvents_ptr)(command_queue, num_events, event_list);
+}
+
+static cl_int (*clEnqueueBarrier_ptr)(cl_command_queue) = NULL;
+cl_int CL_API_CALL clEnqueueBarrier (cl_command_queue command_queue) {
+	if(!clEnqueueBarrier_ptr) clEnqueueBarrier_ptr = getFunction("clEnqueueBarrier");
+	return (*clEnqueueBarrier_ptr)(command_queue);
+}
+
+static void * (*clGetExtensionFunctionAddress_ptr)(const char *) = NULL;
+void * CL_API_CALL clGetExtensionFunctionAddress  (const char * func_name) {
+	if(!clGetExtensionFunctionAddress_ptr) clGetExtensionFunctionAddress_ptr = getFunction("clGetExtensionFunctionAddress");
+	return (*clGetExtensionFunctionAddress_ptr)(func_name);
+}
+

Externals/CLRun/clrun/genclgl.c

@@ -0,0 +1,58 @@
+// Automatically generated by generateClRun.pl
+#include "dynamiclib.h"
+#include "../include/CL/cl_gl.h"
+
+
+static cl_mem (*clCreateFromGLBuffer_ptr)(cl_context     , cl_mem_flags   , cl_GLuint      , int *          ) = NULL;
+cl_mem CL_API_CALL clCreateFromGLBuffer (cl_context context,cl_mem_flags flags,cl_GLuint bufobj,int * errcode_ret) {
+	if(!clCreateFromGLBuffer_ptr) clCreateFromGLBuffer_ptr = getFunction("clCreateFromGLBuffer");
+	return (*clCreateFromGLBuffer_ptr)(context , flags , bufobj , errcode_ret );
+}
+
+static cl_mem (*clCreateFromGLTexture2D_ptr)(cl_context      , cl_mem_flags    , cl_GLenum       , cl_GLint        , cl_GLuint       , cl_int *        ) = NULL;
+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) {
+	if(!clCreateFromGLTexture2D_ptr) clCreateFromGLTexture2D_ptr = getFunction("clCreateFromGLTexture2D");
+	return (*clCreateFromGLTexture2D_ptr)(context , flags , target , miplevel , texture , errcode_ret );
+}
+
+static cl_mem (*clCreateFromGLTexture3D_ptr)(cl_context      , cl_mem_flags    , cl_GLenum       , cl_GLint        , cl_GLuint       , cl_int *        ) = NULL;
+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) {
+	if(!clCreateFromGLTexture3D_ptr) clCreateFromGLTexture3D_ptr = getFunction("clCreateFromGLTexture3D");
+	return (*clCreateFromGLTexture3D_ptr)(context , flags , target , miplevel , texture , errcode_ret );
+}
+
+static cl_mem (*clCreateFromGLRenderbuffer_ptr)(cl_context   , cl_mem_flags , cl_GLuint    , cl_int *     ) = NULL;
+cl_mem CL_API_CALL clCreateFromGLRenderbuffer (cl_context context,cl_mem_flags flags,cl_GLuint renderbuffer,cl_int * errcode_ret) {
+	if(!clCreateFromGLRenderbuffer_ptr) clCreateFromGLRenderbuffer_ptr = getFunction("clCreateFromGLRenderbuffer");
+	return (*clCreateFromGLRenderbuffer_ptr)(context , flags , renderbuffer , errcode_ret );
+}
+
+static cl_int (*clGetGLObjectInfo_ptr)(cl_mem                , cl_gl_object_type *   , cl_GLuint *              ) = NULL;
+cl_int CL_API_CALL clGetGLObjectInfo (cl_mem memobj,cl_gl_object_type * gl_object_type,cl_GLuint * gl_object_name) {
+	if(!clGetGLObjectInfo_ptr) clGetGLObjectInfo_ptr = getFunction("clGetGLObjectInfo");
+	return (*clGetGLObjectInfo_ptr)(memobj , gl_object_type , gl_object_name );
+}
+
+static cl_int (*clGetGLTextureInfo_ptr)(cl_mem               , cl_gl_texture_info   , size_t               , void *               , size_t *             ) = NULL;
+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) {
+	if(!clGetGLTextureInfo_ptr) clGetGLTextureInfo_ptr = getFunction("clGetGLTextureInfo");
+	return (*clGetGLTextureInfo_ptr)(memobj , param_name , param_value_size , param_value , param_value_size_ret );
+}
+
+static cl_int (*clEnqueueAcquireGLObjects_ptr)(cl_command_queue      , cl_uint               , const cl_mem *        , cl_uint               , const cl_event *      , cl_event *            ) = NULL;
+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) {
+	if(!clEnqueueAcquireGLObjects_ptr) clEnqueueAcquireGLObjects_ptr = getFunction("clEnqueueAcquireGLObjects");
+	return (*clEnqueueAcquireGLObjects_ptr)(command_queue , num_objects , mem_objects , num_events_in_wait_list , event_wait_list , event );
+}
+
+static cl_int (*clEnqueueReleaseGLObjects_ptr)(cl_command_queue      , cl_uint               , const cl_mem *        , cl_uint               , const cl_event *      , cl_event *            ) = NULL;
+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) {
+	if(!clEnqueueReleaseGLObjects_ptr) clEnqueueReleaseGLObjects_ptr = getFunction("clEnqueueReleaseGLObjects");
+	return (*clEnqueueReleaseGLObjects_ptr)(command_queue , num_objects , mem_objects , num_events_in_wait_list , event_wait_list , event );
+}
+
+static cl_int (*clGetGLContextInfoKHR_ptr)(const cl_context_properties * , cl_gl_context_info            , size_t                        , void *                        , size_t *                      ) = NULL;
+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) {
+	if(!clGetGLContextInfoKHR_ptr) clGetGLContextInfoKHR_ptr = getFunction("clGetGLContextInfoKHR");
+	return (*clGetGLContextInfoKHR_ptr)(properties , param_name , param_value_size , param_value , param_value_size_ret );
+}

Externals/CLRun/clrun/generateClRun.pl

@@ -0,0 +1,96 @@
+#!/usr/bin/perl -w
+use strict;
+
+sub trim($)
+{
+	my $string = shift;
+	$string =~ s/^\s+//;
+	$string =~ s/\s+$//;
+	return $string;
+}
+
+my $filename = shift;
+
+open(CL, "<$filename") or die "Can't open cl.h";
+
+my ($funcRet, $funcName, $args);
+
+print "// Automatically generated by generateClRun.pl\n";
+print "#include \"dynamiclib.h\"\n";
+print "#include \"$filename\"\n\n\n";
+
+while(<CL>) {
+	chomp;
+	next unless $_ =~ /CL_API_ENTRY\s*(.*)\s*CL_API_CALL/;
+	$funcRet = $1;
+	my $fa = "";
+        my $noArgs = 0;
+	while(<CL>) {
+		$fa .= $_;
+		last if $_ =~ /;$/;
+	}
+
+	chomp $fa;
+	$fa =~ s/\s*\).*;\s*$/\)/g; # remove api
+	$fa =~ /([^(]*)\((.*)\)/s;
+ 	$funcName = $1;
+	$args = $2;
+	
+	# split params by , (ignoring function pointers)
+	(my @args) = $args =~  m/([^(,]*(?:\([^)]+\)[^(),]*)*[^),]*),?/g;
+        
+	my (@argsTypes, @argsNames);
+
+	my $funcArgSig = "";
+	my $tmp;
+	foreach my $arg (@args) {
+		
+		next if ($arg eq "");
+		my ($type, $name) = $arg =~ m|\s*(.*)\s*/\*\s*(.*)\s*\*/|s;
+               
+                # Strip []
+                if(defined $name) {
+                	$name =~ s/\[.*\]//g;
+                }
+
+		if ($arg =~ /\(.*\)/) {
+			$tmp = $type;
+			$type =~ s/\(\*.*?\)/\(\*\)/g 
+		}
+		
+		push @argsTypes, trim($type);
+		push @argsNames, trim($name);
+
+		if ($arg =~ /\(.*\)/) {
+			$funcArgSig .= "$tmp,";
+		} elsif(defined $type) {
+			$funcArgSig .= trim($type)." ".trim($name).",";
+		} else { # Functions with no arguments (i.e. "void" only)
+                	$funcArgSig = "void,";
+                        $noArgs = 1;
+                        last;
+                }
+	}
+
+	chop($funcArgSig); #last ,
+
+        my ($funcArgsNames, $funcArgsTypes);
+
+        if($noArgs eq 0) {
+          $funcArgsNames = ($#argsNames != -1)? join ', ',@argsNames : "";
+          $funcArgsTypes = ($#argsTypes != -1)? join ', ',@argsTypes : "";
+        } else {
+          $funcArgsNames = "";
+          $funcArgsTypes = "void";
+        }
+
+	my $func = "${funcName}_ptr";
+	$args =~ s$(/\*|\*/)$$g; # uncomment names
+	print "static ".trim($funcRet)." (*$func)($funcArgsTypes) = NULL;\n";
+ 	print trim($funcRet)." CL_API_CALL $funcName ($funcArgSig) {\n";
+	print "\tif(!$func) $func = getFunction(\"$funcName\");\n";
+	print "\treturn (*$func)($funcArgsNames);\n";
+ 	print "}\n\n";
+}
+
+close(CL);

Externals/CLRun/include/CL/cl_gl.h

@@ -0,0 +1,153 @@
+/**********************************************************************************
+ * 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: 11707 $ on $Date: 2010-06-13 23:30:16 -0700 (Sun, 13 Jun 2010) $ */
+
+/*
+ * cl_gl.h contains Khronos-approved (KHR) OpenCL extensions which have
+ * OpenGL dependencies. The application is responsible for #including
+ * OpenGL or OpenGL ES headers before #including cl_gl.h.
+ */
+
+#ifndef __OPENCL_CL_GL_H
+#define __OPENCL_CL_GL_H
+
+#ifdef __APPLE__
+#include <OpenCL/cl.h>
+#else
+#include <CL/cl.h>
+#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;
+
+/* cl_gl_object_type */
+#define CL_GL_OBJECT_BUFFER             0x2000
+#define CL_GL_OBJECT_TEXTURE2D          0x2001
+#define CL_GL_OBJECT_TEXTURE3D          0x2002
+#define CL_GL_OBJECT_RENDERBUFFER       0x2003
+
+/* 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
+clCreateFromGLTexture2D(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_0;
+
+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_API_SUFFIX__VERSION_1_0;
+
+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;
+
+/* 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  */

Externals/CLRun/include/clrun.h

@@ -0,0 +1,25 @@
+#ifndef __CLRUN_H
+#define __CLRUN_H
+
+/*#ifdef _WIN32
+#ifdef CLRUN_COMPILE
+#define EXPORTED __declspec(dllexport)
+#else
+#define EXPORTED __declspec(dllimport)
+#endif
+#else*/
+#define EXPORTED
+//#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+extern EXPORTED int clrInit();
+extern EXPORTED int clrHasOpenCL();
+	
+#ifdef __cplusplus
+};
+#endif
+
+#endif

Source/Core/Common/Common.vcproj

@@ -46,7 +46,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_SECURE_SCL=0"
 				MinimalRebuild="true"
 				BasicRuntimeChecks="3"
@@ -116,7 +116,7 @@
 			<Tool
 				Name="VCCLCompilerTool"
 				Optimization="0"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;_DEBUG;_LIB;_SECURE_SCL=0"
 				StringPooling="true"
 				MinimalRebuild="true"
@@ -190,7 +190,7 @@
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				FavorSizeOrSpeed="2"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_SECURE_SCL=0;_CRT_SECURE_NO_WARNINGS"
 				RuntimeLibrary="0"
 				BufferSecurityCheck="false"
@@ -264,7 +264,7 @@
 				Optimization="2"
 				EnableIntrinsicFunctions="true"
 				FavorSizeOrSpeed="1"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_SECURE_SCL=0;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE"
 				StringPooling="true"
 				RuntimeLibrary="0"
@@ -336,7 +336,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="3"
 				FavorSizeOrSpeed="1"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_SECURE_SCL=0;DEBUGFAST;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE"
 				RuntimeLibrary="0"
 				BufferSecurityCheck="false"
@@ -407,7 +407,7 @@
 				Name="VCCLCompilerTool"
 				Optimization="3"
 				FavorSizeOrSpeed="1"
-				AdditionalIncludeDirectories="../../PluginSpecs"
+				AdditionalIncludeDirectories="../../PluginSpecs;../../../Externals/CLRun/include"
 				PreprocessorDefinitions="WIN32;NDEBUG;_LIB;_SECURE_SCL=0;DEBUGFAST;_CRT_SECURE_NO_WARNINGS;_CRT_SECURE_NO_DEPRECATE"
 				RuntimeLibrary="0"
 				FloatingPointModel="0"

Source/Core/Common/Src/OpenCL.cpp

@@ -21,6 +21,10 @@
 #include "Common.h"
 #include "Timer.h"
 
+#ifdef _WIN32
+#include "clrun.h"
+#endif
+
 namespace OpenCL
 {
 
@@ -41,7 +45,13 @@ bool Initialize()
 	if(g_context)
 		return false;
 	int err;                            // error code returned from api calls
-	
+
+#ifdef _WIN32
+    clrInit();
+    if(!clrHasOpenCL())
+        return false;
+#endif
+
 	// Connect to a compute device
 	cl_uint numPlatforms;
 	cl_platform_id platform = NULL;

Source/Core/Common/Src/OpenCL.h

@@ -19,9 +19,11 @@
 #define __OPENCL_H__
 
 #include "Common.h"
-// Change to #if 1 if you want to test OpenCL (and you have it) on Windows
-#if 0
-#pragma comment(lib, "OpenCL.lib")
+// OpenCL on Windows is linked through the CLRun library
+// It provides the headers and all the imports
+// It could be safe to use it for Linux too, but will require to edit the SCons first
+// OpenCL is linked on OSX when possible, it shouldn't require CLRun for now
+#ifdef _WIN32
 #define HAVE_OPENCL 1
 #endif
 

Source/Core/VideoCommon/Src/OpenCL/OCLTextureDecoder.cpp

@@ -152,7 +152,7 @@ PC_TexFormat TexDecoder_Decode_OpenCL(u8 *dst, const u8 *src, int width, int hei
 #if defined(HAVE_OPENCL) && HAVE_OPENCL
 	cl_int err;
     sDecoderParameter& decoder = rgba ? g_DecodeParametersRGBA[texformat] : g_DecodeParametersNative[texformat];
-    if(!decoder.name || !decoder.kernel || decoder.format == PC_TEX_FMT_NONE)
+    if(!g_Inited || !decoder.name || !decoder.kernel || decoder.format == PC_TEX_FMT_NONE)
         return PC_TEX_FMT_NONE;
 
 #ifdef DEBUG_OPENCL
@@ -193,7 +193,5 @@ PC_TexFormat TexDecoder_Decode_OpenCL(u8 *dst, const u8 *src, int width, int hei
 #else
 	return PC_TEX_FMT_NONE;
 #endif
-
-	return PC_TEX_FMT_NONE;
 }
 

Source/Dolphin.sln

@@ -51,6 +51,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Dolphin", "Core\DolphinWX\D
 		{C7E5D50A-2916-464B-86A7-E10B3CC88ADA} = {C7E5D50A-2916-464B-86A7-E10B3CC88ADA}
 		{CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160} = {CFDCEE0E-FA45-4F72-9FCC-0B88F5A75160}
 		{D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8} = {D6E56527-BBB9-4EAD-A6EC-49D4BF6AFCD8}
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1} = {D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}
 		{8D612734-FAA5-4B8A-804F-4DEA2367D495} = {8D612734-FAA5-4B8A-804F-4DEA2367D495}
 		{05C75041-D67D-4903-A362-8395A7B35C75} = {05C75041-D67D-4903-A362-8395A7B35C75}
 		{636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18} = {636FAD5F-02D1-4E9A-BE67-FB8EA99B9A18}
@@ -79,6 +80,7 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Debugger", "Core\DebuggerWX
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VideoCommon", "Core\VideoCommon\VideoCommon.vcproj", "{E5D1F0C0-AA07-4841-A4EB-4CF4DAA6B0FA}"
 	ProjectSection(ProjectDependencies) = postProject
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1} = {D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}
 		{C0B84DA9-FF15-4FAB-9590-17132F3C6DE4} = {C0B84DA9-FF15-4FAB-9590-17132F3C6DE4}
 		{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
 	EndProjectSection
@@ -213,6 +215,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_VideoDX11", "Plugins
 		{C573CAF7-EE6A-458E-8049-16C0BF34C2E9} = {C573CAF7-EE6A-458E-8049-16C0BF34C2E9}
 	EndProjectSection
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "CLRun", "..\Externals\CLRun\clrun\CLRun.vcproj", "{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -597,6 +601,17 @@ Global
 		{21DBE606-2958-43AC-A14E-B6B798D56554}.Release|Win32.Build.0 = Release|Win32
 		{21DBE606-2958-43AC-A14E-B6B798D56554}.Release|x64.ActiveCfg = Release|x64
 		{21DBE606-2958-43AC-A14E-B6B798D56554}.Release|x64.Build.0 = Release|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Debug|Win32.ActiveCfg = Debug|Win32
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Debug|Win32.Build.0 = Debug|Win32
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Debug|x64.ActiveCfg = Debug|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Debug|x64.Build.0 = Debug|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.DebugFast|Win32.ActiveCfg = Release|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.DebugFast|x64.ActiveCfg = Release|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.DebugFast|x64.Build.0 = Release|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Release|Win32.ActiveCfg = Release|Win32
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Release|Win32.Build.0 = Release|Win32
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Release|x64.ActiveCfg = Release|x64
+		{D4833C30-FA5F-4DFE-BD32-109DE1F09ED1}.Release|x64.Build.0 = Release|x64
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE