cl_intel_planar_yuv

cl_image_format image_format;
image_format.image_channel_order     = CL_NV12_INTEL;
image_format.image_channel_data_type = CL_UNORM_INT8;

cl_image_desc image_desc;
image_desc.image_type                = CL_MEM_OBJECT_IMAGE2D;
image_desc.image_width               = width;
image_desc.image_height              = height;
image_desc.image_array_size          = 0;
image_desc.image_row_pitch           = 0;
image_desc.image_slice_pitch         = 0;
image_desc.num_mip_levels            = 0;
image_desc.num_samples               = 0;
image_desc.mem_object                = NULL;

// create a CL_NV12_IMAGE
cl_mem nv12Img = clCreateImage(context,
                               CL_MEM_READ_ONLY | CL_MEM_HOST_NO_ACCESS |
                               CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL,
                               image_format, image_desc,
                               host_ptr, errcode_ret);

// image_width & image_height are ignored for plane extraction
image_desc.image_width               = 0;
image_desc.image_height              = 0;

// set mem_object to the full NV12 image
image_desc.mem_object                = nv12Img;

// get access to the Y plane (CL_R)
image_desc.image_depth               = 0;

// set proper image_format for the Y plane
image_format.image_channel_order     = CL_R;
image_format.image_channel_data_type = CL_UNORM_INT8;

cl_mem nv12YplaneImg = clCreateImage(context, CL_MEM_READ_WRITE,
                                     image_format, image_desc,
                                     NULL, errcode_ret);

// get access to the UV plane (CL_RG)
image_desc.image_depth               = 1;

// set proper image_format for the UV plane
image_format.image_channel_order     = CL_RG;
image_format.image_channel_data_type = CL_UNORM_INT8;

cl_mem nv12UVplaneImg = clCreateImage(context, CL_MEM_READ_WRITE,
                                      image_format, image_desc,
                                      NULL, errcode_ret);
// NOT SUPPORTED: transfer the whole NV12 image to the device
// status = clEnqueueWriteImage(queue, nv12Img, true, origin, region,
//                              row_pitch, slice_pitch,
//                              ptr, 0, NULL, NULL);

// write Y plane of NV12 image
status = clEnqueueWriteImage(queue, nv12YplaneImg, true,
                             origin, region, row_pitch, slice_pitch,
                             ptr, 0, NULL, NULL);

// write UV plane of NV12 image
status = clEnqueueWriteImage(queue, nv12YplaneImg, true,
                             origin, region, row_pitch, slice_pitch,
                             ptr + uvPlaneOffset, 0, NULL, NULL);

// NOT SUPPORTED: read the whole NV12 image back
// status = clEnqueueReadImage(queue, nv12Img, true,
//                             origin, region, row_pitch, slice_pitch,
//                             ptr, 0, NULL, NULL);

// read Y plane of NV12 image
status = clEnqueueReadImage(queue, nv12UVplaneImg, true,
                            origin, region, row_pitch, slice_pitch,
                            ptr, 0, NULL, NULL);

// read UV plane of NV12 image
status = clEnqueueReadImage(queue, nv12UVplaneImg, true,
                            origin, region, row_pitch, slice_pitch,
                            ptr + uvPlaneOffset, 0, NULL, NULL);

// do something with a whole NV12 image
kernel void DoSomethingWithNV12
(
    ...
    read_write image2d_t nv12Img,
    ...
)
{
    ...
    // sample the CL_NV12_INTEL image - supported if CL_NV12_INTEL format is
    // available with CL_MEM_READ_ONLY or CL_MEM_READ_WRITE access flags
    // based on clGetSupportedImageFormats query.
    float4 p = read_imagef(nv12Img, sampler, coord);
    ...
    // write to the CL_NV12_INTEL image - supported if CL_NV12_INTEL format is
    // available with CL_MEM_WRITE_ONLY or CL_MEM_READ_WRITE access flags
    // based on clGetSupportedImageFormats query.
    write_imagef(nv12Img, coord, p);
    ...
}

// do something with planes of an NV12 image
kernel void DoSomethingWithNV12Planes
(
    ...
    read_write image2d_t nv12ImgYPlane,
    read_write image2d_t nv12ImgUVPlane,
    ...
)
{
    ...
    // sample the Y & UV planes
    float4 py = read_imagef(nv12ImgYPlane, sampler, coord);
    float4 puv = read_imagef(nv12ImgUVPlane, sampler, coord);
    ...
    // write to Y & UV planes
    write_imagef(nv12ImgYPlane, coord, py);
    write_imagef(nv12ImgUVPlane, coord, puv);
    ...
}