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