/**
* The copyright in this software is being made available under the BSD License,
* included below. This software may be subject to other third party and contributor
* rights, including patent rights, and no such rights are granted under this license.
*
* Copyright (c) 2013, Dash Industry Forum.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation and/or
* other materials provided with the distribution.
* * Neither the name of Dash Industry Forum nor the names of its
* contributors may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
import XHRLoader from './XHRLoader';
import FetchLoader from './FetchLoader';
import {HTTPRequest} from '../vo/metrics/HTTPRequest';
import FactoryMaker from '../../core/FactoryMaker';
import DashJSError from '../vo/DashJSError';
import CmcdModel from '../models/CmcdModel';
import CmsdModel from '../models/CmsdModel';
import Utils from '../../core/Utils';
import Debug from '../../core/Debug';
import EventBus from '../../core/EventBus';
import Events from '../../core/events/Events';
import Settings from '../../core/Settings';
import Constants from '../constants/Constants';
import LowLatencyThroughputModel from '../models/LowLatencyThroughputModel';
import CustomParametersModel from '../models/CustomParametersModel';
/**
* @module HTTPLoader
* @ignore
* @description Manages download of resources via HTTP.
* @param {Object} cfg - dependencies from parent
*/
function HTTPLoader(cfg) {
cfg = cfg || {};
const context = this.context;
const errHandler = cfg.errHandler;
const dashMetrics = cfg.dashMetrics;
const mediaPlayerModel = cfg.mediaPlayerModel;
const requestModifier = cfg.requestModifier;
const boxParser = cfg.boxParser;
const errors = cfg.errors;
const requestTimeout = cfg.requestTimeout || 0;
const eventBus = EventBus(context).getInstance();
const settings = Settings(context).getInstance();
let instance,
requests,
delayedRequests,
retryRequests,
downloadErrorToRequestTypeMap,
cmcdModel,
cmsdModel,
customParametersModel,
lowLatencyThroughputModel,
logger;
function setup() {
logger = Debug(context).getInstance().getLogger(instance);
requests = [];
delayedRequests = [];
retryRequests = [];
cmcdModel = CmcdModel(context).getInstance();
cmsdModel = CmsdModel(context).getInstance();
lowLatencyThroughputModel = LowLatencyThroughputModel(context).getInstance();
customParametersModel = CustomParametersModel(context).getInstance();
downloadErrorToRequestTypeMap = {
[HTTPRequest.MPD_TYPE]: errors.DOWNLOAD_ERROR_ID_MANIFEST_CODE,
[HTTPRequest.XLINK_EXPANSION_TYPE]: errors.DOWNLOAD_ERROR_ID_XLINK_CODE,
[HTTPRequest.INIT_SEGMENT_TYPE]: errors.DOWNLOAD_ERROR_ID_INITIALIZATION_CODE,
[HTTPRequest.MEDIA_SEGMENT_TYPE]: errors.DOWNLOAD_ERROR_ID_CONTENT_CODE,
[HTTPRequest.INDEX_SEGMENT_TYPE]: errors.DOWNLOAD_ERROR_ID_CONTENT_CODE,
[HTTPRequest.BITSTREAM_SWITCHING_SEGMENT_TYPE]: errors.DOWNLOAD_ERROR_ID_CONTENT_CODE,
[HTTPRequest.OTHER_TYPE]: errors.DOWNLOAD_ERROR_ID_CONTENT_CODE
};
}
function internalLoad(config, remainingAttempts) {
const request = config.request;
const traces = [];
let firstProgress = true;
let needFailureReport = true;
let requestStartTime = new Date();
let lastTraceTime = requestStartTime;
let lastTraceReceivedCount = 0;
let progressTimeout = null;
let fileLoaderType = null;
let httpRequest;
if (!requestModifier || !dashMetrics || !errHandler) {
throw new Error('config object is not correct or missing');
}
const addHttpRequestMetric = function(success) {
request.requestStartDate = requestStartTime;
request.requestEndDate = new Date();
request.firstByteDate = request.firstByteDate || requestStartTime;
request.fileLoaderType = fileLoaderType;
const responseUrl = httpRequest.response ? httpRequest.response.responseURL : null;
const responseStatus = httpRequest.response ? httpRequest.response.status : null;
const responseHeaders = httpRequest.response && httpRequest.response.getAllResponseHeaders ? httpRequest.response.getAllResponseHeaders() :
httpRequest.response ? httpRequest.response.responseHeaders : null;
const cmsd = responseHeaders && settings.get().streaming.cmsd && settings.get().streaming.cmsd.enabled ? cmsdModel.parseResponseHeaders(responseHeaders, request.mediaType) : null;
dashMetrics.addHttpRequest(request, responseUrl, responseStatus, responseHeaders, success ? traces : null, cmsd);
}
const handleLoaded = function (success) {
needFailureReport = false;
addHttpRequestMetric(success);
if (request.type === HTTPRequest.MPD_TYPE) {
dashMetrics.addManifestUpdate(request);
eventBus.trigger(Events.MANIFEST_LOADING_FINISHED, { request });
}
};
const onloadend = function () {
if (progressTimeout) {
clearTimeout(progressTimeout);
progressTimeout = null;
}
if (requests.indexOf(httpRequest) === -1) {
return;
} else {
requests.splice(requests.indexOf(httpRequest), 1);
}
if (needFailureReport) {
handleLoaded(false);
if (remainingAttempts > 0) {
// If we get a 404 to a media segment we should check the client clock again and perform a UTC sync in the background.
try {
if (settings.get().streaming.utcSynchronization.enableBackgroundSyncAfterSegmentDownloadError && request.type === HTTPRequest.MEDIA_SEGMENT_TYPE) {
// Only trigger a sync if the loading failed for the first time
const initialNumberOfAttempts = mediaPlayerModel.getRetryAttemptsForType(HTTPRequest.MEDIA_SEGMENT_TYPE);
if (initialNumberOfAttempts === remainingAttempts) {
eventBus.trigger(Events.ATTEMPT_BACKGROUND_SYNC);
}
}
} catch (e) {
}
remainingAttempts--;
let retryRequest = { config: config };
retryRequests.push(retryRequest);
retryRequest.timeout = setTimeout(function () {
if (retryRequests.indexOf(retryRequest) === -1) {
return;
} else {
retryRequests.splice(retryRequests.indexOf(retryRequest), 1);
}
internalLoad(config, remainingAttempts);
}, mediaPlayerModel.getRetryIntervalsForType(request.type));
} else {
if (request.type === HTTPRequest.MSS_FRAGMENT_INFO_SEGMENT_TYPE) {
return;
}
errHandler.error(new DashJSError(downloadErrorToRequestTypeMap[request.type], request.url + ' is not available', {
request: request,
response: httpRequest.response
}));
if (config.error) {
config.error(request, 'error', httpRequest.response.statusText, httpRequest.response);
}
if (config.complete) {
config.complete(request, httpRequest.response.statusText);
}
}
}
};
const progress = function (event) {
const currentTime = new Date();
if (firstProgress) {
firstProgress = false;
if (!event.lengthComputable ||
(event.lengthComputable && event.total !== event.loaded)) {
request.firstByteDate = currentTime;
}
}
if (event.lengthComputable) {
request.bytesLoaded = event.loaded;
request.bytesTotal = event.total;
}
if (!event.noTrace) {
traces.push({
s: lastTraceTime,
d: event.time ? event.time : currentTime.getTime() - lastTraceTime.getTime(),
b: [event.loaded ? event.loaded - lastTraceReceivedCount : 0]
});
lastTraceTime = currentTime;
lastTraceReceivedCount = event.loaded;
}
if (progressTimeout) {
clearTimeout(progressTimeout);
progressTimeout = null;
}
if (settings.get().streaming.fragmentRequestProgressTimeout > 0) {
progressTimeout = setTimeout(function () {
// No more progress => abort request and treat as an error
logger.warn('Abort request ' + httpRequest.url + ' due to progress timeout');
httpRequest.response.onabort = null;
httpRequest.loader.abort(httpRequest);
onloadend();
}, settings.get().streaming.fragmentRequestProgressTimeout);
}
if (config.progress && event) {
config.progress(event);
}
};
const onload = function () {
if (httpRequest.response.status >= 200 && httpRequest.response.status <= 299) {
handleLoaded(true);
if (config.success) {
config.success(httpRequest.response.response, httpRequest.response.statusText, httpRequest.response.responseURL);
}
if (config.complete) {
config.complete(request, httpRequest.response.statusText);
}
}
};
const onabort = function () {
addHttpRequestMetric(true);
if (progressTimeout) {
clearTimeout(progressTimeout);
progressTimeout = null;
}
if (config.abort) {
config.abort(request);
}
};
const ontimeout = function (event) {
let timeoutMessage;
if (event.lengthComputable) {
let percentageComplete = (event.loaded / event.total) * 100;
timeoutMessage = 'Request timeout: loaded: ' + event.loaded + ', out of: ' + event.total + ' : ' + percentageComplete.toFixed(3) + '% Completed';
} else {
timeoutMessage = 'Request timeout: non-computable download size';
}
logger.warn(timeoutMessage);
};
let loader;
if (request.hasOwnProperty('availabilityTimeComplete') && request.availabilityTimeComplete === false && window.fetch && request.responseType === 'arraybuffer' && request.type === HTTPRequest.MEDIA_SEGMENT_TYPE) {
loader = FetchLoader(context).create({
requestModifier: requestModifier,
lowLatencyThroughputModel,
boxParser: boxParser
});
loader.setup({
dashMetrics
});
fileLoaderType = Constants.FILE_LOADER_TYPES.FETCH;
} else {
loader = XHRLoader(context).create({
requestModifier: requestModifier
});
fileLoaderType = Constants.FILE_LOADER_TYPES.XHR;
}
let headers = null;
let modifiedUrl = requestModifier.modifyRequestURL ? requestModifier.modifyRequestURL(request.url) : request.url;
if (settings.get().streaming.cmcd && settings.get().streaming.cmcd.enabled) {
const cmcdMode = settings.get().streaming.cmcd.mode;
if (cmcdMode === Constants.CMCD_MODE_QUERY) {
const additionalQueryParameter = _getAdditionalQueryParameter(request);
modifiedUrl = Utils.addAditionalQueryParameterToUrl(modifiedUrl, additionalQueryParameter);
} else if (cmcdMode === Constants.CMCD_MODE_HEADER) {
headers = cmcdModel.getHeaderParameters(request);
}
}
const withCredentials = customParametersModel.getXHRWithCredentialsForType(request.type);
// Add queryParams that came from pathway cloning
if (request.queryParams) {
const queryParams = Object.keys(request.queryParams).map((key) => {
return {
key,
value: request.queryParams[key]
}
})
modifiedUrl = Utils.addAditionalQueryParameterToUrl(modifiedUrl, queryParams);
}
request.url = modifiedUrl;
httpRequest = {
url: modifiedUrl,
method: HTTPRequest.GET,
withCredentials: withCredentials,
request: request,
onload: onload,
onend: onloadend,
onerror: onloadend,
progress: progress,
onabort: onabort,
ontimeout: ontimeout,
loader: loader,
timeout: requestTimeout,
headers: headers
};
// Adds the ability to delay single fragment loading time to control buffer.
let now = new Date().getTime();
if (isNaN(request.delayLoadingTime) || now >= request.delayLoadingTime) {
// no delay - just send
requests.push(httpRequest);
loader.load(httpRequest);
} else {
// delay
let delayedRequest = { httpRequest: httpRequest };
delayedRequests.push(delayedRequest);
delayedRequest.delayTimeout = setTimeout(function () {
if (delayedRequests.indexOf(delayedRequest) === -1) {
return;
} else {
delayedRequests.splice(delayedRequests.indexOf(delayedRequest), 1);
}
try {
requestStartTime = new Date();
lastTraceTime = requestStartTime;
requests.push(delayedRequest.httpRequest);
loader.load(delayedRequest.httpRequest);
} catch (e) {
delayedRequest.httpRequest.onerror();
}
}, (request.delayLoadingTime - now));
}
}
function _getAdditionalQueryParameter(request) {
try {
const additionalQueryParameter = [];
const cmcdQueryParameter = cmcdModel.getQueryParameter(request);
if (cmcdQueryParameter) {
additionalQueryParameter.push(cmcdQueryParameter);
}
return additionalQueryParameter;
} catch (e) {
return [];
}
}
/**
* Initiates a download of the resource described by config.request
* @param {Object} config - contains request (FragmentRequest or derived type), and callbacks
* @memberof module:HTTPLoader
* @instance
*/
function load(config) {
if (config.request) {
internalLoad(
config,
mediaPlayerModel.getRetryAttemptsForType(
config.request.type
)
);
} else {
if (config.error) {
config.error(config.request, 'error');
}
}
}
/**
* Aborts any inflight downloads
* @memberof module:HTTPLoader
* @instance
*/
function abort() {
retryRequests.forEach(t => {
clearTimeout(t.timeout);
// abort request in order to trigger LOADING_ABANDONED event
if (t.config.request && t.config.abort) {
t.config.abort(t.config.request);
}
});
retryRequests = [];
delayedRequests.forEach(x => clearTimeout(x.delayTimeout));
delayedRequests = [];
requests.forEach(x => {
// MSS patch: ignore FragmentInfo requests
if (x.request.type === HTTPRequest.MSS_FRAGMENT_INFO_SEGMENT_TYPE) {
return;
}
// abort will trigger onloadend which we don't want
// when deliberately aborting inflight requests -
// set them to undefined so they are not called
x.onloadend = x.onerror = x.onprogress = undefined;
x.loader.abort(x);
});
requests = [];
}
instance = {
load: load,
abort: abort
};
setup();
return instance;
}
HTTPLoader.__dashjs_factory_name = 'HTTPLoader';
const factory = FactoryMaker.getClassFactory(HTTPLoader);
export default factory;