qv4l2camera.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qv4l2camera_p.h"
 
#include <QtMultimedia/private/qcameradevice_p.h>
#include <QtMultimedia/private/qmultimediautils_p.h>
#include <QtMultimedia/private/qv4l2filedescriptor_p.h>
#include <QtMultimedia/private/qv4l2memorytransfer_p.h>
#include <QtMultimedia/private/qv4l2formats_p.h>
#include <QtMultimedia/private/qvideoframe_p.h>
#include <QtCore/qloggingcategory.h>
#include <QtCore/qsocketnotifier.h>
#include <QtCore/private/qcore_unix_p.h>
 
#include <sys/time.h>
 
#include <chrono>
 
QT_BEGIN_NAMESPACE
 
namespace QtV4L2 {
 
using namespace Qt::Literals;
 
Q_STATIC_LOGGING_CATEGORY(qLcV4L2Camera, "qt.multimedia.v4l2.camera");
 
static std::chrono::microseconds toMicroseconds(const timeval &tv)
{
    return std::chrono::seconds{ tv.tv_sec } + std::chrono::microseconds{ tv.tv_usec };
}
 
QV4L2Camera::QV4L2Camera(QCamera *camera) : QPlatformCamera(camera) { }
 
QV4L2Camera::~QV4L2Camera()
{
    stopCapturing();
    closeV4L2Fd();
}
 
bool QV4L2Camera::isActive() const
{
    return m_active;
}
 
void QV4L2Camera::setActive(bool active)
{
    if (m_active == active)
        return;
    if (m_cameraDevice.isNull() && active)
        return;
 
    if (m_cameraFormat.isNull())
        resolveCameraFormat({});
 
    m_active = active;
    if (m_active)
        startCapturing();
    else
        stopCapturing();
 
    Q_EMIT newVideoFrame({});
 
    Q_EMIT activeChanged(active);
}
 
void QV4L2Camera::setCamera(const QCameraDevice &camera)
{
    if (m_cameraDevice == camera)
        return;
 
    stopCapturing();
    closeV4L2Fd();
 
    m_cameraDevice = camera;
    resolveCameraFormat({});
 
    initV4L2Controls();
 
    if (m_active)
        startCapturing();
}
 
bool QV4L2Camera::setCameraFormat(const QCameraFormat &format)
{
    if (!format.isNull() && !m_cameraDevice.videoFormats().contains(format))
        return false;
 
    if (!resolveCameraFormat(format))
        return true;
 
    if (m_active) {
        stopCapturing();
        closeV4L2Fd();
 
        initV4L2Controls();
        startCapturing();
    }
 
    return true;
}
 
bool QV4L2Camera::resolveCameraFormat(const QCameraFormat &format)
{
    auto fmt = format;
    if (fmt.isNull())
        fmt = findBestCameraFormat(m_cameraDevice);
 
    if (fmt == m_cameraFormat)
        return false;
 
    m_cameraFormat = fmt;
    // The device must be reconfigured with the new format before the next stream start.
    m_v4l2Info.formatInitialized = false;
    return true;
}
 
void QV4L2Camera::setFocusMode(QCamera::FocusMode mode)
{
    if (mode == focusMode())
        return;
 
    bool focusDist = supportedFeatures() & QCamera::Feature::FocusDistance;
    if (!focusDist && !m_v4l2Info.rangedFocus)
        return;
 
    switch (mode) {
    default:
    case QCamera::FocusModeAuto:
        setV4L2Parameter(V4L2_CID_FOCUS_AUTO, 1);
        if (m_v4l2Info.rangedFocus)
            setV4L2Parameter(V4L2_CID_AUTO_FOCUS_RANGE, V4L2_AUTO_FOCUS_RANGE_AUTO);
        break;
    case QCamera::FocusModeAutoNear:
        setV4L2Parameter(V4L2_CID_FOCUS_AUTO, 1);
        if (m_v4l2Info.rangedFocus)
            setV4L2Parameter(V4L2_CID_AUTO_FOCUS_RANGE, V4L2_AUTO_FOCUS_RANGE_MACRO);
        else if (focusDist)
            setV4L2Parameter(V4L2_CID_FOCUS_ABSOLUTE, m_v4l2Info.minFocus);
        break;
    case QCamera::FocusModeAutoFar:
        setV4L2Parameter(V4L2_CID_FOCUS_AUTO, 1);
        if (m_v4l2Info.rangedFocus)
            setV4L2Parameter(V4L2_CID_AUTO_FOCUS_RANGE, V4L2_AUTO_FOCUS_RANGE_INFINITY);
        break;
    case QCamera::FocusModeInfinity:
        setV4L2Parameter(V4L2_CID_FOCUS_AUTO, 0);
        setV4L2Parameter(V4L2_CID_FOCUS_ABSOLUTE, m_v4l2Info.maxFocus);
        break;
    case QCamera::FocusModeManual:
        setV4L2Parameter(V4L2_CID_FOCUS_AUTO, 0);
        setFocusDistance(focusDistance());
        break;
    }
    focusModeChanged(mode);
}
 
void QV4L2Camera::setFocusDistance(float d)
{
    int distance = m_v4l2Info.minFocus + int((m_v4l2Info.maxFocus - m_v4l2Info.minFocus) * d);
    setV4L2Parameter(V4L2_CID_FOCUS_ABSOLUTE, distance);
    focusDistanceChanged(d);
}
 
void QV4L2Camera::zoomTo(float factor, float)
{
    if (m_v4l2Info.maxZoom == m_v4l2Info.minZoom)
        return;
    factor = qBound(1., factor, 2.);
    int zoom = m_v4l2Info.minZoom + (factor - 1.) * (m_v4l2Info.maxZoom - m_v4l2Info.minZoom);
    setV4L2Parameter(V4L2_CID_ZOOM_ABSOLUTE, zoom);
    zoomFactorChanged(factor);
}
 
bool QV4L2Camera::isFocusModeSupported(QCamera::FocusMode mode) const
{
    if (supportedFeatures() & QCamera::Feature::FocusDistance
        && (mode == QCamera::FocusModeManual || mode == QCamera::FocusModeAutoNear
            || mode == QCamera::FocusModeInfinity))
        return true;
 
    return mode == QCamera::FocusModeAuto;
}
 
void QV4L2Camera::setFlashMode(QCamera::FlashMode mode)
{
    if (!m_v4l2Info.flashSupported || mode == QCamera::FlashOn)
        return;
    setV4L2Parameter(V4L2_CID_FLASH_LED_MODE,
                     mode == QCamera::FlashAuto ? V4L2_FLASH_LED_MODE_FLASH
                                                : V4L2_FLASH_LED_MODE_NONE);
    flashModeChanged(mode);
}
 
bool QV4L2Camera::isFlashModeSupported(QCamera::FlashMode mode) const
{
    if (m_v4l2Info.flashSupported && mode == QCamera::FlashAuto)
        return true;
    return mode == QCamera::FlashOff;
}
 
bool QV4L2Camera::isFlashReady() const
{
    return getV4L2Parameter(V4L2_CID_FLASH_READY) != 0;
}
 
void QV4L2Camera::setTorchMode(QCamera::TorchMode mode)
{
    if (!m_v4l2Info.torchSupported || mode == QCamera::TorchAuto)
        return;
    setV4L2Parameter(V4L2_CID_FLASH_LED_MODE,
                     mode == QCamera::TorchOn ? V4L2_FLASH_LED_MODE_TORCH
                                              : V4L2_FLASH_LED_MODE_NONE);
    torchModeChanged(mode);
}
 
bool QV4L2Camera::isTorchModeSupported(QCamera::TorchMode mode) const
{
    if (mode == QCamera::TorchOn)
        return m_v4l2Info.torchSupported;
    return mode == QCamera::TorchOff;
}
 
void QV4L2Camera::setExposureMode(QCamera::ExposureMode mode)
{
    if (m_v4l2Info.autoExposureSupported && m_v4l2Info.manualExposureSupported) {
        if (mode != QCamera::ExposureAuto && mode != QCamera::ExposureManual)
            return;
        int value = mode == QCamera::ExposureAuto ? V4L2_EXPOSURE_AUTO : V4L2_EXPOSURE_MANUAL;
        setV4L2Parameter(V4L2_CID_EXPOSURE_AUTO, value);
        exposureModeChanged(mode);
        return;
    }
}
 
bool QV4L2Camera::isExposureModeSupported(QCamera::ExposureMode mode) const
{
    if (mode == QCamera::ExposureAuto)
        return true;
    if (m_v4l2Info.manualExposureSupported && m_v4l2Info.autoExposureSupported)
        return mode == QCamera::ExposureManual;
    return false;
}
 
void QV4L2Camera::setExposureCompensation(float compensation)
{
    if ((m_v4l2Info.minExposureAdjustment != 0 || m_v4l2Info.maxExposureAdjustment != 0)) {
        int value = qBound(m_v4l2Info.minExposureAdjustment, (int)(compensation * 1000),
                           m_v4l2Info.maxExposureAdjustment);
        setV4L2Parameter(V4L2_CID_AUTO_EXPOSURE_BIAS, value);
        exposureCompensationChanged(value / 1000.);
        return;
    }
}
 
void QV4L2Camera::setManualIsoSensitivity(int iso)
{
    if (!(supportedFeatures() & QCamera::Feature::IsoSensitivity))
        return;
    setV4L2Parameter(V4L2_CID_ISO_SENSITIVITY_AUTO,
                     iso <= 0 ? V4L2_ISO_SENSITIVITY_AUTO : V4L2_ISO_SENSITIVITY_MANUAL);
    if (iso > 0) {
        iso = qBound(minIso(), iso, maxIso());
        setV4L2Parameter(V4L2_CID_ISO_SENSITIVITY, iso);
    }
}
 
int QV4L2Camera::isoSensitivity() const
{
    if (!(supportedFeatures() & QCamera::Feature::IsoSensitivity))
        return -1;
    return getV4L2Parameter(V4L2_CID_ISO_SENSITIVITY);
}
 
void QV4L2Camera::setManualExposureTime(float secs)
{
    if (m_v4l2Info.manualExposureSupported && m_v4l2Info.autoExposureSupported) {
        int exposure =
                qBound(m_v4l2Info.minExposure, qRound(secs * 10000.), m_v4l2Info.maxExposure);
        setV4L2Parameter(V4L2_CID_EXPOSURE_ABSOLUTE, exposure);
        exposureTimeChanged(exposure / 10000.);
        return;
    }
}
 
float QV4L2Camera::exposureTime() const
{
    return getV4L2Parameter(V4L2_CID_EXPOSURE_ABSOLUTE) / 10000.;
}
 
bool QV4L2Camera::isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode mode) const
{
    if (m_v4l2Info.autoWhiteBalanceSupported && m_v4l2Info.colorTemperatureSupported)
        return true;
 
    return mode == QCamera::WhiteBalanceAuto;
}
 
void QV4L2Camera::setWhiteBalanceMode(QCamera::WhiteBalanceMode mode)
{
    Q_ASSERT(isWhiteBalanceModeSupported(mode));
 
    int temperature = colorTemperatureForWhiteBalance(mode);
    int t = setV4L2ColorTemperature(temperature);
    if (t == 0)
        mode = QCamera::WhiteBalanceAuto;
    whiteBalanceModeChanged(mode);
}
 
void QV4L2Camera::setColorTemperature(int temperature)
{
    if (temperature == 0) {
        setWhiteBalanceMode(QCamera::WhiteBalanceAuto);
        return;
    }
 
    Q_ASSERT(isWhiteBalanceModeSupported(QCamera::WhiteBalanceManual));
 
    int t = setV4L2ColorTemperature(temperature);
    if (t)
        colorTemperatureChanged(t);
}
 
void QV4L2Camera::readFrame()
{
    Q_ASSERT(m_memoryTransfer);
 
    auto dequeued = m_memoryTransfer->dequeueFrame();
    if (!dequeued) {
        qCWarning(qLcV4L2Camera) << "Cannot take buffer";
 
        if (errno == ENODEV) {
            // camera got removed while being active
            stopCapturing();
            closeV4L2Fd();
        }
 
        return;
    }
 
    QVideoFrame frame =
            QVideoFramePrivate::createFrame(std::move(dequeued->videoBuffer), frameFormat());
 
    const auto timestamp = toMicroseconds(dequeued->timestamp);
    if (!m_firstFrameTime)
        m_firstFrameTime = timestamp;
    const auto frameTime = timestamp - *m_firstFrameTime;
    frame.setStartTime(frameTime.count());
    frame.setEndTime((frameTime + m_frameDuration).count());
 
    Q_EMIT newVideoFrame(frame);
}
 
void QV4L2Camera::setCameraBusy()
{
    m_cameraBusy = true;
    updateError(QCamera::CameraError, QLatin1String("Camera is in use"));
}
 
void QV4L2Camera::initV4L2Controls()
{
    m_v4l2Info = {};
    QCamera::Features features;
 
    const QByteArray deviceName = m_cameraDevice.id();
    Q_ASSERT(!deviceName.isEmpty());
 
    closeV4L2Fd();
 
    const int descriptor = qt_safe_open(deviceName.constData(), O_RDWR);
    if (descriptor == -1) {
        qCWarning(qLcV4L2Camera) << "Unable to open the camera" << deviceName
                                 << "for read to query the parameter info:"
                                 << qt_error_string(errno);
        updateError(QCamera::CameraError, QLatin1String("Cannot open camera"));
        return;
    }
 
    m_v4l2FileDescriptor =
            std::make_shared<QV4L2FileDescriptor>(QUniqueFileDescriptorHandle{ descriptor });
 
    qCDebug(qLcV4L2Camera) << "FD=" << descriptor;
 
    struct v4l2_queryctrl queryControl;
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_AUTO_WHITE_BALANCE;
 
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.autoWhiteBalanceSupported = true;
        setV4L2Parameter(V4L2_CID_AUTO_WHITE_BALANCE, true);
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_WHITE_BALANCE_TEMPERATURE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.minColorTemp = queryControl.minimum;
        m_v4l2Info.maxColorTemp = queryControl.maximum;
        m_v4l2Info.colorTemperatureSupported = true;
        features |= QCamera::Feature::ColorTemperature;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_EXPOSURE_AUTO;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.autoExposureSupported = true;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_EXPOSURE_ABSOLUTE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.manualExposureSupported = true;
        m_v4l2Info.minExposure = queryControl.minimum;
        m_v4l2Info.maxExposure = queryControl.maximum;
        features |= QCamera::Feature::ManualExposureTime;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_AUTO_EXPOSURE_BIAS;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.minExposureAdjustment = queryControl.minimum;
        m_v4l2Info.maxExposureAdjustment = queryControl.maximum;
        features |= QCamera::Feature::ExposureCompensation;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_ISO_SENSITIVITY_AUTO;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        queryControl.id = V4L2_CID_ISO_SENSITIVITY;
        if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
            features |= QCamera::Feature::IsoSensitivity;
            minIsoChanged(queryControl.minimum);
            maxIsoChanged(queryControl.maximum);
        }
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_FOCUS_ABSOLUTE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.minFocus = queryControl.minimum;
        m_v4l2Info.maxFocus = queryControl.maximum;
        features |= QCamera::Feature::FocusDistance;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_AUTO_FOCUS_RANGE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.rangedFocus = true;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_FLASH_LED_MODE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.flashSupported = queryControl.minimum <= V4L2_FLASH_LED_MODE_FLASH
                && queryControl.maximum >= V4L2_FLASH_LED_MODE_FLASH;
        m_v4l2Info.torchSupported = queryControl.minimum <= V4L2_FLASH_LED_MODE_TORCH
                && queryControl.maximum >= V4L2_FLASH_LED_MODE_TORCH;
    }
 
    ::memset(&queryControl, 0, sizeof(queryControl));
    queryControl.id = V4L2_CID_ZOOM_ABSOLUTE;
    if (m_v4l2FileDescriptor->call(VIDIOC_QUERYCTRL, &queryControl)) {
        m_v4l2Info.minZoom = queryControl.minimum;
        m_v4l2Info.maxZoom = queryControl.maximum;
    }
    // zoom factors are in arbitrary units, so we simply normalize them to go from 1 to 2
    // if they are different
    minimumZoomFactorChanged(1);
    maximumZoomFactorChanged(m_v4l2Info.minZoom != m_v4l2Info.maxZoom ? 2 : 1);
 
    supportedFeaturesChanged(features);
}
 
void QV4L2Camera::closeV4L2Fd()
{
    Q_ASSERT(!m_memoryTransfer);
 
    m_v4l2Info = {};
    m_pixFormat = {};
    m_cameraBusy = false;
    m_v4l2FileDescriptor = nullptr;
}
 
int QV4L2Camera::setV4L2ColorTemperature(int temperature)
{
    if (m_v4l2Info.autoWhiteBalanceSupported) {
        setV4L2Parameter(V4L2_CID_AUTO_WHITE_BALANCE, temperature == 0 ? true : false);
    } else if (temperature == 0) {
        temperature = 5600;
    }
 
    if (temperature != 0 && m_v4l2Info.colorTemperatureSupported) {
        temperature = qBound(m_v4l2Info.minColorTemp, temperature, m_v4l2Info.maxColorTemp);
        if (!setV4L2Parameter(
                    V4L2_CID_WHITE_BALANCE_TEMPERATURE,
                    qBound(m_v4l2Info.minColorTemp, temperature, m_v4l2Info.maxColorTemp)))
            temperature = 0;
    } else {
        temperature = 0;
    }
 
    return temperature;
}
 
bool QV4L2Camera::setV4L2Parameter(quint32 id, qint32 value)
{
    v4l2_control control{ id, value };
    if (!m_v4l2FileDescriptor->call(VIDIOC_S_CTRL, &control)) {
        qWarning() << "Unable to set the V4L2 Parameter" << Qt::hex << id << "to" << value
                   << qt_error_string(errno);
        return false;
    }
    return true;
}
 
int QV4L2Camera::getV4L2Parameter(quint32 id) const
{
    struct v4l2_control control{ id, 0 };
    if (!m_v4l2FileDescriptor->call(VIDIOC_G_CTRL, &control)) {
        qWarning() << "Unable to get the V4L2 Parameter" << Qt::hex << id << qt_error_string(errno);
        return 0;
    }
    return control.value;
}
 
q23::expected<void, QString> QV4L2Camera::setV4L2CameraFormat()
{
    if (m_v4l2Info.formatInitialized)
        return {};
 
    Q_ASSERT(m_v4l2FileDescriptor);
 
    Q_ASSERT(!m_cameraFormat.isNull());
    qCDebug(qLcV4L2Camera) << "XXXXX" << this << m_cameraDevice.id() << m_cameraFormat.pixelFormat()
                           << m_cameraFormat.resolution();
 
    v4l2_format fmt = {};
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
    const auto v4l2PixelFormat = v4l2FormatForPixelFormat(m_cameraFormat.pixelFormat());
    if (!v4l2PixelFormat) {
        qWarning() << "Unsupported pixel format" << m_cameraFormat.pixelFormat();
        return q23::unexpected{ u"Unsupported V4L2 pixel format"_s };
    }
 
    auto size = m_cameraFormat.resolution();
    fmt.fmt.pix.width = size.width();
    fmt.fmt.pix.height = size.height();
    fmt.fmt.pix.pixelformat = *v4l2PixelFormat;
    fmt.fmt.pix.field = V4L2_FIELD_ANY;
 
    qCDebug(qLcV4L2Camera) << "setting camera format to" << size << fmt.fmt.pix.pixelformat;
 
    auto setFormatResult = m_v4l2FileDescriptor->call(VIDIOC_S_FMT, &fmt);
    if (!setFormatResult) {
        if (setFormatResult.error() == std::errc::device_or_resource_busy) {
            m_cameraBusy = true;
            return q23::unexpected{ u"Camera is in use"_s };
        }
        qWarning() << "Couldn't set video format on v4l2 camera" << qt_error_string(errno);
        return q23::unexpected{ u"Cannot set V4L2 camera format"_s };
    }
 
    // The driver may have adjusted the requested format, so keep what it negotiated.
    m_pixFormat = fmt.fmt.pix;
 
    const auto negotiatedPixelFormat = formatForV4L2Format(m_pixFormat.pixelformat);
    const bool isCompressed = negotiatedPixelFormat == QVideoFrameFormat::Format_Jpeg;
 
    if (negotiatedPixelFormat == QVideoFrameFormat::Format_Invalid || m_pixFormat.sizeimage == 0
        || (m_pixFormat.bytesperline == 0 && !isCompressed)) {
        qWarning() << "Driver negotiated an unusable camera format" << m_pixFormat.pixelformat;
        return q23::unexpected{ u"Unsupported V4L2 camera format"_s };
    }
 
    m_v4l2Info.formatInitialized = true;
    m_cameraBusy = false;
 
    v4l2_streamparm streamParam = {};
    streamParam.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 
    streamParam.parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
    qreal frameDuration = 1. / m_cameraFormat.maxFrameRate();
    auto [num, den] = qRealToFraction(frameDuration);
    streamParam.parm.capture.timeperframe = { (uint)num, (uint)den };
    m_v4l2FileDescriptor->call(VIDIOC_S_PARM, &streamParam);
 
    using namespace std::chrono;
    m_frameDuration = duration_cast<microseconds>(duration<qreal>{ frameDuration });
    return {};
}
 
void QV4L2Camera::initV4L2MemoryTransfer()
{
    if (m_cameraBusy)
        return;
 
    Q_ASSERT(!m_memoryTransfer);
 
    // QT_V4L2_CAMERA_MEMORY=dmabuf|userptr|mmap selects one strategy, with no fallback.
    const QByteArray forcedStrategy = qgetenv("QT_V4L2_CAMERA_MEMORY");
    const auto isAllowed = [&](QByteArrayView strategy) {
        return forcedStrategy.isEmpty() || forcedStrategy == strategy;
    };
 
#if QT_CONFIG(linux_dmabuf)
    if (isAllowed("dmabuf")) {
        m_memoryTransfer = makeDmaBufMemoryTransfer(m_v4l2FileDescriptor, m_pixFormat);
 
        if (m_memoryTransfer)
            return;
    }
#endif
 
    if (isAllowed("userptr")) {
        m_memoryTransfer = makeUserPtrMemoryTransfer(m_v4l2FileDescriptor, m_pixFormat);
 
        if (m_memoryTransfer)
            return;
 
        if (errno == EBUSY) {
            setCameraBusy();
            return;
        }
    }
 
    if (isAllowed("mmap")) {
        qCDebug(qLcV4L2Camera) << "Trying V4L2_MEMORY_MMAP";
 
        m_memoryTransfer = makeMMapMemoryTransfer(m_v4l2FileDescriptor, m_pixFormat);
    }
 
    if (!m_memoryTransfer) {
        qCWarning(qLcV4L2Camera) << "Cannot init v4l2 memory transfer," << qt_error_string(errno);
        updateError(QCamera::CameraError, QLatin1String("Cannot init V4L2 memory transfer"));
    }
}
 
void QV4L2Camera::stopCapturing()
{
    if (!m_memoryTransfer || !m_v4l2FileDescriptor)
        return;
 
    m_notifier = nullptr;
 
    if (!m_v4l2FileDescriptor->stopStream()) {
        // TODO: handle the case carefully to avoid possible memory corruption
        if (errno != ENODEV)
            qWarning() << "failed to stop capture";
    }
 
    m_memoryTransfer = nullptr;
    m_cameraBusy = false;
}
 
void QV4L2Camera::startCapturing()
{
    if (!m_v4l2FileDescriptor)
        return;
 
    auto setFormatResult = setV4L2CameraFormat();
    if (!setFormatResult) {
        updateError(QCamera::CameraError, setFormatResult.error());
        return;
    }
    initV4L2MemoryTransfer();
 
    if (m_cameraBusy || !m_memoryTransfer)
        return;
 
    if (!m_v4l2FileDescriptor->startStream()) {
        qWarning() << "Couldn't start v4l2 camera stream";
        return;
    }
 
    m_notifier =
            std::make_unique<QSocketNotifier>(m_v4l2FileDescriptor->get(), QSocketNotifier::Read);
    connect(m_notifier.get(), &QSocketNotifier::activated, m_notifier.get(), [this] {
        this->readFrame();
    });
 
    m_firstFrameTime.reset();
}
 
QVideoFrameFormat QV4L2Camera::frameFormat() const
{
    auto result = QPlatformCamera::frameFormat();
    if (m_v4l2Info.formatInitialized) {
        result = QVideoFrameFormat(sizeForV4L2Format(m_pixFormat),
                                   formatForV4L2Format(m_pixFormat.pixelformat));
        result.setStreamFrameRate(m_cameraFormat.maxFrameRate());
    }
 
    result.setColorSpace(colorSpaceForV4L2Colorspace(v4l2_colorspace(m_pixFormat.colorspace)));
    return result;
}
 
} // namespace QtV4L2
 
QT_END_NAMESPACE
 
#include "moc_qv4l2camera_p.cpp"