qffmpegplaybackengine_p.h

Enable keyboard shortcuts

++ // 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

++ #ifndef QFFMPEGPLAYBACKENGINE_P_H

++ #define QFFMPEGPLAYBACKENGINE_P_H

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is not part of the Qt API. It exists purely as an

++ // implementation detail. This header file may change from version to

++ // version without notice, or even be removed.

++ //

++ // We mean it.

++ //

++

++ /* Playback engine design description.

++  *

++  *

++  * PLAYBACK ENGINE OBJECTS

++  *

++  * - Playback engine manages 7 objects inside, each one works in a separate thread.

++  * Each object inherits PlaybackEngineObject. The objects are:

++  *    Demuxer

++  *    Stream Decoders: audio, video, subtitles

++  *    Renderers: audio, video, subtitles

++  *

++  *

++  * THREADS:

++  *

++  * - By default, each object works in a separate thread. It's easy to reconfigure

++  *   to using several objects in thread.

++  * - New thread is allocated if a new object is created and the engine doesn't

++  *   have free threads. If it does, the thread is to be reused.

++  * - If all objects for some thread are deleted, the thread becomes free and the engine

++  *   postpones its termination.

++  *

++  * OBJECTS WEAK CONNECTIVITY

++  *

++  * - The objects know nothing about others and about PlaybackEngine.

++  *   For any interactions the objects use slots/signals.

++  *

++  * - PlaybackEngine knows the objects object and is able to create/delete them and

++  *   call their public methods.

++  *

++  */

++

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegplaybackenginedefs_p.h>

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegtimecontroller_p.h>

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegmediadataholder_p.h>

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegcodeccontext_p.h>

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegplaybackutils_p.h>

++ #include <QtFFmpegMediaPluginImpl/private/qffmpegtime_p.h>

++ #include <QtMultimedia/qplaybackoptions.h>

++

++ #include <QtCore/qpointer.h>

++

++ #include <unordered_map>

++

++ QT_BEGIN_NAMESPACE

++

++ class QAudioSink;

++ class QVideoSink;

++ class QAudioOutput;

++ class QAudioBufferOutput;

++ class QFFmpegMediaPlayer;

++ class QPlaybackOptions;

++

++ namespace QFFmpeg

++ {

++

++ class PlaybackEngine : public QObject

++ {

++     Q_OBJECT

++ public:

++     using TrackType = QPlatformMediaPlayer::TrackType;

++

++     explicit PlaybackEngine(const QPlaybackOptions &options);

++

++     ~PlaybackEngine() override;

++

++     void setMedia(MediaDataHolder media);

++

++     void setVideoSink(QVideoSink *sink);

++

++     void setAudioSink(QAudioOutput *output);

++

++     void setAudioSink(QPlatformAudioOutput *output);

++

++     void setAudioBufferOutput(QAudioBufferOutput *output);

++

++     void setState(QMediaPlayer::PlaybackState state);

++

++     void play() {

++         setState(QMediaPlayer::PlayingState);

++     }

++     void pause() {

++         setState(QMediaPlayer::PausedState);

++     }

++     void stop() {

++         setState(QMediaPlayer::StoppedState);

++     }

++

++     void seek(TrackPosition pos);

++

++     void setLoops(int loopsCount);

++

++     void setPlaybackRate(float rate);

++

++     float playbackRate() const;

++

++     void setActiveTrack(TrackType type, int streamNumber);

++

++     TrackPosition currentPosition(bool topPos = true) const;

++

++     TrackDuration duration() const;

++

++     bool isSeekable() const;

++

++     const QList<MediaDataHolder::StreamInfo> &

++     streamInfo(TrackType trackType) const;

++

++     const QMediaMetaData &metaData() const;

++

++     int activeTrack(TrackType type) const;

++

++     void setPitchCompensation(bool enabled);

++

++ Q_SIGNALS:

++     void endOfStream();

++     void errorOccured(QMediaPlayer::Error, const QString &);

++     void loopChanged();

++     void buffered();

++

++ protected: // objects managing

++     struct ObjectDeleter

++     {

++         void operator()(PlaybackEngineObject *) const;

++

++         PlaybackEngine *engine = nullptr;

++     };

++

++     template<typename T>

++     using ObjectPtr = std::unique_ptr<T, ObjectDeleter>;

++

++     using RendererPtr = ObjectPtr<Renderer>;

++     using StreamPtr = ObjectPtr<StreamDecoder>;

++

++     template<typename T, typename... Args>

++     ObjectPtr<T> createPlaybackEngineObject(Args &&...args);

++

++     virtual RendererPtr createRenderer(TrackType trackType);

++

++     template <typename AudioOutput>

++     void updateActiveAudioOutput(AudioOutput *output);

++

++     void updateActiveVideoOutput(QVideoSink *sink, bool cleanOutput = false);

++

++ private:

++     void createStreamAndRenderer(TrackType trackType);

++

++     void createDemuxer();

++

++     void registerObject(PlaybackEngineObject &object);

++

++     template<typename C, typename Action>

++     void forEachExistingObject(Action &&action);

++

++     template<typename Action>

++     void forEachExistingObject(Action &&action);

++

++     void forceUpdate();

++

++     void recreateObjects();

++

++     void createObjectsIfNeeded();

++

++     void updateObjectsPausedState();

++

++     void deleteFreeThreads();

++

++     void onFirstPacketFound(const PlaybackEngineObjectID &id, TrackPosition absSeekPos);

++

++     void onRendererSynchronized(const PlaybackEngineObjectID &id, SteadyClock::time_point timePoint,

++                                 TrackPosition trackPosition);

++

++     void onRendererFinished(const PlaybackEngineObjectID &id);

++

++     void onRendererLoopChanged(const PlaybackEngineObjectID &id, TrackPosition offset,

++                                int loopIndex);

++

++     void triggerStepIfNeeded();

++

++     static QString objectThreadName(const PlaybackEngineObject &object);

++

++     std::optional<CodecContext> codecContextForTrack(TrackType trackType);

++

++     bool hasMediaStream() const;

++

++     void finilizeTime(TrackPosition pos);

++

++     void finalizeOutputs();

++

++     bool hasRenderer(const PlaybackEngineObjectID &id) const;

++

++     template <typename T>

++     bool checkObjectID(T &object, const PlaybackEngineObjectID &id) const

++     {

++         return object && object->objectID() == id.objectID && id.sessionID == m_currentID.sessionID;

++     }

++

++     void updateVideoSinkSize(QVideoSink *prevSink = nullptr);

++

++     TrackPosition boundPosition(TrackPosition position) const;

++

++     AudioRenderer *getAudioRenderer();

++

++ private:

++     MediaDataHolder m_media;

++

++     TimeController m_timeController;

++

++     std::unordered_map<QString, std::unique_ptr<QThread>> m_threads;

++     bool m_threadsDirty = false;

++

++     QPointer<QVideoSink> m_videoSink;

++     QPointer<QAudioOutput> m_audioOutput;

++     QPointer<QAudioBufferOutput> m_audioBufferOutput;

++

++     QMediaPlayer::PlaybackState m_state = QMediaPlayer::StoppedState;

++

++     ObjectPtr<Demuxer> m_demuxer;

++     QPlatformMediaPlayer::TrackTypeMap<StreamPtr> m_streams;

++     QPlatformMediaPlayer::TrackTypeMap<RendererPtr> m_renderers;

++

++     bool m_seekPending = false;

++

++     QPlatformMediaPlayer::TrackTypeMap<std::optional<CodecContext>> m_codecContexts;

++     int m_loops = QMediaPlayer::Once;

++     LoopOffset m_currentLoopOffset;

++

++     bool m_pitchCompensation = true;

++     QPlaybackOptions m_options;

++     PlaybackEngineObjectID m_currentID{ 1, 1 };

++ };

++

++ template<typename T, typename... Args>

++ PlaybackEngine::ObjectPtr<T> PlaybackEngine::createPlaybackEngineObject(Args &&...args)

++ {

++     ++m_currentID.objectID;

++     auto result = ObjectPtr<T>(new T(m_currentID, std::forward<Args>(args)...), { this });

++     registerObject(*result);

++     return result;

++ }

++ } // namespace QFFmpeg

++

++ QT_END_NAMESPACE

++

++ #endif // QFFMPEGPLAYBACKENGINE_P_H