FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_removelogo.c
Date: 2022-12-05 03:11:11
Exec Total Coverage
Lines: 0 162 0.0%
Functions: 0 9 0.0%
Branches: 0 98 0.0%

Line Branch Exec Source
1 /*
2 * Copyright (c) 2005 Robert Edele <yartrebo@earthlink.net>
3 * Copyright (c) 2012 Stefano Sabatini
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file
24 * Advanced blur-based logo removing filter
25 *
26 * This filter loads an image mask file showing where a logo is and
27 * uses a blur transform to remove the logo.
28 *
29 * Based on the libmpcodecs remove-logo filter by Robert Edele.
30 */
31
32 /**
33 * This code implements a filter to remove annoying TV logos and other annoying
34 * images placed onto a video stream. It works by filling in the pixels that
35 * comprise the logo with neighboring pixels. The transform is very loosely
36 * based on a gaussian blur, but it is different enough to merit its own
37 * paragraph later on. It is a major improvement on the old delogo filter as it
38 * both uses a better blurring algorithm and uses a bitmap to use an arbitrary
39 * and generally much tighter fitting shape than a rectangle.
40 *
41 * The logo removal algorithm has two key points. The first is that it
42 * distinguishes between pixels in the logo and those not in the logo by using
43 * the passed-in bitmap. Pixels not in the logo are copied over directly without
44 * being modified and they also serve as source pixels for the logo
45 * fill-in. Pixels inside the logo have the mask applied.
46 *
47 * At init-time the bitmap is reprocessed internally, and the distance to the
48 * nearest edge of the logo (Manhattan distance), along with a little extra to
49 * remove rough edges, is stored in each pixel. This is done using an in-place
50 * erosion algorithm, and incrementing each pixel that survives any given
51 * erosion. Once every pixel is eroded, the maximum value is recorded, and a
52 * set of masks from size 0 to this size are generaged. The masks are circular
53 * binary masks, where each pixel within a radius N (where N is the size of the
54 * mask) is a 1, and all other pixels are a 0. Although a gaussian mask would be
55 * more mathematically accurate, a binary mask works better in practice because
56 * we generally do not use the central pixels in the mask (because they are in
57 * the logo region), and thus a gaussian mask will cause too little blur and
58 * thus a very unstable image.
59 *
60 * The mask is applied in a special way. Namely, only pixels in the mask that
61 * line up to pixels outside the logo are used. The dynamic mask size means that
62 * the mask is just big enough so that the edges touch pixels outside the logo,
63 * so the blurring is kept to a minimum and at least the first boundary
64 * condition is met (that the image function itself is continuous), even if the
65 * second boundary condition (that the derivative of the image function is
66 * continuous) is not met. A masking algorithm that does preserve the second
67 * boundary coundition (perhaps something based on a highly-modified bi-cubic
68 * algorithm) should offer even better results on paper, but the noise in a
69 * typical TV signal should make anything based on derivatives hopelessly noisy.
70 */
71
72 #include "libavutil/imgutils.h"
73 #include "libavutil/opt.h"
74 #include "avfilter.h"
75 #include "formats.h"
76 #include "internal.h"
77 #include "video.h"
78 #include "bbox.h"
79 #include "lavfutils.h"
80 #include "lswsutils.h"
81
82 typedef struct RemovelogoContext {
83 const AVClass *class;
84 char *filename;
85 /* Stores our collection of masks. The first is for an array of
86 the second for the y axis, and the third for the x axis. */
87 int ***mask;
88 int max_mask_size;
89 int mask_w, mask_h;
90
91 uint8_t *full_mask_data;
92 FFBoundingBox full_mask_bbox;
93 uint8_t *half_mask_data;
94 FFBoundingBox half_mask_bbox;
95 } RemovelogoContext;
96
97 #define OFFSET(x) offsetof(RemovelogoContext, x)
98 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
99 static const AVOption removelogo_options[] = {
100 { "filename", "set bitmap filename", OFFSET(filename), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
101 { "f", "set bitmap filename", OFFSET(filename), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
102 { NULL }
103 };
104
105 AVFILTER_DEFINE_CLASS(removelogo);
106
107 /**
108 * Choose a slightly larger mask size to improve performance.
109 *
110 * This function maps the absolute minimum mask size needed to the
111 * mask size we'll actually use. f(x) = x (the smallest that will
112 * work) will produce the sharpest results, but will be quite
113 * jittery. f(x) = 1.25x (what I'm using) is a good tradeoff in my
114 * opinion. This will calculate only at init-time, so you can put a
115 * long expression here without effecting performance.
116 */
117 #define apply_mask_fudge_factor(x) (((x) >> 2) + (x))
118
119 /**
120 * Pre-process an image to give distance information.
121 *
122 * This function takes a bitmap image and converts it in place into a
123 * distance image. A distance image is zero for pixels outside of the
124 * logo and is the Manhattan distance (|dx| + |dy|) from the logo edge
125 * for pixels inside of the logo. This will overestimate the distance,
126 * but that is safe, and is far easier to implement than a proper
127 * pythagorean distance since I'm using a modified erosion algorithm
128 * to compute the distances.
129 *
130 * @param mask image which will be converted from a greyscale image
131 * into a distance image.
132 */
133 static void convert_mask_to_strength_mask(uint8_t *data, int linesize,
134 int w, int h, int min_val,
135 int *max_mask_size)
136 {
137 int x, y;
138
139 /* How many times we've gone through the loop. Used in the
140 in-place erosion algorithm and to get us max_mask_size later on. */
141 int current_pass = 0;
142
143 /* set all non-zero values to 1 */
144 for (y = 0; y < h; y++)
145 for (x = 0; x < w; x++)
146 data[y*linesize + x] = data[y*linesize + x] > min_val;
147
148 /* For each pass, if a pixel is itself the same value as the
149 current pass, and its four neighbors are too, then it is
150 incremented. If no pixels are incremented by the end of the
151 pass, then we go again. Edge pixels are counted as always
152 excluded (this should be true anyway for any sane mask, but if
153 it isn't this will ensure that we eventually exit). */
154 while (1) {
155 /* If this doesn't get set by the end of this pass, then we're done. */
156 int has_anything_changed = 0;
157 uint8_t *current_pixel0 = data + 1 + linesize, *current_pixel;
158 current_pass++;
159
160 for (y = 1; y < h-1; y++) {
161 current_pixel = current_pixel0;
162 for (x = 1; x < w-1; x++) {
163 /* Apply the in-place erosion transform. It is based
164 on the following two premises:
165 1 - Any pixel that fails 1 erosion will fail all
166 future erosions.
167
168 2 - Only pixels having survived all erosions up to
169 the present will be >= to current_pass.
170 It doesn't matter if it survived the current pass,
171 failed it, or hasn't been tested yet. By using >=
172 instead of ==, we allow the algorithm to work in
173 place. */
174 if ( *current_pixel >= current_pass &&
175 *(current_pixel + 1) >= current_pass &&
176 *(current_pixel - 1) >= current_pass &&
177 *(current_pixel + linesize) >= current_pass &&
178 *(current_pixel - linesize) >= current_pass) {
179 /* Increment the value since it still has not been
180 * eroded, as evidenced by the if statement that
181 * just evaluated to true. */
182 (*current_pixel)++;
183 has_anything_changed = 1;
184 }
185 current_pixel++;
186 }
187 current_pixel0 += linesize;
188 }
189 if (!has_anything_changed)
190 break;
191 }
192
193 /* Apply the fudge factor, which will increase the size of the
194 * mask a little to reduce jitter at the cost of more blur. */
195 for (y = 1; y < h - 1; y++)
196 for (x = 1; x < w - 1; x++)
197 data[(y * linesize) + x] = apply_mask_fudge_factor(data[(y * linesize) + x]);
198
199 /* As a side-effect, we now know the maximum mask size, which
200 * we'll use to generate our masks. */
201 /* Apply the fudge factor to this number too, since we must ensure
202 * that enough masks are generated. */
203 *max_mask_size = apply_mask_fudge_factor(current_pass + 1);
204 }
205
206 static int load_mask(uint8_t **mask, int *w, int *h,
207 const char *filename, void *log_ctx)
208 {
209 int ret;
210 enum AVPixelFormat pix_fmt;
211 uint8_t *src_data[4], *gray_data[4];
212 int src_linesize[4], gray_linesize[4];
213
214 /* load image from file */
215 if ((ret = ff_load_image(src_data, src_linesize, w, h, &pix_fmt, filename, log_ctx)) < 0)
216 return ret;
217
218 /* convert the image to GRAY8 */
219 if ((ret = ff_scale_image(gray_data, gray_linesize, *w, *h, AV_PIX_FMT_GRAY8,
220 src_data, src_linesize, *w, *h, pix_fmt,
221 log_ctx)) < 0)
222 goto end;
223
224 /* copy mask to a newly allocated array */
225 *mask = av_malloc(*w * *h);
226 if (!*mask)
227 ret = AVERROR(ENOMEM);
228 av_image_copy_plane(*mask, *w, gray_data[0], gray_linesize[0], *w, *h);
229
230 end:
231 av_freep(&src_data[0]);
232 av_freep(&gray_data[0]);
233 return ret;
234 }
235
236 /**
237 * Generate a scaled down image with half width, height, and intensity.
238 *
239 * This function not only scales down an image, but halves the value
240 * in each pixel too. The purpose of this is to produce a chroma
241 * filter image out of a luma filter image. The pixel values store the
242 * distance to the edge of the logo and halving the dimensions halves
243 * the distance. This function rounds up, because a downwards rounding
244 * error could cause the filter to fail, but an upwards rounding error
245 * will only cause a minor amount of excess blur in the chroma planes.
246 */
247 static void generate_half_size_image(const uint8_t *src_data, int src_linesize,
248 uint8_t *dst_data, int dst_linesize,
249 int src_w, int src_h,
250 int *max_mask_size)
251 {
252 int x, y;
253
254 /* Copy over the image data, using the average of 4 pixels for to
255 * calculate each downsampled pixel. */
256 for (y = 0; y < src_h/2; y++) {
257 for (x = 0; x < src_w/2; x++) {
258 /* Set the pixel if there exists a non-zero value in the
259 * source pixels, else clear it. */
260 dst_data[(y * dst_linesize) + x] =
261 src_data[((y << 1) * src_linesize) + (x << 1)] ||
262 src_data[((y << 1) * src_linesize) + (x << 1) + 1] ||
263 src_data[(((y << 1) + 1) * src_linesize) + (x << 1)] ||
264 src_data[(((y << 1) + 1) * src_linesize) + (x << 1) + 1];
265 dst_data[(y * dst_linesize) + x] = FFMIN(1, dst_data[(y * dst_linesize) + x]);
266 }
267 }
268
269 convert_mask_to_strength_mask(dst_data, dst_linesize,
270 src_w/2, src_h/2, 0, max_mask_size);
271 }
272
273 static av_cold int init(AVFilterContext *ctx)
274 {
275 RemovelogoContext *s = ctx->priv;
276 int ***mask;
277 int ret = 0;
278 int a, b, c, w, h;
279 int full_max_mask_size, half_max_mask_size;
280
281 if (!s->filename) {
282 av_log(ctx, AV_LOG_ERROR, "The bitmap file name is mandatory\n");
283 return AVERROR(EINVAL);
284 }
285
286 /* Load our mask image. */
287 if ((ret = load_mask(&s->full_mask_data, &w, &h, s->filename, ctx)) < 0)
288 return ret;
289 s->mask_w = w;
290 s->mask_h = h;
291
292 convert_mask_to_strength_mask(s->full_mask_data, w, w, h,
293 16, &full_max_mask_size);
294
295 /* Create the scaled down mask image for the chroma planes. */
296 if (!(s->half_mask_data = av_mallocz(w/2 * h/2)))
297 return AVERROR(ENOMEM);
298 generate_half_size_image(s->full_mask_data, w,
299 s->half_mask_data, w/2,
300 w, h, &half_max_mask_size);
301
302 s->max_mask_size = FFMAX(full_max_mask_size, half_max_mask_size);
303
304 /* Create a circular mask for each size up to max_mask_size. When
305 the filter is applied, the mask size is determined on a pixel
306 by pixel basis, with pixels nearer the edge of the logo getting
307 smaller mask sizes. */
308 mask = (int ***)av_malloc_array(s->max_mask_size + 1, sizeof(int **));
309 if (!mask)
310 return AVERROR(ENOMEM);
311
312 for (a = 0; a <= s->max_mask_size; a++) {
313 mask[a] = (int **)av_malloc_array((a * 2) + 1, sizeof(int *));
314 if (!mask[a]) {
315 av_free(mask);
316 return AVERROR(ENOMEM);
317 }
318 for (b = -a; b <= a; b++) {
319 mask[a][b + a] = (int *)av_malloc_array((a * 2) + 1, sizeof(int));
320 if (!mask[a][b + a]) {
321 av_free(mask);
322 return AVERROR(ENOMEM);
323 }
324 for (c = -a; c <= a; c++) {
325 if ((b * b) + (c * c) <= (a * a)) /* Circular 0/1 mask. */
326 mask[a][b + a][c + a] = 1;
327 else
328 mask[a][b + a][c + a] = 0;
329 }
330 }
331 }
332 s->mask = mask;
333
334 /* Calculate our bounding rectangles, which determine in what
335 * region the logo resides for faster processing. */
336 ff_calculate_bounding_box(&s->full_mask_bbox, s->full_mask_data, w, w, h, 0, 8);
337 ff_calculate_bounding_box(&s->half_mask_bbox, s->half_mask_data, w/2, w/2, h/2, 0, 8);
338
339 #define SHOW_LOGO_INFO(mask_type) \
340 av_log(ctx, AV_LOG_VERBOSE, #mask_type " x1:%d x2:%d y1:%d y2:%d max_mask_size:%d\n", \
341 s->mask_type##_mask_bbox.x1, s->mask_type##_mask_bbox.x2, \
342 s->mask_type##_mask_bbox.y1, s->mask_type##_mask_bbox.y2, \
343 mask_type##_max_mask_size);
344 SHOW_LOGO_INFO(full);
345 SHOW_LOGO_INFO(half);
346
347 return 0;
348 }
349
350 static int config_props_input(AVFilterLink *inlink)
351 {
352 AVFilterContext *ctx = inlink->dst;
353 RemovelogoContext *s = ctx->priv;
354
355 if (inlink->w != s->mask_w || inlink->h != s->mask_h) {
356 av_log(ctx, AV_LOG_INFO,
357 "Mask image size %dx%d does not match with the input video size %dx%d\n",
358 s->mask_w, s->mask_h, inlink->w, inlink->h);
359 return AVERROR(EINVAL);
360 }
361
362 return 0;
363 }
364
365 /**
366 * Blur image.
367 *
368 * It takes a pixel that is inside the mask and blurs it. It does so
369 * by finding the average of all the pixels within the mask and
370 * outside of the mask.
371 *
372 * @param mask_data the mask plane to use for averaging
373 * @param image_data the image plane to blur
374 * @param w width of the image
375 * @param h height of the image
376 * @param x x-coordinate of the pixel to blur
377 * @param y y-coordinate of the pixel to blur
378 */
379 static unsigned int blur_pixel(int ***mask,
380 const uint8_t *mask_data, int mask_linesize,
381 uint8_t *image_data, int image_linesize,
382 int w, int h, int x, int y)
383 {
384 /* Mask size tells how large a circle to use. The radius is about
385 * (slightly larger than) mask size. */
386 int mask_size;
387 int start_posx, start_posy, end_posx, end_posy;
388 int i, j;
389 unsigned int accumulator = 0, divisor = 0;
390 /* What pixel we are reading out of the circular blur mask. */
391 const uint8_t *image_read_position;
392 /* What pixel we are reading out of the filter image. */
393 const uint8_t *mask_read_position;
394
395 /* Prepare our bounding rectangle and clip it if need be. */
396 mask_size = mask_data[y * mask_linesize + x];
397 start_posx = FFMAX(0, x - mask_size);
398 start_posy = FFMAX(0, y - mask_size);
399 end_posx = FFMIN(w - 1, x + mask_size);
400 end_posy = FFMIN(h - 1, y + mask_size);
401
402 image_read_position = image_data + image_linesize * start_posy + start_posx;
403 mask_read_position = mask_data + mask_linesize * start_posy + start_posx;
404
405 for (j = start_posy; j <= end_posy; j++) {
406 for (i = start_posx; i <= end_posx; i++) {
407 /* Check if this pixel is in the mask or not. Only use the
408 * pixel if it is not. */
409 if (!(*mask_read_position) && mask[mask_size][i - start_posx][j - start_posy]) {
410 accumulator += *image_read_position;
411 divisor++;
412 }
413
414 image_read_position++;
415 mask_read_position++;
416 }
417
418 image_read_position += (image_linesize - ((end_posx + 1) - start_posx));
419 mask_read_position += (mask_linesize - ((end_posx + 1) - start_posx));
420 }
421
422 /* If divisor is 0, it means that not a single pixel is outside of
423 the logo, so we have no data. Else we need to normalise the
424 data using the divisor. */
425 return divisor == 0 ? 255:
426 (accumulator + (divisor / 2)) / divisor; /* divide, taking into account average rounding error */
427 }
428
429 /**
430 * Blur image plane using a mask.
431 *
432 * @param source The image to have it's logo removed.
433 * @param destination Where the output image will be stored.
434 * @param source_stride How far apart (in memory) two consecutive lines are.
435 * @param destination Same as source_stride, but for the destination image.
436 * @param width Width of the image. This is the same for source and destination.
437 * @param height Height of the image. This is the same for source and destination.
438 * @param is_image_direct If the image is direct, then source and destination are
439 * the same and we can save a lot of time by not copying pixels that
440 * haven't changed.
441 * @param filter The image that stores the distance to the edge of the logo for
442 * each pixel.
443 * @param logo_start_x smallest x-coordinate that contains at least 1 logo pixel.
444 * @param logo_start_y smallest y-coordinate that contains at least 1 logo pixel.
445 * @param logo_end_x largest x-coordinate that contains at least 1 logo pixel.
446 * @param logo_end_y largest y-coordinate that contains at least 1 logo pixel.
447 *
448 * This function processes an entire plane. Pixels outside of the logo are copied
449 * to the output without change, and pixels inside the logo have the de-blurring
450 * function applied.
451 */
452 static void blur_image(int ***mask,
453 const uint8_t *src_data, int src_linesize,
454 uint8_t *dst_data, int dst_linesize,
455 const uint8_t *mask_data, int mask_linesize,
456 int w, int h, int direct,
457 FFBoundingBox *bbox)
458 {
459 int x, y;
460 uint8_t *dst_line;
461 const uint8_t *src_line;
462
463 if (!direct)
464 av_image_copy_plane(dst_data, dst_linesize, src_data, src_linesize, w, h);
465
466 for (y = bbox->y1; y <= bbox->y2; y++) {
467 src_line = src_data + src_linesize * y;
468 dst_line = dst_data + dst_linesize * y;
469
470 for (x = bbox->x1; x <= bbox->x2; x++) {
471 if (mask_data[y * mask_linesize + x]) {
472 /* Only process if we are in the mask. */
473 dst_line[x] = blur_pixel(mask,
474 mask_data, mask_linesize,
475 dst_data, dst_linesize,
476 w, h, x, y);
477 } else {
478 /* Else just copy the data. */
479 if (!direct)
480 dst_line[x] = src_line[x];
481 }
482 }
483 }
484 }
485
486 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
487 {
488 RemovelogoContext *s = inlink->dst->priv;
489 AVFilterLink *outlink = inlink->dst->outputs[0];
490 AVFrame *outpicref;
491 int direct = 0;
492
493 if (av_frame_is_writable(inpicref)) {
494 direct = 1;
495 outpicref = inpicref;
496 } else {
497 outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
498 if (!outpicref) {
499 av_frame_free(&inpicref);
500 return AVERROR(ENOMEM);
501 }
502 av_frame_copy_props(outpicref, inpicref);
503 }
504
505 blur_image(s->mask,
506 inpicref ->data[0], inpicref ->linesize[0],
507 outpicref->data[0], outpicref->linesize[0],
508 s->full_mask_data, inlink->w,
509 inlink->w, inlink->h, direct, &s->full_mask_bbox);
510 blur_image(s->mask,
511 inpicref ->data[1], inpicref ->linesize[1],
512 outpicref->data[1], outpicref->linesize[1],
513 s->half_mask_data, inlink->w/2,
514 inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
515 blur_image(s->mask,
516 inpicref ->data[2], inpicref ->linesize[2],
517 outpicref->data[2], outpicref->linesize[2],
518 s->half_mask_data, inlink->w/2,
519 inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
520
521 if (!direct)
522 av_frame_free(&inpicref);
523
524 return ff_filter_frame(outlink, outpicref);
525 }
526
527 static av_cold void uninit(AVFilterContext *ctx)
528 {
529 RemovelogoContext *s = ctx->priv;
530 int a, b;
531
532 av_freep(&s->full_mask_data);
533 av_freep(&s->half_mask_data);
534
535 if (s->mask) {
536 /* Loop through each mask. */
537 for (a = 0; a <= s->max_mask_size; a++) {
538 /* Loop through each scanline in a mask. */
539 for (b = -a; b <= a; b++) {
540 av_freep(&s->mask[a][b + a]); /* Free a scanline. */
541 }
542 av_freep(&s->mask[a]);
543 }
544 /* Free the array of pointers pointing to the masks. */
545 av_freep(&s->mask);
546 }
547 }
548
549 static const AVFilterPad removelogo_inputs[] = {
550 {
551 .name = "default",
552 .type = AVMEDIA_TYPE_VIDEO,
553 .config_props = config_props_input,
554 .filter_frame = filter_frame,
555 },
556 };
557
558 static const AVFilterPad removelogo_outputs[] = {
559 {
560 .name = "default",
561 .type = AVMEDIA_TYPE_VIDEO,
562 },
563 };
564
565 const AVFilter ff_vf_removelogo = {
566 .name = "removelogo",
567 .description = NULL_IF_CONFIG_SMALL("Remove a TV logo based on a mask image."),
568 .priv_size = sizeof(RemovelogoContext),
569 .init = init,
570 .uninit = uninit,
571 FILTER_INPUTS(removelogo_inputs),
572 FILTER_OUTPUTS(removelogo_outputs),
573 FILTER_SINGLE_PIXFMT(AV_PIX_FMT_YUV420P),
574 .priv_class = &removelogo_class,
575 .flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC,
576 };
577