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