blackteay/xgplayer
1
0
Fork 0
mirror of https://github.com/bytedance/xgplayer.git synced 2025-04-05 11:18:46 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #307 from yqjiang/feat-transmuxer-refactor

Browse Source 
Feat transmuxer refactor
This commit is contained in:
付宇豪 2019-12-25 21:29:25 +08:00 committed by GitHub
commit 16eca54bd3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
200 changed files with 30757 additions and 32228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples

@ -1 +1 @@
Subproject commit ab5ef722bf0825e2586872eb7fefe594e6e47236
Subproject commit 231af2e62f83616abd2441b2cd4ef4f8779cc01b

78
packages/xgplayer-buffer/dist/Track.js vendored
View File

@ -1,78 +0,0 @@
export default class Track {
/**
* The constructor.
*/
constructor() {
this.id = -1;
this.sequenceNumber = 0;
this.samples = [];
this.droppedSamples = [];
this.length = 0;
}
/**
* Reset the track.
*/
reset() {
this.sequenceNumber = 0;
this.samples = [];
this.length = 0;
}
/**
* destroy the track.
*/
distroy() {
this.reset();
this.id = -1;
}
}
export class AudioTrack extends Track {
/**
* The constructor for audio track.
*/
constructor() {
super();
this.TAG = 'AudioTrack';
this.type = 'audio';
}
}
export class VideoTrack extends Track {
/**
* The constructor for video track.
*/
constructor() {
super();
this.TAG = 'VideoTrack';
this.type = 'video';
this.dropped = 0;
}
/**
* reset the video track.
*/
reset() {
this.sequenceNumber = 0;
this.samples = [];
this.length = 0;
this.dropped = 0;
}
}
export class Tracks {
constructor() {
this.audioTrack = null;
this.videoTrack = null;
}
destroy() {
this.audioTrack = null;
this.videoTrack = null;
}
}

144
packages/xgplayer-buffer/dist/buffer.js vendored
View File

@ -1,144 +0,0 @@
export class XgBuffer {
/**
* A buffer to store loaded data.
*
* @class LoaderBuffer
* @param {number} length - Optional the buffer size
*/
constructor(length) {
this.length = length || 0;
this.historyLen = length || 0;
this.array = [];
this.offset = 0;
}
/**
* The function to push data.
*
* @param {number} data - The data to push into the buffer
*/
push(data) {
this.array.push(data);
this.length += data.byteLength;
this.historyLen += data.byteLength;
}
/**
* The function to shift data.
*
* @param {number} length - The size of shift.
*/
shift(length) {
if (this.array.length < 1) {
return new Uint8Array(0);
}
if (length === undefined) {
return this._shiftBuffer();
}
if (this.offset + length === this.array[0].length) {
let ret = this.array[0].slice(this.offset, this.offset + length);
this.offset = 0;
this.array.shift();
this.length -= length;
return ret;
}
if (this.offset + length < this.array[0].length) {
let ret = this.array[0].slice(this.offset, this.offset + length);
this.offset += length;
this.length -= length;
return ret;
}
let ret = new Uint8Array(length);
let tmpoff = 0;
while (this.array.length > 0 && length > 0) {
if (this.offset + length < this.array[0].length) {
let tmp = this.array[0].slice(this.offset, this.offset + length);
ret.set(tmp, tmpoff);
this.offset += length;
this.length -= length;
length = 0;
break;
} else {
// console.log('mark1')
let templength = this.array[0].length - this.offset;
ret.set(this.array[0].slice(this.offset, this.array[0].length), tmpoff);
this.array.shift();
this.offset = 0;
tmpoff += templength;
this.length -= templength;
length -= templength;
}
}
return ret;
}
/**
* Function to clear the buffer.
*/
clear() {
this.array = [];
this.length = 0;
this.offset = 0;
}
destroy() {
this.clear();
this.historyLen = 0;
}
/**
* Function to shift one unit8Array.
*/
_shiftBuffer() {
this.length -= this.array[0].length;
this.offset = 0;
return this.array.shift();
}
/**
* Convert uint8 data to number.
*
* @param {number} start - the start postion.
* @param {number} length - the length of data.
*/
toInt(start, length) {
let retInt = 0;
let i = this.offset + start;
while (i < this.offset + length + start) {
if (i < this.array[0].length) {
retInt = retInt * 256 + this.array[0][i];
} else if (this.array[1]) {
retInt = retInt * 256 + this.array[1][i - this.array[0].length];
}
i++;
}
return retInt;
}
}
export class RemuxBuffer {
constructor() {
this.video = [];
this.audio = [];
}
destroy() {
this.video = [];
this.audio = [];
}
}

34
packages/xgplayer-buffer/dist/presouce.js vendored
View File

@ -1,34 +0,0 @@
class Source {
constructor() {
this.mimetype = '';
this.init = null;
this.data = [];
}
}
class PreSource {
constructor() {
this.sources = {};
}
getSource(source) {
return this.sources[source];
}
createSource(name) {
this.sources[name] = new Source();
return this.sources[name];
}
clear() {
this.sources = {};
}
destroy() {
this.sources = {};
}
}
export default PreSource;

11
packages/xgplayer-buffer/es/index.js
View File

@ -1,11 +0,0 @@
import _Track, { Tracks as _Tracks, AudioTrack as _AudioTrack, VideoTrack as _VideoTrack } from './track';
import { XgBuffer as _XgBuffer, RemuxBuffer as _RemuxBuffer } from './buffer';
import _PreSource from './presouce';
export var Track = _Track;
export var Tracks = _Tracks;
export var AudioTrack = _AudioTrack;
export var VideoTrack = _VideoTrack;
export var XgBuffer = _XgBuffer;
export var RemuxBuffer = _RemuxBuffer;
export var PreSource = _PreSource;

11
packages/xgplayer-buffer/src/index.js
View File

@ -1,11 +0,0 @@
import _Track, { Tracks as _Tracks, AudioTrack as _AudioTrack, VideoTrack as _VideoTrack } from './track';
import { XgBuffer as _XgBuffer, RemuxBuffer as _RemuxBuffer } from './buffer';
import _PreSource from './presouce';
export const Track = _Track;
export const Tracks = _Tracks;
export const AudioTrack = _AudioTrack;
export const VideoTrack = _VideoTrack;
export const XgBuffer = _XgBuffer;
export const RemuxBuffer = _RemuxBuffer;
export const PreSource = _PreSource;

43
packages/xgplayer-codec/dist/aac/aac-helper.js vendored
View File

@ -1,43 +0,0 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
class AAC {
static getSilentFrame(codec, channelCount) {
if (codec === 'mp4a.40.2') {
// handle LC-AAC
if (channelCount === 1) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x23, 0x80]);
} else if (channelCount === 2) {
return new Uint8Array([0x21, 0x00, 0x49, 0x90, 0x02, 0x19, 0x00, 0x23, 0x80]);
} else if (channelCount === 3) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x8e]);
} else if (channelCount === 4) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x80, 0x2c, 0x80, 0x08, 0x02, 0x38]);
} else if (channelCount === 5) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x38]);
} else if (channelCount === 6) {
return new Uint8Array([0x00, 0xc8, 0x00, 0x80, 0x20, 0x84, 0x01, 0x26, 0x40, 0x08, 0x64, 0x00, 0x82, 0x30, 0x04, 0x99, 0x00, 0x21, 0x90, 0x02, 0x00, 0xb2, 0x00, 0x20, 0x08, 0xe0]);
}
} else {
// handle HE-AAC (mp4a.40.5 / mp4a.40.29)
if (channelCount === 1) {
// ffmpeg -y -f lavfi -i "aevalsrc=0:d=0.05" -c:a libfdk_aac -profile:a aac_he -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x4e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x1c, 0x6, 0xf1, 0xc1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 2) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
} else if (channelCount === 3) {
// ffmpeg -y -f lavfi -i "aevalsrc=0|0|0:d=0.05" -c:a libfdk_aac -profile:a aac_he_v2 -b:a 4k output.aac && hexdump -v -e '16/1 "0x%x," "\n"' -v output.aac
return new Uint8Array([0x1, 0x40, 0x22, 0x80, 0xa3, 0x5e, 0xe6, 0x80, 0xba, 0x8, 0x0, 0x0, 0x0, 0x0, 0x95, 0x0, 0x6, 0xf1, 0xa1, 0xa, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5e]);
}
}
return null;
}
}
exports.default = AAC;

480
packages/xgplayer-codec/dist/compatibility.js vendored
View File

@ -1,480 +0,0 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _xgplayerUtils = require('xgplayer-utils');
var _aacHelper = require('./aac/aac-helper');
var _aacHelper2 = _interopRequireDefault(_aacHelper);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const { REMUX_EVENTS } = _xgplayerUtils.EVENTS;
class Compatibility {
constructor() {
this.nextAudioDts = 0; // 模拟下一段音频数据的dts
this.nextVideoDts = 0; // 模拟下一段视频数据的dts
this.lastAudioSamplesLen = 0; // 上一段音频数据的长度
this.lastVideoSamplesLen = 0; // 上一段视频数据的长度
this.lastVideoDts = undefined; // 上一段音频数据的长度
this.lastAudioDts = undefined; // 上一段视频数据的长度
this.allAudioSamplesCount = 0; // 音频总数据量(原始帧)
this.allVideoSamplesCount = 0; // 视频总数据量(原始帧)
this._firstAudioSample = null;
this._firstVideoSample = null;
this.filledAudioSamples = []; // 补充音频帧（）
this.filledVideoSamples = []; // 补充视频帧（）
this.videoFixedTimes = 0; // 视频时间戳修改次数
this.audioFixedTimes = 0; // 音频时间戳修改次数
this.videoGapAvg = 0; // 视频帧序列间gap平均值
this.audioGapAvg = 0; // 音频帧序列间gap平均值
}
init() {
this.before(REMUX_EVENTS.REMUX_MEDIA, this.doFix.bind(this));
}
reset() {
this.nextAudioDts = 0; // 模拟下一段音频数据的dts
this.nextVideoDts = 0; // 模拟下一段视频数据的dts
this.lastAudioSamplesLen = 0; // 上一段音频数据的长度
this.lastVideoSamplesLen = 0; // 上一段视频数据的长度
this.lastVideoDts = undefined; // 上一段音频数据的长度
this.lastAudioDts = undefined; // 上一段视频数据的长度
this.allAudioSamplesCount = 0; // 音频总数据量(原始帧)
this.allVideoSamplesCount = 0; // 视频总数据量(原始帧)
this._firstAudioSample = null;
this._firstVideoSample = null;
this.filledAudioSamples = []; // 补充音频帧（）
this.filledVideoSamples = []; // 补充视频帧（）
}
doFix() {
const { isFirstAudioSamples, isFirstVideoSamples } = this.getFirstSample();
this.removeInvalidSamples();
this.recordSamplesCount();
if (this._firstVideoSample) {
this.fixRefSampleDuration(this.videoTrack.meta, this.videoTrack.samples);
}
if (this._firstAudioSample) {
this.fixRefSampleDuration(this.audioTrack.meta, this.audioTrack.samples);
}
this.doFixVideo(isFirstVideoSamples);
this.doFixAudio(isFirstAudioSamples);
}
doFixVideo(first) {
let { samples: videoSamples, meta } = this.videoTrack;
if (meta.frameRate && meta.frameRate.fixed === false) {
return;
}
if (!videoSamples || !videoSamples.length || !this._firstVideoSample) {
return;
}
// console.log(`video lastSample, ${videoSamples[videoSamples.length - 1].dts}`)
const firstSample = videoSamples[0];
const firstDts = firstSample.dts;
const samplesLen = videoSamples.length;
// step1. 修复与audio首帧差距太大的问题
if (first && this._firstAudioSample) {
const videoFirstDts = this._firstVideoSample.dts;
const audioFirstDts = this._firstAudioSample.dts;
const gap = videoFirstDts - audioFirstDts;
if (gap > 2 * meta.refSampleDuration) {
const fillCount = Math.floor(gap / meta.refSampleDuration);
for (let i = 0; i < fillCount; i++) {
const clonedFirstSample = Object.assign({}, firstSample); // 视频头部帧缺失需要复制第一帧
// 重新计算sample的dts和pts
clonedFirstSample.dts = videoFirstDts - (i + 1) * meta.refSampleDuration;
clonedFirstSample.pts = clonedFirstSample.dts + clonedFirstSample.cts;
videoSamples.unshift(clonedFirstSample);
this.filledVideoSamples.push({
dts: clonedFirstSample.dts,
size: clonedFirstSample.data.byteLength
});
}
}
}
let gap;
// step2. 修复samples段之间的间距问题、
if (this.nextVideoDts) {
// step1. 处理samples段之间的丢帧情况
// 当发现duration差距大于2帧时进行补帧
gap = firstDts - this.nextVideoDts;
const absGap = Math.abs(gap);
if (gap >= 2 * meta.refSampleDuration) {
const fillFrameCount = Math.floor(gap / meta.refSampleDuration);
for (let i = 0; i < fillFrameCount; i++) {
const clonedSample = Object.assign({}, videoSamples[0]);
const computed = firstDts - (i + 1) * meta.refSampleDuration;
clonedSample.dts = computed > this.nextVideoDts ? computed : this.nextVideoDts; // 补的第一帧一定要是nextVideoDts
clonedSample.pts = clonedSample.dts + clonedSample.cts;
this.videoTrack.samples.unshift(clonedSample);
this.filledVideoSamples.push({
dts: clonedSample.dts,
size: clonedSample.data.byteLength
});
}
} else if (absGap <= meta.refSampleDuration && absGap > 0) {
// 当差距在+-一帧之间时将第一帧的dts强行定位到期望位置
this.recordGapFixTime('video', gap);
console.log('重定位视频帧dts', videoSamples[0].dts, this.nextVideoDts, `pts: ${this.nextVideoDts + videoSamples[0].cts}`);
videoSamples[0].dts = this.nextVideoDts;
videoSamples[0].originDts = videoSamples[0].dts;
videoSamples[0].cts = videoSamples[0].cts || videoSamples[0].pts - videoSamples[0].dts;
videoSamples[0].pts = videoSamples[0].dts + videoSamples[0].cts;
}
}
const lastDts = videoSamples[videoSamples.length - 1].dts;
const lastSampleDuration = videoSamples.length >= 2 ? lastDts - videoSamples[videoSamples.length - 2].dts : meta.refSampleDurationFixed || meta.refSampleDuration;
this.lastVideoSamplesLen = samplesLen;
this.nextVideoDts = lastDts + lastSampleDuration;
this.lastVideoDts = lastDts;
// step2. 修复sample段之内的间距问题
// step3. 修复samples段内部的dts异常问题
for (let i = 0, len = videoSamples.length; i < len; i++) {
const current = videoSamples[i];
const next = videoSamples[i + 1];
if (!next) {
break;
}
const duration = next.dts - current.dts;
if (duration > 2 * meta.refSampleDuration) {
// 两帧之间间隔太大，需要补空白帧
let fillFrameCount = Math.floor(duration / meta.refSampleDuration);
let fillFrameIdx = 0;
while (fillFrameIdx < fillFrameCount) {
const fillFrame = Object.assign({}, next);
fillFrame.dts = current.dts + (fillFrameIdx + 1) * meta.refSampleDuration;
fillFrame.pts = fillFrame.dts + fillFrame.cts;
if (fillFrame < next.dts) {
videoSamples.splice(i, 0, fillFrame);
this.filledVideoSamples.push({
dts: fillFrame.dts,
size: fillFrame.data.byteLength
});
}
fillFrameIdx++;
i++;
}
}
}
this.videoTrack.samples.forEach(sample => {
console.log(sample.dts);
});
this.videoTrack.samples = videoSamples;
}
doFixAudio(first) {
let { samples: audioSamples, meta } = this.audioTrack;
if (!audioSamples || !audioSamples.length) {
return;
}
// console.log(`audio lastSample, ${audioSamples[audioSamples.length - 1].dts}`)
const samplesLen = audioSamples.length;
const silentFrame = _aacHelper2.default.getSilentFrame(meta.codec, meta.channelCount);
const firstSample = this._firstAudioSample;
// 对audioSamples按照dts做排序
// audioSamples = Compatibility.sortAudioSamples(audioSamples)
// step0. 首帧与video首帧间距大的问题
if (this._firstVideoSample && first) {
const videoFirstPts = this._firstVideoSample.pts ? this._firstVideoSample.pts : this._firstVideoSample.dts + this._firstVideoSample.cts;
if (firstSample.dts - videoFirstPts > meta.refSampleDuration) {
const silentSampleCount = Math.floor((firstSample.dts - videoFirstPts) / meta.refSampleDuration);
for (let i = 0; i < silentSampleCount; i++) {
const silentSample = {
data: silentFrame,
datasize: silentFrame.byteLength,
dts: firstSample.dts - (i + 1) * meta.refSampleDuration,
filtered: 0
};
audioSamples.unshift(silentSample);
this.filledAudioSamples.push({
dts: silentSample.dts,
size: silentSample.data.byteLength
});
}
}
}
let gap;
const firstDts = audioSamples[0].dts;
if (this.nextAudioDts) {
// step1. 处理samples段之间的丢帧情况
// 当发现duration差距大于1帧时进行补帧
gap = firstDts - this.nextAudioDts;
const absGap = Math.abs(gap);
if (gap > 2 * meta.refSampleDuration) {
const silentFrameCount = Math.floor(gap / meta.refSampleDuration);
for (let i = 0; i < silentFrameCount; i++) {
const computed = firstDts - (i + 1) * meta.refSampleDuration;
const silentSample = Object.assign({}, audioSamples[0], {
dts: computed > this.nextAudioDts ? computed : this.nextAudioDts
});
this.filledAudioSamples.push({
dts: silentSample.dts,
size: silentSample.data.byteLength
});
this.audioTrack.samples.unshift(silentSample);
}
} else if (absGap <= meta.refSampleDuration && absGap > 0) {
// 当差距比较小的时候将音频帧重定位
// console.log('重定位音频帧dts', audioSamples[0].dts, this.nextAudioDts)
this.recordGapFixTime('video', gap);
audioSamples[0].dts = this.nextAudioDts;
audioSamples[0].pts = this.nextAudioDts;
}
}
const lastDts = audioSamples[audioSamples.length - 1].dts;
const lastSampleDuration = audioSamples.length >= 2 ? lastDts - audioSamples[audioSamples.length - 2].dts : meta.refSampleDuration;
this.lastAudioSamplesLen = samplesLen;
this.nextAudioDts = meta.refSampleDurationFixed ? lastDts + meta.refSampleDurationFixed : lastDts + lastSampleDuration;
this.lastAudioDts = lastDts;
// step3. 修复samples段内部的dts异常问题
for (let i = 0, len = audioSamples.length; i < len; i++) {
const current = audioSamples[i];
const next = audioSamples[i + 1];
if (!next) {
break;
}
const duration = next.dts - current.dts;
audioSamples[i].duration = duration;
/*
if (duration > (2 * meta.refSampleDuration)) {
// 两帧之间间隔太大，需要补空白帧
/**
let silentFrameCount = Math.floor(duration / meta.refSampleDuration)
let frameIdx = 0
while (frameIdx < silentFrameCount) {
const silentSample = {
data: silentFrame,
datasize: silentFrame.byteLength,
dts: current.dts + (frameIdx + 1) * meta.refSampleDuration,
filtered: 0,
isSilent: true
}
audioSamples.splice(i, 0, silentSample)
this.filledAudioSamples.push({
dts: silentSample.dts,
size: silentSample.data.byteLength
})
frameIdx++
i++ // 不对静音帧做比较
}
} */
}
this.audioTrack.samples = Compatibility.sortAudioSamples(audioSamples);
}
getFirstSample() {
// 获取video和audio的首帧数据
let { samples: videoSamples } = this.videoTrack;
let { samples: audioSamples } = this.audioTrack;
let isFirstVideoSamples = false;
let isFirstAudioSamples = false;
if (!this._firstVideoSample && videoSamples.length) {
this._firstVideoSample = Compatibility.findFirstVideoSample(videoSamples);
isFirstVideoSamples = true;
}
if (!this._firstAudioSample && audioSamples.length) {
this._firstAudioSample = Compatibility.findFirstAudioSample(audioSamples); // 寻找dts最小的帧作为首个音频帧
isFirstAudioSamples = true;
}
return {
isFirstVideoSamples,
isFirstAudioSamples
};
}
/**
* 在没有refSampleDuration的问题流中，
*/
fixRefSampleDuration(meta, samples) {
const isVideo = meta.type === 'video';
const allSamplesCount = isVideo ? this.allVideoSamplesCount : this.allAudioSamplesCount;
const firstDts = isVideo ? this._firstVideoSample.dts : this._firstAudioSample.dts;
const filledSamplesCount = isVideo ? this.filledVideoSamples.length : this.filledAudioSamples.length;
const fixedTimes = isVideo ? this.videoFixedTimes : this.filledAudioSamples.length;
const gapAvg = isVideo ? this.videoGapAvg : this.audioGapAvg;
if (!meta.refSampleDuration || meta.refSampleDuration <= 0 || Number.isNaN(meta.refSampleDuration)) {
if (samples.length >= 1) {
const lastDts = samples[samples.length - 1].dts;
meta.refSampleDuration = Math.floor((lastDts - firstDts) / (allSamplesCount + filledSamplesCount - 1)); // 将refSampleDuration重置为计算后的平均值
}
} else if (meta.refSampleDuration) {
if (samples.length >= 3) {
const lastDts = samples[samples.length - 1].dts;
const firstDts = samples[0].dts;
const durationAvg = (lastDts - firstDts) / (samples.length - 1);
meta.refSampleDuration = Math.abs(meta.refSampleDuration - durationAvg) <= meta.refSampleDuration ? meta.refSampleDuration : durationAvg; // 将refSampleDuration重置为计算后的平均值
}
}
if (fixedTimes >= 10 && gapAvg > 10 && !meta.refSampleDurationFixed) {
meta.refSampleDurationFixed = meta.refSampleDuration - gapAvg;
}
}
recordGapFixTime(type, gap) {
if (type === 'video') {
this.videoGapAvg = this.videoFixedTimes === 0 ? gap : Math.floor(this.videoGapAvg * this.videoFixedTimes / this.videoFixedTimes + 1) + Math.floor(gap / this.videoFixedTimes + 1);
this.videoFixedTimes += 1; // 记录修改的权重
} else {
this.audioGapAvg = this.audioFixedTimes === 0 ? gap : Math.floor(this.audioGapAvg * this.audioFixedTimes / this.audioFixedTimes + 1) + Math.floor(gap / this.audioFixedTimes + 1);
this.audioFixedTimes += 1; // 记录修改的权重
}
}
/**
* 记录截止目前一共播放了多少帧
*/
recordSamplesCount() {
const { audioTrack, videoTrack } = this;
this.allAudioSamplesCount += audioTrack.samples.length;
this.allVideoSamplesCount += videoTrack.samples.length;
}
/**
* 去除不合法的帧（倒退、重复帧）
*/
removeInvalidSamples() {
const { _firstVideoSample, _firstAudioSample } = this;
this.audioTrack.samples = this.audioTrack.samples.filter(sample => {
return sample.dts >= _firstAudioSample.dts && (this.lastAudioDts === undefined || sample.dts > this.lastAudioDts);
});
this.videoTrack.samples = this.videoTrack.samples.filter(sample => {
return sample.dts >= _firstVideoSample.dts && (this.lastVideoDts === undefined || sample.dts > this.lastVideoDts);
});
}
static sortAudioSamples(samples) {
if (samples.length === 1) {
return samples;
}
return samples.sort((a, b) => {
return a.dts - b.dts;
});
}
/**
* 寻找dts最小的sample
* @param samples
*/
static findFirstAudioSample(samples) {
if (!samples || samples.length === 0) {
return null;
}
return Compatibility.sortAudioSamples(samples)[0];
}
static findFirstVideoSample(samples) {
if (!samples.length) {
return null;
}
const sorted = samples.sort((a, b) => {
return a.dts - b.dts;
});
for (let i = 0, len = sorted.length; i < len; i++) {
if (sorted[i].isKeyframe) {
return sorted[i];
}
}
}
get tracks() {
return this._context.getInstance('TRACKS');
}
get audioTrack() {
if (this.tracks) {
return this.tracks.audioTrack;
}
return null;
}
get videoTrack() {
if (this.tracks) {
return this.tracks.videoTrack;
}
return null;
}
}
exports.default = Compatibility;

102
packages/xgplayer-codec/dist/h264/nalunit/golomb.js vendored
View File

@ -1,102 +0,0 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
class Golomb {
constructor(uint8array) {
this.TAG = 'Golomb';
this._buffer = uint8array;
this._bufferIndex = 0;
this._totalBytes = uint8array.byteLength;
this._totalBits = uint8array.byteLength * 8;
this._currentWord = 0;
this._currentWordBitsLeft = 0;
}
destroy() {
this._buffer = null;
}
_fillCurrentWord() {
let bufferBytesLeft = this._totalBytes - this._bufferIndex;
if (bufferBytesLeft <= 0) {
// TODO 异常处理
}
let bytesRead = Math.min(4, bufferBytesLeft);
let word = new Uint8Array(4);
word.set(this._buffer.subarray(this._bufferIndex, this._bufferIndex + bytesRead));
this._currentWord = new DataView(word.buffer).getUint32(0, false);
this._bufferIndex += bytesRead;
this._currentWordBitsLeft = bytesRead * 8;
}
readBits(bits) {
if (bits > 32) {
// TODO
}
if (bits <= this._currentWordBitsLeft) {
let result = this._currentWord >>> 32 - bits;
this._currentWord <<= bits;
this._currentWordBitsLeft -= bits;
return result;
}
let result = this._currentWordBitsLeft ? this._currentWord : 0;
// eslint-disable-next-line
result >>> 32 - this._currentWordBitsLeft;
let bitsNeedLeft = bits - this._currentWordBitsLeft;
this._fillCurrentWord();
let bitsReadNext = Math.min(bitsNeedLeft, this._currentWordBitsLeft);
let result2 = this._currentWord >>> 32 - bitsReadNext;
this._currentWord <<= bitsReadNext;
this._currentWordBitsLeft -= bitsReadNext;
result = result << bitsReadNext | result2;
return result;
}
readBool() {
return this.readBits(1) === 1;
}
readByte() {
return this.readBits(8);
}
_skipLeadingZero() {
let zeroCount;
for (zeroCount = 0; zeroCount < this._currentWordBitsLeft; zeroCount++) {
if ((this._currentWord & 0x80000000 >>> zeroCount) !== 0) {
this._currentWord <<= zeroCount;
this._currentWordBitsLeft -= zeroCount;
return zeroCount;
}
}
this._fillCurrentWord();
return zeroCount + this._skipLeadingZero();
}
readUEG() {
// unsigned exponential golomb
let leadingZeros = this._skipLeadingZero();
return this.readBits(leadingZeros + 1) - 1;
}
readSEG() {
// signed exponential golomb
let value = this.readUEG();
if (value & 0x01) {
return value + 1 >>> 1;
} else {
return -1 * (value >>> 1);
}
}
}
exports.default = Golomb;

163
packages/xgplayer-codec/dist/h264/nalunit/index.js vendored
View File

@ -1,163 +0,0 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _sps = require('./sps');
var _sps2 = _interopRequireDefault(_sps);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
class Nalunit {
static getNalunits(buffer) {
if (buffer.length - buffer.position < 4) {
return [];
}
let buf = buffer.dataview;
let position = buffer.position;
if (buf.getInt32(position) === 1 || buf.getInt16(position) === 0 && buf.getInt8(position + 2) === 1) {
return Nalunit.getAnnexbNals(buffer);
} else {
return Nalunit.getAvccNals(buffer);
}
}
static getAnnexbNals(buffer) {
let nals = [];
let position = Nalunit.getHeaderPositionAnnexB(buffer);
let start = position.pos;
let end = start;
while (start < buffer.length - 4) {
let header = buffer.buffer.slice(start, start + position.headerLength);
if (position.pos === buffer.position) {
buffer.skip(position.headerLength);
}
position = Nalunit.getHeaderPositionAnnexB(buffer);
end = position.pos;
let body = new Uint8Array(buffer.buffer.slice(start + header.byteLength, end));
let unit = { header, body };
Nalunit.analyseNal(unit);
nals.push(unit);
buffer.skip(end - buffer.position);
start = end;
}
return nals;
}
static getAvccNals(buffer) {
let nals = [];
while (buffer.position < buffer.length - 4) {
let length = buffer.dataview.getInt32();
if (buffer.length - buffer.position >= length) {
let header = buffer.buffer.slice(buffer.position, buffer.position + 4);
buffer.skip(4);
let body = buffer.buffer.slice(buffer.position, buffer.position + length);
buffer.skip(length);
let unit = { header, body };
Nalunit.analyseNal(unit);
nals.push(unit);
} else {
break;
}
}
return nals;
}
static analyseNal(unit) {
let type = unit.body[0] & 0x1f;
switch (type) {
case 1:
// NDR
unit.ndr = true;
break;
case 5:
// IDR
unit.idr = true;
break;
case 6:
// SEI
break;
case 7:
// SPS
unit.sps = _sps2.default.parseSPS(unit.body);
break;
case 8:
// PPS
unit.pps = true;
break;
case 9:
// AUD
break;
default:
break;
}
}
static getHeaderPositionAnnexB(buffer) {
// seperate
let pos = buffer.position;
let headerLength = 0;
while (headerLength !== 3 && headerLength !== 4 && pos < buffer.length - 4) {
if (buffer.dataview.getInt16(pos) === 0) {
if (buffer.dataview.getInt16(pos + 2) === 1) {
// 0x000001
headerLength = 4;
} else if (buffer.dataview.getInt8(pos + 2) === 1) {
headerLength = 3;
} else {
pos++;
}
} else {
pos++;
}
}
if (pos === buffer.length - 4) {
if (buffer.dataview.getInt16(pos) === 0) {
if (buffer.dataview.getInt16(pos + 2) === 1) {
// 0x000001
headerLength = 4;
}
} else {
pos++;
if (buffer.dataview.getInt16(pos) === 0 && buffer.dataview.getInt8(pos) === 1) {
// 0x0000001
headerLength = 3;
} else {
pos = buffer.length;
}
}
}
return { pos, headerLength };
}
static getAvcc(sps, pps) {
let ret = new Uint8Array(sps.byteLength + pps.byteLength + 11);
ret[0] = 0x01;
ret[1] = sps[1];
ret[2] = sps[2];
ret[3] = sps[3];
ret[4] = 255;
ret[5] = 225;
let offset = 6;
ret.set(new Uint8Array([sps.byteLength >>> 8 & 0xff, sps.byteLength & 0xff]), offset);
offset += 2;
ret.set(sps, offset);
offset += sps.byteLength;
ret[offset] = 1;
offset++;
ret.set(new Uint8Array([pps.byteLength >>> 8 & 0xff, pps.byteLength & 0xff]), offset);
offset += 2;
ret.set(pps, offset);
return ret;
}
}
exports.default = Nalunit;

298
packages/xgplayer-codec/dist/h264/nalunit/sps.js vendored
View File

@ -1,298 +0,0 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _golomb = require('./golomb');
var _golomb2 = _interopRequireDefault(_golomb);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
class SPSParser {
static _ebsp2rbsp(uint8array) {
let src = uint8array;
let srcLength = src.byteLength;
let dst = new Uint8Array(srcLength);
let dstIdx = 0;
for (let i = 0; i < srcLength; i++) {
if (i >= 2) {
if (src[i] === 0x03 && src[i - 1] === 0x00 && src[i - 2] === 0x00) {
continue;
}
}
dst[dstIdx] = src[i];
dstIdx++;
}
return new Uint8Array(dst.buffer, 0, dstIdx);
}
static parseSPS(uint8array) {
let rbsp = SPSParser._ebsp2rbsp(uint8array);
let gb = new _golomb2.default(rbsp);
gb.readByte();
let profileIdc = gb.readByte();
gb.readByte();
let levelIdc = gb.readByte();
gb.readUEG();
let profile_string = SPSParser.getProfileString(profileIdc);
let level_string = SPSParser.getLevelString(levelIdc);
let chroma_format_idc = 1;
let chroma_format = 420;
let chroma_format_table = [0, 420, 422, 444];
let bit_depth = 8;
if (profileIdc === 100 || profileIdc === 110 || profileIdc === 122 || profileIdc === 244 || profileIdc === 44 || profileIdc === 83 || profileIdc === 86 || profileIdc === 118 || profileIdc === 128 || profileIdc === 138 || profileIdc === 144) {
chroma_format_idc = gb.readUEG();
if (chroma_format_idc === 3) {
gb.readBits(1);
}
if (chroma_format_idc <= 3) {
chroma_format = chroma_format_table[chroma_format_idc];
}
bit_depth = gb.readUEG() + 8;
gb.readUEG();
gb.readBits(1);
if (gb.readBool()) {
let scaling_list_count = chroma_format_idc !== 3 ? 8 : 12;
for (let i = 0; i < scaling_list_count; i++) {
if (gb.readBool()) {
if (i < 6) {
SPSParser._skipScalingList(gb, 16);
} else {
SPSParser._skipScalingList(gb, 64);
}
}
}
}
}
gb.readUEG();
let pic_order_cnt_type = gb.readUEG();
if (pic_order_cnt_type === 0) {
gb.readUEG();
} else if (pic_order_cnt_type === 1) {
gb.readBits(1);
gb.readSEG();
gb.readSEG();
let num_ref_frames_in_pic_order_cnt_cycle = gb.readUEG();
for (let i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
gb.readSEG();
}
}
gb.readUEG();
gb.readBits(1);
let pic_width_in_mbs_minus1 = gb.readUEG();
let pic_height_in_map_units_minus1 = gb.readUEG();
let frame_mbs_only_flag = gb.readBits(1);
if (frame_mbs_only_flag === 0) {
gb.readBits(1);
}
gb.readBits(1);
let frame_crop_left_offset = 0;
let frame_crop_right_offset = 0;
let frame_crop_top_offset = 0;
let frame_crop_bottom_offset = 0;
let frame_cropping_flag = gb.readBool();
if (frame_cropping_flag) {
frame_crop_left_offset = gb.readUEG();
frame_crop_right_offset = gb.readUEG();
frame_crop_top_offset = gb.readUEG();
frame_crop_bottom_offset = gb.readUEG();
}
let par_width = 1,
par_height = 1;
let fps = 0,
fps_fixed = true,
fps_num = 0,
fps_den = 0;
let vui_parameters_present_flag = gb.readBool();
if (vui_parameters_present_flag) {
if (gb.readBool()) {
// aspect_ratio_info_present_flag
let aspect_ratio_idc = gb.readByte();
let par_w_table = [1, 12, 10, 16, 40, 24, 20, 32, 80, 18, 15, 64, 160, 4, 3, 2];
let par_h_table = [1, 11, 11, 11, 33, 11, 11, 11, 33, 11, 11, 33, 99, 3, 2, 1];
if (aspect_ratio_idc > 0 && aspect_ratio_idc < 16) {
par_width = par_w_table[aspect_ratio_idc - 1];
par_height = par_h_table[aspect_ratio_idc - 1];
} else if (aspect_ratio_idc === 255) {
par_width = gb.readByte() << 8 | gb.readByte();
par_height = gb.readByte() << 8 | gb.readByte();
}
}
if (gb.readBool()) {
gb.readBool();
}
if (gb.readBool()) {
gb.readBits(4);
if (gb.readBool()) {
gb.readBits(24);
}
}
if (gb.readBool()) {
gb.readUEG();
gb.readUEG();
}
if (gb.readBool()) {
let num_units_in_tick = gb.readBits(32);
let time_scale = gb.readBits(32);
fps_fixed = gb.readBool();
fps_num = time_scale;
fps_den = num_units_in_tick * 2;
fps = fps_num / fps_den;
}
}
let parScale = 1;
if (par_width !== 1 || par_height !== 1) {
parScale = par_width / par_height;
}
let crop_unit_x = 0,
crop_unit_y = 0;
if (chroma_format_idc === 0) {
crop_unit_x = 1;
crop_unit_y = 2 - frame_mbs_only_flag;
} else {
let sub_wc = chroma_format_idc === 3 ? 1 : 2;
let sub_hc = chroma_format_idc === 1 ? 2 : 1;
crop_unit_x = sub_wc;
crop_unit_y = sub_hc * (2 - frame_mbs_only_flag);
}
let codec_width = (pic_width_in_mbs_minus1 + 1) * 16;
let codec_height = (2 - frame_mbs_only_flag) * ((pic_height_in_map_units_minus1 + 1) * 16);
codec_width -= (frame_crop_left_offset + frame_crop_right_offset) * crop_unit_x;
codec_height -= (frame_crop_top_offset + frame_crop_bottom_offset) * crop_unit_y;
let present_width = Math.ceil(codec_width * parScale);
gb.destroy();
gb = null;
return {
profile_string: profile_string,
level_string: level_string,
bit_depth: bit_depth,
chroma_format: chroma_format,
chroma_format_string: SPSParser.getChromaFormatString(chroma_format),
frame_rate: {
fixed: fps_fixed,
fps: fps,
fps_den: fps_den,
fps_num: fps_num
},
par_ratio: {
width: par_width,
height: par_height
},
codec_size: {
width: codec_width,
height: codec_height
},
present_size: {
width: present_width,
height: codec_height
}
};
}
static _skipScalingList(gb, count) {
let last_scale = 8,
next_scale = 8;
let delta_scale = 0;
for (let i = 0; i < count; i++) {
if (next_scale !== 0) {
delta_scale = gb.readSEG();
next_scale = (last_scale + delta_scale + 256) % 256;
}
last_scale = next_scale === 0 ? last_scale : next_scale;
}
}
static getProfileString(profileIdc) {
switch (profileIdc) {
case 66:
return 'Baseline';
case 77:
return 'Main';
case 88:
return 'Extended';
case 100:
return 'High';
case 110:
return 'High10';
case 122:
return 'High422';
case 244:
return 'High444';
default:
return 'Unknown';
}
}
static getLevelString(levelIdc) {
return (levelIdc / 10).toFixed(1);
}
static getChromaFormatString(chroma) {
switch (chroma) {
case 420:
return '4:2:0';
case 422:
return '4:2:2';
case 444:
return '4:4:4';
default:
return 'Unknown';
}
}
static toVideoMeta(spsConfig) {
let meta = {};
if (spsConfig && spsConfig.codec_size) {
meta.codecWidth = spsConfig.codec_size.width;
meta.codecHeight = spsConfig.codec_size.height;
meta.presentWidth = spsConfig.present_size.width;
meta.presentHeight = spsConfig.present_size.height;
}
meta.profile = spsConfig.profile_string;
meta.level = spsConfig.level_string;
meta.bitDepth = spsConfig.bit_depth;
meta.chromaFormat = spsConfig.chroma_format;
meta.parRatio = {
width: spsConfig.par_ratio.width,
height: spsConfig.par_ratio.height
};
meta.frameRate = spsConfig.frame_rate;
let fpsDen = meta.frameRate.fps_den;
let fpsNum = meta.frameRate.fps_num;
meta.refSampleDuration = Math.floor(meta.timescale * (fpsDen / fpsNum));
}
} /* eslint-disable camelcase */
/* eslint-disable one-var */
exports.default = SPSParser;

7
packages/xgplayer-codec/es/index.js
View File

@ -1,7 +0,0 @@
import _Nalunit from './h264/nalunit';
import _SpsParser from './h264/nalunit/sps';
import _Compatibility from './compatibility';
export var Nalunit = _Nalunit;
export var SpsParser = _SpsParser;
export var Compatibility = _Compatibility;

7
packages/xgplayer-codec/src/index.js
View File

@ -1,7 +0,0 @@
import _Nalunit from './h264/nalunit';
import _SpsParser from './h264/nalunit/sps';
import _Compatibility from './compatibility';
export const Nalunit = _Nalunit
export const SpsParser = _SpsParser
export const Compatibility = _Compatibility

280
packages/xgplayer-demux/dist/flv/amf-parser.js vendored
View File

@ -1,280 +0,0 @@
import { isLe, UTF8 } from 'xgplayer-utils';
const DATA_TYPES = {
NUMBER: 0,
BOOLEAN: 1,
STRING: 2,
OBJECT: 3,
MIX_ARRAY: 8,
OBJECT_END: 9,
STRICT_ARRAY: 10,
DATE: 11,
LONE_STRING: 12
};
/**
* meta信息解析
*/
export default class AMFParser {
constructor() {
this.offset = 0;
this.readOffset = this.offset;
}
resolve(meta, size) {
if (size < 3) {
throw new Error('not enough data for metainfo');
}
const metaData = {};
const name = this.parseValue(meta);
const value = this.parseValue(meta, size - name.bodySize);
metaData[name.data] = value.data;
this.resetStatus();
return metaData;
}
resetStatus() {
this.offset = 0;
this.readOffset = this.offset;
}
parseString(buffer) {
const dv = new DataView(buffer, this.readOffset);
const strLen = dv.getUint16(0, !isLe);
let str = '';
if (strLen > 0) {
str = UTF8.decode(new Uint8Array(buffer, this.readOffset + 2, strLen));
} else {
str = '';
}
let size = strLen + 2;
this.readOffset += size;
return {
data: str,
bodySize: strLen + 2
};
}
parseDate(buffer, size) {
const dv = new DataView(buffer, this.readOffset, size);
let ts = dv.getFloat64(0, !isLe);
const timeOffset = dv.getInt16(8, !isLe);
ts += timeOffset * 60 * 1000;
this.readOffset += 10;
return {
data: new Date(ts),
bodySize: 10
};
}
parseObject(buffer, size) {
const name = this.parseString(buffer, size);
const value = this.parseValue(buffer, size - name.bodySize);
return {
data: {
name: name.data,
value: value.data
},
bodySize: name.bodySize + value.bodySize,
isObjEnd: value.isObjEnd
};
}
parseLongString(buffer) {
const dv = new DataView(buffer, this.readOffset);
const strLen = dv.getUint32(0, !isLe);
let str = '';
if (strLen > 0) {
str = UTF8.decode(new Uint8Array(buffer, this.readOffset + 2, strLen));
} else {
str = '';
} // const size = strLen + 4;
this.readOffset += strLen + 4;
return {
data: str,
bodySize: strLen + 4
};
}
/**
* 解析meta中的变量
*/
parseValue(data, size) {
let buffer = new ArrayBuffer();
if (data instanceof ArrayBuffer) {
buffer = data;
} else {
buffer = data.buffer;
}
const {
NUMBER,
BOOLEAN,
STRING,
OBJECT,
MIX_ARRAY,
OBJECT_END,
STRICT_ARRAY,
DATE,
LONE_STRING
} = DATA_TYPES;
const dataView = new DataView(buffer, this.readOffset, size);
let isObjEnd = false;
const type = dataView.getUint8(0);
let offset = 1;
this.readOffset += 1;
let value = null;
switch (type) {
case NUMBER:
{
value = dataView.getFloat64(1, !isLe);
this.readOffset += 8;
offset += 8;
break;
}
case BOOLEAN:
{
const boolNum = dataView.getUint8(1);
value = !!boolNum;
this.readOffset += 1;
offset += 1;
break;
}
case STRING:
{
const str = this.parseString(buffer);
value = str.data;
offset += str.bodySize;
break;
}
case OBJECT:
{
value = {};
let objEndSize = 0;
if (dataView.getUint32(size - 4, !isLe) & 0x00FFFFFF) {
objEndSize = 3;
} // this.readOffset += offset - 1;
while (offset < size - 4) {
const amfObj = this.parseObject(buffer, size - offset - objEndSize);
if (amfObj.isObjectEnd) {
break;
}
value[amfObj.data.name] = amfObj.data.value;
offset += amfObj.bodySize;
}
if (offset <= size - 3) {
const mark = dataView.getUint32(offset - 1, !isLe) & 0x00FFFFFF;
if (mark === 9) {
this.readOffset += 3;
offset += 3;
}
}
break;
}
case MIX_ARRAY:
{
value = {};
offset += 4;
this.readOffset += 4;
let objEndSize = 0;
if ((dataView.getUint32(size - 4, !isLe) & 0x00FFFFFF) === 9) {
objEndSize = 3;
}
while (offset < size - 8) {
const amfVar = this.parseObject(buffer, size - offset - objEndSize);
if (amfVar.isObjectEnd) {
break;
}
value[amfVar.data.name] = amfVar.data.value;
offset += amfVar.bodySize;
}
if (offset <= size - 3) {
const marker = dataView.getUint32(offset - 1, !isLe) & 0x00FFFFFF;
if (marker === 9) {
offset += 3;
this.readOffset += 3;
}
}
break;
}
case OBJECT_END:
{
value = null;
isObjEnd = true;
break;
}
case STRICT_ARRAY:
{
value = [];
const arrLength = dataView.getUint32(1, !isLe);
offset += 4;
this.readOffset += 4;
for (let i = 0; i < arrLength; i++) {
const script = this.parseValue(buffer, size - offset);
value.push(script.data);
offset += script.bodySize;
}
break;
}
case DATE:
{
const date = this.parseDate(buffer, size - 1);
value = date.data;
offset += date.bodySize;
break;
}
case LONE_STRING:
{
const longStr = this.parseLongString(buffer, size - 1);
value = longStr.data;
offset += longStr.bodySize;
break;
}
default:
{
offset = size;
}
}
return {
data: value,
bodySize: offset,
isObjEnd: isObjEnd
};
}
}

706
packages/xgplayer-demux/dist/flv/index.js vendored
View File

@ -1,706 +0,0 @@
import { EVENTS, AudioTrackMeta, VideoTrackMeta } from 'xgplayer-utils';
import { SpsParser } from 'xgplayer-codec';
import { VideoTrack, AudioTrack } from 'xgplayer-buffer';
import AMFParser from './amf-parser';
const DEMUX_EVENTS = EVENTS.DEMUX_EVENTS;
class FlvDemuxer {
constructor() {
this._firstFragmentLoaded = false;
this._trackNum = 0;
this._hasScript = false;
}
init() {
this.on(DEMUX_EVENTS.DEMUX_START, this.doParseFlv.bind(this));
}
/**
* if the flv head is valid
* @param data
* @returns {boolean}
*/
static isFlvFile(data) {
return !(data[0] !== 0x46 || data[1] !== 0x4C || data[2] !== 0x56 || data[3] !== 0x01);
}
/**
* If the stream has audio or video.
* @param {number} streamFlag - Data from the stream which is define whether the audio / video track is exist.
*/
static getPlayType(streamFlag) {
const result = {
hasVideo: false,
hasAudio: false
};
if (streamFlag & 0x01 > 0) {
result.hasVideo = true;
}
if (streamFlag & 0x04 > 0) {
result.hasAudio = true;
}
return result;
}
doParseFlv() {
if (!this._firstFragmentLoaded) {
if (this.loaderBuffer.length < 13) {
return;
}
const header = this.loaderBuffer.shift(13);
this.parseFlvHeader(header);
this.doParseFlv(); // 递归调用，继续解析flv流
} else {
if (this.loaderBuffer.length < 11) {
return;
}
let chunk;
let loopMax = 10000; // 防止死循环产生
do {
chunk = this._parseFlvTag();
} while (chunk && loopMax-- > 0);
this.emit(DEMUX_EVENTS.DEMUX_COMPLETE);
}
}
parseFlvHeader(header) {
if (!FlvDemuxer.isFlvFile(header)) {
this.emit(DEMUX_EVENTS.DEMUX_ERROR, new Error('invalid flv file'));
this.doParseFlv();
} else {
this._firstFragmentLoaded = true;
const playType = FlvDemuxer.getPlayType(header[4]);
if (playType.hasVideo) {
this.initVideoTrack();
}
if (playType.hasAudio) {
this.initAudioTrack();
}
}
this.doParseFlv();
}
/**
* init default video track configs
*/
initVideoTrack() {
this._trackNum++;
let videoTrack = new VideoTrack();
videoTrack.meta = new VideoTrackMeta();
videoTrack.id = videoTrack.meta.id = this._trackNum;
this.tracks.videoTrack = videoTrack;
}
/**
* init default audio track configs
*/
initAudioTrack() {
this._trackNum++;
let audioTrack = new AudioTrack();
audioTrack.meta = new AudioTrackMeta();
audioTrack.id = audioTrack.meta.id = this._trackNum;
this.tracks.audioTrack = audioTrack;
}
/**
* Package the data as the following data structure
* {
* data: Uint8Array. the Stream data.
* info: The first byte info of the Tag.
* tagType: 8、9、18
* timeStamp: the timestemp
* }
*/
_parseFlvTag() {
if (this.loaderBuffer.length < 11) {
return null;
}
let chunk = this._parseFlvTagHeader();
if (chunk) {
this._processChunk(chunk);
}
return chunk;
}
/**
* Parse the 11 byte tag Header
*/
_parseFlvTagHeader() {
let offset = 0;
let chunk = {};
let tagType = this.loaderBuffer.toInt(offset, 1);
offset += 1; // 2 bit FMS reserved, 1 bit filtered, 5 bit tag type
chunk.filtered = (tagType & 32) >>> 5;
chunk.tagType = tagType & 31; // 3 Byte datasize
chunk.datasize = this.loaderBuffer.toInt(offset, 3);
offset += 3;
if (chunk.tagType !== 8 && chunk.tagType !== 9 && chunk.tagType !== 11 && chunk.tagType !== 18 || this.loaderBuffer.toInt(8, 3) !== 0) {
if (this.loaderBuffer && this.loaderBuffer.length > 0) {
this.loaderBuffer.shift(1);
}
this.logger.warn(this.TAG, 'tagType ' + chunk.tagType);
return null;
}
if (this.loaderBuffer.length < chunk.datasize + 15) {
return null;
} // read the data.
this.loaderBuffer.shift(4); // 3 Byte timestamp
let timestamp = this.loaderBuffer.toInt(0, 3);
this.loaderBuffer.shift(3); // 1 Byte timestampExt
let timestampExt = this.loaderBuffer.shift(1)[0];
if (timestampExt > 0) {
timestamp += timestampExt * 0x1000000;
}
chunk.dts = timestamp; // streamId
this.loaderBuffer.shift(3);
return chunk;
}
_processChunk(chunk) {
switch (chunk.tagType) {
case 18:
this._parseScriptData(chunk);
break;
case 8:
this._parseAACData(chunk);
break;
case 9:
this._parseHevcData(chunk);
break;
case 11:
// for some CDN that did not process the currect RTMP messages
this.loaderBuffer.shift(3);
break;
default:
this.loaderBuffer.shift(1);
}
}
/**
* parse flv script data
* @param chunk
* @private
*/
_parseScriptData(chunk) {
let audioTrack = this.tracks.audioTrack;
let videoTrack = this.tracks.videoTrack;
let data = this.loaderBuffer.shift(chunk.datasize);
const info = new AMFParser().resolve(data, data.length);
const onMetaData = this._context.onMetaData = info ? info.onMetaData : undefined; // fill mediaInfo
this._context.mediaInfo.duration = onMetaData.duration;
this._context.mediaInfo.hasVideo = onMetaData.hasVideo;
this._context.mediaInfo.hsaAudio = onMetaData.hasAudio;
let validate = this._datasizeValidator(chunk.datasize);
if (validate) {
this.emit(DEMUX_EVENTS.MEDIA_INFO);
this._hasScript = true;
} // Edit default meta.
if (audioTrack && !audioTrack.hasSpecificConfig) {
let meta = audioTrack.meta;
if (onMetaData.audiosamplerate) {
meta.sampleRate = onMetaData.audiosamplerate;
}
if (onMetaData.audiochannels) {
meta.channelCount = onMetaData.audiochannels;
}
switch (onMetaData.audiosamplerate) {
case 44100:
meta.sampleRateIndex = 4;
break;
case 22050:
meta.sampleRateIndex = 7;
break;
case 11025:
meta.sampleRateIndex = 10;
break;
}
}
if (videoTrack && !videoTrack.hasSpecificConfig) {
let meta = videoTrack.meta;
if (typeof onMetaData.framerate === 'number') {
let fpsNum = Math.floor(onMetaData.framerate * 1000);
if (fpsNum > 0) {
let fps = fpsNum / 1000;
if (!meta.frameRate) {
meta.frameRate = {};
}
meta.frameRate.fixed = true;
meta.frameRate.fps = fps;
meta.frameRate.fps_num = fpsNum;
meta.frameRate.fps_den = 1000;
}
}
}
}
_aacSequenceHeaderParser(data) {
let ret = {};
ret.hasSpecificConfig = true;
ret.objectType = data[1] >>> 3;
ret.sampleRateIndex = (data[1] & 7) << 1 | data[2] >>> 7;
ret.audiosamplerate = this._switchAudioSampleRate(ret.sampleRateIndex);
ret.channelCount = (data[2] & 120) >>> 3;
ret.frameLength = (data[2] & 4) >>> 2;
ret.dependsOnCoreCoder = (data[2] & 2) >>> 1;
ret.extensionFlagIndex = data[2] & 1;
ret.codec = `mp4a.40.${ret.objectType}`;
let userAgent = window.navigator.userAgent.toLowerCase();
let extensionSamplingIndex;
let config;
let samplingIndex = ret.sampleRateIndex;
if (userAgent.indexOf('firefox') !== -1) {
// firefox: use SBR (HE-AAC) if freq less than 24kHz
if (ret.sampleRateIndex >= 6) {
ret.objectType = 5;
config = new Array(4);
extensionSamplingIndex = samplingIndex - 3;
} else {
// use LC-AAC
ret.objectType = 2;
config = new Array(2);
extensionSamplingIndex = samplingIndex;
}
} else if (userAgent.indexOf('android') !== -1) {
// android: always use LC-AAC
ret.objectType = 2;
config = new Array(2);
extensionSamplingIndex = samplingIndex;
} else {
// for other browsers, e.g. chrome...
// Always use HE-AAC to make it easier to switch aac codec profile
ret.objectType = 5;
extensionSamplingIndex = ret.sampleRateIndex;
config = new Array(4);
if (ret.sampleRateIndex >= 6) {
extensionSamplingIndex = ret.sampleRateIndex - 3;
} else if (ret.channelCount === 1) {
// Mono channel
ret.objectType = 2;
config = new Array(2);
extensionSamplingIndex = ret.sampleRateIndex;
}
}
config[0] = ret.objectType << 3;
config[0] |= (ret.sampleRateIndex & 0x0F) >>> 1;
config[1] = (ret.sampleRateIndex & 0x0F) << 7;
config[1] |= (ret.channelCount & 0x0F) << 3;
if (ret.objectType === 5) {
config[1] |= (extensionSamplingIndex & 0x0F) >>> 1;
config[2] = (extensionSamplingIndex & 0x01) << 7; // extended audio object type: force to 2 (LC-AAC)
config[2] |= 2 << 2;
config[3] = 0;
}
ret.config = config;
return ret;
}
_parseAACData(chunk) {
let track = this.tracks.audioTrack;
if (!track) {
return;
}
let meta = track.meta;
if (!meta) {
meta = new AudioTrackMeta();
}
let info = this.loaderBuffer.shift(1)[0];
chunk.data = this.loaderBuffer.shift(chunk.datasize - 1);
let format = (info & 240) >>> 4;
track.format = format;
if (format !== 10) {
this.emit(DEMUX_EVENTS.DEMUX_ERROR, new Error(`invalid audio format: ${format}`));
}
if (format === 10 && !this._hasAudioSequence) {
meta.sampleRate = this._switchAudioSamplingFrequency(info);
meta.sampleRateIndex = (info & 12) >>> 2;
meta.frameLenth = (info & 2) >>> 1;
meta.channelCount = info & 1;
meta.refSampleDuration = Math.floor(1024 / meta.audioSampleRate * meta.timescale);
}
let audioSampleRate = meta.audioSampleRate;
let audioSampleRateIndex = meta.sampleRateIndex;
let refSampleDuration = meta.refSampleDuration;
delete chunk.tagType;
let validate = this._datasizeValidator(chunk.datasize);
if (chunk.data[0] === 0) {
// AAC Sequence Header
let aacHeader = this._aacSequenceHeaderParser(chunk.data);
audioSampleRate = aacHeader.audiosamplerate || meta.audioSampleRate;
audioSampleRateIndex = aacHeader.sampleRateIndex || meta.sampleRateIndex;
refSampleDuration = Math.floor(1024 / audioSampleRate * meta.timescale);
meta.channelCount = aacHeader.channelCount;
meta.sampleRate = audioSampleRate;
meta.sampleRateIndex = audioSampleRateIndex;
meta.refSampleDuration = refSampleDuration;
meta.duration = this._context.mediaInfo.duration * meta.timescale;
meta.config = aacHeader.config;
const audioMedia = this._context.mediaInfo.audio; // fill audio media info
audioMedia.codec = aacHeader.codec;
audioMedia.channelCount = aacHeader.channelCount;
audioMedia.sampleRate = audioSampleRate;
audioMedia.sampleRateIndex = aacHeader.audioSampleRateIndex;
if (this._hasScript && !this._hasAudioSequence) {
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'audio');
} else if (this._hasScript && this._hasAudioSequence) {
this.emit(DEMUX_EVENTS.AUDIO_METADATA_CHANGE);
}
;
this._hasAudioSequence = true;
} else {
chunk.data = chunk.data.slice(1, chunk.data.length);
track.samples.push(chunk);
}
if (!validate) {
const error = new Error('TAG length error at ' + chunk.datasize);
this.emit(DEMUX_EVENTS.DEMUX_ERROR, error.message);
this.logger.warn(this.TAG, error.message);
}
}
/**
* parse hevc/avc video data
* @param chunk
* @private
*/
_parseHevcData(chunk) {
// header
let info = this.loaderBuffer.shift(1)[0];
chunk.frameType = (info & 0xf0) >>> 4;
chunk.isKeyframe = chunk.frameType === 1; // let tempCodecID = this.tracks.videoTrack.codecID
let codecID = info & 0x0f;
this.tracks.videoTrack.codecID = codecID; // hevc和avc的header解析方式一样
chunk.avcPacketType = this.loaderBuffer.shift(1)[0];
chunk.cts = this.loaderBuffer.toInt(0, 3);
this.loaderBuffer.shift(3); // 12 for hevc, 7 for avc
if (codecID === 12) {
const data = this.loaderBuffer.shift(chunk.datasize - 5);
chunk.data = data;
if (Number.parseInt(chunk.avcPacketType) !== 0) {
if (!this._datasizeValidator(chunk.datasize)) {
this.logger.warn(this.TAG, `invalid video tag datasize: ${chunk.datasize}`);
}
let nalu = {};
let r = 0;
nalu.cts = chunk.cts;
nalu.dts = chunk.dts;
while (chunk.data.length > r) {
let sizes = chunk.data.slice(Number.parseInt(r), 4 + r);
nalu.size = sizes[3];
nalu.size += sizes[2] * 256;
nalu.size += sizes[1] * 256 * 256;
nalu.size += sizes[0] * 256 * 256 * 256;
r += 4;
nalu.data = chunk.data.slice(Number.parseInt(r), nalu.size + r);
r += nalu.size;
this.tracks.videoTrack.samples.push(nalu);
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'video');
}
} else if (Number.parseInt(chunk.avcPacketType) === 0) {
if (!this._datasizeValidator(chunk.datasize)) {
this.logger.warn(this.TAG, `invalid video tag datasize: ${chunk.datasize}`);
} else {
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'video');
}
}
} else if (codecID === 7) {
let data = this.loaderBuffer.shift(chunk.datasize - 5);
if (data[4] === 0 && data[5] === 0 && data[6] === 0 && data[7] === 1) {
let avcclength = 0;
for (let i = 0; i < 4; i++) {
avcclength = avcclength * 256 + data[i];
}
avcclength -= 4;
data = data.slice(4, data.length);
data[3] = avcclength % 256;
avcclength = (avcclength - data[3]) / 256;
data[2] = avcclength % 256;
avcclength = (avcclength - data[2]) / 256;
data[1] = avcclength % 256;
data[0] = (avcclength - data[1]) / 256;
}
chunk.data = data; // If it is AVC sequece Header.
if (chunk.avcPacketType === 0) {
this._avcSequenceHeaderParser(chunk.data);
let validate = this._datasizeValidator(chunk.datasize);
if (validate) {
if (this._hasScript && !this._hasVideoSequence) {
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'video');
} else if (this._hasScript && this._hasVideoSequence) {
this.emit(DEMUX_EVENTS.VIDEO_METADATA_CHANGE);
}
this._hasVideoSequence = true;
}
} else {
if (!this._datasizeValidator(chunk.datasize)) {
this.logger.warn(this.TAG, `invalid video tag datasize: ${chunk.datasize}`);
return;
}
this.tracks.videoTrack.samples.push(chunk); // this.emit(DEMUX_EVENTS.DEMUX_COMPLETE)
}
} else {
this.logger.warn(this.TAG, `video codeid is ${codecID}`);
chunk.data = this.loaderBuffer.shift(chunk.datasize - 1);
if (!this._datasizeValidator(chunk.datasize)) {
this.logger.warn(this.TAG, `invalid video tag datasize: ${chunk.datasize}`);
}
this.tracks.videoTrack.samples.push(chunk);
this.emit(DEMUX_EVENTS.DEMUX_COMPLETE);
}
delete chunk.tagType;
}
/**
* parse avc metadata
* @param data
* @private
*/
_avcSequenceHeaderParser(data) {
let track = this.tracks.videoTrack;
if (!track) {
return;
}
let offset = 0;
if (!track.meta) {
track.meta = new VideoTrackMeta();
}
let meta = track.meta;
meta.configurationVersion = data[0];
meta.avcProfileIndication = data[1];
meta.profileCompatibility = data[2];
meta.avcLevelIndication = data[3] / 10;
meta.nalUnitLength = (data[4] & 0x03) + 1;
let numOfSps = data[5] & 0x1f;
offset = 6;
let config = {}; // parse SPS
for (let i = 0; i < numOfSps; i++) {
let size = data[offset] * 255 + data[offset + 1];
offset += 2;
let sps = new Uint8Array(size);
for (let j = 0; j < size; j++) {
sps[j] = data[offset + j];
} // codec string
let codecString = 'avc1.';
for (let j = 1; j < 4; j++) {
let h = sps[j].toString(16);
if (h.length < 2) {
h = '0' + h;
}
codecString += h;
}
meta.codec = codecString;
offset += size;
this.tracks.videoTrack.meta.sps = sps;
config = SpsParser.parseSPS(sps);
}
let numOfPps = data[offset];
offset++;
for (let i = 0; i < numOfPps; i++) {
let size = data[offset] * 255 + data[offset + 1];
offset += 2;
let pps = new Uint8Array(size);
for (let j = 0; j < size; j++) {
pps[j] = data[offset + j];
}
offset += size;
this.tracks.videoTrack.meta.pps = pps;
}
Object.assign(meta, SpsParser.toVideoMeta(config)); // fill video media info
const videoMedia = this._context.mediaInfo.video;
videoMedia.codec = meta.codec;
videoMedia.profile = meta.profile;
videoMedia.level = meta.level;
videoMedia.chromaFormat = meta.chromaFormat;
videoMedia.frameRate = meta.frameRate;
videoMedia.parRatio = meta.parRatio;
videoMedia.width = videoMedia.width === meta.presentWidth ? videoMedia.width : meta.presentWidth;
videoMedia.height = videoMedia.height === meta.presentHeight ? videoMedia.width : meta.presentHeight;
meta.duration = this._context.mediaInfo.duration * meta.timescale;
meta.avcc = new Uint8Array(data.length);
meta.avcc.set(data);
track.meta = meta;
}
/**
* choose audio sample rate
* @param samplingFrequencyIndex
* @returns {number}
* @private
*/
_switchAudioSampleRate(samplingFrequencyIndex) {
let samplingFrequencyList = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
return samplingFrequencyList[samplingFrequencyIndex];
}
/**
* choose audio sampling frequence
* @param info
* @returns {number}
* @private
*/
_switchAudioSamplingFrequency(info) {
let samplingFrequencyIndex = (info & 12) >>> 2;
let samplingFrequencyList = [5500, 11025, 22050, 44100, 48000];
return samplingFrequencyList[samplingFrequencyIndex];
}
/**
* choose audio channel count
* @param info
* @returns {number}
* @private
*/
_switchAudioChannel(info) {
let sampleTrackNumIndex = info & 1;
let sampleTrackNumList = [1, 2];
return sampleTrackNumList[sampleTrackNumIndex];
}
/**
* check datasize is valid use 4 Byte after current tag
* @param datasize
* @returns {boolean}
* @private
*/
_datasizeValidator(datasize) {
let datasizeConfirm = this.loaderBuffer.toInt(0, 4);
this.loaderBuffer.shift(4);
return datasizeConfirm === datasize + 11;
}
get loaderBuffer() {
const buffer = this._context.getInstance('LOADER_BUFFER');
if (buffer) {
return buffer;
} else {
this.emit(DEMUX_EVENTS.DEMUX_ERROR, new Error('找不到 loaderBuffer 实例'));
}
}
get tracks() {
return this._context.getInstance('TRACKS');
}
get logger() {
return this._context.getInstance('LOGGER');
}
}
export default FlvDemuxer;

141
packages/xgplayer-demux/dist/hls/demuxer/m3u8parser.js vendored
View File

@ -1,141 +0,0 @@
/**
* Reference: https://tools.ietf.org/html/rfc8216#section-4.3
*/
class M3U8Parser {
static parse(text, baseurl = '') {
let ret = {
duration: 0
};
if (!text || !text.split) {
return;
}
let refs = text.split(/\r|\n/);
refs = refs.filter(ref => {
return ref;
});
let ref = refs.shift();
if (!ref.match('#EXTM3U')) {
// TODO:M3U格式错误。
return null;
}
ref = refs.shift();
while (ref) {
let refm = ref.match(/#(.[A-Z|-]*):(.*)/);
if (refm && refm.length > 2) {
switch (refm[1]) {
case 'EXT-X-VERSION':
ret.version = parseInt(refm[2]);
break;
case 'EXT-X-MEDIA-SEQUENCE':
ret.sequence = parseInt(refm[2]);
break;
case 'EXT-X-TARGETDURATION':
ret.targetduration = parseFloat(refm[2]);
break;
case 'EXTINF':
M3U8Parser.parseFrag(refm, refs, ret, baseurl);
break;
case 'EXT-X-KEY':
M3U8Parser.parseDecrypt(refm[2], ret);
break;
default:
break;
}
}
ref = refs.shift();
}
return ret;
}
static parseFrag(refm, refs, ret, baseurl) {
if (!ret.frags) {
ret.frags = [];
}
let freg = {
start: ret.duration,
duration: parseFloat(refm[2]) * 1000
};
ret.duration += freg.duration;
let nextline = refs.shift();
if (nextline.match(/#(.*):(.*)/)) {
nextline = refs.shift();
}
if (nextline.length > 0 && nextline.charAt(0) === '/' && baseurl.match(/.*\/\/.*\.\w+/g)) {
baseurl = baseurl.match(/.*\/\/.*\.\w+/g)[0];
}
if (nextline.match(/.*:\/\/.*/)) {
freg.url = nextline;
} else {
freg.url = baseurl + nextline;
}
ret.frags.push(freg);
}
static parseURL(url) {
let baseurl = '';
let urls = url.match(/(.*\/).*\.m3u8/);
if (urls && urls.length > 0) {
for (let i = 0; i < urls.length; i++) {
if (urls[i].match(/.*\/$/g) && urls[i].length > baseurl.length) {
baseurl = urls[i];
}
}
}
return baseurl;
}
static parseDecrypt(refm, ret) {
ret.encrypt = {};
let refs = refm.split(',');
for (let i in refs) {
let cmd = refs[i];
if (cmd.match(/METHOD=(.*)/)) {
ret.encrypt.method = cmd.match(/METHOD=(.*)/)[1];
}
if (cmd.match(/URI="(.*)"/)) {
ret.encrypt.uri = cmd.match(/URI="(.*)"/)[1];
}
if (cmd.match(/IV=0x(.*)/)) {
let iv = cmd.match(/IV=0x(.*)/)[1];
let length = Math.ceil(iv.length / 2);
ret.encrypt.ivb = new Uint8Array(length);
for (let i = length - 1; i >= 0; i--) {
let im = parseInt(iv.substr(i * 2, 2), 16);
ret.encrypt.ivb[i] = im;
}
ret.encrypt.iv = iv;
}
}
;
}
}
export default M3U8Parser;

795
packages/xgplayer-demux/dist/hls/demuxer/ts.js vendored
View File

@ -1,795 +0,0 @@
import { Nalunit } from 'xgplayer-codec';
import { AudioTrack, VideoTrack } from 'xgplayer-buffer';
import { AudioTrackMeta, VideoTrackMeta, AudioTrackSample, VideoTrackSample, EVENTS, Stream } from 'xgplayer-utils';
const DEMUX_EVENTS = EVENTS.DEMUX_EVENTS;
const StreamType = {
0x01: ['video', 'MPEG-1'],
0x02: ['video', 'MPEG-2'],
0x1b: ['video', 'AVC.H264'],
0xea: ['video', 'VC-1'],
0x03: ['audio', 'MPEG-1'],
0x04: ['audio', 'MPEG-2'],
0x0f: ['audio', 'MPEG-2.AAC'],
0x11: ['audio', 'MPEG-4.AAC'],
0x80: ['audio', 'LPCM'],
0x81: ['audio', 'AC3'],
0x06: ['audio', 'AC3'],
0x82: ['audio', 'DTS'],
0x83: ['audio', 'Dolby TrueHD'],
0x84: ['audio', 'AC3-Plus'],
0x85: ['audio', 'DTS-HD'],
0x86: ['audio', 'DTS-MA'],
0xa1: ['audio', 'AC3-Plus-SEC'],
0xa2: ['audio', 'DTS-HD-SEC']
};
class TsDemuxer {
constructor(configs) {
this.configs = Object.assign({}, configs);
this.demuxing = false;
this.pat = [];
this.pmt = [];
this._hasVideoMeta = false;
this._hasAudioMeta = false;
}
init() {
this.on(DEMUX_EVENTS.DEMUX_START, this.demux.bind(this));
}
demux() {
if (this.demuxing) {
return;
}
let buffer = this.inputBuffer;
let frags = {
pat: [],
pmt: []
};
let peses = {}; // Read TS segment
while (buffer.length >= 188) {
while (buffer.length >= 1 && buffer.array[0][buffer.offset] !== 71) {
buffer.shift(1);
}
let buf = buffer.shift(188); // console.log(buf);
let tsStream = new Stream(buf.buffer);
let ts = {};
TsDemuxer.read(tsStream, ts, frags);
if (ts.pes) {
if (!peses[ts.header.pid]) {
peses[ts.header.pid] = [];
}
peses[ts.header.pid].push(ts.pes);
ts.pes.ES.buffer = [ts.pes.ES.buffer];
} else if (peses[ts.header.pid]) {
peses[ts.header.pid][peses[ts.header.pid].length - 1].ES.buffer.push(ts.payload.stream);
}
} // Get Frames data
for (let i = 0; i < Object.keys(peses).length; i++) {
let epeses = peses[Object.keys(peses)[i]];
for (let j = 0; j < epeses.length; j++) {
epeses[j].id = Object.keys(peses)[i];
epeses[j].ES.buffer = TsDemuxer.Merge(epeses[j].ES.buffer);
if (epeses[j].type === 'audio') {
this.pushAudioSample(epeses[j]);
} else if (epeses[j].type === 'video') {
this.pushVideoSample(epeses[j]);
}
}
}
if (this._hasAudioMeta) {
this.emit(DEMUX_EVENTS.DEMUX_COMPLETE, 'audio');
}
if (this._hasVideoMeta) {
this.emit(DEMUX_EVENTS.DEMUX_COMPLETE, 'video');
}
}
pushAudioSample(pes) {
let track;
if (!this._tracks.audioTrack) {
this._tracks.audioTrack = new AudioTrack();
track = this._tracks.audioTrack;
track.meta = new AudioTrackMeta({
audioSampleRate: pes.ES.frequence,
sampleRate: pes.ES.frequence,
channelCount: pes.ES.channel,
codec: 'mp4a.40.' + pes.ES.audioObjectType,
config: pes.ES.audioConfig,
id: 2,
sampleRateIndex: pes.ES.frequencyIndex
});
track.meta.refSampleDuration = Math.floor(1024 / track.meta.audioSampleRate * track.meta.timescale);
if (!this._hasAudioMeta) {
this._hasAudioMeta = true;
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'audio');
}
} else {
track = this._tracks.audioTrack;
}
let data = new Uint8Array(pes.ES.buffer.buffer.slice(pes.ES.buffer.position, pes.ES.buffer.length));
let dts = parseInt(pes.pts / 90);
let pts = parseInt(pes.pts / 90);
let sample = new AudioTrackSample({
dts,
pts,
data
});
track.samples.push(sample);
}
pushVideoSample(pes) {
let nals = Nalunit.getNalunits(pes.ES.buffer);
let track;
if (!this._tracks.videoTrack) {
this._tracks.videoTrack = new VideoTrack();
track = this._tracks.videoTrack;
track.meta = new VideoTrackMeta();
} else {
track = this._tracks.videoTrack;
}
let sampleLength = 0;
let sps = false;
let pps = false;
for (let i = 0; i < nals.length; i++) {
let nal = nals[i];
if (nal.sps) {
// TODO：VideoTrack信息 和 Meta 信息
if (track.sps && TsDemuxer.compaireUint8(nal.body, track.sps)) {
continue;
}
sps = nal;
track.sps = nal.body;
track.meta.chromaFormat = sps.sps.chroma_format;
track.meta.codec = 'avc1.';
for (var j = 1; j < 4; j++) {
var h = sps.body[j].toString(16);
if (h.length < 2) {
h = '0' + h;
}
track.meta.codec += h;
}
track.meta.codecHeight = sps.sps.codec_size.height;
track.meta.codecWidth = sps.sps.codec_size.width;
track.meta.frameRate = sps.sps.frame_rate;
track.meta.id = 1;
track.meta.level = sps.sps.level_string;
track.meta.presentHeight = sps.sps.present_size.height;
track.meta.presentWidth = sps.sps.present_size.width;
track.meta.profile = sps.sps.profile_string;
track.meta.refSampleDuration = Math.floor(track.meta.timescale * (sps.sps.frame_rate.fps_den / sps.sps.frame_rate.fps_num));
track.meta.sarRatio = sps.sps.sar_ratio ? sps.sps.sar_ratio : sps.sps.par_ratio;
} else if (nal.pps) {
track.pps = nal.body;
pps = nal;
} else {
sampleLength += 4 + nal.body.byteLength;
}
}
if (sps && pps) {
track.meta.avcc = Nalunit.getAvcc(sps.body, pps.body);
if (!this._hasVideoMeta) {
this._hasVideoMeta = true;
this.emit(DEMUX_EVENTS.METADATA_PARSED, 'video');
}
}
let data = new Uint8Array(sampleLength);
let offset = 0;
let isKeyframe = false;
for (let i = 0; i < nals.length; i++) {
let nal = nals[i];
let length = nal.body.byteLength;
if (nal.idr) {
isKeyframe = true;
}
if (!nal.pps && !nal.sps) {
data.set(new Uint8Array([length >>> 24 & 0xff, length >>> 16 & 0xff, length >>> 8 & 0xff, length & 0xff]), offset);
offset += 4;
data.set(nal.body, offset);
offset += length;
}
}
let sample = new VideoTrackSample({
dts: parseInt(pes.dts / 90),
pts: parseInt(pes.pts / 90),
cts: (pes.pts - pes.dts) / 90,
originDts: pes.dts,
isKeyframe,
data
});
track.samples.push(sample);
}
destory() {
this.off(DEMUX_EVENTS.DEMUX_START, this.demux);
this.configs = {};
this.demuxing = false;
this.pat = [];
this.pmt = [];
this._hasVideoMeta = false;
this._hasAudioMeta = false;
}
static compaireUint8(a, b) {
if (a.byteLength !== b.byteLength) {
return false;
}
let ret = true;
for (let i = 0; i < a.byteLength; i++) {
if (a[i] !== b[i]) {
ret = false;
}
}
return ret;
}
static Merge(buffers) {
let data;
let length = 0;
let offset = 0;
for (let i = 0; i < buffers.length; i++) {
length += buffers[i].length - buffers[i].position;
}
data = new Uint8Array(length);
for (let i = 0; i < buffers.length; i++) {
let buffer = buffers[i];
data.set(new Uint8Array(buffer.buffer, buffer.position), offset);
offset += buffer.length - buffer.position;
}
return new Stream(data.buffer);
}
static read(stream, ts, frags) {
TsDemuxer.readHeader(stream, ts);
TsDemuxer.readPayload(stream, ts, frags);
if (ts.header.packet === 'MEDIA' && ts.header.payload === 1 && !ts.unknownPIDs) {
ts.pes = TsDemuxer.PES(ts);
}
}
static readPayload(stream, ts, frags) {
let header = ts.header;
let pid = header.pid;
switch (pid) {
case 0:
TsDemuxer.PAT(stream, ts, frags);
break;
case 1:
TsDemuxer.CAT(stream, ts, frags);
break;
case 2:
TsDemuxer.TSDT(stream, ts, frags);
break;
case 0x1fff:
break;
default:
// TODO: some的写法不太好，得改
if (frags.pat.some(item => {
return item.pid === pid;
})) {
TsDemuxer.PMT(stream, ts, frags);
} else {
let sts = frags.pmt ? frags.pmt.filter(item => item.pid === pid) : [];
if (sts.length > 0) {
TsDemuxer.Media(stream, ts, StreamType[sts[0].streamType][0]);
} else {
ts.unknownPIDs = true;
}
;
}
}
}
static readHeader(stream, ts) {
let header = {};
header.sync = stream.readUint8();
let next = stream.readUint16();
header.error = next >>> 15;
header.payload = next >>> 14 & 1;
header.priority = next >>> 13 & 1;
header.pid = next & 0x1fff;
next = stream.readUint8();
header.scrambling = next >> 6 & 0x3; // 是否加密，00表示不加密
/**
* 00 ISO/IEC未来使用保留
* 01 没有调整字段，仅含有184B有效净荷
* 02 没有有效净荷，仅含有183B调整字段
* 03 0~182B调整字段后为有效净荷
*/
header.adaptation = next >> 4 & 0x3;
header.continuity = next & 15;
header.packet = header.pid === 0 ? 'PAT' : 'MEDIA';
ts.header = header;
}
static PAT(stream, ts, frags) {
let ret = {};
let next = stream.readUint8();
stream.skip(next);
next = stream.readUint8();
ret.tabelID = next;
next = stream.readUint16();
ret.error = next >>> 7;
ret.zero = next >>> 6 & 1;
ret.sectionLength = next & 0xfff;
ret.streamID = stream.readUint16();
ret.current = stream.readUint8() & 1;
ret.sectionNumber = stream.readUint8();
ret.lastSectionNumber = stream.readUint8();
let N = (ret.sectionLength - 9) / 4;
let list = [];
for (let i = 0; i < N; i++) {
let programNumber = stream.readUint16();
let pid = stream.readUint16() & 0x1fff;
list.push({
program: programNumber,
pid,
type: programNumber === 0 ? 'network' : 'mapPID'
});
}
if (list.length > 0) {
frags.pat = frags.pat.concat(list);
}
ret.list = list;
ret.program = stream.readUint16();
ret.pid = stream.readUint16() & 0x1fff;
ts.payload = ret; // TODO CRC
}
static PMT(stream, ts, frags) {
let ret = {};
let header = ts.header;
header.packet = 'PMT';
let next = stream.readUint8();
stream.skip(next);
next = stream.readUint8();
ret.tableID = next;
next = stream.readUint16();
ret.sectionLength = next & 0xfff;
ret.program = stream.readUint16();
ret.current = stream.readUint8() & 1;
ret.order = stream.readUint8();
ret.lastOrder = stream.readUint8();
ret.PCR_PID = stream.readUint16() & 0x1fff;
ret.programLength = stream.readUint16() & 0xfff;
let N = (ret.sectionLength - 13) / 5;
let list = [];
for (let i = 0; i < N; i++) {
list.push({
streamType: stream.readUint8(),
pid: stream.readUint16() & 0x1fff,
// 0x07e5 视频，0x07e6
es: stream.readUint16() & 0xfff
});
}
ret.list = list;
if (!this.pmt) {
this.pmt = [];
}
frags.pmt = this.pmt.concat(list.map(item => {
return {
pid: item.pid,
es: item.es,
streamType: item.streamType,
program: ret.program
};
}));
ts.payload = ret;
}
static Media(stream, ts, type) {
let header = ts.header;
let payload = {};
header.type = type;
if (header.adaptation === 0x03) {
payload.adaptationLength = stream.readUint8();
if (payload.adaptationLength > 0) {
let next = stream.readUint8();
payload.discontinue = next >>> 7;
payload.access = next >>> 6 & 0x01;
payload.priority = next >>> 5 & 0x01;
payload.PCR = next >>> 4 & 0x01;
payload.OPCR = next >>> 3 & 0x01;
payload.splicePoint = next >>> 2 & 0x01;
payload.transportPrivate = next >>> 1 & 0x01;
payload.adaptationField = next & 0x01;
let _start = stream.position;
if (payload.PCR === 1) {
payload.programClockBase = stream.readUint32() << 1;
next = stream.readUint16();
payload.programClockBase |= next >>> 15;
payload.programClockExtension = next & 0x1ff;
}
if (payload.OPCR === 1) {
payload.originProgramClockBase = stream.readUint32() << 1;
next = stream.readUint16();
payload.originProgramClockBase += next >>> 15;
payload.originProgramClockExtension = next & 0x1ff;
}
if (payload.splicePoint === 1) {
payload.spliceCountdown = stream.readUint8();
}
if (payload.transportPrivate === 1) {
let length = stream.readUint8();
let transportPrivateData = [];
for (let i = 0; i < length; i++) {
transportPrivateData.push(stream.readUint8());
}
}
if (payload.adaptationField === 1) {
let length = stream.readUint8();
let next = stream.readUint8();
let start = stream.position;
let ltw = next >>> 7;
let piecewise = next >>> 6 & 0x1;
let seamless = next >>> 5 & 0x1;
if (ltw === 1) {
next = stream.readUint16();
payload.ltwValid = next >>> 15;
payload.ltwOffset = next & 0xefff;
}
if (piecewise === 1) {
next = stream.readUint24();
payload.piecewiseRate = next & 0x3fffff;
}
if (seamless === 1) {
next = stream.readInt8();
payload.spliceType = next >>> 4;
payload.dtsNextAU1 = next >>> 1 & 0x7;
payload.marker1 = next & 0x1;
next = stream.readUint16();
payload.dtsNextAU2 = next >>> 1;
payload.marker2 = next & 0x1;
next = stream.readUint16();
payload.dtsNextAU3 = next;
}
stream.skip(length - 1 - (stream.position - start));
}
let lastStuffing = payload.adaptationLength - 1 - (stream.position - _start);
stream.skip(lastStuffing);
}
}
payload.stream = new Stream(stream.buffer.slice(stream.position));
ts.payload = payload;
}
static PES(ts) {
let ret = {};
let buffer = ts.payload.stream;
let next = buffer.readUint24();
if (next !== 1) {
ret.ES = {};
ret.ES.buffer = buffer;
} else {
let streamID = buffer.readUint8();
if (streamID >= 0xe0 && streamID <= 0xef) {
ret.type = 'video';
}
if (streamID >= 0xc0 && streamID <= 0xdf) {
ret.type = 'audio';
}
let packetLength = buffer.readUint16();
ret.packetLength = packetLength;
if (ret.type === 'video' || ret.type === 'audio') {
let next = buffer.readUint8();
let first = next >>> 6;
if (first !== 0x02) {
throw new Error('error when parse pes header');
}
next = buffer.readUint8();
ret.ptsDTSFlag = next >>> 6;
ret.escrFlag = next >>> 5 & 0x01;
ret.esRateFlag = next >>> 4 & 0x01;
ret.dsmFlag = next >>> 3 & 0x01;
ret.additionalFlag = next >>> 2 & 0x01;
ret.crcFlag = next >>> 1 & 0x01;
ret.extensionFlag = next & 0x01;
ret.pesHeaderLength = buffer.readUint8();
let N1 = ret.pesHeaderLength;
if (ret.ptsDTSFlag === 2) {
let pts = [];
next = buffer.readUint8();
pts.push(next >>> 1 & 0x07);
next = buffer.readUint16();
pts.push(next >>> 1);
next = buffer.readUint16();
pts.push(next >>> 1);
ret.pts = pts[0] << 30 | pts[1] << 15 | pts[2];
N1 -= 5; // 视频如果没有dts用pts
if (ret.type === 'video') {
ret.dts = ret.pts;
}
}
if (ret.ptsDTSFlag === 3) {
let pts = [];
next = buffer.readUint8();
pts.push(next >>> 1 & 0x07);
next = buffer.readUint16();
pts.push(next >>> 1);
next = buffer.readUint16();
pts.push(next >>> 1);
ret.pts = pts[0] << 30 | pts[1] << 15 | pts[2];
let dts = [];
next = buffer.readUint8();
dts.push(next >>> 1 & 0x07);
next = buffer.readUint16();
dts.push(next >>> 1);
next = buffer.readUint16();
dts.push(next >>> 1);
ret.dts = dts[0] << 30 | dts[1] << 15 | dts[2];
N1 -= 10;
}
if (ret.escrFlag === 1) {
let escr = [];
let ex = [];
next = buffer.readUint8();
escr.push(next >>> 3 & 0x07);
escr.push(next & 0x03);
next = buffer.readUint16();
escr.push(next >>> 13);
escr.push(next & 0x03);
next = buffer.readUint16();
escr.push(next >>> 13);
ex.push(next & 0x03);
next = buffer.readUint8();
ex.push(next >>> 1);
ret.escr = (escr[0] << 30 | escr[1] << 28 | escr[2] << 15 | escr[3] << 13 | escr[4]) * 300 + (ex[0] << 7 | ex[1]);
N1 -= 6;
}
if (ret.esRateFlag === 1) {
next = buffer.readUint24();
ret.esRate = next >>> 1 & 0x3fffff;
N1 -= 3;
}
if (ret.dsmFlag === 1) {
throw new Error('not support DSM_trick_mode');
}
if (ret.additionalFlag === 1) {
next = buffer.readUint8();
ret.additionalCopyInfo = next & 0x7f;
N1 -= 1;
}
if (ret.crcFlag === 1) {
ret.pesCRC = buffer.readUint16();
N1 -= 2;
}
if (ret.extensionFlag === 1) {
throw new Error('not support extension');
}
if (N1 > 0) {
buffer.skip(N1);
}
ret.ES = TsDemuxer.ES(buffer, ret.type);
} else {
throw new Error('format is not supported');
}
}
return ret;
}
static ES(buffer, type) {
let next;
let ret = {};
if (type === 'video') {
next = buffer.readUint32();
if (next !== 1) {
buffer.back(4);
next = buffer.readUint24();
if (next !== 1) {
throw new Error('h264 nal header parse failed');
}
}
buffer.skip(2); // 09 F0
// TODO readnalu
ret.buffer = buffer;
} else if (type === 'audio') {
next = buffer.readUint16(); // adts的同步字节，12位
if (next >>> 4 !== 0xfff) {
throw new Error('aac ES parse Error');
}
const fq = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];
ret.id = (next >>> 3 & 0x01) === 0 ? 'MPEG-4' : 'MPEG-2';
ret.layer = next >>> 1 & 0x03;
ret.absent = next & 0x01;
next = buffer.readUint16();
ret.audioObjectType = (next >>> 14 & 0x03) + 1;
ret.profile = ret.audioObjectType - 1;
ret.frequencyIndex = next >>> 10 & 0x0f;
ret.frequence = fq[ret.frequencyIndex];
ret.channel = next >>> 6 & 0x07;
ret.frameLength = (next & 0x03) << 11 | buffer.readUint16() >>> 5;
ret.audioConfig = TsDemuxer.getAudioConfig(ret.audioObjectType, ret.channel, ret.frequencyIndex);
buffer.skip(1);
ret.buffer = buffer;
} else {
throw new Error(`ES ${type} is not supported`);
}
return ret;
}
static TSDT(stream, ts, frags) {
// TODO
ts.payload = {};
}
static CAT(stream, ts, frags) {
let ret = {};
ret.tableID = stream.readUint8();
let next = stream.readUint16();
ret.sectionIndicator = next >>> 7;
ret.sectionLength = next & 0x0fff;
stream.skip(2);
next = stream.readUint8();
ret.version = next >>> 3;
ret.currentNextIndicator = next & 0x01;
ret.sectionNumber = stream.readUint8();
ret.lastSectionNumber = stream.readUint8();
let N = (this.sectionLength - 9) / 4;
let list = [];
for (let i = 0; i < N; i++) {
list.push({});
}
ret.crc32 = stream.readUint32();
ts.payload = ret;
}
static getAudioConfig(audioObjectType, channel, sampleIndex) {
let userAgent = navigator.userAgent.toLowerCase();
let config;
let extensionSampleIndex;
if (/firefox/i.test(userAgent)) {
if (sampleIndex >= 6) {
audioObjectType = 5;
config = new Array(4);
extensionSampleIndex = sampleIndex - 3;
} else {
audioObjectType = 2;
config = new Array(2);
extensionSampleIndex = sampleIndex;
}
} else if (userAgent.indexOf('android') !== -1) {
audioObjectType = 2;
config = new Array(2);
extensionSampleIndex = sampleIndex;
} else {
audioObjectType = 5;
config = new Array(4);
if (sampleIndex >= 6) {
extensionSampleIndex = sampleIndex - 3;
} else {
if (channel === 1) {
audioObjectType = 2;
config = new Array(2);
}
extensionSampleIndex = sampleIndex;
}
}
config[0] = audioObjectType << 3;
config[0] |= (sampleIndex & 0x0e) >> 1;
config[1] = (sampleIndex & 0x01) << 7;
config[1] |= channel << 3;
if (audioObjectType === 5) {
config[1] |= (extensionSampleIndex & 0x0e) >> 1;
config[2] = (extensionSampleIndex & 0x01) << 7;
config[2] |= 2 << 2;
config[3] = 0;
}
return config;
}
get inputBuffer() {
return this._context.getInstance(this.configs.inputbuffer);
}
get _tracks() {
return this._context.getInstance('TRACKS');
}
}
export default TsDemuxer;

206
packages/xgplayer-demux/dist/hls/playlist.js vendored
View File

@ -1,206 +0,0 @@
class Playlist {
constructor(configs) {
this._baseURL = '';
this._list = {};
this._ts = {};
this.version = 0;
this.sequence = -1;
this.targetduration = 0;
this.duration = 0;
this.fragLength = 0;
this._lastget = undefined;
this._audoclear = configs.autoclear || false;
}
get list() {
return this._list;
}
set baseURL(baseURL) {
if (this.baseURL !== baseURL) {
this.clear();
this._baseURL = baseURL;
}
}
get baseURL() {
return this._baseURL;
}
push(ts, duration) {
if (!this._ts[ts]) {
this._ts[ts] = {
duration: duration,
downloaded: false,
downloading: false,
start: this.duration
};
this._list[this.duration] = ts;
this.duration += duration;
this.fragLength += 1;
}
}
deleteFrag(url) {
if (this._ts[url]) {
if (this._ts[url].start > this._lastget.time) {
this._lastget = {
duration: this._ts[url].duration,
time: this._ts[url].start,
downloaded: false,
downloading: false,
url: url
};
}
delete this._list[this._ts[url].start];
delete this._ts[url];
this.fragLength -= 1;
}
}
pushM3U8(data, deletepre) {
// 常规信息替换
if (!data) {
return;
}
this.version = data.version;
this.targetduration = data.targetduration;
if (data.encrypt && !this.encrypt) {
this.encrypt = data.encrypt;
} // 新分片信息
if (data.sequence > this.sequence) {
this.sequence = data.sequence;
let newfraglist = [];
for (let i = 0; i < data.frags.length; i++) {
let frag = data.frags[i];
if (!this._ts[frag.url]) {
newfraglist.push(frag.url);
this.push(frag.url, frag.duration);
}
}
if (deletepre) {
let tslist = this.getTsList();
for (let i = 0; i < tslist.length; i++) {
if (newfraglist.indexOf(tslist[i]) < 0) {
this.deleteFrag(tslist[i]);
}
}
}
}
}
getTsList() {
return Object.keys(this._ts);
}
downloaded(tsname, isloaded) {
let ts = this._ts[tsname];
if (ts) {
ts.downloaded = isloaded;
}
}
downloading(tsname, loading) {
let ts = this._ts[tsname];
if (ts) {
ts.downloading = loading;
}
}
getTsByName(name) {
return this._ts[name];
}
getTs(time) {
let timelist = Object.keys(this._list);
let ts;
if (time === undefined) {
if (this._lastget) {
time = this._lastget.time + this._lastget.duration;
} else {
time = 0;
}
}
if (timelist.length < 1 || time >= this.duration) {
return undefined;
}
timelist.sort((a, b) => {
return parseFloat(a) - parseFloat(b);
});
for (let i = 0; i < timelist.length; i++) {
if (time >= parseInt(timelist[i])) {
let url = this._list[timelist[i]];
let downloaded = this._ts[url].downloaded;
let downloading = this._ts[url].downloading;
ts = {
url,
downloaded,
downloading,
time: parseInt(timelist[i]),
duration: parseInt(this._ts[url].duration)
};
if (this.autoclear) {
delete this._ts[this._lastget.url];
delete this._list[this._lastget.time];
}
this._lastget = ts;
} else {
break;
}
}
return ts;
}
clear() {
this._baseURL = '';
this._list = {};
this._ts = {};
this.version = 0;
this.sequence = -1;
this.targetduration = 0;
this.duration = 0;
}
clearDownloaded() {
for (let i = 0, l = Object.keys(this._ts).length; i < l; i++) {
let ts = this._ts[Object.keys(this._ts)[i]];
ts.downloaded = false;
ts.downloading = false;
}
}
destroy() {
this._baseURL = '';
this._list = {};
this._ts = {};
this.version = 0;
this.sequence = -1;
this.targetduration = 0;
this.duration = 0;
this.fragLength = 0;
this._lastget = undefined;
this._audoclear = false;
}
}
export default Playlist;

9
packages/xgplayer-demux/es/index.js
View File

@ -1,9 +0,0 @@
import _M3U8Parser from './hls/demuxer/m3u8parser';
import _TsDemuxer from './hls/demuxer/ts';
import _Playlist from './hls/playlist';
import _FlvDemuxer from './flv/index';
export var M3U8Parser = _M3U8Parser;
export var TsDemuxer = _TsDemuxer;
export var Playlist = _Playlist;
export var FlvDemuxer = _FlvDemuxer;

9
packages/xgplayer-demux/src/index.js
View File

@ -1,9 +0,0 @@
import _M3U8Parser from './hls/demuxer/m3u8parser';
import _TsDemuxer from './hls/demuxer/ts';
import _Playlist from './hls/playlist';
import _FlvDemuxer from './flv/index';
export const M3U8Parser = _M3U8Parser;
export const TsDemuxer = _TsDemuxer;
export const Playlist = _Playlist;
export const FlvDemuxer = _FlvDemuxer;

5756
packages/xgplayer-flv-live/dist/index.js vendored
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv-live/dist/index.js.map vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-live/dist/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-live/dist/index.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

5756
packages/xgplayer-flv-live/es/index.js
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv-live/es/index.js.map
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-live/es/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-live/es/index.min.js.map
View File

File diff suppressed because one or more lines are too long

20
packages/xgplayer-flv-live/package.json
View File

@ -31,13 +31,19 @@
]
},
"dependencies": {
"xgplayer-buffer": "^2.2.0-alpha.0",
"xgplayer-codec": "^2.2.0-alpha.0",
"xgplayer-demux": "^2.2.0-alpha.0",
"xgplayer-loader": "^2.2.0-alpha.0",
"xgplayer-remux": "^2.2.0-alpha.0",
"xgplayer-utils": "^2.2.0-alpha.0",
"xgplayer-utils-mse": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-track": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-presource": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-xgbuffer": "^2.2.0-alpha.0",
"xgplayer-transmuxer-loader-fetch": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-flv": "^2.2.0-alpha.0",
"xgplayer-transmuxer-remux-mp4": "^2.2.0-alpha.0",
"xgplayer-transmuxer-constant-events": "^2.2.0-alpha.0",
"xgplayer-transmuxer-codec-compatibility": "^2.2.0-alpha.0",
"xgplayer-transmuxer-context": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0"
},
"devDependencies": {}
"devDependencies": {
"cross-env": "^6.0.3"
}
}

19
packages/xgplayer-flv-live/src/flv-live.js
View File

@ -1,9 +1,14 @@
import Remuxer from 'xgplayer-remux'
import { FlvDemuxer } from 'xgplayer-demux'
import { FetchLoader } from 'xgplayer-loader'
import { Tracks, XgBuffer, PreSource } from 'xgplayer-buffer'
import { Mse, EVENTS } from 'xgplayer-utils'
import { Compatibility } from 'xgplayer-codec'
import Remuxer from 'xgplayer-transmuxer-remux-mp4'
import FlvDemuxer from 'xgplayer-transmuxer-demux-flv'
import FetchLoader from 'xgplayer-transmuxer-loader-fetch'
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Tracks from 'xgplayer-transmuxer-buffer-track'
import PreSource from 'xgplayer-transmuxer-buffer-presource'
import XgBuffer from 'xgplayer-transmuxer-buffer-xgbuffer'
import Compatibility from 'xgplayer-transmuxer-codec-compatibility'
import Mse from 'xgplayer-utils-mse'
import Player from 'xgplayer'
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;
@ -52,7 +57,7 @@ export default class FlvController {
this._context.registry('FLV_DEMUXER', FlvDemuxer)
this._context.registry('TRACKS', Tracks)
this._context.registry('MP4_REMUXER', Remuxer.Mp4Remuxer)(this._player.currentTime)
this._context.registry('MP4_REMUXER', Remuxer)(this._player.currentTime)
this._context.registry('PRE_SOURCE_BUFFER', PreSource)
if (this._player.config.compatibility !== false) {

7
packages/xgplayer-flv-live/src/index.js
View File

@ -1,6 +1,7 @@
import 'xgplayer-polyfills/babel/external-helpers';
import Player from 'xgplayer'
import { Context, EVENTS } from 'xgplayer-utils';
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Context from 'xgplayer-transmuxer-context';
import FLV from './flv-live'
const flvAllowedEvents = EVENTS.FlvAllowedEvents;
@ -57,7 +58,6 @@ class FlvPlayer extends Player {
this.context.destroy();
this.context = ctx;
}
})
flv.once(EVENTS.LOADER_EVENTS.LOADER_COMPLETE, () => {
@ -81,7 +81,6 @@ class FlvPlayer extends Player {
}
initEvents () {
this.on('seeking', () => {
const time = this.currentTime
const range = this.getBufferedRange()
@ -89,7 +88,6 @@ class FlvPlayer extends Player {
this.flv.seek(this.currentTime)
}
})
}
initFlv () {
@ -107,7 +105,6 @@ class FlvPlayer extends Player {
this.start()
return super.play()
})
} else {
return super.play()
}

6272
packages/xgplayer-flv-vod/dist/index.js vendored
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv-vod/dist/index.js.map vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-vod/dist/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-vod/dist/index.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

6272
packages/xgplayer-flv-vod/es/index.js
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv-vod/es/index.js.map
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-vod/es/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv-vod/es/index.min.js.map
View File

File diff suppressed because one or more lines are too long

16
packages/xgplayer-flv-vod/package.json
View File

@ -28,12 +28,16 @@
]
},
"dependencies": {
"xgplayer-buffer": "^2.2.0-alpha.0",
"xgplayer-codec": "^2.2.0-alpha.0",
"xgplayer-demux": "^2.2.0-alpha.0",
"xgplayer-loader": "^2.2.0-alpha.0",
"xgplayer-remux": "^2.2.0-alpha.0",
"xgplayer-utils": "^2.2.0-alpha.0",
"xgplayer-utils-mse": "^2.2.0-alpha.0",
"xgplayer-transmuxer-context": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-xgbuffer": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-track": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-presource": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-flv": "^2.2.0-alpha.0",
"xgplayer-transmuxer-loader-fetch": "^2.2.0-alpha.0",
"xgplayer-transmuxer-remux-mp4": "^2.2.0-alpha.0",
"xgplayer-transmuxer-constant-events": "^2.2.0-alpha.0",
"xgplayer-transmuxer-codec-compatibility": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0"
},
"devDependencies": {

24
packages/xgplayer-flv-vod/src/flv-vod.js
View File

@ -1,9 +1,14 @@
import FlvDemuxer from '../../xgplayer-demux/src/flv'
import Remuxer from 'xgplayer-remux'
import { Tracks, XgBuffer, PreSource } from 'xgplayer-buffer'
import { FetchLoader } from 'xgplayer-loader'
import { Mse, EVENTS } from 'xgplayer-utils'
import { Compatibility } from 'xgplayer-codec'
import FetchLoader from 'xgplayer-transmuxer-loader-fetch';
import FlvDemuxer from 'xgplayer-transmuxer-demux-flv'
import Remuxer from 'xgplayer-transmuxer-remux-mp4'
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Tracks from 'xgplayer-transmuxer-buffer-track'
import PreSource from 'xgplayer-transmuxer-buffer-presource'
import XgBuffer from 'xgplayer-transmuxer-buffer-xgbuffer'
import Compatibility from 'xgplayer-transmuxer-codec-compatibility'
import Mse from 'xgplayer-utils-mse'
import Player from 'xgplayer'
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;
@ -54,10 +59,10 @@ class FlvController {
this._context.registry('FLV_DEMUXER', FlvDemuxer)
this._context.registry('TRACKS', Tracks)
this._context.registry('MP4_REMUXER', Remuxer.Mp4Remuxer)(this._player.currentTime)
this._context.registry('MP4_REMUXER', Remuxer)(this._player.currentTime)
this._context.registry('PRE_SOURCE_BUFFER', PreSource)
// this._context.registry('COMPATIBILITY', Compatibility)
this._context.registry('COMPATIBILITY', Compatibility)
this._context.registry('LOGGER', Logger)
if (!this.mse) {
@ -66,7 +71,6 @@ class FlvController {
}
this.initListeners()
}
initListeners () {
@ -283,7 +287,7 @@ class FlvController {
}
get loadBuffer () {
return this_context.getInstance('LOADER_BUFFER')
return this._context.getInstance('LOADER_BUFFER')
}
}

6
packages/xgplayer-flv-vod/src/index.js
View File

@ -1,8 +1,8 @@
import 'xgplayer-polyfills/babel/external-helpers';
import Player from 'xgplayer'
import { Context, EVENTS } from 'xgplayer-utils';
import Player from 'xgplayer';
import EVENTS from 'xgplayer-transmuxer-constant-events';
import Context from 'xgplayer-transmuxer-context';
import FLV from './flv-vod'
console.log(Context)
const flvAllowedEvents = EVENTS.FlvAllowedEvents;

3617
packages/xgplayer-flv/dist/index.js vendored
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv/dist/index.js.map vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv/dist/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv/dist/index.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

3617
packages/xgplayer-flv/es/index.js
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-flv/es/index.js.map
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv/es/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-flv/es/index.min.js.map
View File

File diff suppressed because one or more lines are too long

12
packages/xgplayer-flv/package.json
View File

@ -34,20 +34,14 @@
"devDependencies": {
"babel-core": "^6.23.0",
"babel-preset-es2015": "^6.24.1",
"babel-plugin-external-helpers": "^6.22.0"
"babel-plugin-external-helpers": "^6.22.0",
"cross-env": "^6.0.3"
},
"peerDependency": {
"xgplayer": "^0.1.0"
},
"dependencies": {
"concat-typed-array": "^1.0.2",
"event-emitter": "^0.3.5",
"xgplayer-buffer": "^2.2.0-alpha.0",
"xgplayer-codec": "^2.2.0-alpha.0",
"xgplayer-flv-live": "^2.2.0-alpha.0",
"xgplayer-flv-vod": "^2.2.0-alpha.0",
"xgplayer-loader": "^2.2.0-alpha.0",
"xgplayer-remux": "^2.2.0-alpha.0",
"xgplayer-utils": "^2.2.0-alpha.0"
"xgplayer-flv-vod": "^2.2.0-alpha.0"
}
}

2
packages/xgplayer-flv/src/index.js
View File

@ -1,7 +1,7 @@
import FlvLivePlayer from 'xgplayer-flv-live'
import FlvVodPlayer from 'xgplayer-flv-vod'
class FlvPlayer{
class FlvPlayer {
constructor (config) {
if (config.isLive) {
return new FlvLivePlayer(config)

6213
packages/xgplayer-hls-live/dist/index.js vendored
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-hls-live/dist/index.js.map vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-hls-live/dist/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-hls-live/dist/index.min.js.map vendored
View File

File diff suppressed because one or more lines are too long

6213
packages/xgplayer-hls-live/es/index.js
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-hls-live/es/index.js.map
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-hls-live/es/index.min.js vendored
View File

File diff suppressed because one or more lines are too long

2
packages/xgplayer-hls-live/es/index.min.js.map
View File

File diff suppressed because one or more lines are too long

21
packages/xgplayer-hls-live/package.json
View File

@ -31,13 +31,22 @@
},
"license": "ISC",
"dependencies": {
"xgplayer-loader": "^2.2.0-alpha.0",
"xgplayer-buffer": "^2.2.0-alpha.0",
"xgplayer-codec": "^2.2.0-alpha.0",
"xgplayer-demux": "^2.2.0-alpha.0",
"xgplayer-remux": "^2.2.0-alpha.0",
"xgplayer-utils": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0"
"xgplayer-utils-crypto": "^2.2.0-alpha.0",
"xgplayer-demux": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0",
"xgplayer-utils-mse": "^2.2.0-alpha.0",
"xgplayer-transmuxer-constant-events": "^2.2.0-alpha.0",
"xgplayer-transmuxer-context": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-track": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-presource": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-xgbuffer": "^2.2.0-alpha.0",
"xgplayer-transmuxer-loader-fetch": "^2.2.0-alpha.0",
"xgplayer-transmuxer-remux-mp4": "^2.2.0-alpha.0",
"xgplayer-transmuxer-codec-compatibility": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-m3u8": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-ts": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-playlist": "^2.2.0-alpha.0"
},
"devDependencies": {
"cross-env": "^6.0.3"

40
packages/xgplayer-hls-live/src/hls-live.js
View File

@ -1,10 +1,16 @@
import { EVENTS, Mse, Crypto} from 'xgplayer-utils';
import { XgBuffer, PreSource, Tracks } from 'xgplayer-buffer';
import { FetchLoader } from 'xgplayer-loader';
import { Compatibility } from 'xgplayer-codec';
import Mp4Remuxer from 'xgplayer-remux/src/mp4/index';
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Mse from 'xgplayer-utils-mse'
import Tracks from 'xgplayer-transmuxer-buffer-track'
import PreSource from 'xgplayer-transmuxer-buffer-presource'
import XgBuffer from 'xgplayer-transmuxer-buffer-xgbuffer'
import FetchLoader from 'xgplayer-transmuxer-loader-fetch'
import Compatibility from 'xgplayer-transmuxer-codec-compatibility'
import Mp4Remuxer from 'xgplayer-transmuxer-remux-mp4'
import Crypto from 'xgplayer-utils-crypto';
import {Playlist, M3U8Parser, TsDemuxer} from 'xgplayer-demux';
import M3U8Parser from 'xgplayer-transmuxer-demux-m3u8';
import TsDemuxer from 'xgplayer-transmuxer-demux-ts';
import Playlist from 'xgplayer-transmuxer-buffer-playlist';
const LOADER_EVENTS = EVENTS.LOADER_EVENTS;
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;
@ -73,7 +79,7 @@ class HlsLiveController {
this.on(REMUX_EVENTS.REMUX_ERROR, this._onRemuxError.bind(this));
}
_onError(type, mod, err, fatal) {
_onError (type, mod, err, fatal) {
let error = {
errorType: type,
errorDetails: `[${mod}]: ${err.message}`,
@ -101,14 +107,14 @@ class HlsLiveController {
}
_onDemuxError (mod, error, fatal) {
if(fatal === undefined) {
if (fatal === undefined) {
fatal = true;
}
this._onError(LOADER_EVENTS.LOADER_ERROR, mod, error, fatal);
}
_onRemuxError (mod, error, fatal) {
if(fatal === undefined) {
if (fatal === undefined) {
fatal = true;
}
this._onError(REMUX_EVENTS.REMUX_ERROR, mod, error, fatal);
@ -124,7 +130,7 @@ class HlsLiveController {
this._onError('M3U8_PARSER_ERROR', 'M3U8_PARSER', error, false);
}
if(!mdata) {
if (!mdata) {
if (this.retrytimes > 0) {
this.retrytimes--;
this._preload();
@ -145,7 +151,7 @@ class HlsLiveController {
this._context.registry('DECRYPT_BUFFER', XgBuffer)();
this._context.registry('KEY_BUFFER', XgBuffer)();
this._tsloader.buffer = 'DECRYPT_BUFFER';
this._keyLoader = this._context.registry('KEY_LOADER', FetchLoader)({buffer:'KEY_BUFFER',readtype: 3});
this._keyLoader = this._context.registry('KEY_LOADER', FetchLoader)({buffer: 'KEY_BUFFER', readtype: 3});
this.emitTo('KEY_LOADER', LOADER_EVENTS.LADER_START, this._playlist.encrypt.uri);
} else {
this._m3u8Loaded(mdata);
@ -154,29 +160,29 @@ class HlsLiveController {
this.retrytimes = this.configs.retrytimes || 3;
this._playlist.downloaded(this._tsloader.url, true);
this.emit(DEMUX_EVENTS.DEMUX_START);
} else if (buffer.TAG === 'DECRYPT_BUFFER') {
} else if (buffer.TAG === 'DECRYPT_BUFFER') {
this.retrytimes = this.configs.retrytimes || 3;
this._playlist.downloaded(this._tsloader.url, true);
this.emitTo('CRYPTO', CRYTO_EVENTS.START_DECRYPT);
} else if (buffer.TAG == 'KEY_BUFFER') {
} else if (buffer.TAG === 'KEY_BUFFER') {
this.retrytimes = this.configs.retrytimes || 3;
this._playlist.encrypt.key = buffer.shift();
this._crypto = this._context.registry('CRYPTO', Crypto)({
key: this._playlist.encrypt.key,
iv: this._playlist.encrypt.ivb,
method: this._playlist.encrypt.method,
inputbuffer:'DECRYPT_BUFFER',
outputbuffer:'TS_BUFFER'
inputbuffer: 'DECRYPT_BUFFER',
outputbuffer: 'TS_BUFFER'
});
this._crypto.on(CRYTO_EVENTS.DECRYPTED, this._onDcripted.bind(this));
}
}
_onDcripted() {
_onDcripted () {
this.emit(DEMUX_EVENTS.DEMUX_START);
}
_m3u8Loaded(mdata) {
_m3u8Loaded (mdata) {
if (!this.preloadTime) {
this.preloadTime = this._playlist.targetduration ? this._playlist.targetduration : 5;
}

3
packages/xgplayer-hls-live/src/index.js
View File

@ -1,6 +1,7 @@
import 'xgplayer-polyfills/babel/external-helpers';
import Player from 'xgplayer'
import { Context, EVENTS } from 'xgplayer-utils';
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Context from 'xgplayer-transmuxer-context';
import HlsLiveController from './hls-live';
const HlsAllowedEvents = EVENTS.HlsAllowedEvents;
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;

5227
packages/xgplayer-hls-vod/dist/index.js vendored
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-hls-vod/dist/index.js.map vendored
View File

File diff suppressed because one or more lines are too long

5227
packages/xgplayer-hls-vod/es/index.js
View File

File diff suppressed because it is too large Load Diff

2
packages/xgplayer-hls-vod/es/index.js.map
View File

File diff suppressed because one or more lines are too long

20
packages/xgplayer-hls-vod/package.json
View File

@ -27,13 +27,21 @@
},
"license": "ISC",
"dependencies": {
"xgplayer-loader": "^2.2.0-alpha.0",
"xgplayer-buffer": "^2.2.0-alpha.0",
"xgplayer-codec": "^2.2.0-alpha.0",
"xgplayer-demux": "^2.2.0-alpha.0",
"xgplayer-remux": "^2.2.0-alpha.0",
"xgplayer-utils": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0"
"xgplayer-utils-crypto": "^2.2.0-alpha.0",
"xgplayer-polyfills": "^2.2.0-alpha.0",
"xgplayer-utils-mse": "^2.2.0-alpha.0",
"xgplayer-transmuxer-constant-events": "^2.2.0-alpha.0",
"xgplayer-transmuxer-context": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-track": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-presource": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-xgbuffer": "^2.2.0-alpha.0",
"xgplayer-transmuxer-loader-fetch": "^2.2.0-alpha.0",
"xgplayer-transmuxer-remux-mp4": "^2.2.0-alpha.0",
"xgplayer-transmuxer-codec-compatibility": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-m3u8": "^2.2.0-alpha.0",
"xgplayer-transmuxer-demux-ts": "^2.2.0-alpha.0",
"xgplayer-transmuxer-buffer-playlist": "^2.2.0-alpha.0"
},
"devDependencies": {
"cross-env": "^6.0.3"

39
packages/xgplayer-hls-vod/src/hls-vod.js
View File

@ -1,10 +1,16 @@
import { EVENTS, Mse, Crypto } from 'xgplayer-utils';
import { XgBuffer, PreSource, Tracks } from 'xgplayer-buffer';
import { FetchLoader } from 'xgplayer-loader';
import { Compatibility } from 'xgplayer-codec';
import Mp4Remuxer from 'xgplayer-remux/src/mp4/index';
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Mse from 'xgplayer-utils-mse'
import Tracks from 'xgplayer-transmuxer-buffer-track'
import PreSource from 'xgplayer-transmuxer-buffer-presource'
import XgBuffer from 'xgplayer-transmuxer-buffer-xgbuffer'
import FetchLoader from 'xgplayer-transmuxer-loader-fetch'
import Compatibility from 'xgplayer-transmuxer-codec-compatibility'
import Mp4Remuxer from 'xgplayer-transmuxer-remux-mp4'
import Crypto from 'xgplayer-utils-crypto';
import {Playlist, M3U8Parser, TsDemuxer} from 'xgplayer-demux';
import M3U8Parser from 'xgplayer-transmuxer-demux-m3u8';
import TsDemuxer from 'xgplayer-transmuxer-demux-ts';
import Playlist from 'xgplayer-transmuxer-buffer-playlist';
const LOADER_EVENTS = EVENTS.LOADER_EVENTS;
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;
@ -62,7 +68,6 @@ class HlsVodController {
this.on(REMUX_EVENTS.MEDIA_SEGMENT, this._onMediaSegment.bind(this));
this.on(DEMUX_EVENTS.METADATA_PARSED, this._onMetadataParsed.bind(this));
this.on(DEMUX_EVENTS.DEMUX_COMPLETE, this._onDemuxComplete.bind(this));
@ -76,7 +81,7 @@ class HlsVodController {
this.on('WAITING', this._onWaiting.bind(this));
}
_onError(type, mod, err, fatal) {
_onError (type, mod, err, fatal) {
let error = {
errorType: type,
errorDetails: `[${mod}]: ${err.message}`,
@ -91,14 +96,14 @@ class HlsVodController {
}
_onDemuxError (mod, error, fatal) {
if(fatal === undefined) {
if (fatal === undefined) {
fatal = true;
}
this._onError(LOADER_EVENTS.LOADER_ERROR, mod, error, fatal);
}
_onRemuxError (mod, error, fatal) {
if(fatal === undefined) {
if (fatal === undefined) {
fatal = true;
}
this._onError(REMUX_EVENTS.REMUX_ERROR, mod, error, fatal);
@ -173,7 +178,7 @@ class HlsVodController {
this._context.registry('DECRYPT_BUFFER', XgBuffer)();
this._context.registry('KEY_BUFFER', XgBuffer)();
this._tsloader.buffer = 'DECRYPT_BUFFER';
this._keyLoader = this._context.registry('KEY_LOADER', FetchLoader)({buffer:'KEY_BUFFER',readtype: 3});
this._keyLoader = this._context.registry('KEY_LOADER', FetchLoader)({buffer: 'KEY_BUFFER', readtype: 3});
this.emitTo('KEY_LOADER', LOADER_EVENTS.LADER_START, this._playlist.encrypt.uri);
} else {
if (!this.preloadTime) {
@ -200,20 +205,20 @@ class HlsVodController {
} else if (buffer.TAG === 'TS_BUFFER') {
this._preload(this.mse.container.currentTime);
this._playlist.downloaded(this._tsloader.url, true);
this.emit(DEMUX_EVENTS.DEMUX_START, Object.assign({url:this._tsloader.url},this._playlist._ts[this._tsloader.url]));
this.emit(DEMUX_EVENTS.DEMUX_START, Object.assign({url: this._tsloader.url}, this._playlist._ts[this._tsloader.url]));
} else if (buffer.TAG === 'DECRYPT_BUFFER') {
this.retrytimes = this.configs.retrytimes || 3;
this._playlist.downloaded(this._tsloader.url, true);
this.emitTo('CRYPTO', CRYTO_EVENTS.START_DECRYPT, Object.assign({url:this._tsloader.url},this._playlist._ts[this._tsloader.url]));
} else if (buffer.TAG == 'KEY_BUFFER') {
this.emitTo('CRYPTO', CRYTO_EVENTS.START_DECRYPT, Object.assign({url: this._tsloader.url}, this._playlist._ts[this._tsloader.url]));
} else if (buffer.TAG === 'KEY_BUFFER') {
this.retrytimes = this.configs.retrytimes || 3;
this._playlist.encrypt.key = buffer.shift();
this._crypto = this._context.registry('CRYPTO', Crypto)({
key: this._playlist.encrypt.key,
iv: this._playlist.encrypt.ivb,
method: this._playlist.encrypt.method,
inputbuffer:'DECRYPT_BUFFER',
outputbuffer:'TS_BUFFER'
inputbuffer: 'DECRYPT_BUFFER',
outputbuffer: 'TS_BUFFER'
});
this._crypto.on(CRYTO_EVENTS.DECRYPTED, this._onDcripted.bind(this));
@ -231,7 +236,7 @@ class HlsVodController {
}
}
_onDcripted() {
_onDcripted () {
this.emit(DEMUX_EVENTS.DEMUX_START);
}

4
packages/xgplayer-hls-vod/src/index.js
View File

@ -1,13 +1,13 @@
import 'xgplayer-polyfills/babel/external-helpers';
import Player from 'xgplayer'
import { Context, EVENTS } from 'xgplayer-utils';
import EVENTS from 'xgplayer-transmuxer-constant-events'
import Context from 'xgplayer-transmuxer-context';
import HlsVodController from './hls-vod';
const HlsAllowedEvents = EVENTS.HlsAllowedEvents;
const REMUX_EVENTS = EVENTS.REMUX_EVENTS;
const HLS_EVENTS = EVENTS.HLS_EVENTS;
let waitTimer = null;
class HlsVodPlayer extends Player {
constructor (options) {
super(options)

3
packages/xgplayer-loader/es/index.js
View File

@ -1,3 +0,0 @@
import _FetchLoader from './fetch-loader';
export var FetchLoader = _FetchLoader;

3
packages/xgplayer-loader/src/index.js
View File

@ -1,3 +0,0 @@
import _FetchLoader from './fetch-loader';
export const FetchLoader = _FetchLoader;

5
packages/xgplayer-remux/es/index.js
View File

@ -1,5 +0,0 @@
import Mp4Remuxer from './mp4';
export default {
Mp4Remuxer: Mp4Remuxer
};

5
packages/xgplayer-remux/src/index.js
View File

@ -1,5 +0,0 @@
import Mp4Remuxer from './mp4'
export default {
Mp4Remuxer
}

0
packages/xgplayer-buffer/.npmignore → packages/xgplayer-transmuxer-buffer-playlist/.npmignore
View File

3
packages/xgplayer-demux/es/hls/playlist.js → packages/xgplayer-transmuxer-buffer-playlist/es/index.js
View File

@ -22,7 +22,7 @@ var Playlist = function () {
downloaded: false,
downloading: false,
start: this.duration,
discontinue: discontinue ? true : false
discontinue: !!discontinue
};
this._list[this.duration] = ts;
this.duration += duration;
@ -53,7 +53,6 @@ var Playlist = function () {
// 常规信息替换
if (!data) {
throw new Error('No m3u8 data received.');
return;
}
this.version = data.version;
this.targetduration = data.targetduration;

25
packages/xgplayer-transmuxer-buffer-playlist/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-buffer-playlist",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

17
packages/xgplayer-demux/src/hls/playlist.js → packages/xgplayer-transmuxer-buffer-playlist/src/index.js
View File

@ -29,11 +29,11 @@ class Playlist {
push (ts, duration, discontinue) {
if (!this._ts[ts]) {
this._ts[ts] = {duration: duration,
downloaded: false,
downloading: false,
start: this.duration,
discontinue: discontinue ? true: false
this._ts[ts] = {duration: duration,
downloaded: false,
downloading: false,
start: this.duration,
discontinue: !!discontinue
};
this._list[this.duration] = ts;
this.duration += duration;
@ -62,11 +62,10 @@ class Playlist {
// 常规信息替换
if (!data) {
throw new Error(`No m3u8 data received.`);
return;
}
this.version = data.version;
this.targetduration = data.targetduration;
if(data.encrypt && !this.encrypt) {
if (data.encrypt && !this.encrypt) {
this.encrypt = data.encrypt;
}
// 新分片信息
@ -81,10 +80,10 @@ class Playlist {
}
}
if(newfraglist.length < 1) {
if (newfraglist.length < 1) {
throw new Error(`Can not read ts file list.`);
}
if (deletepre) {
let tslist = this.getTsList();
for (let i = 0; i < tslist.length; i++) {

0
packages/xgplayer-codec/.npmignore → packages/xgplayer-transmuxer-buffer-presource/.npmignore
View File

0
packages/xgplayer-buffer/es/presouce.js → packages/xgplayer-transmuxer-buffer-presource/es/index.js
View File

25
packages/xgplayer-transmuxer-buffer-presource/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-buffer-presource",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

0
packages/xgplayer-buffer/src/presouce.js → packages/xgplayer-transmuxer-buffer-presource/src/index.js
View File

0
packages/xgplayer-demux/.npmignore → packages/xgplayer-transmuxer-buffer-stream/.npmignore
View File

150
packages/xgplayer-transmuxer-buffer-stream/es/index.js Normal file
View File

@ -0,0 +1,150 @@
var Stream = function () {
function Stream(buffer) {
babelHelpers.classCallCheck(this, Stream);
if (buffer instanceof ArrayBuffer) {
this.buffer = buffer;
this.dataview = new DataView(buffer);
this.dataview.position = 0;
} else {
throw new Error('data is invalid');
}
}
babelHelpers.createClass(Stream, [{
key: 'back',
value: function back(count) {
this.position -= count;
}
}, {
key: 'skip',
value: function skip(count) {
var loop = Math.floor(count / 4);
var last = count % 4;
for (var i = 0; i < loop; i++) {
Stream.readByte(this.dataview, 4);
}
if (last > 0) {
Stream.readByte(this.dataview, last);
}
}
/**
* [readByte 从DataView中读取数据]
* @param {DataView} buffer [DataView实例]
* @param {Number} size [读取字节数]
* @return {Number} [整数]
*/
}, {
key: 'readUint8',
value: function readUint8() {
return Stream.readByte(this.dataview, 1);
}
}, {
key: 'readUint16',
value: function readUint16() {
return Stream.readByte(this.dataview, 2);
}
}, {
key: 'readUint24',
value: function readUint24() {
return Stream.readByte(this.dataview, 3);
}
}, {
key: 'readUint32',
value: function readUint32() {
return Stream.readByte(this.dataview, 4);
}
}, {
key: 'readUint64',
value: function readUint64() {
return Stream.readByte(this.dataview, 8);
}
}, {
key: 'readInt8',
value: function readInt8() {
return Stream.readByte(this.dataview, 1, true);
}
}, {
key: 'readInt16',
value: function readInt16() {
return Stream.readByte(this.dataview, 2, true);
}
}, {
key: 'readInt32',
value: function readInt32() {
return Stream.readByte(this.dataview, 4, true);
}
}, {
key: 'writeUint32',
value: function writeUint32(value) {
return new Uint8Array([value >>> 24 & 0xff, value >>> 16 & 0xff, value >>> 8 & 0xff, value & 0xff]);
}
}, {
key: 'length',
get: function get() {
return this.buffer.byteLength;
}
}, {
key: 'position',
set: function set(value) {
this.dataview.position = value;
},
get: function get() {
return this.dataview.position;
}
}], [{
key: 'readByte',
value: function readByte(buffer, size, sign) {
var res = void 0;
switch (size) {
case 1:
if (sign) {
res = buffer.getInt8(buffer.position);
} else {
res = buffer.getUint8(buffer.position);
}
break;
case 2:
if (sign) {
res = buffer.getInt16(buffer.position);
} else {
res = buffer.getUint16(buffer.position);
}
break;
case 3:
if (sign) {
throw new Error('not supported for readByte 3');
} else {
res = buffer.getUint8(buffer.position) << 16;
res |= buffer.getUint8(buffer.position + 1) << 8;
res |= buffer.getUint8(buffer.position + 2);
}
break;
case 4:
if (sign) {
res = buffer.getInt32(buffer.position);
} else {
res = buffer.getUint32(buffer.position);
}
break;
case 8:
if (sign) {
throw new Error('not supported for readBody 8');
} else {
res = buffer.getUint32(buffer.position) << 32;
res |= buffer.getUint32(buffer.position + 4);
}
break;
default:
res = '';
}
buffer.position += size;
return res;
}
}]);
return Stream;
}();
export default Stream;

25
packages/xgplayer-transmuxer-buffer-stream/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-buffer-stream",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

0
packages/xgplayer-utils/src/write/stream.js → packages/xgplayer-transmuxer-buffer-stream/src/index.js
View File

0
packages/xgplayer-loader/.npmignore → packages/xgplayer-transmuxer-buffer-track/.npmignore
View File

0
packages/xgplayer-buffer/es/Track.js → packages/xgplayer-transmuxer-buffer-track/es/index.js
View File

25
packages/xgplayer-transmuxer-buffer-track/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-buffer-track",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

0
packages/xgplayer-buffer/src/Track.js → packages/xgplayer-transmuxer-buffer-track/src/index.js
View File

0
packages/xgplayer-remux/.npmignore → packages/xgplayer-transmuxer-buffer-xgbuffer/.npmignore
View File

20
packages/xgplayer-buffer/es/buffer.js → packages/xgplayer-transmuxer-buffer-xgbuffer/es/index.js
View File

@ -1,4 +1,4 @@
export var XgBuffer = function () {
var XgBuffer = function () {
/**
* A buffer to store loaded data.
*
@ -141,20 +141,4 @@ export var XgBuffer = function () {
return XgBuffer;
}();
export var RemuxBuffer = function () {
function RemuxBuffer() {
babelHelpers.classCallCheck(this, RemuxBuffer);
this.video = [];
this.audio = [];
}
babelHelpers.createClass(RemuxBuffer, [{
key: "destroy",
value: function destroy() {
this.video = [];
this.audio = [];
}
}]);
return RemuxBuffer;
}();
export default XgBuffer;

25
packages/xgplayer-transmuxer-buffer-xgbuffer/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-buffer-xgbuffer",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

15
packages/xgplayer-buffer/src/buffer.js → packages/xgplayer-transmuxer-buffer-xgbuffer/src/index.js
View File

@ -1,4 +1,4 @@
export class XgBuffer {
class XgBuffer {
/**
* A buffer to store loaded data.
*
@ -119,15 +119,4 @@ export class XgBuffer {
return retInt
}
}
export class RemuxBuffer {
constructor () {
this.video = []
this.audio = []
}
destroy () {
this.video = []
this.audio = []
}
}
export default XgBuffer;

4
packages/xgplayer-transmuxer-codec-aac/.npmignore Normal file
View File

@ -0,0 +1,4 @@
node_modules
yarn.lock
package-lock.json
.DS_Store

0
packages/xgplayer-codec/es/aac/aac-helper.js → packages/xgplayer-transmuxer-codec-aac/es/index.js
View File

25
packages/xgplayer-transmuxer-codec-aac/package.json Normal file
View File

@ -0,0 +1,25 @@
{
"name": "xgplayer-transmuxer-codec-aac",
"version": "2.2.0-alpha.0",
"description": "",
"main": "es/index.js",
"module": "es/index.js",
"scripts": {
"build": "babel src --out-dir es"
},
"author": "",
"license": "ISC",
"babel": {
"presets": [
[
"es2015",
{
"modules": false
}
]
],
"plugins": [
"external-helpers"
]
}
}

6
packages/xgplayer-codec/src/aac/aac-helper.js → packages/xgplayer-transmuxer-codec-aac/src/index.js
View File

@ -1,7 +1,5 @@
class AAC {
static getSilentFrame(codec, channelCount) {
static getSilentFrame (codec, channelCount) {
if (codec === 'mp4a.40.2') {
// handle LC-AAC
if (channelCount === 1) {
@ -32,7 +30,5 @@ class AAC {
}
return null;
}
}
export default AAC;

4
packages/xgplayer-transmuxer-codec-compatibility/.npmignore Normal file
View File

@ -0,0 +1,4 @@
node_modules
yarn.lock
package-lock.json
.DS_Store

7
packages/xgplayer-codec/es/compatibility.js → packages/xgplayer-transmuxer-codec-compatibility/es/index.js
View File

@ -1,8 +1,7 @@
import { EVENTS } from 'xgplayer-utils';
import AAC from './aac/aac-helper';
import EVENTS from 'xgplayer-transmuxer-constant-events';
import AAC from 'xgplayer-transmuxer-codec-aac';
var REMUX_EVENTS = EVENTS.REMUX_EVENTS,
LOADER_EVENTS = EVENTS.LOADER_EVENTS;
var REMUX_EVENTS = EVENTS.REMUX_EVENTS;
var Compatibility = function () {
function Compatibility() {

Some files were not shown because too many files have changed in this diff Show More