1 /* GStreamer

     2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>

     3  * Copyright (C) <2007> Wim Taymans <wim.taymans@collabora.co.uk>

     4  * Copyright (C) <2007> Edward Hervey <edward.hervey@collabora.co.uk>

     5  * Copyright (C) <2007> Jan Schmidt <thaytan@noraisin.net>

     6  *

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

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

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

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

    11  *

    12  * This library is distributed in the hope that it will be useful,

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

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

    15  * Library General Public License for more details.

    16  *

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

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

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

    20  * Boston, MA 02111-1307, USA.

    21  */

    22 

    23 #ifdef HAVE_CONFIG_H

    24 #include "config.h"

    25 #endif

    26 #include <gst/gst.h>

    27 #include <gst/base/gstbasetransform.h>

    28 #include <gst/video/video.h>

    29 #include <gst/controller/gstcontroller.h>

    30 

    31 #include <stdlib.h>

    32 #include <string.h>

    33 #include <math.h>

    34 

    35 #ifndef M_PI

    36 #define M_PI  3.14159265358979323846

    37 #endif

    38 

    39 #define GST_TYPE_ALPHA \

    40   (gst_alpha_get_type())

    41 #define GST_ALPHA(obj) \

    42   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_ALPHA,GstAlpha))

    43 #define GST_ALPHA_CLASS(klass) \

    44   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_ALPHA,GstAlphaClass))

    45 #define GST_IS_ALPHA(obj) \

    46   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_ALPHA))

    47 #define GST_IS_ALPHA_CLASS(klass) \

    48   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_ALPHA))

    49 

    50 typedef struct _GstAlpha GstAlpha;

    51 typedef struct _GstAlphaClass GstAlphaClass;

    52 

    53 typedef enum

    54 {

    55   ALPHA_METHOD_SET,

    56   ALPHA_METHOD_GREEN,

    57   ALPHA_METHOD_BLUE,

    58   ALPHA_METHOD_CUSTOM,

    59 }

    60 GstAlphaMethod;

    61 

    62 GST_DEBUG_CATEGORY_STATIC (gst_alpha_debug);

    63 #define GST_CAT_DEFAULT gst_alpha_debug

    64 

    65 struct _GstAlpha

    66 {

    67   GstBaseTransform parent;

    68 

    69   /* caps */

    70   GstVideoFormat format;

    71   gint width, height;

    72   gboolean ayuv;

    73 

    74   gdouble alpha;

    75 

    76   guint target_r;

    77   guint target_g;

    78   guint target_b;

    79 

    80   GstAlphaMethod method;

    81 

    82   gfloat angle;

    83   gfloat noise_level;

    84   guint black_sensitivity;

    85   guint white_sensitivity;

    86 

    87   gfloat y;                     /* chroma color */

    88   gint8 cb, cr;

    89   gint8 kg;

    90   gfloat accept_angle_cos;

    91   gfloat accept_angle_sin;

    92   guint8 accept_angle_tg;

    93   guint8 accept_angle_ctg;

    94   guint8 one_over_kc;

    95   guint8 kfgy_scale;

    96 };

    97 

    98 struct _GstAlphaClass

    99 {

   100   GstBaseTransformClass parent_class;

   101 };

   102 

   103 /* elementfactory information */

   104 static const GstElementDetails gst_alpha_details =

   105 GST_ELEMENT_DETAILS ("Alpha filter",

   106     "Filter/Effect/Video",

   107     "Adds an alpha channel to video - uniform or via chroma-keying",

   108     "Wim Taymans <wim@fluendo.com>\n"

   109     "Edward Hervey <edward.hervey@collabora.co.uk>\n"

   110     "Jan Schmidt <thaytan@noraisin.net>");

   111 

   112 /* Alpha signals and args */

   113 enum

   114 {

   115   /* FILL ME */

   116   LAST_SIGNAL

   117 };

   118 

   119 #define DEFAULT_METHOD ALPHA_METHOD_SET

   120 #define DEFAULT_ALPHA 1.0

   121 #define DEFAULT_TARGET_R 0

   122 #define DEFAULT_TARGET_G 255

   123 #define DEFAULT_TARGET_B 0

   124 #define DEFAULT_ANGLE 20.0

   125 #define DEFAULT_NOISE_LEVEL 2.0

   126 #define DEFAULT_BLACK_SENSITIVITY 100

   127 #define DEFAULT_WHITE_SENSITIVITY 100

   128 

   129 enum

   130 {

   131   PROP_0,

   132   PROP_METHOD,

   133   PROP_ALPHA,

   134   PROP_TARGET_R,

   135   PROP_TARGET_G,

   136   PROP_TARGET_B,

   137   PROP_ANGLE,

   138   PROP_NOISE_LEVEL,

   139   PROP_BLACK_SENSITIVITY,

   140   PROP_WHITE_SENSITIVITY,

   141   PROP_LAST

   142 };

   143 

   144 static GstStaticPadTemplate gst_alpha_src_template =

   145 GST_STATIC_PAD_TEMPLATE ("src",

   146     GST_PAD_SRC,

   147     GST_PAD_ALWAYS,

   148     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("AYUV"))

   149     );

   150 

   151 static GstStaticPadTemplate gst_alpha_sink_template =

   152     GST_STATIC_PAD_TEMPLATE ("sink",

   153     GST_PAD_SINK,

   154     GST_PAD_ALWAYS,

   155     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("AYUV") ";" GST_VIDEO_CAPS_YUV ("I420")

   156     )

   157     );

   158 

   159 static gboolean gst_alpha_start (GstBaseTransform * trans);

   160 static gboolean gst_alpha_get_unit_size (GstBaseTransform * btrans,

   161     GstCaps * caps, guint * size);

   162 static GstCaps *gst_alpha_transform_caps (GstBaseTransform * btrans,

   163     GstPadDirection direction, GstCaps * caps);

   164 static gboolean gst_alpha_set_caps (GstBaseTransform * btrans,

   165     GstCaps * incaps, GstCaps * outcaps);

   166 static GstFlowReturn gst_alpha_transform (GstBaseTransform * btrans,

   167     GstBuffer * in, GstBuffer * out);

   168 

   169 static void gst_alpha_init_params (GstAlpha * alpha);

   170 

   171 static void gst_alpha_set_property (GObject * object, guint prop_id,

   172     const GValue * value, GParamSpec * pspec);

   173 static void gst_alpha_get_property (GObject * object, guint prop_id,

   174     GValue * value, GParamSpec * pspec);

   175 

   176 GST_BOILERPLATE (GstAlpha, gst_alpha, GstBaseTransform,

   177     GST_TYPE_BASE_TRANSFORM);

   178 

   179 #define GST_TYPE_ALPHA_METHOD (gst_alpha_method_get_type())

   180 static GType

   181 gst_alpha_method_get_type (void)

   182 {

   183   static GType alpha_method_type = 0;

   184   static const GEnumValue alpha_method[] = {

   185     {ALPHA_METHOD_SET, "Set/adjust alpha channel", "set"},

   186     {ALPHA_METHOD_GREEN, "Chroma Key green", "green"},

   187     {ALPHA_METHOD_BLUE, "Chroma Key blue", "blue"},

   188     {ALPHA_METHOD_CUSTOM, "Chroma Key on target_r/g/b", "custom"},

   189     {0, NULL, NULL},

   190   };

   191 

   192   if (!alpha_method_type) {

   193     alpha_method_type = g_enum_register_static ("GstAlphaMethod", alpha_method);

   194   }

   195   return alpha_method_type;

   196 }

   197 

   198 static void

   199 gst_alpha_base_init (gpointer g_class)

   200 {

   201   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   202 

   203   gst_element_class_set_details (element_class, &gst_alpha_details);

   204 

   205   gst_element_class_add_pad_template (element_class,

   206       gst_static_pad_template_get (&gst_alpha_sink_template));

   207   gst_element_class_add_pad_template (element_class,

   208       gst_static_pad_template_get (&gst_alpha_src_template));

   209 

   210   GST_DEBUG_CATEGORY_INIT (gst_alpha_debug, "alpha", 0,

   211       "alpha - Element for adding alpha channel to streams");

   212 }

   213 static void

   214 gst_alpha_class_init (GstAlphaClass * klass)

   215 {

   216   GObjectClass *gobject_class;

   217   GstBaseTransformClass *btrans_class;

   218 

   219   gobject_class = (GObjectClass *) klass;

   220   btrans_class = (GstBaseTransformClass *) klass;

   221 

   222   gobject_class->set_property = gst_alpha_set_property;

   223   gobject_class->get_property = gst_alpha_get_property;

   224 

   225   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_METHOD,

   226       g_param_spec_enum ("method", "Method",

   227           "How the alpha channels should be created", GST_TYPE_ALPHA_METHOD,

   228           DEFAULT_METHOD, (GParamFlags) G_PARAM_READWRITE));

   229   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ALPHA,

   230       g_param_spec_double ("alpha", "Alpha", "The value for the alpha channel",

   231           0.0, 1.0, DEFAULT_ALPHA,

   232           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   233   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TARGET_R,

   234       g_param_spec_uint ("target_r", "Target Red", "The Red target", 0, 255,

   235           DEFAULT_TARGET_R,

   236           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   237   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TARGET_G,

   238       g_param_spec_uint ("target_g", "Target Green", "The Green target", 0, 255,

   239           DEFAULT_TARGET_G,

   240           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   241   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TARGET_B,

   242       g_param_spec_uint ("target_b", "Target Blue", "The Blue target", 0, 255,

   243           DEFAULT_TARGET_B,

   244           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   245   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ANGLE,

   246       g_param_spec_float ("angle", "Angle", "Size of the colorcube to change",

   247           0.0, 90.0, DEFAULT_ANGLE,

   248           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   249   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_NOISE_LEVEL,

   250       g_param_spec_float ("noise_level", "Noise Level", "Size of noise radius",

   251           0.0, 64.0, DEFAULT_NOISE_LEVEL,

   252           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   253   g_object_class_install_property (G_OBJECT_CLASS (klass),

   254       PROP_BLACK_SENSITIVITY, g_param_spec_uint ("black-sensitivity",

   255           "Black Sensitivity", "Sensitivity to dark colors", 0, 128,

   256           DEFAULT_BLACK_SENSITIVITY,

   257           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   258   g_object_class_install_property (G_OBJECT_CLASS (klass),

   259       PROP_WHITE_SENSITIVITY, g_param_spec_uint ("white-sensitivity",

   260           "Sensitivity", "Sensitivity to bright colors", 0, 128,

   261           DEFAULT_WHITE_SENSITIVITY,

   262           (GParamFlags) G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE));

   263 

   264 

   265   btrans_class->start = GST_DEBUG_FUNCPTR (gst_alpha_start);

   266   btrans_class->transform = GST_DEBUG_FUNCPTR (gst_alpha_transform);

   267   btrans_class->get_unit_size = GST_DEBUG_FUNCPTR (gst_alpha_get_unit_size);

   268   btrans_class->transform_caps = GST_DEBUG_FUNCPTR (gst_alpha_transform_caps);

   269   btrans_class->set_caps = GST_DEBUG_FUNCPTR (gst_alpha_set_caps);

   270 }

   271 

   272 static void

   273 gst_alpha_init (GstAlpha * alpha, GstAlphaClass * klass)

   274 {

   275   alpha->alpha = DEFAULT_ALPHA;

   276   alpha->method = DEFAULT_METHOD;

   277   alpha->target_r = DEFAULT_TARGET_R;

   278   alpha->target_g = DEFAULT_TARGET_G;

   279   alpha->target_b = DEFAULT_TARGET_B;

   280   alpha->angle = DEFAULT_ANGLE;

   281   alpha->noise_level = DEFAULT_NOISE_LEVEL;

   282   alpha->black_sensitivity = DEFAULT_BLACK_SENSITIVITY;

   283   alpha->white_sensitivity = DEFAULT_WHITE_SENSITIVITY;

   284 }

   285 

   286 /* do we need this function? */

   287 static void

   288 gst_alpha_set_property (GObject * object, guint prop_id,

   289     const GValue * value, GParamSpec * pspec)

   290 {

   291   GstAlpha *alpha;

   292 

   293   g_return_if_fail (GST_IS_ALPHA (object));

   294 

   295   alpha = GST_ALPHA (object);

   296 

   297   switch (prop_id) {

   298     case PROP_METHOD:

   299       alpha->method = g_value_get_enum (value);

   300       switch (alpha->method) {

   301         case ALPHA_METHOD_GREEN:

   302           alpha->target_r = 0;

   303           alpha->target_g = 255;

   304           alpha->target_b = 0;

   305           break;

   306         case ALPHA_METHOD_BLUE:

   307           alpha->target_r = 0;

   308           alpha->target_g = 0;

   309           alpha->target_b = 255;

   310           break;

   311         default:

   312           break;

   313       }

   314       gst_alpha_init_params (alpha);

   315       break;

   316     case PROP_ALPHA:

   317       alpha->alpha = g_value_get_double (value);

   318       break;

   319     case PROP_TARGET_R:

   320       alpha->target_r = g_value_get_uint (value);

   321       gst_alpha_init_params (alpha);

   322       break;

   323     case PROP_TARGET_G:

   324       alpha->target_g = g_value_get_uint (value);

   325       gst_alpha_init_params (alpha);

   326       break;

   327     case PROP_TARGET_B:

   328       alpha->target_b = g_value_get_uint (value);

   329       gst_alpha_init_params (alpha);

   330       break;

   331     case PROP_ANGLE:

   332       alpha->angle = g_value_get_float (value);

   333       gst_alpha_init_params (alpha);

   334       break;

   335     case PROP_NOISE_LEVEL:

   336       alpha->noise_level = g_value_get_float (value);

   337       gst_alpha_init_params (alpha);

   338       break;

   339     case PROP_BLACK_SENSITIVITY:

   340       alpha->black_sensitivity = g_value_get_uint (value);

   341       break;

   342     case PROP_WHITE_SENSITIVITY:

   343       alpha->white_sensitivity = g_value_get_uint (value);

   344       break;

   345     default:

   346       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   347       break;

   348   }

   349 }

   350 static void

   351 gst_alpha_get_property (GObject * object, guint prop_id, GValue * value,

   352     GParamSpec * pspec)

   353 {

   354   GstAlpha *alpha;

   355 

   356   g_return_if_fail (GST_IS_ALPHA (object));

   357 

   358   alpha = GST_ALPHA (object);

   359 

   360   switch (prop_id) {

   361     case PROP_METHOD:

   362       g_value_set_enum (value, alpha->method);

   363       break;

   364     case PROP_ALPHA:

   365       g_value_set_double (value, alpha->alpha);

   366       break;

   367     case PROP_TARGET_R:

   368       g_value_set_uint (value, alpha->target_r);

   369       break;

   370     case PROP_TARGET_G:

   371       g_value_set_uint (value, alpha->target_g);

   372       break;

   373     case PROP_TARGET_B:

   374       g_value_set_uint (value, alpha->target_b);

   375       break;

   376     case PROP_ANGLE:

   377       g_value_set_float (value, alpha->angle);

   378       break;

   379     case PROP_NOISE_LEVEL:

   380       g_value_set_float (value, alpha->noise_level);

   381       break;

   382     case PROP_BLACK_SENSITIVITY:

   383       g_value_set_uint (value, alpha->black_sensitivity);

   384       break;

   385     case PROP_WHITE_SENSITIVITY:

   386       g_value_set_uint (value, alpha->white_sensitivity);

   387       break;

   388     default:

   389       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   390       break;

   391   }

   392 }

   393 

   394 static gboolean

   395 gst_alpha_get_unit_size (GstBaseTransform * btrans,

   396     GstCaps * caps, guint * size)

   397 {

   398   GstVideoFormat format;

   399   gint width, height;

   400 

   401   if (!gst_video_format_parse_caps (caps, &format, &width, &height))

   402     return FALSE;

   403 

   404   *size = gst_video_format_get_size (format, width, height);

   405 

   406   GST_DEBUG_OBJECT (btrans, "unit size = %d for format %d w %d height %d",

   407       *size, format, width, height);

   408 

   409   return TRUE;

   410 }

   411 

   412 static GstCaps *

   413 gst_alpha_transform_caps (GstBaseTransform * btrans,

   414     GstPadDirection direction, GstCaps * caps)

   415 {

   416   GstCaps *ret;

   417   GstStructure *structure;

   418   gint i;

   419 

   420   ret = gst_caps_copy (caps);

   421 

   422   /* When going from the SINK pad to the src, we just need to make sure the

   423    * format is AYUV */

   424   if (direction == GST_PAD_SINK) {

   425     for (i = 0; i < gst_caps_get_size (ret); i++) {

   426       structure = gst_caps_get_structure (ret, i);

   427       gst_structure_set (structure, "format",

   428           GST_TYPE_FOURCC, GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'), NULL);

   429     }

   430   } else {

   431     GstCaps *ayuv_caps;

   432 

   433     /* In the other direction, prepend a copy of the caps with format AYUV, 

   434      * and set the first to I420 */

   435     ayuv_caps = gst_caps_copy (ret);

   436 

   437     for (i = 0; i < gst_caps_get_size (ret); i++) {

   438       structure = gst_caps_get_structure (ret, i);

   439       gst_structure_set (structure, "format",

   440           GST_TYPE_FOURCC, GST_MAKE_FOURCC ('I', '4', '2', '0'), NULL);

   441     }

   442 

   443     gst_caps_append (ret, ayuv_caps);

   444   }

   445 

   446   gst_caps_do_simplify (ret);

   447 

   448   return ret;

   449 }

   450 

   451 static gboolean

   452 gst_alpha_set_caps (GstBaseTransform * btrans,

   453     GstCaps * incaps, GstCaps * outcaps)

   454 {

   455   GstAlpha *alpha = GST_ALPHA (btrans);

   456 

   457   if (!gst_video_format_parse_caps (incaps, &alpha->format,

   458           &alpha->width, &alpha->height))

   459     return FALSE;

   460 

   461   if (alpha->format == GST_VIDEO_FORMAT_AYUV)

   462     alpha->ayuv = TRUE;

   463   else

   464     alpha->ayuv = FALSE;

   465 

   466   return TRUE;

   467 }

   468 

   469 static void

   470 gst_alpha_set_ayuv (guint8 * src, guint8 * dest, gint width, gint height,

   471     gdouble alpha)

   472 {

   473   gint b_alpha = (gint) (alpha * 255);

   474   gint y, x;

   475 

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

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

   478       *dest++ = (*src++ * b_alpha) >> 8;

   479       *dest++ = *src++;

   480       *dest++ = *src++;

   481       *dest++ = *src++;

   482     }

   483   }

   484 }

   485 

   486 static void

   487 gst_alpha_set_i420 (guint8 * src, guint8 * dest, gint width, gint height,

   488     gdouble alpha)

   489 {

   490   gint b_alpha = (gint) (alpha * 255);

   491   guint8 *srcY;

   492   guint8 *srcU;

   493   guint8 *srcV;

   494   gint i, j;

   495   gint src_wrap, src_uv_wrap;

   496   gint y_stride, uv_stride;

   497   gboolean odd_width;

   498 

   499   y_stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 0, width);

   500   uv_stride = gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 1, width);

   501 

   502   src_wrap = y_stride - width;

   503   src_uv_wrap = uv_stride - (width / 2);

   504 

   505   srcY = src;

   506   srcU = src + gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420,

   507       1, width, height);

   508   srcV = src + gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420,

   509       2, width, height);

   510 

   511   odd_width = (width % 2 != 0);

   512 

   513   for (i = 0; i < height; i++) {

   514     for (j = 0; j < width / 2; j++) {

   515       *dest++ = b_alpha;

   516       *dest++ = *srcY++;

   517       *dest++ = *srcU;

   518       *dest++ = *srcV;

   519       *dest++ = b_alpha;

   520       *dest++ = *srcY++;

   521       *dest++ = *srcU++;

   522       *dest++ = *srcV++;

   523     }

   524     /* Might have one odd column left to do */

   525     if (odd_width) {

   526       *dest++ = b_alpha;

   527       *dest++ = *srcY++;

   528       *dest++ = *srcU;

   529       *dest++ = *srcV;

   530     }

   531     if (i % 2 == 0) {

   532       srcU -= width / 2;

   533       srcV -= width / 2;

   534     } else {

   535       srcU += src_uv_wrap;

   536       srcV += src_uv_wrap;

   537     }

   538     srcY += src_wrap;

   539   }

   540 }

   541 

   542 static void

   543 gst_alpha_chroma_key_ayuv (guint8 * src, guint8 * dest, gint width, gint height,

   544     GstAlpha * alpha)

   545 {

   546   gint b_alpha;

   547   guint8 *src1;

   548   guint8 *dest1;

   549   gint i, j;

   550   gint x, z, u, v, y, a;

   551   gint tmp, tmp1;

   552   gint x1, y1;

   553   gint smin, smax;

   554 

   555   smin = 128 - alpha->black_sensitivity;

   556   smax = 128 + alpha->white_sensitivity;

   557 

   558   src1 = src;

   559   dest1 = dest;

   560 

   561   for (i = 0; i < height; i++) {

   562     for (j = 0; j < width; j++) {

   563       a = *src1++ * (alpha->alpha);

   564       y = *src1++;

   565       u = *src1++ - 128;

   566       v = *src1++ - 128;

   567 

   568       if (y < smin || y > smax) {

   569         /* too dark or too bright, keep alpha */

   570         b_alpha = a;

   571       } else {

   572         /* Convert foreground to XZ coords where X direction is defined by

   573            the key color */

   574         tmp = ((short) u * alpha->cb + (short) v * alpha->cr) >> 7;

   575         x = CLAMP (tmp, -128, 127);

   576         tmp = ((short) v * alpha->cb - (short) u * alpha->cr) >> 7;

   577         z = CLAMP (tmp, -128, 127);

   578 

   579         /* WARNING: accept angle should never be set greater than "somewhat less

   580            than 90 degrees" to avoid dealing with negative/infinite tg. In reality,

   581            80 degrees should be enough if foreground is reasonable. If this seems

   582            to be a problem, go to alternative ways of checking point position

   583            (scalar product or line equations). This angle should not be too small

   584            either to avoid infinite ctg (used to suppress foreground without use of

   585            division) */

   586 

   587         tmp = ((short) (x) * alpha->accept_angle_tg) >> 4;

   588         tmp = MIN (tmp, 127);

   589 

   590         if (abs (z) > tmp) {

   591           /* keep foreground Kfg = 0 */

   592           b_alpha = a;

   593         } else {

   594           /* Compute Kfg (implicitly) and Kbg, suppress foreground in XZ coord

   595              according to Kfg */

   596           tmp = ((short) (z) * alpha->accept_angle_ctg) >> 4;

   597           tmp = CLAMP (tmp, -128, 127);

   598           x1 = abs (tmp);

   599           y1 = z;

   600 

   601           tmp1 = x - x1;

   602           tmp1 = MAX (tmp1, 0);

   603           b_alpha = (((unsigned char) (tmp1) *

   604                   (unsigned short) (alpha->one_over_kc)) / 2);

   605           b_alpha = 255 - CLAMP (b_alpha, 0, 255);

   606           b_alpha = (a * b_alpha) >> 8;

   607 

   608           tmp = ((unsigned short) (tmp1) * alpha->kfgy_scale) >> 4;

   609           tmp1 = MIN (tmp, 255);

   610 

   611           tmp = y - tmp1;

   612           y = MAX (tmp, 0);

   613 

   614           /* Convert suppressed foreground back to CbCr */

   615           tmp = ((char) (x1) * (short) (alpha->cb) -

   616               (char) (y1) * (short) (alpha->cr)) >> 7;

   617           u = CLAMP (tmp, -128, 127);

   618 

   619           tmp = ((char) (x1) * (short) (alpha->cr) +

   620               (char) (y1) * (short) (alpha->cb)) >> 7;

   621           v = CLAMP (tmp, -128, 127);

   622 

   623           /* Deal with noise. For now, a circle around the key color with

   624              radius of noise_level treated as exact key color. Introduces

   625              sharp transitions.

   626            */

   627           tmp = z * (short) (z) + (x - alpha->kg) * (short) (x - alpha->kg);

   628           tmp = MIN (tmp, 0xffff);

   629 

   630           if (tmp < alpha->noise_level * alpha->noise_level) {

   631             b_alpha = 0;

   632           }

   633         }

   634       }

   635 

   636       u += 128;

   637       v += 128;

   638 

   639       *dest1++ = b_alpha;

   640       *dest1++ = y;

   641       *dest1++ = u;

   642       *dest1++ = v;

   643     }

   644   }

   645 }

   646 

   647 static void

   648 gst_alpha_chromakey_row_i420 (GstAlpha * alpha, guint8 * dest1, guint8 * dest2,

   649     guint8 * srcY1, guint8 * srcY2, guint8 * srcU, guint8 * srcV, gint width)

   650 {

   651   gint xpos;

   652   gint b_alpha;

   653   gint x, z, u, v, y11, y12, y21, y22, a;

   654   gint tmp, tmp1;

   655   gint x1, y1;

   656   gint smin, smax;

   657 

   658   a = 255 * alpha->alpha;

   659   smin = 128 - alpha->black_sensitivity;

   660   smax = 128 + alpha->white_sensitivity;

   661 

   662   for (xpos = 0; xpos < width / 2; xpos++) {

   663     y11 = *srcY1++;

   664     y12 = *srcY1++;

   665     y21 = *srcY2++;

   666     y22 = *srcY2++;

   667     u = *srcU++ - 128;

   668     v = *srcV++ - 128;

   669 

   670     if (y11 < smin || y11 > smax ||

   671         y12 < smin || y12 > smax ||

   672         y21 < smin || y21 > smax || y22 < smin || y22 > smax) {

   673       /* too dark or too bright, make opaque */

   674       b_alpha = 255;

   675     } else {

   676       /* Convert foreground to XZ coords where X direction is defined by

   677          the key color */

   678       tmp = ((short) u * alpha->cb + (short) v * alpha->cr) >> 7;

   679       x = CLAMP (tmp, -128, 127);

   680       tmp = ((short) v * alpha->cb - (short) u * alpha->cr) >> 7;

   681       z = CLAMP (tmp, -128, 127);

   682 

   683       /* WARNING: accept angle should never be set greater than "somewhat less

   684          than 90 degrees" to avoid dealing with negative/infinite tg. In reality,

   685          80 degrees should be enough if foreground is reasonable. If this seems

   686          to be a problem, go to alternative ways of checking point position

   687          (scalar product or line equations). This angle should not be too small

   688          either to avoid infinite ctg (used to suppress foreground without use of

   689          division) */

   690 

   691       tmp = ((short) (x) * alpha->accept_angle_tg) >> 4;

   692       tmp = MIN (tmp, 127);

   693 

   694       if (abs (z) > tmp) {

   695         /* keep foreground Kfg = 0 */

   696         b_alpha = 255;

   697       } else {

   698         /* Compute Kfg (implicitly) and Kbg, suppress foreground in XZ coord

   699            according to Kfg */

   700         tmp = ((short) (z) * alpha->accept_angle_ctg) >> 4;

   701         tmp = CLAMP (tmp, -128, 127);

   702         x1 = abs (tmp);

   703         y1 = z;

   704 

   705         tmp1 = x - x1;

   706         tmp1 = MAX (tmp1, 0);

   707         b_alpha = (((unsigned char) (tmp1) *

   708                 (unsigned short) (alpha->one_over_kc)) / 2);

   709         b_alpha = 255 - CLAMP (b_alpha, 0, 255);

   710         b_alpha = (a * b_alpha) >> 8;

   711 

   712         tmp = ((unsigned short) (tmp1) * alpha->kfgy_scale) >> 4;

   713         tmp1 = MIN (tmp, 255);

   714 

   715         tmp = y11 - tmp1;

   716         y11 = MAX (tmp, 0);

   717         tmp = y12 - tmp1;

   718         y12 = MAX (tmp, 0);

   719         tmp = y21 - tmp1;

   720         y21 = MAX (tmp, 0);

   721         tmp = y22 - tmp1;

   722         y22 = MAX (tmp, 0);

   723 

   724         /* Convert suppressed foreground back to CbCr */

   725         tmp = ((char) (x1) * (short) (alpha->cb) -

   726             (char) (y1) * (short) (alpha->cr)) >> 7;

   727         u = CLAMP (tmp, -128, 127);

   728 

   729         tmp = ((char) (x1) * (short) (alpha->cr) +

   730             (char) (y1) * (short) (alpha->cb)) >> 7;

   731         v = CLAMP (tmp, -128, 127);

   732 

   733         /* Deal with noise. For now, a circle around the key color with

   734            radius of noise_level treated as exact key color. Introduces

   735            sharp transitions.

   736          */

   737         tmp = z * (short) (z) + (x - alpha->kg) * (short) (x - alpha->kg);

   738         tmp = MIN (tmp, 0xffff);

   739 

   740         if (tmp < alpha->noise_level * alpha->noise_level) {

   741           /* Uncomment this if you want total suppression within the noise circle */

   742           b_alpha = 0;

   743         }

   744       }

   745     }

   746 

   747     u += 128;

   748     v += 128;

   749 

   750     *dest1++ = b_alpha;

   751     *dest1++ = y11;

   752     *dest1++ = u;

   753     *dest1++ = v;

   754     *dest1++ = b_alpha;

   755     *dest1++ = y12;

   756     *dest1++ = u;

   757     *dest1++ = v;

   758 

   759     *dest2++ = b_alpha;

   760     *dest2++ = y21;

   761     *dest2++ = u;

   762     *dest2++ = v;

   763     *dest2++ = b_alpha;

   764     *dest2++ = y22;

   765     *dest2++ = u;

   766     *dest2++ = v;

   767   }

   768 }

   769 

   770 /* based on http://www.cs.utah.edu/~michael/chroma/

   771  */

   772 static void

   773 gst_alpha_chroma_key_i420 (guint8 * src, guint8 * dest, gint width, gint height,

   774     GstAlpha * alpha)

   775 {

   776   guint8 *srcY1, *srcY2, *srcU, *srcV;

   777   guint8 *dest1, *dest2;

   778   gint ypos;

   779   gint dest_stride, src_y_stride, src_uv_stride;

   780 

   781   dest_stride =

   782       gst_video_format_get_row_stride (GST_VIDEO_FORMAT_AYUV, 0, width);

   783   src_y_stride =

   784       gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 0, width);

   785   src_uv_stride =

   786       gst_video_format_get_row_stride (GST_VIDEO_FORMAT_I420, 1, width);

   787 

   788   srcY1 = src;

   789   srcY2 = src + src_y_stride;

   790 

   791   srcU = src + gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420,

   792       1, width, height);

   793   srcV = src + gst_video_format_get_component_offset (GST_VIDEO_FORMAT_I420,

   794       2, width, height);

   795 

   796   dest1 = dest;

   797   dest2 = dest + dest_stride;

   798 

   799   /* Redefine Y strides to skip 2 lines at a time ... */

   800   dest_stride *= 2;

   801   src_y_stride *= 2;

   802 

   803   for (ypos = 0; ypos < height / 2; ypos++) {

   804 

   805     gst_alpha_chromakey_row_i420 (alpha, dest1, dest2,

   806         srcY1, srcY2, srcU, srcV, width);

   807 

   808     dest1 += dest_stride;

   809     dest2 += dest_stride;

   810     srcY1 += src_y_stride;

   811     srcY2 += src_y_stride;

   812     srcU += src_uv_stride;

   813     srcV += src_uv_stride;

   814   }

   815 }

   816 

   817 static void

   818 gst_alpha_init_params (GstAlpha * alpha)

   819 {

   820   float kgl;

   821   float tmp;

   822   float tmp1, tmp2;

   823 

   824   alpha->y =

   825       0.257 * alpha->target_r + 0.504 * alpha->target_g +

   826       0.098 * alpha->target_b;

   827   tmp1 =

   828       -0.148 * alpha->target_r - 0.291 * alpha->target_g +

   829       0.439 * alpha->target_b;

   830   tmp2 =

   831       0.439 * alpha->target_r - 0.368 * alpha->target_g -

   832       0.071 * alpha->target_b;

   833   kgl = sqrt (tmp1 * tmp1 + tmp2 * tmp2);

   834   alpha->cb = 127 * (tmp1 / kgl);

   835   alpha->cr = 127 * (tmp2 / kgl);

   836 

   837   alpha->accept_angle_cos = cos (M_PI * alpha->angle / 180);

   838   alpha->accept_angle_sin = sin (M_PI * alpha->angle / 180);

   839   tmp = 15 * tan (M_PI * alpha->angle / 180);

   840   tmp = MIN (tmp, 255);

   841   alpha->accept_angle_tg = tmp;

   842   tmp = 15 / tan (M_PI * alpha->angle / 180);

   843   tmp = MIN (tmp, 255);

   844   alpha->accept_angle_ctg = tmp;

   845   tmp = 1 / (kgl);

   846   alpha->one_over_kc = 255 * 2 * tmp - 255;

   847   tmp = 15 * (float) (alpha->y) / kgl;

   848   tmp = MIN (tmp, 255);

   849   alpha->kfgy_scale = tmp;

   850   alpha->kg = MIN (kgl, 127);

   851 }

   852 

   853 static gboolean

   854 gst_alpha_start (GstBaseTransform * btrans)

   855 {

   856   GstAlpha *alpha = GST_ALPHA (btrans);

   857 

   858   gst_alpha_init_params (alpha);

   859 

   860   return TRUE;

   861 }

   862 

   863 static GstFlowReturn

   864 gst_alpha_transform (GstBaseTransform * btrans, GstBuffer * in, GstBuffer * out)

   865 {

   866   GstAlpha *alpha = GST_ALPHA (btrans);

   867   gint width, height;

   868   GstClockTime timestamp;

   869 

   870   width = alpha->width;

   871   height = alpha->height;

   872 

   873   GST_BUFFER_TIMESTAMP (out) = GST_BUFFER_TIMESTAMP (in);

   874   GST_BUFFER_DURATION (out) = GST_BUFFER_DURATION (in);

   875   timestamp = gst_segment_to_stream_time (&btrans->segment, GST_FORMAT_TIME,

   876       GST_BUFFER_TIMESTAMP (in));

   877   GST_LOG ("Got stream time of %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp));

   878   if (GST_CLOCK_TIME_IS_VALID (timestamp))

   879     gst_object_sync_values (G_OBJECT (alpha), timestamp);

   880 

   881   switch (alpha->method) {

   882     case ALPHA_METHOD_SET:

   883       if (alpha->ayuv) {

   884         gst_alpha_set_ayuv (GST_BUFFER_DATA (in),

   885             GST_BUFFER_DATA (out), width, height, alpha->alpha);

   886       } else {

   887         gst_alpha_set_i420 (GST_BUFFER_DATA (in),

   888             GST_BUFFER_DATA (out), width, height, alpha->alpha);

   889       }

   890       break;

   891     case ALPHA_METHOD_GREEN:

   892     case ALPHA_METHOD_BLUE:

   893     case ALPHA_METHOD_CUSTOM:

   894       if (alpha->ayuv) {

   895         gst_alpha_chroma_key_ayuv (GST_BUFFER_DATA (in),

   896             GST_BUFFER_DATA (out), width, height, alpha);

   897       } else {

   898         gst_alpha_chroma_key_i420 (GST_BUFFER_DATA (in),

   899             GST_BUFFER_DATA (out), width, height, alpha);

   900       }

   901       break;

   902     default:

   903       break;

   904   }

   905 

   906   return GST_FLOW_OK;

   907 }

   908 

   909 static gboolean

   910 plugin_init (GstPlugin * plugin)

   911 {

   912   gst_controller_init (NULL, NULL);

   913 

   914   return gst_element_register (plugin, "alpha", GST_RANK_NONE, GST_TYPE_ALPHA);

   915 }

   916 

   917 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,

   918     GST_VERSION_MINOR,

   919     "alpha",

   920     "adds an alpha channel to video - constant or via chroma-keying",

   921     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)

   922 

   923 

   924 #ifdef __SYMBIAN32__

   925 EXPORT_C GstPluginDesc* _GST_PLUGIN_DESC()

   926 {

   927     return &gst_plugin_desc;

   928 }

   929 

   930 #endif