sys/v4l2/gstv4l2src.c

   1 /* G-Streamer Video4linux2 video-capture plugin
   2  * Copyright (C) 2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
   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
  24 #include <string.h>
  25 #include <sys/time.h>
  26 #include "v4l2src_calls.h"
  27 #include "gstv4l2tuner.h"
  28
  29 GST_DEBUG_CATEGORY (v4l2src_debug);
  30 #define GST_CAT_DEFAULT v4l2src_debug
  31
  32 /* elementfactory details */
  33 static GstElementDetails gst_v4l2src_details = {
  34         "Video (video4linux2) Source",
  35         "Source/Video",
  36         "Reads frames (compressed or uncompressed) from a video4linux2 device",
  37         "Ronald Bultje <rbultje@ronald.bitfreak.net>"
  38 };
  39
  40 /* V4l2Src signals and args */
  41 enum {
  42         SIGNAL_FRAME_CAPTURE,
  43         SIGNAL_FRAME_DROP,
  44         SIGNAL_FRAME_INSERT,
  45         SIGNAL_FRAME_LOST,
  46         LAST_SIGNAL
  47 };
  48
  49 /* arguments */
  50 enum {
  51         ARG_0,
  52         ARG_NUMBUFS,
  53         ARG_BUFSIZE,
  54         ARG_USE_FIXED_FPS
  55 };
  56
  57 guint32 gst_v4l2_formats[] = {
  58   /* from Linux 2.6.0 videodev2.h */
  59   V4L2_PIX_FMT_RGB332,   /*  8  RGB-3-3-2     */
  60   V4L2_PIX_FMT_RGB555,   /* 16  RGB-5-5-5     */
  61   V4L2_PIX_FMT_RGB565,   /* 16  RGB-5-6-5     */
  62   V4L2_PIX_FMT_RGB555X,  /* 16  RGB-5-5-5 BE  */
  63   V4L2_PIX_FMT_RGB565X,  /* 16  RGB-5-6-5 BE  */
  64   V4L2_PIX_FMT_BGR24,    /* 24  BGR-8-8-8     */
  65   V4L2_PIX_FMT_RGB24,    /* 24  RGB-8-8-8     */
  66   V4L2_PIX_FMT_BGR32,    /* 32  BGR-8-8-8-8   */
  67   V4L2_PIX_FMT_RGB32,    /* 32  RGB-8-8-8-8   */
  68   V4L2_PIX_FMT_GREY,     /*  8  Greyscale     */
  69   V4L2_PIX_FMT_YVU410,   /*  9  YVU 4:1:0     */
  70   V4L2_PIX_FMT_YVU420,   /* 12  YVU 4:2:0     */
  71   V4L2_PIX_FMT_YUYV,     /* 16  YUV 4:2:2     */
  72   V4L2_PIX_FMT_UYVY,     /* 16  YUV 4:2:2     */
  73   V4L2_PIX_FMT_YUV422P,  /* 16  YVU422 planar */
  74   V4L2_PIX_FMT_YUV411P,  /* 16  YVU411 planar */
  75   V4L2_PIX_FMT_Y41P,     /* 12  YUV 4:1:1     */
  76   V4L2_PIX_FMT_NV12,     /* 12  Y/CbCr 4:2:0  */
  77   V4L2_PIX_FMT_NV21,     /* 12  Y/CrCb 4:2:0  */
  78   V4L2_PIX_FMT_YUV410,   /*  9  YUV 4:1:0     */
  79   V4L2_PIX_FMT_YUV420,   /* 12  YUV 4:2:0     */
  80   V4L2_PIX_FMT_YYUV,     /* 16  YUV 4:2:2     */
  81   V4L2_PIX_FMT_HI240,    /*  8  8-bit color   */
  82   V4L2_PIX_FMT_MJPEG,    /* Motion-JPEG       */
  83   V4L2_PIX_FMT_JPEG,     /* JFIF JPEG         */
  84   V4L2_PIX_FMT_DV,       /* 1394              */
  85   V4L2_PIX_FMT_MPEG,     /* MPEG              */
  86   V4L2_PIX_FMT_WNVA      /* Winnov hw compres */
  87 };
  88 #define GST_V4L2_FORMAT_COUNT (G_N_ELEMENTS (gst_v4l2_formats))
  89
  90 GST_FORMATS_FUNCTION (GstPad *, gst_v4l2src_get_formats,
  91                       GST_FORMAT_TIME, GST_FORMAT_DEFAULT);
  92 GST_QUERY_TYPE_FUNCTION (GstPad *, gst_v4l2src_get_query_types,
  93                          GST_QUERY_POSITION);
  94
  95 /* init functions */
  96 static void                     gst_v4l2src_class_init          (gpointer         g_class,
  97                                                                  gpointer         class_data);
  98 static void                     gst_v4l2src_base_init           (gpointer         g_class);
  99 static void                     gst_v4l2src_init                (GTypeInstance *  instance,
 100                                                                  gpointer         g_class);
 101
 102 /* signal functions */
 103 static void                     gst_v4l2src_open                (GstElement      *element,
 104                                                                  const gchar     *device);
 105 static void                     gst_v4l2src_close               (GstElement      *element,
 106                                                                  const gchar     *device);
 107
 108 /* pad/buffer functions */
 109 static const GstCaps *          gst_v4l2src_get_all_caps        (void);
 110 static GstPadLinkReturn         gst_v4l2src_link                (GstPad          *pad,
 111                                                                  const GstCaps         *caps);
 112 static GstCaps *                gst_v4l2src_getcaps             (GstPad          *pad);
 113 static GstCaps *                gst_v4l2src_fixate              (GstPad *         pad,
 114                                                                  const GstCaps *  caps);
 115 static GstData *                gst_v4l2src_get                 (GstPad          *pad);
 116 static gboolean                 gst_v4l2src_src_convert         (GstPad    *pad,
 117                                                                  GstFormat  src_format,
 118                                                                  gint64     src_value,
 119                                                                  GstFormat *dest_format,
 120                                                                  gint64    *dest_value);
 121 static gboolean                 gst_v4l2src_src_query           (GstPad      *pad,
 122                                                                  GstQueryType type,
 123                                                                  GstFormat   *format,
 124                                                                  gint64      *value);
 125
 126 /* get/set params */
 127 static void     gst_v4l2src_set_property        (GObject         *object,
 128                                                  guint           prop_id,
 129                                                  const GValue    *value,
 130                                                  GParamSpec      *pspec);
 131 static void     gst_v4l2src_get_property        (GObject         *object,
 132                                                  guint           prop_id,
 133                                                  GValue          *value,
 134                                                  GParamSpec      *pspec);
 135
 136 /* state handling */
 137 static GstElementStateReturn
 138                 gst_v4l2src_change_state        (GstElement      *element);
 139
 140 /* set_clock function for A/V sync */
 141 static void     gst_v4l2src_set_clock           (GstElement     *element,
 142                                                  GstClock       *clock);
 143
 144 static GstElementClass *parent_class = NULL;
 145 static guint gst_v4l2src_signals[LAST_SIGNAL] = { 0 };
 146
 147
 148 GType
 149 gst_v4l2src_get_type (void)
 150 {
 151   static GType v4l2src_type = 0;
 152
 153   if (!v4l2src_type) {
 154     static const GTypeInfo v4l2src_info = {
 155       sizeof (GstV4l2SrcClass),
 156       gst_v4l2src_base_init,
 157       NULL,
 158       gst_v4l2src_class_init,
 159       NULL,
 160       NULL,
 161       sizeof (GstV4l2Src),
 162       0,
 163       gst_v4l2src_init,
 164       NULL
 165     };
 166     v4l2src_type = g_type_register_static(GST_TYPE_V4L2ELEMENT,
 167         "GstV4l2Src", &v4l2src_info, 0);
 168     GST_DEBUG_CATEGORY_INIT (v4l2src_debug, "v4l2src", 0, "v4l2src element");
 169   }
 170   return v4l2src_type;
 171 }
 172
 173 static void
 174 gst_v4l2src_base_init (gpointer g_class)
 175 {
 176   GstPadTemplate *template;
 177   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 178
 179   gst_element_class_set_details (gstelement_class, &gst_v4l2src_details);
 180
 181   template = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
 182       gst_caps_copy (gst_v4l2src_get_all_caps ()));
 183
 184   gst_element_class_add_pad_template (gstelement_class, template);
 185 }
 186
 187 static void
 188 gst_v4l2src_class_init (gpointer g_class, gpointer class_data)
 189 {
 190   GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
 191   GstElementClass *gstelement_class = GST_ELEMENT_CLASS (g_class);
 192   GstV4l2ElementClass *v4l2_class = GST_V4L2ELEMENT_CLASS (g_class);
 193
 194   parent_class = g_type_class_peek_parent (g_class);
 195
 196   gobject_class->set_property = gst_v4l2src_set_property;
 197   gobject_class->get_property = gst_v4l2src_get_property;
 198
 199   g_object_class_install_property(gobject_class, ARG_NUMBUFS,
 200           g_param_spec_int("num_buffers","num_buffers","num_buffers",
 201                            G_MININT,G_MAXINT,0,G_PARAM_READWRITE));
 202   g_object_class_install_property(gobject_class, ARG_BUFSIZE,
 203           g_param_spec_int("buffer_size","buffer_size","buffer_size",
 204                            G_MININT,G_MAXINT,0,G_PARAM_READABLE));
 205
 206   g_object_class_install_property(gobject_class, ARG_USE_FIXED_FPS,
 207           g_param_spec_boolean("use_fixed_fps", "Use Fixed FPS",
 208                                "Drop/Insert frames to reach a certain FPS (TRUE) "
 209                                "or adapt FPS to suit the number of frabbed frames",
 210                                TRUE, G_PARAM_READWRITE));
 211
 212   /* signals */
 213   gst_v4l2src_signals[SIGNAL_FRAME_CAPTURE] =
 214           g_signal_new("frame-capture", G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
 215                        G_STRUCT_OFFSET(GstV4l2SrcClass, frame_capture),
 216                        NULL, NULL, g_cclosure_marshal_VOID__VOID,
 217                        G_TYPE_NONE, 0);
 218   gst_v4l2src_signals[SIGNAL_FRAME_DROP] =
 219           g_signal_new("frame-drop", G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
 220                        G_STRUCT_OFFSET(GstV4l2SrcClass, frame_drop),
 221                        NULL, NULL, g_cclosure_marshal_VOID__VOID,
 222                        G_TYPE_NONE, 0);
 223   gst_v4l2src_signals[SIGNAL_FRAME_INSERT] =
 224           g_signal_new("frame_insert", G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
 225                        G_STRUCT_OFFSET(GstV4l2SrcClass, frame_insert),
 226                        NULL, NULL, g_cclosure_marshal_VOID__VOID,
 227                        G_TYPE_NONE, 0);
 228   gst_v4l2src_signals[SIGNAL_FRAME_LOST] =
 229           g_signal_new("frame-lost", G_TYPE_FROM_CLASS (g_class), G_SIGNAL_RUN_LAST,
 230                        G_STRUCT_OFFSET(GstV4l2SrcClass, frame_lost),
 231                        NULL, NULL, g_cclosure_marshal_VOID__INT,
 232                        G_TYPE_NONE, 1, G_TYPE_INT);
 233
 234   gstelement_class->change_state = gst_v4l2src_change_state;
 235
 236   v4l2_class->open = gst_v4l2src_open;
 237   v4l2_class->close = gst_v4l2src_close;
 238
 239   gstelement_class->set_clock = gst_v4l2src_set_clock;
 240 }
 241
 242
 243 static void
 244 gst_v4l2src_init (GTypeInstance *instance, gpointer g_class)
 245 {
 246   GstV4l2Src *v4l2src = GST_V4L2SRC (instance);
 247
 248   GST_FLAG_SET(GST_ELEMENT(v4l2src), GST_ELEMENT_THREAD_SUGGESTED);
 249
 250   v4l2src->srcpad = gst_pad_new_from_template(
 251       gst_element_class_get_pad_template (GST_ELEMENT_GET_CLASS (v4l2src), "src"), "src");
 252   gst_element_add_pad(GST_ELEMENT(v4l2src), v4l2src->srcpad);
 253
 254   gst_pad_set_get_function(v4l2src->srcpad, gst_v4l2src_get);
 255   gst_pad_set_link_function(v4l2src->srcpad, gst_v4l2src_link);
 256   gst_pad_set_getcaps_function (v4l2src->srcpad, gst_v4l2src_getcaps);
 257   gst_pad_set_fixate_function (v4l2src->srcpad, gst_v4l2src_fixate);
 258   gst_pad_set_convert_function (v4l2src->srcpad, gst_v4l2src_src_convert);
 259   gst_pad_set_formats_function (v4l2src->srcpad, gst_v4l2src_get_formats);
 260   gst_pad_set_query_function (v4l2src->srcpad, gst_v4l2src_src_query);
 261   gst_pad_set_query_type_function (v4l2src->srcpad, gst_v4l2src_get_query_types);
 262
 263   v4l2src->breq.count = 0;
 264
 265   v4l2src->formats = NULL;
 266
 267   /* no clock */
 268   v4l2src->clock = NULL;
 269
 270   /* fps */
 271   v4l2src->use_fixed_fps = TRUE;
 272 }
 273
 274
 275 static void
 276 gst_v4l2src_open (GstElement  *element,
 277                   const gchar *device)
 278 {
 279   gst_v4l2src_fill_format_list (GST_V4L2SRC (element));
 280 }
 281
 282
 283 static void
 284 gst_v4l2src_close (GstElement  *element,
 285                    const gchar *device)
 286 {
 287   gst_v4l2src_clear_format_list (GST_V4L2SRC (element));
 288 }
 289
 290
 291 static gfloat
 292 gst_v4l2src_get_fps (GstV4l2Src *v4l2src)
 293 {
 294         v4l2_std_id norm;
 295         const GList *item;
 296
 297         if (!v4l2src->use_fixed_fps &&
 298             v4l2src->clock != NULL &&
 299             v4l2src->handled > 0) {
 300                 /* try to get time from clock master and calculate fps */
 301                 GstClockTime time = gst_clock_get_time(v4l2src->clock) -
 302                                       v4l2src->substract_time;
 303                 return v4l2src->handled * GST_SECOND / time;
 304         }
 305
 306         /* if that failed ... */
 307
 308         if (!GST_V4L2_IS_OPEN(GST_V4L2ELEMENT(v4l2src)))
 309                 return 0.;
 310
 311         if (!gst_v4l2_get_norm(GST_V4L2ELEMENT(v4l2src), &norm))
 312                 return 0.;
 313         for (item = GST_V4L2ELEMENT(v4l2src)->norms;
 314              item != NULL; item = item->next) {
 315                 GstV4l2TunerNorm *v4l2norm = item->data;
 316                 if (v4l2norm->index == norm)
 317                         return GST_TUNER_NORM(v4l2norm)->fps;
 318         }
 319
 320         return 0.;
 321 }
 322
 323 static gboolean
 324 gst_v4l2src_src_convert (GstPad    *pad,
 325                          GstFormat  src_format,
 326                          gint64     src_value,
 327                          GstFormat *dest_format,
 328                          gint64    *dest_value)
 329 {
 330         GstV4l2Src *v4l2src;
 331         gdouble fps;
 332
 333         v4l2src = GST_V4L2SRC (gst_pad_get_parent (pad));
 334
 335         if ((fps = gst_v4l2src_get_fps(v4l2src)) == 0)
 336                 return FALSE;
 337
 338         switch (src_format) {
 339                 case GST_FORMAT_TIME:
 340                         switch (*dest_format) {
 341                                 case GST_FORMAT_DEFAULT:
 342                                         *dest_value = src_value * fps / GST_SECOND;
 343                                         break;
 344                                 default:
 345                                         return FALSE;
 346                         }
 347                         break;
 348
 349                 case GST_FORMAT_DEFAULT:
 350                         switch (*dest_format) {
 351                                 case GST_FORMAT_TIME:
 352                                         *dest_value = src_value * GST_SECOND / fps;
 353                                         break;
 354                                 default:
 355                                         return FALSE;
 356                         }
 357                         break;
 358
 359                 default:
 360                         return FALSE;
 361         }
 362
 363         return TRUE;
 364 }
 365
 366 static gboolean
 367 gst_v4l2src_src_query (GstPad      *pad,
 368                        GstQueryType type,
 369                        GstFormat   *format,
 370                        gint64      *value)
 371 {
 372   GstV4l2Src *v4l2src = GST_V4L2SRC (gst_pad_get_parent (pad));
 373   gboolean res = TRUE;
 374   gdouble fps;
 375
 376   if ((fps = gst_v4l2src_get_fps(v4l2src)) == 0)
 377     return FALSE;
 378
 379   switch (type) {
 380     case GST_QUERY_POSITION:
 381       switch (*format) {
 382         case GST_FORMAT_TIME:
 383           *value = v4l2src->handled * GST_SECOND / fps;
 384           break;
 385         case GST_FORMAT_DEFAULT:
 386           *value = v4l2src->handled;
 387           break;
 388         default:
 389           res = FALSE;
 390           break;
 391       }
 392       break;
 393     default:
 394       res = FALSE;
 395       break;
 396   }
 397
 398   return res;
 399 }
 400
 401 static GstStructure *
 402 gst_v4l2src_v4l2fourcc_to_caps (guint32 fourcc)
 403 {
 404   GstStructure *structure = NULL;
 405
 406   switch (fourcc) {
 407     case V4L2_PIX_FMT_MJPEG: /* Motion-JPEG */
 408     case V4L2_PIX_FMT_JPEG:  /* JFIF JPEG */
 409       structure = gst_structure_new ("video/x-jpeg", NULL);
 410       break;
 411     case V4L2_PIX_FMT_RGB332:
 412     case V4L2_PIX_FMT_RGB555:
 413     case V4L2_PIX_FMT_RGB555X:
 414     case V4L2_PIX_FMT_RGB565:
 415     case V4L2_PIX_FMT_RGB565X:
 416     case V4L2_PIX_FMT_RGB24:
 417     case V4L2_PIX_FMT_BGR24:
 418     case V4L2_PIX_FMT_RGB32:
 419     case V4L2_PIX_FMT_BGR32: {
 420       guint depth=0, bpp=0;
 421       gint endianness = 0;
 422       guint32 r_mask = 0, b_mask = 0, g_mask = 0;
 423
 424       switch (fourcc) {
 425         case V4L2_PIX_FMT_RGB332:
 426           bpp = depth = 8;
 427           endianness = G_BYTE_ORDER; /* 'like, whatever' */
 428           r_mask = 0xe0; g_mask = 0x1c; b_mask = 0x03;
 429           break;
 430         case V4L2_PIX_FMT_RGB555:
 431         case V4L2_PIX_FMT_RGB555X:
 432           bpp = 16; depth = 15;
 433           endianness = fourcc == V4L2_PIX_FMT_RGB555X ? G_BIG_ENDIAN : G_LITTLE_ENDIAN;
 434           r_mask = 0x7c00;
 435           g_mask = 0x03e0;
 436           b_mask = 0x001f;
 437           break;
 438         case V4L2_PIX_FMT_RGB565:
 439         case V4L2_PIX_FMT_RGB565X:
 440           bpp = depth = 16;
 441           endianness = fourcc == V4L2_PIX_FMT_RGB565X ? G_BIG_ENDIAN : G_LITTLE_ENDIAN;
 442           r_mask = 0xf800;
 443           g_mask = 0x07e0;
 444           b_mask = 0x001f;
 445         case V4L2_PIX_FMT_RGB24:
 446           bpp = depth = 24;
 447           endianness = G_BIG_ENDIAN;
 448           r_mask = 0xff0000;
 449           g_mask = 0x00ff00;
 450           b_mask = 0x0000ff;
 451           break;
 452         case V4L2_PIX_FMT_BGR24:
 453           bpp = depth = 24;
 454           endianness = G_BIG_ENDIAN;
 455           r_mask = 0x0000ff;
 456           g_mask = 0x00ff00;
 457           b_mask = 0xff0000;
 458           break;
 459         case V4L2_PIX_FMT_RGB32:
 460           bpp = depth = 32;
 461           endianness = G_BIG_ENDIAN;
 462           r_mask = 0xff000000;
 463           g_mask = 0x00ff0000;
 464           b_mask = 0x0000ff00;
 465           break;
 466         case V4L2_PIX_FMT_BGR32:
 467           bpp = depth = 32;
 468           endianness = G_BIG_ENDIAN;
 469           r_mask = 0x000000ff;
 470           g_mask = 0x0000ff00;
 471           b_mask = 0x00ff0000;
 472           break;
 473         default:
 474           g_assert_not_reached();
 475           break;
 476       }
 477       structure = gst_structure_new ("video/x-raw-rgb",
 478           "bpp",        G_TYPE_INT, bpp,
 479           "depth",      G_TYPE_INT, depth,
 480           "red_mask",   G_TYPE_INT, r_mask,
 481           "green_mask", G_TYPE_INT, g_mask,
 482           "blue_mask",  G_TYPE_INT, b_mask,
 483           "endianness", G_TYPE_INT, endianness,
 484           NULL);
 485       break;
 486     }
 487     case V4L2_PIX_FMT_GREY:             /*  8  Greyscale     */
 488     case V4L2_PIX_FMT_YUV422P:          /* 16  YVU422 planar */
 489     case V4L2_PIX_FMT_YUV411P:          /* 16  YVU411 planar */
 490     case V4L2_PIX_FMT_NV12:             /* 12  Y/CbCr 4:2:0  */
 491     case V4L2_PIX_FMT_NV21:             /* 12  Y/CrCb 4:2:0  */
 492     case V4L2_PIX_FMT_YYUV:             /* 16  YUV 4:2:2     */
 493     case V4L2_PIX_FMT_HI240:            /*  8  8-bit color   */
 494       /* FIXME: get correct fourccs here */
 495       break;
 496     case V4L2_PIX_FMT_YVU410:
 497     case V4L2_PIX_FMT_YUV410:
 498     case V4L2_PIX_FMT_YUV420: /* I420/IYUV */
 499     case V4L2_PIX_FMT_YUYV:
 500     case V4L2_PIX_FMT_YVU420:
 501     case V4L2_PIX_FMT_UYVY:
 502     case V4L2_PIX_FMT_Y41P: {
 503       guint32 fcc = 0;
 504
 505       switch (fourcc) {
 506         case V4L2_PIX_FMT_YVU410:
 507           fcc = GST_MAKE_FOURCC('Y','V','U','9');
 508           break;
 509         case V4L2_PIX_FMT_YUV410:
 510           fcc = GST_MAKE_FOURCC('Y','U','V','9');
 511           break;
 512         case V4L2_PIX_FMT_YUV420:
 513           fcc = GST_MAKE_FOURCC('I','4','2','0');
 514           break;
 515         case V4L2_PIX_FMT_YUYV:
 516           fcc = GST_MAKE_FOURCC('Y','U','Y','2');
 517           break;
 518         case V4L2_PIX_FMT_YVU420:
 519           fcc = GST_MAKE_FOURCC('Y','V','1','2');
 520           break;
 521         case V4L2_PIX_FMT_UYVY:
 522           fcc = GST_MAKE_FOURCC('U','Y','V','Y');
 523           break;
 524         case V4L2_PIX_FMT_Y41P:
 525           fcc = GST_MAKE_FOURCC('Y','4','1','B');
 526           break;
 527         default:
 528           g_assert_not_reached();
 529           break;
 530       }
 531       structure = gst_structure_new ("video/x-raw-yuv",
 532           "format", GST_TYPE_FOURCC, fcc,
 533           NULL);
 534       break;
 535     }
 536     case V4L2_PIX_FMT_DV:
 537       structure = gst_structure_new ("video/x-dv", "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
 538       break;
 539     case V4L2_PIX_FMT_MPEG:             /* MPEG          */
 540       /* someone figure out the MPEG format used... */
 541       break;
 542     case V4L2_PIX_FMT_WNVA:             /* Winnov hw compres */
 543       break;
 544     default:
 545       GST_DEBUG ("Unknown fourcc 0x%08x " GST_FOURCC_FORMAT,
 546                           fourcc, GST_FOURCC_ARGS(fourcc));
 547       break;
 548   }
 549 #if 0
 550         gst_caps_set_simple (caps,
 551             "width", G_TYPE_INT, width,
 552             "height", G_TYPE_INT, height,
 553             "framerate", G_TYPE_DOUBLE, fps,
 554             NULL);
 555 #endif
 556   return structure;
 557 }
 558
 559 static struct v4l2_fmtdesc *
 560 gst_v4l2src_get_format_from_fourcc (GstV4l2Src *v4l2src, guint32 fourcc)
 561 {
 562   struct v4l2_fmtdesc *fmt;
 563   GSList *walk;
 564
 565   if (fourcc == 0)
 566     return NULL;
 567
 568   walk = v4l2src->formats;
 569   while (walk) {
 570     fmt = (struct v4l2_fmtdesc *) walk->data;
 571     if (fmt->pixelformat == fourcc)
 572       return fmt;
 573     /* special case for jpeg */
 574     if ((fmt->pixelformat == V4L2_PIX_FMT_MJPEG && fourcc == V4L2_PIX_FMT_JPEG) ||
 575         (fmt->pixelformat == V4L2_PIX_FMT_JPEG && fourcc == V4L2_PIX_FMT_MJPEG)) {
 576       return fmt;
 577     }
 578     walk = g_slist_next (walk);
 579   }
 580
 581   return NULL;
 582 }
 583
 584 static guint32
 585 gst_v4l2_fourcc_from_structure (GstStructure *structure)
 586 {
 587   guint32 fourcc = 0;
 588   const gchar *mimetype = gst_structure_get_name (structure);
 589
 590   if (!strcmp(mimetype, "video/x-raw-yuv") ||
 591       !strcmp(mimetype, "video/x-raw-rgb")) {
 592     if (!strcmp(mimetype, "video/x-raw-rgb"))
 593       fourcc = GST_MAKE_FOURCC('R','G','B',' ');
 594     else
 595       gst_structure_get_fourcc (structure, "format", &fourcc);
 596
 597     switch (fourcc) {
 598       case GST_MAKE_FOURCC('I','4','2','0'):
 599       case GST_MAKE_FOURCC('I','Y','U','V'):
 600         fourcc = V4L2_PIX_FMT_YUV420;
 601         break;
 602       case GST_MAKE_FOURCC('Y','U','Y','2'):
 603         fourcc = V4L2_PIX_FMT_YUYV;
 604         break;
 605       case GST_MAKE_FOURCC('Y','4','1','P'):
 606         fourcc = V4L2_PIX_FMT_Y41P;
 607         break;
 608       case GST_MAKE_FOURCC('U','Y','V','Y'):
 609         fourcc = V4L2_PIX_FMT_UYVY;
 610         break;
 611       case GST_MAKE_FOURCC('Y','V','1','2'):
 612         fourcc = V4L2_PIX_FMT_YVU420;
 613         break;
 614       case GST_MAKE_FOURCC('R','G','B',' '): {
 615         gint depth, endianness, r_mask;
 616
 617         gst_structure_get_int (structure, "depth", &depth);
 618         gst_structure_get_int (structure, "endianness", &endianness);
 619         gst_structure_get_int (structure, "red_mask", &r_mask);
 620
 621         switch (depth) {
 622           case 8:
 623             fourcc = V4L2_PIX_FMT_RGB332;
 624             break;
 625           case 15:
 626             fourcc = (endianness == G_LITTLE_ENDIAN) ?
 627                 V4L2_PIX_FMT_RGB555 :
 628                 V4L2_PIX_FMT_RGB555X;
 629             break;
 630           case 16:
 631             fourcc = (endianness == G_LITTLE_ENDIAN) ?
 632                 V4L2_PIX_FMT_RGB565 :
 633                 V4L2_PIX_FMT_RGB565X;
 634             break;
 635           case 24:
 636             fourcc = (r_mask == 0xFF) ?
 637                 V4L2_PIX_FMT_BGR24 :
 638                 V4L2_PIX_FMT_RGB24;
 639             break;
 640           case 32:
 641             fourcc = (r_mask == 0xFF) ?
 642                 V4L2_PIX_FMT_BGR32 :
 643                 V4L2_PIX_FMT_RGB32;
 644             break;
 645         }
 646         default:
 647           break;
 648       }
 649     }
 650   } else if (strcmp (mimetype, "video/x-dv") == 0) {
 651     fourcc = V4L2_PIX_FMT_DV;
 652   } else if (strcmp (mimetype, "video/x-jpeg") == 0) {
 653     fourcc = V4L2_PIX_FMT_JPEG;
 654   }
 655
 656   return fourcc;
 657 }
 658
 659 static struct v4l2_fmtdesc *
 660 gst_v4l2_caps_to_v4l2fourcc (GstV4l2Src *v4l2src, GstStructure *structure)
 661 {
 662   return gst_v4l2src_get_format_from_fourcc (v4l2src,
 663       gst_v4l2_fourcc_from_structure (structure));
 664 }
 665
 666 static const GstCaps *
 667 gst_v4l2src_get_all_caps (void)
 668 {
 669   static GstCaps *caps = NULL;
 670
 671   if (caps == NULL) {
 672     GstStructure *structure;
 673     guint i;
 674
 675     caps = gst_caps_new_empty ();
 676     for (i = 0; i < GST_V4L2_FORMAT_COUNT; i++) {
 677       structure = gst_v4l2src_v4l2fourcc_to_caps (gst_v4l2_formats[i]);
 678       if (structure) {
 679         gst_structure_set (structure,
 680             "width", GST_TYPE_INT_RANGE, 1, 4096,
 681             "height", GST_TYPE_INT_RANGE, 1, 4096,
 682             "framerate", GST_TYPE_DOUBLE_RANGE, (double) 0, G_MAXDOUBLE,
 683             NULL);
 684
 685         gst_caps_append_structure (caps, structure);
 686       }
 687     }
 688   }
 689
 690   return caps;
 691 }
 692
 693 static GstCaps *
 694 gst_v4l2src_fixate (GstPad *pad, const GstCaps *const_caps)
 695 {
 696   gint i;
 697   GstStructure *structure;
 698   G_GNUC_UNUSED gchar *caps_str;
 699   gboolean changed = FALSE;
 700   GstCaps *caps = gst_caps_copy (const_caps);
 701
 702   caps_str = gst_caps_to_string (caps);
 703   GST_DEBUG_OBJECT (gst_pad_get_parent (pad), "fixating caps %s", caps_str);
 704   g_free (caps_str);
 705
 706   for (i = 0; i < gst_caps_get_size (caps); i++) {
 707     structure = gst_caps_get_structure (caps, i);
 708     changed |= gst_caps_structure_fixate_field_nearest_int (structure, "width", G_MAXINT);
 709   }
 710   if (changed) return caps;
 711
 712   for (i = 0; i < gst_caps_get_size (caps); i++) {
 713     structure = gst_caps_get_structure (caps, i);
 714     changed |= gst_caps_structure_fixate_field_nearest_int (structure, "height", G_MAXINT);
 715   }
 716   if (changed) return caps;
 717
 718   gst_caps_free (caps);
 719   return NULL;
 720 }
 721
 722 static GstPadLinkReturn
 723 gst_v4l2src_link (GstPad *pad, const GstCaps *caps)
 724 {
 725   GstV4l2Src *v4l2src;
 726   GstV4l2Element *v4l2element;
 727   struct v4l2_fmtdesc *format;
 728   int w, h;
 729   GstStructure *structure;
 730
 731   v4l2src = GST_V4L2SRC(gst_pad_get_parent (pad));
 732   v4l2element = GST_V4L2ELEMENT(v4l2src);
 733
 734   structure = gst_caps_get_structure (caps, 0);
 735
 736   /* clean up if we still haven't cleaned up our previous
 737    * capture session */
 738   if (GST_V4L2_IS_ACTIVE(v4l2element)) {
 739           if (!gst_v4l2src_capture_deinit(v4l2src))
 740                   return GST_PAD_LINK_REFUSED;
 741   } else if (!GST_V4L2_IS_OPEN(v4l2element)) {
 742           return GST_PAD_LINK_DELAYED;
 743   }
 744
 745   /* we want our own v4l2 type of fourcc codes */
 746   if (!(format = gst_v4l2_caps_to_v4l2fourcc(v4l2src, structure))) {
 747           return GST_PAD_LINK_REFUSED;
 748   }
 749
 750   gst_structure_get_int (structure, "width", &w);
 751   gst_structure_get_int (structure, "height", &h);
 752
 753   /* we found the pixelformat! - try it out */
 754   if (gst_v4l2src_set_capture(v4l2src, format, w, h)) {
 755           if (gst_v4l2src_capture_init(v4l2src)) {
 756                   return GST_PAD_LINK_OK;
 757           }
 758   }
 759
 760   return GST_PAD_LINK_REFUSED;
 761 }
 762
 763
 764 static GstCaps *
 765 gst_v4l2src_getcaps (GstPad  *pad)
 766 {
 767   GstV4l2Src *v4l2src = GST_V4L2SRC(gst_pad_get_parent (pad));
 768   GstCaps *caps;
 769   struct v4l2_fmtdesc *format;
 770   int min_w, max_w, min_h, max_h;
 771   GSList *walk;
 772   GstStructure *structure;
 773
 774   if (!GST_V4L2_IS_OPEN(GST_V4L2ELEMENT(v4l2src))) {
 775           return gst_caps_new_any ();
 776   }
 777
 778   /* build our own capslist */
 779   caps = gst_caps_new_empty();
 780   walk = v4l2src->formats;
 781   while (walk) {
 782     format = (struct v4l2_fmtdesc *) walk->data;
 783     walk = g_slist_next (walk);
 784
 785     /* get size delimiters */
 786     if (!gst_v4l2src_get_size_limits(v4l2src, format,
 787         &min_w, &max_w, &min_h, &max_h)) {
 788       continue;
 789     }
 790
 791     /* add to list */
 792     structure = gst_v4l2src_v4l2fourcc_to_caps (format->pixelformat);
 793
 794     if (structure) {
 795       gst_structure_set (structure,
 796           "width", GST_TYPE_INT_RANGE, min_w, max_w,
 797           "height", GST_TYPE_INT_RANGE, min_h, max_h,
 798           "framerate", GST_TYPE_DOUBLE_RANGE, (double) 0, G_MAXDOUBLE,
 799           NULL);
 800
 801       gst_caps_append_structure (caps, structure);
 802     }
 803   }
 804
 805   return caps;
 806 }
 807
 808 static GstData*
 809 gst_v4l2src_get (GstPad *pad)
 810 {
 811   GstV4l2Src *v4l2src;
 812   GstBuffer *buf;
 813   gint i, num = -1;
 814   gdouble fps = 0;
 815
 816   v4l2src = GST_V4L2SRC (gst_pad_get_parent (pad));
 817
 818   if (v4l2src->use_fixed_fps &&
 819       (fps = gst_v4l2src_get_fps(v4l2src)) == 0) {
 820     GST_ELEMENT_ERROR (v4l2src, RESOURCE, SETTINGS, (NULL), ("could not get frame rate for element"));
 821     return NULL;
 822   }
 823
 824   if (v4l2src->need_writes > 0) {
 825     /* use last frame */
 826     buf = v4l2src->cached_buffer;
 827     v4l2src->need_writes--;
 828   } else {
 829     GstClockTime time;
 830     /* grab a frame from the device */
 831     num = gst_v4l2src_grab_frame(v4l2src);
 832     if (num == -1)
 833       return NULL;
 834
 835     /* to check if v4l2 sets the correct time */
 836     time = GST_TIMEVAL_TO_TIME(v4l2src->pool->buffers[num].buffer.timestamp);
 837     if (v4l2src->clock && v4l2src->use_fixed_fps && time != 0) {
 838       gboolean have_frame = FALSE;
 839
 840       do {
 841         /* FIXME: isn't this v4l2 timestamp its own clock?! */
 842         /* by default, we use the frame once */
 843         v4l2src->need_writes = 1;
 844
 845         g_assert (time >= v4l2src->substract_time);
 846         time -= v4l2src->substract_time;
 847
 848         /* first check whether we lost any frames according to the device */
 849         if (v4l2src->last_seq != 0) {
 850           if (v4l2src->pool->buffers[num].buffer.sequence - v4l2src->last_seq > 1) {
 851             v4l2src->need_writes = v4l2src->pool->buffers[num].buffer.sequence - v4l2src->last_seq;
 852             g_signal_emit(G_OBJECT(v4l2src), gst_v4l2src_signals[SIGNAL_FRAME_LOST], 0,
 853                 v4l2src->need_writes - 1);
 854           }
 855         }
 856         v4l2src->last_seq = v4l2src->pool->buffers[num].buffer.sequence;
 857
 858         /* decide how often we're going to write the frame - set
 859          * v4lmjpegsrc->need_writes to (that-1) and have_frame to TRUE
 860          * if we're going to write it - else, just continue.
 861          *
 862          * time is generally the system or audio clock. Let's
 863          * say that we've written one second of audio, then we want
 864          * to have written one second of video too, within the same
 865          * timeframe. This means that if time - begin_time = X sec,
 866          * we want to have written X*fps frames. If we've written
 867          * more - drop, if we've written less - dup... */
 868         if (v4l2src->handled * (GST_SECOND/fps) - time > 1.5 * (GST_SECOND/fps)) {
 869           /* yo dude, we've got too many frames here! Drop! DROP! */
 870           v4l2src->need_writes--; /* -= (v4l2src->handled - (time / fps)); */
 871           g_signal_emit(G_OBJECT(v4l2src), gst_v4l2src_signals[SIGNAL_FRAME_DROP], 0);
 872         } else if (v4l2src->handled * (GST_SECOND/fps) - time < -1.5 * (GST_SECOND/fps)) {
 873           /* this means we're lagging far behind */
 874           v4l2src->need_writes++; /* += ((time / fps) - v4l2src->handled); */
 875           g_signal_emit(G_OBJECT(v4l2src), gst_v4l2src_signals[SIGNAL_FRAME_INSERT], 0);
 876         }
 877
 878         if (v4l2src->need_writes > 0) {
 879           have_frame = TRUE;
 880           v4l2src->need_writes--;
 881         } else {
 882           if (!gst_v4l2src_queue_frame(v4l2src, num))
 883             return NULL;
 884           num = gst_v4l2src_grab_frame(v4l2src);
 885           if (num == -1)
 886             return NULL;
 887         }
 888       } while (!have_frame);
 889     }
 890
 891     g_assert (num != -1);
 892     GST_LOG_OBJECT (v4l2src, "buffer %d needs %d writes", num, v4l2src->need_writes + 1);
 893     i = v4l2src->pool->buffers[num].buffer.bytesused > 0 ?
 894       v4l2src->pool->buffers[num].buffer.bytesused :
 895       v4l2src->pool->buffers[num].length;
 896     /* check if this is the last buffer in the queue. If so do a memcpy to put it back asap
 897        to avoid framedrops and deadlocks because of stupid elements */
 898     if (gst_atomic_int_read (&v4l2src->pool->refcount) == v4l2src->breq.count) {
 899       GST_LOG_OBJECT (v4l2src, "using memcpy'd buffer");
 900       buf = gst_buffer_new_and_alloc (i);
 901       memcpy (GST_BUFFER_DATA (buf), v4l2src->pool->buffers[num].start, i);
 902       if (!gst_v4l2src_queue_frame(v4l2src, num)) {
 903         gst_data_unref (GST_DATA (buf));
 904         return NULL;
 905       }
 906     } else {
 907       GST_LOG_OBJECT (v4l2src, "using mmap'd buffer");
 908       buf = gst_buffer_new ();
 909       GST_BUFFER_DATA (buf) = v4l2src->pool->buffers[num].start;
 910       GST_BUFFER_SIZE (buf) = i;
 911       GST_BUFFER_FREE_DATA_FUNC (buf) = gst_v4l2src_free_buffer;
 912       GST_BUFFER_PRIVATE (buf) = &v4l2src->pool->buffers[num];
 913       /* no need to be careful here, both are > 0, because the element uses them */
 914       gst_atomic_int_inc (&v4l2src->pool->buffers[num].refcount);
 915       gst_atomic_int_inc (&v4l2src->pool->refcount);
 916     }
 917     GST_BUFFER_MAXSIZE (buf) = v4l2src->pool->buffers[num].length;
 918     if (v4l2src->use_fixed_fps) {
 919       GST_BUFFER_TIMESTAMP (buf) = v4l2src->handled * GST_SECOND / fps;
 920       GST_BUFFER_DURATION (buf) = GST_SECOND / fps;
 921     } else {
 922       /* calculate time based on our own clock */
 923       GST_BUFFER_TIMESTAMP(buf) = GST_TIMEVAL_TO_TIME(v4l2src->pool->buffers[num].buffer.timestamp) -
 924           v4l2src->substract_time;
 925     }
 926     if (v4l2src->need_writes > 0) {
 927       v4l2src->cached_buffer = buf;
 928       for (i = 0; i < v4l2src->need_writes; i++) {
 929         gst_data_ref (GST_DATA (buf));
 930       }
 931     }
 932   }
 933
 934   v4l2src->handled++;
 935   g_signal_emit(G_OBJECT(v4l2src), gst_v4l2src_signals[SIGNAL_FRAME_CAPTURE], 0);
 936
 937   return GST_DATA (buf);
 938 }
 939
 940 static void
 941 gst_v4l2src_set_property (GObject      *object,
 942                           guint        prop_id,
 943                           const GValue *value,
 944                           GParamSpec   *pspec)
 945 {
 946         GstV4l2Src *v4l2src;
 947
 948         g_return_if_fail(GST_IS_V4L2SRC(object));
 949         v4l2src = GST_V4L2SRC(object);
 950
 951         switch (prop_id) {
 952                 case ARG_NUMBUFS:
 953                         if (!GST_V4L2_IS_ACTIVE(GST_V4L2ELEMENT(v4l2src))) {
 954                                 v4l2src->breq.count = g_value_get_int(value);
 955                         }
 956                         break;
 957
 958                 case ARG_USE_FIXED_FPS:
 959                         if (!GST_V4L2_IS_ACTIVE(GST_V4L2ELEMENT(v4l2src))) {
 960                                 v4l2src->use_fixed_fps = g_value_get_boolean(value);
 961                         }
 962                         break;
 963
 964                 default:
 965                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 966                         break;
 967         }
 968 }
 969
 970
 971 static void
 972 gst_v4l2src_get_property (GObject    *object,
 973                           guint      prop_id,
 974                           GValue     *value,
 975                           GParamSpec *pspec)
 976 {
 977         GstV4l2Src *v4l2src;
 978
 979         g_return_if_fail(GST_IS_V4L2SRC(object));
 980         v4l2src = GST_V4L2SRC(object);
 981
 982         switch (prop_id) {
 983                 case ARG_NUMBUFS:
 984                         g_value_set_int(value, v4l2src->breq.count);
 985                         break;
 986
 987                 case ARG_BUFSIZE:
 988                         g_value_set_int(value, v4l2src->format.fmt.pix.sizeimage);
 989                         break;
 990
 991                 case ARG_USE_FIXED_FPS:
 992                         g_value_set_boolean(value, v4l2src->use_fixed_fps);
 993                         break;
 994
 995                 default:
 996                         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 997                         break;
 998         }
 999 }
1000
1001
1002 static GstElementStateReturn
1003 gst_v4l2src_change_state (GstElement *element)
1004 {
1005         GstV4l2Src *v4l2src;
1006         gint transition = GST_STATE_TRANSITION (element);
1007         GstElementStateReturn parent_return;
1008         GTimeVal time;
1009
1010         g_return_val_if_fail(GST_IS_V4L2SRC(element), GST_STATE_FAILURE);
1011         v4l2src = GST_V4L2SRC(element);
1012
1013         if (GST_ELEMENT_CLASS (parent_class)->change_state) {
1014                 parent_return = GST_ELEMENT_CLASS (parent_class)->change_state (element);
1015                 if (parent_return != GST_STATE_SUCCESS)
1016                         return parent_return;
1017         }
1018
1019         switch (transition) {
1020                 case GST_STATE_NULL_TO_READY:
1021                         if (!gst_v4l2src_get_capture(v4l2src))
1022                                 return GST_STATE_FAILURE;
1023                         break;
1024                 case GST_STATE_READY_TO_PAUSED:
1025                         v4l2src->handled = 0;
1026                         v4l2src->need_writes = 0;
1027                         v4l2src->substract_time = 0;
1028                         /* buffer setup moved to capsnego */
1029                         break;
1030                 case GST_STATE_PAUSED_TO_PLAYING:
1031                         /* queue all buffer, start streaming capture */
1032                         if (!gst_v4l2src_capture_start(v4l2src))
1033                                 return GST_STATE_FAILURE;
1034                         g_get_current_time(&time);
1035                         v4l2src->substract_time = GST_TIMEVAL_TO_TIME(time) -
1036                                                     v4l2src->substract_time;
1037                         v4l2src->last_seq = 0;
1038                         break;
1039                 case GST_STATE_PLAYING_TO_PAUSED:
1040                         g_get_current_time(&time);
1041                         v4l2src->substract_time = GST_TIMEVAL_TO_TIME(time) -
1042                                                     v4l2src->substract_time;
1043                         /* de-queue all queued buffers */
1044                         if (!gst_v4l2src_capture_stop(v4l2src))
1045                                 return GST_STATE_FAILURE;
1046                         break;
1047                 case GST_STATE_PAUSED_TO_READY:
1048                         /* stop capturing, unmap all buffers */
1049                         if (!gst_v4l2src_capture_deinit(v4l2src))
1050                                 return GST_STATE_FAILURE;
1051                         break;
1052                 case GST_STATE_READY_TO_NULL:
1053                         break;
1054         }
1055
1056         return GST_STATE_SUCCESS;
1057 }
1058
1059
1060 static void
1061 gst_v4l2src_set_clock (GstElement *element,
1062                            GstClock   *clock)
1063 {
1064         GST_V4L2SRC(element)->clock = clock;
1065 }
1066