others fixups

Author: CastagnaIT

src/decrypters/DrmEngine.cpp

@@ -77,6 +77,24 @@ std::shared_ptr<DRM::IDecrypter> CreateDRM(std::string_view keySystem)
   return drm;
 }
 
+/*!
+ * \brief Get a DRMInfo by Key System
+ * \param drmInfos The manifest DRM info
+ * \param keySystem The Key System to search
+ * \return The DRMInfo if found, otherwise nullptr
+ */
+DRM::DRMInfo* GetDRMInfoByKS(std::vector<DRM::DRMInfo>& drmInfos, std::string_view keySystem)
+{
+  // If no key system is provided its assumend CENC content compatible with any DRM
+  auto itDrmInfo = std::find_if(drmInfos.begin(), drmInfos.end(), [&](const DRMInfo& info)
+                                { return info.keySystem == keySystem || info.keySystem.empty(); });
+
+  if (itDrmInfo != drmInfos.end())
+    return &(*itDrmInfo);
+
+  return nullptr;
+}
+
 } // unnamed namespace
 
 void DRM::CDRMEngine::Initialize()
@@ -205,6 +223,21 @@ bool DRM::CDRMEngine::InitializeSession(std::vector<DRM::DRMInfo> drmInfos,
 
   ConfigureClearKey(drmInfos);
 
+  auto& kodiProps = CSrvBroker::GetKodiProps();
+
+  // This is a kind of hack,
+  // some services use manifests (usually SmoothStreaming) with PlayReady DRM only,
+  // but they have also a Widevine license server that allow to play same stream with Widevine,
+  // this will allow to force change the manifest DRMInfo KeySytem to Widevine and replace the init data
+  bool isPRtoWVKeySystem{false};
+  if (HasKeySystemSupport(KS_WIDEVINE) && drmInfos.size() == 1 &&
+      drmInfos[0].keySystem == KS_PLAYREADY && kodiProps.GetDrmConfigs().size() == 1 &&
+      kodiProps.HasDrmConfig(KS_WIDEVINE))
+  {
+    drmInfos[0].keySystem = KS_WIDEVINE;
+    isPRtoWVKeySystem = true;
+  }
+
   if (!SelectDRM(drmInfos))
   {
     LOG::LogF(LOGERROR, "The stream is encrypted with a DRM not supported by this system");
@@ -213,34 +246,35 @@ bool DRM::CDRMEngine::InitializeSession(std::vector<DRM::DRMInfo> drmInfos,
   }
 
   // Find a compatible DRM info
-  auto itDrmInfo = std::find_if(drmInfos.begin(), drmInfos.end(), [&](const DRMInfo& info) {
-    return info.keySystem == m_keySystem;});
+  auto pDrmInfo = GetDRMInfoByKS(drmInfos, m_keySystem);
 
-  if (itDrmInfo == drmInfos.end()) // Should not happens
+  if (!pDrmInfo)
   {
     LOG::LogF(LOGERROR, "The Key System \"%s\" does not match any DRMInfo", m_keySystem.c_str());
     m_status = EngineStatus::DRM_NOT_SUPPORTED;
     return false;
   }
 
-  DRM::DRMInfo& drmInfo = *itDrmInfo;
-  const auto drmPropCfg = CSrvBroker::GetKodiProps().GetDrmConfig(drmInfo.keySystem);
+  DRM::DRMInfo& drmInfo = *pDrmInfo;
+  const auto drmPropCfg = kodiProps.GetDrmConfig(m_keySystem);
 
   // Set custom init data PSSH provided from property,
   // can allow to initialize a DRM that could be also not specified
   // as supported in the manifest (e.g. missing DASH ContentProtection tags)
-  if (!drmPropCfg.initData.empty())
+  if (!drmPropCfg.initData.empty() || isPRtoWVKeySystem)
   {
     drmInfo.initData.clear();
-    LOG::Log(LOGDEBUG, "Custom init PSSH provided by the \"license\" property");
+
     std::vector<uint8_t> customInitData = BASE64::Decode(drmPropCfg.initData);
 
     if (DRM::IsValidPsshHeader(customInitData))
     {
+      LOG::Log(LOGDEBUG, "Use custom init PSSH provided by the \"license\" property");
       drmInfo.initData = customInitData;
     }
     else if (m_keySystem == DRM::KS_WIDEVINE) // Try to create a PSSH box, KID should be provided by manifest
     {
+      LOG::Log(LOGDEBUG, "Make a Widevine init PSSH to replace PlayReady init data");
       drmInfo.initData =
           DRM::PSSH::MakeWidevine({DRM::ConvertKidStrToBytes(drmInfo.defaultKid)}, customInitData);
     }
@@ -513,14 +547,10 @@ bool DRM::CDRMEngine::SelectDRM(std::vector<DRM::DRMInfo>& drmInfos)
   // the lower index have the higher priority
   for (const std::string& ks : m_supportedKs)
   {
-    auto itDrmInfo = std::find_if(drmInfos.begin(), drmInfos.end(), [&](const DRMInfo& info)
-                                  { return info.keySystem == ks || info.keySystem.empty(); });
+    const DRM::DRMInfo* drmInfo = GetDRMInfoByKS(drmInfos, ks);
 
-    if (itDrmInfo != drmInfos.end())
+    if (drmInfo)
     {
-      if (itDrmInfo->keySystem.empty())
-        itDrmInfo->keySystem = ks;
-
       m_keySystem = ks;
       break;
     }
@@ -637,6 +667,11 @@ void DRM::CDRMEngine::DeleteSessionsByType(const DRMMediaType mediaType)
                    m_sessions.end());
 }
 
+bool DRM::CDRMEngine::HasKeySystemSupport(std::string_view keySystem) const
+{
+  return std::find(m_supportedKs.cbegin(), m_supportedKs.cend(), keySystem) != m_supportedKs.cend();
+}
+
 void DRM::CDRMEngine::Dispose()
 {
   LOG::Log(LOGDEBUG, "Dispose DRM Engine");

src/decrypters/DrmEngine.h

@@ -108,6 +108,9 @@ class ATTR_DLL_LOCAL CDRMEngine
   // \brief Delete all sessions by media type
   void DeleteSessionsByType(const DRMMediaType type);
 
+  // \brief Check if a Key System is supported
+  bool HasKeySystemSupport(std::string_view keySystem) const;
+
   std::vector<std::string> m_supportedKs; // Supported key systems, the lower index has higher priority
   std::string m_keySystem; // Choosen key system
   std::map<std::string, std::shared_ptr<DRM::IDecrypter>> m_drms; // KeySystem - DRM instance