Feature/hdmi switch8.4 test

media/client/ipc/source/MediaKeysIpc.cpp

@@ -123,6 +123,10 @@ const char *toString(const firebolt::rialto::MediaKeyErrorStatus &errorStatus)
     {
         return "FAIL";
     }
+    case firebolt::rialto::MediaKeyErrorStatus::OUTPUT_RESTRICTED:
+    {
+        return "OUTPUT_RESTRICTED";
+    }
     }
     return "UNKNOWN";
 }
@@ -334,7 +338,7 @@ bool MediaKeysIpc::containsKey(int32_t keySessionId, const std::vector<uint8_t>
 }
 
 MediaKeyErrorStatus MediaKeysIpc::createKeySession(KeySessionType sessionType, std::weak_ptr<IMediaKeysClient> client,
-                                                   bool isLDL, int32_t &keySessionId)
+		 bool isLDL, int32_t &keySessionId)
 {
     if (!reattachChannelIfRequired())
     {
@@ -415,6 +419,7 @@ MediaKeyErrorStatus MediaKeysIpc::generateRequest(int32_t keySessionId, InitData
         break;
     }
 
+
     firebolt::rialto::GenerateRequestRequest request;
     request.set_media_keys_handle(m_mediaKeysHandle);
     request.set_key_session_id(keySessionId);

media/public/include/MediaCommon.h

@@ -292,7 +292,8 @@ enum class MediaKeyErrorStatus
     NOT_SUPPORTED,             /**< The request parameters are not supported. */
     INVALID_STATE,             /**< The object is in an invalid state for the operation. */
     INTERFACE_NOT_IMPLEMENTED, /**< The interface is not implemented. */
-    BUFFER_TOO_SMALL           /**< The size of the buffer is too small. */
+    BUFFER_TOO_SMALL,           /**< The size of the buffer is too small. */
+    OUTPUT_RESTRICTED
 };
 
 /**
@@ -473,6 +474,7 @@ struct PlaybackInfo
     int64_t currentPosition{-1}; /**< The current playback position */
     double volume{1.0};          /**< The current volume */
 };
+
 } // namespace firebolt::rialto
 
 #endif // FIREBOLT_RIALTO_MEDIA_COMMON_H_

media/server/ipc/source/MediaKeysModuleService.cpp

@@ -66,6 +66,10 @@ convertMediaKeyErrorStatus(const firebolt::rialto::MediaKeyErrorStatus &errorSta
     {
         return firebolt::rialto::ProtoMediaKeyErrorStatus::FAIL;
     }
+    case firebolt::rialto::MediaKeyErrorStatus::OUTPUT_RESTRICTED:
+    {
+        // TODO
+    }
     }
     return firebolt::rialto::ProtoMediaKeyErrorStatus::FAIL;
 }
@@ -100,6 +104,7 @@ firebolt::rialto::InitDataType covertInitDataType(firebolt::rialto::GenerateRequ
         return firebolt::rialto::InitDataType::UNKNOWN;
     }
 }
+
 } // namespace
 
 namespace firebolt::rialto::server::ipc
@@ -277,11 +282,12 @@ void MediaKeysModuleService::generateRequest(::google::protobuf::RpcController *
                                              ::google::protobuf::Closure *done)
 {
     RIALTO_SERVER_LOG_DEBUG("entry:");
-
     MediaKeyErrorStatus status = m_cdmService.generateRequest(request->media_keys_handle(), request->key_session_id(),
                                                               covertInitDataType(request->init_data_type()),
                                                               std::vector<std::uint8_t>{request->init_data().begin(),
                                                                                         request->init_data().end()});
+
+
     response->set_error_status(convertMediaKeyErrorStatus(status));
     done->Run();
 }

media/server/main/include/MediaKeysServerInternal.h

@@ -28,6 +28,9 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <atomic>
+#include <mutex>
+#include <condition_variable>
 
 namespace firebolt::rialto::server
 {
@@ -149,6 +152,15 @@ class MediaKeysServerInternal : public IMediaKeysServerInternal
      */
     uint32_t m_mainThreadClientId;
 
+
+    std::atomic_bool m_isShuttingDown{false};
+
+    std::atomic_bool m_outputWasRestricted{false};
+
+    std::atomic<GstClockTime> m_currentPositionPts{0};
+
+    std::atomic_bool m_hasCurrentPositionPts{false};
+
     /**
      * @brief Creates a session internally, only to be called on the main thread.
      *

media/server/main/source/MediaKeysCapabilities.cpp

@@ -47,6 +47,8 @@ const char *toString(const firebolt::rialto::MediaKeyErrorStatus &status)
         return "NOT_SUPPORTED";
     case firebolt::rialto::MediaKeyErrorStatus::INVALID_STATE:
         return "INVALID_STATE";
+    case firebolt::rialto::MediaKeyErrorStatus::OUTPUT_RESTRICTED:
+        return "OUTPUT_RESTRICTED";
     }
     return "Unknown";
 }

media/server/main/source/MediaKeysServerInternal.cpp

@@ -18,10 +18,40 @@
  */
 
 #include <stdexcept>
+#include <chrono>
+#include <thread>
 
 #include "MediaKeysServerInternal.h"
 #include "RialtoServerLogging.h"
 
+/*namespace
+{
+const char *toString(const firebolt::rialto::MediaKeyErrorStatus &status)
+{
+    switch (status)
+    {
+    case firebolt::rialto::MediaKeyErrorStatus::OK:
+        return "OK";
+    case firebolt::rialto::MediaKeyErrorStatus::FAIL:
+        return "FAIL";
+    case firebolt::rialto::MediaKeyErrorStatus::BAD_SESSION_ID:
+        return "BAD_SESSION_ID";
+    case firebolt::rialto::MediaKeyErrorStatus::INTERFACE_NOT_IMPLEMENTED:
+        return "INTERFACE_NOT_IMPLEMENTED";
+    case firebolt::rialto::MediaKeyErrorStatus::BUFFER_TOO_SMALL:
+        return "BUFFER_TOO_SMALL";
+    case firebolt::rialto::MediaKeyErrorStatus::NOT_SUPPORTED:
+        return "NOT_SUPPORTED";
+    case firebolt::rialto::MediaKeyErrorStatus::INVALID_STATE:
+        return "INVALID_STATE";
+    case firebolt::rialto::MediaKeyErrorStatus::OUTPUT_RESTRICTED:
+        return "OUTPUT_RESTRICTED";
+    }
+    return "Unknown";
+}
+} */// namespace
+
+
 namespace firebolt::rialto
 {
 const char *mediaKeyErrorStatusToString(const MediaKeyErrorStatus &status)
@@ -51,6 +81,10 @@ std::shared_ptr<IMediaKeysFactory> IMediaKeysFactory::createFactory()
 
 namespace firebolt::rialto::server
 {
+constexpr std::chrono::milliseconds kOutputRestrictedRetryInterval{250};
+constexpr std::chrono::seconds kOutputRestrictedRetryTimeout{6};
+constexpr GstClockTime kStaleThreshold{4 * GST_SECOND};
+
 int32_t generateSessionId()
 {
     static int32_t keySessionId{0};
@@ -140,12 +174,14 @@ MediaKeysServerInternal::MediaKeysServerInternal(
     {
         throw std::runtime_error("MediaKeys construction failed");
     }
+
+     m_outputWasRestricted = false;
 }
 
 MediaKeysServerInternal::~MediaKeysServerInternal()
 {
     RIALTO_SERVER_LOG_DEBUG("entry:");
-
+    m_isShuttingDown = true;
     auto task = [&]()
     {
         m_ocdmSystem.reset();
@@ -569,12 +605,83 @@ MediaKeyErrorStatus MediaKeysServerInternal::getCdmKeySessionIdInternal(int32_t
 
 MediaKeyErrorStatus MediaKeysServerInternal::decrypt(int32_t keySessionId, GstBuffer *encrypted, GstCaps *caps)
 {
-    RIALTO_SERVER_LOG_DEBUG("entry:");
+    RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE: entry:decrypt");
 
-    MediaKeyErrorStatus status;
-    auto task = [&]() { status = decryptInternal(keySessionId, encrypted, caps); };
+    MediaKeyErrorStatus status{MediaKeyErrorStatus::FAIL};
+
+    if (GST_BUFFER_PTS_IS_VALID(encrypted))
+    {
+        GstClockTime bufferPts = GST_BUFFER_PTS(encrypted);
+
+        if (!m_hasCurrentPositionPts.load() || bufferPts > m_currentPositionPts.load())
+        {
+            m_currentPositionPts = bufferPts;
+            m_hasCurrentPositionPts = true;
+        }
+
+        // After OUTPUT_RESTRICTED recovery, drop buffered segments that are behind live playback.
+        const GstClockTime currentPos = m_currentPositionPts.load();
+        if (m_outputWasRestricted.load() && m_hasCurrentPositionPts.load() && currentPos > bufferPts &&
+            (currentPos - bufferPts) > kStaleThreshold)
+        {
+            const double lagSeconds = static_cast<double>(currentPos - bufferPts) / GST_SECOND;
+            RIALTO_SERVER_LOG_WARN("Dropping stale segment (%.3fs behind) after HDCP recovery", lagSeconds);
+            return MediaKeyErrorStatus::OK; // Drop silently, pretend decrypt succeeded
+        }
+    }
+
+    const auto deadline = std::chrono::steady_clock::now() + kOutputRestrictedRetryTimeout;
+    do
+    {
+        auto task = [&]() { status = decryptInternal(keySessionId, encrypted, caps); };
+        m_mainThread->enqueueTaskAndWait(m_mainThreadClientId, task);
+	    RIALTO_SERVER_LOG_DEBUG("DEBUG PURPOSE : Key session id :%d", keySessionId);
+      /*  switch (status)
+        {
+	    case firebolt::rialto::MediaKeyErrorStatus::OK:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : OK");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::FAIL:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : FAIL");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::BAD_SESSION_ID:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : BAD_SESSION_ID");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::INTERFACE_NOT_IMPLEMENTED:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : INTERFACE_NOT_IMPLEMENTED");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::BUFFER_TOO_SMALL:
+	         RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : BUFFER_TOO_SMALL");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::NOT_SUPPORTED:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : NOT_SUPPORTED");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::INVALID_STATE:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : INVALID_STATE");
+		 break;
+	    case firebolt::rialto::MediaKeyErrorStatus::OUTPUT_RESTRICTED:
+        	 RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : Key session status : OUTPUT_RESTRICTED");
+		 break;
+    	}*/
+
+        if (status != MediaKeyErrorStatus::OUTPUT_RESTRICTED)
+        {
+            m_outputWasRestricted = false;
+            break;
+        }
+        m_outputWasRestricted = true;
+	    if (m_isShuttingDown.load())
+        {
+            RIALTO_SERVER_LOG_ERROR("Decrypt retry aborted — shutdown in progress");
+            break;
+        }
+
+        RIALTO_SERVER_LOG_WARN("Decrypt returned OUTPUT_RESTRICTED, retrying after delay");
+
+        std::this_thread::sleep_for(kOutputRestrictedRetryInterval);
+
+    } while (std::chrono::steady_clock::now() < deadline);
 
-    m_mainThread->enqueueTaskAndWait(m_mainThreadClientId, task);
     return status;
 }
 
@@ -604,12 +711,14 @@ bool MediaKeysServerInternal::isNetflixPlayreadyKeySystem() const
     return m_kKeySystem.find("netflix") != std::string::npos;
 }
 
+
 void MediaKeysServerInternal::ping(std::unique_ptr<IHeartbeatHandler> &&heartbeatHandler)
 {
-    RIALTO_SERVER_LOG_DEBUG("entry:");
+    RIALTO_SERVER_LOG_ERROR("entry:");
     auto task = [&]() { heartbeatHandler.reset(); };
 
-    m_mainThread->enqueueTaskAndWait(m_mainThreadClientId, task);
+    m_mainThread->enqueuePriorityTaskAndWait(m_mainThreadClientId, task);
+	RIALTO_SERVER_LOG_ERROR("exit:");
 }
 
 MediaKeyErrorStatus MediaKeysServerInternal::getMetricSystemData(std::vector<uint8_t> &buffer)

media/server/service/source/CdmService.cpp

@@ -492,16 +492,31 @@ bool CdmService::isServerCertificateSupported(const std::string &keySystem)
 
 MediaKeyErrorStatus CdmService::decrypt(int32_t keySessionId, GstBuffer *encrypted, GstCaps *caps)
 {
-    RIALTO_SERVER_LOG_DEBUG("CdmService requested to decrypt, key session id: %d", keySessionId);
 
+    IMediaKeysServerInternal *mediaKeys{nullptr};
+    {
+        std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
+        auto iter = m_sessionInfo.find(keySessionId);
+        if (iter == m_sessionInfo.end()) return MediaKeyErrorStatus::FAIL;
+        mediaKeys = m_mediaKeys[iter->second.mediaKeysHandle].get();
+        // Increment ref counter to prevent destruction while in use
+        ++iter->second.refCounter;
+    }
+    auto status = mediaKeys->decrypt(keySessionId, encrypted, caps);
+    decrementSessionIdUsageCounter(keySessionId);  // May trigger deferred release
+    return status;
+
+/*    RIALTO_SERVER_LOG_DEBUG("CdmService requested to decrypt, key session id: %d", keySessionId);
+
+    RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE : CdmService : decrypt entry");
     std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
     auto mediaKeysHandleIter{m_sessionInfo.find(keySessionId)};
     if (mediaKeysHandleIter == m_sessionInfo.end())
     {
         RIALTO_SERVER_LOG_ERROR("Media keys handle for mksId: %d does not exists", keySessionId);
         return MediaKeyErrorStatus::FAIL;
     }
-    return m_mediaKeys[mediaKeysHandleIter->second.mediaKeysHandle]->decrypt(keySessionId, encrypted, caps);
+    return m_mediaKeys[mediaKeysHandleIter->second.mediaKeysHandle]->decrypt(keySessionId, encrypted, caps);*/
 }
 
 bool CdmService::isNetflixPlayreadyKeySystem(int32_t keySessionId)
@@ -580,12 +595,28 @@ void CdmService::decrementSessionIdUsageCounter(int32_t keySessionId)
 
 void CdmService::ping(const std::shared_ptr<IHeartbeatProcedure> &heartbeatProcedure)
 {
-    std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
+
+    std::unique_lock<std::mutex> lock{m_mediaKeysMutex, std::try_to_lock};
+    if (!lock.owns_lock())
+    {
+        // Server is alive but busy in decrypt retry — acknowledge ping
+        RIALTO_SERVER_LOG_WARN("CdmService::ping - mutex busy (decrypt in progress), skipping CDM ping");
+        return;  // HeartbeatProcedure destructor sends success ack
+    }
+    for (const auto &mediaKeyPair : m_mediaKeys)
+    {
+        auto &mediaKeys = mediaKeyPair.second;
+        mediaKeys->ping(heartbeatProcedure->createHandler());
+    }
+
+    /*std::lock_guard<std::mutex> lock{m_mediaKeysMutex};
+    RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE: ping entry");
     for (const auto &mediaKeyPair : m_mediaKeys)
     {
         auto &mediaKeys = mediaKeyPair.second;
         mediaKeys->ping(heartbeatProcedure->createHandler());
     }
+    RIALTO_SERVER_LOG_ERROR("DEBUG PURPOSE: ping exit");*/
 }
 
 MediaKeyErrorStatus CdmService::getMetricSystemData(int mediaKeysHandle, std::vector<uint8_t> &buffer)

wrappers/CMakeLists.txt

@@ -110,6 +110,8 @@ target_include_directories(
 
         PRIVATE
         include
+        ../common/interface/
+        ../logging/include/
         ${GStreamerApp_INCLUDE_DIRS}
         $<TARGET_PROPERTY:RialtoPlayerPublic,INTERFACE_INCLUDE_DIRECTORIES>
         ${WRAPPER_INCLUDES}

wrappers/include/OcdmSession.h

@@ -94,6 +94,7 @@ class OcdmSession : public IOcdmSession
 private:
     using OcdmGstSessionDecryptExFn = OpenCDMError (*)(struct OpenCDMSession *, GstBuffer *, GstBuffer *,
                                                        const uint32_t, GstBuffer *, GstBuffer *, uint32_t, GstCaps *);
+    using OcdmGstSessionDecryptBufferOnceFn = OpenCDMError (*)(struct OpenCDMSession *, GstBuffer *, GstCaps *);
     /**
      * @brief The System handle.
      */
@@ -115,6 +116,7 @@ class OcdmSession : public IOcdmSession
     struct OpenCDMSession *m_session;
 
     static OcdmGstSessionDecryptExFn m_ocdmGstSessionDecryptEx;
+    static OcdmGstSessionDecryptBufferOnceFn m_ocdmGstSessionDecryptBufferOnce;
 
     /**
      * @brief Requests the processing of the challenge data.