Max comments

IPTVUtils.pro

@@ -5,6 +5,7 @@
 #-------------------------------------------------
 
 QT       += core gui network
+QT       += core gui charts
 
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
@@ -61,7 +62,11 @@ SOURCES += \
     Analyzer/tsanalyzer.cpp \
     playbackwidget.cpp \
     recordwidget.cpp \
-    convertwidget.cpp
+    convertwidget.cpp \
+    Middleware/networkjitter.cpp \
+    recordwidgetgraph.cpp \
+    chart.cpp \
+    recordtxtprinter.cpp
 
 HEADERS += \
         mainwindow.h \
@@ -110,7 +115,11 @@ HEADERS += \
     recordwidget.h \
     convertwidget.h \
     Status/streamid.h \
-    Status/workerstatus.h
+    Status/workerstatus.h \
+    Middleware/networkjitter.h \
+    recordwidgetgraph.h \
+    chart.h \
+    recordtxtprinter.h
 
 FORMS += \
         mainwindow.ui \

Middleware/analyzerpcapmiddleware.cpp

@@ -14,6 +14,7 @@ void AnalyzerPcapMiddleware::init() {
     this->moveToThread(&runnerThread);
     connect(&runnerThread, &QThread::started, this, &AnalyzerPcapMiddleware::run);
     connect(this, &AnalyzerPcapMiddleware::finished, &runnerThread, &QThread::quit);
+
 }
 
 void AnalyzerPcapMiddleware::start() {
@@ -34,9 +35,10 @@ void AnalyzerPcapMiddleware::run() {
     this->thread()->quit();
 }
 
+
 // Buffers packets
 void AnalyzerPcapMiddleware::bufferProducts() {
-    QElapsedTimer statusTimer;
+    QTime statusTimer;
     statusTimer.start();
     packetNumber = 0;
 
@@ -56,7 +58,10 @@ void AnalyzerPcapMiddleware::bufferProducts() {
 
     PcapProduct input;
 
+
     while (!stopping) {
+
+
         input = prevProvider->getProduct();
         if (input.type == PcapProduct::NORMAL && !hasLooped) {
             PacketParser parser((pcap_pkthdr*)input.header.data(), (const u_char*)input.data.data());
@@ -65,28 +70,27 @@ void AnalyzerPcapMiddleware::bufferProducts() {
             if (startTime == -1) {
                 startTime = ((pcap_pkthdr*)input.header.data())->ts.tv_sec * 1000; // convert to ms
                 startTime += ((pcap_pkthdr*)input.header.data())->ts.tv_usec/1000; // convert to ms
+                lastDuration = 0;
             }
             else {
                 endTime = ((pcap_pkthdr*)input.header.data())->ts.tv_sec*1000;
                 endTime += ((pcap_pkthdr*)input.header.data())->ts.tv_usec/1000; // convert to ms
                 duration = endTime - startTime;
                 if (lastDuration == 0)
                     lastDuration = duration;
-            }
 
-            // 1 second of trafic, calculate bitrate for that second
-
-            if (duration - lastDuration >= 1000) {
-                bitrate = (bytes - lastSecondBytes)*8*1000/(duration - lastDuration);
-                lastSecondBytes = bytes;
-                lastDuration = duration;
+                // 1 second of trafic, calculate bitrate for that second
 
+                if (duration - lastDuration >= emitFrequency) {
+                    bitrate = (bytes - lastSecondBytes)*8*1000/(duration - lastDuration);
+                    lastSecondBytes = bytes;
+     //               lastDuration = duration;
+                }
             }
 
             // sanity check, prevents analyzation of packets that do not contain ts-packets
             if (parser.data_len % 188 == 0 && parser.ih->proto == 17 && parser.data_len != 0) {
 
-
                 tsPerIp = parser.data_len/188;
 
                 // For now, assume the only existing protocols
@@ -112,13 +116,14 @@ void AnalyzerPcapMiddleware::bufferProducts() {
                 else
                     stream.bitrateMode = StreamInfo::BitrateMode::VBR;
 
-                stream.id = StreamId(streamId);
-                stream.bytes += parser.data_len;
-                stream.tsPerIp = tsPerIp;
-                stream.currentTime = duration;
-
-                tsAnalyzer.setStream(&stream.tsErrors, &stream.pidMap);
+                //if (duration - stream.lastDuration >= 200)
+                    stream.id = StreamId(streamId);
+                    stream.bytes += parser.data_len;
+                    stream.tsPerIp = tsPerIp;
+                    stream.currentTime = duration;
 
+                    tsAnalyzer.setStream(&stream.tsErrors, &stream.pidMap);
+           //     }
                 // Analyze every TsPacket
                 for (quint8 i = 0; i < tsPerIp; i++) {
                     tsParser.parse((quint8*)(parser.data+i*188));
@@ -135,15 +140,12 @@ void AnalyzerPcapMiddleware::bufferProducts() {
                     }
                     else {
 
-
                     }
                 }
 
                 // case 1: sanity check true
                 buffer.push(input);
                 packetNumber++;
-
-
             }
             else {
 
@@ -153,7 +155,7 @@ void AnalyzerPcapMiddleware::bufferProducts() {
             }
 
         }
-        else if (input.type == PcapProduct::LOOP) {
+        else if (input.type == PcapProduct::LOOP || input.type == PcapProduct::END) {
             hasLooped = true;
 
             buffer.push(input);
@@ -162,10 +164,36 @@ void AnalyzerPcapMiddleware::bufferProducts() {
         }
 
 
-        if (statusTimer.elapsed() >= 200) {
+
+
+
+
+
+        if (lastDuration > 1000000000){
+            lastDuration = 0;
+        }
+
+
+        if (duration - lastDuration >= emitFrequency) {
+
+            lastDuration = duration;
+
+            for (auto &stream : streams) {
+
+                stream.avgBitrate =  ((double)stream.bytes*8*1000.0/stream.currentTime) /1000000.0;
+                stream.currentBitrate = (double)(stream.bytes - stream.lastSecondBytes)*8*1000/(duration - stream.lastDuration) / 1000000;
+                stream.lastSecondBytes = stream.bytes;
+                stream.lastDuration = duration;
+            }
+
             emit status(AnalyzerStatus(Status::STATUS_PERIODIC, bytes, duration, bitrate, duration, pidMap, tsErrors, proto, tsPerIp));
-            emit workerStatus(WorkerStatus(WorkerStatus::STATUS_PERIODIC, streams));
+            if(bitrate / 1000000 < 100){
+                emit bitrateStatus((double) bitrate /1000000,  duration );
+
+            }
+
             statusTimer.restart();
+            emit workerStatus(WorkerStatus(WorkerStatus::STATUS_PERIODIC, streams), false);
         }
 
         if (input.type == PcapProduct::END || input.type == PcapProduct::STOP) {
@@ -175,12 +203,12 @@ void AnalyzerPcapMiddleware::bufferProducts() {
     qInfo("Analyzer done, processed %lli packets", packetNumber-1);
     emit status(AnalyzerStatus(Status::STATUS_FINISHED, bytes, duration, bitrate, duration, pidMap, tsErrors, proto, tsPerIp));
 
-    emit workerStatus(WorkerStatus(WorkerStatus::STATUS_FINISHED, streams));
+    emit workerStatus(WorkerStatus(WorkerStatus::STATUS_FINISHED, streams), false);
     if (input.type == PcapProduct::END &&
             (config.getWorkerMode() == WorkerConfiguration::ANALYSIS_MODE_LIVE ||
              config.getWorkerMode() == WorkerConfiguration::ANALYSIS_MODE_OFFLINE)) {
 
-        emit workerStatus(WorkerStatus(WorkerStatus::STATUS_ANALYZED_ENTIRE, streams));
+        emit workerStatus(WorkerStatus(WorkerStatus::STATUS_ANALYZED_ENTIRE, streams), false);
     }
 }
 

Middleware/analyzerpcapmiddleware.h

@@ -16,6 +16,8 @@ class AnalyzerPcapMiddleware : public PcapMiddleware
 {
     Q_OBJECT
 private:
+    double currentIatDev;
+    qint64 currentIatDevTimestamp;
     ConcurrentQueue<PcapProduct> buffer;
     TsParser tsParser;
     TsAnalyzer tsAnalyzer;
@@ -41,6 +43,7 @@ class AnalyzerPcapMiddleware : public PcapMiddleware
 
 signals:
     void status(AnalyzerStatus status);
+    void bitrateStatus(double bitrate, qint64 duration);
 
 protected slots:
     void run();

Middleware/networkjitter.cpp

@@ -0,0 +1,160 @@
+#include "networkjitter.h"
+#include <QElapsedTimer>
+
+#include <iostream>
+#include "Status/streamid.h"
+#include "Status/streaminfo.h"
+#include "packetparser.h"
+#include "tsparser.h"
+#include <QDebug>
+#include <QtMath>
+
+//This class is for measuring network jitter
+
+void NetworkJitter::init() {
+    this->moveToThread(&runnerThread);
+    connect(&runnerThread, &QThread::started, this, &NetworkJitter::run);
+    connect(this, &NetworkJitter::finished, &runnerThread, &QThread::quit);
+}
+
+
+void NetworkJitter::run(){
+
+    emit started();
+    QElapsedTimer statusTimer;
+    statusTimer.start();
+
+    packetNumber = 0;
+
+
+    qint64 inputTs = 0;
+    qint64 previousInputTs = 0;
+    qint64 difference = 0;
+    qint64 differencePerSec = 0;
+    qint64 packetCounter = 0;
+    qint16 diffratePerSec = 0;
+
+    qint64 diffSum = 0;
+    qint64 finalSum = 0;
+    qint64 startTime = -1;
+    qint64 endTime = -1;
+
+
+    QList<qint16> distanceList;
+    qint64 bytes = 0;
+    PcapProduct input;
+
+    PcapProduct previousInput = prevProvider->getProduct();
+
+    buffer.push(previousInput);
+
+    while (!stopping) {
+        PacketParser parser((pcap_pkthdr*)input.header.data(), (const u_char*)input.data.data());
+        bytes += parser.data_len;
+        input = prevProvider->getProduct();
+
+        {
+
+            PacketParser parser((pcap_pkthdr*)input.header.data(), (const u_char*)input.data.data());
+            bytes += parser.data_len;
+
+            // Takes packet Timestamp and compares it to the previous one to calculate difference.
+            inputTs = ((pcap_pkthdr*)input.header.data())->ts.tv_sec * 1000000;
+            inputTs += ((pcap_pkthdr*)input.header.data())->ts.tv_usec;
+
+            previousInputTs = ((pcap_pkthdr*)previousInput.header.data())->ts.tv_sec * 1000000;
+            previousInputTs += ((pcap_pkthdr*)previousInput.header.data())->ts.tv_usec;
+
+
+
+            if (startTime == -1) {
+                startTime = ((pcap_pkthdr*)input.header.data())->ts.tv_sec * 1000; // convert to ms
+                startTime += ((pcap_pkthdr*)input.header.data())->ts.tv_usec/1000; // convert to ms
+            }
+            else {
+                endTime = ((pcap_pkthdr*)input.header.data())->ts.tv_sec*1000;
+                endTime += ((pcap_pkthdr*)input.header.data())->ts.tv_usec/1000; // convert to ms
+                duration = endTime - startTime;
+
+            }
+
+
+
+
+
+            difference = inputTs - previousInputTs;
+            differencePerSec += difference;
+            distanceList.append(difference);
+
+            //Calculate average diff per second and IAT standard deviation per millisecond
+
+            if(statusTimer.elapsed() >= emitFrequency){
+                // If no packages recieved, wait(?)
+                if(packetCounter != 0){
+                diffratePerSec = differencePerSec/packetCounter;
+                }
+
+                for( int a = 0; a < distanceList.length(); a = a + 1 ) {
+
+                    diffSum += ((distanceList[a] - diffratePerSec) * (distanceList[a] - diffratePerSec));
+                }
+
+                // sqrt of finalSum is equal to the IAT dev
+
+                finalSum = diffSum/ distanceList.length();
+
+
+
+                quint64 streamId = StreamId::calcId(parser.ih->daddr, parser.dport);
+                StreamInfo &stream = streams[streamId];
+
+
+                stream.iatDeviation = sqrt(finalSum);
+
+                emit iatStatus(sqrt(finalSum), duration);
+
+                 emit workerStatus(WorkerStatus(WorkerStatus::STATUS_PERIODIC, streams), true);
+
+
+
+                packetCounter = 0;
+                diffSum = 0;
+                finalSum = 0;
+                distanceList.clear();
+
+
+                differencePerSec = 0;
+                statusTimer.restart();
+
+            }
+
+        }
+        previousInput = input;
+        buffer.push(input);
+        packetNumber++;
+        packetCounter ++;
+
+        if (input.type == PcapProduct::END || input.type == PcapProduct::STOP) {
+            break;
+        }
+
+    }
+    emit finished();
+}
+
+
+
+void NetworkJitter::start() {
+    runnerThread.start();
+}
+
+
+PcapProduct NetworkJitter::getProduct() {
+    return buffer.pop();
+}
+
+
+void NetworkJitter::stop() {
+    stopping = true;
+    buffer.stop();
+}