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