falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

avutil/opencl: merge opencl env to opencl context 

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>
tags/n2.0
highgod0401 Michael Niedermayer 12 years ago
parent
34b78ad04f
commit
8f99494c1c
1 changed files with 160 additions and 170 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +160
    -170
      libavutil/opencl.c

+ 160
- 170
libavutil/opencl.c View File

@@ -49,9 +49,19 @@ typedef struct {
} KernelCode; } KernelCode;


typedef struct { typedef struct {
const AVClass *class;
int log_offset;
void *log_ctx;
int init_count; int init_count;
int opt_init_flag;
/**
* if set to 1, the OpenCL environment was created by the user and
* passed as AVOpenCLExternalEnv when initing ,0:created by opencl wrapper.
*/
int is_user_created;
int platform_idx; int platform_idx;
int device_idx; int device_idx;
char *build_options;
cl_platform_id platform_id; cl_platform_id platform_id;
cl_device_type device_type; cl_device_type device_type;
cl_context context; cl_context context;
@@ -62,25 +72,10 @@ typedef struct {
int kernel_code_count; int kernel_code_count;
KernelCode kernel_code[MAX_KERNEL_CODE_NUM]; KernelCode kernel_code[MAX_KERNEL_CODE_NUM];
int kernel_count; int kernel_count;
/**
* if set to 1, the OpenCL environment was created by the user and
* passed as AVOpenCLExternalEnv when initing ,0:created by opencl wrapper.
*/
int is_user_created;
AVOpenCLDeviceList device_list; AVOpenCLDeviceList device_list;
} GPUEnv;
} OpenclContext;


typedef struct {
const AVClass *class;
int log_offset;
void *log_ctx;
int init_flag;
int platform_idx;
int device_idx;
char *build_options;
} OpenclUtils;

#define OFFSET(x) offsetof(OpenclUtils, x)
#define OFFSET(x) offsetof(OpenclContext, x)


static const AVOption opencl_options[] = { static const AVOption opencl_options[] = {
{ "platform_idx", "set platform index value", OFFSET(platform_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX}, { "platform_idx", "set platform index value", OFFSET(platform_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX},
@@ -93,17 +88,14 @@ static const AVClass openclutils_class = {
.option = opencl_options, .option = opencl_options,
.item_name = av_default_item_name, .item_name = av_default_item_name,
.version = LIBAVUTIL_VERSION_INT, .version = LIBAVUTIL_VERSION_INT,
.log_level_offset_offset = offsetof(OpenclUtils, log_offset),
.parent_log_context_offset = offsetof(OpenclUtils, log_ctx),
.log_level_offset_offset = offsetof(OpenclContext, log_offset),
.parent_log_context_offset = offsetof(OpenclContext, log_ctx),
}; };


static OpenclUtils openclutils = {&openclutils_class};

static GPUEnv gpu_env;
static OpenclContext opencl_ctx = {&openclutils_class};


static const cl_device_type device_type[] = {CL_DEVICE_TYPE_GPU, CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_DEFAULT}; static const cl_device_type device_type[] = {CL_DEVICE_TYPE_GPU, CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_DEFAULT};



typedef struct { typedef struct {
int err_code; int err_code;
const char *err_str; const char *err_str;
@@ -208,7 +200,7 @@ static int get_device_list(AVOpenCLDeviceList *device_list)
AVOpenCLDeviceNode *device_node = NULL; AVOpenCLDeviceNode *device_node = NULL;
status = clGetPlatformIDs(0, NULL, &device_list->platform_num); status = clGetPlatformIDs(0, NULL, &device_list->platform_num);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not get OpenCL platform ids: %s\n", opencl_errstr(status)); "Could not get OpenCL platform ids: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -217,7 +209,7 @@ static int get_device_list(AVOpenCLDeviceList *device_list)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
status = clGetPlatformIDs(device_list->platform_num, platform_ids, NULL); status = clGetPlatformIDs(device_list->platform_num, platform_ids, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not get OpenCL platform ids: %s\n", opencl_errstr(status)); "Could not get OpenCL platform ids: %s\n", opencl_errstr(status));
ret = AVERROR_EXTERNAL; ret = AVERROR_EXTERNAL;
goto end; goto end;
@@ -263,7 +255,7 @@ static int get_device_list(AVOpenCLDeviceList *device_list)
status = clGetDeviceIDs(device_list->platform_node[i]->platform_id, device_type[j], status = clGetDeviceIDs(device_list->platform_node[i]->platform_id, device_type[j],
devices_num[j], device_ids, NULL); devices_num[j], device_ids, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_WARNING,
av_log(&opencl_ctx, AV_LOG_WARNING,
"Could not get device ID: %s:\n", opencl_errstr(status)); "Could not get device ID: %s:\n", opencl_errstr(status));
av_freep(&device_ids); av_freep(&device_ids);
continue; continue;
@@ -282,7 +274,7 @@ static int get_device_list(AVOpenCLDeviceList *device_list)
sizeof(device_node->device_name), device_node->device_name, sizeof(device_node->device_name), device_node->device_name,
NULL); NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_WARNING,
av_log(&opencl_ctx, AV_LOG_WARNING,
"Could not get device name: %s\n", opencl_errstr(status)); "Could not get device name: %s\n", opencl_errstr(status));
continue; continue;
} }
@@ -306,12 +298,12 @@ int av_opencl_get_device_list(AVOpenCLDeviceList **device_list)
int ret = 0; int ret = 0;
*device_list = av_mallocz(sizeof(AVOpenCLDeviceList)); *device_list = av_mallocz(sizeof(AVOpenCLDeviceList));
if (!(*device_list)) { if (!(*device_list)) {
av_log(&openclutils, AV_LOG_ERROR, "Could not allocate opencl device list\n");
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not allocate opencl device list\n");
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
ret = get_device_list(*device_list); ret = get_device_list(*device_list);
if (ret < 0) { if (ret < 0) {
av_log(&openclutils, AV_LOG_ERROR, "Could not get device list from environment\n");
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not get device list from environment\n");
free_device_list(*device_list); free_device_list(*device_list);
av_freep(device_list); av_freep(device_list);
return ret; return ret;
@@ -329,11 +321,11 @@ int av_opencl_set_option(const char *key, const char *val)
{ {
int ret = 0; int ret = 0;
LOCK_OPENCL LOCK_OPENCL
if (!openclutils.init_flag) {
av_opt_set_defaults(&openclutils);
openclutils.init_flag = 1;
if (!opencl_ctx.opt_init_flag) {
av_opt_set_defaults(&opencl_ctx);
opencl_ctx.opt_init_flag = 1;
} }
ret = av_opt_set(&openclutils, key, val, 0);
ret = av_opt_set(&opencl_ctx, key, val, 0);
UNLOCK_OPENCL UNLOCK_OPENCL
return ret; return ret;
} }
@@ -342,7 +334,7 @@ int av_opencl_get_option(const char *key, uint8_t **out_val)
{ {
int ret = 0; int ret = 0;
LOCK_OPENCL LOCK_OPENCL
ret = av_opt_get(&openclutils, key, 0, out_val);
ret = av_opt_get(&opencl_ctx, key, 0, out_val);
UNLOCK_OPENCL UNLOCK_OPENCL
return ret; return ret;
} }
@@ -351,7 +343,7 @@ void av_opencl_free_option(void)
{ {
/*FIXME: free openclutils context*/ /*FIXME: free openclutils context*/
LOCK_OPENCL LOCK_OPENCL
av_opt_free(&openclutils);
av_opt_free(&opencl_ctx);
UNLOCK_OPENCL UNLOCK_OPENCL
} }


@@ -359,7 +351,7 @@ AVOpenCLExternalEnv *av_opencl_alloc_external_env(void)
{ {
AVOpenCLExternalEnv *ext = av_mallocz(sizeof(AVOpenCLExternalEnv)); AVOpenCLExternalEnv *ext = av_mallocz(sizeof(AVOpenCLExternalEnv));
if (!ext) { if (!ext) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not malloc external opencl environment data space\n"); "Could not malloc external opencl environment data space\n");
} }
return ext; return ext;
@@ -374,22 +366,22 @@ int av_opencl_register_kernel_code(const char *kernel_code)
{ {
int i, ret = 0; int i, ret = 0;
LOCK_OPENCL; LOCK_OPENCL;
if (gpu_env.kernel_code_count >= MAX_KERNEL_CODE_NUM) {
av_log(&openclutils, AV_LOG_ERROR,
if (opencl_ctx.kernel_code_count >= MAX_KERNEL_CODE_NUM) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not register kernel code, maximum number of registered kernel code %d already reached\n", "Could not register kernel code, maximum number of registered kernel code %d already reached\n",
MAX_KERNEL_CODE_NUM); MAX_KERNEL_CODE_NUM);
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto end; goto end;
} }
for (i = 0; i < gpu_env.kernel_code_count; i++) {
if (gpu_env.kernel_code[i].kernel_string == kernel_code) {
av_log(&openclutils, AV_LOG_WARNING, "Same kernel code has been registered\n");
for (i = 0; i < opencl_ctx.kernel_code_count; i++) {
if (opencl_ctx.kernel_code[i].kernel_string == kernel_code) {
av_log(&opencl_ctx, AV_LOG_WARNING, "Same kernel code has been registered\n");
goto end; goto end;
} }
} }
gpu_env.kernel_code[gpu_env.kernel_code_count].kernel_string = kernel_code;
gpu_env.kernel_code[gpu_env.kernel_code_count].is_compiled = 0;
gpu_env.kernel_code_count++;
opencl_ctx.kernel_code[opencl_ctx.kernel_code_count].kernel_string = kernel_code;
opencl_ctx.kernel_code[opencl_ctx.kernel_code_count].is_compiled = 0;
opencl_ctx.kernel_code_count++;
end: end:
UNLOCK_OPENCL; UNLOCK_OPENCL;
return ret; return ret;
@@ -401,35 +393,35 @@ int av_opencl_create_kernel(AVOpenCLKernelEnv *env, const char *kernel_name)
int i, ret = 0; int i, ret = 0;
LOCK_OPENCL; LOCK_OPENCL;
if (strlen(kernel_name) + 1 > AV_OPENCL_MAX_KERNEL_NAME_SIZE) { if (strlen(kernel_name) + 1 > AV_OPENCL_MAX_KERNEL_NAME_SIZE) {
av_log(&openclutils, AV_LOG_ERROR, "Created kernel name %s is too long\n", kernel_name);
av_log(&opencl_ctx, AV_LOG_ERROR, "Created kernel name %s is too long\n", kernel_name);
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto end; goto end;
} }
if (!env->kernel) { if (!env->kernel) {
if (gpu_env.kernel_count >= MAX_KERNEL_NUM) {
av_log(&openclutils, AV_LOG_ERROR,
if (opencl_ctx.kernel_count >= MAX_KERNEL_NUM) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not create kernel with name '%s', maximum number of kernels %d already reached\n", "Could not create kernel with name '%s', maximum number of kernels %d already reached\n",
kernel_name, MAX_KERNEL_NUM); kernel_name, MAX_KERNEL_NUM);
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto end; goto end;
} }
if (gpu_env.program_count == 0) {
av_log(&openclutils, AV_LOG_ERROR, "Program count of OpenCL is 0, can not create kernel\n");
if (opencl_ctx.program_count == 0) {
av_log(&opencl_ctx, AV_LOG_ERROR, "Program count of OpenCL is 0, can not create kernel\n");
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto end; goto end;
} }
for (i = 0; i < gpu_env.program_count; i++) {
env->kernel = clCreateKernel(gpu_env.programs[i], kernel_name, &status);
for (i = 0; i < opencl_ctx.program_count; i++) {
env->kernel = clCreateKernel(opencl_ctx.programs[i], kernel_name, &status);
if (status == CL_SUCCESS) if (status == CL_SUCCESS)
break; break;
} }
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR, "Could not create OpenCL kernel: %s\n", opencl_errstr(status));
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL kernel: %s\n", opencl_errstr(status));
ret = AVERROR_EXTERNAL; ret = AVERROR_EXTERNAL;
goto end; goto end;
} }
gpu_env.kernel_count++;
env->command_queue = gpu_env.command_queue;
opencl_ctx.kernel_count++;
env->command_queue = opencl_ctx.command_queue;
av_strlcpy(env->kernel_name, kernel_name, sizeof(env->kernel_name)); av_strlcpy(env->kernel_name, kernel_name, sizeof(env->kernel_name));
} }
end: end:
@@ -445,18 +437,18 @@ void av_opencl_release_kernel(AVOpenCLKernelEnv *env)
goto end; goto end;
status = clReleaseKernel(env->kernel); status = clReleaseKernel(env->kernel);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR, "Could not release kernel: %s\n",
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not release kernel: %s\n",
opencl_errstr(status)); opencl_errstr(status));
} }
env->kernel = NULL; env->kernel = NULL;
env->command_queue = NULL; env->command_queue = NULL;
env->kernel_name[0] = 0; env->kernel_name[0] = 0;
gpu_env.kernel_count--;
opencl_ctx.kernel_count--;
end: end:
UNLOCK_OPENCL UNLOCK_OPENCL
} }


static int init_opencl_env(GPUEnv *gpu_env, AVOpenCLExternalEnv *ext_opencl_env)
static int init_opencl_env(OpenclContext *opencl_ctx, AVOpenCLExternalEnv *ext_opencl_env)
{ {
cl_int status; cl_int status;
cl_context_properties cps[3]; cl_context_properties cps[3];
@@ -464,83 +456,83 @@ static int init_opencl_env(GPUEnv *gpu_env, AVOpenCLExternalEnv *ext_opencl_env)
AVOpenCLDeviceNode *device_node = NULL; AVOpenCLDeviceNode *device_node = NULL;


if (ext_opencl_env) { if (ext_opencl_env) {
if (gpu_env->is_user_created)
if (opencl_ctx->is_user_created)
return 0; return 0;
gpu_env->platform_id = ext_opencl_env->platform_id;
gpu_env->is_user_created = 1;
gpu_env->command_queue = ext_opencl_env->command_queue;
gpu_env->context = ext_opencl_env->context;
gpu_env->device_id = ext_opencl_env->device_id;
gpu_env->device_type = ext_opencl_env->device_type;
opencl_ctx->platform_id = ext_opencl_env->platform_id;
opencl_ctx->is_user_created = 1;
opencl_ctx->command_queue = ext_opencl_env->command_queue;
opencl_ctx->context = ext_opencl_env->context;
opencl_ctx->device_id = ext_opencl_env->device_id;
opencl_ctx->device_type = ext_opencl_env->device_type;
} else { } else {
if (!gpu_env->is_user_created) {
if (!gpu_env->device_list.platform_num) {
ret = get_device_list(&gpu_env->device_list);
if (!opencl_ctx->is_user_created) {
if (!opencl_ctx->device_list.platform_num) {
ret = get_device_list(&opencl_ctx->device_list);
if (ret < 0) { if (ret < 0) {
return ret; return ret;
} }
} }
if (gpu_env->platform_idx >= 0) {
if (gpu_env->device_list.platform_num < gpu_env->platform_idx + 1) {
av_log(&openclutils, AV_LOG_ERROR, "User set platform index not exist\n");
if (opencl_ctx->platform_idx >= 0) {
if (opencl_ctx->device_list.platform_num < opencl_ctx->platform_idx + 1) {
av_log(opencl_ctx, AV_LOG_ERROR, "User set platform index not exist\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
if (!gpu_env->device_list.platform_node[gpu_env->platform_idx]->device_num) {
av_log(&openclutils, AV_LOG_ERROR, "No devices in user specific platform with index %d\n",
gpu_env->platform_idx);
if (!opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_num) {
av_log(opencl_ctx, AV_LOG_ERROR, "No devices in user specific platform with index %d\n",
opencl_ctx->platform_idx);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
gpu_env->platform_id = gpu_env->device_list.platform_node[gpu_env->platform_idx]->platform_id;
opencl_ctx->platform_id = opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->platform_id;
} else { } else {
/* get a usable platform by default*/ /* get a usable platform by default*/
for (i = 0; i < gpu_env->device_list.platform_num; i++) {
if (gpu_env->device_list.platform_node[i]->device_num) {
gpu_env->platform_id = gpu_env->device_list.platform_node[i]->platform_id;
gpu_env->platform_idx = i;
for (i = 0; i < opencl_ctx->device_list.platform_num; i++) {
if (opencl_ctx->device_list.platform_node[i]->device_num) {
opencl_ctx->platform_id = opencl_ctx->device_list.platform_node[i]->platform_id;
opencl_ctx->platform_idx = i;
break; break;
} }
} }
} }
if (!gpu_env->platform_id) {
av_log(&openclutils, AV_LOG_ERROR, "Could not get OpenCL platforms\n");
if (!opencl_ctx->platform_id) {
av_log(opencl_ctx, AV_LOG_ERROR, "Could not get OpenCL platforms\n");
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
/* get a usable device*/ /* get a usable device*/
if (gpu_env->device_idx >= 0) {
if (gpu_env->device_list.platform_node[gpu_env->platform_idx]->device_num < gpu_env->device_idx + 1) {
av_log(&openclutils, AV_LOG_ERROR,
"Could not get OpenCL device idx %d in the user set platform\n", gpu_env->platform_idx);
if (opencl_ctx->device_idx >= 0) {
if (opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_num < opencl_ctx->device_idx + 1) {
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not get OpenCL device idx %d in the user set platform\n", opencl_ctx->platform_idx);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
} else { } else {
gpu_env->device_idx = 0;
opencl_ctx->device_idx = 0;
} }


device_node = gpu_env->device_list.platform_node[gpu_env->platform_idx]->device_node[gpu_env->device_idx];
gpu_env->device_id = device_node->device_id;
gpu_env->device_type = device_node->device_type;
device_node = opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_node[opencl_ctx->device_idx];
opencl_ctx->device_id = device_node->device_id;
opencl_ctx->device_type = device_node->device_type;


/* /*
* Use available platform. * Use available platform.
*/ */
av_log(&openclutils, AV_LOG_VERBOSE, "Platform Name: %s, device id: 0x%x\n",
gpu_env->device_list.platform_node[gpu_env->platform_idx]->platform_name,
(unsigned int)gpu_env->device_id);
av_log(opencl_ctx, AV_LOG_VERBOSE, "Platform Name: %s, device id: 0x%x\n",
opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->platform_name,
(unsigned int)opencl_ctx->device_id);
cps[0] = CL_CONTEXT_PLATFORM; cps[0] = CL_CONTEXT_PLATFORM;
cps[1] = (cl_context_properties)gpu_env->platform_id;
cps[1] = (cl_context_properties)opencl_ctx->platform_id;
cps[2] = 0; cps[2] = 0;
/* Check for GPU. */
gpu_env->context = clCreateContextFromType(cps, gpu_env->device_type,
opencl_ctx->context = clCreateContextFromType(cps, opencl_ctx->device_type,
NULL, NULL, &status); NULL, NULL, &status);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not get OpenCL context from device type: %s\n", opencl_errstr(status)); "Could not get OpenCL context from device type: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
gpu_env->command_queue = clCreateCommandQueue(gpu_env->context, gpu_env->device_id,
opencl_ctx->command_queue = clCreateCommandQueue(opencl_ctx->context, opencl_ctx->device_id,
0, &status); 0, &status);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not create OpenCL command queue: %s\n", opencl_errstr(status)); "Could not create OpenCL command queue: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -549,16 +541,16 @@ static int init_opencl_env(GPUEnv *gpu_env, AVOpenCLExternalEnv *ext_opencl_env)
return ret; return ret;
} }


static int compile_kernel_file(GPUEnv *gpu_env, const char *build_options)
static int compile_kernel_file(OpenclContext *opencl_ctx)
{ {
cl_int status; cl_int status;
char *temp, *source_str = NULL; char *temp, *source_str = NULL;
size_t source_str_len = 0; size_t source_str_len = 0;
int i, ret = 0; int i, ret = 0;


for (i = 0; i < gpu_env->kernel_code_count; i++) {
if (!gpu_env->kernel_code[i].is_compiled)
source_str_len += strlen(gpu_env->kernel_code[i].kernel_string);
for (i = 0; i < opencl_ctx->kernel_code_count; i++) {
if (!opencl_ctx->kernel_code[i].is_compiled)
source_str_len += strlen(opencl_ctx->kernel_code[i].kernel_string);
} }
if (!source_str_len) { if (!source_str_len) {
return 0; return 0;
@@ -568,38 +560,38 @@ static int compile_kernel_file(GPUEnv *gpu_env, const char *build_options)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
temp = source_str; temp = source_str;
for (i = 0; i < gpu_env->kernel_code_count; i++) {
if (!gpu_env->kernel_code[i].is_compiled) {
memcpy(temp, gpu_env->kernel_code[i].kernel_string,
strlen(gpu_env->kernel_code[i].kernel_string));
gpu_env->kernel_code[i].is_compiled = 1;
temp += strlen(gpu_env->kernel_code[i].kernel_string);
for (i = 0; i < opencl_ctx->kernel_code_count; i++) {
if (!opencl_ctx->kernel_code[i].is_compiled) {
memcpy(temp, opencl_ctx->kernel_code[i].kernel_string,
strlen(opencl_ctx->kernel_code[i].kernel_string));
opencl_ctx->kernel_code[i].is_compiled = 1;
temp += strlen(opencl_ctx->kernel_code[i].kernel_string);
} }
} }
/* create a CL program using the kernel source */ /* create a CL program using the kernel source */
gpu_env->programs[gpu_env->program_count] = clCreateProgramWithSource(gpu_env->context,
opencl_ctx->programs[opencl_ctx->program_count] = clCreateProgramWithSource(opencl_ctx->context,
1, (const char **)(&source_str), 1, (const char **)(&source_str),
&source_str_len, &status); &source_str_len, &status);
if(status != CL_SUCCESS) { if(status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not create OpenCL program with source code: %s\n", opencl_errstr(status)); "Could not create OpenCL program with source code: %s\n", opencl_errstr(status));
ret = AVERROR_EXTERNAL; ret = AVERROR_EXTERNAL;
goto end; goto end;
} }
if (!gpu_env->programs[gpu_env->program_count]) {
av_log(&openclutils, AV_LOG_ERROR, "Created program is NULL\n");
if (!opencl_ctx->programs[opencl_ctx->program_count]) {
av_log(opencl_ctx, AV_LOG_ERROR, "Created program is NULL\n");
ret = AVERROR_EXTERNAL; ret = AVERROR_EXTERNAL;
goto end; goto end;
} }
status = clBuildProgram(gpu_env->programs[gpu_env->program_count], 1, &(gpu_env->device_id),
build_options, NULL, NULL);
status = clBuildProgram(opencl_ctx->programs[opencl_ctx->program_count], 1, &(opencl_ctx->device_id),
opencl_ctx->build_options, NULL, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(opencl_ctx, AV_LOG_ERROR,
"Could not compile OpenCL kernel: %s\n", opencl_errstr(status)); "Could not compile OpenCL kernel: %s\n", opencl_errstr(status));
ret = AVERROR_EXTERNAL; ret = AVERROR_EXTERNAL;
goto end; goto end;
} }
gpu_env->program_count++;
opencl_ctx->program_count++;
end: end:
av_free(source_str); av_free(source_str);
return ret; return ret;
@@ -609,27 +601,25 @@ int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env)
{ {
int ret = 0; int ret = 0;
LOCK_OPENCL LOCK_OPENCL
if (!gpu_env.init_count) {
if (!openclutils.init_flag) {
av_opt_set_defaults(&openclutils);
openclutils.init_flag = 1;
if (!opencl_ctx.init_count) {
if (!opencl_ctx.opt_init_flag) {
av_opt_set_defaults(&opencl_ctx);
opencl_ctx.opt_init_flag = 1;
} }
gpu_env.device_idx = openclutils.device_idx;
gpu_env.platform_idx = openclutils.platform_idx;
ret = init_opencl_env(&gpu_env, ext_opencl_env);
ret = init_opencl_env(&opencl_ctx, ext_opencl_env);
if (ret < 0) if (ret < 0)
goto end; goto end;
} }
ret = compile_kernel_file(&gpu_env, openclutils.build_options);
ret = compile_kernel_file(&opencl_ctx);
if (ret < 0) if (ret < 0)
goto end; goto end;
if (gpu_env.kernel_code_count <= 0) {
av_log(&openclutils, AV_LOG_ERROR,
if (opencl_ctx.kernel_code_count <= 0) {
av_log(&opencl_ctx, AV_LOG_ERROR,
"No kernel code is registered, compile kernel file failed\n"); "No kernel code is registered, compile kernel file failed\n");
ret = AVERROR(EINVAL); ret = AVERROR(EINVAL);
goto end; goto end;
} }
gpu_env.init_count++;
opencl_ctx.init_count++;


end: end:
UNLOCK_OPENCL UNLOCK_OPENCL
@@ -641,50 +631,50 @@ void av_opencl_uninit(void)
cl_int status; cl_int status;
int i; int i;
LOCK_OPENCL LOCK_OPENCL
gpu_env.init_count--;
if (gpu_env.is_user_created)
opencl_ctx.init_count--;
if (opencl_ctx.is_user_created)
goto end; goto end;
if (gpu_env.init_count > 0 || gpu_env.kernel_count > 0)
if (opencl_ctx.init_count > 0 || opencl_ctx.kernel_count > 0)
goto end; goto end;
for (i = 0; i < gpu_env.program_count; i++) {
if (gpu_env.programs[i]) {
status = clReleaseProgram(gpu_env.programs[i]);
for (i = 0; i < opencl_ctx.program_count; i++) {
if (opencl_ctx.programs[i]) {
status = clReleaseProgram(opencl_ctx.programs[i]);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not release OpenCL program: %s\n", opencl_errstr(status)); "Could not release OpenCL program: %s\n", opencl_errstr(status));
} }
gpu_env.programs[i] = NULL;
opencl_ctx.programs[i] = NULL;
} }
} }
if (gpu_env.command_queue) {
status = clReleaseCommandQueue(gpu_env.command_queue);
if (opencl_ctx.command_queue) {
status = clReleaseCommandQueue(opencl_ctx.command_queue);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not release OpenCL command queue: %s\n", opencl_errstr(status)); "Could not release OpenCL command queue: %s\n", opencl_errstr(status));
} }
gpu_env.command_queue = NULL;
opencl_ctx.command_queue = NULL;
} }
if (gpu_env.context) {
status = clReleaseContext(gpu_env.context);
if (opencl_ctx.context) {
status = clReleaseContext(opencl_ctx.context);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not release OpenCL context: %s\n", opencl_errstr(status)); "Could not release OpenCL context: %s\n", opencl_errstr(status));
} }
gpu_env.context = NULL;
opencl_ctx.context = NULL;
} }
free_device_list(&gpu_env.device_list);
free_device_list(&opencl_ctx.device_list);
end: end:
if ((gpu_env.init_count <= 0) && (gpu_env.kernel_count <= 0))
av_opt_free(&openclutils); //FIXME: free openclutils context
if ((opencl_ctx.init_count <= 0) && (opencl_ctx.kernel_count <= 0))
av_opt_free(&opencl_ctx); //FIXME: free openclutils context
UNLOCK_OPENCL UNLOCK_OPENCL
} }


int av_opencl_buffer_create(cl_mem *cl_buf, size_t cl_buf_size, int flags, void *host_ptr) int av_opencl_buffer_create(cl_mem *cl_buf, size_t cl_buf_size, int flags, void *host_ptr)
{ {
cl_int status; cl_int status;
*cl_buf = clCreateBuffer(gpu_env.context, flags, cl_buf_size, host_ptr, &status);
*cl_buf = clCreateBuffer(opencl_ctx.context, flags, cl_buf_size, host_ptr, &status);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR, "Could not create OpenCL buffer: %s\n", opencl_errstr(status));
av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
return 0; return 0;
@@ -697,7 +687,7 @@ void av_opencl_buffer_release(cl_mem *cl_buf)
return; return;
status = clReleaseMemObject(*cl_buf); status = clReleaseMemObject(*cl_buf);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not release OpenCL buffer: %s\n", opencl_errstr(status)); "Could not release OpenCL buffer: %s\n", opencl_errstr(status));
} }
memset(cl_buf, 0, sizeof(*cl_buf)); memset(cl_buf, 0, sizeof(*cl_buf));
@@ -706,20 +696,20 @@ void av_opencl_buffer_release(cl_mem *cl_buf)
int av_opencl_buffer_write(cl_mem dst_cl_buf, uint8_t *src_buf, size_t buf_size) int av_opencl_buffer_write(cl_mem dst_cl_buf, uint8_t *src_buf, size_t buf_size)
{ {
cl_int status; cl_int status;
void *mapped = clEnqueueMapBuffer(gpu_env.command_queue, dst_cl_buf,
CL_TRUE,CL_MAP_WRITE, 0, sizeof(uint8_t) * buf_size,
void *mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, dst_cl_buf,
CL_TRUE, CL_MAP_WRITE, 0, sizeof(uint8_t) * buf_size,
0, NULL, NULL, &status); 0, NULL, NULL, &status);


if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not map OpenCL buffer: %s\n", opencl_errstr(status)); "Could not map OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
memcpy(mapped, src_buf, buf_size); memcpy(mapped, src_buf, buf_size);


status = clEnqueueUnmapMemObject(gpu_env.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not unmap OpenCL buffer: %s\n", opencl_errstr(status)); "Could not unmap OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -729,20 +719,20 @@ int av_opencl_buffer_write(cl_mem dst_cl_buf, uint8_t *src_buf, size_t buf_size)
int av_opencl_buffer_read(uint8_t *dst_buf, cl_mem src_cl_buf, size_t buf_size) int av_opencl_buffer_read(uint8_t *dst_buf, cl_mem src_cl_buf, size_t buf_size)
{ {
cl_int status; cl_int status;
void *mapped = clEnqueueMapBuffer(gpu_env.command_queue, src_cl_buf,
CL_TRUE,CL_MAP_READ, 0, buf_size,
void *mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, src_cl_buf,
CL_TRUE, CL_MAP_READ, 0, buf_size,
0, NULL, NULL, &status); 0, NULL, NULL, &status);


if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not map OpenCL buffer: %s\n", opencl_errstr(status)); "Could not map OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
memcpy(dst_buf, mapped, buf_size); memcpy(dst_buf, mapped, buf_size);


status = clEnqueueUnmapMemObject(gpu_env.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not unmap OpenCL buffer: %s\n", opencl_errstr(status)); "Could not unmap OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -763,15 +753,15 @@ int av_opencl_buffer_write_image(cl_mem dst_cl_buf, size_t cl_buffer_size, int d
buffer_size += plane_size[i]; buffer_size += plane_size[i];
} }
if (buffer_size > cl_buffer_size) { if (buffer_size > cl_buffer_size) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Cannot write image to OpenCL buffer: buffer too small\n"); "Cannot write image to OpenCL buffer: buffer too small\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
mapped = clEnqueueMapBuffer(gpu_env.command_queue, dst_cl_buf,
CL_TRUE,CL_MAP_WRITE, 0, buffer_size + dst_cl_offset,
mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, dst_cl_buf,
CL_TRUE, CL_MAP_WRITE, 0, buffer_size + dst_cl_offset,
0, NULL, NULL, &status); 0, NULL, NULL, &status);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not map OpenCL buffer: %s\n", opencl_errstr(status)); "Could not map OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -781,9 +771,9 @@ int av_opencl_buffer_write_image(cl_mem dst_cl_buf, size_t cl_buffer_size, int d
memcpy(temp, src_data[i], plane_size[i]); memcpy(temp, src_data[i], plane_size[i]);
temp += plane_size[i]; temp += plane_size[i];
} }
status = clEnqueueUnmapMemObject(gpu_env.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not unmap OpenCL buffer: %s\n", opencl_errstr(status)); "Could not unmap OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -804,16 +794,16 @@ int av_opencl_buffer_read_image(uint8_t **dst_data, int *plane_size, int plane_n
buffer_size += plane_size[i]; buffer_size += plane_size[i];
} }
if (buffer_size > cl_buffer_size) { if (buffer_size > cl_buffer_size) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Cannot write image to CPU buffer: OpenCL buffer too small\n"); "Cannot write image to CPU buffer: OpenCL buffer too small\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
mapped = clEnqueueMapBuffer(gpu_env.command_queue, src_cl_buf,
CL_TRUE,CL_MAP_READ, 0, buffer_size,
mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, src_cl_buf,
CL_TRUE, CL_MAP_READ, 0, buffer_size,
0, NULL, NULL, &status); 0, NULL, NULL, &status);


if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not map OpenCL buffer: %s\n", opencl_errstr(status)); "Could not map OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }
@@ -824,9 +814,9 @@ int av_opencl_buffer_read_image(uint8_t **dst_data, int *plane_size, int plane_n
temp += plane_size[i]; temp += plane_size[i];
} }
} }
status = clEnqueueUnmapMemObject(gpu_env.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
if (status != CL_SUCCESS) { if (status != CL_SUCCESS) {
av_log(&openclutils, AV_LOG_ERROR,
av_log(&opencl_ctx, AV_LOG_ERROR,
"Could not unmap OpenCL buffer: %s\n", opencl_errstr(status)); "Could not unmap OpenCL buffer: %s\n", opencl_errstr(status));
return AVERROR_EXTERNAL; return AVERROR_EXTERNAL;
} }


Write Preview
Loading…
Cancel
Save