opencl_ruby_ffi 1.2.2 → 1.3.0

data/lib/opencl_ruby_ffi/khr/d3d11_sharing.rb

@@ -0,0 +1,120 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  INVALID_D3D11_DEVICE_KHR = -1006
+  INVALID_D3D11_RESOURCE_KHR = -1007
+  D3D11_RESOURCE_ALREADY_ACQUIRED_KHR = -1008
+  D3D11_RESOURCE_NOT_ACQUIRED_KHR = -1009
+
+  D3D11_DEVICE_KHR = 0x4019
+  D3D11_DXGI_ADAPTER_KHR = 0x401A
+  PREFERRED_DEVICES_FOR_D3D11_KHR = 0x401B
+  ALL_DEVICES_FOR_D3D11_KHR = 0x401C
+  CONTEXT_D3D11_DEVICE_KHR = 0x401D
+  CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR = 0x402D
+  MEM_D3D11_RESOURCE_KHR = 0x401E
+  IMAGE_D3D11_SUBRESOURCE_KHR = 0x401F
+  COMMAND_ACQUIRE_D3D11_OBJECTS_KHR = 0x4020
+  COMMAND_RELEASE_D3D11_OBJECTS_KHR = 0x4021
+
+  class Error
+
+    eval error_class_constructor( :INVALID_D3D11_DEVICE_KHR,            :InvalidD3D11DeviceKHR )
+    eval error_class_constructor( :INVALID_D3D11_RESOURCE_KHR,          :InvalidD3D11ResourceKHR )
+    eval error_class_constructor( :D3D11_RESOURCE_ALREADY_ACQUIRED_KHR, :D3D11ResourceAlreadyAcquiredKHR )
+    eval error_class_constructor( :D3D11_RESOURCE_NOT_ACQUIRED_KHR,     :D3D11ResourceNotAcquiredKHR )
+
+  end
+
+  class Context
+    D3D11_DEVICE_KHR = 0x401D
+    D3D11_PREFER_SHARED_RESOURCES_KHR = 0x402D
+
+    class Properties
+      D3D11_DEVICE_KHR = 0x401D
+      D3D11_PREFER_SHARED_RESOURCES_KHR = 0x402D
+      @codes[0x401D] = 'D3D11_DEVICE_KHR'
+      @codes[0x402D] = 'D3D11_PREFER_SHARED_RESOURCES_KHR'
+    end
+
+  end
+
+  class Mem
+    D3D11_RESOURCE_KHR = 0x401E
+  end
+
+  class Image
+    D3D11_SUBRESOURCE_KHR = 0x401F
+  end
+
+  class CommandType
+    ACQUIRE_D3D11_OBJECTS_KHR = 0x4020
+    RELEASE_D3D11_OBJECTS_KHR = 0x4021
+    @codes[0x4020] = 'ACQUIRE_D3D11_OBJECTS_KHR'
+    @codes[0x4021] = 'RELEASE_D3D11_OBJECTS_KHR'
+  end
+
+  [
+    [ "clGetDeviceIDsFromD3D11KHR",
+      :cl_int,
+      [ Platform,
+        :cl_d3d11_device_source_khr,
+        :pointer,
+        :cl_d3d11_device_set_khr,
+        :cl_uint,
+        :pointer,
+        :pointer
+      ]
+    ], [
+      "clCreateFromD3D11BufferKHR",
+      Mem,
+      [ Context,
+        :cl_mem_flags,
+        :pointer,
+        :pointer ]
+    ], [
+      "clCreateFromD3D11Texture2DKHR",
+      Mem,
+      [ Context, 
+        :cl_mem_flags, 
+        :pointer,
+        :cl_uint,
+        :pointer
+      ]
+    ], [
+      "clCreateFromD3D11Texture3DKHR",
+      Mem,
+      [ Context, 
+        :cl_mem_flags, 
+        :pointer,
+        :cl_uint,
+        :pointer
+      ]
+    ], [
+      "clEnqueueAcquireD3D11ObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ], [
+      "clEnqueueReleaseD3D11ObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ]
+  ].each { |name, return_type, args|
+    attach_extension_function(name, return_type, args)
+  }
+
+end

data/lib/opencl_ruby_ffi/khr/dx9_media_sharing.rb

@@ -0,0 +1,113 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  INVALID_DX9_MEDIA_ADAPTER_KHR = -1010
+  INVALID_DX9_MEDIA_SURFACE_KHR = -1011
+  DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR = -1012
+  DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR = -1013
+
+  ADAPTER_D3D9_KHR = 0x2020
+  ADAPTER_D3D9EX_KHR = 0x2021
+  ADAPTER_DXVA_KHR = 0x2022
+  PREFERRED_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR = 0x2023
+  ALL_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR = 0x2024
+  CONTEXT_ADAPTER_D3D9_KHR = 0x2025
+  CONTEXT_ADAPTER_D3D9EX_KHR = 0x2026
+  CONTEXT_ADAPTER_DXVA_KHR = 0x2027
+  MEM_DX9_MEDIA_ADAPTER_TYPE_KHR = 0x2028
+  MEM_DX9_MEDIA_SURFACE_INFO_KHR = 0x2029
+  IMAGE_DX9_MEDIA_PLANE_KHR = 0x202A
+  COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR = 0x202B
+  COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR = 0x202C
+
+  class Error
+
+    eval error_class_constructor( :INVALID_DX9_MEDIA_ADAPTER_KHR,          :InvalidDX9MediaAdapterKHR )
+    eval error_class_constructor( :INVALID_DX9_MEDIA_SURFACE_KHR,          :InvalidDX9MediaSurfaceKHR )
+    eval error_class_constructor( :DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR, :DX9MediaSurfaceAlreadyAcquiredKHR )
+    eval error_class_constructor( :DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR,     :DX9MediaSurfaceNotAcquiredKHR )
+
+  end
+
+  class Context
+    ADAPTER_D3D9_KHR = 0x2025
+    ADAPTER_D3D9EX_KHR = 0x2026
+    ADAPTER_DXVA_KHR = 0x2027
+
+    class Properties
+      ADAPTER_D3D9_KHR = 0x2025
+      ADAPTER_D3D9EX_KHR = 0x2026
+      ADAPTER_DXVA_KHR = 0x2027
+      @codes[0x2025] = 'ADAPTER_D3D9_KHR'
+      @codes[0x2026] = 'ADAPTER_D3D9EX_KHR'
+      @codes[0x2026] = 'ADAPTER_DXVA_KHR'
+    end
+
+  end
+
+  class Mem
+    DX9_MEDIA_ADAPTER_TYPE_KHR = 0x2028
+    DX9_MEDIA_SURFACE_INFO_KHR = 0x2029
+  end
+
+  class Image
+    DX9_MEDIA_PLANE_KHR = 0x202A
+  end
+
+  class CommandType
+    ACQUIRE_DX9_MEDIA_SURFACES_KHR = 0x202B
+    RELEASE_DX9_MEDIA_SURFACES_KHR = 0x202C
+    @codes[0x202B] = 'ACQUIRE_DX9_MEDIA_SURFACES_KHR'
+    @codes[0x202C] = 'RELEASE_DX9_MEDIA_SURFACES_KHR'
+  end
+
+  [
+    [ "clGetDeviceIDsFromDX9MediaAdapterKHR",
+      :cl_int,
+      [ Platform,
+        :cl_uint,
+        :pointer,
+        :pointer,
+        :cl_dx9_media_adapter_set_khr,
+        :cl_uint,
+        :pointer,
+        :pointer
+      ]
+    ], [
+      "clCreateFromDX9MediaSurfaceKHR",
+      Mem,
+      [ Context,
+        :cl_mem_flags,
+        :cl_dx9_media_adapter_type_khr,
+        :pointer,
+        :cl_uint,
+        :pointer
+      ]
+    ], [
+      "clEnqueueAcquireDX9MediaSurfacesKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ], [
+      "clEnqueueReleaseDX9MediaSurfacesKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer,
+      ]
+    ]
+  ].each { |name, return_type, args|
+    attach_extension_function(name, return_type, args)
+  }
+
+end

data/lib/opencl_ruby_ffi/khr/egl_event.rb

@@ -0,0 +1,15 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  COMMAND_EGL_FENCE_SYNC_OBJECT_KHR = 0x202F
+
+  class CommandType
+    EGL_FENCE_SYNC_OBJECT_KHR = 0x202F
+    @codes[0x202F] = 'EGL_FENCE_SYNC_OBJECT_KHR'
+  end
+
+  attach_extension_function( "clCreateEventFromEGLSyncKHR", Event, [Context, :cl_egl_sync_khr, :cl_egl_display_khr, :pointer] )
+ 
+end

data/lib/opencl_ruby_ffi/khr/egl_image.rb

@@ -0,0 +1,58 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  INVALID_EGL_OBJECT_KHR = -1093
+  EGL_RESOURCE_NOT_ACQUIRED_KHR = -1092
+
+  COMMAND_ACQUIRE_EGL_OBJECTS_KHR = 0x202D
+  COMMAND_RELEASE_EGL_OBJECTS_KHR = 0x202E
+
+  class Error
+
+    eval error_class_constructor( :INVALID_EGL_OBJECT_KHR,        :InvalidEGLObjectKHR )
+    eval error_class_constructor( :EGL_RESOURCE_NOT_ACQUIRED_KHR, :EGLResourceNotAcquiredKHR )
+
+  end
+
+  class CommandType
+    ACQUIRE_EGL_OBJECTS_KHR = 0x202D
+    RELEASE_EGL_OBJECTS_KHR = 0x202E
+    @codes[0x202D] = 'ACQUIRE_EGL_OBJECTS_KHR'
+    @codes[0x202E] = 'RELEASE_EGL_OBJECTS_KHR'
+  end
+
+  [
+    [ "clCreateFromEGLImageKHR",
+      Mem,
+      [ Context,
+        :cl_egl_display_khr,
+        :cl_egl_image_khr,
+        :cl_mem_flags,
+        :pointer,
+        :pointer ]
+    ], [
+      "clEnqueueAcquireEGLObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer]
+    ], [
+      "clEnqueueReleaseEGLObjectsKHR",
+      :cl_int,
+      [ CommandQueue,
+        :cl_uint,
+        :pointer,
+        :cl_uint,
+        :pointer,
+        :pointer]
+    ]
+  ].each { |name, return_type, args|
+    f = attach_extension_function(name, return_type, args)
+  }
+
+end

data/lib/opencl_ruby_ffi/khr/fp16.rb

@@ -0,0 +1,23 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_HALF_FP_CONFIG = 0x1033
+
+  class Device
+
+    HALF_FP_CONFIG = 0x1033
+
+    module KHRFP16
+      extend InnerGenerator
+
+      get_info("Device", :cl_device_fp_config,  "half_fp_config")
+
+    end
+
+    register_extension( :cl_khr_fp16,  KHRFP16, "extensions.include?(\"cl_khr_fp16\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/fp64.rb

@@ -0,0 +1,23 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  DEVICE_DOUBLE_FP_CONFIG = 0x1032
+
+  class Device
+
+    DOUBLE_FP_CONFIG = 0x1032
+
+    module KHRFP64
+      extend InnerGenerator
+
+      get_info("Device", :cl_device_fp_config,  "double_fp_config")
+
+    end
+
+    register_extension( :cl_khr_fp64,  KHRFP64, "platform.version_number >= 1.2 or extensions.include?(\"cl_khr_fp64\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/gl_event.rb

@@ -0,0 +1,38 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  COMMAND_GL_FENCE_SYNC_OBJECT_KHR = 0x200D
+
+  attach_extension_function( "clCreateEventFromGLsyncKHR", Event, [Context, :pointer, :pointer] )
+
+  def self.create_event_from_glsync_khr( context, sync)
+    error_check(INVALID_OPERATION) unless context.platform.extensions.include?( "cl_khr_gl_event" ) or devices.first.extensions.include?("cl_khr_gl_event")
+    error_p = MemoryPointer::new( :cl_int )
+    event = clCreateEventFromGLsyncKHR( context, sync, error_p )
+    error_check(error_p.read_cl_int)
+    return Event::new( event, false )
+  end
+
+  class CommandType
+    GL_FENCE_SYNC_OBJECT_KHR = 0x200D
+    @codes[0x200D] = 'GL_FENCE_SYNC_OBJECT_KHR'
+  end
+
+  class Context
+
+    module KHRGLEvent
+
+      def create_event_from_glsync_khr( sync )
+        return OpenCL.create_event_from_glsync_khr( self, sync )
+      end
+      alias create_event_from_GLsync_KHR create_event_from_glsync_khr
+
+    end
+
+    register_extension( :cl_khr_gl_event, KHRGLEvent, "platform.extensions.include?(\"cl_khr_gl_event\") or devices.first.extensions.include?(\"cl_khr_gl_event\")" )
+
+  end
+
+end

data/lib/opencl_ruby_ffi/khr/gl_sharing.rb

@@ -0,0 +1,79 @@
+require 'opencl_ruby_ffi'
+using OpenCLRefinements if RUBY_VERSION.scan(/\d+/).collect(&:to_i).first >= 2
+
+module OpenCL
+
+  INVALID_GL_SHAREGROUP_REFERENCE_KHR = -1000
+
+  CURRENT_DEVICE_FOR_GL_CONTEXT_KHR = 0x2006
+  DEVICES_FOR_GL_CONTEXT_KHR = 0x2007
+
+  GL_CONTEXT_KHR = 0x2008
+  EGL_DISPLAY_KHR = 0x2009
+  GLX_DISPLAY_KHR = 0x200A
+  WGL_HDC_KHR = 0x200B
+  CGL_SHAREGROUP_KHR = 0x200C
+
+  class Error
+
+    eval error_class_constructor( :INVALID_GL_SHAREGROUP_REFERENCE_KHR, :InvalidGLSharegroupReferenceKHR )
+
+  end
+
+  f = attach_extension_function( "clGetGLContextInfoKHR", :cl_int, [:pointer, :cl_gl_context_info, :size_t, :pointer, :pointer] )
+
+  def self.get_gl_context_info_khr( properties, param_name )
+    props = MemoryPointer::new( :cl_context_properties, properties.length + 1 )
+    properties.each_with_index { |e,i|
+      props[i].write_cl_context_properties(e)
+    }
+    props[properties.length].write_cl_context_properties(0)
+    size_p = MemoryPointer::new( :size_t )
+    error = clGetGLContextInfoKHR( props, param_name, 0, nil, size_p )
+    error_check(error)
+    size = size_p.read_size_t
+    nb_devices = size/Device.size
+    values = MemoryPointer::new( Device, nb_devices )
+    error = clGetGLContextInfoKHR( props, param_name, size, values, nil )
+    error_check(error)
+    return values.get_array_of_pointer(0, nb_devices).collect { |device_ptr|
+      Device::new(device_ptr, false)
+    }
+  end
+
+  class GLContextInfo < Enum
+    CURRENT_DEVICE_FOR_GL_CONTEXT_KHR = 0x2006
+    DEVICES_FOR_GL_CONTEXT_KHR = 0x2007
+    @codes = {}
+    @codes[0x2006] = CURRENT_DEVICE_FOR_GL_CONTEXT_KHR
+    @codes[0x2007] = DEVICES_FOR_GL_CONTEXT_KHR
+  end
+
+  class Context
+
+    class Properties
+      GL_CONTEXT_KHR = 0x2008
+      CGL_SHAREGROUP_KHR = 0x200C
+      EGL_DISPLAY_KHR = 0x2009
+      GLX_DISPLAY_KHR = 0x200A
+      WGL_HDC_KHR = 0x200B
+      @codes[0x2008] = 'GL_CONTEXT_KHR'
+      @codes[0x200C] = 'CGL_SHAREGROUP_KHR'
+      @codes[0x2009] = 'EGL_DISPLAY_KHR'
+      @codes[0x200A] = 'GLX_DISPLAY_KHR'
+      @codes[0x200B] = 'WGL_HDC_KHR'
+    end
+
+    module KHRGLSharing
+
+      def get_gl_info_khr( param_name )
+        return OpenCL.get_gl_context_info_khr( self.properties, param_name )
+      end
+
+    end
+
+    register_extension( :cl_khr_gl_sharing, KHRGLSharing, "platform.extensions.include?(\"cl_khr_gl_sharing\") or devices.first.extensions.include?(\"cl_khr_gl_sharing\")" )
+
+  end
+
+end