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,format=(fourcc)AYUV" ! \
  30  *   alphacolor ! videoconvert ! 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_MAKE ("{ RGBA, BGRA, ARGB, ABGR, AYUV }"))
  53     );
  54
  55 static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
  56     GST_PAD_SRC,
  57     GST_PAD_ALWAYS,
  58     GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBA, BGRA, ARGB, ABGR, AYUV }"))
  59     );
  60
  61 G_DEFINE_TYPE (GstAlphaColor, gst_alpha_color, GST_TYPE_VIDEO_FILTER);
  62
  63 static GstCaps *gst_alpha_color_transform_caps (GstBaseTransform * btrans,
  64     GstPadDirection direction, GstCaps * caps, GstCaps * filter);
  65 static gboolean gst_alpha_color_set_caps (GstBaseTransform * btrans,
  66     GstCaps * incaps, GstCaps * outcaps);
  67 static GstFlowReturn gst_alpha_color_transform_ip (GstBaseTransform * btrans,
  68     GstBuffer * inbuf);
  69
  70 static void
  71 gst_alpha_color_class_init (GstAlphaColorClass * klass)
  72 {
  73   GstElementClass *gstelement_class = (GstElementClass *) klass;
  74   GstBaseTransformClass *gstbasetransform_class =
  75       (GstBaseTransformClass *) klass;
  76
  77   GST_DEBUG_CATEGORY_INIT (alpha_color_debug, "alphacolor", 0,
  78       "ARGB<->AYUV colorspace conversion preserving the alpha channels");
  79
  80   gst_element_class_set_details_simple (gstelement_class, "Alpha color filter",
  81       "Filter/Converter/Video",
  82       "ARGB from/to AYUV colorspace conversion preserving the alpha channel",
  83       "Wim Taymans <wim.taymans@gmail.com>");
  84
  85   gst_element_class_add_pad_template (gstelement_class,
  86       gst_static_pad_template_get (&sink_template));
  87   gst_element_class_add_pad_template (gstelement_class,
  88       gst_static_pad_template_get (&src_template));
  89
  90   gstbasetransform_class->transform_caps =
  91       GST_DEBUG_FUNCPTR (gst_alpha_color_transform_caps);
  92   gstbasetransform_class->set_caps =
  93       GST_DEBUG_FUNCPTR (gst_alpha_color_set_caps);
  94   gstbasetransform_class->transform_ip =
  95       GST_DEBUG_FUNCPTR (gst_alpha_color_transform_ip);
  96 }
  97
  98 static void
  99 gst_alpha_color_init (GstAlphaColor * alpha)
 100 {
 101   GstBaseTransform *btrans = GST_BASE_TRANSFORM (alpha);
 102
 103   btrans->always_in_place = TRUE;
 104 }
 105
 106 static GstCaps *
 107 gst_alpha_color_transform_caps (GstBaseTransform * btrans,
 108     GstPadDirection direction, GstCaps * caps, GstCaps * filter)
 109 {
 110   const GstCaps *tmpl_caps = NULL;
 111   GstCaps *result = NULL, *local_caps = NULL;
 112   guint i;
 113
 114   local_caps = gst_caps_new_empty ();
 115
 116   for (i = 0; i < gst_caps_get_size (caps); i++) {
 117     GstStructure *structure =
 118         gst_structure_copy (gst_caps_get_structure (caps, i));
 119
 120     /* Remove any specific parameter from the structure */
 121     gst_structure_remove_field (structure, "format");
 122     gst_structure_remove_field (structure, "endianness");
 123     gst_structure_remove_field (structure, "depth");
 124     gst_structure_remove_field (structure, "bpp");
 125     gst_structure_remove_field (structure, "red_mask");
 126     gst_structure_remove_field (structure, "green_mask");
 127     gst_structure_remove_field (structure, "blue_mask");
 128     gst_structure_remove_field (structure, "alpha_mask");
 129     gst_structure_remove_field (structure, "color-matrix");
 130     gst_structure_remove_field (structure, "chroma-site");
 131
 132     gst_structure_set_name (structure, "video/x-raw-rgb");
 133     gst_caps_append_structure (local_caps, gst_structure_copy (structure));
 134     gst_structure_set_name (structure, "video/x-raw-yuv");
 135     gst_caps_append_structure (local_caps, structure);
 136   }
 137
 138   /* Get the appropriate template */
 139   if (direction == GST_PAD_SINK) {
 140     tmpl_caps = gst_static_pad_template_get_caps (&src_template);
 141   } else if (direction == GST_PAD_SRC) {
 142     tmpl_caps = gst_static_pad_template_get_caps (&sink_template);
 143   }
 144
 145   /* Intersect with our template caps */
 146   result = gst_caps_intersect (local_caps, tmpl_caps);
 147
 148   gst_caps_unref (local_caps);
 149   gst_caps_do_simplify (result);
 150
 151   GST_LOG_OBJECT (btrans, "transformed %" GST_PTR_FORMAT " to %" GST_PTR_FORMAT,
 152       caps, result);
 153
 154   if (filter) {
 155     GstCaps *intersection;
 156
 157     GST_DEBUG_OBJECT (btrans, "Using filter caps %" GST_PTR_FORMAT, filter);
 158     intersection =
 159         gst_caps_intersect_full (filter, result, GST_CAPS_INTERSECT_FIRST);
 160     gst_caps_unref (result);
 161     result = intersection;
 162     GST_DEBUG_OBJECT (btrans, "Intersection %" GST_PTR_FORMAT, result);
 163   }
 164
 165
 166   return result;
 167 }
 168
 169 /* Generated by -bad/ext/cog/generate_tables */
 170 static const int cog_ycbcr_to_rgb_matrix_8bit_hdtv[] = {
 171   298, 0, 459, -63514,
 172   298, -55, -136, 19681,
 173   298, 541, 0, -73988,
 174 };
 175
 176 static const int cog_ycbcr_to_rgb_matrix_8bit_sdtv[] = {
 177   298, 0, 409, -57068,
 178   298, -100, -208, 34707,
 179   298, 516, 0, -70870,
 180 };
 181
 182 static const gint cog_rgb_to_ycbcr_matrix_8bit_hdtv[] = {
 183   47, 157, 16, 4096,
 184   -26, -87, 112, 32768,
 185   112, -102, -10, 32768,
 186 };
 187
 188 static const gint cog_rgb_to_ycbcr_matrix_8bit_sdtv[] = {
 189   66, 129, 25, 4096,
 190   -38, -74, 112, 32768,
 191   112, -94, -18, 32768,
 192 };
 193
 194 static const gint cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit[] = {
 195   256, -30, -53, 10600,
 196   0, 261, 29, -4367,
 197   0, 19, 262, -3289,
 198 };
 199
 200 static const gint cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit[] = {
 201   256, 25, 49, -9536,
 202   0, 253, -28, 3958,
 203   0, -19, 252, 2918,
 204 };
 205
 206 #define DEFINE_ARGB_AYUV_FUNCTIONS(name, A, R, G, B) \
 207 static void \
 208 transform_##name##_ayuv (GstVideoFrame * frame, const gint *matrix) \
 209 { \
 210   guint8 *data; \
 211   gsize size; \
 212   gint y, u, v; \
 213   gint yc[4]; \
 214   gint uc[4]; \
 215   gint vc[4]; \
 216   \
 217   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);\
 218   size = GST_VIDEO_FRAME_SIZE (frame);\
 219   \
 220   memcpy (yc, matrix, 4 * sizeof (gint)); \
 221   memcpy (uc, matrix + 4, 4 * sizeof (gint)); \
 222   memcpy (vc, matrix + 8, 4 * sizeof (gint)); \
 223   \
 224   while (size > 0) { \
 225     y = (data[R] * yc[0] + data[G] * yc[1] + data[B] * yc[2] + yc[3]) >> 8; \
 226     u = (data[R] * uc[0] + data[G] * uc[1] + data[B] * uc[2] + uc[3]) >> 8; \
 227     v = (data[R] * vc[0] + data[G] * vc[1] + data[B] * vc[2] + vc[3]) >> 8; \
 228     \
 229     data[0] = data[A]; \
 230     data[1] = y; \
 231     data[2] = u; \
 232     data[3] = v; \
 233     \
 234     data += 4; \
 235     size -= 4; \
 236   } \
 237 } \
 238 \
 239 static void \
 240 transform_ayuv_##name (GstVideoFrame * frame, const gint *matrix) \
 241 { \
 242   guint8 *data; \
 243   gsize size; \
 244   gint r, g, b; \
 245   gint rc[4]; \
 246   gint gc[4]; \
 247   gint bc[4]; \
 248   \
 249   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);\
 250   size = GST_VIDEO_FRAME_SIZE (frame);\
 251   \
 252   memcpy (rc, matrix, 4 * sizeof (gint)); \
 253   memcpy (gc, matrix + 4, 4 * sizeof (gint)); \
 254   memcpy (bc, matrix + 8, 4 * sizeof (gint)); \
 255   \
 256   while (size > 0) { \
 257     r = (data[1] * rc[0] + data[2] * rc[1] + data[3] * rc[2] + rc[3]) >> 8; \
 258     g = (data[1] * gc[0] + data[2] * gc[1] + data[3] * gc[2] + gc[3]) >> 8; \
 259     b = (data[1] * bc[0] + data[2] * bc[1] + data[3] * bc[2] + bc[3]) >> 8; \
 260     \
 261     data[A] = data[0]; \
 262     data[R] = CLAMP (r, 0, 255); \
 263     data[G] = CLAMP (g, 0, 255); \
 264     data[B] = CLAMP (b, 0, 255); \
 265     \
 266     data += 4; \
 267     size -= 4; \
 268   } \
 269 }
 270
 271 DEFINE_ARGB_AYUV_FUNCTIONS (rgba, 3, 0, 1, 2);
 272 DEFINE_ARGB_AYUV_FUNCTIONS (bgra, 3, 2, 1, 0);
 273 DEFINE_ARGB_AYUV_FUNCTIONS (argb, 0, 1, 2, 3);
 274 DEFINE_ARGB_AYUV_FUNCTIONS (abgr, 0, 3, 2, 1);
 275
 276 static void
 277 transform_ayuv_ayuv (GstVideoFrame * frame, const gint * matrix)
 278 {
 279   guint8 *data;
 280   gsize size;
 281   gint y, u, v;
 282   gint yc[4];
 283   gint uc[4];
 284   gint vc[4];
 285
 286   if (matrix == NULL)
 287     return;
 288
 289   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 290   size = GST_VIDEO_FRAME_SIZE (frame);
 291
 292   memcpy (yc, matrix, 4 * sizeof (gint));
 293   memcpy (uc, matrix + 4, 4 * sizeof (gint));
 294   memcpy (vc, matrix + 8, 4 * sizeof (gint));
 295
 296   while (size > 0) {
 297     y = (data[1] * yc[0] + data[2] * yc[1] + data[3] * yc[2] + yc[3]) >> 8;
 298     u = (data[1] * uc[0] + data[2] * uc[1] + data[3] * uc[2] + uc[3]) >> 8;
 299     v = (data[1] * vc[0] + data[2] * vc[1] + data[3] * vc[2] + vc[3]) >> 8;
 300
 301     data[0] = data[0];
 302     data[1] = y;
 303     data[2] = u;
 304     data[3] = v;
 305
 306     data += 4;
 307     size -= 4;
 308   }
 309 }
 310
 311 static void
 312 transform_argb_bgra (GstVideoFrame * frame, const gint * matrix)
 313 {
 314   guint8 *data;
 315   gsize size;
 316   gint r, g, b;
 317
 318   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 319   size = GST_VIDEO_FRAME_SIZE (frame);
 320
 321   while (size > 0) {
 322     r = data[1];
 323     g = data[2];
 324     b = data[3];
 325
 326     data[3] = data[0];
 327     data[0] = b;
 328     data[1] = g;
 329     data[2] = r;
 330
 331     data += 4;
 332     size -= 4;
 333   }
 334 }
 335
 336 #define transform_abgr_rgba transform_argb_bgra
 337
 338 static void
 339 transform_argb_abgr (GstVideoFrame * frame, const gint * matrix)
 340 {
 341   guint8 *data;
 342   gsize size;
 343   gint r, g, b;
 344
 345   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 346   size = GST_VIDEO_FRAME_SIZE (frame);
 347
 348   while (size > 0) {
 349     r = data[1];
 350     g = data[2];
 351     b = data[3];
 352
 353     /* data[0] = data[0]; */
 354     data[1] = b;
 355     data[2] = g;
 356     data[3] = r;
 357
 358     data += 4;
 359     size -= 4;
 360   }
 361 }
 362
 363 #define transform_abgr_argb transform_argb_abgr
 364
 365 static void
 366 transform_rgba_bgra (GstVideoFrame * frame, const gint * matrix)
 367 {
 368   guint8 *data;
 369   gsize size;
 370   gint r, g, b;
 371
 372   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 373   size = GST_VIDEO_FRAME_SIZE (frame);
 374
 375   while (size > 0) {
 376     r = data[0];
 377     g = data[1];
 378     b = data[2];
 379
 380     /* data[3] = data[3] */ ;
 381     data[0] = b;
 382     data[1] = g;
 383     data[2] = r;
 384
 385     data += 4;
 386     size -= 4;
 387   }
 388 }
 389
 390 #define transform_bgra_rgba transform_rgba_bgra
 391
 392 static void
 393 transform_argb_rgba (GstVideoFrame * frame, const gint * matrix)
 394 {
 395   guint8 *data;
 396   gsize size;
 397   gint r, g, b;
 398
 399   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 400   size = GST_VIDEO_FRAME_SIZE (frame);
 401
 402   while (size > 0) {
 403     r = data[1];
 404     g = data[2];
 405     b = data[3];
 406
 407     data[3] = data[0];
 408     data[0] = r;
 409     data[1] = g;
 410     data[2] = b;
 411
 412     data += 4;
 413     size -= 4;
 414   }
 415 }
 416
 417 #define transform_abgr_bgra transform_argb_rgba
 418
 419 static void
 420 transform_bgra_argb (GstVideoFrame * frame, const gint * matrix)
 421 {
 422   guint8 *data;
 423   gsize size;
 424   gint r, g, b;
 425
 426   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 427   size = GST_VIDEO_FRAME_SIZE (frame);
 428
 429   while (size > 0) {
 430     r = data[2];
 431     g = data[1];
 432     b = data[0];
 433
 434     data[0] = data[3];
 435     data[1] = r;
 436     data[2] = g;
 437     data[3] = b;
 438
 439     data += 4;
 440     size -= 4;
 441   }
 442 }
 443
 444 #define transform_rgba_abgr transform_bgra_argb
 445
 446 static void
 447 transform_rgba_argb (GstVideoFrame * frame, const gint * matrix)
 448 {
 449   guint8 *data;
 450   gsize size;
 451   gint r, g, b;
 452
 453   data = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
 454   size = GST_VIDEO_FRAME_SIZE (frame);
 455
 456   while (size > 0) {
 457     r = data[0];
 458     g = data[1];
 459     b = data[2];
 460
 461     data[0] = data[3];
 462     data[1] = r;
 463     data[2] = g;
 464     data[3] = b;
 465
 466     data += 4;
 467     size -= 4;
 468   }
 469 }
 470
 471 #define transform_bgra_abgr transform_rgba_argb
 472
 473 static gboolean
 474 gst_alpha_color_set_caps (GstBaseTransform * btrans, GstCaps * incaps,
 475     GstCaps * outcaps)
 476 {
 477   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 478   gboolean ret;
 479   GstVideoInfo in_info, out_info;
 480   gboolean in_sdtv, out_sdtv;
 481
 482   alpha->process = NULL;
 483   alpha->matrix = NULL;
 484
 485   ret = gst_video_info_from_caps (&in_info, incaps);
 486   ret &= gst_video_info_from_caps (&out_info, outcaps);
 487   if (!ret)
 488     goto invalid_caps;
 489
 490   if (GST_VIDEO_INFO_WIDTH (&in_info) != GST_VIDEO_INFO_WIDTH (&out_info) ||
 491       GST_VIDEO_INFO_HEIGHT (&in_info) != GST_VIDEO_INFO_HEIGHT (&out_info))
 492     goto invalid_caps;
 493
 494   in_sdtv =
 495       in_info.color_matrix ? g_str_equal (in_info.color_matrix, "sdtv") : TRUE;
 496   out_sdtv =
 497       out_info.color_matrix ? g_str_equal (out_info.color_matrix,
 498       "sdtv") : TRUE;
 499
 500   switch (GST_VIDEO_INFO_FORMAT (&in_info)) {
 501     case GST_VIDEO_FORMAT_ARGB:
 502       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 503         case GST_VIDEO_FORMAT_ARGB:
 504           alpha->process = NULL;
 505           alpha->matrix = NULL;
 506           break;
 507         case GST_VIDEO_FORMAT_BGRA:
 508           alpha->process = transform_argb_bgra;
 509           alpha->matrix = NULL;
 510           break;
 511         case GST_VIDEO_FORMAT_ABGR:
 512           alpha->process = transform_argb_abgr;
 513           alpha->matrix = NULL;
 514           break;
 515         case GST_VIDEO_FORMAT_RGBA:
 516           alpha->process = transform_argb_rgba;
 517           alpha->matrix = NULL;
 518           break;
 519         case GST_VIDEO_FORMAT_AYUV:
 520           alpha->process = transform_argb_ayuv;
 521           alpha->matrix =
 522               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 523               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 524           break;
 525         default:
 526           alpha->process = NULL;
 527           alpha->matrix = NULL;
 528           break;
 529       }
 530       break;
 531     case GST_VIDEO_FORMAT_BGRA:
 532       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 533         case GST_VIDEO_FORMAT_BGRA:
 534           alpha->process = NULL;
 535           alpha->matrix = NULL;
 536           break;
 537         case GST_VIDEO_FORMAT_ARGB:
 538           alpha->process = transform_bgra_argb;
 539           alpha->matrix = NULL;
 540           break;
 541         case GST_VIDEO_FORMAT_ABGR:
 542           alpha->process = transform_bgra_abgr;
 543           alpha->matrix = NULL;
 544           break;
 545         case GST_VIDEO_FORMAT_RGBA:
 546           alpha->process = transform_bgra_rgba;
 547           alpha->matrix = NULL;
 548           break;
 549         case GST_VIDEO_FORMAT_AYUV:
 550           alpha->process = transform_bgra_ayuv;
 551           alpha->matrix =
 552               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 553               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 554           break;
 555         default:
 556           alpha->process = NULL;
 557           alpha->matrix = NULL;
 558           break;
 559       }
 560       break;
 561     case GST_VIDEO_FORMAT_ABGR:
 562       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 563         case GST_VIDEO_FORMAT_ABGR:
 564           alpha->process = NULL;
 565           alpha->matrix = NULL;
 566           break;
 567         case GST_VIDEO_FORMAT_RGBA:
 568           alpha->process = transform_abgr_rgba;
 569           alpha->matrix = NULL;
 570           break;
 571         case GST_VIDEO_FORMAT_ARGB:
 572           alpha->process = transform_abgr_argb;
 573           alpha->matrix = NULL;
 574           break;
 575         case GST_VIDEO_FORMAT_BGRA:
 576           alpha->process = transform_abgr_bgra;
 577           alpha->matrix = NULL;
 578           break;
 579         case GST_VIDEO_FORMAT_AYUV:
 580           alpha->process = transform_abgr_ayuv;
 581           alpha->matrix =
 582               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 583               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 584           break;
 585         default:
 586           alpha->process = NULL;
 587           alpha->matrix = NULL;
 588           break;
 589       }
 590       break;
 591     case GST_VIDEO_FORMAT_RGBA:
 592       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 593         case GST_VIDEO_FORMAT_RGBA:
 594           alpha->process = NULL;
 595           alpha->matrix = NULL;
 596           break;
 597         case GST_VIDEO_FORMAT_ARGB:
 598           alpha->process = transform_rgba_argb;
 599           alpha->matrix = NULL;
 600           break;
 601         case GST_VIDEO_FORMAT_ABGR:
 602           alpha->process = transform_rgba_abgr;
 603           alpha->matrix = NULL;
 604           break;
 605         case GST_VIDEO_FORMAT_BGRA:
 606           alpha->process = transform_rgba_bgra;
 607           alpha->matrix = NULL;
 608           break;
 609         case GST_VIDEO_FORMAT_AYUV:
 610           alpha->process = transform_rgba_ayuv;
 611           alpha->matrix =
 612               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 613               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 614           break;
 615         default:
 616           alpha->process = NULL;
 617           alpha->matrix = NULL;
 618           break;
 619       }
 620       break;
 621     case GST_VIDEO_FORMAT_AYUV:
 622       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 623         case GST_VIDEO_FORMAT_AYUV:
 624           if (in_sdtv == out_sdtv) {
 625             alpha->process = transform_ayuv_ayuv;
 626             alpha->matrix = NULL;
 627           } else {
 628             alpha->process = transform_ayuv_ayuv;
 629             alpha->matrix =
 630                 out_sdtv ? cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit :
 631                 cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit;
 632           }
 633           break;
 634         case GST_VIDEO_FORMAT_ARGB:
 635           alpha->process = transform_ayuv_argb;
 636           alpha->matrix =
 637               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 638               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 639           break;
 640         case GST_VIDEO_FORMAT_BGRA:
 641           alpha->process = transform_ayuv_bgra;
 642           alpha->matrix =
 643               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 644               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 645           break;
 646         case GST_VIDEO_FORMAT_ABGR:
 647           alpha->process = transform_ayuv_abgr;
 648           alpha->matrix =
 649               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 650               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 651           break;
 652         case GST_VIDEO_FORMAT_RGBA:
 653           alpha->process = transform_ayuv_rgba;
 654           alpha->matrix =
 655               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 656               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 657           break;
 658         default:
 659           alpha->process = NULL;
 660           alpha->matrix = NULL;
 661           break;
 662       }
 663       break;
 664     default:
 665       alpha->process = NULL;
 666       alpha->matrix = NULL;
 667       break;
 668   }
 669
 670   if (GST_VIDEO_INFO_FORMAT (&in_info) == GST_VIDEO_INFO_FORMAT (&out_info)
 671       && in_sdtv == out_sdtv)
 672     gst_base_transform_set_passthrough (btrans, TRUE);
 673   else if (!alpha->process)
 674     goto no_process;
 675
 676   return TRUE;
 677
 678   /* ERRORS */
 679 invalid_caps:
 680   {
 681     GST_DEBUG_OBJECT (alpha, "incomplete or invalid caps");
 682     return FALSE;
 683   }
 684 no_process:
 685   {
 686     GST_DEBUG_OBJECT (alpha, "could not find process function");
 687     return FALSE;
 688   }
 689 }
 690
 691 static GstFlowReturn
 692 gst_alpha_color_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
 693 {
 694   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 695   GstVideoFrame frame;
 696
 697   if (gst_base_transform_is_passthrough (btrans))
 698     return GST_FLOW_OK;
 699
 700   if (G_UNLIKELY (!alpha->process))
 701     goto not_negotiated;
 702
 703   if (!gst_video_frame_map (&frame, &alpha->in_info, inbuf, GST_MAP_READWRITE))
 704     goto invalid_buffer;
 705
 706   /* Transform in place */
 707   alpha->process (&frame, alpha->matrix);
 708
 709   gst_video_frame_unmap (&frame);
 710
 711   return GST_FLOW_OK;
 712
 713   /* ERRORS */
 714 not_negotiated:
 715   {
 716     GST_ERROR_OBJECT (alpha, "Not negotiated yet");
 717     return GST_FLOW_NOT_NEGOTIATED;
 718   }
 719 invalid_buffer:
 720   {
 721     GST_ERROR_OBJECT (alpha, "Invalid buffer received");
 722     return GST_FLOW_ERROR;
 723   }
 724 }
 725
 726 static gboolean
 727 plugin_init (GstPlugin * plugin)
 728 {
 729   return gst_element_register (plugin, "alphacolor", GST_RANK_NONE,
 730       GST_TYPE_ALPHA_COLOR);
 731 }
 732
 733 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 734     GST_VERSION_MINOR,
 735     "alphacolor",
 736     "RGBA from/to AYUV colorspace conversion preserving the alpha channel",
 737     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)