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