fixups

Author: CastagnaIT

src/CompKodiProps.cpp

@@ -737,11 +737,21 @@ bool ADP::KODI_PROPS::CCompKodiProps::ParseDrmConfig(const std::string& data)
       {
         for (auto& jPairUnwrap : jDictLic["unwrapper_params"].GetObject()) // Iterate JSON dict
         {
-          if (jPairUnwrap.name.IsString() && jPairUnwrap.value.IsString())
+          if (!jPairUnwrap.name.IsString() ||
+              !(jPairUnwrap.value.IsString() || jPairUnwrap.value.IsBool()))
           {
-            drmCfg.license.unwrapperParams.emplace(jPairUnwrap.name.GetString(),
-                                                   jPairUnwrap.value.GetString());
+            LOG::LogF(LOGERROR,
+                      "The license parameter \"unwrapper_params\" contains invalid values");
+            break;
           }
+
+          std::string value;
+          if (jPairUnwrap.value.IsString())
+            value = jPairUnwrap.value.GetString();
+          else if (jPairUnwrap.value.IsBool())
+            value = jPairUnwrap.value.GetBool() ? "true" : "false";
+
+          drmCfg.license.unwrapperParams.emplace(jPairUnwrap.name.GetString(), value);
         }
       }
 

src/CompKodiProps.h

@@ -49,8 +49,10 @@ struct Config
   bool curlSSLVerifyPeer{true};
   // Determines if cookies are internally handled by InputStream Adaptive add-on
   bool internalCookies{false};
+
   // Determines how HDCP should be checked
   HdcpCheckType hdcpCheck{HdcpCheckType::DEFAULT};
+
   // Force limit resolutions of manifest streams to the specified value included (value in px, height x width)
   int resolutionLimit{0};
 };

src/Session.cpp

@@ -52,6 +52,7 @@ void SESSION::CSession::DeleteStreams()
 {
   LOG::Log(LOGDEBUG, "CSession::DeleteStreams()");
   m_streams.clear();
+  m_timingStream = nullptr;
 }
 
 /*----------------------------------------------------------------------
@@ -134,32 +135,29 @@ bool SESSION::CSession::Initialize(std::string manifestUrl)
   return true;
 }
 
-void SESSION::CSession::CheckPlayableStreams()
+bool SESSION::CSession::CheckPlayableStreams()
 {
   auto& kodiPropCfg = CSrvBroker::GetKodiProps().GetConfig();
 
+  /*! @todo: Code commented, see todo below about: "Secure path on audio stream is not implemented"
+   *
   if (kodiPropCfg.resolutionLimit == 0 &&
       kodiPropCfg.hdcpCheck == ADP::KODI_PROPS::HdcpCheckType::DEFAULT)
   {
     return;
   }
-
+  */
   uint32_t adpIndex{0};
   CAdaptationSet* adp{nullptr};
 
   while ((adp = m_adaptiveTree->GetAdaptationSet(adpIndex++)))
   {
-    if (adp->GetStreamType() != StreamType::VIDEO)
-      continue;
-
     for (auto& repr : adp->GetRepresentations())
     {
-      // Note to HDCP check:
-      // HDCP check should be done by the DRM where in case of problems should block key's
-      // for example with Widevine you will get "output-restricted" to key status
-      // the following it's an additional check for custom manifest's
-      if (kodiPropCfg.hdcpCheck == ADP::KODI_PROPS::HdcpCheckType::LICENSE &&
-          !m_adaptiveTree->IsReqPrepareStream())
+      //! @todo: Code changed, see todo below about: "Secure path on audio stream is not implemented"
+      // if (kodiPropCfg.hdcpCheck == ADP::KODI_PROPS::HdcpCheckType::LICENSE &&
+      //     !m_adaptiveTree->IsReqPrepareStream())
+      if (!m_adaptiveTree->IsReqPrepareStream())
       {
         // The LICENSE method assume that a service provide in the license response the HDCP parameters
         // currently a comparison is made between the license HDCP values and the one provided by the manifest.
@@ -168,27 +166,68 @@ void SESSION::CSession::CheckPlayableStreams()
         if (!repr->DrmInfos().empty())
         {
           kodi::addon::InputstreamInfo isInfo;
-          if (m_drmEngine.InitializeSession(
-                  repr->DrmInfos(), DRM::DRMMediaType::VIDEO,
-                  m_adaptiveTree->m_currentPeriod->IsSecureDecodeNeeded(), isInfo, repr.get(), adp,
-                  false))
+          DRM::DRMInfo initDrmInfo;
+
+          if (m_drmEngine.InitializeSession(repr->DrmInfos(), DRM::DRMMediaType::VIDEO,
+                                            m_adaptiveTree->m_currentPeriod->IsSecureDecodeNeeded(),
+                                            isInfo, repr.get(), adp, false, initDrmInfo))
           {
             if (!isInfo.GetCryptoSession().GetSessionId().empty())
             {
-              const auto session = m_drmEngine.GetSession(isInfo.GetCryptoSession().GetSessionId());
+              const auto session = m_drmEngine.GetSession(isInfo.GetCryptoSession().GetSessionId(),
+                                                          initDrmInfo.defaultKid);
               if (session)
               {
-                const auto& caps = session->capabilities;
-
-                if (repr->GetHdcpVersion() > caps.hdcpVersion ||
-                    (caps.hdcpLimit > 0 && repr->GetWidth() * repr->GetHeight() > caps.hdcpLimit))
+                //! @todo: HACK REQUIRED BECAUSE ---> Secure path on audio stream is not implemented for CDM Widevine ONLY (non-android) <---
+                //! since audio streams that require Secure path decoder cannot be played
+                //! we have no way to distinguish which ones they are other than to do a KID test with the DRM for each stream,
+                //! this is an expensive method that could open many DRM sessions which will not be unused for playback.
+                //! When in a future this will be implemented, all this code should be cleanup and removed
+                //! and then leave it to CInputStreamAdaptive::OpenStream -> PrepareStream
+                //! the task to initialize DRM session only to the requested streams.
+                //! It can be tested e.g. with some Am@zon videos
+                auto& caps = session->capabilities;
+
+                if (!session->drm->IsSecureDecoderAudioSupported() &&
+                    adp->GetStreamType() == StreamType::AUDIO &&
+                    caps.flags & DRM::DecrypterCapabilites::SSD_SECURE_PATH)
                 {
-                  LOG::Log(LOGDEBUG, "Disabled stream repr ID \"%s\", AdpSet ID \"%s\", as not HDCP compliant",
+                  LOG::Log(LOGWARNING,
+                           "Disabled stream repr ID \"%s\", AdpSet ID \"%s\", "
+                           "Secure path decoder on audio stream is not supported",
                            repr->GetId().data(), adp->GetId().data());
                   repr->isPlayable = false;
+                  continue;
+                }
+
+                // Note to HDCP check:
+                // HDCP check should be done by the DRM where in case of problems should block key's
+                // for example with Widevine you will get "output-restricted" to key status
+                // the following it's an additional check for custom manifest's
+                if (kodiPropCfg.hdcpCheck == ADP::KODI_PROPS::HdcpCheckType::LICENSE)
+                {
+                  if (repr->GetHdcpVersion() > caps.hdcpVersion ||
+                      (caps.hdcpLimit > 0 && repr->GetWidth() * repr->GetHeight() > caps.hdcpLimit))
+                  {
+                    LOG::Log(
+                        LOGWARNING,
+                        "Disabled stream repr ID \"%s\", AdpSet ID \"%s\", as not HDCP compliant",
+                        repr->GetId().data(), adp->GetId().data());
+                    repr->isPlayable = false;
+                    continue;
+                  }
+
                 }
               }
-            } 
+            }
+          }
+          else
+          {
+            if (m_drmEngine.GetStatus() == DRM::EngineStatus::DRM_ERROR ||
+                m_drmEngine.GetStatus() == DRM::EngineStatus::DECRYPTER_ERROR)
+            {
+              return false; // return here, a bad status dont allow you to play streams
+            }
           }
         }
       }
@@ -200,14 +239,16 @@ void SESSION::CSession::CheckPlayableStreams()
       {
         if (repr->GetWidth() * repr->GetHeight() > kodiPropCfg.resolutionLimit)
         {
-          LOG::Log(LOGDEBUG,
+          LOG::Log(LOGWARNING,
                    "Disabled stream repr ID \"%s\", AdpSet ID \"%s\", it exceeds the resolution limits",
                    repr->GetId().data(), adp->GetId().data());
           repr->isPlayable = false;
         }
       }
     }
   }
+
+  return true;
 }
 
 void SESSION::CSession::InitializePeriod()
@@ -221,11 +262,13 @@ void SESSION::CSession::InitializePeriod()
 
   m_chapterStartTime = GetChapterStartTime();
 
-  CheckPlayableStreams(); // Note: this could initialize DRM on all streams right here, instead of OpenStream
-
   // Clean to create new SESSION::STREAM objects. One for each AdaptationSet/Representation
   m_streams.clear();
 
+  // Note: this could initialize DRM on all streams right here, instead of CInputStreamAdaptive::OpenStream
+  if (!CheckPlayableStreams())
+    return;
+
   uint32_t adpIndex{0};
   CAdaptationSet* adp{nullptr};
 
@@ -556,6 +599,8 @@ bool SESSION::CSession::PrepareStream(CStream* stream, uint64_t startPts)
     }
   }
 
+  DRM::DRMInfo initDrmInfo;
+
   if (!repr->DrmInfos().empty())
   {
     DRM::DRMMediaType drmMediaType{DRM::DRMMediaType::UNKNOWN};
@@ -573,7 +618,7 @@ bool SESSION::CSession::PrepareStream(CStream* stream, uint64_t startPts)
 
     if (!m_drmEngine.InitializeSession(repr->DrmInfos(), drmMediaType,
                                        period->IsSecureDecodeNeeded(), stream->m_info, repr, adp,
-                                       m_adaptiveTree->IsChangingPeriod()))
+                                       m_adaptiveTree->IsChangingPeriod(), initDrmInfo))
     {
       return false;
     }
@@ -589,7 +634,8 @@ bool SESSION::CSession::PrepareStream(CStream* stream, uint64_t startPts)
   if (!reader)
     return false;
 
-  const auto session = m_drmEngine.GetSession(stream->m_info.GetCryptoSession().GetSessionId());
+  const auto session = m_drmEngine.GetSession(stream->m_info.GetCryptoSession().GetSessionId(),
+                                              initDrmInfo.defaultKid);
 
   if (adp->GetStreamType() == StreamType::VIDEO || adp->GetStreamType() == StreamType::VIDEO_AUDIO)
   {
@@ -777,6 +823,9 @@ bool SESSION::CSession::SeekTime(double seekTime, unsigned int streamId, bool pr
 {
   bool ret{false};
 
+  if (m_streams.empty())
+    return false;
+
   //we don't have pts < 0 here and work internally with uint64
   if (seekTime < 0)
     seekTime = 0;
@@ -955,7 +1004,7 @@ void SESSION::CSession::OnStreamChange(adaptive::AdaptiveStream* adStream)
 
 bool SESSION::CSession::OnGetStream(int streamid, kodi::addon::InputstreamInfo& info)
 {
-  if (m_drmEngine.GetStatus() == DRM::EngineStatus::DRM_NOT_SUPPORTED ||
+  if (m_drmEngine.GetStatus() == DRM::EngineStatus::DRM_ERROR ||
       m_drmEngine.GetStatus() == DRM::EngineStatus::DECRYPTER_ERROR)
   {
     // If the stream is protected with a unsupported DRM, we have to stop the playback,

src/Session.h

@@ -38,7 +38,7 @@ class ATTR_DLL_LOCAL CSession : public adaptive::AdaptiveStreamObserver
    */
   bool Initialize(std::string manifestUrl);
 
-  void CheckPlayableStreams();
+  bool CheckPlayableStreams();
 
   /*!
    * \brief Initialize adaptive tree period