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[1] = y;
 284     data[2] = u;
 285     data[3] = v;
 286
 287     data += 4;
 288     size -= 4;
 289   }
 290 }
 291
 292 static void
 293 transform_argb_bgra (guint8 * data, gint size, const gint * matrix)
 294 {
 295   gint r, g, b;
 296
 297   while (size > 0) {
 298     r = data[1];
 299     g = data[2];
 300     b = data[3];
 301
 302     data[3] = data[0];
 303     data[0] = b;
 304     data[1] = g;
 305     data[2] = r;
 306
 307     data += 4;
 308     size -= 4;
 309   }
 310 }
 311
 312 #define transform_abgr_rgba transform_argb_bgra
 313
 314 static void
 315 transform_argb_abgr (guint8 * data, gint size, const gint * matrix)
 316 {
 317   gint r, g, b;
 318
 319   while (size > 0) {
 320     r = data[1];
 321     g = data[2];
 322     b = data[3];
 323
 324     /* data[0] = data[0]; */
 325     data[1] = b;
 326     data[2] = g;
 327     data[3] = r;
 328
 329     data += 4;
 330     size -= 4;
 331   }
 332 }
 333
 334 #define transform_abgr_argb transform_argb_abgr
 335
 336 static void
 337 transform_rgba_bgra (guint8 * data, gint size, const gint * matrix)
 338 {
 339   gint r, g, b;
 340
 341   while (size > 0) {
 342     r = data[0];
 343     g = data[1];
 344     b = data[2];
 345
 346     /* data[3] = data[3] */ ;
 347     data[0] = b;
 348     data[1] = g;
 349     data[2] = r;
 350
 351     data += 4;
 352     size -= 4;
 353   }
 354 }
 355
 356 #define transform_bgra_rgba transform_rgba_bgra
 357
 358 static void
 359 transform_argb_rgba (guint8 * data, gint size, const gint * matrix)
 360 {
 361   gint r, g, b;
 362
 363   while (size > 0) {
 364     r = data[1];
 365     g = data[2];
 366     b = data[3];
 367
 368     data[3] = data[0];
 369     data[0] = r;
 370     data[1] = g;
 371     data[2] = b;
 372
 373     data += 4;
 374     size -= 4;
 375   }
 376 }
 377
 378 #define transform_abgr_bgra transform_argb_rgba
 379
 380 static void
 381 transform_bgra_argb (guint8 * data, gint size, const gint * matrix)
 382 {
 383   gint r, g, b;
 384
 385   while (size > 0) {
 386     r = data[2];
 387     g = data[1];
 388     b = data[0];
 389
 390     data[0] = data[3];
 391     data[1] = r;
 392     data[2] = g;
 393     data[3] = b;
 394
 395     data += 4;
 396     size -= 4;
 397   }
 398 }
 399
 400 #define transform_rgba_abgr transform_bgra_argb
 401
 402 static void
 403 transform_rgba_argb (guint8 * data, gint size, const gint * matrix)
 404 {
 405   gint r, g, b;
 406
 407   while (size > 0) {
 408     r = data[0];
 409     g = data[1];
 410     b = data[2];
 411
 412     data[0] = data[3];
 413     data[1] = r;
 414     data[2] = g;
 415     data[3] = b;
 416
 417     data += 4;
 418     size -= 4;
 419   }
 420 }
 421
 422 #define transform_bgra_abgr transform_rgba_argb
 423
 424 static gboolean
 425 gst_alpha_color_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
 426     GstCaps * outcaps)
 427 {
 428   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 429   gboolean ret;
 430   gint w, h;
 431   gint w2, h2;
 432   GstVideoFormat in_format, out_format;
 433   const gchar *matrix;
 434   gboolean in_sdtv, out_sdtv;
 435
 436   alpha->process = NULL;
 437   alpha->matrix = NULL;
 438
 439   ret = gst_video_format_parse_caps (incaps, &in_format, &w, &h);
 440   ret &= gst_video_format_parse_caps (outcaps, &out_format, &w2, &h2);
 441
 442   if (!ret || w != w2 || h != h2) {
 443     GST_DEBUG_OBJECT (alpha, "incomplete or invalid caps!");
 444     return FALSE;
 445   }
 446
 447   matrix = gst_video_parse_caps_color_matrix (incaps);
 448   in_sdtv = matrix ? g_str_equal (matrix, "sdtv") : TRUE;
 449   matrix = gst_video_parse_caps_color_matrix (outcaps);
 450   out_sdtv = matrix ? g_str_equal (matrix, "sdtv") : TRUE;
 451
 452   alpha->in_format = in_format;
 453   alpha->out_format = out_format;
 454   alpha->width = w;
 455   alpha->height = h;
 456
 457   switch (alpha->in_format) {
 458     case GST_VIDEO_FORMAT_ARGB:
 459       switch (alpha->out_format) {
 460         case GST_VIDEO_FORMAT_ARGB:
 461           alpha->process = NULL;
 462           alpha->matrix = NULL;
 463           break;
 464         case GST_VIDEO_FORMAT_BGRA:
 465           alpha->process = transform_argb_bgra;
 466           alpha->matrix = NULL;
 467           break;
 468         case GST_VIDEO_FORMAT_ABGR:
 469           alpha->process = transform_argb_abgr;
 470           alpha->matrix = NULL;
 471           break;
 472         case GST_VIDEO_FORMAT_RGBA:
 473           alpha->process = transform_argb_rgba;
 474           alpha->matrix = NULL;
 475           break;
 476         case GST_VIDEO_FORMAT_AYUV:
 477           alpha->process = transform_argb_ayuv;
 478           alpha->matrix =
 479               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 480               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 481           break;
 482         default:
 483           alpha->process = NULL;
 484           alpha->matrix = NULL;
 485           break;
 486       }
 487       break;
 488     case GST_VIDEO_FORMAT_BGRA:
 489       switch (alpha->out_format) {
 490         case GST_VIDEO_FORMAT_BGRA:
 491           alpha->process = NULL;
 492           alpha->matrix = NULL;
 493           break;
 494         case GST_VIDEO_FORMAT_ARGB:
 495           alpha->process = transform_bgra_argb;
 496           alpha->matrix = NULL;
 497           break;
 498         case GST_VIDEO_FORMAT_ABGR:
 499           alpha->process = transform_bgra_abgr;
 500           alpha->matrix = NULL;
 501           break;
 502         case GST_VIDEO_FORMAT_RGBA:
 503           alpha->process = transform_bgra_rgba;
 504           alpha->matrix = NULL;
 505           break;
 506         case GST_VIDEO_FORMAT_AYUV:
 507           alpha->process = transform_bgra_ayuv;
 508           alpha->matrix =
 509               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 510               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 511           break;
 512         default:
 513           alpha->process = NULL;
 514           alpha->matrix = NULL;
 515           break;
 516       }
 517       break;
 518     case GST_VIDEO_FORMAT_ABGR:
 519       switch (alpha->out_format) {
 520         case GST_VIDEO_FORMAT_ABGR:
 521           alpha->process = NULL;
 522           alpha->matrix = NULL;
 523           break;
 524         case GST_VIDEO_FORMAT_RGBA:
 525           alpha->process = transform_abgr_rgba;
 526           alpha->matrix = NULL;
 527           break;
 528         case GST_VIDEO_FORMAT_ARGB:
 529           alpha->process = transform_abgr_argb;
 530           alpha->matrix = NULL;
 531           break;
 532         case GST_VIDEO_FORMAT_BGRA:
 533           alpha->process = transform_abgr_bgra;
 534           alpha->matrix = NULL;
 535           break;
 536         case GST_VIDEO_FORMAT_AYUV:
 537           alpha->process = transform_abgr_ayuv;
 538           alpha->matrix =
 539               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 540               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 541           break;
 542         default:
 543           alpha->process = NULL;
 544           alpha->matrix = NULL;
 545           break;
 546       }
 547       break;
 548     case GST_VIDEO_FORMAT_RGBA:
 549       switch (alpha->out_format) {
 550         case GST_VIDEO_FORMAT_RGBA:
 551           alpha->process = NULL;
 552           alpha->matrix = NULL;
 553           break;
 554         case GST_VIDEO_FORMAT_ARGB:
 555           alpha->process = transform_rgba_argb;
 556           alpha->matrix = NULL;
 557           break;
 558         case GST_VIDEO_FORMAT_ABGR:
 559           alpha->process = transform_rgba_abgr;
 560           alpha->matrix = NULL;
 561           break;
 562         case GST_VIDEO_FORMAT_BGRA:
 563           alpha->process = transform_rgba_bgra;
 564           alpha->matrix = NULL;
 565           break;
 566         case GST_VIDEO_FORMAT_AYUV:
 567           alpha->process = transform_rgba_ayuv;
 568           alpha->matrix =
 569               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 570               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 571           break;
 572         default:
 573           alpha->process = NULL;
 574           alpha->matrix = NULL;
 575           break;
 576       }
 577       break;
 578     case GST_VIDEO_FORMAT_AYUV:
 579       switch (alpha->out_format) {
 580         case GST_VIDEO_FORMAT_AYUV:
 581           if (in_sdtv == out_sdtv) {
 582             alpha->process = transform_ayuv_ayuv;
 583             alpha->matrix = NULL;
 584           } else {
 585             alpha->process = transform_ayuv_ayuv;
 586             alpha->matrix =
 587                 out_sdtv ? cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit :
 588                 cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit;
 589           }
 590           break;
 591         case GST_VIDEO_FORMAT_ARGB:
 592           alpha->process = transform_ayuv_argb;
 593           alpha->matrix =
 594               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 595               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 596           break;
 597         case GST_VIDEO_FORMAT_BGRA:
 598           alpha->process = transform_ayuv_bgra;
 599           alpha->matrix =
 600               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 601               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 602           break;
 603         case GST_VIDEO_FORMAT_ABGR:
 604           alpha->process = transform_ayuv_abgr;
 605           alpha->matrix =
 606               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 607               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 608           break;
 609         case GST_VIDEO_FORMAT_RGBA:
 610           alpha->process = transform_ayuv_rgba;
 611           alpha->matrix =
 612               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 613               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 614           break;
 615         default:
 616           alpha->process = NULL;
 617           alpha->matrix = NULL;
 618           break;
 619       }
 620       break;
 621     default:
 622       alpha->process = NULL;
 623       alpha->matrix = NULL;
 624       break;
 625   }
 626
 627   if (in_format == out_format && in_sdtv == out_sdtv)
 628     gst_base_transform_set_passthrough (btrans, TRUE);
 629   else if (!alpha->process)
 630     return FALSE;
 631
 632   return TRUE;
 633 }
 634
 635 static GstFlowReturn
 636 gst_alpha_color_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
 637 {
 638   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 639
 640   if (G_UNLIKELY (GST_BUFFER_SIZE (inbuf) != 4 * alpha->width * alpha->height)) {
 641     GST_ERROR_OBJECT (alpha, "Invalid buffer size (was %u, expected %u)",
 642         GST_BUFFER_SIZE (inbuf), alpha->width * alpha->height);
 643     return GST_FLOW_ERROR;
 644   }
 645
 646   if (gst_base_transform_is_passthrough (btrans))
 647     return GST_FLOW_OK;
 648
 649   if (G_UNLIKELY (!alpha->process)) {
 650     GST_ERROR_OBJECT (alpha, "Not negotiated yet");
 651     return GST_FLOW_NOT_NEGOTIATED;
 652   }
 653
 654   /* Transform in place */
 655   alpha->process (GST_BUFFER_DATA (inbuf), GST_BUFFER_SIZE (inbuf),
 656       alpha->matrix);
 657
 658   return GST_FLOW_OK;
 659 }
 660
 661 static gboolean
 662 plugin_init (GstPlugin * plugin)
 663 {
 664   return gst_element_register (plugin, "alphacolor", GST_RANK_NONE,
 665       GST_TYPE_ALPHA_COLOR);
 666 }
 667
 668 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 669     GST_VERSION_MINOR,
 670     "alphacolor",
 671     "RGBA from/to AYUV colorspace conversion preserving the alpha channel",
 672     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)