1 /*
2 * Copyright (c) 2016 Paul B Mahol
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a copy
5 * of this software and associated documentation files (the "Software"), to deal
6 * in the Software without restriction, including without limitation the rights
7 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8 * copies of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20 * SOFTWARE.
21 */
22
23 #include "libavutil/avassert.h"
24 #include "libavutil/imgutils.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/pixdesc.h"
27 #include "avfilter.h"
28 #include "formats.h"
29 #include "internal.h"
30 #include "video.h"
31
32 typedef struct AverageBlurContext {
33 const AVClass *class;
34
35 int radius;
36 int radiusV;
37 int planes;
38
39 int depth;
40 int max;
41 int area;
42 int planewidth[4];
43 int planeheight[4];
44 void *buffer;
45 uint16_t lut[256 * 256 * 256];
46 int nb_planes;
47
48 int (*filter[2])(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
49 } AverageBlurContext;
50
51 #define OFFSET(x) offsetof(AverageBlurContext, x)
52 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
53
54 static const AVOption avgblur_options[] = {
55 { "sizeX", "set horizontal size", OFFSET(radius), AV_OPT_TYPE_INT, {.i64=1}, 1, 1024, FLAGS },
56 { "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=0xF}, 0, 0xF, FLAGS },
57 { "sizeY", "set vertical size", OFFSET(radiusV), AV_OPT_TYPE_INT, {.i64=0}, 0, 1024, FLAGS },
58 { NULL }
59 };
60
61 AVFILTER_DEFINE_CLASS(avgblur);
62
63 typedef struct ThreadData {
64 int height;
65 int width;
66 const void *ptr;
67 void *dptr;
68 int linesize, dlinesize;
69 } ThreadData;
70
71 #define LUT_DIV(sum, area) (lut[(sum)])
72 #define SLOW_DIV(sum, area) ((sum) / (area))
73
74 #define FILTER(name, type, btype, lutunused, areaunused, lutdiv) \
75 static int filter_##name(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \
76 { \
77 AverageBlurContext *s = ctx->priv; \
78 ThreadData *td = arg; \
79 areaunused const int area = s->area; \
80 lutunused const uint16_t *lut = s->lut; \
81 const int size_w = s->radius; \
82 const int size_h = s->radiusV; \
83 btype *col_sum = (btype *)s->buffer + size_w; \
84 const int dlinesize = td->dlinesize / sizeof(type); \
85 const int linesize = td->linesize / sizeof(type); \
86 const int height = td->height; \
87 const int width = td->width; \
88 const type *src = td->ptr; \
89 type *dst = td->dptr; \
90 btype sum = 0; \
91 \
92 for (int x = -size_w; x < 0; x++) { \
93 sum = src[0] * size_h; \
94 for (int y = 0; y <= size_h; y++) \
95 sum += src[y * linesize]; \
96 av_assert2(sum >= 0); \
97 col_sum[x] = sum; \
98 } \
99 \
100 for (int x = 0; x < width; x++) { \
101 sum = src[x] * size_h; \
102 for (int y = 0; y <= size_h; y++) \
103 sum += src[x + y * linesize]; \
104 av_assert2(sum >= 0); \
105 col_sum[x] = sum; \
106 } \
107 \
108 for (int x = width; x < width + size_w; x++) { \
109 sum = src[width - 1] * size_h; \
110 for (int y = 0; y <= size_h; y++) \
111 sum += src[width - 1 + y * linesize]; \
112 av_assert2(sum >= 0); \
113 col_sum[x] = sum; \
114 } \
115 \
116 sum = 0; \
117 for (int x = -size_w; x <= size_w; x++) \
118 sum += col_sum[x]; \
119 av_assert2(sum >= 0); \
120 dst[0] = lutdiv(sum, area); \
121 \
122 for (int x = 1; x < width; x++) { \
123 sum = sum - col_sum[x - size_w - 1] + col_sum[x + size_w]; \
124 av_assert2(sum >= 0); \
125 dst[x] = lutdiv(sum, area); \
126 } \
127 \
128 src = td->ptr; \
129 src += linesize; \
130 dst += dlinesize; \
131 \
132 for (int y = 1; y < height; y++) { \
133 const int syp = FFMIN(size_h, height - y - 1) * linesize; \
134 const int syn = FFMIN(y, size_h + 1) * linesize; \
135 \
136 sum = 0; \
137 \
138 for (int x = -size_w; x < 0; x++) \
139 col_sum[x] += src[0 + syp] - src[0 - syn]; \
140 \
141 for (int x = 0; x < width; x++) \
142 col_sum[x] += src[x + syp] - src[x - syn]; \
143 \
144 for (int x = width; x < width + size_w; x++) \
145 col_sum[x] += src[width - 1 + syp] - src[width - 1 - syn]; \
146 \
147 for (int x = -size_w; x <= size_w; x++) \
148 sum += col_sum[x]; \
149 av_assert2(sum >= 0); \
150 dst[0] = lutdiv(sum, area); \
151 \
152 for (int x = 1; x < width; x++) { \
153 sum = sum - col_sum[x - size_w - 1] + col_sum[x + size_w]; \
154 av_assert2(sum >= 0); \
155 dst[x] = lutdiv(sum, area); \
156 } \
157 \
158 src += linesize; \
159 dst += dlinesize; \
160 } \
161 \
162 return 0; \
163 }
164
165 FILTER(lut8, uint8_t, int32_t, , av_unused, LUT_DIV)
166 FILTER(lut16, uint16_t, int64_t, , av_unused, LUT_DIV)
167
168 FILTER(slow8, uint8_t, int32_t, av_unused, , SLOW_DIV)
169 FILTER(slow16, uint16_t, int64_t, av_unused, , SLOW_DIV)
170
build_lut(AVFilterContext * ctx,int max)171 static void build_lut(AVFilterContext *ctx, int max)
172 {
173 AverageBlurContext *s = ctx->priv;
174 const int area = (2 * s->radiusV + 1) * (2 * s->radius + 1);
175
176 s->area = area;
177 if (max * area >= FF_ARRAY_ELEMS(s->lut))
178 return;
179
180 for (int i = 0, j = 0, k = 0; i < max * area; i++, j++) {
181 if (j == area) {
182 k++;
183 j = 0;
184 }
185
186 s->lut[i] = k;
187 }
188 }
189
uninit(AVFilterContext * ctx)190 static av_cold void uninit(AVFilterContext *ctx)
191 {
192 AverageBlurContext *s = ctx->priv;
193
194 av_freep(&s->buffer);
195 }
196
config_input(AVFilterLink * inlink)197 static int config_input(AVFilterLink *inlink)
198 {
199 AVFilterContext *ctx = inlink->dst;
200 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
201 AverageBlurContext *s = ctx->priv;
202
203 uninit(ctx);
204
205 s->depth = desc->comp[0].depth;
206 s->max = 1 << s->depth;
207 s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
208 s->planewidth[0] = s->planewidth[3] = inlink->w;
209 s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
210 s->planeheight[0] = s->planeheight[3] = inlink->h;
211
212 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
213
214 s->buffer = av_calloc(inlink->w + (1024 * 2 + 1), 4 * ((s->depth + 7) / 8));
215 if (!s->buffer)
216 return AVERROR(ENOMEM);
217
218 if (s->radiusV <= 0)
219 s->radiusV = s->radius;
220
221 s->filter[0] = s->depth <= 8 ? filter_lut8 : filter_lut16;
222 s->filter[1] = s->depth <= 8 ? filter_slow8 : filter_slow16;
223
224 s->radius = FFMIN(s->planewidth[1] / 2, s->radius);
225 s->radiusV = FFMIN(s->planeheight[1] / 2, s->radiusV);
226
227 build_lut(ctx, s->max);
228
229 return 0;
230 }
231
averageiir2d(AVFilterContext * ctx,AVFrame * in,AVFrame * out,int plane)232 static void averageiir2d(AVFilterContext *ctx, AVFrame *in, AVFrame *out, int plane)
233 {
234 AverageBlurContext *s = ctx->priv;
235 const int width = s->planewidth[plane];
236 const int height = s->planeheight[plane];
237 const int slow = (s->max * s->area) >= FF_ARRAY_ELEMS(s->lut);
238 ThreadData td;
239
240 td.width = width;
241 td.height = height;
242 td.ptr = in->data[plane];
243 td.linesize = in->linesize[plane];
244 td.dptr = out->data[plane];
245 td.dlinesize = out->linesize[plane];
246 s->filter[slow](ctx, &td, 0, 0);
247 }
248
249 static const enum AVPixelFormat pix_fmts[] = {
250 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
251 AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
252 AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
253 AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
254 AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
255 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
256 AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
257 AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
258 AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
259 AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
260 AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
261 AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
262 AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
263 AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
264 AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
265 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
266 AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
267 AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
268 AV_PIX_FMT_NONE
269 };
270
filter_frame(AVFilterLink * inlink,AVFrame * in)271 static int filter_frame(AVFilterLink *inlink, AVFrame *in)
272 {
273 AVFilterContext *ctx = inlink->dst;
274 AverageBlurContext *s = ctx->priv;
275 AVFilterLink *outlink = ctx->outputs[0];
276 AVFrame *out;
277 int plane;
278
279 out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
280 if (!out) {
281 av_frame_free(&in);
282 return AVERROR(ENOMEM);
283 }
284 av_frame_copy_props(out, in);
285
286 for (plane = 0; plane < s->nb_planes; plane++) {
287 const int height = s->planeheight[plane];
288 const int width = s->planewidth[plane];
289
290 if (!(s->planes & (1 << plane))) {
291 if (out != in)
292 av_image_copy_plane(out->data[plane], out->linesize[plane],
293 in->data[plane], in->linesize[plane],
294 width * ((s->depth + 7) / 8), height);
295 continue;
296 }
297
298 averageiir2d(ctx, in, out, plane);
299 }
300
301 av_frame_free(&in);
302 return ff_filter_frame(outlink, out);
303 }
304
process_command(AVFilterContext * ctx,const char * cmd,const char * args,char * res,int res_len,int flags)305 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
306 char *res, int res_len, int flags)
307 {
308 AverageBlurContext *s = ctx->priv;
309 const int area = s->area;
310 int ret;
311
312 ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
313 if (ret < 0)
314 return ret;
315
316 if (s->radiusV <= 0)
317 s->radiusV = s->radius;
318
319 s->radius = FFMIN(s->planewidth[1] / 2, s->radius);
320 s->radiusV = FFMIN(s->planeheight[1] / 2, s->radiusV);
321
322 if (area != (2 * s->radiusV + 1) * (2 * s->radius + 1))
323 build_lut(ctx, s->max);
324
325 return 0;
326 }
327
328 static const AVFilterPad avgblur_inputs[] = {
329 {
330 .name = "default",
331 .type = AVMEDIA_TYPE_VIDEO,
332 .config_props = config_input,
333 .filter_frame = filter_frame,
334 },
335 };
336
337 static const AVFilterPad avgblur_outputs[] = {
338 {
339 .name = "default",
340 .type = AVMEDIA_TYPE_VIDEO,
341 },
342 };
343
344 const AVFilter ff_vf_avgblur = {
345 .name = "avgblur",
346 .description = NULL_IF_CONFIG_SMALL("Apply Average Blur filter."),
347 .priv_size = sizeof(AverageBlurContext),
348 .priv_class = &avgblur_class,
349 .uninit = uninit,
350 FILTER_INPUTS(avgblur_inputs),
351 FILTER_OUTPUTS(avgblur_outputs),
352 FILTER_PIXFMTS_ARRAY(pix_fmts),
353 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
354 .process_command = process_command,
355 };
356