qmediacapturesession.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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 "qmediacapturesession.h"
#include "qmediacapturesession_p.h"
#include "qaudiodevice.h"
#include "qcamera.h"
#include "qmediarecorder.h"
#include "qimagecapture.h"
#include "qvideosink.h"
#include "qscreencapture.h"
#include "qwindowcapture.h"
 
#include "qplatformmediaintegration_p.h"
#include "qplatformmediacapture_p.h"
#include "qaudioinput.h"
#include "qaudiooutput.h"
 
QT_BEGIN_NAMESPACE
 
void QMediaCaptureSessionPrivate::setVideoSink(QVideoSink *sink)
{
    if (sink == videoSink)
        return;
    if (videoSink)
        videoSink->setSource(nullptr);
    videoSink = sink;
    if (sink)
        sink->setSource(q);
    if (captureSession)
        captureSession->setVideoPreview(sink);
    emit q->videoOutputChanged();
}
 
QMediaCaptureSession::QMediaCaptureSession(QObject *parent)
    : QObject(parent),
    d_ptr(new QMediaCaptureSessionPrivate)
{
    d_ptr->q = this;
    auto maybeCaptureSession = QPlatformMediaIntegration::instance()->createCaptureSession();
    if (maybeCaptureSession) {
        d_ptr->captureSession = maybeCaptureSession.value();
        d_ptr->captureSession->setCaptureSession(this);
    } else {
        qWarning() << "Failed to initialize QMediaCaptureSession" << maybeCaptureSession.error();
    }
}
 
QMediaCaptureSession::~QMediaCaptureSession()
{
    setCamera(nullptr);
    setRecorder(nullptr);
    setImageCapture(nullptr);
    setScreenCapture(nullptr);
    setWindowCapture(nullptr);
    setAudioInput(nullptr);
    setAudioOutput(nullptr);
    d_ptr->setVideoSink(nullptr);
    delete d_ptr->captureSession;
    delete d_ptr;
}
QAudioInput *QMediaCaptureSession::audioInput() const
{
    return d_ptr->audioInput;
}
 
void QMediaCaptureSession::setAudioInput(QAudioInput *input)
{
    QAudioInput *oldInput = d_ptr->audioInput;
    if (oldInput == input)
        return;
 
    // To avoid double emit of audioInputChanged
    // from recursive setAudioInput(nullptr) call.
    d_ptr->audioInput = nullptr;
 
    if (d_ptr->captureSession)
        d_ptr->captureSession->setAudioInput(nullptr);
    if (oldInput)
        oldInput->setDisconnectFunction({});
    if (input) {
        input->setDisconnectFunction([this](){ setAudioInput(nullptr); });
        if (d_ptr->captureSession)
            d_ptr->captureSession->setAudioInput(input->handle());
    }
    d_ptr->audioInput = input;
    emit audioInputChanged();
}
 
QCamera *QMediaCaptureSession::camera() const
{
    return d_ptr->camera;
}
 
void QMediaCaptureSession::setCamera(QCamera *camera)
{
    // TODO: come up with an unification of the captures setup
    QCamera *oldCamera = d_ptr->camera;
    if (oldCamera == camera)
        return;
    d_ptr->camera = camera;
    if (d_ptr->captureSession)
        d_ptr->captureSession->setCamera(nullptr);
    if (oldCamera) {
        if (oldCamera->captureSession() && oldCamera->captureSession() != this)
            oldCamera->captureSession()->setCamera(nullptr);
        oldCamera->setCaptureSession(nullptr);
    }
    if (camera) {
        if (camera->captureSession())
            camera->captureSession()->setCamera(nullptr);
        if (d_ptr->captureSession)
            d_ptr->captureSession->setCamera(camera->platformCamera());
        camera->setCaptureSession(this);
    }
    emit cameraChanged();
}
 
QScreenCapture *QMediaCaptureSession::screenCapture()
{
    return d_ptr ? d_ptr->screenCapture : nullptr;
}
 
void QMediaCaptureSession::setScreenCapture(QScreenCapture *screenCapture)
{
    // TODO: come up with an unification of the captures setup
    QScreenCapture *oldScreenCapture = d_ptr->screenCapture;
    if (oldScreenCapture == screenCapture)
        return;
    d_ptr->screenCapture = screenCapture;
    if (d_ptr->captureSession)
        d_ptr->captureSession->setScreenCapture(nullptr);
    if (oldScreenCapture) {
        if (oldScreenCapture->captureSession() && oldScreenCapture->captureSession() != this)
            oldScreenCapture->captureSession()->setScreenCapture(nullptr);
        oldScreenCapture->setCaptureSession(nullptr);
    }
    if (screenCapture) {
        if (screenCapture->captureSession())
            screenCapture->captureSession()->setScreenCapture(nullptr);
        if (d_ptr->captureSession)
            d_ptr->captureSession->setScreenCapture(screenCapture->platformScreenCapture());
        screenCapture->setCaptureSession(this);
    }
    emit screenCaptureChanged();
}
 
QWindowCapture *QMediaCaptureSession::windowCapture() {
    return d_ptr ? d_ptr->windowCapture : nullptr;
}
 
void QMediaCaptureSession::setWindowCapture(QWindowCapture *windowCapture)
{
    // TODO: come up with an unification of the captures setup
    QWindowCapture *oldCapture = d_ptr->windowCapture;
    if (oldCapture == windowCapture)
        return;
    d_ptr->windowCapture = windowCapture;
    if (d_ptr->captureSession)
        d_ptr->captureSession->setWindowCapture(nullptr);
    if (oldCapture) {
        if (oldCapture->captureSession() && oldCapture->captureSession() != this)
            oldCapture->captureSession()->setWindowCapture(nullptr);
        oldCapture->setCaptureSession(nullptr);
    }
    if (windowCapture) {
        if (windowCapture->captureSession())
            windowCapture->captureSession()->setWindowCapture(nullptr);
        if (d_ptr->captureSession)
            d_ptr->captureSession->setWindowCapture(windowCapture->platformWindowCapture());
        windowCapture->setCaptureSession(this);
    }
    emit windowCaptureChanged();
}
 
QImageCapture *QMediaCaptureSession::imageCapture()
{
    return d_ptr->imageCapture;
}
 
void QMediaCaptureSession::setImageCapture(QImageCapture *imageCapture)
{
    // TODO: come up with an unification of the captures setup
    QImageCapture *oldImageCapture = d_ptr->imageCapture;
    if (oldImageCapture == imageCapture)
        return;
    d_ptr->imageCapture = imageCapture;
    if (d_ptr->captureSession)
        d_ptr->captureSession->setImageCapture(nullptr);
    if (oldImageCapture) {
        if (oldImageCapture->captureSession() && oldImageCapture->captureSession() != this)
            oldImageCapture->captureSession()->setImageCapture(nullptr);
        oldImageCapture->setCaptureSession(nullptr);
    }
    if (imageCapture) {
        if (imageCapture->captureSession())
            imageCapture->captureSession()->setImageCapture(nullptr);
        if (d_ptr->captureSession)
            d_ptr->captureSession->setImageCapture(imageCapture->platformImageCapture());
        imageCapture->setCaptureSession(this);
    }
    emit imageCaptureChanged();
}
QMediaRecorder *QMediaCaptureSession::recorder()
{
    return d_ptr->recorder;
}
 
void QMediaCaptureSession::setRecorder(QMediaRecorder *recorder)
{
    QMediaRecorder *oldRecorder = d_ptr->recorder;
    if (oldRecorder == recorder)
        return;
    d_ptr->recorder = recorder;
    if (d_ptr->captureSession)
        d_ptr->captureSession->setMediaRecorder(nullptr);
    if (oldRecorder) {
        if (oldRecorder->captureSession() && oldRecorder->captureSession() != this)
            oldRecorder->captureSession()->setRecorder(nullptr);
        oldRecorder->setCaptureSession(nullptr);
    }
    if (recorder) {
        if (recorder->captureSession())
            recorder->captureSession()->setRecorder(nullptr);
        if (d_ptr->captureSession)
            d_ptr->captureSession->setMediaRecorder(recorder->platformRecoder());
        recorder->setCaptureSession(this);
    }
    emit recorderChanged();
}
QObject *QMediaCaptureSession::videoOutput() const
{
    Q_D(const QMediaCaptureSession);
    return d->videoOutput;
}
void QMediaCaptureSession::setVideoOutput(QObject *output)
{
    Q_D(QMediaCaptureSession);
    if (d->videoOutput == output)
        return;
    QVideoSink *sink = qobject_cast<QVideoSink *>(output);
    if (!sink && output) {
        auto *mo = output->metaObject();
        mo->invokeMethod(output, "videoSink", Q_RETURN_ARG(QVideoSink *, sink));
    }
    d->videoOutput = output;
    d->setVideoSink(sink);
}
 
void QMediaCaptureSession::setVideoSink(QVideoSink *sink)
{
    Q_D(QMediaCaptureSession);
    d->videoOutput = nullptr;
    d->setVideoSink(sink);
}
 
QVideoSink *QMediaCaptureSession::videoSink() const
{
    Q_D(const QMediaCaptureSession);
    return d->videoSink;
}
void QMediaCaptureSession::setAudioOutput(QAudioOutput *output)
{
    QAudioOutput *oldOutput = d_ptr->audioOutput;
    if (oldOutput == output)
        return;
 
    // We don't want to end up with signal emitted
    // twice (from recursive call setAudioInput(nullptr)
    // from oldOutput->setDisconnectFunction():
    d_ptr->audioOutput = nullptr;
 
    if (d_ptr->captureSession)
        d_ptr->captureSession->setAudioOutput(nullptr);
    if (oldOutput)
        oldOutput->setDisconnectFunction({});
    if (output) {
        output->setDisconnectFunction([this](){ setAudioOutput(nullptr); });
        if (d_ptr->captureSession)
            d_ptr->captureSession->setAudioOutput(output->handle());
    }
    d_ptr->audioOutput = output;
    emit audioOutputChanged();
}
QAudioOutput *QMediaCaptureSession::audioOutput() const
{
    Q_D(const QMediaCaptureSession);
    return d->audioOutput;
}
 
QPlatformMediaCaptureSession *QMediaCaptureSession::platformSession() const
{
    return d_ptr->captureSession;
}
QT_END_NAMESPACE
 
#include "moc_qmediacapturesession.cpp"