@@ -21,6 +21,8 @@ version next:

 - tile video filter

 - Metal Gear Solid: The Twin Snakes demuxer

 - OpenEXR image decoder

+- removelogo filter

+

 version 0.10:

 - Fixes: CVE-2011-3929, CVE-2011-3934, CVE-2011-3935, CVE-2011-3936,

@@ -1688,6 +1688,7 @@ mptestsrc_filter_deps="gpl"

 negate_filter_deps="lut_filter"

 ocv_filter_deps="libopencv"

 pan_filter_deps="swresample"

+removelogo_filter_deps="avcodec avformat swscale"

 scale_filter_deps="swscale"

 tinterlace_filter_deps="gpl"

 yadif_filter_deps="gpl"

@@ -2237,6 +2237,32 @@ format=monow, pixdesctest

 can be used to test the monowhite pixel format descriptor definition.

+@section removelogo

+

+Suppress a TV station logo, using an image file to determine which

+pixels comprise the logo. It works by filling in the pixels that

+comprise the logo with neighboring pixels.

+

+This filter requires one argument which specifies the filter bitmap

+file, which can be any image format supported by libavformat. The

+width and height of the image file must match those of the video

+stream being processed.

+

+Pixels in the provided bitmap image with a value of zero are not

+considered part of the logo, non-zero pixels are considered part of

+the logo. If you use white (255) for the logo and black (0) for the

+rest, you will be safe. For making the filter bitmap, it is

+recommended to take a screen capture of a black frame with the logo

+visible, and then using a threshold filter followed by the erode

+filter once or twice.

+

+If needed, little splotches can be fixed manually. Remember that if

+logo pixels are not covered, the filter quality will be much

+reduced. Marking too many pixels as part of the logo does not hurt as

+much, but it will increase the amount of blurring needed to cover over

+the image and will destroy more information than necessary, and extra

+pixels will slow things down on a large logo.

+

 @section scale

 Scale the input video to @var{width}:@var{height}[:@var{interl}=@{1|-1@}] and/or convert the image format.

@@ -8,6 +8,7 @@ FFLIBS-$(CONFIG_AMOVIE_FILTER)               += avformat avcodec

 FFLIBS-$(CONFIG_ARESAMPLE_FILTER)            += swresample

 FFLIBS-$(CONFIG_MOVIE_FILTER)                += avformat avcodec

 FFLIBS-$(CONFIG_PAN_FILTER)                  += swresample

+FFLIBS-$(CONFIG_REMOVELOGO_FILTER)           += swscale avformat avcodec

 FFLIBS-$(CONFIG_SCALE_FILTER)                += swscale

 FFLIBS-$(CONFIG_MP_FILTER)                   += avcodec postproc

@@ -25,6 +26,8 @@ OBJS = allfilters.o                                                     \

        vsrc_buffer.o

 OBJS-$(CONFIG_AVCODEC)                       += avcodec.o

+OBJS-$(CONFIG_AVFORMAT)                      += lavfutils.o

+OBJS-$(CONFIG_SWSCALE)                       += lswsutils.o

 OBJS-$(CONFIG_ACONVERT_FILTER)               += af_aconvert.o

 OBJS-$(CONFIG_AFORMAT_FILTER)                += af_aformat.o

@@ -80,6 +83,7 @@ OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o

 OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o

 OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o

 OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o

+OBJS-$(CONFIG_REMOVELOGO_FILTER)             += bbox.o lswsutils.o lavfutils.o vf_removelogo.o

 OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o

 OBJS-$(CONFIG_SELECT_FILTER)                 += vf_select.o

 OBJS-$(CONFIG_SETDAR_FILTER)                 += vf_aspect.o

@@ -88,6 +88,7 @@ void avfilter_register_all(void)

     REGISTER_FILTER (OVERLAY,     overlay,     vf);

     REGISTER_FILTER (PAD,         pad,         vf);

     REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);

+    REGISTER_FILTER (REMOVELOGO,  removelogo,  vf);

     REGISTER_FILTER (SCALE,       scale,       vf);

     REGISTER_FILTER (SELECT,      select,      vf);

     REGISTER_FILTER (SETDAR,      setdar,      vf);

new file mode 100644

@@ -0,0 +1,95 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "libavutil/imgutils.h"

+#include "lavfutils.h"

+

+int ff_load_image(uint8_t *data[4], int linesize[4],

+                  int *w, int *h, enum PixelFormat *pix_fmt,

+                  const char *filename, void *log_ctx)

+{

+    AVInputFormat *iformat = NULL;

+    AVFormatContext *format_ctx;

+    AVCodec *codec;

+    AVCodecContext *codec_ctx;

+    AVFrame *frame;

+    int frame_decoded, ret = 0;

+    AVPacket pkt;

+

+    av_register_all();

+

+    iformat = av_find_input_format("image2");

+    if ((ret = avformat_open_input(&format_ctx, filename, iformat, NULL)) < 0) {

+        av_log(log_ctx, AV_LOG_ERROR,

+               "Failed to open input file '%s'\n", filename);

+        return ret;

+    }

+

+    codec_ctx = format_ctx->streams[0]->codec;

+    codec = avcodec_find_decoder(codec_ctx->codec_id);

+    if (!codec) {

+        av_log(log_ctx, AV_LOG_ERROR, "Failed to find codec\n");

+        ret = AVERROR(EINVAL);

+        goto end;

+    }

+

+    if ((ret = avcodec_open2(codec_ctx, codec, NULL)) < 0) {

+        av_log(log_ctx, AV_LOG_ERROR, "Failed to open codec\n");

+        goto end;

+    }

+

+    if (!(frame = avcodec_alloc_frame()) ) {

+        av_log(log_ctx, AV_LOG_ERROR, "Failed to alloc frame\n");

+        ret = AVERROR(ENOMEM);

+        goto end;

+    }

+

+    ret = av_read_frame(format_ctx, &pkt);

+    if (ret < 0) {

+        av_log(log_ctx, AV_LOG_ERROR, "Failed to read frame from file\n");

+        goto end;

+    }

+

+    ret = avcodec_decode_video2(codec_ctx, frame, &frame_decoded, &pkt);

+    if (ret < 0 || !frame_decoded) {

+        av_log(log_ctx, AV_LOG_ERROR, "Failed to decode image from file\n");

+        goto end;

+    }

+    ret = 0;

+

+    *w       = frame->width;

+    *h       = frame->height;

+    *pix_fmt = frame->format;

+

+    if ((ret = av_image_alloc(data, linesize, *w, *h, *pix_fmt, 16)) < 0)

+        goto end;

+    ret = 0;

+

+    av_image_copy(data, linesize, frame->data, frame->linesize, *pix_fmt, *w, *h);

+

+end:

+    if (codec_ctx)

+        avcodec_close(codec_ctx);

+    if (format_ctx)

+        avformat_close_input(&format_ctx);

+    av_freep(&frame);

+

+    if (ret < 0)

+        av_log(log_ctx, AV_LOG_ERROR, "Error loading image file '%s'\n", filename);

+    return ret;

+}

new file mode 100644

@@ -0,0 +1,43 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

+ * Miscellaneous utilities which make use of the libavformat library

+ */

+

+#ifndef AVFILTER_LAVFUTILS_H

+#define AVFILTER_LAVFUTILS_H

+

+#include "libavformat/avformat.h"

+

+/**

+ * Load image from filename and put the resulting image in data.

+ *

+ * @param w pointer to the width of the loaded image

+ * @param h pointer to the height of the loaded image

+ * @param pix_fmt pointer to the pixel format of the loaded image

+ * @param filename the name of the image file to load

+ * @param log_ctx log context

+ * @return 0 in case of success, a negative error code otherwise.

+ */

+int ff_load_image(uint8_t *data[4], int linesize[4],

+                  int *w, int *h, enum PixelFormat *pix_fmt,

+                  const char *filename, void *log_ctx);

+

+#endif  /* AVFILTER_LAVFUTILS_H */

new file mode 100644

@@ -0,0 +1,50 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "libavutil/imgutils.h"

+#include "lswsutils.h"

+

+int ff_scale_image(uint8_t *dst_data[4], int dst_linesize[4],

+                   int dst_w, int dst_h, enum PixelFormat dst_pix_fmt,

+                   uint8_t * const src_data[4], int src_linesize[4],

+                   int src_w, int src_h, enum PixelFormat src_pix_fmt,

+                   void *log_ctx)

+{

+    int ret;

+    struct SwsContext *sws_ctx = sws_getContext(src_w, src_h, src_pix_fmt,

+                                                dst_w, dst_h, dst_pix_fmt,

+                                                SWS_BILINEAR, NULL, NULL, NULL);

+    if (!sws_ctx) {

+        av_log(log_ctx, AV_LOG_ERROR,

+               "Impossible to create scale context for the conversion "

+               "fmt:%s s:%dx%d -> fmt:%s s:%dx%d\n",

+               av_get_pix_fmt_name(src_pix_fmt), src_w, src_h,

+               av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h);

+        ret = AVERROR(EINVAL);

+        goto end;

+    }

+

+    if ((ret = av_image_alloc(dst_data, dst_linesize, dst_w, dst_h, dst_pix_fmt, 16)) < 0)

+        goto end;

+    ret = 0;

+    sws_scale(sws_ctx, src_data, src_linesize, 0, src_h, dst_data, dst_linesize);

+

+end:

+    sws_freeContext(sws_ctx);

+    return ret;

+}

new file mode 100644

@@ -0,0 +1,38 @@

+/*

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file

+ * Miscellaneous utilities which make use of the libswscale library

+ */

+

+#ifndef AVFILTER_LSWSUTILS_H

+#define AVFILTER_LSWSUTILS_H

+

+#include "libswscale/swscale.h"

+

+/**

+ * Scale image using libswscale.

+ */

+int ff_scale_image(uint8_t *dst_data[4], int dst_linesize[4],

+                   int dst_w, int dst_h, enum PixelFormat dst_pix_fmt,

+                   uint8_t *const src_data[4], int src_linesize[4],

+                   int src_w, int src_h, enum PixelFormat src_pix_fmt,

+                   void *log_ctx);

+

+#endif  /* AVFILTER_LSWSUTILS_H */

@@ -29,8 +29,8 @@

 #include "libavutil/avutil.h"

 #define LIBAVFILTER_VERSION_MAJOR  2

-#define LIBAVFILTER_VERSION_MINOR 66

-#define LIBAVFILTER_VERSION_MICRO 101

+#define LIBAVFILTER_VERSION_MINOR 67

+#define LIBAVFILTER_VERSION_MICRO 100

 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \

                                                LIBAVFILTER_VERSION_MINOR, \

new file mode 100644

@@ -0,0 +1,570 @@

+/*

+ * Copyright (c) 2005 Robert Edele <yartrebo@earthlink.net>

+ * Copyright (c) 2012 Stefano Sabatini

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+/**

+ * @file advanced blur-based logo removing filter

+ *

+ * This filter loads an image mask file showing where a logo is and

+ * uses a blur transform to remove the logo.

+ *

+ * Based on the libmpcodecs remove-logo filter by Robert Edele.

+ */

+

+/**

+ * This code implements a filter to remove annoying TV logos and other annoying

+ * images placed onto a video stream. It works by filling in the pixels that

+ * comprise the logo with neighboring pixels. The transform is very loosely

+ * based on a gaussian blur, but it is different enough to merit its own

+ * paragraph later on. It is a major improvement on the old delogo filter as it

+ * both uses a better blurring algorithm and uses a bitmap to use an arbitrary

+ * and generally much tighter fitting shape than a rectangle.

+ *

+ * The logo removal algorithm has two key points. The first is that it

+ * distinguishes between pixels in the logo and those not in the logo by using

+ * the passed-in bitmap. Pixels not in the logo are copied over directly without

+ * being modified and they also serve as source pixels for the logo

+ * fill-in. Pixels inside the logo have the mask applied.

+ *

+ * At init-time the bitmap is reprocessed internally, and the distance to the

+ * nearest edge of the logo (Manhattan distance), along with a little extra to

+ * remove rough edges, is stored in each pixel. This is done using an in-place

+ * erosion algorithm, and incrementing each pixel that survives any given

+ * erosion.  Once every pixel is eroded, the maximum value is recorded, and a

+ * set of masks from size 0 to this size are generaged. The masks are circular

+ * binary masks, where each pixel within a radius N (where N is the size of the

+ * mask) is a 1, and all other pixels are a 0. Although a gaussian mask would be

+ * more mathematically accurate, a binary mask works better in practice because

+ * we generally do not use the central pixels in the mask (because they are in

+ * the logo region), and thus a gaussian mask will cause too little blur and

+ * thus a very unstable image.

+ *

+ * The mask is applied in a special way. Namely, only pixels in the mask that

+ * line up to pixels outside the logo are used. The dynamic mask size means that

+ * the mask is just big enough so that the edges touch pixels outside the logo,

+ * so the blurring is kept to a minimum and at least the first boundary

+ * condition is met (that the image function itself is continuous), even if the

+ * second boundary condition (that the derivative of the image function is

+ * continuous) is not met. A masking algorithm that does preserve the second

+ * boundary coundition (perhaps something based on a highly-modified bi-cubic

+ * algorithm) should offer even better results on paper, but the noise in a

+ * typical TV signal should make anything based on derivatives hopelessly noisy.

+ */

+

+#include "libavutil/imgutils.h"

+#include "avfilter.h"

+#include "bbox.h"

+#include "lavfutils.h"

+#include "lswsutils.h"

+

+typedef struct {

+    /* Stores our collection of masks. The first is for an array of

+       the second for the y axis, and the third for the x axis. */

+    int ***mask;

+    int max_mask_size;

+    int mask_w, mask_h;

+

+    uint8_t      *full_mask_data;

+    FFBoundingBox full_mask_bbox;

+    uint8_t      *half_mask_data;

+    FFBoundingBox half_mask_bbox;

+} RemovelogoContext;

+

+/**

+ * Choose a slightly larger mask size to improve performance.

+ *

+ * This function maps the absolute minimum mask size needed to the

+ * mask size we'll actually use. f(x) = x (the smallest that will

+ * work) will produce the sharpest results, but will be quite

+ * jittery. f(x) = 1.25x (what I'm using) is a good tradeoff in my

+ * opinion. This will calculate only at init-time, so you can put a

+ * long expression here without effecting performance.

+ */

+#define apply_mask_fudge_factor(x) (((x) >> 2) + x)

+

+/**

+ * Pre-process an image to give distance information.

+ *

+ * This function takes a bitmap image and converts it in place into a

+ * distance image. A distance image is zero for pixels outside of the

+ * logo and is the Manhattan distance (|dx| + |dy|) from the logo edge

+ * for pixels inside of the logo. This will overestimate the distance,

+ * but that is safe, and is far easier to implement than a proper

+ * pythagorean distance since I'm using a modified erosion algorithm

+ * to compute the distances.

+ *

+ * @param mask image which will be converted from a greyscale image

+ * into a distance image.

+ */

+static void convert_mask_to_strength_mask(uint8_t *data, int linesize,

+                                          int w, int h, int min_val,

+                                          int *max_mask_size)

+{

+    int x, y;

+

+    /* How many times we've gone through the loop. Used in the

+       in-place erosion algorithm and to get us max_mask_size later on. */

+    int current_pass = 0;

+

+    /* set all non-zero values to 1 */

+    for (y = 0; y < h; y++)

+        for (x = 0; x < w; x++)

+            data[y*linesize + x] = data[y*linesize + x] > min_val;

+

+    /* For each pass, if a pixel is itself the same value as the

+       current pass, and its four neighbors are too, then it is

+       incremented. If no pixels are incremented by the end of the

+       pass, then we go again. Edge pixels are counted as always

+       excluded (this should be true anyway for any sane mask, but if

+       it isn't this will ensure that we eventually exit). */

+    while (1) {

+        /* If this doesn't get set by the end of this pass, then we're done. */

+        int has_anything_changed = 0;

+        uint8_t *current_pixel0 = data, *current_pixel;

+        current_pass++;

+

+        for (y = 1; y < h-1; y++) {

+            current_pixel = current_pixel0;

+            for (x = 1; x < w-1; x++) {

+                /* Apply the in-place erosion transform. It is based

+                   on the following two premises:

+                   1 - Any pixel that fails 1 erosion will fail all

+                       future erosions.

+

+                   2 - Only pixels having survived all erosions up to

+                       the present will be >= to current_pass.

+                   It doesn't matter if it survived the current pass,

+                   failed it, or hasn't been tested yet.  By using >=

+                   instead of ==, we allow the algorithm to work in

+                   place. */

+                if ( *current_pixel      >= current_pass &&

+                    *(current_pixel + 1) >= current_pass &&

+                    *(current_pixel - 1) >= current_pass &&

+                    *(current_pixel + w) >= current_pass &&

+                    *(current_pixel - w) >= current_pass) {

+                    /* Increment the value since it still has not been

+                     * eroded, as evidenced by the if statement that

+                     * just evaluated to true. */

+                    (*current_pixel)++;

+                    has_anything_changed = 1;

+                }

+                current_pixel++;

+            }

+            current_pixel0 += linesize;

+        }

+        if (!has_anything_changed)

+            break;

+    }

+

+    /* Apply the fudge factor, which will increase the size of the

+     * mask a little to reduce jitter at the cost of more blur. */

+    for (y = 1; y < h - 1; y++)

+        for (x = 1; x < w - 1; x++)

+            data[(y * linesize) + x] = apply_mask_fudge_factor(data[(y * linesize) + x]);

+

+    /* As a side-effect, we now know the maximum mask size, which

+     * we'll use to generate our masks. */

+    /* Apply the fudge factor to this number too, since we must ensure

+     * that enough masks are generated. */

+    *max_mask_size = apply_mask_fudge_factor(current_pass + 1);

+}

+

+static int query_formats(AVFilterContext *ctx)

+{

+    enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };

+    avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));

+    return 0;

+}

+

+static int load_mask(uint8_t **mask, int *w, int *h,

+                     const char *filename, void *log_ctx)

+{

+    int ret;

+    enum PixelFormat pix_fmt;

+    uint8_t *src_data[4], *gray_data[4];

+    int src_linesize[4], gray_linesize[4];

+

+    /* load image from file */

+    if ((ret = ff_load_image(src_data, src_linesize, w, h, &pix_fmt, filename, log_ctx)) < 0)

+        return ret;

+

+    /* convert the image to GRAY8 */

+    if ((ret = ff_scale_image(gray_data, gray_linesize, *w, *h, PIX_FMT_GRAY8,

+                              src_data, src_linesize, *w, *h, pix_fmt,

+                              log_ctx)) < 0)

+        goto end;

+

+    /* copy mask to a newly allocated array */

+    *mask = av_malloc(*w * *h);

+    if (!*mask)

+        ret = AVERROR(ENOMEM);

+    av_image_copy_plane(*mask, *w, gray_data[0], gray_linesize[0], *w, *h);

+

+end:

+    av_free(src_data[0]);

+    av_free(gray_data[0]);

+    return ret;

+}

+

+/**

+ * Generate a scaled down image with half width, height, and intensity.

+ *

+ * This function not only scales down an image, but halves the value

+ * in each pixel too. The purpose of this is to produce a chroma

+ * filter image out of a luma filter image. The pixel values store the

+ * distance to the edge of the logo and halving the dimensions halves

+ * the distance. This function rounds up, because a downwards rounding

+ * error could cause the filter to fail, but an upwards rounding error

+ * will only cause a minor amount of excess blur in the chroma planes.

+ */

+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)

+{

+    int x, y;

+

+    /* Copy over the image data, using the average of 4 pixels for to

+     * calculate each downsampled pixel. */

+    for (y = 0; y < src_h/2; y++) {

+        for (x = 0; x < src_w/2; x++) {

+            /* Set the pixel if there exists a non-zero value in the

+             * source pixels, else clear it. */

+            dst_data[(y * dst_linesize) + x] =

+                src_data[((y << 1) * src_linesize) + (x << 1)] ||

+                src_data[((y << 1) * src_linesize) + (x << 1) + 1] ||

+                src_data[(((y << 1) + 1) * src_linesize) + (x << 1)] ||

+                src_data[(((y << 1) + 1) * src_linesize) + (x << 1) + 1];

+            dst_data[(y * dst_linesize) + x] = FFMIN(1, dst_data[(y * dst_linesize) + x]);

+        }

+    }

+

+    convert_mask_to_strength_mask(dst_data, dst_linesize,

+                                  src_w/2, src_h/2, 0, max_mask_size);

+}

+

+static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)

+{

+    RemovelogoContext *removelogo = ctx->priv;

+    int ***mask;

+    int ret = 0;

+    int a, b, c, w, h;

+    int full_max_mask_size, half_max_mask_size;

+

+    if (!args) {

+        av_log(ctx, AV_LOG_ERROR, "An image file must be specified as argument\n");

+        return AVERROR(EINVAL);

+    }

+

+    /* Load our mask image. */

+    if ((ret = load_mask(&removelogo->full_mask_data, &w, &h, args, ctx)) < 0)

+        return ret;

+    removelogo->mask_w = w;

+    removelogo->mask_h = h;

+

+    convert_mask_to_strength_mask(removelogo->full_mask_data, w, w, h,

+                                  16, &full_max_mask_size);

+

+    /* Create the scaled down mask image for the chroma planes. */

+    if (!(removelogo->half_mask_data = av_mallocz(w/2 * h/2)))

+        return AVERROR(ENOMEM);

+    generate_half_size_image(removelogo->full_mask_data, w,

+                             removelogo->half_mask_data, w/2,

+                             w, h, &half_max_mask_size);

+

+    removelogo->max_mask_size = FFMAX(full_max_mask_size, half_max_mask_size);

+

+    /* Create a circular mask for each size up to max_mask_size. When

+       the filter is applied, the mask size is determined on a pixel

+       by pixel basis, with pixels nearer the edge of the logo getting

+       smaller mask sizes. */

+    mask = (int ***)av_malloc(sizeof(int **) * (removelogo->max_mask_size + 1));

+    if (!mask)

+        return AVERROR(ENOMEM);

+

+    for (a = 0; a <= removelogo->max_mask_size; a++) {

+        mask[a] = (int **)av_malloc(sizeof(int *) * ((a * 2) + 1));

+        if (!mask[a])

+            return AVERROR(ENOMEM);

+        for (b = -a; b <= a; b++) {

+            mask[a][b + a] = (int *)av_malloc(sizeof(int) * ((a * 2) + 1));

+            if (!mask[a][b + a])

+                return AVERROR(ENOMEM);

+            for (c = -a; c <= a; c++) {

+                if ((b * b) + (c * c) <= (a * a)) /* Circular 0/1 mask. */

+                    mask[a][b + a][c + a] = 1;

+                else

+                    mask[a][b + a][c + a] = 0;

+            }

+        }

+    }

+    removelogo->mask = mask;

+

+    /* Calculate our bounding rectangles, which determine in what

+     * region the logo resides for faster processing. */

+    ff_calculate_bounding_box(&removelogo->full_mask_bbox, removelogo->full_mask_data, w, w, h, 0);

+    ff_calculate_bounding_box(&removelogo->half_mask_bbox, removelogo->half_mask_data, w/2, w/2, h/2, 0);

+

+#define SHOW_LOGO_INFO(mask_type)                                       \

+    av_log(ctx, AV_LOG_INFO, #mask_type " x1:%d x2:%d y1:%d y2:%d max_mask_size:%d\n", \

+           removelogo->mask_type##_mask_bbox.x1, removelogo->mask_type##_mask_bbox.x2, \

+           removelogo->mask_type##_mask_bbox.y1, removelogo->mask_type##_mask_bbox.y2, \

+           mask_type##_max_mask_size);

+    SHOW_LOGO_INFO(full);

+    SHOW_LOGO_INFO(half);

+

+    return 0;

+}

+

+static int config_props_input(AVFilterLink *inlink)

+{

+    AVFilterContext *ctx = inlink->dst;

+    RemovelogoContext *removelogo = ctx->priv;

+

+    if (inlink->w != removelogo->mask_w || inlink->h != removelogo->mask_h) {

+        av_log(ctx, AV_LOG_INFO,

+               "Mask image size %dx%d does not match with the input video size %dx%d\n",

+               removelogo->mask_w, removelogo->mask_h, inlink->w, inlink->h);

+        return AVERROR(EINVAL);

+    }

+

+    return 0;

+}

+

+/**

+ * Blur image.

+ *

+ * It takes a pixel that is inside the mask and blurs it. It does so

+ * by finding the average of all the pixels within the mask and

+ * outside of the mask.

+ *

+ * @param mask_data  the mask plane to use for averaging

+ * @param image_data the image plane to blur

+ * @param w width of the image

+ * @param h height of the image

+ * @param x x-coordinate of the pixel to blur

+ * @param y y-coordinate of the pixel to blur

+ */

+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)

+{

+    /* Mask size tells how large a circle to use. The radius is about

+     * (slightly larger than) mask size. */

+    int mask_size;

+    int start_posx, start_posy, end_posx, end_posy;

+    int i, j;

+    unsigned int accumulator = 0, divisor = 0;

+    /* What pixel we are reading out of the circular blur mask. */

+    const uint8_t *image_read_position;

+    /* What pixel we are reading out of the filter image. */

+    const uint8_t *mask_read_position;

+

+    /* Prepare our bounding rectangle and clip it if need be. */

+    mask_size  = mask_data[y * mask_linesize + x];

+    start_posx = FFMAX(0, x - mask_size);

+    start_posy = FFMAX(0, y - mask_size);

+    end_posx   = FFMIN(w - 1, x + mask_size);

+    end_posy   = FFMIN(h - 1, y + mask_size);

+

+    image_read_position = image_data + image_linesize * start_posy + start_posx;

+    mask_read_position  = mask_data  + mask_linesize  * start_posy + start_posx;

+

+    for (j = start_posy; j <= end_posy; j++) {

+        for (i = start_posx; i <= end_posx; i++) {

+            /* Check if this pixel is in the mask or not. Only use the

+             * pixel if it is not. */

+            if (!(*mask_read_position) && mask[mask_size][i - start_posx][j - start_posy]) {

+                accumulator += *image_read_position;

+                divisor++;

+            }

+

+            image_read_position++;

+            mask_read_position++;

+        }

+

+        image_read_position += (image_linesize - ((end_posx + 1) - start_posx));

+        mask_read_position  += (mask_linesize - ((end_posx + 1) - start_posx));

+    }

+

+    /* If divisor is 0, it means that not a single pixel is outside of

+       the logo, so we have no data.  Else we need to normalise the

+       data using the divisor. */

+    return divisor == 0 ? 255:

+        (accumulator + (divisor / 2)) / divisor;  /* divide, taking into account average rounding error */

+}

+

+/**

+ * Blur image plane using a mask.

+ *

+ * @param source The image to have it's logo removed.

+ * @param destination Where the output image will be stored.

+ * @param source_stride How far apart (in memory) two consecutive lines are.

+ * @param destination Same as source_stride, but for the destination image.

+ * @param width Width of the image. This is the same for source and destination.

+ * @param height Height of the image. This is the same for source and destination.

+ * @param is_image_direct If the image is direct, then source and destination are

+ *        the same and we can save a lot of time by not copying pixels that

+ *        haven't changed.

+ * @param filter The image that stores the distance to the edge of the logo for

+ *        each pixel.

+ * @param logo_start_x smallest x-coordinate that contains at least 1 logo pixel.

+ * @param logo_start_y smallest y-coordinate that contains at least 1 logo pixel.

+ * @param logo_end_x   largest x-coordinate that contains at least 1 logo pixel.

+ * @param logo_end_y   largest y-coordinate that contains at least 1 logo pixel.

+ *

+ * This function processes an entire plane. Pixels outside of the logo are copied

+ * to the output without change, and pixels inside the logo have the de-blurring

+ * function applied.

+ */

+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)

+{

+    int x, y;

+    uint8_t *dst_line;

+    const uint8_t *src_line;

+

+    if (!direct)

+        av_image_copy_plane(dst_data, dst_linesize, src_data, src_linesize, w, h);

+

+    for (y = bbox->y1; y <= bbox->y2; y++) {

+        src_line = src_data + src_linesize * y;

+        dst_line = dst_data + dst_linesize * y;

+

+        for (x = bbox->x1; x <= bbox->x2; x++) {

+             if (mask_data[y * mask_linesize + x]) {

+                /* Only process if we are in the mask. */

+                 dst_line[x] = blur_pixel(mask,

+                                          mask_data, mask_linesize,

+                                          dst_data, dst_linesize,

+                                          w, h, x, y);

+            } else {

+                /* Else just copy the data. */

+                if (!direct)

+                    dst_line[x] = src_line[x];

+            }

+        }

+    }

+}

+

+static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)

+{

+    AVFilterLink *outlink = inlink->dst->outputs[0];

+    AVFilterBufferRef *outpicref;

+

+    if (inpicref->perms & AV_PERM_PRESERVE) {

+        outpicref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,

+                                              outlink->w, outlink->h);

+        avfilter_copy_buffer_ref_props(outpicref, inpicref);

+        outpicref->video->w = outlink->w;

+        outpicref->video->h = outlink->h;

+    } else

+        outpicref = inpicref;

+

+    outlink->out_buf = outpicref;

+    avfilter_start_frame(outlink, avfilter_ref_buffer(outpicref, ~0));

+}

+

+static void end_frame(AVFilterLink *inlink)

+{

+    RemovelogoContext *removelogo = inlink->dst->priv;

+    AVFilterLink *outlink = inlink->dst->outputs[0];

+    AVFilterBufferRef *inpicref  = inlink ->cur_buf;

+    AVFilterBufferRef *outpicref = outlink->out_buf;

+    int direct = inpicref == outpicref;

+

+    blur_image(removelogo->mask,

+               inpicref ->data[0], inpicref ->linesize[0],

+               outpicref->data[0], outpicref->linesize[0],

+               removelogo->full_mask_data, inlink->w,

+               inlink->w, inlink->h, direct, &removelogo->full_mask_bbox);

+    blur_image(removelogo->mask,

+               inpicref ->data[1], inpicref ->linesize[1],

+               outpicref->data[1], outpicref->linesize[1],

+               removelogo->half_mask_data, inlink->w/2,

+               inlink->w/2, inlink->h/2, direct, &removelogo->half_mask_bbox);

+    blur_image(removelogo->mask,

+               inpicref ->data[2], inpicref ->linesize[2],

+               outpicref->data[2], outpicref->linesize[2],

+               removelogo->half_mask_data, inlink->w/2,

+               inlink->w/2, inlink->h/2, direct, &removelogo->half_mask_bbox);

+

+    avfilter_draw_slice(outlink, 0, inlink->h, 1);

+    avfilter_end_frame(outlink);

+    avfilter_unref_buffer(inpicref);

+    if (!direct)

+        avfilter_unref_buffer(outpicref);

+}

+

+static void uninit(AVFilterContext *ctx)

+{

+    RemovelogoContext *removelogo = ctx->priv;

+    int a, b;

+

+    av_freep(&removelogo->full_mask_data);

+    av_freep(&removelogo->half_mask_data);

+

+    if (removelogo->mask) {

+        /* Loop through each mask. */

+        for (a = 0; a <= removelogo->max_mask_size; a++) {

+            /* Loop through each scanline in a mask. */

+            for (b = -a; b <= a; b++) {

+                av_free(removelogo->mask[a][b + a]); /* Free a scanline. */

+            }

+            av_free(removelogo->mask[a]);

+        }

+        /* Free the array of pointers pointing to the masks. */