zhui-plus 1.0.0 → 1.0.10

package/dist/WSPlayer/singleThread/VideoDecodeWorker.js

@@ -0,0 +1,1439 @@
+let SDKModule;
+
+const VIDEO_FRAME_SUB_TYPE_I = 0;					//I帧
+const VIDEO_FRAME_SUB_TYPE_P = 1;					//P帧
+const VIDEO_FRAME_SUB_TYPE_B = 2;					//B帧
+const VIDEO_FRAME_SUB_TYPE_SMART_I = 18;			//智能I帧
+const VIDEO_FRAME_SUB_TYPE_SMART_P = 19;			//智能P帧
+const VIDEO_FRAME_SUB_TYPE_SMART_I_NORENDER = 20;	//智能I帧，但不显示
+
+const ENCODE_TYPE_VIDEO_HI_H264 = 2;	//海思H.264编码格式
+const ENCODE_TYPE_VIDEO_MY_H264 = 4;	//公司H.264编码格式
+const ENCODE_TYPE_VIDEO_STD_H264 = 8;	//标准H.264编码格式
+const ENCODE_TYPE_VIDEO_H265 = 12;		//H.265编码格式
+
+const DATA_RECORD_MP4 = 5;				//录制MP4格式
+
+const SP_STREAM_TYPE_DHSTD = 8;			//dav编码格式
+const STREAM_TYPE_SVC = 13;				//H.264 SVC编码格式
+const SP_STREAM_TYPE_FLV = 18;			//flv编码格式
+
+const ENCRYPT_UNKOWN = 0;				//未知加密类型
+const ENCRYPT_AES = 1;					
+const ENCRYPT_AES256 = 2;				
+const ENCRYPT_AES256_GDPR2 = 3;			
+const ENCRYPT_AES_STRING_FORMAT = 16;	
+
+const CACHE_MODE_OFF = 0;				//关闭实时流自适应缓冲模式
+const ADAPTIVE_CACHE = 1;				//自适应缓冲
+const REALTIME_FIRST = 2;				//实时优先
+const FLUENCY_FIRST = 3;				//流畅优先 
+const FRAME_SCENE_POINTS_INFOR_SIZE = 144;          // 景物点信息单组信息长度
+/* IVS类型 */
+var IVS_TYPE =
+{
+	IVSINFOTYPE_PRESETPOS			: 1,						
+	IVSINFOTYPE_MOTINTRKS			: 2,				
+	IVSINFOTYPE_MOTINTRKS_EX		: 3,			
+	IVSINFOTYPE_LIGHT				: 4,   // 光照		
+	IVSINFOTYPE_RAWDATA				: 5,   // jason数据
+	IVSINFOTYPE_TRACK				: 6,   // 智能分析信息 
+	IVSINFOTYPE_TRACK_EX_B0			: 7,   // 智能结构化数据信息
+	IVSINFOTYPE_MOTIONFRAME			: 9,	
+	IVSINFOTYPE_VIDEO_CONCENTRATION : 10,
+	IVSINFOTYPE_OVERLAY_PIC			: 11,	// 叠加图片帧
+	IVSINFOTYPE_OSD_INFO			: 12,	// OSD辅助帧
+	IVSINFOTYPE_GPS_INFO			: 13,   // GPS辅助帧
+	IVSINFOTYPE_TAGGING_INFO		: 14,   // 景物点信息标注帧，辅助帧(0x13)
+	IVSINFOTYPE_TRACK_A1			: 15,   // NVR浓缩信息轨迹点
+	IVSINFOTYPE_DATA_WITH_LARGE_AMOUNT : 16,
+    IVSINFOTYPE_TRACK_A1_EX         : 17,   // NVR浓缩信息轨迹点(扩展)
+	IVSINFOTYPE_DATA_WITH_WATER_LEVEL_MONITOR : 18, //水位检测水位尺信息帧(0x17)
+	IVSINFOTYPE_INTELFLOW			: 19,   // 智能客流量
+	IVSINFOTYPE_DATA_WITH_SOUND_DECIBEL : 20,		//声音警报分贝值信息帧(0x18)
+	IVSINFOTYPE_DATA_WITH_SMART_MOTION : 21,		//智能动检信息帧(0x19)
+	IVSINFOTYPE_DHOP_SMART			: 22,			//开放平台智能帧(0x14)
+	IVSINFOTYPE_TRAFFIC_LIGHT		: 23,			//交通信号灯(红绿灯)辅助帧(0x1D)
+	IVSINFOTYPE_PTZ_LOCATION		: 24,       	//云台位置帧(0x21)
+};
+
+var DRAW_TYPE = 
+{
+	DRAW_JSON : 0,
+	DRAW_TRACK : 1,
+	DRAW_ALARM : 2,
+	DRAW_RULE : 3,
+	DRAW_MOVE_CHECK : 7,
+	DRAW_TEST : 9,
+	DRAW_WEB_RULE : 11,
+	DRAW_WEB_ALARM : 12,
+	DRAW_FLOW_INFO : 13,
+	DRAW_TRACKEX2 : 14,
+	DRAW_WUXI235_TRACKEX2 : 15,
+	DRAW_TRACKEXA1 : 16,
+	DRAW_TRACKEX2_TYPE_HUMAN : 17,
+	DRAW_TRACKEX2_TYPE_VEHICLE : 18,
+	DRAW_TRACKEX2_TYPE_NONMOTOR : 19,
+	DRAW_TRACKEX2_TYPE_SHOPPRESENCE : 20, 
+	DRAW_TRACKEX2_TYPE_FLOWBUSINESS : 21,
+	DRAW_INTELFLOW : 22,
+	DRAW_SMARTMOTION : 23,
+	DRAW_DHOPSMART : 24,
+	DRAW_DATA_WITH_LARGE_AMOUNT : 25,//大数据量帧
+	DRAW_TRACKEX2_TYPE_BAG : 26,
+	DRAW_RULE_HIGHWAY_LANES : 27,			//高速车道线
+	DRAW_WATER_LEVEL_MONITOR : 28,			//水位尺
+	DRAW_END : 29
+};
+
+//DHOP元素类型
+var IVS_DHOP_ElEMENT_TYPE = 
+{
+	EM_DHOP_CIRCLE : 1,
+	EM_DHOP_BrokenLine : 2,
+	EM_DHOP_POLYGON : 3,
+	EM_DHOP_TEXT : 4
+};
+
+importScripts('libplay.js');
+
+addEventListener('message', receiveMessage, false);	
+
+Module.onRuntimeInitialized = function(){
+	m_bLoadSuccess = true;
+	var msgType = 'LoadSuccess';
+	sendMessage(m_nPlayPort, msgType, null);
+}
+
+var m_bPlayback = 0;
+var m_bSupportH264MSE = false;
+var m_bSupportH265MSE = false;
+var m_nCanvasWidth = 1920;
+var m_nCanvasHeight = 1080;
+var m_nPlayPort = 0;
+
+var jsInputData = null;
+var jsInputDataAry = null;
+
+var jsFrameBuf = null;
+var jsFrameInfo = null;
+let dataView = null;
+
+var jsBuf = null;
+var jsFrameBodyData = null;
+
+var jsBufY = null;
+var jsBufU = null;
+var jsBufV = null;
+var jsYuvDataY = null;
+var jsYuvDataU = null;
+var jsYuvDataV = null;
+
+var jsRecordFrameBuf = null;
+var	jsRecordFrameInfo = null;
+var	dataViewRecord = null;
+
+let ivsBuf = null;
+let ivsDataArray = null;
+let ivsDataView = null;
+
+let m_arrayDemuxBuf = null;
+let m_uintDemuxInfo = null;
+let m_dvDemuxInfo = null;
+
+var m_nWidth = 0;
+var m_nHeight = 0;
+var m_nPreWidth = 0;
+var m_nPreHeight = 0;
+
+var m_bSmartEncode = 0;
+var m_nVideoEncodeType = 0;
+
+var m_bLoadSuccess = false;
+
+var m_bDecryptionResult = false;
+
+function receiveMessage(event) 
+{
+	if (!m_bLoadSuccess)
+	{
+		return;
+	}
+	var message = event.data;
+	switch (message.nType) 
+	{
+		//初始化
+        case 'Init':
+			m_bPlayback = message.option.bPlayback;
+			m_bSupportH264MSE = message.option.bSupportH264MSE;
+			m_bSupportH265MSE = message.option.bSupportH265MSE;
+			m_nCanvasWidth = message.option.nCanvasWidth;
+			m_nCanvasHeight = message.option.nCanvasHeight;
+			Init();
+            break;
+        //送流
+		case 'InputData':
+			InputData(message.pData);
+            break;
+		//打开智能绘制
+		case 'OpenIVSDraw':
+			OpenIVSDraw();
+            break;
+		//关闭智能绘制
+		case 'CloseIVSDraw':
+			CloseIVSDraw();
+            break;
+		//开始码流录制
+		case 'StartRecord':
+			StartRecord(message.nRecordType, message.nFileSize, message.bSegment);
+            break;
+		//停止码流录制
+		case 'StopRecord':
+		case 'CancelRecord':
+			StopRecord();
+            break;
+		//设置播放速度
+		case 'SetPlaySpeed':
+			SetPlaySpeed(message.nSpeed);
+            break;
+		//设置OSD叠加
+		case 'SetYUVOSDInfoEx':
+			SetYUVOSDInfoEx(message.OSDInfo);
+			break;
+		case 'GetOriginalKeyCallBack':
+			GetOriginalKey(message.playToken, message.playTokenKey, message.deviceID);
+		case 'SetPlayTokenToDecrypt':
+			SetPlayTokenToDecrypt(message.playToken, message.keySalt, message.deviceID);
+            break;
+		case 'SetWebSecurityKey':
+			SetWebSecurityKey(message.nDecryptType, message.nFrameType, message.strKey, message.stStreamInfo);
+            break;
+		//设置解密秘钥
+		case 'SetSecurityKey':
+			SetSecurityKey(message.nEncryptType, message.szKey, message.nKeyLen, message.szKeyId, message.nKeyIdLen);
+            break;
+		//设置解密秘钥
+		case 'SetSecurityKeyEx':
+			SetSecurityKeyEx(message.nEncryptType, message.stDecryptKey);
+            break;
+		//设置是否支持硬解码标记
+		case 'SetSupportWebMSE':
+			m_bSupportH264MSE = message.bSupportH264MSE;
+			m_bSupportH265MSE = message.bSupportH265MSE;
+			SetSupportWebMSE(m_bSupportH264MSE, m_bSupportH265MSE);
+		//暂停播放
+		case 'Pause':
+			Pause(message.bPause);
+            break;
+		//抓图
+		case 'CatchPic':
+			CatchPic();
+            break;
+		//停止播放
+		case 'Stop':
+			Stop();
+            break;
+		case 'setPrintLogLevel':
+			SetPrintLogLevel(message.nLogLevel);
+			break;
+		case 'SetInt32':
+			SetInt32(message.nSetType, message.nValue);
+			break;
+		case 'InputAudioData':
+			InputAudioData(message.audioData);
+			break;
+		case 'SetPrivacyRecover':
+			SetPrivacyRecover(message.bRecover);
+			break;
+        default:
+            break;
+    }
+}
+
+function Init() 
+{
+	//获取PlaySDK空闲端口号
+	var jsPort = Module._malloc(1);
+	var jsPortAry = new Uint8Array(Module.HEAPU8.buffer, jsPort, 1);
+	Module._PLAY_GetFreePort(jsPortAry.byteOffset);
+	m_nPlayPort = jsPortAry[0];
+	jsPortAry = null;
+	Module._free(jsPort);
+	
+	//设置播放窗口宽高属性
+	Module._PLAY_ViewResolutionChanged(m_nPlayPort, m_nCanvasWidth, m_nCanvasHeight, 0);
+	
+	//设置实时流模式
+	var nRet = Module._PLAY_SetStreamOpenMode(m_nPlayPort, m_bPlayback);
+	nRet = Module._PLAY_OpenStream(m_nPlayPort, 0, 0, 10*1024*1024);
+	
+	nRet = Module._PLAY_SetSupportWebMSE(m_nPlayPort, m_bSupportH264MSE, m_bSupportH265MSE);
+	
+	nRet = Module._PLAY_Play(m_nPlayPort, 1);
+	if (nRet)
+	{
+		//向C++层申请一块wasm内存，用于接收码流
+		jsInputData = Module._malloc(5*1024*1024);
+		jsInputDataAry = new Uint8Array(Module.HEAPU8.buffer, jsInputData, 5*1024*1024);
+		
+		var msgType = 'InitSuccess';
+		sendMessage(m_nPlayPort, msgType, null);
+	}
+}
+
+function InputData(data) 
+{
+	if(jsInputDataAry) 
+	{
+		jsInputDataAry.set(data);
+		var nRet = Module._PLAY_InputData(m_nPlayPort, jsInputDataAry.byteOffset, data.length); 
+		var i = 0;
+	}
+
+	var msgType = 'WorkerReceivedData';
+	var msgData =  
+	{	
+		nLength: data.length
+	}
+	
+	sendMessage(m_nPlayPort, msgType, msgData);
+}
+
+function OpenIVSDraw() 
+{
+	Module._PLAY_RenderPrivateData(m_nPlayPort, 1, 0);
+}
+
+function CloseIVSDraw() 
+{
+	Module._PLAY_RenderPrivateData(m_nPlayPort, 0, 0);
+}
+
+function StartRecord(nRecordType, nFileSize, bSegment) 
+{
+	if (bSegment)
+	{
+		Module._PLAY_SetSegmentRecordData(m_nPlayPort, nFileSize, null, null);
+	}
+	Module._PLAY_StartDataRecord(m_nPlayPort, 0, nRecordType);
+}
+
+function StopRecord() 
+{
+	Module._PLAY_StopDataRecord(m_nPlayPort);
+}
+
+function SetPlaySpeed(nSpeed)
+{
+	Module._PLAY_SetPlaySpeed(m_nPlayPort, nSpeed);
+}
+
+function SetYUVOSDInfoEx(OSDInfo)
+{
+	if (0 == m_nCanvasWidth || 0 == m_nCanvasHeight)
+	{
+		return;
+	}
+	
+	let nOsdCount = OSDInfo.osdCount;
+	let nStuOsdInfoSize = 18376;//单个YUV_OSD_INFO_EX结构体18376字节
+	const OsdDataInfoPtr = Module._malloc(nStuOsdInfoSize);
+	let arrayFormat = new Uint8Array(Module.HEAPU8.buffer);
+	for (let i = 0; i < nStuOsdInfoSize; i ++)
+	{
+		arrayFormat[OsdDataInfoPtr + i] = 0;
+	}
+	
+	Module.HEAPU8[OsdDataInfoPtr + 0] = 1;//是否是私有字体 
+	let strFontPath = "Font.bin";
+	let nSequence = 0;
+	strFontPath.split('').forEach((char, nIndex) => 
+	{
+		let nValue = char.charCodeAt(0);
+		arrayFormat[OsdDataInfoPtr + nSequence + 1] = nValue;
+		nSequence++;
+	});
+	
+	Module.HEAP32[OsdDataInfoPtr/4 + 65] = nOsdCount;
+	for (let i = 0; i < nOsdCount; i ++)
+	{
+		let nPointX = OSDInfo.osdList[i].pointX / m_nCanvasWidth * m_nWidth;
+		let nPointY = OSDInfo.osdList[i].pointY / m_nCanvasHeight * m_nHeight;
+		
+		Module.HEAP32[OsdDataInfoPtr/4 + 66 + 564/4 * i] = nPointX;// 旋转点像素x位置
+		Module.HEAP32[OsdDataInfoPtr/4 + 67 + 564/4 * i] = nPointY;// 旋转点像素y位置
+		Module.HEAP32[OsdDataInfoPtr/4 + 68 + 564/4 * i] = OSDInfo.osdList[i].colorR;// osd叠加颜色r，范围0-255
+		Module.HEAP32[OsdDataInfoPtr/4 + 69 + 564/4 * i] = OSDInfo.osdList[i].colorG;// osd叠加颜色g，范围0-255
+		Module.HEAP32[OsdDataInfoPtr/4 + 70 + 564/4 * i] = OSDInfo.osdList[i].colorB;// osd叠加颜色b，范围0-255
+		Module.HEAP32[OsdDataInfoPtr/4 + 71 + 564/4 * i] = OSDInfo.osdList[i].colorA;// osd叠加透明度，范围0-255
+		
+		nSequence = 0;
+		//JS默认采用UTF-16编码，需要先转为UTF-8编码
+		let UTF8Array = UTF16ToUTF8(OSDInfo.osdList[i].strOsdData);
+		for(let j = 0; j < UTF8Array.length; j++)
+		{
+			arrayFormat[(OsdDataInfoPtr + nSequence + 288 + 564 * i) >> 0] = UTF8Array[j];// osd数据，使用utf-8编码
+			nSequence++;
+		}
+		
+		Module.HEAP32[OsdDataInfoPtr/4 + 200 + 564/4 * i] = OSDInfo.osdList[i].fontX;// 字体宽度, 使用私有字体时无效
+		Module.HEAP32[OsdDataInfoPtr/4 + 201 + 564/4 * i] = OSDInfo.osdList[i].fontY;// 字体高度, 最大512
+		Module.HEAP32[OsdDataInfoPtr/4 + 202 + 564/4 * i] = OSDInfo.osdList[i].rotateAngle;// 旋转角度，范围0-359度
+		Module.HEAPU8[OsdDataInfoPtr + 812 + 564 * i] = OSDInfo.osdList[i].coordinate8192;// 8192坐标系, 0表示像素坐标x,y基于码流分辨率, 1表示基于8192坐标系	
+	}
+	Module._PLAY_SetYUVOSDInfoEx(m_nPlayPort, OsdDataInfoPtr);
+	
+	Module._free(OsdDataInfoPtr);
+}
+
+function GetOriginalKey(playToken, playTokenKey, deviceID)
+{
+	var arrPlayToken = Module.intArrayFromString(playToken).concat(0);//add '\0'
+	var playTokenPtr = Module._malloc(arrPlayToken.length);//采用声明的c函数 _malloc
+	Module.HEAPU8.set(arrPlayToken, playTokenPtr);//复制字符串内容
+	
+	var arrPlayTokenKey = Module.intArrayFromString(playTokenKey).concat(0);
+	var playTokenKeyPtr = Module._malloc(arrPlayTokenKey.length);
+	Module.HEAPU8.set(arrPlayTokenKey, playTokenKeyPtr);
+	
+	var arrDeviceID = Module.intArrayFromString(deviceID).concat(0); 
+	var deviceIDPtr = Module._malloc(arrDeviceID.length);  
+	Module.HEAPU8.set(arrDeviceID, deviceIDPtr); 
+
+	var outKeyPtr = Module._malloc(256);
+	var outKeyLengthPtr = Module._malloc(4);	
+
+	var nRet = Module._PLAY_GetOriginalKey(m_nPlayPort, playTokenPtr, playTokenKeyPtr, deviceIDPtr, outKeyPtr, outKeyLengthPtr);
+	
+	var outKeyLength = Module.HEAP32[outKeyLengthPtr >>2];
+	var outKeyTmp = "";
+	
+	if ((1 == nRet) && (outKeyLength <= 256))
+	{
+		var jsKeyBuf = new ArrayBuffer(outKeyLength);
+		var jsKeyData = new Uint8Array(jsKeyBuf);
+		jsKeyData.set(Module.HEAPU8.subarray(outKeyPtr, outKeyPtr + outKeyLength));
+		outKeyTmp = ArrayBufferToString(jsKeyBuf);
+	}
+	
+	Module._free(playTokenPtr);//释放内存
+	Module._free(playTokenKeyPtr);
+	Module._free(deviceIDPtr);
+	Module._free(outKeyPtr);
+	Module._free(outKeyLengthPtr);
+	
+	var outKeyParam = 
+	{
+		nRet: nRet, 
+		outKey: outKeyTmp,
+	};
+	
+	var msgType = 'GetOriginalKeyCallBack';
+	var msgData =  
+	{	
+		nRet: nRet,
+		outKey: outKeyTmp,
+	}
+	
+	sendMessage(m_nPlayPort, msgType, msgData);
+}
+
+function SetPlayTokenToDecrypt(playToken, keySalt, deviceID)
+{
+	var arrPlayToken = Module.intArrayFromString(playToken).concat(0);
+	var playTokenPtr = Module._malloc(arrPlayToken.length);
+	Module.HEAPU8.set(arrPlayToken, playTokenPtr);
+	
+	var arrKeySalt = Module.intArrayFromString(keySalt).concat(0);
+	var keySaltPtr = Module._malloc(arrKeySalt.length);
+	Module.HEAPU8.set(arrKeySalt, keySaltPtr);
+	
+	var arrDeviceID = Module.intArrayFromString(deviceID).concat(0); 
+	var deviceIDPtr = Module._malloc(arrDeviceID.length);  
+	Module.HEAPU8.set(arrDeviceID, deviceIDPtr); 
+
+	var nRet = Module._PLAY_SetPlayTokenToDecrypt(m_nPlayPort, playTokenPtr, keySaltPtr, deviceIDPtr);
+	
+	Module._free(playTokenPtr);
+	Module._free(keySaltPtr);
+	Module._free(deviceIDPtr);
+	
+	var msgType = 'PlayTokenDecryptResult';
+	var msgData = nRet; 
+	
+	sendMessage(m_nPlayPort, msgType, msgData);
+}
+
+function SetWebSecurityKey(nDecryptType, nFrameType, strKey, stStreamInfo)
+{
+	var arrStrKey = Module.intArrayFromString(strKey).concat(0);
+	var strKeyPtr = Module._malloc(arrStrKey.length);
+	Module.HEAPU8.set(arrStrKey, strKeyPtr);	
+	
+	var arrSdpInfo = Module.intArrayFromString(stStreamInfo.sdpInfo).concat(0); 
+	var sdpInfoPtr = Module._malloc(arrSdpInfo.length);  
+	Module.HEAPU8.set(arrSdpInfo, sdpInfoPtr);  
+
+	var arrUserName = Module.intArrayFromString(stStreamInfo.strUserName).concat(0); 
+	var userNamePtr = Module._malloc(arrUserName.length);  
+	Module.HEAPU8.set(arrUserName, userNamePtr); 		
+
+	var arrPassWord = Module.intArrayFromString(stStreamInfo.strPassWord).concat(0); 
+	var passWordPtr = Module._malloc(arrPassWord.length);  
+	Module.HEAPU8.set(arrPassWord, passWordPtr);   
+
+	const stStreamInfoPtr = Module._malloc(16);//4:uint32的字节大小  	
+	Module.HEAP32[stStreamInfoPtr/4 + 0] = sdpInfoPtr; 
+    Module.HEAP32[stStreamInfoPtr/4 + 1] = userNamePtr;  
+    Module.HEAP32[stStreamInfoPtr/4 + 2] = passWordPtr; 
+    Module.HEAP32[stStreamInfoPtr/4 + 3] = stStreamInfo.nSsrc; 
+	
+	Module._PLAY_SetWebSecurityKey(m_nPlayPort, nDecryptType, nFrameType, strKeyPtr, stStreamInfoPtr);
+	
+	Module._free(strKeyPtr);//释放内存
+	Module._free(sdpInfoPtr);
+	Module._free(userNamePtr);
+	Module._free(passWordPtr);
+	Module._free(stStreamInfoPtr);
+}
+
+function SetSecurityKey(nEncryptType, szKey, nKeyLen, szKeyId, nKeyIdLen)
+{
+	var nRet = 1;
+	
+	var strKey = Module._malloc(49);
+	var arrayKey = new Uint8Array(Module.HEAPU8.buffer);
+	var nSequence = 0;
+	
+	if (ENCRYPT_AES == nEncryptType)
+	{
+		//逐字节的形式去内存中设置值，直接修改wasm内存数据
+		szKey.forEach((value, nIndex) => {
+			arrayKey[(strKey + nSequence) >> 0] = value;
+			nSequence++;
+		});
+	}
+	else if(ENCRYPT_AES256 == nEncryptType)
+	{
+		var szKeyIdTmp = new Uint8Array(16); ;
+
+		//协议规定ENCRYPT_AES256对应的枚举值为1
+		arrayKey[(strKey + nSequence) >> 0] = 1;
+		nSequence++;
+		if (0 == nKeyIdLen)
+		{
+			for(var i = 0; i < 16; i++)
+			{
+				szKeyIdTmp[i] = 0x00;
+			}
+			nKeyIdLen = 16;
+			szKeyId = szKeyIdTmp;
+		}
+		
+		//拼接上key ID，逐字节的形式去内存中设置值，直接修改wasm内存数据
+		szKeyId.forEach((value, nIndex) => {
+			arrayKey[(strKey + nSequence) >> 0] = value;
+			nSequence++;
+		});
+		
+		//拼接上key，逐字节的形式去内存中设置值，直接修改wasm内存数据
+		szKey.forEach((value, nIndex) => {
+			arrayKey[strKey + nSequence] = value;
+			nSequence++;
+		});
+		
+		nKeyLen = 1 + nKeyLen + nKeyIdLen;
+		szKeyIdTmp = null;
+	}
+	else if(ENCRYPT_AES_STRING_FORMAT == nEncryptType)
+	{
+		szKey.split('').forEach((char, nIndex) => {
+			arrayKey[(strKey + nSequence) >> 0] = char.charCodeAt(0);
+			nSequence++;
+		});
+	}
+	nRet = Module._PLAY_SetSecurityKey(m_nPlayPort, strKey, nKeyLen);
+	
+	Module._free(strKey);
+	
+	return nRet;
+}
+
+function SetSecurityKeyEx(nEncryptType, stDecryptKey)
+{	
+	var nRet = 1;	
+	const stDecryptKeyPtr = Module._malloc(96);
+	
+	var nSequence = 0;
+	const keyPtr = Module._malloc(stDecryptKey.KeyLen);
+	var arrayKey = new Uint8Array(Module.HEAPU8.buffer);
+
+	stDecryptKey.Key.split('').forEach((char, nIndex) => {
+		arrayKey[(keyPtr + nSequence) >> 0] = char.charCodeAt(0);
+		nSequence++;
+	});
+	
+	nSequence = 0;
+	const keyIdPtr = Module._malloc(stDecryptKey.KeyIdLen);
+	stDecryptKey.KeyId.split('').forEach((char, nIndex) => {
+		arrayKey[(keyIdPtr + nSequence) >> 0] = char.charCodeAt(0);
+		nSequence++;
+	});
+	
+	Module.HEAP32[stDecryptKeyPtr/4 + 0] = keyPtr;     
+	Module.HEAP32[stDecryptKeyPtr/4 + 1] = stDecryptKey.KeyLen; 
+	Module.HEAP32[stDecryptKeyPtr/4 + 2] = keyIdPtr;  
+	Module.HEAP32[stDecryptKeyPtr/4 + 3] = stDecryptKey.KeyIdLen;             
+	nRet = Module._PLAY_SetSecurityKeyEx(m_nPlayPort, nEncryptType, stDecryptKeyPtr, stDecryptKey.KeyLen);
+	
+	Module._free(keyPtr);
+	Module._free(keyIdPtr);
+	Module._free(stDecryptKeyPtr);
+
+	return nRet;
+}
+
+function SetSupportWebMSE(bSupportH264MSE, bSupportH265MSE)
+{
+	Module._PLAY_SetSupportWebMSE(m_nPlayPort, bSupportH264MSE, bSupportH265MSE);
+}
+
+function Pause(bPause) 
+{
+	Module._PLAY_Pause(m_nPlayPort, bPause);
+}
+
+function CatchPic()
+{
+	var nSize = m_nWidth * m_nHeight * 3/2;
+	var pJpegBuf = Module._malloc(nSize);
+	var pJpegBufArr = new Uint8Array(Module.HEAPU8.buffer, pJpegBuf, nSize);
+	
+	var pJpegSize = Module._malloc(4);
+	var pJpegSizeArr = new Uint8Array(Module.HEAPU8.buffer, pJpegSize, 4);
+	
+	//获取当前图像编码后的jpeg图片数据
+	Module._PLAY_GetPicJPEG(m_nPlayPort, pJpegBufArr.byteOffset, nSize, pJpegSizeArr.byteOffset, 100);
+	
+	//C++内存数据拷贝至JS内存
+	var nDataSize = (pJpegSizeArr[3] << 24) + (pJpegSizeArr[2] << 16) + (pJpegSizeArr[1] << 8) + pJpegSizeArr[0];
+	var pOutJpegBuf = new ArrayBuffer(nDataSize);
+	var pOutJpegBufArr = new Uint8Array(pOutJpegBuf);
+	pOutJpegBufArr.set(Module.HEAPU8.subarray(pJpegBufArr.byteOffset, pJpegBufArr.byteOffset + nDataSize));
+	
+	var msgType = 'CatchPicCallBack';
+	var msgData =  
+	{	
+		buffer: pOutJpegBufArr
+	}
+	sendMessage(m_nPlayPort, msgType, msgData);
+	
+	Module._free(pJpegBuf);
+	Module._free(pJpegSize);
+	pJpegBufArr = null;
+	pJpegSizeArr = null;
+	pOutJpegBuf= null;
+	pOutJpegBufArr = null;
+	
+}
+
+function Stop() 
+{
+	var nRet = Module._PLAY_Stop(m_nPlayPort);
+	if (0 == nRet)
+	{
+		return;
+	}
+	nRet = Module._PLAY_CloseStream(m_nPlayPort); 
+	
+	jsInputDataAry = null;
+	Module._free(jsInputData);
+	
+	jsFrameBuf = null;
+	jsFrameInfo = null;
+	dataView = null;
+	
+	jsBufY = null;
+	jsBufU = null;
+	jsBufV = null;
+	jsYuvDataY = null;
+	jsYuvDataU = null;
+	jsYuvDataV = null;
+	
+	jsRecordFrameBuf = null;
+	jsRecordFrameInfo = null;
+	dataViewRecord = null;
+}
+
+function SetPrintLogLevel(nLogLevel)
+{
+	Module._PLAY_SetPrintLogLevel(nLogLevel);
+}
+
+function SetInt32(nSetType, nValue)
+{
+	Module._PLAY_SetInt32(m_nPlayPort, nSetType, nValue);
+}
+
+function InputAudioData(audioData)
+{
+	var jsAudioData = Module._malloc(audioData.length);
+	var jsAudioDataAry = new Uint8Array(Module.HEAPU8.buffer, jsAudioData, audioData.length);
+	
+	jsAudioDataAry.set(audioData);
+	Module._PLAY_InputAudioData(m_nPlayPort, jsAudioDataAry.byteOffset, audioData.length, 16, 8000);
+	Module._free(jsAudioData);
+}
+
+function SetPrivacyRecover(bRecover)
+{
+	Module._PLAY_SetPrivacyRecover(m_nPlayPort, bRecover);
+}
+
+function cPlusVisibleDecCallBack(nPort, pBufY, pBufU, pBufV, nSize, pFrameInfo)
+{
+	var stuFrameInfo = {};
+	if(!jsFrameInfo) 
+	{
+		jsFrameBuf = new ArrayBuffer(292);//通过二进制对象分配一块连续内存
+		jsFrameInfo = new Uint8Array(jsFrameBuf);//二进制对象绑定到视图，通过视图对内存进行读写操作
+		dataView = new DataView(jsFrameBuf);
+	}
+	jsFrameInfo.set(Module.HEAPU8.subarray(pFrameInfo, pFrameInfo + 292));//c中的内存拷贝到刚分配的js内存中
+	//帧类型
+	stuFrameInfo.nFrameType = dataView.getInt32(0, true);
+	//帧序号
+	stuFrameInfo.nFrameID = dataView.getInt32(4, true);
+	//帧子类型
+	stuFrameInfo.nFrameSubType = dataView.getInt32(56, true);
+	
+	//帧时间
+	stuFrameInfo.nYear = dataView.getUint16(40, true);
+	stuFrameInfo.nMonth = dataView.getUint16(42, true);
+	stuFrameInfo.nDay = dataView.getUint16(46, true);
+	stuFrameInfo.nHour = dataView.getUint16(48, true);
+	stuFrameInfo.nMinute = dataView.getUint16(50, true);
+	stuFrameInfo.nSecond = dataView.getUint16(52, true);
+	
+	var msgData =  {};
+	//视频
+	if (1 == stuFrameInfo.nFrameType)
+	{	
+		//剩余缓冲数据量
+		stuFrameInfo.nRemainData = dataView.getInt32(36, true);
+		//抽帧标记
+		stuFrameInfo.bThrowFrame = dataView.getUint8(120, true);
+		if (0 == stuFrameInfo.bThrowFrame)
+		{
+			//编码类型
+			stuFrameInfo.nEncodeType = dataView.getInt32(108, true);
+			//码流类型
+			stuFrameInfo.nStreamType = dataView.getInt32(112, true);
+			//时间戳
+			stuFrameInfo.nTimeStamp = dataView.getUint32(8, true);
+			//图像宽度
+			stuFrameInfo.nWidth = dataView.getInt32(12, true);
+			m_nWidth = stuFrameInfo.nWidth;
+			//图像高度
+			stuFrameInfo.nHeight = dataView.getInt32(16, true);
+			m_nHeight = stuFrameInfo.nHeight;
+			//视频帧率
+			stuFrameInfo.nFrameRate = dataView.getInt32(20, true);
+			//图像跨距
+			stuFrameInfo.nStride = dataView.getInt32(116, true);
+			//旋转角度类型
+			stuFrameInfo.nRotateType = dataView.getUint8(122, true);
+			//vui句法中视频三原色
+			stuFrameInfo.nColorPrimaries = dataView.getUint8(124, true);
+			//vui句法中视频信号转换函数
+			stuFrameInfo.nColorTransfer = dataView.getUint8(125, true);
+			//vui中视频颜色空间
+			stuFrameInfo.nColorSpace = dataView.getUint8(126, true);
+			//颜色范围 0:yuv范围16-235,对应 TV; 1:yuv范围0-255, 对应 PC
+			stuFrameInfo.bColorFull = dataView.getUint8(127, true);
+			
+			if ((ENCODE_TYPE_VIDEO_HI_H264 == stuFrameInfo.nEncodeType) || (ENCODE_TYPE_VIDEO_MY_H264 == stuFrameInfo.nEncodeType) || (ENCODE_TYPE_VIDEO_STD_H264 == stuFrameInfo.nEncodeType))
+			{
+				//H.264编码类型
+				m_nVideoEncodeType = 1;
+			}
+			else if(12 == stuFrameInfo.nEncodeType)
+			{
+				//H.265编码类型
+				m_nVideoEncodeType = 2;
+			}
+			
+			//智能I/P帧
+			if ((VIDEO_FRAME_SUB_TYPE_SMART_I == stuFrameInfo.nFrameSubType) 
+				|| (VIDEO_FRAME_SUB_TYPE_SMART_P == stuFrameInfo.nFrameSubType)
+				|| (VIDEO_FRAME_SUB_TYPE_SMART_I_NORENDER == stuFrameInfo.nFrameSubType))
+			{
+				//Smart H.264或者Smart H.265
+				m_bSmartEncode = 1;
+			}
+			else if(0 == stuFrameInfo.nFrameSubType)
+			{
+				m_bSmartEncode = 0;
+			}
+			
+			//SVC码流不支持硬解码
+			if ((((1 == m_nVideoEncodeType) && (true == m_bSupportH264MSE)) 
+				|| ((2 == m_nVideoEncodeType) && (true == m_bSupportH265MSE))) 
+				&& (STREAM_TYPE_SVC != stuFrameInfo.nStreamType))
+			{
+				//读取码流裸数据
+				jsBuf = new ArrayBuffer(nSize);//通过二进制对象分配一块连续内存
+				jsFrameBodyData = new Uint8Array(jsBuf);//二进制对象绑定到视图，通过视图对内存进行读写操作
+				jsFrameBodyData.set(Module.HEAPU8.subarray(pBufY, pBufY + nSize));//c中的内存拷贝到刚分配的js内存中
+				
+				msgData =  
+				{	
+					pBufY: jsFrameBodyData, 
+					pBufU: null,
+					pBufV: null, 
+					nSize: nSize,
+					stuFrameInfo: stuFrameInfo,
+				}
+			}
+			else
+			{
+				if((0 == pBufY) || (0 == pBufU) || (0 == pBufV))
+				{
+					return;
+				}
+				
+				if (m_nWidth != m_nPreWidth || m_nHeight != m_nPreHeight)
+				{
+					m_nPreWidth = m_nWidth;
+					m_nPreHeight = m_nHeight;
+					
+					jsBufY = null;
+					jsBufU = null;
+					jsBufV = null;
+					jsYuvDataY = null;
+					jsYuvDataU = null;
+					jsYuvDataV = null;
+					
+					jsBufY = new ArrayBuffer(m_nWidth * m_nHeight);//通过二进制对象分配一块连续内存
+					jsYuvDataY = new Uint8Array(jsBufY);//二进制对象绑定到视图，通过视图对内存进行读写操作
+						
+					jsBufU = new ArrayBuffer(m_nWidth * m_nHeight / 4);
+					jsYuvDataU = new Uint8Array(jsBufU);
+						
+					jsBufV = new ArrayBuffer(m_nWidth * m_nHeight / 4);
+					jsYuvDataV = new Uint8Array(jsBufV);
+				}
+				
+				var h = 0;
+				//将C++层YUV解码数据Y分量数据拷贝至JS层内存中	
+				for(h = 0; h < stuFrameInfo.nHeight; h++)
+				{
+					jsYuvDataY.set(Module.HEAPU8.subarray((pBufY + h * stuFrameInfo.nStride), (pBufY + h * stuFrameInfo.nStride) + stuFrameInfo.nWidth), h * stuFrameInfo.nWidth);//c中的内存拷贝到刚分配的js内存中
+				}
+				//将C++层YUV解码数据U分量数据拷贝至JS层内存中		
+				for(h = 0; h < stuFrameInfo.nHeight / 2; h++)
+				{
+					jsYuvDataU.set(Module.HEAPU8.subarray((pBufU + h * stuFrameInfo.nStride/2), (pBufU + h * stuFrameInfo.nStride/2) + stuFrameInfo.nWidth/2), h * stuFrameInfo.nWidth/2);//c中的内存拷贝到刚分配的js内存中
+				}
+				//将C++层YUV解码数据V分量数据拷贝至JS层内存中		
+				for(h = 0; h < stuFrameInfo.nHeight / 2; h++)
+				{
+					jsYuvDataV.set(Module.HEAPU8.subarray((pBufV + h * stuFrameInfo.nStride/2), (pBufV + h * stuFrameInfo.nStride/2) + stuFrameInfo.nWidth/2), h * stuFrameInfo.nWidth/2);//c中的内存拷贝到刚分配的js内存中
+				}
+				
+				msgData =  
+				{	
+					pBufY: jsYuvDataY,
+					pBufU: jsYuvDataU,
+					pBufV: jsYuvDataV, 
+					nSize: nSize,
+					stuFrameInfo: stuFrameInfo,
+				}
+			}
+		}
+		else
+		{
+			msgData =  
+			{	
+				pBufY: null,
+				pBufU: null,
+				pBufV: null, 
+				nSize: 0,
+				stuFrameInfo: stuFrameInfo,
+			}
+		}
+	}
+	else if(2 == stuFrameInfo.nFrameType)//音频帧
+	{
+		//总通道数
+		stuFrameInfo.nTotalChannel = dataView.getInt32(68, true);
+		//当前通道
+		stuFrameInfo.nCurChannel = dataView.getInt32(72, true);
+		//暂不支持双通道音频播放
+		if (stuFrameInfo.nCurChannel > 0)
+		{
+			return;
+		}
+		//采样位数
+		stuFrameInfo.nBits = dataView.getInt32(28, true);
+		//采样率
+		stuFrameInfo.nSamples = dataView.getInt32(32, true);
+		//声道数
+		stuFrameInfo.nAudioChnNum = dataView.getInt32(24, true);
+		
+		var AudioBuf = new ArrayBuffer(nSize);
+		var UI8AudioData = new Uint8Array(AudioBuf);
+		//将C++层解码后的pcm音频数据拷贝至JS层内存
+        UI8AudioData.set(Module.HEAPU8.subarray(pBufY, pBufY + nSize));
+		
+		msgData =  
+		{	
+			pBufY: UI8AudioData,
+			pBufU: null,
+			pBufV: null, 
+			nSize: nSize,
+			stuFrameInfo: stuFrameInfo,
+		}
+	}
+	
+	var msgType = 'VisibleDecCallBack';
+	
+	sendMessage(nPort, msgType, msgData);
+	
+	jsBuf = null;
+	jsFrameBodyData = null;
+}
+
+/*
+ * C++层AES解密回调。
+ *
+ * @param[in] nPort 端口号
+ * @param[in] nFrameID 视频帧序号
+ * @param[in] bSuccess 是否解密成功
+ */
+function cDigitalSignCallBack(nPort, nFrameID, bSuccess)
+{
+	m_bDecryptionResult = bSuccess;
+	var msgType = 'DecryptionResultCallBack';
+	var msgData =  
+	{	
+		bSuccess: bSuccess
+	}
+	
+	sendMessage(nPort, msgType, msgData);
+}
+
+/*
+ * C++层码流录制回调，回调至JS层进行数据存储
+ *
+ * @param[in] nPort 端口号
+ * @param[in] pData 码流数据
+ * @param[in] nDataLen 数据长度
+ * @param[in] nOffset 偏移量
+ * @param[in] pFrameInfo 码流信息
+ */
+function cRecordDataCallBack(nPort, pData, nDataLen, nOffset, pFrameInfo) 
+{
+	var stuFrameInfo = {};
+	if (!jsRecordFrameInfo) 
+	{
+		jsRecordFrameBuf = new ArrayBuffer(292); //通过二进制对象分配一块连续内存
+		jsRecordFrameInfo = new Uint8Array(jsRecordFrameBuf); //二进制对象绑定到视图，通过视图对内存进行读写操作
+		dataViewRecord = new DataView(jsRecordFrameBuf);
+	}
+	jsRecordFrameInfo.set(Module.HEAPU8.subarray(pFrameInfo, pFrameInfo + 292)); //c中的内存拷贝到刚分配的js内存中
+	
+	//帧类型
+	stuFrameInfo.nFrameType = dataViewRecord.getInt32(0, true);
+	//帧序号
+	stuFrameInfo.nFrameID = dataViewRecord.getInt32(4, true);
+	//帧子类型
+	stuFrameInfo.nFrameSubType = dataViewRecord.getInt32(56, true);
+	
+	//视频帧
+	if (1 == stuFrameInfo.nFrameType) 
+	{
+		//编码类型
+		stuFrameInfo.nEncodeType = dataViewRecord.getInt32(68, true);
+		//码流类型
+		stuFrameInfo.nStreamType = dataViewRecord.getInt32(72, true);
+		
+		//时间戳
+		stuFrameInfo.nTimeStamp = dataViewRecord.getUint32(8, true);
+		//帧时间
+		stuFrameInfo.nYear = dataViewRecord.getUint16(40, true);
+		stuFrameInfo.nMonth = dataViewRecord.getUint16(42, true);
+		stuFrameInfo.nDay = dataViewRecord.getUint16(46, true);
+		stuFrameInfo.nHour = dataViewRecord.getUint16(48, true);
+		stuFrameInfo.nMinute = dataViewRecord.getUint16(50, true);
+		stuFrameInfo.nSecond = dataViewRecord.getUint16(52, true);
+	}
+	
+	var bufRecord = new ArrayBuffer(nDataLen);
+	var arrayRecord = new Uint8Array(bufRecord);  
+	arrayRecord.set(Module.HEAPU8.subarray(pData, pData + nDataLen));
+	
+	var msgType = 'RecordDataCallBack';
+	var msgData =  
+	{	
+		pRecordData: arrayRecord,
+		nLen: nDataLen,
+		Offset: nOffset, 
+		stuFrameInfo: stuFrameInfo,
+	}
+	sendMessage(nPort, msgType, msgData);
+	
+	bufRecord = null;
+	arrayRecord = null;
+}
+
+function cIVSDrawDataCallBack(nPort, pBuf, nType, nLen, nReallen)
+{
+	//帧序号为-1时不绘制
+	if(-1 == nReallen)
+	{
+		return;
+	}
+	
+	var pParseredBuf = null;
+	
+	ivsBuf = new ArrayBuffer(nLen);//通过二进制对象分配一块连续内存
+	ivsDataArray = new Uint8Array(ivsBuf);//二进制对象绑定到视图，通过视图对内存进行读写操作
+	ivsDataArray.set(Module.HEAPU8.subarray(pBuf, pBuf + nLen));
+	ivsDataView = new DataView(ivsDataArray.buffer);
+	
+	if (IVS_TYPE.IVSINFOTYPE_INTELFLOW == nType)
+	{//智能客流量
+		var stuIntelflowInfo = {};
+		stuIntelflowInfo.NumberStat = ivsDataView.getUint16(0, true);//大类业务方案
+		stuIntelflowInfo.nIntelFlowPlanNum = ivsDataView.getUint16(2, true);//智能客流规则数量(最大不会超过32个)
+		
+		var pIntelFlowPlan = ivsDataView.getUint32(4, true);
+		let IntelFlowPlanBuf = new ArrayBuffer(12);
+		let IntelFlowPlanArray = new Uint8Array(IntelFlowPlanBuf);
+		let IntelFlowPlanView = new DataView(IntelFlowPlanBuf);
+		
+		stuIntelflowInfo.pIntelFlowPlan = new Array(stuIntelflowInfo.nIntelFlowPlanNum);
+		for (let i = 0; i < stuIntelflowInfo.nIntelFlowPlanNum; i++)
+		{
+			IntelFlowPlanArray.set(Module.HEAPU8.subarray(pIntelFlowPlan + i * 12, pIntelFlowPlan + i * 12 + 12));
+			//解析智能客流规则
+			stuIntelflowInfo.pIntelFlowPlan[i] = {};
+			stuIntelflowInfo.pIntelFlowPlan[i].PlanId = IntelFlowPlanView.getUint16(0, true);//规则ID
+			stuIntelflowInfo.pIntelFlowPlan[i].RuleType = IntelFlowPlanView.getUint16(2, true);//规则类型
+			stuIntelflowInfo.pIntelFlowPlan[i].RegionNum = IntelFlowPlanView.getUint16(8, true);//区域数目
+			var pRegion = IntelFlowPlanView.getUint32(4, true);
+			let RegionBuf = new ArrayBuffer(12);
+			let RegionArray = new Uint8Array(RegionBuf);
+			let RegionView = new DataView(RegionBuf);
+			
+			stuIntelflowInfo.pIntelFlowPlan[i].pRegion = new Array(stuIntelflowInfo.pIntelFlowPlan[i].RegionNum);
+			for (let j = 0; j < stuIntelflowInfo.pIntelFlowPlan[i].RegionNum; j++)
+			{
+				RegionArray.set(Module.HEAPU8.subarray(pRegion + j * 12, pRegion + j * 12 + 12));
+				
+				stuIntelflowInfo.pIntelFlowPlan[i].pRegion[j] = {};
+				stuIntelflowInfo.pIntelFlowPlan[i].pRegion[j].RegionId = RegionView.getUint16(0, true);//区域ID
+				stuIntelflowInfo.pIntelFlowPlan[i].pRegion[j].State = RegionView.getUint16(2, true);//状态:离开or进入
+				stuIntelflowInfo.pIntelFlowPlan[i].pRegion[j].PeopleNum = RegionView.getUint32(4, true);//人数
+			}
+		}
+		
+		pParseredBuf = stuIntelflowInfo;
+	}
+	else if (IVS_TYPE.IVSINFOTYPE_DHOP_SMART == nType)
+	{//DHOP开放平台智能帧
+		var stuObjDHOP = {};
+		stuObjDHOP.nId = ivsDataView.getUint32(0, true);//对象ID
+		stuObjDHOP.wCustom = ivsDataView.getUint16(4, true);//自定义值
+		stuObjDHOP.chState = ivsDataView.getUint8(6, true);//对象状态
+		stuObjDHOP.chCount = ivsDataView.getUint8(7, true);//元素个数
+		
+		//解析DHOP元素
+		var pElement = ivsDataView.getUint32(8, true);
+		let elementBuf = new ArrayBuffer(12);
+		let elementDataArray = new Uint8Array(elementBuf);
+		let elementDataView = new DataView(elementBuf);
+		
+		stuObjDHOP.pElement = new Array(stuObjDHOP.chCount);
+		for (var i = 0; i < stuObjDHOP.chCount; i++)
+		{
+			elementDataArray.set(Module.HEAPU8.subarray(pElement + i * 12, pElement + i * 12 + 12));
+			//解析DHOP元素类型
+			stuObjDHOP.pElement[i] = {};
+			stuObjDHOP.pElement[i].nStructType = elementDataView.getUint32(0, true);
+			stuObjDHOP.pElement[i].nStructLength = elementDataView.getUint32(4, true);
+			var pStruct = elementDataView.getUint32(8, true);
+			
+			var nBufLength = stuObjDHOP.pElement[i].nStructLength;
+			if (IVS_DHOP_ElEMENT_TYPE.EM_DHOP_TEXT === stuObjDHOP.pElement[i].nStructType)
+			{
+				nBufLength = 20;
+			}
+			
+			let structBuf = new ArrayBuffer(nBufLength);
+			let structArray = new Uint8Array(structBuf);
+			let structDataView = new DataView(structBuf);
+			structArray.set(Module.HEAPU8.subarray(pStruct, pStruct + nBufLength));
+			
+			stuObjDHOP.pElement[i].pStruct = {};
+			if (IVS_DHOP_ElEMENT_TYPE.EM_DHOP_CIRCLE == stuObjDHOP.pElement[i].nStructType)
+			{
+				stuObjDHOP.pElement[i].pStruct.chType = structDataView.getUint8(0, true);//子类型0x3
+				stuObjDHOP.pElement[i].pStruct.chWidth = structDataView.getUint8(1, true);//线宽，单位px
+				stuObjDHOP.pElement[i].pStruct.chStyle = structDataView.getUint8(2, true);//样式
+				
+				stuObjDHOP.pElement[i].pStruct.wRadius = structDataView.getUint16(4, true);//半径
+				stuObjDHOP.pElement[i].pStruct.positionCircle = {};//圆心坐标
+				stuObjDHOP.pElement[i].pStruct.positionCircle.x = structDataView.getUint16(8, true);
+				stuObjDHOP.pElement[i].pStruct.positionCircle.y = structDataView.getUint16(10, true);
+				
+				stuObjDHOP.pElement[i].pStruct.chLineA = structDataView.getUint8(12, true);//边框线条颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chLineR = structDataView.getUint8(13, true);
+				stuObjDHOP.pElement[i].pStruct.chLineG = structDataView.getUint8(14, true);
+				stuObjDHOP.pElement[i].pStruct.chLineB = structDataView.getUint8(15, true);
+				stuObjDHOP.pElement[i].pStruct.chRegA = structDataView.getUint8(16, true);//区域填充颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chRegR = structDataView.getUint8(17, true);
+				stuObjDHOP.pElement[i].pStruct.chRegG = structDataView.getUint8(18, true);
+				stuObjDHOP.pElement[i].pStruct.chRegB = structDataView.getUint8(19, true);
+				
+			}
+			else if(IVS_DHOP_ElEMENT_TYPE.EM_DHOP_BrokenLine == stuObjDHOP.pElement[i].nStructType)
+			{
+				stuObjDHOP.pElement[i].pStruct.chType = structDataView.getUint8(0, true);//子类型0x2
+				stuObjDHOP.pElement[i].pStruct.chCount = structDataView.getUint8(1, true);//端点个数
+				stuObjDHOP.pElement[i].pStruct.chWidth = structDataView.getUint8(2, true);//线宽，单位px
+				stuObjDHOP.pElement[i].pStruct.chStyle = structDataView.getUint8(3, true);//样式
+				stuObjDHOP.pElement[i].pStruct.chLineA = structDataView.getUint8(4, true);//边框线条颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chLineR = structDataView.getUint8(5, true);
+				stuObjDHOP.pElement[i].pStruct.chLineG = structDataView.getUint8(6, true);
+				stuObjDHOP.pElement[i].pStruct.chLineB = structDataView.getUint8(7, true);
+				//端点坐标
+				var pPoints = null;
+				let pointsBuf = null;
+				let pointsDataArray = null;
+				let pointsDataView = null;
+				
+				if (stuObjDHOP.pElement[i].pStruct.chCount > 0)
+				{
+					stuObjDHOP.pElement[i].pStruct.pPoints = new Array(stuObjDHOP.pElement[i].pStruct.chCount);
+					pPoints = structDataView.getUint32(8, true);
+					pointsBuf = new ArrayBuffer(4);
+					pointsDataArray = new Uint8Array(pointsBuf);
+					pointsDataView = new DataView(pointsBuf);
+				}
+				
+				for(var j = 0; j < stuObjDHOP.pElement[i].pStruct.chCount; j++)
+				{
+					pointsDataArray.set(Module.HEAPU8.subarray(pPoints + j*4, pPoints + j*4 + 4));
+					stuObjDHOP.pElement[i].pStruct.pPoints[j] = {};
+					stuObjDHOP.pElement[i].pStruct.pPoints[j].x = pointsDataView.getUint16(0, true);
+					stuObjDHOP.pElement[i].pStruct.pPoints[j].y = pointsDataView.getUint16(2, true);
+				}
+			}
+			else if(IVS_DHOP_ElEMENT_TYPE.EM_DHOP_POLYGON == stuObjDHOP.pElement[i].nStructType)
+			{
+				stuObjDHOP.pElement[i].pStruct.chType = structDataView.getUint8(0, true);//子类型0x3
+				stuObjDHOP.pElement[i].pStruct.chCount = structDataView.getUint8(1, true);//端点个数
+				stuObjDHOP.pElement[i].pStruct.chWidth = structDataView.getUint8(2, true);//线宽，单位px
+				stuObjDHOP.pElement[i].pStruct.chStyle = structDataView.getUint8(3, true);//样式
+				stuObjDHOP.pElement[i].pStruct.chLineA = structDataView.getUint8(4, true);//边框线条颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chLineR = structDataView.getUint8(5, true);
+				stuObjDHOP.pElement[i].pStruct.chLineG = structDataView.getUint8(6, true);
+				stuObjDHOP.pElement[i].pStruct.chLineB = structDataView.getUint8(7, true);
+				stuObjDHOP.pElement[i].pStruct.chRegA = structDataView.getUint8(8, true);//区域填充颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chRegR = structDataView.getUint8(9, true);
+				stuObjDHOP.pElement[i].pStruct.chRegG = structDataView.getUint8(10, true);
+				stuObjDHOP.pElement[i].pStruct.chRegB = structDataView.getUint8(11, true);
+				//端点坐标
+				var pPoints = null;
+				let pointsBuf = null;
+				let pointsDataArray = null;
+				let pointsDataView = null;
+				
+				if (stuObjDHOP.pElement[i].pStruct.chCount > 0)
+				{
+					stuObjDHOP.pElement[i].pStruct.pPoints = new Array(stuObjDHOP.pElement[i].pStruct.chCount);
+					pPoints = structDataView.getUint32(12, true);
+					pointsBuf = new ArrayBuffer(4);
+					pointsDataArray = new Uint8Array(pointsBuf);
+					pointsDataView = new DataView(pointsBuf);
+				}
+				
+				for(var j = 0; j < stuObjDHOP.pElement[i].pStruct.chCount; j++)
+				{
+					pointsDataArray.set(Module.HEAPU8.subarray(pPoints + j*4, pPoints + j*4 + 4));
+					stuObjDHOP.pElement[i].pStruct.pPoints[j] = {};
+					stuObjDHOP.pElement[i].pStruct.pPoints[j].x = pointsDataView.getUint16(0, true);
+					stuObjDHOP.pElement[i].pStruct.pPoints[j].y = pointsDataView.getUint16(2, true);
+				}
+			}
+			else if(IVS_DHOP_ElEMENT_TYPE.EM_DHOP_TEXT == stuObjDHOP.pElement[i].nStructType)
+			{
+				stuObjDHOP.pElement[i].pStruct.chType = structDataView.getUint8(0, true);//子类型0x4
+				stuObjDHOP.pElement[i].pStruct.chCharset = structDataView.getUint8(1, true);//编码方式
+				stuObjDHOP.pElement[i].pStruct.stringPos = {};//字符坐标
+				stuObjDHOP.pElement[i].pStruct.stringPos.x = structDataView.getUint16(4, true);
+				stuObjDHOP.pElement[i].pStruct.stringPos.y = structDataView.getUint16(6, true);
+				stuObjDHOP.pElement[i].pStruct.chLineA = structDataView.getUint8(8, true);//字体颜色(ARGB)
+				stuObjDHOP.pElement[i].pStruct.chLineR = structDataView.getUint8(9, true);
+				stuObjDHOP.pElement[i].pStruct.chLineG = structDataView.getUint8(10, true);
+				stuObjDHOP.pElement[i].pStruct.chLineB = structDataView.getUint8(11, true);
+				stuObjDHOP.pElement[i].pStruct.chFontSize = structDataView.getUint8(12, true);//字体大小，单位px
+				stuObjDHOP.pElement[i].pStruct.chFontAlign = structDataView.getUint8(13, true);//对齐方式
+				stuObjDHOP.pElement[i].pStruct.wTxtLen = structDataView.getUint16(14, true);//字符长度
+				
+				if (stuObjDHOP.pElement[i].pStruct.wTxtLen > 0)
+				{
+					var pString = structDataView.getUint32(16, true);
+					var stringBuf = new ArrayBuffer(stuObjDHOP.pElement[i].pStruct.wTxtLen);
+					var stringDataArray = new Uint8Array(stringBuf);
+					var stringDataView = new DataView(stringBuf);
+					stringDataArray.set(Module.HEAPU8.subarray(pString, pString + stuObjDHOP.pElement[i].pStruct.wTxtLen));
+					stuObjDHOP.pElement[i].pStruct.stringDataArray = stringDataArray;
+				}
+			}
+		}
+		
+		//解析DHOP信息内容
+		stuObjDHOP.nInfoLen = ivsDataView.getUint16(12, true);//信息长度
+		if (stuObjDHOP.nInfoLen > 0)
+		{
+			var pInfo = ivsDataView.getUint32(16, true);
+			let infoBuf = new ArrayBuffer(stuObjDHOP.nInfoLen);
+			let infoDataArray = new Uint8Array(infoBuf);
+			infoDataArray.set(Module.HEAPU8.subarray(pInfo, pInfo + stuObjDHOP.nInfoLen));
+			stuObjDHOP.pInfo = infoDataArray;
+		}
+		
+		pParseredBuf = stuObjDHOP;
+	}
+	else if (IVS_TYPE.IVSINFOTYPE_TAGGING_INFO == nType)//景物点信息标注帧
+	{
+		let dataView = new DataView(ivsBuf); 
+
+		let tagInfoNum = nLen/FRAME_SCENE_POINTS_INFOR_SIZE;
+
+		let tagInfos = [];
+		for (let tagInfoIndex = 0; tagInfoIndex < tagInfoNum; tagInfoIndex++)
+		{
+			var tagInfo = {};
+			let Stride = FRAME_SCENE_POINTS_INFOR_SIZE * tagInfoIndex;
+			//编号
+			tagInfo.nIndex = dataView.getInt32(Stride + 0, true);
+			//景物点x坐标
+			tagInfo.xPoint = dataView.getUint16(Stride + 4, true);
+			//景物点y坐标
+			tagInfo.yPoint = dataView.getUint16(Stride + 6, true);
+			
+			//一级名称
+			var jsNameBuf = new ArrayBuffer(64);
+			jsNameBuf = ivsBuf.slice(Stride + 8);
+			tagInfo.strName = ArrayBufferToStringAutoClip(jsNameBuf); 
+			
+			//使能标记
+			tagInfo.enable = dataView.getInt8(Stride + 72, true);
+			//标签类型
+			tagInfo.titleType = dataView.getInt8(Stride + 73, true);
+			//标签属性
+			tagInfo.titleAttribute = dataView.getInt8(Stride + 74, true);
+			tagInfo.sharpType = dataView.getInt8(Stride + 75, true);
+			tagInfo.polygonNum = dataView.getInt8(Stride + 76, true);
+			tagInfo.polygon = [];
+			//与上一个中间空了三字节
+			for(let i = 0;i< tagInfo.polygonNum*2;i+=2)
+			{
+				tagInfo.polygon[i] ={x: dataView.getInt8(Stride + 79 + 2*i, true),  
+									 y: dataView.getInt8(Stride + 79 + 2*(i+1), true)};
+			}
+
+			tagInfos[tagInfoIndex] = tagInfo;
+			jsNameBuf = null;
+		}
+		
+		var msgType = 'ARTagInfoCallback';
+		var msgData =  
+		{	
+			tagInfo: tagInfos,
+		}
+		
+		sendMessage(nPort, msgType, msgData);
+		
+		pParseredBuf = tagInfos;
+		dataView = null;
+	}
+	else if (IVS_TYPE.IVSINFOTYPE_GPS_INFO == nType)//GPS信息帧
+	{
+		let nUtcLen = (nLen == 136) ? 8:4;//协议中utc类型为ulong
+		let ivsGPSBuf = new ArrayBuffer(nLen - nUtcLen);//通过二进制对象分配一块连续内存
+		let ivsGPSDataArray = new Uint8Array(ivsGPSBuf);//二进制对象绑定到视图，通过视图对内存进行读写操作
+		ivsGPSDataArray.set(Module.HEAPU8.subarray(pBuf + nUtcLen, pBuf + nLen));
+		let ivsGPSDataView = new DataView(ivsGPSDataArray.buffer);
+		
+		let GPSInfos = [];
+		GPSInfos.longitude = ivsGPSDataView.getInt32(0, true) / 1000.0 / 3600.0;
+		GPSInfos.latitude = ivsGPSDataView.getInt32(4, true) /1000.0 / 3600.0;
+		GPSInfos.yaw = ivsGPSDataView.getFloat32(20, true);
+		GPSInfos.pitch = ivsGPSDataView.getFloat32(24, true);
+		GPSInfos.roll = ivsGPSDataView.getFloat32(28, true);
+		GPSInfos.absoluteAltitude = ivsGPSDataView.getFloat32(32, true);
+		GPSInfos.zoom = ivsGPSDataView.getFloat32(36, true);
+		
+		var msgType = 'GPSInfoCallback';
+		var msgData =  
+		{	
+			GPSInfos: GPSInfos,
+		}
+		
+		sendMessage(nPort, msgType, msgData);
+		ivsGPSDataView = null;
+		
+		pParseredBuf = GPSInfos;
+	}
+	else
+	{
+		pParseredBuf = ivsDataArray;
+	}
+	
+	var msgType = 'IVSDataCallBack';
+	var msgData =  
+	{	
+		pBuf: pParseredBuf,
+		nType: nType,
+		nLen: nLen, 
+		nReallen: nReallen,
+	}
+	
+	sendMessage(nPort, msgType, msgData);
+}
+
+function cDemuxDecCBFun(nPort, pBuf, nSize, pMutexInfo)
+{
+	var stuDemuxInfo = {};
+	if(!m_uintDemuxInfo) 
+	{
+		m_arrayDemuxBuf = new ArrayBuffer(72);//通过二进制对象分配一块连续内存
+		m_uintDemuxInfo = new Uint8Array(m_arrayDemuxBuf);//二进制对象绑定到视图，通过视图对内存进行读写操作
+		m_dvDemuxInfo = new DataView(m_arrayDemuxBuf);
+	}  
+	m_uintDemuxInfo.set(Module.HEAPU8.subarray(pMutexInfo, pMutexInfo + 72));//c中的内存拷贝到刚分配的js内存中
+	//帧类型
+	stuDemuxInfo.nFrameType = m_dvDemuxInfo.getInt32(0, true);
+	//帧子类型
+	stuDemuxInfo.nFrameSubType = m_dvDemuxInfo.getInt32(4, true);
+	//编码类型
+	stuDemuxInfo.nEncodeType = m_dvDemuxInfo.getInt32(8, true);
+	//帧序号
+	stuDemuxInfo.nFrameID = m_dvDemuxInfo.getInt32(12, true);
+	//图像宽度
+	stuDemuxInfo.nWidth = m_dvDemuxInfo.getInt32(16, true);
+	//图像高度
+	stuDemuxInfo.nHeight = m_dvDemuxInfo.getInt32(20, true);
+	//视频帧率
+	stuDemuxInfo.nFrameRate = m_dvDemuxInfo.getInt32(24, true);
+	//帧时间
+	stuDemuxInfo.nYear = m_dvDemuxInfo.getUint16(28, true);
+	stuDemuxInfo.nMonth = m_dvDemuxInfo.getUint16(32, true);
+	stuDemuxInfo.nDay = m_dvDemuxInfo.getUint16(36, true);
+	stuDemuxInfo.nHour = m_dvDemuxInfo.getUint16(40, true);
+	stuDemuxInfo.nMinute = m_dvDemuxInfo.getUint16(44, true);
+	stuDemuxInfo.nSecond = m_dvDemuxInfo.getUint16(48, true);
+	//时间戳
+	stuDemuxInfo.nTimeStamp = m_dvDemuxInfo.getUint32(52, true);
+	//总通道数
+	stuDemuxInfo.nTotalChannel = m_dvDemuxInfo.getInt32(56, true);
+	//采样深度
+	stuDemuxInfo.nBits = m_dvDemuxInfo.getInt32(60, true);
+	//采样率
+	stuDemuxInfo.nSamples = m_dvDemuxInfo.getInt32(64, true);	
+	//绝对时间毫秒
+	stuDemuxInfo.nMillisecond = m_dvDemuxInfo.getInt32(68, true);
+	
+	var msgType = 'DemuxdataCallBack';
+	var msgData =  
+	{	
+		pBuf: pBuf,
+		nSize: nSize,
+		pMutexInfo: stuDemuxInfo, 
+	}
+	
+	sendMessage(nPort, msgType, msgData);
+}
+
+function sendMessage(nPort, msgType, msgData) 
+{
+	var event = 
+	{
+		nPort: nPort,
+		msgType: msgType,
+		msgData: msgData,
+	};
+
+    postMessage(event);
+}
+
+function ArrayBufferToString(buffer, encoding = 'utf-8') 
+{
+	const decoder = new TextDecoder(encoding);
+	return decoder.decode(buffer);
+}
+
+function ArrayBufferToStringAutoClip(buffer, encoding = 'utf-8')
+{
+	const decoder = new TextDecoder(encoding);
+	const uint8Array = new Uint8Array(buffer);
+  
+	let i = 0;
+  
+	while (i < uint8Array.length) {
+	  if (uint8Array[i] === 0) {
+		break;
+	  }
+	  i++;
+	}
+  
+	return decoder.decode(buffer.slice(0,i));
+}
+
+function UTF16ToUTF8(UTF16Str) 
+{
+	var UTF8Arr = [];
+	var byteSize = 0;
+	for (var i = 0; i < UTF16Str.length; i++) 
+	{
+		//获取字符Unicode码值
+		var code = UTF16Str.charCodeAt(i);
+
+		//如果码值是1个字节的范围，则直接写入
+		if (code >= 0x00 && code <= 0x7f) 
+		{
+			byteSize += 1;
+			UTF8Arr.push(code);
+
+			//如果码值是2个字节以上的范围，则按规则进行填充补码转换
+		}
+		else if (code >= 0x80 && code <= 0x7ff) 
+		{
+			byteSize += 2;
+			UTF8Arr.push((192 | (31 & (code >> 6))));
+			UTF8Arr.push((128 | (63 & code)))
+		} 
+		else if ((code >= 0x800 && code <= 0xd7ff) || (code >= 0xe000 && code <= 0xffff)) 
+		{
+			byteSize += 3;
+			UTF8Arr.push((224 | (15 & (code >> 12))));
+			UTF8Arr.push((128 | (63 & (code >> 6))));
+			UTF8Arr.push((128 | (63 & code)))
+		} 
+		else if(code >= 0x10000 && code <= 0x10ffff)
+		{
+			byteSize += 4;
+			UTF8Arr.push((240 | (7 & (code >> 18))));
+			UTF8Arr.push((128 | (63 & (code >> 12))));
+			UTF8Arr.push((128 | (63 & (code >> 6))));
+			UTF8Arr.push((128 | (63 & code)))
+		}
+	}
+
+	return UTF8Arr
+}