qimagecapture.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 <qimagecapture.h>
#include <private/qplatformimagecapture_p.h>
#include <qmediametadata.h>
#include <private/qplatformmediacapture_p.h>
#include <private/qplatformmediaintegration_p.h>
#include <private/qplatformmediaformatinfo_p.h>
#include <qmediacapturesession.h>
 
#include "private/qobject_p.h"
#include <qcamera.h>
#include <private/qplatformcamera_p.h>
#include <QtCore/qdebug.h>
#include <QtCore/qurl.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qmetaobject.h>
 
QT_BEGIN_NAMESPACE
 
class QImageCapturePrivate
{
    Q_DECLARE_PUBLIC(QImageCapture)
public:
    QCamera *camera = nullptr;
 
    QMediaCaptureSession *captureSession = nullptr;
    QPlatformImageCapture *control = nullptr;
 
    QImageCapture::Error error = QImageCapture::NoError;
    QString errorString;
    QMediaMetaData metaData;
 
    void _q_error(int id, int error, const QString &errorString);
 
    void unsetError() { error = QImageCapture::NoError; errorString.clear(); }
 
    QImageCapture *q_ptr;
};
 
void QImageCapturePrivate::_q_error(int id, int error, const QString &errorString)
{
    Q_Q(QImageCapture);
 
    this->error = QImageCapture::Error(error);
    this->errorString = errorString;
 
    emit q->errorChanged();
    emit q->errorOccurred(id, this->error, errorString);
}
 
QImageCapture::QImageCapture(QObject *parent)
    : QObject(parent), d_ptr(new QImageCapturePrivate)
{
    Q_D(QImageCapture);
    d->q_ptr = this;
 
    auto maybeControl = QPlatformMediaIntegration::instance()->createImageCapture(this);
    if (!maybeControl) {
        qWarning() << "Failed to initialize QImageCapture" << maybeControl.error();
        d->errorString = maybeControl.error();
        d->error = NotReadyError;
        return;
    }
 
    d->control = maybeControl.value();
    connect(d->control, &QPlatformImageCapture::imageExposed, this, &QImageCapture::imageExposed);
    connect(d->control, &QPlatformImageCapture::imageCaptured, this, &QImageCapture::imageCaptured);
    connect(d->control, &QPlatformImageCapture::imageMetadataAvailable, this,
            &QImageCapture::imageMetadataAvailable);
    connect(d->control, &QPlatformImageCapture::imageAvailable, this,
            &QImageCapture::imageAvailable);
    connect(d->control, &QPlatformImageCapture::imageSaved, this, &QImageCapture::imageSaved);
    connect(d->control, &QPlatformImageCapture::readyForCaptureChanged, this,
            &QImageCapture::readyForCaptureChanged);
    connect(d->control, SIGNAL(error(int,int,QString)),
            this, SLOT(_q_error(int,int,QString)));
}
 
void QImageCapture::setCaptureSession(QMediaCaptureSession *session)
{
    Q_D(QImageCapture);
    d->captureSession = session;
}
 
QImageCapture::~QImageCapture()
{
    if (d_ptr->captureSession)
        d_ptr->captureSession->setImageCapture(nullptr);
    delete d_ptr;
}
 
bool QImageCapture::isAvailable() const
{
    return d_func()->control && d_func()->captureSession && d_func()->captureSession->camera();
}
 
QMediaCaptureSession *QImageCapture::captureSession() const
{
    return d_ptr->captureSession;
}
 
QImageCapture::Error QImageCapture::error() const
{
    return d_func()->error;
}
 
QString QImageCapture::errorString() const
{
    return d_func()->errorString;
}
 
QMediaMetaData QImageCapture::metaData() const
{
    Q_D(const QImageCapture);
    return d->metaData;
}
 
void QImageCapture::setMetaData(const QMediaMetaData &metaData)
{
    Q_D(QImageCapture);
    d->metaData = metaData;
    if (d->control)
        d->control->setMetaData(d->metaData);
    emit metaDataChanged();
}
 
void QImageCapture::addMetaData(const QMediaMetaData &metaData)
{
    Q_D(QImageCapture);
    auto data = d->metaData;
    for (auto k : metaData.keys())
        data.insert(k, metaData.value(k));
    setMetaData(data);
}
 
bool QImageCapture::isReadyForCapture() const
{
    Q_D(const QImageCapture);
    if (!d->control || !d->captureSession || !d->control->isReadyForCapture())
        return false;
    auto *camera = d->captureSession->camera();
    if (!camera || !camera->isActive())
        return false;
    return true;
}
 
int QImageCapture::captureToFile(const QString &file)
{
    Q_D(QImageCapture);
    if (!d->control) {
        d->_q_error(-1, d->error, d->errorString);
        return -1;
    }
 
    d->unsetError();
 
    if (!isReadyForCapture()) {
        d->_q_error(-1, NotReadyError, tr("Could not capture in stopped state"));
        return -1;
    }
 
    return d->control->capture(file);
}
 
int QImageCapture::capture()
{
    Q_D(QImageCapture);
    if (!d->control) {
        d->_q_error(-1, d->error, d->errorString);
        return -1;
    } else {
        d->unsetError();
        return d->control->captureToBuffer();
    }
}
 
QImageCapture::FileFormat QImageCapture::fileFormat() const
{
    Q_D(const QImageCapture);
    return d->control ? d->control->imageSettings().format() : UnspecifiedFormat;
}
 
void QImageCapture::setFileFormat(QImageCapture::FileFormat format)
{
    Q_D(QImageCapture);
    if (!d->control)
        return;
    auto fmt = d->control->imageSettings();
    if (fmt.format() == format)
        return;
    fmt.setFormat(format);
    d->control->setImageSettings(fmt);
    emit fileFormatChanged();
}
 
QList<QImageCapture::FileFormat> QImageCapture::supportedFormats()
{
    return QPlatformMediaIntegration::instance()->formatInfo()->imageFormats;
}
 
QString QImageCapture::fileFormatName(QImageCapture::FileFormat f)
{
    const char *name = nullptr;
    switch (f) {
    case UnspecifiedFormat:
        name = "Unspecified image format";
        break;
    case JPEG:
        name = "JPEG";
        break;
    case PNG:
        name = "PNG";
        break;
    case WebP:
        name = "WebP";
        break;
    case Tiff:
        name = "Tiff";
        break;
    }
    return QString::fromUtf8(name);
}
 
QString QImageCapture::fileFormatDescription(QImageCapture::FileFormat f)
{
    const char *name = nullptr;
    switch (f) {
    case UnspecifiedFormat:
        name = "Unspecified image format";
        break;
    case JPEG:
        name = "JPEG";
        break;
    case PNG:
        name = "PNG";
        break;
    case WebP:
        name = "WebP";
        break;
    case Tiff:
        name = "Tiff";
        break;
    }
    return QString::fromUtf8(name);
}
 
QSize QImageCapture::resolution() const
{
    Q_D(const QImageCapture);
    return d->control ? d->control->imageSettings().resolution() : QSize{};
}
 
void QImageCapture::setResolution(const QSize &resolution)
{
    Q_D(QImageCapture);
    if (!d->control)
        return;
    auto fmt = d->control->imageSettings();
    if (fmt.resolution() == resolution)
        return;
    fmt.setResolution(resolution);
    d->control->setImageSettings(fmt);
    emit resolutionChanged();
}
 
void QImageCapture::setResolution(int width, int height)
{
    setResolution(QSize(width, height));
}
 
QImageCapture::Quality QImageCapture::quality() const
{
    Q_D(const QImageCapture);
    return d->control ? d->control->imageSettings().quality() : NormalQuality;
}
 
void QImageCapture::setQuality(Quality quality)
{
    Q_D(QImageCapture);
    if (!d->control)
        return;
    auto fmt = d->control->imageSettings();
    if (fmt.quality() == quality)
        return;
    fmt.setQuality(quality);
    d->control->setImageSettings(fmt);
    emit resolutionChanged();
}
 
QPlatformImageCapture *QImageCapture::platformImageCapture()
{
    Q_D(QImageCapture);
    return d->control;
}
 
QT_END_NAMESPACE
 
#include "moc_qimagecapture.cpp"