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 "qwindowsmediaencoder_p.h"
++
++ #include <common/mfmetadata_p.h>
++ #include <mediacapture/qwindowsmediacapture_p.h>
++ #include <mediacapture/qwindowsmediadevicesession_p.h>
++
++ #include <QtMultimedia/private/qmediarecorder_p.h>
++ #include <QtMultimedia/private/qmediastoragelocation_p.h>
++ #include <QtCore/qurl.h>
++ #include <QtCore/private/qcomptr_p.h>
++
++ #include <mferror.h>
++ #include <shobjidl.h>
++
++ QT_BEGIN_NAMESPACE
++
++ QWindowsMediaEncoder::QWindowsMediaEncoder(QMediaRecorder *parent)
++ : QObject(parent),
++ QPlatformMediaRecorder(parent)
++ {
++ }
++
++ bool QWindowsMediaEncoder::isLocationWritable(const QUrl &location) const
++ {
++ return location.scheme() == u"file" || location.scheme().isEmpty();
++ }
++
++ QMediaRecorder::RecorderState QWindowsMediaEncoder::state() const
++ {
++ return m_state;
++ }
++
++ qint64 QWindowsMediaEncoder::duration() const
++ {
++ return m_duration;
++ }
++
++ void QWindowsMediaEncoder::record(QMediaEncoderSettings &settings)
++ {
++ if (!m_captureService || !m_mediaDeviceSession) {
++ qWarning() << Q_FUNC_INFO << "Encoder is not set to a capture session";
++ return;
++ }
++ if (m_state != QMediaRecorder::StoppedState)
++ return;
++
++ m_sessionWasActive = m_mediaDeviceSession->isActive() || m_mediaDeviceSession->isActivating();
++
++ if (!m_sessionWasActive) {
++
++ m_mediaDeviceSession->setActive(true);
++
++ if (!m_mediaDeviceSession->isActivating()) {
++ updateError(QMediaRecorder::ResourceError,
++ QMediaRecorderPrivate::msgFailedStartRecording());
++ return;
++ }
++ }
++
++ const auto audioOnly = settings.videoCodec() == QMediaFormat::VideoCodec::Unspecified;
++ m_fileName = QMediaStorageLocation::generateFileName(outputLocation().toLocalFile(),
++ audioOnly ? QStandardPaths::MusicLocation
++ : QStandardPaths::MoviesLocation,
++ settings.preferredSuffix());
++
++ QMediaRecorder::Error ec = m_mediaDeviceSession->startRecording(settings, m_fileName, audioOnly);
++ if (ec == QMediaRecorder::NoError) {
++ m_state = QMediaRecorder::RecordingState;
++
++ actualLocationChanged(QUrl::fromLocalFile(m_fileName));
++ stateChanged(m_state);
++
++ } else {
++ updateError(ec, QMediaRecorderPrivate::msgFailedStartRecording());
++ }
++ }
++
++ void QWindowsMediaEncoder::pause()
++ {
++ if (!m_mediaDeviceSession || m_state != QMediaRecorder::RecordingState)
++ return;
++
++ if (m_mediaDeviceSession->pauseRecording()) {
++ m_state = QMediaRecorder::PausedState;
++ stateChanged(m_state);
++ } else {
++ updateError(QMediaRecorder::FormatError, tr("Failed to pause recording"));
++ }
++ }
++
++ void QWindowsMediaEncoder::resume()
++ {
++ if (!m_mediaDeviceSession || m_state != QMediaRecorder::PausedState)
++ return;
++
++ if (m_mediaDeviceSession->resumeRecording()) {
++ m_state = QMediaRecorder::RecordingState;
++ stateChanged(m_state);
++ } else {
++ updateError(QMediaRecorder::FormatError, tr("Failed to resume recording"));
++ }
++ }
++
++ void QWindowsMediaEncoder::stop()
++ {
++ if (m_mediaDeviceSession && m_state != QMediaRecorder::StoppedState) {
++ m_mediaDeviceSession->stopRecording();
++ if (!m_sessionWasActive)
++ m_mediaDeviceSession->setActive(false);
++ }
++ }
++
++
++
++ void QWindowsMediaEncoder::setCaptureSession(QPlatformMediaCaptureSession *session)
++ {
++ QWindowsMediaCaptureService *captureSession = static_cast<QWindowsMediaCaptureService *>(session);
++ if (m_captureService == captureSession)
++ return;
++
++ if (m_captureService)
++ stop();
++
++ m_captureService = captureSession;
++ if (!m_captureService) {
++ m_mediaDeviceSession = nullptr;
++ return;
++ }
++
++ m_mediaDeviceSession = m_captureService->session();
++ Q_ASSERT(m_mediaDeviceSession);
++
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::recordingStarted, this, &QWindowsMediaEncoder::onRecordingStarted);
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::recordingStopped, this, &QWindowsMediaEncoder::onRecordingStopped);
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::streamingError, this, &QWindowsMediaEncoder::onStreamingError);
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::recordingError, this, &QWindowsMediaEncoder::onRecordingError);
++ connect(m_mediaDeviceSession, &QWindowsMediaDeviceSession::durationChanged, this, &QWindowsMediaEncoder::onDurationChanged);
++ connect(m_captureService, &QWindowsMediaCaptureService::cameraChanged, this, &QWindowsMediaEncoder::onCameraChanged);
++ onCameraChanged();
++ }
++
++ void QWindowsMediaEncoder::setMetaData(const QMediaMetaData &metaData)
++ {
++ m_metaData = metaData;
++ }
++
++ QMediaMetaData QWindowsMediaEncoder::metaData() const
++ {
++ return m_metaData;
++ }
++
++ void QWindowsMediaEncoder::saveMetadata()
++ {
++ if (!m_metaData.isEmpty()) {
++
++ const QString nativeFileName = QDir::toNativeSeparators(m_fileName);
++
++ ComPtr<IPropertyStore> store;
++
++ if (SUCCEEDED(SHGetPropertyStoreFromParsingName(reinterpret_cast<LPCWSTR>(nativeFileName.utf16()),
++ nullptr, GPS_READWRITE, IID_PPV_ARGS(&store)))) {
++
++ MFMetaData::toNative(m_metaData, store.Get());
++
++ store->Commit();
++ }
++ }
++ }
++
++ void QWindowsMediaEncoder::onDurationChanged(qint64 duration)
++ {
++ m_duration = duration;
++ durationChanged(m_duration);
++ }
++
++ void QWindowsMediaEncoder::onStreamingError(HRESULT errorCode)
++ {
++ if (errorCode == MF_E_VIDEO_RECORDING_DEVICE_INVALIDATED)
++ updateError(QMediaRecorder::ResourceError, tr("Camera is no longer present"));
++ else if (errorCode == MF_E_AUDIO_RECORDING_DEVICE_INVALIDATED)
++ updateError(QMediaRecorder::ResourceError, tr("Audio input is no longer present"));
++ else
++ updateError(QMediaRecorder::ResourceError, tr("Streaming error"));
++
++ if (m_state != QMediaRecorder::StoppedState) {
++ m_mediaDeviceSession->stopRecording();
++ if (!m_sessionWasActive)
++ m_mediaDeviceSession->setActive(false);
++ }
++ }
++
++ void QWindowsMediaEncoder::onRecordingError(HRESULT errorCode)
++ {
++ Q_UNUSED(errorCode);
++ updateError(QMediaRecorder::ResourceError, tr("Recording error"));
++
++ auto lastState = m_state;
++ m_state = QMediaRecorder::StoppedState;
++ if (m_state != lastState)
++ stateChanged(m_state);
++ }
++
++ void QWindowsMediaEncoder::onCameraChanged()
++ {
++ }
++
++ void QWindowsMediaEncoder::onRecordingStarted()
++ {
++ }
++
++ void QWindowsMediaEncoder::onRecordingStopped()
++ {
++ saveMetadata();
++
++ auto lastState = m_state;
++ m_state = QMediaRecorder::StoppedState;
++ if (m_state != lastState)
++ stateChanged(m_state);
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qwindowsmediaencoder_p.cpp"