Merge pull request #1991 from CastagnaIT/fix_seek_end

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 SESSION::CSession::SeekTime(double seekTime, bool& isError)
 {
-  bool ret{false};
-
   if (m_streams.empty())
     return false;
 
@@ -949,26 +947,14 @@ bool SESSION::CSession::SeekTime(double seekTime)
 
   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;
-      }
-    }
-
-    maxSeek = (static_cast<double>(maxTime) / 1000) - m_adaptiveTree->m_liveDelay;
-    if (maxSeek < 0)
-      maxSeek = 0;
+    double delayPtsSecs =
+        (static_cast<double>(GetMediaDurationMs()) / 1000) - m_adaptiveTree->m_liveDelay;
 
-    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,
@@ -1023,12 +1009,18 @@ bool SESSION::CSession::SeekTime(double seekTime)
     const double seekSecs = static_cast<double>(seekTimeCorrected) / STREAM_TIME_BASE;
 
     if (!SeekAdStream(*m_timingStream, seekSecs))
+    {
+      isError = true;
       return false;
+    }
 
+    // Note: The following "running" check will download/read the package right now
+    // allowing you to read the PTS diff from stream reader
     if (!CheckReaderRunning(*m_timingStream))
       return false;
 
     ptsDiff = timingReader->GetPTSDiff();
+
     if (ptsDiff < 0 && seekTimeCorrected + ptsDiff > seekTimeCorrected)
       seekTimeCorrected = 0;
     else
@@ -1063,17 +1055,29 @@ bool SESSION::CSession::SeekTime(double seekTime)
       const double seekSecs{static_cast<double>(seekTimeCorrected - ptsDiff) / STREAM_TIME_BASE};
 
       if (!SeekAdStream(*stream, seekSecs))
-        continue;
+      {
+        if (stream->m_info.GetStreamType() == INPUTSTREAM_TYPE_SUBTITLE)
+          continue; // Subtitles failure should not block the seek operations
+
+        isError = true;
+        return false;
+      }
     }
 
     if (!CheckReaderRunning(*stream))
-      continue;
+      return false;
 
     streamReader->SetPTSDiff(ptsDiff);
 
     if (!streamReader->TimeSeek(seekTimeCorrected))
     {
       streamReader->Reset(true);
+
+      if (stream->m_info.GetStreamType() == INPUTSTREAM_TYPE_SUBTITLE)
+        continue; // Subtitles failure should not block the seek operations
+
+      isError = true;
+      return false;
     }
     else
     {
@@ -1085,16 +1089,20 @@ bool SESSION::CSession::SeekTime(double seekTime)
       LOG::Log(LOGINFO, "Seek time %0.1lf for stream: %i continues at %0.1lf (PTS: %llu)", seekTime,
                streamReader->GetStreamId(), destTime, streamReader->PTS());
 
+      // We replace the seek time PTS initially requested with the PTS of the video sample found
+      // in order to search the audio/subtitle sample packet more accurately.
+      // f.e. in the case of MP4 the video packet has very few sample sync points
+      // while the audio stream usually has many sample sync points, this cause a misalignment
+      // because for the video you will never find an exact sample for the requested PTS.
+      // Then get the nearest PTS found for the video, then align the audio/subtitles with it.
       if (stream->m_info.GetStreamType() == INPUTSTREAM_TYPE_VIDEO)
       {
         seekTime = destTime;
         seekTimeCorrected = streamReader->PTS();
       }
-      ret = true;
     }
   }
-
-  return ret;
+  return true;
 }
 
 void SESSION::CSession::OnDemuxRead()
@@ -1105,7 +1113,10 @@ void SESSION::CSession::OnDemuxRead()
 
     if (GetChapterSeekTime() > 0)
     {
-      SeekTime(GetChapterSeekTime());
+      bool isError{false};
+      if (!SeekTime(GetChapterSeekTime(), isError))
+        DeleteStreams();
+
       ResetChapterSeekTime();
     }
   }
@@ -1349,3 +1360,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,12 +147,14 @@ 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
-   *  \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.
+   * \return True if the operation is successful (or seek through chapter/s), otherwise false
    */
-  bool SeekTime(double seekTime);
+  bool SeekTime(double seekTime, bool& isError);
 
   /*! \brief Report if the current content is dynamic/live
    *  \return True if live, false if VOD
@@ -262,6 +264,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()

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);
-    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);
-  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))
+    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))
+      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/parser/DASHTree.cpp

@@ -1825,8 +1825,17 @@ void adaptive::CDashTree::GenerateTemplatedSegments(PLAYLIST::CSegmentTemplate&
 
   const uint64_t timeEnd = wndEnd * segTimescale / 1000;
 
-  // Create segments within time window
-  while (time + segDuration <= timeEnd && segNumber <= segNumberEnd)
+  // Create segments within time window,
+  // a segment that begins within the period and partially
+  // extends beyond the period boundaries must still be generated
+  //! @todo: currently when a segment extends beyond the period boundaries
+  //! it will exist also on next period, this will cause duplicate playback of the content (you can see also twice downloads)
+  //! in theory this should be fixed in the sample reader, where the sample packets of a segment
+  //! (at the beginning or end) must be filtered based on the duration of the period.
+  //! In other words, finish playing a segment early by skipping the samples that fall outside the period,
+  //! while in the next period, start playing the segment from a sample with a specific PTS,
+  //! thus skipping part of the initial samples.
+  while (time < timeEnd && segNumber <= segNumberEnd)
   {
     CSegment seg;
     seg.startPTS_ = time;

src/samplereader/ADTSSampleReader.cpp

@@ -63,5 +63,5 @@ bool CADTSSampleReader::TimeSeek(uint64_t pts)
     m_started = true;
     return AP4_SUCCEEDED(ReadSample());
   }
-  return AP4_ERROR_EOS;
+  return false; // EOS
 }

src/samplereader/FragmentedSampleReader.cpp

@@ -313,7 +313,9 @@ bool CFragmentedSampleReader::TimeSeek(uint64_t pts)
   AP4_Result result = m_lReader->SeekSample(m_track->GetId(), seekPos, sampleIndex);
   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;
   }
 

src/samplereader/TSSampleReader.cpp

@@ -113,5 +113,5 @@ bool CTSSampleReader::TimeSeek(uint64_t pts)
     m_started = true;
     return AP4_SUCCEEDED(ReadSample());
   }
-  return AP4_ERROR_EOS;
+  return false; // EOS
 }

src/samplereader/WebmSampleReader.cpp

@@ -67,5 +67,5 @@ bool CWebmSampleReader::TimeSeek(uint64_t pts)
     m_started = true;
     return AP4_SUCCEEDED(ReadSample());
   }
-  return AP4_ERROR_EOS;
+  return false; // EOS
 }