lavfi/mp: remove remove_logo wrapper

removelogo has been ported to libavfilter, and the wrapper was not
working.

1 files changed, 0 insertions, 906 deletions

diff --git a/libavfilter/libmpcodecs/vf_remove_logo.c b/libavfilter/libmpcodecs/vf_remove_logo.c
deleted file mode 100644
index a970adc5b0..0000000000
--- a/libavfilter/libmpcodecs/vf_remove_logo.c
+++ /dev/null
@@ -1,906 +0,0 @@
-/*
- * This filter loads a .pgm mask file showing where a logo is and uses
- * a blur transform to remove the logo.
- *
- * Copyright (C) 2005 Robert Edele <yartrebo@earthlink.net>
- *
- * This file is part of MPlayer.
- *
- * MPlayer is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * MPlayer 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with MPlayer; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-/**
- * \file
- *
- * \brief Advanced blur-based logo removing filter.
-
- *     Hello and welcome. 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 filter requires 1 argument and has no optional arguments. It requires
- * a filter bitmap, which must be in PGM or PPM format. A sample invocation would
- * be -vf remove_logo=/home/username/logo_bitmaps/xyz.pgm.  Pixels with a value of
- * zero are not part of the logo, and non-zero pixels are 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, I recommend taking a screen capture of a black frame
- * with the logo visible, and then using The GIMP's 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 doesn't hurt as
- * much, but it will increase the amount of blurring needed to cover over the
- * image and will destroy more information than necessary. Additionally, this blur
- * algorithm is O(n) = n^4, where n is the width and height of a hypothetical
- * square logo, so extra pixels will slow things down on a large lo
- *
- *     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 <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ctype.h>
-#include <inttypes.h>
-
-#include "config.h"
-#include "mp_msg.h"
-#include "libvo/fastmemcpy.h"
-
-#include "img_format.h"
-#include "mp_image.h"
-#include "vf.h"
-
-//===========================================================================//
-
-/** \brief Returns the larger of the two arguments. **/
-#define max(x,y) ((x)>(y)?(x):(y))
-/** \brief Returns the smaller of the two arguments. **/
-#define min(x,y) ((x)>(y)?(y):(x))
-
-/**
- * \brief Test if a pixel is part of the logo.
- */
-#define test_filter(image, x, y) ((unsigned char) (image->pixel[((y) * image->width) + (x)]))
-
-/**
- * \brief Chooses 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)
-
-/**
- * \brief Simple implementation of the PGM image format.
- *
- * This struct holds a bare-bones image loaded from a PGM or PPM file. Once
- * loaded and pre-processed, each pixel in this struct will contain how far from
- * the edge of the logo each pixel is, using the manhattan distance (|dx| + |dy|).
- *
- * pixels in char * pixel can be addressed using (y * width) + height.
- */
-typedef struct
-{
-  unsigned int width;
-  unsigned int height;
-
-  unsigned char * pixel;
-
-} pgm_structure;
-
-/**
- * \brief Stores persistant variables.
- *
- * Variables stored here are kept from frame to frame, and separate instances of
- * the filter will get their own separate copies.
- */
-struct vf_priv_s
-{
-  unsigned int fmt; /* Not exactly sure of the use for this. It came with the example filter I used as a basis for this, and it looks like a lot of stuff will break if I remove it. */
-  int max_mask_size; /* The largest possible mask size that will be needed with the given filter and corresponding half_size_filter. The half_size_filter can have a larger requirment in some rare (but not degenerate) cases. */
-  int * * * mask; /* Stores our collection of masks. The first * is for an array of masks, the second for the y axis, and the third for the x axis. */
-  pgm_structure * filter; /* Stores the full-size filter image. This is used to tell what pixels are in the logo or not in the luma plane. */
-  pgm_structure * half_size_filter; /* Stores a 50% width and 50% height filter image. This is used to tell what pixels are in the logo or not in the chroma planes. */
-  /* These 8 variables store the bounding rectangles that the logo resides in. */
-  int bounding_rectangle_posx1;
-  int bounding_rectangle_posy1;
-  int bounding_rectangle_posx2;
-  int bounding_rectangle_posy2;
-  int bounding_rectangle_half_size_posx1;
-  int bounding_rectangle_half_size_posy1;
-  int bounding_rectangle_half_size_posx2;
-  int bounding_rectangle_half_size_posy2;
-} vf_priv_s;
-
-/**
- * \brief Mallocs memory and checks to make sure it succeeded.
- *
- * \param size How many bytes to allocate.
- *
- * \return A pointer to the freshly allocated memory block, or NULL on failutre.
- *
- * Mallocs memory, and checks to make sure it was successfully allocated. Because
- * of how MPlayer works, it cannot safely halt execution, but at least the user
- * will get an error message before the segfault happens.
- */
-static void * safe_malloc(int size)
-{
-  void * answer = malloc(size);
-  if (answer == NULL)
-    mp_msg(MSGT_VFILTER, MSGL_ERR, "Unable to allocate memory in vf_remove_logo.c\n");
-
-  return answer;
-}
-
-/**
- * \brief Calculates the smallest rectangle that will encompass the logo region.
- *
- * \param filter This image contains the logo around which the rectangle will
- *        will be fitted.
- *
- * The bounding rectangle is calculated by testing successive lines (from the four
- * sides of the rectangle) until no more can be removed without removing logo
- * pixels. The results are returned by reference to posx1, posy1, posx2, and
- * posy2.
- */
-static void calculate_bounding_rectangle(int * posx1, int * posy1, int * posx2, int * posy2, pgm_structure * filter)
-{
-  int x; /* Temporary variables to run  */
-  int y; /* through each row or column. */
-  int start_x;
-  int start_y;
-  int end_x = filter->width - 1;
-  int end_y = filter->height - 1;
-  int did_we_find_a_logo_pixel = 0;
-
-  /* Let's find the top bound first. */
-  for (start_x = 0; start_x < filter->width && !did_we_find_a_logo_pixel; start_x++)
-  {
-    for (y = 0; y < filter->height; y++)
-    {
-      did_we_find_a_logo_pixel |= test_filter(filter, start_x, y);
-    }
-  }
-  start_x--;
-
-  /* Now the bottom bound. */
-  did_we_find_a_logo_pixel = 0;
-  for (end_x = filter->width - 1; end_x > start_x && !did_we_find_a_logo_pixel; end_x--)
-  {
-    for (y = 0; y < filter->height; y++)
-    {
-      did_we_find_a_logo_pixel |= test_filter(filter, end_x, y);
-    }
-  }
-  end_x++;
-
-  /* Left bound. */
-  did_we_find_a_logo_pixel = 0;
-  for (start_y = 0; start_y < filter->height && !did_we_find_a_logo_pixel; start_y++)
-  {
-    for (x = 0; x < filter->width; x++)
-    {
-      did_we_find_a_logo_pixel |= test_filter(filter, x, start_y);
-    }
-  }
-  start_y--;
-
-  /* Right bound. */
-  did_we_find_a_logo_pixel = 0;
-  for (end_y = filter->height - 1; end_y > start_y && !did_we_find_a_logo_pixel; end_y--)
-  {
-    for (x = 0; x < filter->width; x++)
-    {
-      did_we_find_a_logo_pixel |= test_filter(filter, x, end_y);
-    }
-  }
-  end_y++;
-
-  *posx1 = start_x;
-  *posy1 = start_y;
-  *posx2 = end_x;
-  *posy2 = end_y;
-
-  return;
-}
-
-/**
- * \brief Free mask memory.
- *
- * \param vf Data structure which stores our persistant data, and is to be freed.
- *
- * We call this function when our filter is done. It will free the memory
- * allocated to the masks and leave the variables in a safe state.
- */
-static void destroy_masks(vf_instance_t * vf)
-{
-  int a, b;
-
-  /* Load values from the vf->priv struct for faster dereferencing. */
-  int * * * mask = vf->priv->mask;
-  int max_mask_size = vf->priv->max_mask_size;
-
-  if (mask == NULL)
-    return; /* Nothing allocated, so return before we segfault. */
-
-  /* Free all allocated memory. */
-  for (a = 0; a <= max_mask_size; a++) /* Loop through each mask. */
-  {
-    for (b = -a; b <= a; b++) /* Loop through each scanline in a mask. */
-    {
-      free(mask[a][b + a]); /* Free a scanline. */
-    }
-    free(mask[a]); /* Free a mask. */
-  }
-  free(mask); /* Free the array of pointers pointing to the masks. */
-
-  /* Set the pointer to NULL, so that any duplicate calls to this function will not cause a crash. */
-  vf->priv->mask = NULL;
-
-  return;
-}
-
-/**
- * \brief Set up our array of masks.
- *
- * \param vf Where our filter stores persistance data, like these masks.
- *
- * This creates an array of progressively larger masks and calculates their
- * values. The values will not change during program execution once this function
- * is done.
- */
-static void initialize_masks(vf_instance_t * vf)
-{
-  int a, b, c;
-
-  /* Load values from the vf->priv struct for faster dereferencing. */
-  int * * * mask = vf->priv->mask;
-  int max_mask_size = vf->priv->max_mask_size; /* This tells us how many masks we'll need to generate. */
-
-  /* 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 * * *) safe_malloc(sizeof(int * *) * (max_mask_size + 1));
-  for (a = 0; a <= max_mask_size; a++)
-  {
-    mask[a] = (int * *) safe_malloc(sizeof(int *) * ((a * 2) + 1));
-    for (b = -a; b <= a; b++)
-    {
-      mask[a][b + a] = (int *) safe_malloc(sizeof(int) * ((a * 2) + 1));
-      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;
-      }
-    }
-  }
-
-  /* Store values back to vf->priv so they aren't lost after the function returns. */
-  vf->priv->mask = mask;
-
-  return;
-}
-
-/**
- * \brief Pre-processes an image to give distance information.
- *
- * \param vf Data structure that holds persistant information. All it is used for
-             in this function is to store the calculated max_mask_size variable.
- * \param mask This image will be converted from a greyscale image into a
- *             distance image.
- *
- * This function takes a greyscale image (pgm_structure * mask) and converts it
- * in place into a distance image. A distance image is zero for pixels ourside of
- * the logo and is the manhattan distance (|dx| + |dy|) 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.
- */
-static void convert_mask_to_strength_mask(vf_instance_t * vf, pgm_structure * mask)
-{
-  int x, y; /* Used by our for loops to go through every single pixel in the picture one at a time. */
-  int has_anything_changed = 1; /* Used by the main while() loop to know if anything changed on the last erosion. */
-  int current_pass = 0; /* 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 max_mask_size; /* This will record how large a mask the pixel that is the furthest from the edge of the logo
-                           (and thus the neediest) is. */
-  char * current_pixel = mask->pixel; /* This stores the actual pixel data. */
-
-  /* First pass, set all non-zero values to 1. After this loop finishes, the data should be considered numeric
-     data for the filter, not color data. */
-  for (x = 0; x < mask->height * mask->width; x++, current_pixel++)
-    if(*current_pixel) *current_pixel = 1;
-
-  /* Second pass and future passes. 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 (has_anything_changed)
-  {
-    current_pass++;
-    current_pixel = mask->pixel;
-
-    has_anything_changed = 0; /* If this doesn't get set by the end of this pass, then we're done. */
-
-    for (y = 1; y < mask->height - 1; y++)
-    {
-      for (x = 1; x < mask->width - 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. */
-        if (*current_pixel >= current_pass && /* By using >= instead of ==, we allow the algorithm to work in place. */
-            *(current_pixel + 1) >= current_pass &&
-            *(current_pixel - 1) >= current_pass &&
-            *(current_pixel + mask->width) >= current_pass &&
-            *(current_pixel - mask->width) >= current_pass)
-         {
-           (*current_pixel)++; /* Increment the value since it still has not been eroded, as evidenced by the if statement
-                                  that just evaluated to true. */
-           has_anything_changed = 1;
-         }
-        current_pixel++;
-      }
-    }
-  }
-
-  /* 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 < mask->height - 1; y++)
-  {
-   for (x = 1; x < mask->width - 1; x++)
-    {
-      mask->pixel[(y * mask->width) + x] = apply_mask_fudge_factor(mask->pixel[(y * mask->width) + x]);
-    }
-  }
-
-  max_mask_size = current_pass + 1; /* As a side-effect, we now know the maximum mask size, which we'll use to generate our masks. */
-  max_mask_size = apply_mask_fudge_factor(max_mask_size); /* Apply the fudge factor to this number too, since we must
-                                                             ensure that enough masks are generated. */
-  vf->priv->max_mask_size = max_mask_size; /* Commit the newly calculated max_mask_size to the vf->priv struct. */
-
-  return;
-}
-
-/**
- * \brief Our blurring function.
- *
- * \param vf Stores persistant data. In this function we are interested in the
- *           array of masks.
- * \param value_out The properly blurred and delogoed pixel is outputted here.
- * \param logo_mask Tells us which pixels are in the logo and which aren't.
- * \param image The image that is having its logo removed.
- * \param x x-coordinate of the pixel to blur.
- * \param y y-coordinate of the pixel to blur.
- * \param plane 0 = luma, 1 = blue chroma, 2 = red chroma (YUV).
- *
- * This function is the core of the filter. It takes a pixel that is inside the
- * logo and blurs it. It does so by finding the average of all the pixels within
- * the mask and outside of the logo.
- */
-static void get_blur(const vf_instance_t * const vf, unsigned int * const value_out, const pgm_structure * const logo_mask,
-              const mp_image_t * const image, const int x, const int y, const int plane)
-{
-  int mask_size; /* Mask size tells how large a circle to use. The radius is about (slightly larger than) mask size. */
-  /* Get values from vf->priv for faster dereferencing. */
-  int * * * mask = vf->priv->mask;
-
-  int start_posx, start_posy, end_posx, end_posy;
-  int i, j;
-  unsigned int accumulator = 0, divisor = 0;
-  const unsigned char * mask_read_position; /* What pixel we are reading out of the circular blur mask. */
-  const unsigned char * logo_mask_read_position; /* What pixel we are reading out of the filter image. */
-
-  /* Prepare our bounding rectangle and clip it if need be. */
-  mask_size = test_filter(logo_mask, x, y);
-  start_posx = max(0, x - mask_size);
-  start_posy = max(0, y - mask_size);
-  end_posx = min(image->width - 1, x + mask_size);
-  end_posy = min(image->height - 1, y + mask_size);
-
-  mask_read_position = image->planes[plane] + (image->stride[plane] * start_posy) + start_posx;
-  logo_mask_read_position = logo_mask->pixel + (start_posy * logo_mask->width) + start_posx;
-
-  for (j = start_posy; j <= end_posy; j++)
-  {
-    for (i = start_posx; i <= end_posx; i++)
-    {
-      if (!(*logo_mask_read_position) && mask[mask_size][i - start_posx][j - start_posy])
-      { /* Check to see if this pixel is in the logo or not. Only use the pixel if it is not. */
-        accumulator += *mask_read_position;
-        divisor++;
-      }
-
-      mask_read_position++;
-      logo_mask_read_position++;
-    }
-
-    mask_read_position += (image->stride[plane] - ((end_posx + 1) - start_posx));
-    logo_mask_read_position += (logo_mask->width - ((end_posx + 1) - start_posx));
-  }
-
-  if (divisor == 0) /* This means that not a single pixel is outside of the logo, so we have no data. */
-  { /* We should put some eye catching value here, to indicate the flaw to the user. */
-    *value_out = 255;
-  }
-  else /* Else we need to normalise the data using the divisor. */
-  {
-    *value_out = (accumulator + (divisor / 2)) / divisor; /* Divide, taking into account average rounding error. */
-  }
-
-  return;
-}
-
-/**
- * \brief Free a pgm_structure. Undoes load_pgm(...).
- */
-static void destroy_pgm(pgm_structure * to_be_destroyed)
-{
-  if (to_be_destroyed == NULL)
-    return; /* Don't do anything if a NULL pointer was passed it. */
-
-  /* Internally allocated memory. */
-  if (to_be_destroyed->pixel != NULL)
-  {
-    free(to_be_destroyed->pixel);
-    to_be_destroyed->pixel = NULL;
-  }
-
-  /* Free the actual struct instance. This is done here and not by the calling function. */
-  free(to_be_destroyed);
-}
-
-/** \brief Helper function for load_pgm(...) to skip whitespace. */
-static void load_pgm_skip(FILE *f) {
-  int c, comment = 0;
-  do {
-    c = fgetc(f);
-    if (c == '#')
-      comment = 1;
-    if (c == '\n')
-      comment = 0;
-  } while (c != EOF && (isspace(c) || comment));
-  ungetc(c, f);
-}
-
-#define REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE(message) {mp_msg(MSGT_VFILTER, MSGL_ERR, message); return NULL;}
-
-/**
- * \brief Loads a raw pgm or ppm file into a newly created pgm_structure object.
- *
- * \param file_name The name of the file to be loaded. So long as the file is a
- *                  valid pgm or ppm file, it will load correctly, even if the
- *                  extension is missing or invalid.
- *
- * \return A pointer to the newly created pgm_structure object. Don't forget to
- *         call destroy_pgm(...) when you're done with this. If an error occurs,
- *         NULL is returned.
- *
- * Can load either raw pgm (P5) or raw ppm (P6) image files as a binary image.
- * While a pgm file will be loaded normally (greyscale), the only thing that is
- * guaranteed with ppm is that all zero (R = 0, G = 0, B = 0) pixels will remain
- * zero, and non-zero pixels will remain non-zero.
- */
-static pgm_structure * load_pgm(const char * file_name)
-{
-  int maximum_greyscale_value;
-  FILE * input;
-  int pnm_number;
-  pgm_structure * new_pgm = (pgm_structure *) safe_malloc (sizeof(pgm_structure));
-  char * write_position;
-  char * end_position;
-  int image_size; /* width * height */
-
-  if((input = fopen(file_name, "rb")) == NULL) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: Unable to open file. File not found or insufficient permissions.\n");
-
-  /* Parse the PGM header. */
-  if (fgetc(input) != 'P') REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: File is not a valid PGM or PPM file.\n");
-  pnm_number = fgetc(input) - '0';
-  if (pnm_number != 5 && pnm_number != 6) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: Invalid PNM file. Only raw PGM (Portable Gray Map) and raw PPM (Portable Pixel Map) subtypes are allowed.\n");
-  load_pgm_skip(input);
-  if (fscanf(input, "%i", &(new_pgm->width)) != 1) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: Invalid PGM/PPM header.\n");
-  load_pgm_skip(input);
-  if (fscanf(input, "%i", &(new_pgm->height)) != 1) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: Invalid PGM/PPM header.\n");
-  load_pgm_skip(input);
-  if (fscanf(input, "%i", &maximum_greyscale_value) != 1) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove-logo: Invalid PGM/PPM header.\n");
-  if (maximum_greyscale_value >= 256) REMOVE_LOGO_LOAD_PGM_ERROR_MESSAGE("[vf]remove_logo: Only 1 byte per pixel (pgm) or 1 byte per color value (ppm) are supported.\n");
-  load_pgm_skip(input);
-
-  new_pgm->pixel = (unsigned char *) safe_malloc (sizeof(unsigned char) * new_pgm->width * new_pgm->height);
-
-  /* Load the pixels. */
-  /* Note: I am aware that fgetc(input) isn't the fastest way of doing things, but it is quite compact and the code only runs once when the filter is initialized.*/
-  image_size = new_pgm->width * new_pgm->height;
-  end_position = new_pgm->pixel + image_size;
-  for (write_position = new_pgm->pixel; write_position < end_position; write_position++)
-  {
-    *write_position = fgetc(input);
-    if (pnm_number == 6) /* This tests to see if the file is a PPM file. */
-    { /* If it is, then consider the pixel set if any of the three color channels are set. Since we just care about == 0 or != 0, a bitwise or will do the trick. */
-      *write_position |= fgetc(input);
-      *write_position |= fgetc(input);
-    }
-  }
-
-  return new_pgm;
-}
-
-/**
- * \brief Generates a scaled down image with half width, height, and intensity.
- *
- * \param vf Our struct for persistant data. In this case, it is used to update
- *           mask_max_size with the larger of the old or new value.
- * \param input_image The image from which the new half-sized one will be based.
- *
- * \return The newly allocated and shrunken image.
- *
- * 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 pgm_structure * generate_half_size_image(vf_instance_t * vf, pgm_structure * input_image)
-{
-  int x, y;
-  pgm_structure * new_pgm = (pgm_structure *) safe_malloc (sizeof(pgm_structure));
-  int has_anything_changed = 1;
-  int current_pass;
-  int max_mask_size;
-  char * current_pixel;
-
-  new_pgm->width = input_image->width / 2;
-  new_pgm->height = input_image->height / 2;
-  new_pgm->pixel = (unsigned char *) safe_malloc (sizeof(unsigned char) * new_pgm->width * new_pgm->height);
-
-  /* Copy over the image data, using the average of 4 pixels for to calculate each downsampled pixel. */
-  for (y = 0; y < new_pgm->height; y++)
-    for (x = 0; x < new_pgm->width; x++)
-    {
-      /* Set the pixel if there exists a non-zero value in the source pixels, else clear it. */
-      new_pgm->pixel[(y * new_pgm->width) + x] = input_image->pixel[((y << 1) * input_image->width) + (x << 1)] ||
-                                                 input_image->pixel[((y << 1) * input_image->width) + (x << 1) + 1] ||
-                                                 input_image->pixel[(((y << 1) + 1) * input_image->width) + (x << 1)] ||
-                                                 input_image->pixel[(((y << 1) + 1) * input_image->width) + (x << 1) + 1];
-      new_pgm->pixel[(y * new_pgm->width) + x] = min(1, new_pgm->pixel[(y * new_pgm->width) + x]);
-    }
-
-  /* Now we need to recalculate the numbers for the smaller size. Just using the old_value / 2 can cause subtle
-     and fairly rare, but very nasty, bugs. */
-
-  current_pixel = new_pgm->pixel;
-  /* First pass, set all non-zero values to 1. */
-  for (x = 0; x < new_pgm->height * new_pgm->width; x++, current_pixel++)
-    if(*current_pixel) *current_pixel = 1;
-
-  /* Second pass and future passes. 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). */
-  current_pass = 0;
-  while (has_anything_changed)
-  {
-    current_pass++;
-
-    has_anything_changed = 0; /* If this doesn't get set by the end of this pass, then we're done. */
-
-    for (y = 1; y < new_pgm->height - 1; y++)
-    {
-      for (x = 1; x < new_pgm->width - 1; x++)
-      {
-        if (new_pgm->pixel[(y * new_pgm->width) + x] >= current_pass && /* By using >= instead of ==, we allow the algorithm to work in place. */
-            new_pgm->pixel[(y * new_pgm->width) + (x + 1)] >= current_pass &&
-            new_pgm->pixel[(y * new_pgm->width) + (x - 1)] >= current_pass &&
-            new_pgm->pixel[((y + 1) * new_pgm->width) + x] >= current_pass &&
-            new_pgm->pixel[((y - 1) * new_pgm->width) + x] >= current_pass)
-         {
-           new_pgm->pixel[(y * new_pgm->width) + x]++; /* Increment the value since it still has not been eroded,
-                                                    as evidenced by the if statement that just evaluated to true. */
-           has_anything_changed = 1;
-         }
-      }
-    }
-  }
-
-  for (y = 1; y < new_pgm->height - 1; y++)
-  {
-   for (x = 1; x < new_pgm->width - 1; x++)
-    {
-      new_pgm->pixel[(y * new_pgm->width) + x] = apply_mask_fudge_factor(new_pgm->pixel[(y * new_pgm->width) + x]);
-    }
-  }
-
-  max_mask_size = current_pass + 1; /* As a side-effect, we now know the maximum mask size, which we'll use to generate our masks. */
-  max_mask_size = apply_mask_fudge_factor(max_mask_size);
-  /* Commit the newly calculated max_mask_size to the vf->priv struct. */
-  vf->priv->max_mask_size = max(max_mask_size, vf->priv->max_mask_size);
-
-  return new_pgm;
-}
-
-/**
- * \brief Checks if YV12 is supported by the next filter.
- */
-static unsigned int find_best(struct vf_instance *vf){
-  int is_format_okay = vf_next_query_format(vf, IMGFMT_YV12);
-  if ((is_format_okay & VFCAP_CSP_SUPPORTED_BY_HW) || (is_format_okay & VFCAP_CSP_SUPPORTED))
-    return IMGFMT_YV12;
-  else
-    return 0;
-}
-
-//===========================================================================//
-
-/**
- * \brief Configure the filter and call the next filter's config function.
- */
-static int config(struct vf_instance *vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt)
-{
-  if(!(vf->priv->fmt=find_best(vf)))
-    return 0;
-  else
-    return vf_next_config(vf,width,height,d_width,d_height,flags,vf->priv->fmt);
-}
-
-/**
- * \brief Removes the logo from a plane (either luma or chroma).
- *
- * \param vf Not needed by this function, but needed by the blur function.
- * \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 convert_yv12(const vf_instance_t * const vf, const char * const source, const int source_stride,
-                         const mp_image_t * const source_image, const int width, const int height,
-                         char * const destination, const int destination_stride, int is_image_direct, pgm_structure * filter,
-                         const int plane, const int logo_start_x, const int logo_start_y, const int logo_end_x, const int logo_end_y)
-{
-  int y;
-  int x;
-
-  /* These pointers point to where we are getting our pixel data (inside mpi) and where we are storing it (inside dmpi). */
-  const unsigned char * source_line;
-  unsigned char * destination_line;
-
-  if (!is_image_direct)
-    memcpy_pic(destination, source, width, height, destination_stride, source_stride);
-
-  for (y = logo_start_y; y <= logo_end_y; y++)
-  {
-    source_line = (const unsigned char *) source + (source_stride * y);
-    destination_line = (unsigned char *) destination + (destination_stride * y);
-
-    for (x = logo_start_x; x <= logo_end_x; x++)
-    {
-      unsigned int output;
-
-      if (filter->pixel[(y * filter->width) + x]) /* Only process if we are in the logo. */
-      {
-        get_blur(vf, &output, filter, source_image, x, y, plane);
-        destination_line[x] = output;
-      }
-      else /* Else just copy the data. */
-        if (!is_image_direct)
-          destination_line[x] = source_line[x];
-    }
-  }
-}
-
-/**
- * \brief Process a frame.
- *
- * \param mpi The image sent to use by the previous filter.
- * \param dmpi Where we will store the processed output image.
- * \param vf This is how the filter gets access to it's persistant data.
- *
- * \return The return code of the next filter, or 0 on failure/error.
- *
- * This function processes an entire frame. The frame is sent by the previous
- * filter, has the logo removed by the filter, and is then sent to the next
- * filter.
- */
-static int put_image(struct vf_instance *vf, mp_image_t *mpi, double pts){
-    mp_image_t *dmpi;
-
-    dmpi=vf_get_image(vf->next,vf->priv->fmt,
-        MP_IMGTYPE_TEMP, MP_IMGFLAG_ACCEPT_STRIDE,
-        mpi->w, mpi->h);
-
-    /* Check to make sure that the filter image and the video stream are the same size. */
-    if (vf->priv->filter->width != mpi->w || vf->priv->filter->height != mpi->h)
-    {
-      mp_msg(MSGT_VFILTER,MSGL_ERR, "Filter image and video stream are not of the same size. (Filter: %d x %d, Stream: %d x %d)\n",
-             vf->priv->filter->width, vf->priv->filter->height, mpi->w, mpi->h);
-      return 0;
-    }
-
-    switch(dmpi->imgfmt){
-    case IMGFMT_YV12:
-          convert_yv12(vf, mpi->planes[0],  mpi->stride[0], mpi, mpi->w, mpi->h,
-                          dmpi->planes[0], dmpi->stride[0],
-                          mpi->flags & MP_IMGFLAG_DIRECT, vf->priv->filter, 0,
-                          vf->priv->bounding_rectangle_posx1, vf->priv->bounding_rectangle_posy1,
-                          vf->priv->bounding_rectangle_posx2, vf->priv->bounding_rectangle_posy2);
-          convert_yv12(vf, mpi->planes[1],  mpi->stride[1], mpi, mpi->w / 2, mpi->h / 2,
-                          dmpi->planes[1], dmpi->stride[1],
-                          mpi->flags & MP_IMGFLAG_DIRECT, vf->priv->half_size_filter, 1,
-                          vf->priv->bounding_rectangle_half_size_posx1, vf->priv->bounding_rectangle_half_size_posy1,
-                          vf->priv->bounding_rectangle_half_size_posx2, vf->priv->bounding_rectangle_half_size_posy2);
-          convert_yv12(vf, mpi->planes[2],  mpi->stride[2], mpi, mpi->w / 2, mpi->h / 2,
-                          dmpi->planes[2], dmpi->stride[2],
-                          mpi->flags & MP_IMGFLAG_DIRECT, vf->priv->half_size_filter, 2,
-                          vf->priv->bounding_rectangle_half_size_posx1, vf->priv->bounding_rectangle_half_size_posy1,
-                          vf->priv->bounding_rectangle_half_size_posx2, vf->priv->bounding_rectangle_half_size_posy2);
-          break;
-
-    default:
-        mp_msg(MSGT_VFILTER,MSGL_ERR,"Unhandled format: 0x%X\n",dmpi->imgfmt);
-        return 0;
-    }
-
-    return vf_next_put_image(vf,dmpi, pts);
-}
-
-//===========================================================================//
-
-/**
- * \brief Checks to see if the next filter accepts YV12 images.
- */
-static int query_format(struct vf_instance *vf, unsigned int fmt)
-{
-  if (fmt == IMGFMT_YV12)
-    return vf_next_query_format(vf, IMGFMT_YV12);
-  else
-    return 0;
-}
-
-/**
- * \brief Frees memory that our filter allocated.
- *
- * This is called at exit-time.
- */
-static void uninit(vf_instance_t *vf)
-{
-  /* Destroy our masks and images. */
-  destroy_pgm(vf->priv->filter);
-  destroy_pgm(vf->priv->half_size_filter);
-  destroy_masks(vf);
-
-  /* Destroy our private structure that had been used to store those masks and images. */
-  free(vf->priv);
-
-  return;
-}
-
-/**
- * \brief Initializes our filter.
- *
- * \param args The arguments passed in from the command line go here. This
- *             filter expects only a single argument telling it where the PGM
- *             or PPM file that describes the logo region is.
- *
- * This sets up our instance variables and parses the arguments to the filter.
- */
-static int vf_open(vf_instance_t *vf, char *args)
-{
-  vf->priv = safe_malloc(sizeof(vf_priv_s));
-  vf->uninit = uninit;
-
-  /* Load our filter image. */
-  if (args)
-    vf->priv->filter = load_pgm(args);
-  else
-  {
-    mp_msg(MSGT_VFILTER, MSGL_ERR, "[vf]remove_logo usage: remove_logo=/path/to/filter_image_file.pgm\n");
-    free(vf->priv);
-    return 0;
-  }
-
-  if (vf->priv->filter == NULL)
-  {
-    /* Error message was displayed by load_pgm(). */
-    free(vf->priv);
-    return 0;
-  }
-
-  /* Create the scaled down filter image for the chroma planes. */
-  convert_mask_to_strength_mask(vf, vf->priv->filter);
-  vf->priv->half_size_filter = generate_half_size_image(vf, vf->priv->filter);
-
-  /* Now that we know how many masks we need (the info is in vf), we can generate the masks. */
-  initialize_masks(vf);
-
-  /* Calculate our bounding rectangles, which determine in what region the logo resides for faster processing. */
-  calculate_bounding_rectangle(&vf->priv->bounding_rectangle_posx1, &vf->priv->bounding_rectangle_posy1,
-                               &vf->priv->bounding_rectangle_posx2, &vf->priv->bounding_rectangle_posy2,
-                                vf->priv->filter);
-  calculate_bounding_rectangle(&vf->priv->bounding_rectangle_half_size_posx1,
-                               &vf->priv->bounding_rectangle_half_size_posy1,
-                               &vf->priv->bounding_rectangle_half_size_posx2,
-                               &vf->priv->bounding_rectangle_half_size_posy2,
-                                vf->priv->half_size_filter);
-
-  vf->config=config;
-  vf->put_image=put_image;
-  vf->query_format=query_format;
-  return 1;
-}
-
-/**
- * \brief Meta data about our filter.
- */
-const vf_info_t vf_info_remove_logo = {
-    "Removes a tv logo based on a mask image.",
-    "remove-logo",
-    "Robert Edele",
-    "",
-    vf_open,
-    NULL
-};
-
-//===========================================================================//