Revision control

++ // Copyright (C) 2016 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 <mediacapture/qgstreamermediarecorder_p.h>
++ #include <qgstreamerformatinfo_p.h>
++ #include <common/qgstpipeline_p.h>
++ #include <common/qgstreamermessage_p.h>
++ #include <common/qgst_debug_p.h>
++ #include <qgstreamerintegration_p.h>
++
++ #include <QtMultimedia/private/qmediastoragelocation_p.h>
++ #include <QtMultimedia/private/qplatformcamera_p.h>
++ #include <QtMultimedia/qaudiodevice.h>
++
++ #include <QtCore/qdebug.h>
++ #include <QtCore/qeventloop.h>
++ #include <QtCore/qstandardpaths.h>
++ #include <QtCore/qloggingcategory.h>
++
++ #include <gst/gsttagsetter.h>
++ #include <gst/gstversion.h>
++ #include <gst/video/video.h>
++ #include <gst/pbutils/encoding-profile.h>
++
++ Q_STATIC_LOGGING_CATEGORY(qLcMediaRecorder, "qt.multimedia.recorder");
++
++ QT_BEGIN_NAMESPACE
++
++ QGstreamerMediaRecorder::QGstreamerMediaRecorder(QMediaRecorder *parent)
++ : QPlatformMediaRecorder(parent), audioPauseControl(*this), videoPauseControl(*this)
++ {
++ signalDurationChangedTimer.setInterval(100);
++ signalDurationChangedTimer.callOnTimeout(&signalDurationChangedTimer, [this]() {
++ durationChanged(duration());
++ });
++ }
++
++ QGstreamerMediaRecorder::~QGstreamerMediaRecorder()
++ {
++ if (m_session)
++ finalize();
++ }
++
++ bool QGstreamerMediaRecorder::isLocationWritable(const QUrl &) const
++ {
++ return true;
++ }
++
++ void QGstreamerMediaRecorder::handleSessionError(QMediaRecorder::Error code,
++ const QString &description)
++ {
++ updateError(code, description);
++ stop();
++ }
++
++ void QGstreamerMediaRecorder::processBusMessage(const QGstreamerMessage &msg)
++ {
++ constexpr bool traceStateChange = false;
++ constexpr bool traceAllEvents = false;
++
++ if constexpr (traceAllEvents)
++ qCDebug(qLcMediaRecorder) << "received event:" << msg;
++
++ switch (msg.type()) {
++ case GST_MESSAGE_ELEMENT: {
++ QGstStructureView s = msg.structure();
++ if (s.name() == "GstBinForwarded")
++ return processBusMessage(s.getMessage());
++
++ qCDebug(qLcMediaRecorder) << "received element message from" << msg.source().name()
++ << s.name();
++ return;
++ }
++
++ case GST_MESSAGE_EOS: {
++ qCDebug(qLcMediaRecorder) << "received EOS from" << msg.source().name();
++ finalize();
++ return;
++ }
++
++ case GST_MESSAGE_ERROR: {
++ qCDebug(qLcMediaRecorder) << "received error:" << msg.source().name()
++ << QCompactGstMessageAdaptor(msg);
++
++ QUniqueGErrorHandle err;
++ QGString debug;
++ gst_message_parse_error(msg.message(), &err, &debug);
++ updateError(QMediaRecorder::ResourceError, QString::fromUtf8(err.get()->message));
++ if (!m_finalizing)
++ stop();
++ finalize();
++ return;
++ }
++
++ case GST_MESSAGE_STATE_CHANGED: {
++ if constexpr (traceStateChange)
++ qCDebug(qLcMediaRecorder) << "received state change" << QCompactGstMessageAdaptor(msg);
++
++ return;
++ }
++
++ default:
++ return;
++ };
++ }
++
++ qint64 QGstreamerMediaRecorder::duration() const
++ {
++ return std::max(audioPauseControl.duration, videoPauseControl.duration);
++ }
++
++
++ static GstEncodingContainerProfile *createContainerProfile(const QMediaEncoderSettings &settings)
++ {
++ auto *formatInfo = QGstreamerIntegration::instance()->gstFormatsInfo();
++
++ auto caps = formatInfo->formatCaps(settings.fileFormat());
++
++ GstEncodingContainerProfile *profile =
++ (GstEncodingContainerProfile *)gst_encoding_container_profile_new(
++ "container_profile", (gchar *)"custom container profile",
++ const_cast<GstCaps *>(caps.caps()),
++ nullptr); // preset
++ return profile;
++ }
++
++ static GstEncodingProfile *createVideoProfile(const QMediaEncoderSettings &settings)
++ {
++ auto *formatInfo = QGstreamerIntegration::instance()->gstFormatsInfo();
++
++ QGstCaps caps = formatInfo->videoCaps(settings.mediaFormat());
++ if (!caps)
++ return nullptr;
++
++ QSize videoResolution = settings.videoResolution();
++ if (videoResolution.isValid())
++ caps.setResolution(videoResolution);
++
++ GstEncodingVideoProfile *profile =
++ gst_encoding_video_profile_new(const_cast<GstCaps *>(caps.caps()), nullptr,
++ nullptr, // restriction
++ 0); // presence
++
++ gst_encoding_video_profile_set_pass(profile, 0);
++ gst_encoding_video_profile_set_variableframerate(profile, TRUE);
++
++ return (GstEncodingProfile *)profile;
++ }
++
++ static GstEncodingProfile *createAudioProfile(const QMediaEncoderSettings &settings)
++ {
++ auto *formatInfo = QGstreamerIntegration::instance()->gstFormatsInfo();
++
++ auto caps = formatInfo->audioCaps(settings.mediaFormat());
++ if (!caps)
++ return nullptr;
++
++ GstEncodingProfile *profile =
++ (GstEncodingProfile *)gst_encoding_audio_profile_new(const_cast<GstCaps *>(caps.caps()),
++ nullptr, // preset
++ nullptr, // restriction
++ 0); // presence
++
++ return profile;
++ }
++
++
++ static GstEncodingContainerProfile *createEncodingProfile(const QMediaEncoderSettings &settings)
++ {
++ auto *containerProfile = createContainerProfile(settings);
++ if (!containerProfile) {
++ qWarning() << "QGstreamerMediaEncoder: failed to create container profile!";
++ return nullptr;
++ }
++
++ GstEncodingProfile *audioProfile = createAudioProfile(settings);
++ GstEncodingProfile *videoProfile = nullptr;
++ if (settings.videoCodec() != QMediaFormat::VideoCodec::Unspecified)
++ videoProfile = createVideoProfile(settings);
++ // qDebug() << "audio profile" << (audioProfile ? gst_caps_to_string(gst_encoding_profile_get_format(audioProfile)) : "(null)");
++ // qDebug() << "video profile" << (videoProfile ? gst_caps_to_string(gst_encoding_profile_get_format(videoProfile)) : "(null)");
++ // qDebug() << "conta profile" << gst_caps_to_string(gst_encoding_profile_get_format((GstEncodingProfile *)containerProfile));
++
++ if (videoProfile) {
++ if (!gst_encoding_container_profile_add_profile(containerProfile, videoProfile)) {
++ qWarning() << "QGstreamerMediaEncoder: failed to add video profile!";
++ gst_encoding_profile_unref(videoProfile);
++ }
++ }
++ if (audioProfile) {
++ if (!gst_encoding_container_profile_add_profile(containerProfile, audioProfile)) {
++ qWarning() << "QGstreamerMediaEncoder: failed to add audio profile!";
++ gst_encoding_profile_unref(audioProfile);
++ }
++ }
++
++ return containerProfile;
++ }
++
++ void QGstreamerMediaRecorder::PauseControl::reset()
++ {
++ pauseOffsetPts = 0;
++ pauseStartPts.reset();
++ duration = 0;
++ firstBufferPts.reset();
++ }
++
++ void QGstreamerMediaRecorder::PauseControl::installOn(QGstPad pad)
++ {
++ pad.addProbe<&QGstreamerMediaRecorder::PauseControl::processBuffer>(this,
++ GST_PAD_PROBE_TYPE_BUFFER);
++ }
++
++ GstPadProbeReturn QGstreamerMediaRecorder::PauseControl::processBuffer(const QGstPad &,
++ GstPadProbeInfo *info)
++ {
++ auto buffer = GST_PAD_PROBE_INFO_BUFFER(info);
++ if (!buffer)
++ return GST_PAD_PROBE_OK;
++
++ buffer = gst_buffer_make_writable(buffer);
++
++ if (!buffer)
++ return GST_PAD_PROBE_OK;
++
++ GST_PAD_PROBE_INFO_DATA(info) = buffer;
++
++ if (!GST_BUFFER_PTS_IS_VALID(buffer))
++ return GST_PAD_PROBE_OK;
++
++ if (!firstBufferPts)
++ firstBufferPts = GST_BUFFER_PTS(buffer);
++
++ if (encoder.state() == QMediaRecorder::PausedState) {
++ if (!pauseStartPts)
++ pauseStartPts = GST_BUFFER_PTS(buffer);
++
++ return GST_PAD_PROBE_DROP;
++ }
++
++ if (pauseStartPts) {
++ pauseOffsetPts += GST_BUFFER_PTS(buffer) - *pauseStartPts;
++ pauseStartPts.reset();
++ }
++ GST_BUFFER_PTS(buffer) -= pauseOffsetPts;
++
++ duration = (GST_BUFFER_PTS(buffer) - *firstBufferPts) / GST_MSECOND;
++
++ return GST_PAD_PROBE_OK;
++ }
++
++ void QGstreamerMediaRecorder::record(QMediaEncoderSettings &settings)
++ {
++ if (!m_session ||m_finalizing || state() != QMediaRecorder::StoppedState)
++ return;
++
++ const auto hasVideo = m_session->camera() && m_session->camera()->isActive();
++ const auto hasAudio = m_session->audioInput() != nullptr;
++
++ if (!hasVideo && !hasAudio) {
++ updateError(QMediaRecorder::ResourceError, QMediaRecorder::tr("No camera or audio input"));
++ return;
++ }
++
++ const auto audioOnly = settings.videoCodec() == QMediaFormat::VideoCodec::Unspecified;
++
++ auto primaryLocation = audioOnly ? QStandardPaths::MusicLocation : QStandardPaths::MoviesLocation;
++ auto container = settings.preferredSuffix();
++ auto location = QMediaStorageLocation::generateFileName(outputLocation().toLocalFile(), primaryLocation, container);
++
++ QUrl actualSink = QUrl::fromLocalFile(QDir::currentPath()).resolved(QUrl{location});
++ qCDebug(qLcMediaRecorder) << "recording new video to" << actualSink;
++
++ Q_ASSERT(!actualSink.isEmpty());
++
++ QGstBin gstEncodebin = QGstBin::createFromFactory("encodebin", "encodebin");
++ Q_ASSERT(gstEncodebin);
++ auto *encodingProfile = createEncodingProfile(settings);
++ g_object_set(gstEncodebin.object(), "profile", encodingProfile, nullptr);
++ gst_encoding_profile_unref(encodingProfile);
++
++ QGstElement gstFileSink = QGstElement::createFromFactory("filesink", "filesink");
++ Q_ASSERT(gstFileSink);
++ gstFileSink.set("location", QFile::encodeName(actualSink.toLocalFile()).constData());
++
++ QGstPad audioSink = {};
++ QGstPad videoSink = {};
++
++ audioPauseControl.reset();
++ videoPauseControl.reset();
++
++ if (hasAudio) {
++ audioSink = gstEncodebin.getRequestPad("audio_%u");
++ if (!audioSink)
++ qWarning() << "Unsupported audio codec";
++ else
++ audioPauseControl.installOn(audioSink);
++ }
++
++ if (hasVideo) {
++ videoSink = gstEncodebin.getRequestPad("video_%u");
++ if (!videoSink)
++ qWarning() << "Unsupported video codec";
++ else
++ videoPauseControl.installOn(videoSink);
++ }
++
++ QGstreamerMediaCaptureSession::RecorderElements recorder{
++ std::move(gstEncodebin),
++ std::move(gstFileSink),
++ std::move(audioSink),
++ std::move(videoSink),
++ };
++
++ m_session->linkAndStartEncoder(std::move(recorder), m_metaData);
++
++ signalDurationChangedTimer.start();
++
++ m_session->pipeline().dumpGraph("recording");
++
++ durationChanged(0);
++ actualLocationChanged(QUrl::fromLocalFile(location));
++ stateChanged(QMediaRecorder::RecordingState);
++ }
++
++ void QGstreamerMediaRecorder::pause()
++ {
++ if (!m_session || m_finalizing || state() != QMediaRecorder::RecordingState)
++ return;
++ signalDurationChangedTimer.stop();
++ durationChanged(duration());
++ m_session->pipeline().dumpGraph("before-pause");
++ stateChanged(QMediaRecorder::PausedState);
++ }
++
++ void QGstreamerMediaRecorder::resume()
++ {
++ m_session->pipeline().dumpGraph("before-resume");
++ if (!m_session || m_finalizing || state() != QMediaRecorder::PausedState)
++ return;
++ signalDurationChangedTimer.start();
++ stateChanged(QMediaRecorder::RecordingState);
++ }
++
++ void QGstreamerMediaRecorder::stop()
++ {
++ if (!m_session || m_finalizing || state() == QMediaRecorder::StoppedState)
++ return;
++ durationChanged(duration());
++ qCDebug(qLcMediaRecorder) << "stop";
++ m_finalizing = true;
++ m_session->unlinkRecorder();
++ signalDurationChangedTimer.stop();
++ }
++
++ void QGstreamerMediaRecorder::finalize()
++ {
++ if (!m_session || !m_finalizing)
++ return;
++
++ qCDebug(qLcMediaRecorder) << "finalize";
++
++ m_session->finalizeRecorder();
++ m_finalizing = false;
++ stateChanged(QMediaRecorder::StoppedState);
++ }
++
++ void QGstreamerMediaRecorder::setMetaData(const QMediaMetaData &metaData)
++ {
++ if (!m_session)
++ return;
++ m_metaData = metaData;
++ }
++
++ QMediaMetaData QGstreamerMediaRecorder::metaData() const
++ {
++ return m_metaData;
++ }
++
++ void QGstreamerMediaRecorder::setCaptureSession(QPlatformMediaCaptureSession *session)
++ {
++ QGstreamerMediaCaptureSession *captureSession =
++ static_cast<QGstreamerMediaCaptureSession *>(session);
++ if (m_session == captureSession)
++ return;
++
++ if (m_session) {
++ stop();
++ if (m_finalizing) {
++ QEventLoop loop;
++ QObject::connect(mediaRecorder(), &QMediaRecorder::recorderStateChanged, &loop,
++ &QEventLoop::quit);
++ loop.exec();
++ }
++ }
++
++ m_session = captureSession;
++ }
++
++ QT_END_NAMESPACE