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 = in_info.colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT601;
 495   out_sdtv = out_info.colorimetry.matrix = GST_VIDEO_COLOR_MATRIX_BT601;
 496
 497   switch (GST_VIDEO_INFO_FORMAT (&in_info)) {
 498     case GST_VIDEO_FORMAT_ARGB:
 499       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 500         case GST_VIDEO_FORMAT_ARGB:
 501           alpha->process = NULL;
 502           alpha->matrix = NULL;
 503           break;
 504         case GST_VIDEO_FORMAT_BGRA:
 505           alpha->process = transform_argb_bgra;
 506           alpha->matrix = NULL;
 507           break;
 508         case GST_VIDEO_FORMAT_ABGR:
 509           alpha->process = transform_argb_abgr;
 510           alpha->matrix = NULL;
 511           break;
 512         case GST_VIDEO_FORMAT_RGBA:
 513           alpha->process = transform_argb_rgba;
 514           alpha->matrix = NULL;
 515           break;
 516         case GST_VIDEO_FORMAT_AYUV:
 517           alpha->process = transform_argb_ayuv;
 518           alpha->matrix =
 519               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 520               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 521           break;
 522         default:
 523           alpha->process = NULL;
 524           alpha->matrix = NULL;
 525           break;
 526       }
 527       break;
 528     case GST_VIDEO_FORMAT_BGRA:
 529       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 530         case GST_VIDEO_FORMAT_BGRA:
 531           alpha->process = NULL;
 532           alpha->matrix = NULL;
 533           break;
 534         case GST_VIDEO_FORMAT_ARGB:
 535           alpha->process = transform_bgra_argb;
 536           alpha->matrix = NULL;
 537           break;
 538         case GST_VIDEO_FORMAT_ABGR:
 539           alpha->process = transform_bgra_abgr;
 540           alpha->matrix = NULL;
 541           break;
 542         case GST_VIDEO_FORMAT_RGBA:
 543           alpha->process = transform_bgra_rgba;
 544           alpha->matrix = NULL;
 545           break;
 546         case GST_VIDEO_FORMAT_AYUV:
 547           alpha->process = transform_bgra_ayuv;
 548           alpha->matrix =
 549               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 550               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 551           break;
 552         default:
 553           alpha->process = NULL;
 554           alpha->matrix = NULL;
 555           break;
 556       }
 557       break;
 558     case GST_VIDEO_FORMAT_ABGR:
 559       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 560         case GST_VIDEO_FORMAT_ABGR:
 561           alpha->process = NULL;
 562           alpha->matrix = NULL;
 563           break;
 564         case GST_VIDEO_FORMAT_RGBA:
 565           alpha->process = transform_abgr_rgba;
 566           alpha->matrix = NULL;
 567           break;
 568         case GST_VIDEO_FORMAT_ARGB:
 569           alpha->process = transform_abgr_argb;
 570           alpha->matrix = NULL;
 571           break;
 572         case GST_VIDEO_FORMAT_BGRA:
 573           alpha->process = transform_abgr_bgra;
 574           alpha->matrix = NULL;
 575           break;
 576         case GST_VIDEO_FORMAT_AYUV:
 577           alpha->process = transform_abgr_ayuv;
 578           alpha->matrix =
 579               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 580               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 581           break;
 582         default:
 583           alpha->process = NULL;
 584           alpha->matrix = NULL;
 585           break;
 586       }
 587       break;
 588     case GST_VIDEO_FORMAT_RGBA:
 589       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 590         case GST_VIDEO_FORMAT_RGBA:
 591           alpha->process = NULL;
 592           alpha->matrix = NULL;
 593           break;
 594         case GST_VIDEO_FORMAT_ARGB:
 595           alpha->process = transform_rgba_argb;
 596           alpha->matrix = NULL;
 597           break;
 598         case GST_VIDEO_FORMAT_ABGR:
 599           alpha->process = transform_rgba_abgr;
 600           alpha->matrix = NULL;
 601           break;
 602         case GST_VIDEO_FORMAT_BGRA:
 603           alpha->process = transform_rgba_bgra;
 604           alpha->matrix = NULL;
 605           break;
 606         case GST_VIDEO_FORMAT_AYUV:
 607           alpha->process = transform_rgba_ayuv;
 608           alpha->matrix =
 609               out_sdtv ? cog_rgb_to_ycbcr_matrix_8bit_sdtv :
 610               cog_rgb_to_ycbcr_matrix_8bit_hdtv;
 611           break;
 612         default:
 613           alpha->process = NULL;
 614           alpha->matrix = NULL;
 615           break;
 616       }
 617       break;
 618     case GST_VIDEO_FORMAT_AYUV:
 619       switch (GST_VIDEO_INFO_FORMAT (&out_info)) {
 620         case GST_VIDEO_FORMAT_AYUV:
 621           if (in_sdtv == out_sdtv) {
 622             alpha->process = transform_ayuv_ayuv;
 623             alpha->matrix = NULL;
 624           } else {
 625             alpha->process = transform_ayuv_ayuv;
 626             alpha->matrix =
 627                 out_sdtv ? cog_ycbcr_hdtv_to_ycbcr_sdtv_matrix_8bit :
 628                 cog_ycbcr_sdtv_to_ycbcr_hdtv_matrix_8bit;
 629           }
 630           break;
 631         case GST_VIDEO_FORMAT_ARGB:
 632           alpha->process = transform_ayuv_argb;
 633           alpha->matrix =
 634               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 635               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 636           break;
 637         case GST_VIDEO_FORMAT_BGRA:
 638           alpha->process = transform_ayuv_bgra;
 639           alpha->matrix =
 640               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 641               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 642           break;
 643         case GST_VIDEO_FORMAT_ABGR:
 644           alpha->process = transform_ayuv_abgr;
 645           alpha->matrix =
 646               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 647               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 648           break;
 649         case GST_VIDEO_FORMAT_RGBA:
 650           alpha->process = transform_ayuv_rgba;
 651           alpha->matrix =
 652               in_sdtv ? cog_ycbcr_to_rgb_matrix_8bit_sdtv :
 653               cog_ycbcr_to_rgb_matrix_8bit_hdtv;
 654           break;
 655         default:
 656           alpha->process = NULL;
 657           alpha->matrix = NULL;
 658           break;
 659       }
 660       break;
 661     default:
 662       alpha->process = NULL;
 663       alpha->matrix = NULL;
 664       break;
 665   }
 666
 667   if (GST_VIDEO_INFO_FORMAT (&in_info) == GST_VIDEO_INFO_FORMAT (&out_info)
 668       && in_sdtv == out_sdtv)
 669     gst_base_transform_set_passthrough (btrans, TRUE);
 670   else if (!alpha->process)
 671     goto no_process;
 672
 673   return TRUE;
 674
 675   /* ERRORS */
 676 invalid_caps:
 677   {
 678     GST_DEBUG_OBJECT (alpha, "incomplete or invalid caps");
 679     return FALSE;
 680   }
 681 no_process:
 682   {
 683     GST_DEBUG_OBJECT (alpha, "could not find process function");
 684     return FALSE;
 685   }
 686 }
 687
 688 static GstFlowReturn
 689 gst_alpha_color_transform_ip (GstBaseTransform * btrans, GstBuffer * inbuf)
 690 {
 691   GstAlphaColor *alpha = GST_ALPHA_COLOR (btrans);
 692   GstVideoFrame frame;
 693
 694   if (gst_base_transform_is_passthrough (btrans))
 695     return GST_FLOW_OK;
 696
 697   if (G_UNLIKELY (!alpha->process))
 698     goto not_negotiated;
 699
 700   if (!gst_video_frame_map (&frame, &alpha->in_info, inbuf, GST_MAP_READWRITE))
 701     goto invalid_buffer;
 702
 703   /* Transform in place */
 704   alpha->process (&frame, alpha->matrix);
 705
 706   gst_video_frame_unmap (&frame);
 707
 708   return GST_FLOW_OK;
 709
 710   /* ERRORS */
 711 not_negotiated:
 712   {
 713     GST_ERROR_OBJECT (alpha, "Not negotiated yet");
 714     return GST_FLOW_NOT_NEGOTIATED;
 715   }
 716 invalid_buffer:
 717   {
 718     GST_ERROR_OBJECT (alpha, "Invalid buffer received");
 719     return GST_FLOW_ERROR;
 720   }
 721 }
 722
 723 static gboolean
 724 plugin_init (GstPlugin * plugin)
 725 {
 726   return gst_element_register (plugin, "alphacolor", GST_RANK_NONE,
 727       GST_TYPE_ALPHA_COLOR);
 728 }
 729
 730 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 731     GST_VERSION_MINOR,
 732     "alphacolor",
 733     "RGBA from/to AYUV colorspace conversion preserving the alpha channel",
 734     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)