Revision control
Copy as Markdown
// Copyright (C) 2016 Research In Motion
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qqnximagecapture_p.h"
#include "qqnxplatformcamera_p.h"
#include "qqnxmediacapturesession_p.h"
#include "qqnxcamera_p.h"
#include "qfile.h"
#include <private/qmediastoragelocation_p.h>
#include <QtCore/qfileinfo.h>
#include <QtCore/qfuture.h>
#include <QtCore/qpromise.h>
#include <QtCore/qthread.h>
#include <camera/camera_api.h>
using namespace Qt::Literals::StringLiterals;
static QString formatExtension(QImageCapture::FileFormat format)
{
switch (format) {
case QImageCapture::JPEG:
return u"jpg"_s;
case QImageCapture::PNG:
return u"png"_s;
case QImageCapture::WebP:
case QImageCapture::Tiff:
case QImageCapture::UnspecifiedFormat:
break;
}
return {};
}
static QString resolveFileName(const QString &fileName, QImageCapture::FileFormat format)
{
const QString extension = formatExtension(format);
if (extension.isEmpty())
return {};
if (fileName.isEmpty()) {
return QMediaStorageLocation::generateFileName(QString(),
QStandardPaths::PicturesLocation, extension);
}
if (fileName.endsWith(extension))
return QFileInfo(fileName).canonicalFilePath();
QString path = fileName;
path.append(u".%1"_s.arg(extension));
return QFileInfo(path).canonicalFilePath();
}
QT_BEGIN_NAMESPACE
QQnxImageCapture::QQnxImageCapture(QImageCapture *parent)
: QPlatformImageCapture(parent)
{
}
bool QQnxImageCapture::isReadyForCapture() const
{
return m_camera && m_camera->isActive();
}
int QQnxImageCapture::capture(const QString &fileName)
{
if (!isReadyForCapture()) {
Q_EMIT error(-1, QImageCapture::NotReadyError, QPlatformImageCapture::msgCameraNotReady());
return -1;
}
// default to PNG format if no format has been specified
const QImageCapture::FileFormat format =
m_settings.format() == QImageCapture::UnspecifiedFormat
? QImageCapture::PNG : m_settings.format();
const QString resolvedFileName = resolveFileName(fileName, format);
if (resolvedFileName.isEmpty()) {
const QString errorMessage = (u"Invalid file format: %1"_s).arg(
QImageCapture::fileFormatName(format));
Q_EMIT error(-1, QImageCapture::NotSupportedFeatureError, errorMessage);
return -1;
}
const int id = m_lastId++;
auto callback = [this, id, fn=std::move(resolvedFileName)](const QVideoFrame &frame) {
saveFrame(id, frame, fn);
};
m_camera->requestVideoFrame(std::move(callback));
return id;
}
int QQnxImageCapture::captureToBuffer()
{
if (!isReadyForCapture()) {
Q_EMIT error(-1, QImageCapture::NotReadyError, QPlatformImageCapture::msgCameraNotReady());
return -1;
}
const int id = m_lastId++;
auto callback = [this, id](const QVideoFrame &frame) { decodeFrame(id, frame); };
m_camera->requestVideoFrame(std::move(callback));
return id;
}
QFuture<QImage> QQnxImageCapture::decodeFrame(int id, const QVideoFrame &frame)
{
if (!frame.isValid()) {
Q_EMIT error(id, QImageCapture::NotReadyError, u"Invalid frame"_s);
return {};
}
QPromise<QImage> promise;
QFuture<QImage> future = promise.future();
// converting a QVideoFrame to QImage is an expensive operation
// run it on a background thread to prevent it from stalling the UI
auto runner = [frame, promise=std::move(promise)]() mutable {
promise.start();
promise.addResult(frame.toImage());
promise.finish();
};
auto *worker = QThread::create(std::move(runner));
auto onFinished = [this, worker, id, future]() mutable {
worker->deleteLater();
if (future.isValid()) {
Q_EMIT imageCaptured(id, future.result());
} else {
qWarning("QQnxImageCapture: failed to capture image to buffer");
}
};
connect(worker, &QThread::finished, this, std::move(onFinished));
Q_EMIT imageExposed(id);
worker->start();
return future;
}
void QQnxImageCapture::saveFrame(int id, const QVideoFrame &frame, const QString &fileName)
{
QFuture<QImage> decodeFuture = decodeFrame(id, frame);
if (decodeFuture.isCanceled())
return;
QPromise<bool> promise;
QFuture<bool> saveFuture = promise.future();
// writing a QImage to disk is a _very_ expensive operation
// run it on a background thread to prevent it from stalling the UI
auto runner = [future=std::move(decodeFuture),
promise=std::move(promise), fileName]() mutable {
promise.start();
promise.addResult(future.result().save(fileName));
promise.finish();
};
auto *worker = QThread::create(std::move(runner));
auto onFinished = [this, worker, id, future=std::move(saveFuture), fn=std::move(fileName)]() {
worker->deleteLater();
if (future.isValid() && future.result())
Q_EMIT imageSaved(id, fn);
else
Q_EMIT error(id, QImageCapture::NotSupportedFeatureError, u"Failed to save image"_s);
};
connect(worker, &QThread::finished, this, std::move(onFinished));
worker->start();
}
QImageEncoderSettings QQnxImageCapture::imageSettings() const
{
return m_settings;
}
void QQnxImageCapture::setImageSettings(const QImageEncoderSettings &settings)
{
m_settings = settings;
}
void QQnxImageCapture::setCaptureSession(QQnxMediaCaptureSession *captureSession)
{
if (m_session == captureSession)
return;
if (m_session)
m_session->disconnect(this);
m_session = captureSession;
if (m_session) {
connect(m_session, &QQnxMediaCaptureSession::cameraChanged,
this, &QQnxImageCapture::onCameraChanged);
}
onCameraChanged();
}
void QQnxImageCapture::onCameraChanged()
{
if (m_camera)
m_camera->disconnect(this);
m_camera = m_session ? static_cast<QQnxPlatformCamera*>(m_session->camera()) : nullptr;
if (m_camera) {
connect(m_camera, &QQnxPlatformCamera::activeChanged,
this, &QQnxImageCapture::onCameraChanged);
}
updateReadyForCapture();
}
void QQnxImageCapture::onCameraActiveChanged(bool active)
{
Q_UNUSED(active);
updateReadyForCapture();
}
void QQnxImageCapture::updateReadyForCapture()
{
const bool readyForCapture = isReadyForCapture();
if (m_lastReadyForCapture == readyForCapture)
return;
m_lastReadyForCapture = readyForCapture;
Q_EMIT readyForCaptureChanged(m_lastReadyForCapture);
}
QT_END_NAMESPACE
#include "moc_qqnximagecapture_p.cpp"