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 127 : MediaPipelineService::MediaPipelineService(
32 : IPlaybackService &playbackService, std::shared_ptr<IMediaPipelineServerInternalFactory> &&mediaPipelineFactory,
33 : std::shared_ptr<IMediaPipelineCapabilitiesFactory> &&mediaPipelineCapabilitiesFactory,
34 127 : IDecryptionService &decryptionService)
35 127 : : m_playbackService{playbackService}, m_mediaPipelineFactory{mediaPipelineFactory},
36 127 : m_mediaPipelineCapabilities{mediaPipelineCapabilitiesFactory->createMediaPipelineCapabilities()},
37 254 : m_decryptionService{decryptionService}
38 : {
39 127 : if (!m_mediaPipelineCapabilities)
40 : {
41 1 : throw std::runtime_error("Could not create Media Pipeline Capabilities");
42 : }
43 :
44 126 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is constructed");
45 130 : }
46 :
47 252 : MediaPipelineService::~MediaPipelineService()
48 : {
49 126 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService is destructed");
50 252 : }
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 81 : bool MediaPipelineService::createSession(int sessionId, const std::shared_ptr<IMediaPipelineClient> &mediaPipelineClient,
59 : std::uint32_t maxWidth, std::uint32_t maxHeight)
60 : {
61 81 : RIALTO_SERVER_LOG_DEBUG("MediaPipelineService requested to create new session with id: %d", sessionId);
62 81 : 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 80 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
70 80 : 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 79 : 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 78 : auto shmBuffer = m_playbackService.getShmBuffer();
81 78 : m_mediaPipelines.emplace(
82 156 : std::make_pair(sessionId,
83 234 : m_mediaPipelineFactory->createMediaPipelineServerInternal(mediaPipelineClient,
84 78 : VideoRequirements{maxWidth, maxHeight},
85 : sessionId, shmBuffer,
86 : m_decryptionService)));
87 78 : 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 81 : }
94 :
95 77 : RIALTO_SERVER_LOG_INFO("New session with id: %d created", sessionId);
96 77 : 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)
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();
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::getImmediateOutput(int sessionId, int32_t sourceId, bool &immediateOutput)
271 : {
272 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to getImmediateOutput, 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->getImmediateOutput(sourceId, immediateOutput);
282 3 : }
283 :
284 3 : bool MediaPipelineService::getStats(int sessionId, int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames)
285 : {
286 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to get stats, 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->getStats(sourceId, renderedFrames, droppedFrames);
296 3 : }
297 :
298 3 : bool MediaPipelineService::setVideoWindow(int sessionId, std::uint32_t x, std::uint32_t y, std::uint32_t width,
299 : std::uint32_t height)
300 : {
301 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to set video window, 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->setVideoWindow(x, y, width, height);
311 3 : }
312 :
313 3 : bool MediaPipelineService::haveData(int sessionId, MediaSourceStatus status, std::uint32_t numFrames,
314 : std::uint32_t needDataRequestId)
315 : {
316 3 : RIALTO_SERVER_LOG_DEBUG("New data available, 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->haveData(status, numFrames, needDataRequestId);
326 3 : }
327 :
328 3 : bool MediaPipelineService::renderFrame(int sessionId)
329 : {
330 3 : RIALTO_SERVER_LOG_DEBUG("Render frame requested, session id: %d", sessionId);
331 :
332 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
333 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
334 3 : if (mediaPipelineIter == m_mediaPipelines.end())
335 : {
336 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
337 1 : return false;
338 : }
339 2 : return mediaPipelineIter->second->renderFrame();
340 3 : }
341 3 : bool MediaPipelineService::setVolume(int sessionId, double targetVolume, uint32_t volumeDuration, EaseType easeType)
342 : {
343 3 : RIALTO_SERVER_LOG_DEBUG("Set volume requested, session id: %d", sessionId);
344 :
345 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
346 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
347 3 : if (mediaPipelineIter == m_mediaPipelines.end())
348 : {
349 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
350 1 : return false;
351 : }
352 2 : return mediaPipelineIter->second->setVolume(targetVolume, volumeDuration, easeType);
353 3 : }
354 :
355 3 : bool MediaPipelineService::getVolume(int sessionId, double &volume)
356 : {
357 3 : RIALTO_SERVER_LOG_DEBUG("Get volume requested, session id: %d", sessionId);
358 :
359 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
360 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
361 3 : if (mediaPipelineIter == m_mediaPipelines.end())
362 : {
363 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exists", sessionId);
364 1 : return false;
365 : }
366 2 : return mediaPipelineIter->second->getVolume(volume);
367 3 : }
368 :
369 3 : bool MediaPipelineService::setMute(int sessionId, std::int32_t sourceId, bool mute)
370 : {
371 3 : RIALTO_SERVER_LOG_DEBUG("Set mute 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 exist", sessionId);
378 1 : return false;
379 : }
380 2 : return mediaPipelineIter->second->setMute(sourceId, mute);
381 3 : }
382 :
383 3 : bool MediaPipelineService::getMute(int sessionId, std::int32_t sourceId, bool &mute)
384 : {
385 3 : RIALTO_SERVER_LOG_DEBUG("Get mute 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 exist", sessionId);
392 1 : return false;
393 : }
394 2 : return mediaPipelineIter->second->getMute(sourceId, mute);
395 3 : }
396 :
397 3 : bool MediaPipelineService::setTextTrackIdentifier(int sessionId, const std::string &textTrackIdentifier)
398 : {
399 3 : RIALTO_SERVER_LOG_DEBUG("Set text track identifier 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->setTextTrackIdentifier(textTrackIdentifier);
409 3 : }
410 :
411 3 : bool MediaPipelineService::getTextTrackIdentifier(int sessionId, std::string &textTrackIdentifier)
412 : {
413 3 : RIALTO_SERVER_LOG_DEBUG("Get text track identifier 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->getTextTrackIdentifier(textTrackIdentifier);
423 3 : }
424 :
425 3 : bool MediaPipelineService::setLowLatency(int sessionId, bool lowLatency)
426 : {
427 3 : RIALTO_SERVER_LOG_DEBUG("Set low latency 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->setLowLatency(lowLatency);
437 3 : }
438 :
439 3 : bool MediaPipelineService::setSync(int sessionId, bool sync)
440 : {
441 3 : RIALTO_SERVER_LOG_DEBUG("Set sync 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->setSync(sync);
451 3 : }
452 :
453 3 : bool MediaPipelineService::getSync(int sessionId, bool &sync)
454 : {
455 3 : RIALTO_SERVER_LOG_DEBUG("Get sync 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->getSync(sync);
465 3 : }
466 :
467 3 : bool MediaPipelineService::setSyncOff(int sessionId, bool syncOff)
468 : {
469 3 : RIALTO_SERVER_LOG_DEBUG("Set sync off 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->setSyncOff(syncOff);
479 3 : }
480 :
481 3 : bool MediaPipelineService::setStreamSyncMode(int sessionId, int32_t sourceId, int32_t streamSyncMode)
482 : {
483 3 : RIALTO_SERVER_LOG_DEBUG("Set stream sync mode 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->setStreamSyncMode(sourceId, streamSyncMode);
493 3 : }
494 :
495 3 : bool MediaPipelineService::getStreamSyncMode(int sessionId, int32_t &streamSyncMode)
496 : {
497 3 : RIALTO_SERVER_LOG_DEBUG("Get stream sync mode 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->getStreamSyncMode(streamSyncMode);
507 3 : }
508 :
509 3 : bool MediaPipelineService::flush(int sessionId, std::int32_t sourceId, bool resetTime)
510 : {
511 3 : RIALTO_SERVER_LOG_DEBUG("Flush 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->flush(sourceId, resetTime);
521 3 : }
522 :
523 3 : bool MediaPipelineService::setSourcePosition(int sessionId, int32_t sourceId, int64_t position, bool resetTime,
524 : double appliedRate, uint64_t stopPosition)
525 : {
526 3 : RIALTO_SERVER_LOG_DEBUG("Set Source Position 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->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
536 3 : }
537 :
538 3 : bool MediaPipelineService::processAudioGap(int sessionId, int64_t position, uint32_t duration, int64_t discontinuityGap,
539 : bool audioAac)
540 : {
541 3 : RIALTO_SERVER_LOG_DEBUG("Process Audio Gap 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->processAudioGap(position, duration, discontinuityGap, audioAac);
551 3 : }
552 :
553 3 : bool MediaPipelineService::setBufferingLimit(int sessionId, uint32_t limitBufferingMs)
554 : {
555 3 : RIALTO_SERVER_LOG_DEBUG("Set buffering limit requested, session id: %d", sessionId);
556 :
557 3 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
558 3 : auto mediaPipelineIter = m_mediaPipelines.find(sessionId);
559 3 : if (mediaPipelineIter == m_mediaPipelines.end())
560 : {
561 1 : RIALTO_SERVER_LOG_ERROR("Session with id: %d does not exist", sessionId);
562 1 : return false;
563 : }
564 2 : return mediaPipelineIter->second->setBufferingLimit(limitBufferingMs);
565 3 : }
566 :
567 3 : bool MediaPipelineService::getBufferingLimit(int sessionId, uint32_t &limitBufferingMs)
568 : {
569 3 : RIALTO_SERVER_LOG_DEBUG("Get buffering limit 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->getBufferingLimit(limitBufferingMs);
579 3 : }
580 :
581 3 : bool MediaPipelineService::setUseBuffering(int sessionId, bool useBuffering)
582 : {
583 3 : RIALTO_SERVER_LOG_DEBUG("Set use buffering 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->setUseBuffering(useBuffering);
593 3 : }
594 :
595 3 : bool MediaPipelineService::getUseBuffering(int sessionId, bool &useBuffering)
596 : {
597 3 : RIALTO_SERVER_LOG_DEBUG("Get use buffering 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->getUseBuffering(useBuffering);
607 3 : }
608 :
609 3 : bool MediaPipelineService::switchSource(int sessionId, const std::unique_ptr<IMediaPipeline::MediaSource> &source)
610 : {
611 3 : RIALTO_SERVER_LOG_INFO("MediaPipelineService requested to switch source, 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 exists", sessionId);
618 1 : return false;
619 : }
620 2 : return mediaPipelineIter->second->switchSource(source);
621 3 : }
622 :
623 1 : std::vector<std::string> MediaPipelineService::getSupportedMimeTypes(MediaSourceType type)
624 : {
625 1 : return m_mediaPipelineCapabilities->getSupportedMimeTypes(type);
626 : }
627 :
628 1 : bool MediaPipelineService::isMimeTypeSupported(const std::string &mimeType)
629 : {
630 1 : return m_mediaPipelineCapabilities->isMimeTypeSupported(mimeType);
631 : }
632 :
633 1 : std::vector<std::string> MediaPipelineService::getSupportedProperties(MediaSourceType mediaType,
634 : const std::vector<std::string> &propertyNames)
635 : {
636 1 : return m_mediaPipelineCapabilities->getSupportedProperties(mediaType, propertyNames);
637 : }
638 :
639 2 : void MediaPipelineService::ping(const std::shared_ptr<IHeartbeatProcedure> &heartbeatProcedure)
640 : {
641 2 : RIALTO_SERVER_LOG_DEBUG("Ping requested");
642 2 : std::lock_guard<std::mutex> lock{m_mediaPipelineMutex};
643 3 : for (const auto &mediaPipelinePair : m_mediaPipelines)
644 : {
645 1 : auto &mediaPipeline = mediaPipelinePair.second;
646 1 : mediaPipeline->ping(heartbeatProcedure->createHandler());
647 : }
648 2 : }
649 : } // namespace firebolt::rialto::server::service
|
