@alessmicrosystems/mpegts.js 1.8.1

package/src/demux/ac3.ts

@@ -0,0 +1,335 @@
+import Log from "../utils/logger";
+import ExpGolomb from "./exp-golomb";
+import { MPEG4AudioObjectTypes, MPEG4SamplingFrequencies, MPEG4SamplingFrequencyIndex } from "./mpeg4-audio";
+
+export class AC3Frame {
+    sampling_frequency: number;
+    sampling_rate_code: number;
+    bit_stream_identification: number;
+    bit_stream_mode: number;
+    low_frequency_effects_channel_on: number;
+    frame_size_code: number;
+    channel_count: number;
+    channel_mode: number;
+
+    data: Uint8Array;
+}
+
+const frame_size_code_table = [
+    [
+         64,  64,   80,   80,   96,   96,  112,  112, 128, 128,
+        160, 160,  192,  192,  224,  224,  256,  256, 320, 320,
+        384, 384,  448,  448,  512,  512,  640,  640, 768, 768,
+        896, 896, 1024, 1024, 1152, 1152, 1280, 1280,
+    ],
+    [
+         69,  70,   87,   88,  104,  105,  121,  122, 139, 140,
+        174, 175,  208,  209,  243,  244,  278,  279, 348, 349,
+        417, 418,  487,  488,  557,  558,  696,  697, 835, 836,
+        975, 976, 1114, 1115, 1253, 1254, 1393, 1394
+    ],
+    [
+          96,   96,  120,  120,  144,  144,  168,  168,  192,  192,
+         240,  240,  288,  288,  336,  336,  384,  384,  480,  480,
+         576,  576,  672,  672,  768,  768,  960,  960, 1152, 1152,
+        1344, 1344, 1536, 1536, 1728, 1728, 1920, 1920,
+    ],
+]
+
+export class AC3Parser {
+
+    private readonly TAG: string = "AC3Parser";
+
+    private data_: Uint8Array;
+    private current_syncword_offset_: number;
+    private eof_flag_: boolean;
+    private has_last_incomplete_data: boolean;
+
+    public constructor(data: Uint8Array) {
+        this.data_ = data;
+        this.current_syncword_offset_ = this.findNextSyncwordOffset(0);
+        if (this.eof_flag_) {
+            Log.e(this.TAG, `Could not found AC3 syncword until payload end`);
+        }
+    }
+
+    private findNextSyncwordOffset(syncword_offset: number): number {
+        let i = syncword_offset;
+        let data = this.data_;
+
+        while (true) {
+            if (i + 7 >= data.byteLength) {
+                this.eof_flag_ = true;
+                return data.byteLength;
+            }
+
+            // search 16-bit 0x0B77 syncword
+            let syncword = (data[i + 0] << 8) | (data[i + 1] << 0)
+            if (syncword === 0x0B77) {
+                return i;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    public readNextAC3Frame(): AC3Frame | null {
+        let data = this.data_;
+        let ac3_frame: AC3Frame = null;
+
+        while (ac3_frame == null) {
+            if (this.eof_flag_) {
+                break;
+            }
+
+            let syncword_offset = this.current_syncword_offset_;
+            let offset = syncword_offset;
+
+            let sampling_rate_code = data[offset + 4] >> 6;
+            let sampling_frequency = [48000, 44200, 33000][sampling_rate_code];
+
+            let frame_size_code = data[offset + 4] & 0x3F;
+            let frame_size = frame_size_code_table[sampling_rate_code][frame_size_code] * 2;
+
+            if (isNaN(frame_size) || offset + frame_size > this.data_.byteLength) {
+                // data not enough for extracting last sample
+                this.eof_flag_ = true;
+                this.has_last_incomplete_data = true;
+                break;
+            }
+
+            let next_syncword_offset = this.findNextSyncwordOffset(offset + frame_size);
+            this.current_syncword_offset_ = next_syncword_offset;
+
+            let bit_stream_identification = data[offset + 5] >> 3;
+            let bit_stream_mode = data[offset + 5] & 0x07;
+
+            let channel_mode = data[offset + 6] >> 5;
+
+            let lfe_skip = 0;
+            if ((channel_mode & 0x01) !== 0 && channel_mode !== 1) { lfe_skip += 2; }
+            if ((channel_mode & 0x04) !== 0) { lfe_skip += 2; }
+            if (channel_mode === 0x02) { lfe_skip += 2; }
+
+            let low_frequency_effects_channel_on = (((data[offset + 6] << 8) | (data[offset + 7] << 0)) >> (12 - lfe_skip)) & 0x01;
+
+            let channel_count = [2, 1, 2, 3, 3, 4, 4, 5][channel_mode] + low_frequency_effects_channel_on;
+
+            ac3_frame = new AC3Frame();
+            ac3_frame.sampling_frequency = sampling_frequency;
+            ac3_frame.channel_count = channel_count;
+            ac3_frame.channel_mode = channel_mode;
+            ac3_frame.bit_stream_identification = bit_stream_identification;
+            ac3_frame.low_frequency_effects_channel_on = low_frequency_effects_channel_on;
+            ac3_frame.bit_stream_mode = bit_stream_mode;
+            ac3_frame.frame_size_code = frame_size_code;
+            ac3_frame.data = data.subarray(offset, offset + frame_size);
+        }
+
+        return ac3_frame;
+    }
+
+    public hasIncompleteData(): boolean {
+        return this.has_last_incomplete_data;
+    }
+
+    public getIncompleteData(): Uint8Array {
+        if (!this.has_last_incomplete_data) {
+            return null;
+        }
+
+        return this.data_.subarray(this.current_syncword_offset_);
+    }
+}
+export class AC3Config {
+
+    public config: Array<number>;
+    public sampling_rate: number;
+    public bit_stream_identification: number;
+    public bit_stream_mode: number;
+    public low_frequency_effects_channel_on: number;
+    public channel_count: number;
+    public channel_mode: number;
+    public codec_mimetype: string;
+    public original_codec_mimetype: string;
+
+    public constructor(frame: AC3Frame) {
+        let config: Array<number> = null;
+
+        config = [
+            (frame.sampling_rate_code << 6) | (frame.bit_stream_identification << 1) | (frame.bit_stream_mode >> 2),
+            ((frame.bit_stream_mode & 0x03) << 6) | (frame.channel_mode << 3) | (frame.low_frequency_effects_channel_on << 2) | (frame.frame_size_code >> 4),
+            (frame.frame_size_code  << 4) & 0xE0,
+        ]
+
+        this.config = config;
+        this.sampling_rate = frame.sampling_frequency;
+        this.bit_stream_identification = frame.bit_stream_identification;
+        this.bit_stream_mode = frame.bit_stream_mode;
+        this.low_frequency_effects_channel_on = frame.low_frequency_effects_channel_on;
+        this.channel_count = frame.channel_count;
+        this.channel_mode = frame.channel_mode;
+        this.codec_mimetype = 'ac-3';
+        this.original_codec_mimetype = 'ac-3';
+    }
+}
+
+export class EAC3Frame {
+    sampling_frequency: number;
+    sampling_rate_code: number;
+    bit_stream_identification: number;
+    low_frequency_effects_channel_on: number;
+    num_blks: number;
+    frame_size: number;
+    channel_count: number;
+    channel_mode: number;
+
+    data: Uint8Array;
+}
+export class EAC3Parser {
+
+    private readonly TAG: string = "EAC3Parser";
+
+    private data_: Uint8Array;
+    private current_syncword_offset_: number;
+    private eof_flag_: boolean;
+    private has_last_incomplete_data: boolean;
+
+    public constructor(data: Uint8Array) {
+        this.data_ = data;
+        this.current_syncword_offset_ = this.findNextSyncwordOffset(0);
+        if (this.eof_flag_) {
+            Log.e(this.TAG, `Could not found AC3 syncword until payload end`);
+        }
+    }
+
+    private findNextSyncwordOffset(syncword_offset: number): number {
+        let i = syncword_offset;
+        let data = this.data_;
+
+        while (true) {
+            if (i + 7 >= data.byteLength) {
+                this.eof_flag_ = true;
+                return data.byteLength;
+            }
+
+            // search 16-bit 0x0B77 syncword
+            let syncword = (data[i + 0] << 8) | (data[i + 1] << 0)
+            if (syncword === 0x0B77) {
+                return i;
+            } else {
+                i++;
+            }
+        }
+    }
+
+    public readNextEAC3Frame(): EAC3Frame | null {
+        let data = this.data_;
+        let eac3_frame: EAC3Frame = null;
+
+        while (eac3_frame == null) {
+            if (this.eof_flag_) {
+                break;
+            }
+
+            let syncword_offset = this.current_syncword_offset_;
+            let offset = syncword_offset;
+
+            let gb = new ExpGolomb(data.subarray(offset + 2));
+
+            let stream_type = gb.readBits(2);
+            let sub_stream_id = gb.readBits(3);
+            let frame_size = (gb.readBits(11) + 1) << 1;
+            let sampling_rate_code = gb.readBits(2);
+            let sampling_frequency: number | null = null;
+            let num_blocks_code: number | null = null;
+            if (sampling_rate_code === 0x03) {
+                sampling_rate_code = gb.readBits(2);
+                sampling_frequency = [24000, 22060, 16000][sampling_rate_code];
+                num_blocks_code = 3
+            } else {
+                sampling_frequency = [48000, 44100, 32000][sampling_rate_code];
+                num_blocks_code = gb.readBits(2);
+            }
+
+            let channel_mode = gb.readBits(3);
+            let low_frequency_effects_channel_on = gb.readBits(1);
+            let bit_stream_identification = gb.readBits(5);
+
+            if (offset + frame_size > this.data_.byteLength) {
+                // data not enough for extracting last sample
+                this.eof_flag_ = true;
+                this.has_last_incomplete_data = true;
+                break;
+            }
+
+            let next_syncword_offset = this.findNextSyncwordOffset(offset + frame_size);
+            this.current_syncword_offset_ = next_syncword_offset;
+
+            let channel_count = [2, 1, 2, 3, 3, 4, 4, 5][channel_mode] + low_frequency_effects_channel_on;
+
+            gb.destroy();
+
+            eac3_frame = new EAC3Frame();
+            eac3_frame.sampling_frequency = sampling_frequency;
+            eac3_frame.channel_count = channel_count;
+            eac3_frame.channel_mode = channel_mode;
+            eac3_frame.bit_stream_identification = bit_stream_identification;
+            eac3_frame.low_frequency_effects_channel_on = low_frequency_effects_channel_on;
+            eac3_frame.frame_size = frame_size;
+            eac3_frame.num_blks = [1, 2, 3, 6][num_blocks_code];
+            eac3_frame.data = data.subarray(offset, offset + frame_size);
+        }
+
+        return eac3_frame;
+    }
+
+    public hasIncompleteData(): boolean {
+        return this.has_last_incomplete_data;
+    }
+
+    public getIncompleteData(): Uint8Array {
+        if (!this.has_last_incomplete_data) {
+            return null;
+        }
+
+        return this.data_.subarray(this.current_syncword_offset_);
+    }
+}
+export class EAC3Config {
+
+    public config: Array<number>;
+    public sampling_rate: number;
+    public bit_stream_identification: number;
+    public num_blks: number;
+    public low_frequency_effects_channel_on: number;
+    public channel_count: number;
+    public channel_mode: number;
+    public codec_mimetype: string;
+    public original_codec_mimetype: string;
+
+    public constructor(frame: EAC3Frame) {
+        let config: Array<number> = null;
+
+        const data_rate_sub = Math.floor((frame.frame_size * frame.sampling_frequency) / (frame.num_blks * 16))
+
+        config = [
+            (data_rate_sub & 0x1FE0 >> 5),
+            (data_rate_sub & 0x001F << 3), // num_ind_sub = zero
+            (frame.sampling_rate_code << 6) | (frame.bit_stream_identification << 1) | (0 << 0),
+            (0 << 7) | (0 << 4) | (frame.channel_mode << 1) | (frame.low_frequency_effects_channel_on << 0),
+            (0 << 5) | (0 << 1) | (0 << 0)
+        ];
+
+
+        this.config = config;
+        this.sampling_rate = frame.sampling_frequency;
+        this.bit_stream_identification = frame.bit_stream_identification;
+        this.num_blks = frame.num_blks;
+        this.low_frequency_effects_channel_on = frame.low_frequency_effects_channel_on;
+        this.channel_count = frame.channel_count;
+        this.channel_mode = frame.channel_mode;
+        this.codec_mimetype = 'ec-3';
+        this.original_codec_mimetype = 'ec-3';
+    }
+}

package/src/demux/amf-parser.js

@@ -0,0 +1,243 @@
+/*
+ * 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 decodeUTF8 from '../utils/utf8-conv.js';
+import {IllegalStateException} from '../utils/exception.js';
+
+let le = (function () {
+    let buf = new ArrayBuffer(2);
+    (new DataView(buf)).setInt16(0, 256, true);  // little-endian write
+    return (new Int16Array(buf))[0] === 256;  // platform-spec read, if equal then LE
+})();
+
+class AMF {
+
+    static parseScriptData(arrayBuffer, dataOffset, dataSize) {
+        let data = {};
+
+        try {
+            let name = AMF.parseValue(arrayBuffer, dataOffset, dataSize);
+            let value = AMF.parseValue(arrayBuffer, dataOffset + name.size, dataSize - name.size);
+
+            data[name.data] = value.data;
+        } catch (e) {
+            Log.e('AMF', e.toString());
+        }
+
+        return data;
+    }
+
+    static parseObject(arrayBuffer, dataOffset, dataSize) {
+        if (dataSize < 3) {
+            throw new IllegalStateException('Data not enough when parse ScriptDataObject');
+        }
+        let name = AMF.parseString(arrayBuffer, dataOffset, dataSize);
+        let value = AMF.parseValue(arrayBuffer, dataOffset + name.size, dataSize - name.size);
+        let isObjectEnd = value.objectEnd;
+
+        return {
+            data: {
+                name: name.data,
+                value: value.data
+            },
+            size: name.size + value.size,
+            objectEnd: isObjectEnd
+        };
+    }
+
+    static parseVariable(arrayBuffer, dataOffset, dataSize) {
+        return AMF.parseObject(arrayBuffer, dataOffset, dataSize);
+    }
+
+    static parseString(arrayBuffer, dataOffset, dataSize) {
+        if (dataSize < 2) {
+            throw new IllegalStateException('Data not enough when parse String');
+        }
+        let v = new DataView(arrayBuffer, dataOffset, dataSize);
+        let length = v.getUint16(0, !le);
+
+        let str;
+        if (length > 0) {
+            str = decodeUTF8(new Uint8Array(arrayBuffer, dataOffset + 2, length));
+        } else {
+            str = '';
+        }
+
+        return {
+            data: str,
+            size: 2 + length
+        };
+    }
+
+    static parseLongString(arrayBuffer, dataOffset, dataSize) {
+        if (dataSize < 4) {
+            throw new IllegalStateException('Data not enough when parse LongString');
+        }
+        let v = new DataView(arrayBuffer, dataOffset, dataSize);
+        let length = v.getUint32(0, !le);
+
+        let str;
+        if (length > 0) {
+            str = decodeUTF8(new Uint8Array(arrayBuffer, dataOffset + 4, length));
+        } else {
+            str = '';
+        }
+
+        return {
+            data: str,
+            size: 4 + length
+        };
+    }
+
+    static parseDate(arrayBuffer, dataOffset, dataSize) {
+        if (dataSize < 10) {
+            throw new IllegalStateException('Data size invalid when parse Date');
+        }
+        let v = new DataView(arrayBuffer, dataOffset, dataSize);
+        let timestamp = v.getFloat64(0, !le);
+        let localTimeOffset = v.getInt16(8, !le);
+        timestamp += localTimeOffset * 60 * 1000;  // get UTC time
+
+        return {
+            data: new Date(timestamp),
+            size: 8 + 2
+        };
+    }
+
+    static parseValue(arrayBuffer, dataOffset, dataSize) {
+        if (dataSize < 1) {
+            throw new IllegalStateException('Data not enough when parse Value');
+        }
+
+        let v = new DataView(arrayBuffer, dataOffset, dataSize);
+
+        let offset = 1;
+        let type = v.getUint8(0);
+        let value;
+        let objectEnd = false;
+
+        try {
+            switch (type) {
+                case 0:  // Number(Double) type
+                    value = v.getFloat64(1, !le);
+                    offset += 8;
+                    break;
+                case 1: {  // Boolean type
+                    let b = v.getUint8(1);
+                    value = b ? true : false;
+                    offset += 1;
+                    break;
+                }
+                case 2: {  // String type
+                    let amfstr = AMF.parseString(arrayBuffer, dataOffset + 1, dataSize - 1);
+                    value = amfstr.data;
+                    offset += amfstr.size;
+                    break;
+                }
+                case 3: { // Object(s) type
+                    value = {};
+                    let terminal = 0;  // workaround for malformed Objects which has missing ScriptDataObjectEnd
+                    if ((v.getUint32(dataSize - 4, !le) & 0x00FFFFFF) === 9) {
+                        terminal = 3;
+                    }
+                    while (offset < dataSize - 4) {  // 4 === type(UI8) + ScriptDataObjectEnd(UI24)
+                        let amfobj = AMF.parseObject(arrayBuffer, dataOffset + offset, dataSize - offset - terminal);
+                        if (amfobj.objectEnd)
+                            break;
+                        value[amfobj.data.name] = amfobj.data.value;
+                        offset += amfobj.size;
+                    }
+                    if (offset <= dataSize - 3) {
+                        let marker = v.getUint32(offset - 1, !le) & 0x00FFFFFF;
+                        if (marker === 9) {
+                            offset += 3;
+                        }
+                    }
+                    break;
+                }
+                case 8: { // ECMA array type (Mixed array)
+                    value = {};
+                    offset += 4;  // ECMAArrayLength(UI32)
+                    let terminal = 0;  // workaround for malformed MixedArrays which has missing ScriptDataObjectEnd
+                    if ((v.getUint32(dataSize - 4, !le) & 0x00FFFFFF) === 9) {
+                        terminal = 3;
+                    }
+                    while (offset < dataSize - 8) {  // 8 === type(UI8) + ECMAArrayLength(UI32) + ScriptDataVariableEnd(UI24)
+                        let amfvar = AMF.parseVariable(arrayBuffer, dataOffset + offset, dataSize - offset - terminal);
+                        if (amfvar.objectEnd)
+                            break;
+                        value[amfvar.data.name] = amfvar.data.value;
+                        offset += amfvar.size;
+                    }
+                    if (offset <= dataSize - 3) {
+                        let marker = v.getUint32(offset - 1, !le) & 0x00FFFFFF;
+                        if (marker === 9) {
+                            offset += 3;
+                        }
+                    }
+                    break;
+                }
+                case 9:  // ScriptDataObjectEnd
+                    value = undefined;
+                    offset = 1;
+                    objectEnd = true;
+                    break;
+                case 10: {  // Strict array type
+                    // ScriptDataValue[n]. NOTE: according to video_file_format_spec_v10_1.pdf
+                    value = [];
+                    let strictArrayLength = v.getUint32(1, !le);
+                    offset += 4;
+                    for (let i = 0; i < strictArrayLength; i++) {
+                        let val = AMF.parseValue(arrayBuffer, dataOffset + offset, dataSize - offset);
+                        value.push(val.data);
+                        offset += val.size;
+                    }
+                    break;
+                }
+                case 11: {  // Date type
+                    let date = AMF.parseDate(arrayBuffer, dataOffset + 1, dataSize - 1);
+                    value = date.data;
+                    offset += date.size;
+                    break;
+                }
+                case 12: {  // Long string type
+                    let amfLongStr = AMF.parseString(arrayBuffer, dataOffset + 1, dataSize - 1);
+                    value = amfLongStr.data;
+                    offset += amfLongStr.size;
+                    break;
+                }
+                default:
+                    // ignore and skip
+                    offset = dataSize;
+                    Log.w('AMF', 'Unsupported AMF value type ' + type);
+            }
+        } catch (e) {
+            Log.e('AMF', e.toString());
+        }
+
+        return {
+            data: value,
+            size: offset,
+            objectEnd: objectEnd
+        };
+    }
+
+}
+
+export default AMF;