gst/gaudieffects/gstsolarize.c

   1 /*
   2  * GStreamer
   3  * Copyright (C) 2010 Luis de Bethencourt <luis@debethencourt.com>
   4  *
   5  * Solarize - curve adjustment video effect.
   6  * Based on Pete Warden's FreeFrame plugin with the same name.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  24  * DEALINGS IN THE SOFTWARE.
  25  *
  26  * Alternatively, the contents of this file may be used under the
  27  * GNU Lesser General Public License Version 2.1 (the "LGPL"), in
  28  * which case the following provisions apply instead of the ones
  29  * mentioned above:
  30  *
  31  * This library is free software; you can redistribute it and/or
  32  * modify it under the terms of the GNU Library General Public
  33  * License as published by the Free Software Foundation; either
  34  * version 2 of the License, or (at your option) any later version.
  35  *
  36  * This library is distributed in the hope that it will be useful,
  37  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  38  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  39  * Library General Public License for more details.
  40  *
  41  * You should have received a copy of the GNU Library General Public
  42  * License along with this library; if not, write to the
  43  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  44  * Boston, MA 02111-1307, USA.
  45  */
  46
  47 /**
  48  * SECTION:element-solarize
  49  *
  50  * Solarize does a smart inverse in a video stream in realtime.
  51  *
  52  * <refsect2>
  53  * <title>Example launch line</title>
  54  * |[
  55  * gst-launch -v videotestsrc ! solarize ! ffmpegcolorspace ! autovideosink
  56  * ]| This pipeline shows the effect of solarize on a test stream
  57  * </refsect2>
  58  */
  59
  60 #ifdef HAVE_CONFIG_H
  61 #  include <config.h>
  62 #endif
  63
  64 #include <gst/gst.h>
  65 #include <math.h>
  66
  67 #include "gstplugin.h"
  68 #include "gstsolarize.h"
  69
  70 #include <gst/video/video.h>
  71 #include <gst/controller/gstcontroller.h>
  72
  73 GST_DEBUG_CATEGORY_STATIC (gst_solarize_debug);
  74 #define GST_CAT_DEFAULT gst_solarize_debug
  75
  76 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
  77 #define CAPS_STR GST_VIDEO_CAPS_BGRx ";" GST_VIDEO_CAPS_RGBx
  78 #else
  79 #define CAPS_STR GST_VIDEO_CAPS_xRGB ";" GST_VIDEO_CAPS_xBGR
  80 #endif
  81
  82 /* Filter signals and args. */
  83 enum
  84 {
  85   LAST_SIGNAL
  86 };
  87
  88 enum
  89 {
  90   PROP_0,
  91   PROP_SILENT
  92 };
  93
  94 /* Initializations */
  95
  96 static gint gate_int (gint value, gint min, gint max);
  97 static void transform (guint32 * src, guint32 * dest, gint video_area);
  98
  99 /* The capabilities of the inputs and outputs. */
 100
 101 static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
 102     GST_PAD_SINK,
 103     GST_PAD_ALWAYS,
 104     GST_STATIC_CAPS (CAPS_STR)
 105     );
 106
 107 static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
 108     GST_PAD_SRC,
 109     GST_PAD_ALWAYS,
 110     GST_STATIC_CAPS (CAPS_STR)
 111     );
 112
 113 GST_BOILERPLATE (GstSolarize, gst_solarize, GstVideoFilter,
 114     GST_TYPE_VIDEO_FILTER);
 115
 116 static void gst_solarize_set_property (GObject * object, guint prop_id,
 117     const GValue * value, GParamSpec * pspec);
 118 static void gst_solarize_get_property (GObject * object, guint prop_id,
 119     GValue * value, GParamSpec * pspec);
 120
 121 static gboolean gst_solarize_set_caps (GstBaseTransform * btrans,
 122     GstCaps * incaps, GstCaps * outcaps);
 123 static GstFlowReturn gst_solarize_transform (GstBaseTransform * btrans,
 124     GstBuffer * in_buf, GstBuffer * out_buf);
 125
 126 /* GObject vmethod implementations */
 127
 128 static void
 129 gst_solarize_base_init (gpointer gclass)
 130 {
 131   GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
 132
 133   gst_element_class_set_details_simple (element_class,
 134       "Solarize",
 135       "Filter/Effect/Video",
 136       "Solarize tunable inverse in the video signal.",
 137       "Luis de Bethencourt <luis@debethencourt.com>");
 138
 139   gst_element_class_add_pad_template (element_class,
 140       gst_static_pad_template_get (&src_factory));
 141   gst_element_class_add_pad_template (element_class,
 142       gst_static_pad_template_get (&sink_factory));
 143 }
 144
 145 /* Initialize the solarize's class. */
 146 static void
 147 gst_solarize_class_init (GstSolarizeClass * klass)
 148 {
 149   GObjectClass *gobject_class = (GObjectClass *) klass;
 150   GstBaseTransformClass *trans_class = (GstBaseTransformClass *) klass;
 151
 152   gobject_class->set_property = gst_solarize_set_property;
 153   gobject_class->get_property = gst_solarize_get_property;
 154
 155   g_object_class_install_property (gobject_class, PROP_SILENT,
 156       g_param_spec_boolean ("silent", "Silent", "Produce verbose output ?",
 157           FALSE, G_PARAM_READWRITE));
 158
 159   trans_class->set_caps = GST_DEBUG_FUNCPTR (gst_solarize_set_caps);
 160   trans_class->transform = GST_DEBUG_FUNCPTR (gst_solarize_transform);
 161 }
 162
 163 /* Initialize the new element,
 164  * instantiate pads and add them to element,
 165  * set pad calback functions, and
 166  * initialize instance structure.
 167  */
 168 static void
 169 gst_solarize_init (GstSolarize * filter, GstSolarizeClass * gclass)
 170 {
 171   filter->silent = FALSE;
 172 }
 173
 174 static void
 175 gst_solarize_set_property (GObject * object, guint prop_id,
 176     const GValue * value, GParamSpec * pspec)
 177 {
 178   GstSolarize *filter = GST_SOLARIZE (object);
 179
 180   switch (prop_id) {
 181     case PROP_SILENT:
 182       filter->silent = g_value_get_boolean (value);
 183       break;
 184     default:
 185       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 186       break;
 187   }
 188 }
 189
 190 static void
 191 gst_solarize_get_property (GObject * object, guint prop_id,
 192     GValue * value, GParamSpec * pspec)
 193 {
 194   GstSolarize *filter = GST_SOLARIZE (object);
 195
 196   switch (prop_id) {
 197     case PROP_SILENT:
 198       g_value_set_boolean (value, filter->silent);
 199       break;
 200     default:
 201       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 202       break;
 203   }
 204 }
 205
 206 /* GstElement vmethod implementations */
 207
 208 /* Handle the link with other elements. */
 209 static gboolean
 210 gst_solarize_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
 211     GstCaps * outcaps)
 212 {
 213   GstSolarize *filter = GST_SOLARIZE (btrans);
 214   GstStructure *structure;
 215   gboolean ret = TRUE;
 216
 217   structure = gst_caps_get_structure (incaps, 0);
 218   ret &= gst_structure_get_int (structure, "width", &filter->width);
 219   ret &= gst_structure_get_int (structure, "height", &filter->height);
 220
 221   return ret;
 222 }
 223
 224 /* Actual processing. */
 225 static GstFlowReturn
 226 gst_solarize_transform (GstBaseTransform * btrans,
 227     GstBuffer * in_buf, GstBuffer * out_buf)
 228 {
 229   GstSolarize *filter = GST_SOLARIZE (btrans);
 230   gint video_size;
 231   guint32 *src = (guint32 *) GST_BUFFER_DATA (in_buf);
 232   guint32 *dest = (guint32 *) GST_BUFFER_DATA (out_buf);
 233
 234   video_size = filter->width * filter->height;
 235
 236   transform (src, dest, video_size);
 237
 238   return GST_FLOW_OK;
 239 }
 240
 241 /* Entry point to initialize the plug-in.
 242  * Register the element factories and other features. */
 243 gboolean
 244 gst_solarize_plugin_init (GstPlugin * solarize)
 245 {
 246   /* debug category for fltering log messages */
 247   GST_DEBUG_CATEGORY_INIT (gst_solarize_debug, "solarize",
 248       0, "Template solarize");
 249
 250   return gst_element_register (solarize, "solarize", GST_RANK_NONE,
 251       GST_TYPE_SOLARIZE);
 252 }
 253
 254 /*** Now the image processing work.... ***/
 255
 256 /* Keep the values inbounds. */
 257 static gint
 258 gate_int (gint value, gint min, gint max)
 259 {
 260   if (value < min) {
 261     return min;
 262   } else if (value > max) {
 263     return max;
 264   } else {
 265     return value;
 266   }
 267 }
 268
 269 /* Transform processes each frame. */
 270 static void
 271 transform (guint32 * src, guint32 * dest, gint video_area)
 272 {
 273   guint32 in;
 274   guint32 color[3];
 275   gint x, c;
 276   gint threshold = 127;
 277   gint start = 50;
 278   gint end = 185;
 279   gint floor = 0;
 280   gint ceiling = 255;
 281
 282   gint period, up_length, down_length, height_scale, param;
 283
 284   period = end - start;
 285   if (period == 0) {
 286     period = 1;
 287   }
 288
 289   up_length = threshold - start;
 290   if (up_length == 0) {
 291     up_length = 1;
 292   }
 293
 294   down_length = end - threshold;
 295   if (down_length == 0) {
 296     down_length = 1;
 297   }
 298
 299   height_scale = ceiling - floor;
 300
 301   /* Loop through pixels. */
 302   for (x = 0; x < video_area; x++) {
 303     in = *src++;
 304
 305     color[0] = (in >> 16) & 0xff;
 306     color[1] = (in >> 8) & 0xff;
 307     color[2] = (in) & 0xff;
 308
 309     /* Loop through colors. */
 310     for (c = 0; c < 3; c++) {
 311       param = color[c];
 312       param += 256;
 313       param -= start;
 314       param %= period;
 315
 316       if (param < up_length) {
 317         color[c] = param * height_scale;
 318         color[c] /= up_length;
 319         color[c] += floor;
 320       } else {
 321         color[c] = down_length - (param - up_length);
 322         color[c] *= height_scale;
 323         color[c] /= down_length;
 324         color[c] += floor;
 325       }
 326     }
 327
 328     color[0] = gate_int (color[0], 0, 255);
 329     color[1] = gate_int (color[1], 0, 255);
 330     color[2] = gate_int (color[2], 0, 255);
 331
 332     *dest++ = (color[0] << 16) | (color[1] << 8) | color[2];
 333   }
 334 }