/* eslint-disable */
|
|
import Event from '../events';
|
import ExpGolomb from './exp-golomb';
|
import EventHandler from '../event-handler';
|
import MP4Remuxer from '../remux/mp4-remuxer';
|
import { logger } from '../utils/logger';
|
|
class h264Demuxer extends EventHandler {
|
|
constructor(wfs, config = null) {
|
super(wfs,
|
Event.H264_DATA_PARSING);
|
|
this.config = this.wfs.config || config;
|
this.wfs = wfs;
|
this.id = 'main';
|
|
this.remuxer = new MP4Remuxer(this.wfs, this.id, this.config);
|
this.contiguous = true;
|
this.timeOffset = 1;
|
this.sn = 0;
|
this.TIMESCALE = 90000;
|
this.timestamp = 0;
|
this.scaleFactor = this.TIMESCALE / 1000;
|
this.H264_TIMEBASE = 3000;
|
this._avcTrack = {
|
container: 'video/mp2t', type: 'video', id: 1, sequenceNumber: 0,
|
samples: [], len: 0, nbNalu: 0, dropped: 0, count: 0
|
};
|
this.browserType = 0;
|
if (navigator.userAgent.toLowerCase().indexOf('firefox') !== -1) {
|
this.browserType = 1;
|
}
|
}
|
|
destroy() {
|
EventHandler.prototype.destroy.call(this);
|
}
|
|
getTimestampM() {
|
this.timestamp += this.H264_TIMEBASE;
|
return this.timestamp;
|
}
|
|
onH264DataParsing(event) {
|
this._parseAVCTrack(event.data);
|
// console.log(this.browserType,'onH264DataParsing')
|
this.remuxer.pushVideo(0, this.sn, this._avcTrack, this.timeOffset, this.contiguous);
|
this.sn += 1;
|
}
|
|
_parseAVCTrack(array) {
|
var track = this._avcTrack,
|
samples = track.samples,
|
units = this._parseAVCNALu(array),
|
units2 = [],
|
debug = false,
|
key = false,
|
length = 0,
|
expGolombDecoder,
|
avcSample,
|
push,
|
i;
|
var debugString = '';
|
var pushAccesUnit = function () {
|
if (units2.length) {
|
if (!this.config.forceKeyFrameOnDiscontinuity ||
|
key === true ||
|
(track.sps && (samples.length || this.contiguous))) {
|
var tss = this.getTimestampM();
|
avcSample = { units: { units: units2, length: length }, pts: tss, dts: tss, key: key };
|
samples.push(avcSample);
|
track.len += length;
|
track.nbNalu += units2.length;
|
} else {
|
track.dropped++;
|
}
|
units2 = [];
|
length = 0;
|
}
|
}.bind(this);
|
|
units.forEach(unit => {
|
switch (unit.type) {
|
//NDR
|
case 1:
|
push = true;
|
if (debug) {
|
debugString += 'NDR ';
|
}
|
break;
|
//IDR
|
case 5:
|
push = true;
|
if (debug) {
|
debugString += 'IDR ';
|
}
|
key = true;
|
break;
|
//SEI
|
case 6:
|
unit.data = this.discardEPB(unit.data);
|
expGolombDecoder = new ExpGolomb(unit.data);
|
// skip frameType
|
expGolombDecoder.readUByte();
|
break;
|
//SPS
|
case 7:
|
push = false;
|
if (debug) {
|
debugString += 'SPS ';
|
}
|
if (!track.sps) {
|
expGolombDecoder = new ExpGolomb(unit.data);
|
var config = expGolombDecoder.readSPS();
|
track.width = config.width;
|
track.height = config.height;
|
track.sps = [unit.data];
|
track.duration = 0;
|
var codecarray = unit.data.subarray(1, 4);
|
var codecstring = 'avc1.';
|
for (i = 0; i < 3; i++) {
|
var h = codecarray[i].toString(16);
|
if (h.length < 2) {
|
h = '0' + h;
|
}
|
codecstring += h;
|
}
|
track.codec = codecstring;
|
this.wfs.trigger(Event.BUFFER_RESET, { mimeType: track.codec });
|
push = true;
|
}
|
break;
|
//PPS
|
case 8:
|
push = false;
|
if (debug) {
|
debugString += 'PPS ';
|
}
|
if (!track.pps) {
|
track.pps = [unit.data];
|
push = true;
|
}
|
break;
|
case 9:
|
push = false;
|
if (debug) {
|
debugString += 'AUD ';
|
}
|
pushAccesUnit();
|
break;
|
default:
|
push = false;
|
debugString += 'unknown NAL ' + unit.type + ' ';
|
break;
|
}
|
|
if (push) {
|
units2.push(unit);
|
length += unit.data.byteLength;
|
}
|
|
});
|
|
if (debug || debugString.length) {
|
logger.log(debugString);
|
}
|
|
pushAccesUnit();
|
|
}
|
|
_parseAVCNALu(array) {
|
var i = 0, len = array.byteLength, value, overflow, state = 0; //state = this.avcNaluState;
|
var units = [], unit, unitType, lastUnitStart, lastUnitType;
|
while (i < len) {
|
value = array[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 < len) {
|
unitType = array[i] & 0x1f;
|
if (lastUnitStart) {
|
unit = { data: array.subarray(lastUnitStart, i - state - 1), type: lastUnitType };
|
units.push(unit);
|
} else {
|
}
|
lastUnitStart = i;
|
lastUnitType = unitType;
|
state = 0;
|
} else {
|
state = 0;
|
}
|
break;
|
default:
|
break;
|
}
|
}
|
|
if (lastUnitStart) {
|
unit = { data: array.subarray(lastUnitStart, len), type: lastUnitType, state: state };
|
units.push(unit);
|
}
|
|
return units;
|
}
|
|
/**
|
* remove Emulation Prevention bytes from a RBSP
|
*/
|
discardEPB(data) {
|
var length = data.byteLength,
|
EPBPositions = [],
|
i = 1,
|
newLength, newData;
|
// Find all `Emulation Prevention Bytes`
|
while (i < length - 2) {
|
if (data[i] === 0 &&
|
data[i + 1] === 0 &&
|
data[i + 2] === 0x03) {
|
EPBPositions.push(i + 2);
|
i += 2;
|
} else {
|
i++;
|
}
|
}
|
// If no Emulation Prevention Bytes were found just return the original
|
// array
|
if (EPBPositions.length === 0) {
|
return data;
|
}
|
// Create a new array to hold the NAL unit data
|
newLength = length - EPBPositions.length;
|
newData = new Uint8Array(newLength);
|
var sourceIndex = 0;
|
|
for (i = 0; i < newLength; sourceIndex++ , i++) {
|
if (sourceIndex === EPBPositions[0]) {
|
// Skip this byte
|
sourceIndex++;
|
// Remove this position index
|
EPBPositions.shift();
|
}
|
newData[i] = data[sourceIndex];
|
}
|
return newData;
|
}
|
|
|
}
|
export default h264Demuxer;
|
