Revision control
++ // Copyright (C) 2016 The Qt Company Ltd and/or its subsidiary(-ies).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "avfimagecapture_p.h"
++
++ #include <camera/avfcamera_p.h>
++ #include <camera/avfcameraservice_p.h>
++ #include <camera/avfcamerarenderer_p.h>
++ #include <camera/avfcamerasession_p.h>
++
++ #include <QtMultimedia/private/qavfcameradebug_p.h>
++ #include <QtMultimedia/private/qavfcamerautility_p.h>
++ #include <QtMultimedia/private/qmediastoragelocation_p.h>
++ #include <QtMultimedia/private/qmemoryvideobuffer_p.h>
++ #include <QtMultimedia/private/qplatformimagecapture_p.h>
++ #include <QtMultimedia/private/qvideoframe_p.h>
++ #include <QtConcurrent/qtconcurrentrun.h>
++ #include <QtGui/qimagereader.h>
++ #include <QtCore/qbuffer.h>
++ #include <QtCore/qfile.h>
++ #include <QtCore/qurl.h>
++
++ #import <AVFoundation/AVFoundation.h>
++
++ QT_USE_NAMESPACE
++
++ using namespace Qt::Literals;
++
++ AVFImageCapture::AVFImageCapture(QImageCapture *parent)
++ : QPlatformImageCapture(parent)
++ {
++ m_stillImageOutput = [[AVCaptureStillImageOutput alloc] init];
++
++ NSDictionary *outputSettings = [[NSDictionary alloc] initWithObjectsAndKeys:
++ AVVideoCodecTypeJPEG, AVVideoCodecKey, nil];
++
++ [m_stillImageOutput setOutputSettings:outputSettings];
++ [outputSettings release];
++ }
++
++ AVFImageCapture::~AVFImageCapture()
++ {
++ [m_stillImageOutput release];
++ }
++
++ bool AVFImageCapture::isReadyForCapture() const
++ {
++ return m_cameraControl && m_videoConnection && m_cameraControl->isActive();
++ }
++
++ void AVFImageCapture::updateReadyStatus()
++ {
++ if (m_ready != isReadyForCapture()) {
++ m_ready = !m_ready;
++ qCDebug(qLcCamera) << "ReadyToCapture status changed:" << m_ready;
++ Q_EMIT readyForCaptureChanged(m_ready);
++ }
++ }
++
++ int AVFImageCapture::doCapture(const QString &fileName)
++ {
++ if (!m_session) {
++ QMetaObject::invokeMethod(this, [this, id = m_lastCaptureId] {
++ error(id, QImageCapture::ResourceError, QPlatformImageCapture::msgImageCaptureNotSet());
++ }, Qt::QueuedConnection);
++ return -1;
++ }
++ if (!isReadyForCapture()) {
++ QMetaObject::invokeMethod(this, [this, id = m_lastCaptureId] {
++ error(id, QImageCapture::NotReadyError, QPlatformImageCapture::msgCameraNotReady());
++ }, Qt::QueuedConnection);
++ return -1;
++ }
++ m_lastCaptureId++;
++
++ bool captureToBuffer = fileName.isEmpty();
++
++ auto request = CaptureRequest{
++ m_lastCaptureId,
++ std::make_unique<QSemaphore>(),
++ };
++ m_requestsMutex.lock();
++ m_captureRequests.push(request);
++ m_requestsMutex.unlock();
++
++ [m_stillImageOutput
++ captureStillImageAsynchronouslyFromConnection:m_videoConnection
++ completionHandler:[=, this](CMSampleBufferRef imageSampleBuffer,
++ NSError *nsError) {
++ if (nsError) {
++ QStringList messageParts{
++ QString::fromNSString(nsError.localizedDescription),
++ QString::fromNSString(nsError.localizedFailureReason),
++ QString::fromNSString(nsError.localizedRecoverySuggestion),
++ };
++
++ QString errorMessage = messageParts.join(QChar(u' '));
++ qCDebug(qLcCamera) << "Image capture failed:" << errorMessage;
++
++ QMetaObject::invokeMethod(this, [this, captureId = request.captureId, errorMessage] {
++ error(captureId, QImageCapture::ResourceError, errorMessage);
++ }, Qt::QueuedConnection);
++ return;
++ }
++
++ // Wait for the preview to be generated before saving the JPEG (but only
++ // if we have AVFCameraRenderer attached).
++ // It is possible to stop camera immediately after trying to capture an
++ // image; this can result in a blocked callback's thread, waiting for a
++ // new viewfinder's frame to arrive/semaphore to be released. It is also
++ // unspecified on which thread this callback gets executed, (probably it's
++ // not the same thread that initiated a capture and stopped the camera),
++ // so we cannot reliably check the camera's status. Instead, we wait
++ // with a timeout and treat a failure to acquire a semaphore as an error.
++ if (!m_session->videoOutput() || request.previewReady->tryAcquire(1, 1000)) {
++ qCDebug(qLcCamera) << "Image capture completed";
++
++ NSData *nsJpgData = [AVCaptureStillImageOutput jpegStillImageNSDataRepresentation:imageSampleBuffer];
++ QByteArray jpgData = QByteArray::fromRawData((const char *)[nsJpgData bytes], [nsJpgData length]);
++
++ if (captureToBuffer) {
++ QBuffer data(&jpgData);
++ QImageReader reader(&data, "JPEG");
++ QSize size = reader.size();
++ auto buffer = std::make_unique<QMemoryVideoBuffer>(
++ QByteArray(jpgData.constData(), jpgData.size()), -1);
++ QVideoFrame frame = QVideoFramePrivate::createFrame(
++ std::move(buffer), QVideoFrameFormat(size, QVideoFrameFormat::Format_Jpeg));
++ QMetaObject::invokeMethod(this, [this, captureId = request.captureId, frame] {
++ imageAvailable(captureId, frame);
++ }, Qt::QueuedConnection);
++ } else {
++ QFile f(fileName);
++ if (f.open(QFile::WriteOnly)) {
++ if (f.write(jpgData) != -1) {
++ QMetaObject::invokeMethod(this,
++ [this, captureId = request.captureId, fileName] {
++ imageSaved(captureId, fileName);
++ }, Qt::QueuedConnection);
++ } else {
++ QString errorString = f.errorString();
++ QMetaObject::invokeMethod(
++ this, [this, captureId = request.captureId, errorString] {
++ error(captureId, QImageCapture::OutOfSpaceError, errorString);
++ }, Qt::QueuedConnection);
++ }
++ } else {
++ QString errorMessage = tr("Could not open destination file:\n%1").arg(fileName);
++ QMetaObject::invokeMethod(this,
++ [this, captureId = request.captureId, errorMessage] {
++ error(captureId, QImageCapture::ResourceError, errorMessage);
++ }, Qt::QueuedConnection);
++ }
++ }
++ } else {
++ const QString errorMessage = u"Image capture failed: timed out waiting"
++ " for a preview frame."_s;
++ qCDebug(qLcCamera) << errorMessage;
++ QMetaObject::invokeMethod(this, [this, captureId = request.captureId, errorMessage] {
++ error(captureId, QImageCapture::ResourceError, errorMessage);
++ }, Qt::QueuedConnection);
++ }
++ }];
++
++ return request.captureId;
++ }
++
++ int AVFImageCapture::capture(const QString &fileName)
++ {
++ auto actualFileName = QMediaStorageLocation::generateFileName(fileName, QStandardPaths::PicturesLocation, QLatin1String("jpg"));
++
++ qCDebug(qLcCamera) << "Capture image to" << actualFileName;
++ return doCapture(actualFileName);
++ }
++
++ int AVFImageCapture::captureToBuffer()
++ {
++ return doCapture(QString());
++ }
++
++ void AVFImageCapture::onNewViewfinderFrame(const QVideoFrame &frame)
++ {
++ std::unique_lock guard(m_requestsMutex);
++
++ if (m_captureRequests.empty())
++ return;
++
++ CaptureRequest request = std::move(m_captureRequests.front());
++ m_captureRequests.pop();
++ guard.unlock();
++
++ Q_EMIT imageExposed(request.captureId);
++
++ QFuture<QImage> future = QtConcurrent::run([frame]() -> QImage {
++ return frame.toImage();
++ });
++
++ future.then(this, [this, request](QImage image) {
++ Q_EMIT imageCaptured(request.captureId, image);
++ request.previewReady->release();
++ });
++ }
++
++ void AVFImageCapture::onCameraChanged()
++ {
++ auto camera = m_service ? static_cast<AVFCamera *>(m_service->camera()) : nullptr;
++
++ if (camera == m_cameraControl)
++ return;
++
++ m_cameraControl = camera;
++
++ if (m_cameraControl)
++ connect(m_cameraControl, &AVFCamera::activeChanged, this,
++ &AVFImageCapture::updateReadyStatus);
++ updateReadyStatus();
++ }
++
++ void AVFImageCapture::updateCaptureConnection()
++ {
++ if (m_session && m_session->videoCaptureDevice()) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO;
++ AVCaptureSession *captureSession = m_session->captureSession();
++
++ if (![captureSession.outputs containsObject:m_stillImageOutput]) {
++ if ([captureSession canAddOutput:m_stillImageOutput]) {
++ [captureSession beginConfiguration];
++ // Lock the video capture device to make sure the active format is not reset
++ const AVFConfigurationLock lock(m_session->videoCaptureDevice());
++ [captureSession addOutput:m_stillImageOutput];
++ m_videoConnection = [m_stillImageOutput connectionWithMediaType:AVMediaTypeVideo];
++ [captureSession commitConfiguration];
++ updateReadyStatus();
++ }
++ } else {
++ m_videoConnection = [m_stillImageOutput connectionWithMediaType:AVMediaTypeVideo];
++ }
++ }
++ }
++
++
++ QImageEncoderSettings AVFImageCapture::imageSettings() const
++ {
++ QImageEncoderSettings settings;
++
++ if (!videoCaptureDeviceIsValid())
++ return settings;
++
++ AVCaptureDevice *captureDevice = m_service->session()->videoCaptureDevice();
++ if (!captureDevice.activeFormat) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "no active format";
++ return settings;
++ }
++
++ QSize res(qt_device_format_resolution(captureDevice.activeFormat));
++ #ifdef Q_OS_IOS
++ if (!m_service->avfImageCaptureControl() || !m_service->avfImageCaptureControl()->stillImageOutput()) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "no still image output";
++ return settings;
++ }
++
++ AVCaptureStillImageOutput *stillImageOutput = m_service->avfImageCaptureControl()->stillImageOutput();
++ if (stillImageOutput.highResolutionStillImageOutputEnabled)
++ res = qt_device_format_high_resolution(captureDevice.activeFormat);
++ #endif
++ if (res.isNull() || !res.isValid()) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "failed to exctract the image resolution";
++ return settings;
++ }
++
++ settings.setResolution(res);
++ settings.setFormat(QImageCapture::JPEG);
++
++ return settings;
++ }
++
++ void AVFImageCapture::setImageSettings(const QImageEncoderSettings &settings)
++ {
++ if (m_settings == settings)
++ return;
++
++ m_settings = settings;
++ applySettings();
++ }
++
++ bool AVFImageCapture::applySettings()
++ {
++ if (!videoCaptureDeviceIsValid())
++ return false;
++
++ AVFCameraSession *session = m_service->session();
++ if (!session)
++ return false;
++
++ if (!m_service->imageCapture()
++ || !m_service->avfImageCaptureControl()->stillImageOutput()) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "no still image output";
++ return false;
++ }
++
++ if (m_settings.format() != QImageCapture::UnspecifiedFormat && m_settings.format() != QImageCapture::JPEG) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "unsupported format:" << m_settings.format();
++ return false;
++ }
++
++ QSize res(m_settings.resolution());
++ if (res.isNull()) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "invalid resolution:" << res;
++ return false;
++ }
++
++ if (!res.isValid()) {
++ // Invalid == default value.
++ // Here we could choose the best format available, but
++ // activeFormat is already equal to 'preset high' by default,
++ // which is good enough, otherwise we can end in some format with low framerates.
++ return false;
++ }
++
++ bool activeFormatChanged = false;
++
++ AVCaptureDevice *captureDevice = m_service->session()->videoCaptureDevice();
++ AVCaptureDeviceFormat *match = qt_find_best_resolution_match(captureDevice, res,
++ m_service->session()->defaultCodec());
++
++ if (!match) {
++ qCDebug(qLcCamera) << Q_FUNC_INFO << "unsupported resolution:" << res;
++ return false;
++ }
++
++ activeFormatChanged = qt_set_active_format(captureDevice, match, true);
++
++ #ifdef Q_OS_IOS
++ AVCaptureStillImageOutput *imageOutput = m_service->avfImageCaptureControl()->stillImageOutput();
++ if (res == qt_device_format_high_resolution(captureDevice.activeFormat))
++ imageOutput.highResolutionStillImageOutputEnabled = YES;
++ else
++ imageOutput.highResolutionStillImageOutputEnabled = NO;
++ #endif
++
++ return activeFormatChanged;
++ }
++
++ void AVFImageCapture::setCaptureSession(QPlatformMediaCaptureSession *session)
++ {
++ AVFCameraService *captureSession = static_cast<AVFCameraService *>(session);
++ if (m_service == captureSession)
++ return;
++
++ m_service = captureSession;
++ if (!m_service) {
++ m_session->disconnect(this);
++ if (m_cameraControl)
++ m_cameraControl->disconnect(this);
++ m_session = nullptr;
++ m_cameraControl = nullptr;
++ m_videoConnection = nil;
++ } else {
++ m_session = m_service->session();
++ Q_ASSERT(m_session);
++
++ connect(m_service, &AVFCameraService::cameraChanged, this, &AVFImageCapture::onCameraChanged);
++ connect(m_session, &AVFCameraSession::readyToConfigureConnections, this, &AVFImageCapture::updateCaptureConnection);
++ connect(m_session, &AVFCameraSession::newViewfinderFrame,
++ this, &AVFImageCapture::onNewViewfinderFrame);
++ }
++
++ updateCaptureConnection();
++ onCameraChanged();
++ updateReadyStatus();
++ }
++
++ bool AVFImageCapture::videoCaptureDeviceIsValid() const
++ {
++ if (!m_service || !m_service->session() || !m_service->session()->videoCaptureDevice())
++ return false;
++
++ AVCaptureDevice *captureDevice = m_service->session()->videoCaptureDevice();
++ if (!captureDevice.formats || !captureDevice.formats.count)
++ return false;
++
++ return true;
++ }
++
++ #include "moc_avfimagecapture_p.cpp"