Add a tech preview eglfs device integration for VSP2 composition

This creates a new device integration for eglfs, eglfs_kms_vsp2, that's very
similar to eglfs_kms_gbm, but includes an extra step for doing VSP2 hardware
compositing.

The main Qt content is drawn to double buffered off-screen GBM buffers which
are converted using drmPrimeHandleToFD so we get DMA buffer file descriptors
that can be used by the VSP2 blending hardware. The blending hardware writes to
double buffered DRM dumb buffers, which are flipped with drmModePageFlip.

Communicating with the VSP2 is done using the Video4Linux2 (V4L2) streaming
API. There are two steps in creating abstractions for this. First, there is the
QLinuxMedia class that consists of a Qt style wrapper for V4L2 without anything
VSP2 specific. Second, there is QVsp2BlendingDevice which hides some of the
streaming details of the VSP2 and has some level of error recovery. Both
classes include a fair bit of logging and error reporting.

The patch is written with Wayland compositors in mind, but should work for
other use cases as well.

This is just the basic support to make compositing work, additional features
may be added in subsequent patches, i.e:

- Auto-detect VSP2 (-feature-vsp2 currently needs to be explicitly enabled).
- Support for setting the alpha value of a layer.
- Support clipping layers.
- Support for scaling layers.
- Support for other output formats than RGBA32.
- Hardware cursor support.
- Support foreign layers below the main Qt layer.
- Support for memory mapped and user pointer buffer types (currently only DMA
  buffers are supported).

Change-Id: I1917d2dbdbaeded0d9c021baaa799d56afe1a9bd
Reviewed-by: Laszlo Agocs <laszlo.agocs@qt.io>

1 files changed, 607 insertions, 0 deletions

diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_vsp2/qlinuxmediadevice.cpp b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_vsp2/qlinuxmediadevice.cpp
new file mode 100644
index 0000000000..21de052b87
--- /dev/null
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_vsp2/qlinuxmediadevice.cpp
@@ -0,0 +1,607 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qeglfsintegration_p.h"
+#include "qlinuxmediadevice.h"
+#include <qeglfskmshelpers.h>
+
+#include <QtCore/QLoggingCategory>
+#include <QtCore/QSize>
+#include <QtCore/QRect>
+
+#include <sys/ioctl.h>
+#include <fcntl.h>
+
+#include <cstdlib> //this needs to go before mediactl/mediactl.h because it uses size_t without including it
+extern "C" {
+#include <mediactl/mediactl.h>
+#include <mediactl/v4l2subdev.h>
+}
+
+QT_BEGIN_NAMESPACE
+
+Q_DECLARE_LOGGING_CATEGORY(qLcEglfsKmsDebug)
+
+static QString mediaBusFmtToString(uint code)
+{
+    switch (code) {
+    case MEDIA_BUS_FMT_FIXED: return "FIXED";
+    case MEDIA_BUS_FMT_RGB444_1X12: return "RGB444_1X12";
+//    case MEDIA_BUS_FMT_RGB444_2X8_PADHI_B: return "RGB444_2X8_PADHI_B";
+//    case MEDIA_BUS_FMT_RGB444_2X8_PADHI_L: return "RGB444_2X8_PADHI_L";
+//    case MEDIA_BUS_FMT_RGB555_2X8_PADHI_B: return "RGB555_2X8_PADHI_B";
+//    case MEDIA_BUS_FMT_RGB555_2X8_PADHI_L: return "RGB555_2X8_PADHI_L";
+    case MEDIA_BUS_FMT_RGB565_1X16: return "RGB565_1X16";
+    case MEDIA_BUS_FMT_BGR565_2X8_BE: return "BGR565_2X8_BE";
+    case MEDIA_BUS_FMT_BGR565_2X8_LE: return "BGR565_2X8_LE";
+    case MEDIA_BUS_FMT_RGB565_2X8_BE: return "RGB565_2X8_BE";
+    case MEDIA_BUS_FMT_RGB565_2X8_LE: return "RGB565_2X8_LE";
+    case MEDIA_BUS_FMT_RGB666_1X18: return "RGB666_1X18";
+    case MEDIA_BUS_FMT_RBG888_1X24: return "RBG888_1X24";
+//    case MEDIA_BUS_FMT_RGB666_1X24_CPADH: return "RGB666_1X24_CPADH";
+    case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG: return "RGB666_1X7X3_SPWG";
+    case MEDIA_BUS_FMT_BGR888_1X24: return "BGR888_1X24";
+    case MEDIA_BUS_FMT_GBR888_1X24: return "GBR888_1X24";
+    case MEDIA_BUS_FMT_RGB888_1X24: return "RGB888_1X24";
+    case MEDIA_BUS_FMT_RGB888_2X12_BE: return "RGB888_2X12_BE";
+    case MEDIA_BUS_FMT_RGB888_2X12_LE: return "RGB888_2X12_LE";
+    case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG: return "RGB888_1X7X4_SPWG";
+//    case MEDIA_BUS_FMT_RGB888_1X7X4_JEID: return "RGB888_1X7X4_JEID";
+    case MEDIA_BUS_FMT_ARGB8888_1X32: return "ARGB8888_1X32";
+    case MEDIA_BUS_FMT_RGB888_1X32_PADHI: return "RGB888_1X32_PADHI";
+//    case MEDIA_BUS_FMT_RGB101010_1X30: return "RGB101010_1X30";
+//    case MEDIA_BUS_FMT_RGB121212_1X36: return "RGB121212_1X36";
+//    case MEDIA_BUS_FMT_RGB161616_1X48: return "RGB161616_1X48";
+    case MEDIA_BUS_FMT_Y8_1X8: return "Y8_1X8";
+    case MEDIA_BUS_FMT_UV8_1X8: return "UV8_1X8";
+    case MEDIA_BUS_FMT_UYVY8_1_5X8: return "UYVY8_1_5X8";
+    case MEDIA_BUS_FMT_VYUY8_1_5X8: return "VYUY8_1_5X8";
+    case MEDIA_BUS_FMT_YUYV8_1_5X8: return "YUYV8_1_5X8";
+    case MEDIA_BUS_FMT_YVYU8_1_5X8: return "YVYU8_1_5X8";
+    case MEDIA_BUS_FMT_UYVY8_2X8: return "UYVY8_2X8";
+    case MEDIA_BUS_FMT_VYUY8_2X8: return "VYUY8_2X8";
+    case MEDIA_BUS_FMT_YUYV8_2X8: return "YUYV8_2X8";
+    case MEDIA_BUS_FMT_YVYU8_2X8: return "YVYU8_2X8";
+    case MEDIA_BUS_FMT_Y10_1X10: return "Y10_1X10";
+    case MEDIA_BUS_FMT_UYVY10_2X10: return "UYVY10_2X10";
+    case MEDIA_BUS_FMT_VYUY10_2X10: return "VYUY10_2X10";
+    case MEDIA_BUS_FMT_YUYV10_2X10: return "YUYV10_2X10";
+    case MEDIA_BUS_FMT_YVYU10_2X10: return "YVYU10_2X10";
+    case MEDIA_BUS_FMT_Y12_1X12: return "Y12_1X12";
+    case MEDIA_BUS_FMT_UYVY12_2X12: return "UYVY12_2X12";
+    case MEDIA_BUS_FMT_VYUY12_2X12: return "VYUY12_2X12";
+    case MEDIA_BUS_FMT_YUYV12_2X12: return "YUYV12_2X12";
+    case MEDIA_BUS_FMT_YVYU12_2X12: return "YVYU12_2X12";
+    case MEDIA_BUS_FMT_UYVY8_1X16: return "UYVY8_1X16";
+    case MEDIA_BUS_FMT_VYUY8_1X16: return "VYUY8_1X16";
+    case MEDIA_BUS_FMT_YUYV8_1X16: return "YUYV8_1X16";
+    case MEDIA_BUS_FMT_YVYU8_1X16: return "YVYU8_1X16";
+    case MEDIA_BUS_FMT_YDYUYDYV8_1X16: return "YDYUYDYV8_1X16";
+    case MEDIA_BUS_FMT_UYVY10_1X20: return "UYVY10_1X20";
+    case MEDIA_BUS_FMT_VYUY10_1X20: return "VYUY10_1X20";
+    case MEDIA_BUS_FMT_YUYV10_1X20: return "YUYV10_1X20";
+    case MEDIA_BUS_FMT_YVYU10_1X20: return "YVYU10_1X20";
+    case MEDIA_BUS_FMT_VUY8_1X24: return "VUY8_1X24";
+    case MEDIA_BUS_FMT_YUV8_1X24: return "YUV8_1X24";
+//    case MEDIA_BUS_FMT_UYYVYY8_0_5X24: return "UYYVYY8_0_5X24";
+    case MEDIA_BUS_FMT_UYVY12_1X24: return "UYVY12_1X24";
+    case MEDIA_BUS_FMT_VYUY12_1X24: return "VYUY12_1X24";
+    case MEDIA_BUS_FMT_YUYV12_1X24: return "YUYV12_1X24";
+    case MEDIA_BUS_FMT_YVYU12_1X24: return "YVYU12_1X24";
+    case MEDIA_BUS_FMT_YUV10_1X30: return "YUV10_1X30";
+//    case MEDIA_BUS_FMT_UYYVYY10_0_5X30: return "UYYVYY10_0_5X30";
+    case MEDIA_BUS_FMT_AYUV8_1X32: return "AYUV8_1X32";
+//    case MEDIA_BUS_FMT_UYYVYY12_0_5X36: return "UYYVYY12_0_5X36";
+//    case MEDIA_BUS_FMT_YUV12_1X36: return "YUV12_1X36";
+//    case MEDIA_BUS_FMT_YUV16_1X48: return "YUV16_1X48";
+//    case MEDIA_BUS_FMT_UYYVYY16_0_5X48: return "UYYVYY16_0_5X48";
+    case MEDIA_BUS_FMT_SBGGR8_1X8: return "SBGGR8_1X8";
+    case MEDIA_BUS_FMT_SGBRG8_1X8: return "SGBRG8_1X8";
+    case MEDIA_BUS_FMT_SGRBG8_1X8: return "SGRBG8_1X8";
+    case MEDIA_BUS_FMT_SRGGB8_1X8: return "SRGGB8_1X8";
+    case MEDIA_BUS_FMT_SBGGR10_ALAW8_1X8: return "SBGGR10_ALAW8_1X8";
+    case MEDIA_BUS_FMT_SGBRG10_ALAW8_1X8: return "SGBRG10_ALAW8_1X8";
+    case MEDIA_BUS_FMT_SGRBG10_ALAW8_1X8: return "SGRBG10_ALAW8_1X8";
+    case MEDIA_BUS_FMT_SRGGB10_ALAW8_1X8: return "SRGGB10_ALAW8_1X8";
+    case MEDIA_BUS_FMT_SBGGR10_DPCM8_1X8: return "SBGGR10_DPCM8_1X8";
+    case MEDIA_BUS_FMT_SGBRG10_DPCM8_1X8: return "SGBRG10_DPCM8_1X8";
+    case MEDIA_BUS_FMT_SGRBG10_DPCM8_1X8: return "SGRBG10_DPCM8_1X8";
+    case MEDIA_BUS_FMT_SRGGB10_DPCM8_1X8: return "SRGGB10_DPCM8_1X8";
+//    case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_B: return "SBGGR10_2X8_PADHI_B";
+//    case MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_L: return "SBGGR10_2X8_PADHI_L";
+//    case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_B: return "SBGGR10_2X8_PADLO_B";
+//    case MEDIA_BUS_FMT_SBGGR10_2X8_PADLO_L: return "SBGGR10_2X8_PADLO_L";
+    case MEDIA_BUS_FMT_SBGGR10_1X10: return "SBGGR10_1X10";
+    case MEDIA_BUS_FMT_SGBRG10_1X10: return "SGBRG10_1X10";
+    case MEDIA_BUS_FMT_SGRBG10_1X10: return "SGRBG10_1X10";
+    case MEDIA_BUS_FMT_SRGGB10_1X10: return "SRGGB10_1X10";
+    case MEDIA_BUS_FMT_SBGGR12_1X12: return "SBGGR12_1X12";
+    case MEDIA_BUS_FMT_SGBRG12_1X12: return "SGBRG12_1X12";
+    case MEDIA_BUS_FMT_SGRBG12_1X12: return "SGRBG12_1X12";
+    case MEDIA_BUS_FMT_SRGGB12_1X12: return "SRGGB12_1X12";
+    case MEDIA_BUS_FMT_SBGGR14_1X14: return "SBGGR14_1X14";
+    case MEDIA_BUS_FMT_SGBRG14_1X14: return "SGBRG14_1X14";
+    case MEDIA_BUS_FMT_SGRBG14_1X14: return "SGRBG14_1X14";
+    case MEDIA_BUS_FMT_SRGGB14_1X14: return "SRGGB14_1X14";
+    case MEDIA_BUS_FMT_SBGGR16_1X16: return "SBGGR16_1X16";
+    case MEDIA_BUS_FMT_SGBRG16_1X16: return "SGBRG16_1X16";
+    case MEDIA_BUS_FMT_SGRBG16_1X16: return "SGRBG16_1X16";
+    case MEDIA_BUS_FMT_SRGGB16_1X16: return "SRGGB16_1X16";
+    case MEDIA_BUS_FMT_JPEG_1X8: return "JPEG_1X8";
+    case MEDIA_BUS_FMT_S5C_UYVY_JPEG_1X8: return "S5C_UYVY_JPEG_1X8";
+    case MEDIA_BUS_FMT_AHSV8888_1X32: return "AHSV8888_1X32";
+    default: return QString(code);
+    }
+}
+
+static QDebug operator<<(QDebug debug, const struct v4l2_mbus_framefmt &format)
+{
+    QDebugStateSaver saver(debug);
+    debug.nospace() << "v4l2_mbus_framefmt("
+                    << "code: " << mediaBusFmtToString(format.code) << ", "
+                    << "size: " << format.width << "x" << format.height << ")";
+    return debug;
+}
+
+static QDebug operator<<(QDebug debug, const struct v4l2_pix_format_mplane &format)
+{
+    QDebugStateSaver saver(debug);
+    debug.nospace() << "v4l2_pix_format_mplane("
+                    << "pixel format: " << q_fourccToString(format.pixelformat) << ", "
+                    << "size: " << format.width << "x" << format.height << ", "
+                    << "planes: " << format.num_planes << ")";
+    return debug;
+}
+
+QLinuxMediaDevice::QLinuxMediaDevice(const QString &devicePath)
+    : m_mediaDevice(media_device_new(devicePath.toStdString().c_str()))
+{
+    if (!m_mediaDevice)
+        qFatal("Couldn't get media device");
+
+    if (media_device_enumerate(m_mediaDevice))
+        qFatal("Couldn't enumerate media device");
+
+    m_info = media_get_info(m_mediaDevice);
+
+    qCDebug(qLcEglfsKmsDebug) << "Opened linux media device:"
+                              << "\n\t Path:" << devicePath
+                              << "\n\t Model:" << model()
+                              << "\n\t Device name:" << deviceName();
+
+    resetLinks();
+}
+
+QLinuxMediaDevice::~QLinuxMediaDevice()
+{
+    if (m_mediaDevice)
+        media_device_unref(m_mediaDevice);
+}
+
+QString QLinuxMediaDevice::model()
+{
+    return QString(m_info->model);
+}
+
+QString QLinuxMediaDevice::deviceName()
+{
+    return QString(m_info->bus_info).split(":").last();
+}
+
+bool QLinuxMediaDevice::resetLinks()
+{
+    if (media_reset_links(m_mediaDevice)) {
+        qWarning() << "Could not reset media controller links.";
+        return false;
+    }
+    qCDebug(qLcEglfsKmsDebug) << "Reset media links";
+    return true;
+}
+
+struct media_link *QLinuxMediaDevice::parseLink(const QString &link)
+{
+    char *endp = nullptr;;
+    struct media_link *mediaLink = media_parse_link(m_mediaDevice, link.toStdString().c_str(), &endp);
+
+    if (!mediaLink)
+        qWarning() << "Failed to parse media link:" << link;
+
+    return mediaLink;
+}
+
+struct media_pad *QLinuxMediaDevice::parsePad(const QString &pad)
+{
+    struct media_pad *mediaPad = media_parse_pad(m_mediaDevice, pad.toStdString().c_str(), nullptr);
+
+    if (!mediaPad)
+        qWarning() << "Failed to parse media pad:" << pad;
+
+    return mediaPad;
+}
+
+bool QLinuxMediaDevice::enableLink(struct media_link *link)
+{
+    if (media_setup_link(m_mediaDevice, link->source, link->sink, 1)) {
+        qWarning() << "Failed to enable media link.";
+        return false;
+    }
+    return true;
+}
+
+bool QLinuxMediaDevice::disableLink(struct media_link *link)
+{
+    if (media_setup_link(m_mediaDevice, link->source, link->sink, 0)) {
+        qWarning() << "Failed to disable media link.";
+        return false;
+    }
+    return true;
+}
+
+media_entity *QLinuxMediaDevice::getEntity(const QString &name)
+{
+    struct media_entity *entity = media_get_entity_by_name(m_mediaDevice, name.toStdString().c_str(), name.length());
+
+    if (!entity)
+        qWarning() << "Failed to get media entity:" << name;
+
+    return entity;
+}
+
+int QLinuxMediaDevice::openVideoDevice(const QString &name)
+{
+    struct media_entity *entity = getEntity(name);
+    const char *deviceName = media_entity_get_devname(entity);
+    int fd = open(deviceName, O_RDWR);
+    qCDebug(qLcEglfsKmsDebug) << "Opened video device:" << deviceName << "with fd" << fd;
+    return fd;
+}
+
+QLinuxMediaDevice::CaptureSubDevice::CaptureSubDevice(QLinuxMediaDevice *mediaDevice, const QString &name)
+    : m_subdevFd(mediaDevice->openVideoDevice(name))
+{
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::setFormat(const QSize &size, uint32_t pixelFormat)
+{
+    Q_ASSERT(size.isValid());
+    struct v4l2_format format;
+    memset(&format, 0, sizeof(struct v4l2_format));
+    format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    if (ioctl(m_subdevFd, VIDIOC_G_FMT, &format) == -1) {
+        qErrnoWarning("VIDIOC_G_FMT for capture device failed");
+        return false;
+    }
+
+    format.fmt.pix_mp.width = static_cast<uint>(size.width());
+    format.fmt.pix_mp.height = static_cast<uint>(size.height());
+    format.fmt.pix_mp.field = V4L2_FIELD_NONE;
+    format.fmt.pix_mp.pixelformat = pixelFormat;
+    format.fmt.pix_mp.num_planes = 1;
+    format.fmt.pix_mp.flags = 0;
+    format.fmt.pix_mp.plane_fmt[0].bytesperline = 0;
+    format.fmt.pix_mp.plane_fmt[0].sizeimage = 0;
+
+    if (ioctl(m_subdevFd, VIDIOC_S_FMT, &format) == -1) {
+        qWarning() << "Capture device" << m_subdevFd << "VIDIOC_S_FMT with format" << format.fmt.pix_mp
+                   << "failed:" << strerror(errno);
+        return false;
+    }
+
+    qCDebug(qLcEglfsKmsDebug) << "Capture device" << m_subdevFd << "format set:" << format.fmt.pix_mp;
+    return true;
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::clearBuffers()
+{
+    struct v4l2_requestbuffers requestBuffers;
+    memset(&requestBuffers, 0, sizeof(requestBuffers));
+    requestBuffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    requestBuffers.memory = V4L2_MEMORY_DMABUF;
+    requestBuffers.count = 0;
+    if (ioctl(m_subdevFd, VIDIOC_REQBUFS, &requestBuffers) == -1) {
+        qWarning("Capture device %d: VIDIOC_REQBUFS clear failed: %s", m_subdevFd, strerror(errno));
+        return false;
+    }
+    qCDebug(qLcEglfsKmsDebug, "Capture device %d: Deallocced buffers with REQBUF, now has %d buffers", m_subdevFd, requestBuffers.count);
+    Q_ASSERT(requestBuffers.count == 0);
+    return true;
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::requestBuffer()
+{
+    struct v4l2_requestbuffers requestBuffers;
+    memset(&requestBuffers, 0, sizeof(requestBuffers));
+    requestBuffers.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    requestBuffers.memory = V4L2_MEMORY_DMABUF;
+    requestBuffers.count = 1;
+    if (ioctl(m_subdevFd, VIDIOC_REQBUFS, &requestBuffers) == -1) {
+        if (errno == EINVAL)
+            qWarning("Capture device %d: Multi-planar capture or dma buffers not supported", m_subdevFd);
+        qWarning("Capture device %d: VIDIOC_REQBUFS failed: %s", m_subdevFd, strerror(errno));
+        return false;
+    }
+    Q_ASSERT(requestBuffers.count == 1);
+    return true;
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::queueBuffer(int dmabufFd, const QSize &bufferSize)
+{
+    const uint numPlanes = 1;
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    buffer.memory = V4L2_MEMORY_DMABUF;
+    buffer.index = 0;
+
+    struct v4l2_plane planes[VIDEO_MAX_PLANES];
+    buffer.m.planes = planes;
+    buffer.length = numPlanes;
+    memset(planes, 0, sizeof(planes));
+    for (uint i = 0; i < numPlanes; i++) {
+        buffer.m.planes[i].m.fd = dmabufFd;
+        buffer.m.planes[i].length = static_cast<uint>(bufferSize.width() * bufferSize.height() * 4); //TODO: don't harcode bpp
+        buffer.m.planes[i].bytesused = static_cast<uint>(bufferSize.width() * bufferSize.height() * 4); //TODO: don't harcode bpp
+    }
+
+    if (ioctl(m_subdevFd, VIDIOC_QBUF, &buffer) == -1) {
+        qWarning("Capture device %d: VIDIOC_QBUF failed for dma buffer with fd %d: %s",
+                 m_subdevFd, dmabufFd, strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::dequeueBuffer()
+{
+    const int numPlanes = 1;
+    struct v4l2_buffer buffer;
+    struct v4l2_plane planes[VIDEO_MAX_PLANES];
+
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    buffer.memory = V4L2_MEMORY_DMABUF;
+    buffer.index = 0;
+    buffer.m.planes = planes;
+    buffer.length = numPlanes;
+    memset(planes, 0, sizeof(planes));
+
+    if (ioctl(m_subdevFd, VIDIOC_DQBUF, &buffer) == -1) {
+        qWarning("Capture device %d: VIDIOC_DQBUF failed: %s", m_subdevFd, strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::streamOn()
+{
+    return QLinuxMediaDevice::streamOn(m_subdevFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+}
+
+bool QLinuxMediaDevice::CaptureSubDevice::streamOff()
+{
+    return QLinuxMediaDevice::streamOff(m_subdevFd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+}
+
+QLinuxMediaDevice::OutputSubDevice::OutputSubDevice(QLinuxMediaDevice *mediaDevice, const QString &name)
+    : m_subdevFd(mediaDevice->openVideoDevice(name))
+{
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::setFormat(const QSize &size, uint32_t pixelFormat, uint32_t bytesPerLine)
+{
+    Q_ASSERT(size.isValid());
+    struct v4l2_format format;
+    memset(&format, 0, sizeof(struct v4l2_format));
+    format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    if (ioctl(m_subdevFd, VIDIOC_G_FMT, &format) == -1) {
+        qErrnoWarning("VIDIOC_G_FMT for output device failed");
+        return false;
+    }
+
+    format.fmt.pix_mp.width = static_cast<uint>(size.width());
+    format.fmt.pix_mp.height = static_cast<uint>(size.height());
+    format.fmt.pix_mp.field = V4L2_FIELD_NONE;
+    format.fmt.pix_mp.pixelformat = pixelFormat;
+    format.fmt.pix_mp.num_planes = 1;
+    format.fmt.pix_mp.flags = 0;
+    format.fmt.pix_mp.plane_fmt[0].bytesperline = bytesPerLine;
+    format.fmt.pix_mp.plane_fmt[0].sizeimage = 0;
+
+    if (ioctl(m_subdevFd, VIDIOC_S_FMT, &format) == -1) {
+        qWarning() << "Output device" << m_subdevFd << "VIDIOC_S_FMT with format" << format.fmt.pix_mp
+                   << "failed:" << strerror(errno);
+        return false;
+    }
+
+    qCDebug(qLcEglfsKmsDebug) << "Output device device" << m_subdevFd << "format set:" << format.fmt.pix_mp;
+    return true;
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::clearBuffers()
+{
+    struct v4l2_requestbuffers requestBuffers;
+    memset(&requestBuffers, 0, sizeof(requestBuffers));
+    requestBuffers.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    requestBuffers.memory = V4L2_MEMORY_DMABUF;
+    requestBuffers.count = 0;
+    if (ioctl(m_subdevFd, VIDIOC_REQBUFS, &requestBuffers) == -1) {
+        qWarning("Output device %d: VIDIOC_REQBUFS clear failed: %s", m_subdevFd, strerror(errno));
+        return false;
+    }
+    qCDebug(qLcEglfsKmsDebug, "Output device %d: Deallocced buffers with REQBUF, now has %d buffers", m_subdevFd, requestBuffers.count);
+    Q_ASSERT(requestBuffers.count == 0);
+    return true;
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::requestBuffer()
+{
+    struct v4l2_requestbuffers requestBuffers;
+    memset(&requestBuffers, 0, sizeof(requestBuffers));
+    requestBuffers.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    requestBuffers.memory = V4L2_MEMORY_DMABUF;
+    requestBuffers.count = 1;
+    if (ioctl(m_subdevFd, VIDIOC_REQBUFS, &requestBuffers) == -1) {
+        if (errno == EINVAL)
+            qWarning("Output device %d: Multi-planar output or dma buffers not supported", m_subdevFd);
+        qWarning("Output device %d: VIDIOC_REQBUFS failed: %s", m_subdevFd, strerror(errno));
+        return false;
+    }
+    qCDebug(qLcEglfsKmsDebug) << "REQBUF returned" << requestBuffers.count << "buffers for output device" << m_subdevFd;
+    return true;
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::queueBuffer(int dmabufFd, uint bytesUsed, uint length)
+{
+    const int numPlanes = 1;
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    buffer.memory = V4L2_MEMORY_DMABUF;
+    buffer.index = 0;
+    buffer.length = numPlanes;
+    buffer.bytesused = bytesUsed;
+    buffer.field = V4L2_FIELD_NONE; //TODO: what is this?
+
+    struct v4l2_plane planes[numPlanes];
+    memset(planes, 0, sizeof(planes));
+    buffer.m.planes = planes;
+
+    for (int i = 0; i < numPlanes; i++) {
+        buffer.m.planes[i].m.fd = dmabufFd;
+        buffer.m.planes[i].length = length;
+        buffer.m.planes[i].bytesused = bytesUsed;
+    }
+
+    if (ioctl(m_subdevFd, VIDIOC_QBUF, &buffer) == -1) {
+        qWarning("Output device %d: VIDIOC_QBUF failed for dmabuf %d: %s", m_subdevFd, dmabufFd, strerror(errno));
+        return false;
+    }
+
+    if (!(buffer.flags & V4L2_BUF_FLAG_QUEUED)) {
+        qWarning() << "Queued flag not set on buffer for output device";
+        return false;
+    }
+
+    return true;
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::streamOn()
+{
+    return QLinuxMediaDevice::streamOn(m_subdevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
+}
+
+bool QLinuxMediaDevice::OutputSubDevice::streamOff()
+{
+    return QLinuxMediaDevice::streamOff(m_subdevFd, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE);
+}
+
+bool QLinuxMediaDevice::setSubdevFormat(struct media_pad *pad, const QSize &size, uint32_t mbusFormat)
+{
+    Q_ASSERT(size.isValid());
+    struct v4l2_mbus_framefmt format;
+    format.width = static_cast<uint>(size.width());
+    format.height = static_cast<uint>(size.height());
+    format.code = mbusFormat;
+
+    if (v4l2_subdev_set_format(pad->entity, &format, pad->index, V4L2_SUBDEV_FORMAT_ACTIVE)) {
+        qWarning() << "Setting v4l2_subdev_set_format failed for format" << format;
+        return false;
+    }
+
+    if (format.code != mbusFormat) {
+        qWarning() << "Got" << mediaBusFmtToString(format.code) << "instead of"
+                   << mediaBusFmtToString(mbusFormat) << "when setting subdevice format";
+        return false;
+    }
+
+    qCDebug(qLcEglfsKmsDebug) << "Set format to" << format << "for entity" << pad->entity << "index" << pad->index;
+    return true;
+}
+
+bool QLinuxMediaDevice::setSubdevSelection(struct media_pad *pad, const QRect &geometry, uint target)
+{
+    Q_ASSERT(geometry.isValid());
+    struct v4l2_rect rect;
+    rect.left = geometry.left();
+    rect.top = geometry.top();
+    rect.width = static_cast<uint>(geometry.width());
+    rect.height = static_cast<uint>(geometry.height());
+
+    int ret = v4l2_subdev_set_selection(pad->entity, &rect, pad->index, target, V4L2_SUBDEV_FORMAT_ACTIVE);
+    if (ret) {
+        qWarning() << "Setting subdev selection failed.";
+        return false;
+    }
+
+    return true;
+}
+
+bool QLinuxMediaDevice::setSubdevCrop(struct media_pad *pad, const QRect &geometry)
+{
+    return setSubdevSelection(pad, geometry, V4L2_SEL_TGT_CROP);
+}
+
+bool QLinuxMediaDevice::setSubdevCompose(struct media_pad *pad, const QRect &geometry)
+{
+    return setSubdevSelection(pad, geometry, V4L2_SEL_TGT_COMPOSE);
+}
+
+bool QLinuxMediaDevice::streamOn(int subDeviceFd, v4l2_buf_type bufferType)
+{
+    if (ioctl(subDeviceFd, VIDIOC_STREAMON, &bufferType) == -1) {
+        qWarning("VIDIOC_STREAMON failed for subdevice %d: %s", subDeviceFd, strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+bool QLinuxMediaDevice::streamOff(int subDeviceFd, v4l2_buf_type bufferType)
+{
+    if (ioctl(subDeviceFd, VIDIOC_STREAMOFF, &bufferType) == -1) {
+        qWarning("VIDIOC_STREAMOFF failed for subdevice %d: %s", subDeviceFd, strerror(errno));
+        return false;
+    }
+
+    return true;
+}
+
+QT_END_NAMESPACE