subprojects/gst-plugins-bad/sys/v4l2codecs/gstv4l2decoder.c

   1 /* GStreamer
   2  * Copyright (C) 2020 Nicolas Dufresne <nicolas.dufresne@collabora.com>
   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., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include "gstv4l2codecallocator.h"
  25 #include "gstv4l2codecpool.h"
  26 #include "gstv4l2decoder.h"
  27 #include "gstv4l2format.h"
  28 #include "linux/media.h"
  29 #include "linux/videodev2.h"
  30
  31 #include <fcntl.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/stat.h>
  34 #include <sys/types.h>
  35 #include <unistd.h>
  36
  37 #include <gst/base/base.h>
  38
  39 #define IMAGE_MINSZ (256*1024)  /* 256kB */
  40
  41 GST_DEBUG_CATEGORY (v4l2_decoder_debug);
  42 #define GST_CAT_DEFAULT v4l2_decoder_debug
  43
  44 enum
  45 {
  46   PROP_0,
  47   PROP_MEDIA_DEVICE,
  48   PROP_VIDEO_DEVICE,
  49 };
  50
  51 struct _GstV4l2Request
  52 {
  53   /* non-thread safe */
  54   gint ref_count;
  55
  56   GstV4l2Decoder *decoder;
  57   gint fd;
  58   guint32 frame_num;
  59   GstMemory *bitstream;
  60   GstBuffer *pic_buf;
  61   GstPoll *poll;
  62   GstPollFD pollfd;
  63
  64   /* request state */
  65   gboolean pending;
  66   gboolean failed;
  67   gboolean hold_pic_buf;
  68   gboolean sub_request;
  69 };
  70
  71 struct _GstV4l2Decoder
  72 {
  73   GstObject parent;
  74
  75   gboolean opened;
  76   gint media_fd;
  77   gint video_fd;
  78   GstQueueArray *request_pool;
  79   GstQueueArray *pending_requests;
  80   guint version;
  81
  82   enum v4l2_buf_type src_buf_type;
  83   enum v4l2_buf_type sink_buf_type;
  84   gboolean mplane;
  85
  86   /* properties */
  87   gchar *media_device;
  88   gchar *video_device;
  89   guint render_delay;
  90
  91   /* detected features */
  92   gboolean supports_holding_capture;
  93 };
  94
  95 G_DEFINE_TYPE_WITH_CODE (GstV4l2Decoder, gst_v4l2_decoder, GST_TYPE_OBJECT,
  96     GST_DEBUG_CATEGORY_INIT (v4l2_decoder_debug, "v4l2codecs-decoder", 0,
  97         "V4L2 stateless decoder helper"));
  98
  99 static void gst_v4l2_request_free (GstV4l2Request * request);
 100
 101 static guint32
 102 direction_to_buffer_type (GstV4l2Decoder * self, GstPadDirection direction)
 103 {
 104   if (direction == GST_PAD_SRC)
 105     return self->src_buf_type;
 106   else
 107     return self->sink_buf_type;
 108 }
 109
 110 static void
 111 gst_v4l2_decoder_finalize (GObject * obj)
 112 {
 113   GstV4l2Decoder *self = GST_V4L2_DECODER (obj);
 114
 115   gst_v4l2_decoder_close (self);
 116
 117   g_free (self->media_device);
 118   g_free (self->video_device);
 119   gst_queue_array_free (self->request_pool);
 120   gst_queue_array_free (self->pending_requests);
 121
 122   G_OBJECT_CLASS (gst_v4l2_decoder_parent_class)->finalize (obj);
 123 }
 124
 125 static void
 126 gst_v4l2_decoder_init (GstV4l2Decoder * self)
 127 {
 128   self->request_pool = gst_queue_array_new (16);
 129   self->pending_requests = gst_queue_array_new (16);
 130 }
 131
 132 static void
 133 gst_v4l2_decoder_class_init (GstV4l2DecoderClass * klass)
 134 {
 135   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 136
 137   gobject_class->finalize = gst_v4l2_decoder_finalize;
 138   gobject_class->get_property = gst_v4l2_decoder_get_property;
 139   gobject_class->set_property = gst_v4l2_decoder_set_property;
 140
 141   gst_v4l2_decoder_install_properties (gobject_class, 0, NULL);
 142 }
 143
 144 GstV4l2Decoder *
 145 gst_v4l2_decoder_new (GstV4l2CodecDevice * device)
 146 {
 147   GstV4l2Decoder *decoder;
 148
 149   g_return_val_if_fail (device->function == MEDIA_ENT_F_PROC_VIDEO_DECODER,
 150       NULL);
 151
 152   decoder = g_object_new (GST_TYPE_V4L2_DECODER,
 153       "media-device", device->media_device_path,
 154       "video-device", device->video_device_path, NULL);
 155
 156   return gst_object_ref_sink (decoder);
 157 }
 158
 159 guint
 160 gst_v4l2_decoder_get_version (GstV4l2Decoder * self)
 161 {
 162   return self->version;
 163 }
 164
 165 gboolean
 166 gst_v4l2_decoder_open (GstV4l2Decoder * self)
 167 {
 168   gint ret;
 169   struct v4l2_capability querycap;
 170   guint32 capabilities;
 171
 172   self->media_fd = open (self->media_device, 0);
 173   if (self->media_fd < 0) {
 174     GST_ERROR_OBJECT (self, "Failed to open '%s': %s",
 175         self->media_device, g_strerror (errno));
 176     return FALSE;
 177   }
 178
 179   self->video_fd = open (self->video_device, O_NONBLOCK);
 180   if (self->video_fd < 0) {
 181     GST_ERROR_OBJECT (self, "Failed to open '%s': %s",
 182         self->video_device, g_strerror (errno));
 183     return FALSE;
 184   }
 185
 186   ret = ioctl (self->video_fd, VIDIOC_QUERYCAP, &querycap);
 187   if (ret < 0) {
 188     GST_ERROR_OBJECT (self, "VIDIOC_QUERYCAP failed: %s", g_strerror (errno));
 189     gst_v4l2_decoder_close (self);
 190     return FALSE;
 191   }
 192
 193   self->version = querycap.version;
 194
 195   if (querycap.capabilities & V4L2_CAP_DEVICE_CAPS)
 196     capabilities = querycap.device_caps;
 197   else
 198     capabilities = querycap.capabilities;
 199
 200   if (capabilities & V4L2_CAP_VIDEO_M2M_MPLANE) {
 201     self->sink_buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
 202     self->src_buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 203     self->mplane = TRUE;
 204   } else if (capabilities & V4L2_CAP_VIDEO_M2M) {
 205     self->sink_buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
 206     self->src_buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 207     self->mplane = FALSE;
 208   } else {
 209     GST_ERROR_OBJECT (self, "Unsupported memory-2-memory device.");
 210     gst_v4l2_decoder_close (self);
 211     return FALSE;
 212   }
 213
 214   self->opened = TRUE;
 215
 216   return TRUE;
 217 }
 218
 219 gboolean
 220 gst_v4l2_decoder_close (GstV4l2Decoder * self)
 221 {
 222   GstV4l2Request *request;
 223
 224   while ((request = gst_queue_array_pop_head (self->pending_requests)))
 225     gst_v4l2_request_unref (request);
 226
 227   while ((request = gst_queue_array_pop_head (self->request_pool)))
 228     gst_v4l2_request_free (request);
 229
 230   if (self->media_fd)
 231     close (self->media_fd);
 232   if (self->video_fd)
 233     close (self->video_fd);
 234
 235   self->media_fd = 0;
 236   self->video_fd = 0;
 237   self->opened = FALSE;
 238
 239   return TRUE;
 240 }
 241
 242 gboolean
 243 gst_v4l2_decoder_streamon (GstV4l2Decoder * self, GstPadDirection direction)
 244 {
 245   gint ret;
 246   guint32 type = direction_to_buffer_type (self, direction);
 247
 248   ret = ioctl (self->video_fd, VIDIOC_STREAMON, &type);
 249   if (ret < 0) {
 250     GST_ERROR_OBJECT (self, "VIDIOC_STREAMON failed: %s", g_strerror (errno));
 251     return FALSE;
 252   }
 253
 254   return TRUE;
 255 }
 256
 257 gboolean
 258 gst_v4l2_decoder_streamoff (GstV4l2Decoder * self, GstPadDirection direction)
 259 {
 260   guint32 type = direction_to_buffer_type (self, direction);
 261   gint ret;
 262
 263   if (direction == GST_PAD_SRC) {
 264     GstV4l2Request *pending_req;
 265
 266     /* STREAMOFF have the effect of cancelling all requests and unqueuing all
 267      * buffers, so clear the pending request list */
 268     while ((pending_req = gst_queue_array_pop_head (self->pending_requests))) {
 269       g_clear_pointer (&pending_req->bitstream, gst_memory_unref);
 270       pending_req->pending = FALSE;
 271       gst_v4l2_request_unref (pending_req);
 272     }
 273   }
 274
 275   ret = ioctl (self->video_fd, VIDIOC_STREAMOFF, &type);
 276   if (ret < 0) {
 277     GST_ERROR_OBJECT (self, "VIDIOC_STREAMOFF failed: %s", g_strerror (errno));
 278     return FALSE;
 279   }
 280
 281   return TRUE;
 282 }
 283
 284 gboolean
 285 gst_v4l2_decoder_flush (GstV4l2Decoder * self)
 286 {
 287   /* We ignore streamoff failure as it's not relevant, if we manage to
 288    * streamon again, we are good. */
 289   gst_v4l2_decoder_streamoff (self, GST_PAD_SINK);
 290   gst_v4l2_decoder_streamoff (self, GST_PAD_SRC);
 291
 292   return gst_v4l2_decoder_streamon (self, GST_PAD_SINK) &&
 293       gst_v4l2_decoder_streamon (self, GST_PAD_SRC);
 294 }
 295
 296 gboolean
 297 gst_v4l2_decoder_enum_sink_fmt (GstV4l2Decoder * self, gint i,
 298     guint32 * out_fmt)
 299 {
 300   struct v4l2_fmtdesc fmtdesc = { i, self->sink_buf_type, };
 301   gint ret;
 302
 303   g_return_val_if_fail (self->opened, FALSE);
 304
 305   ret = ioctl (self->video_fd, VIDIOC_ENUM_FMT, &fmtdesc);
 306   if (ret < 0) {
 307     if (errno != EINVAL)
 308       GST_ERROR_OBJECT (self, "VIDIOC_ENUM_FMT failed: %s", g_strerror (errno));
 309     return FALSE;
 310   }
 311
 312   GST_DEBUG_OBJECT (self, "Found format %" GST_FOURCC_FORMAT " (%s)",
 313       GST_FOURCC_ARGS (fmtdesc.pixelformat), fmtdesc.description);
 314   *out_fmt = fmtdesc.pixelformat;
 315
 316   return TRUE;
 317 }
 318
 319 gboolean
 320 gst_v4l2_decoder_set_sink_fmt (GstV4l2Decoder * self, guint32 pix_fmt,
 321     gint width, gint height, gint pixel_bitdepth)
 322 {
 323   struct v4l2_format format = (struct v4l2_format) {
 324     .type = self->sink_buf_type,
 325     /* Compatible with .fmt.pix for these field */
 326     .fmt.pix_mp = (struct v4l2_pix_format_mplane) {
 327           .pixelformat = pix_fmt,
 328           .width = width,
 329           .height = height,
 330         },
 331   };
 332   gint ret;
 333
 334   /* Using raw image size for now, it is guarantied to be large enough */
 335   gsize sizeimage = MAX (IMAGE_MINSZ, (width * height * pixel_bitdepth) / 8);
 336
 337   if (self->mplane)
 338     format.fmt.pix_mp.plane_fmt[0].sizeimage = sizeimage;
 339   else
 340     format.fmt.pix.sizeimage = sizeimage;
 341
 342   ret = ioctl (self->video_fd, VIDIOC_S_FMT, &format);
 343   if (ret < 0) {
 344     GST_ERROR_OBJECT (self, "VIDIOC_S_FMT failed: %s", g_strerror (errno));
 345     return FALSE;
 346   }
 347
 348   if (format.fmt.pix_mp.pixelformat != pix_fmt
 349       || format.fmt.pix_mp.width < width || format.fmt.pix_mp.height < height) {
 350     GST_WARNING_OBJECT (self, "Failed to set sink format to %"
 351         GST_FOURCC_FORMAT " %ix%i", GST_FOURCC_ARGS (pix_fmt), width, height);
 352     errno = EINVAL;
 353     return FALSE;
 354   }
 355
 356   return TRUE;
 357 }
 358
 359 static GstCaps *
 360 gst_v4l2_decoder_enum_size_for_format (GstV4l2Decoder * self,
 361     guint32 pixelformat, gint index, gint unscaled_width, gint unscaled_height)
 362 {
 363   struct v4l2_frmsizeenum size;
 364   GstVideoFormat format;
 365   gint ret;
 366   gboolean res;
 367
 368   memset (&size, 0, sizeof (struct v4l2_frmsizeenum));
 369   size.index = index;
 370   size.pixel_format = pixelformat;
 371
 372   GST_DEBUG_OBJECT (self, "enumerate size index %d for %" GST_FOURCC_FORMAT,
 373       index, GST_FOURCC_ARGS (pixelformat));
 374
 375   ret = ioctl (self->video_fd, VIDIOC_ENUM_FRAMESIZES, &size);
 376
 377   if (ret < 0)
 378     return NULL;
 379
 380   if (size.type != V4L2_FRMSIZE_TYPE_DISCRETE) {
 381     GST_WARNING_OBJECT (self, "V4L2_FRMSIZE type not supported");
 382     return NULL;
 383   }
 384
 385   if (gst_util_fraction_compare (unscaled_width, unscaled_height,
 386           size.discrete.width, size.discrete.height)) {
 387     GST_DEBUG_OBJECT (self,
 388         "Pixel ratio modification not supported %dx%d %dx%d (%d)",
 389         unscaled_width, unscaled_height, size.discrete.width,
 390         size.discrete.height, ret);
 391     return NULL;
 392   }
 393
 394   res = gst_v4l2_format_to_video_format (pixelformat, &format);
 395   g_assert (res);
 396
 397   GST_DEBUG_OBJECT (self, "get size (%d x %d) index %d for %" GST_FOURCC_FORMAT,
 398       size.discrete.width, size.discrete.height, index,
 399       GST_FOURCC_ARGS (pixelformat));
 400
 401   return gst_caps_new_simple ("video/x-raw", "format", G_TYPE_STRING,
 402       gst_video_format_to_string (format),
 403       "width", G_TYPE_INT, size.discrete.width,
 404       "height", G_TYPE_INT, size.discrete.height, NULL);
 405 }
 406
 407 static GstCaps *
 408 gst_v4l2_decoder_probe_caps_for_format (GstV4l2Decoder * self,
 409     guint32 pixelformat, gint unscaled_width, gint unscaled_height)
 410 {
 411   gint index = 0;
 412   GstCaps *caps, *tmp;
 413   GstVideoFormat format;
 414
 415   GST_DEBUG_OBJECT (self, "enumerate size for %" GST_FOURCC_FORMAT,
 416       GST_FOURCC_ARGS (pixelformat));
 417
 418   if (!gst_v4l2_format_to_video_format (pixelformat, &format))
 419     return gst_caps_new_empty ();
 420
 421   caps = gst_caps_new_simple ("video/x-raw", "format", G_TYPE_STRING,
 422       gst_video_format_to_string (format), NULL);
 423
 424   while ((tmp = gst_v4l2_decoder_enum_size_for_format (self, pixelformat,
 425               index++, unscaled_width, unscaled_height))) {
 426     caps = gst_caps_merge (caps, tmp);
 427   }
 428
 429   return caps;
 430 }
 431
 432 GstCaps *
 433 gst_v4l2_decoder_enum_src_formats (GstV4l2Decoder * self)
 434 {
 435   gint ret;
 436   struct v4l2_format fmt = {
 437     .type = self->src_buf_type,
 438   };
 439   GstCaps *caps;
 440   gint i;
 441
 442   g_return_val_if_fail (self->opened, FALSE);
 443
 444   ret = ioctl (self->video_fd, VIDIOC_G_FMT, &fmt);
 445   if (ret < 0) {
 446     GST_ERROR_OBJECT (self, "VIDIOC_G_FMT failed: %s", g_strerror (errno));
 447     return FALSE;
 448   }
 449
 450   caps =
 451       gst_v4l2_decoder_probe_caps_for_format (self,
 452       fmt.fmt.pix_mp.pixelformat, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height);
 453
 454   /* And then enumerate other possible formats and place that as a second
 455    * structure in the caps */
 456   for (i = 0; ret >= 0; i++) {
 457     struct v4l2_fmtdesc fmtdesc = { i, self->src_buf_type, };
 458     GstCaps *tmp;
 459
 460     ret = ioctl (self->video_fd, VIDIOC_ENUM_FMT, &fmtdesc);
 461     if (ret < 0) {
 462       if (errno != EINVAL)
 463         GST_ERROR_OBJECT (self, "VIDIOC_ENUM_FMT failed: %s",
 464             g_strerror (errno));
 465       continue;
 466     }
 467
 468     tmp = gst_v4l2_decoder_probe_caps_for_format (self, fmtdesc.pixelformat,
 469         fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height);
 470     caps = gst_caps_merge (caps, tmp);
 471   }
 472
 473   return caps;
 474 }
 475
 476 gboolean
 477 gst_v4l2_decoder_select_src_format (GstV4l2Decoder * self, GstCaps * caps,
 478     GstVideoInfo * info)
 479 {
 480   gint ret;
 481   struct v4l2_format fmt = {
 482     .type = self->src_buf_type,
 483   };
 484   GstStructure *str;
 485   const gchar *format_str;
 486   GstVideoFormat format;
 487   guint32 pix_fmt;
 488
 489   if (gst_caps_is_empty (caps))
 490     return FALSE;
 491
 492   ret = ioctl (self->video_fd, VIDIOC_G_FMT, &fmt);
 493   if (ret < 0) {
 494     GST_ERROR_OBJECT (self, "VIDIOC_G_FMT failed: %s", g_strerror (errno));
 495     return FALSE;
 496   }
 497
 498   caps = gst_caps_make_writable (caps);
 499   str = gst_caps_get_structure (caps, 0);
 500   gst_structure_fixate_field (str, "format");
 501
 502   format_str = gst_structure_get_string (str, "format");
 503   format = gst_video_format_from_string (format_str);
 504
 505   if (gst_v4l2_format_from_video_format (format, &pix_fmt) &&
 506       pix_fmt != fmt.fmt.pix_mp.pixelformat) {
 507     GST_DEBUG_OBJECT (self, "Trying to use peer format: %s ", format_str);
 508     fmt.fmt.pix_mp.pixelformat = pix_fmt;
 509
 510     ret = ioctl (self->video_fd, VIDIOC_S_FMT, &fmt);
 511     if (ret < 0) {
 512       GST_ERROR_OBJECT (self, "VIDIOC_S_FMT failed: %s", g_strerror (errno));
 513       return FALSE;
 514     }
 515   }
 516
 517   if (!gst_v4l2_format_to_video_info (&fmt, info)) {
 518     GST_ERROR_OBJECT (self, "Unsupported V4L2 pixelformat %" GST_FOURCC_FORMAT,
 519         GST_FOURCC_ARGS (fmt.fmt.pix_mp.pixelformat));
 520     return FALSE;
 521   }
 522
 523   GST_INFO_OBJECT (self, "Selected format %s %ix%i",
 524       gst_video_format_to_string (info->finfo->format),
 525       info->width, info->height);
 526
 527   return TRUE;
 528 }
 529
 530 gint
 531 gst_v4l2_decoder_request_buffers (GstV4l2Decoder * self,
 532     GstPadDirection direction, guint num_buffers)
 533 {
 534   gint ret;
 535   struct v4l2_requestbuffers reqbufs = {
 536     .count = num_buffers,
 537     .memory = V4L2_MEMORY_MMAP,
 538     .type = direction_to_buffer_type (self, direction),
 539   };
 540
 541   GST_DEBUG_OBJECT (self, "Requesting %u buffers", num_buffers);
 542
 543   ret = ioctl (self->video_fd, VIDIOC_REQBUFS, &reqbufs);
 544   if (ret < 0) {
 545     GST_ERROR_OBJECT (self, "VIDIOC_REQBUFS failed: %s", g_strerror (errno));
 546     return ret;
 547   }
 548
 549   if (direction == GST_PAD_SINK) {
 550     if (reqbufs.capabilities & V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF)
 551       self->supports_holding_capture = TRUE;
 552     else
 553       self->supports_holding_capture = FALSE;
 554   }
 555
 556   return reqbufs.count;
 557 }
 558
 559 gboolean
 560 gst_v4l2_decoder_export_buffer (GstV4l2Decoder * self,
 561     GstPadDirection direction, gint index, gint * fds, gsize * sizes,
 562     gsize * offsets, guint * num_fds)
 563 {
 564   gint i, ret;
 565   struct v4l2_plane planes[GST_VIDEO_MAX_PLANES] = { {0} };
 566   struct v4l2_buffer v4l2_buf = {
 567     .index = 0,
 568     .type = direction_to_buffer_type (self, direction),
 569   };
 570
 571   if (self->mplane) {
 572     v4l2_buf.length = GST_VIDEO_MAX_PLANES;
 573     v4l2_buf.m.planes = planes;
 574   }
 575
 576   ret = ioctl (self->video_fd, VIDIOC_QUERYBUF, &v4l2_buf);
 577   if (ret < 0) {
 578     GST_ERROR_OBJECT (self, "VIDIOC_QUERYBUF failed: %s", g_strerror (errno));
 579     return FALSE;
 580   }
 581
 582   if (self->mplane) {
 583     for (i = 0; i < v4l2_buf.length; i++) {
 584       struct v4l2_plane *plane = v4l2_buf.m.planes + i;
 585       struct v4l2_exportbuffer expbuf = {
 586         .type = direction_to_buffer_type (self, direction),
 587         .index = index,
 588         .plane = i,
 589         .flags = O_CLOEXEC | O_RDWR,
 590       };
 591
 592       ret = ioctl (self->video_fd, VIDIOC_EXPBUF, &expbuf);
 593       if (ret < 0) {
 594         gint j;
 595         GST_ERROR_OBJECT (self, "VIDIOC_EXPBUF failed: %s", g_strerror (errno));
 596
 597         for (j = i - 1; j >= 0; j--)
 598           close (fds[j]);
 599
 600         return FALSE;
 601       }
 602
 603       *num_fds = v4l2_buf.length;
 604       fds[i] = expbuf.fd;
 605       sizes[i] = plane->length;
 606       offsets[i] = plane->data_offset;
 607     }
 608   } else {
 609     struct v4l2_exportbuffer expbuf = {
 610       .type = direction_to_buffer_type (self, direction),
 611       .index = index,
 612       .flags = O_CLOEXEC | O_RDWR,
 613     };
 614
 615     ret = ioctl (self->video_fd, VIDIOC_EXPBUF, &expbuf);
 616     if (ret < 0) {
 617       GST_ERROR_OBJECT (self, "VIDIOC_EXPBUF failed: %s", g_strerror (errno));
 618       return FALSE;
 619     }
 620
 621     *num_fds = 1;
 622     fds[0] = expbuf.fd;
 623     sizes[0] = v4l2_buf.length;
 624     offsets[0] = 0;
 625   }
 626
 627   return TRUE;
 628 }
 629
 630 static gboolean
 631 gst_v4l2_decoder_queue_sink_mem (GstV4l2Decoder * self,
 632     GstV4l2Request * request, GstMemory * mem, guint32 frame_num, guint flags)
 633 {
 634   gint ret;
 635   gsize bytesused = gst_memory_get_sizes (mem, NULL, NULL);
 636   struct v4l2_plane plane = {
 637     .bytesused = bytesused,
 638   };
 639   struct v4l2_buffer buf = {
 640     .type = self->sink_buf_type,
 641     .memory = V4L2_MEMORY_MMAP,
 642     .index = gst_v4l2_codec_memory_get_index (mem),
 643     .timestamp.tv_sec = frame_num / 1000000,
 644     .timestamp.tv_usec = frame_num % 1000000,
 645     .request_fd = request->fd,
 646     .flags = V4L2_BUF_FLAG_REQUEST_FD | flags,
 647   };
 648
 649   GST_TRACE_OBJECT (self, "Queueing bitstream buffer %i", buf.index);
 650
 651   if (self->mplane) {
 652     buf.length = 1;
 653     buf.m.planes = &plane;
 654   } else {
 655     buf.bytesused = bytesused;
 656   }
 657
 658   ret = ioctl (self->video_fd, VIDIOC_QBUF, &buf);
 659   if (ret < 0) {
 660     GST_ERROR_OBJECT (self, "VIDIOC_QBUF failed: %s", g_strerror (errno));
 661     return FALSE;
 662   }
 663
 664   return TRUE;
 665 }
 666
 667 static gboolean
 668 gst_v4l2_decoder_queue_src_buffer (GstV4l2Decoder * self, GstBuffer * buffer)
 669 {
 670   gint i, ret;
 671   struct v4l2_plane planes[GST_VIDEO_MAX_PLANES];
 672   struct v4l2_buffer buf = {
 673     .type = self->src_buf_type,
 674     .memory = V4L2_MEMORY_MMAP,
 675     .index = gst_v4l2_codec_buffer_get_index (buffer),
 676   };
 677
 678   GST_TRACE_OBJECT (self, "Queuing picture buffer %i", buf.index);
 679
 680   if (self->mplane) {
 681     buf.length = gst_buffer_n_memory (buffer);
 682     buf.m.planes = planes;
 683     for (i = 0; i < buf.length; i++) {
 684       GstMemory *mem = gst_buffer_peek_memory (buffer, i);
 685       /* *INDENT-OFF* */
 686       planes[i] = (struct v4l2_plane) {
 687         .bytesused = gst_memory_get_sizes (mem, NULL, NULL),
 688       };
 689       /* *INDENT-ON* */
 690     }
 691   } else {
 692     buf.bytesused = gst_buffer_get_size (buffer);
 693   }
 694
 695   ret = ioctl (self->video_fd, VIDIOC_QBUF, &buf);
 696   if (ret < 0) {
 697     GST_ERROR_OBJECT (self, "VIDIOC_QBUF failed: %s", g_strerror (errno));
 698     return FALSE;
 699   }
 700
 701   return TRUE;
 702 }
 703
 704 static gboolean
 705 gst_v4l2_decoder_dequeue_sink (GstV4l2Decoder * self)
 706 {
 707   gint ret;
 708   struct v4l2_plane planes[GST_VIDEO_MAX_PLANES] = { {0} };
 709   struct v4l2_buffer buf = {
 710     .type = self->sink_buf_type,
 711     .memory = V4L2_MEMORY_MMAP,
 712   };
 713
 714   if (self->mplane) {
 715     buf.length = GST_VIDEO_MAX_PLANES;
 716     buf.m.planes = planes;
 717   }
 718
 719   ret = ioctl (self->video_fd, VIDIOC_DQBUF, &buf);
 720   if (ret < 0) {
 721     GST_ERROR_OBJECT (self, "VIDIOC_DQBUF failed: %s", g_strerror (errno));
 722     return FALSE;
 723   }
 724
 725   GST_TRACE_OBJECT (self, "Dequeued bitstream buffer %i", buf.index);
 726
 727   return TRUE;
 728 }
 729
 730 static gboolean
 731 gst_v4l2_decoder_dequeue_src (GstV4l2Decoder * self, guint32 * out_frame_num)
 732 {
 733   gint ret;
 734   struct v4l2_plane planes[GST_VIDEO_MAX_PLANES] = { {0} };
 735   struct v4l2_buffer buf = {
 736     .type = self->src_buf_type,
 737     .memory = V4L2_MEMORY_MMAP,
 738   };
 739
 740   if (self->mplane) {
 741     buf.length = GST_VIDEO_MAX_PLANES;
 742     buf.m.planes = planes;
 743   }
 744
 745   ret = ioctl (self->video_fd, VIDIOC_DQBUF, &buf);
 746   if (ret < 0) {
 747     GST_ERROR_OBJECT (self, "VIDIOC_DQBUF failed: %s", g_strerror (errno));
 748     return FALSE;
 749   }
 750
 751   *out_frame_num = buf.timestamp.tv_usec + buf.timestamp.tv_sec * 1000000;
 752
 753   GST_TRACE_OBJECT (self, "Dequeued picture buffer %i", buf.index);
 754
 755   return TRUE;
 756 }
 757
 758 gboolean
 759 gst_v4l2_decoder_set_controls (GstV4l2Decoder * self, GstV4l2Request * request,
 760     struct v4l2_ext_control * control, guint count)
 761 {
 762   gint ret;
 763   struct v4l2_ext_controls controls = {
 764     .controls = control,
 765     .count = count,
 766     .request_fd = request ? request->fd : 0,
 767     .which = request ? V4L2_CTRL_WHICH_REQUEST_VAL : 0,
 768   };
 769
 770   ret = ioctl (self->video_fd, VIDIOC_S_EXT_CTRLS, &controls);
 771   if (ret < 0) {
 772     GST_ERROR_OBJECT (self, "VIDIOC_S_EXT_CTRLS failed: %s",
 773         g_strerror (errno));
 774     return FALSE;
 775   }
 776
 777   return TRUE;
 778 }
 779
 780 gboolean
 781 gst_v4l2_decoder_get_controls (GstV4l2Decoder * self,
 782     struct v4l2_ext_control * control, guint count)
 783 {
 784   gint ret;
 785   struct v4l2_ext_controls controls = {
 786     .controls = control,
 787     .count = count,
 788   };
 789
 790   ret = ioctl (self->video_fd, VIDIOC_G_EXT_CTRLS, &controls);
 791   if (ret < 0) {
 792     GST_ERROR_OBJECT (self, "VIDIOC_G_EXT_CTRLS failed: %s",
 793         g_strerror (errno));
 794     return FALSE;
 795   }
 796
 797   return TRUE;
 798 }
 799
 800 gboolean
 801 gst_v4l2_decoder_query_control_size (GstV4l2Decoder * self,
 802     unsigned int control_id, unsigned int *control_size)
 803 {
 804   gint ret;
 805   struct v4l2_query_ext_ctrl control = {
 806     .id = control_id,
 807   };
 808
 809   if (control_size)
 810     *control_size = 0;
 811
 812   ret = ioctl (self->video_fd, VIDIOC_QUERY_EXT_CTRL, &control);
 813   if (ret < 0)
 814     /*
 815      * It's not an error if a control is not supported by this driver.
 816      * Return false but don't print any error.
 817      */
 818     return FALSE;
 819
 820   if (control_size)
 821     *control_size = control.elem_size;
 822   return TRUE;
 823 }
 824
 825 void
 826 gst_v4l2_decoder_install_properties (GObjectClass * gobject_class,
 827     gint prop_offset, GstV4l2CodecDevice * device)
 828 {
 829   const gchar *media_device_path = NULL;
 830   const gchar *video_device_path = NULL;
 831
 832   if (device) {
 833     media_device_path = device->media_device_path;
 834     video_device_path = device->video_device_path;
 835   }
 836
 837   g_object_class_install_property (gobject_class, PROP_MEDIA_DEVICE,
 838       g_param_spec_string ("media-device", "Media Device Path",
 839           "Path to the media device node", media_device_path,
 840           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 841
 842   g_object_class_install_property (gobject_class, PROP_VIDEO_DEVICE,
 843       g_param_spec_string ("video-device", "Video Device Path",
 844           "Path to the video device node", video_device_path,
 845           G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 846 }
 847
 848 void
 849 gst_v4l2_decoder_set_property (GObject * object, guint prop_id,
 850     const GValue * value, GParamSpec * pspec)
 851 {
 852   GstV4l2Decoder *self = GST_V4L2_DECODER (object);
 853
 854   switch (prop_id) {
 855     case PROP_MEDIA_DEVICE:
 856       g_free (self->media_device);
 857       self->media_device = g_value_dup_string (value);
 858       break;
 859     case PROP_VIDEO_DEVICE:
 860       g_free (self->video_device);
 861       self->video_device = g_value_dup_string (value);
 862       break;
 863     default:
 864       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 865       break;
 866   }
 867 }
 868
 869 void
 870 gst_v4l2_decoder_get_property (GObject * object, guint prop_id,
 871     GValue * value, GParamSpec * pspec)
 872 {
 873   GstV4l2Decoder *self = GST_V4L2_DECODER (object);
 874
 875   switch (prop_id) {
 876     case PROP_MEDIA_DEVICE:
 877       g_value_set_string (value, self->media_device);
 878       break;
 879     case PROP_VIDEO_DEVICE:
 880       g_value_set_string (value, self->video_device);
 881       break;
 882     default:
 883       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 884       break;
 885   }
 886 }
 887
 888 /**
 889  * gst_v4l2_decoder_register:
 890  * @plugin: a #GstPlugin
 891  * @dec_type: A #GType for the codec
 892  * @class_init: The #GClassInitFunc for #dec_type
 893  * @instance_init: The #GInstanceInitFunc for #dec_type
 894  * @element_name_tmpl: A string to use for the first codec found and as a template for the next ones.
 895  * @device: (transfer full) A #GstV4l2CodecDevice
 896  * @rank: The rank to use for the element
 897  * @class_data: (nullable) (transfer full) A #gpointer to pass as class_data, set to @device if null
 898  * @element_name (nullable) (out) Sets the pointer to the new element name
 899  *
 900  * Registers a decoder element as a subtype of @dec_type for @plugin.
 901  * Will create a different sub_types for each subsequent @decoder of the
 902  * same type.
 903  */
 904 void
 905 gst_v4l2_decoder_register (GstPlugin * plugin,
 906     GType dec_type, GClassInitFunc class_init, gconstpointer class_data,
 907     GInstanceInitFunc instance_init, const gchar * element_name_tmpl,
 908     GstV4l2CodecDevice * device, guint rank, gchar ** element_name)
 909 {
 910   GTypeQuery type_query;
 911   GTypeInfo type_info = { 0, };
 912   GType subtype;
 913   gchar *type_name;
 914
 915   g_type_query (dec_type, &type_query);
 916   memset (&type_info, 0, sizeof (type_info));
 917   type_info.class_size = type_query.class_size;
 918   type_info.instance_size = type_query.instance_size;
 919   type_info.class_init = class_init;
 920   type_info.class_data = class_data;
 921   type_info.instance_init = instance_init;
 922
 923   if (class_data == device)
 924     GST_MINI_OBJECT_FLAG_SET (device, GST_MINI_OBJECT_FLAG_MAY_BE_LEAKED);
 925
 926   /* The first decoder to be registered should use a constant name, like
 927    * v4l2slvp8dec, for any additional decoders, we create unique names. Decoder
 928    * names may change between boots, so this should help gain stable names for
 929    * the most common use cases. SL stands for state-less, we differentiate
 930    * with v4l2vp8dec as this element may not have the same properties */
 931   type_name = g_strdup_printf (element_name_tmpl, "");
 932
 933   if (g_type_from_name (type_name) != 0) {
 934     gchar *basename = g_path_get_basename (device->video_device_path);
 935     g_free (type_name);
 936     type_name = g_strdup_printf (element_name_tmpl, basename);
 937     g_free (basename);
 938   }
 939
 940   subtype = g_type_register_static (dec_type, type_name, &type_info, 0);
 941
 942   if (!gst_element_register (plugin, type_name, rank, subtype)) {
 943     GST_WARNING ("Failed to register plugin '%s'", type_name);
 944     g_free (type_name);
 945     type_name = NULL;
 946   }
 947
 948   if (element_name)
 949     *element_name = type_name;
 950   else
 951     g_free (type_name);
 952 }
 953
 954 /*
 955  * gst_v4l2_decoder_alloc_request:
 956  * @self a #GstV4l2Decoder pointer
 957  * @frame_num: Used as a timestamp to identify references
 958  * @bitstream the #GstMemory that holds the bitstream data
 959  * @pic_buf the #GstBuffer holding the decoded picture
 960  *
 961  * Allocate a Linux media request file descriptor. This request wrapper will
 962  * hold a reference to the requested bitstream memory to decoded and the
 963  * picture buffer this request will decode to. This will be used for
 964  * transparent management of the V4L2 queues.
 965  *
 966  * Returns: a new #GstV4l2Request
 967  */
 968 GstV4l2Request *
 969 gst_v4l2_decoder_alloc_request (GstV4l2Decoder * self, guint32 frame_num,
 970     GstMemory * bitstream, GstBuffer * pic_buf)
 971 {
 972   GstV4l2Request *request = gst_queue_array_pop_head (self->request_pool);
 973   gint ret;
 974
 975   if (!request) {
 976     request = g_new0 (GstV4l2Request, 1);
 977
 978     ret = ioctl (self->media_fd, MEDIA_IOC_REQUEST_ALLOC, &request->fd);
 979     if (ret < 0) {
 980       GST_ERROR_OBJECT (self, "MEDIA_IOC_REQUEST_ALLOC failed: %s",
 981           g_strerror (errno));
 982       return NULL;
 983     }
 984
 985     request->poll = gst_poll_new (FALSE);
 986     gst_poll_fd_init (&request->pollfd);
 987     request->pollfd.fd = request->fd;
 988     gst_poll_add_fd (request->poll, &request->pollfd);
 989     gst_poll_fd_ctl_pri (request->poll, &request->pollfd, TRUE);
 990   }
 991
 992   request->decoder = g_object_ref (self);
 993   request->bitstream = gst_memory_ref (bitstream);
 994   request->pic_buf = gst_buffer_ref (pic_buf);
 995   request->frame_num = frame_num;
 996   request->ref_count = 1;
 997
 998   return request;
 999 }
1000
1001 /*
1002  * gst_v4l2_decoder_alloc_sub_request:
1003  * @self a #GstV4l2Decoder pointer
1004  * @prev_request the #GstV4l2Request this request continue
1005  * @bitstream the #GstMemory that holds the bitstream data
1006  *
1007  * Allocate a Linux media request file descriptor. Similar to
1008  * gst_v4l2_decoder_alloc_request(), but used when a request is the
1009  * continuation of the decoding of the same picture. This is notably the case
1010  * for subsequent slices or for second field of a frame.
1011  *
1012  * Returns: a new #GstV4l2Request
1013  */
1014 GstV4l2Request *
1015 gst_v4l2_decoder_alloc_sub_request (GstV4l2Decoder * self,
1016     GstV4l2Request * prev_request, GstMemory * bitstream)
1017 {
1018   GstV4l2Request *request = gst_queue_array_pop_head (self->request_pool);
1019   gint ret;
1020
1021   if (!request) {
1022     request = g_new0 (GstV4l2Request, 1);
1023
1024     ret = ioctl (self->media_fd, MEDIA_IOC_REQUEST_ALLOC, &request->fd);
1025     if (ret < 0) {
1026       GST_ERROR_OBJECT (self, "MEDIA_IOC_REQUEST_ALLOC failed: %s",
1027           g_strerror (errno));
1028       return NULL;
1029     }
1030
1031     request->poll = gst_poll_new (FALSE);
1032     gst_poll_fd_init (&request->pollfd);
1033     request->pollfd.fd = request->fd;
1034     gst_poll_add_fd (request->poll, &request->pollfd);
1035     gst_poll_fd_ctl_pri (request->poll, &request->pollfd, TRUE);
1036   }
1037
1038   request->decoder = g_object_ref (self);
1039   request->bitstream = gst_memory_ref (bitstream);
1040   request->pic_buf = gst_buffer_ref (prev_request->pic_buf);
1041   request->frame_num = prev_request->frame_num;
1042   request->sub_request = TRUE;
1043   request->ref_count = 1;
1044
1045   return request;
1046 }
1047
1048 /**
1049  * gst_v4l2_decoder_set_render_delay:
1050  * @self: a #GstV4l2Decoder pointer
1051  * @delay: The expected render delay
1052  *
1053  * The decoder will adjust the number of allowed concurrent request in order
1054  * to allow this delay. The same number of concurrent bitstream buffer will be
1055  * used, so make sure to adjust the number of bitstream buffer.
1056  *
1057  * For per-slice decoder, this is the maximum number of pending slice, so the
1058  * render backlog in frame may be less then the render delay.
1059  */
1060 void
1061 gst_v4l2_decoder_set_render_delay (GstV4l2Decoder * self, guint delay)
1062 {
1063   self->render_delay = delay;
1064 }
1065
1066 /**
1067  * gst_v4l2_decoder_get_render_delay:
1068  * @self: a #GstV4l2Decoder pointer
1069  *
1070  * This function is used to avoid storing the render delay in multiple places.
1071  *
1072  * Returns: The currently configured render delay.
1073  */
1074 guint
1075 gst_v4l2_decoder_get_render_delay (GstV4l2Decoder * self)
1076 {
1077   return self->render_delay;
1078 }
1079
1080 GstV4l2Request *
1081 gst_v4l2_request_ref (GstV4l2Request * request)
1082 {
1083   request->ref_count++;
1084   return request;
1085 }
1086
1087 static void
1088 gst_v4l2_request_free (GstV4l2Request * request)
1089 {
1090   GstV4l2Decoder *decoder = request->decoder;
1091
1092   request->decoder = NULL;
1093   close (request->fd);
1094   gst_poll_free (request->poll);
1095   g_free (request);
1096
1097   if (decoder)
1098     g_object_unref (decoder);
1099 }
1100
1101 void
1102 gst_v4l2_request_unref (GstV4l2Request * request)
1103 {
1104   GstV4l2Decoder *decoder = request->decoder;
1105   gint ret;
1106
1107   g_return_if_fail (request->ref_count > 0);
1108
1109   if (--request->ref_count > 0)
1110     return;
1111
1112   g_clear_pointer (&request->bitstream, gst_memory_unref);
1113   g_clear_pointer (&request->pic_buf, gst_buffer_unref);
1114   request->frame_num = G_MAXUINT32;
1115   request->failed = FALSE;
1116   request->hold_pic_buf = FALSE;
1117   request->sub_request = FALSE;
1118
1119   if (request->pending) {
1120     gint idx;
1121
1122     GST_DEBUG_OBJECT (decoder, "Freeing pending request %i.", request->fd);
1123
1124     idx = gst_queue_array_find (decoder->pending_requests, NULL, request);
1125     if (idx >= 0)
1126       gst_queue_array_drop_element (decoder->pending_requests, idx);
1127
1128     gst_v4l2_request_free (request);
1129     return;
1130   }
1131
1132   GST_TRACE_OBJECT (decoder, "Recycling request %i.", request->fd);
1133
1134   ret = ioctl (request->fd, MEDIA_REQUEST_IOC_REINIT, NULL);
1135   if (ret < 0) {
1136     GST_ERROR_OBJECT (request->decoder, "MEDIA_REQUEST_IOC_REINIT failed: %s",
1137         g_strerror (errno));
1138     gst_v4l2_request_free (request);
1139     return;
1140   }
1141
1142   gst_queue_array_push_tail (decoder->request_pool, request);
1143   g_clear_object (&request->decoder);
1144 }
1145
1146 gboolean
1147 gst_v4l2_request_queue (GstV4l2Request * request, guint flags)
1148 {
1149   GstV4l2Decoder *decoder = request->decoder;
1150   gint ret;
1151   guint max_pending;
1152
1153   GST_TRACE_OBJECT (decoder, "Queuing request %i.", request->fd);
1154
1155   /* this would lead to stalls if we tried to use this feature and it wasn't
1156    * supported. */
1157   if ((flags & V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF)
1158       && !decoder->supports_holding_capture) {
1159     GST_ERROR_OBJECT (decoder,
1160         "Driver does not support holding capture buffer.");
1161     return FALSE;
1162   }
1163
1164   if (!gst_v4l2_decoder_queue_sink_mem (decoder, request,
1165           request->bitstream, request->frame_num, flags)) {
1166     GST_ERROR_OBJECT (decoder, "Driver did not accept the bitstream data.");
1167     return FALSE;
1168   }
1169
1170   if (!request->sub_request &&
1171       !gst_v4l2_decoder_queue_src_buffer (decoder, request->pic_buf)) {
1172     GST_ERROR_OBJECT (decoder, "Driver did not accept the picture buffer.");
1173     return FALSE;
1174   }
1175
1176   ret = ioctl (request->fd, MEDIA_REQUEST_IOC_QUEUE, NULL);
1177   if (ret < 0) {
1178     GST_ERROR_OBJECT (decoder, "MEDIA_REQUEST_IOC_QUEUE, failed: %s",
1179         g_strerror (errno));
1180     return FALSE;
1181   }
1182
1183   if (flags & V4L2_BUF_FLAG_M2M_HOLD_CAPTURE_BUF)
1184     request->hold_pic_buf = TRUE;
1185
1186   request->pending = TRUE;
1187   gst_queue_array_push_tail (decoder->pending_requests,
1188       gst_v4l2_request_ref (request));
1189
1190   max_pending = MAX (1, decoder->render_delay);
1191
1192   if (gst_queue_array_get_length (decoder->pending_requests) > max_pending) {
1193     GstV4l2Request *pending_req;
1194
1195     pending_req = gst_queue_array_peek_head (decoder->pending_requests);
1196     gst_v4l2_request_set_done (pending_req);
1197   }
1198
1199   return TRUE;
1200 }
1201
1202 gint
1203 gst_v4l2_request_set_done (GstV4l2Request * request)
1204 {
1205   GstV4l2Decoder *decoder = request->decoder;
1206   GstV4l2Request *pending_req = NULL;
1207   gint ret;
1208
1209   if (!request->pending)
1210     return 1;
1211
1212   GST_DEBUG_OBJECT (decoder, "Waiting for request %i to complete.",
1213       request->fd);
1214
1215   ret = gst_poll_wait (request->poll, GST_SECOND);
1216   if (ret == 0) {
1217     GST_WARNING_OBJECT (decoder, "Request %i took too long.", request->fd);
1218     return 0;
1219   }
1220
1221   if (ret < 0) {
1222     GST_WARNING_OBJECT (decoder, "Request %i error: %s (%i)",
1223         request->fd, g_strerror (errno), errno);
1224     return ret;
1225   }
1226
1227   while ((pending_req = gst_queue_array_pop_head (decoder->pending_requests))) {
1228     gst_v4l2_decoder_dequeue_sink (decoder);
1229     g_clear_pointer (&pending_req->bitstream, gst_memory_unref);
1230
1231     if (!pending_req->hold_pic_buf) {
1232       guint32 frame_num = G_MAXUINT32;
1233
1234       if (!gst_v4l2_decoder_dequeue_src (decoder, &frame_num)) {
1235         pending_req->failed = TRUE;
1236       } else if (frame_num != pending_req->frame_num) {
1237         GST_WARNING_OBJECT (decoder,
1238             "Requested frame %u, but driver returned frame %u.",
1239             pending_req->frame_num, frame_num);
1240         pending_req->failed = TRUE;
1241       }
1242     }
1243
1244     pending_req->pending = FALSE;
1245     gst_v4l2_request_unref (pending_req);
1246
1247     if (pending_req == request)
1248       break;
1249   }
1250
1251   /* Pending request must be in the pending request list */
1252   g_assert (pending_req == request);
1253
1254   return ret;
1255 }
1256
1257 gboolean
1258 gst_v4l2_request_failed (GstV4l2Request * request)
1259 {
1260   return request->failed;
1261 }
1262
1263 GstBuffer *
1264 gst_v4l2_request_dup_pic_buf (GstV4l2Request * request)
1265 {
1266   return gst_buffer_ref (request->pic_buf);
1267 }
1268
1269 gint
1270 gst_v4l2_request_get_fd (GstV4l2Request * request)
1271 {
1272   return request->fd;
1273 }