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