Add the content length mismatch warning

Author: robertbryer

index.d.ts

@@ -2049,6 +2049,8 @@ export interface MediaPlayerClass {
 
     on(type: LogEvent['type'], listener: (e: LogEvent) => void, scope?: object): void;
 
+    on(type: FragmentContentLengthMismatch['type'], listener: (e: FragmentContentLengthMismatch) => void, scope?: object): void;
+
     on(type: ManifestLoadedEvent['type'], listener: (e: ManifestLoadedEvent) => void, scope?: object): void;
 
     on(type: MetricEvent['type'], listener: (e: MetricEvent) => void, scope?: object): void;
@@ -2432,6 +2434,7 @@ export interface MediaPlayerEvents {
     KEY_SESSION_UPDATED: 'public_keySessionUpdated';
     LICENSE_REQUEST_COMPLETE: 'public_licenseRequestComplete';
     LICENSE_REQUEST_SENDING: 'public_licenseRequestSending';
+    FRAGMENT_CONTENT_LENGTH_MISMATCH: 'fragmentContentLengthMismatch';
     LOG: 'log';
     MANIFEST_LOADED: 'manifestLoaded';
     MANIFEST_LOADING_STARTED: 'manifestLoadingStarted';
@@ -2712,6 +2715,14 @@ export interface LogEvent extends MediaPlayerEvent {
     type: MediaPlayerEvents['LOG'];
 }
 
+export interface FragmentContentLengthMismatch extends MediaPlayerEvent {
+    type: MediaPlayerEvents['FRAGMENT_CONTENT_LENGTH_MISMATCH'];
+    responseUrl: string;
+    mediaType: string;
+    headerLength: number;
+    bodyLength: number;
+}
+
 export interface ManifestLoadedEvent extends MediaPlayerEvent {
     data: object;
     type: MediaPlayerEvents['MANIFEST_LOADED'];

src/streaming/MediaPlayerEvents.js

@@ -493,6 +493,12 @@ class MediaPlayerEvents extends EventsBase {
          * @type {string}
          */
         this.MANAGED_MEDIA_SOURCE_END_STREAMING = 'managedMediaSourceEndStreaming';
+
+        /**
+         * Triggered when the 'Content-Length' header for a fragment does not match the byte length.
+         * @event MediaPlayerEvents#FRAGMENT_CONTENT_LENGTH_MISMATCH
+         */
+        this.FRAGMENT_CONTENT_LENGTH_MISMATCH = 'fragmentContentLengthMismatch';
     }
 }
 

src/streaming/net/HTTPLoader.js

@@ -45,6 +45,7 @@ import CommonAccessTokenController from '../controllers/CommonAccessTokenControl
 import ExtUrlQueryInfoController from '../controllers/ExtUrlQueryInfoController.js';
 import CommonMediaRequest from '../vo/CommonMediaRequest.js';
 import CommonMediaResponse from '../vo/CommonMediaResponse.js';
+import MediaPlayerEvents from '../MediaPlayerEvents.js';
 
 /**
  * @module HTTPLoader
@@ -267,6 +268,15 @@ function HTTPLoader(cfg) {
                 // GET requests still need a body since dash.js consumes it (manifests, segments).
                 const hasUsableBody = !!commonMediaResponse.data || requestObject.method === HTTPRequest.POST;
                 if (commonMediaResponse.status >= 200 && commonMediaResponse.status <= 299 && hasUsableBody) {
+                    if (hasContentLengthMismatch(commonMediaResponse)) {
+                        const responseUrl = commonMediaResponse.url;
+                        const mediaType = requestObject.mediaType
+                        const headerLength = commonMediaResponse.headers['content-length'];
+                        const bodyLength = commonMediaResponse.data.byteLength;
+
+                        eventBus.trigger(MediaPlayerEvents.FRAGMENT_CONTENT_LENGTH_MISMATCH, { responseUrl, mediaType, headerLength, bodyLength });
+                    }
+
                     if (config.success) {
                         config.success(commonMediaResponse.data, commonMediaResponse.statusText, commonMediaResponse.url);
                     }
@@ -687,6 +697,19 @@ function HTTPLoader(cfg) {
         }
     }
 
+    function hasContentLengthMismatch(response) {
+        if (response && response.data && response.headers) {
+            const headerLength = response.headers['content-length'];
+            const dataLength = response.data.byteLength;
+
+            if (headerLength && dataLength && Math.abs(dataLength - headerLength) > headerLength * 0.25) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     function reset() {
         httpRequests = [];
         delayedRequests = [];

test/unit/test/streaming/streaming.net.HTTPLoader.js

@@ -8,6 +8,8 @@ import {HTTPRequest} from '../../../../src/streaming/vo/metrics/HTTPRequest.js';
 import Settings from '../../../../src/core/Settings.js';
 import CmcdController from '../../../../src/streaming/controllers/CmcdController.js';
 import ClientDataReportingController from '../../../../src/streaming/controllers/ClientDataReportingController.js';
+import EventBus from '../../../../src/core/EventBus.js';
+import MediaPlayerEvents from '../../../../src/streaming/MediaPlayerEvents.js';
 
 import {expect} from 'chai';
 import {fakeXhr} from 'nise';
@@ -203,6 +205,48 @@ describe('HTTPLoader', function () {
         requests[0].respond(200);
     });
 
+    it('Emits a FRAGMENT_CONTENT_LENGTH_MISMATCH event when Content-Length does not match actual length of response', async () => {
+        const eventBus = EventBus(context).getInstance();
+        const spy = sinon.spy();
+        let resolveOnComplete;
+        const completePromise = new Promise((resolve) => {
+            resolveOnComplete = resolve;
+        });
+
+        eventBus.on(MediaPlayerEvents.FRAGMENT_CONTENT_LENGTH_MISMATCH, spy, null);
+
+        const callbacks = _createCallbacks();
+        callbacks.complete = sinon.spy(() => resolveOnComplete());
+
+        httpLoader = _createHttpLoader();
+        const originalLoad = httpLoader.load;
+        httpLoader.load = new Proxy(originalLoad, {
+            apply(target, thisArg, args) {
+                const result = Reflect.apply(target, thisArg, args);
+
+                result.then(() => {
+                    requests[0].respond(200, { 'content-length': 15 }, '0'.repeat(8));
+                });
+
+                return result;
+            }
+        });
+
+        await httpLoader.load({
+            request: {
+                responseType: 'arraybuffer',
+                type: HTTPRequest.MEDIA_SEGMENT_TYPE,
+                availabilityTimeComplete: true
+            },
+            success: callbacks.success,
+            complete: callbacks.complete,
+            error: callbacks.error
+        });
+        await completePromise;
+
+        expect(spy.calledOnce).to.be.true;
+    });
+
     describe('request timeout selection', function () {
         [
             {