2018-01-29 18:20:59 +03:00
|
|
|
/**
|
|
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
|
|
* Optimized YUV/RGB conversion operations using openCL
|
|
|
|
*
|
|
|
|
* Copyright 2019 David Fort <contact@hardening-consulting.com>
|
|
|
|
* Copyright 2019 Rangee Gmbh
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <freerdp/types.h>
|
|
|
|
#include <freerdp/primitives.h>
|
|
|
|
#include "prim_internal.h"
|
|
|
|
|
2019-11-07 17:19:49 +03:00
|
|
|
#if defined(WITH_OPENCL)
|
|
|
|
#ifdef __APPLE__
|
|
|
|
#include "OpenCL/opencl.h"
|
|
|
|
#else
|
|
|
|
#include <CL/cl.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
2018-01-29 18:20:59 +03:00
|
|
|
|
|
|
|
#define TAG FREERDP_TAG("primitives")
|
|
|
|
|
2019-11-07 17:19:49 +03:00
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
BOOL support;
|
|
|
|
cl_platform_id platformId;
|
|
|
|
cl_device_id deviceId;
|
|
|
|
cl_context context;
|
|
|
|
cl_command_queue commandQueue;
|
|
|
|
cl_program program;
|
|
|
|
} primitives_opencl_context;
|
2018-01-29 18:20:59 +03:00
|
|
|
|
2019-11-07 17:19:49 +03:00
|
|
|
static primitives_opencl_context* primitives_get_opencl_context(void);
|
2018-01-29 18:20:59 +03:00
|
|
|
|
2019-11-22 14:32:45 +03:00
|
|
|
static pstatus_t opencl_YUVToRGB(const char* kernelName, const BYTE* const pSrc[3],
|
2019-11-13 18:35:03 +03:00
|
|
|
const UINT32 srcStep[3], BYTE* pDst, UINT32 dstStep,
|
|
|
|
const prim_size_t* roi)
|
2018-01-29 18:20:59 +03:00
|
|
|
{
|
|
|
|
cl_int ret;
|
2019-11-13 18:35:03 +03:00
|
|
|
cl_uint i;
|
2019-11-13 10:28:14 +03:00
|
|
|
cl_mem objs[3] = { NULL, NULL, NULL };
|
2018-01-29 18:20:59 +03:00
|
|
|
cl_mem destObj;
|
|
|
|
cl_kernel kernel;
|
|
|
|
size_t indexes[2];
|
2019-11-13 10:28:14 +03:00
|
|
|
const char* sourceNames[] = { "Y", "U", "V" };
|
|
|
|
primitives_opencl_context* cl = primitives_get_opencl_context();
|
2018-01-29 18:20:59 +03:00
|
|
|
|
|
|
|
kernel = clCreateKernel(cl->program, kernelName, &ret);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable to create kernel %s", kernelName);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
{
|
2019-11-29 10:52:37 +03:00
|
|
|
objs[i] = clCreateBuffer(cl->context, CL_MEM_READ_ONLY | CL_MEM_USE_HOST_PTR,
|
|
|
|
srcStep[i] * roi->height, (char*)pSrc[i], &ret);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to create %sobj", sourceNames[i]);
|
|
|
|
goto error_objs;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
destObj = clCreateBuffer(cl->context, CL_MEM_WRITE_ONLY, dstStep * roi->height, NULL, &ret);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to create dest obj");
|
|
|
|
goto error_objs;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* push source + stride arguments*/
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
{
|
2019-11-13 18:35:03 +03:00
|
|
|
ret = clSetKernelArg(kernel, i * 2, sizeof(cl_mem), &objs[i]);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to set arg for %sobj", sourceNames[i]);
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
ret = clSetKernelArg(kernel, i * 2 + 1, sizeof(cl_int), &srcStep[i]);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to set arg stride for %sobj", sourceNames[i]);
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
ret = clSetKernelArg(kernel, 6, sizeof(cl_mem), &destObj);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to set arg destObj");
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
ret = clSetKernelArg(kernel, 7, sizeof(cl_int), &dstStep);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to set arg dstStep");
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
|
|
|
|
indexes[0] = roi->width;
|
|
|
|
indexes[1] = roi->height;
|
2019-11-29 10:52:37 +03:00
|
|
|
ret = clEnqueueNDRangeKernel(cl->commandQueue, kernel, 2, NULL, indexes, NULL, 0, NULL, NULL);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to enqueue call kernel");
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Transfer result to host */
|
2019-11-13 10:28:14 +03:00
|
|
|
ret = clEnqueueReadBuffer(cl->commandQueue, destObj, CL_TRUE, 0, roi->height * dstStep, pDst, 0,
|
|
|
|
NULL, NULL);
|
2018-01-29 18:20:59 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "unable to read back buffer");
|
|
|
|
goto error_set_args;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* cleanup things */
|
|
|
|
clReleaseMemObject(destObj);
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
if (objs[i])
|
|
|
|
clReleaseMemObject(objs[i]);
|
|
|
|
clReleaseKernel(kernel);
|
|
|
|
|
|
|
|
return PRIMITIVES_SUCCESS;
|
|
|
|
|
|
|
|
error_set_args:
|
|
|
|
clReleaseMemObject(destObj);
|
|
|
|
error_objs:
|
|
|
|
for (i = 0; i < 3; i++)
|
|
|
|
{
|
|
|
|
if (objs[i])
|
|
|
|
clReleaseMemObject(objs[i]);
|
|
|
|
}
|
|
|
|
clReleaseKernel(kernel);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2019-11-07 17:19:49 +03:00
|
|
|
static primitives_opencl_context openclContext;
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
static primitives_opencl_context* primitives_get_opencl_context(void)
|
2019-11-07 17:19:49 +03:00
|
|
|
{
|
|
|
|
return &openclContext;
|
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
static pstatus_t primitives_uninit_opencl(void)
|
2019-11-07 17:19:49 +03:00
|
|
|
{
|
|
|
|
if (!openclContext.support)
|
|
|
|
return PRIMITIVES_SUCCESS;
|
|
|
|
|
|
|
|
clReleaseProgram(openclContext.program);
|
|
|
|
clReleaseCommandQueue(openclContext.commandQueue);
|
|
|
|
clReleaseContext(openclContext.context);
|
|
|
|
clReleaseDevice(openclContext.deviceId);
|
|
|
|
openclContext.support = FALSE;
|
|
|
|
return PRIMITIVES_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2019-11-13 10:28:14 +03:00
|
|
|
static const char* openclProgram =
|
|
|
|
#include "primitives.cl"
|
|
|
|
;
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
static BOOL primitives_init_opencl_context(primitives_opencl_context* cl)
|
2019-11-07 17:19:49 +03:00
|
|
|
{
|
|
|
|
cl_platform_id* platform_ids = NULL;
|
|
|
|
cl_uint ndevices, nplatforms, i;
|
|
|
|
cl_kernel kernel;
|
|
|
|
cl_int ret;
|
|
|
|
|
|
|
|
BOOL gotGPU = FALSE;
|
|
|
|
size_t programLen;
|
|
|
|
|
|
|
|
ret = clGetPlatformIDs(0, NULL, &nplatforms);
|
|
|
|
if (ret != CL_SUCCESS || nplatforms < 1)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
platform_ids = calloc(nplatforms, sizeof(*platform_ids));
|
|
|
|
if (!platform_ids)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
ret = clGetPlatformIDs(nplatforms, platform_ids, &nplatforms);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
free(platform_ids);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; (i < nplatforms) && !gotGPU; i++)
|
|
|
|
{
|
|
|
|
cl_device_id device_id;
|
|
|
|
cl_context context;
|
|
|
|
char platformName[1000];
|
|
|
|
char deviceName[1000];
|
|
|
|
|
|
|
|
ret = clGetPlatformInfo(platform_ids[i], CL_PLATFORM_NAME, sizeof(platformName),
|
|
|
|
platformName, NULL);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = clGetDeviceIDs(platform_ids[i], CL_DEVICE_TYPE_GPU, 1, &device_id, &ndevices);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = clGetDeviceInfo(device_id, CL_DEVICE_NAME, sizeof(deviceName), deviceName, NULL);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable get device name for platform %s", platformName);
|
|
|
|
clReleaseDevice(device_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable to create context for platform %s, device %s",
|
|
|
|
platformName, deviceName);
|
|
|
|
clReleaseDevice(device_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
cl->commandQueue = clCreateCommandQueue(context, device_id, 0, &ret);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable to create command queue");
|
|
|
|
clReleaseContext(context);
|
|
|
|
clReleaseDevice(device_id);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
WLog_INFO(TAG, "openCL: using platform=%s device=%s", platformName, deviceName);
|
|
|
|
|
|
|
|
cl->platformId = platform_ids[i];
|
|
|
|
cl->deviceId = device_id;
|
|
|
|
cl->context = context;
|
|
|
|
gotGPU = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(platform_ids);
|
|
|
|
|
|
|
|
if (!gotGPU)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: no GPU found");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2019-11-13 10:28:14 +03:00
|
|
|
programLen = strlen(openclProgram);
|
2019-11-07 17:19:49 +03:00
|
|
|
cl->program =
|
2019-11-13 10:28:14 +03:00
|
|
|
clCreateProgramWithSource(cl->context, 1, (const char**)&openclProgram, &programLen, &ret);
|
2019-11-07 17:19:49 +03:00
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
2019-11-13 10:28:14 +03:00
|
|
|
WLog_ERR(TAG, "openCL: unable to create program");
|
2019-11-07 17:19:49 +03:00
|
|
|
goto out_program_create;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = clBuildProgram(cl->program, 1, &cl->deviceId, NULL, NULL, NULL);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
size_t length;
|
|
|
|
char buffer[2048];
|
|
|
|
ret = clGetProgramBuildInfo(cl->program, cl->deviceId, CL_PROGRAM_BUILD_LOG, sizeof(buffer),
|
|
|
|
buffer, &length);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG,
|
|
|
|
"openCL: building program failed but unable to retrieve buildLog, error=%d",
|
|
|
|
ret);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable to build program, errorLog=%s", buffer);
|
|
|
|
}
|
|
|
|
goto out_program_build;
|
|
|
|
}
|
|
|
|
|
|
|
|
kernel = clCreateKernel(cl->program, "yuv420_to_bgra_1b", &ret);
|
|
|
|
if (ret != CL_SUCCESS)
|
|
|
|
{
|
|
|
|
WLog_ERR(TAG, "openCL: unable to create yuv420_to_bgra_1b kernel");
|
|
|
|
goto out_program_build;
|
|
|
|
}
|
|
|
|
clReleaseKernel(kernel);
|
|
|
|
|
|
|
|
cl->support = TRUE;
|
|
|
|
return TRUE;
|
|
|
|
|
|
|
|
out_program_build:
|
|
|
|
clReleaseProgram(cl->program);
|
|
|
|
out_program_create:
|
|
|
|
clReleaseCommandQueue(cl->commandQueue);
|
|
|
|
clReleaseContext(cl->context);
|
|
|
|
clReleaseDevice(cl->deviceId);
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2019-11-22 14:32:45 +03:00
|
|
|
static pstatus_t opencl_YUV420ToRGB_8u_P3AC4R(const BYTE* const pSrc[3], const UINT32 srcStep[3],
|
2019-11-13 10:28:14 +03:00
|
|
|
BYTE* pDst, UINT32 dstStep, UINT32 DstFormat,
|
|
|
|
const prim_size_t* roi)
|
2018-01-29 18:20:59 +03:00
|
|
|
{
|
2019-11-13 10:28:14 +03:00
|
|
|
const char* kernel_name;
|
2018-01-29 18:20:59 +03:00
|
|
|
|
2019-11-13 10:28:14 +03:00
|
|
|
switch (DstFormat)
|
2018-01-29 18:20:59 +03:00
|
|
|
{
|
2019-11-07 17:19:49 +03:00
|
|
|
case PIXEL_FORMAT_BGRA32:
|
|
|
|
case PIXEL_FORMAT_BGRX32:
|
|
|
|
kernel_name = "yuv420_to_bgra_1b";
|
|
|
|
break;
|
|
|
|
case PIXEL_FORMAT_XRGB32:
|
|
|
|
case PIXEL_FORMAT_ARGB32:
|
|
|
|
kernel_name = "yuv420_to_argb_1b";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
primitives_t* p = primitives_get_by_type(PRIMITIVES_ONLY_CPU);
|
|
|
|
if (!p)
|
|
|
|
return -1;
|
|
|
|
return p->YUV420ToRGB_8u_P3AC4R(pSrc, srcStep, pDst, dstStep, DstFormat, roi);
|
|
|
|
}
|
2018-01-29 18:20:59 +03:00
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
return opencl_YUVToRGB(kernel_name, pSrc, srcStep, pDst, dstStep, roi);
|
2018-01-29 18:20:59 +03:00
|
|
|
}
|
|
|
|
|
2019-11-22 14:32:45 +03:00
|
|
|
static pstatus_t opencl_YUV444ToRGB_8u_P3AC4R(const BYTE* const pSrc[3], const UINT32 srcStep[3],
|
2019-11-13 18:37:28 +03:00
|
|
|
BYTE* pDst, UINT32 dstStep, UINT32 DstFormat,
|
|
|
|
const prim_size_t* roi)
|
|
|
|
{
|
|
|
|
const char* kernel_name;
|
|
|
|
|
|
|
|
switch (DstFormat)
|
|
|
|
{
|
|
|
|
case PIXEL_FORMAT_BGRA32:
|
|
|
|
case PIXEL_FORMAT_BGRX32:
|
|
|
|
kernel_name = "yuv444_to_bgra_1b";
|
|
|
|
break;
|
|
|
|
case PIXEL_FORMAT_XRGB32:
|
|
|
|
case PIXEL_FORMAT_ARGB32:
|
|
|
|
kernel_name = "yuv444_to_argb_1b";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
primitives_t* p = primitives_get_by_type(PRIMITIVES_ONLY_CPU);
|
|
|
|
if (!p)
|
|
|
|
return -1;
|
|
|
|
return p->YUV444ToRGB_8u_P3AC4R(pSrc, srcStep, pDst, dstStep, DstFormat, roi);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return opencl_YUVToRGB(kernel_name, pSrc, srcStep, pDst, dstStep, roi);
|
|
|
|
}
|
|
|
|
|
2019-11-13 18:35:03 +03:00
|
|
|
BOOL primitives_init_opencl(primitives_t* prims)
|
2018-01-29 18:20:59 +03:00
|
|
|
{
|
2019-11-13 18:35:03 +03:00
|
|
|
primitives_t* p = primitives_get_by_type(PRIMITIVES_ONLY_CPU);
|
|
|
|
if (!prims || !p)
|
|
|
|
return FALSE;
|
|
|
|
*prims = *p;
|
|
|
|
|
|
|
|
if (!primitives_init_opencl_context(&openclContext))
|
|
|
|
return FALSE;
|
|
|
|
|
2018-01-29 18:20:59 +03:00
|
|
|
prims->YUV420ToRGB_8u_P3AC4R = opencl_YUV420ToRGB_8u_P3AC4R;
|
2019-11-13 18:37:28 +03:00
|
|
|
prims->YUV444ToRGB_8u_P3AC4R = opencl_YUV444ToRGB_8u_P3AC4R;
|
2019-11-13 18:35:03 +03:00
|
|
|
prims->flags |= PRIM_FLAGS_HAVE_EXTGPU;
|
|
|
|
prims->uninit = primitives_uninit_opencl;
|
|
|
|
return TRUE;
|
2018-01-29 18:20:59 +03:00
|
|
|
}
|