@alessmicrosystems/mpegts.js 1.8.1

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@alessmicrosystems/mpegts.js",
+  "version": "1.8.1",
+  "description": "HTML5 MPEG2-TS Stream Player",
+  "main": "./dist/mpegts.js",
+  "types": "./d.ts/mpegts.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alessblaze/mpegts.js.git"
+  },
+  "keywords": [
+    "html5",
+    "mpegts",
+    "m2ts",
+    "mse",
+    "arib",
+    "dvb"
+  ],
+  "scripts": {
+    "build": "webpack --mode=production --progress",
+    "build:debug": "webpack --mode=development --progress",
+    "watch": "webpack --mode=development --progress --watch",
+    "serve": "webpack serve --mode=development --progress"
+  },
+  "dependencies": {
+    "es6-promise": "^4.2.5"
+  },
+  "devDependencies": {
+    "@types/express-serve-static-core": "4.17.37",
+    "@types/node": "^10.12.18",
+    "@typescript-eslint/eslint-plugin": "^8.59.3",
+    "@typescript-eslint/parser": "^8.59.3",
+    "browser-sync": "^3.0.4",
+    "eslint": "^10.4.0",
+    "exports-loader": "^0.7.0",
+    "file-loader": "^3.0.1",
+    "loader-utils": ">=1.4.1",
+    "minimist": ">=1.2.6",
+    "socket.io-parser": ">=3.3.3",
+    "source-map-loader": "^0.2.4",
+    "ssri": ">=8.0.1",
+    "terser-webpack-plugin": "^5.6.0",
+    "ts-loader": "^8.4.0",
+    "typescript": "^5.2.2",
+    "webpack": "^5.106.2",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^5.2.4",
+    "ws": ">=7.4.6",
+    "xmlhttprequest-ssl": ">=1.6.2"
+  },
+  "author": "Albert Blasczykowski <albertalesso@gmail.com>",
+  "license": "Apache-2.0"
+}

package/src/config.js

@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+export const defaultConfig = {
+    enableWorker: false,
+    enableWorkerForMSE: false,
+    enableStashBuffer: true,
+    stashInitialSize: undefined,
+
+    isLive: false,
+
+    preferredAudioPid: 0,
+
+    liveBufferLatencyChasing: false,
+    liveBufferLatencyChasingOnPaused: false,
+    liveBufferLatencyMaxLatency: 1.5,
+    liveBufferLatencyMinRemain: 0.5,
+
+    liveSync: false,
+    liveSyncMaxLatency: 1.2,
+    liveSyncTargetLatency: 0.8,
+    liveSyncPlaybackRate: 1.2,
+
+    lazyLoad: true,
+    lazyLoadMaxDuration: 3 * 60,
+    lazyLoadRecoverDuration: 30,
+    deferLoadAfterSourceOpen: true,
+
+    // autoCleanupSourceBuffer: default as false, leave unspecified
+    autoCleanupMaxBackwardDuration: 3 * 60,
+    autoCleanupMinBackwardDuration: 2 * 60,
+
+    statisticsInfoReportInterval: 600,
+
+    fixAudioTimestampGap: true,
+
+    accurateSeek: false,
+    seekType: 'range',  // [range, param, custom]
+    seekParamStart: 'bstart',
+    seekParamEnd: 'bend',
+    rangeLoadZeroStart: false,
+    customSeekHandler: undefined,
+    reuseRedirectedURL: false,
+    // referrerPolicy: leave as unspecified
+
+    headers: undefined,
+    customLoader: undefined
+};
+
+export function createDefaultConfig() {
+    return Object.assign({}, defaultConfig);
+}

package/src/core/features.js

@@ -0,0 +1,88 @@
+/*
+ * 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 IOController from '../io/io-controller.js';
+import {createDefaultConfig} from '../config.js';
+
+class Features {
+
+    static supportMSEH264Playback() {
+        const avc_aac_mime_type = 'video/mp4; codecs="avc1.42E01E,mp4a.40.2"';
+        const support_w3c_mse = self.MediaSource && self.MediaSource.isTypeSupported(avc_aac_mime_type);
+        const support_apple_mme = self.ManagedMediaSource && self.ManagedMediaSource.isTypeSupported(avc_aac_mime_type);
+        return support_w3c_mse || support_apple_mme;
+    }
+
+    static supportMSEH265Playback() {
+        const hevc_mime_type = 'video/mp4; codecs="hvc1.1.6.L93.B0"';
+        const support_w3c_mse = self.MediaSource && self.MediaSource.isTypeSupported(hevc_mime_type);
+        const support_apple_mme = self.ManagedMediaSource && self.ManagedMediaSource.isTypeSupported(hevc_mime_type);
+        return support_w3c_mse || support_apple_mme;
+    }
+
+    static supportNetworkStreamIO() {
+        let ioctl = new IOController({}, createDefaultConfig());
+        let loaderType = ioctl.loaderType;
+        ioctl.destroy();
+        return loaderType == 'fetch-stream-loader' || loaderType == 'xhr-moz-chunked-loader';
+    }
+
+    static getNetworkLoaderTypeName() {
+        let ioctl = new IOController({}, createDefaultConfig());
+        let loaderType = ioctl.loaderType;
+        ioctl.destroy();
+        return loaderType;
+    }
+
+    static supportNativeMediaPlayback(mimeType) {
+        if (Features.videoElement == undefined) {
+            Features.videoElement = window.document.createElement('video');
+        }
+        let canPlay = Features.videoElement.canPlayType(mimeType);
+        return canPlay === 'probably' || canPlay == 'maybe';
+    }
+
+    static getFeatureList() {
+        let features = {
+            msePlayback: false,
+            mseLivePlayback: false,
+            mseH265Playback: false,
+            networkStreamIO: false,
+            networkLoaderName: '',
+            nativeMP4H264Playback: false,
+            nativeMP4H265Playback: false,
+            nativeWebmVP8Playback: false,
+            nativeWebmVP9Playback: false
+        };
+
+        features.msePlayback = Features.supportMSEH264Playback();
+        features.networkStreamIO = Features.supportNetworkStreamIO();
+        features.networkLoaderName = Features.getNetworkLoaderTypeName();
+        features.mseLivePlayback = features.msePlayback && features.networkStreamIO;
+        features.mseH265Playback = Features.supportMSEH265Playback();
+        features.nativeMP4H264Playback = Features.supportNativeMediaPlayback('video/mp4; codecs="avc1.42001E, mp4a.40.2"');
+        features.nativeMP4H265Playback = Features.supportNativeMediaPlayback('video/mp4; codecs="hvc1.1.6.L93.B0"');
+        features.nativeWebmVP8Playback = Features.supportNativeMediaPlayback('video/webm; codecs="vp8.0, vorbis"');
+        features.nativeWebmVP9Playback = Features.supportNativeMediaPlayback('video/webm; codecs="vp9"');
+
+        return features;
+    }
+
+}
+
+export default Features;

package/src/core/media-info.js

@@ -0,0 +1,127 @@
+/*
+ * 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 MediaInfo {
+
+    constructor() {
+        this.mimeType = null;
+        this.duration = null;
+
+        this.hasAudio = null;
+        this.hasVideo = null;
+        this.audioCodec = null;
+        this.videoCodec = null;
+        this.audioDataRate = null;
+        this.videoDataRate = null;
+
+        this.audioSampleRate = null;
+        this.audioChannelCount = null;
+
+        this.width = null;
+        this.height = null;
+        this.fps = null;
+        this.profile = null;
+        this.level = null;
+        this.refFrames = null;
+        this.chromaFormat = null;
+        this.sarNum = null;
+        this.sarDen = null;
+
+        this.metadata = null;
+        this.segments = null;  // MediaInfo[]
+        this.segmentCount = null;
+        this.hasKeyframesIndex = null;
+        this.keyframesIndex = null;
+    }
+
+    isComplete() {
+        let audioInfoComplete = (this.hasAudio === false) ||
+                                (this.hasAudio === true &&
+                                 this.audioCodec != null &&
+                                 this.audioSampleRate != null &&
+                                 this.audioChannelCount != null);
+
+        let videoInfoComplete = (this.hasVideo === false) ||
+                                (this.hasVideo === true &&
+                                 this.videoCodec != null &&
+                                 this.width != null &&
+                                 this.height != null &&
+                                 this.fps != null &&
+                                 this.profile != null &&
+                                 this.level != null &&
+                                 this.refFrames != null &&
+                                 this.chromaFormat != null &&
+                                 this.sarNum != null &&
+                                 this.sarDen != null);
+
+        // keyframesIndex may not be present
+        return this.mimeType != null &&
+               audioInfoComplete &&
+               videoInfoComplete;
+    }
+
+    isSeekable() {
+        return this.hasKeyframesIndex === true;
+    }
+
+    getNearestKeyframe(milliseconds) {
+        if (this.keyframesIndex == null) {
+            return null;
+        }
+
+        let table = this.keyframesIndex;
+        let keyframeIdx = this._search(table.times, milliseconds);
+
+        return {
+            index: keyframeIdx,
+            milliseconds: table.times[keyframeIdx],
+            fileposition: table.filepositions[keyframeIdx]
+        };
+    }
+
+    _search(list, value) {
+        let idx = 0;
+
+        let last = list.length - 1;
+        let mid = 0;
+        let lbound = 0;
+        let ubound = last;
+
+        if (value < list[0]) {
+            idx = 0;
+            lbound = ubound + 1;  // skip search
+        }
+
+        while (lbound <= ubound) {
+            mid = lbound + Math.floor((ubound - lbound) / 2);
+            if (mid === last || (value >= list[mid] && value < list[mid + 1])) {
+                idx = mid;
+                break;
+            } else if (list[mid] < value) {
+                lbound = mid + 1;
+            } else {
+                ubound = mid - 1;
+            }
+        }
+
+        return idx;
+    }
+
+}
+
+export default MediaInfo;

package/src/core/media-segment-info.js

@@ -0,0 +1,230 @@
+/*
+ * 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.
+ */
+
+// Represents an media sample (audio / video)
+export class SampleInfo {
+
+    constructor(dts, pts, duration, originalDts, isSync) {
+        this.dts = dts;
+        this.pts = pts;
+        this.duration = duration;
+        this.originalDts = originalDts;
+        this.isSyncPoint = isSync;
+        this.fileposition = null;
+    }
+
+}
+
+// Media Segment concept is defined in Media Source Extensions spec.
+// Particularly in ISO BMFF format, an Media Segment contains a moof box followed by a mdat box.
+export class MediaSegmentInfo {
+
+    constructor() {
+        this.beginDts = 0;
+        this.endDts = 0;
+        this.beginPts = 0;
+        this.endPts = 0;
+        this.originalBeginDts = 0;
+        this.originalEndDts = 0;
+        this.syncPoints = [];     // SampleInfo[n], for video IDR frames only
+        this.firstSample = null;  // SampleInfo
+        this.lastSample = null;   // SampleInfo
+    }
+
+    appendSyncPoint(sampleInfo) {  // also called Random Access Point
+        sampleInfo.isSyncPoint = true;
+        this.syncPoints.push(sampleInfo);
+    }
+
+}
+
+// Ordered list for recording video IDR frames, sorted by originalDts
+export class IDRSampleList {
+
+    constructor() {
+        this._list = [];
+    }
+
+    clear() {
+        this._list = [];
+    }
+
+    appendArray(syncPoints) {
+        let list = this._list;
+
+        if (syncPoints.length === 0) {
+            return;
+        }
+
+        if (list.length > 0 && syncPoints[0].originalDts < list[list.length - 1].originalDts) {
+            this.clear();
+        }
+
+        Array.prototype.push.apply(list, syncPoints);
+    }
+
+    getLastSyncPointBeforeDts(dts) {
+        if (this._list.length == 0) {
+            return null;
+        }
+
+        let list = this._list;
+        let idx = 0;
+        let last = list.length - 1;
+        let mid = 0;
+        let lbound = 0;
+        let ubound = last;
+
+        if (dts < list[0].dts) {
+            idx = 0;
+            lbound = ubound + 1;
+        }
+
+        while (lbound <= ubound) {
+            mid = lbound + Math.floor((ubound - lbound) / 2);
+            if (mid === last || (dts >= list[mid].dts && dts < list[mid + 1].dts)) {
+                idx = mid;
+                break;
+            } else if (list[mid].dts < dts) {
+                lbound = mid + 1;
+            } else {
+                ubound = mid - 1;
+            }
+        }
+        return this._list[idx];
+    }
+
+}
+
+// Data structure for recording information of media segments in single track.
+export class MediaSegmentInfoList {
+
+    constructor(type) {
+        this._type = type;
+        this._list = [];
+        this._lastAppendLocation = -1;  // cached last insert location
+    }
+
+    get type() {
+        return this._type;
+    }
+
+    get length() {
+        return this._list.length;
+    }
+
+    isEmpty() {
+        return this._list.length === 0;
+    }
+
+    clear() {
+        this._list = [];
+        this._lastAppendLocation = -1;
+    }
+
+    _searchNearestSegmentBefore(originalBeginDts) {
+        let list = this._list;
+        if (list.length === 0) {
+            return -2;
+        }
+        let last = list.length - 1;
+        let mid = 0;
+        let lbound = 0;
+        let ubound = last;
+
+        let idx = 0;
+
+        if (originalBeginDts < list[0].originalBeginDts) {
+            idx = -1;
+            return idx;
+        }
+
+        while (lbound <= ubound) {
+            mid = lbound + Math.floor((ubound - lbound) / 2);
+            if (mid === last || (originalBeginDts > list[mid].lastSample.originalDts &&
+                                (originalBeginDts < list[mid + 1].originalBeginDts))) {
+                idx = mid;
+                break;
+            } else if (list[mid].originalBeginDts < originalBeginDts) {
+                lbound = mid + 1;
+            } else {
+                ubound = mid - 1;
+            }
+        }
+        return idx;
+    }
+
+    _searchNearestSegmentAfter(originalBeginDts) {
+        return this._searchNearestSegmentBefore(originalBeginDts) + 1;
+    }
+
+    append(mediaSegmentInfo) {
+        let list = this._list;
+        let msi = mediaSegmentInfo;
+        let lastAppendIdx = this._lastAppendLocation;
+        let insertIdx = 0;
+
+        if (lastAppendIdx !== -1 && lastAppendIdx < list.length &&
+                                    msi.originalBeginDts >= list[lastAppendIdx].lastSample.originalDts &&
+                                    ((lastAppendIdx === list.length - 1) ||
+                                    (lastAppendIdx < list.length - 1 &&
+                                    msi.originalBeginDts < list[lastAppendIdx + 1].originalBeginDts))) {
+            insertIdx = lastAppendIdx + 1;  // use cached location idx
+        } else {
+            if (list.length > 0) {
+                insertIdx = this._searchNearestSegmentBefore(msi.originalBeginDts) + 1;
+            }
+        }
+
+        this._lastAppendLocation = insertIdx;
+        this._list.splice(insertIdx, 0, msi);
+    }
+
+    getLastSegmentBefore(originalBeginDts) {
+        let idx = this._searchNearestSegmentBefore(originalBeginDts);
+        if (idx >= 0) {
+            return this._list[idx];
+        } else {  // -1
+            return null;
+        }
+    }
+
+    getLastSampleBefore(originalBeginDts) {
+        let segment = this.getLastSegmentBefore(originalBeginDts);
+        if (segment != null) {
+            return segment.lastSample;
+        } else {
+            return null;
+        }
+    }
+
+    getLastSyncPointBefore(originalBeginDts) {
+        let segmentIdx = this._searchNearestSegmentBefore(originalBeginDts);
+        let syncPoints = this._list[segmentIdx].syncPoints;
+        while (syncPoints.length === 0 && segmentIdx > 0) {
+            segmentIdx--;
+            syncPoints = this._list[segmentIdx].syncPoints;
+        }
+        if (syncPoints.length > 0) {
+            return syncPoints[syncPoints.length - 1];
+        } else {
+            return null;
+        }
+    }
+
+}