1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// 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 interractions the objects use slots/signals.
*
* - PlaybackEngine knows the objects object and is able to create/delete them and
* call their public methods.
*
*/
#include "playbackengine/qffmpegplaybackenginedefs_p.h"
#include "playbackengine/qffmpegtimecontroller_p.h"
#include "playbackengine/qffmpegmediadataholder_p.h"
#include <unordered_map>
QT_BEGIN_NAMESPACE
class QAudioSink;
class QVideoSink;
class QAudioOutput;
class QFFmpegMediaPlayer;
namespace QFFmpeg
{
class PlaybackEngine : public QObject, protected PlaybackEngineInternal::MediaDataHolder
{
Q_OBJECT
public:
PlaybackEngine();
~PlaybackEngine() override;
bool setMedia(const QUrl &media, QIODevice *stream);
void setVideoSink(QVideoSink *sink);
void setAudioSink(QAudioOutput *output);
void setAudioSink(QPlatformAudioOutput *output);
void setState(QMediaPlayer::PlaybackState state);
void play() {
setState(QMediaPlayer::PlayingState);
}
void pause() {
setState(QMediaPlayer::PausedState);
}
void stop() {
setState(QMediaPlayer::StoppedState);
}
void seek(qint64 pos);
void setPlaybackRate(float rate);
float playbackRate() const;
void setActiveTrack(QPlatformMediaPlayer::TrackType type, int streamNumber);
using MediaDataHolder::activeTrack;
bool isSeekable() const;
qint64 currentPosition() const;
// To be removed after aligning with Decoder
using MediaDataHolder::m_currentAVStreamIndex;
using MediaDataHolder::m_duration;
using MediaDataHolder::m_metaData;
using MediaDataHolder::m_requestedStreams;
using MediaDataHolder::m_streamMap;
signals:
void endOfStream();
void errorOccured(int, const QString &);
protected: // objects managing
using Demuxer = PlaybackEngineInternal::Demuxer;
using PlaybackEngineObject = PlaybackEngineInternal::PlaybackEngineObject;
using Renderer = PlaybackEngineInternal::Renderer;
using AudioRenderer = PlaybackEngineInternal::AudioRenderer;
using VideoRenderer = PlaybackEngineInternal::VideoRenderer;
using SubtitleRenderer = PlaybackEngineInternal::SubtitleRenderer;
using StreamDecoder = PlaybackEngineInternal::StreamDecoder;
using TimeController = PlaybackEngineInternal::TimeController;
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(QPlatformMediaPlayer::TrackType trackType);
private:
void createStreamAndRenderer(QPlatformMediaPlayer::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 onRendererSynchronized(std::chrono::steady_clock::time_point time, qint64 trackTime);
void onRendererFinished();
void triggerStepIfNeeded();
static QString objectThreadName(const PlaybackEngineObject &object);
std::optional<Codec> codecForTrack(QPlatformMediaPlayer::TrackType trackType);
private:
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;
QMediaPlayer::PlaybackState m_state = QMediaPlayer::StoppedState;
ObjectPtr<Demuxer> m_demuxer;
std::array<StreamPtr, QPlatformMediaPlayer::NTrackTypes> m_streams;
std::array<RendererPtr, QPlatformMediaPlayer::NTrackTypes> m_renderers;
std::array<std::optional<Codec>, QPlatformMediaPlayer::NTrackTypes> m_codecs;
};
template<typename T, typename... Args>
PlaybackEngine::ObjectPtr<T> PlaybackEngine::createPlaybackEngineObject(Args &&...args)
{
auto result = ObjectPtr<T>(new T(std::forward<Args>(args)...), { this });
registerObject(*result);
return result;
}
}
QT_END_NAMESPACE
#endif // QFFMPEGPLAYBACKENGINE_P_H
|
