throughput calculation in FetchLoader

samples/dash-if-reference-player/index.html

@@ -314,14 +314,14 @@
                         <label data-toggle="tooltip" data-placement="right"
                                title="Default fetch throughput calculation for low latency streaming based on downloaded data chunks.">
                             <input type="radio" id="abrFetchThroughputCalculationDownloadedData" autocomplete="off"
-                                   checked="checked" name="abrFetchThroughputCalculation"
+                                    name="abrFetchThroughputCalculation"
                                    ng-click="changeFetchThroughputCalculation('abrFetchThroughputCalculationDownloadedData')">
                             Data chunks
                         </label>
                         <label data-toggle="tooltip" data-placement="right"
                                title="LoL+ fetch throughput calculation for low latency streaming based on moof parsing.">
                             <input type="radio" id="abrFetchThroughputCalculationMoofParsing" autocomplete="off"
-                                   name="abrFetchThroughputCalculation"
+                                   checked="checked" name="abrFetchThroughputCalculation"
                                    ng-click="changeFetchThroughputCalculation('abrFetchThroughputCalculationMoofParsing')">
                             moof parsing
                         </label>

src/core/Settings.js

@@ -870,7 +870,7 @@ function Settings() {
                     audio: true,
                     video: true
                 },
-                fetchThroughputCalculationMode: Constants.ABR_FETCH_THROUGHPUT_CALCULATION_DOWNLOADED_DATA
+                fetchThroughputCalculationMode: Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING
             },
             cmcd: {
                 enabled: false,

src/streaming/models/MetricsModel.js

@@ -116,12 +116,13 @@ function MetricsModel(config) {
         }
     }
 
-    function appendHttpTrace(httpRequest, s, d, b) {
+    function appendHttpTrace(httpRequest, s, d, b, t) {
         let vo = new HTTPRequestTrace();
 
         vo.s = s;
         vo.d = d;
         vo.b = b;
+        vo.t = t;
 
         httpRequest.trace.push(vo);
 
@@ -185,7 +186,7 @@ function MetricsModel(config) {
 
         if (traces) {
             traces.forEach(trace => {
-                appendHttpTrace(vo, trace.s, trace.d, trace.b);
+                appendHttpTrace(vo, trace.s, trace.d, trace.b, trace.t);
             });
         } else {
             // The interval and trace shall be absent for redirect and failure records.

src/streaming/net/FetchLoader.js

@@ -153,11 +153,17 @@ function FetchLoader(cfg) {
                         // If there is pending data, call progress so network metrics
                         // are correctly generated
                         // Same structure as https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequestEventTarget/
+                        let calculatedThroughput = null;
+                        if (calculationMode === Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING) {
+                            calculatedThroughput = calculateThroughputByChunkData(startTimeData, endTimeData);
+                        }
+
                         httpRequest.progress({
                             loaded: bytesReceived,
                             total: isNaN(totalBytes) ? bytesReceived : totalBytes,
                             lengthComputable: true,
-                            time: calculateDownloadedTime(calculationMode, startTimeData, endTimeData, downloadedData, bytesReceived),
+                            time: calculateDownloadedTime(downloadedData, bytesReceived),
+                            throughput: calculatedThroughput,
                             stream: true
                         });
 
@@ -195,7 +201,7 @@ function FetchLoader(cfg) {
                         const end = boxesInfo.lastCompletedOffset + boxesInfo.size;
 
                         // Store the end time of each chunk download  with its size in array EndTimeData
-                        if (calculationMode === Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING) {
+                        if (calculationMode === Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING && !lastChunkWasFinished) {
                             lastChunkWasFinished = true;
                             endTimeData.push({
                                 ts: performance.now(), /* jshint ignore:line */
@@ -285,43 +291,7 @@ function FetchLoader(cfg) {
         }
     }
 
-    // Compute the download time of a segment
-    function calculateDownloadedTime(calculationMode, startTimeData, endTimeData, downloadedData, bytesReceived) {
-        switch (calculationMode) {
-            case Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING:
-                return _calculateDownloadedTimeByMoofParsing(startTimeData, endTimeData);
-            case Constants.ABR_FETCH_THROUGHPUT_CALCULATION_DOWNLOADED_DATA:
-                return _calculateDownloadedTimeByBytesReceived(downloadedData, bytesReceived);
-            default:
-                return _calculateDownloadedTimeByBytesReceived(downloadedData, bytesReceived);
-        }
-    }
-
-    function _calculateDownloadedTimeByMoofParsing(startTimeData, endTimeData) {
-        try {
-            let datum, datumE;
-            // Filter the first and last chunks in a segment in both arrays [StartTimeData and EndTimeData]
-            datum = startTimeData.filter((data, i) => i > 0 && i < startTimeData.length - 1);
-            datumE = endTimeData.filter((dataE, i) => i > 0 && i < endTimeData.length - 1);
-            // Compute the download time of a segment based on the filtered data [last chunk end time - first chunk beginning time]
-            let segDownloadTime = 0;
-            if (datum.length > 1) {
-                for (let i = 0; i < datum.length; i++) {
-                    if (datum[i] && datumE[i]) {
-                        let chunkDownladTime = datumE[i].ts - datum[i].ts;
-                        segDownloadTime += chunkDownladTime;
-                    }
-                }
-
-                return segDownloadTime;
-            }
-            return null;
-        } catch (e) {
-            return null;
-        }
-    }
-
-    function _calculateDownloadedTimeByBytesReceived(downloadedData, bytesReceived) {
+    function calculateDownloadedTime(downloadedData, bytesReceived) {
         try {
             downloadedData = downloadedData.filter(data => data.bytes > ((bytesReceived / 4) / downloadedData.length));
             if (downloadedData.length > 1) {
@@ -343,6 +313,51 @@ function FetchLoader(cfg) {
         }
     }
 
+    function calculateThroughputByChunkData(startTimeData, endTimeData) {
+        try {
+            let datum, datumE;
+            // Filter the last chunks in a segment in both arrays [StartTimeData and EndTimeData]
+            datum = startTimeData.filter((data, i) => i < startTimeData.length - 1);
+            datumE = endTimeData.filter((dataE, i) => i < endTimeData.length - 1);
+            let chunkThroughputs = [];
+            // Compute the average throughput of the filtered chunk data
+            if (datum.length > 1) {
+                let shortDurationBytesReceived = 0;
+                let shortDurationStartTime = 0;
+                for (let i = 0; i < datum.length; i++) {
+                    if (datum[i] && datumE[i]) {
+                        let chunkDownloadTime = datumE[i].ts - datum[i].ts;
+                        if (chunkDownloadTime > 1) {
+                            chunkThroughputs.push((8 * datumE[i].bytes) / chunkDownloadTime);
+                        } else {
+                            if (shortDurationStartTime === 0) {
+                                shortDurationStartTime = datum[i].ts;
+                            }
+                            let cumulatedChunkDownloadTime = datumE[i].ts - shortDurationStartTime;
+                            if (cumulatedChunkDownloadTime > 1) {
+                                chunkThroughputs.push((8 * shortDurationBytesReceived) / cumulatedChunkDownloadTime);
+                                shortDurationBytesReceived = 0;
+                                shortDurationStartTime = 0;
+                            } else {
+                                // continue cumulating short duration data
+                                shortDurationBytesReceived += datumE[i].bytes;
+                            }
+                        }
+                    }
+                }
+
+                if (chunkThroughputs.length > 0) {
+                    const sumOfChunkThroughputs = chunkThroughputs.reduce((a, b) => a + b, 0);
+                    return sumOfChunkThroughputs / chunkThroughputs.length;
+                }
+            }
+
+            return null;
+        } catch (e) {
+            return null;
+        }
+    }
+
     instance = {
         load: load,
         abort: abort,

src/streaming/net/HTTPLoader.js

@@ -201,7 +201,8 @@ function HTTPLoader(cfg) {
                 traces.push({
                     s: lastTraceTime,
                     d: event.time ? event.time : currentTime.getTime() - lastTraceTime.getTime(),
-                    b: [event.loaded ? event.loaded - lastTraceReceivedCount : 0]
+                    b: [event.loaded ? event.loaded - lastTraceReceivedCount : 0],
+                    t: event.throughput
                 });
 
                 lastTraceTime = currentTime;

src/streaming/rules/ThroughputHistory.js

@@ -62,8 +62,11 @@ function ThroughputHistory(config) {
 
     function setup() {
         ewmaHalfLife = {
-            throughputHalfLife: { fast: EWMA_THROUGHPUT_FAST_HALF_LIFE_SECONDS, slow: EWMA_THROUGHPUT_SLOW_HALF_LIFE_SECONDS },
-            latencyHalfLife:    { fast: EWMA_LATENCY_FAST_HALF_LIFE_COUNT,      slow: EWMA_LATENCY_SLOW_HALF_LIFE_COUNT }
+            throughputHalfLife: {
+                fast: EWMA_THROUGHPUT_FAST_HALF_LIFE_SECONDS,
+                slow: EWMA_THROUGHPUT_SLOW_HALF_LIFE_SECONDS
+            },
+            latencyHalfLife: { fast: EWMA_LATENCY_FAST_HALF_LIFE_COUNT, slow: EWMA_LATENCY_SLOW_HALF_LIFE_COUNT }
         };
 
         reset();
@@ -86,14 +89,23 @@ function ThroughputHistory(config) {
         const downloadTimeInMilliseconds = (httpRequest._tfinish.getTime() - httpRequest.tresponse.getTime()) || 1; //Make sure never 0 we divide by this value. Avoid infinity!
         const downloadBytes = httpRequest.trace.reduce((a, b) => a + b.b[0], 0);
 
-        let throughputMeasureTime;
+        let throughputMeasureTime = 0, throughput = 0;
         if (settings.get().streaming.lowLatencyEnabled) {
-            throughputMeasureTime = httpRequest.trace.reduce((a, b) => a + b.d, 0);
+            const calculationMode = settings.get().streaming.abr.fetchThroughputCalculationMode;
+            if (calculationMode === Constants.ABR_FETCH_THROUGHPUT_CALCULATION_MOOF_PARSING) {
+                const sumOfThroughputValues = httpRequest.trace.reduce((a, b) => a + b.t, 0);
+                throughput = Math.round(sumOfThroughputValues / httpRequest.trace.length);
+            }
+            if (throughput === 0) {
+                throughputMeasureTime = httpRequest.trace.reduce((a, b) => a + b.d, 0);
+            }
         } else {
             throughputMeasureTime = useDeadTimeLatency ? downloadTimeInMilliseconds : latencyTimeInMilliseconds + downloadTimeInMilliseconds;
         }
 
-        const throughput = Math.round((8 * downloadBytes) / throughputMeasureTime); // bits/ms = kbits/s
+        if (throughputMeasureTime !== 0) {
+            throughput = Math.round((8 * downloadBytes) / throughputMeasureTime); // bits/ms = kbits/s
+        }
 
         checkSettingsForMediaType(mediaType);
 
@@ -225,8 +237,12 @@ function ThroughputHistory(config) {
     function checkSettingsForMediaType(mediaType) {
         throughputDict[mediaType] = throughputDict[mediaType] || [];
         latencyDict[mediaType] = latencyDict[mediaType] || [];
-        ewmaThroughputDict[mediaType] = ewmaThroughputDict[mediaType] || {fastEstimate: 0, slowEstimate: 0, totalWeight: 0};
-        ewmaLatencyDict[mediaType] = ewmaLatencyDict[mediaType] || {fastEstimate: 0, slowEstimate: 0, totalWeight: 0};
+        ewmaThroughputDict[mediaType] = ewmaThroughputDict[mediaType] || {
+            fastEstimate: 0,
+            slowEstimate: 0,
+            totalWeight: 0
+        };
+        ewmaLatencyDict[mediaType] = ewmaLatencyDict[mediaType] || { fastEstimate: 0, slowEstimate: 0, totalWeight: 0 };
     }
 
     function clearSettingsForMediaType(mediaType) {

src/streaming/vo/metrics/HTTPRequest.js

@@ -155,6 +155,11 @@ class HTTPRequestTrace {
          * @public
          */
         this.b = [];
+        /**
+         * Measurement throughput in kbits/s
+         * @public
+         */
+         this.t = null;
     }
 }