jmuxer 2.0.7 → 2.1.0

package/src/remuxer/h264.js

@@ -1,11 +1,13 @@
 import * as debug from '../util/debug';
-import { H264Parser } from '../parsers/h264.js';
+import { H264Parser, NALU264 } from '../parsers/h264.js';
 import { BaseRemuxer } from './base.js';
+import { appendByteArray } from '../util/utils.js';
 
 export class H264Remuxer extends BaseRemuxer {
 
-    constructor(timescale) {
-        super();
+    constructor(timescale, duration, frameDuration) {
+        super('H264Remuxer');
+        this.frameDuration = frameDuration;
         this.readyToDecode = false;
         this.nextDts = 0;
         this.dts = 0;
@@ -20,11 +22,13 @@ export class H264Remuxer extends BaseRemuxer {
             width: 0,
             height: 0,
             timescale: timescale,
-            duration: timescale,
+            duration: duration,
             samples: [],
         };
         this.samples = [];
-        this.h264 = new H264Parser(this);
+        this.remainingData = new Uint8Array();
+        this.kfCounter = 0;
+        this.pendingUnits = {};
     }
 
     resetTrack() {
@@ -33,6 +37,99 @@ export class H264Remuxer extends BaseRemuxer {
         this.mp4track.pps = '';
         this.nextDts = 0;
         this.dts = 0;
+        this.remainingData = new Uint8Array();
+        this.kfCounter = 0;
+        this.pendingUnits = {};
+    }
+
+    feed(data, duration, compositionTimeOffset) {
+        let slices = [];
+        let left;
+        data = appendByteArray(this.remainingData, data);
+        [slices, left] = H264Parser.extractNALu(data);
+        this.remainingData = left || new Uint8Array();
+    
+        if (slices.length > 0) {
+            this.remux(this.getVideoFrames(slices, duration, compositionTimeOffset));
+            return true;
+        } else {
+            debug.error('Failed to extract any NAL units from video data:', left);
+            this.dispatch('outOfData');
+            return false;
+        }
+    }
+
+    getVideoFrames(nalus, duration, compositionTimeOffset) {
+        let units = [],
+            frames = [],
+            fd = 0, // frame duration
+            tt = 0, // time ticks (remainder adjustment counter)
+            keyFrame = false,
+            vcl = false; // Video Coding Layer data (i.e., a "real" frame)
+        if (this.pendingUnits.units) {
+            units = this.pendingUnits.units;
+            vcl = this.pendingUnits.vcl;
+            keyFrame = this.pendingUnits.keyFrame;
+            this.pendingUnits = {};
+        }
+
+        for (let nalu of nalus) {
+            let unit = new NALU264(nalu);
+
+            // frame boundary detection
+            if (units.length && vcl && (unit.isFirstSlice || !unit.isVCL)) {
+                frames.push({
+                    units,
+                    keyFrame
+                });
+                units = [];
+                keyFrame = false;
+                vcl = false;
+            }
+
+            units.push(unit);
+            keyFrame = keyFrame || unit.isKeyframe;
+            vcl = vcl || unit.isVCL;
+        }
+
+        if (units.length) {
+            // lets keep indecisive nalus as pending in case of fixed fps
+            if (!duration) {
+                this.pendingUnits = {
+                    units,
+                    keyFrame,
+                    vcl
+                };
+            } else if (vcl) {
+                frames.push({
+                    units,
+                    keyFrame
+                });
+            } else {
+                let last = frames.length - 1;
+                if (last >= 0) {
+                    frames[last].units = frames[last].units.concat(units);
+                }
+            }
+        }
+
+        fd = duration ? duration / frames.length | 0 : this.frameDuration;
+        tt = duration ? (duration - (fd * frames.length)) : 0;
+
+        frames.map((frame) => {
+            frame.duration = fd;
+            frame.compositionTimeOffset = compositionTimeOffset;
+            if (tt > 0) {
+                frame.duration++;
+                tt--;
+            }
+            this.kfCounter++;
+            if (frame.keyFrame) {
+                this.dispatch('keyframePosition', (this.kfCounter * fd) / 1000);
+            }
+        });
+        debug.log(`jmuxer: No. of H264 frames of the last chunk: ${frames.length}`);
+        return frames;
     }
 
     remux(frames) {
@@ -40,7 +137,7 @@ export class H264Remuxer extends BaseRemuxer {
             let units = [];
             let size = 0;
             for (let unit of frame.units) {
-                if (this.h264.parseNAL(unit)) {
+                if (this.parseNAL(unit)) {
                     units.push(unit);
                     size += unit.getSize();
                 }
@@ -67,7 +164,6 @@ export class H264Remuxer extends BaseRemuxer {
         let samples = this.mp4track.samples;
         let mp4Sample,
             duration;
-
         this.dts = this.nextDts;
         while (this.samples.length) {
             let sample = this.samples.shift(),
@@ -105,4 +201,64 @@ export class H264Remuxer extends BaseRemuxer {
 
         return new Uint8Array(payload.buffer, 0, this.mp4track.len);
     }
+
+    parseSPS(sps) {
+        var config = H264Parser.readSPS(new Uint8Array(sps));
+
+        this.mp4track.fps = config.fps || this.mp4track.fps;
+        this.mp4track.width = config.width;
+        this.mp4track.height = config.height;
+        this.mp4track.sps = [new Uint8Array(sps)];
+        this.mp4track.codec = 'avc1.';
+
+        let codecarray = new DataView(sps.buffer, sps.byteOffset + 1, 4);
+        for (let i = 0; i < 3; ++i) {
+            var h = codecarray.getUint8(i).toString(16);
+            if (h.length < 2) {
+                h = '0' + h;
+            }
+            this.mp4track.codec += h;
+        }
+    }
+
+    parsePPS(pps) {
+        this.mp4track.pps = [new Uint8Array(pps)];
+    }
+
+    parseNAL(unit) {
+        if (!unit) return false;
+
+        if (unit.isVCL) {
+            return true;
+        }
+
+        let push = false;
+        switch (unit.type()) {
+            case NALU264.PPS:
+                if (!this.mp4track.pps) {
+                    this.parsePPS(unit.getPayload());
+                }
+                push = true;
+                break;
+            case NALU264.SPS:
+                if (!this.mp4track.sps) {
+                    this.parseSPS(unit.getPayload());
+                }
+                push = true;
+                break;
+            case NALU264.AUD:
+                debug.log('AUD - ignoing');
+                break;
+            case NALU264.SEI:
+                debug.log('SEI - ignoing');
+                break;
+            default:
+        }
+
+        if (!this.readyToDecode && this.mp4track.pps && this.mp4track.sps) {
+            this.readyToDecode = true;
+        }
+        
+        return push;
+    }
 }

package/src/remuxer/h265.js

@@ -0,0 +1,288 @@
+import * as debug from '../util/debug';
+import { H265Parser, NALU265 } from '../parsers/h265.js';
+import { BaseRemuxer } from './base.js';
+import { appendByteArray } from '../util/utils.js';
+
+export class H265Remuxer extends BaseRemuxer {
+
+    constructor(timescale, duration, frameDuration) {
+        super('H264Remuxer');
+        this.frameDuration = frameDuration;
+        this.readyToDecode = false;
+        this.nextDts = 0;
+        this.dts = 0;
+        this.mp4track = {
+            id: BaseRemuxer.getTrackID(),
+            type: 'video',
+            len: 0,
+            fragmented: true,
+            vps: '',
+            sps: '',
+            pps: '',
+            hvcC: {},
+            fps: 30,
+            width: 0,
+            height: 0,
+            timescale: timescale,
+            duration: duration,
+            samples: [],
+        };
+        this.samples = [];
+        this.remainingData = new Uint8Array();
+        this.kfCounter = 0;
+        this.pendingUnits = {};
+    }
+
+    resetTrack() {
+        this.readyToDecode = false;
+        this.mp4track.vps = '';
+        this.mp4track.sps = '';
+        this.mp4track.pps = '';
+        this.mp4track.hvcC = {};
+        this.nextDts = 0;
+        this.dts = 0;
+        this.remainingData = new Uint8Array();
+        this.kfCounter = 0;
+        this.pendingUnits = {};
+    }
+
+    feed(data, duration, compositionTimeOffset) {
+        let slices = [];
+        let left;
+        data = appendByteArray(this.remainingData, data);
+        [slices, left] = H265Parser.extractNALu(data);
+        this.remainingData = left || new Uint8Array();
+    
+        if (slices.length > 0) {
+            this.remux(this.getVideoFrames(slices, duration, compositionTimeOffset));
+            return true;
+        } else {
+            debug.error('Failed to extract any NAL units from video data:', left);
+            this.dispatch('outOfData');
+            return false;
+        }
+    }
+
+    getVideoFrames(nalus, duration, compositionTimeOffset) {
+        let units = [],
+            frames = [],
+            fd = 0,
+            tt = 0,
+            keyFrame = false,
+            vcl = false;
+
+        if (this.pendingUnits.units) {
+            units = this.pendingUnits.units;
+            vcl = this.pendingUnits.vcl;
+            keyFrame = this.pendingUnits.keyFrame;
+            this.pendingUnits = {};
+        }
+
+        for (let nalu of nalus) {
+            let unit = new NALU265(nalu);
+
+            // frame boundary detection
+            if (units.length && vcl && (unit.isFirstSlice || !unit.isVCL)) {
+                frames.push({
+                    units,
+                    keyFrame
+                });
+                units = [];
+                keyFrame = false;
+                vcl = false;
+            }
+
+            units.push(unit);
+            keyFrame = keyFrame || unit.isKeyframe;
+            vcl = vcl || unit.isVCL;
+        }
+
+        if (units.length) {
+            if (!duration) {
+                this.pendingUnits = {
+                    units,
+                    keyFrame,
+                    vcl
+                };
+            } else if (vcl) {
+                frames.push({
+                    units,
+                    keyFrame
+                });
+            } else {
+                let last = frames.length - 1;
+                if (last >= 0) {
+                    frames[last].units = frames[last].units.concat(units);
+                }
+            }
+        }
+
+        fd = duration ? (duration / frames.length) | 0 : this.frameDuration;
+        tt = duration ? duration - fd * frames.length : 0;
+
+        frames.map((frame) => {
+            frame.duration = fd;
+            frame.compositionTimeOffset = compositionTimeOffset;
+            if (tt > 0) {
+                frame.duration++;
+                tt--;
+            }
+            this.kfCounter++;
+            if (frame.keyFrame) {
+                this.dispatch('keyframePosition', (this.kfCounter * fd) / 1000);
+            }
+        });
+
+        debug.log(`jmuxer: No. of H265 frames of the last chunk: ${frames.length}`);
+        return frames;
+    }
+
+    remux(frames) {
+        for (let frame of frames) {
+            let units = [];
+            let size = 0;
+            for (let unit of frame.units) {
+                if (this.parseNAL(unit)) {
+                    units.push(unit);
+                    size += unit.getSize();
+                }
+            }
+            if (units.length > 0 && this.readyToDecode) {
+                this.mp4track.len += size;
+                this.samples.push({
+                    units: units,
+                    size: size,
+                    keyFrame: frame.keyFrame,
+                    duration: frame.duration,
+                    compositionTimeOffset: frame.compositionTimeOffset
+                });
+            }
+        }
+    }
+
+    getPayload() {
+        if (!this.isReady()) {
+            return null;
+        }
+        let payload = new Uint8Array(this.mp4track.len);
+        let offset = 0;
+        let samples = this.mp4track.samples;
+        let mp4Sample,
+            duration;
+        this.dts = this.nextDts;
+        while (this.samples.length) {
+            let sample = this.samples.shift(),
+                units = sample.units;
+
+            duration = sample.duration;
+            if (duration <= 0) {
+                debug.log(`remuxer: invalid sample duration at DTS: ${this.nextDts} :${duration}`);
+                this.mp4track.len -= sample.size;
+                continue;
+            }
+            this.nextDts += duration;
+            mp4Sample = {
+                size: sample.size,
+                duration: duration,
+                cts: sample.compositionTimeOffset || 0,
+                flags: {
+                    isLeading: 0,
+                    isDependedOn: 0,
+                    hasRedundancy: 0,
+                    degradPrio: 0,
+                    isNonSync: sample.keyFrame ? 0 : 1,
+                    dependsOn: sample.keyFrame ? 2 : 1,
+                },
+            };
+
+            for (const unit of units) {
+                payload.set(unit.getData(), offset);
+                offset += unit.getSize();
+            }
+            samples.push(mp4Sample);
+        }
+
+        if (!samples.length) return null;
+
+        return new Uint8Array(payload.buffer, 0, this.mp4track.len);
+    }
+
+    parseSPS(sps) {
+        this.mp4track.sps = [new Uint8Array(sps)];
+        
+        sps = H265Parser.removeEmulationPreventionBytes(sps);
+        const config = H265Parser.readSPS(new Uint8Array(sps));
+
+        this.mp4track.fps = config.fps || this.mp4track.fps;
+        this.mp4track.width = config.width;
+        this.mp4track.height = config.height;
+
+        this.mp4track.codec = `hvc1.${config.profile_idc}.${config.profile_compatibility_flags.toString(16)}`
+            + `.L${config.level_idc}${config.tier_flag ? 'H' : 'L'}`
+            + `.${config.constraint_indicator_flags.map(b => b.toString(16)).join('.').toUpperCase()}`;
+
+        this.mp4track.hvcC = {
+            profile_space: config.profile_space,
+            tier_flag: config.tier_flag,
+            profile_idc: config.profile_idc,
+            profile_compatibility_flags: config.profile_compatibility_flags,
+            constraint_indicator_flags: config.constraint_indicator_flags,
+            level_idc: config.level_idc,
+            chroma_format_idc: config.chroma_format_idc
+        };
+    }
+
+    parsePPS(pps) {
+        this.mp4track.pps = [pps];
+    }
+
+    parseVPS(vps) {
+        this.mp4track.vps = [vps];
+    }
+
+    parseNAL(unit) {
+        if (!unit) return false;
+
+        if (unit.isVCL) {
+            return true;
+        }
+
+        let push = false;
+        switch (unit.type()) {
+            case NALU265.VPS:
+                if (!this.mp4track.vps) {
+                    this.parseVPS(unit.getPayload());
+                }
+                push = true;
+                break;
+
+            case NALU265.SPS:
+                if (!this.mp4track.sps) {
+                    this.parseSPS(unit.getPayload());
+                }
+                push = true;
+                break;
+
+            case NALU265.PPS:
+                if (!this.mp4track.pps) {
+                    this.parsePPS(unit.getPayload());
+                }
+                push = true;
+                break;
+            case NALU265.AUD:
+                debug.log('AUD - ignoing');
+                break;
+            case NALU265.SEI:
+            case NALU265.SEI2:
+                debug.log('SEI - ignoing');
+                break;
+            default:
+        }
+
+        if (!this.readyToDecode && this.mp4track.vps && this.mp4track.sps && this.mp4track.pps) {
+            this.readyToDecode = true;
+        }
+
+        return push;
+    }
+}

package/src/util/debug.js

@@ -1,10 +1,10 @@
 let logger;
 let errorLogger;
 
-export function setLogger() {
+export function setLogger(log, err) {
     /*eslint-disable */
-    logger = console.log;
-    errorLogger = console.error;
+    logger = log;
+    errorLogger = err;
     /*eslint-enable */
 }
 

package/src/util/event.js

@@ -27,10 +27,10 @@ export default class Event {
         this.listener = {};
     }
 
-    dispatch(event, data) {
+    dispatch(event, ...data) {
         if (this.listener[event]) {
             this.listener[event].map((each) => {
-                each.apply(null, [data]);
+                each.apply(null, data);
             });
             return true;
         }

package/src/util/mp4-generator.js

@@ -14,6 +14,8 @@ export class MP4 {
             esds: [],
             ftyp: [],
             hdlr: [],
+            hev1: [],
+            hvcC: [],
             mdat: [],
             mdhd: [],
             mdia: [],
@@ -179,9 +181,9 @@ export class MP4 {
             (timescale >> 16) & 0xFF,
             (timescale >> 8) & 0xFF,
             timescale & 0xFF, // timescale
-            (duration >> 24),
-            (duration >> 16) & 0xFF,
-            (duration >> 8) & 0xFF,
+            (duration >>> 24) & 0xFF,
+            (duration >>> 16) & 0xFF,
+            (duration >>> 8) & 0xFF,
             duration & 0xFF, // duration
             0x55, 0xc4, // 'und' language (undetermined)
             0x00, 0x00,
@@ -251,9 +253,9 @@ export class MP4 {
                 (timescale >> 16) & 0xFF,
                 (timescale >> 8) & 0xFF,
                 timescale & 0xFF, // timescale
-                (duration >> 24) & 0xFF,
-                (duration >> 16) & 0xFF,
-                (duration >> 8) & 0xFF,
+                (duration >>> 24) & 0xFF,
+                (duration >>> 16) & 0xFF,
+                (duration >>> 8) & 0xFF,
                 duration & 0xFF, // duration
                 0x00, 0x01, 0x00, 0x00, // 1.0 rate
                 0x01, 0x00, // 1.0 volume
@@ -375,6 +377,116 @@ export class MP4 {
             0x00, 0x2d, 0xc6, 0xc0])) // avgBitrate
         );
     }
+    
+    static hev1(track) {
+        let vps = [],
+            sps = [],
+            pps = [],
+            data,
+            len;
+
+        // assemble the VPSs
+        for (let i = 0; i < (track.vps?.length || 0); i++) {
+            data = track.vps[i];
+            len = data.byteLength;
+            vps.push((len >>> 8) & 0xFF, len & 0xFF);
+            vps = vps.concat(Array.prototype.slice.call(data));
+        }
+
+        // assemble the SPSs
+        for (let i = 0; i < (track.sps?.length || 0); i++) {
+            data = track.sps[i];
+            len = data.byteLength;
+            sps.push((len >>> 8) & 0xFF, len & 0xFF);
+            sps = sps.concat(Array.prototype.slice.call(data));
+        }
+
+        // assemble the PPSs
+        for (let i = 0; i < (track.pps?.length || 0); i++) {
+            data = track.pps[i];
+            len = data.byteLength;
+            pps.push((len >>> 8) & 0xFF, len & 0xFF);
+            pps = pps.concat(Array.prototype.slice.call(data));
+        }
+
+        let {
+            profile_space,
+            tier_flag,
+            profile_idc,
+            profile_compatibility_flags,
+            constraint_indicator_flags,
+            level_idc,
+            chroma_format_idc
+        } = track.hvcC;
+
+        const hvcc = MP4.box(MP4.types.hvcC, new Uint8Array([
+            0x01, // configurationVersion
+            (profile_space << 6) | (tier_flag << 5) | profile_idc,
+            (profile_compatibility_flags >> 24) & 0xFF,
+            (profile_compatibility_flags >> 16) & 0xFF,
+            (profile_compatibility_flags >> 8) & 0xFF,
+            profile_compatibility_flags & 0xFF,
+            ...constraint_indicator_flags,
+            level_idc,
+            0xF0, 0x00, // min_spatial_segmentation_idc = 0
+            0xFC | 0,   // parallelismType = 0
+            0xFC | chroma_format_idc, // chromaFormat (from SPS)
+            0xF8 | 0,   // bitDepthLumaMinus8 = 0 (8-bit)
+            0xF8 | 0,   // bitDepthChromaMinus8 = 0
+            0x00, 0x00, // avgFrameRate = 0
+            0x03,       // constantFrameRate = 0, numTemporalLayers = 0, lengthSizeMinusOne = 3 (AKA 4)
+            0x03,       // numOfArrays
+
+            0x20,       // array_completeness + NAL_unit_type (32 = VPS)
+            0x00, 0x01, // numNalus
+            ...vps,
+
+            0x21,       // NAL_unit_type (33 = SPS)
+            0x00, 0x01,
+            ...sps,
+
+            0x22,       // NAL_unit_type (34 = PPS)
+            0x00, 0x01,
+            ...pps
+        ]));
+
+        const width = track.width;
+        const height = track.height;
+
+        return MP4.box(MP4.types.hev1, new Uint8Array([
+            0x00, 0x00, 0x00, // reserved
+            0x00, 0x00, 0x00, // reserved
+            0x00, 0x01,       // data_reference_index
+            0x00, 0x00,       // pre_defined
+            0x00, 0x00,       // reserved
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00, // pre_defined
+            (width >> 8) & 0xFF, width & 0xff,
+            (height >> 8) & 0xFF, height & 0xff,
+            0x00, 0x48, 0x00, 0x00, // horizresolution
+            0x00, 0x48, 0x00, 0x00, // vertresolution
+            0x00, 0x00, 0x00, 0x00, // reserved
+            0x00, 0x01,             // frame_count
+            0x12,
+            0x62, 0x69, 0x6E, 0x65, // 'binelpro.ru'
+            0x6C, 0x70, 0x72, 0x6F,
+            0x2E, 0x72, 0x75, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00,       // compressorname padding
+            0x00, 0x18,             // depth = 24
+            0x11, 0x11              // pre_defined = -1
+        ]),
+        hvcc,
+        MP4.box(MP4.types.btrt, new Uint8Array([
+            0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB
+            0x00, 0x2d, 0xc6, 0xc0, // maxBitrate
+            0x00, 0x2d, 0xc6, 0xc0  // avgBitrate
+        ])));
+    }
 
     static esds(track) {
         var configlen = track.config.byteLength;
@@ -445,6 +557,9 @@ export class MP4 {
         if (track.type === 'audio') {
             return MP4.box(MP4.types.stsd, MP4.STSD, MP4.mp4a(track));
         } else {
+            if (track.codec.startsWith('hvc1')) {
+                return MP4.box(MP4.types.stsd, MP4.STSD, MP4.hev1(track));
+            }
             return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
         }
     }
@@ -465,9 +580,9 @@ export class MP4 {
             (id >> 8) & 0xFF,
             id & 0xFF, // track_ID
             0x00, 0x00, 0x00, 0x00, // reserved
-            (duration >> 24),
-            (duration >> 16) & 0xFF,
-            (duration >> 8) & 0xFF,
+            (duration >>> 24) & 0xFF,
+            (duration >>> 16) & 0xFF,
+            (duration >>> 8) & 0xFF,
             duration & 0xFF, // duration
             0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, // reserved