FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 
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 };
209  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
210  if (!fmts_list)
211  return AVERROR(ENOMEM);
212  return ff_set_common_formats(ctx, fmts_list);
213 }
214 
215 static int load_mask(uint8_t **mask, int *w, int *h,
216  const char *filename, void *log_ctx)
217 {
218  int ret;
219  enum AVPixelFormat pix_fmt;
220  uint8_t *src_data[4], *gray_data[4];
221  int src_linesize[4], gray_linesize[4];
222 
223  /* load image from file */
224  if ((ret = ff_load_image(src_data, src_linesize, w, h, &pix_fmt, filename, log_ctx)) < 0)
225  return ret;
226 
227  /* convert the image to GRAY8 */
228  if ((ret = ff_scale_image(gray_data, gray_linesize, *w, *h, AV_PIX_FMT_GRAY8,
229  src_data, src_linesize, *w, *h, pix_fmt,
230  log_ctx)) < 0)
231  goto end;
232 
233  /* copy mask to a newly allocated array */
234  *mask = av_malloc(*w * *h);
235  if (!*mask)
236  ret = AVERROR(ENOMEM);
237  av_image_copy_plane(*mask, *w, gray_data[0], gray_linesize[0], *w, *h);
238 
239 end:
240  av_freep(&src_data[0]);
241  av_freep(&gray_data[0]);
242  return ret;
243 }
244 
245 /**
246  * Generate a scaled down image with half width, height, and intensity.
247  *
248  * This function not only scales down an image, but halves the value
249  * in each pixel too. The purpose of this is to produce a chroma
250  * filter image out of a luma filter image. The pixel values store the
251  * distance to the edge of the logo and halving the dimensions halves
252  * the distance. This function rounds up, because a downwards rounding
253  * error could cause the filter to fail, but an upwards rounding error
254  * will only cause a minor amount of excess blur in the chroma planes.
255  */
256 static void generate_half_size_image(const uint8_t *src_data, int src_linesize,
257  uint8_t *dst_data, int dst_linesize,
258  int src_w, int src_h,
259  int *max_mask_size)
260 {
261  int x, y;
262 
263  /* Copy over the image data, using the average of 4 pixels for to
264  * calculate each downsampled pixel. */
265  for (y = 0; y < src_h/2; y++) {
266  for (x = 0; x < src_w/2; x++) {
267  /* Set the pixel if there exists a non-zero value in the
268  * source pixels, else clear it. */
269  dst_data[(y * dst_linesize) + x] =
270  src_data[((y << 1) * src_linesize) + (x << 1)] ||
271  src_data[((y << 1) * src_linesize) + (x << 1) + 1] ||
272  src_data[(((y << 1) + 1) * src_linesize) + (x << 1)] ||
273  src_data[(((y << 1) + 1) * src_linesize) + (x << 1) + 1];
274  dst_data[(y * dst_linesize) + x] = FFMIN(1, dst_data[(y * dst_linesize) + x]);
275  }
276  }
277 
278  convert_mask_to_strength_mask(dst_data, dst_linesize,
279  src_w/2, src_h/2, 0, max_mask_size);
280 }
281 
283 {
284  RemovelogoContext *s = ctx->priv;
285  int ***mask;
286  int ret = 0;
287  int a, b, c, w, h;
288  int full_max_mask_size, half_max_mask_size;
289 
290  if (!s->filename) {
291  av_log(ctx, AV_LOG_ERROR, "The bitmap file name is mandatory\n");
292  return AVERROR(EINVAL);
293  }
294 
295  /* Load our mask image. */
296  if ((ret = load_mask(&s->full_mask_data, &w, &h, s->filename, ctx)) < 0)
297  return ret;
298  s->mask_w = w;
299  s->mask_h = h;
300 
302  16, &full_max_mask_size);
303 
304  /* Create the scaled down mask image for the chroma planes. */
305  if (!(s->half_mask_data = av_mallocz(w/2 * h/2)))
306  return AVERROR(ENOMEM);
308  s->half_mask_data, w/2,
309  w, h, &half_max_mask_size);
310 
311  s->max_mask_size = FFMAX(full_max_mask_size, half_max_mask_size);
312 
313  /* Create a circular mask for each size up to max_mask_size. When
314  the filter is applied, the mask size is determined on a pixel
315  by pixel basis, with pixels nearer the edge of the logo getting
316  smaller mask sizes. */
317  mask = (int ***)av_malloc_array(s->max_mask_size + 1, sizeof(int **));
318  if (!mask)
319  return AVERROR(ENOMEM);
320 
321  for (a = 0; a <= s->max_mask_size; a++) {
322  mask[a] = (int **)av_malloc_array((a * 2) + 1, sizeof(int *));
323  if (!mask[a]) {
324  av_free(mask);
325  return AVERROR(ENOMEM);
326  }
327  for (b = -a; b <= a; b++) {
328  mask[a][b + a] = (int *)av_malloc_array((a * 2) + 1, sizeof(int));
329  if (!mask[a][b + a]) {
330  av_free(mask);
331  return AVERROR(ENOMEM);
332  }
333  for (c = -a; c <= a; c++) {
334  if ((b * b) + (c * c) <= (a * a)) /* Circular 0/1 mask. */
335  mask[a][b + a][c + a] = 1;
336  else
337  mask[a][b + a][c + a] = 0;
338  }
339  }
340  }
341  s->mask = mask;
342 
343  /* Calculate our bounding rectangles, which determine in what
344  * region the logo resides for faster processing. */
346  ff_calculate_bounding_box(&s->half_mask_bbox, s->half_mask_data, w/2, w/2, h/2, 0);
347 
348 #define SHOW_LOGO_INFO(mask_type) \
349  av_log(ctx, AV_LOG_VERBOSE, #mask_type " x1:%d x2:%d y1:%d y2:%d max_mask_size:%d\n", \
350  s->mask_type##_mask_bbox.x1, s->mask_type##_mask_bbox.x2, \
351  s->mask_type##_mask_bbox.y1, s->mask_type##_mask_bbox.y2, \
352  mask_type##_max_mask_size);
353  SHOW_LOGO_INFO(full);
354  SHOW_LOGO_INFO(half);
355 
356  return 0;
357 }
358 
359 static int config_props_input(AVFilterLink *inlink)
360 {
361  AVFilterContext *ctx = inlink->dst;
362  RemovelogoContext *s = ctx->priv;
363 
364  if (inlink->w != s->mask_w || inlink->h != s->mask_h) {
365  av_log(ctx, AV_LOG_INFO,
366  "Mask image size %dx%d does not match with the input video size %dx%d\n",
367  s->mask_w, s->mask_h, inlink->w, inlink->h);
368  return AVERROR(EINVAL);
369  }
370 
371  return 0;
372 }
373 
374 /**
375  * Blur image.
376  *
377  * It takes a pixel that is inside the mask and blurs it. It does so
378  * by finding the average of all the pixels within the mask and
379  * outside of the mask.
380  *
381  * @param mask_data the mask plane to use for averaging
382  * @param image_data the image plane to blur
383  * @param w width of the image
384  * @param h height of the image
385  * @param x x-coordinate of the pixel to blur
386  * @param y y-coordinate of the pixel to blur
387  */
388 static unsigned int blur_pixel(int ***mask,
389  const uint8_t *mask_data, int mask_linesize,
390  uint8_t *image_data, int image_linesize,
391  int w, int h, int x, int y)
392 {
393  /* Mask size tells how large a circle to use. The radius is about
394  * (slightly larger than) mask size. */
395  int mask_size;
396  int start_posx, start_posy, end_posx, end_posy;
397  int i, j;
398  unsigned int accumulator = 0, divisor = 0;
399  /* What pixel we are reading out of the circular blur mask. */
400  const uint8_t *image_read_position;
401  /* What pixel we are reading out of the filter image. */
402  const uint8_t *mask_read_position;
403 
404  /* Prepare our bounding rectangle and clip it if need be. */
405  mask_size = mask_data[y * mask_linesize + x];
406  start_posx = FFMAX(0, x - mask_size);
407  start_posy = FFMAX(0, y - mask_size);
408  end_posx = FFMIN(w - 1, x + mask_size);
409  end_posy = FFMIN(h - 1, y + mask_size);
410 
411  image_read_position = image_data + image_linesize * start_posy + start_posx;
412  mask_read_position = mask_data + mask_linesize * start_posy + start_posx;
413 
414  for (j = start_posy; j <= end_posy; j++) {
415  for (i = start_posx; i <= end_posx; i++) {
416  /* Check if this pixel is in the mask or not. Only use the
417  * pixel if it is not. */
418  if (!(*mask_read_position) && mask[mask_size][i - start_posx][j - start_posy]) {
419  accumulator += *image_read_position;
420  divisor++;
421  }
422 
423  image_read_position++;
424  mask_read_position++;
425  }
426 
427  image_read_position += (image_linesize - ((end_posx + 1) - start_posx));
428  mask_read_position += (mask_linesize - ((end_posx + 1) - start_posx));
429  }
430 
431  /* If divisor is 0, it means that not a single pixel is outside of
432  the logo, so we have no data. Else we need to normalise the
433  data using the divisor. */
434  return divisor == 0 ? 255:
435  (accumulator + (divisor / 2)) / divisor; /* divide, taking into account average rounding error */
436 }
437 
438 /**
439  * Blur image plane using a mask.
440  *
441  * @param source The image to have it's logo removed.
442  * @param destination Where the output image will be stored.
443  * @param source_stride How far apart (in memory) two consecutive lines are.
444  * @param destination Same as source_stride, but for the destination image.
445  * @param width Width of the image. This is the same for source and destination.
446  * @param height Height of the image. This is the same for source and destination.
447  * @param is_image_direct If the image is direct, then source and destination are
448  * the same and we can save a lot of time by not copying pixels that
449  * haven't changed.
450  * @param filter The image that stores the distance to the edge of the logo for
451  * each pixel.
452  * @param logo_start_x smallest x-coordinate that contains at least 1 logo pixel.
453  * @param logo_start_y smallest y-coordinate that contains at least 1 logo pixel.
454  * @param logo_end_x largest x-coordinate that contains at least 1 logo pixel.
455  * @param logo_end_y largest y-coordinate that contains at least 1 logo pixel.
456  *
457  * This function processes an entire plane. Pixels outside of the logo are copied
458  * to the output without change, and pixels inside the logo have the de-blurring
459  * function applied.
460  */
461 static void blur_image(int ***mask,
462  const uint8_t *src_data, int src_linesize,
463  uint8_t *dst_data, int dst_linesize,
464  const uint8_t *mask_data, int mask_linesize,
465  int w, int h, int direct,
466  FFBoundingBox *bbox)
467 {
468  int x, y;
469  uint8_t *dst_line;
470  const uint8_t *src_line;
471 
472  if (!direct)
473  av_image_copy_plane(dst_data, dst_linesize, src_data, src_linesize, w, h);
474 
475  for (y = bbox->y1; y <= bbox->y2; y++) {
476  src_line = src_data + src_linesize * y;
477  dst_line = dst_data + dst_linesize * y;
478 
479  for (x = bbox->x1; x <= bbox->x2; x++) {
480  if (mask_data[y * mask_linesize + x]) {
481  /* Only process if we are in the mask. */
482  dst_line[x] = blur_pixel(mask,
483  mask_data, mask_linesize,
484  dst_data, dst_linesize,
485  w, h, x, y);
486  } else {
487  /* Else just copy the data. */
488  if (!direct)
489  dst_line[x] = src_line[x];
490  }
491  }
492  }
493 }
494 
495 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
496 {
497  RemovelogoContext *s = inlink->dst->priv;
498  AVFilterLink *outlink = inlink->dst->outputs[0];
499  AVFrame *outpicref;
500  int direct = 0;
501 
502  if (av_frame_is_writable(inpicref)) {
503  direct = 1;
504  outpicref = inpicref;
505  } else {
506  outpicref = ff_get_video_buffer(outlink, outlink->w, outlink->h);
507  if (!outpicref) {
508  av_frame_free(&inpicref);
509  return AVERROR(ENOMEM);
510  }
511  av_frame_copy_props(outpicref, inpicref);
512  }
513 
514  blur_image(s->mask,
515  inpicref ->data[0], inpicref ->linesize[0],
516  outpicref->data[0], outpicref->linesize[0],
517  s->full_mask_data, inlink->w,
518  inlink->w, inlink->h, direct, &s->full_mask_bbox);
519  blur_image(s->mask,
520  inpicref ->data[1], inpicref ->linesize[1],
521  outpicref->data[1], outpicref->linesize[1],
522  s->half_mask_data, inlink->w/2,
523  inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
524  blur_image(s->mask,
525  inpicref ->data[2], inpicref ->linesize[2],
526  outpicref->data[2], outpicref->linesize[2],
527  s->half_mask_data, inlink->w/2,
528  inlink->w/2, inlink->h/2, direct, &s->half_mask_bbox);
529 
530  if (!direct)
531  av_frame_free(&inpicref);
532 
533  return ff_filter_frame(outlink, outpicref);
534 }
535 
537 {
538  RemovelogoContext *s = ctx->priv;
539  int a, b;
540 
543 
544  if (s->mask) {
545  /* Loop through each mask. */
546  for (a = 0; a <= s->max_mask_size; a++) {
547  /* Loop through each scanline in a mask. */
548  for (b = -a; b <= a; b++) {
549  av_freep(&s->mask[a][b + a]); /* Free a scanline. */
550  }
551  av_freep(&s->mask[a]);
552  }
553  /* Free the array of pointers pointing to the masks. */
554  av_freep(&s->mask);
555  }
556 }
557 
558 static const AVFilterPad removelogo_inputs[] = {
559  {
560  .name = "default",
561  .type = AVMEDIA_TYPE_VIDEO,
562  .config_props = config_props_input,
563  .filter_frame = filter_frame,
564  },
565  { NULL }
566 };
567 
568 static const AVFilterPad removelogo_outputs[] = {
569  {
570  .name = "default",
571  .type = AVMEDIA_TYPE_VIDEO,
572  },
573  { NULL }
574 };
575 
577  .name = "removelogo",
578  .description = NULL_IF_CONFIG_SMALL("Remove a TV logo based on a mask image."),
579  .priv_size = sizeof(RemovelogoContext),
580  .init = init,
581  .uninit = uninit,
583  .inputs = removelogo_inputs,
584  .outputs = removelogo_outputs,
585  .priv_class = &removelogo_class,
587 };
#define NULL
Definition: coverity.c:32
static enum AVPixelFormat pix_fmt
This code implements a filter to remove annoying TV logos and other annoying images placed onto a vid...
Definition: vf_removelogo.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
AVFILTER_DEFINE_CLASS(removelogo)
misc image utilities
Main libavfilter public API header.
Miscellaneous utilities which make use of the libswscale library.
const char * b
Definition: vf_curves.c:116
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.
AVFilter ff_vf_removelogo
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
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.
#define SHOW_LOGO_INFO(mask_type)
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
#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:125
uint8_t * half_mask_data
Definition: vf_removelogo.c:93
const char * name
Pad name.
Definition: internal.h:60
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
static av_cold void uninit(AVFilterContext *ctx)
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVOptions.
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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
FFBoundingBox full_mask_bbox
Definition: vf_removelogo.c:92
#define av_log(a,...)
A filter pad used for either input or output.
Definition: internal.h:54
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
static const uint16_t mask[17]
Definition: lzw.c:38
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
#define apply_mask_fudge_factor(x)
Choose a slightly larger mask size to improve performance.
static const AVFilterPad removelogo_outputs[]
static av_cold int init(AVFilterContext *ctx)
#define FFMAX(a, b)
Definition: common.h:94
uint8_t * full_mask_data
Definition: vf_removelogo.c:91
static const AVOption removelogo_options[]
Definition: vf_removelogo.c:99
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.
#define FFMIN(a, b)
Definition: common.h:96
uint8_t w
Definition: llviddspenc.c:38
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
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:24
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.
static const AVFilterPad inputs[]
Definition: af_acontrast.c:193
int y1
Definition: bbox.h:27
#define OFFSET(x)
Definition: vf_removelogo.c:97
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
Definition: frame.c:594
static const AVFilterPad removelogo_inputs[]
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:257
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
const char * name
Filter name.
Definition: avfilter.h:148
static int config_props_input(AVFilterLink *inlink)
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
#define flags(name, subs,...)
Definition: cbs_av1.c:596
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
int ff_calculate_bounding_box(FFBoundingBox *bbox, const uint8_t *data, int linesize, int w, int h, int min_val)
Calculate the smallest rectangle that will encompass the region with values > min_val.
Definition: bbox.c:23
static double c[64]
#define av_free(p)
static int load_mask(uint8_t **mask, int *w, int *h, const char *filename, void *log_ctx)
A list of supported formats for one end of a filter link.
Definition: formats.h:64
int x1
Definition: bbox.h:27
An instance of a filter.
Definition: avfilter.h:338
#define av_freep(p)
static int query_formats(AVFilterContext *ctx)
#define av_malloc_array(a, b)
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:338
internal API functions
FFBoundingBox half_mask_bbox
Definition: vf_removelogo.c:94
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define FLAGS
Definition: vf_removelogo.c:98
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
Miscellaneous utilities which make use of the libavformat library.