gst/videobox/gstvideobox.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 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23 #include <gst/gst.h>
  24 #include <gst/base/gstbasetransform.h>
  25 #include <gst/video/video.h>
  26
  27 #include <string.h>
  28
  29 GST_DEBUG_CATEGORY (videobox_debug);
  30 #define GST_CAT_DEFAULT videobox_debug
  31
  32 #define GST_TYPE_VIDEO_BOX \
  33   (gst_video_box_get_type())
  34 #define GST_VIDEO_BOX(obj) \
  35   (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_VIDEO_BOX,GstVideoBox))
  36 #define GST_VIDEO_BOX_CLASS(klass) \
  37   (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_VIDEO_BOX,GstVideoBoxClass))
  38 #define GST_IS_VIDEO_BOX(obj) \
  39   (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_VIDEO_BOX))
  40 #define GST_IS_VIDEO_BOX_CLASS(obj) \
  41   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_VIDEO_BOX))
  42
  43 typedef struct _GstVideoBox GstVideoBox;
  44 typedef struct _GstVideoBoxClass GstVideoBoxClass;
  45
  46 typedef enum
  47 {
  48   VIDEO_BOX_FILL_BLACK,
  49   VIDEO_BOX_FILL_GREEN,
  50   VIDEO_BOX_FILL_BLUE,
  51 }
  52 GstVideoBoxFill;
  53
  54 struct _GstVideoBox
  55 {
  56   GstBaseTransform element;
  57
  58   /* caps */
  59   gint in_width, in_height;
  60   gint out_width, out_height;
  61
  62   gint box_left, box_right, box_top, box_bottom;
  63
  64   gint border_left, border_right, border_top, border_bottom;
  65   gint crop_left, crop_right, crop_top, crop_bottom;
  66
  67   gboolean use_alpha;
  68   gdouble alpha;
  69   gdouble border_alpha;
  70
  71   GstVideoBoxFill fill_type;
  72 };
  73
  74 struct _GstVideoBoxClass
  75 {
  76   GstBaseTransformClass parent_class;
  77 };
  78
  79 /* elementfactory information */
  80 static GstElementDetails gst_video_box_details =
  81 GST_ELEMENT_DETAILS ("video box filter",
  82     "Filter/Effect/Video",
  83     "Resizes a video by adding borders or cropping",
  84     "Wim Taymans <wim@fluendo.com>");
  85
  86
  87 #define DEFAULT_LEFT      0
  88 #define DEFAULT_RIGHT     0
  89 #define DEFAULT_TOP       0
  90 #define DEFAULT_BOTTOM    0
  91 #define DEFAULT_FILL_TYPE VIDEO_BOX_FILL_BLACK
  92 #define DEFAULT_ALPHA     1.0
  93 #define DEFAULT_BORDER_ALPHA 1.0
  94
  95 enum
  96 {
  97   PROP_0,
  98   PROP_LEFT,
  99   PROP_RIGHT,
 100   PROP_TOP,
 101   PROP_BOTTOM,
 102   PROP_FILL_TYPE,
 103   PROP_ALPHA,
 104   PROP_BORDER_ALPHA,
 105   /* FILL ME */
 106 };
 107
 108 static GstStaticPadTemplate gst_video_box_src_template =
 109 GST_STATIC_PAD_TEMPLATE ("src",
 110     GST_PAD_SRC,
 111     GST_PAD_ALWAYS,
 112     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("{ AYUV, I420 }"))
 113     );
 114
 115 static GstStaticPadTemplate gst_video_box_sink_template =
 116 GST_STATIC_PAD_TEMPLATE ("sink",
 117     GST_PAD_SINK,
 118     GST_PAD_ALWAYS,
 119     GST_STATIC_CAPS (GST_VIDEO_CAPS_YUV ("I420"))
 120     );
 121
 122
 123 GST_BOILERPLATE (GstVideoBox, gst_video_box, GstBaseTransform,
 124     GST_TYPE_BASE_TRANSFORM);
 125
 126 static void gst_video_box_set_property (GObject * object, guint prop_id,
 127     const GValue * value, GParamSpec * pspec);
 128 static void gst_video_box_get_property (GObject * object, guint prop_id,
 129     GValue * value, GParamSpec * pspec);
 130
 131 static GstCaps *gst_video_box_transform_caps (GstBaseTransform * trans,
 132     GstPadDirection direction, GstCaps * from);
 133 static gboolean gst_video_box_set_caps (GstBaseTransform * trans,
 134     GstCaps * in, GstCaps * out);
 135 static gboolean gst_video_box_get_unit_size (GstBaseTransform * trans,
 136     GstCaps * caps, guint * size);
 137 static GstFlowReturn gst_video_box_transform (GstBaseTransform * trans,
 138     GstBuffer * in, GstBuffer * out);
 139
 140
 141 #define GST_TYPE_VIDEO_BOX_FILL (gst_video_box_fill_get_type())
 142 static GType
 143 gst_video_box_fill_get_type (void)
 144 {
 145   static GType video_box_fill_type = 0;
 146   static GEnumValue video_box_fill[] = {
 147     {VIDEO_BOX_FILL_BLACK, "0", "Black"},
 148     {VIDEO_BOX_FILL_GREEN, "1", "Colorkey green"},
 149     {VIDEO_BOX_FILL_BLUE, "2", "Colorkey blue"},
 150     {0, NULL, NULL},
 151   };
 152
 153   if (!video_box_fill_type) {
 154     video_box_fill_type =
 155         g_enum_register_static ("GstVideoBoxFill", video_box_fill);
 156   }
 157   return video_box_fill_type;
 158 }
 159
 160
 161 static void
 162 gst_video_box_base_init (gpointer g_class)
 163 {
 164   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
 165
 166   gst_element_class_set_details (element_class, &gst_video_box_details);
 167
 168   gst_element_class_add_pad_template (element_class,
 169       gst_static_pad_template_get (&gst_video_box_sink_template));
 170   gst_element_class_add_pad_template (element_class,
 171       gst_static_pad_template_get (&gst_video_box_src_template));
 172 }
 173
 174 static void
 175 gst_video_box_class_init (GstVideoBoxClass * klass)
 176 {
 177   GObjectClass *gobject_class;
 178   GstBaseTransformClass *trans_class;
 179
 180   gobject_class = (GObjectClass *) klass;
 181   trans_class = (GstBaseTransformClass *) klass;
 182
 183   gobject_class->set_property = gst_video_box_set_property;
 184   gobject_class->get_property = gst_video_box_get_property;
 185
 186   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_FILL_TYPE,
 187       g_param_spec_enum ("fill", "Fill", "How to fill the borders",
 188           GST_TYPE_VIDEO_BOX_FILL, DEFAULT_FILL_TYPE,
 189           (GParamFlags) G_PARAM_READWRITE));
 190   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_LEFT,
 191       g_param_spec_int ("left", "Left",
 192           "Pixels to box at left (<0  = add a border)", G_MININT, G_MAXINT,
 193           DEFAULT_LEFT, G_PARAM_READWRITE));
 194   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_RIGHT,
 195       g_param_spec_int ("right", "Right",
 196           "Pixels to box at right (<0 = add a border)", G_MININT, G_MAXINT,
 197           DEFAULT_RIGHT, G_PARAM_READWRITE));
 198   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TOP,
 199       g_param_spec_int ("top", "Top",
 200           "Pixels to box at top (<0 = add a border)", G_MININT, G_MAXINT,
 201           DEFAULT_TOP, G_PARAM_READWRITE));
 202   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BOTTOM,
 203       g_param_spec_int ("bottom", "Bottom",
 204           "Pixels to box at bottom (<0 = add a border)", G_MININT, G_MAXINT,
 205           DEFAULT_BOTTOM, G_PARAM_READWRITE));
 206   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_ALPHA,
 207       g_param_spec_double ("alpha", "Alpha", "Alpha value picture", 0.0, 1.0,
 208           DEFAULT_ALPHA, G_PARAM_READWRITE));
 209   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_BORDER_ALPHA,
 210       g_param_spec_double ("border_alpha", "Border Alpha",
 211           "Alpha value of the border", 0.0, 1.0, DEFAULT_BORDER_ALPHA,
 212           G_PARAM_READWRITE));
 213
 214   trans_class->transform_caps = gst_video_box_transform_caps;
 215   trans_class->set_caps = gst_video_box_set_caps;
 216   trans_class->get_unit_size = gst_video_box_get_unit_size;
 217   trans_class->transform = gst_video_box_transform;
 218
 219   GST_DEBUG_CATEGORY_INIT (videobox_debug, "videobox", 0,
 220       "Resizes a video by adding borders or cropping");
 221 }
 222
 223 static void
 224 gst_video_box_init (GstVideoBox * video_box, GstVideoBoxClass * g_class)
 225 {
 226   video_box->box_right = DEFAULT_RIGHT;
 227   video_box->box_left = DEFAULT_LEFT;
 228   video_box->box_top = DEFAULT_TOP;
 229   video_box->box_bottom = DEFAULT_BOTTOM;
 230   video_box->crop_right = 0;
 231   video_box->crop_left = 0;
 232   video_box->crop_top = 0;
 233   video_box->crop_bottom = 0;
 234   video_box->fill_type = DEFAULT_FILL_TYPE;
 235   video_box->alpha = DEFAULT_ALPHA;
 236   video_box->border_alpha = DEFAULT_BORDER_ALPHA;
 237 }
 238
 239 static void
 240 gst_video_box_set_property (GObject * object, guint prop_id,
 241     const GValue * value, GParamSpec * pspec)
 242 {
 243   GstVideoBox *video_box = GST_VIDEO_BOX (object);
 244
 245   switch (prop_id) {
 246     case PROP_LEFT:
 247       video_box->box_left = g_value_get_int (value);
 248       if (video_box->box_left < 0) {
 249         video_box->border_left = -video_box->box_left;
 250         video_box->crop_left = 0;
 251       } else {
 252         video_box->border_left = 0;
 253         video_box->crop_left = video_box->box_left;
 254       }
 255       break;
 256     case PROP_RIGHT:
 257       video_box->box_right = g_value_get_int (value);
 258       if (video_box->box_right < 0) {
 259         video_box->border_right = -video_box->box_right;
 260         video_box->crop_right = 0;
 261       } else {
 262         video_box->border_right = 0;
 263         video_box->crop_right = video_box->box_right;
 264       }
 265       break;
 266     case PROP_TOP:
 267       video_box->box_top = g_value_get_int (value);
 268       if (video_box->box_top < 0) {
 269         video_box->border_top = -video_box->box_top;
 270         video_box->crop_top = 0;
 271       } else {
 272         video_box->border_top = 0;
 273         video_box->crop_top = video_box->box_top;
 274       }
 275       break;
 276     case PROP_BOTTOM:
 277       video_box->box_bottom = g_value_get_int (value);
 278       if (video_box->box_bottom < 0) {
 279         video_box->border_bottom = -video_box->box_bottom;
 280         video_box->crop_bottom = 0;
 281       } else {
 282         video_box->border_bottom = 0;
 283         video_box->crop_bottom = video_box->box_bottom;
 284       }
 285       break;
 286     case PROP_FILL_TYPE:
 287       video_box->fill_type = g_value_get_enum (value);
 288       break;
 289     case PROP_ALPHA:
 290       video_box->alpha = g_value_get_double (value);
 291       break;
 292     case PROP_BORDER_ALPHA:
 293       video_box->border_alpha = g_value_get_double (value);
 294       break;
 295     default:
 296       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 297       break;
 298   }
 299
 300   if (video_box->box_left == 0 && video_box->box_right == 0 &&
 301       video_box->box_top == 0 && video_box->box_bottom == 0)
 302     gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (video_box), TRUE);
 303   else
 304     gst_base_transform_set_passthrough (GST_BASE_TRANSFORM (video_box), FALSE);
 305 }
 306 static void
 307 gst_video_box_get_property (GObject * object, guint prop_id, GValue * value,
 308     GParamSpec * pspec)
 309 {
 310   GstVideoBox *video_box = GST_VIDEO_BOX (object);
 311
 312   switch (prop_id) {
 313     case PROP_LEFT:
 314       g_value_set_int (value, video_box->box_left);
 315       break;
 316     case PROP_RIGHT:
 317       g_value_set_int (value, video_box->box_right);
 318       break;
 319     case PROP_TOP:
 320       g_value_set_int (value, video_box->box_top);
 321       break;
 322     case PROP_BOTTOM:
 323       g_value_set_int (value, video_box->box_bottom);
 324       break;
 325     case PROP_FILL_TYPE:
 326       g_value_set_enum (value, video_box->fill_type);
 327       break;
 328     case PROP_ALPHA:
 329       g_value_set_double (value, video_box->alpha);
 330       break;
 331     case PROP_BORDER_ALPHA:
 332       g_value_set_double (value, video_box->border_alpha);
 333       break;
 334     default:
 335       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 336       break;
 337   }
 338 }
 339
 340 static GstCaps *
 341 gst_video_box_transform_caps (GstBaseTransform * trans,
 342     GstPadDirection direction, GstCaps * from)
 343 {
 344   GstVideoBox *video_box;
 345   GstCaps *to;
 346   GstStructure *structure;
 347   GValue list_value = { 0 }, value = {
 348   0};
 349   gint dir, i, tmp;
 350
 351   video_box = GST_VIDEO_BOX (trans);
 352
 353   g_value_init (&list_value, GST_TYPE_LIST);
 354   g_value_init (&value, GST_TYPE_FOURCC);
 355   gst_value_set_fourcc (&value, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 356   gst_value_list_append_value (&list_value, &value);
 357   g_value_unset (&value);
 358
 359   to = gst_caps_copy (from);
 360   dir = (direction == GST_PAD_SINK) ? -1 : 1;
 361
 362   for (i = 0; i < gst_caps_get_size (to); i++) {
 363     structure = gst_caps_get_structure (to, i);
 364     if (direction == GST_PAD_SINK) {    /* I420 to { I420, AYUV } */
 365       g_value_init (&value, GST_TYPE_FOURCC);
 366       gst_value_set_fourcc (&value, GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'));
 367       gst_value_list_append_value (&list_value, &value);
 368       g_value_unset (&value);
 369       gst_structure_set_value (structure, "format", &list_value);
 370     } else if (direction == GST_PAD_SRC) {
 371       gst_structure_set_value (structure, "format", &list_value);
 372     }
 373     if (gst_structure_get_int (structure, "width", &tmp))
 374       gst_structure_set (structure, "width", G_TYPE_INT,
 375           tmp + direction * (video_box->box_left + video_box->box_right), NULL);
 376     if (gst_structure_get_int (structure, "height", &tmp))
 377       gst_structure_set (structure, "height", G_TYPE_INT,
 378           tmp + direction * (video_box->box_top + video_box->box_bottom), NULL);
 379   }
 380
 381   g_value_unset (&list_value);
 382
 383   return to;
 384 }
 385
 386 static gboolean
 387 gst_video_box_set_caps (GstBaseTransform * trans, GstCaps * in, GstCaps * out)
 388 {
 389   GstVideoBox *video_box;
 390   GstStructure *structure;
 391   gboolean ret;
 392   guint32 fourcc = 0;
 393
 394   video_box = GST_VIDEO_BOX (trans);
 395
 396   structure = gst_caps_get_structure (in, 0);
 397   ret = gst_structure_get_int (structure, "width", &video_box->in_width);
 398   ret &= gst_structure_get_int (structure, "height", &video_box->in_height);
 399
 400   structure = gst_caps_get_structure (out, 0);
 401   ret &= gst_structure_get_int (structure, "width", &video_box->out_width);
 402   ret &= gst_structure_get_int (structure, "height", &video_box->out_height);
 403   ret &= gst_structure_get_fourcc (structure, "format", &fourcc);
 404
 405   video_box->use_alpha = fourcc == GST_STR_FOURCC ("AYUV");
 406
 407   return ret;
 408 }
 409
 410 /* see gst-plugins/gst/games/gstvideoimage.c, paint_setup_I420() */
 411 #define GST_VIDEO_I420_Y_ROWSTRIDE(width) (GST_ROUND_UP_4(width))
 412 #define GST_VIDEO_I420_U_ROWSTRIDE(width) (GST_ROUND_UP_8(width)/2)
 413 #define GST_VIDEO_I420_V_ROWSTRIDE(width) ((GST_ROUND_UP_8(GST_VIDEO_I420_Y_ROWSTRIDE(width)))/2)
 414
 415 #define GST_VIDEO_I420_Y_OFFSET(w,h) (0)
 416 #define GST_VIDEO_I420_U_OFFSET(w,h) (GST_VIDEO_I420_Y_OFFSET(w,h)+(GST_VIDEO_I420_Y_ROWSTRIDE(w)*GST_ROUND_UP_2(h)))
 417 #define GST_VIDEO_I420_V_OFFSET(w,h) (GST_VIDEO_I420_U_OFFSET(w,h)+(GST_VIDEO_I420_U_ROWSTRIDE(w)*GST_ROUND_UP_2(h)/2))
 418
 419 #define GST_VIDEO_I420_SIZE(w,h)     (GST_VIDEO_I420_V_OFFSET(w,h)+(GST_VIDEO_I420_V_ROWSTRIDE(w)*GST_ROUND_UP_2(h)/2))
 420
 421 static gboolean
 422 gst_video_box_get_unit_size (GstBaseTransform * trans, GstCaps * caps,
 423     guint * size)
 424 {
 425   GstVideoBox *video_box;
 426   GstStructure *structure = NULL;
 427   guint32 fourcc;
 428   gint width, height;
 429
 430   g_return_val_if_fail (size, FALSE);
 431   video_box = GST_VIDEO_BOX (trans);
 432
 433   structure = gst_caps_get_structure (caps, 0);
 434   gst_structure_get_fourcc (structure, "format", &fourcc);
 435   gst_structure_get_int (structure, "width", &width);
 436   gst_structure_get_int (structure, "height", &height);
 437
 438   switch (fourcc) {
 439     case GST_MAKE_FOURCC ('A', 'Y', 'U', 'V'):
 440       *size = width * height * 4;
 441       break;
 442     case GST_MAKE_FOURCC ('I', '4', '2', '0'):
 443       *size = GST_VIDEO_I420_SIZE (width, height);
 444       break;
 445     default:
 446       return FALSE;
 447       break;
 448   }
 449
 450   return TRUE;
 451 }
 452
 453 static int yuv_colors_Y[] = { 16, 150, 29 };
 454 static int yuv_colors_U[] = { 128, 46, 255 };
 455 static int yuv_colors_V[] = { 128, 21, 107 };
 456
 457 static void
 458 gst_video_box_copy_plane_i420 (GstVideoBox * video_box, guint8 * src,
 459     guint8 * dest, gint br, gint bl, gint bt, gint bb, gint src_crop_width,
 460     gint src_crop_height, gint src_stride, gint dest_width, gint dest_stride,
 461     guint8 fill_color)
 462 {
 463   gint j;
 464
 465   /* top border */
 466   for (j = 0; j < bt; j++) {
 467     memset (dest, fill_color, dest_width);
 468     dest += dest_stride;
 469   }
 470
 471   /* copy and add left and right border */
 472   for (j = 0; j < src_crop_height; j++) {
 473     memset (dest, fill_color, bl);
 474     memcpy (dest + bl, src, src_crop_width);
 475     memset (dest + bl + src_crop_width, fill_color, br);
 476     dest += dest_stride;
 477     src += src_stride;
 478   }
 479
 480   /* bottom border */
 481   for (j = 0; j < bb; j++) {
 482     memset (dest, fill_color, dest_width);
 483     dest += dest_stride;
 484   }
 485 }
 486
 487 static void
 488 gst_video_box_i420 (GstVideoBox * video_box, guint8 * src, guint8 * dest)
 489 {
 490   guint8 *srcY, *srcU, *srcV;
 491   guint8 *destY, *destU, *destV;
 492   gint crop_width, crop_height;
 493   gint out_width, out_height;
 494   gint src_width, src_height;
 495   gint src_stride, dest_stride;
 496   gint br, bl, bt, bb;
 497
 498   br = video_box->border_right;
 499   bl = video_box->border_left;
 500   bt = video_box->border_top;
 501   bb = video_box->border_bottom;
 502
 503   out_width = video_box->out_width;
 504   out_height = video_box->out_height;
 505
 506   src_width = video_box->in_width;
 507   src_height = video_box->in_height;
 508
 509   crop_width = src_width - (video_box->crop_left + video_box->crop_right);
 510   crop_height = src_height - (video_box->crop_top + video_box->crop_bottom);
 511
 512   /* Y plane */
 513   src_stride = GST_VIDEO_I420_Y_ROWSTRIDE (src_width);
 514   dest_stride = GST_VIDEO_I420_Y_ROWSTRIDE (out_width);
 515
 516   destY = dest + GST_VIDEO_I420_Y_OFFSET (out_width, out_height);
 517
 518   srcY = src + GST_VIDEO_I420_Y_OFFSET (src_width, src_height);
 519   srcY += src_stride * video_box->crop_top + video_box->crop_left;
 520
 521   gst_video_box_copy_plane_i420 (video_box, srcY, destY, br, bl, bt, bb,
 522       crop_width, crop_height, src_stride, out_width, dest_stride,
 523       yuv_colors_Y[video_box->fill_type]);
 524
 525   /* U plane */
 526   src_stride = GST_VIDEO_I420_U_ROWSTRIDE (src_width);
 527   dest_stride = GST_VIDEO_I420_U_ROWSTRIDE (out_width);
 528
 529   destU = dest + GST_VIDEO_I420_U_OFFSET (out_width, out_height);
 530
 531   srcU = src + GST_VIDEO_I420_U_OFFSET (src_width, src_height);
 532   srcU += src_stride * (video_box->crop_top / 2) + (video_box->crop_left / 2);
 533
 534   gst_video_box_copy_plane_i420 (video_box, srcU, destU, br / 2, bl / 2, bt / 2,
 535       bb / 2, crop_width / 2, crop_height / 2, src_stride, out_width / 2,
 536       dest_stride, yuv_colors_U[video_box->fill_type]);
 537
 538   /* V plane */
 539   src_stride = GST_VIDEO_I420_V_ROWSTRIDE (src_width);
 540   dest_stride = GST_VIDEO_I420_V_ROWSTRIDE (out_width);
 541
 542   destV = dest + GST_VIDEO_I420_V_OFFSET (out_width, out_height);
 543
 544   srcV = src + GST_VIDEO_I420_V_OFFSET (src_width, src_height);
 545   srcV += src_stride * (video_box->crop_top / 2) + (video_box->crop_left / 2);
 546
 547   gst_video_box_copy_plane_i420 (video_box, srcV, destV, br / 2, bl / 2, bt / 2,
 548       bb / 2, crop_width / 2, crop_height / 2, src_stride, out_width / 2,
 549       dest_stride, yuv_colors_V[video_box->fill_type]);
 550 }
 551
 552 /* Note the source image is always I420, we
 553  * are converting to AYUV on the fly here */
 554
 555 static void
 556 gst_video_box_ayuv (GstVideoBox * video_box, guint8 * src, guint8 * dest)
 557 {
 558   guint8 *srcY, *srcU, *srcV;
 559   gint crop_width, crop_width2, crop_height;
 560   gint out_width, out_height;
 561   gint src_stride, src_stride2;
 562   gint br, bl, bt, bb;
 563   gint colorY, colorU, colorV;
 564   gint i, j;
 565   guint8 b_alpha = (guint8) (video_box->border_alpha * 255);
 566   guint8 i_alpha = (guint8) (video_box->alpha * 255);
 567   guint32 *destp = (guint32 *) dest;
 568   guint32 ayuv;
 569
 570   br = video_box->border_right;
 571   bl = video_box->border_left;
 572   bt = video_box->border_top;
 573   bb = video_box->border_bottom;
 574
 575   out_width = video_box->out_width;
 576   out_height = video_box->out_height;
 577
 578   src_stride = GST_VIDEO_I420_Y_ROWSTRIDE (video_box->in_width);
 579   src_stride2 = src_stride / 2;
 580
 581   crop_width =
 582       video_box->in_width - (video_box->crop_left + video_box->crop_right);
 583   crop_width2 = crop_width / 2;
 584   crop_height =
 585       video_box->in_height - (video_box->crop_top + video_box->crop_bottom);
 586
 587   srcY =
 588       src + GST_VIDEO_I420_Y_OFFSET (video_box->in_width, video_box->in_height);
 589   srcY += src_stride * video_box->crop_top + video_box->crop_left;
 590   srcU =
 591       src + GST_VIDEO_I420_U_OFFSET (video_box->in_width, video_box->in_height);
 592   srcU += src_stride2 * (video_box->crop_top / 2) + (video_box->crop_left / 2);
 593   srcV =
 594       src + GST_VIDEO_I420_V_OFFSET (video_box->in_width, video_box->in_height);
 595   srcV += src_stride2 * (video_box->crop_top / 2) + (video_box->crop_left / 2);
 596
 597   colorY = yuv_colors_Y[video_box->fill_type];
 598   colorU = yuv_colors_U[video_box->fill_type];
 599   colorV = yuv_colors_V[video_box->fill_type];
 600
 601   ayuv =
 602       GUINT32_FROM_BE ((b_alpha << 24) | (colorY << 16) | (colorU << 8) |
 603       colorV);
 604
 605   /* top border */
 606   for (i = 0; i < bt; i++) {
 607     for (j = 0; j < out_width; j++) {
 608       *destp++ = ayuv;
 609     }
 610   }
 611   for (i = 0; i < crop_height; i++) {
 612     /* left border */
 613     for (j = 0; j < bl; j++) {
 614       *destp++ = ayuv;
 615     }
 616     dest = (guint8 *) destp;
 617     /* center */
 618     for (j = 0; j < crop_width2; j++) {
 619       *dest++ = i_alpha;
 620       *dest++ = *srcY++;
 621       *dest++ = *srcU;
 622       *dest++ = *srcV;
 623       *dest++ = i_alpha;
 624       *dest++ = *srcY++;
 625       *dest++ = *srcU++;
 626       *dest++ = *srcV++;
 627     }
 628     if (i % 2 == 0) {
 629       srcU -= crop_width2;
 630       srcV -= crop_width2;
 631     } else {
 632       srcU += src_stride2 - crop_width2;
 633       srcV += src_stride2 - crop_width2;
 634     }
 635     srcY += src_stride - crop_width;
 636
 637     destp = (guint32 *) dest;
 638     /* right border */
 639     for (j = 0; j < br; j++) {
 640       *destp++ = ayuv;
 641     }
 642   }
 643   /* bottom border */
 644   for (i = 0; i < bb; i++) {
 645     for (j = 0; j < out_width; j++) {
 646       *destp++ = ayuv;
 647     }
 648   }
 649 }
 650
 651 static GstFlowReturn
 652 gst_video_box_transform (GstBaseTransform * trans, GstBuffer * in,
 653     GstBuffer * out)
 654 {
 655   GstVideoBox *video_box;
 656
 657   video_box = GST_VIDEO_BOX (trans);
 658
 659   if (video_box->use_alpha) {
 660     gst_video_box_ayuv (video_box, GST_BUFFER_DATA (in), GST_BUFFER_DATA (out));
 661   } else {
 662     gst_video_box_i420 (video_box, GST_BUFFER_DATA (in), GST_BUFFER_DATA (out));
 663   }
 664
 665   return GST_FLOW_OK;
 666 }
 667
 668 static gboolean
 669 plugin_init (GstPlugin * plugin)
 670 {
 671   return gst_element_register (plugin, "videobox", GST_RANK_NONE,
 672       GST_TYPE_VIDEO_BOX);
 673 }
 674
 675 GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
 676     GST_VERSION_MINOR,
 677     "videobox",
 678     "resizes a video by adding borders or cropping",
 679     plugin_init, VERSION, GST_LICENSE, GST_PACKAGE, GST_ORIGIN)