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 :
20 : #include "MediaPipelineService.h"
21 : #include "IMediaPipelineServerInternal.h"
22 : #include "RialtoServerLogging.h"
23 : #include <exception>
24 : #include <future>
25 : #include <string>
26 : #include <utility>
27 : #include <vector>
28 :
29 : namespace firebolt::rialto::server::service
30 : {
31 135 : MediaPipelineService::MediaPipelineService(
32 : IPlaybackService &playbackService, std::shared_ptr<IMediaPipelineServerInternalFactory> &&mediaPipelineFactory,
33 : std::shared_ptr<IMediaPipelineCapabilitiesFactory> &&mediaPipelineCapabilitiesFactory,
34 135 : IDecryptionService &decryptionService)
35 135 : : m_playbackService{playbackService}, m_mediaPipelineFactory{mediaPipelineFactory},
36 135 : m_mediaPipelineCapabilities{mediaPipelineCapabilitiesFactory->createMediaPipelineCapabilities()},
37 270 : m_decryptionService{decryptionService}
38 : {
39 135 : if (!m_mediaPipelineCapabilities)
40 : {
41 1 : throw std::runtime_error("Could not create Media Pipeline Capabilities");
42 : }
43 :
44 134 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is constructed");
45 138 : }
46 :
47 268 : MediaPipelineService::~MediaPipelineService()
48 : {
49 134 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is destructed");
50 268 : }
51 :
52 1 : void MediaPipelineService::clearMediaPipelines()
53 : {
54 1 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
55 1 : m_mediaPipelines.clear();
56 : }
57 :
58 87 : bool MediaPipelineService::createSession(int sessionId, const std::shared_ptr<IMediaPipelineClient> &mediaPipelineClient,
59 : std::uint32_t maxWidth, std::uint32_t maxHeight)
60 : {
61 87 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService requested to create new session with id: %d", sessionId);
62 87 : if (!m_playbackService.isActive())
63 : {
64 1 : RIALTO_SERVER_LOG_ERROR("Skip to create session with id: %d - Session Server in Inactive state", sessionId);
65 1 : return false;
66 : }
67 :
68 : {
69 86 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
70 86 : if (m_mediaPipelines.size() == static_cast<size_t>(m_playbackService.getMaxPlaybacks()))
71 : {
72 1 : RIALTO_SERVER_LOG_ERROR("Unable to create a session with id: %d. Max session number reached.", sessionId);
73 1 : return false;
74 : }
75 85 : if (m_mediaPipelines.find(sessionId) != m_mediaPipelines.end())
76 : {
77 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d already exists", sessionId);
78 1 : return false;
79 : }
80 84 : auto shmBuffer = m_playbackService.getShmBuffer();
81 84 : m_mediaPipelines.emplace(
82 168 : std::make_pair(sessionId,
83 252 : m_mediaPipelineFactory->createMediaPipelineServerInternal(mediaPipelineClient,
84 84 : VideoRequirements{maxWidth, maxHeight},
85 : sessionId, shmBuffer,
86 : m_decryptionService)));
87 84 : if (!m_mediaPipelines.at(sessionId))
88 : {
89 1 : RIALTO_SERVER_LOG_ERROR("Could not create MediaPipeline for session with id: %d", sessionId);
90 1 : m_mediaPipelines.erase(sessionId);
91 1 : return false;
92 : }
93 87 : }
94 :
95 83 : RIALTO_SERVER_LOG_INFO("New session with id: %d created", sessionId);
96 83 : return true;
97 : }
98 :
99 3 : bool MediaPipelineService::destroySession(int sessionId)
100 : {
101 3 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService requested to destroy session with id: %d", sessionId);
102 : {
103 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
104 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
105 3 : if (mediaPipelineIter == m_mediaPipelines.end())
106 : {
107 2 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
108 2 : return false;
109 : }
110 1 : m_mediaPipelines.erase(mediaPipelineIter);
111 3 : }
112 1 : RIALTO_SERVER_LOG_INFO("Session with id: %d destroyed", sessionId);
113 1 : return true;
114 : }
115 :
116 3 : bool MediaPipelineService::load(int sessionId, MediaType type, const std::string &mimeType, const std::string &url)
117 : {
118 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to load session with id: %d", sessionId);
119 :
120 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
121 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
122 3 : if (mediaPipelineIter == m_mediaPipelines.end())
123 : {
124 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
125 1 : return false;
126 : }
127 2 : return mediaPipelineIter->second->load(type, mimeType, url);
128 3 : }
129 :
130 3 : bool MediaPipelineService::attachSource(int sessionId, const std::unique_ptr<IMediaPipeline::MediaSource> &source)
131 : {
132 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to attach source, session id: %d", sessionId);
133 :
134 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
135 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
136 3 : if (mediaPipelineIter == m_mediaPipelines.end())
137 : {
138 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
139 1 : return false;
140 : }
141 2 : return mediaPipelineIter->second->attachSource(source);
142 3 : }
143 :
144 3 : bool MediaPipelineService::removeSource(int sessionId, std::int32_t sourceId)
145 : {
146 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to remove source, session id: %d", sessionId);
147 :
148 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
149 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
150 3 : if (mediaPipelineIter == m_mediaPipelines.end())
151 : {
152 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
153 1 : return false;
154 : }
155 2 : return mediaPipelineIter->second->removeSource(sourceId);
156 3 : }
157 :
158 3 : bool MediaPipelineService::allSourcesAttached(int sessionId)
159 : {
160 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService notified that all sources were attached, session id: %d", sessionId);
161 :
162 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
163 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
164 3 : if (mediaPipelineIter == m_mediaPipelines.end())
165 : {
166 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
167 1 : return false;
168 : }
169 2 : return mediaPipelineIter->second->allSourcesAttached();
170 3 : }
171 :
172 3 : bool MediaPipelineService::play(int sessionId, bool &async)
173 : {
174 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to play, session id: %d", sessionId);
175 :
176 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
177 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
178 3 : if (mediaPipelineIter == m_mediaPipelines.end())
179 : {
180 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
181 1 : return false;
182 : }
183 2 : return mediaPipelineIter->second->play(async);
184 3 : }
185 :
186 3 : bool MediaPipelineService::pause(int sessionId)
187 : {
188 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to pause, session id: %d", sessionId);
189 :
190 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
191 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
192 3 : if (mediaPipelineIter == m_mediaPipelines.end())
193 : {
194 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
195 1 : return false;
196 : }
197 2 : return mediaPipelineIter->second->pause();
198 3 : }
199 :
200 3 : bool MediaPipelineService::stop(int sessionId)
201 : {
202 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to stop, session id: %d", sessionId);
203 :
204 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
205 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
206 3 : if (mediaPipelineIter == m_mediaPipelines.end())
207 : {
208 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
209 1 : return false;
210 : }
211 2 : return mediaPipelineIter->second->stop();
212 3 : }
213 :
214 3 : bool MediaPipelineService::setPlaybackRate(int sessionId, double rate)
215 : {
216 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to set playback rate, session id: %d", sessionId);
217 :
218 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
219 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
220 3 : if (mediaPipelineIter == m_mediaPipelines.end())
221 : {
222 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
223 1 : return false;
224 : }
225 2 : return mediaPipelineIter->second->setPlaybackRate(rate);
226 3 : }
227 :
228 3 : bool MediaPipelineService::setPosition(int sessionId, std::int64_t position)
229 : {
230 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to set position, session id: %d", sessionId);
231 :
232 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
233 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
234 3 : if (mediaPipelineIter == m_mediaPipelines.end())
235 : {
236 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
237 1 : return false;
238 : }
239 2 : return mediaPipelineIter->second->setPosition(position);
240 3 : }
241 :
242 3 : bool MediaPipelineService::getPosition(int sessionId, std::int64_t &position)
243 : {
244 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to get position, session id: %d", sessionId);
245 :
246 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
247 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
248 3 : if (mediaPipelineIter == m_mediaPipelines.end())
249 : {
250 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
251 1 : return false;
252 : }
253 2 : return mediaPipelineIter->second->getPosition(position);
254 3 : }
255 :
256 3 : bool MediaPipelineService::setImmediateOutput(int sessionId, int32_t sourceId, bool immediateOutput)
257 : {
258 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to setImmediateOutput, session id: %d", sessionId);
259 :
260 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
261 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
262 3 : if (mediaPipelineIter == m_mediaPipelines.end())
263 : {
264 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
265 1 : return false;
266 : }
267 2 : return mediaPipelineIter->second->setImmediateOutput(sourceId, immediateOutput);
268 3 : }
269 :
270 3 : bool MediaPipelineService::setReportDecodeErrors(int sessionId, int32_t sourceId, bool reportDecodeErrors)
271 : {
272 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to setReportDecodeErrors, session id: %d", sessionId);
273 :
274 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
275 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
276 3 : if (mediaPipelineIter == m_mediaPipelines.end())
277 : {
278 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
279 1 : return false;
280 : }
281 2 : return mediaPipelineIter->second->setReportDecodeErrors(sourceId, reportDecodeErrors);
282 3 : }
283 :
284 3 : bool MediaPipelineService::getQueuedFrames(int sessionId, int32_t sourceId, uint32_t &queuedFrames)
285 : {
286 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to getQueuedFrames, session id: %d", sessionId);
287 :
288 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
289 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
290 3 : if (mediaPipelineIter == m_mediaPipelines.end())
291 : {
292 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
293 1 : return false;
294 : }
295 2 : return mediaPipelineIter->second->getQueuedFrames(sourceId, queuedFrames);
296 3 : }
297 :
298 3 : bool MediaPipelineService::getImmediateOutput(int sessionId, int32_t sourceId, bool &immediateOutput)
299 : {
300 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to getImmediateOutput, session id: %d", sessionId);
301 :
302 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
303 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
304 3 : if (mediaPipelineIter == m_mediaPipelines.end())
305 : {
306 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
307 1 : return false;
308 : }
309 2 : return mediaPipelineIter->second->getImmediateOutput(sourceId, immediateOutput);
310 3 : }
311 :
312 3 : bool MediaPipelineService::getStats(int sessionId, int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames)
313 : {
314 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to get stats, session id: %d", sessionId);
315 :
316 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
317 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
318 3 : if (mediaPipelineIter == m_mediaPipelines.end())
319 : {
320 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
321 1 : return false;
322 : }
323 2 : return mediaPipelineIter->second->getStats(sourceId, renderedFrames, droppedFrames);
324 3 : }
325 :
326 3 : bool MediaPipelineService::setVideoWindow(int sessionId, std::uint32_t x, std::uint32_t y, std::uint32_t width,
327 : std::uint32_t height)
328 : {
329 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to set video window, session id: %d", sessionId);
330 :
331 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
332 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
333 3 : if (mediaPipelineIter == m_mediaPipelines.end())
334 : {
335 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
336 1 : return false;
337 : }
338 2 : return mediaPipelineIter->second->setVideoWindow(x, y, width, height);
339 3 : }
340 :
341 3 : bool MediaPipelineService::haveData(int sessionId, MediaSourceStatus status, std::uint32_t numFrames,
342 : std::uint32_t needDataRequestId)
343 : {
344 3 : RIALTO_SERVER_LOG_DEBUG("New data available, session id: %d", sessionId);
345 :
346 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
347 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
348 3 : if (mediaPipelineIter == m_mediaPipelines.end())
349 : {
350 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
351 1 : return false;
352 : }
353 2 : return mediaPipelineIter->second->haveData(status, numFrames, needDataRequestId);
354 3 : }
355 :
356 3 : bool MediaPipelineService::renderFrame(int sessionId)
357 : {
358 3 : RIALTO_SERVER_LOG_DEBUG("Render frame requested, session id: %d", sessionId);
359 :
360 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
361 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
362 3 : if (mediaPipelineIter == m_mediaPipelines.end())
363 : {
364 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
365 1 : return false;
366 : }
367 2 : return mediaPipelineIter->second->renderFrame();
368 3 : }
369 3 : bool MediaPipelineService::setVolume(int sessionId, double targetVolume, uint32_t volumeDuration, EaseType easeType)
370 : {
371 3 : RIALTO_SERVER_LOG_DEBUG("Set volume requested, session id: %d", sessionId);
372 :
373 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
374 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
375 3 : if (mediaPipelineIter == m_mediaPipelines.end())
376 : {
377 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
378 1 : return false;
379 : }
380 2 : return mediaPipelineIter->second->setVolume(targetVolume, volumeDuration, easeType);
381 3 : }
382 :
383 3 : bool MediaPipelineService::getVolume(int sessionId, double &volume)
384 : {
385 3 : RIALTO_SERVER_LOG_DEBUG("Get volume requested, session id: %d", sessionId);
386 :
387 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
388 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
389 3 : if (mediaPipelineIter == m_mediaPipelines.end())
390 : {
391 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
392 1 : return false;
393 : }
394 2 : return mediaPipelineIter->second->getVolume(volume);
395 3 : }
396 :
397 3 : bool MediaPipelineService::setMute(int sessionId, std::int32_t sourceId, bool mute)
398 : {
399 3 : RIALTO_SERVER_LOG_DEBUG("Set mute requested, session id: %d", sessionId);
400 :
401 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
402 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
403 3 : if (mediaPipelineIter == m_mediaPipelines.end())
404 : {
405 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
406 1 : return false;
407 : }
408 2 : return mediaPipelineIter->second->setMute(sourceId, mute);
409 3 : }
410 :
411 3 : bool MediaPipelineService::getMute(int sessionId, std::int32_t sourceId, bool &mute)
412 : {
413 3 : RIALTO_SERVER_LOG_DEBUG("Get mute requested, session id: %d", sessionId);
414 :
415 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
416 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
417 3 : if (mediaPipelineIter == m_mediaPipelines.end())
418 : {
419 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
420 1 : return false;
421 : }
422 2 : return mediaPipelineIter->second->getMute(sourceId, mute);
423 3 : }
424 :
425 3 : bool MediaPipelineService::setTextTrackIdentifier(int sessionId, const std::string &textTrackIdentifier)
426 : {
427 3 : RIALTO_SERVER_LOG_DEBUG("Set text track identifier requested, session id: %d", sessionId);
428 :
429 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
430 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
431 3 : if (mediaPipelineIter == m_mediaPipelines.end())
432 : {
433 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
434 1 : return false;
435 : }
436 2 : return mediaPipelineIter->second->setTextTrackIdentifier(textTrackIdentifier);
437 3 : }
438 :
439 3 : bool MediaPipelineService::getTextTrackIdentifier(int sessionId, std::string &textTrackIdentifier)
440 : {
441 3 : RIALTO_SERVER_LOG_DEBUG("Get text track identifier requested, session id: %d", sessionId);
442 :
443 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
444 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
445 3 : if (mediaPipelineIter == m_mediaPipelines.end())
446 : {
447 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
448 1 : return false;
449 : }
450 2 : return mediaPipelineIter->second->getTextTrackIdentifier(textTrackIdentifier);
451 3 : }
452 :
453 3 : bool MediaPipelineService::setLowLatency(int sessionId, bool lowLatency)
454 : {
455 3 : RIALTO_SERVER_LOG_DEBUG("Set low latency requested, session id: %d", sessionId);
456 :
457 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
458 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
459 3 : if (mediaPipelineIter == m_mediaPipelines.end())
460 : {
461 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
462 1 : return false;
463 : }
464 2 : return mediaPipelineIter->second->setLowLatency(lowLatency);
465 3 : }
466 :
467 3 : bool MediaPipelineService::setSync(int sessionId, bool sync)
468 : {
469 3 : RIALTO_SERVER_LOG_DEBUG("Set sync requested, session id: %d", sessionId);
470 :
471 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
472 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
473 3 : if (mediaPipelineIter == m_mediaPipelines.end())
474 : {
475 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
476 1 : return false;
477 : }
478 2 : return mediaPipelineIter->second->setSync(sync);
479 3 : }
480 :
481 3 : bool MediaPipelineService::getSync(int sessionId, bool &sync)
482 : {
483 3 : RIALTO_SERVER_LOG_DEBUG("Get sync requested, session id: %d", sessionId);
484 :
485 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
486 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
487 3 : if (mediaPipelineIter == m_mediaPipelines.end())
488 : {
489 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
490 1 : return false;
491 : }
492 2 : return mediaPipelineIter->second->getSync(sync);
493 3 : }
494 :
495 3 : bool MediaPipelineService::setSyncOff(int sessionId, bool syncOff)
496 : {
497 3 : RIALTO_SERVER_LOG_DEBUG("Set sync off requested, session id: %d", sessionId);
498 :
499 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
500 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
501 3 : if (mediaPipelineIter == m_mediaPipelines.end())
502 : {
503 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
504 1 : return false;
505 : }
506 2 : return mediaPipelineIter->second->setSyncOff(syncOff);
507 3 : }
508 :
509 3 : bool MediaPipelineService::setStreamSyncMode(int sessionId, int32_t sourceId, int32_t streamSyncMode)
510 : {
511 3 : RIALTO_SERVER_LOG_DEBUG("Set stream sync mode requested, session id: %d", sessionId);
512 :
513 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
514 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
515 3 : if (mediaPipelineIter == m_mediaPipelines.end())
516 : {
517 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
518 1 : return false;
519 : }
520 2 : return mediaPipelineIter->second->setStreamSyncMode(sourceId, streamSyncMode);
521 3 : }
522 :
523 3 : bool MediaPipelineService::getStreamSyncMode(int sessionId, int32_t &streamSyncMode)
524 : {
525 3 : RIALTO_SERVER_LOG_DEBUG("Get stream sync mode requested, session id: %d", sessionId);
526 :
527 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
528 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
529 3 : if (mediaPipelineIter == m_mediaPipelines.end())
530 : {
531 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
532 1 : return false;
533 : }
534 2 : return mediaPipelineIter->second->getStreamSyncMode(streamSyncMode);
535 3 : }
536 :
537 3 : bool MediaPipelineService::flush(int sessionId, std::int32_t sourceId, bool resetTime, bool &isAsync)
538 : {
539 3 : RIALTO_SERVER_LOG_DEBUG("Flush requested, session id: %d", sessionId);
540 :
541 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
542 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
543 3 : if (mediaPipelineIter == m_mediaPipelines.end())
544 : {
545 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
546 1 : return false;
547 : }
548 2 : return mediaPipelineIter->second->flush(sourceId, resetTime, isAsync);
549 3 : }
550 :
551 3 : bool MediaPipelineService::setSourcePosition(int sessionId, int32_t sourceId, int64_t position, bool resetTime,
552 : double appliedRate, uint64_t stopPosition)
553 : {
554 3 : RIALTO_SERVER_LOG_DEBUG("Set Source Position requested, session id: %d", sessionId);
555 :
556 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
557 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
558 3 : if (mediaPipelineIter == m_mediaPipelines.end())
559 : {
560 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
561 1 : return false;
562 : }
563 2 : return mediaPipelineIter->second->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
564 3 : }
565 :
566 0 : bool MediaPipelineService::setSubtitleOffset(int sessionId, int32_t sourceId, int64_t position)
567 : {
568 0 : RIALTO_SERVER_LOG_DEBUG("Set Subtitle Offset requested, session id: %d", sessionId);
569 :
570 0 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
571 0 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
572 0 : if (mediaPipelineIter == m_mediaPipelines.end())
573 : {
574 0 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
575 0 : return false;
576 : }
577 0 : return mediaPipelineIter->second->setSubtitleOffset(sourceId, position);
578 : }
579 :
580 3 : bool MediaPipelineService::processAudioGap(int sessionId, int64_t position, uint32_t duration, int64_t discontinuityGap,
581 : bool audioAac)
582 : {
583 3 : RIALTO_SERVER_LOG_DEBUG("Process Audio Gap requested, session id: %d", sessionId);
584 :
585 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
586 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
587 3 : if (mediaPipelineIter == m_mediaPipelines.end())
588 : {
589 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
590 1 : return false;
591 : }
592 2 : return mediaPipelineIter->second->processAudioGap(position, duration, discontinuityGap, audioAac);
593 3 : }
594 :
595 3 : bool MediaPipelineService::setBufferingLimit(int sessionId, uint32_t limitBufferingMs)
596 : {
597 3 : RIALTO_SERVER_LOG_DEBUG("Set buffering limit requested, session id: %d", sessionId);
598 :
599 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
600 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
601 3 : if (mediaPipelineIter == m_mediaPipelines.end())
602 : {
603 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
604 1 : return false;
605 : }
606 2 : return mediaPipelineIter->second->setBufferingLimit(limitBufferingMs);
607 3 : }
608 :
609 3 : bool MediaPipelineService::getBufferingLimit(int sessionId, uint32_t &limitBufferingMs)
610 : {
611 3 : RIALTO_SERVER_LOG_DEBUG("Get buffering limit requested, session id: %d", sessionId);
612 :
613 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
614 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
615 3 : if (mediaPipelineIter == m_mediaPipelines.end())
616 : {
617 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
618 1 : return false;
619 : }
620 2 : return mediaPipelineIter->second->getBufferingLimit(limitBufferingMs);
621 3 : }
622 :
623 3 : bool MediaPipelineService::setUseBuffering(int sessionId, bool useBuffering)
624 : {
625 3 : RIALTO_SERVER_LOG_DEBUG("Set use buffering requested, session id: %d", sessionId);
626 :
627 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
628 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
629 3 : if (mediaPipelineIter == m_mediaPipelines.end())
630 : {
631 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
632 1 : return false;
633 : }
634 2 : return mediaPipelineIter->second->setUseBuffering(useBuffering);
635 3 : }
636 :
637 3 : bool MediaPipelineService::getUseBuffering(int sessionId, bool &useBuffering)
638 : {
639 3 : RIALTO_SERVER_LOG_DEBUG("Get use buffering requested, session id: %d", sessionId);
640 :
641 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
642 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
643 3 : if (mediaPipelineIter == m_mediaPipelines.end())
644 : {
645 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
646 1 : return false;
647 : }
648 2 : return mediaPipelineIter->second->getUseBuffering(useBuffering);
649 3 : }
650 :
651 3 : bool MediaPipelineService::switchSource(int sessionId, const std::unique_ptr<IMediaPipeline::MediaSource> &source)
652 : {
653 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to switch source, session id: %d", sessionId);
654 :
655 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
656 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
657 3 : if (mediaPipelineIter == m_mediaPipelines.end())
658 : {
659 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
660 1 : return false;
661 : }
662 2 : return mediaPipelineIter->second->switchSource(source);
663 3 : }
664 :
665 2 : bool MediaPipelineService::isVideoMaster(bool &isVideoMaster)
666 : {
667 2 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested check if video is master");
668 :
669 2 : return m_mediaPipelineCapabilities->isVideoMaster(isVideoMaster);
670 : }
671 :
672 1 : std::vector<std::string> MediaPipelineService::getSupportedMimeTypes(MediaSourceType type)
673 : {
674 1 : return m_mediaPipelineCapabilities->getSupportedMimeTypes(type);
675 : }
676 :
677 1 : bool MediaPipelineService::isMimeTypeSupported(const std::string &mimeType)
678 : {
679 1 : return m_mediaPipelineCapabilities->isMimeTypeSupported(mimeType);
680 : }
681 :
682 1 : std::vector<std::string> MediaPipelineService::getSupportedProperties(MediaSourceType mediaType,
683 : const std::vector<std::string> &propertyNames)
684 : {
685 1 : return m_mediaPipelineCapabilities->getSupportedProperties(mediaType, propertyNames);
686 : }
687 :
688 2 : void MediaPipelineService::ping(const std::shared_ptr<IHeartbeatProcedure> &heartbeatProcedure)
689 : {
690 2 : RIALTO_SERVER_LOG_DEBUG("Ping requested");
691 2 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
692 3 : for (const auto &mediaPipelinePair : m_mediaPipelines)
693 : {
694 1 : auto &mediaPipeline = mediaPipelinePair.second;
695 1 : mediaPipeline->ping(heartbeatProcedure->createHandler());
696 : }
697 2 : }
698 :
699 : } // namespace firebolt::rialto::server::service
|
