#include "precomp.hpp"

#ifdef HAVE_VA

# include <va/va.h>

#else // HAVE_VA

# define NO_VA_SUPPORT_ERROR CV_Error(cv::Error::StsBadFunc, "OpenCV was build without VA support (libva)")

#endif // HAVE_VA

using namespace cv;

#ifdef HAVE_OPENCL

# include "opencv2/core/opencl/runtime/opencl_core.hpp"

# include "opencv2/core.hpp"

# include "opencv2/core/ocl.hpp"

# include "opencl_kernels_core.hpp"

#endif // HAVE_OPENCL

#if defined(HAVE_VA_INTEL) && defined(HAVE_OPENCL)

# include <CL/va_ext.h>

#endif // HAVE_VA_INTEL && HAVE_OPENCL

namespace cv { namespace va_intel {

#if defined(HAVE_VA_INTEL) && defined(HAVE_OPENCL)

static clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn clGetDeviceIDsFromVA_APIMediaAdapterINTEL = NULL;

static clCreateFromVA_APIMediaSurfaceINTEL_fn clCreateFromVA_APIMediaSurfaceINTEL = NULL;

static clEnqueueAcquireVA_APIMediaSurfacesINTEL_fn clEnqueueAcquireVA_APIMediaSurfacesINTEL = NULL;

static clEnqueueReleaseVA_APIMediaSurfacesINTEL_fn clEnqueueReleaseVA_APIMediaSurfacesINTEL = NULL;

static bool contextInitialized = false;

#endif // HAVE_VA_INTEL && HAVE_OPENCL

namespace ocl {

Context& initializeContextFromVA(VADisplay display, bool tryInterop)

{

(void)display; (void)tryInterop;

#if !defined(HAVE_VA)

NO_VA_SUPPORT_ERROR;

#else // !HAVE_VA

# if (defined(HAVE_VA_INTEL) && defined(HAVE_OPENCL))

contextInitialized = false;

if (tryInterop)

{

cl_uint numPlatforms;

cl_int status = clGetPlatformIDs(0, NULL, &numPlatforms);

if (status != CL_SUCCESS)

CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get number of platforms");

if (numPlatforms == 0)

CV_Error(cv::Error::OpenCLInitError, "OpenCL: No available platforms");

std::vector<cl_platform_id> platforms(numPlatforms);

status = clGetPlatformIDs(numPlatforms, &platforms[0], NULL);

if (status != CL_SUCCESS)

CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get platform Id list");

// For CL-VA interop, we must find platform/device with "cl_intel_va_api_media_sharing" extension.

// With standard initialization procedure, we should examine platform extension string for that.

// But in practice, the platform ext string doesn't contain it, while device ext string does.

// Follow Intel procedure (see tutorial), we should obtain device IDs by extension call.

// Note that we must obtain function pointers using specific platform ID, and can't provide pointers in advance.

// So, we iterate and select the first platform, for which we got non-NULL pointers, device, and CL context.

int found = -1;

cl_context context = 0;

cl_device_id device = 0;

for (int i = 0; i < (int)numPlatforms; ++i)

{

// Get extension function pointers

clGetDeviceIDsFromVA_APIMediaAdapterINTEL = (clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn)

clGetExtensionFunctionAddressForPlatform(platforms[i], "clGetDeviceIDsFromVA_APIMediaAdapterINTEL");

clCreateFromVA_APIMediaSurfaceINTEL = (clCreateFromVA_APIMediaSurfaceINTEL_fn)

clGetExtensionFunctionAddressForPlatform(platforms[i], "clCreateFromVA_APIMediaSurfaceINTEL");

clEnqueueAcquireVA_APIMediaSurfacesINTEL = (clEnqueueAcquireVA_APIMediaSurfacesINTEL_fn)

clGetExtensionFunctionAddressForPlatform(platforms[i], "clEnqueueAcquireVA_APIMediaSurfacesINTEL");

clEnqueueReleaseVA_APIMediaSurfacesINTEL = (clEnqueueReleaseVA_APIMediaSurfacesINTEL_fn)

clGetExtensionFunctionAddressForPlatform(platforms[i], "clEnqueueReleaseVA_APIMediaSurfacesINTEL");

if (((void*)clGetDeviceIDsFromVA_APIMediaAdapterINTEL == NULL) ||

((void*)clCreateFromVA_APIMediaSurfaceINTEL == NULL) ||

((void*)clEnqueueAcquireVA_APIMediaSurfacesINTEL == NULL) ||

((void*)clEnqueueReleaseVA_APIMediaSurfacesINTEL == NULL))

{

continue;

}

// Query device list

cl_uint numDevices = 0;

status = clGetDeviceIDsFromVA_APIMediaAdapterINTEL(platforms[i], CL_VA_API_DISPLAY_INTEL, display,

CL_PREFERRED_DEVICES_FOR_VA_API_INTEL, 0, NULL, &numDevices);

if ((status != CL_SUCCESS) || !(numDevices > 0))

continue;

numDevices = 1; // initializeContextFromHandle() expects only 1 device

status = clGetDeviceIDsFromVA_APIMediaAdapterINTEL(platforms[i], CL_VA_API_DISPLAY_INTEL, display,

CL_PREFERRED_DEVICES_FOR_VA_API_INTEL, numDevices, &device, NULL);

if (status != CL_SUCCESS)

continue;

// Creating CL-VA media sharing OpenCL context

cl_context_properties props[] = {

CL_CONTEXT_VA_API_DISPLAY_INTEL, (cl_context_properties) display,

CL_CONTEXT_INTEROP_USER_SYNC, CL_FALSE, // no explicit sync required

0

};

context = clCreateContext(props, numDevices, &device, NULL, NULL, &status);

if (status != CL_SUCCESS)

{

clReleaseDevice(device);

}

else

{

found = i;

break;

}

}

if (found >= 0)

{

contextInitialized = true;

Context& ctx = Context::getDefault(false);

initializeContextFromHandle(ctx, platforms[found], context, device);

return ctx;

}

}

# endif // HAVE_VA_INTEL && HAVE_OPENCL

{

Context& ctx = Context::getDefault(true);

return ctx;

}

#endif // !HAVE_VA

}

#if defined(HAVE_VA_INTEL) && defined(HAVE_OPENCL)

static bool ocl_convert_nv12_to_bgr(cl_mem clImageY, cl_mem clImageUV, cl_mem clBuffer, int step, int cols, int rows)

}

static bool ocl_convert_bgr_to_nv12(cl_mem clBuffer, int step, int cols, int rows, cl_mem clImageY, cl_mem clImageUV)

}

#endif // HAVE_VA_INTEL && HAVE_OPENCL

} // namespace cv::va_intel::ocl

#if defined(HAVE_VA)

const int NCHANNELS = 3;

static void copy_convert_nv12_to_bgr(const VAImage& image, const unsigned char* buffer, Mat& bgr)

}

static void copy_convert_bgr_to_nv12(const VAImage& image, const Mat& bgr, unsigned char* buffer)

}

#endif // HAVE_VA

void convertToVASurface(VADisplay display, InputArray src, VASurfaceID surface, Size size)

}

void convertFromVASurface(VADisplay display, VASurfaceID surface, Size size, OutputArray dst)

}

}} // namespace cv::va_intel