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 "qmediarecorder_p.h"
++
++ #include <private/qplatformmediarecorder_p.h>
++ #include <qaudiodevice.h>
++ #include <qcamera.h>
++ #include <qscreencapture.h>
++ #include <qwindowcapture.h>
++ #include <qmediacapturesession.h>
++ #include <private/qplatformcamera_p.h>
++ #include <private/qplatformsurfacecapture_p.h>
++ #include <private/qplatformmediaintegration_p.h>
++ #include <private/qplatformmediacapture_p.h>
++
++ #include <QtCore/qdebug.h>
++ #include <QtCore/qurl.h>
++ #include <QtCore/qstringlist.h>
++ #include <QtCore/qmetaobject.h>
++ #include <QtCore/qtimer.h>
++
++ #include <qaudioformat.h>
++
++ QT_BEGIN_NAMESPACE
++
++ /*!
++ \class QMediaRecorder
++ \inmodule QtMultimedia
++ \ingroup multimedia
++ \ingroup multimedia_recording
++ \ingroup multimedia_video
++ \ingroup multimedia_audio
++
++ \brief The QMediaRecorder class is used for encoding and recording a capture session.
++
++ Use the QMediaRecorder class to encode and record media generated in
++ \l QMediaCaptureSession. You can generate:
++ \list
++ \li Audio. Use \l QAudioInput or \l QAudioBufferInput.
++ \li Video. Use \l QCamera, \l QScreenCapture, \l QWindowCapture, \l QVideoFrameInput,
++ or \l QGStreamerVideoSource (on embedded Linux with the \c gstreamer media backend).
++ \endlist
++
++ To record media, connect a generator to a corresponding media capture session.
++
++ Performance of video encoding and recording is limited by the hardware,
++ the operating system, the installed graphic drivers, and the input video format.
++ If \c QCamera, \c QScreenCapture, or \c QWindowCapture produces video frames
++ faster than \c QMediaRecorder can encode and record them, the recorder
++ may drop some frames. This is likely to occur if the input frame resolution
++ is high, 4K for example, and hardware-accelerated encoding is unavailable.
++ If you generate input video via \c QVideoFrameInput, the method
++ \c QVideoFrameInput::sendVideoFrame will do nothing and return \c false
++ whenever this limitation is reached and the internal frame queue is full.
++ Rely on the signal \c QVideoFrameInput::readyToSendVideoFrame to know
++ when the recorder is ready to receive new frames again.
++ If you cannot change the rate of video frame generation and dropping frames
++ is undesirable, we recommend implementing your own frame queue on top of
++ \c QVideoFrameInput, considering the memory limitations of the hardware.
++
++ \snippet multimedia-snippets/media.cpp Media recorder
++ */
++ /*!
++ \qmltype MediaRecorder
++ \nativetype QMediaRecorder
++ \brief For encoding and recording media generated in a CaptureSession.
++
++ \inqmlmodule QtMultimedia
++ \ingroup multimedia_qml
++ \ingroup multimedia_audio_qml
++ \ingroup multimedia_video_qml
++
++ Use the MediaRecorder element within a CaptureSession to encode and record:
++ \list
++ \li Audio captured from an audio interface (like microphone or line input).
++ \li Video captured from camera, screen, or an application window.
++ \endlist
++
++ Performance of video encoding and recording is limited by the hardware,
++ the operating system, the installed graphic drivers, and the input video format.
++ If \c Camera, \c ScreenCapture, or \c WindowCapture produces video frames
++ faster than \c MediaRecorder can encode and record them, the recorder
++ may drop some frames. This is likely to occur if the input frame resolution
++ is high, 4K for example, and hardware-accelerated encoding is unavailable.
++
++ \since 6.2
++ The code below shows a simple capture session containing a MediaRecorder using the default
++ camera and default audio input.
++
++ \qml
++ CaptureSession {
++ id: captureSession
++ camera: Camera {
++ id: camera
++ active: true
++ }
++ audioInput: AudioInput {}
++ recorder: MediaRecorder {
++ id: recorder
++ }
++ }
++ \endqml
++
++ The code below shows how the recording can be started and stopped.
++ \qml
++ CameraButton {
++ text: "Record"
++ visible: recorder.recorderState !== MediaRecorder.RecordingState
++ onClicked: recorder.record()
++ }
++
++ CameraButton {
++ id: stopButton
++ text: "Stop"
++ visible: recorder.recorderState === MediaRecorder.RecordingState
++ onClicked: recorder.stop()
++ }
++ \endqml
++
++ \sa CaptureSession, Camera, ScreenCapture, WindowCapture, AudioInput, ImageCapture
++ */
++ QMediaRecorderPrivate::QMediaRecorderPrivate()
++ {
++ #if QT_CONFIG(mimetype)
++ // Force an early initialization of the mime database
++ // to avoid a delay when recording for the first time.
++ encoderSettings.mimeType();
++ #endif
++ }
++
++ QString QMediaRecorderPrivate::msgFailedStartRecording()
++ {
++ return QMediaRecorder::tr("Failed to start recording");
++ }
++
++ /*!
++ Constructs a media recorder.
++ The media recorder is a child of \a{parent}.
++ */
++
++ QMediaRecorder::QMediaRecorder(QObject *parent)
++ : QObject(parent),
++ d_ptr(new QMediaRecorderPrivate)
++ {
++ Q_D(QMediaRecorder);
++
++ auto &mediaIntegration = *QPlatformMediaIntegration::instance();
++
++ d->q_ptr = this;
++ auto maybeControl = mediaIntegration.createRecorder(this);
++ if (maybeControl) {
++ // The first format info initialization may take some time,
++ // for users it seems to be more suitable to have a delay on the object construction
++ // rather than on QMediaRecorder::record
++ mediaIntegration.formatInfo();
++
++ d->control = maybeControl.value();
++ } else {
++ d->initErrorMessage = maybeControl.error();
++ qWarning() << "Failed to initialize QMediaRecorder" << maybeControl.error();
++ }
++ }
++
++ /*!
++ Destroys a media recorder object.
++ */
++
++ QMediaRecorder::~QMediaRecorder()
++ {
++ if (d_ptr->captureSession)
++ d_ptr->captureSession->setRecorder(nullptr);
++ delete d_ptr->control;
++ delete d_ptr;
++ }
++
++ /*!
++ \internal
++ */
++ QPlatformMediaRecorder *QMediaRecorder::platformRecoder() const
++ {
++ return d_ptr->control;
++ }
++
++ /*!
++ \internal
++ */
++ void QMediaRecorder::setCaptureSession(QMediaCaptureSession *session)
++ {
++ Q_D(QMediaRecorder);
++ d->captureSession = session;
++ }
++ /*!
++ \qmlproperty url QtMultimedia::MediaRecorder::outputLocation
++ \brief The destination location of media content.
++
++ Setting the location can fail, for example when the service supports only
++ local file system locations but a network URL was passed. If the operation
++ fails, the \l errorOccurred() signal is emitted.
++
++ The output location can be empty, a directory, or a file. The path to a
++ directory or file can be relative or absolute. The \l record() method
++ generates the actual location according to the specified output location and
++ system-specific settings. Refer to the \l actualLocation property description
++ for details.
++
++ \sa actualLocation, errorOccurred()
++ */
++
++ /*!
++ \property QMediaRecorder::outputLocation
++ \brief The destination location of media content.
++
++ Setting the location can fail, for example when the service supports only
++ local file system locations but a network URL was passed. If the operation
++ fails, the \l errorOccurred() signal is emitted.
++
++ The output location is ignored if a writable \l outputDevice
++ has been assigned to the recorder.
++ This behavior may change in the future, so we recommend setting only one output,
++ either \c outputLocation or \c outputDevice.
++
++ The output location can be empty, a directory, or a file. The path to a
++ directory or file can be relative or absolute. The \l record() method
++ generates the actual location according to the specified output location and
++ system-specific settings. Refer to the \l actualLocation property description
++ for details.
++
++ \sa actualLocation, outputDevice()
++ */
++
++ /*!
++ \qmlproperty url QtMultimedia::MediaRecorder::actualLocation
++ \brief The actual location of the last media content.
++
++ The actual location is reset when a new \l outputLocation is assigned.
++ When \l record() is invoked, the recorder generates the actual location
++ basing on the following rules.
++ \list
++ \li If \c outputLocation is empty, a directory, or a file
++ without an extension, the recorder generates the appropriate extension
++ based on the selected media format and system MIME types.
++ \li If \c outputLocation is a directory, the recorder generates a new file
++ name within it.
++ \li If \c outputLocation is empty, the recorder generates a new file name in
++ the system-specific directory for audio or video.
++ \li The recorder generates the actual location before
++ emitting \c recorderStateChanged(RecordingState).
++ \endlist
++ */
++
++ /*!
++ \property QMediaRecorder::actualLocation
++ \brief The actual location of the last media content.
++
++ The actual location is reset when a new \l outputLocation
++ or a non-null \l outputDevice is assigned.
++ When \l record() is invoked and \c outputDevice is \c null or not writable,
++ the recorder generates the actual location basing on the following rules.
++ \list
++ \li If \c outputLocation is empty, a directory, or a file
++ without an extension, the recorder generates the appropriate extension
++ based on the selected media format and system MIME types.
++ \li If \c outputLocation is a directory, the recorder generates a new file
++ name within it.
++ \li If \c outputLocation is empty, the recorder generates a new file name in
++ the system-specific directory for audio or video.
++ \li The recorder generates the actual location before
++ emitting \c recorderStateChanged(RecordingState).
++ \endlist
++ */
++
++ /*!
++ Returns \c true if media recorder service ready to use.
++ */
++ bool QMediaRecorder::isAvailable() const
++ {
++ return d_func()->control && d_func()->captureSession;
++ }
++
++ QUrl QMediaRecorder::outputLocation() const
++ {
++ return d_func()->control ? d_func()->control->outputLocation() : QUrl();
++ }
++
++ void QMediaRecorder::setOutputLocation(const QUrl &location)
++ {
++ Q_D(QMediaRecorder);
++ if (!d->control) {
++ Q_EMIT errorOccurred(QMediaRecorder::ResourceError, d->initErrorMessage);
++ return;
++ }
++ d->control->setOutputLocation(location);
++ d->control->clearActualLocation();
++ if (!location.isEmpty() && !d->control->isLocationWritable(location))
++ Q_EMIT errorOccurred(QMediaRecorder::LocationNotWritable,
++ QStringLiteral("Output location not writable"));
++ }
++
++ /*!
++ Set the output IO device for media content.
++
++ The \a device must have been opened in the \l{QIODevice::WriteOnly}{WriteOnly} or
++ \l{QIODevice::ReadWrite}{ReadWrite} modes before the recording starts.
++
++ The media recorder doesn't take ownership of the specified \a device.
++ If the recording has been started, the device must be kept alive and open until
++ the signal \c recorderStateChanged(StoppedState) is emitted.
++
++ This method resets \l actualLocation immediately unless
++ the specified \a device is \c null.
++
++ If a writable output device is assigned to the recorder, \l outputLocation
++ is ignored, and \l actualLocation is not generated when recording starts.
++ This behavior may change in the future, so we recommend setting only
++ one output, either \c outputLocation or \c outputDevice.
++
++ \c QMediaRecorder::setOutputDevice is only supported with the FFmpeg backend.
++
++ \sa outputDevice(), outputLocation
++ */
++ void QMediaRecorder::setOutputDevice(QIODevice *device)
++ {
++ Q_D(QMediaRecorder);
++ if (!d->control) {
++ Q_EMIT errorOccurred(QMediaRecorder::ResourceError, d->initErrorMessage);
++ return;
++ }
++
++ d->control->setOutputDevice(device);
++
++ if (device)
++ d->control->clearActualLocation();
++ }
++
++ /*!
++ Returns the output IO device for media content.
++
++ \sa setOutputDevice()
++ */
++ QIODevice *QMediaRecorder::outputDevice() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->control ? d->control->outputDevice() : nullptr;
++ }
++
++ QUrl QMediaRecorder::actualLocation() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->control ? d->control->actualLocation() : QUrl();
++ }
++
++ /*!
++ Returns the current media recorder state.
++
++ \sa QMediaRecorder::RecorderState
++ */
++
++ QMediaRecorder::RecorderState QMediaRecorder::recorderState() const
++ {
++ return d_func()->control ? QMediaRecorder::RecorderState(d_func()->control->state()) : StoppedState;
++ }
++
++ /*!
++ \property QMediaRecorder::error
++
++ Returns the current error state.
++
++ \sa errorString()
++ */
++
++ QMediaRecorder::Error QMediaRecorder::error() const
++ {
++ Q_D(const QMediaRecorder);
++
++ return d->control ? d->control->error() : QMediaRecorder::ResourceError;
++ }
++ /*!
++ \qmlproperty string QtMultimedia::MediaRecorder::errorString
++ \brief This property holds a string describing the current error state.
++
++ \sa error
++ */
++ /*!
++ \property QMediaRecorder::errorString
++
++ Returns a string describing the current error state.
++
++ \sa error()
++ */
++
++ QString QMediaRecorder::errorString() const
++ {
++ Q_D(const QMediaRecorder);
++
++ return d->control ? d->control->errorString() : d->initErrorMessage;
++ }
++ /*!
++ \qmlproperty qint64 QtMultimedia::MediaRecorder::duration
++
++ \brief This property holds the recorded media duration in milliseconds.
++ */
++
++ /*!
++ \property QMediaRecorder::duration
++
++ \brief the recorded media duration in milliseconds.
++ */
++
++ qint64 QMediaRecorder::duration() const
++ {
++ return d_func()->control ? d_func()->control->duration() : 0;
++ }
++
++ #if QT_DEPRECATED_SINCE(6, 9)
++ /*!
++ \fn void QMediaRecorder::encoderSettingsChanged()
++ \deprecated [6.9] Use specific signals instead.
++
++ Signals when the encoder settings change.
++ */
++ #endif
++
++ /*!
++ \qmlmethod void QtMultimedia::MediaRecorder::record()
++ \brief Starts recording.
++
++ While the recorder state is changed immediately to
++ \c MediaRecorder.RecordingState, recording may start asynchronously.
++
++ If recording fails, the error() signal is emitted with recorder state being
++ reset back to \c{QMediaRecorder.StoppedState}.
++
++ This method updates \l actualLocation according to its generation rules.
++
++ \note On mobile devices, recording will happen in the orientation the
++ device had when calling record and is locked for the duration of the recording.
++ To avoid artifacts on the user interface, we recommend to keep the user interface
++ locked to the same orientation as long as the recording is ongoing using
++ the contentOrientation property of the Window and unlock it again once the recording
++ is finished.
++ */
++ /*!
++ Starts recording.
++
++ While the recorder state is changed immediately to
++ c\{QMediaRecorder::RecordingState}, recording may start asynchronously.
++
++ If recording fails error() signal is emitted with recorder state being
++ reset back to \c{QMediaRecorder::StoppedState}.
++
++ This method updates \l actualLocation according to its generation rules.
++
++ \note On mobile devices, recording will happen in the orientation the
++ device had when calling record and is locked for the duration of the recording.
++ To avoid artifacts on the user interface, we recommend to keep the user interface
++ locked to the same orientation as long as the recording is ongoing using
++ the contentOrientation property of QWindow and unlock it again once the recording
++ is finished.
++ */
++
++ void QMediaRecorder::record()
++ {
++ Q_D(QMediaRecorder);
++
++ if (!d->control || !d->captureSession)
++ return;
++
++ if (d->control->state() == QMediaRecorder::PausedState) {
++ d->control->resume();
++ } else {
++ auto oldMediaFormat = d->encoderSettings.mediaFormat();
++
++ auto platformSession = d->captureSession->platformSession();
++ const bool hasVideo = platformSession && !platformSession->activeVideoSources().empty();
++
++ d->encoderSettings.resolveFormat(hasVideo ? QMediaFormat::RequiresVideo : QMediaFormat::NoFlags);
++ d->control->clearActualLocation();
++ d->control->clearError();
++
++ auto settings = d->encoderSettings;
++ d->control->record(d->encoderSettings);
++
++ #if QT_DEPRECATED_SINCE(6, 9)
++ QT_WARNING_PUSH
++ QT_WARNING_DISABLE_DEPRECATED
++ if (settings != d->encoderSettings)
++ Q_EMIT encoderSettingsChanged();
++ QT_WARNING_POP
++ #endif
++
++ if (oldMediaFormat != d->encoderSettings.mediaFormat())
++ Q_EMIT mediaFormatChanged();
++
++ if (settings.encodingMode() != d->encoderSettings.encodingMode())
++ Q_EMIT encodingModeChanged();
++
++ if (settings.quality() != d->encoderSettings.quality())
++ Q_EMIT qualityChanged();
++
++ if (settings.videoResolution() != d->encoderSettings.videoResolution())
++ Q_EMIT videoResolutionChanged();
++
++ if (!QtPrivate::fuzzyCompare(settings.videoFrameRate(),
++ d->encoderSettings.videoFrameRate()))
++ Q_EMIT videoFrameRateChanged();
++
++ if (settings.videoBitRate() != d->encoderSettings.videoBitRate())
++ Q_EMIT videoBitRateChanged();
++
++ if (settings.audioBitRate() != d->encoderSettings.audioBitRate())
++ Q_EMIT audioBitRateChanged();
++
++ if (settings.audioChannelCount() != d->encoderSettings.audioChannelCount())
++ Q_EMIT audioChannelCountChanged();
++
++ if (settings.audioSampleRate() != d->encoderSettings.audioSampleRate())
++ Q_EMIT audioSampleRateChanged();
++ }
++ }
++ /*!
++ \qmlmethod void QtMultimedia::MediaRecorder::pause()
++ \brief Pauses recording.
++
++ The recorder state is changed to QMediaRecorder.PausedState.
++
++ Depending on the platform, pausing recording may be not supported.
++ In this case the recorder state is unchanged.
++ */
++ /*!
++ Pauses recording.
++
++ The recorder state is changed to QMediaRecorder::PausedState.
++
++ Depending on the platform, pausing recording may be not supported.
++ In this case the recorder state is unchanged.
++ */
++
++ void QMediaRecorder::pause()
++ {
++ Q_D(QMediaRecorder);
++ if (d->control && d->captureSession)
++ d->control->pause();
++ }
++ /*!
++ \qmlmethod void QtMultimedia::MediaRecorder::stop()
++ \brief Stops the recording.
++
++ The recorder will stop the recording. Processing pending video and audio data might
++ however still take some time. The recording is finished, once the state of the media
++ recorder changes to QMediaRecorder::StoppedState.
++ */
++
++ /*!
++ The recorder will stop the recording. Processing pending video and audio data might
++ however still take some time. The recording is finished, once the state of the media
++ recorder changes to QMediaRecorder::StoppedState.
++ */
++ void QMediaRecorder::stop()
++ {
++ Q_D(QMediaRecorder);
++ if (d->control && d->captureSession)
++ d->control->stop();
++ }
++ /*!
++ \qmlproperty enumeration QtMultimedia::MediaRecorder::recorderState
++ \brief This property holds the current media recorder state.
++
++ The state property represents the user request and is changed synchronously
++ during record(), pause() or stop() calls.
++ Recorder state may also change asynchronously when recording fails.
++
++ \value MediaRecorder.StoppedState The recorder is not active.
++ \value MediaRecorder.RecordingState The recording is requested.
++ \value MediaRecorder.PausedState The recorder is pause.
++ */
++ /*!
++ \enum QMediaRecorder::RecorderState
++
++ \value StoppedState The recorder is not active.
++ \value RecordingState The recording is requested.
++ \value PausedState The recorder is paused.
++ */
++ /*!
++ \qmlproperty enumeration QtMultimedia::MediaRecorder::error
++ \brief This property holds the current media recorder error state.
++
++ \value MediaRecorder.NoError Not in an error state.
++ \value MediaRecorder.ResourceError Not enough system resources
++ \value MediaRecorder.FormatError the current format is not supported.
++ \value MediaRecorder.OutOfSpaceError No space left on device.
++ \value MediaRecorder.LocationNotWriteable The output location is not writable.
++ */
++ /*!
++ \enum QMediaRecorder::Error
++
++ \value NoError No Errors.
++ \value ResourceError Device is not ready or not available.
++ \value FormatError Current format is not supported.
++ \value OutOfSpaceError No space left on device.
++ \value LocationNotWritable The output location is not writable.
++ */
++
++ /*!
++ \property QMediaRecorder::recorderState
++ \brief The current state of the media recorder.
++
++ The state property represents the user request and is changed synchronously
++ during record(), pause() or stop() calls.
++ Recorder state may also change asynchronously when recording fails.
++ */
++
++ /*!
++ \qmlsignal QtMultimedia::MediaRecorder::recorderStateChanged(RecorderState state)
++ \brief Signals that a media recorder's \a state has changed.
++ */
++
++ /*!
++ \fn QMediaRecorder::recorderStateChanged(QMediaRecorder::RecorderState state)
++
++ Signals that a media recorder's \a state has changed.
++ */
++
++ /*!
++ \qmlsignal QtMultimedia::MediaRecorder::durationChanged(qint64 duration)
++ \brief Signals that the \a duration of the recorded media has changed.
++ */
++
++ /*!
++ \fn QMediaRecorder::durationChanged(qint64 duration)
++
++ Signals that the \a duration of the recorded media has changed.
++ */
++ /*!
++ \qmlsignal QtMultimedia::MediaRecorder::actualLocationChanged(const QUrl &location)
++ \brief Signals that the actual \a location of the recorded media has changed.
++
++ This signal is usually emitted when recording starts.
++ */
++ /*!
++ \fn QMediaRecorder::actualLocationChanged(const QUrl &location)
++
++ Signals that the actual \a location of the recorded media has changed.
++ This signal is usually emitted when recording starts.
++ */
++ /*!
++ \qmlsignal QtMultimedia::MediaRecorder::errorOccurred(Error error, const QString &errorString)
++ \brief Signals that an \a error has occurred.
++
++ The \a errorString contains a description of the error.
++ */
++ /*!
++ \fn QMediaRecorder::errorOccurred(QMediaRecorder::Error error, const QString &errorString)
++
++ Signals that an \a error has occurred, with \a errorString containing
++ a description of the error.
++ */
++
++ /*!
++ \qmlproperty mediaMetaData QtMultimedia::MediaRecorder::metaData
++
++ \brief This property holds meta data associated with the recording.
++
++ When a recording is started, any meta-data assigned will be attached to that
++ recording.
++
++ \note Ensure that meta-data is assigned correctly by assigning it before
++ starting the recording.
++
++ \sa mediaMetaData
++ */
++
++ /*!
++ \property QMediaRecorder::metaData
++
++ Returns the metaData associated with the recording.
++ */
++ QMediaMetaData QMediaRecorder::metaData() const
++ {
++ Q_D(const QMediaRecorder);
++
++ return d->control ? d->control->metaData() : QMediaMetaData{};
++ }
++
++ /*!
++ Sets the meta data to \a metaData.
++
++ \note To ensure that meta-data is set correctly, it should be set before starting the recording.
++ Once the recording is started, any meta-data set will be attached to the next recording.
++ */
++ void QMediaRecorder::setMetaData(const QMediaMetaData &metaData)
++ {
++ Q_D(QMediaRecorder);
++
++ if (d->control && d->captureSession)
++ d->control->setMetaData(metaData);
++ }
++
++ /*!
++ Adds \a metaData to the recorded media.
++ */
++ void QMediaRecorder::addMetaData(const QMediaMetaData &metaData)
++ {
++ auto data = this->metaData();
++ // merge data
++ for (auto &&[key, value] : metaData.asKeyValueRange())
++ data.insert(key, value);
++ setMetaData(data);
++ }
++
++ /*!
++ \property QMediaRecorder::autoStop
++
++ This property controls whether the media recorder stops automatically when
++ all media inputs have reported the end of the stream or have been deactivated.
++
++ The end of the stream is reported by sending an empty media frame,
++ which you can send explicitly via \l QVideoFrameInput or \l QAudioBufferInput.
++
++ Video inputs, specificly, \l QCamera, \l QScreenCapture and \l QWindowCapture,
++ can be deactivated via the function \c setActive.
++
++ Defaults to \c false.
++
++ QMediaRecorder::autoStop is only supported with the FFmpeg backend.
++
++ \sa QCamera, QScreenCapture, QWindowCapture
++ */
++
++ bool QMediaRecorder::autoStop() const
++ {
++ Q_D(const QMediaRecorder);
++
++ return d->autoStop;
++ }
++
++ void QMediaRecorder::setAutoStop(bool autoStop)
++ {
++ Q_D(QMediaRecorder);
++
++ if (d->autoStop == autoStop)
++ return;
++
++ d->autoStop = autoStop;
++
++ if (d->control)
++ d->control->updateAutoStop();
++
++ Q_EMIT autoStopChanged();
++ }
++
++ /*!
++ \qmlsignal QtMultimedia::MediaRecorder::metaDataChanged()
++
++ \brief Signals that a media object's meta-data has changed.
++
++ If multiple meta-data elements are changed metaDataChanged() is emitted
++ once.
++ */
++ /*!
++ \fn QMediaRecorder::metaDataChanged()
++
++ Signals that a media object's meta-data has changed.
++
++ If multiple meta-data elements are changed metaDataChanged() is emitted
++ once.
++ */
++
++ /*!
++ Returns the media capture session.
++ */
++ QMediaCaptureSession *QMediaRecorder::captureSession() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->captureSession;
++ }
++ /*!
++ \qmlproperty enumeration QtMultimedia::MediaRecorder::quality
++
++ Enumerates quality encoding levels.
++
++ \value MediaRecorder.VeryLowQuality
++ \value MediaRecorder.LowQuality
++ \value MediaRecorder.NormalQuality
++ \value MediaRecorder.HighQuality
++ \value MediaRecorder.VeryHighQuality
++ */
++ /*!
++ \enum QMediaRecorder::Quality
++
++ Enumerates quality encoding levels.
++
++ \value VeryLowQuality
++ \value LowQuality
++ \value NormalQuality
++ \value HighQuality
++ \value VeryHighQuality
++ */
++
++ /*!
++ \enum QMediaRecorder::EncodingMode
++
++ Enumerates encoding modes.
++
++ \value ConstantQualityEncoding Encoding will aim to have a constant quality, adjusting bitrate to fit.
++ \value ConstantBitRateEncoding Encoding will use a constant bit rate, adjust quality to fit.
++ \value AverageBitRateEncoding Encoding will try to keep an average bitrate setting, but will use
++ more or less as needed.
++ \value TwoPassEncoding The media will first be processed to determine the characteristics,
++ and then processed a second time allocating more bits to the areas
++ that need it.
++ */
++
++ /*!
++
++ \qmlproperty mediaFormat QtMultimedia::MediaRecorder::mediaFormat
++
++ \brief This property holds the current MediaFormat of the recorder.
++ */
++ /*!
++ \property QMediaRecorder::mediaFormat
++
++ \brief This property holds the current \l QMediaFormat of the recorder.
++
++ The value of this property may change when invoking \l record(). If this happens, the
++ mediaFormatChanged() signal will be emitted. This will always happen if the
++ \l QMediaFormat::audioCodec or \l QMediaFormat::fileFormat properties are set to unspecified.
++ If a video source (\l QCamera, \l QScreenCapture, or \l QVideoFrameInput) is connected to the
++ \l QMediaCaptureSession, \l QMediaFormat::videoCodec must also be specified.
++ The \l QMediaFormat::audioCodec and \l QMediaFormat::videoCodec property values may also change
++ if the media backend does not support the selected file format or codec.
++
++ The \l QMediaFormat::fileFormat property value may also change to an \c audio only format if a
++ video format was requested, but \l QMediaCaptureSession does not have a video source connected.
++ For example, if \l QMediaFormat::fileFormat is set to \l QMediaFormat::MPEG4, it may
++ be changed to \l QMediaFormat::Mpeg4Audio.
++
++ Applications can determine if \c mediaFormat will change before recording starts by calling the
++ \l QMediaFormat::isSupported() function. When recording without any video inputs,
++ \l record() will not be changed the \l QMediaFormat if the following is true:
++ \list
++ \li \l QMediaFormat::fileFormat is specified
++ \li \l QMediaFormat::audioCodec is specified
++ \li \l QMediaFormat::videoCodec is \b{unspecified}
++ \li \l QMediaFormat::isSupported() returns \c true
++ \endlist
++ When recording with video input, \c mediaFormat will not be changed if the following is true:
++ \list
++ \li \l QMediaFormat::fileFormat is specified
++ \li \l QMediaFormat::audioCodec is specified
++ \li \l QMediaFormat::videoCodec is specified
++ \li \l QMediaFormat::isSupported() returns \c true
++ \endlist
++
++ \note The \l QMediaRecorder does not take the file name extension from the \l outputLocation
++ property into account when determining the \l QMediaFormat::fileFormat, and will not adjust the
++ extension of the \l outputLocation \l QUrl to match the selected file format if an extension is
++ specified. Applications should therefore make sure to set the
++ \l {QMediaFormat::fileFormat}{QMediaRecorder::mediaFormat::fileFormat} to match the file
++ extension, or not specify a file extension. If no file extension is specified, the
++ \l actualLocation file extension will be updated to match the file format used for recording.
++
++ \sa QMediaFormat::isSupported(), actualLocation
++ */
++ QMediaFormat QMediaRecorder::mediaFormat() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.mediaFormat();
++ }
++
++ void QMediaRecorder::setMediaFormat(const QMediaFormat &format)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.mediaFormat() == format)
++ return;
++ d->encoderSettings.setMediaFormat(format);
++ Q_EMIT mediaFormatChanged();
++ }
++
++ /*!
++
++ \qmlproperty enumeration QtMultimedia::MediaRecorder::encodingMode
++ \since 6.6
++ \brief This property holds the encoding mode.
++ \sa QMediaRecorder::EncodingMode
++ */
++
++ /*!
++ \property QMediaRecorder::encodingMode
++ \brief the encoding mode.
++ \sa EncodingMode
++ */
++
++ /*!
++ Returns the encoding mode.
++
++ \sa EncodingMode
++ */
++ QMediaRecorder::EncodingMode QMediaRecorder::encodingMode() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.encodingMode();
++ }
++
++ /*!
++ \fn void QMediaRecorder::encodingModeChanged()
++
++ Signals when the encoding mode changes.
++ */
++ /*!
++ Sets the encoding \a mode setting.
++
++ If ConstantQualityEncoding is set, the quality
++ encoding parameter is used and bit rates are ignored,
++ otherwise the bitrates are used.
++
++ \sa encodingMode(), EncodingMode
++ */
++ void QMediaRecorder::setEncodingMode(EncodingMode mode)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.encodingMode() == mode)
++ return;
++ d->encoderSettings.setEncodingMode(mode);
++ Q_EMIT encodingModeChanged();
++ }
++
++ /*!
++ \property QMediaRecorder::quality
++
++ Returns the recording quality.
++ */
++ QMediaRecorder::Quality QMediaRecorder::quality() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.quality();
++ }
++
++ /*!
++ \fn void QMediaRecorder::qualityChanged()
++
++ Signals when the recording quality changes.
++ */
++ void QMediaRecorder::setQuality(Quality quality)
++ {
++ Q_D(QMediaRecorder);
++
++ quality = std::clamp(quality, QMediaRecorder::Quality::VeryLowQuality,
++ QMediaRecorder::Quality::VeryHighQuality);
++
++ if (d->encoderSettings.quality() == quality)
++ return;
++
++ d->encoderSettings.setQuality(quality);
++ Q_EMIT qualityChanged();
++ }
++
++ /*!
++ \qmlproperty Size QtMultimedia::MediaRecorder::videoResolution
++ \since 6.6
++ \brief This property holds the resolution of the encoded video.
++
++ Set an empty Size to make the recorder choose an optimal resolution based
++ on what is available from the video source and the limitations of the codec.
++ */
++
++ /*!
++ \property QMediaRecorder::videoResolution
++ \since 6.6
++ \brief the resolution of the encoded video.
++
++ An empty QSize indicates the recorder will choose an optimal resolution based
++ on what is available from the video source and the limitations of the codec.
++ */
++
++ /*!
++ Returns the resolution of the encoded video.
++ */
++ QSize QMediaRecorder::videoResolution() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.videoResolution();
++ }
++
++ /*!
++ \fn void QMediaRecorder::videoResolutionChanged()
++
++ Signals when the video recording resolution changes.
++ */
++ /*!
++ Sets the resolution of the encoded video to \a{size}.
++
++ Pass an empty QSize to make the recorder choose an optimal resolution based
++ on what is available from the video source and the limitations of the codec.
++ */
++ void QMediaRecorder::setVideoResolution(const QSize &size)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.videoResolution() == size)
++ return;
++ d->encoderSettings.setVideoResolution(size);
++ Q_EMIT videoResolutionChanged();
++ }
++
++ /*! \fn void QMediaRecorder::setVideoResolution(int width, int height)
++
++ Sets the \a width and \a height of the resolution of the encoded video.
++
++ \overload
++ */
++
++ /*!
++ \qmlproperty real QtMultimedia::MediaRecorder::videoFrameRate
++ \since 6.6
++ \brief This property holds the video frame rate used in encoding.
++
++ If this property is set to a positive frame rate, MediaRecorder attempts to
++ encode at that rate. If the video source's and recoder's frame rates are
++ different, frames from the source may be dropped or duplicated to
++ reach the target rate.
++
++ If left at the default value (-1) or set to another non-positive value,
++ MediaRecorder attempts to make the optimal choice based on the video source
++ and codec limitations.
++ */
++
++ /*!
++ \property QMediaRecorder::videoFrameRate
++ \since 6.6
++ \brief the video frame rate used in encoding.
++
++ If this property is set to a positive frame rate, QMediaRecorder attempts to
++ encode at that rate. If the video source's and recoder's frame rates are
++ different, frames from the source may be dropped or duplicated to
++ reach the target rate.
++
++ If left at the default value (-1) or set to another non-positive value,
++ QMediaRecorder attempts to make the optimal choice based on the video source
++ and codec limitations.
++ */
++
++ /*!
++ Returns the video encoding frame rate.
++ */
++ qreal QMediaRecorder::videoFrameRate() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.videoFrameRate();
++ }
++
++ /*!
++ \fn void QMediaRecorder::videoFrameRateChanged()
++
++ Signals when the video encoding frame rate changes.
++ */
++ /*!
++ Sets the video encoding \a frameRate.
++ */
++ void QMediaRecorder::setVideoFrameRate(qreal frameRate)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.videoFrameRate() == frameRate)
++ return;
++ d->encoderSettings.setVideoFrameRate(frameRate);
++ Q_EMIT videoFrameRateChanged();
++ }
++
++ /*!
++ \qmlproperty int QtMultimedia::MediaRecorder::videoBitRate
++ \since 6.6
++ \brief This property holds the bit rate of the compressed video stream in bits per second.
++ */
++
++ /*!
++ \property QMediaRecorder::videoBitRate
++ \since 6.6
++ \brief the bit rate of the compressed video stream in bits per second.
++ */
++
++ /*!
++ Returns the bit rate of the compressed video stream in bits per second.
++ */
++ int QMediaRecorder::videoBitRate() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.videoBitRate();
++ }
++
++ /*!
++ \fn void QMediaRecorder::videoBitRateChanged()
++
++ Signals when the recording video bit rate changes.
++ */
++ /*!
++ Sets the video \a bitRate in bits per second.
++ */
++ void QMediaRecorder::setVideoBitRate(int bitRate)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.videoBitRate() == bitRate)
++ return;
++ d->encoderSettings.setVideoBitRate(bitRate);
++ Q_EMIT videoBitRateChanged();
++ }
++
++ /*!
++ \qmlproperty int QtMultimedia::MediaRecorder::audioBitRate
++ \since 6.6
++ \brief This property holds the bit rate of the compressed audio stream in bits per second.
++ */
++
++ /*!
++ \property QMediaRecorder::audioBitRate
++ \brief the bit rate of the compressed audio stream in bits per second.
++ */
++ /*!
++ Returns the bit rate of the compressed audio stream in bits per second.
++ */
++ int QMediaRecorder::audioBitRate() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.audioBitRate();
++ }
++
++ /*!
++ \fn void QMediaRecorder::audioBitRateChanged()
++
++ Signals when the recording audio bit rate changes.
++ */
++ /*!
++ Sets the audio \a bitRate in bits per second.
++ */
++ void QMediaRecorder::setAudioBitRate(int bitRate)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.audioBitRate() == bitRate)
++ return;
++ d->encoderSettings.setAudioBitRate(bitRate);
++ Q_EMIT audioBitRateChanged();
++ }
++
++ /*!
++ \qmlproperty int QtMultimedia::MediaRecorder::audioChannelCount
++ \since 6.6
++ \brief This property holds the number of audio channels.
++ */
++
++ /*!
++ \property QMediaRecorder::audioChannelCount
++ \brief the number of audio channels.
++ */
++
++ /*!
++ Returns the number of audio channels.
++ */
++ int QMediaRecorder::audioChannelCount() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.audioChannelCount();
++ }
++
++ /*!
++ \fn void QMediaRecorder::audioChannelCountChanged()
++
++ Signals when the recording audio channel count changes.
++ */
++ /*!
++ Sets the number of audio \a channels.
++
++ A value of -1 indicates the recorder should make an optimal choice based on
++ what is available from the audio source and the limitations of the codec.
++ */
++ void QMediaRecorder::setAudioChannelCount(int channels)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.audioChannelCount() == channels)
++ return;
++ d->encoderSettings.setAudioChannelCount(channels);
++ Q_EMIT audioChannelCountChanged();
++ }
++
++ /*!
++ \qmlproperty int QtMultimedia::MediaRecorder::audioSampleRate
++ \since 6.6
++ \brief This property holds the audio sample rate in Hz.
++ */
++
++ /*!
++ \property QMediaRecorder::audioSampleRate
++ \brief the audio sample rate in Hz.
++ */
++
++ /*!
++ Returns the audio sample rate in Hz.
++ */
++ int QMediaRecorder::audioSampleRate() const
++ {
++ Q_D(const QMediaRecorder);
++ return d->encoderSettings.audioSampleRate();
++ }
++ /*!
++ \fn void QMediaRecorder::audioSampleRateChanged()
++
++ Signals when the recording audio sample rate changes.
++ */
++ /*!
++ Sets the audio \a sampleRate in Hz.
++
++ A value of \c -1 indicates the recorder should make an optimal choice based
++ on what is available from the audio source, and the limitations of the codec.
++ */
++ void QMediaRecorder::setAudioSampleRate(int sampleRate)
++ {
++ Q_D(QMediaRecorder);
++ if (d->encoderSettings.audioSampleRate() == sampleRate)
++ return;
++ d->encoderSettings.setAudioSampleRate(sampleRate);
++ Q_EMIT audioSampleRateChanged();
++ }
++
++ QT_END_NAMESPACE
++
++ #include "moc_qmediarecorder.cpp"