git.sesse.net Git - ffmpeg/blob - libavfilter/opencl.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include <stdio.h>
  20 #include <string.h>
  21
  22 #include "libavutil/mem.h"
  23 #include "libavutil/pixdesc.h"
  24
  25 #include "formats.h"
  26 #include "opencl.h"
  27
  28 int ff_opencl_filter_query_formats(AVFilterContext *avctx)
  29 {
  30     const static enum AVPixelFormat pix_fmts[] = {
  31         AV_PIX_FMT_OPENCL,
  32         AV_PIX_FMT_NONE,
  33     };
  34     AVFilterFormats *formats;
  35
  36     formats = ff_make_format_list(pix_fmts);
  37     if (!formats)
  38         return AVERROR(ENOMEM);
  39
  40     return ff_set_common_formats(avctx, formats);
  41 }
  42
  43 static int opencl_filter_set_device(AVFilterContext *avctx,
  44                                     AVBufferRef *device)
  45 {
  46     OpenCLFilterContext *ctx = avctx->priv;
  47
  48     av_buffer_unref(&ctx->device_ref);
  49
  50     ctx->device_ref = av_buffer_ref(device);
  51     if (!ctx->device_ref)
  52         return AVERROR(ENOMEM);
  53
  54     ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
  55     ctx->hwctx  = ctx->device->hwctx;
  56
  57     return 0;
  58 }
  59
  60 int ff_opencl_filter_config_input(AVFilterLink *inlink)
  61 {
  62     AVFilterContext   *avctx = inlink->dst;
  63     OpenCLFilterContext *ctx = avctx->priv;
  64     AVHWFramesContext *input_frames;
  65     int err;
  66
  67     if (!inlink->hw_frames_ctx) {
  68         av_log(avctx, AV_LOG_ERROR, "OpenCL filtering requires a "
  69                "hardware frames context on the input.\n");
  70         return AVERROR(EINVAL);
  71     }
  72
  73     // Extract the device and default output format from the first input.
  74     if (avctx->inputs[0] != inlink)
  75         return 0;
  76
  77     input_frames = (AVHWFramesContext*)inlink->hw_frames_ctx->data;
  78     if (input_frames->format != AV_PIX_FMT_OPENCL)
  79         return AVERROR(EINVAL);
  80
  81     err = opencl_filter_set_device(avctx, input_frames->device_ref);
  82     if (err < 0)
  83         return err;
  84
  85     // Default output parameters match input parameters.
  86     if (ctx->output_format == AV_PIX_FMT_NONE)
  87         ctx->output_format = input_frames->sw_format;
  88     if (!ctx->output_width)
  89         ctx->output_width  = inlink->w;
  90     if (!ctx->output_height)
  91         ctx->output_height = inlink->h;
  92
  93     return 0;
  94 }
  95
  96 int ff_opencl_filter_config_output(AVFilterLink *outlink)
  97 {
  98     AVFilterContext   *avctx = outlink->src;
  99     OpenCLFilterContext *ctx = avctx->priv;
 100     AVBufferRef       *output_frames_ref = NULL;
 101     AVHWFramesContext *output_frames;
 102     int err;
 103
 104     av_buffer_unref(&outlink->hw_frames_ctx);
 105
 106     if (!ctx->device_ref) {
 107         if (!avctx->hw_device_ctx) {
 108             av_log(avctx, AV_LOG_ERROR, "OpenCL filtering requires an "
 109                    "OpenCL device.\n");
 110             return AVERROR(EINVAL);
 111         }
 112
 113         err = opencl_filter_set_device(avctx, avctx->hw_device_ctx);
 114         if (err < 0)
 115             return err;
 116     }
 117
 118     output_frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
 119     if (!output_frames_ref) {
 120         err = AVERROR(ENOMEM);
 121         goto fail;
 122     }
 123     output_frames = (AVHWFramesContext*)output_frames_ref->data;
 124
 125     output_frames->format    = AV_PIX_FMT_OPENCL;
 126     output_frames->sw_format = ctx->output_format;
 127     output_frames->width     = ctx->output_width;
 128     output_frames->height    = ctx->output_height;
 129
 130     err = av_hwframe_ctx_init(output_frames_ref);
 131     if (err < 0) {
 132         av_log(avctx, AV_LOG_ERROR, "Failed to initialise output "
 133                "frames: %d.\n", err);
 134         goto fail;
 135     }
 136
 137     outlink->hw_frames_ctx = output_frames_ref;
 138     outlink->w = ctx->output_width;
 139     outlink->h = ctx->output_height;
 140
 141     return 0;
 142 fail:
 143     av_buffer_unref(&output_frames_ref);
 144     return err;
 145 }
 146
 147 int ff_opencl_filter_init(AVFilterContext *avctx)
 148 {
 149     OpenCLFilterContext *ctx = avctx->priv;
 150
 151     ctx->output_format = AV_PIX_FMT_NONE;
 152
 153     return 0;
 154 }
 155
 156 void ff_opencl_filter_uninit(AVFilterContext *avctx)
 157 {
 158     OpenCLFilterContext *ctx = avctx->priv;
 159     cl_int cle;
 160
 161     if (ctx->program) {
 162         cle = clReleaseProgram(ctx->program);
 163         if (cle != CL_SUCCESS)
 164             av_log(avctx, AV_LOG_ERROR, "Failed to release "
 165                    "program: %d.\n", cle);
 166     }
 167
 168     av_buffer_unref(&ctx->device_ref);
 169 }
 170
 171 int ff_opencl_filter_load_program(AVFilterContext *avctx,
 172                                   const char **program_source_array,
 173                                   int nb_strings)
 174 {
 175     OpenCLFilterContext *ctx = avctx->priv;
 176     cl_int cle;
 177
 178     ctx->program = clCreateProgramWithSource(ctx->hwctx->context, nb_strings,
 179                                              program_source_array,
 180                                              NULL, &cle);
 181     if (!ctx->program) {
 182         av_log(avctx, AV_LOG_ERROR, "Failed to create program: %d.\n", cle);
 183         return AVERROR(EIO);
 184     }
 185
 186     cle = clBuildProgram(ctx->program, 1, &ctx->hwctx->device_id,
 187                          NULL, NULL, NULL);
 188     if (cle != CL_SUCCESS) {
 189         av_log(avctx, AV_LOG_ERROR, "Failed to build program: %d.\n", cle);
 190
 191         if (cle == CL_BUILD_PROGRAM_FAILURE) {
 192             char *log;
 193             size_t log_length;
 194
 195             clGetProgramBuildInfo(ctx->program, ctx->hwctx->device_id,
 196                                   CL_PROGRAM_BUILD_LOG, 0, NULL, &log_length);
 197
 198             log = av_malloc(log_length);
 199             if (log) {
 200                 cle = clGetProgramBuildInfo(ctx->program,
 201                                             ctx->hwctx->device_id,
 202                                             CL_PROGRAM_BUILD_LOG,
 203                                             log_length, log, NULL);
 204                 if (cle == CL_SUCCESS)
 205                     av_log(avctx, AV_LOG_ERROR, "Build log:\n%s\n", log);
 206             }
 207
 208             av_free(log);
 209         }
 210
 211         clReleaseProgram(ctx->program);
 212         ctx->program = NULL;
 213         return AVERROR(EIO);
 214     }
 215
 216     return 0;
 217 }
 218
 219 int ff_opencl_filter_load_program_from_file(AVFilterContext *avctx,
 220                                             const char *filename)
 221 {
 222     FILE *file;
 223     char *src = NULL;
 224     size_t pos, len, rb;
 225     const char *src_const;
 226     int err;
 227
 228     file = av_fopen_utf8(filename, "r");
 229     if (!file) {
 230         av_log(avctx, AV_LOG_ERROR, "Unable to open program "
 231                "source file \"%s\".\n", filename);
 232         return AVERROR(ENOENT);
 233     }
 234
 235     len = 1 << 16;
 236     pos = 0;
 237
 238     err = av_reallocp(&src, len);
 239     if (err < 0)
 240         goto fail;
 241
 242     err = snprintf(src, len, "#line 1 \"%s\"\n", filename);
 243     if (err < 0) {
 244         err = AVERROR(errno);
 245         goto fail;
 246     }
 247     if (err > len / 2) {
 248         err = AVERROR(EINVAL);
 249         goto fail;
 250     }
 251     pos = err;
 252
 253     while (1) {
 254         rb = fread(src + pos, 1, len - pos - 1, file);
 255         if (rb == 0 && ferror(file)) {
 256             err = AVERROR(EIO);
 257             goto fail;
 258         }
 259         pos += rb;
 260         if (pos < len)
 261             break;
 262         len <<= 1;
 263         err = av_reallocp(&src, len);
 264         if (err < 0)
 265             goto fail;
 266     }
 267     src[pos] = 0;
 268
 269     src_const = src;
 270
 271     err = ff_opencl_filter_load_program(avctx, &src_const, 1);
 272 fail:
 273     fclose(file);
 274     av_freep(&src);
 275     return err;
 276 }
 277
 278 int ff_opencl_filter_work_size_from_image(AVFilterContext *avctx,
 279                                           size_t *work_size,
 280                                           AVFrame *frame, int plane,
 281                                           int block_alignment)
 282 {
 283     cl_mem image;
 284     cl_mem_object_type type;
 285     size_t width, height;
 286     cl_int cle;
 287
 288     if (frame->format != AV_PIX_FMT_OPENCL) {
 289         av_log(avctx, AV_LOG_ERROR, "Invalid frame format %s, "
 290                "opencl required.\n", av_get_pix_fmt_name(frame->format));
 291         return AVERROR(EINVAL);
 292     }
 293
 294     image = (cl_mem)frame->data[plane];
 295     if (!image) {
 296         av_log(avctx, AV_LOG_ERROR, "Plane %d required but not set.\n",
 297                plane);
 298         return AVERROR(EINVAL);
 299     }
 300
 301     cle = clGetMemObjectInfo(image, CL_MEM_TYPE, sizeof(type),
 302                              &type, NULL);
 303     if (cle != CL_SUCCESS) {
 304         av_log(avctx, AV_LOG_ERROR, "Failed to query object type of "
 305                "plane %d: %d.\n", plane, cle);
 306         return AVERROR_UNKNOWN;
 307     }
 308     if (type != CL_MEM_OBJECT_IMAGE2D) {
 309         av_log(avctx, AV_LOG_ERROR, "Plane %d is not a 2D image.\n",
 310                plane);
 311         return AVERROR(EINVAL);
 312     }
 313
 314     cle = clGetImageInfo(image, CL_IMAGE_WIDTH,  sizeof(size_t),
 315                          &width, NULL);
 316     if (cle != CL_SUCCESS) {
 317         av_log(avctx, AV_LOG_ERROR, "Failed to query plane %d width: %d.\n",
 318                plane, cle);
 319         return AVERROR_UNKNOWN;
 320     }
 321
 322     cle = clGetImageInfo(image, CL_IMAGE_HEIGHT, sizeof(size_t),
 323                          &height, NULL);
 324     if (cle != CL_SUCCESS) {
 325         av_log(avctx, AV_LOG_ERROR, "Failed to query plane %d height: %d.\n",
 326                plane, cle);
 327         return AVERROR_UNKNOWN;
 328     }
 329
 330     if (block_alignment) {
 331         width  = FFALIGN(width,  block_alignment);
 332         height = FFALIGN(height, block_alignment);
 333     }
 334
 335     work_size[0] = width;
 336     work_size[1] = height;
 337
 338     return 0;
 339 }
 340
 341 void ff_opencl_print_const_matrix_3x3(AVBPrint *buf, const char *name_str,
 342                                       double mat[3][3])
 343 {
 344     int i, j;
 345     av_bprintf(buf, "__constant float %s[9] = {\n", name_str);
 346     for (i = 0; i < 3; i++) {
 347         for (j = 0; j < 3; j++)
 348             av_bprintf(buf, " %.5ff,", mat[i][j]);
 349         av_bprintf(buf, "\n");
 350     }
 351     av_bprintf(buf, "};\n");
 352 }
 353
 354 cl_ulong ff_opencl_get_event_time(cl_event event) {
 355     cl_ulong time_start;
 356     cl_ulong time_end;
 357
 358     clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
 359     clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);
 360
 361     return time_end - time_start;
 362 }