gst/alpha/gstalphacolor.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:element-alphacolor
  22  *
  23  * The alphacolor element does memory-efficient (in-place) colourspace
  24  * conversion from RGBA to AYUV or AYUV to RGBA while preserving the
  25  * alpha channel.
  26  *
  27  * Sample pipeline:
  28  * |[
  29  * gst-launch videotestsrc ! "video/x-raw-yuv,format=(fourcc)AYUV" ! \
  30  *   alphacolor ! "video/x-raw-rgb" ! ffmpegcolorspace ! autovideosink
  31  * ]|
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include "gstalphacolor.h"
  39
  40 #include <gst/gst.h>
  41 #include <gst/video/video.h>
  42
  43 #include <string.h>
  44
  45 GST_DEBUG_CATEGORY_STATIC (alpha_color_debug);
  46 #define GST_CAT_DEFAULT alpha_color_debug
  47
  48 /* elementfactory information */
  49 static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
  50     GST_PAD_SINK,
  51     GST_PAD_ALWAYS,
  52     GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBA ";" GST_VIDEO_CAPS_BGRA ";"
  53         GST_VIDEO_CAPS_ARGB ";" GST_VIDEO_CAPS_ABGR ";"
  54         GST_VIDEO_CAPS_YUV ("AYUV"))
  55     );
  56
  57 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  58     GST_PAD_SRC,
  59     GST_PAD_ALWAYS,
  60     GST_STATIC_CAPS (GST_VIDEO_CAPS_RGBA ";" GST_VIDEO_CAPS_BGRA ";"
  61         GST_VIDEO_CAPS_ARGB ";" GST_VIDEO_CAPS_ABGR ";"
  62         GST_VIDEO_CAPS_YUV ("AYUV"))
  63     );
  64
  65 GST_BOILERPLATE (GstAlphaColor, gst_alpha_color, GstVideoFilter,
  66     GST_TYPE_VIDEO_FILTER);
  67
  68 static GstCaps *gst_alpha_color_transform_caps (GstBaseTransform * btrans,
  69     GstPadDirection direction, GstCaps * caps);
  70 static gboolean gst_alpha_color_set_caps (GstBaseTransform * btrans,
  71     GstCaps * incaps, GstCaps * outcaps);
  72 static GstFlowReturn gst_alpha_color_transform_ip (GstBaseTransform * btrans,
  73     GstBuffer * inbuf);
  74
  75 static void
  76 gst_alpha_color_base_init (gpointer g_class)
  77 {
  78   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
  79
  80   gst_element_class_set_details_simple (element_class, "Alpha color filter",
  81       "Filter/Converter/Video",
  82       "ARGB from/to AYUV colorspace conversion preserving the alpha channel",
  83       "Wim Taymans <wim@fluendo.com>");
  84
  85   gst_element_class_add_static_pad_template (element_class,
  86       &sink_template);
  87   gst_element_class_add_static_pad_template (element_class, &src_template);
  88 }
  89
  90 static void
  91 gst_alpha_color_class_init (GstAlphaColorClass * klass)
  92 {
  93   GstBaseTransformClass *gstbasetransform_class =
  94       (GstBaseTransformClass *) klass;
  95
  96   gstbasetransform_class->transform_caps =
  97       GST_DEBUG_FUNCPTR (gst_alpha_color_transform_caps);
  98   gstbasetransform_class->set_caps =
  99       GST_DEBUG_FUNCPTR (gst_alpha_color_set_caps);
 100   gstbasetransform_class->transform_ip =
 101       GST_DEBUG_FUNCPTR (gst_alpha_color_transform_ip);
 102
 103   GST_DEBUG_CATEGORY_INIT (alpha_color_debug, "alphacolor", 0,
 104       "ARGB<->AYUV colorspace conversion preserving the alpha channels");
 105 }
 106
 107 static void
 108 gst_alpha_color_init (GstAlphaColor * alpha, GstAlphaColorClass * g_class)
 109 {
 110   GstBaseTransform *btrans = GST_BASE_TRANSFORM (alpha);
 111
 112   btrans->always_in_place = TRUE;
 113 }
 114
 115 static GstCaps *
 116 gst_alpha_color_transform_caps (GstBaseTransform * btrans,
 117     GstPadDirection direction, GstCaps * caps)
 118 {
 119   const GstCaps *tmpl_caps = NULL;
 120   GstCaps *result = NULL, *local_caps = NULL;
 121   guint i;
 122
 123   local_caps = gst_caps_new_empty ();
 124
 125   for (i = 0; i < gst_caps_get_size (caps); i++) {
 126     GstStructure *structure =
 127         gst_structure_copy (gst_caps_get_structure (caps, i));
 128
 129     /* Remove any specific parameter from the structure */
 130     gst_structure_remove_field (structure, "format");
 131     gst_structure_remove_field (structure, "endianness");
 132     gst_structure_remove_field (structure, "depth");
 133     gst_structure_remove_field (structure, "bpp");
 134     gst_structure_remove_field (structure, "red_mask");
 135     gst_structure_remove_field (structure, "green_mask");
 136     gst_structure_remove_field (structure, "blue_mask");
 137     gst_structure_remove_field (structure, "alpha_mask");
 138     gst_structure_remove_field (structure, "color-matrix");
 139     gst_structure_remove_field (structure, "chroma-site");
 140
 141     gst_structure_set_name (structure, "video/x-raw-rgb");
 142     gst_caps_append_structure (local_caps, gst_structure_copy (structure));
 143     gst_structure_set_name (structure, "video/x-raw-yuv");
 144     gst_caps_append_structure (local_caps, structure);
 145   }
 146
 147   /* Get the appropriate template */
 148   if (direction == GST_PAD_SINK) {
 149     tmpl_caps = gst_static_pad_template_get_caps (&src_template);
 150   } else if (direction == GST_PAD_SRC) {
 151     tmpl_caps = gst_static_pad_template_get_caps (&sink_template);
 152   }
 153
 154   /* Intersect with our template caps */
 155   result = gst_caps_intersect (local_caps, tmpl_caps);
 156
 157   gst_caps_unref (local_caps);
 158   gst_caps_do_simplify (result);
 159
 160   GST_LOG_OBJECT (btrans, "transformed %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT,
 161       caps, result);
 162
 163   return result;
 164 }
 165
 166 /* Generated by -bad/ext/cog/generate_tables */
 167 static const int cog_ycbcr_to_rgb_matrix_8bit_hdtv[] = {
 168   298, 0, 459, -63514,
 169   298, -55, -136, 19681,
 170   298, 541, 0, -73988,
 171 };
 172
 173 static const int cog_ycbcr_to_rgb_matrix_8bit_sdtv[] = {
 174   298, 0, 409, -57068,
 175   298, -100, -208, 34707,
 176   298, 516, 0, -70870,
 177 };
 178
 179 static const gint cog_rgb_to_ycbcr_matrix_8bit_hdtv[] = {
 180   47, 157, 16, 4096,
 181   -26, -87, 112, 32768,
 182   112, -102, -10, 32768,
 183 };
 184
 185 static const gint cog_rgb_to_ycbcr_matrix_8bit_sdtv[] = {
 186   66, 129, 25, 4096,
 187   -38, -74, 112, 32768,
 188   112, -94, -18, 32768,
 189 };
 190
 191 static const gint cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit[] = {
 192   256, -30, -53, 10600,
 193   0, 261, 29, -4367,
 194   0, 19, 262, -3289,
 195 };
 196
 197 static const gint cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit[] = {
 198   256, 25, 49, -9536,
 199   0, 253, -28, 3958,
 200   0, -19, 252, 2918,
 201 };
 202
 203 #define DEFINE_ARGB_AYUV_FUNCTIONS(name, A, R, G, B) \
 204 static void \
 205 transform_##name##_ayuv (guint8 * data, gint size, const gint *matrix) \
 206 { \
 207   gint y, u, v; \
 208   gint yc[4]; \
 209   gint uc[4]; \
 210   gint vc[4]; \
 211   \
 212   memcpy (yc, matrix, 4 * sizeof (gint)); \
 213   memcpy (uc, matrix + 4, 4 * sizeof (gint)); \
 214   memcpy (vc, matrix + 8, 4 * sizeof (gint)); \
 215   \
 216   while (size > 0) { \
 217     y = (data[R] * yc[0] + data[G] * yc[1] + data[B] * yc[2] + yc[3]) >> 8; \
 218     u = (data[R] * uc[0] + data[G] * uc[1] + data[B] * uc[2] + uc[3]) >> 8; \
 219     v = (data[R] * vc[0] + data[G] * vc[1] + data[B] * vc[2] + vc[3]) >> 8; \
 220     \
 221     data[0] = data[A]; \
 222     data[1] = y; \
 223     data[2] = u; \
 224     data[3] = v; \
 225     \
 226     data += 4; \
 227     size -= 4; \
 228   } \
 229 } \
 230 \
 231 static void \
 232 transform_ayuv_##name (guint8 * data, gint size, const gint *matrix) \
 233 { \
 234   gint r, g, b; \
 235   gint rc[4]; \
 236   gint gc[4]; \
 237   gint bc[4]; \
 238   \
 239   memcpy (rc, matrix, 4 * sizeof (gint)); \
 240   memcpy (gc, matrix + 4, 4 * sizeof (gint)); \
 241   memcpy (bc, matrix + 8, 4 * sizeof (gint)); \
 242   \
 243   while (size > 0) { \
 244     r = (data[1] * rc[0] + data[2] * rc[1] + data[3] * rc[2] + rc[3]) >> 8; \
 245     g = (data[1] * gc[0] + data[2] * gc[1] + data[3] * gc[2] + gc[3]) >> 8; \
 246     b = (data[1] * bc[0] + data[2] * bc[1] + data[3] * bc[2] + bc[3]) >> 8; \
 247     \
 248     data[A] = data[0]; \
 249     data[R] = CLAMP (r, 0, 255); \
 250     data[G] = CLAMP (g, 0, 255); \
 251     data[B] = CLAMP (b, 0, 255); \
 252     \
 253     data += 4; \
 254     size -= 4; \
 255   } \
 256 }
 257
 258 DEFINE_ARGB_AYUV_FUNCTIONS (rgba, 3, 0, 1, 2);
 259 DEFINE_ARGB_AYUV_FUNCTIONS (bgra, 3, 2, 1, 0);
 260 DEFINE_ARGB_AYUV_FUNCTIONS (argb, 0, 1, 2, 3);
 261 DEFINE_ARGB_AYUV_FUNCTIONS (abgr, 0, 3, 2, 1);
 262
 263 static void
 264 transform_ayuv_ayuv (guint8 * data, gint size, const gint * matrix)
 265 {
 266   gint y, u, v;
 267   gint yc[4];
 268   gint uc[4];
 269   gint vc[4];
 270
 271   if (matrix == NULL)
 272     return;
 273
 274   memcpy (yc, matrix, 4 * sizeof (gint));
 275   memcpy (uc, matrix + 4, 4 * sizeof (gint));
 276   memcpy (vc, matrix + 8, 4 * sizeof (gint));
 277
 278   while (size > 0) {
 279     y = (data[1] * yc[0] + data[2] * yc[1] + data[3] * yc[2] + yc[3]) >> 8;
 280     u = (data[1] * uc[0] + data[2] * uc[1] + data[3] * uc[2] + uc[3]) >> 8;
 281     v = (data[1] * vc[0] + data[2] * vc[1] + data[3] * vc[2] + vc[3]) >> 8;
 282
 283     data[0] = data[0];
 284     data[1] = y;
 285     data[2] = u;
 286     data[3] = v;
 287
 288     data += 4;
 289     size -= 4;
 290   }
 291 }
 292
 293 static void
 294 transform_argb_bgra (guint8 * data, gint size, const gint * matrix)
 295 {
 296   gint r, g, b;
 297
 298   while (size > 0) {
 299     r = data[1];
 300     g = data[2];
 301     b = data[3];
 302
 303     data[3] = data[0];
 304     data[0] = b;
 305     data[1] = g;
 306     data[2] = r;
 307
 308     data += 4;
 309     size -= 4;
 310   }
 311 }
 312
 313 #define transform_abgr_rgba transform_argb_bgra
 314
 315 static void
 316 transform_argb_abgr (guint8 * data, gint size, const gint * matrix)
 317 {
 318   gint r, g, b;
 319
 320   while (size > 0) {
 321     r = data[1];
 322     g = data[2];
 323     b = data[3];
 324
 325     /* data[0] = data[0]; */
 326     data[1] = b;
 327     data[2] = g;
 328     data[3] = r;
 329
 330     data += 4;
 331     size -= 4;
 332   }
 333 }
 334
 335 #define transform_abgr_argb transform_argb_abgr
 336
 337 static void
 338 transform_rgba_bgra (guint8 * data, gint size, const gint * matrix)
 339 {
 340   gint r, g, b;
 341
 342   while (size > 0) {
 343     r = data[0];
 344     g = data[1];
 345     b = data[2];
 346
 347     /* data[3] = data[3] */ ;
 348     data[0] = b;
 349     data[1] = g;
 350     data[2] = r;
 351
 352     data += 4;
 353     size -= 4;
 354   }
 355 }
 356
 357 #define transform_bgra_rgba transform_rgba_bgra
 358
 359 static void
 360 transform_argb_rgba (guint8 * data, gint size, const gint * matrix)
 361 {
 362   gint r, g, b;
 363
 364   while (size > 0) {
 365     r = data[1];
 366     g = data[2];
 367     b = data[3];
 368
 369     data[3] = data[0];
 370     data[0] = r;
 371     data[1] = g;
 372     data[2] = b;
 373
 374     data += 4;
 375     size -= 4;
 376   }
 377 }
 378
 379 #define transform_abgr_bgra transform_argb_rgba
 380
 381 static void
 382 transform_bgra_argb (guint8 * data, gint size, const gint * matrix)
 383 {
 384   gint r, g, b;
 385
 386   while (size > 0) {
 387     r = data[2];
 388     g = data[1];
 389     b = data[0];
 390
 391     data[0] = data[3];
 392     data[1] = r;
 393     data[2] = g;
 394     data[3] = b;
 395
 396     data += 4;
 397     size -= 4;
 398   }
 399 }
 400
 401 #define transform_rgba_abgr transform_bgra_argb
 402
 403 static void
 404 transform_rgba_argb (guint8 * data, gint size, const gint * matrix)
 405 {
 406   gint r, g, b;
 407
 408   while (size > 0) {
 409     r = data[0];
 410     g = data[1];
 411     b = data[2];
 412
 413     data[0] = data[3];
 414     data[1] = r;
 415     data[2] = g;
 416     data[3] = b;
 417
 418     data += 4;
 419     size -= 4;
 420   }
 421 }
 422
 423 #define transform_bgra_abgr transform_rgba_argb
 424
 425 static gboolean
 426 gst_alpha_color_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
 427     GstCaps * outcaps)
 428 {
 429   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 430   gboolean ret;
 431   gint w, h;
 432   gint w2, h2;
 433   GstVideoFormat in_format, out_format;
 434   const gchar *matrix;
 435   gboolean in_sdtv, out_sdtv;
 436
 437   alpha->process = NULL;
 438   alpha->matrix = NULL;
 439
 440   ret = gst_video_format_parse_caps (incaps, &in_format, &w, &h);
 441   ret &= gst_video_format_parse_caps (outcaps, &out_format, &w2, &h2);
 442
 443   if (!ret || w != w2 || h != h2) {
 444     GST_DEBUG_OBJECT (alpha, "incomplete or invalid caps!");
 445     return FALSE;
 446   }
 447
 448   matrix = gst_video_parse_caps_color_matrix (incaps);
 449   in_sdtv = matrix ? g_str_equal (matrix, "sdtv") : TRUE;
 450   matrix = gst_video_parse_caps_color_matrix (outcaps);
 451   out_sdtv = matrix ? g_str_equal (matrix, "sdtv") : TRUE;
 452
 453   alpha->in_format = in_format;
 454   alpha->out_format = out_format;
 455   alpha->width = w;
 456   alpha->height = h;
 457
 458   switch (alpha->in_format) {
 459     case GST_VIDEO_FORMAT_ARGB:
 460       switch (alpha->out_format) {
 461         case GST_VIDEO_FORMAT_ARGB:
 462           alpha->process = NULL;
 463           alpha->matrix = NULL;
 464           break;
 465         case GST_VIDEO_FORMAT_BGRA:
 466           alpha->process = transform_argb_bgra;
 467           alpha->matrix = NULL;
 468           break;
 469         case GST_VIDEO_FORMAT_ABGR:
 470           alpha->process = transform_argb_abgr;
 471           alpha->matrix = NULL;
 472           break;
 473         case GST_VIDEO_FORMAT_RGBA:
 474           alpha->process = transform_argb_rgba;
 475           alpha->matrix = NULL;
 476           break;
 477         case GST_VIDEO_FORMAT_AYUV:
 478           alpha->process = transform_argb_ayuv;
 479           alpha->matrix =
 480               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 481               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 482           break;
 483         default:
 484           alpha->process = NULL;
 485           alpha->matrix = NULL;
 486           break;
 487       }
 488       break;
 489     case GST_VIDEO_FORMAT_BGRA:
 490       switch (alpha->out_format) {
 491         case GST_VIDEO_FORMAT_BGRA:
 492           alpha->process = NULL;
 493           alpha->matrix = NULL;
 494           break;
 495         case GST_VIDEO_FORMAT_ARGB:
 496           alpha->process = transform_bgra_argb;
 497           alpha->matrix = NULL;
 498           break;
 499         case GST_VIDEO_FORMAT_ABGR:
 500           alpha->process = transform_bgra_abgr;
 501           alpha->matrix = NULL;
 502           break;
 503         case GST_VIDEO_FORMAT_RGBA:
 504           alpha->process = transform_bgra_rgba;
 505           alpha->matrix = NULL;
 506           break;
 507         case GST_VIDEO_FORMAT_AYUV:
 508           alpha->process = transform_bgra_ayuv;
 509           alpha->matrix =
 510               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 511               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 512           break;
 513         default:
 514           alpha->process = NULL;
 515           alpha->matrix = NULL;
 516           break;
 517       }
 518       break;
 519     case GST_VIDEO_FORMAT_ABGR:
 520       switch (alpha->out_format) {
 521         case GST_VIDEO_FORMAT_ABGR:
 522           alpha->process = NULL;
 523           alpha->matrix = NULL;
 524           break;
 525         case GST_VIDEO_FORMAT_RGBA:
 526           alpha->process = transform_abgr_rgba;
 527           alpha->matrix = NULL;
 528           break;
 529         case GST_VIDEO_FORMAT_ARGB:
 530           alpha->process = transform_abgr_argb;
 531           alpha->matrix = NULL;
 532           break;
 533         case GST_VIDEO_FORMAT_BGRA:
 534           alpha->process = transform_abgr_bgra;
 535           alpha->matrix = NULL;
 536           break;
 537         case GST_VIDEO_FORMAT_AYUV:
 538           alpha->process = transform_abgr_ayuv;
 539           alpha->matrix =
 540               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 541               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 542           break;
 543         default:
 544           alpha->process = NULL;
 545           alpha->matrix = NULL;
 546           break;
 547       }
 548       break;
 549     case GST_VIDEO_FORMAT_RGBA:
 550       switch (alpha->out_format) {
 551         case GST_VIDEO_FORMAT_RGBA:
 552           alpha->process = NULL;
 553           alpha->matrix = NULL;
 554           break;
 555         case GST_VIDEO_FORMAT_ARGB:
 556           alpha->process = transform_rgba_argb;
 557           alpha->matrix = NULL;
 558           break;
 559         case GST_VIDEO_FORMAT_ABGR:
 560           alpha->process = transform_rgba_abgr;
 561           alpha->matrix = NULL;
 562           break;
 563         case GST_VIDEO_FORMAT_BGRA:
 564           alpha->process = transform_rgba_bgra;
 565           alpha->matrix = NULL;
 566           break;
 567         case GST_VIDEO_FORMAT_AYUV:
 568           alpha->process = transform_rgba_ayuv;
 569           alpha->matrix =
 570               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 571               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 572           break;
 573         default:
 574           alpha->process = NULL;
 575           alpha->matrix = NULL;
 576           break;
 577       }
 578       break;
 579     case GST_VIDEO_FORMAT_AYUV:
 580       switch (alpha->out_format) {
 581         case GST_VIDEO_FORMAT_AYUV:
 582           if (in_sdtv == out_sdtv) {
 583             alpha->process = transform_ayuv_ayuv;
 584             alpha->matrix = NULL;
 585           } else {
 586             alpha->process = transform_ayuv_ayuv;
 587             alpha->matrix =
 588                 out_sdtv ? cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit :
 589                 cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit;
 590           }
 591           break;
 592         case GST_VIDEO_FORMAT_ARGB:
 593           alpha->process = transform_ayuv_argb;
 594           alpha->matrix =
 595               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 596               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 597           break;
 598         case GST_VIDEO_FORMAT_BGRA:
 599           alpha->process = transform_ayuv_bgra;
 600           alpha->matrix =
 601               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 602               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 603           break;
 604         case GST_VIDEO_FORMAT_ABGR:
 605           alpha->process = transform_ayuv_abgr;
 606           alpha->matrix =
 607               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 608               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 609           break;
 610         case GST_VIDEO_FORMAT_RGBA:
 611           alpha->process = transform_ayuv_rgba;
 612           alpha->matrix =
 613               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 614               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 615           break;
 616         default:
 617           alpha->process = NULL;
 618           alpha->matrix = NULL;
 619           break;
 620       }
 621       break;
 622     default:
 623       alpha->process = NULL;
 624       alpha->matrix = NULL;
 625       break;
 626   }
 627
 628   if (in_format == out_format && in_sdtv == out_sdtv)
 629     gst_base_transform_set_passthrough (btrans, TRUE);
 630   else if (!alpha->process)
 631     return FALSE;
 632
 633   return TRUE;
 634 }
 635
 636 static GstFlowReturn
 637 gst_alpha_color_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
 638 {
 639   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 640
 641   if (G_UNLIKELY (GST_BUFFER_SIZE (inbuf) != 4 * alpha->width * alpha->height)) {
 642     GST_ERROR_OBJECT (alpha, "Invalid buffer size (was %u, expected %u)",
 643         GST_BUFFER_SIZE (inbuf), alpha->width * alpha->height);
 644     return GST_FLOW_ERROR;
 645   }
 646
 647   if (gst_base_transform_is_passthrough (btrans))
 648     return GST_FLOW_OK;
 649
 650   if (G_UNLIKELY (!alpha->process)) {
 651     GST_ERROR_OBJECT (alpha, "Not negotiated yet");
 652     return GST_FLOW_NOT_NEGOTIATED;
 653   }
 654
 655   /* Transform in place */
 656   alpha->process (GST_BUFFER_DATA (inbuf), GST_BUFFER_SIZE (inbuf),
 657       alpha->matrix);
 658
 659   return GST_FLOW_OK;
 660 }
 661
 662 static gboolean
 663 plugin_init (GstPlugin * plugin)
 664 {
 665   return gst_element_register (plugin, "alphacolor", GST_RANK_NONE,
 666       GST_TYPE_ALPHA_COLOR);
 667 }
 668
 669 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 670     GST_VERSION_MINOR,
 671     "alphacolor",
 672     "RGBA from/to AYUV colorspace conversion preserving the alpha channel",
 673     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)