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 <inttypes.h>
21 : #include <stdexcept>
22 : #include <stdint.h>
23 :
24 : #include "KeyIdMap.h"
25 : #include "MediaPipeline.h"
26 : #include "MediaPipelineProxy.h"
27 : #include "RialtoClientLogging.h"
28 :
29 : namespace
30 : {
31 155 : const char *toString(const firebolt::rialto::client::MediaPipeline::State &state)
32 : {
33 155 : switch (state)
34 : {
35 49 : case firebolt::rialto::client::MediaPipeline::State::IDLE:
36 49 : return "IDLE";
37 8 : case firebolt::rialto::client::MediaPipeline::State::BUFFERING:
38 8 : return "BUFFERING";
39 72 : case firebolt::rialto::client::MediaPipeline::State::PLAYING:
40 72 : return "PLAYING";
41 8 : case firebolt::rialto::client::MediaPipeline::State::SEEKING:
42 8 : return "SEEKING";
43 8 : case firebolt::rialto::client::MediaPipeline::State::FAILURE:
44 8 : return "FAILURE";
45 10 : case firebolt::rialto::client::MediaPipeline::State::END_OF_STREAM:
46 10 : return "END_OF_STREAM";
47 : }
48 0 : return "UNKNOWN";
49 : }
50 :
51 68 : const char *toString(const firebolt::rialto::PlaybackState &state)
52 : {
53 68 : switch (state)
54 : {
55 1 : case firebolt::rialto::PlaybackState::IDLE:
56 1 : return "IDLE";
57 50 : case firebolt::rialto::PlaybackState::PLAYING:
58 50 : return "PLAYING";
59 0 : case firebolt::rialto::PlaybackState::PAUSED:
60 0 : return "PAUSED";
61 4 : case firebolt::rialto::PlaybackState::SEEKING:
62 4 : return "SEEKING";
63 3 : case firebolt::rialto::PlaybackState::SEEK_DONE:
64 3 : return "SEEK_DONE";
65 3 : case firebolt::rialto::PlaybackState::STOPPED:
66 3 : return "STOPPED";
67 4 : case firebolt::rialto::PlaybackState::END_OF_STREAM:
68 4 : return "END_OF_STREAM";
69 3 : case firebolt::rialto::PlaybackState::FAILURE:
70 3 : return "FAILURE";
71 0 : case firebolt::rialto::PlaybackState::UNKNOWN:
72 0 : return "UNKNOWN";
73 : }
74 0 : return "UNKNOWN";
75 : }
76 :
77 4 : const char *toString(const firebolt::rialto::NetworkState &state)
78 : {
79 4 : switch (state)
80 : {
81 1 : case firebolt::rialto::NetworkState::IDLE:
82 1 : return "IDLE";
83 3 : case firebolt::rialto::NetworkState::BUFFERING:
84 3 : return "BUFFERING";
85 0 : case firebolt::rialto::NetworkState::BUFFERING_PROGRESS:
86 0 : return "BUFFERING_PROGRESS";
87 0 : case firebolt::rialto::NetworkState::BUFFERED:
88 0 : return "BUFFERED";
89 0 : case firebolt::rialto::NetworkState::STALLED:
90 0 : return "STALLED";
91 0 : case firebolt::rialto::NetworkState::FORMAT_ERROR:
92 0 : return "FORMAT_ERROR";
93 0 : case firebolt::rialto::NetworkState::NETWORK_ERROR:
94 0 : return "NETWORK_ERROR";
95 0 : case firebolt::rialto::NetworkState::DECODE_ERROR:
96 0 : return "DECODE_ERROR";
97 0 : case firebolt::rialto::NetworkState::UNKNOWN:
98 0 : return "UNKNOWN";
99 : }
100 0 : return "UNKNOWN";
101 : }
102 : } // namespace
103 :
104 : namespace firebolt::rialto
105 : {
106 3 : std::shared_ptr<IMediaPipelineFactory> IMediaPipelineFactory::createFactory()
107 : {
108 3 : std::shared_ptr<IMediaPipelineFactory> factory;
109 :
110 : try
111 : {
112 3 : factory = std::make_shared<MediaPipelineFactory>();
113 : }
114 0 : catch (const std::exception &e)
115 : {
116 0 : RIALTO_CLIENT_LOG_ERROR("Failed to create the media player factory, reason: %s", e.what());
117 : }
118 :
119 3 : return factory;
120 : }
121 :
122 0 : std::unique_ptr<IMediaPipeline> MediaPipelineFactory::createMediaPipeline(std::weak_ptr<IMediaPipelineClient> client,
123 : const VideoRequirements &videoRequirements) const
124 : {
125 0 : return createMediaPipeline(client, videoRequirements, {}, {});
126 : }
127 :
128 : std::unique_ptr<IMediaPipeline>
129 3 : MediaPipelineFactory::createMediaPipeline(std::weak_ptr<IMediaPipelineClient> client,
130 : const VideoRequirements &videoRequirements,
131 : std::weak_ptr<client::IMediaPipelineIpcFactory> mediaPipelineIpcFactory,
132 : std::weak_ptr<client::IClientController> clientController) const
133 : {
134 3 : std::unique_ptr<IMediaPipeline> mediaPipeline;
135 : try
136 : {
137 3 : std::shared_ptr<client::IMediaPipelineIpcFactory> mediaPipelineIpcFactoryLocked = mediaPipelineIpcFactory.lock();
138 3 : std::shared_ptr<client::IClientController> clientControllerLocked = clientController.lock();
139 : firebolt::rialto::client::IClientController &cc =
140 3 : clientControllerLocked ? *clientControllerLocked
141 0 : : client::IClientControllerAccessor::instance().getClientController();
142 :
143 : auto mp{std::make_shared<client::MediaPipeline>(client, videoRequirements,
144 3 : mediaPipelineIpcFactoryLocked
145 7 : ? mediaPipelineIpcFactoryLocked
146 : : client::IMediaPipelineIpcFactory::getFactory(),
147 10 : common::IMediaFrameWriterFactory::getFactory(), cc)};
148 2 : mediaPipeline = std::move(std::make_unique<client::MediaPipelineProxy>(mp, cc));
149 6 : }
150 2 : catch (const std::exception &e)
151 : {
152 2 : RIALTO_CLIENT_LOG_ERROR("Failed to create the media player, reason: %s", e.what());
153 : }
154 :
155 3 : return mediaPipeline;
156 : }
157 :
158 : }; // namespace firebolt::rialto
159 :
160 : namespace firebolt::rialto::client
161 : {
162 5 : MediaPipelineProxy::MediaPipelineProxy(const std::shared_ptr<IMediaPipelineAndIControlClient> &mediaPipeline,
163 5 : IClientController &clientController)
164 5 : : m_mediaPipeline{mediaPipeline}, m_clientController{clientController}
165 : {
166 5 : ApplicationState state{ApplicationState::UNKNOWN};
167 5 : if (!m_clientController.registerClient(m_mediaPipeline, state))
168 : {
169 2 : throw std::runtime_error("Failed to register client with clientController");
170 : }
171 3 : m_mediaPipeline->notifyApplicationState(state);
172 7 : }
173 :
174 5 : MediaPipelineProxy::~MediaPipelineProxy()
175 : {
176 3 : if (!m_clientController.unregisterClient(m_mediaPipeline))
177 : {
178 0 : RIALTO_CLIENT_LOG_WARN("Failed to unregister client with clientController");
179 : }
180 5 : }
181 :
182 124 : MediaPipeline::MediaPipeline(std::weak_ptr<IMediaPipelineClient> client, const VideoRequirements &videoRequirements,
183 : const std::shared_ptr<IMediaPipelineIpcFactory> &mediaPipelineIpcFactory,
184 : const std::shared_ptr<common::IMediaFrameWriterFactory> &mediaFrameWriterFactory,
185 124 : IClientController &clientController)
186 372 : : m_mediaPipelineClient(client), m_clientController{clientController}, m_currentAppState{ApplicationState::UNKNOWN},
187 124 : m_mediaFrameWriterFactory(mediaFrameWriterFactory), m_currentState(State::IDLE), m_attachingSource(false)
188 : {
189 124 : RIALTO_CLIENT_LOG_DEBUG("entry:");
190 :
191 124 : m_mediaPipelineIpc = mediaPipelineIpcFactory->createMediaPipelineIpc(this, videoRequirements);
192 :
193 124 : if (!m_mediaPipelineIpc)
194 : {
195 2 : throw std::runtime_error("Media player ipc could not be created");
196 : }
197 :
198 122 : m_shmHandleObserverId = m_clientController.subscribeSharedMemoryHandle(
199 122 : [this](const std::shared_ptr<ISharedMemoryHandle> &handle)
200 : {
201 19 : std::lock_guard<std::mutex> lock{m_shmMutex};
202 19 : m_shmHandle = handle;
203 19 : });
204 140 : }
205 :
206 242 : MediaPipeline::~MediaPipeline()
207 : {
208 122 : RIALTO_CLIENT_LOG_DEBUG("entry:");
209 :
210 122 : m_clientController.unsubscribeSharedMemoryHandle(m_shmHandleObserverId);
211 122 : m_mediaPipelineIpc.reset();
212 242 : }
213 :
214 2 : bool MediaPipeline::load(MediaType type, const std::string &mimeType, const std::string &url, bool isLive)
215 : {
216 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
217 :
218 2 : return m_mediaPipelineIpc->load(type, mimeType, url, isLive);
219 : }
220 :
221 39 : bool MediaPipeline::attachSource(const std::unique_ptr<IMediaPipeline::MediaSource> &source)
222 : {
223 39 : RIALTO_CLIENT_LOG_DEBUG("entry:");
224 :
225 : // We should not process needDatas while attach source is ongoing
226 : {
227 39 : std::unique_lock<std::mutex> lock{m_attachSourceMutex};
228 39 : m_attachingSource = true;
229 : }
230 :
231 39 : int32_t sourceId = -1;
232 :
233 39 : bool status = m_mediaPipelineIpc->attachSource(source, sourceId);
234 39 : if (status)
235 : {
236 38 : source->setId(sourceId);
237 38 : m_attachedSources.add(sourceId, source->getType());
238 : }
239 :
240 : // Unblock needDatas
241 : {
242 39 : std::unique_lock<std::mutex> lock{m_attachSourceMutex};
243 39 : m_attachingSource = false;
244 39 : m_attachSourceCond.notify_all();
245 : }
246 39 : return status;
247 : }
248 :
249 5 : bool MediaPipeline::removeSource(int32_t id)
250 : {
251 5 : RIALTO_CLIENT_LOG_DEBUG("entry:");
252 5 : m_attachedSources.remove(id);
253 5 : return m_mediaPipelineIpc->removeSource(id);
254 : }
255 :
256 2 : bool MediaPipeline::allSourcesAttached()
257 : {
258 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
259 :
260 2 : return m_mediaPipelineIpc->allSourcesAttached();
261 : }
262 :
263 2 : bool MediaPipeline::play(bool &async)
264 : {
265 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
266 :
267 2 : return m_mediaPipelineIpc->play(async);
268 : }
269 :
270 2 : bool MediaPipeline::pause()
271 : {
272 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
273 :
274 2 : return m_mediaPipelineIpc->pause();
275 : }
276 :
277 0 : bool MediaPipeline::stop()
278 : {
279 0 : RIALTO_CLIENT_LOG_DEBUG("entry:");
280 :
281 0 : m_currentState = State::IDLE;
282 :
283 0 : return m_mediaPipelineIpc->stop();
284 : }
285 :
286 2 : bool MediaPipeline::setPlaybackRate(double rate)
287 : {
288 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
289 :
290 2 : return m_mediaPipelineIpc->setPlaybackRate(rate);
291 : }
292 :
293 7 : bool MediaPipeline::setPosition(int64_t position)
294 : {
295 7 : switch (m_currentState)
296 : {
297 5 : case State::PLAYING:
298 : case State::BUFFERING:
299 : case State::SEEKING:
300 : case State::END_OF_STREAM:
301 : {
302 5 : return handleSetPosition(position);
303 : }
304 2 : case State::IDLE:
305 : case State::FAILURE:
306 : default:
307 : {
308 2 : RIALTO_CLIENT_LOG_WARN("SetPosition received in unexpected state '%s'", toString(m_currentState));
309 2 : return false;
310 : }
311 : }
312 : }
313 :
314 2 : bool MediaPipeline::getPosition(int64_t &position)
315 : {
316 2 : return m_mediaPipelineIpc->getPosition(position);
317 : }
318 :
319 2 : bool MediaPipeline::setImmediateOutput(int32_t sourceId, bool immediateOutput)
320 : {
321 2 : return m_mediaPipelineIpc->setImmediateOutput(sourceId, immediateOutput);
322 : }
323 :
324 2 : bool MediaPipeline::setReportDecodeErrors(int32_t sourceId, bool reportDecodeErrors)
325 : {
326 2 : return m_mediaPipelineIpc->setReportDecodeErrors(sourceId, reportDecodeErrors);
327 : }
328 :
329 2 : bool MediaPipeline::getQueuedFrames(int32_t sourceId, uint32_t &queuedFrames)
330 : {
331 2 : return m_mediaPipelineIpc->getQueuedFrames(sourceId, queuedFrames);
332 : }
333 :
334 2 : bool MediaPipeline::getImmediateOutput(int32_t sourceId, bool &immediateOutput)
335 : {
336 2 : return m_mediaPipelineIpc->getImmediateOutput(sourceId, immediateOutput);
337 : }
338 :
339 2 : bool MediaPipeline::getStats(int32_t sourceId, uint64_t &renderedFrames, uint64_t &droppedFrames)
340 : {
341 2 : return m_mediaPipelineIpc->getStats(sourceId, renderedFrames, droppedFrames);
342 : }
343 :
344 5 : bool MediaPipeline::handleSetPosition(int64_t position)
345 : {
346 : // needData requests no longer valid
347 : {
348 5 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
349 5 : m_needDataRequestMap.clear();
350 : }
351 5 : return m_mediaPipelineIpc->setPosition(position);
352 : }
353 :
354 2 : bool MediaPipeline::setVideoWindow(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
355 : {
356 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
357 :
358 2 : return m_mediaPipelineIpc->setVideoWindow(x, y, width, height);
359 : }
360 :
361 27 : bool MediaPipeline::haveData(MediaSourceStatus status, uint32_t needDataRequestId)
362 : {
363 27 : RIALTO_CLIENT_LOG_DEBUG("entry:");
364 :
365 27 : switch (m_currentState)
366 : {
367 22 : case State::BUFFERING:
368 : case State::PLAYING:
369 : {
370 22 : return handleHaveData(status, needDataRequestId);
371 : }
372 2 : case State::SEEKING:
373 : {
374 2 : RIALTO_CLIENT_LOG_INFO("HaveData received while seeking, discarding NeedData request %u", needDataRequestId);
375 2 : discardNeedDataRequest(needDataRequestId);
376 2 : return true;
377 : }
378 3 : case State::IDLE:
379 : case State::END_OF_STREAM:
380 : case State::FAILURE:
381 : default:
382 : {
383 3 : RIALTO_CLIENT_LOG_WARN("HaveData received in unexpected state '%s', discarding NeedData request %u",
384 : toString(m_currentState), needDataRequestId);
385 3 : discardNeedDataRequest(needDataRequestId);
386 3 : return false;
387 : }
388 : }
389 : }
390 :
391 22 : bool MediaPipeline::handleHaveData(MediaSourceStatus status, uint32_t needDataRequestId)
392 : {
393 22 : RIALTO_CLIENT_LOG_DEBUG("entry:");
394 :
395 22 : std::shared_ptr<NeedDataRequest> needDataRequest;
396 :
397 : // Find the needDataRequest for this needDataRequestId
398 : // The needData request can be cancelled from another thread
399 : {
400 22 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
401 :
402 22 : auto needDataRequestIt = m_needDataRequestMap.find(needDataRequestId);
403 22 : if (needDataRequestIt == m_needDataRequestMap.end())
404 : {
405 : // Return success here as the data written is just ignored
406 19 : RIALTO_CLIENT_LOG_WARN("Could not find need data request, with id %u", needDataRequestId);
407 19 : return true;
408 : }
409 :
410 3 : needDataRequest = needDataRequestIt->second;
411 3 : m_needDataRequestMap.erase(needDataRequestIt);
412 22 : }
413 3 : if (m_attachedSources.isFlushing(needDataRequest->sourceId))
414 : {
415 0 : RIALTO_CLIENT_LOG_WARN("Source %d is flushing. Ignoring need data request, with id %u",
416 : needDataRequest->sourceId, needDataRequestId);
417 0 : return true;
418 : }
419 :
420 3 : uint32_t numFrames = needDataRequest->frameWriter ? needDataRequest->frameWriter->getNumFrames() : 0;
421 3 : return m_mediaPipelineIpc->haveData(status, numFrames, needDataRequestId);
422 22 : }
423 :
424 53 : AddSegmentStatus MediaPipeline::addSegment(uint32_t needDataRequestId, const std::unique_ptr<MediaSegment> &mediaSegment)
425 : {
426 53 : RIALTO_CLIENT_LOG_DEBUG("entry:");
427 :
428 53 : if (nullptr == mediaSegment || nullptr == mediaSegment->getData())
429 : {
430 2 : return AddSegmentStatus::ERROR;
431 : }
432 :
433 51 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
434 51 : auto needDataRequestIt = m_needDataRequestMap.find(needDataRequestId);
435 51 : if (needDataRequestIt == m_needDataRequestMap.end())
436 : {
437 0 : RIALTO_CLIENT_LOG_ERROR("Could not find need data request, with id %u", needDataRequestId);
438 0 : return AddSegmentStatus::ERROR;
439 : }
440 :
441 51 : std::shared_ptr<NeedDataRequest> needDataRequest = needDataRequestIt->second;
442 51 : std::shared_ptr<ISharedMemoryHandle> shmHandle;
443 : {
444 51 : std::lock_guard<std::mutex> shmLock{m_shmMutex};
445 51 : shmHandle = m_shmHandle;
446 : }
447 51 : if (nullptr == shmHandle || nullptr == shmHandle->getShm())
448 : {
449 2 : RIALTO_CLIENT_LOG_ERROR("Shared buffer no longer valid");
450 2 : return AddSegmentStatus::ERROR;
451 : }
452 :
453 : // This block of code is only for playready apps using rialto c++ interface
454 : // Widevine apps and playready apps using rialto-ocdm set MediaSegment::keyId earlier
455 49 : if (mediaSegment->isEncrypted())
456 : {
457 2 : auto keyId = KeyIdMap::instance().get(mediaSegment->getMediaKeySessionId());
458 2 : if (!keyId.empty() && mediaSegment->getKeyId().empty())
459 : {
460 1 : RIALTO_CLIENT_LOG_DEBUG("Adding Playready keyID to media segment");
461 1 : mediaSegment->setKeyId(keyId);
462 : }
463 2 : }
464 :
465 49 : if (!needDataRequest->frameWriter)
466 : {
467 17 : if (firebolt::rialto::MediaSourceType::UNKNOWN != mediaSegment->getType())
468 : {
469 16 : needDataRequest->frameWriter =
470 32 : m_mediaFrameWriterFactory->createFrameWriter(shmHandle->getShm(), needDataRequest->shmInfo);
471 : }
472 : else
473 : {
474 1 : RIALTO_CLIENT_LOG_ERROR("Unrecognised type %u", static_cast<uint32_t>(mediaSegment->getType()));
475 1 : return AddSegmentStatus::ERROR;
476 : }
477 :
478 16 : if (!needDataRequest->frameWriter)
479 : {
480 1 : RIALTO_CLIENT_LOG_ERROR("Could not create frame writer");
481 1 : return AddSegmentStatus::ERROR;
482 : }
483 : }
484 :
485 47 : return needDataRequest->frameWriter->writeFrame(mediaSegment);
486 51 : }
487 :
488 2 : bool MediaPipeline::renderFrame()
489 : {
490 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
491 2 : return m_mediaPipelineIpc->renderFrame();
492 : }
493 :
494 3 : bool MediaPipeline::setVolume(double targetVolume, uint32_t volumeDuration, EaseType easeType)
495 : {
496 3 : RIALTO_CLIENT_LOG_DEBUG("entry:");
497 3 : return m_mediaPipelineIpc->setVolume(targetVolume, volumeDuration, easeType);
498 : }
499 :
500 2 : bool MediaPipeline::getVolume(double ¤tVolume)
501 : {
502 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
503 2 : return m_mediaPipelineIpc->getVolume(currentVolume);
504 : }
505 :
506 2 : bool MediaPipeline::setMute(int32_t sourceId, bool mute)
507 : {
508 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
509 2 : return m_mediaPipelineIpc->setMute(sourceId, mute);
510 : }
511 :
512 2 : bool MediaPipeline::getMute(int32_t sourceId, bool &mute)
513 : {
514 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
515 2 : return m_mediaPipelineIpc->getMute(sourceId, mute);
516 : }
517 :
518 2 : bool MediaPipeline::setTextTrackIdentifier(const std::string &textTrackIdentifier)
519 : {
520 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
521 2 : return m_mediaPipelineIpc->setTextTrackIdentifier(textTrackIdentifier);
522 : }
523 :
524 2 : bool MediaPipeline::getTextTrackIdentifier(std::string &textTrackIdentifier)
525 : {
526 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
527 2 : return m_mediaPipelineIpc->getTextTrackIdentifier(textTrackIdentifier);
528 : }
529 :
530 2 : bool MediaPipeline::setLowLatency(bool lowLatency)
531 : {
532 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
533 2 : return m_mediaPipelineIpc->setLowLatency(lowLatency);
534 : }
535 :
536 2 : bool MediaPipeline::setSync(bool sync)
537 : {
538 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
539 2 : return m_mediaPipelineIpc->setSync(sync);
540 : }
541 :
542 2 : bool MediaPipeline::getSync(bool &sync)
543 : {
544 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
545 2 : return m_mediaPipelineIpc->getSync(sync);
546 : }
547 :
548 2 : bool MediaPipeline::setSyncOff(bool syncOff)
549 : {
550 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
551 2 : return m_mediaPipelineIpc->setSyncOff(syncOff);
552 : }
553 :
554 2 : bool MediaPipeline::setStreamSyncMode(int32_t sourceId, int32_t streamSyncMode)
555 : {
556 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
557 2 : return m_mediaPipelineIpc->setStreamSyncMode(sourceId, streamSyncMode);
558 : }
559 :
560 2 : bool MediaPipeline::getStreamSyncMode(int32_t &streamSyncMode)
561 : {
562 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
563 2 : return m_mediaPipelineIpc->getStreamSyncMode(streamSyncMode);
564 : }
565 :
566 7 : bool MediaPipeline::flush(int32_t sourceId, bool resetTime, bool &async)
567 : {
568 7 : RIALTO_CLIENT_LOG_DEBUG("entry:");
569 :
570 : {
571 7 : std::unique_lock<std::mutex> flushLock{m_flushMutex};
572 7 : if (!m_mediaPipelineIpc->flush(sourceId, resetTime, async))
573 : {
574 1 : return false;
575 : }
576 6 : m_attachedSources.setFlushing(sourceId, true);
577 7 : }
578 :
579 : // Clear all need datas for flushed source
580 6 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
581 8 : for (auto it = m_needDataRequestMap.begin(); it != m_needDataRequestMap.end();)
582 : {
583 2 : if (it->second->sourceId == sourceId)
584 : {
585 2 : it = m_needDataRequestMap.erase(it);
586 : }
587 : else
588 : {
589 0 : ++it;
590 : }
591 : }
592 6 : return true;
593 : }
594 :
595 2 : bool MediaPipeline::setSourcePosition(int32_t sourceId, int64_t position, bool resetTime, double appliedRate,
596 : uint64_t stopPosition)
597 : {
598 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
599 :
600 2 : return m_mediaPipelineIpc->setSourcePosition(sourceId, position, resetTime, appliedRate, stopPosition);
601 : }
602 :
603 2 : bool MediaPipeline::setSubtitleOffset(int32_t sourceId, int64_t position)
604 : {
605 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
606 :
607 2 : return m_mediaPipelineIpc->setSubtitleOffset(sourceId, position);
608 : }
609 :
610 2 : bool MediaPipeline::processAudioGap(int64_t position, uint32_t duration, int64_t discontinuityGap, bool audioAac)
611 : {
612 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
613 :
614 2 : return m_mediaPipelineIpc->processAudioGap(position, duration, discontinuityGap, audioAac);
615 : }
616 :
617 2 : bool MediaPipeline::setBufferingLimit(uint32_t limitBufferingMs)
618 : {
619 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
620 :
621 2 : return m_mediaPipelineIpc->setBufferingLimit(limitBufferingMs);
622 : }
623 :
624 2 : bool MediaPipeline::getBufferingLimit(uint32_t &limitBufferingMs)
625 : {
626 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
627 :
628 2 : return m_mediaPipelineIpc->getBufferingLimit(limitBufferingMs);
629 : }
630 :
631 2 : bool MediaPipeline::setUseBuffering(bool useBuffering)
632 : {
633 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
634 :
635 2 : return m_mediaPipelineIpc->setUseBuffering(useBuffering);
636 : }
637 :
638 2 : bool MediaPipeline::getUseBuffering(bool &useBuffering)
639 : {
640 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
641 :
642 2 : return m_mediaPipelineIpc->getUseBuffering(useBuffering);
643 : }
644 :
645 2 : bool MediaPipeline::switchSource(const std::unique_ptr<MediaSource> &source)
646 : {
647 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
648 :
649 2 : return m_mediaPipelineIpc->switchSource(source);
650 : }
651 :
652 2 : bool MediaPipeline::getDuration(int64_t &duration)
653 : {
654 2 : RIALTO_CLIENT_LOG_DEBUG("entry:");
655 :
656 2 : return m_mediaPipelineIpc->getDuration(duration);
657 : }
658 :
659 5 : void MediaPipeline::discardNeedDataRequest(uint32_t needDataRequestId)
660 : {
661 : // Find the needDataRequest for this needDataRequestId
662 : // The needData request can be cancelled from another thread
663 : {
664 5 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
665 :
666 5 : auto needDataRequestIt = m_needDataRequestMap.find(needDataRequestId);
667 5 : if (needDataRequestIt == m_needDataRequestMap.end())
668 : {
669 0 : RIALTO_CLIENT_LOG_INFO("Could not find need data request, with id %u", needDataRequestId);
670 : }
671 : else
672 : {
673 5 : RIALTO_CLIENT_LOG_INFO("Discarding need data request with id %u", needDataRequestId);
674 5 : m_needDataRequestMap.erase(needDataRequestIt);
675 : }
676 : }
677 : }
678 :
679 0 : std::weak_ptr<IMediaPipelineClient> MediaPipeline::getClient()
680 : {
681 0 : return m_mediaPipelineClient;
682 : }
683 :
684 4 : void MediaPipeline::updateState(NetworkState state)
685 : {
686 4 : State newState = m_currentState;
687 :
688 4 : switch (state)
689 : {
690 3 : case NetworkState::BUFFERING:
691 : case NetworkState::BUFFERING_PROGRESS:
692 : case NetworkState::STALLED:
693 : {
694 3 : newState = State::BUFFERING;
695 3 : break;
696 : }
697 0 : case NetworkState::FORMAT_ERROR:
698 : case NetworkState::NETWORK_ERROR:
699 : case NetworkState::DECODE_ERROR:
700 : {
701 0 : newState = State::FAILURE;
702 0 : break;
703 : }
704 1 : default:
705 : {
706 1 : break;
707 : }
708 : }
709 :
710 4 : RIALTO_CLIENT_LOG_DEBUG("Received network state '%s', old state '%s', new state '%s'", toString(state),
711 : toString(m_currentState), toString(newState));
712 4 : m_currentState = newState;
713 : }
714 :
715 68 : void MediaPipeline::updateState(PlaybackState state)
716 : {
717 68 : State newState = m_currentState;
718 :
719 68 : switch (state)
720 : {
721 50 : case PlaybackState::PLAYING:
722 : case PlaybackState::PAUSED:
723 : {
724 50 : newState = State::PLAYING;
725 50 : break;
726 : }
727 4 : case PlaybackState::SEEKING:
728 : {
729 4 : newState = State::SEEKING;
730 4 : break;
731 : }
732 3 : case PlaybackState::STOPPED:
733 : {
734 3 : newState = State::IDLE;
735 3 : break;
736 : }
737 3 : case PlaybackState::SEEK_DONE:
738 : {
739 3 : newState = State::BUFFERING;
740 3 : break;
741 : }
742 4 : case PlaybackState::END_OF_STREAM:
743 : {
744 4 : newState = State::END_OF_STREAM;
745 4 : break;
746 : }
747 3 : case PlaybackState::FAILURE:
748 : {
749 3 : newState = State::FAILURE;
750 3 : break;
751 : }
752 1 : default:
753 : {
754 1 : break;
755 : }
756 : }
757 :
758 68 : RIALTO_CLIENT_LOG_DEBUG("Received playback state '%s', old state '%s', new state '%s'", toString(state),
759 : toString(m_currentState), toString(newState));
760 68 : m_currentState = newState;
761 : }
762 :
763 68 : void MediaPipeline::notifyPlaybackState(PlaybackState state)
764 : {
765 68 : RIALTO_CLIENT_LOG_DEBUG("entry:");
766 :
767 68 : updateState(state);
768 :
769 68 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
770 68 : if (client)
771 : {
772 68 : client->notifyPlaybackState(state);
773 : }
774 : }
775 :
776 0 : void MediaPipeline::notifyPosition(int64_t position)
777 : {
778 0 : RIALTO_CLIENT_LOG_DEBUG("entry:");
779 :
780 0 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
781 0 : if (client)
782 : {
783 0 : client->notifyPosition(position);
784 : }
785 : }
786 :
787 4 : void MediaPipeline::notifyNetworkState(NetworkState state)
788 : {
789 4 : RIALTO_CLIENT_LOG_DEBUG("entry:");
790 :
791 4 : updateState(state);
792 :
793 4 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
794 4 : if (client)
795 : {
796 4 : client->notifyNetworkState(state);
797 : }
798 : }
799 :
800 49 : void MediaPipeline::notifyNeedMediaData(int32_t sourceId, size_t frameCount, uint32_t requestId,
801 : const std::shared_ptr<MediaPlayerShmInfo> &shmInfo)
802 : {
803 49 : RIALTO_CLIENT_LOG_DEBUG("entry:");
804 :
805 : // If attach source is ongoing wait till it has completed so that all sources are attached
806 : {
807 49 : std::unique_lock<std::mutex> lock{m_attachSourceMutex};
808 49 : if (m_attachingSource)
809 0 : m_attachSourceCond.wait(lock, [this] { return !m_attachingSource; });
810 49 : }
811 :
812 49 : if (MediaSourceType::UNKNOWN == m_attachedSources.getType(sourceId))
813 : {
814 2 : RIALTO_CLIENT_LOG_WARN("NeedMediaData received for unknown source %d, ignoring request id %u", sourceId,
815 : requestId);
816 2 : return;
817 : }
818 47 : if (m_attachedSources.isFlushing(sourceId))
819 : {
820 1 : RIALTO_CLIENT_LOG_WARN("NeedMediaData received for flushing source %d, ignoring request id %u", sourceId,
821 : requestId);
822 1 : return;
823 : }
824 :
825 46 : switch (m_currentState)
826 : {
827 39 : case State::BUFFERING:
828 : case State::PLAYING:
829 : {
830 39 : std::shared_ptr<NeedDataRequest> needDataRequest = std::make_shared<NeedDataRequest>();
831 39 : needDataRequest->sourceId = sourceId;
832 39 : needDataRequest->shmInfo = shmInfo;
833 :
834 : {
835 39 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
836 39 : if (ApplicationState::RUNNING != m_currentAppState)
837 : {
838 1 : RIALTO_CLIENT_LOG_INFO("NeedMediaData received in state != RUNNING, ignoring request id %u", requestId);
839 1 : break;
840 : }
841 38 : m_needDataRequestMap[requestId] = std::move(needDataRequest);
842 39 : }
843 :
844 38 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
845 38 : if (client)
846 : {
847 38 : client->notifyNeedMediaData(sourceId, frameCount, requestId, nullptr);
848 : }
849 :
850 38 : break;
851 39 : }
852 1 : case State::SEEKING:
853 : {
854 1 : RIALTO_CLIENT_LOG_INFO("NeedMediaData received while seeking, ignoring request id %u", requestId);
855 1 : break;
856 : }
857 6 : case State::IDLE:
858 : case State::END_OF_STREAM:
859 : case State::FAILURE:
860 : default:
861 : {
862 6 : RIALTO_CLIENT_LOG_WARN("NeedMediaData received in unexpected state '%s', ignoring request id %u",
863 : toString(m_currentState), requestId);
864 6 : break;
865 : }
866 : }
867 : }
868 :
869 121 : void MediaPipeline::notifyApplicationState(ApplicationState state)
870 : {
871 121 : RIALTO_CLIENT_LOG_DEBUG("entry:");
872 121 : std::lock_guard<std::mutex> lock{m_needDataRequestMapMutex};
873 121 : m_currentAppState = state;
874 121 : if (ApplicationState::RUNNING != state)
875 : {
876 : // If shared memory in use, wait for it to finish before returning
877 4 : m_needDataRequestMap.clear();
878 : }
879 121 : }
880 :
881 1 : void MediaPipeline::notifyQos(int32_t sourceId, const QosInfo &qosInfo)
882 : {
883 1 : RIALTO_CLIENT_LOG_DEBUG("entry:");
884 :
885 1 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
886 1 : if (client)
887 : {
888 1 : client->notifyQos(sourceId, qosInfo);
889 : }
890 : }
891 :
892 0 : void MediaPipeline::notifyBufferUnderflow(int32_t sourceId)
893 : {
894 0 : RIALTO_CLIENT_LOG_DEBUG("entry:");
895 :
896 0 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
897 0 : if (client)
898 : {
899 0 : client->notifyBufferUnderflow(sourceId);
900 : }
901 : }
902 :
903 1 : void MediaPipeline::notifyFirstFrameReceived(int32_t sourceId)
904 : {
905 1 : RIALTO_CLIENT_LOG_DEBUG("entry:");
906 :
907 1 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
908 1 : if (client)
909 : {
910 1 : client->notifyFirstFrameReceived(sourceId);
911 : }
912 : }
913 :
914 1 : void MediaPipeline::notifyPlaybackError(int32_t sourceId, PlaybackError error)
915 : {
916 1 : RIALTO_CLIENT_LOG_DEBUG("entry:");
917 :
918 1 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
919 1 : if (client)
920 : {
921 1 : client->notifyPlaybackError(sourceId, error);
922 : }
923 : }
924 :
925 4 : void MediaPipeline::notifySourceFlushed(int32_t sourceId)
926 : {
927 4 : RIALTO_CLIENT_LOG_DEBUG("entry:");
928 : {
929 4 : std::lock_guard<std::mutex> lock{m_flushMutex};
930 4 : m_attachedSources.setFlushing(sourceId, false);
931 : }
932 4 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
933 4 : if (client)
934 : {
935 4 : client->notifySourceFlushed(sourceId);
936 : }
937 :
938 4 : State expected = State::END_OF_STREAM;
939 4 : m_currentState.compare_exchange_strong(expected, State::BUFFERING);
940 : }
941 :
942 1 : void MediaPipeline::notifyPlaybackInfo(const PlaybackInfo &playbackInfo)
943 : {
944 1 : RIALTO_CLIENT_LOG_DEBUG("entry:");
945 :
946 1 : std::shared_ptr<IMediaPipelineClient> client = m_mediaPipelineClient.lock();
947 1 : if (client)
948 : {
949 1 : client->notifyPlaybackInfo(playbackInfo);
950 : }
951 : }
952 :
953 : }; // namespace firebolt::rialto::client
|