sys/v4l2/gstv4l2sink.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2009 Texas Instruments, Inc - http://www.ti.com/
   4  *
   5  * Description: V4L2 sink element
   6  *  Created on: Jul 2, 2009
   7  *      Author: Rob Clark <rob@ti.com>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 /**
  26  * SECTION:element-v4l2sink
  27  *
  28  * v4l2sink can be used to display video to v4l2 devices (screen overlays
  29  * provided by the graphics hardware, tv-out, etc)
  30  *
  31  * <refsect2>
  32  * <title>Example launch lines</title>
  33  * |[
  34  * gst-launch videotestsrc ! v4l2sink device=/dev/video1
  35  * ]| This pipeline displays a test pattern on /dev/video1
  36  * </refsect2>
  37  */
  38
  39
  40 #ifdef HAVE_CONFIG_H
  41 #include <config.h>
  42 #endif
  43
  44
  45 #include "gstv4l2colorbalance.h"
  46 #ifdef HAVE_XVIDEO
  47 #include "gstv4l2xoverlay.h"
  48 #endif
  49 #include "gstv4l2vidorient.h"
  50
  51 #include "gstv4l2sink.h"
  52 #include "gst/gst-i18n-plugin.h"
  53
  54 #include <string.h>
  55
  56 GST_DEBUG_CATEGORY (v4l2sink_debug);
  57 #define GST_CAT_DEFAULT v4l2sink_debug
  58
  59 #define PROP_DEF_QUEUE_SIZE         12
  60 #define PROP_DEF_MIN_QUEUED_BUFS    1
  61 #define DEFAULT_PROP_DEVICE   "/dev/video1"
  62
  63 enum
  64 {
  65   PROP_0,
  66   V4L2_STD_OBJECT_PROPS,
  67   PROP_QUEUE_SIZE,
  68   PROP_MIN_QUEUED_BUFS,
  69   PROP_OVERLAY_TOP,
  70   PROP_OVERLAY_LEFT,
  71   PROP_OVERLAY_WIDTH,
  72   PROP_OVERLAY_HEIGHT,
  73   PROP_CROP_TOP,
  74   PROP_CROP_LEFT,
  75   PROP_CROP_WIDTH,
  76   PROP_CROP_HEIGHT,
  77 };
  78
  79
  80 GST_IMPLEMENT_V4L2_PROBE_METHODS (GstV4l2SinkClass, gst_v4l2sink);
  81 GST_IMPLEMENT_V4L2_COLOR_BALANCE_METHODS (GstV4l2Sink, gst_v4l2sink);
  82 #ifdef HAVE_XVIDEO
  83 GST_IMPLEMENT_V4L2_XOVERLAY_METHODS (GstV4l2Sink, gst_v4l2sink);
  84 #endif
  85 GST_IMPLEMENT_V4L2_VIDORIENT_METHODS (GstV4l2Sink, gst_v4l2sink);
  86
  87 static gboolean
  88 gst_v4l2sink_iface_supported (GstImplementsInterface * iface, GType iface_type)
  89 {
  90   GstV4l2Object *v4l2object = GST_V4L2SINK (iface)->v4l2object;
  91
  92 #ifdef HAVE_XVIDEO
  93   g_assert (iface_type == GST_TYPE_X_OVERLAY ||
  94       iface_type == GST_TYPE_COLOR_BALANCE ||
  95       iface_type == GST_TYPE_VIDEO_ORIENTATION);
  96 #else
  97   g_assert (iface_type == GST_TYPE_COLOR_BALANCE ||
  98       iface_type == GST_TYPE_VIDEO_ORIENTATION);
  99 #endif
 100
 101   if (v4l2object->video_fd == -1)
 102     return FALSE;
 103
 104 #ifdef HAVE_XVIDEO
 105   if (iface_type == GST_TYPE_X_OVERLAY && !GST_V4L2_IS_OVERLAY (v4l2object))
 106     return FALSE;
 107 #endif
 108
 109   return TRUE;
 110 }
 111
 112 static void
 113 gst_v4l2sink_interface_init (GstImplementsInterfaceClass * klass)
 114 {
 115   /*
 116    * default virtual functions
 117    */
 118   klass->supported = gst_v4l2sink_iface_supported;
 119 }
 120
 121 static void
 122 gst_v4l2sink_init_interfaces (GType type)
 123 {
 124   static const GInterfaceInfo v4l2iface_info = {
 125     (GInterfaceInitFunc) gst_v4l2sink_interface_init,
 126     NULL,
 127     NULL,
 128   };
 129 #ifdef HAVE_XVIDEO
 130   static const GInterfaceInfo v4l2_xoverlay_info = {
 131     (GInterfaceInitFunc) gst_v4l2sink_xoverlay_interface_init,
 132     NULL,
 133     NULL,
 134   };
 135 #endif
 136   static const GInterfaceInfo v4l2_colorbalance_info = {
 137     (GInterfaceInitFunc) gst_v4l2sink_color_balance_interface_init,
 138     NULL,
 139     NULL,
 140   };
 141   static const GInterfaceInfo v4l2_videoorientation_info = {
 142     (GInterfaceInitFunc) gst_v4l2sink_video_orientation_interface_init,
 143     NULL,
 144     NULL,
 145   };
 146   static const GInterfaceInfo v4l2_propertyprobe_info = {
 147     (GInterfaceInitFunc) gst_v4l2sink_property_probe_interface_init,
 148     NULL,
 149     NULL,
 150   };
 151
 152   g_type_add_interface_static (type,
 153       GST_TYPE_IMPLEMENTS_INTERFACE, &v4l2iface_info);
 154 #ifdef HAVE_XVIDEO
 155   g_type_add_interface_static (type, GST_TYPE_X_OVERLAY, &v4l2_xoverlay_info);
 156 #endif
 157   g_type_add_interface_static (type,
 158       GST_TYPE_COLOR_BALANCE, &v4l2_colorbalance_info);
 159   g_type_add_interface_static (type,
 160       GST_TYPE_VIDEO_ORIENTATION, &v4l2_videoorientation_info);
 161   g_type_add_interface_static (type, GST_TYPE_PROPERTY_PROBE,
 162       &v4l2_propertyprobe_info);
 163 }
 164
 165
 166 GST_BOILERPLATE_FULL (GstV4l2Sink, gst_v4l2sink, GstVideoSink,
 167     GST_TYPE_VIDEO_SINK, gst_v4l2sink_init_interfaces);
 168
 169
 170 static void gst_v4l2sink_dispose (GObject * object);
 171 static void gst_v4l2sink_finalize (GstV4l2Sink * v4l2sink);
 172
 173 /* GObject methods: */
 174 static void gst_v4l2sink_set_property (GObject * object, guint prop_id,
 175     const GValue * value, GParamSpec * pspec);
 176 static void gst_v4l2sink_get_property (GObject * object, guint prop_id,
 177     GValue * value, GParamSpec * pspec);
 178
 179
 180 /* GstElement methods: */
 181 static GstStateChangeReturn gst_v4l2sink_change_state (GstElement * element,
 182     GstStateChange transition);
 183
 184 /* GstBaseSink methods: */
 185 static GstCaps *gst_v4l2sink_get_caps (GstBaseSink * bsink);
 186 static gboolean gst_v4l2sink_set_caps (GstBaseSink * bsink, GstCaps * caps);
 187 static GstFlowReturn gst_v4l2sink_buffer_alloc (GstBaseSink * bsink,
 188     guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf);
 189 static GstFlowReturn gst_v4l2sink_show_frame (GstBaseSink * bsink,
 190     GstBuffer * buf);
 191
 192
 193 static void
 194 gst_v4l2sink_base_init (gpointer g_class)
 195 {
 196   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 197   GstV4l2SinkClass *gstv4l2sink_class = GST_V4L2SINK_CLASS (g_class);
 198
 199   gstv4l2sink_class->v4l2_class_devices = NULL;
 200
 201   GST_DEBUG_CATEGORY_INIT (v4l2sink_debug, "v4l2sink", 0, "V4L2 sink element");
 202
 203   gst_element_class_set_details_simple (gstelement_class,
 204       "Video (video4linux2) Sink", "Sink/Video",
 205       "Displays frames on a video4linux2 device", "Rob Clark <rob@ti.com>,");
 206
 207   gst_element_class_add_pad_template
 208       (gstelement_class,
 209       gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
 210           gst_v4l2_object_get_all_caps ()));
 211 }
 212
 213 static void
 214 gst_v4l2sink_class_init (GstV4l2SinkClass * klass)
 215 {
 216   GObjectClass *gobject_class;
 217   GstElementClass *element_class;
 218   GstBaseSinkClass *basesink_class;
 219
 220   gobject_class = G_OBJECT_CLASS (klass);
 221   element_class = GST_ELEMENT_CLASS (klass);
 222   basesink_class = GST_BASE_SINK_CLASS (klass);
 223
 224   gobject_class->dispose = gst_v4l2sink_dispose;
 225   gobject_class->finalize = (GObjectFinalizeFunc) gst_v4l2sink_finalize;
 226   gobject_class->set_property = gst_v4l2sink_set_property;
 227   gobject_class->get_property = gst_v4l2sink_get_property;
 228
 229   element_class->change_state = gst_v4l2sink_change_state;
 230
 231   gst_v4l2_object_install_properties_helper (gobject_class,
 232       DEFAULT_PROP_DEVICE);
 233   g_object_class_install_property (gobject_class, PROP_QUEUE_SIZE,
 234       g_param_spec_uint ("queue-size", "Queue size",
 235           "Number of buffers to be enqueud in the driver in streaming mode",
 236           GST_V4L2_MIN_BUFFERS, GST_V4L2_MAX_BUFFERS, PROP_DEF_QUEUE_SIZE,
 237           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 238   g_object_class_install_property (gobject_class, PROP_MIN_QUEUED_BUFS,
 239       g_param_spec_uint ("min-queued-bufs", "Minimum queued bufs",
 240           "Minimum number of queued bufs; v4l2sink won't dqbuf if the driver "
 241           "doesn't have more than this number (which normally you shouldn't change)",
 242           0, GST_V4L2_MAX_BUFFERS, PROP_DEF_MIN_QUEUED_BUFS,
 243           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 244   g_object_class_install_property (gobject_class, PROP_OVERLAY_TOP,
 245       g_param_spec_int ("overlay-top", "Overlay top",
 246           "The topmost (y) coordinate of the video overlay; top left corner of screen is 0,0",
 247           G_MININT, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 248   g_object_class_install_property (gobject_class, PROP_OVERLAY_LEFT,
 249       g_param_spec_int ("overlay-left", "Overlay left",
 250           "The leftmost (x) coordinate of the video overlay; top left corner of screen is 0,0",
 251           G_MININT, G_MAXINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 252   g_object_class_install_property (gobject_class, PROP_OVERLAY_WIDTH,
 253       g_param_spec_uint ("overlay-width", "Overlay width",
 254           "The width of the video overlay; default is equal to negotiated image width",
 255           0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 256   g_object_class_install_property (gobject_class, PROP_OVERLAY_HEIGHT,
 257       g_param_spec_uint ("overlay-height", "Overlay height",
 258           "The height of the video overlay; default is equal to negotiated image height",
 259           0, G_MAXUINT, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 260
 261   g_object_class_install_property (gobject_class, PROP_CROP_TOP,
 262       g_param_spec_int ("crop-top", "Crop top",
 263           "The topmost (y) coordinate of the video crop; top left corner of image is 0,0",
 264           0x80000000, 0x7fffffff, 0, G_PARAM_READWRITE));
 265   g_object_class_install_property (gobject_class, PROP_CROP_LEFT,
 266       g_param_spec_int ("crop-left", "Crop left",
 267           "The leftmost (x) coordinate of the video crop; top left corner of image is 0,0",
 268           0x80000000, 0x7fffffff, 0, G_PARAM_READWRITE));
 269   g_object_class_install_property (gobject_class, PROP_CROP_WIDTH,
 270       g_param_spec_uint ("crop-width", "Crop width",
 271           "The width of the video crop; default is equal to negotiated image width",
 272           0, 0xffffffff, 0, G_PARAM_READWRITE));
 273   g_object_class_install_property (gobject_class, PROP_CROP_HEIGHT,
 274       g_param_spec_uint ("crop-height", "Crop height",
 275           "The height of the video crop; default is equal to negotiated image height",
 276           0, 0xffffffff, 0, G_PARAM_READWRITE));
 277
 278   basesink_class->get_caps = GST_DEBUG_FUNCPTR (gst_v4l2sink_get_caps);
 279   basesink_class->set_caps = GST_DEBUG_FUNCPTR (gst_v4l2sink_set_caps);
 280   basesink_class->buffer_alloc = GST_DEBUG_FUNCPTR (gst_v4l2sink_buffer_alloc);
 281   basesink_class->render = GST_DEBUG_FUNCPTR (gst_v4l2sink_show_frame);
 282 }
 283
 284 static void
 285 gst_v4l2sink_init (GstV4l2Sink * v4l2sink, GstV4l2SinkClass * klass)
 286 {
 287   v4l2sink->v4l2object = gst_v4l2_object_new (GST_ELEMENT (v4l2sink),
 288       V4L2_BUF_TYPE_VIDEO_OUTPUT, DEFAULT_PROP_DEVICE,
 289       gst_v4l2_get_output, gst_v4l2_set_output, NULL);
 290
 291   /* same default value for video output device as is used for
 292    * v4l2src/capture is no good..  so lets set a saner default
 293    * (which can be overridden by the one creating the v4l2sink
 294    * after the constructor returns)
 295    */
 296   g_object_set (v4l2sink, "device", "/dev/video1", NULL);
 297
 298   /* number of buffers requested */
 299   v4l2sink->num_buffers = PROP_DEF_QUEUE_SIZE;
 300   v4l2sink->min_queued_bufs = PROP_DEF_MIN_QUEUED_BUFS;
 301
 302   v4l2sink->probed_caps = NULL;
 303   v4l2sink->current_caps = NULL;
 304
 305   v4l2sink->overlay_fields_set = 0;
 306   v4l2sink->crop_fields_set = 0;
 307   v4l2sink->state = 0;
 308 }
 309
 310
 311 static void
 312 gst_v4l2sink_dispose (GObject * object)
 313 {
 314   GstV4l2Sink *v4l2sink = GST_V4L2SINK (object);
 315
 316   if (v4l2sink->probed_caps) {
 317     gst_caps_unref (v4l2sink->probed_caps);
 318   }
 319
 320   if (v4l2sink->current_caps) {
 321     gst_caps_unref (v4l2sink->current_caps);
 322   }
 323
 324   G_OBJECT_CLASS (parent_class)->dispose (object);
 325 }
 326
 327
 328 static void
 329 gst_v4l2sink_finalize (GstV4l2Sink * v4l2sink)
 330 {
 331   gst_v4l2_object_destroy (v4l2sink->v4l2object);
 332
 333   G_OBJECT_CLASS (parent_class)->finalize ((GObject *) (v4l2sink));
 334 }
 335
 336
 337 /*
 338  * State values
 339  */
 340 enum
 341 {
 342   STATE_OFF = 0,
 343   STATE_PENDING_STREAMON,
 344   STATE_STREAMING
 345 };
 346
 347 /*
 348  * flags to indicate which overlay/crop properties the user has set (and
 349  * therefore which ones should override the defaults from the driver)
 350  */
 351 enum
 352 {
 353   RECT_TOP_SET = 0x01,
 354   RECT_LEFT_SET = 0x02,
 355   RECT_WIDTH_SET = 0x04,
 356   RECT_HEIGHT_SET = 0x08
 357 };
 358
 359 static void
 360 gst_v4l2sink_sync_overlay_fields (GstV4l2Sink * v4l2sink)
 361 {
 362   if (!v4l2sink->overlay_fields_set)
 363     return;
 364
 365   if (GST_V4L2_IS_OPEN (v4l2sink->v4l2object)) {
 366
 367     gint fd = v4l2sink->v4l2object->video_fd;
 368     struct v4l2_format format;
 369
 370     memset (&format, 0x00, sizeof (struct v4l2_format));
 371     format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
 372
 373     g_return_if_fail (v4l2_ioctl (fd, VIDIOC_G_FMT, &format) >= 0);
 374
 375     GST_DEBUG_OBJECT (v4l2sink,
 376         "setting overlay: overlay_fields_set=0x%02x, top=%d, left=%d, width=%d, height=%d",
 377         v4l2sink->overlay_fields_set,
 378         v4l2sink->overlay.top, v4l2sink->overlay.left,
 379         v4l2sink->overlay.width, v4l2sink->overlay.height);
 380
 381     if (v4l2sink->overlay_fields_set & RECT_TOP_SET)
 382       format.fmt.win.w.top = v4l2sink->overlay.top;
 383     if (v4l2sink->overlay_fields_set & RECT_LEFT_SET)
 384       format.fmt.win.w.left = v4l2sink->overlay.left;
 385     if (v4l2sink->overlay_fields_set & RECT_WIDTH_SET)
 386       format.fmt.win.w.width = v4l2sink->overlay.width;
 387     if (v4l2sink->overlay_fields_set & RECT_HEIGHT_SET)
 388       format.fmt.win.w.height = v4l2sink->overlay.height;
 389
 390     g_return_if_fail (v4l2_ioctl (fd, VIDIOC_S_FMT, &format) >= 0);
 391
 392     v4l2sink->overlay_fields_set = 0;
 393     v4l2sink->overlay = format.fmt.win.w;
 394   }
 395 }
 396
 397 static void
 398 gst_v4l2sink_sync_crop_fields (GstV4l2Sink * v4l2sink)
 399 {
 400   if (!v4l2sink->crop_fields_set)
 401     return;
 402
 403   if (GST_V4L2_IS_OPEN (v4l2sink->v4l2object)) {
 404
 405     gint fd = v4l2sink->v4l2object->video_fd;
 406     struct v4l2_crop crop;
 407
 408     memset (&crop, 0x00, sizeof (struct v4l2_crop));
 409     crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
 410
 411     g_return_if_fail (v4l2_ioctl (fd, VIDIOC_G_CROP, &crop) >= 0);
 412
 413     GST_DEBUG_OBJECT (v4l2sink,
 414         "setting crop: crop_fields_set=0x%02x, top=%d, left=%d, width=%d, height=%d",
 415         v4l2sink->crop_fields_set,
 416         v4l2sink->crop.top, v4l2sink->crop.left,
 417         v4l2sink->crop.width, v4l2sink->crop.height);
 418
 419     if (v4l2sink->crop_fields_set & RECT_TOP_SET)
 420       crop.c.top = v4l2sink->crop.top;
 421     if (v4l2sink->crop_fields_set & RECT_LEFT_SET)
 422       crop.c.left = v4l2sink->crop.left;
 423     if (v4l2sink->crop_fields_set & RECT_WIDTH_SET)
 424       crop.c.width = v4l2sink->crop.width;
 425     if (v4l2sink->crop_fields_set & RECT_HEIGHT_SET)
 426       crop.c.height = v4l2sink->crop.height;
 427
 428     g_return_if_fail (v4l2_ioctl (fd, VIDIOC_S_CROP, &crop) >= 0);
 429
 430     v4l2sink->crop_fields_set = 0;
 431     v4l2sink->crop = crop.c;
 432   }
 433 }
 434
 435
 436 static void
 437 gst_v4l2sink_set_property (GObject * object,
 438     guint prop_id, const GValue * value, GParamSpec * pspec)
 439 {
 440   GstV4l2Sink *v4l2sink = GST_V4L2SINK (object);
 441
 442   if (!gst_v4l2_object_set_property_helper (v4l2sink->v4l2object,
 443           prop_id, value, pspec)) {
 444     switch (prop_id) {
 445       case PROP_QUEUE_SIZE:
 446         v4l2sink->num_buffers = g_value_get_uint (value);
 447         break;
 448       case PROP_MIN_QUEUED_BUFS:
 449         v4l2sink->min_queued_bufs = g_value_get_uint (value);
 450         break;
 451       case PROP_OVERLAY_TOP:
 452         v4l2sink->overlay.top = g_value_get_int (value);
 453         v4l2sink->overlay_fields_set |= RECT_TOP_SET;
 454         gst_v4l2sink_sync_overlay_fields (v4l2sink);
 455         break;
 456       case PROP_OVERLAY_LEFT:
 457         v4l2sink->overlay.left = g_value_get_int (value);
 458         v4l2sink->overlay_fields_set |= RECT_LEFT_SET;
 459         gst_v4l2sink_sync_overlay_fields (v4l2sink);
 460         break;
 461       case PROP_OVERLAY_WIDTH:
 462         v4l2sink->overlay.width = g_value_get_uint (value);
 463         v4l2sink->overlay_fields_set |= RECT_WIDTH_SET;
 464         gst_v4l2sink_sync_overlay_fields (v4l2sink);
 465         break;
 466       case PROP_OVERLAY_HEIGHT:
 467         v4l2sink->overlay.height = g_value_get_uint (value);
 468         v4l2sink->overlay_fields_set |= RECT_HEIGHT_SET;
 469         gst_v4l2sink_sync_overlay_fields (v4l2sink);
 470         break;
 471       case PROP_CROP_TOP:
 472         v4l2sink->crop.top = g_value_get_int (value);
 473         v4l2sink->crop_fields_set |= RECT_TOP_SET;
 474         gst_v4l2sink_sync_crop_fields (v4l2sink);
 475         break;
 476       case PROP_CROP_LEFT:
 477         v4l2sink->crop.left = g_value_get_int (value);
 478         v4l2sink->crop_fields_set |= RECT_LEFT_SET;
 479         gst_v4l2sink_sync_crop_fields (v4l2sink);
 480         break;
 481       case PROP_CROP_WIDTH:
 482         v4l2sink->crop.width = g_value_get_uint (value);
 483         v4l2sink->crop_fields_set |= RECT_WIDTH_SET;
 484         gst_v4l2sink_sync_crop_fields (v4l2sink);
 485         break;
 486       case PROP_CROP_HEIGHT:
 487         v4l2sink->crop.height = g_value_get_uint (value);
 488         v4l2sink->crop_fields_set |= RECT_HEIGHT_SET;
 489         gst_v4l2sink_sync_crop_fields (v4l2sink);
 490         break;
 491       default:
 492         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 493         break;
 494     }
 495   }
 496 }
 497
 498
 499 static void
 500 gst_v4l2sink_get_property (GObject * object,
 501     guint prop_id, GValue * value, GParamSpec * pspec)
 502 {
 503   GstV4l2Sink *v4l2sink = GST_V4L2SINK (object);
 504
 505   if (!gst_v4l2_object_get_property_helper (v4l2sink->v4l2object,
 506           prop_id, value, pspec)) {
 507     switch (prop_id) {
 508       case PROP_QUEUE_SIZE:
 509         g_value_set_uint (value, v4l2sink->num_buffers);
 510         break;
 511       case PROP_MIN_QUEUED_BUFS:
 512         g_value_set_uint (value, v4l2sink->min_queued_bufs);
 513         break;
 514       case PROP_OVERLAY_TOP:
 515         g_value_set_int (value, v4l2sink->overlay.top);
 516         break;
 517       case PROP_OVERLAY_LEFT:
 518         g_value_set_int (value, v4l2sink->overlay.left);
 519         break;
 520       case PROP_OVERLAY_WIDTH:
 521         g_value_set_uint (value, v4l2sink->overlay.width);
 522         break;
 523       case PROP_OVERLAY_HEIGHT:
 524         g_value_set_uint (value, v4l2sink->overlay.height);
 525         break;
 526       case PROP_CROP_TOP:
 527         g_value_set_int (value, v4l2sink->crop.top);
 528         break;
 529       case PROP_CROP_LEFT:
 530         g_value_set_int (value, v4l2sink->crop.left);
 531         break;
 532       case PROP_CROP_WIDTH:
 533         g_value_set_uint (value, v4l2sink->crop.width);
 534         break;
 535       case PROP_CROP_HEIGHT:
 536         g_value_set_uint (value, v4l2sink->crop.height);
 537         break;
 538       default:
 539         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 540         break;
 541     }
 542   }
 543 }
 544
 545 static GstStateChangeReturn
 546 gst_v4l2sink_change_state (GstElement * element, GstStateChange transition)
 547 {
 548   GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
 549   GstV4l2Sink *v4l2sink = GST_V4L2SINK (element);
 550
 551   GST_DEBUG_OBJECT (v4l2sink, "%d -> %d",
 552       GST_STATE_TRANSITION_CURRENT (transition),
 553       GST_STATE_TRANSITION_NEXT (transition));
 554
 555   switch (transition) {
 556     case GST_STATE_CHANGE_NULL_TO_READY:
 557       /* open the device */
 558       if (!gst_v4l2_object_start (v4l2sink->v4l2object))
 559         return GST_STATE_CHANGE_FAILURE;
 560       break;
 561     default:
 562       break;
 563   }
 564
 565   ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 566
 567   switch (transition) {
 568     case GST_STATE_CHANGE_PAUSED_TO_READY:
 569       if (v4l2sink->state == STATE_STREAMING) {
 570         if (!gst_v4l2_object_stop_streaming (v4l2sink->v4l2object)) {
 571           return GST_STATE_CHANGE_FAILURE;
 572         }
 573         v4l2sink->state = STATE_PENDING_STREAMON;
 574       }
 575       break;
 576     case GST_STATE_CHANGE_READY_TO_NULL:
 577       if (NULL != v4l2sink->pool)
 578         gst_v4l2_buffer_pool_destroy (v4l2sink->pool);
 579       v4l2sink->pool = NULL;
 580       /* close the device */
 581       if (!gst_v4l2_object_stop (v4l2sink->v4l2object))
 582         return GST_STATE_CHANGE_FAILURE;
 583       v4l2sink->state = STATE_OFF;
 584       break;
 585     default:
 586       break;
 587   }
 588
 589   return ret;
 590 }
 591
 592
 593 static GstCaps *
 594 gst_v4l2sink_get_caps (GstBaseSink * bsink)
 595 {
 596   GstV4l2Sink *v4l2sink = GST_V4L2SINK (bsink);
 597   GstCaps *ret;
 598   GSList *walk;
 599   GSList *formats;
 600
 601   if (!GST_V4L2_IS_OPEN (v4l2sink->v4l2object)) {
 602     /* FIXME: copy? */
 603     GST_DEBUG_OBJECT (v4l2sink, "device is not open");
 604     return
 605         gst_caps_copy (gst_pad_get_pad_template_caps (GST_BASE_SINK_PAD
 606             (v4l2sink)));
 607   }
 608
 609   if (v4l2sink->probed_caps) {
 610     LOG_CAPS (v4l2sink, v4l2sink->probed_caps);
 611     return gst_caps_ref (v4l2sink->probed_caps);
 612   }
 613
 614   formats = gst_v4l2_object_get_format_list (v4l2sink->v4l2object);
 615
 616   ret = gst_caps_new_empty ();
 617
 618   for (walk = v4l2sink->v4l2object->formats; walk; walk = walk->next) {
 619     struct v4l2_fmtdesc *format;
 620
 621     GstStructure *template;
 622
 623     format = (struct v4l2_fmtdesc *) walk->data;
 624
 625     template = gst_v4l2_object_v4l2fourcc_to_structure (format->pixelformat);
 626
 627     if (template) {
 628       GstCaps *tmp;
 629
 630       tmp =
 631           gst_v4l2_object_probe_caps_for_format (v4l2sink->v4l2object,
 632           format->pixelformat, template);
 633       if (tmp)
 634         gst_caps_append (ret, tmp);
 635
 636       gst_structure_free (template);
 637     } else {
 638       GST_DEBUG_OBJECT (v4l2sink, "unknown format %u", format->pixelformat);
 639     }
 640   }
 641
 642   v4l2sink->probed_caps = gst_caps_ref (ret);
 643
 644   GST_INFO_OBJECT (v4l2sink, "probed caps: %p", ret);
 645   LOG_CAPS (v4l2sink, ret);
 646
 647   return ret;
 648 }
 649
 650 static gboolean
 651 gst_v4l2sink_set_caps (GstBaseSink * bsink, GstCaps * caps)
 652 {
 653   GstV4l2Sink *v4l2sink = GST_V4L2SINK (bsink);
 654   gint w = 0, h = 0;
 655   struct v4l2_fmtdesc *format;
 656   guint fps_n, fps_d;
 657   guint size;
 658
 659   LOG_CAPS (v4l2sink, caps);
 660
 661   if (!GST_V4L2_IS_OPEN (v4l2sink->v4l2object)) {
 662     GST_DEBUG_OBJECT (v4l2sink, "device is not open");
 663     return FALSE;
 664   }
 665
 666   if (v4l2sink->current_caps) {
 667     GST_DEBUG_OBJECT (v4l2sink, "already have caps set.. are they equal?");
 668     LOG_CAPS (v4l2sink, v4l2sink->current_caps);
 669     if (gst_caps_is_equal (v4l2sink->current_caps, caps)) {
 670       GST_DEBUG_OBJECT (v4l2sink, "yes they are!");
 671       return TRUE;
 672     }
 673     GST_DEBUG_OBJECT (v4l2sink, "no they aren't!");
 674   }
 675
 676   if (v4l2sink->pool) {
 677     /* TODO: if we've already allocated buffers, we probably need to
 678      * do something here to free and reallocate....
 679      *
 680      *   gst_v4l2_object_stop_streaming()
 681      *   gst_v4l2_buffer_pool_destroy()
 682      *
 683      */
 684     GST_DEBUG_OBJECT (v4l2sink, "warning, changing caps not supported yet");
 685     return FALSE;
 686   }
 687
 688   /* we want our own v4l2 type of fourcc codes */
 689   if (!gst_v4l2_object_get_caps_info (v4l2sink->v4l2object, caps,
 690           &format, &w, &h, &fps_n, &fps_d, &size)) {
 691     GST_DEBUG_OBJECT (v4l2sink, "can't get capture format from caps %p", caps);
 692     return FALSE;
 693   }
 694
 695   if (!format) {
 696     GST_DEBUG_OBJECT (v4l2sink, "unrecognized caps!!");
 697     return FALSE;
 698   }
 699
 700   if (!gst_v4l2_object_set_format (v4l2sink->v4l2object, format->pixelformat, w,
 701           h)) {
 702     /* error already posted */
 703     return FALSE;
 704   }
 705
 706   v4l2sink->current_caps = gst_caps_ref (caps);
 707
 708   return TRUE;
 709 }
 710
 711 /* buffer alloc function to implement pad_alloc for upstream element */
 712 static GstFlowReturn
 713 gst_v4l2sink_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size,
 714     GstCaps * caps, GstBuffer ** buf)
 715 {
 716   GstV4l2Sink *v4l2sink = GST_V4L2SINK (bsink);
 717   GstV4l2Buffer *v4l2buf;
 718
 719   if (v4l2sink->v4l2object->vcap.capabilities & V4L2_CAP_STREAMING) {
 720
 721     /* initialize the buffer pool if not initialized yet (first buffer): */
 722     if (G_UNLIKELY (!v4l2sink->pool)) {
 723
 724       /* set_caps() might not be called yet.. so just to make sure: */
 725       if (!gst_v4l2sink_set_caps (bsink, caps)) {
 726         return GST_FLOW_ERROR;
 727       }
 728
 729       GST_V4L2_CHECK_OPEN (v4l2sink->v4l2object);
 730
 731       if (!(v4l2sink->pool = gst_v4l2_buffer_pool_new (GST_ELEMENT (v4l2sink),
 732                   v4l2sink->v4l2object->video_fd,
 733                   v4l2sink->num_buffers, caps, FALSE,
 734                   V4L2_BUF_TYPE_VIDEO_OUTPUT))) {
 735         return GST_FLOW_ERROR;
 736       }
 737
 738       gst_v4l2sink_sync_overlay_fields (v4l2sink);
 739       gst_v4l2sink_sync_crop_fields (v4l2sink);
 740
 741 #ifdef HAVE_XVIDEO
 742       gst_v4l2_xoverlay_prepare_xwindow_id (v4l2sink->v4l2object, TRUE);
 743 #endif
 744
 745       v4l2sink->state = STATE_PENDING_STREAMON;
 746
 747       GST_INFO_OBJECT (v4l2sink, "outputting buffers via mmap()");
 748
 749       if (v4l2sink->num_buffers != v4l2sink->pool->buffer_count) {
 750         v4l2sink->num_buffers = v4l2sink->pool->buffer_count;
 751         g_object_notify (G_OBJECT (v4l2sink), "queue-size");
 752       }
 753     }
 754
 755     v4l2buf = gst_v4l2_buffer_pool_get (v4l2sink->pool, TRUE);
 756
 757     if (G_LIKELY (v4l2buf)) {
 758       GST_DEBUG_OBJECT (v4l2sink, "allocated buffer: %p", v4l2buf);
 759       *buf = GST_BUFFER (v4l2buf);
 760       return GST_FLOW_OK;
 761     } else {
 762       GST_DEBUG_OBJECT (v4l2sink, "failed to allocate buffer");
 763       return GST_FLOW_ERROR;
 764     }
 765
 766   } else {
 767     GST_ERROR_OBJECT (v4l2sink, "only supporting streaming mode for now...");
 768     return GST_FLOW_ERROR;
 769   }
 770 }
 771
 772 /* called after A/V sync to render frame */
 773 static GstFlowReturn
 774 gst_v4l2sink_show_frame (GstBaseSink * bsink, GstBuffer * buf)
 775 {
 776   GstV4l2Sink *v4l2sink = GST_V4L2SINK (bsink);
 777   GstBuffer *newbuf = NULL;
 778
 779   GST_DEBUG_OBJECT (v4l2sink, "render buffer: %p", buf);
 780
 781   if (!GST_IS_V4L2_BUFFER (buf)) {
 782     GstFlowReturn ret;
 783
 784     /* special case check for sub-buffers:  In certain cases, places like
 785      * GstBaseTransform, which might check that the buffer is writable
 786      * before copying metadata, timestamp, and such, will find that the
 787      * buffer has more than one reference to it.  In these cases, they
 788      * will create a sub-buffer with an offset=0 and length equal to the
 789      * original buffer size.
 790      *
 791      * This could happen in two scenarios: (1) a tee in the pipeline, and
 792      * (2) because the refcnt is incremented in gst_mini_object_free()
 793      * before the finalize function is called, and decremented after it
 794      * returns..  but returning this buffer to the buffer pool in the
 795      * finalize function, could wake up a thread blocked in _buffer_alloc()
 796      * which could run and get a buffer w/ refcnt==2 before the thread
 797      * originally unref'ing the buffer returns from finalize function and
 798      * decrements the refcnt back to 1!
 799      */
 800     if (buf->parent &&
 801         (GST_BUFFER_DATA (buf) == GST_BUFFER_DATA (buf->parent)) &&
 802         (GST_BUFFER_SIZE (buf) == GST_BUFFER_SIZE (buf->parent))) {
 803       GST_DEBUG_OBJECT (v4l2sink, "I have a sub-buffer!");
 804       return gst_v4l2sink_show_frame (bsink, buf->parent);
 805     }
 806
 807     GST_DEBUG_OBJECT (v4l2sink, "slow-path.. I got a %s so I need to memcpy",
 808         g_type_name (G_OBJECT_TYPE (buf)));
 809
 810     ret = gst_v4l2sink_buffer_alloc (bsink,
 811         GST_BUFFER_OFFSET (buf), GST_BUFFER_SIZE (buf), GST_BUFFER_CAPS (buf),
 812         &newbuf);
 813
 814     if (GST_FLOW_OK != ret) {
 815       GST_DEBUG_OBJECT (v4l2sink,
 816           "dropping frame!  Consider increasing 'queue-size' property!");
 817       return GST_FLOW_OK;
 818     }
 819
 820     memcpy (GST_BUFFER_DATA (newbuf),
 821         GST_BUFFER_DATA (buf),
 822         MIN (GST_BUFFER_SIZE (newbuf), GST_BUFFER_SIZE (buf)));
 823
 824     GST_DEBUG_OBJECT (v4l2sink, "render copied buffer: %p", newbuf);
 825
 826     buf = newbuf;
 827   }
 828
 829   if (!gst_v4l2_buffer_pool_qbuf (v4l2sink->pool, GST_V4L2_BUFFER (buf))) {
 830     return GST_FLOW_ERROR;
 831   }
 832   if (v4l2sink->state == STATE_PENDING_STREAMON) {
 833     if (!gst_v4l2_object_start_streaming (v4l2sink->v4l2object)) {
 834       return GST_FLOW_ERROR;
 835     }
 836     v4l2sink->state = STATE_STREAMING;
 837   }
 838
 839   if (!newbuf) {
 840     gst_buffer_ref (buf);
 841   }
 842
 843   /* if the driver has more than one buffer, ie. more than just the one we
 844    * just queued, then dequeue one immediately to make it available via
 845    * _buffer_alloc():
 846    */
 847   if (gst_v4l2_buffer_pool_available_buffers (v4l2sink->pool) >
 848       v4l2sink->min_queued_bufs) {
 849     GstV4l2Buffer *v4l2buf = gst_v4l2_buffer_pool_dqbuf (v4l2sink->pool);
 850
 851     /* note: if we get a buf, we don't want to use it directly (because
 852      * someone else could still hold a ref).. but instead we release our
 853      * reference to it, and if no one else holds a ref it will be returned
 854      * to the pool of available buffers..  and if not, we keep looping.
 855      */
 856     if (v4l2buf) {
 857       gst_buffer_unref (GST_BUFFER (v4l2buf));
 858     }
 859   }
 860
 861   return GST_FLOW_OK;
 862 }