完善fps统计

src/decoder.cpp

@@ -64,7 +64,7 @@ qint32 Decoder::recvData(quint8* buf, qint32 bufSize)
             }
         }
         qint64 readSize = qMin(m_deviceSocket->bytesAvailable(), (qint64)bufSize);
-        qDebug() << "ready recv data " << readSize;
+        //qDebug() << "ready recv data " << readSize;
         return m_deviceSocket->read((char*)buf, readSize);
     }    
     return 0;
@@ -252,6 +252,5 @@ void Decoder::pushFrame()
         // the previous newFrame will consume this frame
         return;
     }    
-    //qDebug() << "------------>" << QTime::currentTime();
     emit newFrame();
 }

src/decoder.h

@@ -6,8 +6,6 @@
 #include <QPointer>
 #include <QMutex>
 
-//#include "convert.h"
-
 extern "C"
 {
 #include "libavcodec/avcodec.h"

src/fpscounter.cpp

@@ -1,8 +1,9 @@
+#include <QTimerEvent>
 #include <QDebug>
 
 #include "fpscounter.h"
 
-FpsCounter::FpsCounter()
+FpsCounter::FpsCounter(QObject* parent) : QObject(parent)
 {
 
 }
@@ -12,63 +13,59 @@ FpsCounter::~FpsCounter()
 
 }
 
-void FpsCounter::fpsCounterInit()
+void FpsCounter::start()
 {
-    m_started = false;
-    // no need to initialize the other fields, they are meaningful only when
-    // started is true
+    resetCounter();
+    startCounterTimer();
 }
 
-void FpsCounter::fpsCounterStart()
+void FpsCounter::stop()
 {    
-    m_started = true;
-    m_timeCounter.start();
-    m_rendered = 0;
-#ifdef SKIP_FRAMES
-    m_skipped = 0;
-#endif
+    stopCounterTimer();
+    resetCounter();
 }
 
-void FpsCounter::fpsCounterStop()
+bool FpsCounter::isStarted()
 {
-    m_started = false;
+    return m_counterTimer;
 }
 
-void FpsCounter::fpsCounterAddRenderedFrame()
+void FpsCounter::addRenderedFrame()
 {
-    checkExpired();
     m_rendered++;
 }
 
-void FpsCounter::checkExpired()
+void FpsCounter::addSkippedFrame()
 {
-    if (m_timeCounter.elapsed() >= 1000) {
-        displayFps();
-        m_timeCounter.restart();
-        m_rendered = 0;
-#ifdef SKIP_FRAMES
-        m_skipped = 0;
-#endif
-       }
+    m_skipped++;
 }
 
-void FpsCounter::displayFps()
+void FpsCounter::timerEvent(QTimerEvent *event)
 {
-#ifdef SKIP_FRAMES
-    if (m_skipped) {
-        //qInfo << "%d fps (+%d frames skipped)", m_rendered, m_skipped);
-    } else {
-#endif
-    //qInfo m_rendered << "fps";
-#ifdef SKIP_FRAMES
+    if (event && m_counterTimer == event->timerId()) {
+        m_curRendered = m_rendered;
+        m_curSkipped = m_skipped;
+        resetCounter();
+        qInfo("FPS:%d Discard:%d", m_curRendered, m_skipped);
     }
-#endif
 }
 
-#ifdef SKIP_FRAMES
-void FpsCounter::fpsCounterAddSkippedFrame()
+void FpsCounter::startCounterTimer()
 {
-    checkExpired();
-    m_skipped++;
+    stopCounterTimer();
+    m_counterTimer = startTimer(1000);
+}
+
+void FpsCounter::stopCounterTimer()
+{
+    if (m_counterTimer) {
+        killTimer(m_counterTimer);
+        m_counterTimer = 0;
+    }
+}
+
+void FpsCounter::resetCounter()
+{
+    m_rendered = 0;
+    m_skipped = 0;
 }
-#endif

src/fpscounter.h

@@ -1,32 +1,35 @@
 #ifndef FPSCOUNTER_H
 #define FPSCOUNTER_H
-#include <QTime>
+#include <QObject>
 
-class FpsCounter
+class FpsCounter : public QObject
 {
+    Q_OBJECT
 public:
-    FpsCounter();
+    FpsCounter(QObject* parent = Q_NULLPTR);
     virtual ~FpsCounter();
 
-    void fpsCounterInit();
-    void fpsCounterStart();
-    void fpsCounterStop();
-    void fpsCounterAddRenderedFrame();
-#ifdef SKIP_FRAMES
-    void fpsCounterAddSkippedFrame();
-#endif
+    void start();
+    void stop();
+    bool isStarted();
+    void addRenderedFrame();
+    void addSkippedFrame();
+
+protected:
+    virtual void timerEvent(QTimerEvent *event);
 
 private:
-    void checkExpired();
-    void displayFps();
+    void startCounterTimer();
+    void stopCounterTimer();
+    void resetCounter();
 
 private:    
-    bool m_started = false;
-    QTime m_timeCounter;
+    quint32 m_counterTimer = 0;
+    quint32 m_curRendered = 0;
+    quint32 m_curSkipped = 0;
+
     quint32 m_rendered = 0;
-#ifdef SKIP_FRAMES
     quint32 m_skipped = 0;
-#endif
 };
 
 #endif // FPSCOUNTER_H

src/frames.cpp

@@ -30,6 +30,8 @@ bool Frames::init()
     // there is initially no rendering frame, so consider it has already been
     // consumed
     m_renderingFrameConsumed = true;
+
+    m_fpsCounter.start();
     return true;
 
 error:
@@ -47,6 +49,7 @@ void Frames::deInit()
         av_frame_free(&m_renderingframe);
         m_renderingframe = Q_NULLPTR;
     }
+    m_fpsCounter.stop();
 }
 
 void Frames::lock()
@@ -75,7 +78,9 @@ bool Frames::offerDecodedFrame()
         m_renderingFrameConsumedCond.wait(&m_mutex);
     }    
 #else
-
+    if (m_fpsCounter.isStarted() && !m_renderingFrameConsumed) {
+        m_fpsCounter.addSkippedFrame();
+    }
 #endif
 
     swap();
@@ -89,7 +94,9 @@ const AVFrame *Frames::consumeRenderedFrame()
 {
     Q_ASSERT(!m_renderingFrameConsumed);
     m_renderingFrameConsumed = true;
-
+    if (m_fpsCounter.isStarted()) {
+        m_fpsCounter.addRenderedFrame();
+    }
 #ifndef SKIP_FRAMES
     // if SKIP_FRAMES is disabled, then notify the decoder the current frame is
     // consumed, so that it may push a new one

src/frames.h

@@ -3,6 +3,8 @@
 #include <QMutex>
 #include <QWaitCondition>
 
+#include "fpscounter.h"
+
 // forward declarations
 typedef struct AVFrame AVFrame;
 
@@ -40,6 +42,7 @@ private:
     AVFrame* m_renderingframe = Q_NULLPTR;
     QMutex m_mutex;
     bool m_renderingFrameConsumed = true;
+    FpsCounter m_fpsCounter;
 
 #ifndef SKIP_FRAMES
     QWaitCondition m_renderingFrameConsumedCond;