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