[FFmpeg-devel] [PATCH] libavfilter/unsharp: add opencl unsharp filter

Stefano Sabatini stefasab at gmail.com
Wed Apr 24 00:49:59 CEST 2013


On date Tuesday 2013-04-23 14:30:41 +0800, Wei Gao encoded:
[...]
> From 7eaeb25facbfae38cf6e13d074be8eecdb669df7 Mon Sep 17 00:00:00 2001
> From: highgod0401 <highgod0401 at gmail.com>
> Date: Tue, 23 Apr 2013 14:26:23 +0800
> Subject: [PATCH 1/2] lavu/opencl:add opencl set param function
> 
> ---
>  libavutil/Makefile          |  2 +-
>  libavutil/opencl_internal.c | 60 +++++++++++++++++++++++++++++++++++++++++++++
>  libavutil/opencl_internal.h | 33 +++++++++++++++++++++++++
>  3 files changed, 94 insertions(+), 1 deletion(-)
>  create mode 100644 libavutil/opencl_internal.c
>  create mode 100644 libavutil/opencl_internal.h
> 
> diff --git a/libavutil/Makefile b/libavutil/Makefile
> index 33f82ed..e14d5a4 100644
> --- a/libavutil/Makefile
> +++ b/libavutil/Makefile
> @@ -108,7 +108,7 @@ OBJS = adler32.o                                                        \
>         xtea.o                                                           \
>  
>  OBJS-$(CONFIG_LZO)                      += lzo.o
> -OBJS-$(CONFIG_OPENCL)                   += opencl.o
> +OBJS-$(CONFIG_OPENCL)                   += opencl.o opencl_internal.o
>  
>  OBJS += $(COMPAT_OBJS:%=../compat/%)
>  
> diff --git a/libavutil/opencl_internal.c b/libavutil/opencl_internal.c
> new file mode 100644
> index 0000000..c5a2f77
> --- /dev/null
> +++ b/libavutil/opencl_internal.c
> @@ -0,0 +1,60 @@
> +/*
> + * Copyright (C) 2012 Peng Gao <peng at multicorewareinc.com>
> + * Copyright (C) 2012 Li   Cao <li at multicorewareinc.com>
> + * Copyright (C) 2012 Wei  Gao <weigao at 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
> + */
> +
> +#include "opencl_internal.h"
> +#include "libavutil/log.h"
> +
> +
> +int ff_opencl_set_parameter(FFOpenclParam *opencl_param, ...)
> +{
> +    int ret = 0;
> +    va_list arg_ptr;
> +    void *param;
> +    size_t param_size;
> +    cl_int status;
> +    if (!opencl_param->kernel) {
> +        av_log(opencl_param->ctx, AV_LOG_ERROR, "OpenCL kernel must be set\n");
> +        return AVERROR(EINVAL);
> +    }
> +    va_start(arg_ptr, opencl_param);
> +    do {
> +        param = va_arg(arg_ptr, void *);
> +        if (!param)
> +            break;
> +        param_size = va_arg(arg_ptr, size_t);
> +        if (!param_size) {

> +            av_log(opencl_param->ctx, AV_LOG_ERROR, "parameter size must not be 0\n");

Nit: Parameter size ...

> +            ret = AVERROR(EINVAL);
> +            goto end;
> +        }
> +        status = clSetKernelArg(opencl_param->kernel, opencl_param->param_num, param_size, param);
> +        if (status != CL_SUCCESS) {
> +            av_log(opencl_param->ctx, AV_LOG_ERROR, "cannot set kernel argument: %d\n", status);

Nit: Cannot set ...

> +            ret = AVERROR_EXTERNAL;
> +            goto end;
> +        }
> +        opencl_param->param_num++;
> +    } while (param && param_size);
> +end:
> +    va_end(arg_ptr);
> +    return ret;
> +}
> diff --git a/libavutil/opencl_internal.h b/libavutil/opencl_internal.h
> new file mode 100644
> index 0000000..34b39a0
> --- /dev/null
> +++ b/libavutil/opencl_internal.h
> @@ -0,0 +1,33 @@
> +/*
> + * Copyright (C) 2012 Peng Gao <peng at multicorewareinc.com>
> + * Copyright (C) 2012 Li   Cao <li at multicorewareinc.com>
> + * Copyright (C) 2012 Wei  Gao <weigao at 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
> + */
> +
> +#include "opencl.h"
> +
> +#define FF_OPENCL_PARAM_INFO(a) ((void*)(&(a))), (sizeof(a))
> +
> +typedef struct {
> +    cl_kernel kernel;
> +    int param_num;
> +    void *ctx;
> +} FFOpenclParam;
> +
> +int ff_opencl_set_parameter(FFOpenclParam *opencl_param, ...);
> -- 
> 1.7.11.msysgit.1

LGTM otherwise (you could update deshake_opencl.c to make use of it). 


> From afef50db17d2e7130fc6bdd4eb119ce1c6770b2a Mon Sep 17 00:00:00 2001
> From: highgod0401 <highgod0401 at gmail.com>
> Date: Tue, 23 Apr 2013 14:27:34 +0800
> Subject: [PATCH 2/2] lavfi/unsharp: add opencl unsharp filter
> 
> ---
>  doc/filters.texi                |   5 +
>  libavfilter/Makefile            |   2 +-
>  libavfilter/opencl_allkernels.c |   4 +-
>  libavfilter/unsharp.h           |  79 +++++++++++
>  libavfilter/unsharp_kernel.h    | 132 ++++++++++++++++++
>  libavfilter/unsharp_opencl.c    | 292 ++++++++++++++++++++++++++++++++++++++++
>  libavfilter/unsharp_opencl.h    |  34 +++++
>  libavfilter/vf_unsharp.c        |  88 +++++++-----
>  8 files changed, 598 insertions(+), 38 deletions(-)
>  create mode 100644 libavfilter/unsharp.h
>  create mode 100644 libavfilter/unsharp_kernel.h
>  create mode 100644 libavfilter/unsharp_opencl.c
>  create mode 100644 libavfilter/unsharp_opencl.h
> 
> diff --git a/doc/filters.texi b/doc/filters.texi
> index adf6000..80a5db3 100644
> --- a/doc/filters.texi
> +++ b/doc/filters.texi
> @@ -5998,6 +5998,11 @@ sharpen it, a value of zero will disable the effect.
>  
>  Default value is 1.0 for @option{luma_amount}, 0.0 for
>  @option{chroma_amount}.
> +
> + at 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
> diff --git a/libavfilter/Makefile b/libavfilter/Makefile
> index 04a5b39..4fbcf13 100644
> --- a/libavfilter/Makefile
> +++ b/libavfilter/Makefile
> @@ -144,7 +144,7 @@ OBJS-$(CONFIG_NOFORMAT_FILTER)               += vf_format.o
>  OBJS-$(CONFIG_NOISE_FILTER)                  += vf_noise.o
>  OBJS-$(CONFIG_NULL_FILTER)                   += vf_null.o
>  OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o
> -OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o
> +OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o unsharp_opencl.o
>  OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o
>  OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o
>  OBJS-$(CONFIG_PERMS_FILTER)                  += f_perms.o
> diff --git a/libavfilter/opencl_allkernels.c b/libavfilter/opencl_allkernels.c
> index 021eec2..8dbdc5f 100644
> --- a/libavfilter/opencl_allkernels.c
> +++ b/libavfilter/opencl_allkernels.c
> @@ -22,6 +22,7 @@
>  #if CONFIG_OPENCL
>  #include "libavutil/opencl.h"
>  #include "deshake_kernel.h"
> +#include "unsharp_kernel.h"
>  #endif
>  
>  #define OPENCL_REGISTER_KERNEL_CODE(X, x)                                              \
> @@ -34,6 +35,7 @@
>  void ff_opencl_register_filter_kernel_code_all(void)
>  {
>   #if CONFIG_OPENCL
> -   OPENCL_REGISTER_KERNEL_CODE(DESHAKE,     deshake);
> +    OPENCL_REGISTER_KERNEL_CODE(DESHAKE,     deshake);
> +    OPENCL_REGISTER_KERNEL_CODE(UNSHARP,     unsharp);

Nit+++: no need to reindent

>   #endif
>  }
> diff --git a/libavfilter/unsharp.h b/libavfilter/unsharp.h
> new file mode 100644
> index 0000000..a82bde9
> --- /dev/null
> +++ b/libavfilter/unsharp.h
> @@ -0,0 +1,79 @@
> +/*
> + * Copyright (C) 2013 Wei Gao <weigao at 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_UNSHARP_H
> +#define AVFILTER_UNSHARP_H
> +
> +#include "config.h"
> +#include "avfilter.h"
> +#if CONFIG_OPENCL
> +#include "libavutil/opencl.h"
> +#endif
> +
> +#define MIN_MATRIX_SIZE 3
> +#define MAX_MATRIX_SIZE 63
> +
> +/* right-shift and round-up */
> +#define SHIFTUP(x,shift) (-((-(x))>>(shift)))
> +
> +#if CONFIG_OPENCL
> +
> +typedef struct {
> +    cl_mem cl_luma_mask;
> +    cl_mem cl_chroma_mask;
> +    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;
> +    AVOpenCLKernelEnv kernel_env;
> +} UnsharpOpenclContext;
> +
> +#endif

> +
> +

nit+++: remove double empty line

> +typedef struct UnsharpFilterParam {
> +    int msize_x;                             ///< matrix width
> +    int msize_y;                             ///< matrix height
> +    int amount;                              ///< effect amount
> +    int steps_x;                             ///< horizontal step count
> +    int steps_y;                             ///< vertical step count
> +    int scalebits;                           ///< bits to shift pixel
> +    int32_t halfscale;                       ///< amount to add to pixel
> +    uint32_t *sc[MAX_MATRIX_SIZE - 1];       ///< finite state machine storage
> +} UnsharpFilterParam;
> +
> +typedef struct {
> +    const AVClass *class;
> +    int lmsize_x, lmsize_y, cmsize_x, cmsize_y;
> +    float lamount, camount;
> +    UnsharpFilterParam luma;   ///< luma parameters (width, height, amount)
> +    UnsharpFilterParam chroma; ///< chroma parameters (width, height, amount)
> +    int hsub, vsub;
> +    int opencl;
> +#if CONFIG_OPENCL
> +    UnsharpOpenclContext opencl_ctx;
> +#endif
> +    int (* apply_unsharp)(AVFilterContext *ctx, AVFrame *in, AVFrame *out);
> +} UnsharpContext;
> +
> +#endif /* AVFILTER_UNSHARP_H */
> diff --git a/libavfilter/unsharp_kernel.h b/libavfilter/unsharp_kernel.h
> new file mode 100644
> index 0000000..c1de11d
> --- /dev/null
> +++ b/libavfilter/unsharp_kernel.h
> @@ -0,0 +1,132 @@
> +/*
> + * Copyright (C) 2013 Wei Gao <weigao at 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_UNSHARP_KERNEL_H
> +#define AVFILTER_UNSHARP_KERNEL_H
> +
> +#include "libavutil/opencl.h"
> +
> +const char *ff_kernel_unsharp_opencl = AV_OPENCL_KERNEL(
> +kernel void unsharp(global  unsigned char *src,
> +                    global  unsigned char *dst,
> +                    const global  unsigned int *mask_lu,
> +                    const global  unsigned int *mask_ch,
> +                    int amount_lu,
> +                    int amount_ch,
> +                    int step_x_lu,
> +                    int step_y_lu,
> +                    int step_x_ch,
> +                    int step_y_ch,
> +                    int scalebits_lu,
> +                    int scalebits_ch,
> +                    int halfscale_lu,
> +                    int halfscale_ch,
> +                    int src_stride_lu,
> +                    int src_stride_ch,
> +                    int dst_stride_lu,
> +                    int dst_stride_ch,
> +                    int height,
> +                    int width,
> +                    int ch,
> +                    int cw)
> +{
> +    global unsigned char *dst_y = dst;
> +    global unsigned char *dst_u = dst_y + height * dst_stride_lu;
> +    global unsigned char *dst_v = dst_u + ch * dst_stride_ch;
> +
> +    global unsigned char *src_y = src;
> +    global unsigned char *src_u = src_y + height * src_stride_lu;
> +    global unsigned char *src_v = src_u + ch * src_stride_ch;
> +
> +    global unsigned char *temp_dst;
> +    global unsigned char *temp_src;
> +    const global unsigned int *temp_mask;
> +    int global_id = get_global_id(0);
> +    int i, j, x, y, temp_src_stride, temp_dst_stride, temp_height, temp_width, temp_steps_x, temp_steps_y,
> +        temp_amount, temp_scalebits, temp_halfscale, sum, idx_x, idx_y, temp, res;
> +    if (global_id < width * height) {
> +        y = global_id / width;
> +        x = global_id % width;
> +        temp_dst = dst_y;
> +        temp_src = src_y;
> +        temp_src_stride = src_stride_lu;
> +        temp_dst_stride = dst_stride_lu;
> +        temp_height = height;
> +        temp_width = width;
> +        temp_steps_x = step_x_lu;
> +        temp_steps_y = step_y_lu;
> +        temp_mask = mask_lu;
> +        temp_amount = amount_lu;
> +        temp_scalebits = scalebits_lu;
> +        temp_halfscale = halfscale_lu;
> +    } else if ((global_id >= width * height) && (global_id < width * height + ch * cw)) {
> +        y = (global_id - width * height) / cw;
> +        x = (global_id - width * height) % cw;
> +        temp_dst = dst_u;
> +        temp_src = src_u;
> +        temp_src_stride = src_stride_ch;
> +        temp_dst_stride = dst_stride_ch;
> +        temp_height = ch;
> +        temp_width = cw;
> +        temp_steps_x = step_x_ch;
> +        temp_steps_y = step_y_ch;
> +        temp_mask = mask_ch;
> +        temp_amount = amount_ch;
> +        temp_scalebits = scalebits_ch;
> +        temp_halfscale = halfscale_ch;
> +    } else {
> +        y = (global_id - width * height - ch * cw) / cw;
> +        x = (global_id - width * height - ch * cw) % cw;
> +        temp_dst = dst_v;
> +        temp_src = src_v;
> +        temp_src_stride = src_stride_ch;
> +        temp_dst_stride = dst_stride_ch;
> +        temp_height = ch;
> +        temp_width = cw;
> +        temp_steps_x = step_x_ch;
> +        temp_steps_y = step_y_ch;
> +        temp_mask = mask_ch;
> +        temp_amount = amount_ch;
> +        temp_scalebits = scalebits_ch;
> +        temp_halfscale = halfscale_ch;
> +    }
> +    if (temp_amount) {
> +        sum = 0;
> +        for (j = 0; j <= 2 * temp_steps_y; j++) {
> +            idx_y = (y - temp_steps_y + j) <= 0 ? 0 : (y - temp_steps_y + j) >= temp_height ? temp_height-1 : y - temp_steps_y + j;
> +            for (i = 0; i <= 2 * temp_steps_x; i++) {
> +                idx_x = (x - temp_steps_x + i) <= 0 ? 0 : (x - temp_steps_x + i) >= temp_width ? temp_width-1 : x - temp_steps_x + i;
> +                sum += temp_mask[i + j * (2 * temp_steps_x + 1)] * temp_src[idx_x + idx_y * temp_src_stride];
> +            }
> +        }
> +        temp = (int)temp_src[x + y * temp_src_stride];
> +        res = temp + (((temp - (int)((sum + temp_halfscale) >> temp_scalebits)) * temp_amount) >> 16);

> +        if (res & (~0xFF))
> +            temp_dst[x + y * temp_dst_stride] = (-res) >> 31;
> +        else
> +            temp_dst[x + y * temp_dst_stride] = res;

is this equivalent to av_clip_uint8 ?


> +    } else {
> +        temp_dst[x + y * temp_dst_stride] = temp_src[x + y * temp_src_stride];
> +    }
> +}

please verify that the output is bit-exact with C-code unsharp.

> +
> +);
> +
> +#endif /* AVFILTER_UNSHARP_KERNEL_H */
> diff --git a/libavfilter/unsharp_opencl.c b/libavfilter/unsharp_opencl.c
> new file mode 100644
> index 0000000..186a181
> --- /dev/null
> +++ b/libavfilter/unsharp_opencl.c
> @@ -0,0 +1,292 @@
> +/*
> + * Copyright (C) 2013 Wei Gao <weigao at 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
> + */
> +
> +/**
> + * @file
> + * unsharp input video
> + */
> +
> +#include "unsharp_opencl.h"
> +#include "libavutil/opencl_internal.h"
> +
> +#define PLANE_NUM 3
> +

> +static void add_mask_counter(uint32_t *dst, uint32_t *counter1, uint32_t *counter2, int len)

nit: this could be static inline

> +{
> +    int i;
> +    for (i = 0; i < len; i++) {
> +        dst[i] = counter1[i] + counter2[i];
> +    }
> +}
> +
> +static int compute_mask(AVFilterContext *ctx, int step, uint32_t *mask)
> +{
> +    int i, z, ret = 0;
> +    int counter_size = sizeof(uint32_t) * (2 * step + 1);
> +    uint32_t *temp1_counter, *temp2_counter, **counter;
> +    if (!mask) {
> +        av_log(ctx, AV_LOG_ERROR, "input pointer of mask x and mask y should not be NULL\n");

Nit+: Input ...

In general first character is usually Upcased.

> +        return AVERROR(EINVAL);
> +    }
> +    temp1_counter = av_mallocz(counter_size);
> +    if (!temp1_counter) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate mask counter1 space\n");

remove the final " space", also feel free to drop error messages
for ENOMEM errors

> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }
> +    temp2_counter = av_mallocz(counter_size);
> +    if (!temp2_counter) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate mask counter2 space\n");
> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }

> +    counter = av_mallocz(sizeof(uint32_t *) * (2 * step + 1));

counter_size?

> +    if (!counter) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate mask counter space\n");
> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }
> +    for (i = 0; i < 2 * step + 1; i++) {
> +        counter[i] = av_mallocz(counter_size);
> +        if (!counter[i]) {
> +            av_log(&ctx, AV_LOG_ERROR, "Could not allocate mask counter space\n");
> +            ret = AVERROR(ENOMEM);
> +            goto end;
> +        }
> +    }
> +    for (i = 0; i < 2 * step + 1; i++) {
> +        memset(temp1_counter, 0, counter_size);
> +        temp1_counter[i] = 1;
> +        for (z = 0; z < step * 2; z += 2) {
> +            add_mask_counter(temp2_counter, counter[z], temp1_counter, step * 2);
> +            memcpy(counter[z], temp1_counter, counter_size);
> +            add_mask_counter(temp1_counter, counter[z + 1], temp2_counter, step * 2);
> +            memcpy(counter[z + 1], temp2_counter, counter_size);
> +        }
> +    }
> +    memcpy(mask, temp1_counter, sizeof(uint32_t) * (2 * step + 1));
> +end:
> +    av_freep(&temp1_counter);
> +    av_freep(&temp2_counter);
> +    for (i = 0; i < 2 * step + 1; i++) {
> +        av_freep(&counter[i]);
> +    }
> +    av_freep(&counter);
> +    return ret;
> +}
> +
> +static int generate_mask(AVFilterContext *ctx)
> +{
> +    UnsharpContext *unsharp = ctx->priv;
> +    int i, j, ret = 0;
> +    int max_step_x = unsharp->luma.steps_x > unsharp->chroma.steps_x ? unsharp->luma.steps_x : unsharp->chroma.steps_x;
> +    int max_step_y = unsharp->luma.steps_y > unsharp->chroma.steps_y ? unsharp->luma.steps_y : unsharp->chroma.steps_y;
> +    uint32_t *mask_x, *mask_y, *mask;
> +    mask_x = av_mallocz(sizeof(uint32_t) * (2 * max_step_x + 1));
> +    if (!mask_x) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate x mask\n");
> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }
> +    mask_y = av_mallocz(sizeof(uint32_t) * (2 * max_step_y + 1));
> +    if (!mask_y) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate y mask\n");
> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }
> +    mask = av_mallocz(sizeof(uint32_t) * (2 * max_step_x + 1) * (2 * max_step_y + 1));
> +    if (!mask) {
> +        av_log(&ctx, AV_LOG_ERROR, "Could not allocate mask\n");
> +        ret = AVERROR(ENOMEM);
> +        goto end;
> +    }
> +

> +    ret = compute_mask(ctx, unsharp->luma.steps_x, mask_x);
> +    if (ret < 0)
> +        goto end;
> +    ret = compute_mask(ctx, unsharp->luma.steps_y, mask_y);
> +    if (ret < 0)
> +        goto end;
> +    for (j = 0; j < 2 * unsharp->luma.steps_y + 1; j++) {
> +        for (i = 0; i < 2 * unsharp->luma.steps_x + 1; i++) {
> +            mask[i + j * (2 * unsharp->luma.steps_x + 1)] = mask_y[j] * mask_x[i];
> +        }
> +    }
> +    ret = av_opencl_buffer_write(unsharp->opencl_ctx.cl_luma_mask, (uint8_t *)mask,
> +                                 sizeof(uint32_t) * (2 * unsharp->luma.steps_x + 1) * (2 * unsharp->luma.steps_y + 1));
> +    if (ret < 0)
> +        goto end;

> +    ret = compute_mask(ctx, unsharp->chroma.steps_x, mask_x);
> +    if (ret < 0)
> +        goto end;
> +    ret = compute_mask(ctx, unsharp->chroma.steps_y, mask_y);
> +    if (ret < 0)
> +        goto end;
> +    for (j = 0; j < 2 * unsharp->chroma.steps_y + 1; j++) {
> +        for (i = 0; i < 2 * unsharp->chroma.steps_x + 1; i++) {
> +            mask[i + j * (2 * unsharp->chroma.steps_x + 1)] = mask_y[j] * mask_x[i];
> +        }
> +    }
> +    ret = av_opencl_buffer_write(unsharp->opencl_ctx.cl_chroma_mask, (uint8_t *)mask,
> +                                 sizeof(uint32_t) * (2 * unsharp->chroma.steps_x + 1) * (2 * unsharp->chroma.steps_y + 1));
> +    if (ret < 0)
> +        goto end;

this could be factorized (with a loop, a macro, or a function)

> +end:
> +    av_freep(&mask_x);
> +    av_freep(&mask_y);
> +    av_freep(&mask);
> +    return ret;
> +}
> +
> +int ff_opencl_apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
> +{
> +    int ret;
> +    AVFilterLink *link = ctx->inputs[0];
> +    UnsharpContext *unsharp = ctx->priv;
> +    cl_int status;
> +    int cw = SHIFTUP(link->w, unsharp->hsub);
> +    int ch = SHIFTUP(link->h, unsharp->vsub);
> +    const size_t global_work_size = link->w * link->h + 2 * ch * cw;
> +    FFOpenclParam opencl_param = {0};
> +
> +    opencl_param.ctx = ctx;
> +    opencl_param.kernel = unsharp->opencl_ctx.kernel_env.kernel;
> +    ret = ff_opencl_set_parameter(&opencl_param,
> +                                  FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_inbuf),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_outbuf),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_luma_mask),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->opencl_ctx.cl_chroma_mask),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->luma.amount),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->chroma.amount),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->luma.steps_x),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->luma.steps_y),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->chroma.steps_x),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->chroma.steps_y),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->luma.scalebits),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->chroma.scalebits),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->luma.halfscale),
> +                                  FF_OPENCL_PARAM_INFO(unsharp->chroma.halfscale),
> +                                  FF_OPENCL_PARAM_INFO(in->linesize[0]),
> +                                  FF_OPENCL_PARAM_INFO(in->linesize[1]),
> +                                  FF_OPENCL_PARAM_INFO(out->linesize[0]),
> +                                  FF_OPENCL_PARAM_INFO(out->linesize[1]),
> +                                  FF_OPENCL_PARAM_INFO(link->h),
> +                                  FF_OPENCL_PARAM_INFO(link->w),
> +                                  FF_OPENCL_PARAM_INFO(ch),
> +                                  FF_OPENCL_PARAM_INFO(cw),
> +                                  NULL);
> +    if (ret < 0)
> +        return ret;
> +    status = clEnqueueNDRangeKernel(unsharp->opencl_ctx.kernel_env.command_queue,
> +                                    unsharp->opencl_ctx.kernel_env.kernel, 1, NULL,
> +                                    &global_work_size, NULL, 0, NULL, NULL);
> +    if (status != CL_SUCCESS) {
> +        av_log(ctx, AV_LOG_ERROR, "run unsharp kernel error: %d\n", status);

nit: "OpenCL run kernel error occurred: %d\n", status

Note: it would be nice to print a description of the error rather
than an error code

> +        return AVERROR_EXTERNAL;
> +    }
> +    clFinish(unsharp->opencl_ctx.kernel_env.command_queue);
> +    return av_opencl_buffer_read_image(out->data, unsharp->opencl_ctx.out_plane_size,
> +                                      unsharp->opencl_ctx.plane_num, unsharp->opencl_ctx.cl_outbuf,
> +                                      unsharp->opencl_ctx.cl_outbuf_size);

nit++: weird align

> +}
> +
> +int ff_opencl_unsharp_init(AVFilterContext *ctx)
> +{
> +    int ret = 0;
> +    UnsharpContext *unsharp = ctx->priv;
> +    ret = av_opencl_init(NULL);
> +    if (ret < 0)
> +        return ret;
> +    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_luma_mask,
> +                                  sizeof(uint32_t) * (2 * unsharp->luma.steps_x + 1) * (2 * unsharp->luma.steps_y + 1),
> +                                  CL_MEM_READ_ONLY, NULL);
> +    if (ret < 0)
> +        return ret;
> +    ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_chroma_mask,
> +                                  sizeof(uint32_t) * (2 * unsharp->chroma.steps_x + 1) * (2 * unsharp->chroma.steps_y + 1),
> +                                  CL_MEM_READ_ONLY, NULL);
> +    if (ret < 0)
> +        return ret;
> +    ret = generate_mask(ctx);
> +    if (ret < 0)
> +        return ret;
> +    unsharp->opencl_ctx.plane_num = PLANE_NUM;
> +    if (!unsharp->opencl_ctx.kernel_env.kernel) {
> +        ret =  av_opencl_create_kernel(&unsharp->opencl_ctx.kernel_env, "unsharp");
> +        if (ret < 0) {
> +            av_log(ctx, AV_LOG_ERROR, "OpenCL failed to create kernel for name 'unsharp'\n");

nit: for name -> with name

> +            return ret;
> +        }
> +    }
> +    return ret;
> +}
> +
> +void ff_opencl_unsharp_uninit(AVFilterContext *ctx)
> +{
> +    UnsharpContext *unsharp = ctx->priv;
> +    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_inbuf);
> +    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_outbuf);
> +    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_luma_mask);
> +    av_opencl_buffer_release(&unsharp->opencl_ctx.cl_chroma_mask);
> +    av_opencl_release_kernel(&unsharp->opencl_ctx.kernel_env);
> +    av_opencl_uninit();
> +}
> +
> +int ff_opencl_unsharp_process_inout_buf(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
> +{
> +    int ret = 0;
> +    AVFilterLink *link = ctx->inputs[0];
> +    UnsharpContext *unsharp = ctx->priv;
> +    int ch = SHIFTUP(link->h, unsharp->vsub);
> +
> +    if ((!unsharp->opencl_ctx.cl_inbuf) || (!unsharp->opencl_ctx.cl_outbuf)) {
> +        unsharp->opencl_ctx.in_plane_size[0]  = (in->linesize[0] * in->height);
> +        unsharp->opencl_ctx.in_plane_size[1]  = (in->linesize[1] * ch);
> +        unsharp->opencl_ctx.in_plane_size[2]  = (in->linesize[2] * ch);
> +        unsharp->opencl_ctx.out_plane_size[0] = (out->linesize[0] * out->height);
> +        unsharp->opencl_ctx.out_plane_size[1] = (out->linesize[1] * ch);
> +        unsharp->opencl_ctx.out_plane_size[2] = (out->linesize[2] * ch);
> +        unsharp->opencl_ctx.cl_inbuf_size  = unsharp->opencl_ctx.in_plane_size[0] +
> +                                             unsharp->opencl_ctx.in_plane_size[1] +
> +                                             unsharp->opencl_ctx.in_plane_size[2];
> +        unsharp->opencl_ctx.cl_outbuf_size = unsharp->opencl_ctx.out_plane_size[0] +
> +                                             unsharp->opencl_ctx.out_plane_size[1] +
> +                                             unsharp->opencl_ctx.out_plane_size[2];
> +        if (!unsharp->opencl_ctx.cl_inbuf) {
> +            ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_inbuf,
> +                                          unsharp->opencl_ctx.cl_inbuf_size,
> +                                          CL_MEM_READ_ONLY, NULL);
> +            if (ret < 0)
> +                return ret;
> +        }
> +        if (!unsharp->opencl_ctx.cl_outbuf) {
> +            ret = av_opencl_buffer_create(&unsharp->opencl_ctx.cl_outbuf,
> +                                          unsharp->opencl_ctx.cl_outbuf_size,
> +                                          CL_MEM_READ_WRITE, NULL);
> +            if (ret < 0)
> +                return ret;
> +        }
> +    }
> +    return av_opencl_buffer_write_image(unsharp->opencl_ctx.cl_inbuf,
> +                                       unsharp->opencl_ctx.cl_inbuf_size,
> +                                       0, in->data,unsharp->opencl_ctx.in_plane_size,
> +                                       unsharp->opencl_ctx.plane_num);
> +}
> +
> diff --git a/libavfilter/unsharp_opencl.h b/libavfilter/unsharp_opencl.h
> new file mode 100644
> index 0000000..3aefab6
> --- /dev/null
> +++ b/libavfilter/unsharp_opencl.h
> @@ -0,0 +1,34 @@
> +/*
> + * Copyright (C) 2013 Wei Gao <weigao at 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_UNSHARP_OPENCL_H
> +#define AVFILTER_UNSHARP_OPENCL_H
> +
> +#include "unsharp.h"
> +
> +int ff_opencl_unsharp_init(AVFilterContext *ctx);
> +
> +void ff_opencl_unsharp_uninit(AVFilterContext *ctx);
> +
> +int ff_opencl_unsharp_process_inout_buf(AVFilterContext *ctx, AVFrame *in, AVFrame *out);
> +
> +int ff_opencl_apply_unsharp(AVFilterContext *ctx, AVFrame *in, AVFrame *out);
> +
> +#endif /* AVFILTER_UNSHARP_OPENCL_H */
> diff --git a/libavfilter/vf_unsharp.c b/libavfilter/vf_unsharp.c
> index 038ba4b..e2f7e85 100644
> --- a/libavfilter/vf_unsharp.c
> +++ b/libavfilter/vf_unsharp.c
> @@ -46,36 +46,12 @@
>  #include "libavutil/mem.h"
>  #include "libavutil/opt.h"
>  #include "libavutil/pixdesc.h"
> -
> -#define MIN_MATRIX_SIZE 3
> -#define MAX_MATRIX_SIZE 63
> -
> -/* right-shift and round-up */
> -#define SHIFTUP(x,shift) (-((-(x))>>(shift)))
> -
> -typedef struct FilterParam {
> -    int msize_x;                             ///< matrix width
> -    int msize_y;                             ///< matrix height
> -    int amount;                              ///< effect amount
> -    int steps_x;                             ///< horizontal step count
> -    int steps_y;                             ///< vertical step count
> -    int scalebits;                           ///< bits to shift pixel
> -    int32_t halfscale;                       ///< amount to add to pixel
> -    uint32_t *sc[MAX_MATRIX_SIZE - 1];       ///< finite state machine storage
> -} FilterParam;
> -
> -typedef struct {
> -    const AVClass *class;
> -    int lmsize_x, lmsize_y, cmsize_x, cmsize_y;
> -    float lamount, camount;
> -    FilterParam luma;   ///< luma parameters (width, height, amount)
> -    FilterParam chroma; ///< chroma parameters (width, height, amount)
> -    int hsub, vsub;
> -} UnsharpContext;
> +#include "unsharp.h"
> +#include "unsharp_opencl.h"
>  
>  static void apply_unsharp(      uint8_t *dst, int dst_stride,
>                            const uint8_t *src, int src_stride,
> -                          int width, int height, FilterParam *fp)
> +                          int width, int height, UnsharpFilterParam *fp)
>  {
>      uint32_t **sc = fp->sc;
>      uint32_t sr[MAX_MATRIX_SIZE - 1], tmp1, tmp2;
> @@ -131,7 +107,25 @@ static void apply_unsharp(      uint8_t *dst, int dst_stride,
>      }
>  }
>  
> -static void set_filter_param(FilterParam *fp, int msize_x, int msize_y, float amount)
> +static int apply_unsharp_c(AVFilterContext *ctx, AVFrame *in, AVFrame *out)
> +{
> +    AVFilterLink *inlink = ctx->inputs[0];
> +    UnsharpContext *unsharp = ctx->priv;
> +    int i, plane_w[3], plane_h[3];
> +    UnsharpFilterParam *fp[3];
> +    plane_w[0] = inlink->w;
> +    plane_w[1] = plane_w[2] = SHIFTUP(inlink->w, unsharp->hsub);
> +    plane_h[0] = inlink->h;
> +    plane_h[1] = plane_h[2] = SHIFTUP(inlink->h, unsharp->vsub);
> +    fp[0] = &unsharp->luma;
> +    fp[1] = fp[2] = &unsharp->chroma;
> +    for (i = 0; i < 3; i++) {
> +        apply_unsharp(out->data[i], out->linesize[i], in->data[i], in->linesize[i], plane_w[i], plane_h[i], fp[i]);
> +    }
> +    return 0;
> +}
> +
> +static void set_filter_param(UnsharpFilterParam *fp, int msize_x, int msize_y, float amount)
>  {
>      fp->msize_x = msize_x;
>      fp->msize_y = msize_y;
> @@ -145,12 +139,24 @@ static void set_filter_param(FilterParam *fp, int msize_x, int msize_y, float am
>  
>  static av_cold int init(AVFilterContext *ctx)
>  {
> +    int ret = 0;
>      UnsharpContext *unsharp = ctx->priv;
>  
>  
>      set_filter_param(&unsharp->luma,   unsharp->lmsize_x, unsharp->lmsize_y, unsharp->lamount);
>      set_filter_param(&unsharp->chroma, unsharp->cmsize_x, unsharp->cmsize_y, unsharp->camount);
>  
> +    unsharp->apply_unsharp = apply_unsharp_c;
> +    if (!CONFIG_OPENCL && unsharp->opencl) {
> +        av_log(ctx, AV_LOG_ERROR, "OpenCL support was not enabled in this build, cannot be selected\n");
> +        return AVERROR(EINVAL);
> +    }
> +    if (CONFIG_OPENCL && unsharp->opencl) {
> +        unsharp->apply_unsharp = ff_opencl_apply_unsharp;
> +        ret = ff_opencl_unsharp_init(ctx);
> +        if (ret < 0)
> +            return ret;
> +    }
>      return 0;
>  }
>  
> @@ -167,7 +173,7 @@ static int query_formats(AVFilterContext *ctx)
>      return 0;
>  }
>  
> -static int init_filter_param(AVFilterContext *ctx, FilterParam *fp, const char *effect_type, int width)
> +static int init_filter_param(AVFilterContext *ctx, UnsharpFilterParam *fp, const char *effect_type, int width)
>  {
>      int z;
>      const char *effect = fp->amount == 0 ? "none" : fp->amount < 0 ? "blur" : "sharpen";
> @@ -208,7 +214,7 @@ static int config_props(AVFilterLink *link)
>      return 0;
>  }
>  
> -static void free_filter_param(FilterParam *fp)
> +static void free_filter_param(UnsharpFilterParam *fp)
>  {
>      int z;
>  
> @@ -220,6 +226,10 @@ static av_cold void uninit(AVFilterContext *ctx)
>  {
>      UnsharpContext *unsharp = ctx->priv;
>  
> +    if (CONFIG_OPENCL && unsharp->opencl) {
> +        ff_opencl_unsharp_uninit(ctx);
> +    }
> +
>      free_filter_param(&unsharp->luma);
>      free_filter_param(&unsharp->chroma);
>  }
> @@ -229,8 +239,7 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
>      UnsharpContext *unsharp = link->dst->priv;
>      AVFilterLink *outlink   = link->dst->outputs[0];
>      AVFrame *out;
> -    int cw = SHIFTUP(link->w, unsharp->hsub);
> -    int ch = SHIFTUP(link->h, unsharp->vsub);
> +    int ret = 0;
>  
>      out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
>      if (!out) {
> @@ -238,12 +247,18 @@ static int filter_frame(AVFilterLink *link, AVFrame *in)
>          return AVERROR(ENOMEM);
>      }
>      av_frame_copy_props(out, in);
> +    if (CONFIG_OPENCL && unsharp->opencl) {
> +        ret = ff_opencl_unsharp_process_inout_buf(link->dst,in, out);

nit: link->dst,_in,

> +        if (ret < 0)
> +            goto end;
> +    }
>  
> -    apply_unsharp(out->data[0], out->linesize[0], in->data[0], in->linesize[0], link->w, link->h, &unsharp->luma);
> -    apply_unsharp(out->data[1], out->linesize[1], in->data[1], in->linesize[1], cw,      ch,      &unsharp->chroma);
> -    apply_unsharp(out->data[2], out->linesize[2], in->data[2], in->linesize[2], cw,      ch,      &unsharp->chroma);
> -
> +    ret = unsharp->apply_unsharp(link->dst, in, out);
> +end:
>      av_frame_free(&in);
> +
> +    if (ret < 0)
> +        return ret;
>      return ff_filter_frame(outlink, out);
>  }
>  
> @@ -264,6 +279,7 @@ static const AVOption unsharp_options[] = {
>      { "cy",             "chroma matrix vertical size",   OFFSET(cmsize_y), AV_OPT_TYPE_INT,   { .i64 = 5 }, MIN_SIZE, MAX_SIZE, FLAGS },
>      { "chroma_amount",  "chroma effect strength",        OFFSET(camount),  AV_OPT_TYPE_FLOAT, { .dbl = 0 },       -2,        5, FLAGS },
>      { "ca",             "chroma effect strength",        OFFSET(camount),  AV_OPT_TYPE_FLOAT, { .dbl = 0 },       -2,        5, FLAGS },
> +    { "opencl",         "use OpenCL filtering capabilities", OFFSET(opencl), AV_OPT_TYPE_INT, { .i64 = 0 },        0,        1, FLAGS },
>      { NULL },
>  };

Overall, very nice work.
-- 
FFmpeg = Forgiving & Formidable Moronic Ponderous Enhanced Gadget


More information about the ffmpeg-devel mailing list