@alessmicrosystems/mpegts.js 1.8.1

package/src/demux/av1.ts

@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2023 もにょてっく. All Rights Reserved.
+ *
+ * @author もにょ〜ん <monyone.teihen@gmail.com>
+ *
+ * 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";
+
+export class AV1OBUInMpegTsParser {
+
+    private readonly TAG: string = "AV1OBUInMpegTsParser";
+
+    private data_: Uint8Array;
+    private current_startcode_offset_: number = 0;
+    private eof_flag_: boolean = false;
+
+    static _ebsp2rbsp(uint8array: Uint8Array) {
+        let src = uint8array;
+        let src_length = src.byteLength;
+        let dst = new Uint8Array(src_length);
+        let dst_idx = 0;
+
+        for (let i = 0; i < src_length; i++) {
+            if (i >= 2) {
+                // Unescape: Skip 0x03 after 00 00
+                if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
+                    continue;
+                }
+            }
+            dst[dst_idx] = src[i];
+            dst_idx++;
+        }
+
+        return new Uint8Array(dst.buffer, 0, dst_idx);
+    }
+
+    public constructor(data: Uint8Array) {
+        this.data_ = data;
+        this.current_startcode_offset_ = this.findNextStartCodeOffset(0);
+        if (this.eof_flag_) {
+            Log.e(this.TAG, "Could not find AV1 startcode until payload end!");
+        }
+    }
+
+    private findNextStartCodeOffset(start_offset: number) {
+        let i = start_offset;
+        let data = this.data_;
+
+        while (true) {
+            if (i + 2 >= data.byteLength) {
+                this.eof_flag_ = true;
+                return data.byteLength;
+            }
+
+            // search 00 00 01
+            let uint24 = (data[i + 0] << 16)
+                        | (data[i + 1] << 8)
+                        | (data[i + 2]);
+            if (uint24 === 0x000001) {
+                return i;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    public readNextOBUPayload(): Uint8Array | null {
+        let data = this.data_;
+        let payload: Uint8Array | null = null;
+
+        while (payload == null) {
+            if (this.eof_flag_) {
+                break;
+            }
+            // offset pointed to start code
+            let startcode_offset = this.current_startcode_offset_;
+
+            // nalu payload start offset
+            let offset = startcode_offset + 3;
+            let next_startcode_offset = this.findNextStartCodeOffset(offset);
+            this.current_startcode_offset_ = next_startcode_offset;
+
+            payload = AV1OBUInMpegTsParser._ebsp2rbsp(data.subarray(offset, next_startcode_offset));
+        }
+
+        return payload;
+    }
+
+}
+
+export default AV1OBUInMpegTsParser;

package/src/demux/base-demuxer.ts

@@ -0,0 +1,69 @@
+import MediaInfo from '../core/media-info';
+import { PESPrivateData, PESPrivateDataDescriptor } from './pes-private-data';
+import { SMPTE2038Data } from './smpte2038';
+import { SCTE35Data } from './scte35';
+import { KLVData } from './klv';
+import { PGSData } from './pgs-data';
+import { SEIData } from './sei';
+
+type OnErrorCallback = (type: string, info: string) => void;
+type OnMediaInfoCallback = (mediaInfo: MediaInfo) => void;
+type OnMetaDataArrivedCallback = (metadata: any) => void;
+type OnTrackMetadataCallback = (type: string, metadata: any) => void;
+type OnDataAvailableCallback = (audioTrack: any, videoTrack: any) => void;
+type OnTimedID3MetadataCallback = (timed_id3_data: PESPrivateData) => void;
+type onPGSSubitleDataCallback = (pgs_data: PGSData) => void;
+type OnSynchronousKLVMetadataCallback = (synchronous_klv_data: KLVData) => void;
+type OnAsynchronousKLVMetadataCallback = (asynchronous_klv_data: PESPrivateData) => void;
+type OnSMPTE2038MetadataCallback = (smpte2038_data: SMPTE2038Data) => void;
+type OnSEICallback = (sei_data: SEIData) => void;
+type OnSCTE35MetadataCallback = (scte35_data: SCTE35Data) => void;
+type OnPESPrivateDataCallback = (private_data: PESPrivateData) => void;
+type OnPESPrivateDataDescriptorCallback = (private_data_descriptor: PESPrivateDataDescriptor) => void;
+export type TracksUpdatedInfo = {
+    audioTracks: Array<{pid: number, codec: string, lang?: string}>,
+    subtitleTracks: Array<{pid: number, type: string, lang?: string}>,
+};
+type OnTracksUpdatedCallback = (info: TracksUpdatedInfo) => void;
+
+export default abstract class BaseDemuxer {
+
+    public onError: OnErrorCallback;
+    public onMediaInfo: OnMediaInfoCallback;
+    public onMetaDataArrived: OnMetaDataArrivedCallback;
+    public onTrackMetadata: OnTrackMetadataCallback;
+    public onDataAvailable: OnDataAvailableCallback;
+    public onTimedID3Metadata: OnTimedID3MetadataCallback;
+    public onPGSSubtitleData: onPGSSubitleDataCallback;
+    public onSynchronousKLVMetadata: OnSynchronousKLVMetadataCallback
+    public onAsynchronousKLVMetadata: OnAsynchronousKLVMetadataCallback;
+    public onSMPTE2038Metadata: OnSMPTE2038MetadataCallback;
+    public onSEI: OnSEICallback;
+    public onSCTE35Metadata: OnSCTE35MetadataCallback;
+    public onPESPrivateData: OnPESPrivateDataCallback;
+    public onPESPrivateDataDescriptor: OnPESPrivateDataDescriptorCallback;
+    public onTracksUpdated: OnTracksUpdatedCallback;
+
+    public constructor() {}
+
+    public destroy(): void {
+        this.onError = null;
+        this.onMediaInfo = null;
+        this.onMetaDataArrived = null;
+        this.onTrackMetadata = null;
+        this.onDataAvailable = null;
+        this.onTimedID3Metadata = null;
+        this.onPGSSubtitleData = null;
+        this.onSynchronousKLVMetadata = null;
+        this.onAsynchronousKLVMetadata = null;
+        this.onSMPTE2038Metadata = null;
+        this.onSEI = null;
+        this.onSCTE35Metadata = null;
+        this.onPESPrivateData = null;
+        this.onPESPrivateDataDescriptor = null;
+        this.onTracksUpdated = null;
+    }
+
+    abstract parseChunks(chunk: ArrayBuffer, byteStart: number): number;
+
+}

package/src/demux/demux-errors.js

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+const DemuxErrors = {
+    OK: 'OK',
+    FORMAT_ERROR: 'FormatError',
+    FORMAT_UNSUPPORTED: 'FormatUnsupported',
+    CODEC_UNSUPPORTED: 'CodecUnsupported'
+};
+
+export default DemuxErrors;

package/src/demux/exp-golomb.js

@@ -0,0 +1,116 @@
+/*
+ * 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 {IllegalStateException, InvalidArgumentException} from '../utils/exception.js';
+
+// Exponential-Golomb buffer decoder
+class ExpGolomb {
+
+    constructor(uint8array) {
+        this.TAG = 'ExpGolomb';
+
+        this._buffer = uint8array;
+        this._buffer_index = 0;
+        this._total_bytes = uint8array.byteLength;
+        this._total_bits = uint8array.byteLength * 8;
+        this._current_word = 0;
+        this._current_word_bits_left = 0;
+    }
+
+    destroy() {
+        this._buffer = null;
+    }
+
+    _fillCurrentWord() {
+        let buffer_bytes_left = this._total_bytes - this._buffer_index;
+        if (buffer_bytes_left <= 0)
+            throw new IllegalStateException('ExpGolomb: _fillCurrentWord() but no bytes available');
+
+        let bytes_read = Math.min(4, buffer_bytes_left);
+        let word = new Uint8Array(4);
+        word.set(this._buffer.subarray(this._buffer_index, this._buffer_index + bytes_read));
+        this._current_word = new DataView(word.buffer).getUint32(0, false);
+
+        this._buffer_index += bytes_read;
+        this._current_word_bits_left = bytes_read * 8;
+    }
+
+    readBits(bits) {
+        if (bits > 32)
+            throw new InvalidArgumentException('ExpGolomb: readBits() bits exceeded max 32bits!');
+
+        if (bits <= this._current_word_bits_left) {
+            let result = this._current_word >>> (32 - bits);
+            this._current_word <<= bits;
+            this._current_word_bits_left -= bits;
+            return result;
+        }
+
+        let result = this._current_word_bits_left ? this._current_word : 0;
+        result = result >>> (32 - this._current_word_bits_left);
+        let bits_need_left = bits - this._current_word_bits_left;
+
+        this._fillCurrentWord();
+        let bits_read_next = Math.min(bits_need_left, this._current_word_bits_left);
+
+        let result2 = this._current_word >>> (32 - bits_read_next);
+        this._current_word <<= bits_read_next;
+        this._current_word_bits_left -= bits_read_next;
+
+        result = (result << bits_read_next) | result2;
+        return result;
+    }
+
+    readBool() {
+        return this.readBits(1) === 1;
+    }
+
+    readByte() {
+        return this.readBits(8);
+    }
+
+    _skipLeadingZero() {
+        let zero_count;
+        for (zero_count = 0; zero_count < this._current_word_bits_left; zero_count++) {
+            if (0 !== (this._current_word & (0x80000000 >>> zero_count))) {
+                this._current_word <<= zero_count;
+                this._current_word_bits_left -= zero_count;
+                return zero_count;
+            }
+        }
+        this._fillCurrentWord();
+        return zero_count + this._skipLeadingZero();
+    }
+
+    readUEG() {  // unsigned exponential golomb
+        let leading_zeros = this._skipLeadingZero();
+        return this.readBits(leading_zeros + 1) - 1;
+    }
+
+    readSEG() {  // signed exponential golomb
+        let value = this.readUEG();
+        if (value & 0x01) {
+            return (value + 1) >>> 1;
+        } else {
+            return -1 * (value >>> 1);
+        }
+    }
+
+}
+
+export default ExpGolomb;