@alessmicrosystems/mpegts.js 1.8.1

package/src/io/loader.js

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {NotImplementedException} from '../utils/exception.js';
+
+export const LoaderStatus = {
+    kIdle: 0,
+    kConnecting: 1,
+    kBuffering: 2,
+    kError: 3,
+    kComplete: 4
+};
+
+export const LoaderErrors = {
+    OK: 'OK',
+    EXCEPTION: 'Exception',
+    HTTP_STATUS_CODE_INVALID: 'HttpStatusCodeInvalid',
+    CONNECTING_TIMEOUT: 'ConnectingTimeout',
+    EARLY_EOF: 'EarlyEof',
+    UNRECOVERABLE_EARLY_EOF: 'UnrecoverableEarlyEof'
+};
+
+/* Loader has callbacks which have following prototypes:
+ *     function onContentLengthKnown(contentLength: number): void
+ *     function onURLRedirect(url: string): void
+ *     function onDataArrival(chunk: ArrayBuffer, byteStart: number, receivedLength: number): void
+ *     function onError(errorType: number, errorInfo: {code: number, msg: string}): void
+ *     function onComplete(rangeFrom: number, rangeTo: number): void
+ */
+export class BaseLoader {
+
+    constructor(typeName) {
+        this._type = typeName || 'undefined';
+        this._status = LoaderStatus.kIdle;
+        this._needStash = false;
+        // callbacks
+        this._onContentLengthKnown = null;
+        this._onURLRedirect = null;
+        this._onDataArrival = null;
+        this._onError = null;
+        this._onComplete = null;
+    }
+
+    destroy() {
+        this._status = LoaderStatus.kIdle;
+        this._onContentLengthKnown = null;
+        this._onURLRedirect = null;
+        this._onDataArrival = null;
+        this._onError = null;
+        this._onComplete = null;
+    }
+
+    isWorking() {
+        return this._status === LoaderStatus.kConnecting || this._status === LoaderStatus.kBuffering;
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    get status() {
+        return this._status;
+    }
+
+    get needStashBuffer() {
+        return this._needStash;
+    }
+
+    get onContentLengthKnown() {
+        return this._onContentLengthKnown;
+    }
+
+    set onContentLengthKnown(callback) {
+        this._onContentLengthKnown = callback;
+    }
+
+    get onURLRedirect() {
+        return this._onURLRedirect;
+    }
+
+    set onURLRedirect(callback) {
+        this._onURLRedirect = callback;
+    }
+
+    get onDataArrival() {
+        return this._onDataArrival;
+    }
+
+    set onDataArrival(callback) {
+        this._onDataArrival = callback;
+    }
+
+    get onError() {
+        return this._onError;
+    }
+
+    set onError(callback) {
+        this._onError = callback;
+    }
+
+    get onComplete() {
+        return this._onComplete;
+    }
+
+    set onComplete(callback) {
+        this._onComplete = callback;
+    }
+
+    // pure virtual
+    open(dataSource, range) {
+        throw new NotImplementedException('Unimplemented abstract function!');
+    }
+
+    abort() {
+        throw new NotImplementedException('Unimplemented abstract function!');
+    }
+
+
+}

package/src/io/param-seek-handler.js

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ParamSeekHandler {
+
+    constructor(paramStart, paramEnd) {
+        this._startName = paramStart;
+        this._endName = paramEnd;
+    }
+
+    getConfig(baseUrl, range) {
+        let url = baseUrl;
+
+        if (range.from !== 0 || range.to !== -1) {
+            let needAnd = true;
+            if (url.indexOf('?') === -1) {
+                url += '?';
+                needAnd = false;
+            }
+
+            if (needAnd) {
+                url += '&';
+            }
+
+            url += `${this._startName}=${range.from.toString()}`;
+
+            if (range.to !== -1) {
+                url += `&${this._endName}=${range.to.toString()}`;
+            }
+        }
+
+        return {
+            url: url,
+            headers: {}
+        };
+    }
+
+    removeURLParameters(seekedURL) {
+        let baseURL = seekedURL.split('?')[0];
+        let params = undefined;
+
+        let queryIndex = seekedURL.indexOf('?');
+        if (queryIndex !== -1) {
+            params = seekedURL.substring(queryIndex + 1);
+        }
+
+        let resultParams = '';
+
+        if (params != undefined && params.length > 0) {
+            let pairs = params.split('&');
+
+            for (let i = 0; i < pairs.length; i++) {
+                let pair = pairs[i].split('=');
+                let requireAnd = (i > 0);
+
+                if (pair[0] !== this._startName && pair[0] !== this._endName) {
+                    if (requireAnd) {
+                        resultParams += '&';
+                    }
+                    resultParams += pairs[i];
+                }
+            }
+        }
+
+        return (resultParams.length === 0) ? baseURL : baseURL + '?' + resultParams;
+    }
+
+}
+
+export default ParamSeekHandler;

package/src/io/range-seek-handler.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class RangeSeekHandler {
+
+    constructor(zeroStart) {
+        this._zeroStart = zeroStart || false;
+    }
+
+    getConfig(url, range) {
+        let headers = {};
+
+        if (range.from !== 0 || range.to !== -1) {
+            let param;
+            if (range.to !== -1) {
+                param = `bytes=${range.from.toString()}-${range.to.toString()}`;
+            } else {
+                param = `bytes=${range.from.toString()}-`;
+            }
+            headers['Range'] = param;
+        } else if (this._zeroStart) {
+            headers['Range'] = 'bytes=0-';
+        }
+
+        return {
+            url: url,
+            headers: headers
+        };
+    }
+
+    removeURLParameters(seekedURL) {
+        return seekedURL;
+    }
+
+}
+
+export default RangeSeekHandler;

package/src/io/speed-sampler.js

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Utility class to calculate realtime network I/O speed
+class SpeedSampler {
+
+    constructor() {
+        // milliseconds
+        this._firstCheckpoint = 0;
+        this._lastCheckpoint = 0;
+        this._intervalBytes = 0;
+        this._totalBytes = 0;
+        this._lastSecondBytes = 0;
+
+        // compatibility detection
+        if (self.performance && self.performance.now) {
+            this._now = self.performance.now.bind(self.performance);
+        } else {
+            this._now = Date.now;
+        }
+    }
+
+    reset() {
+        this._firstCheckpoint = this._lastCheckpoint = 0;
+        this._totalBytes = this._intervalBytes = 0;
+        this._lastSecondBytes = 0;
+    }
+
+    addBytes(bytes) {
+        if (this._firstCheckpoint === 0) {
+            this._firstCheckpoint = this._now();
+            this._lastCheckpoint = this._firstCheckpoint;
+            this._intervalBytes += bytes;
+            this._totalBytes += bytes;
+        } else if (this._now() - this._lastCheckpoint < 1000) {
+            this._intervalBytes += bytes;
+            this._totalBytes += bytes;
+        } else {  // duration >= 1000
+            this._lastSecondBytes = this._intervalBytes;
+            this._intervalBytes = bytes;
+            this._totalBytes += bytes;
+            this._lastCheckpoint = this._now();
+        }
+    }
+
+    get currentKBps() {
+        this.addBytes(0);
+
+        let durationSeconds = (this._now() - this._lastCheckpoint) / 1000;
+        if (durationSeconds == 0) durationSeconds = 1;
+        return (this._intervalBytes / durationSeconds) / 1024;
+    }
+
+    get lastSecondKBps() {
+        this.addBytes(0);
+
+        if (this._lastSecondBytes !== 0) {
+            return this._lastSecondBytes / 1024;
+        } else {  // lastSecondBytes === 0
+            if (this._now() - this._lastCheckpoint >= 500) {
+                // if time interval since last checkpoint has exceeded 500ms
+                // the speed is nearly accurate
+                return this.currentKBps;
+            } else {
+                // We don't know
+                return 0;
+            }
+        }
+    }
+
+    get averageKBps() {
+        let durationSeconds = (this._now() - this._firstCheckpoint) / 1000;
+        return (this._totalBytes / durationSeconds) / 1024;
+    }
+
+}
+
+export default SpeedSampler;

package/src/io/websocket-loader.js

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Log from '../utils/logger.js';
+import {BaseLoader, LoaderStatus, LoaderErrors} from './loader.js';
+import {RuntimeException} from '../utils/exception.js';
+
+// For MPEG-TS/FLV over WebSocket live stream
+class WebSocketLoader extends BaseLoader {
+
+    static isSupported() {
+        try {
+            return (typeof self.WebSocket !== 'undefined');
+        } catch (e) {
+            return false;
+        }
+    }
+
+    constructor() {
+        super('websocket-loader');
+        this.TAG = 'WebSocketLoader';
+
+        this._needStash = true;
+
+        this._ws = null;
+        this._requestAbort = false;
+        this._receivedLength = 0;
+    }
+
+    destroy() {
+        if (this._ws) {
+            this.abort();
+        }
+        super.destroy();
+    }
+
+    open(dataSource) {
+        try {
+            let ws = this._ws = new self.WebSocket(dataSource.url);
+            ws.binaryType = 'arraybuffer';
+            ws.onopen = this._onWebSocketOpen.bind(this);
+            ws.onclose = this._onWebSocketClose.bind(this);
+            ws.onmessage = this._onWebSocketMessage.bind(this);
+            ws.onerror = this._onWebSocketError.bind(this);
+
+            this._status = LoaderStatus.kConnecting;
+        } catch (e) {
+            this._status = LoaderStatus.kError;
+
+            let info = {code: e.code, msg: e.message};
+
+            if (this._onError) {
+                this._onError(LoaderErrors.EXCEPTION, info);
+            } else {
+                throw new RuntimeException(info.msg);
+            }
+        }
+    }
+
+    abort() {
+        let ws = this._ws;
+        if (ws && (ws.readyState === 0 || ws.readyState === 1)) {  // CONNECTING || OPEN
+            this._requestAbort = true;
+            ws.close();
+        }
+
+        this._ws = null;
+        this._status = LoaderStatus.kComplete;
+    }
+
+    _onWebSocketOpen(e) {
+        this._status = LoaderStatus.kBuffering;
+    }
+
+    _onWebSocketClose(e) {
+        if (this._requestAbort === true) {
+            this._requestAbort = false;
+            return;
+        }
+
+        this._status = LoaderStatus.kComplete;
+
+        if (this._onComplete) {
+            this._onComplete(0, this._receivedLength - 1);
+        }
+    }
+
+    _onWebSocketMessage(e) {
+        if (e.data instanceof ArrayBuffer) {
+            this._dispatchArrayBuffer(e.data);
+        } else if (e.data instanceof Blob) {
+            let reader = new FileReader();
+            reader.onload = () => {
+                this._dispatchArrayBuffer(reader.result);
+            };
+            reader.readAsArrayBuffer(e.data);
+        } else {
+            this._status = LoaderStatus.kError;
+            let info = {code: -1, msg: 'Unsupported WebSocket message type: ' + e.data.constructor.name};
+
+            if (this._onError) {
+                this._onError(LoaderErrors.EXCEPTION, info);
+            } else {
+                throw new RuntimeException(info.msg);
+            }
+        }
+    }
+
+    _dispatchArrayBuffer(arraybuffer) {
+        let chunk = arraybuffer;
+        let byteStart = this._receivedLength;
+        this._receivedLength += chunk.byteLength;
+
+        if (this._onDataArrival) {
+            this._onDataArrival(chunk, byteStart, this._receivedLength);
+        }
+    }
+
+    _onWebSocketError(e) {
+        this._status = LoaderStatus.kError;
+
+        let info = {
+            code: e.code,
+            msg: e.message
+        };
+
+        if (this._onError) {
+            this._onError(LoaderErrors.EXCEPTION, info);
+        } else {
+            throw new RuntimeException(info.msg);
+        }
+    }
+
+}
+
+export default WebSocketLoader;