@@ -3209,7 +3209,6 @@ deinterlace_qsv_filter_deps="libmfx"

 deinterlace_vaapi_filter_deps="vaapi"

 delogo_filter_deps="gpl"

 deshake_filter_select="pixelutils"

-deshake_filter_suggest="opencl"

 drawtext_filter_deps="libfreetype"

 drawtext_filter_suggest="libfontconfig libfribidi"

 elbg_filter_deps="avcodec"

@@ -3285,7 +3284,6 @@ tinterlace_pad_test_deps="tinterlace_filter"

 tonemap_filter_deps="const_nan"

 unsharp_opencl_filter_deps="opencl"

 uspp_filter_deps="gpl avcodec"

-unsharp_filter_suggest="opencl"

 vaguedenoiser_filter_deps="gpl"

 vidstabdetect_filter_deps="libvidstab"

 vidstabtransform_filter_deps="libvidstab"

@@ -15,6 +15,9 @@ libavutil:     2017-10-21

 API changes, most recent first:

+2017-11-xx - xxxxxxx - lavu 55.3.0 - opencl.h

+  Remove experiental OpenCL API (av_opencl_*).

+

 2017-11-xx - xxxxxxx - lavu 55.2.0 - hwcontext.h hwcontext_opencl.h

   Add AV_HWDEVICE_TYPE_OPENCL and a new installed header with

   OpenCL-specific hwcontext definitions.

@@ -6913,10 +6913,6 @@ Default value is @samp{exhaustive}.

 If set then a detailed log of the motion search is written to the

 specified file.

-@item opencl

-If set to 1, specify using OpenCL capabilities, only available if

-FFmpeg was configured with @code{--enable-opencl}. Default value is 0.

-

 @end table

 @section despill

@@ -15048,10 +15044,6 @@ sharpen it, a value of zero will disable the effect.

 Default value is 0.0.

-@item opencl

-If set to 1, specify using OpenCL capabilities, only available if

-FFmpeg was configured with @code{--enable-opencl}. Default value is 0.

-

 @end table

 All parameters are optional and default to the equivalent of the

@@ -1057,33 +1057,3 @@ indication of the corresponding powers of 10 and of 2.

 @end table

 @c man end EXPRESSION EVALUATION

-

-@chapter OpenCL Options

-@c man begin OPENCL OPTIONS

-

-When FFmpeg is configured with @code{--enable-opencl}, it is possible

-to set the options for the global OpenCL context.

-

-The list of supported options follows:

-

-@table @option

-@item build_options

-Set build options used to compile the registered kernels.

-

-See reference "OpenCL Specification Version: 1.2 chapter 5.6.4".

-

-@item platform_idx

-Select the index of the platform to run OpenCL code.

-

-The specified index must be one of the indexes in the device list

-which can be obtained with @code{ffmpeg -opencl_bench} or @code{av_opencl_get_device_list()}.

-

-@item device_idx

-Select the index of the device used to run OpenCL code.

-

-The specified index must be one of the indexes in the device list which

-can be obtained with @code{ffmpeg -opencl_bench} or @code{av_opencl_get_device_list()}.

-

-@end table

-

-@c man end OPENCL OPTIONS

@@ -29,7 +29,6 @@ $(1)$(PROGSSUF)_g$(EXESUF): FF_EXTRALIBS += $(EXTRALIBS-$(1))

 -include $$(OBJS-$(1):.o=.d)

 endef

-$(foreach P,$(AVPROGS-yes),$(eval OBJS-$(P)-$(CONFIG_OPENCL) += fftools/cmdutils_opencl.o))

 $(foreach P,$(AVPROGS-yes),$(eval $(call DOFFTOOL,$(P))))

 all: $(AVPROGS)

@@ -105,12 +105,6 @@ int opt_max_alloc(void *optctx, const char *opt, const char *arg);

 int opt_codec_debug(void *optctx, const char *opt, const char *arg);

-#if CONFIG_OPENCL

-int opt_opencl(void *optctx, const char *opt, const char *arg);

-

-int opt_opencl_bench(void *optctx, const char *opt, const char *arg);

-#endif

-

 /**

  * Limit the execution time.

  */

@@ -207,17 +201,6 @@ typedef struct OptionDef {

 void show_help_options(const OptionDef *options, const char *msg, int req_flags,

                        int rej_flags, int alt_flags);

-#if CONFIG_OPENCL

-#define CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                  \

-    { "opencl_bench", OPT_EXIT, {.func_arg = opt_opencl_bench},                                                         \

-       "run benchmark on all OpenCL devices and show results" },                                                        \

-    { "opencl_options", HAS_ARG, {.func_arg = opt_opencl},                                                              \

-       "set OpenCL environment options" },                                                                              \

-

-#else

-#define CMDUTILS_COMMON_OPTIONS_OPENCL

-#endif

-

 #if CONFIG_AVDEVICE

 #define CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                \

     { "sources"    , OPT_EXIT | HAS_ARG, { .func_arg = show_sources },                                                  \

@@ -257,7 +240,6 @@ void show_help_options(const OptionDef *options, const char *msg, int req_flags,

     { "max_alloc",   HAS_ARG,              { .func_arg = opt_max_alloc },    "set maximum size of a single allocated block", "bytes" }, \

     { "cpuflags",    HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },     "force specific cpu flags", "flags" },     \

     { "hide_banner", OPT_BOOL | OPT_EXPERT, {&hide_banner},     "do not show program banner", "hide_banner" },          \

-    CMDUTILS_COMMON_OPTIONS_OPENCL                                                                                      \

     CMDUTILS_COMMON_OPTIONS_AVDEVICE                                                                                    \

 /**

deleted file mode 100644

@@ -1,283 +0,0 @@

-/*

- * Copyright (C) 2013 Lenny Wang

- *

- * 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 "libavutil/opt.h"

-#include "libavutil/time.h"

-#include "libavutil/log.h"

-#include "libavutil/opencl.h"

-#include "libavutil/avstring.h"

-#include "cmdutils.h"

-

-typedef struct {

-    int platform_idx;

-    int device_idx;

-    char device_name[64];

-    int64_t runtime;

-} OpenCLDeviceBenchmark;

-

-const char *ocl_bench_source = AV_OPENCL_KERNEL(

-inline unsigned char clip_uint8(int a)

-{

-    if (a & (~0xFF))

-        return (-a)>>31;

-    else

-        return a;

-}

-

-kernel void unsharp_bench(

-                    global unsigned char *src,

-                    global unsigned char *dst,

-                    global int *mask,

-                    int width,

-                    int height)

-{

-    int i, j, local_idx, lc_idx, sum = 0;

-    int2 thread_idx, block_idx, global_idx, lm_idx;

-    thread_idx.x = get_local_id(0);

-    thread_idx.y = get_local_id(1);

-    block_idx.x = get_group_id(0);

-    block_idx.y = get_group_id(1);

-    global_idx.x = get_global_id(0);

-    global_idx.y = get_global_id(1);

-    local uchar data[32][32];

-    local int lc[128];

-

-    for (i = 0; i <= 1; i++) {

-        lm_idx.y = -8 + (block_idx.y + i) * 16 + thread_idx.y;

-        lm_idx.y = lm_idx.y < 0 ? 0 : lm_idx.y;

-        lm_idx.y = lm_idx.y >= height ? height - 1: lm_idx.y;

-        for (j = 0; j <= 1; j++) {

-            lm_idx.x = -8 + (block_idx.x + j) * 16 + thread_idx.x;

-            lm_idx.x = lm_idx.x < 0 ? 0 : lm_idx.x;

-            lm_idx.x = lm_idx.x >= width ? width - 1: lm_idx.x;

-            data[i*16 + thread_idx.y][j*16 + thread_idx.x] = src[lm_idx.y*width + lm_idx.x];

-        }

-    }

-    local_idx = thread_idx.y*16 + thread_idx.x;

-    if (local_idx < 128)

-        lc[local_idx] = mask[local_idx];

-    barrier(CLK_LOCAL_MEM_FENCE);

-

-    \n#pragma unroll\n

-    for (i = -4; i <= 4; i++) {

-        lm_idx.y = 8 + i + thread_idx.y;

-        \n#pragma unroll\n

-        for (j = -4; j <= 4; j++) {

-            lm_idx.x = 8 + j + thread_idx.x;

-            lc_idx = (i + 4)*8 + j + 4;

-            sum += (int)data[lm_idx.y][lm_idx.x] * lc[lc_idx];

-        }

-    }

-    int temp = (int)data[thread_idx.y + 8][thread_idx.x + 8];

-    int res = temp + (((temp - (int)((sum + 1<<15) >> 16))) >> 16);

-    if (global_idx.x < width && global_idx.y < height)

-        dst[global_idx.x + global_idx.y*width] = clip_uint8(res);

-}

-);

-

-#define OCLCHECK(method, ... )                                                 \

-do {                                                                           \

-    status = method(__VA_ARGS__);                                              \

-    if (status != CL_SUCCESS) {                                                \

-        av_log(NULL, AV_LOG_ERROR, # method " error '%s'\n",                   \

-               av_opencl_errstr(status));                                      \

-        ret = AVERROR_EXTERNAL;                                                \

-        goto end;                                                              \

-    }                                                                          \

-} while (0)

-

-#define CREATEBUF(out, flags, size)                                            \

-do {                                                                           \

-    out = clCreateBuffer(ext_opencl_env->context, flags, size, NULL, &status); \

-    if (status != CL_SUCCESS) {                                                \

-        av_log(NULL, AV_LOG_ERROR, "Could not create OpenCL buffer\n");        \

-        ret = AVERROR_EXTERNAL;                                                \

-        goto end;                                                              \

-    }                                                                          \

-} while (0)

-

-static void fill_rand_int(int *data, int n)

-{

-    int i;

-    srand(av_gettime());

-    for (i = 0; i < n; i++)

-        data[i] = rand();

-}

-

-#define OPENCL_NB_ITER 5

-static int64_t run_opencl_bench(AVOpenCLExternalEnv *ext_opencl_env)

-{

-    int i, arg = 0, width = 1920, height = 1088;

-    int64_t start, ret = 0;

-    cl_int status;

-    size_t kernel_len;

-    char *inbuf;

-    int *mask = NULL;

-    int buf_size = width * height * sizeof(char);

-    int mask_size = sizeof(uint32_t) * 128;

-

-    cl_mem cl_mask = NULL, cl_inbuf = NULL, cl_outbuf = NULL;

-    cl_kernel kernel = NULL;

-    cl_program program = NULL;

-    size_t local_work_size_2d[2] = {16, 16};

-    size_t global_work_size_2d[2] = {(size_t)width, (size_t)height};

-

-    if (!(inbuf = av_malloc(buf_size)) || !(mask = av_malloc(mask_size))) {

-        av_log(NULL, AV_LOG_ERROR, "Out of memory\n");

-        ret = AVERROR(ENOMEM);

-        goto end;

-    }

-    fill_rand_int((int*)inbuf, buf_size/4);

-    fill_rand_int(mask, mask_size/4);

-

-    CREATEBUF(cl_mask, CL_MEM_READ_ONLY, mask_size);

-    CREATEBUF(cl_inbuf, CL_MEM_READ_ONLY, buf_size);

-    CREATEBUF(cl_outbuf, CL_MEM_READ_WRITE, buf_size);

-

-    kernel_len = strlen(ocl_bench_source);

-    program = clCreateProgramWithSource(ext_opencl_env->context, 1, &ocl_bench_source,

-                                        &kernel_len, &status);

-    if (status != CL_SUCCESS || !program) {

-        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to create benchmark program\n");

-        ret = AVERROR_EXTERNAL;

-        goto end;

-    }

-    status = clBuildProgram(program, 1, &(ext_opencl_env->device_id), NULL, NULL, NULL);

-    if (status != CL_SUCCESS) {

-        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to build benchmark program\n");

-        ret = AVERROR_EXTERNAL;

-        goto end;

-    }

-    kernel = clCreateKernel(program, "unsharp_bench", &status);

-    if (status != CL_SUCCESS) {

-        av_log(NULL, AV_LOG_ERROR, "OpenCL unable to create benchmark kernel\n");

-        ret = AVERROR_EXTERNAL;

-        goto end;

-    }

-

-    OCLCHECK(clEnqueueWriteBuffer, ext_opencl_env->command_queue, cl_inbuf, CL_TRUE, 0,

-             buf_size, inbuf, 0, NULL, NULL);

-    OCLCHECK(clEnqueueWriteBuffer, ext_opencl_env->command_queue, cl_mask, CL_TRUE, 0,

-             mask_size, mask, 0, NULL, NULL);

-    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_inbuf);

-    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_outbuf);

-    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_mem), &cl_mask);

-    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_int), &width);

-    OCLCHECK(clSetKernelArg, kernel, arg++, sizeof(cl_int), &height);

-

-    start = av_gettime_relative();

-    for (i = 0; i < OPENCL_NB_ITER; i++)

-        OCLCHECK(clEnqueueNDRangeKernel, ext_opencl_env->command_queue, kernel, 2, NULL,

-                 global_work_size_2d, local_work_size_2d, 0, NULL, NULL);

-    clFinish(ext_opencl_env->command_queue);

-    ret = (av_gettime_relative() - start)/OPENCL_NB_ITER;

-end:

-    if (kernel)

-        clReleaseKernel(kernel);

-    if (program)

-        clReleaseProgram(program);

-    if (cl_inbuf)

-        clReleaseMemObject(cl_inbuf);

-    if (cl_outbuf)

-        clReleaseMemObject(cl_outbuf);

-    if (cl_mask)

-        clReleaseMemObject(cl_mask);

-    av_free(inbuf);

-    av_free(mask);

-    return ret;

-}

-

-static int compare_ocl_device_desc(const void *a, const void *b)

-{

-    const OpenCLDeviceBenchmark* va = (const OpenCLDeviceBenchmark*)a;

-    const OpenCLDeviceBenchmark* vb = (const OpenCLDeviceBenchmark*)b;

-    return FFDIFFSIGN(va->runtime , vb->runtime);

-}

-

-int opt_opencl_bench(void *optctx, const char *opt, const char *arg)

-{

-    int i, j, nb_devices = 0, count = 0, ret = 0;

-    int64_t score = 0;

-    AVOpenCLDeviceList *device_list;

-    AVOpenCLDeviceNode *device_node = NULL;

-    OpenCLDeviceBenchmark *devices = NULL;

-    cl_platform_id platform;

-

-    ret = av_opencl_get_device_list(&device_list);

-    if (ret < 0) {

-        return ret;

-    }

-    for (i = 0; i < device_list->platform_num; i++)

-        nb_devices += device_list->platform_node[i]->device_num;

-    if (!nb_devices) {

-        av_log(NULL, AV_LOG_ERROR, "No OpenCL device detected!\n");

-        av_opencl_free_device_list(&device_list);

-        return AVERROR(EINVAL);

-    }

-    if (!(devices = av_malloc_array(nb_devices, sizeof(OpenCLDeviceBenchmark)))) {

-        av_log(NULL, AV_LOG_ERROR, "Could not allocate buffer\n");

-        av_opencl_free_device_list(&device_list);

-        return AVERROR(ENOMEM);

-    }

-

-    for (i = 0; i < device_list->platform_num; i++) {

-        for (j = 0; j < device_list->platform_node[i]->device_num; j++) {

-            device_node = device_list->platform_node[i]->device_node[j];

-            platform = device_list->platform_node[i]->platform_id;

-            score = av_opencl_benchmark(device_node, platform, run_opencl_bench);

-            if (score > 0) {

-                devices[count].platform_idx = i;

-                devices[count].device_idx = j;

-                devices[count].runtime = score;

-                av_strlcpy(devices[count].device_name, device_node->device_name,

-                           sizeof(devices[count].device_name));

-                count++;

-            }

-        }

-    }

-    qsort(devices, count, sizeof(OpenCLDeviceBenchmark), compare_ocl_device_desc);

-    fprintf(stderr, "platform_idx\tdevice_idx\tdevice_name\truntime\n");

-    for (i = 0; i < count; i++)

-        fprintf(stdout, "%d\t%d\t%s\t%"PRId64"\n",

-                devices[i].platform_idx, devices[i].device_idx,

-                devices[i].device_name, devices[i].runtime);

-

-    av_opencl_free_device_list(&device_list);

-    av_free(devices);

-    return 0;

-}

-

-int opt_opencl(void *optctx, const char *opt, const char *arg)

-{

-    char *key, *value;

-    const char *opts = arg;

-    int ret = 0;

-    while (*opts) {

-        ret = av_opt_get_key_value(&opts, "=", ":", 0, &key, &value);

-        if (ret < 0)

-            return ret;

-        ret = av_opencl_set_option(key, value);

-        if (ret < 0)

-            return ret;

-        if (*opts)

-            opts++;

-    }

-    return ret;

-}

@@ -19,7 +19,6 @@ OBJS = allfilters.o                                                     \

        framequeue.o                                                     \

        graphdump.o                                                      \

        graphparser.o                                                    \

-       opencl_allkernels.o                                              \

        transform.o                                                      \

        video.o                                                          \

@@ -250,7 +249,6 @@ OBJS-$(CONFIG_NOISE_FILTER)                  += vf_noise.o

 OBJS-$(CONFIG_NULL_FILTER)                   += vf_null.o

 OBJS-$(CONFIG_OCR_FILTER)                    += vf_ocr.o

 OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o

-OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o unsharp_opencl.o

 OBJS-$(CONFIG_OSCILLOSCOPE_FILTER)           += vf_datascope.o

 OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o framesync.o

 OBJS-$(CONFIG_OVERLAY_OPENCL_FILTER)         += vf_overlay_opencl.o opencl.o \

@@ -396,7 +394,6 @@ OBJS-$(CONFIG_MOVIE_FILTER)                  += src_movie.o

 SLIBOBJS-$(HAVE_GNU_WINDRES)                 += avfilterres.o

 SKIPHEADERS-$(CONFIG_LIBVIDSTAB)             += vidstabutils.h

-SKIPHEADERS-$(CONFIG_OPENCL)                 += opencl_internal.h deshake_opencl_kernel.h unsharp_opencl_kernel.h

 OBJS-$(CONFIG_SHARED)                        += log2_tab.o

@@ -22,7 +22,6 @@

 #include "libavutil/thread.h"

 #include "avfilter.h"

 #include "config.h"

-#include "opencl_allkernels.h"

 #define REGISTER_FILTER(X, x, y)                                        \

@@ -407,7 +406,6 @@ static void register_all(void)

     REGISTER_FILTER_UNCONDITIONAL(vsink_buffer);

     REGISTER_FILTER_UNCONDITIONAL(af_afifo);

     REGISTER_FILTER_UNCONDITIONAL(vf_fifo);

-    ff_opencl_register_filter_kernel_code_all();

 }

 void avfilter_register_all(void)

@@ -26,9 +26,6 @@

 #include "avfilter.h"

 #include "transform.h"

 #include "libavutil/pixelutils.h"

-#if CONFIG_OPENCL

-#include "libavutil/opencl.h"

-#endif

 enum SearchMethod {

@@ -53,24 +50,6 @@ typedef struct Transform {

     double zoom;          ///< Zoom percentage

 } Transform;

-#if CONFIG_OPENCL

-

-typedef struct DeshakeOpenclContext {

-    cl_command_queue command_queue;

-    cl_program program;

-    cl_kernel kernel_luma;

-    cl_kernel kernel_chroma;

-    int in_plane_size[8];

-    int out_plane_size[8];

-    int plane_num;

-    cl_mem cl_inbuf;

-    size_t cl_inbuf_size;

-    cl_mem cl_outbuf;

-    size_t cl_outbuf_size;

-} DeshakeOpenclContext;

-

-#endif

-

 #define MAX_R 64

 typedef struct DeshakeContext {

@@ -96,9 +75,6 @@ typedef struct DeshakeContext {

     int cy;

     char *filename;            ///< Motion search detailed log filename

     int opencl;

-#if CONFIG_OPENCL

-    DeshakeOpenclContext opencl_ctx;

-#endif

     int (* transform)(AVFilterContext *ctx, int width, int height, int cw, int ch,

                       const float *matrix_y, const float *matrix_uv, enum InterpolateMethod interpolate,

                       enum FillMethod fill, AVFrame *in, AVFrame *out);

deleted file mode 100644

@@ -1,198 +0,0 @@

-/*

- * Copyright (C) 2013 Wei Gao <weigao@multicorewareinc.com>

- * Copyright (C) 2013 Lenny Wang

- *

- * 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

- */

-

-/**

- * @file

- * transform input video

- */

-

-#include "libavutil/common.h"

-#include "libavutil/dict.h"

-#include "libavutil/pixdesc.h"

-#include "deshake_opencl.h"

-#include "libavutil/opencl_internal.h"

-

-#define PLANE_NUM 3

-#define ROUND_TO_16(a) (((((a) - 1)/16)+1)*16)

-

-int ff_opencl_transform(AVFilterContext *ctx,

-                        int width, int height, int cw, int ch,

-                        const float *matrix_y, const float *matrix_uv,

-                        enum InterpolateMethod interpolate,

-                        enum FillMethod fill, AVFrame *in, AVFrame *out)

-{

-    int ret = 0;

-    cl_int status;

-    DeshakeContext *deshake = ctx->priv;

-    float4 packed_matrix_lu = {matrix_y[0], matrix_y[1], matrix_y[2], matrix_y[5]};

-    float4 packed_matrix_ch = {matrix_uv[0], matrix_uv[1], matrix_uv[2], matrix_uv[5]};

-    size_t global_worksize_lu[2] = {(size_t)ROUND_TO_16(width), (size_t)ROUND_TO_16(height)};

-    size_t global_worksize_ch[2] = {(size_t)ROUND_TO_16(cw), (size_t)(2*ROUND_TO_16(ch))};

-    size_t local_worksize[2] = {16, 16};

-    FFOpenclParam param_lu = {0};

-    FFOpenclParam param_ch = {0};

-    param_lu.ctx = param_ch.ctx = ctx;

-    param_lu.kernel = deshake->opencl_ctx.kernel_luma;

-    param_ch.kernel = deshake->opencl_ctx.kernel_chroma;

-

-    if ((unsigned int)interpolate > INTERPOLATE_BIQUADRATIC) {

-        av_log(ctx, AV_LOG_ERROR, "Selected interpolate method is invalid\n");

-        return AVERROR(EINVAL);

-    }

-    ret = avpriv_opencl_set_parameter(&param_lu,

-                                  FF_OPENCL_PARAM_INFO(deshake->opencl_ctx.cl_inbuf),

-                                  FF_OPENCL_PARAM_INFO(deshake->opencl_ctx.cl_outbuf),

-                                  FF_OPENCL_PARAM_INFO(packed_matrix_lu),

-                                  FF_OPENCL_PARAM_INFO(interpolate),

-                                  FF_OPENCL_PARAM_INFO(fill),

-                                  FF_OPENCL_PARAM_INFO(in->linesize[0]),

-                                  FF_OPENCL_PARAM_INFO(out->linesize[0]),

-                                  FF_OPENCL_PARAM_INFO(height),

-                                  FF_OPENCL_PARAM_INFO(width),

-                                  NULL);

-    if (ret < 0)

-        return ret;

-    ret = avpriv_opencl_set_parameter(&param_ch,

-                                  FF_OPENCL_PARAM_INFO(deshake->opencl_ctx.cl_inbuf),

-                                  FF_OPENCL_PARAM_INFO(deshake->opencl_ctx.cl_outbuf),

-                                  FF_OPENCL_PARAM_INFO(packed_matrix_ch),

-                                  FF_OPENCL_PARAM_INFO(interpolate),

-                                  FF_OPENCL_PARAM_INFO(fill),

-                                  FF_OPENCL_PARAM_INFO(in->linesize[0]),

-                                  FF_OPENCL_PARAM_INFO(out->linesize[0]),

-                                  FF_OPENCL_PARAM_INFO(in->linesize[1]),

-                                  FF_OPENCL_PARAM_INFO(out->linesize[1]),

-                                  FF_OPENCL_PARAM_INFO(height),

-                                  FF_OPENCL_PARAM_INFO(width),

-                                  FF_OPENCL_PARAM_INFO(ch),

-                                  FF_OPENCL_PARAM_INFO(cw),

-                                  NULL);

-    if (ret < 0)

-        return ret;

-    status = clEnqueueNDRangeKernel(deshake->opencl_ctx.command_queue,

-                                    deshake->opencl_ctx.kernel_luma, 2, NULL,

-                                    global_worksize_lu, local_worksize, 0, NULL, NULL);

-    status |= clEnqueueNDRangeKernel(deshake->opencl_ctx.command_queue,

-                                    deshake->opencl_ctx.kernel_chroma, 2, NULL,

-                                    global_worksize_ch, local_worksize, 0, NULL, NULL);

-    if (status != CL_SUCCESS) {

-        av_log(ctx, AV_LOG_ERROR, "OpenCL run kernel error occurred: %s\n", av_opencl_errstr(status));

-        return AVERROR_EXTERNAL;

-    }

-    ret = av_opencl_buffer_read_image(out->data, deshake->opencl_ctx.out_plane_size,

-                                      deshake->opencl_ctx.plane_num, deshake->opencl_ctx.cl_outbuf,

-                                      deshake->opencl_ctx.cl_outbuf_size);

-    if (ret < 0)

-        return ret;

-    return ret;

-}

-

-int ff_opencl_deshake_init(AVFilterContext *ctx)

-{

-    int ret = 0;

-    DeshakeContext *deshake = ctx->priv;

-    ret = av_opencl_init(NULL);

-    if (ret < 0)

-        return ret;

-    deshake->opencl_ctx.plane_num = PLANE_NUM;

-    deshake->opencl_ctx.command_queue = av_opencl_get_command_queue();

-    if (!deshake->opencl_ctx.command_queue) {

-        av_log(ctx, AV_LOG_ERROR, "Unable to get OpenCL command queue in filter 'deshake'\n");

-        return AVERROR(EINVAL);

-    }

-    deshake->opencl_ctx.program = av_opencl_compile("avfilter_transform", NULL);

-    if (!deshake->opencl_ctx.program) {

-        av_log(ctx, AV_LOG_ERROR, "OpenCL failed to compile program 'avfilter_transform'\n");

-        return AVERROR(EINVAL);

-    }

-    if (!deshake->opencl_ctx.kernel_luma) {

-        deshake->opencl_ctx.kernel_luma = clCreateKernel(deshake->opencl_ctx.program,

-                                                         "avfilter_transform_luma", &ret);

-        if (ret != CL_SUCCESS) {

-            av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel 'avfilter_transform_luma'\n");

-            return AVERROR(EINVAL);

-        }

-    }

-    if (!deshake->opencl_ctx.kernel_chroma) {

-        deshake->opencl_ctx.kernel_chroma = clCreateKernel(deshake->opencl_ctx.program,

-                                                           "avfilter_transform_chroma", &ret);

-        if (ret != CL_SUCCESS) {

-            av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel 'avfilter_transform_chroma'\n");

-            return AVERROR(EINVAL);

-        }

-    }

-    return ret;

-}

-

-void ff_opencl_deshake_uninit(AVFilterContext *ctx)

-{

-    DeshakeContext *deshake = ctx->priv;

-    av_opencl_buffer_release(&deshake->opencl_ctx.cl_inbuf);

-    av_opencl_buffer_release(&deshake->opencl_ctx.cl_outbuf);

-    clReleaseKernel(deshake->opencl_ctx.kernel_luma);

-    clReleaseKernel(deshake->opencl_ctx.kernel_chroma);

-    clReleaseProgram(deshake->opencl_ctx.program);

-    deshake->opencl_ctx.command_queue = NULL;

-    av_opencl_uninit();

-}

-

-int ff_opencl_deshake_process_inout_buf(AVFilterContext *ctx, AVFrame *in, AVFrame *out)

-{

-    int ret = 0;

-    AVFilterLink *link = ctx->inputs[0];

-    DeshakeContext *deshake = ctx->priv;

-    const int hshift = av_pix_fmt_desc_get(link->format)->log2_chroma_h;

-    int chroma_height = AV_CEIL_RSHIFT(link->h, hshift);

-

-    if ((!deshake->opencl_ctx.cl_inbuf) || (!deshake->opencl_ctx.cl_outbuf)) {

-        deshake->opencl_ctx.in_plane_size[0]  = (in->linesize[0] * in->height);

-        deshake->opencl_ctx.in_plane_size[1]  = (in->linesize[1] * chroma_height);

-        deshake->opencl_ctx.in_plane_size[2]  = (in->linesize[2] * chroma_height);

-        deshake->opencl_ctx.out_plane_size[0] = (out->linesize[0] * out->height);

-        deshake->opencl_ctx.out_plane_size[1] = (out->linesize[1] * chroma_height);

-        deshake->opencl_ctx.out_plane_size[2] = (out->linesize[2] * chroma_height);

-        deshake->opencl_ctx.cl_inbuf_size  = deshake->opencl_ctx.in_plane_size[0] +

-                                             deshake->opencl_ctx.in_plane_size[1] +

-                                             deshake->opencl_ctx.in_plane_size[2];

-        deshake->opencl_ctx.cl_outbuf_size = deshake->opencl_ctx.out_plane_size[0] +

-                                             deshake->opencl_ctx.out_plane_size[1] +

-                                             deshake->opencl_ctx.out_plane_size[2];

-        if (!deshake->opencl_ctx.cl_inbuf) {

-            ret = av_opencl_buffer_create(&deshake->opencl_ctx.cl_inbuf,

-                                            deshake->opencl_ctx.cl_inbuf_size,

-                                            CL_MEM_READ_ONLY, NULL);

-            if (ret < 0)

-                return ret;

-        }

-        if (!deshake->opencl_ctx.cl_outbuf) {

-            ret = av_opencl_buffer_create(&deshake->opencl_ctx.cl_outbuf,

-                                            deshake->opencl_ctx.cl_outbuf_size,

-                                            CL_MEM_READ_WRITE, NULL);

-            if (ret < 0)

-                return ret;

-        }

-    }

-    ret = av_opencl_buffer_write_image(deshake->opencl_ctx.cl_inbuf,

-                                 deshake->opencl_ctx.cl_inbuf_size,

-                                 0, in->data,deshake->opencl_ctx.in_plane_size,

-                                 deshake->opencl_ctx.plane_num);

-    return ret;

-}

deleted file mode 100644

@@ -1,45 +0,0 @@

-/*

- * Copyright (C) 2013 Wei Gao <weigao@multicorewareinc.com>

- *

- * 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

- */

-

-#ifndef AVFILTER_DESHAKE_OPENCL_H

-#define AVFILTER_DESHAKE_OPENCL_H

-

-#include "deshake.h"

-

-typedef struct float4 {

-    float x;

-    float y;

-    float z;

-    float w;

-} float4;

-

-int ff_opencl_deshake_init(AVFilterContext *ctx);

-

-void ff_opencl_deshake_uninit(AVFilterContext *ctx);

-

-int ff_opencl_deshake_process_inout_buf(AVFilterContext *ctx, AVFrame *in, AVFrame *out);

-

-int ff_opencl_transform(AVFilterContext *ctx,

-                        int width, int height, int cw, int ch,

-                        const float *matrix_y, const float *matrix_uv,

-                        enum InterpolateMethod interpolate,

-                        enum FillMethod fill, AVFrame *in, AVFrame *out);

-

-#endif /* AVFILTER_DESHAKE_OPENCL_H */

deleted file mode 100644

@@ -1,225 +0,0 @@

-/*

- * Copyright (C) 2013 Wei Gao <weigao@multicorewareinc.com>

- * Copyright (C) 2013 Lenny Wang

- *

- *

- * 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

- */

-

-#ifndef AVFILTER_DESHAKE_OPENCL_KERNEL_H

-#define AVFILTER_DESHAKE_OPENCL_KERNEL_H

-

-#include "libavutil/opencl.h"

-

-const char *ff_kernel_deshake_opencl = AV_OPENCL_KERNEL(

-inline unsigned char pixel(global const unsigned char *src, int x, int y,

-                           int w, int h,int stride, unsigned char def)

-{

-    return (x < 0 || y < 0 || x >= w || y >= h) ? def : src[x + y * stride];

-}

-

-unsigned char interpolate_nearest(float x, float y, global const unsigned char *src,

-                                  int width, int height, int stride, unsigned char def)

-{

-    return pixel(src, (int)(x + 0.5f), (int)(y + 0.5f), width, height, stride, def);

-}

-

-unsigned char interpolate_bilinear(float x, float y, global const unsigned char *src,

-                                   int width, int height, int stride, unsigned char def)

-{

-    int x_c, x_f, y_c, y_f;

-    int v1, v2, v3, v4;

-    x_f = (int)x;

-    y_f = (int)y;

-    x_c = x_f + 1;

-    y_c = y_f + 1;

-

-    if (x_f < -1 || x_f > width || y_f < -1 || y_f > height) {

-        return def;

-    } else {

-        v4 = pixel(src, x_f, y_f, width, height, stride, def);

-        v2 = pixel(src, x_c, y_f, width, height, stride, def);

-        v3 = pixel(src, x_f, y_c, width, height, stride, def);

-        v1 = pixel(src, x_c, y_c, width, height, stride, def);

-        return (v1*(x - x_f)*(y - y_f) + v2*((x - x_f)*(y_c - y)) +

-                v3*(x_c - x)*(y - y_f) + v4*((x_c - x)*(y_c - y)));

-    }

-}

-

-unsigned char interpolate_biquadratic(float x, float y, global const unsigned char *src,

-                                      int width, int height, int stride, unsigned char def)

-{

-    int     x_c, x_f, y_c, y_f;

-    unsigned char v1,  v2,  v3,  v4;

-    float   f1,  f2,  f3,  f4;

-    x_f = (int)x;

-    y_f = (int)y;

-    x_c = x_f + 1;

-    y_c = y_f + 1;

-

-    if (x_f < - 1 || x_f > width || y_f < -1 || y_f > height)

-        return def;

-    else {

-        v4 = pixel(src, x_f, y_f, width, height, stride, def);

-        v2 = pixel(src, x_c, y_f, width, height, stride, def);

-        v3 = pixel(src, x_f, y_c, width, height, stride, def);

-        v1 = pixel(src, x_c, y_c, width, height, stride, def);

-

-        f1 = 1 - sqrt((x_c - x) * (y_c - y));

-        f2 = 1 - sqrt((x_c - x) * (y - y_f));

-        f3 = 1 - sqrt((x - x_f) * (y_c - y));

-        f4 = 1 - sqrt((x - x_f) * (y - y_f));

-        return (v1 * f1 + v2 * f2 + v3 * f3 + v4 * f4) / (f1 + f2 + f3 + f4);

-    }

-}

-

-inline const float clipf(float a, float amin, float amax)

-{

-    if      (a < amin) return amin;

-    else if (a > amax) return amax;

-    else               return a;

-}

-

-inline int mirror(int v, int m)

-{

-    while ((unsigned)v > (unsigned)m) {

-        v = -v;

-        if (v < 0)

-            v += 2 * m;

-    }

-    return v;

-}

-

-kernel void avfilter_transform_luma(global unsigned char *src,

-                                    global unsigned char *dst,

-                                    float4 matrix,

-                                    int interpolate,

-                                    int fill,

-                                    int src_stride_lu,

-                                    int dst_stride_lu,

-                                    int height,