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