changed: Modify rate calculation to obtain a proper average with heav…

…y seeking/cache swapping

xbmc/filesystem/CacheStrategy.cpp

@@ -235,17 +235,18 @@ int64_t CSimpleFileCache::Seek(int64_t iFilePosition)
   return iFilePosition;
 }
 
-void CSimpleFileCache::Reset(int64_t iSourcePosition, bool clearAnyway)
+bool CSimpleFileCache::Reset(int64_t iSourcePosition, bool clearAnyway)
 {
   if (!clearAnyway && IsCachedPosition(iSourcePosition))
   {
     m_nReadPosition = m_cacheFileRead->Seek(iSourcePosition - m_nStartPosition, SEEK_SET);
-    return;
+    return false;
   }
 
   m_nStartPosition = iSourcePosition;
   m_nWritePosition = m_cacheFileWrite->Seek(0, SEEK_SET);
   m_nReadPosition = m_cacheFileRead->Seek(0, SEEK_SET);
+  return true;
 }
 
 void CSimpleFileCache::EndOfInput()
@@ -330,33 +331,32 @@ int64_t CDoubleCache::Seek(int64_t iFilePosition)
   return m_pCache->Seek(iFilePosition);
 }
 
-void CDoubleCache::Reset(int64_t iSourcePosition, bool clearAnyway)
+bool CDoubleCache::Reset(int64_t iSourcePosition, bool clearAnyway)
 {
   if (!clearAnyway && m_pCache->IsCachedPosition(iSourcePosition)
       && (!m_pCacheOld || !m_pCacheOld->IsCachedPosition(iSourcePosition)
           || m_pCache->CachedDataEndPos() >= m_pCacheOld->CachedDataEndPos()))
   {
-    m_pCache->Reset(iSourcePosition, clearAnyway);
-    return;
+    return m_pCache->Reset(iSourcePosition, clearAnyway);
   }
   if (!m_pCacheOld)
   {
     CCacheStrategy *pCacheNew = m_pCache->CreateNew();
     if (pCacheNew->Open() != CACHE_RC_OK)
     {
       delete pCacheNew;
-      m_pCache->Reset(iSourcePosition, clearAnyway);
-      return;
+      return m_pCache->Reset(iSourcePosition, clearAnyway);
     }
-    pCacheNew->Reset(iSourcePosition, clearAnyway);
+    bool bRes = pCacheNew->Reset(iSourcePosition, clearAnyway);
     m_pCacheOld = m_pCache;
     m_pCache = pCacheNew;
-    return;
+    return bRes;
   }
-  m_pCacheOld->Reset(iSourcePosition, clearAnyway);
+  bool bRes = m_pCacheOld->Reset(iSourcePosition, clearAnyway);
   CCacheStrategy *tmp = m_pCacheOld;
   m_pCacheOld = m_pCache;
   m_pCache = tmp;
+  return bRes;
 }
 
 void CDoubleCache::EndOfInput()

xbmc/filesystem/CacheStrategy.h

@@ -50,7 +50,7 @@ class CCacheStrategy{
   virtual int64_t WaitForData(unsigned int iMinAvail, unsigned int iMillis) = 0;
 
   virtual int64_t Seek(int64_t iFilePosition) = 0;
-  virtual void Reset(int64_t iSourcePosition, bool clearAnyway=true) = 0;
+  virtual bool Reset(int64_t iSourcePosition, bool clearAnyway=true) = 0;
 
   virtual void EndOfInput(); // mark the end of the input stream so that Read will know when to return EOF
   virtual bool IsEndOfInput();
@@ -83,7 +83,7 @@ class CSimpleFileCache : public CCacheStrategy {
   virtual int64_t WaitForData(unsigned int iMinAvail, unsigned int iMillis) ;
 
   virtual int64_t Seek(int64_t iFilePosition);
-  virtual void Reset(int64_t iSourcePosition, bool clearAnyway=true);
+  virtual bool Reset(int64_t iSourcePosition, bool clearAnyway=true);
   virtual void EndOfInput();
 
   virtual int64_t CachedDataEndPosIfSeekTo(int64_t iFilePosition);
@@ -118,7 +118,7 @@ class CDoubleCache : public CCacheStrategy{
   virtual int64_t WaitForData(unsigned int iMinAvail, unsigned int iMillis) ;
 
   virtual int64_t Seek(int64_t iFilePosition);
-  virtual void Reset(int64_t iSourcePosition, bool clearAnyway=true);
+  virtual bool Reset(int64_t iSourcePosition, bool clearAnyway=true);
   virtual void EndOfInput();
   virtual bool IsEndOfInput();
   virtual void ClearEndOfInput();

xbmc/filesystem/CircularCache.cpp

@@ -232,17 +232,19 @@ int64_t CCircularCache::Seek(int64_t pos)
   return CACHE_RC_ERROR;
 }
 
-void CCircularCache::Reset(int64_t pos, bool clearAnyway)
+bool CCircularCache::Reset(int64_t pos, bool clearAnyway)
 {
   CSingleLock lock(m_sync);
   if (!clearAnyway && IsCachedPosition(pos))
   {
     m_cur = pos;
-    return;
+    return false;
   }
   m_end = pos;
   m_beg = pos;
   m_cur = pos;
+
+  return true;
 }
 
 int64_t CCircularCache::CachedDataEndPosIfSeekTo(int64_t iFilePosition)

xbmc/filesystem/CircularCache.h

@@ -42,7 +42,7 @@ class CCircularCache : public CCacheStrategy
     virtual int64_t WaitForData(unsigned int minimum, unsigned int iMillis) ;
 
     virtual int64_t Seek(int64_t pos) ;
-    virtual void Reset(int64_t pos, bool clearAnyway=true) ;
+    virtual bool Reset(int64_t pos, bool clearAnyway=true) ;
 
     virtual int64_t CachedDataEndPosIfSeekTo(int64_t iFilePosition);
     virtual int64_t CachedDataEndPos(); 

xbmc/filesystem/FileCache.cpp

@@ -44,20 +44,35 @@ class CWriteRate
     m_stamp = XbmcThreads::SystemClockMillis();
     m_pos   = 0;
     m_pause = 0;
+    m_size = 0;
+    m_time = 0;
   }
 
-  void Reset(int64_t pos)
+  void Reset(int64_t pos, bool bResetAll = true)
   {
     m_stamp = XbmcThreads::SystemClockMillis();
     m_pos   = pos;
+
+    if (bResetAll)
+    {
+      m_size  = 0;
+      m_time  = 0;
+    }
   }
 
   unsigned Rate(int64_t pos, unsigned int time_bias = 0)
   {
-    const unsigned ts = XbmcThreads::SystemClockMillis() + time_bias;
-    if (ts == m_stamp)
+    const unsigned ts = XbmcThreads::SystemClockMillis();
+
+    m_size += (pos - m_pos);
+    m_time += (ts - m_stamp);
+    m_pos = pos;
+    m_stamp = ts;
+
+    if (m_time == 0)
       return 0;
-    return (unsigned)(1000 * (pos - m_pos) / (ts - m_stamp));
+
+    return (unsigned)(1000 * (m_size / (m_time + time_bias)));
   }
 
   void Pause()
@@ -75,6 +90,8 @@ class CWriteRate
   unsigned m_stamp;
   int64_t  m_pos;
   unsigned m_pause;
+  int64_t  m_size;
+  int64_t  m_time;
 };
 
 
@@ -233,11 +250,11 @@ void CFileCache::Process()
       }
       if (!sourceSeekFailed)
       {
-        m_pCache->Reset(m_seekPos, false);
+        const bool bCompleteReset = m_pCache->Reset(m_seekPos, false);
         m_readPos = m_seekPos;
         m_writePos = m_pCache->CachedDataEndPos();
         assert(m_writePos == cacheMaxPos);
-        average.Reset(m_writePos);
+        average.Reset(m_writePos, bCompleteReset); // Can only recalculate new average from scratch after a full reset (empty cache)
         limiter.Reset(m_writePos);
         m_cacheFull = (m_pCache->GetMaxWriteSize(m_chunkSize) == 0);
         m_nSeekResult = m_seekPos;

xbmc/filesystem/MemBufferCache.cpp

@@ -215,13 +215,14 @@ int64_t MemBufferCache::Seek(int64_t iFilePosition)
   return CACHE_RC_ERROR;
 }
 
-void MemBufferCache::Reset(int64_t iSourcePosition)
+bool MemBufferCache::Reset(int64_t iSourcePosition, bool clearAnyway)
 {
   CSingleLock lock(m_sync);
   m_nStartPosition = iSourcePosition;
   m_buffer.Clear();
   m_HistoryBuffer.Clear();
   m_forwardBuffer.Clear();
+  return true;
 }
 
 

xbmc/filesystem/MemBufferCache.h

@@ -46,7 +46,7 @@ class MemBufferCache : public CCacheStrategy
     virtual int64_t WaitForData(unsigned int iMinAvail, unsigned int iMillis) ;
 
     virtual int64_t Seek(int64_t iFilePosition) ;
-    virtual void Reset(int64_t iSourcePosition) ;
+    virtual bool Reset(int64_t iSourcePosition, bool clearAnyway) ;
 
 protected:
     int64_t m_nStartPosition;