[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