Seek fixes and improvements

Author: CastagnaIT

src/Session.cpp

@@ -911,10 +911,8 @@ bool SESSION::CSession::GetNextSample(ISampleReader*& sampleReader)
   return false;
 }
 
-bool SESSION::CSession::SeekTime(double seekTime, bool preceeding)
+bool SESSION::CSession::SeekTime(double seekTime, bool& isError, bool preceeding)
 {
-  bool ret{false};
-
   if (m_streams.empty())
     return false;
 
@@ -949,26 +947,14 @@ bool SESSION::CSession::SeekTime(double seekTime, bool preceeding)
 
   seekTime -= chapterTime;
 
-  // don't try to seek past the end of the stream, leave a sensible amount so we can buffer properly
   if (m_adaptiveTree->IsLive())
   {
-    double maxSeek{0};
-    uint64_t curTime;
-    uint64_t maxTime{0};
-    for (auto& stream : m_streams)
-    {
-      if (stream->IsEnabled() && (curTime = stream->m_adStream.getMaxTimeMs()) && curTime > maxTime)
-      {
-        maxTime = curTime;
-      }
-    }
+    double delayPtsSecs =
+        (static_cast<double>(GetMediaDurationMs()) / 1000) - m_adaptiveTree->m_liveDelay;
 
-    maxSeek = (static_cast<double>(maxTime) / 1000) - m_adaptiveTree->m_liveDelay;
-    if (maxSeek < 0)
-      maxSeek = 0;
-
-    if (seekTime > maxSeek)
-      seekTime = maxSeek;
+    // Check to avoid seek into live delay duration portion, to allow an appropriate live buffering
+    if (seekTime > delayPtsSecs)
+      seekTime = delayPtsSecs;
   }
 
   // Helper lambda to check if reader is started,
@@ -993,7 +979,7 @@ bool SESSION::CSession::SeekTime(double seekTime, bool preceeding)
   {
     if (!stream.m_adStream.seek_time(seekSecs))
     {
-      stream.GetReader()->Reset(true);
+      stream.GetReader()->Reset(false);
       return false;
     }
     if (!preceeding)
@@ -1057,17 +1043,22 @@ bool SESSION::CSession::SeekTime(double seekTime, bool preceeding)
       const double seekSecs{static_cast<double>(seekTimeCorrected - ptsDiff) / STREAM_TIME_BASE};
 
       if (!SeekAdStream(*stream, seekSecs, preceeding))
-        continue;
+        return false;
     }
 
     if (!CheckReaderRunning(*stream))
-      continue;
+      return false;
 
     streamReader->SetPTSDiff(ptsDiff);
 
     if (!streamReader->TimeSeek(seekTimeCorrected, preceeding))
     {
+      //! @todo: check whether we can better manage EOS on stream readers
+      //! if it fails for other reasons, we could avoid setting isError
+      //! to allow an attempt to restore playback to previous state (see PosTime method)
       streamReader->Reset(true);
+      isError = true;
+      return false;
     }
     else
     {
@@ -1085,11 +1076,9 @@ bool SESSION::CSession::SeekTime(double seekTime, bool preceeding)
         seekTimeCorrected = streamReader->PTS();
         preceeding = false;
       }
-      ret = true;
     }
   }
-
-  return ret;
+  return true;
 }
 
 void SESSION::CSession::OnDemuxRead()
@@ -1100,7 +1089,10 @@ void SESSION::CSession::OnDemuxRead()
 
     if (GetChapterSeekTime() > 0)
     {
-      SeekTime(GetChapterSeekTime());
+      bool isError{false};
+      if (!SeekTime(GetChapterSeekTime(), isError))
+        DeleteStreams();
+
       ResetChapterSeekTime();
     }
   }
@@ -1344,3 +1336,11 @@ PLAYLIST::CAdaptationSet* SESSION::CSession::DetermineDefaultAdpSet(PLAYLIST::CP
 
   return defaultAdp;
 }
+
+uint64_t SESSION::CSession::GetMediaDurationMs()
+{
+  if (!m_timingStream || !m_timingStream->IsEnabled())
+    return 0;
+
+  return m_timingStream->m_adStream.getMaxTimeMs();
+}

src/Session.h

@@ -147,14 +147,16 @@ class ATTR_DLL_LOCAL CSession : public adaptive::AdaptiveStreamObserver
    */
   void OnScreenResChange();
 
-  /*! \brief Seek streams and readers to a specified time
-   *  \param seekTime The seek time in seconds
-   *  \param preceeding True to seek to keyframe preceeding seektime,
-   *         false to clamp to the start of the next segment
-   *  \return True if seeking to another chapter or 1+ streams successfully
-   *          seeked, false on error or no streams seeked
+  /*!
+   * \brief Seek streams and readers to a specified time.
+   * \param seekTime The seek time in seconds.
+   * \param isError Cannot seek due to unrecoverable error,
+   *                in this case the method always return false.
+   * \param preceeding True to seek to keyframe preceeding seektime,
+   *                   false to clamp to the start of the next segment.
+   * \return True if the operation is successful (or seek through chapter/s), otherwise false
    */
-  bool SeekTime(double seekTime, bool preceeding = true);
+  bool SeekTime(double seekTime, bool& isError, bool preceeding = true);
 
   /*! \brief Report if the current content is dynamic/live
    *  \return True if live, false if VOD
@@ -264,6 +266,11 @@ class ATTR_DLL_LOCAL CSession : public adaptive::AdaptiveStreamObserver
    */
   PLAYLIST::CAdaptationSet* DetermineDefaultAdpSet(PLAYLIST::CPeriod* period);
 
+  /*!
+   * \brief Get the media duration in ms, based on segments.
+   */
+  uint64_t GetMediaDurationMs();
+
 private:
   DRM::CDRMEngine m_drmEngine;
 

src/common/AdaptiveStream.cpp

@@ -1135,25 +1135,21 @@ bool adaptive::AdaptiveStream::seek(uint64_t const pos, bool& isEos)
 
 uint64_t adaptive::AdaptiveStream::getMaxTimeMs()
 {
-  if (current_rep_->Timeline().IsEmpty())
+  const CSegment* lastSeg = current_rep_->Timeline().GetBack();
+  if (!lastSeg)
     return 0;
 
-  uint64_t duration{0};
-  if (current_rep_->Timeline().GetSize() > 1)
+  const uint64_t maxPts =
+      (lastSeg->m_endPts * current_rep_->timescale_ext_) / current_rep_->timescale_int_;
+
+  if (absolutePTSOffset_ > maxPts)
   {
-    duration =
-        current_rep_->Timeline().Get(current_rep_->Timeline().GetSize() - 1)->startPTS_ -
-        current_rep_->Timeline().Get(current_rep_->Timeline().GetSize() - 2)->startPTS_;
+    LOG::LogF(LOGERROR, "Absolute PTS offset (%llu) exceeds max PTS (%llu)", absolutePTSOffset_,
+              maxPts);
+    return 0;
   }
 
-  uint64_t timeExt = ((current_rep_->Timeline()
-                           .Get(current_rep_->Timeline().GetSize() - 1)
-                           ->startPTS_ +
-                       duration) *
-                      current_rep_->timescale_ext_) /
-                     current_rep_->timescale_int_;
-
-  return (timeExt - absolutePTSOffset_) / 1000;
+  return (maxPts - absolutePTSOffset_) / 1000;
 }
 
 void adaptive::AdaptiveStream::Disable()
@@ -1231,7 +1227,7 @@ bool adaptive::AdaptiveStream::seek_time(double seek_seconds)
   std::lock_guard<adaptive::AdaptiveTree::TreeUpdateThread> lckUpdTree(m_tree->GetTreeUpdMutex());
 
   const uint64_t pts = static_cast<uint64_t>(seek_seconds * current_rep_->GetTimescale());
-  const CSegment* seekSeg = current_rep_->Timeline().FindByPTSOrNext(pts);
+  const CSegment* seekSeg = current_rep_->Timeline().FindByNearestPTS(pts);
 
   if (!seekSeg)
     return false;

src/main.cpp

@@ -301,13 +301,6 @@ DEMUX_PACKET* CInputStreamAdaptive::DemuxRead(void)
   // since it can cause to reopen all streams, reset the check just before
   m_checkCoreReopen = false;
 
-  if (~m_failedSeekTime)
-  {
-    LOG::Log(LOGDEBUG, "Seeking to last failed seek position (%d)", m_failedSeekTime);
-    m_session->SeekTime(static_cast<double>(m_failedSeekTime) * 0.001f, false);
-    m_failedSeekTime = ~0;
-  }
-
   ISampleReader* sr{nullptr};
 
   if (m_session->GetNextSample(sr))
@@ -425,15 +418,36 @@ void CInputStreamAdaptive::SetVideoResolution(unsigned int width,
 
 bool CInputStreamAdaptive::PosTime(int ms)
 {
+  // Note: VP may require a seek (ms) even beyond the total duration of the media.
+  // Note: When you return false VP will continue to request packets with DemuxRead callbacks
+  // VP should expect to continue playback from the last PTS fed (as if the seek had not occurred)
+  // or you can stop playback by forcibly stop the packet feed from DemuxRead callbacks.
   if (!m_session)
     return false;
 
   LOG::Log(LOGINFO, "PosTime (%d)", ms);
 
-  bool ret = m_session->SeekTime(static_cast<double>(ms) * 0.001f, false);
-  m_failedSeekTime = ret ? ~0 : ms;
+  const uint64_t currentTimeMs = m_session->GetElapsedTimeMs();
+  bool isError{false};
+
+  if (m_session->SeekTime(static_cast<double>(ms) * 0.001f, isError, false))
+    return true;
+
+  if (!isError)
+  {
+    // If for some reason the seek operation fails without errors
+    // try to restore the streams/readers to previous (current) position
+    LOG::Log(LOGWARNING, "PosTime - Seek failed. Attempt to restore previous %llu ms position",
+             currentTimeMs);
 
-  return ret;
+    if (m_session->SeekTime(static_cast<double>(currentTimeMs) * 0.001f, isError, false))
+      return false; // returns false because the initially requested seek was unsuccessful
+  }
+
+  // A problem has occurred or EOS, force stop playback
+  LOG::Log(LOGDEBUG, "PosTime - Cannot seek at %d ms position.", ms);
+  m_session->DeleteStreams();
+  return false;
 }
 
 int CInputStreamAdaptive::GetTotalTime()

src/main.h

@@ -57,7 +57,6 @@ class ATTR_DLL_LOCAL CInputStreamAdaptive : public kodi::addon::CInstanceInputSt
 
 private:
   std::shared_ptr<SESSION::CSession> m_session;
-  int m_failedSeekTime = ~0;
 
   // The last PTS of the segment package fed to kodi.
   // NO_PTS_VALUE only when playback starts or a new period starts

src/samplereader/FragmentedSampleReader.cpp

@@ -311,7 +311,9 @@ bool CFragmentedSampleReader::TimeSeek(uint64_t pts, bool preceeding)
   AP4_Result result = m_lReader->SeekSample(m_track->GetId(), seekPos, sampleIndex, preceeding);
   if (AP4_FAILED(result))
   {
-    LOG::LogF(LOGERROR, "Cannot seek track id %u, error %i", m_track->GetId(), result);
+    if (result != AP4_ERROR_EOS)
+      LOG::LogF(LOGERROR, "Cannot seek track id %u, error %i", m_track->GetId(), result);
+
     return false;
   }