Line data Source code
1 : /*
2 : * If not stated otherwise in this file or this component's LICENSE file the
3 : * following copyright and licenses apply:
4 : *
5 : * Copyright 2022 Sky UK
6 : *
7 : * Licensed under the Apache License, Version 2.0 (the "License");
8 : * you may not use this file except in compliance with the License.
9 : * You may obtain a copy of the License at
10 : *
11 : * http://www.apache.org/licenses/LICENSE-2.0
12 : *
13 : * Unless required by applicable law or agreed to in writing, software
14 : * distributed under the License is distributed on an "AS IS" BASIS,
15 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 : * See the License for the specific language governing permissions and
17 : * limitations under the License.
18 : */
19 : #include "tasks/generic/GenericPlayerTaskFactory.h"
20 : #include "IMediaPipeline.h"
21 : #include "tasks/generic/AttachSamples.h"
22 : #include "tasks/generic/AttachSource.h"
23 : #include "tasks/generic/CheckAudioUnderflow.h"
24 : #include "tasks/generic/DeepElementAdded.h"
25 : #include "tasks/generic/EnoughData.h"
26 : #include "tasks/generic/Eos.h"
27 : #include "tasks/generic/FinishSetupSource.h"
28 : #include "tasks/generic/Flush.h"
29 : #include "tasks/generic/HandleBusMessage.h"
30 : #include "tasks/generic/NeedData.h"
31 : #include "tasks/generic/Pause.h"
32 : #include "tasks/generic/Ping.h"
33 : #include "tasks/generic/Play.h"
34 : #include "tasks/generic/ProcessAudioGap.h"
35 : #include "tasks/generic/ReadShmDataAndAttachSamples.h"
36 : #include "tasks/generic/RenderFrame.h"
37 : #include "tasks/generic/ReportPosition.h"
38 : #include "tasks/generic/SetBufferingLimit.h"
39 : #include "tasks/generic/SetImmediateOutput.h"
40 : #include "tasks/generic/SetLowLatency.h"
41 : #include "tasks/generic/SetMute.h"
42 : #include "tasks/generic/SetPlaybackRate.h"
43 : #include "tasks/generic/SetPosition.h"
44 : #include "tasks/generic/SetSourcePosition.h"
45 : #include "tasks/generic/SetStreamSyncMode.h"
46 : #include "tasks/generic/SetSubtitleOffset.h"
47 : #include "tasks/generic/SetSync.h"
48 : #include "tasks/generic/SetSyncOff.h"
49 : #include "tasks/generic/SetTextTrackIdentifier.h"
50 : #include "tasks/generic/SetUseBuffering.h"
51 : #include "tasks/generic/SetVideoGeometry.h"
52 : #include "tasks/generic/SetVolume.h"
53 : #include "tasks/generic/SetupElement.h"
54 : #include "tasks/generic/SetupSource.h"
55 : #include "tasks/generic/Shutdown.h"
56 : #include "tasks/generic/Stop.h"
57 : #include "tasks/generic/SwitchSource.h"
58 : #include "tasks/generic/SynchroniseSubtitleClock.h"
59 : #include "tasks/generic/Underflow.h"
60 : #include "tasks/generic/UpdatePlaybackGroup.h"
61 :
62 : namespace firebolt::rialto::server
63 : {
64 40 : GenericPlayerTaskFactory::GenericPlayerTaskFactory(
65 : IGstGenericPlayerClient *client, const std::shared_ptr<firebolt::rialto::wrappers::IGstWrapper> &gstWrapper,
66 : const std::shared_ptr<firebolt::rialto::wrappers::IGlibWrapper> &glibWrapper,
67 : const std::shared_ptr<firebolt::rialto::wrappers::IRdkGstreamerUtilsWrapper> &rdkGstreamerUtilsWrapper,
68 40 : const std::shared_ptr<IGstTextTrackSinkFactory> &gstTextTrackSinkFactory)
69 40 : : m_client{client}, m_gstWrapper{gstWrapper}, m_glibWrapper{glibWrapper},
70 80 : m_rdkGstreamerUtilsWrapper{rdkGstreamerUtilsWrapper}, m_gstTextTrackSinkFactory{gstTextTrackSinkFactory}
71 : {
72 40 : }
73 :
74 : std::unique_ptr<IPlayerTask>
75 1 : GenericPlayerTaskFactory::createAttachSamples(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
76 : const IMediaPipeline::MediaSegmentVector &mediaSegments) const
77 : {
78 1 : return std::make_unique<tasks::generic::AttachSamples>(context, m_gstWrapper, player, mediaSegments);
79 : }
80 :
81 : std::unique_ptr<IPlayerTask>
82 1 : GenericPlayerTaskFactory::createAttachSource(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
83 : const std::unique_ptr<IMediaPipeline::MediaSource> &source) const
84 : {
85 1 : return std::make_unique<tasks::generic::AttachSource>(context, m_gstWrapper, m_glibWrapper,
86 2 : m_gstTextTrackSinkFactory, player, source);
87 : }
88 :
89 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createDeepElementAdded(GenericPlayerContext &context,
90 : IGstGenericPlayerPrivate &player,
91 : GstBin *pipeline, GstBin *bin,
92 : GstElement *element) const
93 : {
94 2 : return std::make_unique<tasks::generic::DeepElementAdded>(context, player, m_gstWrapper, m_glibWrapper, pipeline,
95 2 : bin, element);
96 : }
97 :
98 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createEnoughData(GenericPlayerContext &context, GstAppSrc *src) const
99 : {
100 1 : return std::make_unique<tasks::generic::EnoughData>(context, src);
101 : }
102 :
103 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createEos(GenericPlayerContext &context,
104 : IGstGenericPlayerPrivate &player,
105 : const firebolt::rialto::MediaSourceType &type) const
106 : {
107 1 : return std::make_unique<tasks::generic::Eos>(context, player, m_gstWrapper, type);
108 : }
109 :
110 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createFinishSetupSource(GenericPlayerContext &context,
111 : IGstGenericPlayerPrivate &player) const
112 : {
113 1 : return std::make_unique<tasks::generic::FinishSetupSource>(context, player, m_client);
114 : }
115 :
116 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createHandleBusMessage(GenericPlayerContext &context,
117 : IGstGenericPlayerPrivate &player,
118 : GstMessage *message,
119 : const IFlushWatcher &flushWatcher) const
120 : {
121 2 : return std::make_unique<tasks::generic::HandleBusMessage>(context, player, m_client, m_gstWrapper, m_glibWrapper,
122 2 : message, flushWatcher);
123 : }
124 :
125 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createNeedData(GenericPlayerContext &context,
126 : IGstGenericPlayerPrivate &player,
127 : GstAppSrc *src) const
128 : {
129 1 : return std::make_unique<tasks::generic::NeedData>(context, player, m_client, src);
130 : }
131 :
132 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPause(GenericPlayerContext &context,
133 : IGstGenericPlayerPrivate &player) const
134 : {
135 1 : return std::make_unique<tasks::generic::Pause>(context, player);
136 : }
137 :
138 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPlay(IGstGenericPlayerPrivate &player) const
139 : {
140 1 : return std::make_unique<tasks::generic::Play>(player);
141 : }
142 :
143 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createReadShmDataAndAttachSamples(
144 : GenericPlayerContext &context, IGstGenericPlayerPrivate &player, const std::shared_ptr<IDataReader> &dataReader) const
145 : {
146 1 : return std::make_unique<tasks::generic::ReadShmDataAndAttachSamples>(context, m_gstWrapper, player, dataReader);
147 : }
148 :
149 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createReportPosition(GenericPlayerContext &context,
150 : IGstGenericPlayerPrivate &player) const
151 : {
152 1 : return std::make_unique<tasks::generic::ReportPosition>(context, m_client, m_gstWrapper, player);
153 : }
154 :
155 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createCheckAudioUnderflow(GenericPlayerContext &context,
156 : IGstGenericPlayerPrivate &player) const
157 : {
158 1 : return std::make_unique<tasks::generic::CheckAudioUnderflow>(context, player, m_client, m_gstWrapper);
159 : }
160 :
161 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetPlaybackRate(GenericPlayerContext &context,
162 : double rate) const
163 : {
164 1 : return std::make_unique<tasks::generic::SetPlaybackRate>(context, m_gstWrapper, m_glibWrapper, rate);
165 : }
166 :
167 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetPosition(GenericPlayerContext &context,
168 : IGstGenericPlayerPrivate &player,
169 : std::int64_t position) const
170 : {
171 1 : return std::make_unique<tasks::generic::SetPosition>(context, player, m_client, m_gstWrapper, position);
172 : }
173 :
174 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetupElement(GenericPlayerContext &context,
175 : IGstGenericPlayerPrivate &player,
176 : GstElement *element) const
177 : {
178 1 : return std::make_unique<tasks::generic::SetupElement>(context, m_gstWrapper, m_glibWrapper, player, element);
179 : }
180 :
181 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetupSource(GenericPlayerContext &context,
182 : IGstGenericPlayerPrivate &player,
183 : GstElement *source) const
184 : {
185 1 : return std::make_unique<tasks::generic::SetupSource>(context, player, source);
186 : }
187 :
188 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetVideoGeometry(GenericPlayerContext &context,
189 : IGstGenericPlayerPrivate &player,
190 : const Rectangle &rectangle) const
191 : {
192 1 : return std::make_unique<tasks::generic::SetVideoGeometry>(context, player, rectangle);
193 : }
194 :
195 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetVolume(GenericPlayerContext &context,
196 : IGstGenericPlayerPrivate &player,
197 : double targetVolume, uint32_t volumeDuration,
198 : firebolt::rialto::EaseType easeType) const
199 : {
200 1 : return std::make_unique<tasks::generic::SetVolume>(context, player, m_gstWrapper, m_glibWrapper,
201 1 : m_rdkGstreamerUtilsWrapper, targetVolume, volumeDuration,
202 2 : easeType);
203 : }
204 :
205 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetMute(GenericPlayerContext &context,
206 : IGstGenericPlayerPrivate &player,
207 : const MediaSourceType &mediaSourceType,
208 : bool mute) const
209 : {
210 1 : return std::make_unique<tasks::generic::SetMute>(context, player, m_gstWrapper, m_glibWrapper, mediaSourceType, mute);
211 : }
212 :
213 : std::unique_ptr<IPlayerTask>
214 1 : GenericPlayerTaskFactory::createSetTextTrackIdentifier(GenericPlayerContext &context,
215 : const std::string &textTrackIdentifier) const
216 : {
217 1 : return std::make_unique<tasks::generic::SetTextTrackIdentifier>(context, m_glibWrapper, textTrackIdentifier);
218 : }
219 :
220 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetLowLatency(GenericPlayerContext &context,
221 : IGstGenericPlayerPrivate &player,
222 : bool lowLatency) const
223 : {
224 1 : return std::make_unique<tasks::generic::SetLowLatency>(context, player, lowLatency);
225 : }
226 :
227 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSync(GenericPlayerContext &context,
228 : IGstGenericPlayerPrivate &player, bool sync) const
229 : {
230 1 : return std::make_unique<tasks::generic::SetSync>(context, player, sync);
231 : }
232 :
233 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSyncOff(GenericPlayerContext &context,
234 : IGstGenericPlayerPrivate &player,
235 : bool syncOff) const
236 : {
237 1 : return std::make_unique<tasks::generic::SetSyncOff>(context, player, syncOff);
238 : }
239 :
240 : std::unique_ptr<IPlayerTask>
241 1 : GenericPlayerTaskFactory::createSetStreamSyncMode(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
242 : const firebolt::rialto::MediaSourceType &type,
243 : int32_t streamSyncMode) const
244 : {
245 1 : return std::make_unique<tasks::generic::SetStreamSyncMode>(context, player, type, streamSyncMode);
246 : }
247 :
248 2 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createShutdown(IGstGenericPlayerPrivate &player) const
249 : {
250 2 : return std::make_unique<tasks::generic::Shutdown>(player);
251 : }
252 :
253 2 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createStop(GenericPlayerContext &context,
254 : IGstGenericPlayerPrivate &player) const
255 : {
256 2 : return std::make_unique<tasks::generic::Stop>(context, player);
257 : }
258 :
259 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createUnderflow(GenericPlayerContext &context,
260 : IGstGenericPlayerPrivate &player,
261 : bool underflowEnabled,
262 : MediaSourceType sourceType) const
263 : {
264 1 : return std::make_unique<tasks::generic::Underflow>(context, player, m_client, underflowEnabled, sourceType);
265 : }
266 :
267 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createUpdatePlaybackGroup(GenericPlayerContext &context,
268 : IGstGenericPlayerPrivate &player,
269 : GstElement *typefind,
270 : const GstCaps *caps) const
271 : {
272 2 : return std::make_unique<tasks::generic::UpdatePlaybackGroup>(context, player, m_gstWrapper, m_glibWrapper, typefind,
273 2 : caps);
274 : }
275 :
276 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createRenderFrame(GenericPlayerContext &context,
277 : IGstGenericPlayerPrivate &player) const
278 : {
279 1 : return std::make_unique<tasks::generic::RenderFrame>(context, player);
280 : }
281 :
282 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPing(std::unique_ptr<IHeartbeatHandler> &&heartbeatHandler) const
283 : {
284 1 : return std::make_unique<tasks::generic::Ping>(std::move(heartbeatHandler));
285 : }
286 :
287 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createFlush(GenericPlayerContext &context,
288 : IGstGenericPlayerPrivate &player,
289 : const firebolt::rialto::MediaSourceType &type,
290 : bool resetTime, bool isAsync) const
291 : {
292 1 : return std::make_unique<tasks::generic::Flush>(context, player, m_client, m_gstWrapper, type, resetTime, isAsync);
293 : }
294 :
295 : std::unique_ptr<IPlayerTask>
296 1 : GenericPlayerTaskFactory::createSetSourcePosition(GenericPlayerContext &context,
297 : const firebolt::rialto::MediaSourceType &type, std::int64_t position,
298 : bool resetTime, double appliedRate, uint64_t stopPosition) const
299 : {
300 2 : return std::make_unique<tasks::generic::SetSourcePosition>(context, m_glibWrapper, type, position, resetTime,
301 2 : appliedRate, stopPosition);
302 : }
303 :
304 0 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSubtitleOffset(GenericPlayerContext &context,
305 : std::int64_t position) const
306 : {
307 0 : return std::make_unique<tasks::generic::SetSubtitleOffset>(context, m_glibWrapper, position);
308 : }
309 :
310 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createProcessAudioGap(GenericPlayerContext &context,
311 : std::int64_t position,
312 : std::uint32_t duration,
313 : std::int64_t discontinuityGap,
314 : bool audioAac) const
315 : {
316 1 : return std::make_unique<tasks::generic::ProcessAudioGap>(context, m_gstWrapper, m_glibWrapper,
317 1 : m_rdkGstreamerUtilsWrapper, position, duration,
318 2 : discontinuityGap, audioAac);
319 : }
320 :
321 : std::unique_ptr<IPlayerTask>
322 1 : GenericPlayerTaskFactory::createSetImmediateOutput(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
323 : const firebolt::rialto::MediaSourceType &type,
324 : bool immediateOutput) const
325 : {
326 1 : return std::make_unique<tasks::generic::SetImmediateOutput>(context, player, type, immediateOutput);
327 : }
328 :
329 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetBufferingLimit(GenericPlayerContext &context,
330 : IGstGenericPlayerPrivate &player,
331 : std::uint32_t limit) const
332 : {
333 1 : return std::make_unique<tasks::generic::SetBufferingLimit>(context, player, limit);
334 : }
335 :
336 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetUseBuffering(GenericPlayerContext &context,
337 : IGstGenericPlayerPrivate &player,
338 : bool useBuffering) const
339 : {
340 1 : return std::make_unique<tasks::generic::SetUseBuffering>(context, player, useBuffering);
341 : }
342 :
343 : std::unique_ptr<IPlayerTask>
344 1 : GenericPlayerTaskFactory::createSwitchSource(IGstGenericPlayerPrivate &player,
345 : const std::unique_ptr<IMediaPipeline::MediaSource> &source) const
346 : {
347 1 : return std::make_unique<tasks::generic::SwitchSource>(player, source);
348 : }
349 :
350 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSynchroniseSubtitleClock(GenericPlayerContext &context,
351 : IGstGenericPlayerPrivate &player) const
352 : {
353 1 : return std::make_unique<tasks::generic::SynchroniseSubtitleClock>(context, player, m_gstWrapper, m_glibWrapper);
354 : }
355 : } // namespace firebolt::rialto::server
|
