FFmpeg
vf_removelogo.c
Go to the documentation of this file.
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;
89  int mask_w, mask_h;
90 
91  uint8_t *full_mask_data;
93  uint8_t *half_mask_data;
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 
207 {
208  static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
210 }
211 
212 static int load_mask(uint8_t **mask, int *w, int *h,
213  const char *filename, void *log_ctx)
214 {
215  int ret;
216  enum AVPixelFormat pix_fmt;
217  uint8_t *src_data[4], *gray_data[4];
218  int src_linesize[4], gray_linesize[4];
219 
220  /* load image from file */
221  if ((ret = ff_load_image(src_data, src_linesize, w, h, &pix_fmt, filename, log_ctx)) < 0)
222  return ret;
223 
224  /* convert the image to GRAY8 */
225  if ((ret = ff_scale_image(gray_data, gray_linesize, *w, *h, AV_PIX_FMT_GRAY8,
226  src_data, src_linesize, *w, *h, pix_fmt,
227  log_ctx)) < 0)
228  goto end;
229 
230  /* copy mask to a newly allocated array */
231  *mask = av_malloc(*w * *h);
232  if (!*mask)
233  ret = AVERROR(ENOMEM);
234  av_image_copy_plane(*mask, *w, gray_data[0], gray_linesize[0], *w, *h);
235 
236 end:
237  av_freep(&src_data[0]);
238  av_freep(&gray_data[0]);
239  return ret;
240 }
241 
242 /**
243  * Generate a scaled down image with half width, height, and intensity.
244  *
245  * This function not only scales down an image, but halves the value
246  * in each pixel too. The purpose of this is to produce a chroma
247  * filter image out of a luma filter image. The pixel values store the
248  * distance to the edge of the logo and halving the dimensions halves
249  * the distance. This function rounds up, because a downwards rounding
250  * error could cause the filter to fail, but an upwards rounding error
251  * will only cause a minor amount of excess blur in the chroma planes.
252  */
253 static void generate_half_size_image(const uint8_t *src_data, int src_linesize,
254  uint8_t *dst_data, int dst_linesize,
255  int src_w, int src_h,
256  int *max_mask_size)
257 {
258  int x, y;
259 
260  /* Copy over the image data, using the average of 4 pixels for to
261  * calculate each downsampled pixel. */
262  for (y = 0; y < src_h/2; y++) {
263  for (x = 0; x < src_w/2; x++) {
264  /* Set the pixel if there exists a non-zero value in the
265  * source pixels, else clear it. */
266  dst_data[(y * dst_linesize) + x] =
267  src_data[((y << 1) * src_linesize) + (x << 1)] ||
268  src_data[((y << 1) * src_linesize) + (x << 1) + 1] ||
269  src_data[(((y << 1) + 1) * src_linesize) + (x << 1)] ||
270  src_data[(((y << 1) + 1) * src_linesize) + (x << 1) + 1];
271  dst_data[(y * dst_linesize) + x] = FFMIN(1, dst_data[(y * dst_linesize) + x]);
272  }
273  }
274 
275  convert_mask_to_strength_mask(dst_data, dst_linesize,
276  src_w/2, src_h/2, 0, max_mask_size);
277 }
278 
280 {
281  RemovelogoContext *s = ctx->priv;
282  int ***mask;
283  int ret = 0;
284  int a, b, c, w, h;
285  int full_max_mask_size, half_max_mask_size;
286 
287  if (!s->filename) {
288  av_log(ctx, AV_LOG_ERROR, "The bitmap file name is mandatory\n");
289  return AVERROR(EINVAL);
290  }
291 
292  /* Load our mask image. */
293  if ((ret = load_mask(&s->full_mask_data, &w, &h, s->filename, ctx)) < 0)
294  return ret;
295  s->mask_w = w;
296  s->mask_h = h;
297 
298  convert_mask_to_strength_mask(s->full_mask_data, w, w, h,
299  16, &full_max_mask_size);
300 
301  /* Create the scaled down mask image for the chroma planes. */
302  if (!(s->half_mask_data = av_mallocz(w/2 * h/2)))
303  return AVERROR(ENOMEM);
304  generate_half_size_image(s->full_mask_data, w,
305  s->half_mask_data, w/2,
306  w, h, &half_max_mask_size);
307 
308  s->max_mask_size = FFMAX(full_max_mask_size, half_max_mask_size);
309 
310  /* Create a circular mask for each size up to max_mask_size. When
311  the filter is applied, the mask size is determined on a pixel
312  by pixel basis, with pixels nearer the edge of the logo getting
313  smaller mask sizes. */
314  mask = (int ***)av_malloc_array(s->max_mask_size + 1, sizeof(int **));
315  if (!mask)
316  return AVERROR(ENOMEM);
317 
318  for (a = 0; a <= s->max_mask_size; a++) {
319  mask[a] = (int **)av_malloc_array((a * 2) + 1, sizeof(int *));
320  if (!mask[a]) {
321  av_free(mask);
322  return AVERROR(ENOMEM);
323  }
324  for (b = -a; b <= a; b++) {
325  mask[a][b + a] = (int *)av_malloc_array((a * 2) + 1, sizeof(int));
326  if (!mask[a][b + a]) {
327  av_free(mask);
328  return AVERROR(ENOMEM);
329  }
330  for (c = -a; c <= a; c++) {
331  if ((b * b) + (c * c) <= (a * a)) /* Circular 0/1 mask. */
332  mask[a][b + a][c + a] = 1;
333  else
334  mask[a][b + a][c + a] = 0;
335  }
336  }
337  }
338  s->mask = mask;
339 
340  /* Calculate our bounding rectangles, which determine in what
341  * region the logo resides for faster processing. */
342  ff_calculate_bounding_box(&s->full_mask_bbox, s->full_mask_data, w, w, h, 0, 8);
343  ff_calculate_bounding_box(&s->half_mask_bbox, s->half_mask_data, w/2, w/2, h/2, 0, 8);
344 
345 #define SHOW_LOGO_INFO(mask_type) \
346  av_log(ctx, AV_LOG_VERBOSE, #mask_type " x1:%d x2:%d y1:%d y2:%d max_mask_size:%d\n", \
347  s->mask_type##_mask_bbox.x1, s->mask_type##_mask_bbox.x2, \
348  s->mask_type##_mask_bbox.y1, s->mask_type##_mask_bbox.y2, \
349  mask_type##_max_mask_size);
350  SHOW_LOGO_INFO(full);
352 
353  return 0;
354 }
355 
357 {
358  AVFilterContext *ctx = inlink->dst;
359  RemovelogoContext *s = ctx->priv;
360 
361  if (inlink->w != s->mask_w || inlink->h != s->mask_h) {
363  "Mask image size %dx%d does not match with the input video size %dx%d\n",
364  s->mask_w, s->mask_h, inlink->w, inlink->h);
365  return AVERROR(EINVAL);
366  }
367 
368  return 0;
369 }
370 
371 /**
372  * Blur image.
373  *
374  * It takes a pixel that is inside the mask and blurs it. It does so
375  * by finding the average of all the pixels within the mask and
376  * outside of the mask.
377  *
378  * @param mask_data the mask plane to use for averaging
379  * @param image_data the image plane to blur
380  * @param w width of the image
381  * @param h height of the image
382  * @param x x-coordinate of the pixel to blur
383  * @param y y-coordinate of the pixel to blur
384  */
385 static unsigned int blur_pixel(int ***mask,
386  const uint8_t *mask_data, int mask_linesize,
387  uint8_t *image_data, int image_linesize,
388  int w, int h, int x, int y)
389 {
390  /* Mask size tells how large a circle to use. The radius is about
391  * (slightly larger than) mask size. */
392  int mask_size;
393  int start_posx, start_posy, end_posx, end_posy;
394  int i, j;
395  unsigned int accumulator = 0, divisor = 0;
396  /* What pixel we are reading out of the circular blur mask. */
397  const uint8_t *image_read_position;
398  /* What pixel we are reading out of the filter image. */
399  const uint8_t *mask_read_position;
400 
401  /* Prepare our bounding rectangle and clip it if need be. */
402  mask_size = mask_data[y * mask_linesize + x];
403  start_posx = FFMAX(0, x - mask_size);
404  start_posy = FFMAX(0, y - mask_size);
405  end_posx = FFMIN(w - 1, x + mask_size);
406  end_posy = FFMIN(h - 1, y + mask_size);
407 
408  image_read_position = image_data + image_linesize * start_posy + start_posx;
409  mask_read_position = mask_data + mask_linesize * start_posy + start_posx;
410 
411  for (j = start_posy; j <= end_posy; j++) {
412  for (i = start_posx; i <= end_posx; i++) {
413  /* Check if this pixel is in the mask or not. Only use the
414  * pixel if it is not. */
415  if (!(*mask_read_position) && mask[mask_size][i - start_posx][j - start_posy]) {
416  accumulator += *image_read_position;
417  divisor++;
418  }
419 
420  image_read_position++;
421  mask_read_position++;
422  }
423 
424  image_read_position += (image_linesize - ((end_posx + 1) - start_posx));
425  mask_read_position += (mask_linesize - ((end_posx + 1) - start_posx));
426  }
427 
428  /* If divisor is 0, it means that not a single pixel is outside of
429  the logo, so we have no data. Else we need to normalise the
430  data using the divisor. */
431  return divisor == 0 ? 255:
432  (accumulator + (divisor / 2)) / divisor; /* divide, taking into account average rounding error */
433 }
434 
435 /**
436  * Blur image plane using a mask.
437  *
438  * @param source The image to have it's logo removed.
439  * @param destination Where the output image will be stored.
440  * @param source_stride How far apart (in memory) two consecutive lines are.
441  * @param destination Same as source_stride, but for the destination image.
442  * @param width Width of the image. This is the same for source and destination.
443  * @param height Height of the image. This is the same for source and destination.
444  * @param is_image_direct If the image is direct, then source and destination are
445  * the same and we can save a lot of time by not copying pixels that
446  * haven't changed.
447  * @param filter The image that stores the distance to the edge of the logo for
448  * each pixel.
449  * @param logo_start_x smallest x-coordinate that contains at least 1 logo pixel.
450  * @param logo_start_y smallest y-coordinate that contains at least 1 logo pixel.
451  * @param logo_end_x largest x-coordinate that contains at least 1 logo pixel.
452  * @param logo_end_y largest y-coordinate that contains at least 1 logo pixel.
453  *
454  * This function processes an entire plane. Pixels outside of the logo are copied
455  * to the output without change, and pixels inside the logo have the de-blurring
456  * function applied.
457  */
458 static void blur_image(int ***mask,
459  const uint8_t *src_data, int src_linesize,
460  uint8_t *dst_data, int dst_linesize,
461  const uint8_t *mask_data, int mask_linesize,
462  int w, int h, int direct,
463  FFBoundingBox *bbox)
464 {
465  int x, y;
466  uint8_t *dst_line;
467  const uint8_t *src_line;
468 
469  if (!direct)
470  av_image_copy_plane(dst_data, dst_linesize, src_data, src_linesize, w, h);
471 
472  for (y = bbox->y1; y <= bbox->y2; y++) {
473  src_line = src_data + src_linesize * y;
474  dst_line = dst_data + dst_linesize * y;
475 
476  for (x = bbox->x1; x <= bbox->x2; x++) {
477  if (mask_data[y * mask_linesize + x]) {
478  /* Only process if we are in the mask. */
479  dst_line[x] = blur_pixel(mask,
480  mask_data, mask_linesize,
481  dst_data, dst_linesize,
482  w, h, x, y);
483  } else {
484  /* Else just copy the data. */
485  if (!direct)
486  dst_line[x] = src_line[x];
487  }
488  }
489  }
490 }
491 
492 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
493 {
494  RemovelogoContext *s = inlink->dst->priv;
495  AVFilterLink *outlink = inlink->dst->outputs[0];
496  AVFrame *outpicref;
497  int direct = 0;
498 
499  if (av_frame_is_writable(inpicref)) {
500  direct = 1;
501  outpicref = inpicref;
502  } else {
503  outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
504  if (!outpicref) {
505  av_frame_free(&inpicref);
506  return AVERROR(ENOMEM);
507  }
508  av_frame_copy_props(outpicref, inpicref);
509  }
510 
511  blur_image(s->mask,
512  inpicref ->data[0], inpicref ->linesize[0],
513  outpicref->data[0], outpicref->linesize[0],
514  s->full_mask_data, inlink->w,
515  inlink->w, inlink->h, direct, &s->full_mask_bbox);
516  blur_image(s->mask,
517  inpicref ->data[1], inpicref ->linesize[1],
518  outpicref->data[1], outpicref->linesize[1],
519  s->half_mask_data, inlink->w/2,
520  inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
521  blur_image(s->mask,
522  inpicref ->data[2], inpicref ->linesize[2],
523  outpicref->data[2], outpicref->linesize[2],
524  s->half_mask_data, inlink->w/2,
525  inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
526 
527  if (!direct)
528  av_frame_free(&inpicref);
529 
530  return ff_filter_frame(outlink, outpicref);
531 }
532 
534 {
535  RemovelogoContext *s = ctx->priv;
536  int a, b;
537 
538  av_freep(&s->full_mask_data);
539  av_freep(&s->half_mask_data);
540 
541  if (s->mask) {
542  /* Loop through each mask. */
543  for (a = 0; a <= s->max_mask_size; a++) {
544  /* Loop through each scanline in a mask. */
545  for (b = -a; b <= a; b++) {
546  av_freep(&s->mask[a][b + a]); /* Free a scanline. */
547  }
548  av_freep(&s->mask[a]);
549  }
550  /* Free the array of pointers pointing to the masks. */
551  av_freep(&s->mask);
552  }
553 }
554 
555 static const AVFilterPad removelogo_inputs[] = {
556  {
557  .name = "default",
558  .type = AVMEDIA_TYPE_VIDEO,
559  .config_props = config_props_input,
560  .filter_frame = filter_frame,
561  },
562 };
563 
564 static const AVFilterPad removelogo_outputs[] = {
565  {
566  .name = "default",
567  .type = AVMEDIA_TYPE_VIDEO,
568  },
569 };
570 
572  .name = "removelogo",
573  .description = NULL_IF_CONFIG_SMALL("Remove a TV logo based on a mask image."),
574  .priv_size = sizeof(RemovelogoContext),
575  .init = init,
576  .uninit = uninit,
580  .priv_class = &removelogo_class,
582 };
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:98
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(removelogo)
direct
static void direct(const float *in, const FFTComplex *ir, int len, float *out)
Definition: af_afir.c:61
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
bbox.h
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1019
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
removelogo_inputs
static const AVFilterPad removelogo_inputs[]
Definition: vf_removelogo.c:555
RemovelogoContext::full_mask_bbox
FFBoundingBox full_mask_bbox
Definition: vf_removelogo.c:92
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
ff_calculate_bounding_box
int ff_calculate_bounding_box(FFBoundingBox *bbox, const uint8_t *data, int linesize, int w, int h, int min_val, int depth)
Calculate the smallest rectangle that will encompass the region with values > min_val.
Definition: bbox.c:81
w
uint8_t w
Definition: llviddspenc.c:38
OFFSET
#define OFFSET(x)
Definition: vf_removelogo.c:97
RemovelogoContext::mask_w
int mask_w
Definition: vf_removelogo.c:89
convert_mask_to_strength_mask
static void convert_mask_to_strength_mask(uint8_t *data, int linesize, int w, int h, int min_val, int *max_mask_size)
Pre-process an image to give distance information.
Definition: vf_removelogo.c:133
AVOption
AVOption.
Definition: opt.h:247
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
half
static uint8_t half(int a, int b)
Definition: mobiclip.c:541
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
Definition: vf_removelogo.c:492
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:153
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
config_props_input
static int config_props_input(AVFilterLink *inlink)
Definition: vf_removelogo.c:356
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
formats.h
blur_pixel
static unsigned int blur_pixel(int ***mask, const uint8_t *mask_data, int mask_linesize, uint8_t *image_data, int image_linesize, int w, int h, int x, int y)
Blur image.
Definition: vf_removelogo.c:385
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:50
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
s
#define s(width, name)
Definition: cbs_vp9.c:257
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:703
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
ctx
AVFormatContext * ctx
Definition: movenc.c:48
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
removelogo_options
static const AVOption removelogo_options[]
Definition: vf_removelogo.c:99
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:152
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:537
RemovelogoContext::mask_h
int mask_h
Definition: vf_removelogo.c:89
apply_mask_fudge_factor
#define apply_mask_fudge_factor(x)
Choose a slightly larger mask size to improve performance.
Definition: vf_removelogo.c:117
RemovelogoContext::half_mask_data
uint8_t * half_mask_data
Definition: vf_removelogo.c:93
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
accumulator
#define accumulator
Definition: phase_template.c:34
RemovelogoContext::half_mask_bbox
FFBoundingBox half_mask_bbox
Definition: vf_removelogo.c:94
FFBoundingBox::x1
int x1
Definition: bbox.h:27
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_removelogo.c:206
RemovelogoContext::max_mask_size
int max_mask_size
Definition: vf_removelogo.c:88
SHOW_LOGO_INFO
#define SHOW_LOGO_INFO(mask_type)
blur_image
static void blur_image(int ***mask, const uint8_t *src_data, int src_linesize, uint8_t *dst_data, int dst_linesize, const uint8_t *mask_data, int mask_linesize, int w, int h, int direct, FFBoundingBox *bbox)
Blur image plane using a mask.
Definition: vf_removelogo.c:458
av_frame_is_writable
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:473
ff_load_image
int ff_load_image(uint8_t *data[4], int linesize[4], int *w, int *h, enum AVPixelFormat *pix_fmt, const char *filename, void *log_ctx)
Load image from filename and put the resulting image in data.
Definition: lavfutils.c:34
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
internal.h
AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC
Some filters support a generic "enable" expression option that can be used to enable or disable a fil...
Definition: avfilter.h:130
i
int i
Definition: input.c:406
FFBoundingBox::y1
int y1
Definition: bbox.h:27
RemovelogoContext::mask
int *** mask
Definition: vf_removelogo.c:87
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_removelogo.c:533
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_vf_removelogo
const AVFilter ff_vf_removelogo
Definition: vf_removelogo.c:571
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:56
AVFilter
Filter definition.
Definition: avfilter.h:149
ret
ret
Definition: filter_design.txt:187
generate_half_size_image
static void generate_half_size_image(const uint8_t *src_data, int src_linesize, uint8_t *dst_data, int dst_linesize, int src_w, int src_h, int *max_mask_size)
Generate a scaled down image with half width, height, and intensity.
Definition: vf_removelogo.c:253
RemovelogoContext
This code implements a filter to remove annoying TV logos and other annoying images placed onto a vid...
Definition: vf_removelogo.c:82
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
avfilter.h
lavfutils.h
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_removelogo.c:279
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFBoundingBox
Definition: bbox.h:26
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
removelogo_outputs
static const AVFilterPad removelogo_outputs[]
Definition: vf_removelogo.c:564
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:153
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
RemovelogoContext::filename
char * filename
Definition: vf_removelogo.c:84
load_mask
static int load_mask(uint8_t **mask, int *w, int *h, const char *filename, void *log_ctx)
Definition: vf_removelogo.c:212
FLAGS
#define FLAGS
Definition: vf_removelogo.c:98
h
h
Definition: vp9dsp_template.c:2038
RemovelogoContext::full_mask_data
uint8_t * full_mask_data
Definition: vf_removelogo.c:91
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:228
int
int
Definition: ffmpeg_filter.c:156
ff_scale_image
int ff_scale_image(uint8_t *dst_data[4], int dst_linesize[4], int dst_w, int dst_h, enum AVPixelFormat dst_pix_fmt, uint8_t *const src_data[4], int src_linesize[4], int src_w, int src_h, enum AVPixelFormat src_pix_fmt, void *log_ctx)
Scale image using libswscale.
Definition: lswsutils.c:22
lswsutils.h