sys/v4l/gstv4lmjpegsrc.c

   1 /* GStreamer
   2  *
   3  * gstv4lmjpegsrc.c: hardware MJPEG video source plugin
   4  *
   5  * Copyright (C) 2001-2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include <config.h>
  25 #endif
  26
  27 #include <string.h>
  28 #include "v4lmjpegsrc_calls.h"
  29
  30 GST_DEBUG_CATEGORY (v4lmjpegsrc_debug);
  31 #define GST_CAT_DEFAULT v4lmjpegsrc_debug
  32
  33 /* elementfactory information */
  34 static GstElementDetails gst_v4lmjpegsrc_details =
  35 GST_ELEMENT_DETAILS ("Video (video4linux/MJPEG) Source",
  36     "Source/Video",
  37     "Reads MJPEG-encoded frames from a zoran MJPEG/video4linux device",
  38     "Ronald Bultje <rbultje@ronald.bitfreak.net>");
  39
  40 /* V4lMjpegSrc signals and args */
  41 enum
  42 {
  43   SIGNAL_FRAME_CAPTURE,
  44   SIGNAL_FRAME_DROP,
  45   SIGNAL_FRAME_INSERT,
  46   SIGNAL_FRAME_LOST,
  47   LAST_SIGNAL
  48 };
  49
  50 /* arguments */
  51 enum
  52 {
  53   ARG_0,
  54 #if 0
  55   ARG_X_OFFSET,
  56   ARG_Y_OFFSET,
  57   ARG_F_WIDTH,
  58   ARG_F_HEIGHT,
  59   /* normally, we would want to use subframe capture, however,
  60    * for the time being it's easier if we disable it first */
  61 #endif
  62   ARG_QUALITY,
  63   ARG_NUMBUFS,
  64   ARG_BUFSIZE,
  65   ARG_USE_FIXED_FPS
  66 };
  67
  68 GST_FORMATS_FUNCTION (GstPad *, gst_v4lmjpegsrc_get_formats,
  69     GST_FORMAT_TIME, GST_FORMAT_DEFAULT);
  70 GST_QUERY_TYPE_FUNCTION (GstPad *, gst_v4lmjpegsrc_get_query_types,
  71     GST_QUERY_POSITION);
  72
  73 /* init functions */
  74 static void gst_v4lmjpegsrc_base_init (gpointer g_class);
  75 static void gst_v4lmjpegsrc_class_init (GstV4lMjpegSrcClass * klass);
  76 static void gst_v4lmjpegsrc_init (GstV4lMjpegSrc * v4lmjpegsrc);
  77
  78 /* pad/info functions */
  79 static gboolean gst_v4lmjpegsrc_src_convert (GstPad * pad,
  80     GstFormat src_format,
  81     gint64 src_value, GstFormat * dest_format, gint64 * dest_value);
  82 static gboolean gst_v4lmjpegsrc_src_query (GstPad * pad,
  83     GstQueryType type, GstFormat * format, gint64 * value);
  84
  85 /* buffer functions */
  86 static GstPadLinkReturn gst_v4lmjpegsrc_srcconnect (GstPad * pad,
  87     const GstCaps * caps);
  88 static GstData *gst_v4lmjpegsrc_get (GstPad * pad);
  89 static GstCaps *gst_v4lmjpegsrc_getcaps (GstPad * pad);
  90
  91 /* get/set params */
  92 static void gst_v4lmjpegsrc_set_property (GObject * object,
  93     guint prop_id, const GValue * value, GParamSpec * pspec);
  94 static void gst_v4lmjpegsrc_get_property (GObject * object,
  95     guint prop_id, GValue * value, GParamSpec * pspec);
  96
  97 /* set_clock function for A/V sync */
  98 static void gst_v4lmjpegsrc_set_clock (GstElement * element, GstClock * clock);
  99
 100 /* state handling */
 101 static GstStateChangeReturn gst_v4lmjpegsrc_change_state (GstElement * element);
 102
 103 /* requeue buffer after use */
 104 static void gst_v4lmjpegsrc_buffer_free (GstBuffer * buffer);
 105
 106 static GstElementClass *parent_class = NULL;
 107 static guint gst_v4lmjpegsrc_signals[LAST_SIGNAL] = { 0 };
 108
 109
 110 GType
 111 gst_v4lmjpegsrc_get_type (void)
 112 {
 113   static GType v4lmjpegsrc_type = 0;
 114
 115   if (!v4lmjpegsrc_type) {
 116     static const GTypeInfo v4lmjpegsrc_info = {
 117       sizeof (GstV4lMjpegSrcClass),
 118       gst_v4lmjpegsrc_base_init,
 119       NULL,
 120       (GClassInitFunc) gst_v4lmjpegsrc_class_init,
 121       NULL,
 122       NULL,
 123       sizeof (GstV4lMjpegSrc),
 124       0,
 125       (GInstanceInitFunc) gst_v4lmjpegsrc_init,
 126       NULL
 127     };
 128
 129     v4lmjpegsrc_type =
 130         g_type_register_static (GST_TYPE_V4LELEMENT, "GstV4lMjpegSrc",
 131         &v4lmjpegsrc_info, 0);
 132   }
 133   return v4lmjpegsrc_type;
 134 }
 135
 136
 137 static void
 138 gst_v4lmjpegsrc_base_init (gpointer g_class)
 139 {
 140   static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE ("src",
 141       GST_PAD_SRC,
 142       GST_PAD_ALWAYS,
 143       GST_STATIC_CAPS ("image/jpeg, "
 144           "width = (int) [ 0, MAX ], "
 145           "height = (int) [ 0, MAX ], " "framerate = (fraction) [ 0, MAX ]")
 146       );
 147   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 148
 149   gst_element_class_set_details (gstelement_class, &gst_v4lmjpegsrc_details);
 150
 151   gst_element_class_add_pad_template (gstelement_class,
 152       gst_static_pad_template_get (&src_template));
 153 }
 154 static void
 155 gst_v4lmjpegsrc_class_init (GstV4lMjpegSrcClass * klass)
 156 {
 157   GObjectClass *gobject_class;
 158   GstElementClass *gstelement_class;
 159
 160   gobject_class = (GObjectClass *) klass;
 161   gstelement_class = (GstElementClass *) klass;
 162
 163   parent_class = g_type_class_peek_parent (klass);
 164
 165 #if 0
 166   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_X_OFFSET,
 167       g_param_spec_int ("x_offset", "x_offset", "x_offset",
 168           G_MININT, G_MAXINT, 0, G_PARAM_WRITABLE));
 169   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_Y_OFFSET,
 170       g_param_spec_int ("y_offset", "y_offset", "y_offset",
 171           G_MININT, G_MAXINT, 0, G_PARAM_WRITABLE));
 172   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_F_WIDTH,
 173       g_param_spec_int ("frame_width", "frame_width", "frame_width",
 174           G_MININT, G_MAXINT, 0, G_PARAM_WRITABLE));
 175   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_F_HEIGHT,
 176       g_param_spec_int ("frame_height", "frame_height", "frame_height",
 177           G_MININT, G_MAXINT, 0, G_PARAM_WRITABLE));
 178 #endif
 179
 180   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_QUALITY,
 181       g_param_spec_int ("quality", "Quality", "JPEG frame quality",
 182           1, 100, 50, G_PARAM_READWRITE));
 183
 184   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_NUMBUFS,
 185       g_param_spec_int ("num_buffers", "Num Buffers", "Number of Buffers",
 186           1, 256, 64, G_PARAM_READWRITE));
 187   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_BUFSIZE,
 188       g_param_spec_int ("buffer_size", "Buffer Size", "Size of buffers",
 189           0, 512 * 1024, 128 * 1024, G_PARAM_READABLE));
 190
 191   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_USE_FIXED_FPS,
 192       g_param_spec_boolean ("use_fixed_fps", "Use Fixed FPS",
 193           "Drop/Insert frames to reach a certain FPS (TRUE) "
 194           "or adapt FPS to suit the number of grabbed frames",
 195           TRUE, G_PARAM_READWRITE));
 196
 197   /* signals */
 198   gst_v4lmjpegsrc_signals[SIGNAL_FRAME_CAPTURE] =
 199       g_signal_new ("frame-capture", G_TYPE_FROM_CLASS (klass),
 200       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstV4lMjpegSrcClass, frame_capture),
 201       NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 202   gst_v4lmjpegsrc_signals[SIGNAL_FRAME_DROP] =
 203       g_signal_new ("frame-drop", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 204       G_STRUCT_OFFSET (GstV4lMjpegSrcClass, frame_drop), NULL, NULL,
 205       g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 206   gst_v4lmjpegsrc_signals[SIGNAL_FRAME_INSERT] =
 207       g_signal_new ("frame-insert", G_TYPE_FROM_CLASS (klass),
 208       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GstV4lMjpegSrcClass, frame_insert),
 209       NULL, NULL, g_cclosure_marshal_VOID__VOID, G_TYPE_NONE, 0);
 210   gst_v4lmjpegsrc_signals[SIGNAL_FRAME_LOST] =
 211       g_signal_new ("frame-lost", G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST,
 212       G_STRUCT_OFFSET (GstV4lMjpegSrcClass, frame_lost), NULL, NULL,
 213       g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 214
 215   GST_DEBUG_CATEGORY_INIT (v4lmjpegsrc_debug, "v4lmjpegsrc", 0,
 216       "V4L MJPEG source element");
 217   gobject_class->set_property = gst_v4lmjpegsrc_set_property;
 218   gobject_class->get_property = gst_v4lmjpegsrc_get_property;
 219
 220   gstelement_class->change_state = gst_v4lmjpegsrc_change_state;
 221
 222   gstelement_class->set_clock = gst_v4lmjpegsrc_set_clock;
 223 }
 224
 225
 226 static void
 227 gst_v4lmjpegsrc_init (GstV4lMjpegSrc * v4lmjpegsrc)
 228 {
 229   GstElementClass *klass = GST_ELEMENT_GET_CLASS (v4lmjpegsrc);
 230
 231   GST_OBJECT_FLAG_SET (GST_ELEMENT (v4lmjpegsrc), GST_ELEMENT_THREAD_SUGGESTED);
 232
 233   v4lmjpegsrc->srcpad =
 234       gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
 235           "src"), "src");
 236   gst_element_add_pad (GST_ELEMENT (v4lmjpegsrc), v4lmjpegsrc->srcpad);
 237
 238   gst_pad_set_get_function (v4lmjpegsrc->srcpad, gst_v4lmjpegsrc_get);
 239   gst_pad_set_getcaps_function (v4lmjpegsrc->srcpad, gst_v4lmjpegsrc_getcaps);
 240   gst_pad_set_link_function (v4lmjpegsrc->srcpad, gst_v4lmjpegsrc_srcconnect);
 241   gst_pad_set_convert_function (v4lmjpegsrc->srcpad,
 242       gst_v4lmjpegsrc_src_convert);
 243   gst_pad_set_formats_function (v4lmjpegsrc->srcpad,
 244       gst_v4lmjpegsrc_get_formats);
 245   gst_pad_set_query_function (v4lmjpegsrc->srcpad, gst_v4lmjpegsrc_src_query);
 246   gst_pad_set_query_type_function (v4lmjpegsrc->srcpad,
 247       gst_v4lmjpegsrc_get_query_types);
 248
 249 #if 0
 250   v4lmjpegsrc->frame_width = 0;
 251   v4lmjpegsrc->frame_height = 0;
 252   v4lmjpegsrc->x_offset = -1;
 253   v4lmjpegsrc->y_offset = -1;
 254 #endif
 255
 256   v4lmjpegsrc->quality = 50;
 257
 258   v4lmjpegsrc->numbufs = 64;
 259
 260   /* no clock */
 261   v4lmjpegsrc->clock = NULL;
 262
 263   /* fps */
 264   v4lmjpegsrc->use_fixed_fps = TRUE;
 265
 266   v4lmjpegsrc->is_capturing = FALSE;
 267 }
 268
 269
 270 static gboolean
 271 gst_v4lmjpegsrc_get_fps (GstV4lMjpegSrc * v4lmjpegsrc, GValue * fps)
 272 {
 273   gint norm;
 274
 275   g_return_val_if_fail (GST_VALUE_HOLDS_FRACTION (fps), FALSE);
 276
 277   if (!v4lmjpegsrc->use_fixed_fps &&
 278       v4lmjpegsrc->clock != NULL && v4lmjpegsrc->handled > 0) {
 279     /* try to get time from clock master and calculate fps */
 280     GstClockTime time =
 281         gst_clock_get_time (v4lmjpegsrc->clock) - v4lmjpegsrc->substract_time;
 282     return v4lmjpegsrc->handled * GST_SECOND / time;
 283   }
 284
 285   /* if that failed ... */
 286
 287   if (!GST_V4L_IS_OPEN (GST_V4LELEMENT (v4lmjpegsrc)))
 288     return FALSE;
 289
 290   if (!gst_v4l_get_chan_norm (GST_V4LELEMENT (v4lmjpegsrc), NULL, &norm))
 291     return FALSE;
 292
 293   if (norm == VIDEO_MODE_NTSC)
 294     gst_value_set_fraction (fps, 30000, 1001);
 295   else
 296     gst_value_set_fraction (fps, 25, 1);
 297
 298   return TRUE;
 299 }
 300
 301 static gboolean
 302 gst_v4lmjpegsrc_src_convert (GstPad * pad,
 303     GstFormat src_format,
 304     gint64 src_value, GstFormat * dest_format, gint64 * dest_value)
 305 {
 306   GstV4lMjpegSrc *v4lmjpegsrc;
 307   GValue fps = { 0 };
 308   gboolean result = TRUE;
 309
 310   v4lmjpegsrc = GST_V4LMJPEGSRC (gst_pad_get_parent (pad));
 311
 312   g_value_init (&fps, GST_VALUE_FRACTION);
 313   if (!gst_v4lmjpegsrc_get_fps (v4lmjpegsrc, &fps))
 314     return FALSE;
 315
 316   switch (src_format) {
 317     case GST_FORMAT_TIME:
 318       switch (*dest_format) {
 319         case GST_FORMAT_DEFAULT:
 320           *dest_value = gst_util_uint64_scale (src_value,
 321               gst_value_get_fraction_numerator (&fps),
 322               gst_value_get_fraction_denominator (&fps) * GST_SECOND);
 323           break;
 324         default:
 325           result = FALSE;
 326       }
 327       break;
 328
 329     case GST_FORMAT_DEFAULT:
 330       switch (*dest_format) {
 331         case GST_FORMAT_TIME:
 332           *dest_value = src_value * gst_util_uint64_scale_int (GST_SECOND,
 333               gst_value_get_fraction_denominator (&fps),
 334               gst_value_get_fraction_numerator (&fps));
 335           break;
 336         default:
 337           result = FALSE;
 338       }
 339       break;
 340
 341     default:
 342       result = FALSE;
 343   }
 344
 345   g_value_unset (&fps);
 346   return result;
 347 }
 348
 349 static gboolean
 350 gst_v4lmjpegsrc_src_query (GstPad * pad,
 351     GstQueryType type, GstFormat * format, gint64 * value)
 352 {
 353   GstV4lMjpegSrc *v4lmjpegsrc = GST_V4LMJPEGSRC (gst_pad_get_parent (pad));
 354   gboolean res = TRUE;
 355   GValue fps = { 0 };
 356
 357   g_value_init (&fps, GST_VALUE_FRACTION);
 358   if (!gst_v4lmjpegsrc_get_fps (v4lmjpegsrc, &fps))
 359     return FALSE;
 360
 361   switch (type) {
 362     case GST_QUERY_POSITION:
 363       switch (*format) {
 364         case GST_FORMAT_TIME:
 365           *value = v4lmjpegsrc->handled * gst_util_uint64_scale_int (GST_SECOND,
 366               gst_value_get_fraction_denominator (&fps),
 367               gst_value_get_fraction_numerator (&fps));
 368           break;
 369         case GST_FORMAT_DEFAULT:
 370           *value = v4lmjpegsrc->handled;
 371           break;
 372         default:
 373           res = FALSE;
 374           break;
 375       }
 376       break;
 377     default:
 378       res = FALSE;
 379       break;
 380   }
 381
 382   g_value_unset (&fps);
 383   return res;
 384 }
 385
 386 static inline gulong
 387 calc_bufsize (int hor_dec, int ver_dec)
 388 {
 389   guint8 div = hor_dec * ver_dec;
 390   guint32 num = (1024 * 512) / (div);
 391   guint32 result = 2;
 392
 393   num--;
 394   while (num) {
 395     num >>= 1;
 396     result <<= 1;
 397   }
 398
 399   if (result > (512 * 1024))
 400     return (512 * 1024);
 401   if (result < 8192)
 402     return 8192;
 403   return result;
 404 }
 405
 406 static GstPadLinkReturn
 407 gst_v4lmjpegsrc_srcconnect (GstPad * pad, const GstCaps * caps)
 408 {
 409   GstV4lMjpegSrc *v4lmjpegsrc = GST_V4LMJPEGSRC (gst_pad_get_parent (pad));
 410   gint hor_dec, ver_dec;
 411   gint w, h;
 412   gint max_w = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxwidth,
 413       max_h = GST_V4LELEMENT (v4lmjpegsrc)->vcap.maxheight;
 414   gulong bufsize;
 415   GstStructure *structure;
 416   gboolean was_capturing;
 417
 418   /* in case the buffers are active (which means that we already
 419    * did capsnego before and didn't clean up), clean up anyways */
 420   if ((was_capturing = v4lmjpegsrc->is_capturing)) {
 421     if (!gst_v4lmjpegsrc_capture_stop (v4lmjpegsrc))
 422       return GST_PAD_LINK_REFUSED;
 423   }
 424   if (GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc))) {
 425     if (!gst_v4lmjpegsrc_capture_deinit (v4lmjpegsrc))
 426       return GST_PAD_LINK_REFUSED;
 427   } else if (!GST_V4L_IS_OPEN (GST_V4LELEMENT (v4lmjpegsrc))) {
 428     return GST_PAD_LINK_DELAYED;
 429   }
 430
 431   /* Note: basically, we don't give a damn about the opposite caps here.
 432    * that might seem odd, but it isn't. we know that the opposite caps is
 433    * either NULL or has mime type image/jpeg, and in both cases, we'll set
 434    * our own mime type back and it'll work. Other properties are to be set
 435    * by the src, not by the opposite caps */
 436
 437   structure = gst_caps_get_structure (caps, 0);
 438   gst_structure_get_int (structure, "width", &w);
 439   gst_structure_get_int (structure, "height", &h);
 440
 441   /* figure out decimation */
 442   if (w >= max_w) {
 443     hor_dec = 1;
 444   } else if (w * 2 >= max_w) {
 445     hor_dec = 2;
 446   } else {
 447     hor_dec = 4;
 448   }
 449   if (h >= max_h) {
 450     ver_dec = 1;
 451   } else if (h * 2 >= max_h) {
 452     ver_dec = 2;
 453   } else {
 454     ver_dec = 4;
 455   }
 456
 457   /* calculate bufsize */
 458   bufsize = calc_bufsize (hor_dec, ver_dec);
 459
 460   /* set buffer info */
 461   if (!gst_v4lmjpegsrc_set_buffer (v4lmjpegsrc, v4lmjpegsrc->numbufs, bufsize)) {
 462     return GST_PAD_LINK_REFUSED;
 463   }
 464
 465   /* set capture parameters and mmap the buffers */
 466   if (hor_dec == ver_dec) {
 467     if (!gst_v4lmjpegsrc_set_capture (v4lmjpegsrc,
 468             hor_dec, v4lmjpegsrc->quality)) {
 469       return GST_PAD_LINK_REFUSED;
 470     }
 471   } else {
 472     if (!gst_v4lmjpegsrc_set_capture_m (v4lmjpegsrc,
 473             0, 0, max_w, max_h, hor_dec, ver_dec, v4lmjpegsrc->quality)) {
 474       return GST_PAD_LINK_REFUSED;
 475     }
 476   }
 477 #if 0
 478   if (!v4lmjpegsrc->frame_width && !v4lmjpegsrc->frame_height &&
 479       v4lmjpegsrc->x_offset < 0 && v4lmjpegsrc->y_offset < 0 &&
 480       v4lmjpegsrc->horizontal_decimation == v4lmjpegsrc->vertical_decimation) {
 481     if (!gst_v4lmjpegsrc_set_capture (v4lmjpegsrc,
 482             v4lmjpegsrc->horizontal_decimation, v4lmjpegsrc->quality))
 483       return GST_PAD_LINK_REFUSED;
 484   } else {
 485     if (!gst_v4lmjpegsrc_set_capture_m (v4lmjpegsrc,
 486             v4lmjpegsrc->x_offset, v4lmjpegsrc->y_offset,
 487             v4lmjpegsrc->frame_width, v4lmjpegsrc->frame_height,
 488             v4lmjpegsrc->horizontal_decimation,
 489             v4lmjpegsrc->vertical_decimation, v4lmjpegsrc->quality))
 490       return GST_PAD_LINK_REFUSED;
 491   }
 492 #endif
 493
 494   if (!gst_v4lmjpegsrc_capture_init (v4lmjpegsrc))
 495     return GST_PAD_LINK_REFUSED;
 496
 497   if (was_capturing || GST_STATE (v4lmjpegsrc) == GST_STATE_PLAYING)
 498     if (!gst_v4lmjpegsrc_capture_start (v4lmjpegsrc))
 499       return GST_PAD_LINK_REFUSED;
 500
 501   return GST_PAD_LINK_OK;
 502 }
 503
 504
 505 static GstData *
 506 gst_v4lmjpegsrc_get (GstPad * pad)
 507 {
 508   GstV4lMjpegSrc *v4lmjpegsrc;
 509   GstBuffer *buf;
 510   gint num;
 511   GValue fps = { 0 };
 512   GstClockTime duration;
 513   GstClockTime cur_frame_time;
 514
 515   g_return_val_if_fail (pad != NULL, NULL);
 516
 517   v4lmjpegsrc = GST_V4LMJPEGSRC (gst_pad_get_parent (pad));
 518
 519   if (v4lmjpegsrc->use_fixed_fps) {
 520     g_value_init (&fps, GST_VALUE_FRACTION);
 521     duration = gst_util_uint64_scale_int (GST_SECOND,
 522         gst_value_get_fraction_denominator (&fps),
 523         gst_value_get_fraction_numerator (&fps));
 524     cur_frame_time =
 525         gst_util_uint64_scale_int (v4lmjpegsrc->handled * GST_SECOND,
 526         gst_value_get_fraction_denominator (&fps),
 527         gst_value_get_fraction_numerator (&fps));
 528
 529
 530     if (!gst_v4lmjpegsrc_get_fps (v4lmjpegsrc, &fps)) {
 531       g_value_unset (&fps);
 532       return NULL;
 533     }
 534   }
 535
 536   if (v4lmjpegsrc->need_writes > 0) {
 537     /* use last frame */
 538     num = v4lmjpegsrc->last_frame;
 539     v4lmjpegsrc->need_writes--;
 540   } else if (v4lmjpegsrc->clock && v4lmjpegsrc->use_fixed_fps) {
 541     GstClockTime time;
 542     gboolean have_frame = FALSE;
 543
 544     do {
 545       /* by default, we use the frame once */
 546       v4lmjpegsrc->need_writes = 1;
 547
 548       /* grab a frame from the device */
 549       if (!gst_v4lmjpegsrc_grab_frame (v4lmjpegsrc, &num,
 550               &v4lmjpegsrc->last_size))
 551         return NULL;
 552
 553       v4lmjpegsrc->last_frame = num;
 554       time = GST_TIMEVAL_TO_TIME (v4lmjpegsrc->bsync.timestamp) -
 555           v4lmjpegsrc->substract_time;
 556
 557       /* first check whether we lost any frames according to the device */
 558       if (v4lmjpegsrc->last_seq != 0) {
 559         if (v4lmjpegsrc->bsync.seq - v4lmjpegsrc->last_seq > 1) {
 560           v4lmjpegsrc->need_writes =
 561               v4lmjpegsrc->bsync.seq - v4lmjpegsrc->last_seq;
 562           g_signal_emit (G_OBJECT (v4lmjpegsrc),
 563               gst_v4lmjpegsrc_signals[SIGNAL_FRAME_LOST], 0,
 564               v4lmjpegsrc->bsync.seq - v4lmjpegsrc->last_seq - 1);
 565         }
 566       }
 567       v4lmjpegsrc->last_seq = v4lmjpegsrc->bsync.seq;
 568
 569       /* decide how often we're going to write the frame - set
 570        * v4lmjpegsrc->need_writes to (that-1) and have_frame to TRUE
 571        * if we're going to write it - else, just continue.
 572        *
 573        * time is generally the system or audio clock. Let's
 574        * say that we've written one second of audio, then we want
 575        * to have written one second of video too, within the same
 576        * timeframe. This means that if time - begin_time = X sec,
 577        * we want to have written X*fps frames. If we've written
 578        * more - drop, if we've written less - dup... */
 579       if (cur_frame_time - time > 1.5 * duration) {
 580         /* yo dude, we've got too many frames here! Drop! DROP! */
 581         v4lmjpegsrc->need_writes--;     /* -= (v4lmjpegsrc->handled - (time / fps)); */
 582         g_signal_emit (G_OBJECT (v4lmjpegsrc),
 583             gst_v4lmjpegsrc_signals[SIGNAL_FRAME_DROP], 0);
 584       } else if (cur_frame_time - time < -1.5 * duration) {
 585         /* this means we're lagging far behind */
 586         v4lmjpegsrc->need_writes++;     /* += ((time / fps) - v4lmjpegsrc->handled); */
 587         g_signal_emit (G_OBJECT (v4lmjpegsrc),
 588             gst_v4lmjpegsrc_signals[SIGNAL_FRAME_INSERT], 0);
 589       }
 590
 591       if (v4lmjpegsrc->need_writes > 0) {
 592         have_frame = TRUE;
 593         v4lmjpegsrc->use_num_times[num] = v4lmjpegsrc->need_writes;
 594         v4lmjpegsrc->need_writes--;
 595       } else {
 596         gst_v4lmjpegsrc_requeue_frame (v4lmjpegsrc, num);
 597       }
 598     } while (!have_frame);
 599   } else {
 600     /* grab a frame from the device */
 601     if (!gst_v4lmjpegsrc_grab_frame (v4lmjpegsrc, &num,
 602             &v4lmjpegsrc->last_size))
 603       return NULL;
 604
 605     v4lmjpegsrc->use_num_times[num] = 1;
 606   }
 607
 608   buf = gst_buffer_new ();
 609   GST_BUFFER_FREE_DATA_FUNC (buf) = gst_v4lmjpegsrc_buffer_free;
 610   GST_BUFFER_PRIVATE (buf) = v4lmjpegsrc;
 611   GST_BUFFER_DATA (buf) = gst_v4lmjpegsrc_get_buffer (v4lmjpegsrc, num);
 612   GST_BUFFER_SIZE (buf) = v4lmjpegsrc->last_size;
 613   GST_BUFFER_MAXSIZE (buf) = v4lmjpegsrc->breq.size;
 614   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_READONLY);
 615   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_DONTFREE);
 616   if (v4lmjpegsrc->use_fixed_fps)
 617     GST_BUFFER_TIMESTAMP (buf) = cur_frame_time;
 618   else                          /* calculate time based on our own clock */
 619     GST_BUFFER_TIMESTAMP (buf) =
 620         GST_TIMEVAL_TO_TIME (v4lmjpegsrc->bsync.timestamp) -
 621         v4lmjpegsrc->substract_time;
 622
 623   v4lmjpegsrc->handled++;
 624   g_signal_emit (G_OBJECT (v4lmjpegsrc),
 625       gst_v4lmjpegsrc_signals[SIGNAL_FRAME_CAPTURE], 0);
 626
 627   return GST_DATA (buf);
 628 }
 629
 630
 631 static GstCaps *
 632 gst_v4lmjpegsrc_getcaps (GstPad * pad)
 633 {
 634   GstV4lMjpegSrc *v4lmjpegsrc = GST_V4LMJPEGSRC (gst_pad_get_parent (pad));
 635   struct video_capability *vcap = &GST_V4LELEMENT (v4lmjpegsrc)->vcap;
 636   GstCaps *caps;
 637   GstStructure *str;
 638   gint i;
 639   GValue w = { 0 }, h = {
 640   0}, w1 = {
 641   0}, h1 = {
 642   0}, fps = {
 643   0};
 644
 645   if (!GST_V4L_IS_OPEN (GST_V4LELEMENT (v4lmjpegsrc))) {
 646     return gst_caps_copy (gst_pad_get_pad_template_caps (pad));
 647   }
 648
 649   g_value_init (&fps, GST_TYPE_FRACTION);
 650   gst_return_val_if_fail (gst_v4lmjpegsrc_get_fps (v4lmjpegsrc, &fps), NULL);
 651
 652   caps = gst_caps_new_simple ("image/jpeg", NULL);
 653   str = gst_caps_get_structure (caps, 0);
 654   gst_structure_set_value (str, "framerate", &fps);
 655   g_value_unset (&fps);
 656
 657   g_value_init (&w, GST_TYPE_LIST);
 658   g_value_init (&h, GST_TYPE_LIST);
 659   g_value_init (&w1, G_TYPE_INT);
 660   g_value_init (&h1, G_TYPE_INT);
 661   for (i = 0; i <= 2; i++) {
 662     g_value_set_int (&w1, vcap->maxwidth / (1 << i));
 663     g_value_set_int (&h1, vcap->maxheight / (1 << i));
 664     gst_value_list_append_value (&w, &w1);
 665     gst_value_list_append_value (&h, &h1);
 666   }
 667   g_value_unset (&h1);
 668   g_value_unset (&w1);
 669   gst_structure_set_value (str, "width", &w);
 670   gst_structure_set_value (str, "height", &h);
 671   g_value_unset (&w);
 672   g_value_unset (&h);
 673
 674   return caps;
 675 }
 676
 677
 678 static void
 679 gst_v4lmjpegsrc_set_property (GObject * object,
 680     guint prop_id, const GValue * value, GParamSpec * pspec)
 681 {
 682   GstV4lMjpegSrc *v4lmjpegsrc;
 683
 684   g_return_if_fail (GST_IS_V4LMJPEGSRC (object));
 685   v4lmjpegsrc = GST_V4LMJPEGSRC (object);
 686
 687   switch (prop_id) {
 688 #if 0
 689     case ARG_X_OFFSET:
 690       v4lmjpegsrc->x_offset = g_value_get_int (value);
 691       break;
 692     case ARG_Y_OFFSET:
 693       v4lmjpegsrc->y_offset = g_value_get_int (value);
 694       break;
 695     case ARG_F_WIDTH:
 696       v4lmjpegsrc->frame_width = g_value_get_int (value);
 697       break;
 698     case ARG_F_HEIGHT:
 699       v4lmjpegsrc->frame_height = g_value_get_int (value);
 700       break;
 701 #endif
 702     case ARG_QUALITY:
 703       v4lmjpegsrc->quality = g_value_get_int (value);
 704       break;
 705     case ARG_NUMBUFS:
 706       v4lmjpegsrc->numbufs = g_value_get_int (value);
 707       break;
 708     case ARG_USE_FIXED_FPS:
 709       if (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc))) {
 710         v4lmjpegsrc->use_fixed_fps = g_value_get_boolean (value);
 711       }
 712       break;
 713     default:
 714       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 715       break;
 716   }
 717 }
 718
 719
 720 static void
 721 gst_v4lmjpegsrc_get_property (GObject * object,
 722     guint prop_id, GValue * value, GParamSpec * pspec)
 723 {
 724   GstV4lMjpegSrc *v4lmjpegsrc;
 725
 726   g_return_if_fail (GST_IS_V4LMJPEGSRC (object));
 727   v4lmjpegsrc = GST_V4LMJPEGSRC (object);
 728
 729   switch (prop_id) {
 730 #if 0
 731     case ARG_X_OFFSET:
 732       g_value_set_int (value, v4lmjpegsrc->x_offset);
 733       break;
 734     case ARG_Y_OFFSET:
 735       g_value_set_int (value, v4lmjpegsrc->y_offset);
 736       break;
 737     case ARG_F_WIDTH:
 738       g_value_set_int (value, v4lmjpegsrc->frame_width);
 739       break;
 740     case ARG_F_HEIGHT:
 741       g_value_set_int (value, v4lmjpegsrc->frame_height);
 742       break;
 743 #endif
 744     case ARG_QUALITY:
 745       g_value_set_int (value, v4lmjpegsrc->quality);
 746       break;
 747     case ARG_NUMBUFS:
 748       if (GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc)))
 749         g_value_set_int (value, v4lmjpegsrc->breq.count);
 750       else
 751         g_value_set_int (value, v4lmjpegsrc->numbufs);
 752       break;
 753     case ARG_BUFSIZE:
 754       g_value_set_int (value, v4lmjpegsrc->breq.size);
 755       break;
 756     case ARG_USE_FIXED_FPS:
 757       g_value_set_boolean (value, v4lmjpegsrc->use_fixed_fps);
 758       break;
 759     default:
 760       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 761       break;
 762   }
 763 }
 764
 765
 766 static GstStateChangeReturn
 767 gst_v4lmjpegsrc_change_state (GstElement * element, GstStateChange transition)
 768 {
 769   GstV4lMjpegSrc *v4lmjpegsrc;
 770   GTimeVal time;
 771
 772   g_return_val_if_fail (GST_IS_V4LMJPEGSRC (element), GST_STATE_CHANGE_FAILURE);
 773
 774   v4lmjpegsrc = GST_V4LMJPEGSRC (element);
 775
 776   switch (transition) {
 777     case GST_STATE_CHANGE_READY_TO_PAUSED:
 778       /* actual buffer set-up used to be done here - but I moved
 779        * it to capsnego itself */
 780       v4lmjpegsrc->handled = 0;
 781       v4lmjpegsrc->need_writes = 0;
 782       v4lmjpegsrc->last_frame = 0;
 783       v4lmjpegsrc->substract_time = 0;
 784       break;
 785     case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
 786       /* queue all buffer, start streaming capture */
 787       if (GST_V4LELEMENT (v4lmjpegsrc)->buffer &&
 788           !gst_v4lmjpegsrc_capture_start (v4lmjpegsrc))
 789         return GST_STATE_CHANGE_FAILURE;
 790       g_get_current_time (&time);
 791       v4lmjpegsrc->substract_time = GST_TIMEVAL_TO_TIME (time) -
 792           v4lmjpegsrc->substract_time;
 793       v4lmjpegsrc->last_seq = 0;
 794       break;
 795     case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
 796       g_get_current_time (&time);
 797       v4lmjpegsrc->substract_time = GST_TIMEVAL_TO_TIME (time) -
 798           v4lmjpegsrc->substract_time;
 799       /* de-queue all queued buffers */
 800       if (v4lmjpegsrc->is_capturing &&
 801           !gst_v4lmjpegsrc_capture_stop (v4lmjpegsrc))
 802         return GST_STATE_CHANGE_FAILURE;
 803       break;
 804     case GST_STATE_CHANGE_PAUSED_TO_READY:
 805       /* stop capturing, unmap all buffers */
 806       if (GST_V4LELEMENT (v4lmjpegsrc)->buffer &&
 807           !gst_v4lmjpegsrc_capture_deinit (v4lmjpegsrc))
 808         return GST_STATE_CHANGE_FAILURE;
 809       break;
 810   }
 811
 812   if (GST_ELEMENT_CLASS (parent_class)->change_state)
 813     return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
 814
 815   return GST_STATE_CHANGE_SUCCESS;
 816 }
 817
 818
 819 static void
 820 gst_v4lmjpegsrc_set_clock (GstElement * element, GstClock * clock)
 821 {
 822   GST_V4LMJPEGSRC (element)->clock = clock;
 823 }
 824
 825
 826 #if 0
 827 static GstBuffer *
 828 gst_v4lmjpegsrc_buffer_new (GstBufferPool * pool,
 829     guint64 offset, guint size, gpointer user_data)
 830 {
 831   GstBuffer *buffer;
 832   GstV4lMjpegSrc *v4lmjpegsrc = GST_V4LMJPEGSRC (user_data);
 833
 834   if (!GST_V4L_IS_ACTIVE (GST_V4LELEMENT (v4lmjpegsrc)))
 835     return NULL;
 836
 837   buffer = gst_buffer_new ();
 838   if (!buffer)
 839     return NULL;
 840
 841   /* TODO: add interlacing info to buffer as metadata */
 842   GST_BUFFER_MAXSIZE (buffer) = v4lmjpegsrc->breq.size;
 843   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_DONTFREE);
 844
 845   return buffer;
 846 }
 847 #endif
 848
 849 static void
 850 gst_v4lmjpegsrc_buffer_free (GstBuffer * buf)
 851 {
 852   GstV4lMjpegSrc *v4lmjpegsrc = GST_V4LMJPEGSRC (GST_BUFFER_PRIVATE (buf));
 853   int n;
 854
 855   if (gst_element_get_state (GST_ELEMENT (v4lmjpegsrc)) != GST_STATE_PLAYING)
 856     return;                     /* we've already cleaned up ourselves */
 857
 858   for (n = 0; n < v4lmjpegsrc->breq.count; n++)
 859     if (GST_BUFFER_DATA (buf) == gst_v4lmjpegsrc_get_buffer (v4lmjpegsrc, n)) {
 860       v4lmjpegsrc->use_num_times[n]--;
 861       if (v4lmjpegsrc->use_num_times[n] <= 0) {
 862         gst_v4lmjpegsrc_requeue_frame (v4lmjpegsrc, n);
 863       }
 864       break;
 865     }
 866
 867   if (n == v4lmjpegsrc->breq.count)
 868     GST_ELEMENT_ERROR (v4lmjpegsrc, RESOURCE, TOO_LAZY, (NULL),
 869         ("Couldn't find the buffer"));
 870 }