Ticket #13176: 20171120_#13176_mythplayer-Fix-issues-with-vsync2.patch

mythtv/libs/libmythtv/mythplayer.cpp

@@ -816 +816 @@
         if (ffrew_skip != 0 && ffrew_skip != 1)
         {
             UpdateFFRewSkip();
-            videosync->setFrameInterval(frame_interval);
         }
         else
         {
@@ -1890 +1889 @@
 
     if (avsync_predictor_enabled)
     {
-        avsync_predictor += frame_interval;
+        avsync_predictor += frame_interval + avsync_adjustment + repeat_delay;
         if (avsync_predictor >= refreshrate)
         {
             int refreshperiodsinframe = avsync_predictor/refreshrate;
@@ -1956 +1955 @@
             LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO,
                 LOC + QString("AVSync waitforframe %1 %2")
                     .arg(avsync_adjustment).arg(m_double_framerate));
-            vsync_delay_clock = videosync->WaitForFrame
-                                (frameDelay + avsync_adjustment + repeat_delay);
+            vsync_delay_clock = videosync->WaitForFrame(frameDelay, avsync_adjustment + repeat_delay);
         }
         else
         {
@@ -1994 +1992 @@
             osdLock.unlock();
             // Display the second field
             if (!player_ctx->IsPBP() || player_ctx->IsPrimaryPBP())
-                vsync_delay_clock = videosync->WaitForFrame(frameDelay +
-                                                        avsync_adjustment);
+                vsync_delay_clock = videosync->WaitForFrame(frameDelay, avsync_adjustment);
             videoOutput->Show(ps);
         }
 
@@ -2008 +2005 @@
     }
     else
     {
-        vsync_delay_clock = videosync->WaitForFrame(frameDelay);
+        vsync_delay_clock = videosync->WaitForFrame(frameDelay, 0);
         //currentaudiotime = AVSyncGetAudiotime();
     }
 
@@ -2450 +2447 @@
 
     if (player_ctx->IsPIP() && FlagIsSet(kVideoIsNull))
     {
-        videosync = new DummyVideoSync(videoOutput, fr_int, 0, false);
+        videosync = new DummyVideoSync(videoOutput, 0);
     }
     else if (FlagIsSet(kVideoIsNull))
     {
-        videosync = new USleepVideoSync(videoOutput, fr_int, 0, false);
+        videosync = new USleepVideoSync(videoOutput, 0);
     }
     else if (videoOutput)
     {
@@ -2465 +2462 @@
 
         m_double_process = videoOutput->IsExtraProcessingRequired();
 
-        videosync = VideoSync::BestMethod(
-            videoOutput, (uint)fr_int, (uint)rf_int, m_double_framerate);
+        videosync = VideoSync::BestMethod(videoOutput, (uint)rf_int);
 
         // Make sure video sync can do it
         if (videosync != NULL && m_double_framerate)
@@ -2482 +2478 @@
     }
     if (!videosync)
     {
-        videosync = new BusyWaitVideoSync(
-            videoOutput, fr_int, rf_int, m_double_framerate);
+        videosync = new BusyWaitVideoSync(videoOutput, rf_int);
     }
 
     InitAVSync();
@@ -3751 +3746 @@
     normal_speed = next_normal_speed;
 
     bool skip_changed = UpdateFFRewSkip();
-    videosync->setFrameInterval(frame_interval);
 
     if (skip_changed && videoOutput)
     {

mythtv/libs/libmythtv/vsync.cpp

@@ -59 +59 @@
 #define TESTVIDEOSYNC(NAME) \
     do { if (++m_forceskip > skip) \
     { \
-        trial = new NAME (video_output,     frame_interval, \
-                          refresh_interval, halve_frame_interval); \
+        trial = new NAME (video_output, refresh_interval); \
         if (trial->TryInit()) \
         { \
             m_forceskip = skip; \
@@ -72 +71 @@
 
 #define LOC QString("VSYNC: ")
 
-/** \fn VideoSync::BestMethod(VideoOutput*,uint,uint,bool)
+/** \fn VideoSync::BestMethod(VideoOutput*,uint)
  *  \brief Returns the most sophisticated video sync method available.
  */
 VideoSync *VideoSync::BestMethod(VideoOutput *video_output,
-                                 uint frame_interval, uint refresh_interval,
-                                 bool halve_frame_interval)
+                                 uint refresh_interval)
 {
     VideoSync *trial = NULL;
     tryingVideoSync  = true;
@@ -110 +108 @@
     return NULL;
 }
 
-/** \fn VideoSync::VideoSync(VideoOutput*,int,int,bool)
- *  \brief Used by BestMethod(VideoOutput*,uint,uint,bool) to initialize
+/** \fn VideoSync::VideoSync(VideoOutput*,int)
+ *  \brief Used by BestMethod(VideoOutput*,uint) to initialize
  *         video synchronization method.
  */
-VideoSync::VideoSync(VideoOutput *video_output,
-                     int frameint, int refreshint,
-                     bool halve_frame_interval) :
-    m_video_output(video_output),   m_frame_interval(frameint),
-    m_refresh_interval(refreshint), m_interlaced(halve_frame_interval),
+VideoSync::VideoSync(VideoOutput *video_output, int refreshint) :
+    m_video_output(video_output), m_refresh_interval(refreshint),
     m_nexttrigger(0), m_delay(-1)
 {
 }
@@ -135 +130 @@
     m_nexttrigger = GetTime();
 }
 
-/** \fn VideoSync::CalcDelay()
+/** \fn VideoSync::CalcDelay(int)
  *  \brief Calculates the delay to the next frame.
  *
  *   Regardless of the timing method, if delay is greater than four full
@@ -146 +141 @@
  *   Also prevent the nexttrigger from falling too far in the past in case
  *   we are trying to speed up video output faster than possible.
  */
-int VideoSync::CalcDelay()
+int VideoSync::CalcDelay(int nominal_frame_interval)
 {
     int64_t now = GetTime();
 #if 0
@@ -160 +155 @@
     LOG(VB_GENERAL, LOG_DEBUG, QString("delay %1").arg(ret_val));
 #endif
 
-    if (ret_val > m_frame_interval * 4)
+    if (ret_val > nominal_frame_interval * 4)
     {
-        if (m_interlaced)
-            ret_val = (m_frame_interval / 2) * 4;
-        else
-            ret_val = m_frame_interval * 4;
+        ret_val = nominal_frame_interval * 4;
 
         // set nexttrigger to our new target time
         m_nexttrigger = now + ret_val;
     }
 
-    if (ret_val < -m_frame_interval && m_frame_interval >= m_refresh_interval)
+    if (ret_val < -nominal_frame_interval && nominal_frame_interval >= m_refresh_interval)
     {
-        ret_val = -m_frame_interval;
+        ret_val = -nominal_frame_interval;
 
         // set nexttrigger to our new target time
         m_nexttrigger = now + ret_val;
@@ -242 +234 @@
 
 const char *DRMVideoSync::sm_dri_dev = "/dev/dri/card0";
 
-DRMVideoSync::DRMVideoSync(VideoOutput *vo, int fr, int ri, bool intl) :
-    VideoSync(vo, fr, ri, intl)
+DRMVideoSync::DRMVideoSync(VideoOutput *vo, int ri) :
+    VideoSync(vo, ri)
 {
     m_dri_fd = -1;
 }
@@ -291 +283 @@
     VideoSync::Start();
 }
 
-int DRMVideoSync::WaitForFrame(int sync_delay)
+int DRMVideoSync::WaitForFrame(int nominal_frame_interval, int extra_delay)
 {
     // Offset for externally-provided A/V sync delay
-    m_nexttrigger += sync_delay;
+    m_nexttrigger += nominal_frame_interval + extra_delay;
 
-    m_delay = CalcDelay();
+    m_delay = CalcDelay(nominal_frame_interval);
 #if 0
     LOG(VB_GENERAL, LOG_DEBUG, QString("WaitForFrame at : %1").arg(m_delay));
 #endif
@@ -308 +300 @@
         blank.request.type = DRM_VBLANK_RELATIVE;
         blank.request.sequence = 1;
         drmWaitVBlank(m_dri_fd, &blank);
-        m_delay = CalcDelay();
+        m_delay = CalcDelay(nominal_frame_interval);
 #if 0
         LOG(VB_GENERAL, LOG_DEBUG, QString("Delay at sync: %1").arg(m_delay));
 #endif
@@ -323 +315 @@
         blank.request.type = DRM_VBLANK_RELATIVE;
         blank.request.sequence = n;
         drmWaitVBlank(m_dri_fd, &blank);
-        m_delay = CalcDelay();
+        m_delay = CalcDelay(nominal_frame_interval);
 #if 0
         LOG(VB_GENERAL, LOG_DEBUG,
             QString("Wait %1 intervals. Count %2 Delay %3")
@@ -337 +329 @@
 
 #ifdef __linux__
 #define RTCRATE 1024
-RTCVideoSync::RTCVideoSync(VideoOutput *vo, int fi, int ri, bool intr) :
-    VideoSync(vo, fi, ri, intr)
+RTCVideoSync::RTCVideoSync(VideoOutput *vo, int ri) :
+    VideoSync(vo, ri)
 {
     m_rtcfd = -1;
 }
@@ -377 +369 @@
     return true;
 }
 
-int RTCVideoSync::WaitForFrame(int sync_delay)
+int RTCVideoSync::WaitForFrame(int nominal_frame_interval, int extra_delay)
 {
-    m_nexttrigger += sync_delay;
+    m_nexttrigger += nominal_frame_interval + extra_delay;
 
-    m_delay = CalcDelay();
+    m_delay = CalcDelay(nominal_frame_interval);
 
     unsigned long rtcdata;
     while (m_delay > 0)
     {
         ssize_t val = read(m_rtcfd, &rtcdata, sizeof(rtcdata));
-        m_delay = CalcDelay();
+        m_delay = CalcDelay(nominal_frame_interval);
 
         if ((val < 0) && (m_delay > 0))
             std::this_thread::sleep_for(std::chrono::microseconds(m_delay));
@@ -396 +388 @@
 }
 #endif /* __linux__ */
 
-BusyWaitVideoSync::BusyWaitVideoSync(VideoOutput *vo,
-                                     int fr, int ri, bool intl) :
-    VideoSync(vo, fr, ri, intl)
+BusyWaitVideoSync::BusyWaitVideoSync(VideoOutput *vo, int ri) :
+    VideoSync(vo, ri)
 {
     m_cheat = 5000;
     m_fudge = 0;
@@ -413 +404 @@
     return true;
 }
 
-int BusyWaitVideoSync::WaitForFrame(int sync_delay)
+int BusyWaitVideoSync::WaitForFrame(int nominal_frame_interval, int extra_delay)
 {
     // Offset for externally-provided A/V sync delay
-    m_nexttrigger += sync_delay;
+    m_nexttrigger += nominal_frame_interval + extra_delay;
 
-    m_delay = CalcDelay();
+    m_delay = CalcDelay(nominal_frame_interval);
 
     if (m_delay > 0)
     {
@@ -431 +422 @@
 
         // If late, draw the frame ASAP.  If early, hold the CPU until
         // half as late as the previous frame (fudge).
-        m_delay = CalcDelay();
-        m_fudge = min(m_fudge, m_frame_interval);
+        m_delay = CalcDelay(nominal_frame_interval);
+        m_fudge = min(m_fudge, nominal_frame_interval);
         while (m_delay + m_fudge > 0)
         {
-            m_delay = CalcDelay();
+            m_delay = CalcDelay(nominal_frame_interval);
             cnt++;
         }
         m_fudge = abs(m_delay / 2);
@@ -445 +436 @@
     return 0;
 }
 
-USleepVideoSync::USleepVideoSync(VideoOutput *vo,
-                                 int fr, int ri, bool intl) :
-    VideoSync(vo, fr, ri, intl)
+USleepVideoSync::USleepVideoSync(VideoOutput *vo, int ri) :
+    VideoSync(vo, ri)
 {
 }
 
@@ -460 +450 @@
     return true;
 }
 
-int USleepVideoSync::WaitForFrame(int sync_delay)
+int USleepVideoSync::WaitForFrame(int nominal_frame_interval, int extra_delay)
 {
     // Offset for externally-provided A/V sync delay
-    m_nexttrigger += sync_delay;
+    m_nexttrigger += nominal_frame_interval + extra_delay;
 
-    m_delay = CalcDelay();
+    m_delay = CalcDelay(nominal_frame_interval);
     if (m_delay > 0)
         std::this_thread::sleep_for(std::chrono::microseconds(m_delay));
     return 0;

mythtv/libs/libmythtv/vsync.h

@@ -46 +46 @@
 // virtual base class
 {
   public:
-    VideoSync(VideoOutput*, int fi, int ri, bool intr);
+    VideoSync(VideoOutput*, int ri);
     virtual ~VideoSync() {}
 
     /// \brief Returns name of instanciated VSync method.
@@ -69 +69 @@
      *   always be called from same thread, to prevent bad
      *   interactions with threads.
      *
-     *  \param sync_delay time until the desired frame or field
-     *  \sa CalcDelay(void), KeepPhase(void)
+     *  \param nominal_frame_interval the frame interval normally expected
+     *  \param extra_delay extra time beyond nominal until the desired frame or field
+     *  \sa CalcDelay(int), KeepPhase(void)
      */
-    virtual int WaitForFrame(int sync_delay) = 0;
+    virtual int WaitForFrame(int nominal_frame_interval, int extra_delay) = 0;
 
     /// \brief Returns the (minimum) refresh interval of the output device.
     int getRefreshInterval(void) const { return m_refresh_interval; }
     /// \brief Sets the refresh interval of the output device.
     void setRefreshInterval(int ri) { m_refresh_interval = ri; }
 
-    virtual void setFrameInterval(int fi) { m_frame_interval = fi; };
-
     /** \brief Stops VSync; must be called from main thread.
      *
      *   Start(void), WaitForFrame(void), and Stop(void) should
@@ -90 +89 @@
     virtual void Stop(void) {}
 
     // documented in vsync.cpp
-    static VideoSync *BestMethod(VideoOutput*,
-                                 uint frame_interval, uint refresh_interval,
-                                 bool interlaced);
+    static VideoSync *BestMethod(VideoOutput *, uint refresh_interval);
+
   protected:
     int64_t GetTime(void);
-    int CalcDelay(void);
+    int CalcDelay(int nominal_frame_interval);
     void KeepPhase(void) MDEPRECATED;
 
     VideoOutput *m_video_output;
-    int m_frame_interval; // of video
     int m_refresh_interval; // of display
-    bool m_interlaced;
     int64_t m_nexttrigger;
     int m_delay;
     
@@ -118 +114 @@
 class DRMVideoSync : public VideoSync
 {
   public:
-    DRMVideoSync(VideoOutput*,
-                 int frame_interval, int refresh_interval, bool interlaced);
+    DRMVideoSync(VideoOutput *, int refresh_interval);
     ~DRMVideoSync();
 
     QString getName(void) const { return QString("DRM"); }
     bool TryInit(void);
     void Start(void);
-    int WaitForFrame(int sync_delay);
+    int WaitForFrame(int nominal_frame_interval, int extra_delay) override;
 
   private:
     int m_dri_fd;
@@ -148 +143 @@
 class RTCVideoSync : public VideoSync
 {
   public:
-    RTCVideoSync(VideoOutput*,
-                 int frame_interval, int refresh_interval, bool interlaced);
+    RTCVideoSync(VideoOutput *, int refresh_interval);
     ~RTCVideoSync();
 
     QString getName(void) const { return QString("RTC"); }
     bool TryInit(void);
-    int WaitForFrame(int sync_delay);
+    int WaitForFrame(int nominal_frame_interval, int extra_delay) override;
 
   private:
     int m_rtcfd;
@@ -174 +168 @@
 class BusyWaitVideoSync : public VideoSync
 {
   public:
-    BusyWaitVideoSync(VideoOutput*,
-                      int frame_interval, int refresh_interval, 
-                      bool interlaced);
+    BusyWaitVideoSync(VideoOutput *, int refresh_interval);
     ~BusyWaitVideoSync();
 
     QString getName(void) const { return QString("USleep with busy wait"); }
     bool TryInit(void);
-    int WaitForFrame(int sync_delay);
+    int WaitForFrame(int nominal_frame_interval, int extra_delay) override;
 
   private:
     int m_cheat;
@@ -201 +193 @@
 class USleepVideoSync : public VideoSync
 {
   public:
-    USleepVideoSync(VideoOutput*,
-                    int frame_interval, int refresh_interval, 
-                    bool interlaced);
+    USleepVideoSync(VideoOutput *, int refresh_interval);
     ~USleepVideoSync();
 
     QString getName(void) const { return QString("USleep"); }
     bool TryInit(void);
-    int WaitForFrame(int sync_delay);
+    int WaitForFrame(int nominal_frame_interval, int extra_delay) override;
 };
 
 class DummyVideoSync : public VideoSync
 {
   public:
-    DummyVideoSync(VideoOutput* vo, int fr, int ri, bool intl)
-     : VideoSync(vo, fr, ri, intl) { }
+    DummyVideoSync(VideoOutput* vo, int ri) : VideoSync(vo, ri) { }
     ~DummyVideoSync() { }
 
     QString getName(void) const { return QString("Dummy"); }
     bool TryInit(void) { return true; }
-    int WaitForFrame(int /*sync_delay*/) { return 0; }
+    int WaitForFrame(int nominal_frame_interval, int extra_delay) override { return 0; }
 };
 #endif /* VSYNC_H_INCLUDED */