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 138 : MediaPipelineService::MediaPipelineService(
32 : IPlaybackService &playbackService, std::shared_ptr<IMediaPipelineServerInternalFactory> &&mediaPipelineFactory,
33 : std::shared_ptr<IMediaPipelineCapabilitiesFactory> &&mediaPipelineCapabilitiesFactory,
34 138 : IDecryptionService &decryptionService)
35 138 : : m_playbackService{playbackService}, m_mediaPipelineFactory{std::move(mediaPipelineFactory)},
36 138 : m_mediaPipelineCapabilities{mediaPipelineCapabilitiesFactory->createMediaPipelineCapabilities()},
37 276 : m_decryptionService{decryptionService}
38 : {
39 138 : if (!m_mediaPipelineCapabilities)
40 : {
41 1 : throw std::runtime_error("Could not create Media Pipeline Capabilities");
42 : }
43 :
44 137 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is constructed");
45 141 : }
46 :
47 274 : MediaPipelineService::~MediaPipelineService()
48 : {
49 137 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is destructed");
50 274 : }
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 89 : bool MediaPipelineService::createSession(int sessionId, const std::shared_ptr<IMediaPipelineClient> &mediaPipelineClient,
59 : std::uint32_t maxWidth, std::uint32_t maxHeight)
60 : {
61 89 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService requested to create new session with id: %d", sessionId);
62 89 : 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 88 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
70 88 : 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 87 : 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 86 : auto shmBuffer = m_playbackService.getShmBuffer();
81 86 : m_mediaPipelines.emplace(
82 172 : std::make_pair(sessionId,
83 258 : m_mediaPipelineFactory->createMediaPipelineServerInternal(mediaPipelineClient,
84 86 : VideoRequirements{maxWidth, maxHeight},
85 : sessionId, shmBuffer,
86 : m_decryptionService)));
87 86 : 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 89 : }
94 :
95 85 : RIALTO_SERVER_LOG_INFO("New session with id: %d created", sessionId);
96 85 : 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::setReportDecodeErrors(int sessionId, int32_t sourceId, bool reportDecodeErrors)
286 : {
287 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to setReportDecodeErrors, 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->setReportDecodeErrors(sourceId, reportDecodeErrors);
297 3 : }
298 :
299 3 : bool MediaPipelineService::getQueuedFrames(int sessionId, int32_t sourceId, uint32_t &queuedFrames)
300 : {
301 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to getQueuedFrames, 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->getQueuedFrames(sourceId, queuedFrames);
311 3 : }
312 :
313 3 : bool MediaPipelineService::getImmediateOutput(int sessionId, int32_t sourceId, bool &immediateOutput)
314 : {
315 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to getImmediateOutput, session id: %d", sessionId);
316 :
317 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
318 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
319 3 : if (mediaPipelineIter == m_mediaPipelines.end())
320 : {
321 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
322 1 : return false;
323 : }
324 2 : return mediaPipelineIter->second->getImmediateOutput(sourceId, immediateOutput);
325 3 : }
326 :
327 3 : bool MediaPipelineService::getStats(int sessionId, int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames)
328 : {
329 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to get stats, 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->getStats(sourceId, renderedFrames, droppedFrames);
339 3 : }
340 :
341 3 : bool MediaPipelineService::setVideoWindow(int sessionId, std::uint32_t x, std::uint32_t y, std::uint32_t width,
342 : std::uint32_t height)
343 : {
344 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to set video window, 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->setVideoWindow(x, y, width, height);
354 3 : }
355 :
356 3 : bool MediaPipelineService::haveData(int sessionId, MediaSourceStatus status, std::uint32_t numFrames,
357 : std::uint32_t needDataRequestId)
358 : {
359 3 : RIALTO_SERVER_LOG_DEBUG("New data available, session id: %d", sessionId);
360 :
361 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
362 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
363 3 : if (mediaPipelineIter == m_mediaPipelines.end())
364 : {
365 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
366 1 : return false;
367 : }
368 2 : return mediaPipelineIter->second->haveData(status, numFrames, needDataRequestId);
369 3 : }
370 :
371 3 : bool MediaPipelineService::renderFrame(int sessionId)
372 : {
373 3 : RIALTO_SERVER_LOG_DEBUG("Render frame requested, session id: %d", sessionId);
374 :
375 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
376 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
377 3 : if (mediaPipelineIter == m_mediaPipelines.end())
378 : {
379 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
380 1 : return false;
381 : }
382 2 : return mediaPipelineIter->second->renderFrame();
383 3 : }
384 3 : bool MediaPipelineService::setVolume(int sessionId, double targetVolume, uint32_t volumeDuration, EaseType easeType)
385 : {
386 3 : RIALTO_SERVER_LOG_DEBUG("Set volume 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 exists", sessionId);
393 1 : return false;
394 : }
395 2 : return mediaPipelineIter->second->setVolume(targetVolume, volumeDuration, easeType);
396 3 : }
397 :
398 3 : bool MediaPipelineService::getVolume(int sessionId, double &volume)
399 : {
400 3 : RIALTO_SERVER_LOG_DEBUG("Get volume 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 exists", sessionId);
407 1 : return false;
408 : }
409 2 : return mediaPipelineIter->second->getVolume(volume);
410 3 : }
411 :
412 3 : bool MediaPipelineService::setMute(int sessionId, std::int32_t sourceId, bool mute)
413 : {
414 3 : RIALTO_SERVER_LOG_DEBUG("Set mute 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->setMute(sourceId, mute);
424 3 : }
425 :
426 3 : bool MediaPipelineService::getMute(int sessionId, std::int32_t sourceId, bool &mute)
427 : {
428 3 : RIALTO_SERVER_LOG_DEBUG("Get mute 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->getMute(sourceId, mute);
438 3 : }
439 :
440 3 : bool MediaPipelineService::setTextTrackIdentifier(int sessionId, const std::string &textTrackIdentifier)
441 : {
442 3 : RIALTO_SERVER_LOG_DEBUG("Set text track identifier 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->setTextTrackIdentifier(textTrackIdentifier);
452 3 : }
453 :
454 3 : bool MediaPipelineService::getTextTrackIdentifier(int sessionId, std::string &textTrackIdentifier)
455 : {
456 3 : RIALTO_SERVER_LOG_DEBUG("Get text track identifier 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->getTextTrackIdentifier(textTrackIdentifier);
466 3 : }
467 :
468 3 : bool MediaPipelineService::setLowLatency(int sessionId, bool lowLatency)
469 : {
470 3 : RIALTO_SERVER_LOG_DEBUG("Set low latency 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->setLowLatency(lowLatency);
480 3 : }
481 :
482 3 : bool MediaPipelineService::setSync(int sessionId, bool sync)
483 : {
484 3 : RIALTO_SERVER_LOG_DEBUG("Set sync 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->setSync(sync);
494 3 : }
495 :
496 3 : bool MediaPipelineService::getSync(int sessionId, bool &sync)
497 : {
498 3 : RIALTO_SERVER_LOG_DEBUG("Get sync 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->getSync(sync);
508 3 : }
509 :
510 3 : bool MediaPipelineService::setSyncOff(int sessionId, bool syncOff)
511 : {
512 3 : RIALTO_SERVER_LOG_DEBUG("Set sync off 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->setSyncOff(syncOff);
522 3 : }
523 :
524 3 : bool MediaPipelineService::setStreamSyncMode(int sessionId, int32_t sourceId, int32_t streamSyncMode)
525 : {
526 3 : RIALTO_SERVER_LOG_DEBUG("Set stream sync mode 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->setStreamSyncMode(sourceId, streamSyncMode);
536 3 : }
537 :
538 3 : bool MediaPipelineService::getStreamSyncMode(int sessionId, int32_t &streamSyncMode)
539 : {
540 3 : RIALTO_SERVER_LOG_DEBUG("Get stream sync mode requested, session id: %d", sessionId);
541 :
542 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
543 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
544 3 : if (mediaPipelineIter == m_mediaPipelines.end())
545 : {
546 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
547 1 : return false;
548 : }
549 2 : return mediaPipelineIter->second->getStreamSyncMode(streamSyncMode);
550 3 : }
551 :
552 3 : bool MediaPipelineService::flush(int sessionId, std::int32_t sourceId, bool resetTime, bool &isAsync)
553 : {
554 3 : RIALTO_SERVER_LOG_DEBUG("Flush 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->flush(sourceId, resetTime, isAsync);
564 3 : }
565 :
566 3 : bool MediaPipelineService::setSourcePosition(int sessionId, int32_t sourceId, int64_t position, bool resetTime,
567 : double appliedRate, uint64_t stopPosition)
568 : {
569 3 : RIALTO_SERVER_LOG_DEBUG("Set Source Position requested, session id: %d", sessionId);
570 :
571 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
572 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
573 3 : if (mediaPipelineIter == m_mediaPipelines.end())
574 : {
575 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
576 1 : return false;
577 : }
578 2 : return mediaPipelineIter->second->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
579 3 : }
580 :
581 0 : bool MediaPipelineService::setSubtitleOffset(int sessionId, int32_t sourceId, int64_t position)
582 : {
583 0 : RIALTO_SERVER_LOG_DEBUG("Set Subtitle Offset requested, session id: %d", sessionId);
584 :
585 0 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
586 0 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
587 0 : if (mediaPipelineIter == m_mediaPipelines.end())
588 : {
589 0 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
590 0 : return false;
591 : }
592 0 : return mediaPipelineIter->second->setSubtitleOffset(sourceId, position);
593 : }
594 :
595 3 : bool MediaPipelineService::processAudioGap(int sessionId, int64_t position, uint32_t duration, int64_t discontinuityGap,
596 : bool audioAac)
597 : {
598 3 : RIALTO_SERVER_LOG_DEBUG("Process Audio Gap 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->processAudioGap(position, duration, discontinuityGap, audioAac);
608 3 : }
609 :
610 3 : bool MediaPipelineService::setBufferingLimit(int sessionId, uint32_t limitBufferingMs)
611 : {
612 3 : RIALTO_SERVER_LOG_DEBUG("Set buffering limit 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->setBufferingLimit(limitBufferingMs);
622 3 : }
623 :
624 3 : bool MediaPipelineService::getBufferingLimit(int sessionId, uint32_t &limitBufferingMs)
625 : {
626 3 : RIALTO_SERVER_LOG_DEBUG("Get buffering limit 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->getBufferingLimit(limitBufferingMs);
636 3 : }
637 :
638 3 : bool MediaPipelineService::setUseBuffering(int sessionId, bool useBuffering)
639 : {
640 3 : RIALTO_SERVER_LOG_DEBUG("Set use buffering requested, 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 exist", sessionId);
647 1 : return false;
648 : }
649 2 : return mediaPipelineIter->second->setUseBuffering(useBuffering);
650 3 : }
651 :
652 3 : bool MediaPipelineService::getUseBuffering(int sessionId, bool &useBuffering)
653 : {
654 3 : RIALTO_SERVER_LOG_DEBUG("Get use buffering requested, session id: %d", sessionId);
655 :
656 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
657 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
658 3 : if (mediaPipelineIter == m_mediaPipelines.end())
659 : {
660 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
661 1 : return false;
662 : }
663 2 : return mediaPipelineIter->second->getUseBuffering(useBuffering);
664 3 : }
665 :
666 3 : bool MediaPipelineService::switchSource(int sessionId, const std::unique_ptr<IMediaPipeline::MediaSource> &source)
667 : {
668 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to switch source, session id: %d", sessionId);
669 :
670 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
671 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
672 3 : if (mediaPipelineIter == m_mediaPipelines.end())
673 : {
674 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
675 1 : return false;
676 : }
677 2 : return mediaPipelineIter->second->switchSource(source);
678 3 : }
679 :
680 2 : bool MediaPipelineService::isVideoMaster(bool &isVideoMaster)
681 : {
682 2 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested check if video is master");
683 :
684 2 : return m_mediaPipelineCapabilities->isVideoMaster(isVideoMaster);
685 : }
686 :
687 1 : std::vector<std::string> MediaPipelineService::getSupportedMimeTypes(MediaSourceType type)
688 : {
689 1 : return m_mediaPipelineCapabilities->getSupportedMimeTypes(type);
690 : }
691 :
692 1 : bool MediaPipelineService::isMimeTypeSupported(const std::string &mimeType)
693 : {
694 1 : return m_mediaPipelineCapabilities->isMimeTypeSupported(mimeType);
695 : }
696 :
697 1 : std::vector<std::string> MediaPipelineService::getSupportedProperties(MediaSourceType mediaType,
698 : const std::vector<std::string> &propertyNames)
699 : {
700 1 : return m_mediaPipelineCapabilities->getSupportedProperties(mediaType, propertyNames);
701 : }
702 :
703 2 : void MediaPipelineService::ping(const std::shared_ptr<IHeartbeatProcedure> &heartbeatProcedure)
704 : {
705 2 : RIALTO_SERVER_LOG_DEBUG("Ping requested");
706 2 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
707 3 : for (const auto &mediaPipelinePair : m_mediaPipelines)
708 : {
709 1 : auto &mediaPipeline = mediaPipelinePair.second;
710 1 : mediaPipeline->ping(heartbeatProcedure->createHandler());
711 : }
712 2 : }
713 :
714 : } // namespace firebolt::rialto::server::service
|
