sys/v4l2/gstv4l2bufferpool.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2001-2002 Ronald Bultje <rbultje@ronald.bitfreak.net>
   4  *               2006 Edgard Lima <edgard.lima@indt.org.br>
   5  *               2009 Texas Instruments, Inc - http://www.ti.com/
   6  *
   7  * gstv4l2bufferpool.c V4L2 buffer pool class
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Library General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Library General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Library General Public
  20  * License along with this library; if not, write to the
  21  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  22  * Boston, MA 02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <config.h>
  27 #endif
  28
  29 #include <sys/mman.h>
  30 #include <string.h>
  31 #include <unistd.h>
  32
  33 #include "gst/video/video.h"
  34 #include "gst/video/gstmetavideo.h"
  35
  36 #include <gstv4l2bufferpool.h>
  37
  38 #include "gstv4l2src.h"
  39 #include "gstv4l2sink.h"
  40 #include "v4l2_calls.h"
  41 #include "gst/gst-i18n-plugin.h"
  42
  43 /* videodev2.h is not versioned and we can't easily check for the presence
  44  * of enum values at compile time, but the V4L2_CAP_VIDEO_OUTPUT_OVERLAY define
  45  * was added in the same commit as V4L2_FIELD_INTERLACED_{TB,BT} (b2787845) */
  46 #ifndef V4L2_CAP_VIDEO_OUTPUT_OVERLAY
  47 #define V4L2_FIELD_INTERLACED_TB 8
  48 #define V4L2_FIELD_INTERLACED_BT 9
  49 #endif
  50
  51
  52 GST_DEBUG_CATEGORY_EXTERN (v4l2_debug);
  53 #define GST_CAT_DEFAULT v4l2_debug
  54
  55 /*
  56  * GstV4l2Buffer:
  57  */
  58 const GstMetaInfo *
  59 gst_meta_v4l2_get_info (void)
  60 {
  61   static const GstMetaInfo *meta_info = NULL;
  62
  63   if (meta_info == NULL) {
  64     meta_info =
  65         gst_meta_register ("GstMetaV4l2", "GstMetaV4l2",
  66         sizeof (GstMetaV4l2), (GstMetaInitFunction) NULL,
  67         (GstMetaFreeFunction) NULL, (GstMetaCopyFunction) NULL,
  68         (GstMetaTransformFunction) NULL);
  69   }
  70   return meta_info;
  71 }
  72
  73 /*
  74  * GstV4l2BufferPool:
  75  */
  76 #define gst_v4l2_buffer_pool_parent_class parent_class
  77 G_DEFINE_TYPE (GstV4l2BufferPool, gst_v4l2_buffer_pool, GST_TYPE_BUFFER_POOL);
  78
  79 static void gst_v4l2_buffer_pool_release_buffer (GstBufferPool * bpool,
  80     GstBuffer * buffer);
  81
  82 static void
  83 gst_v4l2_buffer_pool_free_buffer (GstBufferPool * bpool, GstBuffer * buffer)
  84 {
  85   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
  86   GstV4l2Object *obj;
  87
  88   obj = pool->obj;
  89
  90   switch (obj->mode) {
  91     case GST_V4L2_IO_RW:
  92       break;
  93     case GST_V4L2_IO_MMAP:
  94     {
  95       GstMetaV4l2 *meta;
  96       gint index;
  97
  98       meta = GST_META_V4L2_GET (buffer);
  99       g_assert (meta != NULL);
 100
 101       index = meta->vbuffer.index;
 102       GST_LOG_OBJECT (pool,
 103           "mmap buffer %p idx %d (data %p, len %u) freed, unmapping", buffer,
 104           index, meta->mem, meta->vbuffer.length);
 105
 106       v4l2_munmap (meta->mem, meta->vbuffer.length);
 107       pool->buffers[index] = NULL;
 108       break;
 109     }
 110     case GST_V4L2_IO_USERPTR:
 111     default:
 112       g_assert_not_reached ();
 113       break;
 114   }
 115   gst_buffer_unref (buffer);
 116 }
 117
 118 static GstFlowReturn
 119 gst_v4l2_buffer_pool_alloc_buffer (GstBufferPool * bpool, GstBuffer ** buffer,
 120     GstBufferPoolParams * params)
 121 {
 122   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 123   GstBuffer *newbuf;
 124   GstMetaV4l2 *meta;
 125   GstV4l2Object *obj;
 126   GstVideoInfo *info;
 127   guint index;
 128
 129   obj = pool->obj;
 130   info = &obj->info;
 131
 132   switch (obj->mode) {
 133     case GST_V4L2_IO_RW:
 134     {
 135       newbuf =
 136           gst_buffer_new_allocate (pool->allocator, pool->size, pool->align);
 137       break;
 138     }
 139     case GST_V4L2_IO_MMAP:
 140     {
 141       newbuf = gst_buffer_new ();
 142       meta = GST_META_V4L2_ADD (newbuf);
 143
 144       index = pool->num_allocated;
 145
 146       GST_LOG_OBJECT (pool, "creating buffer %u, %p", index, newbuf, pool);
 147
 148       meta->vbuffer.index = index;
 149       meta->vbuffer.type = obj->type;
 150       meta->vbuffer.memory = V4L2_MEMORY_MMAP;
 151
 152       if (v4l2_ioctl (pool->video_fd, VIDIOC_QUERYBUF, &meta->vbuffer) < 0)
 153         goto querybuf_failed;
 154
 155       GST_LOG_OBJECT (pool, "  index:     %u", meta->vbuffer.index);
 156       GST_LOG_OBJECT (pool, "  type:      %d", meta->vbuffer.type);
 157       GST_LOG_OBJECT (pool, "  bytesused: %u", meta->vbuffer.bytesused);
 158       GST_LOG_OBJECT (pool, "  flags:     %08x", meta->vbuffer.flags);
 159       GST_LOG_OBJECT (pool, "  field:     %d", meta->vbuffer.field);
 160       GST_LOG_OBJECT (pool, "  memory:    %d", meta->vbuffer.memory);
 161       if (meta->vbuffer.memory == V4L2_MEMORY_MMAP)
 162         GST_LOG_OBJECT (pool, "  MMAP offset:  %u", meta->vbuffer.m.offset);
 163       GST_LOG_OBJECT (pool, "  length:    %u", meta->vbuffer.length);
 164       GST_LOG_OBJECT (pool, "  input:     %u", meta->vbuffer.input);
 165
 166       meta->mem = v4l2_mmap (0, meta->vbuffer.length,
 167           PROT_READ | PROT_WRITE, MAP_SHARED, pool->video_fd,
 168           meta->vbuffer.m.offset);
 169       if (meta->mem == MAP_FAILED)
 170         goto mmap_failed;
 171
 172       gst_buffer_take_memory (newbuf, -1,
 173           gst_memory_new_wrapped (0,
 174               meta->mem, NULL, meta->vbuffer.length, 0, meta->vbuffer.length));
 175
 176       /* add metadata to raw video buffers */
 177       if (info->finfo) {
 178         gsize offset[GST_VIDEO_MAX_PLANES];
 179         gint stride[GST_VIDEO_MAX_PLANES];
 180
 181         offset[0] = 0;
 182         stride[0] = obj->bytesperline;
 183
 184         GST_DEBUG_OBJECT (pool, "adding video meta, stride %d", stride[0]);
 185         gst_buffer_add_meta_video_full (newbuf, info->flags,
 186             GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info),
 187             GST_VIDEO_INFO_HEIGHT (info), GST_VIDEO_INFO_N_PLANES (info),
 188             offset, stride);
 189       }
 190       break;
 191     }
 192     case GST_V4L2_IO_USERPTR:
 193     default:
 194       g_assert_not_reached ();
 195       break;
 196   }
 197
 198   pool->num_allocated++;
 199
 200   *buffer = newbuf;
 201
 202   return GST_FLOW_OK;
 203
 204   /* ERRORS */
 205 querybuf_failed:
 206   {
 207     gint errnosave = errno;
 208
 209     GST_WARNING ("Failed QUERYBUF: %s", g_strerror (errnosave));
 210     gst_buffer_unref (newbuf);
 211     errno = errnosave;
 212     return GST_FLOW_ERROR;
 213   }
 214 mmap_failed:
 215   {
 216     gint errnosave = errno;
 217
 218     GST_WARNING ("Failed to mmap: %s", g_strerror (errnosave));
 219     gst_buffer_unref (newbuf);
 220     errno = errnosave;
 221     return GST_FLOW_ERROR;
 222   }
 223 }
 224
 225 static gboolean
 226 gst_v4l2_buffer_pool_set_config (GstBufferPool * bpool, GstStructure * config)
 227 {
 228   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 229   const GstCaps *caps;
 230   guint size, min_buffers, max_buffers;
 231   guint prefix, align;
 232
 233   GST_DEBUG_OBJECT (pool, "set config");
 234
 235   /* parse the config and keep around */
 236   if (!gst_buffer_pool_config_get (config, &caps, &size, &min_buffers,
 237           &max_buffers, &prefix, &align))
 238     goto wrong_config;
 239
 240   GST_DEBUG_OBJECT (pool, "config %" GST_PTR_FORMAT, config);
 241
 242   pool->size = size;
 243   pool->max_buffers = MAX (min_buffers, max_buffers);
 244   pool->min_buffers = MIN (pool->max_buffers, min_buffers);
 245   pool->prefix = prefix;
 246   pool->align = align;
 247
 248   gst_buffer_pool_config_set (config, caps, size, min_buffers,
 249       max_buffers, prefix, align);
 250
 251   return GST_BUFFER_POOL_CLASS (parent_class)->set_config (bpool, config);
 252
 253 wrong_config:
 254   {
 255     GST_WARNING_OBJECT (pool, "invalid config %" GST_PTR_FORMAT, config);
 256     return FALSE;
 257   }
 258 }
 259
 260 static gboolean
 261 start_streaming (GstV4l2BufferPool * pool)
 262 {
 263   GstV4l2Object *obj = pool->obj;
 264
 265   switch (obj->mode) {
 266     case GST_V4L2_IO_RW:
 267       break;
 268     case GST_V4L2_IO_MMAP:
 269     case GST_V4L2_IO_USERPTR:
 270       GST_DEBUG_OBJECT (pool, "STREAMON");
 271       if (v4l2_ioctl (pool->video_fd, VIDIOC_STREAMON, &obj->type) < 0)
 272         goto start_failed;
 273       break;
 274     default:
 275       g_assert_not_reached ();
 276       break;
 277   }
 278
 279   pool->streaming = TRUE;
 280
 281   return TRUE;
 282
 283   /* ERRORS */
 284 start_failed:
 285   {
 286     GST_ERROR_OBJECT (pool, "error with STREAMON %d (%s)", errno,
 287         g_strerror (errno));
 288     return FALSE;
 289   }
 290 }
 291
 292 static gboolean
 293 gst_v4l2_buffer_pool_start (GstBufferPool * bpool)
 294 {
 295   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 296   GstV4l2Object *obj = pool->obj;
 297   gint n;
 298   struct v4l2_requestbuffers breq;
 299   gint min_buffers, max_buffers;
 300
 301   min_buffers = pool->min_buffers;
 302   max_buffers = pool->max_buffers;
 303
 304   switch (obj->mode) {
 305     case GST_V4L2_IO_RW:
 306     {
 307       break;
 308     }
 309     case GST_V4L2_IO_MMAP:
 310     {
 311       /* first, lets request buffers, and see how many we can get: */
 312       GST_DEBUG_OBJECT (pool, "starting, requesting %d MMAP buffers",
 313           max_buffers);
 314
 315       memset (&breq, 0, sizeof (struct v4l2_requestbuffers));
 316       breq.type = obj->type;
 317       breq.count = max_buffers;
 318       breq.memory = V4L2_MEMORY_MMAP;
 319
 320       if (v4l2_ioctl (pool->video_fd, VIDIOC_REQBUFS, &breq) < 0)
 321         goto reqbufs_failed;
 322
 323       GST_LOG_OBJECT (pool, " count:  %u", breq.count);
 324       GST_LOG_OBJECT (pool, " type:   %d", breq.type);
 325       GST_LOG_OBJECT (pool, " memory: %d", breq.memory);
 326
 327       if (breq.count < GST_V4L2_MIN_BUFFERS)
 328         goto no_buffers;
 329
 330       if (max_buffers != breq.count) {
 331         GST_WARNING_OBJECT (pool, "using %u buffers instead", breq.count);
 332         max_buffers = breq.count;
 333       }
 334       break;
 335     }
 336     case GST_V4L2_IO_USERPTR:
 337     default:
 338       g_assert_not_reached ();
 339       break;
 340   }
 341
 342   pool->obj = obj;
 343   pool->max_buffers = max_buffers;
 344   pool->buffers = g_new0 (GstBuffer *, max_buffers);
 345   pool->num_allocated = 0;
 346
 347   /* now, allocate the buffers: */
 348   for (n = 0; n < min_buffers; n++) {
 349     GstBuffer *buffer;
 350
 351     if (gst_v4l2_buffer_pool_alloc_buffer (bpool, &buffer, NULL) != GST_FLOW_OK)
 352       goto buffer_new_failed;
 353
 354     gst_v4l2_buffer_pool_release_buffer (bpool, buffer);
 355   }
 356
 357   /* we can start capturing now, we wait for the playback case until we queued
 358    * the first buffer */
 359   if (obj->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 360     if (!start_streaming (pool))
 361       goto start_failed;
 362
 363   gst_poll_set_flushing (obj->poll, FALSE);
 364
 365   return TRUE;
 366
 367   /* ERRORS */
 368 reqbufs_failed:
 369   {
 370     GST_ERROR_OBJECT (pool,
 371         "error requesting %d buffers: %s", max_buffers, g_strerror (errno));
 372     return FALSE;
 373   }
 374 no_buffers:
 375   {
 376     GST_ERROR_OBJECT (pool,
 377         "we received %d from device '%s', we want at least %d",
 378         breq.count, obj->videodev, GST_V4L2_MIN_BUFFERS);
 379     return FALSE;
 380   }
 381 buffer_new_failed:
 382   {
 383     GST_ERROR_OBJECT (pool, "failed to create a buffer");
 384     return FALSE;
 385   }
 386 start_failed:
 387   {
 388     GST_ERROR_OBJECT (pool, "failed to start streaming");
 389     return FALSE;
 390   }
 391 }
 392
 393 static gboolean
 394 gst_v4l2_buffer_pool_stop (GstBufferPool * bpool)
 395 {
 396   gboolean ret;
 397   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 398   GstV4l2Object *obj = pool->obj;
 399   guint n;
 400
 401   GST_DEBUG_OBJECT (pool, "stopping pool");
 402
 403   gst_poll_set_flushing (obj->poll, TRUE);
 404
 405   if (pool->streaming) {
 406     switch (obj->mode) {
 407       case GST_V4L2_IO_RW:
 408         break;
 409       case GST_V4L2_IO_MMAP:
 410       case GST_V4L2_IO_USERPTR:
 411         /* we actually need to sync on all queued buffers but not
 412          * on the non-queued ones */
 413         GST_DEBUG_OBJECT (pool, "STREAMOFF");
 414         if (v4l2_ioctl (pool->video_fd, VIDIOC_STREAMOFF, &obj->type) < 0)
 415           goto stop_failed;
 416         break;
 417       default:
 418         g_assert_not_reached ();
 419         break;
 420     }
 421     pool->streaming = FALSE;
 422   }
 423
 424   /* first free the buffers in the queue */
 425   ret = GST_BUFFER_POOL_CLASS (parent_class)->stop (bpool);
 426
 427   /* then free the remaining buffers */
 428   for (n = 0; n < pool->num_allocated; n++) {
 429     if (pool->buffers[n])
 430       gst_v4l2_buffer_pool_free_buffer (bpool, pool->buffers[n]);
 431   }
 432   return ret;
 433
 434   /* ERRORS */
 435 stop_failed:
 436   {
 437     GST_ERROR_OBJECT (pool, "error with STREAMOFF %d (%s)", errno,
 438         g_strerror (errno));
 439     return FALSE;
 440   }
 441 }
 442
 443 static GstFlowReturn
 444 gst_v4l2_object_poll (GstV4l2Object * v4l2object)
 445 {
 446   gint ret;
 447
 448   if (v4l2object->can_poll_device) {
 449     GST_LOG_OBJECT (v4l2object->element, "polling device");
 450     ret = gst_poll_wait (v4l2object->poll, GST_CLOCK_TIME_NONE);
 451     if (G_UNLIKELY (ret < 0)) {
 452       if (errno == EBUSY)
 453         goto stopped;
 454       if (errno == ENXIO) {
 455         GST_WARNING_OBJECT (v4l2object->element,
 456             "v4l2 device doesn't support polling. Disabling");
 457         v4l2object->can_poll_device = FALSE;
 458       } else {
 459         if (errno != EAGAIN && errno != EINTR)
 460           goto select_error;
 461       }
 462     }
 463   }
 464   return GST_FLOW_OK;
 465
 466   /* ERRORS */
 467 stopped:
 468   {
 469     GST_DEBUG ("stop called");
 470     return GST_FLOW_WRONG_STATE;
 471   }
 472 select_error:
 473   {
 474     GST_ELEMENT_ERROR (v4l2object->element, RESOURCE, READ, (NULL),
 475         ("poll error %d: %s (%d)", ret, g_strerror (errno), errno));
 476     return GST_FLOW_ERROR;
 477   }
 478 }
 479
 480 static GstFlowReturn
 481 gst_v4l2_buffer_pool_qbuf (GstV4l2BufferPool * pool, GstBuffer * buf)
 482 {
 483   GstMetaV4l2 *meta;
 484   gint index;
 485
 486   meta = GST_META_V4L2_GET (buf);
 487   g_assert (meta != NULL);
 488
 489   index = meta->vbuffer.index;
 490
 491   GST_LOG_OBJECT (pool, "enqueue buffer %p, index:%d, queued:%d", buf,
 492       index, pool->num_queued);
 493
 494   if (pool->buffers[index] != NULL)
 495     goto already_queued;
 496
 497   if (v4l2_ioctl (pool->video_fd, VIDIOC_QBUF, &meta->vbuffer) < 0)
 498     goto queue_failed;
 499
 500   pool->buffers[index] = buf;
 501   pool->num_queued++;
 502
 503   return GST_FLOW_OK;
 504
 505   /* ERRORS */
 506 already_queued:
 507   {
 508     GST_WARNING_OBJECT (pool, "the buffer was already queued");
 509     return GST_FLOW_ERROR;
 510   }
 511 queue_failed:
 512   {
 513     GST_WARNING_OBJECT (pool, "could not queue a buffer %d (%s)", errno,
 514         g_strerror (errno));
 515     return GST_FLOW_ERROR;
 516   }
 517 }
 518
 519 static GstFlowReturn
 520 gst_v4l2_buffer_pool_dqbuf (GstV4l2BufferPool * pool, GstBuffer ** buffer)
 521 {
 522   GstFlowReturn res;
 523   GstBuffer *outbuf;
 524   struct v4l2_buffer vbuffer;
 525   GstV4l2Object *obj = pool->obj;
 526
 527   if (obj->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
 528     /* select works for input devices when data is available. According to the
 529      * specs we can also poll to find out when a frame has been displayed but
 530      * that just seems to lock up here */
 531     if ((res = gst_v4l2_object_poll (obj)) != GST_FLOW_OK)
 532       goto poll_error;
 533   }
 534
 535   memset (&vbuffer, 0x00, sizeof (vbuffer));
 536   vbuffer.type = obj->type;
 537   vbuffer.memory = V4L2_MEMORY_MMAP;
 538
 539   GST_LOG_OBJECT (pool, "doing DQBUF");
 540   if (v4l2_ioctl (pool->video_fd, VIDIOC_DQBUF, &vbuffer) < 0)
 541     goto error;
 542
 543   /* get our GstBuffer with that index from the pool, if the buffer was
 544    * outstanding we have a serious problem.
 545    */
 546   outbuf = pool->buffers[vbuffer.index];
 547   if (outbuf == NULL)
 548     goto no_buffer;
 549
 550   /* mark the buffer outstanding */
 551   pool->buffers[vbuffer.index] = NULL;
 552   pool->num_queued--;
 553
 554   GST_LOG_OBJECT (pool,
 555       "dequeued buffer %p seq:%d (ix=%d), used %d, flags %08x, pool-queued=%d, buffer=%p",
 556       outbuf, vbuffer.sequence, vbuffer.index, vbuffer.bytesused, vbuffer.flags,
 557       pool->num_queued, outbuf);
 558
 559   /* set top/bottom field first if v4l2_buffer has the information */
 560   if (vbuffer.field == V4L2_FIELD_INTERLACED_TB)
 561     GST_BUFFER_FLAG_SET (outbuf, GST_VIDEO_BUFFER_TFF);
 562   if (vbuffer.field == V4L2_FIELD_INTERLACED_BT)
 563     GST_BUFFER_FLAG_UNSET (outbuf, GST_VIDEO_BUFFER_TFF);
 564
 565   /* this can change at every frame, esp. with jpeg */
 566   if (obj->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
 567     gst_buffer_resize (outbuf, 0, vbuffer.bytesused);
 568   else
 569     gst_buffer_resize (outbuf, 0, vbuffer.length);
 570
 571   *buffer = outbuf;
 572
 573   return GST_FLOW_OK;
 574
 575   /* ERRORS */
 576 poll_error:
 577   {
 578     GST_DEBUG_OBJECT (pool, "poll error %s", gst_flow_get_name (res));
 579     return res;
 580   }
 581 error:
 582   {
 583     GST_WARNING_OBJECT (pool,
 584         "problem dequeuing frame %d (ix=%d), pool-ct=%d, buf.flags=%d",
 585         vbuffer.sequence, vbuffer.index,
 586         GST_MINI_OBJECT_REFCOUNT (pool), vbuffer.flags);
 587
 588     switch (errno) {
 589       case EAGAIN:
 590         GST_WARNING_OBJECT (pool,
 591             "Non-blocking I/O has been selected using O_NONBLOCK and"
 592             " no buffer was in the outgoing queue. device %s", obj->videodev);
 593         break;
 594       case EINVAL:
 595         GST_ERROR_OBJECT (pool,
 596             "The buffer type is not supported, or the index is out of bounds, "
 597             "or no buffers have been allocated yet, or the userptr "
 598             "or length are invalid. device %s", obj->videodev);
 599         break;
 600       case ENOMEM:
 601         GST_ERROR_OBJECT (pool,
 602             "insufficient memory to enqueue a user pointer buffer");
 603         break;
 604       case EIO:
 605         GST_INFO_OBJECT (pool,
 606             "VIDIOC_DQBUF failed due to an internal error."
 607             " Can also indicate temporary problems like signal loss."
 608             " Note the driver might dequeue an (empty) buffer despite"
 609             " returning an error, or even stop capturing."
 610             " device %s", obj->videodev);
 611         /* have we de-queued a buffer ? */
 612         if (!(vbuffer.flags & (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))) {
 613           GST_DEBUG_OBJECT (pool, "reenqueing buffer");
 614           /* FIXME ... should we do something here? */
 615         }
 616         break;
 617       case EINTR:
 618         GST_WARNING_OBJECT (pool,
 619             "could not sync on a buffer on device %s", obj->videodev);
 620         break;
 621       default:
 622         GST_WARNING_OBJECT (pool,
 623             "Grabbing frame got interrupted on %s unexpectedly. %d: %s.",
 624             obj->videodev, errno, g_strerror (errno));
 625         break;
 626     }
 627     return GST_FLOW_ERROR;
 628   }
 629 no_buffer:
 630   {
 631     GST_ERROR_OBJECT (pool, "No free buffer found in the pool at index %d.",
 632         vbuffer.index);
 633     return GST_FLOW_ERROR;
 634   }
 635 }
 636
 637 static GstFlowReturn
 638 gst_v4l2_buffer_pool_acquire_buffer (GstBufferPool * bpool, GstBuffer ** buffer,
 639     GstBufferPoolParams * params)
 640 {
 641   GstFlowReturn ret;
 642   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 643   GstV4l2Object *obj = pool->obj;
 644
 645   GST_DEBUG_OBJECT (pool, "acquire");
 646
 647   if (GST_BUFFER_POOL_IS_FLUSHING (bpool))
 648     goto flushing;
 649
 650   switch (obj->type) {
 651     case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 652       /* capture, This function should return a buffer with new captured data */
 653       switch (obj->mode) {
 654         case GST_V4L2_IO_RW:
 655           /* take empty buffer from the pool */
 656           ret = GST_BUFFER_POOL_CLASS (parent_class)->acquire_buffer (bpool,
 657               buffer, params);
 658           break;
 659
 660         case GST_V4L2_IO_MMAP:
 661           /* just dequeue a buffer, we basically use the queue of v4l2 as the
 662            * storage for our buffers. This function does poll first so we can
 663            * interrupt it fine. */
 664           ret = gst_v4l2_buffer_pool_dqbuf (pool, buffer);
 665           break;
 666
 667         case GST_V4L2_IO_USERPTR:
 668         default:
 669           g_assert_not_reached ();
 670           break;
 671       }
 672       break;
 673
 674     case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 675       /* playback, This function should return an empty buffer */
 676       switch (obj->mode) {
 677         case GST_V4L2_IO_RW:
 678           /* get an empty buffer */
 679           ret = GST_BUFFER_POOL_CLASS (parent_class)->acquire_buffer (bpool,
 680               buffer, params);
 681           break;
 682
 683         case GST_V4L2_IO_MMAP:
 684           /* get a free unqueued buffer */
 685           ret = GST_BUFFER_POOL_CLASS (parent_class)->acquire_buffer (bpool,
 686               buffer, params);
 687           break;
 688
 689         case GST_V4L2_IO_USERPTR:
 690         default:
 691           g_assert_not_reached ();
 692           break;
 693       }
 694       break;
 695
 696     default:
 697       g_assert_not_reached ();
 698       break;
 699   }
 700   return ret;
 701
 702   /* ERRORS */
 703 flushing:
 704   {
 705     GST_DEBUG_OBJECT (pool, "We are flushing");
 706     return GST_FLOW_WRONG_STATE;
 707   }
 708 }
 709
 710 static void
 711 gst_v4l2_buffer_pool_release_buffer (GstBufferPool * bpool, GstBuffer * buffer)
 712 {
 713   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 714   GstV4l2Object *obj = pool->obj;
 715
 716   GST_DEBUG_OBJECT (pool, "release buffer %p", buffer);
 717
 718   switch (obj->type) {
 719     case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 720       /* capture, put the buffer back in the queue so that we can refill it
 721        * later. */
 722       switch (obj->mode) {
 723         case GST_V4L2_IO_RW:
 724           /* release back in the pool */
 725           GST_BUFFER_POOL_CLASS (parent_class)->release_buffer (bpool, buffer);
 726           break;
 727
 728         case GST_V4L2_IO_MMAP:
 729           /* queue back in the device */
 730           gst_v4l2_buffer_pool_qbuf (pool, buffer);
 731           break;
 732
 733         case GST_V4L2_IO_USERPTR:
 734         default:
 735           g_assert_not_reached ();
 736           break;
 737       }
 738       break;
 739
 740     case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 741     {
 742       GstMetaV4l2 *meta;
 743
 744       meta = GST_META_V4L2_GET (buffer);
 745       g_assert (meta != NULL);
 746
 747       if (pool->buffers[meta->vbuffer.index] == NULL) {
 748         GST_LOG_OBJECT (pool, "buffer not queued, putting on free list");
 749         /* playback, put the buffer back in the queue to refill later. */
 750         GST_BUFFER_POOL_CLASS (parent_class)->release_buffer (bpool, buffer);
 751       } else {
 752         /* the buffer is queued in the device but maybe not played yet. We just
 753          * leave it there and not make it available for future calls to acquire
 754          * for now. The buffer will be dequeued and reused later. */
 755         GST_LOG_OBJECT (pool, "buffer is queued");
 756       }
 757       break;
 758     }
 759
 760     default:
 761       g_assert_not_reached ();
 762       break;
 763   }
 764 }
 765
 766 static void
 767 gst_v4l2_buffer_pool_finalize (GObject * object)
 768 {
 769   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (object);
 770
 771   if (pool->video_fd >= 0)
 772     v4l2_close (pool->video_fd);
 773
 774   if (pool->buffers) {
 775     g_free (pool->buffers);
 776     pool->buffers = NULL;
 777   }
 778
 779   G_OBJECT_CLASS (parent_class)->finalize (object);
 780 }
 781
 782 static void
 783 gst_v4l2_buffer_pool_init (GstV4l2BufferPool * pool)
 784 {
 785 }
 786
 787 static void
 788 gst_v4l2_buffer_pool_class_init (GstV4l2BufferPoolClass * klass)
 789 {
 790   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 791   GstBufferPoolClass *bufferpool_class = GST_BUFFER_POOL_CLASS (klass);
 792
 793   object_class->finalize = gst_v4l2_buffer_pool_finalize;
 794
 795   bufferpool_class->start = gst_v4l2_buffer_pool_start;
 796   bufferpool_class->stop = gst_v4l2_buffer_pool_stop;
 797   bufferpool_class->set_config = gst_v4l2_buffer_pool_set_config;
 798   bufferpool_class->alloc_buffer = gst_v4l2_buffer_pool_alloc_buffer;
 799   bufferpool_class->acquire_buffer = gst_v4l2_buffer_pool_acquire_buffer;
 800   bufferpool_class->release_buffer = gst_v4l2_buffer_pool_release_buffer;
 801   bufferpool_class->free_buffer = gst_v4l2_buffer_pool_free_buffer;
 802 }
 803
 804 /**
 805  * gst_v4l2_buffer_pool_new:
 806  * @obj:  the v4l2 object owning the pool
 807  *
 808  * Construct a new buffer pool.
 809  *
 810  * Returns: the new pool, use gst_object_unref() to free resources
 811  */
 812 GstBufferPool *
 813 gst_v4l2_buffer_pool_new (GstV4l2Object * obj)
 814 {
 815   GstV4l2BufferPool *pool;
 816   gint fd;
 817
 818   fd = v4l2_dup (obj->video_fd);
 819   if (fd < 0)
 820     goto dup_failed;
 821
 822   pool = (GstV4l2BufferPool *) g_object_new (GST_TYPE_V4L2_BUFFER_POOL, NULL);
 823   pool->video_fd = fd;
 824   pool->obj = obj;
 825
 826   return GST_BUFFER_POOL_CAST (pool);
 827
 828   /* ERRORS */
 829 dup_failed:
 830   {
 831     GST_DEBUG ("failed to dup fd %d (%s)", errno, g_strerror (errno));
 832     return NULL;
 833   }
 834 }
 835
 836 static GstFlowReturn
 837 gst_v4l2_do_read (GstV4l2BufferPool * pool, GstBuffer * buf)
 838 {
 839   GstFlowReturn res;
 840   GstV4l2Object *obj = pool->obj;
 841   gint amount;
 842   gpointer data;
 843   gint buffersize;
 844
 845   buffersize = gst_buffer_get_size (buf);
 846
 847   GST_LOG_OBJECT (pool, "reading %d bytes into buffer %p", buffersize, buf);
 848
 849   data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
 850
 851   do {
 852     if ((res = gst_v4l2_object_poll (obj)) != GST_FLOW_OK)
 853       goto poll_error;
 854
 855     amount = v4l2_read (obj->video_fd, data, buffersize);
 856
 857     if (amount == buffersize) {
 858       break;
 859     } else if (amount == -1) {
 860       if (errno == EAGAIN || errno == EINTR) {
 861         continue;
 862       } else
 863         goto read_error;
 864     } else {
 865       /* short reads can happen if a signal interrupts the read */
 866       continue;
 867     }
 868   } while (TRUE);
 869
 870   GST_LOG_OBJECT (pool, "read %d bytes", amount);
 871   gst_buffer_unmap (buf, data, amount);
 872
 873   return GST_FLOW_OK;
 874
 875   /* ERRORS */
 876 poll_error:
 877   {
 878     GST_DEBUG ("poll error %s", gst_flow_get_name (res));
 879     goto cleanup;
 880   }
 881 read_error:
 882   {
 883     GST_ELEMENT_ERROR (obj->element, RESOURCE, READ,
 884         (_("Error reading %d bytes from device '%s'."),
 885             buffersize, obj->videodev), GST_ERROR_SYSTEM);
 886     res = GST_FLOW_ERROR;
 887     goto cleanup;
 888   }
 889 cleanup:
 890   {
 891     gst_buffer_unmap (buf, data, 0);
 892     return res;
 893   }
 894 }
 895
 896 /**
 897  * gst_v4l2_buffer_pool_process:
 898  * @bpool: a #GstBufferPool
 899  * @buf: a #GstBuffer
 900  *
 901  * Process @buf in @bpool. For capture devices, this functions fills @buf with
 902  * data from the device. For output devices, this functions send the contents of
 903  * @buf to the device for playback.
 904  *
 905  * Returns: %GST_FLOW_OK on success.
 906  */
 907 GstFlowReturn
 908 gst_v4l2_buffer_pool_process (GstBufferPool * bpool, GstBuffer * buf)
 909 {
 910   GstFlowReturn ret = GST_FLOW_OK;
 911   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
 912   GstV4l2Object *obj = pool->obj;
 913
 914   GST_DEBUG_OBJECT (pool, "process buffer %p", buf);
 915
 916   switch (obj->type) {
 917     case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 918       /* capture */
 919       switch (obj->mode) {
 920         case GST_V4L2_IO_RW:
 921           /* capture into the buffer */
 922           ret = gst_v4l2_do_read (pool, buf);
 923           break;
 924
 925         case GST_V4L2_IO_MMAP:
 926         {
 927           GstBuffer *tmp;
 928
 929           if (buf->pool == bpool)
 930             /* nothing, data was inside the buffer when we did _acquire() */
 931             goto done;
 932
 933           /* buffer not from our pool, grab a frame and copy it into the target */
 934           if ((ret = gst_v4l2_buffer_pool_dqbuf (pool, &tmp)) != GST_FLOW_OK)
 935             goto done;
 936
 937           if (!gst_v4l2_object_copy (obj, buf, tmp))
 938             goto copy_failed;
 939
 940           /* an queue the buffer again after the copy */
 941           if ((ret = gst_v4l2_buffer_pool_qbuf (pool, tmp)) != GST_FLOW_OK)
 942             goto done;
 943           break;
 944         }
 945
 946         case GST_V4L2_IO_USERPTR:
 947         default:
 948           g_assert_not_reached ();
 949           break;
 950       }
 951       break;
 952
 953     case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 954       /* playback */
 955       switch (obj->mode) {
 956         case GST_V4L2_IO_RW:
 957           /* FIXME, do write() */
 958           break;
 959
 960         case GST_V4L2_IO_MMAP:
 961         {
 962           GstBuffer *to_queue;
 963
 964           if (buf->pool == bpool) {
 965             /* nothing, we can queue directly */
 966             to_queue = buf;
 967           } else {
 968             /* this can block if all buffers are outstanding which would be
 969              * strange because we would expect the upstream element to have
 970              * allocated them and returned to us.. */
 971             ret = GST_BUFFER_POOL_CLASS (parent_class)->acquire_buffer (bpool,
 972                 &to_queue, NULL);
 973             if (ret != GST_FLOW_OK)
 974               goto done;
 975
 976             /* copy into it and queue */
 977             if (!gst_v4l2_object_copy (obj, to_queue, buf))
 978               goto copy_failed;
 979           }
 980
 981           if ((ret = gst_v4l2_buffer_pool_qbuf (pool, to_queue)) != GST_FLOW_OK)
 982             goto done;
 983
 984           /* if we are not streaming yet (this is the first buffer, start
 985            * streaming now */
 986           if (!pool->streaming)
 987             if (!start_streaming (pool))
 988               goto start_failed;
 989
 990           if (pool->num_queued == pool->num_allocated) {
 991             /* all buffers are queued, try to dequeue one and release it back
 992              * into the pool so that _acquire can get to it again. */
 993             ret = gst_v4l2_buffer_pool_dqbuf (pool, &to_queue);
 994             if (ret != GST_FLOW_OK)
 995               goto done;
 996
 997             /* release the rendered buffer back into the pool. This wakes up any
 998              * thread waiting for a buffer in _acquire() */
 999             gst_v4l2_buffer_pool_release_buffer (bpool, to_queue);
1000           }
1001           break;
1002         }
1003
1004         case GST_V4L2_IO_USERPTR:
1005         default:
1006           g_assert_not_reached ();
1007           break;
1008       }
1009       break;
1010     default:
1011       g_assert_not_reached ();
1012       break;
1013   }
1014 done:
1015   return ret;
1016
1017   /* ERRORS */
1018 copy_failed:
1019   {
1020     GST_ERROR_OBJECT (obj->element, "failed to copy data");
1021     return GST_FLOW_ERROR;
1022   }
1023 start_failed:
1024   {
1025     GST_ERROR_OBJECT (obj->element, "failed to start streaming");
1026     return GST_FLOW_ERROR;
1027   }
1028 }
1029
1030 /**
1031  * gst_v4l2_buffer_pool_available_buffers:
1032  * @pool: the pool
1033  *
1034  * Check the number of buffers available to the driver, ie. buffers that
1035  * have been QBUF'd but not yet DQBUF'd.
1036  *
1037  * Returns: the number of buffers available.
1038  */
1039 gint
1040 gst_v4l2_buffer_pool_available_buffers (GstBufferPool * bpool)
1041 {
1042   GstV4l2BufferPool *pool = GST_V4L2_BUFFER_POOL (bpool);
1043
1044   return pool->num_queued;
1045 }