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