LCOV - code coverage report
Current view: top level - media/server/gstplayer/source/tasks/generic - HandleBusMessage.cpp (source / functions) Coverage Total Hit
Test: coverage.info Lines: 96.8 % 126 122
Test Date: 2025-10-17 11:07:32 Functions: 100.0 % 4 4

            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 "tasks/generic/HandleBusMessage.h"
      21              : #include "GenericPlayerContext.h"
      22              : #include "IGstGenericPlayerClient.h"
      23              : #include "IGstWrapper.h"
      24              : #include "RialtoServerLogging.h"
      25              : 
      26              : namespace firebolt::rialto::server::tasks::generic
      27              : {
      28           36 : HandleBusMessage::HandleBusMessage(GenericPlayerContext &context, IGstGenericPlayerPrivate &player,
      29              :                                    IGstGenericPlayerClient *client,
      30              :                                    const std::shared_ptr<firebolt::rialto::wrappers::IGstWrapper> &gstWrapper,
      31              :                                    const std::shared_ptr<firebolt::rialto::wrappers::IGlibWrapper> &glibWrapper,
      32           36 :                                    GstMessage *message, const IFlushWatcher &flushWatcher)
      33           36 :     : m_context{context}, m_player{player}, m_gstPlayerClient{client}, m_gstWrapper{gstWrapper},
      34           36 :       m_glibWrapper{glibWrapper}, m_message{message}, m_flushWatcher{flushWatcher},
      35           36 :       m_isFlushOngoingDuringCreation{flushWatcher.isFlushOngoing()},
      36           72 :       m_isAsyncFlushOngoingDuringCreation{flushWatcher.isAsyncFlushOngoing()}
      37              : {
      38           36 :     RIALTO_SERVER_LOG_DEBUG("Constructing HandleBusMessage");
      39              : }
      40              : 
      41           37 : HandleBusMessage::~HandleBusMessage()
      42              : {
      43           36 :     RIALTO_SERVER_LOG_DEBUG("HandleBusMessage finished");
      44           37 : }
      45              : 
      46           35 : void HandleBusMessage::execute() const
      47              : {
      48           35 :     RIALTO_SERVER_LOG_DEBUG("Executing HandleBusMessage");
      49           35 :     switch (GST_MESSAGE_TYPE(m_message))
      50              :     {
      51           14 :     case GST_MESSAGE_STATE_CHANGED:
      52              :     {
      53           14 :         if (m_context.pipeline && GST_MESSAGE_SRC(m_message) == GST_OBJECT(m_context.pipeline))
      54              :         {
      55              :             GstState oldState, newState, pending;
      56           12 :             m_gstWrapper->gstMessageParseStateChanged(m_message, &oldState, &newState, &pending);
      57           12 :             RIALTO_SERVER_LOG_MIL("State changed (old: %s, new: %s, pending: %s)",
      58              :                                   m_gstWrapper->gstElementStateGetName(oldState),
      59              :                                   m_gstWrapper->gstElementStateGetName(newState),
      60              :                                   m_gstWrapper->gstElementStateGetName(pending));
      61              : 
      62           24 :             std::string filename = std::string(m_gstWrapper->gstElementStateGetName(oldState)) + "-" +
      63           36 :                                    std::string(m_gstWrapper->gstElementStateGetName(newState));
      64           12 :             m_gstWrapper->gstDebugBinToDotFileWithTs(GST_BIN(m_context.pipeline), GST_DEBUG_GRAPH_SHOW_ALL,
      65              :                                                      filename.c_str());
      66           12 :             if (!m_gstPlayerClient)
      67              :             {
      68            1 :                 break;
      69              :             }
      70           11 :             switch (newState)
      71              :             {
      72            1 :             case GST_STATE_NULL:
      73              :             {
      74            1 :                 m_gstPlayerClient->notifyPlaybackState(PlaybackState::STOPPED);
      75            1 :                 break;
      76              :             }
      77            5 :             case GST_STATE_PAUSED:
      78              :             {
      79            5 :                 if (pending != GST_STATE_PAUSED)
      80              :                 {
      81              :                     // If async flush was requested before HandleBusMessage task creation (but it was not executed yet)
      82              :                     // or if async flush was created after HandleBusMessage task creation (but before its execution)
      83              :                     // we can't report playback state, because async flush causes state loss - reported state is probably invalid.
      84            4 :                     if (m_isAsyncFlushOngoingDuringCreation || m_flushWatcher.isAsyncFlushOngoing())
      85              :                     {
      86            2 :                         RIALTO_SERVER_LOG_WARN("Skip PAUSED notification - flush is ongoing");
      87            2 :                         break;
      88              :                     }
      89              :                     // newState==GST_STATE_PAUSED, pending==GST_STATE_PAUSED state transition is received as a result of
      90              :                     // waiting for preroll after seek.
      91              :                     // Subsequent newState==GST_STATE_PAUSED, pending!=GST_STATE_PAUSED transition will
      92              :                     // indicate that the pipeline is prerolled and it reached GST_STATE_PAUSED state after seek.
      93            2 :                     m_gstPlayerClient->notifyPlaybackState(PlaybackState::PAUSED);
      94              :                 }
      95            3 :                 if (m_player.hasSourceType(MediaSourceType::SUBTITLE))
      96              :                 {
      97            0 :                     m_player.stopSubtitleClockResyncTimer();
      98              :                 }
      99            3 :                 break;
     100              :             }
     101            5 :             case GST_STATE_PLAYING:
     102              :             {
     103              :                 // If async flush was requested before HandleBusMessage task creation (but it was not executed yet)
     104              :                 // or if async flush was created after HandleBusMessage task creation (but before its execution)
     105              :                 // we can't report playback state, because async flush causes state loss - reported state is probably invalid.
     106            5 :                 if (m_isAsyncFlushOngoingDuringCreation || m_flushWatcher.isAsyncFlushOngoing())
     107              :                 {
     108            2 :                     RIALTO_SERVER_LOG_WARN("Skip PLAYING notification - flush is ongoing");
     109            2 :                     break;
     110              :                 }
     111            3 :                 if (m_context.pendingPlaybackRate != kNoPendingPlaybackRate)
     112              :                 {
     113            1 :                     m_player.setPendingPlaybackRate();
     114              :                 }
     115            3 :                 m_player.startPositionReportingAndCheckAudioUnderflowTimer();
     116            3 :                 if (m_player.hasSourceType(MediaSourceType::SUBTITLE))
     117              :                 {
     118            0 :                     m_player.startSubtitleClockResyncTimer();
     119              :                 }
     120              : 
     121            3 :                 m_context.isPlaying = true;
     122            3 :                 m_gstPlayerClient->notifyPlaybackState(PlaybackState::PLAYING);
     123            3 :                 break;
     124              :             }
     125            0 :             case GST_STATE_VOID_PENDING:
     126              :             case GST_STATE_READY:
     127              :             {
     128            0 :                 break;
     129              :             }
     130              :             }
     131           12 :         }
     132           13 :         break;
     133              :     }
     134            6 :     case GST_MESSAGE_EOS:
     135              :     {
     136              :         // If flush was requested before HandleBusMessage task creation (but it was not executed yet)
     137              :         // or if flush was created after HandleBusMessage task creation (but before its execution)
     138              :         // we can't report EOS, because flush clears EOS.
     139            6 :         if (m_isFlushOngoingDuringCreation || m_flushWatcher.isFlushOngoing())
     140              :         {
     141            2 :             RIALTO_SERVER_LOG_WARN("Skip EOS notification - flush is ongoing");
     142            2 :             break;
     143              :         }
     144            4 :         if (m_context.pipeline && GST_MESSAGE_SRC(m_message) == GST_OBJECT(m_context.pipeline))
     145              :         {
     146            2 :             RIALTO_SERVER_LOG_MIL("End of stream reached.");
     147            2 :             if (!m_context.eosNotified && m_gstPlayerClient)
     148              :             {
     149            1 :                 m_gstPlayerClient->notifyPlaybackState(PlaybackState::END_OF_STREAM);
     150            1 :                 m_context.eosNotified = true;
     151              :             }
     152              :         }
     153            4 :         break;
     154              :     }
     155            4 :     case GST_MESSAGE_QOS:
     156              :     {
     157              :         GstFormat format;
     158            4 :         gboolean isLive = FALSE;
     159            4 :         guint64 runningTime = 0;
     160            4 :         guint64 streamTime = 0;
     161            4 :         guint64 timestamp = 0;
     162            4 :         guint64 duration = 0;
     163            4 :         guint64 dropped = 0;
     164            4 :         guint64 processed = 0;
     165              : 
     166            4 :         m_gstWrapper->gstMessageParseQos(m_message, &isLive, &runningTime, &streamTime, &timestamp, &duration);
     167            4 :         m_gstWrapper->gstMessageParseQosStats(m_message, &format, &processed, &dropped);
     168              : 
     169            4 :         if (GST_FORMAT_BUFFERS == format || GST_FORMAT_DEFAULT == format)
     170              :         {
     171            3 :             RIALTO_SERVER_LOG_INFO("QOS message: runningTime  %" G_GUINT64_FORMAT ", streamTime %" G_GUINT64_FORMAT
     172              :                                    ", timestamp %" G_GUINT64_FORMAT ", duration %" G_GUINT64_FORMAT
     173              :                                    ", format %u, processed %" G_GUINT64_FORMAT ", dropped %" G_GUINT64_FORMAT,
     174              :                                    runningTime, streamTime, timestamp, duration, format, processed, dropped);
     175              : 
     176            3 :             if (m_gstPlayerClient)
     177              :             {
     178            3 :                 firebolt::rialto::QosInfo qosInfo = {processed, dropped};
     179              :                 const gchar *klass;
     180            3 :                 klass = m_gstWrapper->gstElementClassGetMetadata(GST_ELEMENT_GET_CLASS(GST_MESSAGE_SRC(m_message)),
     181              :                                                                  GST_ELEMENT_METADATA_KLASS);
     182              : 
     183            3 :                 if (g_strrstr(klass, "Video"))
     184              :                 {
     185            1 :                     m_gstPlayerClient->notifyQos(firebolt::rialto::MediaSourceType::VIDEO, qosInfo);
     186              :                 }
     187            2 :                 else if (g_strrstr(klass, "Audio"))
     188              :                 {
     189            1 :                     m_gstPlayerClient->notifyQos(firebolt::rialto::MediaSourceType::AUDIO, qosInfo);
     190              :                 }
     191              :                 else
     192              :                 {
     193            1 :                     RIALTO_SERVER_LOG_WARN("Unknown source type for class '%s', ignoring QOS Message", klass);
     194              :                 }
     195              :             }
     196            3 :         }
     197              :         else
     198              :         {
     199            1 :             RIALTO_SERVER_LOG_WARN("Received a QOS_MESSAGE with unhandled format %s",
     200              :                                    m_gstWrapper->gstFormatGetName(format));
     201              :         }
     202            4 :         break;
     203              :     }
     204            6 :     case GST_MESSAGE_ERROR:
     205              :     {
     206            6 :         GError *err = nullptr;
     207            6 :         gchar *debug = nullptr;
     208            6 :         m_gstWrapper->gstMessageParseError(m_message, &err, &debug);
     209              : 
     210            6 :         if ((err->domain == GST_STREAM_ERROR) && (allSourcesEos()))
     211              :         {
     212            2 :             RIALTO_SERVER_LOG_WARN("Got stream error from %s. But all streams are ended, so reporting EOS. Error code "
     213              :                                    "%d: %s "
     214              :                                    "(%s).",
     215              :                                    GST_OBJECT_NAME(GST_MESSAGE_SRC(m_message)), err->code, err->message, debug);
     216            2 :             if (!m_context.eosNotified && m_gstPlayerClient)
     217              :             {
     218            1 :                 m_gstPlayerClient->notifyPlaybackState(PlaybackState::END_OF_STREAM);
     219            1 :                 m_context.eosNotified = true;
     220              :             }
     221              :         }
     222              :         else
     223              :         {
     224            4 :             RIALTO_SERVER_LOG_ERROR("Error from %s - %d: %s (%s)", GST_OBJECT_NAME(GST_MESSAGE_SRC(m_message)),
     225              :                                     err->code, err->message, debug);
     226            4 :             m_gstPlayerClient->notifyPlaybackState(PlaybackState::FAILURE);
     227              :         }
     228              : 
     229            6 :         m_glibWrapper->gFree(debug);
     230            6 :         m_glibWrapper->gErrorFree(err);
     231            6 :         break;
     232              :     }
     233            4 :     case GST_MESSAGE_WARNING:
     234              :     {
     235            4 :         PlaybackError rialtoError = PlaybackError::UNKNOWN;
     236            4 :         GError *err = nullptr;
     237            4 :         gchar *debug = nullptr;
     238            4 :         m_gstWrapper->gstMessageParseWarning(m_message, &err, &debug);
     239              : 
     240            4 :         if ((err->domain == GST_STREAM_ERROR) && (err->code == GST_STREAM_ERROR_DECRYPT))
     241              :         {
     242            3 :             RIALTO_SERVER_LOG_WARN("Decrypt error %s - %d: %s (%s)", GST_OBJECT_NAME(GST_MESSAGE_SRC(m_message)),
     243              :                                    err->code, err->message, debug);
     244            3 :             rialtoError = PlaybackError::DECRYPTION;
     245              :         }
     246              :         else
     247              :         {
     248            1 :             RIALTO_SERVER_LOG_WARN("Unknown warning, ignoring %s - %d: %s (%s)",
     249              :                                    GST_OBJECT_NAME(GST_MESSAGE_SRC(m_message)), err->code, err->message, debug);
     250              :         }
     251              : 
     252            4 :         if ((PlaybackError::UNKNOWN != rialtoError) && (m_gstPlayerClient))
     253              :         {
     254            3 :             const gchar *kName = GST_ELEMENT_NAME(GST_ELEMENT(GST_MESSAGE_SRC(m_message)));
     255            3 :             if (g_strrstr(kName, "video"))
     256              :             {
     257            1 :                 m_gstPlayerClient->notifyPlaybackError(firebolt::rialto::MediaSourceType::VIDEO,
     258              :                                                        PlaybackError::DECRYPTION);
     259              :             }
     260            2 :             else if (g_strrstr(kName, "audio"))
     261              :             {
     262            1 :                 m_gstPlayerClient->notifyPlaybackError(firebolt::rialto::MediaSourceType::AUDIO,
     263              :                                                        PlaybackError::DECRYPTION);
     264              :             }
     265              :             else
     266              :             {
     267            1 :                 RIALTO_SERVER_LOG_WARN("Unknown source type for element '%s', not propagating error", kName);
     268              :             }
     269              :         }
     270              : 
     271            4 :         m_glibWrapper->gFree(debug);
     272            4 :         m_glibWrapper->gErrorFree(err);
     273            4 :         break;
     274              :     }
     275            1 :     default:
     276            1 :         break;
     277              :     }
     278              : 
     279           35 :     m_gstWrapper->gstMessageUnref(m_message);
     280              : }
     281              : 
     282            4 : bool HandleBusMessage::allSourcesEos() const
     283              : {
     284            8 :     for (const auto &streamInfo : m_context.streamInfo)
     285              :     {
     286            6 :         const auto eosInfoIt = m_context.endOfStreamInfo.find(streamInfo.first);
     287            6 :         if (eosInfoIt == m_context.endOfStreamInfo.end() || eosInfoIt->second != EosState::SET)
     288              :         {
     289            2 :             return false;
     290              :         }
     291              :     }
     292            2 :     return true;
     293              : }
     294              : } // namespace firebolt::rialto::server::tasks::generic
        

Generated by: LCOV version 2.0-1