jmuxer 2.0.7 → 2.1.1

package/src/jmuxer.js

@@ -1,8 +1,4 @@
 import * as debug from './util/debug';
-import { NALU } from './util/nalu.js';
-import { appendByteArray } from './util/utils.js';
-import { H264Parser } from './parsers/h264.js';
-import { AACParser } from './parsers/aac.js';
 import Event from './util/event';
 import RemuxController from './controller/remux.js';
 import BufferController from './controller/buffer.js';
@@ -19,6 +15,7 @@ export default class JMuxer extends Event {
         let defaults = {
             node: '',
             mode: 'both', // both, audio, video
+            videoCodec: 'H264', // H264, H265
             flushingTime: 500,
             maxDelay: 500,
             clearBuffer: true,
@@ -28,20 +25,24 @@ export default class JMuxer extends Event {
             onReady: function() {}, // function called when MSE is ready to accept frames
             onData: function() {}, // function called when data is ready to be sent
             onError: function() {}, // function called when jmuxer encounters any buffer related errors
+            onUnsupportedCodec: function() {}, // function called when a codec is not supported by the browser
             onMissingVideoFrames: function () {}, // function called when jmuxer encounters any missing video frames
             onMissingAudioFrames: function () {}, // function called when jmuxer encounters any missing audio frames
+            onKeyframePosition: function () {}, // function called when a keyframe is detected thus the provided time is seekable
+            onLoggerLog: console.log,
+            onLoggerErr: console.error,
         };
         this.options = Object.assign({}, defaults, options);
         this.env = typeof process === 'object' && typeof window === 'undefined' ? 'node' : 'browser';
         if (this.options.debug) {
-            debug.setLogger();
+            debug.setLogger(this.options.onLoggerLog, this.options.onLoggerErr);
         }
 
         if (!this.options.fps) {
             this.options.fps = 30;
         }
         this.frameDuration = (1000 / this.options.fps) | 0;
-        this.remuxController = new RemuxController(this.env);
+        this.remuxController = new RemuxController(this.env, options.live, this.options.videoCodec, this.frameDuration);
         this.remuxController.addTrack(this.options.mode);
 
         this.initData();
@@ -52,12 +53,34 @@ export default class JMuxer extends Event {
             this.remuxController.on('ready', this.createBuffer.bind(this));
             this.initBrowser();
         }
+
+        this.remuxController.on('missingVideoFrames', () => {
+            if (typeof this.options.onMissingVideoFrames === 'function') {
+                this.options.onMissingVideoFrames.call(null);
+            }
+        });
+        this.remuxController.on('missingAudioFrames', () => {
+            if (typeof this.options.onMissingAudioFrames === 'function') {
+                this.options.onMissingAudioFrames.call(null);
+            }
+        });
+        if (this.clearBuffer) {
+            // this is used to know when keyframes are,
+            // to essentially know which specific times are seekable
+            this.remuxController.on('keyframePosition', time => {
+                this.kfPosition.push(time);
+            });
+        }
+        if (typeof this.options.onKeyframePosition === 'function') {
+            this.remuxController.on('keyframePosition', time => {
+                this.options.onKeyframePosition.call(null, time);
+            });
+        }
     }
 
     initData() {
         this.lastCleaningTime = Date.now();
         this.kfPosition = [];
-        this.kfCounter = 0;
         this.pendingUnits = {};
         this.remainingData = new Uint8Array();
         this.startInterval();
@@ -134,143 +157,11 @@ export default class JMuxer extends Event {
     }
 
     feed(data) {
-        let remux = false,
-            slices,
-            left,
-            duration,
-            chunks = {
-                video: [],
-                audio: []
-            };
-
         if (!data || !this.remuxController) return;
-        duration = data.duration ? parseInt(data.duration) : 0;
+        
+        data.duration = data.duration ? parseInt(data.duration) : 0;
 
-        if (data.video) {
-            data.video = appendByteArray(this.remainingData, data.video);
-            [slices, left] = H264Parser.extractNALu(data.video);
-            this.remainingData = left || new Uint8Array();
-
-            if (slices.length > 0) {
-                chunks.video = this.getVideoFrames(slices, duration, data.compositionTimeOffset);
-                remux = true;
-            } else {
-                debug.error('Failed to extract any NAL units from video data:', left);
-                if (typeof this.options.onMissingVideoFrames === 'function') {
-                    this.options.onMissingVideoFrames.call(null, data);
-                }
-                return;
-            }
-        }
-        if (data.audio) {
-            slices = AACParser.extractAAC(data.audio);
-            if (slices.length > 0) {
-                chunks.audio = this.getAudioFrames(slices, duration);
-                remux = true;
-            } else {
-                debug.error('Failed to extract audio data from:', data.audio);
-                if (typeof this.options.onMissingAudioFrames === 'function') {
-                    this.options.onMissingAudioFrames.call(null, data);
-                }
-                return;
-            }
-        }
-        if (!remux) {
-            debug.error('Input object must have video and/or audio property. Make sure it is a valid typed array');
-            return;
-        }
-        this.remuxController.remux(chunks);
-    }
-
-    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 NALU(nalu);
-            if (unit.type() === NALU.IDR || unit.type() === NALU.NDR) {
-                H264Parser.parseHeader(unit);
-            }
-            if (units.length && vcl && (unit.isfmb || !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.options.clearBuffer) {
-                this.kfPosition.push((this.kfCounter * fd) / 1000);
-            }
-        });
-        debug.log(`jmuxer: No. of frames of the last chunk: ${frames.length}`);
-        return frames;
-    }
-
-    getAudioFrames(aacFrames, duration) {
-        let frames = [],
-            fd = 0,
-            tt = 0;
-
-        for (let units of aacFrames) {
-            frames.push({ units });
-        }
-        fd = duration ? duration / frames.length | 0 : this.frameDuration;
-        tt = duration ? (duration - (fd * frames.length)) : 0;
-        frames.map((frame) => {
-            frame.duration = fd;
-            if (tt > 0) {
-                frame.duration++;
-                tt--;
-            }
-        });
-        return frames;
+        this.remuxController.feed(data);
     }
 
     destroy() {
@@ -324,7 +215,10 @@ export default class JMuxer extends Event {
         for (let type in this.remuxController.tracks) {
             let track = this.remuxController.tracks[type];
             if (!JMuxer.isSupported(`${type}/mp4; codecs="${track.mp4track.codec}"`)) {
-                debug.error('Browser does not support codec');
+                debug.error(`Browser does not support codec: ${type}/mp4; codecs="${track.mp4track.codec}"`);
+                if (typeof this.options.onUnsupportedCodec === 'function') {
+                    this.options.onUnsupportedCodec.call(null, track.mp4track.codec);
+                }
                 return false;
             }
             let sb = this.mediaSource.addSourceBuffer(`${type}/mp4; codecs="${track.mp4track.codec}"`);
@@ -353,7 +247,8 @@ export default class JMuxer extends Event {
         if (this.node.buffered && this.node.buffered.length > 0 && !this.node.seeking) {
             const end = this.node.buffered.end(0);
             if (end - this.node.currentTime > (this.options.maxDelay / 1000)) {
-                console.log('delay');
+                debug.log('delay');
+                if (this.node.paused) this.node.play().catch(debug.error);
                 this.node.currentTime = end - 0.001;
             }
         }
@@ -429,7 +324,7 @@ export default class JMuxer extends Event {
         URL.revokeObjectURL(this.url);
         // this.createBuffer();
         if (typeof this.options.onReady === 'function') {
-            this.options.onReady.call(null, this.isReset);
+            this.options.onReady.call(null, this.isReset, this.mediaSource);
         }
     }
 

package/src/parsers/aac.js

@@ -1,7 +1,6 @@
 import * as debug from '../util/debug';
 
 export class AACParser {
-    static aacHeader;
 
     static get samplingRateMap() {
         return [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
@@ -22,56 +21,30 @@ export class AACParser {
     static extractAAC(buffer) {
         let i = 0,
             length = buffer.byteLength,
-            result = [],
+            slices = [],
             headerLength,
             frameLength;
 
         if (!AACParser.isAACPattern(buffer)) {
             debug.error('Invalid ADTS audio format');
-            return result;
+            return {
+                valid: false,
+            };
         }
         headerLength = AACParser.getHeaderLength(buffer);
-        if (!AACParser.aacHeader) {
-            AACParser.aacHeader = buffer.subarray(0, headerLength);
-        }
+        const header = buffer.subarray(0, headerLength);
 
         while (i < length) {
             frameLength = AACParser.getFrameLength(buffer);
-            result.push(buffer.subarray(headerLength, frameLength));
+            slices.push(buffer.subarray(headerLength, frameLength));
             buffer = buffer.slice(frameLength);
             i += frameLength;
         }
-        return result;
-    }
-
-    constructor(remuxer) {
-        this.remuxer = remuxer;
-        this.track = remuxer.mp4track;
+        return {
+            valid: true,
+            header,
+            slices,
+        };
     }
 
-    setAACConfig() {
-        let objectType,
-            sampleIndex,
-            channelCount,
-            config = new Uint8Array(2),
-            headerData = AACParser.aacHeader;
-
-        if (!headerData) return;
-            
-        objectType = ((headerData[2] & 0xC0) >>> 6) + 1;
-        sampleIndex = ((headerData[2] & 0x3C) >>> 2);
-        channelCount = ((headerData[2] & 0x01) << 2);
-        channelCount |= ((headerData[3] & 0xC0) >>> 6);
-
-        /* refer to http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Audio_Specific_Config */
-        config[0] = objectType << 3;
-        config[0] |= (sampleIndex & 0x0E) >> 1;
-        config[1] |= (sampleIndex & 0x01) << 7;
-        config[1] |= channelCount << 3;
-
-        this.track.codec = 'mp4a.40.' + objectType;
-        this.track.channelCount = channelCount;
-        this.track.config = config;
-        this.remuxer.readyToDecode = true;
-    }
 }

package/src/parsers/h264.js

@@ -1,56 +1,42 @@
 import { ExpGolomb } from '../util/exp-golomb.js';
-import { NALU } from '../util/nalu.js';
 import * as debug from '../util/debug';
 
+// spec https://www.itu.int/rec/T-REC-H.264/
+
 export class H264Parser {
 
     static extractNALu(buffer) {
         let i = 0,
             length = buffer.byteLength,
-            value,
-            state = 0,
             result = [],
-            left,
-            lastIndex = 0;
+            lastIndex = 0,
+            zeroCount = 0;
 
         while (i < length) {
-            value = buffer[i++];
-            // finding 3 or 4-byte start codes (00 00 01 OR 00 00 00 01)
-            switch (state) {
-                case 0:
-                    if (value === 0) {
-                        state = 1;
-                    }
-                    break;
-                case 1:
-                    if (value === 0) {
-                        state = 2;
-                    } else {
-                        state = 0;
-                    }
-                    break;
-                case 2:
-                case 3:
-                    if (value === 0) {
-                        state = 3;
-                    } else if (value === 1 && i < length) {
-                        if (lastIndex != i - state -1) {
-                            result.push(buffer.subarray(lastIndex, i - state -1));
-                        }
-                        lastIndex = i;
-                        state = 0;
-                    } else {
-                        state = 0;
-                    }
-                    break;
-                default:
-                    break;
+            let value = buffer[i++];
+
+            if (value === 0) {
+                zeroCount++;
+            } else if (value === 1 && zeroCount >= 2) {
+                let startCodeLength = zeroCount + 1;
+
+                if (lastIndex !== i - startCodeLength) {
+                    result.push(buffer.subarray(lastIndex, i - startCodeLength));
+                }
+
+                lastIndex = i;
+                zeroCount = 0;
+            } else {
+                zeroCount = 0;
             }
         }
 
+        // Remaining data after last start code
+        let left = null;
         if (lastIndex < length) {
             left = buffer.subarray(lastIndex, length);
         }
+
         return [result, left];
     }
 
@@ -235,9 +221,11 @@ export class H264Parser {
                 let fixedFrameRate = decoder.readBoolean();
                 let frameDuration = timeScale / (2 * unitsInTick);
 
-                if (fixedFrameRate) {
-                    fps = frameDuration;
-                }
+                // if (fixedFrameRate) {
+                //     fps = frameDuration;
+                // }
+                // Return the fps value even if fixedFrameRate is not set
+                fps = frameDuration;
             }
         }
         return {
@@ -246,76 +234,95 @@ export class H264Parser {
             height: ((2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16) - ((frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset)),
         };
     }
-    static parseHeader(unit) {
-        let decoder = new ExpGolomb(unit.getPayload());
-        // skip NALu type
-        decoder.readUByte();
-        unit.isfmb = decoder.readUEG() === 0;
-        unit.stype = decoder.readUEG();
+    
+}
+
+export class NALU264 {
+    static get NDR() { return 1; }
+    static get IDR() { return 5; }
+    static get SEI() { return 6; }
+    static get SPS() { return 7; }
+    static get PPS() { return 8; }
+    static get AUD() { return 9; }
+
+    static get TYPES() {
+        return {
+            [NALU264.IDR]: 'IDR',
+            [NALU264.SEI]: 'SEI',
+            [NALU264.SPS]: 'SPS',
+            [NALU264.PPS]: 'PPS',
+            [NALU264.NDR]: 'NDR',
+            [NALU264.AUD]: 'AUD',
+        };
+    }
+
+    constructor(data) {
+        this.payload = data;
+        this.nri = (this.payload[0] & 0x60) >> 5; // nal_ref_idc
+        this.nalUnitType = this.payload[0] & 0x1f;
+        this._sliceType = null;
+        this._isFirstSlice = false;
+    }
+
+    toString() {
+        return `${NALU264.TYPES[this.type()] || 'UNKNOWN'}: NRI: ${this.getNri()}`;
     }
-    constructor(remuxer) {
-        this.remuxer = remuxer;
-        this.track = remuxer.mp4track;
+
+    getNri() {
+        return this.nri;
     }
 
-    parseSPS(sps) {
-        var config = H264Parser.readSPS(new Uint8Array(sps));
+    type() {
+        return this.nalUnitType;
+    }
 
-        this.track.fps = config.fps;
-        this.track.width = config.width;
-        this.track.height = config.height;
-        this.track.sps = [new Uint8Array(sps)];
-        this.track.codec = 'avc1.';
+    get isKeyframe() {
+        return this.nalUnitType === NALU264.IDR;
+    }
 
-        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.track.codec += h;
-        }
+    get isVCL() {
+        return this.nalUnitType == NALU264.IDR || this.nalUnitType == NALU264.NDR;
     }
 
-    parsePPS(pps) {
-        this.track.pps = [new Uint8Array(pps)];
+    parseHeader() {
+        let decoder = new ExpGolomb(this.getPayload());
+        // skip NALu type
+        decoder.readUByte();
+        this._isFirstSlice = decoder.readUEG() === 0;
+        this._sliceType = decoder.readUEG();
     }
 
-    parseNAL(unit) {
-        if (!unit) return false;
+    get isFirstSlice() {
+        if (!this._isFirstSlice) {
+            this.parseHeader();
+        }
+        return this._isFirstSlice;
+    }
 
-        let push = false;
-        switch (unit.type()) {
-            case NALU.IDR:
-            case NALU.NDR:
-                push = true;
-                break;
-            case NALU.PPS:
-                if (!this.track.pps) {
-                    this.parsePPS(unit.getPayload());
-                    if (!this.remuxer.readyToDecode && this.track.pps && this.track.sps) {
-                        this.remuxer.readyToDecode = true;
-                    }
-                }
-                push = true;
-                break;
-            case NALU.SPS:
-                if (!this.track.sps) {
-                    this.parseSPS(unit.getPayload());
-                    if (!this.remuxer.readyToDecode && this.track.pps && this.track.sps) {
-                        this.remuxer.readyToDecode = true;
-                    }
-                }
-                push = true;
-                break;
-            case NALU.AUD:
-                debug.log('AUD - ignoing');
-                break;
-            case NALU.SEI:
-                debug.log('SEI - ignoing');
-                break;
-            default:
+    get sliceType() {
+        if (!this._sliceType) {
+            this.parseHeader();
         }
-        return push;
+        return this._sliceType;
+    }
+    
+    getPayload() {
+        return this.payload;
+    }
+
+    getPayloadSize() {
+        return this.payload.byteLength;
+    }
+
+    getSize() {
+        return 4 + this.getPayloadSize();
+    }
+
+    getData() {
+        const result = new Uint8Array(this.getSize());
+        const view = new DataView(result.buffer);
+        view.setUint32(0, this.getSize() - 4);
+        result.set(this.getPayload(), 4);
+        return result;
     }
 }