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/FirstFrameReceived.h"
29 : #include "tasks/generic/Flush.h"
30 : #include "tasks/generic/HandleBusMessage.h"
31 : #include "tasks/generic/NeedData.h"
32 : #include "tasks/generic/Pause.h"
33 : #include "tasks/generic/Ping.h"
34 : #include "tasks/generic/Play.h"
35 : #include "tasks/generic/ProcessAudioGap.h"
36 : #include "tasks/generic/ReadShmDataAndAttachSamples.h"
37 : #include "tasks/generic/RemoveSource.h"
38 : #include "tasks/generic/RenderFrame.h"
39 : #include "tasks/generic/ReportPosition.h"
40 : #include "tasks/generic/SetBufferingLimit.h"
41 : #include "tasks/generic/SetImmediateOutput.h"
42 : #include "tasks/generic/SetLowLatency.h"
43 : #include "tasks/generic/SetMute.h"
44 : #include "tasks/generic/SetPlaybackRate.h"
45 : #include "tasks/generic/SetPosition.h"
46 : #include "tasks/generic/SetReportDecodeErrors.h"
47 : #include "tasks/generic/SetSourcePosition.h"
48 : #include "tasks/generic/SetStreamSyncMode.h"
49 : #include "tasks/generic/SetSubtitleOffset.h"
50 : #include "tasks/generic/SetSync.h"
51 : #include "tasks/generic/SetSyncOff.h"
52 : #include "tasks/generic/SetTextTrackIdentifier.h"
53 : #include "tasks/generic/SetUseBuffering.h"
54 : #include "tasks/generic/SetVideoGeometry.h"
55 : #include "tasks/generic/SetVolume.h"
56 : #include "tasks/generic/SetupElement.h"
57 : #include "tasks/generic/SetupSource.h"
58 : #include "tasks/generic/Shutdown.h"
59 : #include "tasks/generic/Stop.h"
60 : #include "tasks/generic/SwitchSource.h"
61 : #include "tasks/generic/SynchroniseSubtitleClock.h"
62 : #include "tasks/generic/Underflow.h"
63 : #include "tasks/generic/UpdatePlaybackGroup.h"
64 :
65 : namespace firebolt::rialto::server
66 : {
67 43 : GenericPlayerTaskFactory::GenericPlayerTaskFactory(
68 : IGstGenericPlayerClient *client, const std::shared_ptr<firebolt::rialto::wrappers::IGstWrapper> &gstWrapper,
69 : const std::shared_ptr<firebolt::rialto::wrappers::IGlibWrapper> &glibWrapper,
70 : const std::shared_ptr<firebolt::rialto::wrappers::IRdkGstreamerUtilsWrapper> &rdkGstreamerUtilsWrapper,
71 43 : const std::shared_ptr<IGstTextTrackSinkFactory> &gstTextTrackSinkFactory)
72 43 : : m_client{client}, m_gstWrapper{gstWrapper}, m_glibWrapper{glibWrapper},
73 86 : m_rdkGstreamerUtilsWrapper{rdkGstreamerUtilsWrapper}, m_gstTextTrackSinkFactory{gstTextTrackSinkFactory}
74 : {
75 43 : }
76 :
77 : std::unique_ptr<IPlayerTask>
78 1 : GenericPlayerTaskFactory::createAttachSamples(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
79 : const IMediaPipeline::MediaSegmentVector &mediaSegments) const
80 : {
81 1 : return std::make_unique<tasks::generic::AttachSamples>(context, m_gstWrapper, player, mediaSegments);
82 : }
83 :
84 : std::unique_ptr<IPlayerTask>
85 1 : GenericPlayerTaskFactory::createAttachSource(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
86 : const std::unique_ptr<IMediaPipeline::MediaSource> &source) const
87 : {
88 1 : return std::make_unique<tasks::generic::AttachSource>(context, m_gstWrapper, m_glibWrapper,
89 2 : m_gstTextTrackSinkFactory, player, source);
90 : }
91 :
92 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createDeepElementAdded(GenericPlayerContext &context,
93 : IGstGenericPlayerPrivate &player,
94 : GstBin *pipeline, GstBin *bin,
95 : GstElement *element) const
96 : {
97 2 : return std::make_unique<tasks::generic::DeepElementAdded>(context, player, m_gstWrapper, m_glibWrapper, pipeline,
98 2 : bin, element);
99 : }
100 :
101 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createEnoughData(GenericPlayerContext &context, GstAppSrc *src) const
102 : {
103 1 : return std::make_unique<tasks::generic::EnoughData>(context, src);
104 : }
105 :
106 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createEos(GenericPlayerContext &context,
107 : IGstGenericPlayerPrivate &player,
108 : const firebolt::rialto::MediaSourceType &type) const
109 : {
110 1 : return std::make_unique<tasks::generic::Eos>(context, player, m_gstWrapper, type);
111 : }
112 :
113 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createFinishSetupSource(GenericPlayerContext &context,
114 : IGstGenericPlayerPrivate &player) const
115 : {
116 1 : return std::make_unique<tasks::generic::FinishSetupSource>(context, player, m_client);
117 : }
118 :
119 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createHandleBusMessage(GenericPlayerContext &context,
120 : IGstGenericPlayerPrivate &player,
121 : GstMessage *message,
122 : const IFlushWatcher &flushWatcher) const
123 : {
124 2 : return std::make_unique<tasks::generic::HandleBusMessage>(context, player, m_client, m_gstWrapper, m_glibWrapper,
125 2 : message, flushWatcher);
126 : }
127 :
128 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createNeedData(GenericPlayerContext &context,
129 : IGstGenericPlayerPrivate &player,
130 : GstAppSrc *src) const
131 : {
132 1 : return std::make_unique<tasks::generic::NeedData>(context, player, m_client, src);
133 : }
134 :
135 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPause(GenericPlayerContext &context,
136 : IGstGenericPlayerPrivate &player) const
137 : {
138 1 : return std::make_unique<tasks::generic::Pause>(context, player);
139 : }
140 :
141 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPlay(IGstGenericPlayerPrivate &player) const
142 : {
143 1 : return std::make_unique<tasks::generic::Play>(player);
144 : }
145 :
146 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createReadShmDataAndAttachSamples(
147 : GenericPlayerContext &context, IGstGenericPlayerPrivate &player, const std::shared_ptr<IDataReader> &dataReader) const
148 : {
149 1 : return std::make_unique<tasks::generic::ReadShmDataAndAttachSamples>(context, m_gstWrapper, player, dataReader);
150 : }
151 :
152 : std::unique_ptr<IPlayerTask>
153 1 : GenericPlayerTaskFactory::createRemoveSource(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
154 : const firebolt::rialto::MediaSourceType &type) const
155 : {
156 1 : return std::make_unique<tasks::generic::RemoveSource>(context, player, m_client, m_gstWrapper, type);
157 : }
158 :
159 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createReportPosition(GenericPlayerContext &context,
160 : IGstGenericPlayerPrivate &player) const
161 : {
162 1 : return std::make_unique<tasks::generic::ReportPosition>(context, m_client, m_gstWrapper, player);
163 : }
164 :
165 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createCheckAudioUnderflow(GenericPlayerContext &context,
166 : IGstGenericPlayerPrivate &player) const
167 : {
168 1 : return std::make_unique<tasks::generic::CheckAudioUnderflow>(context, player, m_client, m_gstWrapper);
169 : }
170 :
171 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetPlaybackRate(GenericPlayerContext &context,
172 : double rate) const
173 : {
174 1 : return std::make_unique<tasks::generic::SetPlaybackRate>(context, m_gstWrapper, m_glibWrapper, rate);
175 : }
176 :
177 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetPosition(GenericPlayerContext &context,
178 : IGstGenericPlayerPrivate &player,
179 : std::int64_t position) const
180 : {
181 1 : return std::make_unique<tasks::generic::SetPosition>(context, player, m_client, m_gstWrapper, position);
182 : }
183 :
184 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetupElement(GenericPlayerContext &context,
185 : IGstGenericPlayerPrivate &player,
186 : GstElement *element) const
187 : {
188 1 : return std::make_unique<tasks::generic::SetupElement>(context, m_gstWrapper, m_glibWrapper, player, element);
189 : }
190 :
191 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetupSource(GenericPlayerContext &context,
192 : IGstGenericPlayerPrivate &player,
193 : GstElement *source) const
194 : {
195 1 : return std::make_unique<tasks::generic::SetupSource>(context, player, source);
196 : }
197 :
198 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetVideoGeometry(GenericPlayerContext &context,
199 : IGstGenericPlayerPrivate &player,
200 : const Rectangle &rectangle) const
201 : {
202 1 : return std::make_unique<tasks::generic::SetVideoGeometry>(context, player, rectangle);
203 : }
204 :
205 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetVolume(GenericPlayerContext &context,
206 : IGstGenericPlayerPrivate &player,
207 : double targetVolume, uint32_t volumeDuration,
208 : firebolt::rialto::EaseType easeType) const
209 : {
210 1 : return std::make_unique<tasks::generic::SetVolume>(context, player, m_gstWrapper, m_glibWrapper,
211 1 : m_rdkGstreamerUtilsWrapper, targetVolume, volumeDuration,
212 2 : easeType);
213 : }
214 :
215 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetMute(GenericPlayerContext &context,
216 : IGstGenericPlayerPrivate &player,
217 : const MediaSourceType &mediaSourceType,
218 : bool mute) const
219 : {
220 1 : return std::make_unique<tasks::generic::SetMute>(context, player, m_gstWrapper, m_glibWrapper, mediaSourceType, mute);
221 : }
222 :
223 : std::unique_ptr<IPlayerTask>
224 1 : GenericPlayerTaskFactory::createSetTextTrackIdentifier(GenericPlayerContext &context,
225 : const std::string &textTrackIdentifier) const
226 : {
227 1 : return std::make_unique<tasks::generic::SetTextTrackIdentifier>(context, m_glibWrapper, textTrackIdentifier);
228 : }
229 :
230 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetLowLatency(GenericPlayerContext &context,
231 : IGstGenericPlayerPrivate &player,
232 : bool lowLatency) const
233 : {
234 1 : return std::make_unique<tasks::generic::SetLowLatency>(context, player, lowLatency);
235 : }
236 :
237 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSync(GenericPlayerContext &context,
238 : IGstGenericPlayerPrivate &player, bool sync) const
239 : {
240 1 : return std::make_unique<tasks::generic::SetSync>(context, player, sync);
241 : }
242 :
243 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSyncOff(GenericPlayerContext &context,
244 : IGstGenericPlayerPrivate &player,
245 : bool syncOff) const
246 : {
247 1 : return std::make_unique<tasks::generic::SetSyncOff>(context, player, syncOff);
248 : }
249 :
250 : std::unique_ptr<IPlayerTask>
251 1 : GenericPlayerTaskFactory::createSetStreamSyncMode(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
252 : const firebolt::rialto::MediaSourceType &type,
253 : int32_t streamSyncMode) const
254 : {
255 1 : return std::make_unique<tasks::generic::SetStreamSyncMode>(context, player, type, streamSyncMode);
256 : }
257 :
258 2 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createShutdown(IGstGenericPlayerPrivate &player) const
259 : {
260 2 : return std::make_unique<tasks::generic::Shutdown>(player);
261 : }
262 :
263 2 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createStop(GenericPlayerContext &context,
264 : IGstGenericPlayerPrivate &player) const
265 : {
266 2 : return std::make_unique<tasks::generic::Stop>(context, player);
267 : }
268 :
269 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createUnderflow(GenericPlayerContext &context,
270 : IGstGenericPlayerPrivate &player,
271 : bool underflowEnabled,
272 : MediaSourceType sourceType) const
273 : {
274 1 : return std::make_unique<tasks::generic::Underflow>(context, player, m_client, underflowEnabled, sourceType);
275 : }
276 :
277 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createFirstFrameReceived(GenericPlayerContext &context,
278 : IGstGenericPlayerPrivate &player,
279 : MediaSourceType sourceType,
280 : AudioFirstFrameAction audioAction) const
281 : {
282 1 : return std::make_unique<tasks::generic::FirstFrameReceived>(context, player, m_client, sourceType, audioAction);
283 : }
284 :
285 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createUpdatePlaybackGroup(GenericPlayerContext &context,
286 : IGstGenericPlayerPrivate &player,
287 : GstElement *typefind, GstCaps *caps) const
288 : {
289 2 : return std::make_unique<tasks::generic::UpdatePlaybackGroup>(context, player, m_gstWrapper, m_glibWrapper, typefind,
290 2 : caps);
291 : }
292 :
293 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createRenderFrame(GenericPlayerContext &context,
294 : IGstGenericPlayerPrivate &player) const
295 : {
296 1 : return std::make_unique<tasks::generic::RenderFrame>(context, player);
297 : }
298 :
299 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createPing(std::unique_ptr<IHeartbeatHandler> &&heartbeatHandler) const
300 : {
301 1 : return std::make_unique<tasks::generic::Ping>(std::move(heartbeatHandler));
302 : }
303 :
304 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createFlush(GenericPlayerContext &context,
305 : IGstGenericPlayerPrivate &player,
306 : const firebolt::rialto::MediaSourceType &type,
307 : bool resetTime, bool isAsync) const
308 : {
309 1 : return std::make_unique<tasks::generic::Flush>(context, player, m_client, m_gstWrapper, type, resetTime, isAsync);
310 : }
311 :
312 : std::unique_ptr<IPlayerTask>
313 1 : GenericPlayerTaskFactory::createSetSourcePosition(GenericPlayerContext &context,
314 : const firebolt::rialto::MediaSourceType &type, std::int64_t position,
315 : bool resetTime, double appliedRate, uint64_t stopPosition) const
316 : {
317 2 : return std::make_unique<tasks::generic::SetSourcePosition>(context, m_glibWrapper, type, position, resetTime,
318 2 : appliedRate, stopPosition);
319 : }
320 :
321 0 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetSubtitleOffset(GenericPlayerContext &context,
322 : std::int64_t position) const
323 : {
324 0 : return std::make_unique<tasks::generic::SetSubtitleOffset>(context, m_glibWrapper, position);
325 : }
326 :
327 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createProcessAudioGap(GenericPlayerContext &context,
328 : std::int64_t position,
329 : std::uint32_t duration,
330 : std::int64_t discontinuityGap,
331 : bool audioAac) const
332 : {
333 1 : return std::make_unique<tasks::generic::ProcessAudioGap>(context, m_gstWrapper, m_glibWrapper,
334 1 : m_rdkGstreamerUtilsWrapper, position, duration,
335 2 : discontinuityGap, audioAac);
336 : }
337 :
338 : std::unique_ptr<IPlayerTask>
339 1 : GenericPlayerTaskFactory::createSetImmediateOutput(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
340 : const firebolt::rialto::MediaSourceType &type,
341 : bool immediateOutput) const
342 : {
343 1 : return std::make_unique<tasks::generic::SetImmediateOutput>(context, player, type, immediateOutput);
344 : }
345 :
346 : std::unique_ptr<IPlayerTask>
347 1 : GenericPlayerTaskFactory::createSetReportDecodeErrors(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
348 : const firebolt::rialto::MediaSourceType &type,
349 : bool reportDecodeErrors) const
350 : {
351 1 : return std::make_unique<tasks::generic::SetReportDecodeErrors>(context, player, type, reportDecodeErrors);
352 : }
353 :
354 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetBufferingLimit(GenericPlayerContext &context,
355 : IGstGenericPlayerPrivate &player,
356 : std::uint32_t limit) const
357 : {
358 1 : return std::make_unique<tasks::generic::SetBufferingLimit>(context, player, limit);
359 : }
360 :
361 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSetUseBuffering(GenericPlayerContext &context,
362 : IGstGenericPlayerPrivate &player,
363 : bool useBuffering) const
364 : {
365 1 : return std::make_unique<tasks::generic::SetUseBuffering>(context, player, useBuffering);
366 : }
367 :
368 : std::unique_ptr<IPlayerTask>
369 1 : GenericPlayerTaskFactory::createSwitchSource(IGstGenericPlayerPrivate &player,
370 : const std::unique_ptr<IMediaPipeline::MediaSource> &source) const
371 : {
372 1 : return std::make_unique<tasks::generic::SwitchSource>(player, source);
373 : }
374 :
375 1 : std::unique_ptr<IPlayerTask> GenericPlayerTaskFactory::createSynchroniseSubtitleClock(GenericPlayerContext &context,
376 : IGstGenericPlayerPrivate &player) const
377 : {
378 1 : return std::make_unique<tasks::generic::SynchroniseSubtitleClock>(context, player, m_gstWrapper, m_glibWrapper);
379 : }
380 : } // namespace firebolt::rialto::server
|
