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