dlls/opencl/pe_thunks.c

   1 /* Automatically generated from OpenCL registry files; DO NOT EDIT! */
   2
   3 #include "opencl_private.h"
   4 #include "opencl_types.h"
   5 #include "unixlib.h"
   6
   7 WINE_DEFAULT_DEBUG_CHANNEL(opencl);
   8
   9 cl_int WINAPI clBuildProgram( cl_program program, cl_uint num_devices, const cl_device_id* device_list, const char* options, void (WINAPI* pfn_notify)(cl_program program, void* user_data), void* user_data )
  10 {
  11     TRACE( "(%p, %u, %p, %p, %p, %p)\n", program, num_devices, device_list, options, pfn_notify, user_data );
  12     return opencl_funcs->pclBuildProgram( program, num_devices, device_list, options, pfn_notify, user_data );
  13 }
  14
  15 cl_int WINAPI 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 )
  16 {
  17     TRACE( "(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data );
  18     return opencl_funcs->pclCompileProgram( program, num_devices, device_list, options, num_input_headers, input_headers, header_include_names, pfn_notify, user_data );
  19 }
  20
  21 cl_mem WINAPI clCreateBuffer( cl_context context, cl_mem_flags flags, size_t size, void* host_ptr, cl_int* errcode_ret )
  22 {
  23     TRACE( "(%p, %s, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), size, host_ptr, errcode_ret );
  24     return opencl_funcs->pclCreateBuffer( context, flags, size, host_ptr, errcode_ret );
  25 }
  26
  27 cl_command_queue WINAPI clCreateCommandQueue( cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_int* errcode_ret )
  28 {
  29     TRACE( "(%p, %p, %s, %p)\n", context, device, wine_dbgstr_longlong(properties), errcode_ret );
  30     return opencl_funcs->pclCreateCommandQueue( context, device, properties, errcode_ret );
  31 }
  32
  33 cl_context WINAPI clCreateContext( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret )
  34 {
  35     TRACE( "(%p, %u, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
  36     return opencl_funcs->pclCreateContext( properties, num_devices, devices, pfn_notify, user_data, errcode_ret );
  37 }
  38
  39 cl_context WINAPI clCreateContextFromType( const cl_context_properties* properties, cl_device_type device_type, void (WINAPI* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), void* user_data, cl_int* errcode_ret )
  40 {
  41     TRACE( "(%p, %s, %p, %p, %p)\n", properties, wine_dbgstr_longlong(device_type), pfn_notify, user_data, errcode_ret );
  42     return opencl_funcs->pclCreateContextFromType( properties, device_type, pfn_notify, user_data, errcode_ret );
  43 }
  44
  45 cl_mem WINAPI 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 )
  46 {
  47     TRACE( "(%p, %s, %p, %p, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_desc, host_ptr, errcode_ret );
  48     return opencl_funcs->pclCreateImage( context, flags, image_format, image_desc, host_ptr, errcode_ret );
  49 }
  50
  51 cl_mem WINAPI 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 )
  52 {
  53     TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
  54     return opencl_funcs->pclCreateImage2D( context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret );
  55 }
  56
  57 cl_mem WINAPI 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 )
  58 {
  59     TRACE( "(%p, %s, %p, %Iu, %Iu, %Iu, %Iu, %Iu, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
  60     return opencl_funcs->pclCreateImage3D( context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret );
  61 }
  62
  63 cl_kernel WINAPI clCreateKernel( cl_program program, const char* kernel_name, cl_int* errcode_ret )
  64 {
  65     TRACE( "(%p, %p, %p)\n", program, kernel_name, errcode_ret );
  66     return opencl_funcs->pclCreateKernel( program, kernel_name, errcode_ret );
  67 }
  68
  69 cl_int WINAPI clCreateKernelsInProgram( cl_program program, cl_uint num_kernels, cl_kernel* kernels, cl_uint* num_kernels_ret )
  70 {
  71     TRACE( "(%p, %u, %p, %p)\n", program, num_kernels, kernels, num_kernels_ret );
  72     return opencl_funcs->pclCreateKernelsInProgram( program, num_kernels, kernels, num_kernels_ret );
  73 }
  74
  75 cl_program WINAPI 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 )
  76 {
  77     TRACE( "(%p, %u, %p, %p, %p, %p, %p)\n", context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
  78     return opencl_funcs->pclCreateProgramWithBinary( context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret );
  79 }
  80
  81 cl_program WINAPI clCreateProgramWithBuiltInKernels( cl_context context, cl_uint num_devices, const cl_device_id* device_list, const char* kernel_names, cl_int* errcode_ret )
  82 {
  83     TRACE( "(%p, %u, %p, %p, %p)\n", context, num_devices, device_list, kernel_names, errcode_ret );
  84     return opencl_funcs->pclCreateProgramWithBuiltInKernels( context, num_devices, device_list, kernel_names, errcode_ret );
  85 }
  86
  87 cl_program WINAPI clCreateProgramWithSource( cl_context context, cl_uint count, const char** strings, const size_t* lengths, cl_int* errcode_ret )
  88 {
  89     TRACE( "(%p, %u, %p, %p, %p)\n", context, count, strings, lengths, errcode_ret );
  90     return opencl_funcs->pclCreateProgramWithSource( context, count, strings, lengths, errcode_ret );
  91 }
  92
  93 cl_sampler WINAPI clCreateSampler( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret )
  94 {
  95     TRACE( "(%p, %u, %u, %u, %p)\n", context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
  96     return opencl_funcs->pclCreateSampler( context, normalized_coords, addressing_mode, filter_mode, errcode_ret );
  97 }
  98
  99 cl_mem WINAPI clCreateSubBuffer( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void* buffer_create_info, cl_int* errcode_ret )
 100 {
 101     TRACE( "(%p, %s, %u, %p, %p)\n", buffer, wine_dbgstr_longlong(flags), buffer_create_type, buffer_create_info, errcode_ret );
 102     return opencl_funcs->pclCreateSubBuffer( buffer, flags, buffer_create_type, buffer_create_info, errcode_ret );
 103 }
 104
 105 cl_int WINAPI clCreateSubDevices( cl_device_id in_device, const cl_device_partition_property* properties, cl_uint num_devices, cl_device_id* out_devices, cl_uint* num_devices_ret )
 106 {
 107     TRACE( "(%p, %p, %u, %p, %p)\n", in_device, properties, num_devices, out_devices, num_devices_ret );
 108     return opencl_funcs->pclCreateSubDevices( in_device, properties, num_devices, out_devices, num_devices_ret );
 109 }
 110
 111 cl_event WINAPI clCreateUserEvent( cl_context context, cl_int* errcode_ret )
 112 {
 113     TRACE( "(%p, %p)\n", context, errcode_ret );
 114     return opencl_funcs->pclCreateUserEvent( context, errcode_ret );
 115 }
 116
 117 cl_int WINAPI clEnqueueBarrier( cl_command_queue command_queue )
 118 {
 119     TRACE( "(%p)\n", command_queue );
 120     return opencl_funcs->pclEnqueueBarrier( command_queue );
 121 }
 122
 123 cl_int WINAPI clEnqueueBarrierWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 124 {
 125     TRACE( "(%p, %u, %p, %p)\n", command_queue, num_events_in_wait_list, event_wait_list, event );
 126     return opencl_funcs->pclEnqueueBarrierWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
 127 }
 128
 129 cl_int WINAPI clEnqueueCopyBuffer( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 130 {
 131     TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
 132     return opencl_funcs->pclEnqueueCopyBuffer( command_queue, src_buffer, dst_buffer, src_offset, dst_offset, size, num_events_in_wait_list, event_wait_list, event );
 133 }
 134
 135 cl_int WINAPI 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 )
 136 {
 137     TRACE( "(%p, %p, %p, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %u, %p, %p)\n", 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 );
 138     return opencl_funcs->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 );
 139 }
 140
 141 cl_int WINAPI 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 )
 142 {
 143     TRACE( "(%p, %p, %p, %Iu, %p, %p, %u, %p, %p)\n", command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 144     return opencl_funcs->pclEnqueueCopyBufferToImage( command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 145 }
 146
 147 cl_int WINAPI 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 )
 148 {
 149     TRACE( "(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 150     return opencl_funcs->pclEnqueueCopyImage( command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event );
 151 }
 152
 153 cl_int WINAPI 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 )
 154 {
 155     TRACE( "(%p, %p, %p, %p, %p, %Iu, %u, %p, %p)\n", command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
 156     return opencl_funcs->pclEnqueueCopyImageToBuffer( command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event );
 157 }
 158
 159 cl_int WINAPI clEnqueueFillBuffer( cl_command_queue command_queue, cl_mem buffer, const void* pattern, size_t pattern_size, size_t offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 160 {
 161     TRACE( "(%p, %p, %p, %Iu, %Iu, %Iu, %u, %p, %p)\n", command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
 162     return opencl_funcs->pclEnqueueFillBuffer( command_queue, buffer, pattern, pattern_size, offset, size, num_events_in_wait_list, event_wait_list, event );
 163 }
 164
 165 cl_int WINAPI 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 )
 166 {
 167     TRACE( "(%p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
 168     return opencl_funcs->pclEnqueueFillImage( command_queue, image, fill_color, origin, region, num_events_in_wait_list, event_wait_list, event );
 169 }
 170
 171 void* WINAPI clEnqueueMapBuffer( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags, size_t offset, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event, cl_int* errcode_ret )
 172 {
 173     TRACE( "(%p, %p, %u, %s, %Iu, %Iu, %u, %p, %p, %p)\n", command_queue, buffer, blocking_map, wine_dbgstr_longlong(map_flags), offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
 174     return opencl_funcs->pclEnqueueMapBuffer( command_queue, buffer, blocking_map, map_flags, offset, size, num_events_in_wait_list, event_wait_list, event, errcode_ret );
 175 }
 176
 177 void* WINAPI 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 )
 178 {
 179     TRACE( "(%p, %p, %u, %s, %p, %p, %p, %p, %u, %p, %p, %p)\n", command_queue, image, blocking_map, wine_dbgstr_longlong(map_flags), origin, region, image_row_pitch, image_slice_pitch, num_events_in_wait_list, event_wait_list, event, errcode_ret );
 180     return opencl_funcs->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 );
 181 }
 182
 183 cl_int WINAPI clEnqueueMarker( cl_command_queue command_queue, cl_event* event )
 184 {
 185     TRACE( "(%p, %p)\n", command_queue, event );
 186     return opencl_funcs->pclEnqueueMarker( command_queue, event );
 187 }
 188
 189 cl_int WINAPI clEnqueueMarkerWithWaitList( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 190 {
 191     TRACE( "(%p, %u, %p, %p)\n", command_queue, num_events_in_wait_list, event_wait_list, event );
 192     return opencl_funcs->pclEnqueueMarkerWithWaitList( command_queue, num_events_in_wait_list, event_wait_list, event );
 193 }
 194
 195 cl_int WINAPI 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 )
 196 {
 197     TRACE( "(%p, %u, %p, %s, %u, %p, %p)\n", command_queue, num_mem_objects, mem_objects, wine_dbgstr_longlong(flags), num_events_in_wait_list, event_wait_list, event );
 198     return opencl_funcs->pclEnqueueMigrateMemObjects( command_queue, num_mem_objects, mem_objects, flags, num_events_in_wait_list, event_wait_list, event );
 199 }
 200
 201 cl_int WINAPI 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 )
 202 {
 203     TRACE( "(%p, %p, %u, %p, %p, %p, %u, %p, %p)\n", command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
 204     return opencl_funcs->pclEnqueueNDRangeKernel( command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event );
 205 }
 206
 207 cl_int WINAPI clEnqueueNativeKernel( cl_command_queue command_queue, void (WINAPI* 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 )
 208 {
 209     TRACE( "(%p, %p, %p, %Iu, %u, %p, %p, %u, %p, %p)\n", command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event );
 210     return opencl_funcs->pclEnqueueNativeKernel( command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc, num_events_in_wait_list, event_wait_list, event );
 211 }
 212
 213 cl_int WINAPI clEnqueueReadBuffer( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset, size_t size, void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 214 {
 215     TRACE( "(%p, %p, %u, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 216     return opencl_funcs->pclEnqueueReadBuffer( command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 217 }
 218
 219 cl_int WINAPI 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 )
 220 {
 221     TRACE( "(%p, %p, %u, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %p, %u, %p, %p)\n", 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 );
 222     return opencl_funcs->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 );
 223 }
 224
 225 cl_int WINAPI 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 )
 226 {
 227     TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 228     return opencl_funcs->pclEnqueueReadImage( command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 229 }
 230
 231 cl_int WINAPI 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 )
 232 {
 233     TRACE( "(%p, %p, %u, %p, %p)\n", command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
 234     return opencl_funcs->pclEnqueueTask( command_queue, kernel, num_events_in_wait_list, event_wait_list, event );
 235 }
 236
 237 cl_int WINAPI 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 )
 238 {
 239     TRACE( "(%p, %p, %p, %u, %p, %p)\n", command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
 240     return opencl_funcs->pclEnqueueUnmapMemObject( command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event );
 241 }
 242
 243 cl_int WINAPI clEnqueueWaitForEvents( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list )
 244 {
 245     TRACE( "(%p, %u, %p)\n", command_queue, num_events, event_list );
 246     return opencl_funcs->pclEnqueueWaitForEvents( command_queue, num_events, event_list );
 247 }
 248
 249 cl_int WINAPI clEnqueueWriteBuffer( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t offset, size_t size, const void* ptr, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event )
 250 {
 251     TRACE( "(%p, %p, %u, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 252     return opencl_funcs->pclEnqueueWriteBuffer( command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event );
 253 }
 254
 255 cl_int WINAPI clEnqueueWriteBufferRect( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, 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 )
 256 {
 257     TRACE( "(%p, %p, %u, %p, %p, %p, %Iu, %Iu, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, buffer, blocking_write, 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 );
 258     return opencl_funcs->pclEnqueueWriteBufferRect( command_queue, buffer, blocking_write, 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 );
 259 }
 260
 261 cl_int WINAPI 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 )
 262 {
 263     TRACE( "(%p, %p, %u, %p, %p, %Iu, %Iu, %p, %u, %p, %p)\n", command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 264     return opencl_funcs->pclEnqueueWriteImage( command_queue, image, blocking_write, origin, region, input_row_pitch, input_slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event );
 265 }
 266
 267 cl_int WINAPI clFinish( cl_command_queue command_queue )
 268 {
 269     TRACE( "(%p)\n", command_queue );
 270     return opencl_funcs->pclFinish( command_queue );
 271 }
 272
 273 cl_int WINAPI clFlush( cl_command_queue command_queue )
 274 {
 275     TRACE( "(%p)\n", command_queue );
 276     return opencl_funcs->pclFlush( command_queue );
 277 }
 278
 279 cl_int WINAPI 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 )
 280 {
 281     TRACE( "(%p, %u, %Iu, %p, %p)\n", command_queue, param_name, param_value_size, param_value, param_value_size_ret );
 282     return opencl_funcs->pclGetCommandQueueInfo( command_queue, param_name, param_value_size, param_value, param_value_size_ret );
 283 }
 284
 285 cl_int WINAPI clGetContextInfo( cl_context context, cl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 286 {
 287     TRACE( "(%p, %u, %Iu, %p, %p)\n", context, param_name, param_value_size, param_value, param_value_size_ret );
 288     return opencl_funcs->pclGetContextInfo( context, param_name, param_value_size, param_value, param_value_size_ret );
 289 }
 290
 291 cl_int WINAPI clGetDeviceIDs( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id* devices, cl_uint* num_devices )
 292 {
 293     TRACE( "(%p, %s, %u, %p, %p)\n", platform, wine_dbgstr_longlong(device_type), num_entries, devices, num_devices );
 294     return opencl_funcs->pclGetDeviceIDs( platform, device_type, num_entries, devices, num_devices );
 295 }
 296
 297 cl_int WINAPI clGetEventInfo( cl_event event, cl_event_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 298 {
 299     TRACE( "(%p, %u, %Iu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
 300     return opencl_funcs->pclGetEventInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
 301 }
 302
 303 cl_int WINAPI clGetEventProfilingInfo( cl_event event, cl_profiling_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 304 {
 305     TRACE( "(%p, %u, %Iu, %p, %p)\n", event, param_name, param_value_size, param_value, param_value_size_ret );
 306     return opencl_funcs->pclGetEventProfilingInfo( event, param_name, param_value_size, param_value, param_value_size_ret );
 307 }
 308
 309 cl_int WINAPI clGetImageInfo( cl_mem image, cl_image_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 310 {
 311     TRACE( "(%p, %u, %Iu, %p, %p)\n", image, param_name, param_value_size, param_value, param_value_size_ret );
 312     return opencl_funcs->pclGetImageInfo( image, param_name, param_value_size, param_value, param_value_size_ret );
 313 }
 314
 315 cl_int WINAPI clGetKernelArgInfo( cl_kernel kernel, cl_uint arg_index, cl_kernel_arg_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 316 {
 317     TRACE( "(%p, %u, %u, %Iu, %p, %p)\n", kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
 318     return opencl_funcs->pclGetKernelArgInfo( kernel, arg_index, param_name, param_value_size, param_value, param_value_size_ret );
 319 }
 320
 321 cl_int WINAPI clGetKernelInfo( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 322 {
 323     TRACE( "(%p, %u, %Iu, %p, %p)\n", kernel, param_name, param_value_size, param_value, param_value_size_ret );
 324     return opencl_funcs->pclGetKernelInfo( kernel, param_name, param_value_size, param_value, param_value_size_ret );
 325 }
 326
 327 cl_int WINAPI 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 )
 328 {
 329     TRACE( "(%p, %p, %u, %Iu, %p, %p)\n", kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
 330     return opencl_funcs->pclGetKernelWorkGroupInfo( kernel, device, param_name, param_value_size, param_value, param_value_size_ret );
 331 }
 332
 333 cl_int WINAPI clGetMemObjectInfo( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 334 {
 335     TRACE( "(%p, %u, %Iu, %p, %p)\n", memobj, param_name, param_value_size, param_value, param_value_size_ret );
 336     return opencl_funcs->pclGetMemObjectInfo( memobj, param_name, param_value_size, param_value, param_value_size_ret );
 337 }
 338
 339 cl_int WINAPI clGetPlatformIDs( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms )
 340 {
 341     TRACE( "(%u, %p, %p)\n", num_entries, platforms, num_platforms );
 342     return opencl_funcs->pclGetPlatformIDs( num_entries, platforms, num_platforms );
 343 }
 344
 345 cl_int WINAPI 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 )
 346 {
 347     TRACE( "(%p, %p, %u, %Iu, %p, %p)\n", program, device, param_name, param_value_size, param_value, param_value_size_ret );
 348     return opencl_funcs->pclGetProgramBuildInfo( program, device, param_name, param_value_size, param_value, param_value_size_ret );
 349 }
 350
 351 cl_int WINAPI clGetProgramInfo( cl_program program, cl_program_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 352 {
 353     TRACE( "(%p, %u, %Iu, %p, %p)\n", program, param_name, param_value_size, param_value, param_value_size_ret );
 354     return opencl_funcs->pclGetProgramInfo( program, param_name, param_value_size, param_value, param_value_size_ret );
 355 }
 356
 357 cl_int WINAPI clGetSamplerInfo( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret )
 358 {
 359     TRACE( "(%p, %u, %Iu, %p, %p)\n", sampler, param_name, param_value_size, param_value, param_value_size_ret );
 360     return opencl_funcs->pclGetSamplerInfo( sampler, param_name, param_value_size, param_value, param_value_size_ret );
 361 }
 362
 363 cl_int WINAPI 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 )
 364 {
 365     TRACE( "(%p, %s, %u, %u, %p, %p)\n", context, wine_dbgstr_longlong(flags), image_type, num_entries, image_formats, num_image_formats );
 366     return opencl_funcs->pclGetSupportedImageFormats( context, flags, image_type, num_entries, image_formats, num_image_formats );
 367 }
 368
 369 cl_program WINAPI 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 )
 370 {
 371     TRACE( "(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret );
 372     return opencl_funcs->pclLinkProgram( context, num_devices, device_list, options, num_input_programs, input_programs, pfn_notify, user_data, errcode_ret );
 373 }
 374
 375 cl_int WINAPI clReleaseCommandQueue( cl_command_queue command_queue )
 376 {
 377     TRACE( "(%p)\n", command_queue );
 378     return opencl_funcs->pclReleaseCommandQueue( command_queue );
 379 }
 380
 381 cl_int WINAPI clReleaseContext( cl_context context )
 382 {
 383     TRACE( "(%p)\n", context );
 384     return opencl_funcs->pclReleaseContext( context );
 385 }
 386
 387 cl_int WINAPI clReleaseDevice( cl_device_id device )
 388 {
 389     TRACE( "(%p)\n", device );
 390     return opencl_funcs->pclReleaseDevice( device );
 391 }
 392
 393 cl_int WINAPI clReleaseEvent( cl_event event )
 394 {
 395     TRACE( "(%p)\n", event );
 396     return opencl_funcs->pclReleaseEvent( event );
 397 }
 398
 399 cl_int WINAPI clReleaseKernel( cl_kernel kernel )
 400 {
 401     TRACE( "(%p)\n", kernel );
 402     return opencl_funcs->pclReleaseKernel( kernel );
 403 }
 404
 405 cl_int WINAPI clReleaseMemObject( cl_mem memobj )
 406 {
 407     TRACE( "(%p)\n", memobj );
 408     return opencl_funcs->pclReleaseMemObject( memobj );
 409 }
 410
 411 cl_int WINAPI clReleaseProgram( cl_program program )
 412 {
 413     TRACE( "(%p)\n", program );
 414     return opencl_funcs->pclReleaseProgram( program );
 415 }
 416
 417 cl_int WINAPI clReleaseSampler( cl_sampler sampler )
 418 {
 419     TRACE( "(%p)\n", sampler );
 420     return opencl_funcs->pclReleaseSampler( sampler );
 421 }
 422
 423 cl_int WINAPI clRetainCommandQueue( cl_command_queue command_queue )
 424 {
 425     TRACE( "(%p)\n", command_queue );
 426     return opencl_funcs->pclRetainCommandQueue( command_queue );
 427 }
 428
 429 cl_int WINAPI clRetainContext( cl_context context )
 430 {
 431     TRACE( "(%p)\n", context );
 432     return opencl_funcs->pclRetainContext( context );
 433 }
 434
 435 cl_int WINAPI clRetainDevice( cl_device_id device )
 436 {
 437     TRACE( "(%p)\n", device );
 438     return opencl_funcs->pclRetainDevice( device );
 439 }
 440
 441 cl_int WINAPI clRetainEvent( cl_event event )
 442 {
 443     TRACE( "(%p)\n", event );
 444     return opencl_funcs->pclRetainEvent( event );
 445 }
 446
 447 cl_int WINAPI clRetainKernel( cl_kernel kernel )
 448 {
 449     TRACE( "(%p)\n", kernel );
 450     return opencl_funcs->pclRetainKernel( kernel );
 451 }
 452
 453 cl_int WINAPI clRetainMemObject( cl_mem memobj )
 454 {
 455     TRACE( "(%p)\n", memobj );
 456     return opencl_funcs->pclRetainMemObject( memobj );
 457 }
 458
 459 cl_int WINAPI clRetainProgram( cl_program program )
 460 {
 461     TRACE( "(%p)\n", program );
 462     return opencl_funcs->pclRetainProgram( program );
 463 }
 464
 465 cl_int WINAPI clRetainSampler( cl_sampler sampler )
 466 {
 467     TRACE( "(%p)\n", sampler );
 468     return opencl_funcs->pclRetainSampler( sampler );
 469 }
 470
 471 cl_int WINAPI clSetEventCallback( cl_event event, cl_int command_exec_callback_type, void (WINAPI* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), void* user_data )
 472 {
 473     TRACE( "(%p, %d, %p, %p)\n", event, command_exec_callback_type, pfn_notify, user_data );
 474     return opencl_funcs->pclSetEventCallback( event, command_exec_callback_type, pfn_notify, user_data );
 475 }
 476
 477 cl_int WINAPI clSetKernelArg( cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void* arg_value )
 478 {
 479     TRACE( "(%p, %u, %Iu, %p)\n", kernel, arg_index, arg_size, arg_value );
 480     return opencl_funcs->pclSetKernelArg( kernel, arg_index, arg_size, arg_value );
 481 }
 482
 483 cl_int WINAPI clSetMemObjectDestructorCallback( cl_mem memobj, void (WINAPI* pfn_notify)(cl_mem memobj, void* user_data), void* user_data )
 484 {
 485     TRACE( "(%p, %p, %p)\n", memobj, pfn_notify, user_data );
 486     return opencl_funcs->pclSetMemObjectDestructorCallback( memobj, pfn_notify, user_data );
 487 }
 488
 489 cl_int WINAPI clSetUserEventStatus( cl_event event, cl_int execution_status )
 490 {
 491     TRACE( "(%p, %d)\n", event, execution_status );
 492     return opencl_funcs->pclSetUserEventStatus( event, execution_status );
 493 }
 494
 495 cl_int WINAPI clUnloadCompiler( void  )
 496 {
 497     TRACE( "()\n" );
 498     return opencl_funcs->pclUnloadCompiler();
 499 }
 500
 501 cl_int WINAPI clUnloadPlatformCompiler( cl_platform_id platform )
 502 {
 503     TRACE( "(%p)\n", platform );
 504     return opencl_funcs->pclUnloadPlatformCompiler( platform );
 505 }
 506
 507 cl_int WINAPI clWaitForEvents( cl_uint num_events, const cl_event* event_list )
 508 {
 509     TRACE( "(%u, %p)\n", num_events, event_list );
 510     return opencl_funcs->pclWaitForEvents( num_events, event_list );
 511 }
 512
 513 BOOL extension_is_supported( const char *name, size_t len )
 514 {
 515     unsigned int i;
 516
 517     static const char *const unsupported[] =
 518     {
 519         "cl_apple_contextloggingfunctions",
 520         "cl_apple_setmemobjectdestructor",
 521         "cl_arm_import_memory",
 522         "cl_arm_shared_virtual_memory",
 523         "cl_ext_device_fission",
 524         "cl_ext_migrate_memobject",
 525         "cl_img_generate_mipmap",
 526         "cl_img_use_gralloc_ptr",
 527         "cl_intel_accelerator",
 528         "cl_intel_create_buffer_with_properties",
 529         "cl_intel_d3d11_nv12_media_sharing",
 530         "cl_intel_dx9_media_sharing",
 531         "cl_intel_unified_shared_memory",
 532         "cl_intel_va_api_media_sharing",
 533         "cl_khr_create_command_queue",
 534         "cl_khr_d3d10_sharing",
 535         "cl_khr_d3d11_sharing",
 536         "cl_khr_dx9_media_sharing",
 537         "cl_khr_egl_event",
 538         "cl_khr_egl_image",
 539         "cl_khr_gl_event",
 540         "cl_khr_gl_sharing",
 541         "cl_khr_icd",
 542         "cl_khr_il_program",
 543         "cl_khr_subgroups",
 544         "cl_khr_terminate_context",
 545         "cl_loader_layers",
 546         "cl_nv_d3d10_sharing",
 547         "cl_nv_d3d11_sharing",
 548         "cl_nv_d3d9_sharing",
 549         "cl_qcom_ext_host_ptr",
 550     };
 551
 552     for (i = 0; i < ARRAY_SIZE(unsupported); ++i)
 553     {
 554         if (!strncasecmp( name, unsupported[i], len ))
 555             return FALSE;
 556     }
 557     return TRUE;
 558 }