LCOV - code coverage report
Current view: top level - media/client/main/source - MediaPipeline.cpp (source / functions) Coverage Total Hit
Test: coverage.info Lines: 88.3 % 453 400
Test Date: 2026-11-10 16:58:19 Functions: 91.4 % 70 64

            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 &currentVolume)
     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
        

Generated by: LCOV version 2.0-1