History

avfilter: add dblur video filter

Paul B Mahol committed 6 years ago

Commit 726dbc51 parent d49db996 files · +334 −1Browse files

Showing the changes to libavfilter (4 of 6 files). Show all

Unified · Split

4 files
  1. libavfilter/Makefile +1 −0
  2. libavfilter/allfilters.c +1 −0
  3. libavfilter/version.h +1 −1
  4. libavfilter/vf_dblur.c +307 −0
libavfilter/Makefile+1−0
@@ -206,6 +206,7 @@ OBJS-$(CONFIG_CROPDETECT_FILTER) += vf_cropdetect.o · 205 unmodified lines
206206 OBJS-$(CONFIG_CUE_FILTER) += f_cue.o
207207 OBJS-$(CONFIG_CURVES_FILTER) += vf_curves.o
208208 OBJS-$(CONFIG_DATASCOPE_FILTER) += vf_datascope.o
209+OBJS-$(CONFIG_DBLUR_FILTER) += vf_dblur.o
209210 OBJS-$(CONFIG_DCTDNOIZ_FILTER) += vf_dctdnoiz.o
210211 OBJS-$(CONFIG_DEBAND_FILTER) += vf_deband.o
211212 OBJS-$(CONFIG_DEBLOCK_FILTER) += vf_deblock.o
libavfilter/allfilters.c+1−0
@@ -194,6 +194,7 @@ extern AVFilter ff_vf_cropdetect; · 193 unmodified lines
194194 extern AVFilter ff_vf_cue;
195195 extern AVFilter ff_vf_curves;
196196 extern AVFilter ff_vf_datascope;
197+extern AVFilter ff_vf_dblur;
197198 extern AVFilter ff_vf_dctdnoiz;
198199 extern AVFilter ff_vf_deband;
199200 extern AVFilter ff_vf_deblock;
libavfilter/version.h+1−1
@@ -30,7 +30,7 @@ · 29 unmodified lines
3030 #include "libavutil/version.h"
3131
3232 #define LIBAVFILTER_VERSION_MAJOR 7
33−#define LIBAVFILTER_VERSION_MINOR 83
33+#define LIBAVFILTER_VERSION_MINOR 84
3434 #define LIBAVFILTER_VERSION_MICRO 100
3535
3636
libavfilter/vf_dblur.c+307−0
@@ -0,0 +1,307 @@
1+/*
2+ * Copyright (c) 2020 Paul B Mahol
3+ *
4+ * This file is part of FFmpeg.
5+ *
6+ * FFmpeg is free software; you can redistribute it and/or
7+ * modify it under the terms of the GNU Lesser General Public
8+ * License as published by the Free Software Foundation; either
9+ * version 2.1 of the License, or (at your option) any later version.
10+ *
11+ * FFmpeg is distributed in the hope that it will be useful,
12+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
13+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14+ * Lesser General Public License for more details.
15+ *
16+ * You should have received a copy of the GNU Lesser General Public
17+ * License along with FFmpeg; if not, write to the Free Software
18+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19+ */
20+
21+#include "libavutil/imgutils.h"
22+#include "libavutil/opt.h"
23+#include "libavutil/pixdesc.h"
24+#include "avfilter.h"
25+#include "formats.h"
26+#include "internal.h"
27+#include "video.h"
28+
29+typedef struct DBlurContext {
30+ const AVClass *class;
31+
32+ float angle;
33+ float radius;
34+ int planes;
35+
36+ float b0, b1, q, c, R3;
37+
38+ int depth;
39+ int planewidth[4];
40+ int planeheight[4];
41+ float *buffer;
42+ int nb_planes;
43+ void (*horiz_slice)(float *buffer, int width, int height, int steps, float nu, float bscale);
44+} DBlurContext;
45+
46+#define OFFSET(x) offsetof(DBlurContext, x)
47+#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
48+
49+static const AVOption dblur_options[] = {
50+ { "angle", "set angle", OFFSET(angle), AV_OPT_TYPE_FLOAT, {.dbl=45}, 0.0, 360, FLAGS },
51+ { "radius", "set radius", OFFSET(radius), AV_OPT_TYPE_FLOAT, {.dbl=5}, 1, 8192, FLAGS },
52+ { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
53+ { NULL }
54+};
55+
56+AVFILTER_DEFINE_CLASS(dblur);
57+
58+#define f(n, m) (dst[(n) * width + (m)])
59+
60+static int filter_horizontally(AVFilterContext *ctx, int width, int height)
61+{
62+ DBlurContext *s = ctx->priv;
63+ const float b0 = s->b0;
64+ const float b1 = s->b1;
65+ const float q = s->q;
66+ const float c = s->c;
67+ float *dst = s->buffer;
68+ float g;
69+
70+ if (s->R3 > 0) {
71+ for (int y = 1; y < height - 1; y++) {
72+ g = q * f(0, 0) + c * f(0, 0);
73+ for (int x = 0; x < width; x++) {
74+ f(y, x) = b0 * f(y, x) + b1 * f(y - 1, x) + g;
75+ g = q * f(y, x) + c * f(y - 1, x);
76+ }
77+ }
78+
79+ for (int y = height - 2; y >= 0; y--) {
80+ g = q * f(y, width - 1) + c * f(y, width - 1);
81+ for (int x = width - 1; x >= 0; x--) {
82+ f(y, x) = b0 * f(y, x) + b1 * f(y + 1, x) + g;
83+ g = q * f(y, x) + c * f(y + 1, x);
84+ }
85+ }
86+ } else {
87+ for (int y = 1; y < height - 1; y++) {
88+ g = q * f(0, width - 1) + c * f(0, width - 1);
89+ for (int x = width - 1; x >= 0; x--) {
90+ f(y, x) = b0 * f(y, x) + b1 * f(y - 1, x) + g;
91+ g = q * f(y, x) + c * f(y - 1, x);
92+ }
93+ }
94+
95+ for (int y = height - 2; y >= 0; y--) {
96+ g = q * f(y, 0) + c * f(y, 0);
97+ for (int x = 0; x < width; x++) {
98+ f(y, x) = b0 * f(y, x) + b1 * f(y + 1, x) + g;
99+ g = q * f(y, x) + c * f(y + 1, x);
100+ }
101+ }
102+ }
103+
104+ return 0;
105+}
106+
107+static void diriir2d(AVFilterContext *ctx, int plane)
108+{
109+ DBlurContext *s = ctx->priv;
110+ const int width = s->planewidth[plane];
111+ const int height = s->planeheight[plane];
112+
113+ filter_horizontally(ctx, width, height);
114+}
115+
116+static int query_formats(AVFilterContext *ctx)
117+{
118+ static const enum AVPixelFormat pix_fmts[] = {
119+ AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
120+ AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
121+ AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
122+ AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
123+ AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
124+ AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
125+ AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
126+ AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
127+ AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
128+ AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
129+ AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
130+ AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
131+ AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
132+ AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
133+ AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
134+ AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
135+ AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
136+ AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
137+ AV_PIX_FMT_NONE
138+ };
139+
140+ return ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
141+}
142+
143+static int config_input(AVFilterLink *inlink)
144+{
145+ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
146+ DBlurContext *s = inlink->dst->priv;
147+
148+ s->depth = desc->comp[0].depth;
149+ s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
150+ s->planewidth[0] = s->planewidth[3] = inlink->w;
151+ s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
152+ s->planeheight[0] = s->planeheight[3] = inlink->h;
153+
154+ s->nb_planes = av_pix_fmt_count_planes(inlink->format);
155+
156+ s->buffer = av_malloc_array(FFALIGN(inlink->w, 16), FFALIGN(inlink->h, 16) * sizeof(*s->buffer));
157+ if (!s->buffer)
158+ return AVERROR(ENOMEM);
159+
160+ return 0;
161+}
162+
163+static void set_params(DBlurContext *s, float angle, float r)
164+{
165+ float mu, nu, R1, R2, w1, w2;
166+ float a0, a1, a2, a3;
167+
168+ angle = angle * M_PI / 180.f;
169+
170+ mu = cosf(angle);
171+ nu = sinf(angle);
172+ R1 = (mu * r) * (mu * r);
173+ R2 = (nu * r) * (nu * r);
174+ s->R3 = mu * nu * r * r;
175+ w1 = sqrtf(0.25f + R1);
176+ w2 = sqrtf(0.25f + R2);
177+ a0 = (w1 + 0.5f) * (w2 + 0.5f) - fabsf(s->R3);
178+ a1 = 0.5f + w2 - a0;
179+ a2 = 0.5f + w1 - a0;
180+ a3 = a0 - w1 - w2;
181+ s->b0 = 1.f / a0;
182+ s->b1 = -a2 / a0;
183+ s->q = -a1 / a0;
184+ s->c = -a3 / a0;
185+}
186+
187+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
188+{
189+ AVFilterContext *ctx = inlink->dst;
190+ DBlurContext *s = ctx->priv;
191+ AVFilterLink *outlink = ctx->outputs[0];
192+ AVFrame *out;
193+ int plane;
194+
195+ set_params(s, s->angle, s->radius);
196+
197+ if (av_frame_is_writable(in)) {
198+ out = in;
199+ } else {
200+ out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
201+ if (!out) {
202+ av_frame_free(&in);
203+ return AVERROR(ENOMEM);
204+ }
205+ av_frame_copy_props(out, in);
206+ }
207+
208+ for (plane = 0; plane < s->nb_planes; plane++) {
209+ const int height = s->planeheight[plane];
210+ const int width = s->planewidth[plane];
211+ float *bptr = s->buffer;
212+ const uint8_t *src = in->data[plane];
213+ const uint16_t *src16 = (const uint16_t *)in->data[plane];
214+ uint8_t *dst = out->data[plane];
215+ uint16_t *dst16 = (uint16_t *)out->data[plane];
216+ int y, x;
217+
218+ if (!(s->planes & (1 << plane))) {
219+ if (out != in)
220+ av_image_copy_plane(out->data[plane], out->linesize[plane],
221+ in->data[plane], in->linesize[plane],
222+ width * ((s->depth + 7) / 8), height);
223+ continue;
224+ }
225+
226+ if (s->depth == 8) {
227+ for (y = 0; y < height; y++) {
228+ for (x = 0; x < width; x++) {
229+ bptr[x] = src[x];
230+ }
231+ bptr += width;
232+ src += in->linesize[plane];
233+ }
234+ } else {
235+ for (y = 0; y < height; y++) {
236+ for (x = 0; x < width; x++) {
237+ bptr[x] = src16[x];
238+ }
239+ bptr += width;
240+ src16 += in->linesize[plane] / 2;
241+ }
242+ }
243+
244+ diriir2d(ctx, plane);
245+
246+ bptr = s->buffer;
247+ if (s->depth == 8) {
248+ for (y = 0; y < height; y++) {
249+ for (x = 0; x < width; x++) {
250+ dst[x] = bptr[x];
251+ }
252+ bptr += width;
253+ dst += out->linesize[plane];
254+ }
255+ } else {
256+ for (y = 0; y < height; y++) {
257+ for (x = 0; x < width; x++) {
258+ dst16[x] = bptr[x];
259+ }
260+ bptr += width;
261+ dst16 += out->linesize[plane] / 2;
262+ }
263+ }
264+ }
265+
266+ if (out != in)
267+ av_frame_free(&in);
268+ return ff_filter_frame(outlink, out);
269+}
270+
271+static av_cold void uninit(AVFilterContext *ctx)
272+{
273+ DBlurContext *s = ctx->priv;
274+
275+ av_freep(&s->buffer);
276+}
277+
278+static const AVFilterPad dblur_inputs[] = {
279+ {
280+ .name = "default",
281+ .type = AVMEDIA_TYPE_VIDEO,
282+ .config_props = config_input,
283+ .filter_frame = filter_frame,
284+ },
285+ { NULL }
286+};
287+
288+static const AVFilterPad dblur_outputs[] = {
289+ {
290+ .name = "default",
291+ .type = AVMEDIA_TYPE_VIDEO,
292+ },
293+ { NULL }
294+};
295+
296+AVFilter ff_vf_dblur = {
297+ .name = "dblur",
298+ .description = NULL_IF_CONFIG_SMALL("Apply Directional Blur filter."),
299+ .priv_size = sizeof(DBlurContext),
300+ .priv_class = &dblur_class,
301+ .uninit = uninit,
302+ .query_formats = query_formats,
303+ .inputs = dblur_inputs,
304+ .outputs = dblur_outputs,
305+ .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
306+ .process_command = ff_filter_process_command,
307+};

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t