RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-25 00:32:31 +00:00
Code Issues Projects Releases Wiki Activity
0728d64497
ffmpeg/libavfilter/opencl.c

363 lines
10 KiB
C
Raw Blame History

/*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdio.h>
#include <string.h>
#include "libavutil/mem.h"
#include "libavutil/pixdesc.h"
#include "formats.h"
#include "opencl.h"
int ff_opencl_filter_query_formats(AVFilterContext *avctx)
{
const static enum AVPixelFormat pix_fmts[] = {
AV_PIX_FMT_OPENCL,
AV_PIX_FMT_NONE,
};
AVFilterFormats *formats;
formats = ff_make_format_list(pix_fmts);
if (!formats)
return AVERROR(ENOMEM);
return ff_set_common_formats(avctx, formats);
}
static int opencl_filter_set_device(AVFilterContext *avctx,
AVBufferRef *device)
{
OpenCLFilterContext *ctx = avctx->priv;
av_buffer_unref(&ctx->device_ref);
ctx->device_ref = av_buffer_ref(device);
if (!ctx->device_ref)
return AVERROR(ENOMEM);
ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
ctx->hwctx = ctx->device->hwctx;
return 0;
}
int ff_opencl_filter_config_input(AVFilterLink *inlink)
{
AVFilterContext *avctx = inlink->dst;
OpenCLFilterContext *ctx = avctx->priv;
AVHWFramesContext *input_frames;
int err;
if (!inlink->hw_frames_ctx) {
av_log(avctx, AV_LOG_ERROR, "OpenCL filtering requires a "
"hardware frames context on the input.\n");
return AVERROR(EINVAL);
}
// Extract the device and default output format from the first input.
if (avctx->inputs[0] != inlink)
return 0;
input_frames = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
if (input_frames->format != AV_PIX_FMT_OPENCL)
return AVERROR(EINVAL);
err = opencl_filter_set_device(avctx, input_frames->device_ref);
if (err < 0)
return err;
// Default output parameters match input parameters.
if (ctx->output_format == AV_PIX_FMT_NONE)
ctx->output_format = input_frames->sw_format;
if (!ctx->output_width)
ctx->output_width = inlink->w;
if (!ctx->output_height)
ctx->output_height = inlink->h;
return 0;
}
int ff_opencl_filter_config_output(AVFilterLink *outlink)
{
AVFilterContext *avctx = outlink->src;
OpenCLFilterContext *ctx = avctx->priv;
AVBufferRef *output_frames_ref = NULL;
AVHWFramesContext *output_frames;
int err;
av_buffer_unref(&outlink->hw_frames_ctx);
if (!ctx->device_ref) {
if (!avctx->hw_device_ctx) {
av_log(avctx, AV_LOG_ERROR, "OpenCL filtering requires an "
"OpenCL device.\n");
return AVERROR(EINVAL);
}
err = opencl_filter_set_device(avctx, avctx->hw_device_ctx);
if (err < 0)
return err;
}
output_frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
if (!output_frames_ref) {
err = AVERROR(ENOMEM);
goto fail;
}
output_frames = (AVHWFramesContext*)output_frames_ref->data;
output_frames->format = AV_PIX_FMT_OPENCL;
output_frames->sw_format = ctx->output_format;
output_frames->width = ctx->output_width;
output_frames->height = ctx->output_height;
err = av_hwframe_ctx_init(output_frames_ref);
if (err < 0) {
av_log(avctx, AV_LOG_ERROR, "Failed to initialise output "
"frames: %d.\n", err);
goto fail;
}
outlink->hw_frames_ctx = output_frames_ref;
outlink->w = ctx->output_width;
outlink->h = ctx->output_height;
return 0;
fail:
av_buffer_unref(&output_frames_ref);
return err;
}
int ff_opencl_filter_init(AVFilterContext *avctx)
{
OpenCLFilterContext *ctx = avctx->priv;
ctx->output_format = AV_PIX_FMT_NONE;
return 0;
}
void ff_opencl_filter_uninit(AVFilterContext *avctx)
{
OpenCLFilterContext *ctx = avctx->priv;
cl_int cle;
if (ctx->program) {
cle = clReleaseProgram(ctx->program);
if (cle != CL_SUCCESS)
av_log(avctx, AV_LOG_ERROR, "Failed to release "
"program: %d.\n", cle);
}
av_buffer_unref(&ctx->device_ref);
}
int ff_opencl_filter_load_program(AVFilterContext *avctx,
const char **program_source_array,
int nb_strings)
{
OpenCLFilterContext *ctx = avctx->priv;
cl_int cle;
ctx->program = clCreateProgramWithSource(ctx->hwctx->context, nb_strings,
program_source_array,
NULL, &cle);
if (!ctx->program) {
av_log(avctx, AV_LOG_ERROR, "Failed to create program: %d.\n", cle);
return AVERROR(EIO);
}
cle = clBuildProgram(ctx->program, 1, &ctx->hwctx->device_id,
NULL, NULL, NULL);
if (cle != CL_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to build program: %d.\n", cle);
if (cle == CL_BUILD_PROGRAM_FAILURE) {
char *log;
size_t log_length;
clGetProgramBuildInfo(ctx->program, ctx->hwctx->device_id,
CL_PROGRAM_BUILD_LOG, 0, NULL, &log_length);
log = av_malloc(log_length);
if (log) {
cle = clGetProgramBuildInfo(ctx->program,
ctx->hwctx->device_id,
CL_PROGRAM_BUILD_LOG,
log_length, log, NULL);
if (cle == CL_SUCCESS)
av_log(avctx, AV_LOG_ERROR, "Build log:\n%s\n", log);
}
av_free(log);
}
clReleaseProgram(ctx->program);
ctx->program = NULL;
return AVERROR(EIO);
}
return 0;
}
int ff_opencl_filter_load_program_from_file(AVFilterContext *avctx,
const char *filename)
{
FILE *file;
char *src = NULL;
size_t pos, len, rb;
const char *src_const;
int err;
file = fopen(filename, "r");
if (!file) {
av_log(avctx, AV_LOG_ERROR, "Unable to open program "
"source file \"%s\".\n", filename);
return AVERROR(ENOENT);
}
len = 1 << 16;
pos = 0;
err = av_reallocp(&src, len);
if (err < 0)
goto fail;
err = snprintf(src, len, "#line 1 \"%s\"\n", filename);
if (err < 0) {
err = AVERROR(errno);
goto fail;
}
if (err > len / 2) {
err = AVERROR(EINVAL);
goto fail;
}
pos = err;
while (1) {
rb = fread(src + pos, 1, len - pos - 1, file);
if (rb == 0 && ferror(file)) {
err = AVERROR(EIO);
goto fail;
}
pos += rb;
if (pos < len)
break;
len <<= 1;
err = av_reallocp(&src, len);
if (err < 0)
goto fail;
}
src[pos] = 0;
src_const = src;
err = ff_opencl_filter_load_program(avctx, &src_const, 1);
fail:
fclose(file);
av_freep(&src);
return err;
}
int ff_opencl_filter_work_size_from_image(AVFilterContext *avctx,
size_t *work_size,
AVFrame *frame, int plane,
int block_alignment)
{
cl_mem image;
cl_mem_object_type type;
size_t width, height;
cl_int cle;
if (frame->format != AV_PIX_FMT_OPENCL) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame format %s, "
"opencl required.\n", av_get_pix_fmt_name(frame->format));
return AVERROR(EINVAL);
}
image = (cl_mem)frame->data[plane];
if (!image) {
av_log(avctx, AV_LOG_ERROR, "Plane %d required but not set.\n",
plane);
return AVERROR(EINVAL);
}
cle = clGetMemObjectInfo(image, CL_MEM_TYPE, sizeof(type),
&type, NULL);
if (cle != CL_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to query object type of "
"plane %d: %d.\n", plane, cle);
return AVERROR_UNKNOWN;
}
if (type != CL_MEM_OBJECT_IMAGE2D) {
av_log(avctx, AV_LOG_ERROR, "Plane %d is not a 2D image.\n",
plane);
return AVERROR(EINVAL);
}
cle = clGetImageInfo(image, CL_IMAGE_WIDTH, sizeof(size_t),
&width, NULL);
if (cle != CL_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to query plane %d width: %d.\n",
plane, cle);
return AVERROR_UNKNOWN;
}
cle = clGetImageInfo(image, CL_IMAGE_HEIGHT, sizeof(size_t),
&height, NULL);
if (cle != CL_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to query plane %d height: %d.\n",
plane, cle);
return AVERROR_UNKNOWN;
}
if (block_alignment) {
width = FFALIGN(width, block_alignment);
height = FFALIGN(height, block_alignment);
}
work_size[0] = width;
work_size[1] = height;
return 0;
}
void ff_opencl_print_const_matrix_3x3(AVBPrint *buf, const char *name_str,
double mat[3][3])
{
int i, j;
av_bprintf(buf, "__constant float %s[9] = {\n", name_str);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++)
av_bprintf(buf, " %.5ff,", mat[i][j]);
av_bprintf(buf, "\n");
}
av_bprintf(buf, "};\n");
}
cl_ulong ff_opencl_get_event_time(cl_event event) {
cl_ulong time_start;
cl_ulong time_end;
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);
return time_end - time_start;
}
Reference in New Issue View Git Blame Copy Permalink