sys/v4l2/v4l2src_calls.c

   1 /* G-Streamer Video4linux2 video-capture plugin - system calls
   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 <stdlib.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <fcntl.h>
  28 #include <sys/ioctl.h>
  29 #include <sys/mman.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include "v4l2src_calls.h"
  33 #include <sys/time.h>
  34 #include <unistd.h>
  35
  36 #define GST_CAT_DEFAULT v4l2src_debug
  37
  38 /* lalala... */
  39 #define GST_V4L2_SET_ACTIVE(element) (element)->buffer = GINT_TO_POINTER (-1)
  40 #define GST_V4L2_SET_INACTIVE(element) (element)->buffer = NULL
  41
  42 #define DEBUG(format, args...) \
  43         GST_CAT_DEBUG_OBJECT (\
  44                 v4l2src_debug, v4l2src, \
  45                 "V4L2SRC: " format, ##args)
  46
  47 /* On some systems MAP_FAILED seems to be missing */
  48 #ifndef MAP_FAILED
  49 #define MAP_FAILED ( (caddr_t) -1 )
  50 #endif
  51
  52 /******************************************************
  53  * gst_v4l2src_fill_format_list():
  54  *   create list of supported capture formats
  55  * return value: TRUE on success, FALSE on error
  56  ******************************************************/
  57
  58 gboolean
  59 gst_v4l2src_fill_format_list (GstV4l2Src *v4l2src)
  60 {
  61   gint n;
  62   struct v4l2_fmtdesc *format;
  63
  64   GST_DEBUG_OBJECT (v4l2src, "getting src format enumerations");
  65
  66   /* format enumeration */
  67   for (n=0;;n++) {
  68     format = g_new (struct v4l2_fmtdesc, 1);
  69     format->index = n;
  70     format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  71     if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_ENUM_FMT, format) < 0) {
  72       if (errno == EINVAL) {
  73         break; /* end of enumeration */
  74       } else {
  75         gst_element_error (v4l2src, RESOURCE, SETTINGS, NULL,
  76             ("failed to get number %d in pixelformat enumeration for %s: %s",
  77             n, GST_V4L2ELEMENT(v4l2src)->device, g_strerror (errno)));
  78         g_free (format);
  79         return FALSE;
  80       }
  81     }
  82     GST_LOG_OBJECT (v4l2src, "got format"GST_FOURCC_FORMAT,
  83         GST_FOURCC_ARGS (format->pixelformat));
  84     v4l2src->formats = g_slist_prepend (v4l2src->formats, format);
  85   }
  86
  87   return TRUE;
  88 }
  89
  90
  91 /******************************************************
  92  * gst_v4l2src_clear_format_list():
  93  *   free list of supported capture formats
  94  * return value: TRUE on success, FALSE on error
  95  ******************************************************/
  96
  97 gboolean
  98 gst_v4l2src_clear_format_list (GstV4l2Src *v4l2src)
  99 {
 100   g_slist_foreach (v4l2src->formats, (GFunc) g_free, NULL);
 101   g_slist_free (v4l2src->formats);
 102
 103   return TRUE;
 104 }
 105
 106
 107 /******************************************************
 108  * gst_v4l2src_queue_frame():
 109  *   queue a frame for capturing
 110  * return value: TRUE on success, FALSE on error
 111  ******************************************************/
 112
 113 gboolean
 114 gst_v4l2src_queue_frame (GstV4l2Src *v4l2src,
 115                          guint i)
 116 {
 117   GST_LOG_OBJECT (v4l2src, "queueing frame %u", i);
 118
 119   if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_QBUF, &v4l2src->pool->buffers[i].buffer) < 0) {
 120     gst_element_error (v4l2src, RESOURCE, WRITE,
 121                        (_("Could not write to device \"%s\""), GST_V4L2ELEMENT(v4l2src)->device),
 122                        ("Error queueing buffer %u on device %s", i, g_strerror(errno)));
 123     return FALSE;
 124   }
 125
 126   return TRUE;
 127 }
 128
 129
 130 /******************************************************
 131  * gst_v4l2src_grab_frame ():
 132  *   grab a frame for capturing
 133  * return value: TRUE on success, FALSE on error
 134  ******************************************************/
 135
 136 gint
 137 gst_v4l2src_grab_frame (GstV4l2Src *v4l2src)
 138 {
 139   struct v4l2_buffer buffer;
 140
 141   buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 142   while (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_DQBUF, &buffer) < 0) {
 143     /* if the sync() got interrupted, we can retry */
 144     if (errno != EINTR) {
 145       gst_element_error (v4l2src, RESOURCE, SYNC, NULL, ("could not sync on a buffer on device %s: %s",
 146           GST_V4L2ELEMENT(v4l2src)->device, g_strerror (errno)));
 147       return -1;
 148     }
 149     GST_DEBUG_OBJECT (v4l2src, "grab got interrupted");
 150   }
 151
 152   GST_LOG_OBJECT (v4l2src, "grabbed frame %d", buffer.index);
 153
 154   return buffer.index;
 155 }
 156
 157
 158 /******************************************************
 159  * gst_v4l2src_get_capture():
 160  *   get capture parameters
 161  * return value: TRUE on success, FALSE on error
 162  ******************************************************/
 163
 164 gboolean
 165 gst_v4l2src_get_capture (GstV4l2Src *v4l2src)
 166 {
 167         DEBUG("Getting capture format");
 168
 169         GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 170
 171         v4l2src->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 172         if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_G_FMT, &v4l2src->format) < 0) {
 173                 gst_element_error (v4l2src, RESOURCE, SETTINGS, NULL,
 174                                    ("failed to get pixelformat for device %s: %s",
 175                                    n, GST_V4L2ELEMENT(v4l2src)->device, g_strerror (errno)));
 176                 return FALSE;
 177         }
 178
 179         return TRUE;
 180 }
 181
 182
 183 /******************************************************
 184  * gst_v4l2src_set_capture():
 185  *   set capture parameters
 186  * return value: TRUE on success, FALSE on error
 187  ******************************************************/
 188
 189 gboolean
 190 gst_v4l2src_set_capture (GstV4l2Src          *v4l2src,
 191                          struct v4l2_fmtdesc *fmt,
 192                          gint                 width,
 193                          gint                 height)
 194 {
 195         DEBUG("Setting capture format to %dx%d, format %s",
 196                 width, height, fmt->description);
 197
 198         GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 199         GST_V4L2_CHECK_NOT_ACTIVE(GST_V4L2ELEMENT(v4l2src));
 200
 201         memset(&v4l2src->format, 0, sizeof(struct v4l2_format));
 202         v4l2src->format.fmt.pix.width = width;
 203         v4l2src->format.fmt.pix.height = height;
 204         v4l2src->format.fmt.pix.pixelformat = fmt->pixelformat;
 205         v4l2src->format.fmt.pix.field = V4L2_FIELD_INTERLACED;
 206         v4l2src->format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 207
 208         if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_S_FMT, &v4l2src->format) < 0) {
 209                 gst_element_error (v4l2src, RESOURCE, SETTINGS, NULL,
 210                                    ("failed to set pixelformat to %s @ %dx%d for device %s: %s",
 211                                    fmt->description, width, height, GST_V4L2ELEMENT(v4l2src)->device, g_strerror (errno)));
 212                 return FALSE;
 213         }
 214
 215         /* update internal info */
 216         return gst_v4l2src_get_capture(v4l2src);;
 217 }
 218
 219
 220 /******************************************************
 221  * gst_v4l2src_capture_init():
 222  *   initialize the capture system
 223  * return value: TRUE on success, FALSE on error
 224  ******************************************************/
 225
 226 gboolean
 227 gst_v4l2src_capture_init (GstV4l2Src *v4l2src)
 228 {
 229   gint n;
 230   guint buffers;
 231
 232   GST_DEBUG_OBJECT (v4l2src, "initting the capture system");
 233
 234   GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 235   GST_V4L2_CHECK_NOT_ACTIVE(GST_V4L2ELEMENT(v4l2src));
 236
 237   /* request buffer info */
 238   buffers = v4l2src->breq.count;
 239   if (v4l2src->breq.count > GST_V4L2_MAX_BUFFERS) {
 240     v4l2src->breq.count = GST_V4L2_MAX_BUFFERS;
 241   }
 242   if (v4l2src->breq.count < GST_V4L2_MIN_BUFFERS) {
 243     v4l2src->breq.count = GST_V4L2_MIN_BUFFERS;
 244   }
 245   v4l2src->breq.type = v4l2src->format.type;
 246   v4l2src->breq.memory = V4L2_MEMORY_MMAP;
 247   if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_REQBUFS, &v4l2src->breq) < 0) {
 248     gst_element_error (v4l2src, RESOURCE, READ,
 249                        (_("Could not get buffers from device \"%s\""), GST_V4L2ELEMENT(v4l2src)->device),
 250                        ("error requesting %d buffers: %s", v4l2src->breq.count, g_strerror (errno)));
 251     return FALSE;
 252   }
 253
 254   if (v4l2src->breq.count < GST_V4L2_MIN_BUFFERS) {
 255     gst_element_error (v4l2src, RESOURCE, READ,
 256                        (_("Could not get enough buffers from device \"%s\""), GST_V4L2ELEMENT(v4l2src)->device),
 257                        ("we received %d, we want at least %d", v4l2src->breq.count, GST_V4L2_MIN_BUFFERS));
 258     v4l2src->breq.count = buffers;
 259     return FALSE;
 260   }
 261   if (v4l2src->breq.count != buffers)
 262     g_object_notify (G_OBJECT (v4l2src), "num_buffers");
 263
 264   GST_INFO_OBJECT (v4l2src, "Got %d buffers ("GST_FOURCC_FORMAT") of size %d KB\n",
 265       v4l2src->breq.count, GST_FOURCC_ARGS (v4l2src->format.fmt.pix.pixelformat),
 266       v4l2src->format.fmt.pix.sizeimage / 1024);
 267
 268   /* Map the buffers */
 269   v4l2src->pool = g_new (GstV4l2BufferPool, 1);
 270   gst_atomic_int_init (&v4l2src->pool->refcount, 1);
 271   v4l2src->pool->video_fd = GST_V4L2ELEMENT (v4l2src)->video_fd;
 272   v4l2src->pool->buffer_count = v4l2src->breq.count;
 273   v4l2src->pool->buffers = g_new0 (GstV4l2Buffer, v4l2src->breq.count);
 274
 275   for (n = 0; n < v4l2src->breq.count; n++) {
 276     GstV4l2Buffer *buffer = &v4l2src->pool->buffers[n];
 277
 278     gst_atomic_int_init (&buffer->refcount, 1);
 279     buffer->pool = v4l2src->pool;
 280     buffer->buffer.index = n;
 281     buffer->buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 282     if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_QUERYBUF, &buffer->buffer) < 0) {
 283     gst_element_error (v4l2src, RESOURCE, READ, NULL,
 284                        ("Could not get buffer properties of buffer %d: %s", n, g_strerror (errno)));
 285       gst_v4l2src_capture_deinit(v4l2src);
 286       return FALSE;
 287     }
 288     buffer->start = mmap (0, buffer->buffer.length, PROT_READ|PROT_WRITE, MAP_SHARED,
 289         GST_V4L2ELEMENT(v4l2src)->video_fd, buffer->buffer.m.offset);
 290     if (buffer->start == MAP_FAILED) {
 291     gst_element_error (v4l2src, RESOURCE, READ, NULL,
 292                        ("Could not mmap video buffer %d: %s", n, g_strerror (errno)));
 293       buffer->start = 0;
 294       gst_v4l2src_capture_deinit (v4l2src);
 295       return FALSE;
 296     }
 297     buffer->length = buffer->buffer.length;
 298     if (!gst_v4l2src_queue_frame(v4l2src, n)) {
 299       gst_v4l2src_capture_deinit (v4l2src);
 300       return FALSE;
 301     }
 302   }
 303
 304   GST_V4L2_SET_ACTIVE(GST_V4L2ELEMENT (v4l2src));
 305   return TRUE;
 306 }
 307
 308
 309 /******************************************************
 310  * gst_v4l2src_capture_start():
 311  *   start streaming capture
 312  * return value: TRUE on success, FALSE on error
 313  ******************************************************/
 314
 315 gboolean
 316 gst_v4l2src_capture_start (GstV4l2Src *v4l2src)
 317 {
 318   gint type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 319
 320   GST_DEBUG_OBJECT (v4l2src, "starting the capturing");
 321
 322   GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 323   if (!GST_V4L2_IS_ACTIVE (GST_V4L2ELEMENT(v4l2src))) {
 324     gst_pad_renegotiate (v4l2src->srcpad);
 325   }
 326   GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
 327
 328   v4l2src->quit = FALSE;
 329
 330   if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMON, &type) < 0) {
 331     gst_element_error (v4l2src, RESOURCE, OPEN_READ, NULL,
 332                        ("Error starting streaming capture from device %s: %s",
 333                         GST_V4L2ELEMENT(v4l2src)->device, g_strerror(errno)));
 334     return FALSE;
 335   }
 336
 337   return TRUE;
 338 }
 339
 340
 341 /******************************************************
 342  * gst_v4l2src_capture_stop():
 343  *   stop streaming capture
 344  * return value: TRUE on success, FALSE on error
 345  ******************************************************/
 346
 347 gboolean
 348 gst_v4l2src_capture_stop (GstV4l2Src *v4l2src)
 349 {
 350   gint type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 351
 352   GST_DEBUG_OBJECT (v4l2src, "stopping capturing");
 353   GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 354   GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
 355
 356   /* we actually need to sync on all queued buffers but not
 357    * on the non-queued ones */
 358   if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_STREAMOFF, &type) < 0) {
 359     gst_element_error (v4l2src, RESOURCE, CLOSE, NULL,
 360                        ("Error stopping streaming capture from device %s: %s",
 361                         GST_V4L2ELEMENT(v4l2src)->device, g_strerror (errno)));
 362     return FALSE;
 363   }
 364
 365   /* make an optional pending wait stop */
 366   v4l2src->quit = TRUE;
 367
 368   return TRUE;
 369 }
 370
 371 static void
 372 gst_v4l2src_buffer_pool_free (GstV4l2BufferPool *pool, gboolean do_close)
 373 {
 374   guint i;
 375
 376   for (i = 0; i < pool->buffer_count; i++) {
 377     gst_atomic_int_destroy (&pool->buffers[i].refcount);
 378     munmap (pool->buffers[i].start, pool->buffers[i].length);
 379   }
 380   g_free (pool->buffers);
 381   gst_atomic_int_destroy (&pool->refcount);
 382   if (do_close)
 383     close (pool->video_fd);
 384   g_free (pool);
 385 }
 386
 387 void
 388 gst_v4l2src_free_buffer (GstBuffer *buffer)
 389 {
 390   GstV4l2Buffer *buf = (GstV4l2Buffer *) GST_BUFFER_PRIVATE (buffer);
 391
 392   GST_LOG ("freeing buffer %p (nr. %d)", buffer, buf->buffer.index);
 393
 394   if (!gst_atomic_int_dec_and_test (&buf->refcount)) {
 395     /* we're still in use, add to queue again
 396        note: this might fail because the device is already stopped (race) */
 397     if (ioctl(buf->pool->video_fd, VIDIOC_QBUF, &buf->buffer) < 0)
 398       GST_INFO ("readding to queue failed, assuming video device is stopped");
 399   }
 400   if (gst_atomic_int_dec_and_test (&buf->pool->refcount)) {
 401     /* we're last thing that used all this */
 402     gst_v4l2src_buffer_pool_free (buf->pool, TRUE);
 403   }
 404 }
 405
 406 /******************************************************
 407  * gst_v4l2src_capture_deinit():
 408  *   deinitialize the capture system
 409  * return value: TRUE on success, FALSE on error
 410  ******************************************************/
 411
 412 gboolean
 413 gst_v4l2src_capture_deinit (GstV4l2Src *v4l2src)
 414 {
 415   gint i, dequeue = 0;
 416
 417   GST_DEBUG_OBJECT (v4l2src, "deinitting capture system");
 418
 419   GST_V4L2_CHECK_OPEN(GST_V4L2ELEMENT(v4l2src));
 420   GST_V4L2_CHECK_ACTIVE(GST_V4L2ELEMENT(v4l2src));
 421
 422   /* free the buffers */
 423   for (i = 0; i < v4l2src->breq.count; i++) {
 424     if (gst_atomic_int_dec_and_test (&v4l2src->pool->buffers[i].refcount))
 425       dequeue++;
 426   }
 427   for (i = 0; i < dequeue; i++) {
 428     struct v4l2_buffer buffer;
 429     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 430     if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd, VIDIOC_DQBUF, &buffer) < 0)
 431       GST_WARNING_OBJECT (v4l2src, "Could not dequeue buffer on uninitialization");
 432   }
 433   if (gst_atomic_int_dec_and_test (&v4l2src->pool->refcount)) {
 434     /* we're last thing that used all this */
 435     gst_v4l2src_buffer_pool_free (v4l2src->pool, FALSE);
 436   }
 437   v4l2src->pool = NULL;
 438
 439   GST_V4L2_SET_INACTIVE (GST_V4L2ELEMENT (v4l2src));
 440   return TRUE;
 441 }
 442
 443
 444 /*
 445
 446  */
 447
 448 gboolean
 449 gst_v4l2src_get_size_limits (GstV4l2Src          *v4l2src,
 450                              struct v4l2_fmtdesc *format,
 451                              gint *min_w, gint *max_w,
 452                              gint *min_h, gint *max_h)
 453 {
 454         struct v4l2_format fmt;
 455
 456         GST_LOG_OBJECT (v4l2src, "getting size limits with format " GST_FOURCC_FORMAT,
 457             GST_FOURCC_ARGS (format->pixelformat));
 458
 459         /* get size delimiters */
 460         memset(&fmt, 0, sizeof(fmt));
 461         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 462         fmt.fmt.pix.width = 0;
 463         fmt.fmt.pix.height = 0;
 464         fmt.fmt.pix.pixelformat = format->pixelformat;
 465         fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;
 466         if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
 467                   VIDIOC_TRY_FMT, &fmt) < 0) {
 468                 return FALSE;
 469         }
 470
 471         if (min_w)
 472                 *min_w = fmt.fmt.pix.width;
 473         if (min_h)
 474                 *min_h = fmt.fmt.pix.height;
 475         GST_LOG_OBJECT (v4l2src, "got min size %dx%d", fmt.fmt.pix.width, fmt.fmt.pix.height);
 476
 477         fmt.fmt.pix.width = G_MAXINT;
 478         fmt.fmt.pix.height = 576;
 479         if (ioctl(GST_V4L2ELEMENT(v4l2src)->video_fd,
 480                   VIDIOC_TRY_FMT, &fmt) < 0) {
 481                 return FALSE;
 482         }
 483
 484         if (max_w)
 485                 *max_w = fmt.fmt.pix.width;
 486         if (max_h)
 487                 *max_h = fmt.fmt.pix.height;
 488         GST_LOG_OBJECT (v4l2src, "got max size %dx%d", fmt.fmt.pix.width, fmt.fmt.pix.height);
 489
 490         return TRUE;
 491 }