d3d9/tests: Add r500 fp_special results.
[wine] / dlls / opencl / opencl.c
1 /*
2  * OpenCL.dll proxy for native OpenCL implementation.
3  *
4  * Copyright 2010 Peter Urbanec
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27
28 #include "wine/debug.h"
29 #include "wine/library.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(opencl);
32
33 #if defined(HAVE_CL_CL_H)
34 #define CL_USE_DEPRECATED_OPENCL_1_1_APIS
35 #include <CL/cl.h>
36 #elif defined(HAVE_OPENCL_OPENCL_H)
37 #include <OpenCL/opencl.h>
38 #endif
39
40 /* TODO: Figure out how to provide GL context sharing before enabling OpenGL */
41 #define OPENCL_WITH_GL 0
42
43
44 /*---------------------------------------------------------------*/
45 /* Platform API */
46
47 cl_int WINAPI wine_clGetPlatformIDs(cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms)
48 {
49     cl_int ret;
50     TRACE("(%d, %p, %p)\n", num_entries, platforms, num_platforms);
51     ret = clGetPlatformIDs(num_entries, platforms, num_platforms);
52     TRACE("(%d, %p, %p)=%d\n", num_entries, platforms, num_platforms, ret);
53     return ret;
54 }
55
56 cl_int WINAPI wine_clGetPlatformInfo(cl_platform_id platform, cl_platform_info param_name,
57                                      SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
58 {
59     cl_int ret;
60     TRACE("(%p, 0x%x, %ld, %p, %p)\n", platform, param_name, param_value_size, param_value, param_value_size_ret);
61
62     /* Hide all extensions.
63      * TODO: Add individual extension support as needed.
64      */
65     if (param_name == CL_PLATFORM_EXTENSIONS)
66     {
67         ret = CL_INVALID_VALUE;
68
69         if (param_value && param_value_size > 0)
70         {
71             char *exts = (char *) param_value;
72             exts[0] = '\0';
73             ret = CL_SUCCESS;
74         }
75
76         if (param_value_size_ret)
77         {
78             *param_value_size_ret = 1;
79             ret = CL_SUCCESS;
80         }
81     }
82     else
83     {
84         ret = clGetPlatformInfo(platform, param_name, param_value_size, param_value, param_value_size_ret);
85     }
86
87     TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", platform, param_name, param_value_size, param_value, param_value_size_ret, ret);
88     return ret;
89 }
90
91
92 /*---------------------------------------------------------------*/
93 /* Device APIs */
94
95 cl_int WINAPI wine_clGetDeviceIDs(cl_platform_id platform, cl_device_type device_type,
96                                   cl_uint num_entries, cl_device_id * devices, cl_uint * num_devices)
97 {
98     cl_int ret;
99     TRACE("(%p, 0x%lx, %d, %p, %p)\n", platform, (long unsigned int)device_type, num_entries, devices, num_devices);
100     ret = clGetDeviceIDs(platform, device_type, num_entries, devices, num_devices);
101     TRACE("(%p, 0x%lx, %d, %p, %p)=%d\n", platform, (long unsigned int)device_type, num_entries, devices, num_devices, ret);
102     return ret;
103 }
104
105 cl_int WINAPI wine_clGetDeviceInfo(cl_device_id device, cl_device_info param_name,
106                                    SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
107 {
108     cl_int ret;
109     TRACE("(%p, 0x%x, %ld, %p, %p)\n",device, param_name, param_value_size, param_value, param_value_size_ret);
110
111     /* Hide all extensions.
112      * TODO: Add individual extension support as needed.
113      */
114     if (param_name == CL_DEVICE_EXTENSIONS)
115     {
116         ret = CL_INVALID_VALUE;
117
118         if (param_value && param_value_size > 0)
119         {
120             char *exts = (char *) param_value;
121             exts[0] = '\0';
122             ret = CL_SUCCESS;
123         }
124
125         if (param_value_size_ret)
126         {
127             *param_value_size_ret = 1;
128             ret = CL_SUCCESS;
129         }
130     }
131     else
132     {
133         ret = clGetDeviceInfo(device, param_name, param_value_size, param_value, param_value_size_ret);
134     }
135
136     /* Filter out the CL_EXEC_NATIVE_KERNEL flag */
137     if (param_name == CL_DEVICE_EXECUTION_CAPABILITIES)
138     {
139         cl_device_exec_capabilities *caps = (cl_device_exec_capabilities *) param_value;
140         *caps &= ~CL_EXEC_NATIVE_KERNEL;
141     }
142
143     TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n",device, param_name, param_value_size, param_value, param_value_size_ret, ret);
144     return ret;
145 }
146
147
148 /*---------------------------------------------------------------*/
149 /* Context APIs  */
150
151 typedef struct
152 {
153     void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data);
154     void *user_data;
155 } CONTEXT_CALLBACK;
156
157 static void context_fn_notify(const char *errinfo, const void *private_info, size_t cb, void *user_data)
158 {
159     CONTEXT_CALLBACK *ccb;
160     TRACE("(%s, %p, %ld, %p)\n", errinfo, private_info, (SIZE_T)cb, user_data);
161     ccb = (CONTEXT_CALLBACK *) user_data;
162     if(ccb->pfn_notify) ccb->pfn_notify(errinfo, private_info, cb, ccb->user_data);
163     TRACE("Callback COMPLETED\n");
164 }
165
166 cl_context WINAPI wine_clCreateContext(const cl_context_properties * properties, cl_uint num_devices, const cl_device_id * devices,
167                                        void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
168                                        void * user_data, cl_int * errcode_ret)
169 {
170     cl_context ret;
171     CONTEXT_CALLBACK *ccb;
172     TRACE("(%p, %d, %p, %p, %p, %p)\n", properties, num_devices, devices, pfn_notify, user_data, errcode_ret);
173     /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
174      * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
175      * The problem is determining when a context is being destroyed. clReleaseContext only decrements
176      * the use count for a context, it's destruction can come much later and therefore there is a risk
177      * that the callback could be invoked after the user_data memory has been free()d.
178      */
179     ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
180     ccb->pfn_notify = pfn_notify;
181     ccb->user_data = user_data;
182     ret = clCreateContext(properties, num_devices, devices, context_fn_notify, ccb, errcode_ret);
183     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);
184     return ret;
185 }
186
187 cl_context WINAPI wine_clCreateContextFromType(const cl_context_properties * properties, cl_device_type device_type,
188                                                void WINAPI (*pfn_notify)(const char *errinfo, const void *private_info, size_t cb, void *user_data),
189                                                void * user_data, cl_int * errcode_ret)
190 {
191     cl_context ret;
192     CONTEXT_CALLBACK *ccb;
193     TRACE("(%p, 0x%lx, %p, %p, %p)\n", properties, (long unsigned int)device_type, pfn_notify, user_data, errcode_ret);
194     /* FIXME: The CONTEXT_CALLBACK structure is currently leaked.
195      * Pointers to callback redirectors should be remembered and free()d when the context is destroyed.
196      * The problem is determining when a context is being destroyed. clReleaseContext only decrements
197      * the use count for a context, it's destruction can come much later and therefore there is a risk
198      * that the callback could be invoked after the user_data memory has been free()d.
199      */
200     ccb = HeapAlloc(GetProcessHeap(), 0, sizeof(CONTEXT_CALLBACK));
201     ccb->pfn_notify = pfn_notify;
202     ccb->user_data = user_data;
203     ret = clCreateContextFromType(properties, device_type, context_fn_notify, ccb, errcode_ret);
204     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);
205     return ret;
206 }
207
208 cl_int WINAPI wine_clRetainContext(cl_context context)
209 {
210     cl_int ret;
211     TRACE("(%p)\n", context);
212     ret = clRetainContext(context);
213     TRACE("(%p)=%d\n", context, ret);
214     return ret;
215 }
216
217 cl_int WINAPI wine_clReleaseContext(cl_context context)
218 {
219     cl_int ret;
220     TRACE("(%p)\n", context);
221     ret = clReleaseContext(context);
222     TRACE("(%p)=%d\n", context, ret);
223     return ret;
224 }
225
226 cl_int WINAPI wine_clGetContextInfo(cl_context context, cl_context_info param_name,
227                                     SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
228 {
229     cl_int ret;
230     TRACE("(%p, 0x%x, %ld, %p, %p)\n", context, param_name, param_value_size, param_value, param_value_size_ret);
231     ret = clGetContextInfo(context, param_name, param_value_size, param_value, param_value_size_ret);
232     TRACE("(%p, 0x%x, %ld, %p, %p)=%d\n", context, param_name, param_value_size, param_value, param_value_size_ret, ret);
233     return ret;
234 }
235
236
237 /*---------------------------------------------------------------*/
238 /* Command Queue APIs */
239
240 cl_command_queue WINAPI wine_clCreateCommandQueue(cl_context context, cl_device_id device,
241                                                   cl_command_queue_properties properties, cl_int * errcode_ret)
242 {
243     cl_command_queue ret;
244     TRACE("(%p, %p, 0x%lx, %p)\n", context, device, (long unsigned int)properties, errcode_ret);
245     ret = clCreateCommandQueue(context, device, properties, errcode_ret);
246     TRACE("(%p, %p, 0x%lx, %p)=%p\n", context, device, (long unsigned int)properties, errcode_ret, ret);
247     return ret;
248 }
249
250 cl_int WINAPI wine_clRetainCommandQueue(cl_command_queue command_queue)
251 {
252     cl_int ret;
253     TRACE("(%p)\n", command_queue);
254     ret = clRetainCommandQueue(command_queue);
255     TRACE("(%p)=%d\n", command_queue, ret);
256     return ret;
257 }
258
259 cl_int WINAPI wine_clReleaseCommandQueue(cl_command_queue command_queue)
260 {
261     cl_int ret;
262     TRACE("(%p)\n", command_queue);
263     ret = clReleaseCommandQueue(command_queue);
264     TRACE("(%p)=%d\n", command_queue, ret);
265     return ret;
266 }
267
268 cl_int WINAPI wine_clGetCommandQueueInfo(cl_command_queue command_queue, cl_command_queue_info param_name,
269                                          SIZE_T param_value_size, void * param_value, size_t * param_value_size_ret)
270 {
271     cl_int ret;
272     TRACE("%p, %d, %ld, %p, %p\n", command_queue, param_name, param_value_size, param_value, param_value_size_ret);
273     ret = clGetCommandQueueInfo(command_queue, param_name, param_value_size, param_value, param_value_size_ret);
274     return ret;
275 }
276
277 cl_int WINAPI wine_clSetCommandQueueProperty(cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable,
278                                              cl_command_queue_properties * old_properties)
279 {
280     FIXME("(%p, 0x%lx, %d, %p): deprecated\n", command_queue, (long unsigned int)properties, enable, old_properties);
281     return CL_INVALID_QUEUE_PROPERTIES;
282 }
283
284
285 /*---------------------------------------------------------------*/
286 /* Memory Object APIs  */
287
288 cl_mem WINAPI wine_clCreateBuffer(cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret)
289 {
290     cl_mem ret;
291     TRACE("\n");
292     ret = clCreateBuffer(context, flags, size, host_ptr, errcode_ret);
293     return ret;
294 }
295
296 cl_mem WINAPI wine_clCreateImage2D(cl_context context, cl_mem_flags flags, cl_image_format * image_format,
297                                    size_t image_width, size_t image_height, size_t image_row_pitch, void * host_ptr, cl_int * errcode_ret)
298 {
299     cl_mem ret;
300     TRACE("\n");
301     ret = clCreateImage2D(context, flags, image_format, image_width, image_height, image_row_pitch, host_ptr, errcode_ret);
302     return ret;
303 }
304
305 cl_mem WINAPI wine_clCreateImage3D(cl_context context, cl_mem_flags flags, cl_image_format * image_format,
306                                    size_t image_width, size_t image_height, size_t image_depth, size_t image_row_pitch, size_t image_slice_pitch,
307                                    void * host_ptr, cl_int * errcode_ret)
308 {
309     cl_mem ret;
310     TRACE("\n");
311     ret = clCreateImage3D(context, flags, image_format, image_width, image_height, image_depth, image_row_pitch, image_slice_pitch, host_ptr, errcode_ret);
312     return ret;
313 }
314
315 cl_int WINAPI wine_clRetainMemObject(cl_mem memobj)
316 {
317     cl_int ret;
318     TRACE("(%p)\n", memobj);
319     ret = clRetainMemObject(memobj);
320     TRACE("(%p)=%d\n", memobj, ret);
321     return ret;
322 }
323
324 cl_int WINAPI wine_clReleaseMemObject(cl_mem memobj)
325 {
326     cl_int ret;
327     TRACE("(%p)\n", memobj);
328     ret = clReleaseMemObject(memobj);
329     TRACE("(%p)=%d\n", memobj, ret);
330     return ret;
331 }
332
333 cl_int WINAPI wine_clGetSupportedImageFormats(cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries,
334                                               cl_image_format * image_formats, cl_uint * num_image_formats)
335 {
336     cl_int ret;
337     TRACE("\n");
338     ret = clGetSupportedImageFormats(context, flags, image_type, num_entries, image_formats, num_image_formats);
339     return ret;
340 }
341
342 cl_int WINAPI wine_clGetMemObjectInfo(cl_mem memobj, cl_mem_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret)
343 {
344     cl_int ret;
345     TRACE("\n");
346     ret = clGetMemObjectInfo(memobj, param_name, param_value_size, param_value, param_value_size_ret);
347     return ret;
348 }
349
350 cl_int WINAPI wine_clGetImageInfo(cl_mem image, cl_image_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret)
351 {
352     cl_int ret;
353     TRACE("\n");
354     ret = clGetImageInfo(image, param_name, param_value_size, param_value, param_value_size_ret);
355     return ret;
356 }
357
358
359 /*---------------------------------------------------------------*/
360 /* Sampler APIs  */
361
362 cl_sampler WINAPI wine_clCreateSampler(cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode,
363                                        cl_filter_mode filter_mode, cl_int * errcode_ret)
364 {
365     cl_sampler ret;
366     TRACE("\n");
367     ret = clCreateSampler(context, normalized_coords, addressing_mode, filter_mode, errcode_ret);
368     return ret;
369 }
370
371 cl_int WINAPI wine_clRetainSampler(cl_sampler sampler)
372 {
373     cl_int ret;
374     TRACE("\n");
375     ret = clRetainSampler(sampler);
376     return ret;
377 }
378
379 cl_int WINAPI wine_clReleaseSampler(cl_sampler sampler)
380 {
381     cl_int ret;
382     TRACE("\n");
383     ret = clReleaseSampler(sampler);
384     return ret;
385 }
386
387 cl_int WINAPI wine_clGetSamplerInfo(cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size,
388                                     void * param_value, size_t * param_value_size_ret)
389 {
390     cl_int ret;
391     TRACE("\n");
392     ret = clGetSamplerInfo(sampler, param_name, param_value_size, param_value, param_value_size_ret);
393     return ret;
394 }
395
396
397 /*---------------------------------------------------------------*/
398 /* Program Object APIs  */
399
400 cl_program WINAPI wine_clCreateProgramWithSource(cl_context context, cl_uint count, const char ** strings,
401                                                  const size_t * lengths, cl_int * errcode_ret)
402 {
403     cl_program ret;
404     TRACE("\n");
405     ret = clCreateProgramWithSource(context, count, strings, lengths, errcode_ret);
406     return ret;
407 }
408
409 cl_program WINAPI wine_clCreateProgramWithBinary(cl_context context, cl_uint num_devices, const cl_device_id * device_list,
410                                                  const size_t * lengths, const unsigned char ** binaries, cl_int * binary_status,
411                                                  cl_int * errcode_ret)
412 {
413     cl_program ret;
414     TRACE("\n");
415     ret = clCreateProgramWithBinary(context, num_devices, device_list, lengths, binaries, binary_status, errcode_ret);
416     return ret;
417 }
418
419 cl_int WINAPI wine_clRetainProgram(cl_program program)
420 {
421     cl_int ret;
422     TRACE("\n");
423     ret = clRetainProgram(program);
424     return ret;
425 }
426
427 cl_int WINAPI wine_clReleaseProgram(cl_program program)
428 {
429     cl_int ret;
430     TRACE("\n");
431     ret = clReleaseProgram(program);
432     return ret;
433 }
434
435 typedef struct
436 {
437     void WINAPI (*pfn_notify)(cl_program program, void * user_data);
438     void *user_data;
439 } PROGRAM_CALLBACK;
440
441 static void program_fn_notify(cl_program program, void * user_data)
442 {
443     PROGRAM_CALLBACK *pcb;
444     TRACE("(%p, %p)\n", program, user_data);
445     pcb = (PROGRAM_CALLBACK *) user_data;
446     pcb->pfn_notify(program, pcb->user_data);
447     HeapFree(GetProcessHeap(), 0, pcb);
448     TRACE("Callback COMPLETED\n");
449 }
450
451 cl_int WINAPI wine_clBuildProgram(cl_program program, cl_uint num_devices, const cl_device_id * device_list, const char * options,
452                                   void WINAPI (*pfn_notify)(cl_program program, void * user_data),
453                                   void * user_data)
454 {
455     cl_int ret;
456     TRACE("\n");
457     if(pfn_notify)
458     {
459         /* When pfn_notify is provided, clBuildProgram is asynchronous */
460         PROGRAM_CALLBACK *pcb;
461         pcb = HeapAlloc(GetProcessHeap(), 0, sizeof(PROGRAM_CALLBACK));
462         pcb->pfn_notify = pfn_notify;
463         pcb->user_data = user_data;
464         ret = clBuildProgram(program, num_devices, device_list, options, program_fn_notify, pcb);
465     }
466     else
467     {
468         /* When pfn_notify is NULL, clBuildProgram is synchronous */
469         ret = clBuildProgram(program, num_devices, device_list, options, NULL, user_data);
470     }
471     return ret;
472 }
473
474 cl_int WINAPI wine_clUnloadCompiler(void)
475 {
476     cl_int ret;
477     TRACE("()\n");
478     ret = clUnloadCompiler();
479     TRACE("()=%d\n", ret);
480     return ret;
481 }
482
483 cl_int WINAPI wine_clGetProgramInfo(cl_program program, cl_program_info param_name,
484                                     size_t param_value_size, void * param_value, size_t * param_value_size_ret)
485 {
486     cl_int ret;
487     TRACE("\n");
488     ret = clGetProgramInfo(program, param_name, param_value_size, param_value, param_value_size_ret);
489     return ret;
490 }
491
492 cl_int WINAPI wine_clGetProgramBuildInfo(cl_program program, cl_device_id device,
493                                          cl_program_build_info param_name, size_t param_value_size, void * param_value,
494                                          size_t * param_value_size_ret)
495 {
496     cl_int ret;
497     TRACE("\n");
498     ret = clGetProgramBuildInfo(program, device, param_name, param_value_size, param_value, param_value_size_ret);
499     return ret;
500 }
501
502
503 /*---------------------------------------------------------------*/
504 /* Kernel Object APIs */
505
506 cl_kernel WINAPI wine_clCreateKernel(cl_program program, char * kernel_name, cl_int * errcode_ret)
507 {
508     cl_kernel ret;
509     TRACE("\n");
510     ret = clCreateKernel(program, kernel_name, errcode_ret);
511     return ret;
512 }
513
514 cl_int WINAPI wine_clCreateKernelsInProgram(cl_program program, cl_uint num_kernels,
515                                             cl_kernel * kernels, cl_uint * num_kernels_ret)
516 {
517     cl_int ret;
518     TRACE("\n");
519     ret = clCreateKernelsInProgram(program, num_kernels, kernels, num_kernels_ret);
520     return ret;
521 }
522
523 cl_int WINAPI wine_clRetainKernel(cl_kernel kernel)
524 {
525     cl_int ret;
526     TRACE("\n");
527     ret = clRetainKernel(kernel);
528     return ret;
529 }
530
531 cl_int WINAPI wine_clReleaseKernel(cl_kernel kernel)
532 {
533     cl_int ret;
534     TRACE("\n");
535     ret = clReleaseKernel(kernel);
536     return ret;
537 }
538
539 cl_int WINAPI wine_clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size, void * arg_value)
540 {
541     cl_int ret;
542     TRACE("\n");
543     ret = clSetKernelArg(kernel, arg_index, arg_size, arg_value);
544     return ret;
545 }
546
547 cl_int WINAPI wine_clGetKernelInfo(cl_kernel kernel, cl_kernel_info param_name,
548                                    size_t param_value_size, void * param_value, size_t * param_value_size_ret)
549 {
550     cl_int ret;
551     TRACE("\n");
552     ret = clGetKernelInfo(kernel, param_name, param_value_size, param_value, param_value_size_ret);
553     return ret;
554 }
555
556 cl_int WINAPI wine_clGetKernelWorkGroupInfo(cl_kernel kernel, cl_device_id device,
557                                             cl_kernel_work_group_info param_name, size_t param_value_size,
558                                             void * param_value, size_t * param_value_size_ret)
559 {
560     cl_int ret;
561     TRACE("\n");
562     ret = clGetKernelWorkGroupInfo(kernel, device, param_name, param_value_size, param_value, param_value_size_ret);
563     return ret;
564 }
565
566
567 /*---------------------------------------------------------------*/
568 /* Event Object APIs  */
569
570 cl_int WINAPI wine_clWaitForEvents(cl_uint num_events, cl_event * event_list)
571 {
572     cl_int ret;
573     TRACE("\n");
574     ret = clWaitForEvents(num_events, event_list);
575     return ret;
576 }
577
578 cl_int WINAPI wine_clGetEventInfo(cl_event event, cl_event_info param_name, size_t param_value_size,
579                                   void * param_value, size_t * param_value_size_ret)
580 {
581     cl_int ret;
582     TRACE("\n");
583     ret = clGetEventInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
584     return ret;
585 }
586
587 cl_int WINAPI wine_clRetainEvent(cl_event event)
588 {
589     cl_int ret;
590     TRACE("\n");
591     ret = clRetainEvent(event);
592     return ret;
593 }
594
595 cl_int WINAPI wine_clReleaseEvent(cl_event event)
596 {
597     cl_int ret;
598     TRACE("\n");
599     ret = clReleaseEvent(event);
600     return ret;
601 }
602
603
604 /*---------------------------------------------------------------*/
605 /* Profiling APIs  */
606
607 cl_int WINAPI wine_clGetEventProfilingInfo(cl_event event, cl_profiling_info param_name, size_t param_value_size,
608                                            void * param_value, size_t * param_value_size_ret)
609 {
610     cl_int ret;
611     TRACE("\n");
612     ret = clGetEventProfilingInfo(event, param_name, param_value_size, param_value, param_value_size_ret);
613     return ret;
614 }
615
616
617 /*---------------------------------------------------------------*/
618 /* Flush and Finish APIs */
619
620 cl_int WINAPI wine_clFlush(cl_command_queue command_queue)
621 {
622     cl_int ret;
623     TRACE("(%p)\n", command_queue);
624     ret = clFlush(command_queue);
625     TRACE("(%p)=%d\n", command_queue, ret);
626     return ret;
627 }
628
629 cl_int WINAPI wine_clFinish(cl_command_queue command_queue)
630 {
631     cl_int ret;
632     TRACE("(%p)\n", command_queue);
633     ret = clFinish(command_queue);
634     TRACE("(%p)=%d\n", command_queue, ret);
635     return ret;
636 }
637
638
639 /*---------------------------------------------------------------*/
640 /* Enqueued Commands APIs */
641
642 cl_int WINAPI wine_clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read,
643                                        size_t offset, size_t cb, void * ptr,
644                                        cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
645 {
646     cl_int ret;
647     TRACE("\n");
648     ret = clEnqueueReadBuffer(command_queue, buffer, blocking_read, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
649     return ret;
650 }
651
652 cl_int WINAPI wine_clEnqueueWriteBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write,
653                                         size_t offset, size_t cb, const void * ptr,
654                                         cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
655 {
656     cl_int ret;
657     TRACE("\n");
658     ret = clEnqueueWriteBuffer(command_queue, buffer, blocking_write, offset, cb, ptr, num_events_in_wait_list, event_wait_list, event);
659     return ret;
660 }
661
662 cl_int WINAPI wine_clEnqueueCopyBuffer(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer,
663                                        size_t src_offset, size_t dst_offset, size_t cb,
664                                        cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
665 {
666     cl_int ret;
667     TRACE("\n");
668     ret = clEnqueueCopyBuffer(command_queue, src_buffer, dst_buffer, src_offset, dst_offset, cb, num_events_in_wait_list, event_wait_list, event);
669     return ret;
670 }
671
672 cl_int WINAPI wine_clEnqueueReadImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_read,
673                                       const size_t * origin, const size_t * region,
674                                       SIZE_T row_pitch, SIZE_T slice_pitch, void * ptr,
675                                       cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
676 {
677     cl_int ret;
678     TRACE("(%p, %p, %d, %p, %p, %ld, %ld, %p, %d, %p, %p)\n", command_queue, image, blocking_read,
679           origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
680     ret = clEnqueueReadImage(command_queue, image, blocking_read, origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event);
681     TRACE("(%p, %p, %d, %p, %p, %ld, %ld, %p, %d, %p, %p)=%d\n", command_queue, image, blocking_read,
682           origin, region, row_pitch, slice_pitch, ptr, num_events_in_wait_list, event_wait_list, event, ret);
683     return ret;
684 }
685
686 cl_int WINAPI wine_clEnqueueWriteImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_write,
687                                        const size_t * origin, const size_t * region,
688                                        size_t input_row_pitch, size_t input_slice_pitch, const void * ptr,
689                                        cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
690 {
691     cl_int ret;
692     TRACE("\n");
693     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);
694     return ret;
695 }
696
697 cl_int WINAPI wine_clEnqueueCopyImage(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image,
698                                       size_t * src_origin, size_t * dst_origin, size_t * region,
699                                       cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
700 {
701     cl_int ret;
702     TRACE("\n");
703     ret = clEnqueueCopyImage(command_queue, src_image, dst_image, src_origin, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
704     return ret;
705 }
706
707 cl_int WINAPI wine_clEnqueueCopyImageToBuffer(cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer,
708                                               size_t * src_origin, size_t * region, size_t dst_offset,
709                                               cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
710 {
711     cl_int ret;
712     TRACE("\n");
713     ret = clEnqueueCopyImageToBuffer(command_queue, src_image, dst_buffer, src_origin, region, dst_offset, num_events_in_wait_list, event_wait_list, event);
714     return ret;
715 }
716
717 cl_int WINAPI wine_clEnqueueCopyBufferToImage(cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image,
718                                               size_t src_offset, size_t * dst_origin, size_t * region,
719                                               cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
720 {
721     cl_int ret;
722     TRACE("\n");
723     ret = clEnqueueCopyBufferToImage(command_queue, src_buffer, dst_image, src_offset, dst_origin, region, num_events_in_wait_list, event_wait_list, event);
724     return ret;
725 }
726
727 void * WINAPI wine_clEnqueueMapBuffer(cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map,
728                                       cl_map_flags map_flags, size_t offset, size_t cb,
729                                       cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret)
730 {
731     void * ret;
732     TRACE("\n");
733     ret = clEnqueueMapBuffer(command_queue, buffer, blocking_map, map_flags, offset, cb, num_events_in_wait_list, event_wait_list, event, errcode_ret);
734     return ret;
735 }
736
737 void * WINAPI wine_clEnqueueMapImage(cl_command_queue command_queue, cl_mem image, cl_bool blocking_map,
738                                      cl_map_flags map_flags, size_t * origin, size_t * region,
739                                      size_t * image_row_pitch, size_t * image_slice_pitch,
740                                      cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event, cl_int * errcode_ret)
741 {
742     void * ret;
743     TRACE("\n");
744     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);
745     return ret;
746 }
747
748 cl_int WINAPI wine_clEnqueueUnmapMemObject(cl_command_queue command_queue, cl_mem memobj, void * mapped_ptr,
749                                            cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
750 {
751     cl_int ret;
752     TRACE("\n");
753     ret = clEnqueueUnmapMemObject(command_queue, memobj, mapped_ptr, num_events_in_wait_list, event_wait_list, event);
754     return ret;
755 }
756
757 cl_int WINAPI wine_clEnqueueNDRangeKernel(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim,
758                                           size_t * global_work_offset, size_t * global_work_size, size_t * local_work_size,
759                                           cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
760 {
761     cl_int ret;
762     TRACE("\n");
763     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);
764     return ret;
765 }
766
767 cl_int WINAPI wine_clEnqueueTask(cl_command_queue command_queue, cl_kernel kernel,
768                                  cl_uint num_events_in_wait_list, cl_event * event_wait_list, cl_event * event)
769 {
770     cl_int ret;
771     TRACE("\n");
772     ret = clEnqueueTask(command_queue, kernel, num_events_in_wait_list, event_wait_list, event);
773     return ret;
774 }
775
776 cl_int WINAPI wine_clEnqueueNativeKernel(cl_command_queue command_queue,
777                                          void WINAPI (*user_func)(void *args),
778                                          void * args, size_t cb_args,
779                                          cl_uint num_mem_objects, const cl_mem * mem_list, const void ** args_mem_loc,
780                                          cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
781 {
782     cl_int ret = CL_INVALID_OPERATION;
783     /* FIXME: There appears to be no obvious method for translating the ABI for user_func.
784      * There is no opaque user_data structure passed, that could encapsulate the return address.
785      * The OpenCL specification seems to indicate that args has an implementation specific
786      * structure that cannot be used to stash away a return address for the WINAPI user_func.
787      */
788 #if 0
789     ret = clEnqueueNativeKernel(command_queue, user_func, args, cb_args, num_mem_objects, mem_list, args_mem_loc,
790                                  num_events_in_wait_list, event_wait_list, event);
791 #else
792     FIXME("not supported due to user_func ABI mismatch\n");
793 #endif
794     return ret;
795 }
796
797 cl_int WINAPI wine_clEnqueueMarker(cl_command_queue command_queue, cl_event * event)
798 {
799     cl_int ret;
800     TRACE("\n");
801     ret = clEnqueueMarker(command_queue, event);
802     return ret;
803 }
804
805 cl_int WINAPI wine_clEnqueueWaitForEvents(cl_command_queue command_queue, cl_uint num_events, cl_event * event_list)
806 {
807     cl_int ret;
808     TRACE("\n");
809     ret = clEnqueueWaitForEvents(command_queue, num_events, event_list);
810     return ret;
811 }
812
813 cl_int WINAPI wine_clEnqueueBarrier(cl_command_queue command_queue)
814 {
815     cl_int ret;
816     TRACE("\n");
817     ret = clEnqueueBarrier(command_queue);
818     return ret;
819 }
820
821
822 /*---------------------------------------------------------------*/
823 /* Extension function access */
824
825 void * WINAPI wine_clGetExtensionFunctionAddress(const char * func_name)
826 {
827     void * ret = 0;
828     TRACE("(%s)\n",func_name);
829 #if 0
830     ret = clGetExtensionFunctionAddress(func_name);
831 #else
832     FIXME("extensions not implemented\n");
833 #endif
834     TRACE("(%s)=%p\n",func_name, ret);
835     return ret;
836 }
837
838
839 #if OPENCL_WITH_GL
840 /*---------------------------------------------------------------*/
841 /* Khronos-approved (KHR) OpenCL extensions which have OpenGL dependencies. */
842
843 cl_mem WINAPI wine_clCreateFromGLBuffer(cl_context context, cl_mem_flags flags, cl_GLuint bufobj, int * errcode_ret)
844 {
845 }
846
847 cl_mem WINAPI wine_clCreateFromGLTexture2D(cl_context context, cl_mem_flags flags, cl_GLenum target,
848                                            cl_GLint miplevel, cl_GLuint texture, cl_int * errcode_ret)
849 {
850 }
851
852 cl_mem WINAPI wine_clCreateFromGLTexture3D(cl_context context, cl_mem_flags flags, cl_GLenum target,
853                                            cl_GLint miplevel, cl_GLuint texture, cl_int * errcode_ret)
854 {
855 }
856
857 cl_mem WINAPI wine_clCreateFromGLRenderbuffer(cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer, cl_int * errcode_ret)
858 {
859 }
860
861 cl_int WINAPI wine_clGetGLObjectInfo(cl_mem memobj, cl_gl_object_type * gl_object_type, cl_GLuint * gl_object_name)
862 {
863 }
864
865 cl_int WINAPI wine_clGetGLTextureInfo(cl_mem memobj, cl_gl_texture_info param_name, size_t param_value_size,
866                                       void * param_value, size_t * param_value_size_ret)
867 {
868 }
869
870 cl_int WINAPI wine_clEnqueueAcquireGLObjects(cl_command_queue command_queue, cl_uint num_objects, const cl_mem * mem_objects,
871                                              cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
872 {
873 }
874
875 cl_int WINAPI wine_clEnqueueReleaseGLObjects(cl_command_queue command_queue, cl_uint num_objects, const cl_mem * mem_objects,
876                                              cl_uint num_events_in_wait_list, const cl_event * event_wait_list, cl_event * event)
877 {
878 }
879
880
881 /*---------------------------------------------------------------*/
882 /* cl_khr_gl_sharing extension  */
883
884 cl_int WINAPI wine_clGetGLContextInfoKHR(const cl_context_properties * properties, cl_gl_context_info param_name,
885                                          size_t param_value_size, void * param_value, size_t * param_value_size_ret)
886 {
887 }
888
889 #endif
890
891
892 #if 0
893 /*---------------------------------------------------------------*/
894 /* cl_khr_icd extension */
895
896 cl_int WINAPI wine_clIcdGetPlatformIDsKHR(cl_uint num_entries, cl_platform_id * platforms, cl_uint * num_platforms)
897 {
898 }
899 #endif