| Name String |
| |
| cl_intel_va_api_media_sharing |
| |
| Contributors |
| |
| Ben Ashbaugh, Intel |
| Jacek Danecki, Intel |
| Krzysztof Laskowski, Intel |
| |
| Contact |
| |
| Ben Ashbaugh, Intel (ben.ashbaugh 'at' intel.com) |
| |
| Version |
| |
| Version 1, December 8, 2014 |
| |
| Number |
| |
| OpenCL Extension #36 |
| |
| Status |
| |
| Final Draft |
| |
| Dependencies |
| |
| OpenCL 1.2 is required and a VA API implementation supporting |
| sharing of surfaces with OpenCL is required. This extension is written |
| against revision 19 of the OpenCL 1.2 specification and against revision |
| 19 of the OpenCL 1.2 extension specification. |
| |
| Overview |
| |
| The goal of this extension is to provide interoperability between OpenCL |
| and the cross-platform Video Acceleration API (VA API). The extension |
| specifically enables sharing of VA API surfaces for media. It uses |
| similar mechanisms and provides similar surface sharing capabilities for |
| VA API that are provided by the Khronos OpenCL 1.2 Media Surface Sharing |
| extension for DX9. |
| |
| New Procedures and Functions |
| |
| cl_int clGetDeviceIDsFromVA_APIMediaAdapterINTEL ( |
| cl_platform_id platform, |
| cl_va_api_device_source_intel media_adapter_type , |
| void *media_adapter, |
| cl_va_api_device_set_intel media_adapter_set, |
| cl_uint num_entries, |
| cl_device_id *devices, |
| cl_uint *num_devices) |
| |
| cl_mem clCreateFromVA_APIMediaSurfaceINTEL( |
| cl_context context, |
| cl_mem_flags flags, |
| VASurfaceID *surface , |
| cl_uint plane, |
| cl_int *errcode_ret) |
| |
| cl_int clEnqueueAcquireVA_APIMediaSurfacesINTEL( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| |
| cl_int clEnqueueReleaseVA_APIMediaSurfacesINTEL( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| |
| New Tokens |
| |
| Accepted as a VA API device source in the <media_adapter_type> |
| parameter of clGetDeviceIDsFromVA_APIMediaAdapterINTEL: |
| |
| CL_VA_API_DISPLAY_INTEL 0x4094 |
| |
| Accepted as a set of VA API devices in the <media_adapter_set> |
| parameter of clGetDeviceIDsFromVA_APIMediaAdapterINTEL: |
| |
| CL_PREFERRED_DEVICES_FOR_VA_API_INTEL 0x4095 |
| CL_ALL_DEVICES_FOR_VA_API_INTEL 0x4096 |
| |
| Accepted as a property name in the <properties> parameter of |
| clCreateContext and clCreateContextFromType: |
| |
| CL_CONTEXT_VA_API_DISPLAY_INTEL 0x4097 |
| |
| Accepted as the property being queried in the <param_name> |
| parameter of clGetMemObjectInfo: |
| |
| CL_MEM_VA_API_MEDIA_SURFACE_INTEL 0x4098 |
| |
| Accepted as the property being queried in the <param_name> |
| parameter of clGetImageInfo: |
| |
| CL_IMAGE_VA_API_PLANE_INTEL 0x4099 |
| |
| Returned in the <param_value> parameter of clGetEventInfo when |
| <param_name> is CL_EVENT_COMMAND_TYPE: |
| |
| CL_COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL 0x409A |
| CL_COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL 0x409B |
| |
| Returned by clCreateContext and clCreateContextFromType if the VA API |
| display specified for interoperability is not compatible with the |
| devices against which the context is to be created: |
| |
| CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL -1098 |
| |
| Returned by clCreateFromVA_APIMediaSurfaceINTEL when <surface> is not a |
| VA API surface of the required type, by clGetMemObjectInfo when |
| <param_name> is CL_MEM_VA_API_MEDIA_SURFACE_INTEL when <memobj> was not |
| created from a VA API surface, and from clGetImageInfo when |
| <param_name> is CL_IMAGE_VA_API_PLANE_INTEL and <image> was not created |
| from a VA API surface: |
| |
| CL_INVALID_VA_API_MEDIA_SURFACE_INTEL -1099 |
| |
| Returned by clEnqueueAcquireVA_APIMediaSurfacesINTEL when any of <mem_objects> |
| are currently acquired by OpenCL: |
| |
| CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL -1100 |
| |
| Returned by clEnqueueReleaseVA_APIMediaSurfacesINTEL when any of <mem_objects> |
| are not currently acquired by OpenCL: |
| |
| CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL -1101 |
| |
| Additions to Chapter 4 of the OpenCL 1.2 Specification |
| |
| In section 4.4, replace the description of <properties> under |
| clCreateContext with: |
| |
| "<properties> specifies a list of context property names and their |
| corresponding values. Each property is followed immediately by the |
| corresponding desired value. The list is terminated with zero. |
| If a property is not specified in <properties>, then its default |
| value (listed in table 4.4) is used (it is said to be specified |
| implicitly). If <properties> is NULL or empty (points to a list |
| whose first value is zero), all attributes take on their default |
| values." |
| |
| Add the following to table 4.5: |
| |
| "-------------------------------------------------------------------------------------- |
| cl_context_properties Value type Default value Description |
| --------------------- ---------- ------------- ----------- |
| CL_CONTEXT_VA_API_DISPLAY_INTEL VADisplay* NULL Specifies a VA display to |
| use for VA API interop. |
| --------------------------------------------------------------------------------------" |
| |
| Add to the list of errors for clCreateContext: |
| |
| "* CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL if the value of the property |
| CL_CONTEXT_VA_API_DISPLAY_INTEL is non-NULL and does not specify a valid |
| VA API display with which the cl_device_ids against which this context |
| is to be created may interoperate. |
| |
| * CL_INVALID_OPERATION if VA API interoperability is specified by |
| setting CL_CONTEXT_VA_API_DISPLAY_INTEL to a non-NULL value, and |
| interoperability with any other graphics API is also specified. " |
| |
| Add to the list of errors for clCreateContextFromType the same new |
| errors described above for clCreateContext. |
| |
| Additions to Chapter 5 of the OpenCL 1.2 Specification |
| |
| 5.4.5 Memory Object Queries |
| |
| Add to the list of errors for clGetMemObjectInfo: |
| |
| "* CL_INVALID_VA_API_MEDIA_SURFACE_INTEL if <param_name> is |
| CL_MEM_VA_API_MEDIA_SURFACE_INTEL and <memobj> was not created from |
| a VA API surface using clCreateFromVA_APIMediaSurfaceINTEL." |
| |
| Extend table 5.11 to include the following entries: |
| |
| -------------------------------------------------------------------------- |
| cl_mem_info Return type Info. returned in param_value |
| ----------- --------------- ----------------------------- |
| CL_MEM_VA_API_MEDIA_ VASurfaceID* Returns the <surface> argument |
| SURFACE_INTEL value specified when <memobj> |
| was created. |
| --------------------------------------------------------------------------- |
| |
| Add to the list of errors for clGetImageInfo: |
| |
| "* CL_INVALID_VA_API_MEDIA_SURFACE_INTEL if <param_name> is |
| CL_IMAGE_VA_API_PLANE_INTEL and <image> was not created from a VA API |
| surface using clCreateFromVA_APIMediaSurfaceINTEL." |
| |
| Extend table 5.9 to include the following entry: |
| |
| ------------------------------------------------------------------------ |
| cl_image_info Return type Info. returned in param_value |
| ------------- ----------- ----------------------------- |
| CL_IMAGE_VA_API_PLANE_INTEL cl_uint Returns the <plane> argument |
| value specified when <image> |
| was created. |
| ------------------------------------------------------------------------ |
| |
| 5.9 Event Objects |
| |
| Add to Table 5.18 in the "Info returned in <param_value>" column |
| for cl_event_info CL_EVENT_COMMAND_TYPE: |
| |
| CL_COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL |
| CL_COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL |
| |
| Add new section 9.X to the OpenCL 1.2 extension specification: |
| |
| 9.X Sharing VA API Media Surfaces with OpenCL |
| |
| This section discusses OpenCL functions that allow applications to use |
| VA API media surfaces as OpenCL memory objects. This allows efficient |
| sharing of data between OpenCL and VA API. The OpenCL API may be |
| used to execute kernels that read and/or write memory objects that are |
| also VA API surfaces. An OpenCL image object may be created from |
| a VA API surface. OpenCL memory objects may be created from VA API |
| surfaces if and only if the OpenCL context has been created from a VA |
| API display. |
| |
| 9.X.1 Querying OpenCL Devices Corresponding to VA API Displays |
| |
| The OpenCL devices corresponding to a VA API display may be queried |
| using the function |
| |
| cl_int clGetDeviceIDsFromVA_APIMediaAdapterINTEL( |
| cl_platform_id platform, |
| cl_va_api_device_source_intel media_adapter_type, |
| void *media_adapter, |
| cl_va_api_device_set_intel media_adapter_set, |
| cl_uint num_entries, |
| cl_device_id *devices, |
| cl_uint *num_devices) |
| |
| <platform> refers to the platform ID returned by clGetPlatformIDs. |
| |
| <media_adapter_type> specifies the type of <media_adapter>, and must be |
| one of the values shown in table 9.X.1.1. |
| |
| <media_adapter> specifies the media adapter whose corresponding OpenCL |
| devices are being queried. The type of <media_adapter> must be as specified |
| in table 9.X.1.1. |
| |
| <media_adapter_set> specifies the set of devices to return and must be |
| one of the values shown in table 9.X.1.2. |
| |
| <num_entries> is the number of cl_device_id entries that can be added to |
| <devices>. If <devices> is not NULL then <num_entries> must be greater than |
| zero. |
| |
| <devices> returns a list of OpenCL devices found. The cl_device_id values |
| returned in <devices> can be used to identify a specific OpenCL device. |
| If <devices> is NULL, this argument is ignored. The number of |
| OpenCL devices returned is the minimum of the value specified by |
| <num_entries> and the number of OpenCL devices corresponding to |
| <media_adapter>. |
| |
| <num_devices> returns the number of OpenCL devices available that |
| correspond to <media_adapter>. If <num_devices> is NULL, this argument |
| is ignored. |
| |
| clGetDeviceIDsFromVA_APIMediaAdapterINTEL returns CL_SUCCESS if the |
| function is executed successfully. Otherwise it may return: |
| |
| * CL_INVALID_PLATFORM if <platform> is not a valid platform, |
| |
| * CL_INVALID_VALUE if <media_adapter_type> is not a valid value, |
| <media_adapter_set> is not a valid value, <num_entries> is equal |
| to zero and <devices> is not NULL, or if both <num_devices> |
| and <devices> are NULL. |
| |
| * CL_DEVICE_NOT_FOUND if no OpenCL devices that correspond to |
| <media_adapter> were found. |
| |
| -------------------------------------------------------------------- |
| cl_va_api_device_source_intel Type of <media_adapter> |
| ----------------------------- ----------------------- |
| CL_VA_API_DISPLAY_INTEL VADisplay* |
| -------------------------------------------------------------------- |
| Table 9.X.1.1: Types used to specify the object whose corresponding |
| OpenCL devices are being queried by |
| clGetDeviceIDsFromVA_APIMediaAdapterINTEL. |
| |
| -------------------------------------------------------------------- |
| cl_va_api_device_set_intel Devices returned in <devices> |
| -------------------------- ----------------------------- |
| CL_PREFERRED_DEVICES_FOR_VA_API_INTEL The OpenCL devices associated with |
| the specified media adapter. |
| |
| CL_ALL_DEVICES_FOR_VA_API_INTEL All OpenCL devices which may |
| interoperate with the specified |
| media adapter. Performance of |
| sharing data on these devices may |
| be considerably less than on the |
| preferred devices. |
| -------------------------------------------------------------------- |
| Table 9.X.1.2: Types used to specify the set of devices returned from |
| clGetDeviceIDsFromVA_APIMediaAdapterINTEL. |
| |
| 9.X.2 Lifetime of Shared Resources |
| |
| An OpenCL memory object created from a VA API surface remains |
| valid as long as the corresponding VA API surface has not been |
| deleted. If the VA API surface is deleted through the VA API, |
| subsequent use of the OpenCL memory object will result in undefined |
| behavior, including but not limited to possible OpenCL errors, data |
| corruption, and program termination. |
| |
| 9.X.4 Sharing VA API Media Surfaces as OpenCL Image Objects |
| |
| The function |
| |
| cl_mem clCreateFromVA_APIMediaSurfaceINTEL( |
| cl_context context, |
| cl_mem_flags flags, |
| VASurfaceID *surface, |
| cl_uint plane, |
| cl_int *errcode_ret) |
| |
| creates an OpenCL 2D image object from a VA API media surface or a |
| plane of a VA API media surface. |
| |
| <context> is a valid OpenCL context created from a VA API display. |
| |
| <flags> is a bit-field that is used to specify usage information. |
| Refer to table 5.3 for a description of <flags>. Only |
| CL_MEM_READ_ONLY, CL_MEM_WRITE_ONLY and CL_MEM_READ_WRITE values |
| specified in table 5.3 can be used. |
| |
| <surface> is a pointer to the VA API surface to share. |
| |
| <plane> is the plane of <surface> to share, for planar formats. |
| For non-planar formats, <plane> must be 0. |
| |
| <errcode_ret> will return an appropriate error code. If |
| <errcode_ret> is NULL, no error code is returned. |
| |
| clCreateFromVA_APIMediaSurfaceINTEL returns a valid non-zero OpenCL 2D |
| image object and <errcode_ret> is set to CL_SUCCESS if the OpenCL 2D |
| image object is created successfully. Otherwise, it returns a NULL value |
| with one of the following error values returned in <errcode_ret>: |
| |
| * CL_INVALID_CONTEXT if <context> is not a valid context. |
| |
| * CL_INVALID_VALUE if values specified in <flags> are not valid |
| or if <plane> is not a valid plane of <resource>. |
| |
| * CL_INVALID_VA_API_MEDIA_SURFACE_INTEL if <surface> is not a VA API |
| surface, if a cl_mem from <surface> and <plane> has already been |
| created, or if <context> was not created against the same VA API |
| display from which <surface> was created. |
| |
| * CL_INVALID_IMAGE_FORMAT_DESCRIPTOR if the format of <surface> is |
| not listed in table 9.X.4.1. |
| |
| * CL_INVALID_OPERATION if there are no devices in <context> that |
| support VA API sharing. |
| |
| * CL_OUT_OF_RESOURCES if there is a failure to allocate resources |
| required by the OpenCL implementation on the device. |
| |
| * CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources |
| required by the OpenCL implementation on the host. |
| |
| The width and height of the returned OpenCL 2D image object are |
| determined by the width and height of the <plane> of <surface>. The |
| channel type and order of the returned OpenCL 2D image object is |
| determined by the format and <plane> of <surface> in table 9.X.4.1. |
| |
| ------------------------------------------------------------------ |
| VA_FOURCC cl_channel_order cl_channel_type |
| ------------------------------ ---------------- --------------- |
| VA_FOURCC_NV12,Plane0 CL_R CL_UNORM_INT8 |
| VA_FOURCC_NV12,Plane1 CL_RG CL_UNORM_INT8 |
| ------------------------------------------------------------------ |
| Table 9.X.4.1: List of VA API FourCC codes and corresponding OpenCL |
| Image Formats. |
| |
| For the NV12 surface format, plane 0 corresponds to the luminance (Y) |
| channel data and plane 1 corresponds to the chrominance (UV) channel |
| data. |
| |
| 9.X.5 Querying Properties of Memory Objects Created From VA API Surfaces |
| |
| Properties of media objects created from VA API surfaces may be queried |
| using clGetMemObjectInfo and clGetImageInfo with <param_name> |
| CL_MEM_VA_API_MEDIA_SURFACE_INTEL and CL_IMAGE_VA_API_PLANE_INTEL as |
| described in section 5.3.7 and 5.4.5. |
| |
| 9.X.6 Sharing Memory Objects Created From VA API Surfaces Between VA API |
| and OpenCL |
| |
| The function |
| |
| cl_int clEnqueueAcquireVA_APIMediaSurfacesINTEL( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| |
| is used to acquire OpenCL memory objects that have been created from |
| VA API surfaces. The VA API surfaces are acquired by the OpenCL context |
| associated with <command_queue> and can therefore be used by all command- |
| queues associated with the OpenCL context. |
| |
| OpenCL memory objects created from VA API surfaces must be acquired before |
| they can be used by any OpenCL commands queued to a command-queue. If an |
| OpenCL memory object created from a VA API surface is used while it is not |
| acquired by OpenCL, the call attempting to use that OpenCL memory object |
| will return CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL. |
| |
| If CL_CONTEXT_INTEROP_USER_SYNC is not specified as CL_TRUE during context |
| creation, clEnqueueAcquireVA_APIMediaSurfacesINTEL provides the |
| synchronization guarantee that any VA API calls made before |
| clEnqueueAcquireVA_APIMediaSurfacesINTEL is called will complete executing |
| before <event> reports completion and before the execution of any subsequent |
| OpenCL work issued in <command_queue> begins. If the context was created |
| with properties specifying CL_CONTEXT_INTEROP_USER_SYNC as CL_TRUE, the user |
| is responsible for guaranteeing that any VA API calls involving the interop |
| device(s) used in the OpenCL context made before |
| clEnqueueAcquireVA_APIMediaSurfacesINTEL is called have completed before |
| calling clEnqueueAcquireVA_APIMediaSurfacesINTEL. |
| |
| <command_queue> is a valid command-queue. |
| |
| <num_objects> is the number of memory objects to be acquired in |
| <mem_objects>. |
| |
| <mem_objects> is a pointer to a list of OpenCL memory objects that |
| were created from VA API surfaces. |
| |
| <event_wait_list> and <num_events_in_wait_list> specify events that |
| need to complete before this particular command can be executed. If |
| <event_wait_list> is NULL, then this particular command does not |
| wait on any event to complete. If <event_wait_list> is NULL, |
| <num_events_in_wait_list> must be 0. If <event_wait_list> is not |
| NULL, the list of events pointed to by <event_wait_list> must be |
| valid and <num_events_in_wait_list> must be greater than 0. The |
| events specified in <event_wait_list> act as synchronization points. |
| |
| <event> returns an event object that identifies this particular |
| command and can be used to query or queue a wait for this |
| particular command to complete. <event> can be NULL in which case it |
| will not be possible for the application to query the status of this |
| command or queue a wait for this command to complete. |
| |
| clEnqueueAcquireVA_APIMediaSurfacesINTEL returns CL_SUCCESS if the |
| function is executed successfully. If <num_objects> is 0 and |
| <mem_objects> is NULL then the function does nothing and returns |
| CL_SUCCESS. Otherwise it returns one of the following errors: |
| |
| * CL_INVALID_VALUE if <num_objects> is zero and <mem_objects> is |
| not a NULL value or if <num_objects> > 0 and <mem_objects> is |
| NULL. |
| |
| * CL_INVALID_MEM_OBJECT if memory objects in <mem_objects> are not |
| valid OpenCL memory objects or if memory objects in <mem_objects> |
| have not been created from VA API surfaces. |
| |
| * CL_INVALID_COMMAND_QUEUE if <command_queue> is not a valid |
| command-queue. |
| |
| * CL_INVALID_CONTEXT if the context associated with <command_queue> |
| was not created from a VA API display. |
| |
| * CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL if memory objects |
| in <mem_objects> have previously been acquired using |
| clEnqueueAcquireVA_APIMediaSurfacesINTEL but have not been released |
| using clEnqueueReleaseVA_APIMediaSurfacesINTEL. |
| |
| * CL_INVALID_EVENT_WAIT_LIST if <event_wait_list> is NULL and |
| <num_events_in_wait_list> > 0, or <event_wait_list> is not NULL |
| and <num_events_in_wait_list> is 0, or if event objects in |
| <event_wait_list> are not valid events. |
| |
| * CL_OUT_OF_RESOURCES if there is a failure to allocate resources |
| required by the OpenCL implementation on the device. |
| |
| * CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources |
| required by the OpenCL implementation on the host. |
| |
| The function |
| |
| cl_int clEnqueueReleaseVA_APIMediaSurfacesINTEL( |
| cl_command_queue command_queue, |
| cl_uint num_objects, |
| const cl_mem *mem_objects, |
| cl_uint num_events_in_wait_list, |
| const cl_event *event_wait_list, |
| cl_event *event) |
| |
| is used to release OpenCL memory objects that have been created from |
| VA API surfaces. The VA API surfaces are released by the OpenCL context |
| associated with <command_queue>. |
| |
| OpenCL memory objects created from VA API surfaces which have been |
| acquired by OpenCL must be released by OpenCL before they may be |
| accessed by VA API. Accessing a VA API surface while its corresponding |
| OpenCL memory object is acquired is in error and will result in |
| undefined behavior, including but not limited to possible OpenCL errors, |
| data corruption, and program termination. |
| |
| If CL_CONTEXT_INTEROP_USER_SYNC is not specified as CL_TRUE during |
| context creation, clEnqueueReleaseVA_APIMediaSurfacesINTEL provides the |
| synchronization guarantee that any VA API calls made after |
| clEnqueueReleaseVA_APIMediaSurfacesINTEL is called will not start |
| executing until after all events in <event_wait_list> are complete and |
| all work already submitted to <command_queue> completes execution. If |
| the context was created with properties specifying |
| CL_CONTEXT_INTEROP_USER_SYNC specified as CL_TRUE, the user is |
| responsible for guaranteeing that any VA API calls involving the |
| interop device(s) used in the OpenCL context made after |
| clEnqueueReleaseVA_APIMediaSurfacesINTEL is called will not start |
| executing until after the event returned by |
| clEnqueueReleaseVA_APIMediaSurfacesINTEL reports completion. |
| |
| <num_objects> is the number of memory objects to be released in |
| <mem_objects>. |
| |
| <mem_objects> is a pointer to a list of OpenCL memory objects that |
| were created from VA API surfaces. |
| |
| <event_wait_list> and <num_events_in_wait_list> specify events that |
| need to complete before this particular command can be executed. If |
| <event_wait_list> is NULL, then this particular command does not |
| wait on any event to complete. If <event_wait_list> is NULL, |
| <num_events_in_wait_list> must be 0. If <event_wait_list> is not |
| NULL, the list of events pointed to by <event_wait_list> must be |
| valid and <num_events_in_wait_list> must be greater than 0. The |
| events specified in <event_wait_list> act as synchronization points. |
| |
| <event> returns an event object that identifies this particular |
| command and can be used to query or queue a wait for this |
| particular command to complete. <event> can be NULL in which case it |
| will not be possible for the application to query the status of this |
| command or queue a wait for this command to complete. |
| |
| clEnqueueReleaseVA_APIMediaSurfacesINTEL returns CL_SUCCESS if the |
| function is executed successfully. If <num_objects> is 0 and |
| <mem_objects> is NULL the function does nothing and returns |
| CL_SUCCESS. Otherwise it returns one of the following errors: |
| |
| * CL_INVALID_VALUE if <num_objects> is zero and <mem_objects> is |
| not a NULL value or if <num_objects> > 0 and <mem_objects> is |
| NULL. |
| |
| * CL_INVALID_MEM_OBJECT if memory objects in <mem_objects> are not |
| valid OpenCL memory objects or if memory objects in <mem_objects> |
| have not been created from VA API surfaces. |
| |
| * CL_INVALID_COMMAND_QUEUE if <command_queue> is not a valid |
| command-queue. |
| |
| * CL_INVALID_CONTEXT if the context associated with <command_queue> |
| was not created from a VA API display. |
| |
| * CL_VA_API_MEDIA_SURFACE_NOT_ACQUIRED_INTEL if memory objects in |
| <mem_objects> have not previously been acquired using |
| clEnqueueAcquireVA_APIMediaSurfacesINTEL, or have already been |
| released using clEnqueueReleaseVA_APIMediaSurfacesINTEL since the |
| last time that they were acquired. |
| |
| * CL_INVALID_EVENT_WAIT_LIST if <event_wait_list> is NULL and |
| <num_events_in_wait_list> > 0, or <event_wait_list> is not NULL |
| and <num_events_in_wait_list> is 0, or if event objects in |
| <event_wait_list> are not valid events. |
| |
| * CL_OUT_OF_RESOURCES if there is a failure to allocate resources |
| required by the OpenCL implementation on the device. |
| |
| * CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources |
| required by the OpenCL implementation on the host. |
| |
| Issues |
| |
| None |
| |
| Revision History |
| |
| Version 1 (2014/12/08): First public revision. |
