Added opencl-version_1_2 patchset

2025-01-28 22:04:43 -08:00 · 2019-03-15 09:51:33 +11:00 · 2019-03-15 09:51:33 +11:00 · 3d9797093d
commit 3d9797093d
parent 993b6c9c83
7 changed files with 1941 additions and 1 deletions
--- a/patches/opencl-version_1_2/0001-opencl-Add-OpenCL-1.0-function-pointer-loader.patch
+++ b/patches/opencl-version_1_2/0001-opencl-Add-OpenCL-1.0-function-pointer-loader.patch
@ -0,0 +1,441 @@
+From 3d9a49e946e17ac814c3680fdf9e7983eb76183b Mon Sep 17 00:00:00 2001
+From: Nakarin Khankham <garuda2550@gmail.com>
+Date: Sat, 9 Mar 2019 21:37:24 +0700
+Subject: [PATCH 1/5] opencl: Add OpenCL 1.0 function pointer loader.
+
+Signed-off-by: Nakarin Khankham <garuda2550@gmail.com>
+---
+ configure            |  56 +++++++++
+ configure.ac         |   1 +
+ dlls/opencl/opencl.c | 321 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/config.h.in  |   3 +
+ 4 files changed, 381 insertions(+)
+
+diff --git a/configure b/configure
+index 5a091db..1444fd4 100755
+--- a/configure
+++ b/configure
+@@ -11800,6 +11800,62 @@ if test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" = xyes; then :
+ 
+ fi
+ 
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -lOpenCL" >&5
+$as_echo_n "checking for -lOpenCL... " >&6; }
+if ${ac_cv_lib_soname_OpenCL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_soname_save_LIBS=$LIBS
+LIBS="-lOpenCL  $LIBS"
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char clGetPlatformInfo ();
+int
+main ()
+{
+return clGetPlatformInfo ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  case "$LIBEXT" in
+    dll) ac_cv_lib_soname_OpenCL=`$ac_cv_path_LDD conftest.exe | grep "OpenCL" | sed -e "s/dll.*/dll/"';2,$d'` ;;
+    dylib) ac_cv_lib_soname_OpenCL=`$OTOOL -L conftest$ac_exeext | grep "libOpenCL\\.[0-9A-Za-z.]*dylib" | sed -e "s/^.*\/\(libOpenCL\.[0-9A-Za-z.]*dylib\).*$/\1/"';2,$d'` ;;
+    *) ac_cv_lib_soname_OpenCL=`$READELF -d conftest$ac_exeext | grep "NEEDED.*libOpenCL\\.$LIBEXT" | sed -e "s/^.*\\[\\(libOpenCL\\.$LIBEXT[^	 ]*\\)\\].*$/\1/"';2,$d'`
+       if ${ac_cv_lib_soname_OpenCL:+false} :; then :
+  ac_cv_lib_soname_OpenCL=`$LDD conftest$ac_exeext | grep "libOpenCL\\.$LIBEXT" | sed -e "s/^.*\(libOpenCL\.$LIBEXT[^	 ]*\).*$/\1/"';2,$d'`
+fi ;;
+  esac
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  LIBS=$ac_check_soname_save_LIBS
+fi
+if ${ac_cv_lib_soname_OpenCL:+false} :; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+$as_echo "not found" >&6; }
+       cat >>confdefs.h <<_ACEOF
+#define SONAME_LIBOPENCL "libOpenCL.$LIBEXT"
+_ACEOF
+
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_soname_OpenCL" >&5
+$as_echo "$ac_cv_lib_soname_OpenCL" >&6; }
+
+cat >>confdefs.h <<_ACEOF
+#define SONAME_LIBOPENCL "$ac_cv_lib_soname_OpenCL"
+_ACEOF
+
+
+fi
+ fi
+ if test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" != xyes; then :
+   case "x$with_opencl" in
+diff --git a/configure.ac b/configure.ac
+index 87d8bf5..0f0a459 100644
+--- a/configure.ac
+++ b/configure.ac
+@@ -1252,6 +1252,7 @@ dnl **** Check for OpenCL ****
+ if test "$ac_cv_header_CL_cl_h" = "yes"
+ then
+     AC_CHECK_LIB(OpenCL,clGetPlatformInfo,[AC_SUBST(OPENCL_LIBS,["-lOpenCL"])])
+    WINE_CHECK_SONAME(OpenCL,clGetPlatformInfo,,[AC_DEFINE_UNQUOTED(SONAME_LIBOPENCL,["libOpenCL.$LIBEXT"])])
+ fi
+ WINE_NOTICE_WITH(opencl,[test "x$ac_cv_lib_OpenCL_clGetPlatformInfo" != xyes],
+                  [OpenCL ${notice_platform}development files not found, OpenCL won't be supported.],
+diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
+index 2d145bf..7d292c0 100644
+--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/opencl.c
+@@ -43,6 +43,327 @@ WINE_DEFAULT_DEBUG_CHANNEL(opencl);
+ #define OPENCL_WITH_GL 0
+ 
+ 
+/* Platform API */
+static cl_int (*pclGetPlatformIDs)(cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms);
+static cl_int (*pclGetPlatformInfo)(cl_platform_id platform, cl_platform_info param_name,
+                                    size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+
+/* Device APIs */
+static cl_int (*pclGetDeviceIDs)(cl_platform_id platform, cl_device_type device_type,
+                                 cl_uint num_entries, cl_device_id * devices, cl_uint * num_devices);
+static cl_int (*pclGetDeviceInfo)(cl_device_id device, cl_device_info param_name,
+                                  size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+
+/* Context APIs  */
+static cl_context (*pclCreateContext)(const cl_context_properties * properties, cl_uint num_devices, const cl_device_id * devices,
+                                      void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
+                                      void * user_data, cl_int * errcode_ret);
+static cl_context (*pclCreateContextFromType)(const cl_context_properties * properties, cl_device_type device_type,
+                                              void (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
+                                              void * user_data, cl_int * errcode_ret);
+static cl_int (*pclRetainContext)(cl_context context);
+static cl_int (*pclReleaseContext)(cl_context context);
+static cl_int (*pclGetContextInfo)(cl_context context, cl_context_info param_name,
+                                   size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+
+/* Command Queue APIs */
+static cl_command_queue (*pclCreateCommandQueue)(cl_context context, cl_device_id device,
+                                                 cl_command_queue_properties properties, cl_int * errcode_ret);
+static cl_int (*pclRetainCommandQueue)(cl_command_queue command_queue);
+static cl_int (*pclReleaseCommandQueue)(cl_command_queue command_queue);
+static cl_int (*pclGetCommandQueueInfo)(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);
+static cl_int (*pclSetCommandQueueProperty)(cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable,
+                                            cl_command_queue_properties * old_properties);
+
+/* Memory Object APIs  */
+static cl_mem (*pclCreateBuffer)(cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret);
+static cl_mem (*pclCreateImage2D)(cl_context context, cl_mem_flags flags, 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);
+static cl_mem (*pclCreateImage3D)(cl_context context, cl_mem_flags flags, 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);
+static cl_int (*pclRetainMemObject)(cl_mem memobj);
+static cl_int (*pclReleaseMemObject)(cl_mem memobj);
+static cl_int (*pclGetSupportedImageFormats)(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);
+static cl_int (*pclGetMemObjectInfo)(cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+static cl_int (*pclGetImageInfo)(cl_mem image, cl_image_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+
+/* Sampler APIs  */
+static cl_sampler (*pclCreateSampler)(cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode,
+                                      cl_filter_mode filter_mode, cl_int * errcode_ret);
+static cl_int (*pclRetainSampler)(cl_sampler sampler);
+static cl_int (*pclReleaseSampler)(cl_sampler sampler);
+static cl_int (*pclGetSamplerInfo)(cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size,
+                                   void * param_value, size_t * param_value_size_ret);
+
+/* Program Object APIs  */
+static cl_program (*pclCreateProgramWithSource)(cl_context context, cl_uint count, const char ** strings,
+                                                const size_t * lengths, cl_int * errcode_ret);
+static cl_program (*pclCreateProgramWithBinary)(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);
+static cl_int (*pclRetainProgram)(cl_program program);
+static cl_int (*pclReleaseProgram)(cl_program program);
+static cl_int (*pclBuildProgram)(cl_program program, cl_uint num_devices, const cl_device_id * device_list, const char * options,
+                                 void (*pfn_notify)(cl_program program, void * user_data),
+                                 void * user_data);
+static cl_int (*pclUnloadCompiler)(void);
+static cl_int (*pclGetProgramInfo)(cl_program program, cl_program_info param_name,
+                                   size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+static cl_int (*pclGetProgramBuildInfo)(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);
+
+/* Kernel Object APIs */
+static cl_kernel (*pclCreateKernel)(cl_program program, char * kernel_name, cl_int * errcode_ret);
+static cl_int (*pclCreateKernelsInProgram)(cl_program program, cl_uint num_kernels,
+                                           cl_kernel * kernels, cl_uint * num_kernels_ret);
+static cl_int (*pclRetainKernel)(cl_kernel kernel);
+static cl_int (*pclReleaseKernel)(cl_kernel kernel);
+static cl_int (*pclSetKernelArg)(cl_kernel kernel, cl_uint arg_index, size_t arg_size, void * arg_value);
+static cl_int (*pclGetKernelInfo)(cl_kernel kernel, cl_kernel_info param_name,
+                                  size_t param_value_size, void * param_value, size_t * param_value_size_ret);
+static cl_int (*pclGetKernelWorkGroupInfo)(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);
+/* Event Object APIs  */
+static cl_int (*pclWaitForEvents)(cl_uint num_events, cl_event * event_list);
+static cl_int (*pclGetEventInfo)(cl_event event, cl_event_info param_name, size_t param_value_size,
+                                 void * param_value, size_t * param_value_size_ret);
+static cl_int (*pclRetainEvent)(cl_event event);
+static cl_int (*pclReleaseEvent)(cl_event event);
+
+/* Profiling APIs  */
+static cl_int (*pclGetEventProfilingInfo)(cl_event event, cl_profiling_info param_name, size_t param_value_size,
+                                           void * param_value, size_t * param_value_size_ret);
+
+/* Flush and Finish APIs */
+static cl_int (*pclFlush)(cl_command_queue command_queue);
+static cl_int (*pclFinish)(cl_command_queue command_queue);
+
+/* Enqueued Commands APIs */
+static cl_int (*pclEnqueueReadBuffer)(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);
+static cl_int (*pclEnqueueWriteBuffer)(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);
+static cl_int (*pclEnqueueCopyBuffer)(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);
+static cl_int (*pclEnqueueReadImage)(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);
+static cl_int (*pclEnqueueWriteImage)(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);
+static cl_int (*pclEnqueueCopyImage)(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image,
+                                      size_t * src_origin, size_t * dst_origin, size_t * region,
+                                      cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueCopyImageToBuffer)(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer,
+                                             size_t * src_origin, size_t * region, size_t dst_offset,
+                                             cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueCopyBufferToImage)(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image,
+                                             size_t src_offset, size_t * dst_origin, size_t * region,
+                                             cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static void * (*pclEnqueueMapBuffer)(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, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret);
+static void * (*pclEnqueueMapImage)(cl_command_queue command_queue, cl_mem image, cl_bool blocking_map,
+                                    cl_map_flags map_flags, size_t * origin, size_t * region,
+                                    size_t * image_row_pitch, size_t * image_slice_pitch,
+                                    cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret);
+static cl_int (*pclEnqueueUnmapMemObject)(cl_command_queue command_queue, cl_mem memobj, void * mapped_ptr,
+                                          cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueNDRangeKernel)(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
+                                         size_t * global_work_offset, size_t * global_work_size, size_t * local_work_size,
+                                         cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueTask)(cl_command_queue command_queue, cl_kernel kernel,
+                                cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueNativeKernel)(cl_command_queue command_queue,
+                                        void (*user_func)(void *args),
+                                        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);
+static cl_int (*pclEnqueueMarker)(cl_command_queue command_queue, cl_event * event);
+static cl_int (*pclEnqueueWaitForEvents)(cl_command_queue command_queue, cl_uint num_events, cl_event * event_list);
+static cl_int (*pclEnqueueBarrier)(cl_command_queue command_queue);
+
+/* Extension function access */
+static void * (*pclGetExtensionFunctionAddress)(const char * func_name);
+
+
+static BOOL init_opencl(void);
+static BOOL load_opencl_func(void);
+
+static void * opencl_handle = NULL;
+
+
+/***********************************************************************
+ *      DllMain [Internal]
+ *
+ * Initializes the internal 'opencl.dll'.
+ */
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved)
+{
+    TRACE("opencl.dll: %p,%x,%p\n", hinstDLL, reason, reserved);
+
+    switch (reason)
+    {
+    case DLL_PROCESS_ATTACH:
+        DisableThreadLibraryCalls(hinstDLL);
+        if (init_opencl())
+            load_opencl_func();
+        break;
+
+    case DLL_PROCESS_DETACH:
+        if (reserved) break;
+        if (opencl_handle) wine_dlclose(opencl_handle, NULL, 0);
+    }
+
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *      init_opencl [Internal]
+ *
+ * Initializes OpenCL library.
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+static BOOL init_opencl(void)
+{
+#ifdef SONAME_LIBOPENCL
+    char error[256];
+
+    opencl_handle = wine_dlopen(SONAME_LIBOPENCL, RTLD_NOW, error, sizeof(error));
+    if (opencl_handle != NULL)
+    {
+        TRACE("Opened library %s\n", SONAME_LIBOPENCL);
+        return TRUE;
+    }
+    else
+        ERR("Failed to open library %s: %s\n", SONAME_LIBOPENCL, error);
+#else
+    ERR("OpenCL is needed but support was not included at build time\n");
+#endif
+    return FALSE;
+}
+
+
+/***********************************************************************
+ *      load_opencl_func [Internal]
+ *
+ * Populate function table.
+ *
+ * RETURNS
+ *     Success: TRUE
+ *     Failure: FALSE
+ */
+static BOOL load_opencl_func(void)
+{
+    char error[256];
+
+    if (opencl_handle == NULL)
+        return FALSE;
+
+#define LOAD_FUNCPTR(f) \
+    if (!(p##f = wine_dlsym(opencl_handle, #f, error, sizeof(error)))) \
+    WARN("%s not found in %s (%s)\n", #f, SONAME_LIBOPENCL, error);
+
+    /* Platform API */
+    LOAD_FUNCPTR(clGetPlatformIDs);
+    LOAD_FUNCPTR(clGetPlatformInfo);
+    /* Device APIs */
+    LOAD_FUNCPTR(clGetDeviceIDs);
+    LOAD_FUNCPTR(clGetDeviceInfo);
+    /* Context APIs  */
+    LOAD_FUNCPTR(clCreateContext);
+    LOAD_FUNCPTR(clCreateContextFromType);
+    LOAD_FUNCPTR(clRetainContext);
+    LOAD_FUNCPTR(clReleaseContext);
+    LOAD_FUNCPTR(clGetContextInfo);
+    /* Command Queue APIs */
+    LOAD_FUNCPTR(clCreateCommandQueue);
+    LOAD_FUNCPTR(clRetainCommandQueue);
+    LOAD_FUNCPTR(clReleaseCommandQueue);
+    LOAD_FUNCPTR(clGetCommandQueueInfo);
+    LOAD_FUNCPTR(clSetCommandQueueProperty);
+    /* Memory Object APIs  */
+    LOAD_FUNCPTR(clCreateBuffer);
+    LOAD_FUNCPTR(clCreateImage2D);
+    LOAD_FUNCPTR(clCreateImage3D);
+    LOAD_FUNCPTR(clRetainMemObject);
+    LOAD_FUNCPTR(clReleaseMemObject);
+    LOAD_FUNCPTR(clGetSupportedImageFormats);
+    LOAD_FUNCPTR(clGetMemObjectInfo);
+    LOAD_FUNCPTR(clGetImageInfo);
+    /* Sampler APIs  */
+    LOAD_FUNCPTR(clCreateSampler);
+    LOAD_FUNCPTR(clRetainSampler);
+    LOAD_FUNCPTR(clReleaseSampler);
+    LOAD_FUNCPTR(clGetSamplerInfo);
+    /* Program Object APIs  */
+    LOAD_FUNCPTR(clCreateProgramWithSource);
+    LOAD_FUNCPTR(clCreateProgramWithBinary);
+    LOAD_FUNCPTR(clRetainProgram);
+    LOAD_FUNCPTR(clReleaseProgram);
+    LOAD_FUNCPTR(clBuildProgram);
+    LOAD_FUNCPTR(clUnloadCompiler);
+    LOAD_FUNCPTR(clGetProgramInfo);
+    LOAD_FUNCPTR(clGetProgramBuildInfo);
+    /* Kernel Object APIs */
+    LOAD_FUNCPTR(clCreateKernel);
+    LOAD_FUNCPTR(clCreateKernelsInProgram);
+    LOAD_FUNCPTR(clRetainKernel);
+    LOAD_FUNCPTR(clReleaseKernel);
+    LOAD_FUNCPTR(clSetKernelArg);
+    LOAD_FUNCPTR(clGetKernelInfo);
+    LOAD_FUNCPTR(clGetKernelWorkGroupInfo);
+    /* Event Object APIs  */
+    LOAD_FUNCPTR(clWaitForEvents);
+    LOAD_FUNCPTR(clGetEventInfo);
+    LOAD_FUNCPTR(clRetainEvent);
+    LOAD_FUNCPTR(clReleaseEvent);
+    /* Profiling APIs  */
+    LOAD_FUNCPTR(clGetEventProfilingInfo);
+    /* Flush and Finish APIs */
+    LOAD_FUNCPTR(clFlush);
+    LOAD_FUNCPTR(clFinish);
+    /* Enqueued Commands APIs */
+    LOAD_FUNCPTR(clEnqueueReadBuffer);
+    LOAD_FUNCPTR(clEnqueueWriteBuffer);
+    LOAD_FUNCPTR(clEnqueueCopyBuffer);
+    LOAD_FUNCPTR(clEnqueueReadImage);
+    LOAD_FUNCPTR(clEnqueueWriteImage);
+    LOAD_FUNCPTR(clEnqueueCopyImage);
+    LOAD_FUNCPTR(clEnqueueCopyImageToBuffer);
+    LOAD_FUNCPTR(clEnqueueCopyBufferToImage);
+    LOAD_FUNCPTR(clEnqueueMapBuffer);
+    LOAD_FUNCPTR(clEnqueueMapImage);
+    LOAD_FUNCPTR(clEnqueueUnmapMemObject);
+    LOAD_FUNCPTR(clEnqueueNDRangeKernel);
+    LOAD_FUNCPTR(clEnqueueTask);
+    LOAD_FUNCPTR(clEnqueueNativeKernel);
+    LOAD_FUNCPTR(clEnqueueMarker);
+    LOAD_FUNCPTR(clEnqueueWaitForEvents);
+    LOAD_FUNCPTR(clEnqueueBarrier);
+    /* Extension function access */
+    LOAD_FUNCPTR(clGetExtensionFunctionAddress);
+
+#undef LOAD_FUNCPTR
+
+    return TRUE;
+}
+
+
+ /*---------------------------------------------------------------*/
+ /* Platform API */
+ 
+diff --git a/include/config.h.in b/include/config.h.in
+index b3df2f3..1330d30 100644
+--- a/include/config.h.in
+++ b/include/config.h.in
+@@ -1443,6 +1443,9 @@
+ /* Define to the soname of the libopenal library. */
+ #undef SONAME_LIBOPENAL
+ 
+/* Define to the soname of the libOpenCL library. */
+#undef SONAME_LIBOPENCL
+
+ /* Define to the soname of the libOSMesa library. */
+ #undef SONAME_LIBOSMESA
+ 
+-- 
+1.9.1
+
--- a/patches/opencl-version_1_2/0002-opencl-Use-function-pointer-instead-of-call-the-func.patch
+++ b/patches/opencl-version_1_2/0002-opencl-Use-function-pointer-instead-of-call-the-func.patch
@ -0,0 +1,739 @@
+From f99a46f3697d10d3db1d92db1e450f9be34fed55 Mon Sep 17 00:00:00 2001
+From: Nakarin Khankham <garuda2550@gmail.com>
+Date: Sat, 9 Mar 2019 21:40:48 +0700
+Subject: [PATCH 2/5] opencl: Use function pointer instead of call the function
+ directly.
+
+Signed-off-by: Nakarin Khankham <garuda2550@gmail.com>
+---
+ dlls/opencl/opencl.c | 241 +++++++++++++++++++++++++++++++++++++--------------
+ 1 file changed, 177 insertions(+), 64 deletions(-)
+
+diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
+index 7d292c0..221cf1a 100644
+--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/opencl.c
+@@ -371,7 +371,8 @@ cl_int WINAPI wine_clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platfor
+ {
+     cl_int ret;
+     TRACE("(%d, %p, %p)\n", num_entries, platforms, num_platforms);
+-    ret = clGetPlatformIDs(num_entries, platforms, num_platforms);
+    if (!pclGetPlatformIDs) return CL_INVALID_VALUE;
+    ret = pclGetPlatformIDs(num_entries, platforms, num_platforms);
+     TRACE("(%d, %p, %p)=%d\n", num_entries, platforms, num_platforms, ret);
+     return ret;
+ }
+@@ -382,6 +383,8 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
+     cl_int ret;
+     TRACE("(%p, 0x%x, %ld, %p, %p)\n", platform, param_name, param_value_size, param_value, param_value_size_ret);
+ 
+    if (!pclGetPlatformInfo) return CL_INVALID_VALUE;
+
+     /* Hide all extensions.
+      * TODO: Add individual extension support as needed.
+      */
+@@ -404,7 +407,7 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
+     }
+     else
+     {
+-        ret = clGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
+        ret = pclGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
+     }
+ 
+     TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", platform, param_name, param_value_size, param_value, param_value_size_ret, ret);
+@@ -420,7 +423,8 @@ cl_int WINAPI wine_clGetDeviceIDs(cl_platform_id platform, cl_device_type device
+ {
+     cl_int ret;
+     TRACE("(%p, 0x%lx, %d, %p, %p)\n", platform, (long unsigned int)device_type, num_entries, devices, num_devices);
+-    ret = clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices);
+    if (!pclGetDeviceIDs) return CL_INVALID_VALUE;
+    ret = pclGetDeviceIDs(platform, device_type, num_entries, devices, num_devices);
+     TRACE("(%p, 0x%lx, %d, %p, %p)=%d\n", platform, (long unsigned int)device_type, num_entries, devices, num_devices, ret);
+     return ret;
+ }
+@@ -431,6 +435,8 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
+     cl_int ret;
+     TRACE("(%p, 0x%x, %ld, %p, %p)\n",device, param_name, param_value_size, param_value, param_value_size_ret);
+ 
+    if (!pclGetDeviceInfo) return CL_INVALID_VALUE;
+
+     /* Hide all extensions.
+      * TODO: Add individual extension support as needed.
+      */
+@@ -453,7 +459,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
+     }
+     else
+     {
+-        ret = clGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
+        ret = pclGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
+     }
+ 
+     /* Filter out the CL_EXEC_NATIVE_KERNEL flag */
+@@ -493,6 +499,11 @@ cl_context WINAPI wine_clCreateContext(const cl_context_properties * properties,
+     cl_context ret;
+     CONTEXT_CALLBACK *ccb;
+     TRACE("(%p, %d, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
+    if (!pclCreateContext)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+     /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
+      * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
+      * The problem is determining when a context is being destroyed. clReleaseContext only decrements
+@@ -502,7 +513,7 @@ cl_context WINAPI wine_clCreateContext(const cl_context_properties * properties,
+     ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
+     ccb->pfn_notify = pfn_notify;
+     ccb->user_data = user_data;
+-    ret = clCreateContext(properties, num_devices, devices, context_fn_notify, ccb, errcode_ret);
+    ret = pclCreateContext(properties, num_devices, devices, context_fn_notify, ccb, errcode_ret);
+     TRACE("(%p, %d, %p, %p, %p, %p (%d)))=%p\n", properties, num_devices, devices, &pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
+     return ret;
+ }
+@@ -514,6 +525,11 @@ cl_context WINAPI wine_clCreateContextFromType(const cl_context_properties * pro
+     cl_context ret;
+     CONTEXT_CALLBACK *ccb;
+     TRACE("(%p, 0x%lx, %p, %p, %p)\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret);
+    if (!pclCreateContextFromType)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+     /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
+      * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
+      * The problem is determining when a context is being destroyed. clReleaseContext only decrements
+@@ -523,7 +539,7 @@ cl_context WINAPI wine_clCreateContextFromType(const cl_context_properties * pro
+     ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
+     ccb->pfn_notify = pfn_notify;
+     ccb->user_data = user_data;
+-    ret = clCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
+    ret = pclCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
+     TRACE("(%p, 0x%lx, %p, %p, %p (%d)))=%p\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret, errcode_ret ? *errcode_ret : 0, ret);
+     return ret;
+ }
+@@ -532,7 +548,8 @@ cl_int WINAPI wine_clRetainContext(cl_context context)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", context);
+-    ret = clRetainContext(context);
+    if (!pclRetainContext) return CL_INVALID_VALUE;
+    ret = pclRetainContext(context);
+     TRACE("(%p)=%d\n", context, ret);
+     return ret;
+ }
+@@ -541,7 +558,8 @@ cl_int WINAPI wine_clReleaseContext(cl_context context)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", context);
+-    ret = clReleaseContext(context);
+    if (!pclReleaseContext) return CL_INVALID_VALUE;
+    ret = pclReleaseContext(context);
+     TRACE("(%p)=%d\n", context, ret);
+     return ret;
+ }
+@@ -551,7 +569,8 @@ cl_int WINAPI wine_clGetContextInfo(cl_context context, cl_context_info param_na
+ {
+     cl_int ret;
+     TRACE("(%p, 0x%x, %ld, %p, %p)\n", context, param_name, param_value_size, param_value, param_value_size_ret);
+-    ret = clGetContextInfo(context, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetContextInfo) return CL_INVALID_VALUE;
+    ret = pclGetContextInfo(context, param_name, param_value_size, param_value, param_value_size_ret);
+     TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", context, param_name, param_value_size, param_value, param_value_size_ret, ret);
+     return ret;
+ }
+@@ -565,7 +584,12 @@ cl_command_queue WINAPI wine_clCreateCommandQueue(cl_context context, cl_device_
+ {
+     cl_command_queue ret;
+     TRACE("(%p, %p, 0x%lx, %p)\n", context, device, (long unsigned int)properties, errcode_ret);
+-    ret = clCreateCommandQueue(context, device, properties, errcode_ret);
+    if (!pclCreateCommandQueue)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateCommandQueue(context, device, properties, errcode_ret);
+     TRACE("(%p, %p, 0x%lx, %p)=%p\n", context, device, (long unsigned int)properties, errcode_ret, ret);
+     return ret;
+ }
+@@ -574,7 +598,8 @@ cl_int WINAPI wine_clRetainCommandQueue(cl_command_queue command_queue)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", command_queue);
+-    ret = clRetainCommandQueue(command_queue);
+    if (!pclRetainCommandQueue) return CL_INVALID_VALUE;
+    ret = pclRetainCommandQueue(command_queue);
+     TRACE("(%p)=%d\n", command_queue, ret);
+     return ret;
+ }
+@@ -583,7 +608,8 @@ cl_int WINAPI wine_clReleaseCommandQueue(cl_command_queue command_queue)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", command_queue);
+-    ret = clReleaseCommandQueue(command_queue);
+    if (!pclReleaseCommandQueue) return CL_INVALID_VALUE;
+    ret = pclReleaseCommandQueue(command_queue);
+     TRACE("(%p)=%d\n", command_queue, ret);
+     return ret;
+ }
+@@ -593,7 +619,8 @@ cl_int WINAPI wine_clGetCommandQueueInfo(cl_command_queue command_queue, cl_comm
+ {
+     cl_int ret;
+     TRACE("%p, %d, %ld, %p, %p\n", command_queue, param_name, param_value_size, param_value, param_value_size_ret);
+-    ret = clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetCommandQueueInfo) return CL_INVALID_VALUE;
+    ret = pclGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -612,7 +639,12 @@ cl_mem WINAPI wine_clCreateBuffer(cl_context context, cl_mem_flags flags, size_t
+ {
+     cl_mem ret;
+     TRACE("\n");
+-    ret = clCreateBuffer(context, flags, size, host_ptr, errcode_ret);
+    if (!pclCreateBuffer)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateBuffer(context, flags, size, host_ptr, errcode_ret);
+     return ret;
+ }
+ 
+@@ -621,7 +653,12 @@ cl_mem WINAPI wine_clCreateImage2D(cl_context context, cl_mem_flags flags, cl_im
+ {
+     cl_mem ret;
+     TRACE("\n");
+-    ret = clCreateImage2D(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
+    if (!pclCreateImage2D)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateImage2D(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
+     return ret;
+ }
+ 
+@@ -631,7 +668,12 @@ cl_mem WINAPI wine_clCreateImage3D(cl_context context, cl_mem_flags flags, cl_im
+ {
+     cl_mem ret;
+     TRACE("\n");
+-    ret = clCreateImage3D(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
+    if (!pclCreateImage3D)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateImage3D(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
+     return ret;
+ }
+ 
+@@ -639,7 +681,8 @@ cl_int WINAPI wine_clRetainMemObject(cl_mem memobj)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", memobj);
+-    ret = clRetainMemObject(memobj);
+    if (!pclRetainMemObject) return CL_INVALID_VALUE;
+    ret = pclRetainMemObject(memobj);
+     TRACE("(%p)=%d\n", memobj, ret);
+     return ret;
+ }
+@@ -648,7 +691,8 @@ cl_int WINAPI wine_clReleaseMemObject(cl_mem memobj)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", memobj);
+-    ret = clReleaseMemObject(memobj);
+    if (!pclReleaseMemObject) return CL_INVALID_VALUE;
+    ret = pclReleaseMemObject(memobj);
+     TRACE("(%p)=%d\n", memobj, ret);
+     return ret;
+ }
+@@ -658,7 +702,8 @@ cl_int WINAPI wine_clGetSupportedImageFormats(cl_context context, cl_mem_flags f
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetSupportedImageFormats(context, flags, image_type, num_entries, image_formats, num_image_formats);
+    if (!pclGetSupportedImageFormats) return CL_INVALID_VALUE;
+    ret = pclGetSupportedImageFormats(context, flags, image_type, num_entries, image_formats, num_image_formats);
+     return ret;
+ }
+ 
+@@ -666,7 +711,8 @@ cl_int WINAPI wine_clGetMemObjectInfo(cl_mem memobj, cl_mem_info param_name, siz
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetMemObjectInfo(memobj, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetMemObjectInfo) return CL_INVALID_VALUE;
+    ret = pclGetMemObjectInfo(memobj, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -674,7 +720,8 @@ cl_int WINAPI wine_clGetImageInfo(cl_mem image, cl_image_info param_name, size_t
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetImageInfo(image, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetImageInfo) return CL_INVALID_VALUE;
+    ret = pclGetImageInfo(image, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -687,7 +734,12 @@ cl_sampler WINAPI wine_clCreateSampler(cl_context context, cl_bool normalized_co
+ {
+     cl_sampler ret;
+     TRACE("\n");
+-    ret = clCreateSampler(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
+    if (!pclCreateSampler)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateSampler(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
+     return ret;
+ }
+ 
+@@ -695,7 +747,8 @@ cl_int WINAPI wine_clRetainSampler(cl_sampler sampler)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clRetainSampler(sampler);
+    if (!pclRetainSampler) return CL_INVALID_VALUE;
+    ret = pclRetainSampler(sampler);
+     return ret;
+ }
+ 
+@@ -703,7 +756,8 @@ cl_int WINAPI wine_clReleaseSampler(cl_sampler sampler)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clReleaseSampler(sampler);
+    if (!pclReleaseSampler) return CL_INVALID_VALUE;
+    ret = pclReleaseSampler(sampler);
+     return ret;
+ }
+ 
+@@ -712,7 +766,8 @@ cl_int WINAPI wine_clGetSamplerInfo(cl_sampler sampler, cl_sampler_info param_na
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetSamplerInfo(sampler, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetSamplerInfo) return CL_INVALID_VALUE;
+    ret = pclGetSamplerInfo(sampler, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -725,7 +780,12 @@ cl_program WINAPI wine_clCreateProgramWithSource(cl_context context, cl_uint cou
+ {
+     cl_program ret;
+     TRACE("\n");
+-    ret = clCreateProgramWithSource(context, count, strings, lengths, errcode_ret);
+    if (!pclCreateProgramWithSource)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateProgramWithSource(context, count, strings, lengths, errcode_ret);
+     return ret;
+ }
+ 
+@@ -735,7 +795,12 @@ cl_program WINAPI wine_clCreateProgramWithBinary(cl_context context, cl_uint num
+ {
+     cl_program ret;
+     TRACE("\n");
+-    ret = clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
+    if (!pclCreateProgramWithBinary)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
+     return ret;
+ }
+ 
+@@ -743,7 +808,8 @@ cl_int WINAPI wine_clRetainProgram(cl_program program)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clRetainProgram(program);
+    if (!pclRetainProgram) return CL_INVALID_PROGRAM;
+    ret = pclRetainProgram(program);
+     return ret;
+ }
+ 
+@@ -751,7 +817,8 @@ cl_int WINAPI wine_clReleaseProgram(cl_program program)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clReleaseProgram(program);
+    if (!pclReleaseProgram) return CL_INVALID_PROGRAM;
+    ret = pclReleaseProgram(program);
+     return ret;
+ }
+ 
+@@ -777,6 +844,7 @@ cl_int WINAPI wine_clBuildProgram(cl_program program, cl_uint num_devices, const
+ {
+     cl_int ret;
+     TRACE("\n");
+    if (!pclBuildProgram) return CL_INVALID_VALUE;
+     if(pfn_notify)
+     {
+         /* When pfn_notify is provided, clBuildProgram is asynchronous */
+@@ -784,12 +852,12 @@ cl_int WINAPI wine_clBuildProgram(cl_program program, cl_uint num_devices, const
+         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
+         pcb->pfn_notify = pfn_notify;
+         pcb->user_data = user_data;
+-        ret = clBuildProgram(program, num_devices, device_list, options, program_fn_notify, pcb);
+        ret = pclBuildProgram(program, num_devices, device_list, options, program_fn_notify, pcb);
+     }
+     else
+     {
+         /* When pfn_notify is NULL, clBuildProgram is synchronous */
+-        ret = clBuildProgram(program, num_devices, device_list, options, NULL, user_data);
+        ret = pclBuildProgram(program, num_devices, device_list, options, NULL, user_data);
+     }
+     return ret;
+ }
+@@ -798,7 +866,8 @@ cl_int WINAPI wine_clUnloadCompiler(void)
+ {
+     cl_int ret;
+     TRACE("()\n");
+-    ret = clUnloadCompiler();
+    if (!pclUnloadCompiler) return CL_SUCCESS;
+    ret = pclUnloadCompiler();
+     TRACE("()=%d\n", ret);
+     return ret;
+ }
+@@ -808,7 +877,8 @@ cl_int WINAPI wine_clGetProgramInfo(cl_program program, cl_program_info param_na
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetProgramInfo(program, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetProgramInfo) return CL_INVALID_VALUE;
+    ret = pclGetProgramInfo(program, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -818,7 +888,8 @@ cl_int WINAPI wine_clGetProgramBuildInfo(cl_program program, cl_device_id device
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetProgramBuildInfo(program, device, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetProgramBuildInfo) return CL_INVALID_VALUE;
+    ret = pclGetProgramBuildInfo(program, device, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -830,7 +901,12 @@ cl_kernel WINAPI wine_clCreateKernel(cl_program program, char * kernel_name, cl_
+ {
+     cl_kernel ret;
+     TRACE("\n");
+-    ret = clCreateKernel(program, kernel_name, errcode_ret);
+    if (!pclCreateKernel)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateKernel(program, kernel_name, errcode_ret);
+     return ret;
+ }
+ 
+@@ -839,7 +915,8 @@ cl_int WINAPI wine_clCreateKernelsInProgram(cl_program program, cl_uint num_kern
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
+    if (!pclCreateKernelsInProgram) return CL_INVALID_VALUE;
+    ret = pclCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
+     return ret;
+ }
+ 
+@@ -847,7 +924,8 @@ cl_int WINAPI wine_clRetainKernel(cl_kernel kernel)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clRetainKernel(kernel);
+    if (!pclRetainKernel) return CL_INVALID_KERNEL;
+    ret = pclRetainKernel(kernel);
+     return ret;
+ }
+ 
+@@ -855,7 +933,8 @@ cl_int WINAPI wine_clReleaseKernel(cl_kernel kernel)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clReleaseKernel(kernel);
+    if (!pclReleaseKernel) return CL_INVALID_KERNEL;
+    ret = pclReleaseKernel(kernel);
+     return ret;
+ }
+ 
+@@ -863,7 +942,8 @@ cl_int WINAPI wine_clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t ar
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clSetKernelArg(kernel, arg_index, arg_size, arg_value);
+    if (!pclSetKernelArg) return CL_INVALID_KERNEL;
+    ret = pclSetKernelArg(kernel, arg_index, arg_size, arg_value);
+     return ret;
+ }
+ 
+@@ -872,7 +952,8 @@ cl_int WINAPI wine_clGetKernelInfo(cl_kernel kernel, cl_kernel_info param_name,
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetKernelInfo(kernel, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetKernelInfo) return CL_INVALID_VALUE;
+    ret = pclGetKernelInfo(kernel, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -882,7 +963,8 @@ cl_int WINAPI wine_clGetKernelWorkGroupInfo(cl_kernel kernel, cl_device_id devic
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetKernelWorkGroupInfo) return CL_INVALID_VALUE;
+    ret = pclGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -894,7 +976,8 @@ cl_int WINAPI wine_clWaitForEvents(cl_uint num_events, cl_event * event_list)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clWaitForEvents(num_events, event_list);
+    if (!pclWaitForEvents) return CL_INVALID_EVENT;
+    ret = pclWaitForEvents(num_events, event_list);
+     return ret;
+ }
+ 
+@@ -903,7 +986,8 @@ cl_int WINAPI wine_clGetEventInfo(cl_event event, cl_event_info param_name, size
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetEventInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetEventInfo) return CL_INVALID_EVENT;
+    ret = pclGetEventInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -911,7 +995,8 @@ cl_int WINAPI wine_clRetainEvent(cl_event event)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clRetainEvent(event);
+    if (!pclRetainEvent) return CL_INVALID_EVENT;
+    ret = pclRetainEvent(event);
+     return ret;
+ }
+ 
+@@ -919,7 +1004,8 @@ cl_int WINAPI wine_clReleaseEvent(cl_event event)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clReleaseEvent(event);
+    if (!pclReleaseEvent) return CL_INVALID_EVENT;
+    ret = pclReleaseEvent(event);
+     return ret;
+ }
+ 
+@@ -932,7 +1018,8 @@ cl_int WINAPI wine_clGetEventProfilingInfo(cl_event event, cl_profiling_info par
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clGetEventProfilingInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
+    if (!pclGetEventProfilingInfo) return CL_INVALID_EVENT;
+    ret = pclGetEventProfilingInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
+     return ret;
+ }
+ 
+@@ -944,7 +1031,8 @@ cl_int WINAPI wine_clFlush(cl_command_queue command_queue)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", command_queue);
+-    ret = clFlush(command_queue);
+    if (!pclFlush) return CL_INVALID_COMMAND_QUEUE;
+    ret = pclFlush(command_queue);
+     TRACE("(%p)=%d\n", command_queue, ret);
+     return ret;
+ }
+@@ -953,7 +1041,8 @@ cl_int WINAPI wine_clFinish(cl_command_queue command_queue)
+ {
+     cl_int ret;
+     TRACE("(%p)\n", command_queue);
+-    ret = clFinish(command_queue);
+    if (!pclFinish) return CL_INVALID_COMMAND_QUEUE;
+    ret = pclFinish(command_queue);
+     TRACE("(%p)=%d\n", command_queue, ret);
+     return ret;
+ }
+@@ -968,7 +1057,8 @@ cl_int WINAPI wine_clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem bu
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueReadBuffer) return CL_INVALID_VALUE;
+    ret = pclEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -978,7 +1068,8 @@ cl_int WINAPI wine_clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem b
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueWriteBuffer) return CL_INVALID_VALUE;
+    ret = pclEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -988,7 +1079,8 @@ cl_int WINAPI wine_clEnqueueCopyBuffer(cl_command_queue command_queue, cl_mem sr
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueCopyBuffer) return CL_INVALID_VALUE;
+    ret = pclEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1000,7 +1092,8 @@ cl_int WINAPI wine_clEnqueueReadImage(cl_command_queue command_queue, cl_mem ima
+     cl_int ret;
+     TRACE("(%p, %p, %d, %p, %p, %ld, %ld, %p, %d, %p, %p)\n", command_queue, image, blocking_read,
+           origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+-    ret = clEnqueueReadImage(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueReadImage) return CL_INVALID_VALUE;
+    ret = pclEnqueueReadImage(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+     TRACE("(%p, %p, %d, %p, %p, %ld, %ld, %p, %d, %p, %p)=%d\n", command_queue, image, blocking_read,
+           origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event, ret);
+     return ret;
+@@ -1013,7 +1106,8 @@ cl_int WINAPI wine_clEnqueueWriteImage(cl_command_queue command_queue, cl_mem im
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueWriteImage(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueWriteImage) return CL_INVALID_VALUE;
+    ret = pclEnqueueWriteImage(command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1023,7 +1117,8 @@ cl_int WINAPI wine_clEnqueueCopyImage(cl_command_queue command_queue, cl_mem src
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueCopyImage) return CL_INVALID_VALUE;
+    ret = pclEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1033,7 +1128,8 @@ cl_int WINAPI wine_clEnqueueCopyImageToBuffer(cl_command_queue command_queue, cl
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueCopyImageToBuffer) return CL_INVALID_VALUE;
+    ret = pclEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1043,7 +1139,8 @@ cl_int WINAPI wine_clEnqueueCopyBufferToImage(cl_command_queue command_queue, cl
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueCopyBufferToImage) return CL_INVALID_VALUE;
+    ret = pclEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1053,7 +1150,12 @@ void * WINAPI wine_clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buf
+ {
+     void * ret;
+     TRACE("\n");
+-    ret = clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, event, errcode_ret);
+    if (!pclEnqueueMapBuffer)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, event, errcode_ret);
+     return ret;
+ }
+ 
+@@ -1064,7 +1166,12 @@ void * WINAPI wine_clEnqueueMapImage(cl_command_queue command_queue, cl_mem imag
+ {
+     void * ret;
+     TRACE("\n");
+-    ret = clEnqueueMapImage(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);
+    if (!pclEnqueueMapImage)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclEnqueueMapImage(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);
+     return ret;
+ }
+ 
+@@ -1073,7 +1180,8 @@ cl_int WINAPI wine_clEnqueueUnmapMemObject(cl_command_queue command_queue, cl_me
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueUnmapMemObject) return CL_INVALID_VALUE;
+    ret = pclEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1083,7 +1191,8 @@ cl_int WINAPI wine_clEnqueueNDRangeKernel(cl_command_queue command_queue, cl_ker
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueNDRangeKernel) return CL_INVALID_VALUE;
+    ret = pclEnqueueNDRangeKernel(command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1092,7 +1201,8 @@ cl_int WINAPI wine_clEnqueueTask(cl_command_queue command_queue, cl_kernel kerne
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
+    if (!pclEnqueueTask) return CL_INVALID_VALUE;
+    ret = pclEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
+     return ret;
+ }
+ 
+@@ -1121,7 +1231,8 @@ cl_int WINAPI wine_clEnqueueMarker(cl_command_queue command_queue, cl_event * ev
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueMarker(command_queue, event);
+    if (!pclEnqueueMarker) return CL_INVALID_VALUE;
+    ret = pclEnqueueMarker(command_queue, event);
+     return ret;
+ }
+ 
+@@ -1129,7 +1240,8 @@ cl_int WINAPI wine_clEnqueueWaitForEvents(cl_command_queue command_queue, cl_uin
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueWaitForEvents(command_queue, num_events, event_list);
+    if (!pclEnqueueWaitForEvents) return CL_INVALID_VALUE;
+    ret = pclEnqueueWaitForEvents(command_queue, num_events, event_list);
+     return ret;
+ }
+ 
+@@ -1137,7 +1249,8 @@ cl_int WINAPI wine_clEnqueueBarrier(cl_command_queue command_queue)
+ {
+     cl_int ret;
+     TRACE("\n");
+-    ret = clEnqueueBarrier(command_queue);
+    if (!pclEnqueueBarrier) return CL_INVALID_VALUE;
+    ret = pclEnqueueBarrier(command_queue);
+     return ret;
+ }
+ 
+-- 
+1.9.1
+
--- a/patches/opencl-version_1_2/0003-opencl-Add-OpenCL-1.1-implementation.patch
+++ b/patches/opencl-version_1_2/0003-opencl-Add-OpenCL-1.1-implementation.patch
@ -0,0 +1,286 @@
+From 73c7c7b43fcc85af543c53c2cf0180e6be1473a4 Mon Sep 17 00:00:00 2001
+From: Nakarin Khankham <garuda2550@gmail.com>
+Date: Sat, 9 Mar 2019 21:53:49 +0700
+Subject: [PATCH 3/5] opencl: Add OpenCL 1.1 implementation.
+
+Signed-off-by: Nakarin Khankham <garuda2550@gmail.com>
+---
+ dlls/opencl/opencl.c    | 194 ++++++++++++++++++++++++++++++++++++++++++++++++
+ dlls/opencl/opencl.spec |  10 +++
+ 2 files changed, 204 insertions(+)
+
+diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
+index 221cf1a..41fc71b 100644
+--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/opencl.c
+@@ -196,6 +196,28 @@ static cl_int (*pclEnqueueBarrier)(cl_command_queue command_queue);
+ /* Extension function access */
+ static void * (*pclGetExtensionFunctionAddress)(const char * func_name);
+ 
+/* OpenCL 1.1 functions */
+static cl_mem (*pclCreateSubBuffer)(cl_mem buffer, cl_mem_flags flags,
+                                    cl_buffer_create_type buffer_create_type, const void * buffer_create_info, cl_int * errcode_ret);
+static cl_event (*pclCreateUserEvent)(cl_context context, cl_int * errcode_ret);
+static cl_int (*pclEnqueueCopyBufferRect)(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);
+static cl_int (*pclEnqueueReadBufferRect)(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
+                                          const size_t * buffer_origin, const size_t * host_origin, 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);
+static cl_int (*pclEnqueueWriteBufferRect)(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
+                                           const size_t * buffer_origin, const size_t * host_origin, 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);
+static cl_int (*pclSetEventCallback)(cl_event event, cl_int command_exec_callback_type,
+                                     void (*pfn_notify)(cl_event, cl_int, void *), void *user_data);
+static cl_int (*pclSetMemObjectDestructorCallback)(cl_mem memobj, void (*pfn_notify)(cl_mem, void*), void *user_data);
+static cl_int (*pclSetUserEventStatus)(cl_event event, cl_int execution_status);
+
+ 
+ static BOOL init_opencl(void);
+ static BOOL load_opencl_func(void);
+@@ -358,6 +380,18 @@ static BOOL load_opencl_func(void)
+     /* Extension function access */
+     LOAD_FUNCPTR(clGetExtensionFunctionAddress);
+ 
+    /* OpenCL 1.1 functions */
+#ifdef CL_VERSION_1_1
+    LOAD_FUNCPTR(clCreateSubBuffer);
+    LOAD_FUNCPTR(clCreateUserEvent);
+    LOAD_FUNCPTR(clEnqueueCopyBufferRect);
+    LOAD_FUNCPTR(clEnqueueReadBufferRect);
+    LOAD_FUNCPTR(clEnqueueWriteBufferRect);
+    LOAD_FUNCPTR(clSetEventCallback);
+    LOAD_FUNCPTR(clSetMemObjectDestructorCallback);
+    LOAD_FUNCPTR(clSetUserEventStatus);
+#endif
+
+ #undef LOAD_FUNCPTR
+ 
+     return TRUE;
+@@ -648,6 +682,20 @@ cl_mem WINAPI wine_clCreateBuffer(cl_context context, cl_mem_flags flags, size_t
+     return ret;
+ }
+ 
+cl_mem WINAPI wine_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_mem ret;
+    TRACE("\n");
+    if (!pclCreateSubBuffer)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateSubBuffer(buffer, flags, buffer_create_type, buffer_create_info, errcode_ret);
+    return ret;
+}
+
+ cl_mem WINAPI wine_clCreateImage2D(cl_context context, cl_mem_flags flags, 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)
+ {
+@@ -725,6 +773,46 @@ cl_int WINAPI wine_clGetImageInfo(cl_mem image, cl_image_info param_name, size_t
+     return ret;
+ }
+ 
+typedef struct
+{
+    void WINAPI (*pfn_notify)(cl_mem memobj, void* user_data);
+    void *user_data;
+} MEM_CALLBACK;
+
+static void mem_fn_notify(cl_mem memobj, void* user_data)
+{
+    MEM_CALLBACK *mcb;
+    FIXME("(%p, %p)\n", memobj, user_data);
+    mcb = (MEM_CALLBACK *) user_data;
+    mcb->pfn_notify(memobj, mcb->user_data);
+    HeapFree(GetProcessHeap(), 0, mcb);
+    FIXME("Callback COMPLETED\n");
+}
+
+cl_int WINAPI wine_clSetMemObjectDestructorCallback(cl_mem memobj, void WINAPI (*pfn_notify)(cl_mem, void*), void *user_data)
+{
+    /* FIXME: Based on PROGRAM_CALLBACK/program_fn_notify function. I'm not sure about this. */
+    cl_int ret;
+    FIXME("(%p, %p, %p)\n", memobj, pfn_notify, user_data);
+    if (!pclSetMemObjectDestructorCallback) return CL_INVALID_VALUE;
+    if(pfn_notify)
+    {
+        /* When pfn_notify is provided, clSetMemObjectDestructorCallback is asynchronous */
+        MEM_CALLBACK *mcb;
+        mcb = HeapAlloc(GetProcessHeap(), 0, sizeof(MEM_CALLBACK));
+        mcb->pfn_notify = pfn_notify;
+        mcb->user_data = user_data;
+        ret = pclSetMemObjectDestructorCallback(memobj, mem_fn_notify, user_data);
+    }
+    else
+    {
+        /* When pfn_notify is NULL, clSetMemObjectDestructorCallback is synchronous */
+        ret = pclSetMemObjectDestructorCallback(memobj, NULL, user_data);
+    }
+    FIXME("(%p, %p, %p)=%d\n", memobj, pfn_notify, user_data, ret);
+    return ret;
+}
+
+ 
+ /*---------------------------------------------------------------*/
+ /* Sampler APIs  */
+@@ -1009,6 +1097,69 @@ cl_int WINAPI wine_clReleaseEvent(cl_event event)
+     return ret;
+ }
+ 
+cl_event WINAPI wine_clCreateUserEvent(cl_context context, cl_int * errcode_ret)
+{
+    cl_event ret;
+    TRACE("\n");
+    if (!pclCreateUserEvent)
+    {
+        *errcode_ret = CL_INVALID_CONTEXT;
+        return NULL;
+    }
+    ret = pclCreateUserEvent(context, errcode_ret);
+    return ret;
+}
+
+typedef struct
+{
+    void WINAPI (*pfn_notify)(cl_event event, cl_int num, void* user_data);
+    void *user_data;
+} EVENT_CALLBACK;
+
+static void event_fn_notify(cl_event event, cl_int num, void* user_data)
+{
+    EVENT_CALLBACK *ecb;
+    FIXME("(%p, %d, %p)\n", event, num, user_data);
+    ecb = (EVENT_CALLBACK *) user_data;
+    ecb->pfn_notify(event, num, ecb->user_data);
+    HeapFree(GetProcessHeap(), 0, ecb);
+    FIXME("Callback COMPLETED\n");
+}
+
+cl_int WINAPI wine_clSetEventCallback(cl_event event, cl_int command_exec_callback_type,
+                                      void WINAPI (*pfn_notify)(cl_event, cl_int, void *), void *user_data)
+{
+    /* FIXME: Based on PROGRAM_CALLBACK/program_fn_notify function. I'm not sure about this. */
+    cl_int ret;
+    FIXME("(%p, %d, %p, %p)\n", event, command_exec_callback_type, pfn_notify, user_data);
+    if (!pclSetEventCallback) return CL_INVALID_EVENT;
+    if(pfn_notify)
+    {
+        /* When pfn_notify is provided, clSetEventCallback is asynchronous */
+        EVENT_CALLBACK *ecb;
+        ecb = HeapAlloc(GetProcessHeap(), 0, sizeof(EVENT_CALLBACK));
+        ecb->pfn_notify = pfn_notify;
+        ecb->user_data = user_data;
+        ret = pclSetEventCallback(event, command_exec_callback_type, event_fn_notify, user_data);
+    }
+    else
+    {
+        /* When pfn_notify is NULL, clSetEventCallback is synchronous */
+        ret = pclSetEventCallback(event, command_exec_callback_type, NULL, user_data);
+    }
+    FIXME("(%p, %d, %p, %p)=%d\n", event, command_exec_callback_type, pfn_notify, user_data, ret);
+    return ret;
+}
+
+cl_int WINAPI wine_clSetUserEventStatus(cl_event event, cl_int execution_status)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclSetUserEventStatus) return CL_INVALID_EVENT;
+    ret = pclSetUserEventStatus(event, execution_status);
+    return ret;
+}
+
+ 
+ /*---------------------------------------------------------------*/
+ /* Profiling APIs  */
+@@ -1062,6 +1213,21 @@ cl_int WINAPI wine_clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem bu
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueReadBufferRect(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
+                                           const size_t * buffer_origin, const size_t * host_origin, 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_int ret;
+    TRACE("\n");
+    if (!pclEnqueueReadBufferRect) return CL_INVALID_VALUE;
+    ret = pclEnqueueReadBufferRect(command_queue, buffer, blocking_read,
+        buffer_origin, host_origin, region,
+        buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch,
+        ptr, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_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)
+@@ -1073,6 +1239,21 @@ cl_int WINAPI wine_clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem b
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
+                                            const size_t * buffer_origin, const size_t * host_origin, 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_int ret;
+    TRACE("\n");
+    if (!pclEnqueueWriteBufferRect) return CL_INVALID_VALUE;
+    ret = pclEnqueueWriteBufferRect(command_queue, buffer, blocking_read,
+        buffer_origin, host_origin, region,
+        buffer_row_pitch, buffer_slice_pitch, host_row_pitch, host_slice_pitch,
+        ptr, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_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)
+@@ -1084,6 +1265,19 @@ cl_int WINAPI wine_clEnqueueCopyBuffer(cl_command_queue command_queue, cl_mem sr
+     return ret;
+ }
+ 
+cl_int WINAPI wine_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_int ret;
+    TRACE("\n");
+    if (!pclEnqueueCopyBufferRect) return CL_INVALID_VALUE;
+    ret = pclEnqueueCopyBufferRect(command_queue, src_buffer, dst_buffer, src_origin,  dst_origin, region, src_row_pitch, src_slice_pitch, dst_row_pitch, dst_slice_pitch, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_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,
+diff --git a/dlls/opencl/opencl.spec b/dlls/opencl/opencl.spec
+index ba8ce6e..4782653 100644
+--- a/dlls/opencl/opencl.spec
+++ b/dlls/opencl/opencl.spec
+@@ -94,3 +94,13 @@
+ # @ stdcall clGetGLTextureInfo( long long long ptr ptr ) wine_clGetGLTextureInfo
+ # @ stdcall clEnqueueAcquireGLObjects( long long ptr long ptr ptr ) wine_clEnqueueAcquireGLObjects
+ # @ stdcall clEnqueueReleaseGLObjects( long long ptr long ptr ptr ) wine_clEnqueueReleaseGLObjects
+
+# OpenCL 1.1
+@ stdcall clCreateSubBuffer( long long long ptr ptr ) wine_clCreateSubBuffer
+@ stdcall clCreateUserEvent( long ptr ) wine_clCreateUserEvent
+@ stdcall clEnqueueCopyBufferRect( long long long ptr ptr ptr long long long long long ptr ptr ) wine_clEnqueueCopyBufferRect
+@ stdcall clEnqueueReadBufferRect( long long long ptr ptr ptr long long long long ptr long ptr ptr ) wine_clEnqueueReadBufferRect
+@ stdcall clEnqueueWriteBufferRect( long long long ptr ptr ptr long long long long ptr long ptr ptr ) wine_clEnqueueWriteBufferRect
+@ stdcall clSetEventCallback( long long ptr ptr ) wine_clSetEventCallback
+@ stdcall clSetMemObjectDestructorCallback( long ptr ptr ) wine_clSetMemObjectDestructorCallback
+@ stdcall clSetUserEventStatus( long long ) wine_clSetUserEventStatus
+-- 
+1.9.1
+
--- a/patches/opencl-version_1_2/0004-opencl-Add-OpenCL-1.2-implementation.patch
+++ b/patches/opencl-version_1_2/0004-opencl-Add-OpenCL-1.2-implementation.patch
@ -0,0 +1,391 @@
+From da060b9c27b02dfa808185ec7938899b7839e942 Mon Sep 17 00:00:00 2001
+From: Nakarin Khankham <garuda2550@gmail.com>
+Date: Sat, 9 Mar 2019 22:27:52 +0700
+Subject: [PATCH 4/5] opencl: Add OpenCL 1.2 implementation.
+
+Signed-off-by: Nakarin Khankham <garuda2550@gmail.com>
+---
+ dlls/opencl/opencl.c    | 252 ++++++++++++++++++++++++++++++++++++++++++++++++
+ dlls/opencl/opencl.spec |  18 ++++
+ 2 files changed, 270 insertions(+)
+
+diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
+index 41fc71b..fccc45c 100644
+--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/opencl.c
+@@ -218,6 +218,39 @@ static cl_int (*pclSetEventCallback)(cl_event event, cl_int command_exec_callbac
+ static cl_int (*pclSetMemObjectDestructorCallback)(cl_mem memobj, void (*pfn_notify)(cl_mem, void*), void *user_data);
+ static cl_int (*pclSetUserEventStatus)(cl_event event, cl_int execution_status);
+ 
+/* OpenCL 1.2 functions */
+static cl_int (*pclCompileProgram)(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 (*pfn_notify)(cl_program program, void * user_data),
+                                   void * user_data);
+static cl_mem (*pclCreateImage)(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);
+static cl_program (*pclCreateProgramWithBuiltInKernels)(cl_context context, cl_uint num_devices, const cl_device_id * device_list,
+                                                        const char * kernel_names, cl_int * errcode_ret);
+static cl_int (*pclCreateSubDevices)(cl_device_id in_device, const cl_device_partition_property * properties, cl_uint num_entries,
+                                     cl_device_id * out_devices, cl_uint * num_devices);
+static cl_int (*pclEnqueueBarrierWithWaitList)(cl_command_queue command_queue, cl_uint num_events_in_wait_list,
+                                               const cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueFillBuffer)(cl_command_queue command_queue, cl_mem buffer, const void * pattern, size_t pattern_size, size_t offset, size_t cb,
+                                      cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueFillImage)(cl_command_queue command_queue, cl_mem image, const void * fill_color,
+                                     const size_t * origin, const size_t * region,
+                                     cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueMarkerWithWaitList)(cl_command_queue command_queue, cl_uint num_events_in_wait_list,
+                                              const cl_event * event_wait_list, cl_event * event);
+static cl_int (*pclEnqueueMigrateMemObjects)(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);
+static void * (*pclGetExtensionFunctionAddressForPlatform)(cl_platform_id platform, const char * function_name);
+static cl_int (*pclGetKernelArgInfo)(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);
+static cl_program (*pclLinkProgram)(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 (* pfn_notify)(cl_program program, void * user_data),
+                                    void * user_data, cl_int * errcode_ret);
+static cl_int (*pclReleaseDevice)(cl_device_id device);
+static cl_int (*pclRetainDevice)(cl_device_id device);
+static cl_int (*pclUnloadPlatformCompiler)(cl_platform_id platform);
+
+ 
+ static BOOL init_opencl(void);
+ static BOOL load_opencl_func(void);
+@@ -392,6 +425,26 @@ static BOOL load_opencl_func(void)
+     LOAD_FUNCPTR(clSetUserEventStatus);
+ #endif
+ 
+    /* OpenCL 1.2 functions */
+#ifdef CL_VERSION_1_2
+    LOAD_FUNCPTR(clCompileProgram);
+    /*LOAD_FUNCPTR(clCreateFromGLTexture);*/
+    LOAD_FUNCPTR(clCreateImage);
+    LOAD_FUNCPTR(clCreateProgramWithBuiltInKernels);
+    LOAD_FUNCPTR(clCreateSubDevices);
+    LOAD_FUNCPTR(clEnqueueBarrierWithWaitList);
+    LOAD_FUNCPTR(clEnqueueFillBuffer);
+    LOAD_FUNCPTR(clEnqueueFillImage);
+    LOAD_FUNCPTR(clEnqueueMarkerWithWaitList);
+    LOAD_FUNCPTR(clEnqueueMigrateMemObjects);
+    LOAD_FUNCPTR(clGetExtensionFunctionAddressForPlatform);
+    LOAD_FUNCPTR(clGetKernelArgInfo);
+    LOAD_FUNCPTR(clLinkProgram);
+    LOAD_FUNCPTR(clReleaseDevice);
+    LOAD_FUNCPTR(clRetainDevice);
+    LOAD_FUNCPTR(clUnloadPlatformCompiler);
+#endif
+
+ #undef LOAD_FUNCPTR
+ 
+     return TRUE;
+@@ -507,6 +560,38 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clCreateSubDevices(cl_device_id in_device, const cl_device_partition_property * properties, cl_uint num_entries,
+                                      cl_device_id * out_devices, cl_uint * num_devices)
+{
+    cl_int ret;
+    TRACE("(%p, %p, %d, %p, %p)\n", in_device, properties, num_entries, out_devices, num_devices);
+    if (!pclCreateSubDevices) return CL_INVALID_VALUE;
+    ret = pclCreateSubDevices(in_device, properties, num_entries, out_devices, num_devices);
+    TRACE("(%p, %p, %d, %p, %p)=%d\n", in_device, properties, num_entries, out_devices, num_devices, ret);
+    return ret;
+}
+
+cl_int WINAPI wine_clRetainDevice(cl_device_id device)
+{
+    cl_int ret;
+    TRACE("(%p)\n", device);
+    if (!pclRetainDevice) return CL_INVALID_DEVICE;
+    ret = pclRetainDevice(device);
+    TRACE("(%p)=%d\n", device, ret);
+    return ret;
+
+}
+
+cl_int WINAPI wine_clReleaseDevice(cl_device_id device)
+{
+    cl_int ret;
+    TRACE("(%p)\n", device);
+    if (!pclReleaseDevice) return CL_INVALID_DEVICE;
+    ret = pclReleaseDevice(device);
+    TRACE("(%p)=%d\n", device, ret);
+    return ret;
+}
+
+ 
+ /*---------------------------------------------------------------*/
+ /* Context APIs  */
+@@ -696,6 +781,20 @@ cl_mem WINAPI wine_clCreateSubBuffer(cl_mem buffer, cl_mem_flags flags,
+     return ret;
+ }
+ 
+cl_mem WINAPI wine_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_mem ret;
+    TRACE("\n");
+    if (!pclCreateImage)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateImage(context, flags, image_format, image_desc, host_ptr, errcode_ret);
+    return ret;
+}
+
+ cl_mem WINAPI wine_clCreateImage2D(cl_context context, cl_mem_flags flags, 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)
+ {
+@@ -892,6 +991,20 @@ cl_program WINAPI wine_clCreateProgramWithBinary(cl_context context, cl_uint num
+     return ret;
+ }
+ 
+cl_program WINAPI wine_clCreateProgramWithBuiltInKernels(cl_context context, cl_uint num_devices, const cl_device_id * device_list,
+                                                         const char * kernel_names, cl_int * errcode_ret)
+{
+    cl_program ret;
+    TRACE("\n");
+    if (!pclCreateProgramWithBuiltInKernels)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    ret = pclCreateProgramWithBuiltInKernels(context, num_devices, device_list, kernel_names, errcode_ret);
+    return ret;
+}
+
+ cl_int WINAPI wine_clRetainProgram(cl_program program)
+ {
+     cl_int ret;
+@@ -950,6 +1063,60 @@ cl_int WINAPI wine_clBuildProgram(cl_program program, cl_uint num_devices, const
+     return ret;
+ }
+ 
+cl_int WINAPI wine_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 WINAPI (*pfn_notify)(cl_program program, void * user_data),
+                                    void * user_data)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclCompileProgram) return CL_INVALID_VALUE;
+    if(pfn_notify)
+    {
+        /* When pfn_notify is provided, clCompileProgram is asynchronous */
+        PROGRAM_CALLBACK *pcb;
+        pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
+        pcb->pfn_notify = pfn_notify;
+        pcb->user_data = user_data;
+        ret = pclCompileProgram(program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, program_fn_notify, user_data);
+    }
+    else
+    {
+        /* When pfn_notify is NULL, clCompileProgram is synchronous */
+        ret = pclCompileProgram(program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, NULL, user_data);
+    }
+    return ret;
+}
+
+cl_program WINAPI wine_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 WINAPI (* pfn_notify)(cl_program program, void * user_data),
+                                     void * user_data, cl_int * errcode_ret)
+{
+    cl_program ret;
+    TRACE("\n");
+    if (!pclLinkProgram)
+    {
+        *errcode_ret = CL_INVALID_VALUE;
+        return NULL;
+    }
+    if(pfn_notify)
+    {
+        /* When pfn_notify is provided, clLinkProgram is asynchronous */
+        PROGRAM_CALLBACK *pcb;
+        pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
+        pcb->pfn_notify = pfn_notify;
+        pcb->user_data = user_data;
+        ret = pclLinkProgram(context, num_devices, device_list, options, num_input_programs, input_programs, program_fn_notify, user_data, errcode_ret);
+    }
+    else
+    {
+        /* When pfn_notify is NULL, clLinkProgram is synchronous */
+        ret = pclLinkProgram(context, num_devices, device_list, options, num_input_programs, input_programs, NULL, user_data, errcode_ret);
+    }
+    return ret;
+}
+
+ cl_int WINAPI wine_clUnloadCompiler(void)
+ {
+     cl_int ret;
+@@ -960,6 +1127,16 @@ cl_int WINAPI wine_clUnloadCompiler(void)
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clUnloadPlatformCompiler(cl_platform_id platform)
+{
+    cl_int ret;
+    TRACE("()\n");
+    if (!pclUnloadPlatformCompiler) return CL_SUCCESS;
+    ret = pclUnloadPlatformCompiler(platform);
+    TRACE("()=%d\n", ret);
+    return ret;
+}
+
+ cl_int WINAPI wine_clGetProgramInfo(cl_program program, cl_program_info param_name,
+                                     size_t param_value_size, void * param_value, size_t * param_value_size_ret)
+ {
+@@ -1035,6 +1212,16 @@ cl_int WINAPI wine_clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t ar
+     return ret;
+ }
+ 
+cl_int WINAPI wine_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_int ret;
+    TRACE("\n");
+    if (!pclGetKernelArgInfo) return CL_INVALID_VALUE;
+    ret = pclGetKernelArgInfo(kernel, arg_indx, param_name, param_value_size, param_value, param_value_size_ret);
+    return ret;
+}
+
+ cl_int WINAPI wine_clGetKernelInfo(cl_kernel kernel, cl_kernel_info param_name,
+                                    size_t param_value_size, void * param_value, size_t * param_value_size_ret)
+ {
+@@ -1254,6 +1441,16 @@ cl_int WINAPI wine_clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueFillBuffer(cl_command_queue command_queue, cl_mem buffer, const void * pattern, size_t pattern_size, size_t offset, size_t cb,
+                                       cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclEnqueueFillBuffer) return CL_INVALID_VALUE;
+    ret = pclEnqueueFillBuffer(command_queue, buffer, pattern, pattern_size, offset, cb, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_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)
+@@ -1305,6 +1502,17 @@ cl_int WINAPI wine_clEnqueueWriteImage(cl_command_queue command_queue, cl_mem im
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueFillImage(cl_command_queue command_queue, cl_mem image, const void * fill_color,
+                                      const size_t * origin, const size_t * region,
+                                      cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclEnqueueFillImage) return CL_INVALID_VALUE;
+    ret = pclEnqueueFillImage(command_queue, image, fill_color,  origin, region, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_clEnqueueCopyImage(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image,
+                                       size_t * src_origin, size_t * dst_origin, size_t * region,
+                                       cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
+@@ -1379,6 +1587,16 @@ cl_int WINAPI wine_clEnqueueUnmapMemObject(cl_command_queue command_queue, cl_me
+     return ret;
+ }
+ 
+cl_int WINAPI wine_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_int ret;
+    TRACE("\n");
+    if (!pclEnqueueMigrateMemObjects) return CL_INVALID_VALUE;
+    ret = pclEnqueueMigrateMemObjects(command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_clEnqueueNDRangeKernel(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
+                                           size_t * global_work_offset, size_t * global_work_size, size_t * local_work_size,
+                                           cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
+@@ -1430,6 +1648,16 @@ cl_int WINAPI wine_clEnqueueMarker(cl_command_queue command_queue, cl_event * ev
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueMarkerWithWaitList(cl_command_queue command_queue, cl_uint num_events_in_wait_list,
+                                               const cl_event * event_wait_list, cl_event * event)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclEnqueueMarkerWithWaitList) return CL_INVALID_COMMAND_QUEUE;
+    ret = pclEnqueueMarkerWithWaitList(command_queue, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ cl_int WINAPI wine_clEnqueueWaitForEvents(cl_command_queue command_queue, cl_uint num_events, cl_event * event_list)
+ {
+     cl_int ret;
+@@ -1448,10 +1676,34 @@ cl_int WINAPI wine_clEnqueueBarrier(cl_command_queue command_queue)
+     return ret;
+ }
+ 
+cl_int WINAPI wine_clEnqueueBarrierWithWaitList(cl_command_queue command_queue, cl_uint num_events_in_wait_list,
+                                                const cl_event * event_wait_list, cl_event * event)
+{
+    cl_int ret;
+    TRACE("\n");
+    if (!pclEnqueueBarrierWithWaitList) return CL_INVALID_COMMAND_QUEUE;
+    ret = pclEnqueueBarrierWithWaitList(command_queue, num_events_in_wait_list, event_wait_list, event);
+    return ret;
+}
+
+ 
+ /*---------------------------------------------------------------*/
+ /* Extension function access */
+ 
+void * WINAPI wine_clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, const char * function_name)
+{
+    void * ret = NULL;
+    TRACE("(%p, %s)\n", platform, function_name);
+#if 0
+    if (!pclGetExtensionFunctionAddressForPlatform) return NULL;
+    ret = pclGetExtensionFunctionAddressForPlatform(platform, function_name);
+#else
+    FIXME("(%p, %s), extensions support is not implemented\n", platform, function_name);
+#endif
+    TRACE("(%p, %s)=%p\n", platform, function_name, ret);
+    return ret;
+}
+
+ void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
+ {
+     void * ret = 0;
+diff --git a/dlls/opencl/opencl.spec b/dlls/opencl/opencl.spec
+index 4782653..60dda4d 100644
+--- a/dlls/opencl/opencl.spec
+++ b/dlls/opencl/opencl.spec
+@@ -104,3 +104,21 @@
+ @ stdcall clSetEventCallback( long long ptr ptr ) wine_clSetEventCallback
+ @ stdcall clSetMemObjectDestructorCallback( long ptr ptr ) wine_clSetMemObjectDestructorCallback
+ @ stdcall clSetUserEventStatus( long long ) wine_clSetUserEventStatus
+
+# OpenCL 1.2
+@ stdcall clCompileProgram( long long ptr str long ptr ptr ptr ptr ) wine_clCompileProgram
+@ stub clCreateFromGLTexture
+@ stdcall clCreateImage( long long ptr ptr ptr ptr ) wine_clCreateImage
+@ stdcall clCreateProgramWithBuiltInKernels( long long ptr str ptr ) wine_clCreateProgramWithBuiltInKernels
+@ stdcall clCreateSubDevices( long ptr long ptr ptr ) wine_clCreateSubDevices
+@ stdcall clEnqueueBarrierWithWaitList( long long ptr ptr ) wine_clEnqueueBarrierWithWaitList
+@ stdcall clEnqueueFillBuffer( long long ptr long long long long ptr ptr ) wine_clEnqueueFillBuffer
+@ stdcall clEnqueueFillImage( long long ptr ptr ptr long ptr ptr ) wine_clEnqueueFillImage
+@ stdcall clEnqueueMarkerWithWaitList( long long ptr ptr ) wine_clEnqueueMarkerWithWaitList
+@ stdcall clEnqueueMigrateMemObjects( long long ptr long long ptr ptr ) wine_clEnqueueMigrateMemObjects
+@ stdcall clGetExtensionFunctionAddressForPlatform( long str ) wine_clGetExtensionFunctionAddressForPlatform
+@ stdcall clGetKernelArgInfo( long long long long ptr ptr ) wine_clGetKernelArgInfo
+@ stdcall clLinkProgram( long long ptr str long ptr ptr ptr ptr ) wine_clLinkProgram
+@ stdcall clReleaseDevice( long ) wine_clReleaseDevice
+@ stdcall clRetainDevice( long ) wine_clRetainDevice
+@ stdcall clUnloadPlatformCompiler( long ) wine_clUnloadPlatformCompiler
+-- 
+1.9.1
+
--- a/patches/opencl-version_1_2/0005-opencl-Expose-all-extensions-list-to-wine.patch
+++ b/patches/opencl-version_1_2/0005-opencl-Expose-all-extensions-list-to-wine.patch
@ -0,0 +1,55 @@
+From e7d44cc8b01ba8b3b54c79d4eaf5ea674ac4e997 Mon Sep 17 00:00:00 2001
+From: Nakarin Khankham <garuda2550@gmail.com>
+Date: Sat, 9 Mar 2019 22:40:55 +0700
+Subject: [PATCH 5/5] opencl: Expose all extensions list to wine.
+
+Ideally we should blacklist each extensions instead.
+
+Signed-off-by: Nakarin Khankham <garuda2550@gmail.com>
+---
+ dlls/opencl/opencl.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/dlls/opencl/opencl.c b/dlls/opencl/opencl.c
+index fccc45c..d028bcd 100644
+--- a/dlls/opencl/opencl.c
+++ b/dlls/opencl/opencl.c
+@@ -475,7 +475,7 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
+     /* Hide all extensions.
+      * TODO: Add individual extension support as needed.
+      */
+-    if (param_name == CL_PLATFORM_EXTENSIONS)
+/*    if (param_name == CL_PLATFORM_EXTENSIONS)
+     {
+         ret = CL_INVALID_VALUE;
+ 
+@@ -492,7 +492,7 @@ cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info p
+             ret = CL_SUCCESS;
+         }
+     }
+-    else
+    else*/
+     {
+         ret = pclGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
+     }
+@@ -527,7 +527,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
+     /* Hide all extensions.
+      * TODO: Add individual extension support as needed.
+      */
+-    if (param_name == CL_DEVICE_EXTENSIONS)
+/*    if (param_name == CL_DEVICE_EXTENSIONS)
+     {
+         ret = CL_INVALID_VALUE;
+ 
+@@ -544,7 +544,7 @@ cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_nam
+             ret = CL_SUCCESS;
+         }
+     }
+-    else
+    else*/
+     {
+         ret = pclGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
+     }
+-- 
+1.9.1
+
--- a/patches/opencl-version_1_2/definition
+++ b/patches/opencl-version_1_2/definition
@ -0,0 +1 @@
+Fixes: [46470] opencl: Add support for OpenCL 1.2.
--- a/patches/patchinstall.sh
+++ b/patches/patchinstall.sh
@ -52,7 +52,7 @@ usage()
 # Get the upstream commit sha
 upstream_commit()
 {
-	echo "f34f13825fd060fda40f0a5b02dc1b420e3a8e1e"
+	echo "73355cab96de112f5125907424b37289afc6ebe7"
 }

 # Show version information
@ -249,6 +249,7 @@ patch_enable_all ()
 	enable_oleaut32_OLEPictureImpl_SaveAsFile="$1"
 	enable_oleaut32_OleLoadPicture="$1"
 	enable_oleaut32_OleLoadPictureFile="$1"
+	enable_opencl_version_1_2="$1"
 	enable_opengl32_wglChoosePixelFormat="$1"
 	enable_packager_DllMain="$1"
 	enable_pdh_PdhLookupPerfNameByIndex_processor="$1"
@ -898,6 +899,9 @@ patch_enable ()
 		oleaut32-OleLoadPictureFile)
 			enable_oleaut32_OleLoadPictureFile="$2"
 			;;
+		opencl-version_1_2)
+			enable_opencl_version_1_2="$2"
+			;;
 		opengl32-wglChoosePixelFormat)
 			enable_opengl32_wglChoosePixelFormat="$2"
 			;;
@ -5286,6 +5290,29 @@ if test "$enable_oleaut32_OleLoadPictureFile" -eq 1; then
 	) >> "$patchlist"
 fi

+# Patchset opencl-version_1_2
+# |
+# | This patchset fixes the following Wine bugs:
+# |   *	[#46470] opencl: Add support for OpenCL 1.2.
+# |
+# | Modified files:
+# |   *	configure, configure.ac, dlls/opencl/opencl.c, dlls/opencl/opencl.spec, include/config.h.in
+# |
+if test "$enable_opencl_version_1_2" -eq 1; then
+	patch_apply opencl-version_1_2/0001-opencl-Add-OpenCL-1.0-function-pointer-loader.patch
+	patch_apply opencl-version_1_2/0002-opencl-Use-function-pointer-instead-of-call-the-func.patch
+	patch_apply opencl-version_1_2/0003-opencl-Add-OpenCL-1.1-implementation.patch
+	patch_apply opencl-version_1_2/0004-opencl-Add-OpenCL-1.2-implementation.patch
+	patch_apply opencl-version_1_2/0005-opencl-Expose-all-extensions-list-to-wine.patch
+	(
+		printf '%s\n' '+    { "Nakarin Khankham", "opencl: Add OpenCL 1.0 function pointer loader.", 1 },';
+		printf '%s\n' '+    { "Nakarin Khankham", "opencl: Use function pointer instead of call the function directly.", 1 },';
+		printf '%s\n' '+    { "Nakarin Khankham", "opencl: Add OpenCL 1.1 implementation.", 1 },';
+		printf '%s\n' '+    { "Nakarin Khankham", "opencl: Add OpenCL 1.2 implementation.", 1 },';
+		printf '%s\n' '+    { "Nakarin Khankham", "opencl: Expose all extensions list to wine.", 1 },';
+	) >> "$patchlist"
+fi
+
 # Patchset opengl32-wglChoosePixelFormat
 # |
 # | This patchset fixes the following Wine bugs:
				`@ -0,0 +1 @@`
				`Fixes: [46470] opencl: Add support for OpenCL 1.2.`