xbmc/cores/VideoPlayer/DVDClock.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "DVDClock.h"
  10
  11 #include "VideoReferenceClock.h"
  12 #include "cores/VideoPlayer/Interface/TimingConstants.h"
  13 #include "utils/MathUtils.h"
  14 #include "utils/TimeUtils.h"
  15 #include "utils/log.h"
  16
  17 #include <inttypes.h>
  18 #include <math.h>
  19 #include <memory>
  20 #include <mutex>
  21
  22 CDVDClock::CDVDClock()
  23 {
  24   std::unique_lock<CCriticalSection> lock(m_systemsection);
  25
  26   m_pauseClock = 0;
  27   m_bReset = true;
  28   m_paused = false;
  29   m_speedAfterPause = DVD_PLAYSPEED_PAUSE;
  30   m_iDisc = 0;
  31   m_maxspeedadjust = 5.0;
  32   m_systemAdjust = 0;
  33   m_speedAdjust = 0;
  34   m_startClock = 0;
  35   m_vSyncAdjust = 0;
  36   m_frameTime = DVD_TIME_BASE / 60.0;
  37
  38   m_videoRefClock = std::make_unique<CVideoReferenceClock>();
  39   m_lastSystemTime = m_videoRefClock->GetTime();
  40   m_systemOffset = m_videoRefClock->GetTime();
  41   m_systemFrequency = CurrentHostFrequency();
  42   m_systemUsed = m_systemFrequency;
  43 }
  44
  45 CDVDClock::~CDVDClock() = default;
  46
  47 // Returns the current absolute clock in units of DVD_TIME_BASE (usually microseconds).
  48 double CDVDClock::GetAbsoluteClock(bool interpolated /*= true*/)
  49 {
  50   std::unique_lock<CCriticalSection> lock(m_systemsection);
  51
  52   int64_t current;
  53   current = m_videoRefClock->GetTime(interpolated);
  54
  55   return SystemToAbsolute(current);
  56 }
  57
  58 double CDVDClock::GetClock(bool interpolated /*= true*/)
  59 {
  60   std::unique_lock<CCriticalSection> lock(m_critSection);
  61
  62   int64_t current = m_videoRefClock->GetTime(interpolated);
  63   m_systemAdjust += m_speedAdjust * (current - m_lastSystemTime);
  64   m_lastSystemTime = current;
  65
  66   return SystemToPlaying(current);
  67 }
  68
  69 double CDVDClock::GetClock(double& absolute, bool interpolated /*= true*/)
  70 {
  71   int64_t current = m_videoRefClock->GetTime(interpolated);
  72
  73   std::unique_lock<CCriticalSection> lock(m_systemsection);
  74   absolute = SystemToAbsolute(current);
  75
  76   m_systemAdjust += m_speedAdjust * (current - m_lastSystemTime);
  77   m_lastSystemTime = current;
  78
  79   return SystemToPlaying(current);
  80 }
  81
  82 void CDVDClock::SetVsyncAdjust(double adjustment)
  83 {
  84   std::unique_lock<CCriticalSection> lock(m_critSection);
  85   m_vSyncAdjust = adjustment;
  86 }
  87
  88 double CDVDClock::GetVsyncAdjust()
  89 {
  90   std::unique_lock<CCriticalSection> lock(m_critSection);
  91   return m_vSyncAdjust;
  92 }
  93
  94 void CDVDClock::Pause(bool pause)
  95 {
  96   std::unique_lock<CCriticalSection> lock(m_critSection);
  97
  98   if (pause && !m_paused)
  99   {
 100     if (!m_pauseClock)
 101       m_speedAfterPause = m_systemFrequency * DVD_PLAYSPEED_NORMAL / m_systemUsed;
 102     else
 103       m_speedAfterPause = DVD_PLAYSPEED_PAUSE;
 104
 105     SetSpeed(DVD_PLAYSPEED_PAUSE);
 106     m_paused = true;
 107   }
 108   else if (!pause && m_paused)
 109   {
 110     m_paused = false;
 111     SetSpeed(m_speedAfterPause);
 112   }
 113 }
 114
 115 void CDVDClock::Advance(double time)
 116 {
 117   std::unique_lock<CCriticalSection> lock(m_critSection);
 118
 119   if (m_pauseClock)
 120   {
 121     m_pauseClock += time / DVD_TIME_BASE * m_systemFrequency;
 122   }
 123 }
 124
 125 void CDVDClock::SetSpeed(int iSpeed)
 126 {
 127   // this will sometimes be a little bit of due to rounding errors, ie clock might jump a bit when changing speed
 128   std::unique_lock<CCriticalSection> lock(m_critSection);
 129
 130   if (m_paused)
 131   {
 132     m_speedAfterPause = iSpeed;
 133     return;
 134   }
 135
 136   if (iSpeed == DVD_PLAYSPEED_PAUSE)
 137   {
 138     if (!m_pauseClock)
 139       m_pauseClock = m_videoRefClock->GetTime();
 140     return;
 141   }
 142
 143   int64_t current;
 144   int64_t newfreq = m_systemFrequency * DVD_PLAYSPEED_NORMAL / iSpeed;
 145
 146   current = m_videoRefClock->GetTime();
 147   if (m_pauseClock)
 148   {
 149     m_startClock += current - m_pauseClock;
 150     m_pauseClock = 0;
 151   }
 152
 153   m_startClock = current - (int64_t)((double)(current - m_startClock) * newfreq / m_systemUsed);
 154   m_systemUsed = newfreq;
 155 }
 156
 157 void CDVDClock::SetSpeedAdjust(double adjust)
 158 {
 159   CLog::Log(LOGDEBUG, "CDVDClock::SetSpeedAdjust - adjusted:{:f}", adjust);
 160
 161   std::unique_lock<CCriticalSection> lock(m_critSection);
 162   m_speedAdjust = adjust;
 163 }
 164
 165 double CDVDClock::GetSpeedAdjust()
 166 {
 167   std::unique_lock<CCriticalSection> lock(m_critSection);
 168   return m_speedAdjust;
 169 }
 170
 171 double CDVDClock::ErrorAdjust(double error, const char* log)
 172 {
 173   std::unique_lock<CCriticalSection> lock(m_critSection);
 174
 175   double clock, absolute, adjustment;
 176   clock = GetClock(absolute);
 177
 178   // skip minor updates while speed adjust is active
 179   // -> adjusting buffer levels
 180   if (m_speedAdjust != 0 && error < DVD_MSEC_TO_TIME(100))
 181   {
 182     return 0;
 183   }
 184
 185   adjustment = error;
 186
 187   if (m_vSyncAdjust != 0)
 188   {
 189     // Audio ahead is more noticeable then audio behind video.
 190     // Correct if aufio is more than 20ms ahead or more then
 191     // 27ms behind. In a worst case scenario we switch from
 192     // 20ms ahead to 21ms behind (for fps of 23.976)
 193     if (error > 0.02 * DVD_TIME_BASE)
 194       adjustment = m_frameTime;
 195     else if (error < -0.027 * DVD_TIME_BASE)
 196       adjustment = -m_frameTime;
 197     else
 198       adjustment = 0;
 199   }
 200
 201   if (adjustment == 0)
 202     return 0;
 203
 204   Discontinuity(clock+adjustment, absolute);
 205
 206   CLog::Log(LOGDEBUG, "CDVDClock::ErrorAdjust - {} - error:{:f}, adjusted:{:f}", log, error,
 207             adjustment);
 208   return adjustment;
 209 }
 210
 211 void CDVDClock::Discontinuity(double clock, double absolute)
 212 {
 213   std::unique_lock<CCriticalSection> lock(m_critSection);
 214   m_startClock = AbsoluteToSystem(absolute);
 215   if(m_pauseClock)
 216     m_pauseClock = m_startClock;
 217   m_iDisc = clock;
 218   m_bReset = false;
 219   m_systemAdjust = 0;
 220   m_speedAdjust = 0;
 221 }
 222
 223 void CDVDClock::SetMaxSpeedAdjust(double speed)
 224 {
 225   std::unique_lock<CCriticalSection> lock(m_speedsection);
 226
 227   m_maxspeedadjust = speed;
 228 }
 229
 230 //returns the refreshrate if the videoreferenceclock is running, -1 otherwise
 231 int CDVDClock::UpdateFramerate(double fps, double* interval /*= NULL*/)
 232 {
 233   //sent with fps of 0 means we are not playing video
 234   if(fps == 0.0)
 235     return -1;
 236
 237   m_frameTime = 1/fps * DVD_TIME_BASE;
 238
 239   //check if the videoreferenceclock is running, will return -1 if not
 240   double rate = m_videoRefClock->GetRefreshRate(interval);
 241
 242   if (rate <= 0)
 243     return -1;
 244
 245   std::unique_lock<CCriticalSection> lock(m_speedsection);
 246
 247   double weight = (rate * 2) / fps;
 248
 249   //set the speed of the videoreferenceclock based on fps, refreshrate and maximum speed adjust set by user
 250   if (m_maxspeedadjust > 0.05)
 251   {
 252     if (weight / MathUtils::round_int(weight) < 1.0 + m_maxspeedadjust / 100.0 &&
 253       weight / MathUtils::round_int(weight) > 1.0 - m_maxspeedadjust / 100.0)
 254       weight = MathUtils::round_int(weight);
 255   }
 256   double speed = (rate * 2.0 ) / (fps * weight);
 257   lock.unlock();
 258
 259   m_videoRefClock->SetSpeed(speed);
 260
 261   return rate;
 262 }
 263
 264 bool CDVDClock::GetClockInfo(int& MissedVblanks, double& ClockSpeed, double& RefreshRate) const
 265 {
 266   return m_videoRefClock->GetClockInfo(MissedVblanks, ClockSpeed, RefreshRate);
 267 }
 268
 269 double CDVDClock::SystemToAbsolute(int64_t system)
 270 {
 271   return DVD_TIME_BASE * (double)(system - m_systemOffset) / m_systemFrequency;
 272 }
 273
 274 int64_t CDVDClock::AbsoluteToSystem(double absolute)
 275 {
 276   return (int64_t)(absolute / DVD_TIME_BASE * m_systemFrequency) + m_systemOffset;
 277 }
 278
 279 double CDVDClock::SystemToPlaying(int64_t system)
 280 {
 281   int64_t current;
 282
 283   if (m_bReset)
 284   {
 285     m_startClock = system;
 286     m_systemUsed = m_systemFrequency;
 287     if(m_pauseClock)
 288       m_pauseClock = m_startClock;
 289     m_iDisc = 0;
 290     m_systemAdjust = 0;
 291     m_speedAdjust = 0;
 292     m_vSyncAdjust = 0;
 293     m_bReset = false;
 294   }
 295
 296   if (m_pauseClock)
 297     current = m_pauseClock;
 298   else
 299     current = system;
 300
 301   return DVD_TIME_BASE * (double)(current - m_startClock + m_systemAdjust) / m_systemUsed + m_iDisc;
 302 }
 303
 304 double CDVDClock::GetClockSpeed()
 305 {
 306   std::unique_lock<CCriticalSection> lock(m_critSection);
 307
 308   double speed = (double)m_systemFrequency / m_systemUsed;
 309   return m_videoRefClock->GetSpeed() * speed + m_speedAdjust;
 310 }