(in-package #:ocl-ffi)

;;; Platform API

(cffi:defcfun ("clGetPlatformIDs" %get-platform-ids) cl-error-code
  (num-entries cl-uint)
  (platforms cl-platform-id)
  (num-platforms (:pointer cl-uint)))

(cffi:defcfun ("clGetPlatformInfo" %get-platform-info) cl-error-code
  (platform cl-platform-id)
  (param-name cl-platform-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Device APIs

(cffi:defcfun ("clGetDeviceIDs" %get-device-ids) cl-error-code
  (platform cl-platform-id)
  (device-type cl-device-type)
  (num-entries cl-uint)
  (devices (:pointer cl-device-id))
  (num-devices (:pointer cl-uint)))

(cffi:defcfun ("clGetDeviceInfo" %get-device-info) cl-error-code
  (device cl-device-id)
  (param-name cl-device-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clCreateSubDevices" %create-sub-devices) cl-int
  (in-device cl-device-id)
  (properties (:pointer cl-device-partition-property))
  (num-devices cl-uint)
  (out-devices (:pointer cl-device-id))
  (num-devices-ret (:pointer cl-uint)))

(cffi:defcfun ("clRetainDevice" %retain-device) cl-error-code
  (device cl-device-id))

(cffi:defcfun ("clReleaseDevice" %release-device) cl-error-code
  (device cl-device-id))

(cffi:defcfun ("clSetDefaultDeviceCommandQueue" %set-default-device-command-queue) cl-int
  (context cl-context)
  (device cl-device-id)
  (command-queue cl-command-queue))

(cffi:defcfun ("clGetDeviceAndHostTimer" %get-device-and-host-timer) cl-int
  (device cl-device-id)
  (device-timestamp (:pointer cl-ulong))
  (host-timestamp (:pointer cl-ulong)))

(cffi:defcfun ("clGetHostTimer" %get-host-timer) cl-int
  (device cl-device-id)
  (host-timestamp (:pointer cl-ulong)))

;;; Context APIs

(cffi:defcfun ("clCreateContext" %create-context) cl-context
  (properties (:pointer cl-context-properties))
  (num-devices cl-uint)
  (devices (:pointer cl-device-id))
  (pfn-notify :pointer)
  (user-data (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateContextFromType" %create-context-from-type) cl-context
  (device-type cl-device-type)
  (pfn-notify :pointer)
  (user-data (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainContext" %retain-context) cl-error-code
  (context cl-context))

(cffi:defcfun ("clReleaseContext" %release-context) cl-error-code
  (context cl-context))

(cffi:defcfun ("clGetContextInfo" %get-context-info) cl-int
  (context cl-context)
  (param-name cl-context-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clSetContextDestructorCallback" set-context-destructor-callback) cl-int
  (context cl-context)
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

;;; Command Queue APIs

(cffi:defcfun ("clCreateCommandQueueWithProperties" %create-command-queue-with-properties) cl-command-queue
  (context cl-context)
  (device cl-device-id)
  (properties (:pointer cl-queue-properties))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainCommandQueue" %retain-command-queue) cl-error-code
  (command-queue cl-command-queue))

(cffi:defcfun ("clReleaseCommandQueue" %release-command-queue) cl-error-code
  (command-queue cl-command-queue))

(cffi:defcfun ("clGetCommandQueueInfo" %get-command-queue-info) cl-int
  (command-queue cl-command-queue)
  (param-name cl-command-queue-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Memory Object APIs

(cffi:defcfun ("clCreateBuffer" %create-buffer) cl-mem
  (context cl-context)
  (flags cl-mem-flags)
  (size :size)
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateSubBuffer" create-sub-buffer) cl-mem
  (buffer cl-mem)
  (flags cl-mem-flags)
  (size :size)
  (host-ptr (:pointer :void))
  (buffer-create-type cl-buffer-create-type)
  (buffer-create-info (:pointer :void))
  (errcode-ret (:pointer :int)))

(cffi:defcfun ("clCreateImage" create-image) cl-mem
  (context cl-context)
  (flags cl-mem-flags)
  (image-format (:pointer (:struct cl-image-format)))
  (image-desc (:pointer (:struct cl-image-desc)))
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreatePipe" %create-pipe) cl-mem
  (context cl-context)
  (flags cl-mem-flags)
  (pipe-packet-size cl-uint)
  (pipe-max-packets cl-uint)
  (properties (:pointer cl-pipe-properties))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateBufferWithProperties" create-buffer-with-properties) cl-mem
  (context cl-context)
  (properties (:pointer cl-mem-properties))
  (flags cl-mem-flags)
  (size :size)
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateImageWithProperties" create-image-with-properties) cl-mem
  (context cl-context)
  (properties (:pointer cl-mem-properties))
  (flags cl-mem-flags)
  (image-format (:pointer (:struct cl-image-format)))
  (image-desc (:pointer (:struct cl-image-desc)))
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainMemObject" %retain-mem-object) cl-error-code
  (memobj cl-mem))

(cffi:defcfun ("clReleaseMemObject" %release-mem-object) cl-error-code
  (memobj cl-mem))

(cffi:defcfun ("clGetSupportedImageFormats" %get-supported-image-formats) cl-error-code
  (context cl-context)
  (flags cl-mem-flags)
  (image-type cl-mem-object-type)
  (num-entries cl-uint)
  (image-formats (:pointer (:struct cl-image-format)))
  (num-image-formats (:pointer cl-uint)))

(cffi:defcfun ("clGetMemObjectInfo" %get-mem-object-info) cl-int
  (memobj cl-mem)
  (param-name cl-mem-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetImageInfo" %get-image-info) cl-int
  (image cl-mem)
  (param-name cl-image-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetPipeInfo" %get-pipe-info) cl-int
  (pipe cl-mem)
  (param-name cl-pipe-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clSetMemObjectDestructorCallback" set-mem-object-destructor-callback) cl-int
  (memobj cl-mem)
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

;;; SVM Allocation APIs

(cffi:defcfun ("clSVMAlloc" svm-alloc) (:pointer :void)
  (context cl-context)
  (flags cl-svm-mem-flags)
  (size :size)
  (aligment cl-uint))

(cffi:defcfun ("clSVMFree" svm-free) :void
  (context cl-context)
  (svm-pointer (:pointer :void)))

;;; Sampler APIs

(cffi:defcfun ("clCreateSamplerWithProperties" %create-sampler-with-properties) cl-sampler
  (context cl-context)
  (sampler-properties (:pointer cl-sampler-properties))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainSampler" %retain-sampler) cl-int
  (sampler cl-sampler))

(cffi:defcfun ("clReleaseSampler" %release-sampler) cl-int
  (sampler cl-sampler))

(cffi:defcfun ("clGetSamplerInfo" %get-sampler-info) cl-int
  (sampler cl-sampler)
  (param-name cl-sampler-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Program Object APIs

(cffi:defcfun ("clCreateProgramWithSource" %create-program-with-source) cl-program
  (context cl-context)
  (count cl-uint)
  (strings (:pointer (:pointer :char)))
  (lengths (:pointer :size))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateProgramWithBinary" create-program-with-binary) cl-program
  (context cl-context)
  (num-devices cl-uint)
  (device-list (:pointer cl-device-id))
  (lengths (:pointer :size))
  (binaries (:pointer (:pointer :unsigned-char)))
  (binary-status (:pointer cl-int))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateProgramWithBuiltInKernels" create-program-with-built-in-kernels) cl-program
  (context cl-context)
  (num-devices cl-uint)
  (device-list (:pointer cl-device-id))
  (kernel-names (:pointer :char))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateProgramWithIL" create-program-with-il) cl-program
  (context cl-context)
  (il (:pointer :void))
  (length :size)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainProgram" %retain-program) cl-error-code
  (program cl-program))

(cffi:defcfun ("clReleaseProgram" %release-program) cl-error-code
  (program cl-program))

(cffi:defcfun ("clBuildProgram" %build-program) cl-error-code
  (program cl-program)
  (num-devices cl-uint)
  (device-list (:pointer cl-device-id))
  (options :string)
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

(cffi:defcfun ("clCompileProgram" %compile-program) cl-error-code
  (program cl-program)
  (num-devices cl-uint)
  (device-list (:pointer cl-device-id))
  (options (:pointer :char))
  (num-input-headers cl-uint)
  (input-headers (:pointer cl-program))
  (header-include-names (:pointer (:pointer :char)))
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

(cffi:defcfun ("clLinkProgram" %link-program) cl-program
  (context cl-context)
  (num-devices cl-uint)
  (device-list (:pointer cl-device-id))
  (options (:pointer :char))
  (num-input-programs cl-uint)
  (input-programs (:pointer cl-program))
  (pfn-notify :pointer)
  (user-data (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clSetProgramReleaseCallback" set-program-release-callback) cl-int
  (program cl-program)
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

(cffi:defcfun ("clSetProgramSpecializationConstant" set-program-specialization-constant) cl-int
  (program cl-program)
  (spec-id cl-uint)
  (spec-size :size)
  (spec-value (:pointer :void)))

(cffi:defcfun ("clUnloadPlatformCompiler" %unload-platform-compiler) cl-error-code
  (platform cl-platform-id))

(cffi:defcfun ("clGetProgramInfo" %get-program-info) cl-int
  (program cl-program)
  (param-name cl-program-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetProgramBuildInfo" %get-program-build-info) cl-int
  (program cl-program)
  (device cl-device-id)
  (param-name cl-program-build-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Kernel Object APIs

(cffi:defcfun ("clCreateKernel" %create-kernel) cl-kernel
  (program cl-program)
  (kernel-name :string)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateKernelsInProgram" %create-kernels-in-program) cl-error-code
  (program cl-program)
  (num-kernels cl-uint)
  (kernels (:pointer cl-kernel))
  (num-kernels-ret (:pointer cl-uint)))

(cffi:defcfun ("clCloneKernel" %clone-kernel) cl-kernel
  (source-kernel cl-kernel)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainKernel" %retain-kernel) cl-error-code
  (kernel cl-kernel))

(cffi:defcfun ("clReleaseKernel" %release-kernel) cl-error-code
  (kernel cl-kernel))

(cffi:defcfun ("clSetKernelArg" %set-kernel-arg) cl-error-code
  (kernel cl-kernel)
  (arg-index cl-uint)
  (arg-size :size)
  (arg-value (:pointer :void)))

(cffi:defcfun ("clSetKernelArgSVMPointer" set-kernel-arg-svm-pointer) cl-int
  (kernel cl-kernel)
  (arg-index cl-uint)
  (arg-value (:pointer :void)))

(cffi:defcfun ("clSetKernelExecInfo" set-kernel-exec-info) cl-int
  (kernel cl-kernel)
  (param-name cl-kernel-exec-info)
  (param-value-size :size)
  (param-value (:pointer :void)))

(cffi:defcfun ("clGetKernelInfo" %get-kernel-info) cl-int
  (kernel cl-kernel)
  (param-name cl-kernel-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetKernelArgInfo" %get-kernel-arg-info) cl-int
  (kernel cl-kernel)
  (arg-indx cl-uint)
  (param-name cl-kernel-arg-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetKernelWorkGroupInfo" %get-kernel-work-group-info) cl-int
  (kernel cl-kernel)
  (device cl-device-id)
  (param-name cl-kernel-work-group-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clGetKernelSubGroupInfo" %get-kernel-sub-group-info) cl-int
  (kernel cl-kernel)
  (device cl-device-id)
  (param-name cl-kernel-sub-group-info)
  (input-value-size :size)
  (input-value (:pointer :void))
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Event Object APIs

(cffi:defcfun ("clWaitForEvents" %wait-for-events) cl-error-code
  (num-events cl-uint)
  (event-list (:pointer cl-event)))

(cffi:defcfun ("clGetEventInfo" %get-event-info) cl-error-code
  (event cl-event)
  (param-name cl-event-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

(cffi:defcfun ("clCreateUserEvent" %create-user-event) cl-event
  (context cl-context)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clRetainEvent" %retain-event) cl-error-code
  (event cl-event))

(cffi:defcfun ("clReleaseEvent" %release-event) cl-error-code
  (event cl-event))

(cffi:defcfun ("clSetUserEventStatus" %set-user-event-status) cl-error-code
  (event cl-event)
  (execution-status cl-int))

(cffi:defcfun ("clSetEventCallback" set-event-callback) cl-int
  (event cl-event)
  (command-exec-callback-type cl-int)
  (pfn-notify :pointer)
  (user-data (:pointer :void)))

;;; Profiling APIs

(cffi:defcfun ("clGetEventProfilingInfo" %get-event-profiling-info) cl-error-code
  (event cl-event)
  (param-name cl-profiling-info)
  (param-value-size :size)
  (param-value (:pointer :void))
  (param-value-size-ret (:pointer :size)))

;;; Flush and Finish APIs

(cffi:defcfun ("clFlush" %flush) cl-error-code
  (command-queue cl-command-queue))

(cffi:defcfun ("clFinish" %finish) cl-error-code
  (command-queue cl-command-queue))

;;; Enqueued Commands APIs

(cffi:defcfun ("clEnqueueReadBuffer" %enqueue-read-buffer) cl-error-code
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (blocking-read cl-bool)
  (offset :size)
  (size :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueReadBufferRect" enqueue-read-buffer-rect) cl-int
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (blocking-read cl-bool)
  (buffer-origin (:pointer :size))
  (host-origin (:pointer :size))
  (region (:pointer :size))
  (buffer-row-pitch :size)
  (buffer-slice-pitch :size)
  (host-row-pitch :size)
  (host-slice-pitch :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueWriteBuffer" enqueue-write-buffer) cl-int
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (blocking-write cl-bool)
  (offset :size)
  (size :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueWriteBufferRect" enqueue-write-buffer-rect) cl-int
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (blocking-write cl-bool)
  (buffer-origin (:pointer :size))
  (host-origin (:pointer :size))
  (region (:pointer :size))
  (buffer-row-pitch :size)
  (buffer-slice-pitch :size)
  (host-row-pitch :size)
  (host-slice-pitch :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueFillBuffer" enqueue-fill-buffer) cl-int
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (pattern (:pointer :void))
  (pattern-size :size)
  (offset :size)
  (size :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueCopyBuffer" enqueue-copy-buffer) cl-int
  (command-queue cl-command-queue)
  (src-buffer cl-mem)
  (dst-buffer cl-mem)
  (src-offset :size)
  (dst-offset :size)
  (size :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueCopyBufferRect" enqueue-copy-buffer-rect) cl-int
  (command-queue cl-command-queue)
  (src-buffer cl-mem)
  (dst-buffer cl-mem)
  (src-origin (:pointer :size))
  (dst-origin (:pointer :size))
  (region (:pointer :size))
  (src-row-pitch :size)
  (src-slice-pitch :size)
  (dst-row-pitch :size)
  (dst-slice-pitch :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueReadImage" enqueue-read-image) cl-int
  (command-queue cl-command-queue)
  (image cl-mem)
  (blocking-read cl-bool)
  (origin (:pointer :size))
  (region (:pointer :size))
  (row-pitch :size)
  (slice-pitch :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueWriteImage" enqueue-write-image) cl-int
  (command-queue cl-command-queue)
  (image cl-mem)
  (blocking-write cl-bool)
  (origin (:pointer :size))
  (region (:pointer :size))
  (input-row-pitch :size)
  (input-slice-pitch :size)
  (ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueFillImage" enqueue-fill-image) cl-int
  (command-queue cl-command-queue)
  (image cl-mem)
  (fill-color (:pointer :void))
  (origin (:pointer :size))
  (region (:pointer :size))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueCopyImage" enqueue-copy-image) cl-int
  (command-queue cl-command-queue)
  (src-image cl-mem)
  (dst-image cl-mem)
  (src-origin (:pointer :size))
  (dst-origin (:pointer :size))
  (region (:pointer :size))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueCopyImageToBuffer" enqueue-copy-image-to-buffer) cl-int
  (command-queue cl-command-queue)
  (src-image cl-mem)
  (dst-buffer cl-mem)
  (src-origin (:pointer :size))
  (region (:pointer :size))
  (dst-offset :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueCopyBufferToImage" enqueue-copy-buffer-to-image) cl-int
  (command-queue cl-command-queue)
  (src-buffer cl-mem)
  (dst-image cl-mem)
  (src-offset :size)
  (dst-origin (:pointer :size))
  (region (:pointer :size))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueMapBuffer" enqueue-map-buffer) (:pointer :void)
  (command-queue cl-command-queue)
  (buffer cl-mem)
  (blocking-map cl-bool)
  (map-flags cl-map-flags)
  (offset :size)
  (size :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clEnqueueMapImage" enqueue-map-image) (:pointer :void)
  (command-queue cl-command-queue)
  (image cl-mem)
  (blocking-map cl-bool)
  (map-flags cl-map-flags)
  (origin (:pointer :size))
  (region (:pointer :size))
  (image-row-pitch (:pointer :size))
  (image-slice-pitch (:pointer :size))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clEnqueueUnmapMemObject" enqueue-unmap-mem-object) cl-int
  (command-queue cl-command-queue)
  (memobj cl-mem)
  (mapped-ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueMigrateMemObjects" enqueue-migrate-mem-objects) cl-int
  (command-queue cl-command-queue)
  (num-mem-objects cl-uint)
  (mem-objects (:pointer cl-mem))
  (flags cl-mem-migration-flags)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueNDRangeKernel" %enqueue-nd-range-kernel) cl-error-code
  (command-queue cl-command-queue)
  (kernel cl-kernel)
  (work-dim cl-uint)
  (global-work-offset (:pointer :size))
  (global-work-size (:pointer :size))
  (local-work-size (:pointer :size))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueNativeKernel" enqueue-native-kernel) cl-int
  (command-queue cl-command-queue)
  (user-func :pointer)
  (args (:pointer :void))
  (cb-args :size)
  (num-mem-objects cl-uint)
  (mem-list (:pointer cl-mem))
  (args-mem-loc (:pointer (:pointer :void)))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueMarkerWithWaitList" enqueue-marker-with-wait-list) cl-int
  (command-queue cl-command-queue)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueBarrierWithWaitList" enqueue-barrier-with-wait-list) cl-int
  (command-queue cl-command-queue)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMFree" %enqueue-svm-free) cl-error-code
  (command-queue cl-command-queue)
  (num-svm-pointers cl-uint)
  (svm-pointers (:pointer (:pointer :void)))
  (pfn-free-func :pointer)
  (user-data :pointer)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMMemcpy" %enqueue-svm-memcpy) cl-error-code
  (command-queue cl-command-queue)
  (blocking-copy cl-bool)
  (dst-ptr (:pointer :void))
  (src-ptr (:pointer :void))
  (size :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMMemfill" %enqueue-svm-memfill) cl-error-code
  (command-queue cl-command-queue)
  (svm-ptr (:pointer :void))
  (pattern (:pointer :void))
  (pattern-size :size)
  (size :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMMap" %enqueue-svm-map) cl-error-code
  (command-queue cl-command-queue)
  (blocking-map cl-bool)
  (flags cl-map-flags)
  (svm-ptr (:pointer :void))
  (size :size)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMUnmap" %enqueue-svm-unmap) cl-error-code
  (command-queue cl-command-queue)
  (svm-ptr (:pointer :void))
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueSVMMigrateMem" %enqueue-svm-migrate-mem) cl-error-code
  (command-queue cl-command-queue)
  (num-svm-pointers cl-uint)
  (svm-pointers (:pointer (:pointer :void)))
  (sizes (:pointer :size))
  (flags cl-mem-migration-flags)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))

;;; Extension function access

(cffi:defcfun ("clGetExtensionFunctionAddressForPlatform"
               get-extension-function-address-for-platform)
    (:pointer :void)
  (platform cl-platform-id)
  (func-name :string))

;;; Deprecated OpenCL 1.0 APIs

(cffi:defcfun ("clSetCommandQueueProperty" set-command-queue-property) cl-int
  (command-queue cl-command-queue)
  (properties cl-command-queue-properties)
  (enable cl-bool)
  (old-properties (:pointer cl-command-queue-properties)))

;;; Deprecated OpenCL 1.1 APIs

(cffi:defcfun ("clCreateImage2D" create-image-2d) cl-mem
  (context cl-context)
  (flags cl-mem-flags)
  (image-format (:pointer (:struct cl-image-format)))
  (image-width :size)
  (image-height :size)
  (image-row-pitch :size)
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateImage3D" create-image-3d) cl-mem
  (context cl-context)
  (flags cl-mem-flags)
  (image-format (:pointer (:struct cl-image-format)))
  (image-width :size)
  (image-height :size)
  (image-depth :size)
  (image-row-pitch :size)
  (image-slice-pitch :size)
  (host-ptr (:pointer :void))
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clEnqueueMarker" enqueue-marker) cl-int
  (command-queue cl-command-queue)
  (event (:pointer cl-event)))

(cffi:defcfun ("clEnqueueWaitForEvents" %enqueue-wait-for-events) cl-error-code
  (command-queue cl-command-queue)
  (num-events cl-uint)
  (event-list (:pointer cl-event)))

(cffi:defcfun ("clEnqueueBarrier" enqueue-barrier) cl-int
  (command-queue cl-command-queue))

(cffi:defcfun ("clUnloadCompiler" unload-compiler) cl-int)

(cffi:defcfun ("clGetExtensionFunctionAddress" get-extension-function-address) (:pointer :void)
  (func-name :string))

;;; Deprecated OpenCL 2.0 APIs

(cffi:defcfun ("clCreateCommandQueue" %create-command-queue) cl-command-queue
  (context cl-context)
  (device cl-device-id)
  (properties cl-command-queue-properties)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clCreateSampler" create-sampler) cl-sampler
  (context cl-context)
  (normalized-coords cl-bool)
  (addressing-mode cl-addressing-mode)
  (filter-mode cl-filter-mode)
  (errcode-ret (:pointer cl-int)))

(cffi:defcfun ("clEnqueueTask" enqueue-task) cl-int
  (command-queue cl-command-queue)
  (kernel cl-kernel)
  (num-events-in-wait-list cl-uint)
  (event-wait-list (:pointer cl-event))
  (event (:pointer cl-event)))