WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavutil/opencl.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* Copyright (C) 2012 Peng Gao
		3	* Copyright (C) 2012 Li Cao
		4	* Copyright (C) 2012 Wei Gao
		5	*
		6	* This file is part of FFmpeg.
		7	*
		8	* FFmpeg is free software; you can redistribute it and/or
		9	* modify it under the terms of the GNU Lesser General Public
		10	* License as published by the Free Software Foundation; either
		11	* version 2.1 of the License, or (at your option) any later version.
		12	*
		13	* FFmpeg is distributed in the hope that it will be useful,
		14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		16	* Lesser General Public License for more details.
		17	*
		18	* You should have received a copy of the GNU Lesser General Public
		19	* License along with FFmpeg; if not, write to the Free Software
		20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
		21	*/
		22
		23	#include "opencl.h"
		24	#include "avstring.h"
		25	#include "log.h"
		26	#include "avassert.h"
		27	#include "opt.h"
		28
		29	#if HAVE_PTHREADS
		30
		31	#include
		32	static pthread_mutex_t atomic_opencl_lock = PTHREAD_MUTEX_INITIALIZER;
		33
		34	#define LOCK_OPENCL pthread_mutex_lock(&atomic_opencl_lock)
		35	#define UNLOCK_OPENCL pthread_mutex_unlock(&atomic_opencl_lock)
		36
		37	#elif !HAVE_THREADS
		38	#define LOCK_OPENCL
		39	#define UNLOCK_OPENCL
		40	#endif
		41
		42
		43	#define MAX_KERNEL_NUM 500
		44	#define MAX_KERNEL_CODE_NUM 200
		45
		46	typedef struct {
		47	int is_compiled;
		48	const char *kernel_string;
		49	} KernelCode;
		50
		51	typedef struct {
		52	const AVClass *class;
		53	int log_offset;
		54	void *log_ctx;
		55	int init_count;
		56	int opt_init_flag;
		57	/**
		58	* if set to 1, the OpenCL environment was created by the user and
		59	* passed as AVOpenCLExternalEnv when initing ,0:created by opencl wrapper.
		60	*/
		61	int is_user_created;
		62	int platform_idx;
		63	int device_idx;
		64	char *build_options;
		65	cl_platform_id platform_id;
		66	cl_device_type device_type;
		67	cl_context context;
		68	cl_device_id device_id;
		69	cl_command_queue command_queue;
		70	int program_count;
		71	cl_program programs[MAX_KERNEL_CODE_NUM];
		72	int kernel_code_count;
		73	KernelCode kernel_code[MAX_KERNEL_CODE_NUM];
		74	int kernel_count;
		75	AVOpenCLDeviceList device_list;
		76	} OpenclContext;
		77
		78	#define OFFSET(x) offsetof(OpenclContext, x)
		79
		80	static const AVOption opencl_options[] = {
		81	{ "platform_idx", "set platform index value", OFFSET(platform_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX},
		82	{ "device_idx", "set device index value", OFFSET(device_idx), AV_OPT_TYPE_INT, {.i64=-1}, -1, INT_MAX},
		83	{ "build_options", "build options of opencl", OFFSET(build_options), AV_OPT_TYPE_STRING, {.str="-I."}, CHAR_MIN, CHAR_MAX},
		84	{ NULL }
		85	};
		86
		87	static const AVClass openclutils_class = {
		88	.class_name = "OPENCLUTILS",
		89	.option = opencl_options,
		90	.item_name = av_default_item_name,
		91	.version = LIBAVUTIL_VERSION_INT,
		92	.log_level_offset_offset = offsetof(OpenclContext, log_offset),
		93	.parent_log_context_offset = offsetof(OpenclContext, log_ctx),
		94	};
		95
		96	static OpenclContext opencl_ctx = {&openclutils_class};
		97
		98	static const cl_device_type device_type[] = {CL_DEVICE_TYPE_GPU, CL_DEVICE_TYPE_CPU, CL_DEVICE_TYPE_DEFAULT};
		99
		100	typedef struct {
		101	int err_code;
		102	const char *err_str;
		103	} OpenclErrorMsg;
		104
		105	static const OpenclErrorMsg opencl_err_msg[] = {
		106	{CL_DEVICE_NOT_FOUND, "DEVICE NOT FOUND"},
		107	{CL_DEVICE_NOT_AVAILABLE, "DEVICE NOT AVAILABLE"},
		108	{CL_COMPILER_NOT_AVAILABLE, "COMPILER NOT AVAILABLE"},
		109	{CL_MEM_OBJECT_ALLOCATION_FAILURE, "MEM OBJECT ALLOCATION FAILURE"},
		110	{CL_OUT_OF_RESOURCES, "OUT OF RESOURCES"},
		111	{CL_OUT_OF_HOST_MEMORY, "OUT OF HOST MEMORY"},
		112	{CL_PROFILING_INFO_NOT_AVAILABLE, "PROFILING INFO NOT AVAILABLE"},
		113	{CL_MEM_COPY_OVERLAP, "MEM COPY OVERLAP"},
		114	{CL_IMAGE_FORMAT_MISMATCH, "IMAGE FORMAT MISMATCH"},
		115	{CL_IMAGE_FORMAT_NOT_SUPPORTED, "IMAGE FORMAT NOT_SUPPORTED"},
		116	{CL_BUILD_PROGRAM_FAILURE, "BUILD PROGRAM FAILURE"},
		117	{CL_MAP_FAILURE, "MAP FAILURE"},
		118	{CL_MISALIGNED_SUB_BUFFER_OFFSET, "MISALIGNED SUB BUFFER OFFSET"},
		119	{CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST, "EXEC STATUS ERROR FOR EVENTS IN WAIT LIST"},
		120	{CL_COMPILE_PROGRAM_FAILURE, "COMPILE PROGRAM FAILURE"},
		121	{CL_LINKER_NOT_AVAILABLE, "LINKER NOT AVAILABLE"},
		122	{CL_LINK_PROGRAM_FAILURE, "LINK PROGRAM FAILURE"},
		123	{CL_DEVICE_PARTITION_FAILED, "DEVICE PARTITION FAILED"},
		124	{CL_KERNEL_ARG_INFO_NOT_AVAILABLE, "KERNEL ARG INFO NOT AVAILABLE"},
		125	{CL_INVALID_VALUE, "INVALID VALUE"},
		126	{CL_INVALID_DEVICE_TYPE, "INVALID DEVICE TYPE"},
		127	{CL_INVALID_PLATFORM, "INVALID PLATFORM"},
		128	{CL_INVALID_DEVICE, "INVALID DEVICE"},
		129	{CL_INVALID_CONTEXT, "INVALID CONTEXT"},
		130	{CL_INVALID_QUEUE_PROPERTIES, "INVALID QUEUE PROPERTIES"},
		131	{CL_INVALID_COMMAND_QUEUE, "INVALID COMMAND QUEUE"},
		132	{CL_INVALID_HOST_PTR, "INVALID HOST PTR"},
		133	{CL_INVALID_MEM_OBJECT, "INVALID MEM OBJECT"},
		134	{CL_INVALID_IMAGE_FORMAT_DESCRIPTOR, "INVALID IMAGE FORMAT DESCRIPTOR"},
		135	{CL_INVALID_IMAGE_SIZE, "INVALID IMAGE SIZE"},
		136	{CL_INVALID_SAMPLER, "INVALID SAMPLER"},
		137	{CL_INVALID_BINARY, "INVALID BINARY"},
		138	{CL_INVALID_BUILD_OPTIONS, "INVALID BUILD OPTIONS"},
		139	{CL_INVALID_PROGRAM, "INVALID PROGRAM"},
		140	{CL_INVALID_PROGRAM_EXECUTABLE, "INVALID PROGRAM EXECUTABLE"},
		141	{CL_INVALID_KERNEL_NAME, "INVALID KERNEL NAME"},
		142	{CL_INVALID_KERNEL_DEFINITION, "INVALID KERNEL DEFINITION"},
		143	{CL_INVALID_KERNEL, "INVALID KERNEL"},
		144	{CL_INVALID_ARG_INDEX, "INVALID ARG INDEX"},
		145	{CL_INVALID_ARG_VALUE, "INVALID ARG VALUE"},
		146	{CL_INVALID_ARG_SIZE, "INVALID ARG_SIZE"},
		147	{CL_INVALID_KERNEL_ARGS, "INVALID KERNEL ARGS"},
		148	{CL_INVALID_WORK_DIMENSION, "INVALID WORK DIMENSION"},
		149	{CL_INVALID_WORK_GROUP_SIZE, "INVALID WORK GROUP SIZE"},
		150	{CL_INVALID_WORK_ITEM_SIZE, "INVALID WORK ITEM SIZE"},
		151	{CL_INVALID_GLOBAL_OFFSET, "INVALID GLOBAL OFFSET"},
		152	{CL_INVALID_EVENT_WAIT_LIST, "INVALID EVENT WAIT LIST"},
		153	{CL_INVALID_EVENT, "INVALID EVENT"},
		154	{CL_INVALID_OPERATION, "INVALID OPERATION"},
		155	{CL_INVALID_GL_OBJECT, "INVALID GL OBJECT"},
		156	{CL_INVALID_BUFFER_SIZE, "INVALID BUFFER SIZE"},
		157	{CL_INVALID_MIP_LEVEL, "INVALID MIP LEVEL"},
		158	{CL_INVALID_GLOBAL_WORK_SIZE, "INVALID GLOBAL WORK SIZE"},
		159	{CL_INVALID_PROPERTY, "INVALID PROPERTY"},
		160	{CL_INVALID_IMAGE_DESCRIPTOR, "INVALID IMAGE DESCRIPTOR"},
		161	{CL_INVALID_COMPILER_OPTIONS, "INVALID COMPILER OPTIONS"},
		162	{CL_INVALID_LINKER_OPTIONS, "INVALID LINKER OPTIONS"},
		163	{CL_INVALID_DEVICE_PARTITION_COUNT, "INVALID DEVICE PARTITION COUNT"},
		164	};
		165
		166	const char *av_opencl_errstr(cl_int status)
		167	{
		168	int i;
		169	for (i = 0; i < sizeof(opencl_err_msg); i++) {
		170	if (opencl_err_msg[i].err_code == status)
		171	return opencl_err_msg[i].err_str;
		172	}
		173	return "unknown error";
		174	}
		175
		176	static void free_device_list(AVOpenCLDeviceList *device_list)
		177	{
		178	int i, j;
		179	if (!device_list)
		180	return;
		181	for (i = 0; i < device_list->platform_num; i++) {
		182	if (!device_list->platform_node[i])
		183	continue;
		184	for (j = 0; j < device_list->platform_node[i]->device_num; j++) {
		185	av_freep(&(device_list->platform_node[i]->device_node[j]));
		186	}
		187	av_freep(&device_list->platform_node[i]->device_node);
		188	av_freep(&device_list->platform_node[i]);
		189	}
		190	av_freep(&device_list->platform_node);
		191	device_list->platform_num = 0;
		192	}
		193
		194	static int get_device_list(AVOpenCLDeviceList *device_list)
		195	{
		196	cl_int status;
		197	int i, j, k, device_num, total_devices_num,ret = 0;
		198	int *devices_num;
		199	cl_platform_id *platform_ids = NULL;
		200	cl_device_id *device_ids = NULL;
		201	AVOpenCLDeviceNode *device_node = NULL;
		202	status = clGetPlatformIDs(0, NULL, &device_list->platform_num);
		203	if (status != CL_SUCCESS) {
		204	av_log(&opencl_ctx, AV_LOG_ERROR,
		205	"Could not get OpenCL platform ids: %s\n", av_opencl_errstr(status));
		206	return AVERROR_EXTERNAL;
		207	}
		208	platform_ids = av_mallocz(device_list->platform_num * sizeof(cl_platform_id));
		209	if (!platform_ids)
		210	return AVERROR(ENOMEM);
		211	status = clGetPlatformIDs(device_list->platform_num, platform_ids, NULL);
		212	if (status != CL_SUCCESS) {
		213	av_log(&opencl_ctx, AV_LOG_ERROR,
		214	"Could not get OpenCL platform ids: %s\n", av_opencl_errstr(status));
		215	ret = AVERROR_EXTERNAL;
		216	goto end;
		217	}
		218	device_list->platform_node = av_mallocz(device_list->platform_num * sizeof(AVOpenCLPlatformNode *));
		219	if (!device_list->platform_node) {
		220	ret = AVERROR(ENOMEM);
		221	goto end;
		222	}
		223	devices_num = av_mallocz(sizeof(int) * FF_ARRAY_ELEMS(device_type));
		224	if (!devices_num) {
		225	ret = AVERROR(ENOMEM);
		226	goto end;
		227	}
		228	for (i = 0; i < device_list->platform_num; i++) {
		229	device_list->platform_node[i] = av_mallocz(sizeof(AVOpenCLPlatformNode));
		230	if (!device_list->platform_node[i]) {
		231	ret = AVERROR(ENOMEM);
		232	goto end;
		233	}
		234	device_list->platform_node[i]->platform_id = platform_ids[i];
		235	status = clGetPlatformInfo(platform_ids[i], CL_PLATFORM_VENDOR,
		236	sizeof(device_list->platform_node[i]->platform_name),
		237	device_list->platform_node[i]->platform_name, NULL);
		238	total_devices_num = 0;
		239	for (j = 0; j < FF_ARRAY_ELEMS(device_type); j++) {
		240	status = clGetDeviceIDs(device_list->platform_node[i]->platform_id,
		241	device_type[j], 0, NULL, &devices_num[j]);
		242	total_devices_num += devices_num[j];
		243	}
		244	device_list->platform_node[i]->device_node = av_mallocz(total_devices_num * sizeof(AVOpenCLDeviceNode *));
		245	if (!device_list->platform_node[i]->device_node) {
		246	ret = AVERROR(ENOMEM);
		247	goto end;
		248	}
		249	for (j = 0; j < FF_ARRAY_ELEMS(device_type); j++) {
		250	if (devices_num[j]) {
		251	device_ids = av_mallocz(devices_num[j] * sizeof(cl_device_id));
		252	if (!device_ids) {
		253	ret = AVERROR(ENOMEM);
		254	goto end;
		255	}
		256	status = clGetDeviceIDs(device_list->platform_node[i]->platform_id, device_type[j],
		257	devices_num[j], device_ids, NULL);
		258	if (status != CL_SUCCESS) {
		259	av_log(&opencl_ctx, AV_LOG_WARNING,
		260	"Could not get device ID: %s:\n", av_opencl_errstr(status));
		261	av_freep(&device_ids);
		262	continue;
		263	}
		264	for (k = 0; k < devices_num[j]; k++) {
		265	device_num = device_list->platform_node[i]->device_num;
		266	device_list->platform_node[i]->device_node[device_num] = av_mallocz(sizeof(AVOpenCLDeviceNode));
		267	if (!device_list->platform_node[i]->device_node[device_num]) {
		268	ret = AVERROR(ENOMEM);
		269	goto end;
		270	}
		271	device_node = device_list->platform_node[i]->device_node[device_num];
		272	device_node->device_id = device_ids[k];
		273	device_node->device_type = device_type[j];
		274	status = clGetDeviceInfo(device_node->device_id, CL_DEVICE_NAME,
		275	sizeof(device_node->device_name), device_node->device_name,
		276	NULL);
		277	if (status != CL_SUCCESS) {
		278	av_log(&opencl_ctx, AV_LOG_WARNING,
		279	"Could not get device name: %s\n", av_opencl_errstr(status));
		280	continue;
		281	}
		282	device_list->platform_node[i]->device_num++;
		283	}
		284	av_freep(&device_ids);
		285	}
		286	}
		287	}
		288	end:
		289	av_freep(&platform_ids);
		290	av_freep(&devices_num);
		291	av_freep(&device_ids);
		292	if (ret < 0)
		293	free_device_list(device_list);
		294	return ret;
		295	}
		296
		297	int av_opencl_get_device_list(AVOpenCLDeviceList **device_list)
		298	{
		299	int ret = 0;
		300	*device_list = av_mallocz(sizeof(AVOpenCLDeviceList));
		301	if (!(*device_list)) {
		302	av_log(&opencl_ctx, AV_LOG_ERROR, "Could not allocate opencl device list\n");
		303	return AVERROR(ENOMEM);
		304	}
		305	ret = get_device_list(*device_list);
		306	if (ret < 0) {
		307	av_log(&opencl_ctx, AV_LOG_ERROR, "Could not get device list from environment\n");
		308	free_device_list(*device_list);
		309	av_freep(device_list);
		310	return ret;
		311	}
		312	return ret;
		313	}
		314
		315	void av_opencl_free_device_list(AVOpenCLDeviceList **device_list)
		316	{
		317	free_device_list(*device_list);
		318	av_freep(device_list);
		319	}
		320
		321	int av_opencl_set_option(const char key, const char val)
		322	{
		323	int ret = 0;
		324	LOCK_OPENCL;
		325	if (!opencl_ctx.opt_init_flag) {
		326	av_opt_set_defaults(&opencl_ctx);
		327	opencl_ctx.opt_init_flag = 1;
		328	}
		329	ret = av_opt_set(&opencl_ctx, key, val, 0);
		330	UNLOCK_OPENCL;
		331	return ret;
		332	}
		333
		334	int av_opencl_get_option(const char key, uint8_t *out_val)
		335	{
		336	int ret = 0;
		337	LOCK_OPENCL;
		338	ret = av_opt_get(&opencl_ctx, key, 0, out_val);
		339	UNLOCK_OPENCL;
		340	return ret;
		341	}
		342
		343	void av_opencl_free_option(void)
		344	{
		345	/FIXME: free openclutils context/
		346	LOCK_OPENCL;
		347	av_opt_free(&opencl_ctx);
		348	UNLOCK_OPENCL;
		349	}
		350
		351	AVOpenCLExternalEnv *av_opencl_alloc_external_env(void)
		352	{
		353	AVOpenCLExternalEnv *ext = av_mallocz(sizeof(AVOpenCLExternalEnv));
		354	if (!ext) {
		355	av_log(&opencl_ctx, AV_LOG_ERROR,
		356	"Could not malloc external opencl environment data space\n");
		357	}
		358	return ext;
		359	}
		360
		361	void av_opencl_free_external_env(AVOpenCLExternalEnv **ext_opencl_env)
		362	{
		363	av_freep(ext_opencl_env);
		364	}
		365
		366	int av_opencl_register_kernel_code(const char *kernel_code)
		367	{
		368	int i, ret = 0;
		369	LOCK_OPENCL;
		370	if (opencl_ctx.kernel_code_count >= MAX_KERNEL_CODE_NUM) {
		371	av_log(&opencl_ctx, AV_LOG_ERROR,
		372	"Could not register kernel code, maximum number of registered kernel code %d already reached\n",
		373	MAX_KERNEL_CODE_NUM);
		374	ret = AVERROR(EINVAL);
		375	goto end;
		376	}
		377	for (i = 0; i < opencl_ctx.kernel_code_count; i++) {
		378	if (opencl_ctx.kernel_code[i].kernel_string == kernel_code) {
		379	av_log(&opencl_ctx, AV_LOG_WARNING, "Same kernel code has been registered\n");
		380	goto end;
		381	}
		382	}
		383	opencl_ctx.kernel_code[opencl_ctx.kernel_code_count].kernel_string = kernel_code;
		384	opencl_ctx.kernel_code[opencl_ctx.kernel_code_count].is_compiled = 0;
		385	opencl_ctx.kernel_code_count++;
		386	end:
		387	UNLOCK_OPENCL;
		388	return ret;
		389	}
		390
		391	int av_opencl_create_kernel(AVOpenCLKernelEnv env, const char kernel_name)
		392	{
		393	cl_int status;
		394	int i, ret = 0;
		395	LOCK_OPENCL;
		396	if (strlen(kernel_name) + 1 > AV_OPENCL_MAX_KERNEL_NAME_SIZE) {
		397	av_log(&opencl_ctx, AV_LOG_ERROR, "Created kernel name %s is too long\n", kernel_name);
		398	ret = AVERROR(EINVAL);
		399	goto end;
		400	}
		401	if (!env->kernel) {
		402	if (opencl_ctx.kernel_count >= MAX_KERNEL_NUM) {
		403	av_log(&opencl_ctx, AV_LOG_ERROR,
		404	"Could not create kernel with name '%s', maximum number of kernels %d already reached\n",
		405	kernel_name, MAX_KERNEL_NUM);
		406	ret = AVERROR(EINVAL);
		407	goto end;
		408	}
		409	if (opencl_ctx.program_count == 0) {
		410	av_log(&opencl_ctx, AV_LOG_ERROR, "Program count of OpenCL is 0, can not create kernel\n");
		411	ret = AVERROR(EINVAL);
		412	goto end;
		413	}
		414	for (i = 0; i < opencl_ctx.program_count; i++) {
		415	env->kernel = clCreateKernel(opencl_ctx.programs[i], kernel_name, &status);
		416	if (status == CL_SUCCESS)
		417	break;
		418	}
		419	if (status != CL_SUCCESS) {
		420	av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL kernel: %s\n", av_opencl_errstr(status));
		421	ret = AVERROR_EXTERNAL;
		422	goto end;
		423	}
		424	opencl_ctx.kernel_count++;
		425	env->command_queue = opencl_ctx.command_queue;
		426	av_strlcpy(env->kernel_name, kernel_name, sizeof(env->kernel_name));
		427	}
		428	end:
		429	UNLOCK_OPENCL;
		430	return ret;
		431	}
		432
		433	void av_opencl_release_kernel(AVOpenCLKernelEnv *env)
		434	{
		435	cl_int status;
		436	LOCK_OPENCL;
		437	if (!env->kernel)
		438	goto end;
		439	status = clReleaseKernel(env->kernel);
		440	if (status != CL_SUCCESS) {
		441	av_log(&opencl_ctx, AV_LOG_ERROR, "Could not release kernel: %s\n",
		442	av_opencl_errstr(status));
		443	}
		444	env->kernel = NULL;
		445	env->command_queue = NULL;
		446	env->kernel_name[0] = 0;
		447	opencl_ctx.kernel_count--;
		448	end:
		449	UNLOCK_OPENCL;
		450	}
		451
		452	static int init_opencl_env(OpenclContext opencl_ctx, AVOpenCLExternalEnv ext_opencl_env)
		453	{
		454	cl_int status;
		455	cl_context_properties cps[3];
		456	int i, ret = 0;
		457	AVOpenCLDeviceNode *device_node = NULL;
		458
		459	if (ext_opencl_env) {
		460	if (opencl_ctx->is_user_created)
		461	return 0;
		462	opencl_ctx->platform_id = ext_opencl_env->platform_id;
		463	opencl_ctx->is_user_created = 1;
		464	opencl_ctx->command_queue = ext_opencl_env->command_queue;
		465	opencl_ctx->context = ext_opencl_env->context;
		466	opencl_ctx->device_id = ext_opencl_env->device_id;
		467	opencl_ctx->device_type = ext_opencl_env->device_type;
		468	} else {
		469	if (!opencl_ctx->is_user_created) {
		470	if (!opencl_ctx->device_list.platform_num) {
		471	ret = get_device_list(&opencl_ctx->device_list);
		472	if (ret < 0) {
		473	return ret;
		474	}
		475	}
		476	if (opencl_ctx->platform_idx >= 0) {
		477	if (opencl_ctx->device_list.platform_num < opencl_ctx->platform_idx + 1) {
		478	av_log(opencl_ctx, AV_LOG_ERROR, "User set platform index not exist\n");
		479	return AVERROR(EINVAL);
		480	}
		481	if (!opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_num) {
		482	av_log(opencl_ctx, AV_LOG_ERROR, "No devices in user specific platform with index %d\n",
		483	opencl_ctx->platform_idx);
		484	return AVERROR(EINVAL);
		485	}
		486	opencl_ctx->platform_id = opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->platform_id;
		487	} else {
		488	/* get a usable platform by default*/
		489	for (i = 0; i < opencl_ctx->device_list.platform_num; i++) {
		490	if (opencl_ctx->device_list.platform_node[i]->device_num) {
		491	opencl_ctx->platform_id = opencl_ctx->device_list.platform_node[i]->platform_id;
		492	opencl_ctx->platform_idx = i;
		493	break;
		494	}
		495	}
		496	}
		497	if (!opencl_ctx->platform_id) {
		498	av_log(opencl_ctx, AV_LOG_ERROR, "Could not get OpenCL platforms\n");
		499	return AVERROR_EXTERNAL;
		500	}
		501	/* get a usable device*/
		502	if (opencl_ctx->device_idx >= 0) {
		503	if (opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_num < opencl_ctx->device_idx + 1) {
		504	av_log(opencl_ctx, AV_LOG_ERROR,
		505	"Could not get OpenCL device idx %d in the user set platform\n", opencl_ctx->platform_idx);
		506	return AVERROR(EINVAL);
		507	}
		508	} else {
		509	opencl_ctx->device_idx = 0;
		510	}
		511
		512	device_node = opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->device_node[opencl_ctx->device_idx];
		513	opencl_ctx->device_id = device_node->device_id;
		514	opencl_ctx->device_type = device_node->device_type;
		515
		516	/*
		517	* Use available platform.
		518	*/
		519	av_log(opencl_ctx, AV_LOG_VERBOSE, "Platform Name: %s, Device Name: %s\n",
		520	opencl_ctx->device_list.platform_node[opencl_ctx->platform_idx]->platform_name,
		521	device_node->device_name);
		522	cps[0] = CL_CONTEXT_PLATFORM;
		523	cps[1] = (cl_context_properties)opencl_ctx->platform_id;
		524	cps[2] = 0;
		525
		526	opencl_ctx->context = clCreateContextFromType(cps, opencl_ctx->device_type,
		527	NULL, NULL, &status);
		528	if (status != CL_SUCCESS) {
		529	av_log(opencl_ctx, AV_LOG_ERROR,
		530	"Could not get OpenCL context from device type: %s\n", av_opencl_errstr(status));
		531	return AVERROR_EXTERNAL;
		532	}
		533	opencl_ctx->command_queue = clCreateCommandQueue(opencl_ctx->context, opencl_ctx->device_id,
		534	0, &status);
		535	if (status != CL_SUCCESS) {
		536	av_log(opencl_ctx, AV_LOG_ERROR,
		537	"Could not create OpenCL command queue: %s\n", av_opencl_errstr(status));
		538	return AVERROR_EXTERNAL;
		539	}
		540	}
		541	}
		542	return ret;
		543	}
		544
		545	static int compile_kernel_file(OpenclContext *opencl_ctx)
		546	{
		547	cl_int status;
		548	int i, kernel_code_count = 0;
		549	const char *kernel_code[MAX_KERNEL_CODE_NUM] = {NULL};
		550	size_t kernel_code_len[MAX_KERNEL_CODE_NUM] = {0};
		551
		552	for (i = 0; i < opencl_ctx->kernel_code_count; i++) {
		553	if (!opencl_ctx->kernel_code[i].is_compiled) {
		554	kernel_code[kernel_code_count] = opencl_ctx->kernel_code[i].kernel_string;
		555	kernel_code_len[kernel_code_count] = strlen(opencl_ctx->kernel_code[i].kernel_string);
		556	opencl_ctx->kernel_code[i].is_compiled = 1;
		557	kernel_code_count++;
		558	}
		559	}
		560	if (!kernel_code_count)
		561	return 0;
		562	/* create a CL program using the kernel source */
		563	opencl_ctx->programs[opencl_ctx->program_count] = clCreateProgramWithSource(opencl_ctx->context,
		564	kernel_code_count,
		565	kernel_code,
		566	kernel_code_len,
		567	&status);
		568	if(status != CL_SUCCESS) {
		569	av_log(opencl_ctx, AV_LOG_ERROR,
		570	"Could not create OpenCL program with source code: %s\n", av_opencl_errstr(status));
		571	return AVERROR_EXTERNAL;
		572	}
		573	if (!opencl_ctx->programs[opencl_ctx->program_count]) {
		574	av_log(opencl_ctx, AV_LOG_ERROR, "Created program is NULL\n");
		575	return AVERROR_EXTERNAL;
		576	}
		577	status = clBuildProgram(opencl_ctx->programs[opencl_ctx->program_count], 1, &(opencl_ctx->device_id),
		578	opencl_ctx->build_options, NULL, NULL);
		579	if (status != CL_SUCCESS) {
		580	av_log(opencl_ctx, AV_LOG_ERROR,
		581	"Could not compile OpenCL kernel: %s\n", av_opencl_errstr(status));
		582	return AVERROR_EXTERNAL;
		583	}
		584	opencl_ctx->program_count++;
		585	return 0;
		586	}
		587
		588	int av_opencl_init(AVOpenCLExternalEnv *ext_opencl_env)
		589	{
		590	int ret = 0;
		591	LOCK_OPENCL;
		592	if (!opencl_ctx.init_count) {
		593	if (!opencl_ctx.opt_init_flag) {
		594	av_opt_set_defaults(&opencl_ctx);
		595	opencl_ctx.opt_init_flag = 1;
		596	}
		597	ret = init_opencl_env(&opencl_ctx, ext_opencl_env);
		598	if (ret < 0)
		599	goto end;
		600	}
		601	ret = compile_kernel_file(&opencl_ctx);
		602	if (ret < 0)
		603	goto end;
		604	if (opencl_ctx.kernel_code_count <= 0) {
		605	av_log(&opencl_ctx, AV_LOG_ERROR,
		606	"No kernel code is registered, compile kernel file failed\n");
		607	ret = AVERROR(EINVAL);
		608	goto end;
		609	}
		610	opencl_ctx.init_count++;
		611
		612	end:
		613	UNLOCK_OPENCL;
		614	return ret;
		615	}
		616
		617	void av_opencl_uninit(void)
		618	{
		619	cl_int status;
		620	int i;
		621	LOCK_OPENCL;
		622	opencl_ctx.init_count--;
		623	if (opencl_ctx.is_user_created)
		624	goto end;
		625	if (opencl_ctx.init_count > 0 \|\| opencl_ctx.kernel_count > 0)
		626	goto end;
		627	for (i = 0; i < opencl_ctx.program_count; i++) {
		628	if (opencl_ctx.programs[i]) {
		629	status = clReleaseProgram(opencl_ctx.programs[i]);
		630	if (status != CL_SUCCESS) {
		631	av_log(&opencl_ctx, AV_LOG_ERROR,
		632	"Could not release OpenCL program: %s\n", av_opencl_errstr(status));
		633	}
		634	opencl_ctx.programs[i] = NULL;
		635	}
		636	}
		637	if (opencl_ctx.command_queue) {
		638	status = clReleaseCommandQueue(opencl_ctx.command_queue);
		639	if (status != CL_SUCCESS) {
		640	av_log(&opencl_ctx, AV_LOG_ERROR,
		641	"Could not release OpenCL command queue: %s\n", av_opencl_errstr(status));
		642	}
		643	opencl_ctx.command_queue = NULL;
		644	}
		645	if (opencl_ctx.context) {
		646	status = clReleaseContext(opencl_ctx.context);
		647	if (status != CL_SUCCESS) {
		648	av_log(&opencl_ctx, AV_LOG_ERROR,
		649	"Could not release OpenCL context: %s\n", av_opencl_errstr(status));
		650	}
		651	opencl_ctx.context = NULL;
		652	}
		653	free_device_list(&opencl_ctx.device_list);
		654	end:
		655	if ((opencl_ctx.init_count <= 0) && (opencl_ctx.kernel_count <= 0))
		656	av_opt_free(&opencl_ctx); //FIXME: free openclutils context
		657	UNLOCK_OPENCL;
		658	}
		659
		660	int av_opencl_buffer_create(cl_mem cl_buf, size_t cl_buf_size, int flags, void host_ptr)
		661	{
		662	cl_int status;
		663	*cl_buf = clCreateBuffer(opencl_ctx.context, flags, cl_buf_size, host_ptr, &status);
		664	if (status != CL_SUCCESS) {
		665	av_log(&opencl_ctx, AV_LOG_ERROR, "Could not create OpenCL buffer: %s\n", av_opencl_errstr(status));
		666	return AVERROR_EXTERNAL;
		667	}
		668	return 0;
		669	}
		670
		671	void av_opencl_buffer_release(cl_mem *cl_buf)
		672	{
		673	cl_int status = 0;
		674	if (!cl_buf)
		675	return;
		676	status = clReleaseMemObject(*cl_buf);
		677	if (status != CL_SUCCESS) {
		678	av_log(&opencl_ctx, AV_LOG_ERROR,
		679	"Could not release OpenCL buffer: %s\n", av_opencl_errstr(status));
		680	}
		681	memset(cl_buf, 0, sizeof(*cl_buf));
		682	}
		683
		684	int av_opencl_buffer_write(cl_mem dst_cl_buf, uint8_t *src_buf, size_t buf_size)
		685	{
		686	cl_int status;
		687	void *mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, dst_cl_buf,
		688	CL_TRUE, CL_MAP_WRITE, 0, sizeof(uint8_t) * buf_size,
		689	0, NULL, NULL, &status);
		690
		691	if (status != CL_SUCCESS) {
		692	av_log(&opencl_ctx, AV_LOG_ERROR,
		693	"Could not map OpenCL buffer: %s\n", av_opencl_errstr(status));
		694	return AVERROR_EXTERNAL;
		695	}
		696	memcpy(mapped, src_buf, buf_size);
		697
		698	status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
		699	if (status != CL_SUCCESS) {
		700	av_log(&opencl_ctx, AV_LOG_ERROR,
		701	"Could not unmap OpenCL buffer: %s\n", av_opencl_errstr(status));
		702	return AVERROR_EXTERNAL;
		703	}
		704	return 0;
		705	}
		706
		707	int av_opencl_buffer_read(uint8_t *dst_buf, cl_mem src_cl_buf, size_t buf_size)
		708	{
		709	cl_int status;
		710	void *mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, src_cl_buf,
		711	CL_TRUE, CL_MAP_READ, 0, buf_size,
		712	0, NULL, NULL, &status);
		713
		714	if (status != CL_SUCCESS) {
		715	av_log(&opencl_ctx, AV_LOG_ERROR,
		716	"Could not map OpenCL buffer: %s\n", av_opencl_errstr(status));
		717	return AVERROR_EXTERNAL;
		718	}
		719	memcpy(dst_buf, mapped, buf_size);
		720
		721	status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
		722	if (status != CL_SUCCESS) {
		723	av_log(&opencl_ctx, AV_LOG_ERROR,
		724	"Could not unmap OpenCL buffer: %s\n", av_opencl_errstr(status));
		725	return AVERROR_EXTERNAL;
		726	}
		727	return 0;
		728	}
		729
		730	int av_opencl_buffer_write_image(cl_mem dst_cl_buf, size_t cl_buffer_size, int dst_cl_offset,
		731	uint8_t *src_data, int plane_size, int plane_num)
		732	{
		733	int i, buffer_size = 0;
		734	uint8_t *temp;
		735	cl_int status;
		736	void *mapped;
		737	if ((unsigned int)plane_num > 8) {
		738	return AVERROR(EINVAL);
		739	}
		740	for (i = 0;i < plane_num;i++) {
		741	buffer_size += plane_size[i];
		742	}
		743	if (buffer_size > cl_buffer_size) {
		744	av_log(&opencl_ctx, AV_LOG_ERROR,
		745	"Cannot write image to OpenCL buffer: buffer too small\n");
		746	return AVERROR(EINVAL);
		747	}
		748	mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, dst_cl_buf,
		749	CL_TRUE, CL_MAP_WRITE, 0, buffer_size + dst_cl_offset,
		750	0, NULL, NULL, &status);
		751	if (status != CL_SUCCESS) {
		752	av_log(&opencl_ctx, AV_LOG_ERROR,
		753	"Could not map OpenCL buffer: %s\n", av_opencl_errstr(status));
		754	return AVERROR_EXTERNAL;
		755	}
		756	temp = mapped;
		757	temp += dst_cl_offset;
		758	for (i = 0; i < plane_num; i++) {
		759	memcpy(temp, src_data[i], plane_size[i]);
		760	temp += plane_size[i];
		761	}
		762	status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, dst_cl_buf, mapped, 0, NULL, NULL);
		763	if (status != CL_SUCCESS) {
		764	av_log(&opencl_ctx, AV_LOG_ERROR,
		765	"Could not unmap OpenCL buffer: %s\n", av_opencl_errstr(status));
		766	return AVERROR_EXTERNAL;
		767	}
		768	return 0;
		769	}
		770
		771	int av_opencl_buffer_read_image(uint8_t *dst_data, int plane_size, int plane_num,
		772	cl_mem src_cl_buf, size_t cl_buffer_size)
		773	{
		774	int i,buffer_size = 0,ret = 0;
		775	uint8_t *temp;
		776	void *mapped;
		777	cl_int status;
		778	if ((unsigned int)plane_num > 8) {
		779	return AVERROR(EINVAL);
		780	}
		781	for (i = 0; i < plane_num; i++) {
		782	buffer_size += plane_size[i];
		783	}
		784	if (buffer_size > cl_buffer_size) {
		785	av_log(&opencl_ctx, AV_LOG_ERROR,
		786	"Cannot write image to CPU buffer: OpenCL buffer too small\n");
		787	return AVERROR(EINVAL);
		788	}
		789	mapped = clEnqueueMapBuffer(opencl_ctx.command_queue, src_cl_buf,
		790	CL_TRUE, CL_MAP_READ, 0, buffer_size,
		791	0, NULL, NULL, &status);
		792
		793	if (status != CL_SUCCESS) {
		794	av_log(&opencl_ctx, AV_LOG_ERROR,
		795	"Could not map OpenCL buffer: %s\n", av_opencl_errstr(status));
		796	return AVERROR_EXTERNAL;
		797	}
		798	temp = mapped;
		799	if (ret >= 0) {
		800	for (i = 0; i < plane_num; i++) {
		801	memcpy(dst_data[i], temp, plane_size[i]);
		802	temp += plane_size[i];
		803	}
		804	}
		805	status = clEnqueueUnmapMemObject(opencl_ctx.command_queue, src_cl_buf, mapped, 0, NULL, NULL);
		806	if (status != CL_SUCCESS) {
		807	av_log(&opencl_ctx, AV_LOG_ERROR,
		808	"Could not unmap OpenCL buffer: %s\n", av_opencl_errstr(status));
		809	return AVERROR_EXTERNAL;
		810	}
		811	return 0;
		812	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavutil/opencl.c – Rev 4349