AG_GST_CHECK_PLUGIN(cheeseeffects)

gst/cheeseeffects/Makefile

plugin_LTLIBRARIES = libgstcheeseeffects.la

libgstcheeseeffects_la_SOURCES = \

	gstplugin.c \

	gstcommon.c \

	gstsqueeze.c

libgstcheeseeffects_la_CFLAGS = \

	$(GST_PLUGINS_BASE_CFLAGS) \

	$(GST_CFLAGS)

libgstcheeseeffects_la_LIBADD = \

	$(GST_PLUGINS_BASE_LIBS) -lgstvideo-@GST_MAJORMINOR@ \

	$(GST_BASE_LIBS) \

	$(GST_LIBS) \

	$(LIBM)

libgstcheeseeffects_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)

libgstcheeseeffects_la_LIBTOOLFLAGS = --tag=disable-static

noinst_HEADERS = gstcommon.h gstsqueeze.h

/* GStreamer

 * Copyright (C) <2010> Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

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

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#include "gstcommon.h"

GType

gst_cheese_interp_method_get_type (void)

{

  static GType interp_method_type = 0;

  static const GEnumValue interp_methods[] = {

    {GST_CHEESE_INTERP_NEAREST, "Nearest Neighbour", "nearest-neighbour"},

    {GST_CHEESE_INTERP_BILINEAR, "Bilinear", "bilinear"},

    {0, NULL, NULL},

  };

  if (!interp_method_type) {

    interp_method_type =

        g_enum_register_static ("GstCheeseInterpMethod", interp_methods);

  }

  return interp_method_type;

}

gdouble

smoothstep (gdouble edge0, gdouble edge1, gdouble x)

{

  gdouble t = CLAMP ((x - edge0) / (edge1 - edge0), 0.0, 1.0);

  return t * t * (3.0 - 2.0 * t);

}

gdouble

length (gdouble x, gdouble y)

{

  return sqrt (x * x + y * y);

}

/**

 * bilerp:

 * @tl: top left pixel

 * @tr: top right pixel

 * @bl: bottom pixel

 * @br: bottom right pixel

 * @u: fixed point (with 8 bit fractional part) u texture coordinate

 * @v: fixed point (with 8 bit fractional part) v texture coordinate

 *

 * Retrieves pixel color at fractional coordinate (u,v) using known colors from the four given neighbours

 *

 * Return value: interpolated pixel

 */

guint32

bilerp (guint32 tl, guint32 tr, guint32 bl, guint32 br, guint32 u, guint32 v)

{

  guint32 f, r;

  guint32 du, dv;

  guint32 duv, duiv, diuv, diuiv;

  guint32 ptr, ptl, pbl, pbr;

  /* take fractional part from texture coords */

  du = u & 0x000000ff;

  dv = v & 0x000000ff;

  /* interpolation coefficients */

  duv = du * dv;

  duiv = (du << 8) - duv;       /* du * (256 - dv) */

  diuv = (dv << 8) - duv;       /* (256 - du) * dv */

  diuiv = 65536 - duv - diuv - duiv;    /* (256 - du) * (256 - dv) */

  /* restore fixed point at 8 */

  duv >>= 8;

  duiv >>= 8;

  diuv >>= 8;

  diuiv >>= 8;

  /* take first color component and convert it to fixed point */

  /* ptl = ((tl >> 24) & 0xFF) << 8                           */

  /*     = (tl & 0xFF000000) >> (24 - 8)                      */

  /*     = tl >> 16                                           */

  ptl = tl >> 16;

  ptr = tr >> 16;

  pbl = bl >> 16;

  pbr = br >> 16;

  /* bilinear interpolation */

  r = (ptl * diuiv) + (ptr * duiv)

      + (pbl * diuv) + (pbr * duv);

  /* take integer part, shifted 8 bits to the left after mult, and put

   * it in the right place inside the pixel */

  r = (r & 0x00ff0000) << 8;

  /* repeat for the other components */

  ptl = (tl & 0x00ff0000) >> 8;

  ptr = (tr & 0x00ff0000) >> 8;

  pbl = (bl & 0x00ff0000) >> 8;

  pbr = (br & 0x00ff0000) >> 8;

  f = (ptl * diuiv) + (ptr * duiv)

      + (pbl * diuv) + (pbr * duv);

  r |= (f & 0x00ff0000);

  ptl = (tl & 0x0000ff00);

  ptr = (tr & 0x0000ff00);

  pbl = (bl & 0x0000ff00);

  pbr = (br & 0x0000ff00);

  f = (ptl * diuiv) + (ptr * duiv)

      + (pbl * diuv) + (pbr * duv);

  r |= (f & 0x00ff0000) >> 8;

  ptl = (tl & 0x000000ff) << 8;

  ptr = (tr & 0x000000ff) << 8;

  pbl = (bl & 0x000000ff) << 8;

  pbr = (br & 0x000000ff) << 8;

  f = (ptl * diuiv) + (ptr * duiv)

      + (pbl * diuv) + (pbr * duv);

  r |= (f & 0x00ff0000) >> 16;

  return r;

}

/* GStreamer

 * Copyright (C) <2010> Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

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

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifndef __GST_CHEESECOMMON_H__

#define __GST_CHEESECOMMON_H__

#include <gst/gst.h>

#include <gst/video/gstvideofilter.h>

#include <math.h>

G_BEGIN_DECLS

#define GST_TYPE_CHEESE_INTERP_METHOD (gst_cheese_interp_method_get_type())

    GType gst_cheese_interp_method_get_type (void);

/**

 * GstCheeseInterpMethod:

 * @GST_CHEESE_INTERP_NEAREST: use nearest neighbour interpolation (fast but jagged).

 * @GST_CHEESE_INTERP_BILINEAR: use bilinear interpolation (slow but smooth).

 *

 * Interpolation method to get correct pixel colors from transformed

 * fractional coordinates

 */

typedef enum

{

  GST_CHEESE_INTERP_NEAREST,

  GST_CHEESE_INTERP_BILINEAR,

} GstCheeseInterpMethod;

#define DEFAULT_INTERP_METHOD GST_CHEESE_INTERP_NEAREST

gdouble smoothstep (gdouble edge0, gdouble edge1, gdouble x);

gdouble length (gdouble x, gdouble y);

guint32 bilerp (guint32 tl, guint32 tr, guint32 bl, guint32 br, guint32 u,

    guint32 v);

G_END_DECLS

#endif /* __GST_CHEESECOMMON_H__ */

/* GStreamer

 * Copyright (C) <2010> Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

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

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif

#include <gst/gst.h>

#include "gstsqueeze.h"

#ifndef PACKAGE

#define PACKAGE "cheeseeffects"

#endif

struct _elements_entry

{

  const gchar *name;

    GType (*type) (void);

};

static const struct _elements_entry _elements[] = {

  {"cheesesqueeze", gst_cheese_squeeze_get_type},

  {NULL, 0},

};

static gboolean

plugin_init (GstPlugin * plugin)

{

  gint i = 0;

  while (_elements[i].name) {

    if (!gst_element_register (plugin, _elements[i].name,

            GST_RANK_NONE, (_elements[i].type) ()))

      return FALSE;

    i++;

  }

  return TRUE;

}

GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,

    GST_VERSION_MINOR,

    "cheeseeffects",

    "cheese video effects.",

    plugin_init, VERSION, "LGPL", "GStreamer", "http://gstreamer.net/")

/* GStreamer

 * Copyright (C) <2010> Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

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

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/**

 * SECTION:element-squeeze

 *

 * Squeeze applies a transform that diverges at the center of the

 * video giving the impression that the video surface is being pinched

 *

 * <refsect2>

 * <title>Example launch line</title>

 * |[

 * gst-launch -v videotestsrc ! cheesesqueeze ! ffmpegcolorspace ! autovideosink

 * ]| This pipeline shows the effect of cheesesqueeze on a test stream.

 * </refsect2>

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gst/video/video.h>

#include "gstsqueeze.h"

enum

{

  PROP_0,

  PROP_METHOD

};

static void gst_cheese_squeeze_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec);

static void gst_cheese_squeeze_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec);

GST_BOILERPLATE (GstCheeseSqueeze, gst_cheese_squeeze, GstVideoFilter,

    GST_TYPE_VIDEO_FILTER);

static void init_distortion_map (GstCheeseSqueeze * filter);

static GstStaticPadTemplate gst_cheese_squeeze_src_template =

    GST_STATIC_PAD_TEMPLATE ("src",

    GST_PAD_SRC,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_xRGB ";"

        GST_VIDEO_CAPS_BGRx ";" GST_VIDEO_CAPS_xBGR ";"

        GST_VIDEO_CAPS_YUV ("AYUV"))

    );

static GstStaticPadTemplate gst_cheese_squeeze_sink_template =

    GST_STATIC_PAD_TEMPLATE ("sink",

    GST_PAD_SINK,

    GST_PAD_ALWAYS,

    GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBx ";" GST_VIDEO_CAPS_xRGB ";"

        GST_VIDEO_CAPS_BGRx ";" GST_VIDEO_CAPS_xBGR ";"

        GST_VIDEO_CAPS_YUV ("AYUV"))

    );

static gboolean

gst_cheese_squeeze_set_caps (GstBaseTransform * btrans, GstCaps * incaps,

    GstCaps * outcaps)

{

  GstCheeseSqueeze *filter = GST_CHEESE_SQUEEZE (btrans);

  GstStructure *structure;

  gboolean ret = FALSE;

  structure = gst_caps_get_structure (incaps, 0);

  GST_OBJECT_LOCK (filter);

  if (gst_structure_get_int (structure, "width", &filter->width) &&

      gst_structure_get_int (structure, "height", &filter->height)) {

    g_free (filter->map);

    filter->map =

        g_malloc (2 * filter->width * filter->height * sizeof (guint32));

    init_distortion_map (filter);

    ret = TRUE;

  }

  GST_OBJECT_UNLOCK (filter);

  return ret;

}

static GstFlowReturn

gst_cheese_squeeze_transform (GstBaseTransform * trans, GstBuffer * in,

    GstBuffer * out)

{

  GstCheeseSqueeze *filter = GST_CHEESE_SQUEEZE (trans);

  guint32 *src = (guint32 *) GST_BUFFER_DATA (in);

  guint32 *dest = (guint32 *) GST_BUFFER_DATA (out);

  gint width, height;

  gint x, y;

  guint32 newx, newy;

  guint32 u, v;

  guint32 idx;

  guint32 tlidx;

  guint32 tridx;

  guint32 blidx;

  guint32 bridx;

  GstFlowReturn ret = GST_FLOW_OK;

  GST_OBJECT_LOCK (filter);

  width = filter->width;

  height = filter->height;

  for (y = 0; y < height; y++) {

    for (x = 0; x < width; x++) {

      /* may be worth to precalculate offsets in an outer loop like

         warptv does */

      idx = 2 * (x + y * width);

      /* u, v, fixed point coordinates */

      u = filter->map[idx];

      v = filter->map[idx + 1];

      switch (filter->method) {

        case GST_CHEESE_INTERP_NEAREST:

          newx = (u + 128) >> 8;        /* nearbyint (newx) */

          newy = (v + 128) >> 8;        /* nearbyint (newy) */

          dest[x + y * width] = src[newx + newy * width];

          break;

        case GST_CHEESE_INTERP_BILINEAR:

          newx = u >> 8;        /* floor (newx) */

          newy = v >> 8;        /* floor (newy) */

          /* do not try to interpolate with out of bound pixels */

          /* is there a better way to do this? */

          tlidx = newx + newy * width;

          tridx = (CLAMP (newx + 1, 0, width - 1)) + newy * width;

          blidx = newx + (CLAMP (newy + 1, 0, height - 1)) * width;

          bridx =

              (CLAMP (newx + 1, 0, width - 1)) + (CLAMP (newy + 1, 0,

                  height - 1)) * width;

          dest[x + y * width] = bilerp (src[tlidx], src[tridx],

              src[blidx], src[bridx], u, v);

          break;

        default:

          g_assert_not_reached ();

      }

    }

  }

  GST_OBJECT_UNLOCK (filter);

  return ret;

}

static void

gst_cheese_squeeze_set_property (GObject * object, guint prop_id,

    const GValue * value, GParamSpec * pspec)

{

  GstCheeseSqueeze *filter = GST_CHEESE_SQUEEZE (object);

  switch (prop_id) {

    case PROP_METHOD:

      GST_OBJECT_LOCK (filter);

      filter->method = g_value_get_enum (value);

      GST_OBJECT_UNLOCK (filter);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_cheese_squeeze_get_property (GObject * object, guint prop_id,

    GValue * value, GParamSpec * pspec)

{

  GstCheeseSqueeze *filter = GST_CHEESE_SQUEEZE (object);

  switch (prop_id) {

    case PROP_METHOD:

      GST_OBJECT_LOCK (filter);

      g_value_set_enum (value, filter->method);

      GST_OBJECT_UNLOCK (filter);

      break;

    default:

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

      break;

  }

}

static void

gst_cheese_squeeze_finalize (GObject * object)

{

  GstCheeseSqueeze *filter = GST_CHEESE_SQUEEZE (object);

  g_free (filter->map);

  G_OBJECT_CLASS (parent_class)->finalize (object);

}

static void

gst_cheese_squeeze_base_init (gpointer g_class)

{

  GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

  gst_element_class_set_details_simple (element_class, "Squeeze effect",

      "Filter/Effect/Video",

      "Squeeze the video input",

      "Filippo Argiolas <filippo.argiolas@gmail.com>");

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_cheese_squeeze_sink_template));

  gst_element_class_add_pad_template (element_class,

      gst_static_pad_template_get (&gst_cheese_squeeze_src_template));

}

static void

gst_cheese_squeeze_class_init (GstCheeseSqueezeClass * klass)

{

  GObjectClass *gobject_class = (GObjectClass *) klass;

  GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;

  gobject_class->finalize = gst_cheese_squeeze_finalize;

  gobject_class->set_property = gst_cheese_squeeze_set_property;

  gobject_class->get_property = gst_cheese_squeeze_get_property;

  g_object_class_install_property (gobject_class, PROP_METHOD,

      g_param_spec_enum ("interp-method", "interp-method",

          "How to calculate the color of transformed fractional coordinates",

          GST_TYPE_CHEESE_INTERP_METHOD, DEFAULT_INTERP_METHOD,

          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_cheese_squeeze_set_caps);

  trans_class->transform = GST_DEBUG_FUNCPTR (gst_cheese_squeeze_transform);

}

static void

gst_cheese_squeeze_init (GstCheeseSqueeze * filter,

    GstCheeseSqueezeClass * klass)

{

  filter->map = NULL;

  gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SRC_PAD (filter));

  gst_pad_use_fixed_caps (GST_BASE_TRANSFORM_SINK_PAD (filter));

}

static void

init_distortion_map (GstCheeseSqueeze * filter)

{

  gint x, y;

  gdouble newx, newy;

  gdouble norm_x;

  gdouble norm_y;

  gdouble r;

  gint width = filter->width;

  gint height = filter->height;

  gdouble hw = (width - 1.0) / 2.0;

  gdouble hh = (height - 1.0) / 2.0;

  /* this is run once at set_caps so it's optimized for readability

   * and math clarity, not for performance */

  for (y = 0; y < height; y++) {

    for (x = 0; x < width; x++) {

      /* normalize in ((-1.0, -1.0), (1.0, 1.0) */

      norm_x = x / hw - 1.0;

      norm_y = y / hh - 1.0;

      /* work on r to have circular simmetry around center */

      r = length (norm_x, norm_y);

      /* transform */

      /* the power of r is the amount of squeezing, the lower it is

       * the smoother will be the squeeze. */

      /* the multiplicative factor is the zooming amount (given the

       * squeezing moves everything to the center a little zoom can be

       * nice) */

      if (r > 0)

        norm_x /= pow (r, 0.4) * 1.2;

      /* ensure transform doesn't give us out of bound coordinates */

      norm_x = CLAMP (norm_x, -1.0, 1.0);

      norm_y = CLAMP (norm_y, -1.0, 1.0);

      /* unnormalize */

      newx = (norm_x + 1.0) * hw;

      newy = (norm_y + 1.0) * hh;

      /* store new coordinates in fixed point (32 bits with 8 bits for

         the fractional part) */

      /* transformed x and y are stored in the map next to each other */

      filter->map[(2 * x) + y * 2 * width] = newx * 256;

      filter->map[(2 * x + 1) + y * 2 * width] = newy * 256;

    }

  }

}

/* GStreamer

 * Copyright (C) <2010> Filippo Argiolas <filippo.argiolas@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

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

 *

 * This library 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

 * Library General Public License for more details.

 *

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

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

#ifndef __GST_CHEESE_SQUEEZE_H__

#define __GST_CHEESE_SQUEEZE_H__

#include <gst/gst.h>

#include <gst/video/gstvideofilter.h>

#include "gstcommon.h"

G_BEGIN_DECLS

#define GST_TYPE_CHEESE_SQUEEZE \

  (gst_cheese_squeeze_get_type())

#define GST_CHEESE_SQUEEZE(obj) \

  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CHEESE_SQUEEZE,GstCheeseSqueeze))

#define GST_CHEESE_SQUEEZE_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CHEESE_SQUEEZE,GstCheeseSqueezeClass))

#define GST_IS_CHEESE_SQUEEZE(obj) \

  (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CHEESE_SQUEEZE))

#define GST_IS_CHEESE_SQUEEZE_CLASS(klass) \

  (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CHEESE_SQUEEZE))

typedef struct _GstCheeseSqueeze GstCheeseSqueeze;

typedef struct _GstCheeseSqueezeClass GstCheeseSqueezeClass;

struct _GstCheeseSqueeze

{

  GstVideoFilter videofilter;

  /* < private > */

  GstCheeseInterpMethod method;

  gint width, height;

  guint32 *map;

};

struct _GstCheeseSqueezeClass

{

  GstVideoFilterClass parent_class;

};

GType gst_cheese_squeeze_get_type (void);

G_END_DECLS

#endif /* __GST_CHEESE_SQUEEZE_H__ */