xbmc/cores/VideoPlayer/PTSTracker.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 "PTSTracker.h"
  10
  11 #include "DVDCodecs/DVDCodecUtils.h"
  12 #include "cores/VideoPlayer/Interface/TimingConstants.h"
  13 #include "utils/StringUtils.h"
  14 #include "utils/log.h"
  15
  16 #include <algorithm>
  17 #include <cmath>
  18
  19 #define MAXERR DVD_MSEC_TO_TIME(2.5)
  20
  21 CPtsTracker::CPtsTracker()
  22 {
  23   ResetVFRDetection();
  24   Flush();
  25 }
  26
  27 void CPtsTracker::ResetVFRDetection(void)
  28 {
  29   m_minframeduration = DVD_NOPTS_VALUE;
  30   m_maxframeduration = DVD_NOPTS_VALUE;
  31   m_VFRCounter = 0;
  32   m_patternCounter = 0;
  33   m_lastPattern.clear();
  34 }
  35
  36 void CPtsTracker::Flush()
  37 {
  38   m_pattern.clear();
  39   m_ringpos       = 0;
  40   m_prevpts       = DVD_NOPTS_VALUE;
  41   m_ringfill      = 0;
  42   m_haspattern    = false;
  43   m_patternlength = 0;
  44   m_frameduration = DVD_NOPTS_VALUE;
  45   memset(m_diffring, 0, sizeof(m_diffring));
  46 }
  47
  48 void CPtsTracker::Add(double pts)
  49 {
  50   //can't get a diff with just one pts
  51   if (m_prevpts == DVD_NOPTS_VALUE)
  52   {
  53     m_prevpts = pts;
  54     return;
  55   }
  56
  57   //increase the ringbuffer position
  58   m_ringpos = (m_ringpos + 1) % DIFFRINGSIZE;
  59   //add the current diff to the ringbuffer
  60   m_diffring[m_ringpos] = pts - m_prevpts;
  61   //save the pts
  62   m_prevpts = pts;
  63
  64   if (m_ringfill < DIFFRINGSIZE)
  65     m_ringfill++;
  66
  67   //only search for patterns if we have full ringbuffer
  68   if (m_ringfill < DIFFRINGSIZE)
  69     return;
  70
  71   //get the current pattern in the ringbuffer
  72   std::vector<double> pattern;
  73   GetPattern(pattern);
  74
  75   //check if the pattern is the same as the saved pattern
  76   //and if it is actually a pattern
  77   if (!CheckPattern(pattern))
  78   {
  79     if (m_haspattern)
  80     {
  81       m_VFRCounter++;
  82       m_lastPattern = m_pattern;
  83       CLog::Log(LOGDEBUG, "CPtsTracker: pattern lost on diff {:f}, number of losses {}", GetDiff(0),
  84                 m_VFRCounter);
  85       Flush();
  86     }
  87
  88     //no pattern detected or current pattern broke/changed
  89     //save detected pattern so we can check it with the next iteration
  90     m_pattern = pattern;
  91
  92     return;
  93   }
  94   else
  95   {
  96     if (!m_haspattern)
  97     {
  98       m_haspattern = true;
  99       m_patternlength = m_pattern.size();
 100
 101       if (!m_lastPattern.empty() && !CheckPattern(m_lastPattern))
 102       {
 103         m_patternCounter++;
 104       }
 105
 106       double frameduration = CalcFrameDuration();
 107       CLog::Log(LOGDEBUG, "CPtsTracker: detected pattern of length {}: {}, frameduration: {:f}",
 108                 (int)pattern.size(), GetPatternStr(), frameduration);
 109     }
 110   }
 111
 112   m_frameduration = CalcFrameDuration();
 113 }
 114
 115 //gets a diff diffnr into the past
 116 inline double CPtsTracker::GetDiff(int diffnr)
 117 {
 118   //m_ringpos is the last added diff, so if we want to go in the past we have to move back in the ringbuffer
 119   int pos = m_ringpos - diffnr;
 120   if (pos < 0)
 121     pos += DIFFRINGSIZE;
 122
 123   return m_diffring[pos];
 124 }
 125
 126 //calculate the current pattern in the ringbuffer
 127 void CPtsTracker::GetPattern(std::vector<double>& pattern)
 128 {
 129   int difftypesbuff[DIFFRINGSIZE]; //difftypes of the diffs, difftypesbuff[0] is the last added diff,
 130                                    //difftypesbuff[1] the one added before that etc
 131
 132   //get the difftypes
 133   std::vector<double> difftypes;
 134   for (int i = 0; i < m_ringfill; i++)
 135   {
 136     bool hasmatch = false;
 137     for (unsigned int j = 0; j < difftypes.size(); j++)
 138     {
 139       if (MatchDiff(GetDiff(i), difftypes[j]))
 140       {
 141         hasmatch = true;
 142         break;
 143       }
 144     }
 145
 146     //if we don't have a match with a saved difftype, we add it as a new one
 147     if (!hasmatch)
 148       difftypes.push_back(GetDiff(i));
 149   }
 150
 151   //mark each diff with what difftype it is
 152   for (int i = 0; i < m_ringfill; i++)
 153   {
 154     for (unsigned int j = 0; j < difftypes.size(); j++)
 155     {
 156       if (MatchDiff(GetDiff(i), difftypes[j]))
 157       {
 158         difftypesbuff[i] = j;
 159         break;
 160       }
 161     }
 162   }
 163
 164   bool checkexisting = !m_pattern.empty();
 165
 166   //we check for patterns to the length of DIFFRINGSIZE / 2
 167   for (int i = 1; i <= m_ringfill / 2; i++)
 168   {
 169     //check the existing pattern length first
 170     int length = checkexisting ? m_pattern.size() : i;
 171
 172     bool hasmatch = true;
 173     for (int j = 1; j <= m_ringfill / length; j++)
 174     {
 175       int nrdiffs = length;
 176       //we want to check the full buffer to see if the pattern repeats
 177       //but we can't go beyond the buffer
 178       if (j * length + length > m_ringfill)
 179         nrdiffs = m_ringfill - j * length;
 180
 181       if (nrdiffs < 1)  //if the buffersize can be cleanly divided by i we're done here
 182         break;
 183
 184       if (!MatchDifftype(difftypesbuff, difftypesbuff + j * length, nrdiffs))
 185       {
 186         hasmatch = false;
 187         break;
 188       }
 189     }
 190
 191     if (checkexisting)
 192     {
 193       checkexisting = false;
 194       i--;
 195     }
 196
 197     if (hasmatch)
 198     {
 199       for (int i = 0; i < length; i++)
 200       {
 201         double avgdiff = 0.0;
 202         for (int j = 0; j < m_ringfill / length; j++)
 203           avgdiff += GetDiff(j * length + i);
 204
 205         avgdiff /= m_ringfill / length;
 206         pattern.push_back(avgdiff);
 207       }
 208       break;
 209     }
 210   }
 211   std::sort(pattern.begin(), pattern.end());
 212 }
 213
 214 inline bool CPtsTracker::MatchDiff(double diff1, double diff2)
 215 {
 216   return fabs(diff1 - diff2) < MAXERR;
 217 }
 218
 219 //check if diffs1 is the same as diffs2
 220 inline bool CPtsTracker::MatchDifftype(int diffs1[], int diffs2[], int nrdiffs)
 221 {
 222   for (int i = 0; i < nrdiffs; i++)
 223   {
 224     if (diffs1[i] != diffs2[i])
 225       return false;
 226   }
 227   return true;
 228 }
 229
 230 //check if our current detected pattern is the same as the one we saved
 231 bool CPtsTracker::CheckPattern(std::vector<double>& pattern)
 232 {
 233   //if no pattern was detected or if the size of the patterns differ we don't have a match
 234   if (pattern.empty() || pattern.size() != m_pattern.size())
 235     return false;
 236
 237   if (pattern.size() == 1)
 238   {
 239     if (pattern[0] < MAXERR)
 240       return false; //all diffs are too close to 0, can't use this
 241   }
 242
 243   //check if the current pattern matches the saved pattern, with an offset of 1
 244   for (unsigned int i = 0; i < m_pattern.size(); i++)
 245   {
 246     double diff = pattern[i];
 247
 248     if (!MatchDiff(diff, m_pattern[i]))
 249       return false;
 250   }
 251
 252   return true;
 253 }
 254
 255 //calculate how long each frame should last from the saved pattern
 256 //also retrieve information of max and min frame rate duration, for VFR files case
 257 double CPtsTracker::CalcFrameDuration()
 258 {
 259   if (!m_pattern.empty())
 260   {
 261     //take the average of all diffs in the pattern
 262     double frameduration;
 263     double current, currentmin, currentmax;
 264
 265     currentmin = m_pattern[0];
 266     currentmax = currentmin;
 267     frameduration = currentmin;
 268     for (unsigned int i = 1; i < m_pattern.size(); i++)
 269     {
 270       current = m_pattern[i];
 271       if (current>currentmax)
 272         currentmax = current;
 273       if (current<currentmin)
 274         currentmin = current;
 275       frameduration += current;
 276     }
 277     frameduration /= m_pattern.size();
 278
 279     // Update min and max frame duration, only if data is valid
 280     bool standard = false;
 281     double tempduration = CDVDCodecUtils::NormalizeFrameduration(currentmin, &standard);
 282     if (m_minframeduration == DVD_NOPTS_VALUE)
 283     {
 284       if (standard)
 285         m_minframeduration = tempduration;
 286     }
 287     else
 288     {
 289       if (standard && (tempduration < m_minframeduration))
 290         m_minframeduration = tempduration;
 291     }
 292
 293     tempduration = CDVDCodecUtils::NormalizeFrameduration(currentmax, &standard);
 294     if (m_maxframeduration == DVD_NOPTS_VALUE)
 295     {
 296       if (standard)
 297         m_maxframeduration = tempduration;
 298     }
 299     else
 300     {
 301       if (standard && (tempduration > m_maxframeduration))
 302         m_maxframeduration = tempduration;
 303     }
 304
 305     //frameduration is not completely correct, use a common one if it's close
 306     return CDVDCodecUtils::NormalizeFrameduration(frameduration);
 307   }
 308
 309   return DVD_NOPTS_VALUE;
 310 }
 311
 312 //looks pretty in the log
 313 std::string CPtsTracker::GetPatternStr()
 314 {
 315   std::string patternstr;
 316
 317   for (unsigned int i = 0; i < m_pattern.size(); i++)
 318     patternstr += StringUtils::Format("{:.2f} ", m_pattern[i]);
 319
 320   StringUtils::Trim(patternstr);
 321
 322   return patternstr;
 323 }