@jxstjh/jhvideo
Version:
HTML5 jhvideo base on MPEG2-TS Stream Player
298 lines • 12.4 kB
JavaScript
/*
* Copyright (C) 2016 Bilibili. All Rights Reserved.
*
* @author zheng qian <xqq@xqq.im>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import EventEmitter from 'events';
import work from 'webworkify-webpack';
import Log from '../utils/logger.js';
import LoggingControl from '../utils/logging-control.js';
import TransmuxingController from './transmuxing-controller.js';
import TransmuxingEvents from './transmuxing-events.js';
import TransmuxingWorker from './transmuxing-worker.js';
import MediaInfo from './media-info.js';
var Transmuxer = /** @class */ (function () {
function Transmuxer(mediaDataSource, config) {
this.TAG = 'Transmuxer';
this._emitter = new EventEmitter();
if (config.enableWorker && typeof (Worker) !== 'undefined') {
try {
this._worker = work(require.resolve('./transmuxing-worker'));
this._workerDestroying = false;
this._worker.addEventListener('message', this._onWorkerMessage.bind(this));
this._worker.postMessage({ cmd: 'init', param: [mediaDataSource, config] });
this.e = {
onLoggingConfigChanged: this._onLoggingConfigChanged.bind(this)
};
LoggingControl.registerListener(this.e.onLoggingConfigChanged);
this._worker.postMessage({ cmd: 'logging_config', param: LoggingControl.getConfig() });
}
catch (error) {
Log.e(this.TAG, 'Error while initialize transmuxing worker, fallback to inline transmuxing');
this._worker = null;
this._controller = new TransmuxingController(mediaDataSource, config);
}
}
else {
this._controller = new TransmuxingController(mediaDataSource, config);
}
if (this._controller) {
var ctl = this._controller;
ctl.on(TransmuxingEvents.IO_ERROR, this._onIOError.bind(this));
ctl.on(TransmuxingEvents.DEMUX_ERROR, this._onDemuxError.bind(this));
ctl.on(TransmuxingEvents.INIT_SEGMENT, this._onInitSegment.bind(this));
ctl.on(TransmuxingEvents.MEDIA_SEGMENT, this._onMediaSegment.bind(this));
ctl.on(TransmuxingEvents.LOADING_COMPLETE, this._onLoadingComplete.bind(this));
ctl.on(TransmuxingEvents.RECOVERED_EARLY_EOF, this._onRecoveredEarlyEof.bind(this));
ctl.on(TransmuxingEvents.MEDIA_INFO, this._onMediaInfo.bind(this));
ctl.on(TransmuxingEvents.METADATA_ARRIVED, this._onMetaDataArrived.bind(this));
ctl.on(TransmuxingEvents.SCRIPTDATA_ARRIVED, this._onScriptDataArrived.bind(this));
ctl.on(TransmuxingEvents.PES_PRIVATE_DATA_DESCRIPTOR, this._onPESPrivateDataDescriptor.bind(this));
ctl.on(TransmuxingEvents.PES_PRIVATE_DATA_ARRIVED, this._onPESPrivateDataArrived.bind(this));
ctl.on(TransmuxingEvents.STATISTICS_INFO, this._onStatisticsInfo.bind(this));
ctl.on(TransmuxingEvents.RECOMMEND_SEEKPOINT, this._onRecommendSeekpoint.bind(this));
ctl.on(TransmuxingEvents.JSON_INFORMATION, this._onInformationJSON.bind(this));
ctl.on(TransmuxingEvents.ESDATA_ARRIVED, this._onEsDataArrived.bind(this));
ctl.on(TransmuxingEvents.ESSCRIPTDATA_ARRIVED, this._onEsScriptDataArrived.bind(this));
}
}
Transmuxer.prototype.destroy = function () {
if (this._worker) {
if (!this._workerDestroying) {
this._workerDestroying = true;
this._worker.postMessage({ cmd: 'destroy' });
LoggingControl.removeListener(this.e.onLoggingConfigChanged);
this.e = null;
}
}
else {
this._controller.destroy();
this._controller = null;
}
this._emitter.removeAllListeners();
this._emitter = null;
};
Transmuxer.prototype.on = function (event, listener) {
this._emitter.addListener(event, listener);
};
Transmuxer.prototype.off = function (event, listener) {
this._emitter.removeListener(event, listener);
};
Transmuxer.prototype.hasWorker = function () {
return this._worker != null;
};
Transmuxer.prototype.open = function () {
if (this._worker) {
this._worker.postMessage({ cmd: 'start' });
}
else {
this._controller.start();
}
};
Transmuxer.prototype.close = function () {
if (this._worker) {
this._worker.postMessage({ cmd: 'stop' });
}
else {
this._controller.stop();
}
};
Transmuxer.prototype.seek = function (milliseconds) {
if (this._worker) {
this._worker.postMessage({ cmd: 'seek', param: milliseconds });
}
else {
this._controller.seek(milliseconds);
}
};
Transmuxer.prototype.pause = function () {
if (this._worker) {
this._worker.postMessage({ cmd: 'pause' });
}
else {
this._controller.pause();
}
};
Transmuxer.prototype.resume = function () {
if (this._worker) {
this._worker.postMessage({ cmd: 'resume' });
}
else {
this._controller.resume();
}
};
// inputData(chunk, byteStart, receivedLength) {
// if (this._worker) {
// this._worker.postMessage({ cmd: 'input', param: [chunk, byteStart, receivedLength] })
// } else {
// this._controller._ioctl._onLoaderChunkArrival(chunk, byteStart, receivedLength)
// }
// }
Transmuxer.prototype._onInitSegment = function (type, initSegment) {
var _this = this;
// do async invoke
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.INIT_SEGMENT, type, initSegment);
});
};
Transmuxer.prototype._onMediaSegment = function (type, mediaSegment) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.MEDIA_SEGMENT, type, mediaSegment);
});
};
Transmuxer.prototype._onLoadingComplete = function () {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.LOADING_COMPLETE);
});
};
Transmuxer.prototype._onRecoveredEarlyEof = function () {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.RECOVERED_EARLY_EOF);
});
};
Transmuxer.prototype._onMediaInfo = function (mediaInfo) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.MEDIA_INFO, mediaInfo);
});
};
Transmuxer.prototype._onMetaDataArrived = function (metadata) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.METADATA_ARRIVED, metadata);
});
};
// h265
Transmuxer.prototype._onEsDataArrived = function (e, t) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.ESDATA_ARRIVED, e, t);
});
};
Transmuxer.prototype._onEsScriptDataArrived = function (e) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.ESSCRIPTDATA_ARRIVED, e);
});
};
Transmuxer.prototype._onScriptDataArrived = function (data) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.SCRIPTDATA_ARRIVED, data);
});
};
Transmuxer.prototype._onPESPrivateDataDescriptor = function (data) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.PES_PRIVATE_DATA_DESCRIPTOR, data);
});
};
Transmuxer.prototype._onPESPrivateDataArrived = function (data) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.PES_PRIVATE_DATA_ARRIVED, data);
});
};
Transmuxer.prototype._onStatisticsInfo = function (statisticsInfo) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.STATISTICS_INFO, statisticsInfo);
});
};
Transmuxer.prototype._onIOError = function (type, info) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.IO_ERROR, type, info);
});
};
Transmuxer.prototype._onDemuxError = function (type, info) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.DEMUX_ERROR, type, info);
});
};
Transmuxer.prototype._onRecommendSeekpoint = function (milliseconds) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.RECOMMEND_SEEKPOINT, milliseconds);
});
};
Transmuxer.prototype._onInformationJSON = function (type, info) {
var _this = this;
Promise.resolve().then(function () {
_this._emitter.emit(TransmuxingEvents.JSON_INFORMATION, type, info);
});
};
Transmuxer.prototype._onLoggingConfigChanged = function (config) {
if (this._worker) {
this._worker.postMessage({ cmd: 'logging_config', param: config });
}
};
Transmuxer.prototype._onWorkerMessage = function (e) {
var message = e.data;
var data = message.data;
if (message.msg === 'destroyed' || this._workerDestroying) {
this._workerDestroying = false;
this._worker.terminate();
this._worker = null;
return;
}
switch (message.msg) {
case TransmuxingEvents.INIT_SEGMENT:
case TransmuxingEvents.MEDIA_SEGMENT:
this._emitter.emit(message.msg, data.type, data.data);
break;
case TransmuxingEvents.LOADING_COMPLETE:
case TransmuxingEvents.RECOVERED_EARLY_EOF:
this._emitter.emit(message.msg);
break;
case TransmuxingEvents.MEDIA_INFO:
Object.setPrototypeOf(data, MediaInfo.prototype);
this._emitter.emit(message.msg, data);
break;
case TransmuxingEvents.METADATA_ARRIVED:
case TransmuxingEvents.SCRIPTDATA_ARRIVED:
case TransmuxingEvents.PES_PRIVATE_DATA_DESCRIPTOR:
case TransmuxingEvents.PES_PRIVATE_DATA_ARRIVED:
case TransmuxingEvents.STATISTICS_INFO:
this._emitter.emit(message.msg, data);
break;
case TransmuxingEvents.IO_ERROR:
case TransmuxingEvents.DEMUX_ERROR:
this._emitter.emit(message.msg, data.type, data.info);
break;
case TransmuxingEvents.RECOMMEND_SEEKPOINT:
this._emitter.emit(message.msg, data);
break;
case TransmuxingEvents.ESDATA_ARRIVED:
this._emitter.emit(message.msg, data.type, data.data);
break;
case TransmuxingEvents.ESSCRIPTDATA_ARRIVED:
this._emitter.emit(message.msg, data);
break;
case 'logcat_callback':
Log.emitter.emit('log', data.type, data.logcat);
break;
default:
break;
}
};
return Transmuxer;
}());
export default Transmuxer;
//# sourceMappingURL=transmuxer.js.map