Revision control
++ // 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 "qwindowsimagecapture_p.h"
++
++ #include <mediacapture/qwindowsmediacapture_p.h>
++ #include <mediacapture/qwindowsmediadevicesession_p.h>
++
++ #include <QtMultimedia/private/qmediastoragelocation_p.h>
++ #include <QtGui/qimagewriter.h>
++ #include <QtConcurrent/qtconcurrentrun.h>
++
++ QT_BEGIN_NAMESPACE
++
++ using namespace Qt::StringLiterals;
++
++ QWindowsImageCapture::QWindowsImageCapture(QImageCapture *parent)
++ : QPlatformImageCapture(parent)
++ {
++ }
++
++ QWindowsImageCapture::~QWindowsImageCapture() = default;
++
++ bool QWindowsImageCapture::isReadyForCapture() const
++ {
++ if (!m_mediaDeviceSession)
++ return false;
++ return !m_capturing && m_mediaDeviceSession->isActive() && !m_mediaDeviceSession->activeCamera().isNull();
++ }
++
++ int QWindowsImageCapture::capture(const QString &fileName)
++ {
++ auto ext = writerFormat(m_settings.format());
++ auto path = QMediaStorageLocation::generateFileName(fileName, QStandardPaths::PicturesLocation, ext);
++ return doCapture(path);
++ }
++
++ int QWindowsImageCapture::captureToBuffer()
++ {
++ return doCapture(QString());
++ }
++
++ int QWindowsImageCapture::doCapture(const QString &fileName)
++ {
++ if (!isReadyForCapture())
++ return -1;
++ m_fileName = fileName;
++ m_capturing = true;
++ return m_captureId;
++ }
++
++ QImageEncoderSettings QWindowsImageCapture::imageSettings() const
++ {
++ return m_settings;
++ }
++
++ void QWindowsImageCapture::setImageSettings(const QImageEncoderSettings &settings)
++ {
++ m_settings = settings;
++ }
++
++ void QWindowsImageCapture::setCaptureSession(QPlatformMediaCaptureSession *session)
++ {
++ QWindowsMediaCaptureService *captureService = static_cast<QWindowsMediaCaptureService *>(session);
++ if (m_captureService == captureService)
++ return;
++
++ auto readyForCapture = isReadyForCapture();
++ if (m_mediaDeviceSession)
++ disconnect(m_mediaDeviceSession, nullptr, this, nullptr);
++
++ m_captureService = captureService;
++ if (!m_captureService) {
++ if (readyForCapture)
++ Q_EMIT readyForCaptureChanged(false);
++ m_mediaDeviceSession = nullptr;
++ return;
++ }
++
++ m_mediaDeviceSession = m_captureService->session();
++ Q_ASSERT(m_mediaDeviceSession);
++
++ if (isReadyForCapture() != readyForCapture)
++ Q_EMIT readyForCaptureChanged(isReadyForCapture());
++
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::readyForCaptureChanged,
++ this, &QWindowsImageCapture::readyForCaptureChanged);
++
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::videoFrameChanged,
++ this, &QWindowsImageCapture::handleVideoFrameChanged);
++ }
++
++ void QWindowsImageCapture::handleVideoFrameChanged(const QVideoFrame &frame)
++ {
++ if (m_capturing) {
++
++ QImage image = frame.toImage();
++
++ QSize size = m_settings.resolution();
++ if (size.isValid() && image.size() != size) {
++ image = image.scaled(size, Qt::KeepAspectRatioByExpanding);
++ if (image.size() != size) {
++ int xoff = (image.size().width() - size.width()) / 2;
++ int yoff = (image.size().height() - size.height()) / 2;
++ image = image.copy(xoff, yoff, size.width(), size.height());
++ }
++ }
++
++ Q_EMIT imageExposed(m_captureId);
++ Q_EMIT imageAvailable(m_captureId, frame);
++ Q_EMIT imageCaptured(m_captureId, image);
++
++ QMediaMetaData metaData = this->metaData();
++ metaData.insert(QMediaMetaData::Date, QDateTime::currentDateTime());
++ metaData.insert(QMediaMetaData::Resolution, size);
++
++ Q_EMIT imageMetadataAvailable(m_captureId, metaData);
++
++ if (!m_fileName.isEmpty()) {
++
++ (void)QtConcurrent::run(&QWindowsImageCapture::saveImage, this,
++ m_captureId, m_fileName, image, metaData, m_settings);
++ }
++
++ ++m_captureId;
++ m_capturing = false;
++ }
++ }
++
++ void QWindowsImageCapture::saveImage(int captureId, const QString &fileName,
++ const QImage &image, const QMediaMetaData &metaData,
++ const QImageEncoderSettings &settings)
++ {
++ QImageWriter imageWriter;
++ imageWriter.setFileName(fileName);
++
++ QString format = writerFormat(settings.format());
++ imageWriter.setFormat(format.toUtf8());
++
++ int quality = writerQuality(format, settings.quality());
++ if (quality > -1)
++ imageWriter.setQuality(quality);
++
++ for (auto key : metaData.keys())
++ imageWriter.setText(QMediaMetaData::metaDataKeyToString(key),
++ metaData.stringValue(key));
++
++ imageWriter.write(image);
++
++ QMetaObject::invokeMethod(this, [this, captureId, fileName] {
++ Q_EMIT imageSaved(captureId, fileName);
++ }, Qt::QueuedConnection);
++ }
++
++ QString QWindowsImageCapture::writerFormat(QImageCapture::FileFormat reqFormat)
++ {
++ QString format;
++
++ switch (reqFormat) {
++ case QImageCapture::FileFormat::JPEG:
++ format = u"jpg"_s;
++ break;
++ case QImageCapture::FileFormat::PNG:
++ format = u"png"_s;
++ break;
++ case QImageCapture::FileFormat::WebP:
++ format = u"webp"_s;
++ break;
++ case QImageCapture::FileFormat::Tiff:
++ format = u"tiff"_s;
++ break;
++ default:
++ format = u"jpg"_s;
++ }
++
++ auto supported = QImageWriter::supportedImageFormats();
++ for (const auto &f : supported)
++ if (format.compare(QString::fromUtf8(f), Qt::CaseInsensitive) == 0)
++ return format;
++
++ return u"jpg"_s;
++ }
++
++ int QWindowsImageCapture::writerQuality(const QString &writerFormat,
++ QImageCapture::Quality quality)
++ {
++ if (writerFormat.compare(u"jpg", Qt::CaseInsensitive) == 0 ||
++ writerFormat.compare(u"jpeg", Qt::CaseInsensitive) == 0) {
++
++ switch (quality) {
++ case QImageCapture::Quality::VeryLowQuality:
++ return 10;
++ case QImageCapture::Quality::LowQuality:
++ return 30;
++ case QImageCapture::Quality::NormalQuality:
++ return 75;
++ case QImageCapture::Quality::HighQuality:
++ return 90;
++ case QImageCapture::Quality::VeryHighQuality:
++ return 98;
++ default:
++ return 75;
++ }
++ }
++ return -1;
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qwindowsimagecapture_p.cpp"