• 基于metaRTC嵌入式webrtc的H265网页播放器实现（我与metaRTC的缘分）

           目前100ms延迟已达成，暂不进一步开始，过程中还是感觉有点力不从心，还是多点积累再出发！我与meta RTC的缘分开始于实现H265网页播放的理想，搜遍全网，也只发现metaRTC实现了webrtc H265编码的发送，相信很多网友也是这个初衷，所以大家聚到了一起，也是这个机缘让我认识了一众大佬，很多资深的音视频开发大佬都藏身于metaRTC的群里，我给自己打开了一扇窗，见识了更广阔的世界。在了解metaRTC后，很长一段时间没有怎么实质的做什么研究工作，metaRTC更新也很快，很多基于ffmpeg的，我也不熟，中途只是埋头做自己的pion系列服务器软件（其中大佬开源m7s（langhuihui/monibuca: 🧩 Monibuca is a Modularized, Extensible framework for building Streaming Server (github.com)）媒体服务器软件也给我极大的帮助），（期间做了一个kvs 的自研信令和flutterwebrtc客户端，这些都为我后来深入了解metaRTC打下了基础。在群里也就偶尔发一下言，潜水听大佬们讲一个一个的新概念和专业知识，受益良多，后来慢慢发现自己不能置身事外，正值杨大佬开始做metaRTC5.0稳定版，于是我开始跟进源码的运用，先后移植了自己以前基于kvs（）做的信令系统，完善了datachannel传输，多peer管理等，并基于IPC应用做了一个基于RV1126嵌入式IPC音视频的硬编传输（详见metaRTC性能测试_superxxd的博客-CSDN博客），也感受了群主强大的研发能力，深受鼓舞。但一直的梦想H265 浏览器播放没有得到满足。

        在8月12日晚上，我在群里发言，希望做一个基于metaRTC的H265网页版的播放器，以下是当时的热闹的聊天信息

    6328e3fe694147d6ac9afe0c381eb97c.png14fdc6944e1c46889ddf8719bdf5db59.png

     50a01fd6463a438a8f60651c36f450a2.png

        从当时的发言，看得出来，我的确是一脸懵逼，甚至连wasm不能硬解都不清楚，只是听说过。但是因为我认为实现过程比实现本身的价值更高，于是就义无反顾地出发了，惯用套路，各种baidu,github,也发现了前辈大佬们做了相当多的工作，于是在他们的基础上开始干活，直接在别人项目上动手测试，先看看是怎么运作的，效果是什么样的，然后一点一点的根据自己的想法实现文件传输，解码播放，测试、性能优化。中间各种花屏，解码不成功，不出图。让我都想要放弃。但事实证明实现的过程比实现本身更有价值，过程会让你将书本知识变成自己的理解，融入自己的知识体系。现在终于实现了一版好于我预期的播放器。初始源码开源在如下地址https://github.com/xiangxud/webrtc_H265player，欢迎大家star,fork 和提issue pr

       我先在我的go写的项目里面验证我的想法，于是写了datachannel h265视频编码发送的函数，并实现了帧的解析

    1. const (
    2. 	//H265
    3. 	// https://zhuanlan.zhihu.com/p/458497037
    4. 	NALU_H265_VPS       = 0x4001
    5. 	NALU_H265_SPS       = 0x4201
    6. 	NALU_H265_PPS       = 0x4401
    7. 	NALU_H265_SEI       = 0x4e01
    8. 	NALU_H265_IFRAME    = 0x2601
    9. 	NALU_H265_PFRAME    = 0x0201
    10. 	HEVC_NAL_TRAIL_N    = 0
    11. 	HEVC_NAL_TRAIL_R    = 1
    12. 	HEVC_NAL_TSA_N      = 2
    13. 	HEVC_NAL_TSA_R      = 3
    14. 	HEVC_NAL_STSA_N     = 4
    15. 	HEVC_NAL_STSA_R     = 5
    16. 	HEVC_NAL_BLA_W_LP   = 16
    17. 	HEVC_NAL_BLA_W_RADL = 17
    18. 	HEVC_NAL_BLA_N_LP   = 18
    19. 	HEVC_NAL_IDR_W_RADL = 19
    20. 	HEVC_NAL_IDR_N_LP   = 20
    21. 	HEVC_NAL_CRA_NUT    = 21
    22. 	HEVC_NAL_RADL_N     = 6
    23. 	HEVC_NAL_RADL_R     = 7
    24. 	HEVC_NAL_RASL_N     = 8
    25. 	HEVC_NAL_RASL_R     = 9
    26. )
    27.  
    28. // int type = (NALU头第一字节 & 0x7E) >> 1
    29. // hvcC extradata是一种头描述的格式。而annex-b格式中，则是将VPS, SPS和PPS等同于普通NAL，用start code分隔，非常简单。Annex-B格式的”extradata”：
    30.  
    31. // start code+VPS+start code+SPS+start code+PPS
    32. //格式详情参见以下博客
    33. // 作者：一川烟草i蓑衣
    34. // 链接：https://www.jianshu.com/p/909071e8f8c6
    35.  
    36. func GetFrameTypeName(frametype uint16) (string, error) {
    37. 	switch frametype {
    38. 	case NALU_H265_VPS:
    39. 		return "H265_FRAME_VPS", nil
    40. 	case NALU_H265_SPS:
    41. 		return "H265_FRAME_SPS", nil
    42. 	case NALU_H265_PPS:
    43. 		return "H265_FRAME_PPS", nil
    44. 	case NALU_H265_SEI:
    45. 		return "H265_FRAME_SEI", nil
    46. 	case NALU_H265_IFRAME:
    47. 		return "H265_FRAME_I", nil
    48. 	case NALU_H265_PFRAME:
    49. 		return "H265_FRAME_P", nil
    50. 	default:
    51. 		return "", errors.New("frametype unsupport")
    52. 	}
    53. }
    54. func FindStartCode2(Buf []byte) bool {
    55. 	if Buf[0] != 0 || Buf[1] != 0 || Buf[2] != 1 {
    56. 		return false //判断是否为0x000001,如果是返回1
    57. 	} else {
    58. 		return true
    59. 	}
    60. }
    61.  
    62. func FindStartCode3(Buf []byte) bool {
    63. 	if Buf[0] != 0 || Buf[1] != 0 || Buf[2] != 0 || Buf[3] != 1 {
    64. 		return false //判断是否为0x00000001,如果是返回1
    65. 	} else {
    66. 		return true
    67. 	}
    68. }
    69. func GetFrameType(pdata []byte) (uint8, uint16, error) {
    70. 	var frametype uint16
    71.  
    72. 	destcount := 0
    73. 	// naluendptr := 0
    74. 	if FindStartCode2(pdata) {
    75. 		destcount = 3
    76. 	} else if FindStartCode3(pdata) {
    77. 		destcount = 4
    78. 	} else {
    79. 		return 0, 0, errors.New("not find")
    80. 	}
    81. 	temptype := (pdata[destcount] & 0x7E) >> 1
    82. 	bytesBuffer := bytes.NewBuffer(pdata[destcount : destcount+2])
    83. 	binary.Read(bytesBuffer, binary.BigEndian, &frametype)
    84. 	fmt.Printf("temptype :%02x type is 0x%04x", temptype, frametype)
    85. 	return temptype, frametype, nil
    86. }
    1. func H265DataChannelHandler(dc *webrtc.DataChannel, mediatype string) {
    2. 	fmt.Printf("H265DataChannelHandler\n")
    3.  
    4. 	dc.OnOpen(func() {
    5.  
    6. 		nInSendH265Track++
    7. 		fmt.Printf("dc.OnOpen %d\n", nInSendH265Track)
    8. 		sendH265ImportFrame(dc, utils.NALU_H265_SEI)
    9. 		sendH265ImportFrame(dc, utils.NALU_H265_VPS)
    10. 		sendH265ImportFrame(dc, utils.NALU_H265_SPS)
    11. 		sendH265ImportFrame(dc, utils.NALU_H265_PPS)
    12. 		sendH265ImportFrame(dc, utils.NALU_H265_IFRAME)
    13.  
    14. 		if nInSendH265Track <= 1 {
    15.  
    16. 			go func() {
    17. 				fmt.Println("read stdin for h265\n")
    18. 				fmt.Println("start thread for  h265 ok\n")
    19. 				sig := make(chan os.Signal)
    20. 				signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL, syscall.SIGABRT, syscall.SIGQUIT)
    21. 				var file *os.File
    22. 				var err error
    23. 				if !USE_FILE_UPLOAD {
    24. 					rk1126.ResumeH264()
    25. 				} else {
    26. 					fileName := "./h265_high.mp4"
    27. 					file, err = os.Open(fileName)
    28. 					defer file.Close()
    29. 					if err != nil {
    30. 						fmt.Println("Open the file failed,err:", err)
    31. 						os.Exit(-1)
    32. 					}
    33. 					fmt.Println("open file ", fileName, " ok\n")
    34.  
    35. 				}
    36. 				// // h264FrameDuration=
    37. 				timestart := time.Now().UnixMilli()
    38. 				ticker := time.NewTicker(h264FrameDuration)
    39. 				defer ticker.Stop()
    40. 				for {
    41. 					select {
    42.  
    43. 					case <-sig:
    44. 						rk1126.PauseH264()
    45. 						break
    46. 					case <-sysvideochan:
    47. 						rk1126.PauseH264()
    48. 						fmt.Println("sysvideochan exit")
    49. 						nInSendH265Track = 0
    50. 						return
    51. 					case <-ticker.C:
    52. 						// default:
    53. 						if nInSendH265Track <= 0 {
    54. 							rk1126.PauseH264()
    55. 							fmt.Println("no dc channel exit")
    56. 							return
    57. 						}
    58. 						if USE_FILE_UPLOAD {
    59. 							var arr [256]byte
    60. 							var buf []byte
    61. 							bufflen := 0
    62. 							for {
    63. 								// var arr [MAXPACKETSIZE]byte
    64.  
    65. 								n, err := file.Read(arr[:])
    66. 								if err == io.EOF {
    67. 									fmt.Println("file read finished")
    68. 									file.Seek(0, 0)
    69. 									continue
    70. 									//break
    71. 								}
    72. 								if err != nil {
    73. 									fmt.Println("file read failed", err)
    74. 									os.Exit(-1)
    75. 								}
    76. 								buf = append(buf, arr[:n]...)
    77. 								bufflen += n
    78. 								if bufflen >= MAXPACKETSIZE {
    79. 									break
    80. 								}
    81. 							}
    82. 							h265 := &rk1126.Mediadata{}
    83. 							h265.Data = buf
    84. 							h265.Len = bufflen
    85. 							timestart := time.Now().UnixMilli()
    86. 							for _, vdc := range H265dcmap {
    87. 								SendH265FrameData(vdc, h265, timestart)
    88. 							}
    89. 							time.Sleep(h264FrameDuration)
    90. 						} else {
    91. 							delayms := time.Now().UnixMilli() - timestart
    92. 							fmt.Println("send H265 delay ", delayms)
    93. 							// fmt.Println("GetH264Data start nInSendH264Track->", nInSendH264Track)
    94. 							timestart = time.Now().UnixMilli()
    95. 							h265 := rk1126.GetH264Data()
    96. 							// data := h264.Data[0 : h264.Len-1]
    97. 							if h265 != nil {
    98. 								for _, vdc := range H265dcmap {
    99. 									// fmt.Println("\r\nSendH265FrameData ", vdc)
    100. 									SendH265FrameData(vdc, h265, h265.Timestamp.Milliseconds())
    101. 								}
    102. 								rk1126.VideoDone(h265)
    103. 								// fmt.Println("\r\nh264 send ok")
    104. 							} else {
    105. 								fmt.Println("h265 data is nil")
    106. 							}
    107.  
    108. 						}
    109.  
    110. 					}
    111.  
    112. 				}
    113. 				fmt.Println("h265 thread exit")
    114. 				nInSendH265Track = 0
    115. 			}()
    116. 		}
    117. 	})
    118. 	dc.OnMessage(func(msg webrtc.DataChannelMessage) {
    119. 		msg_ := string(msg.Data)
    120. 		fmt.Println(msg_)
    121.  
    122. 	})
    123. 	dc.OnClose(func() {
    124. 		fmt.Println("hd265 dc close")
    125. 		nInSendH265Track--
    126. 		for k, v := range H265dcmap {
    127. 			if v == dc {
    128. 				delete(H265dcmap, k)
    129. 			}
    130. 		}
    131. 		if mediatype == "audio" {
    132. 			nInSendAudioTrack--
    133. 			if nInSendAudioTrack <= 0 {
    134. 				//用户全部退出就是让采集程序退出
    135. 				fmt.Println("sysaudiochan 退出")
    136. 				if sysaudiochan != nil {
    137. 					sysaudiochan <- struct{}{}
    138. 				}
    139. 			}
    140.  
    141. 		}
    142. 		// syschan <- struct{}{}
    143. 	})
    144.  
    145. }
    146.  
    147. var vpsFrame rk1126.Mediadata
    148. var spsFrame rk1126.Mediadata
    149. var ppsFrame rk1126.Mediadata
    150. var seiFrame rk1126.Mediadata
    151. var keyFrame rk1126.Mediadata
    152.  
    153. func SaveFrameKeyData(pdata *rk1126.Mediadata, frametype uint16) {
    154. 	switch frametype {
    155. 	case utils.NALU_H265_VPS:
    156. 		vpsFrame = *pdata
    157. 	case utils.NALU_H265_SPS:
    158. 		spsFrame = *pdata
    159. 	case utils.NALU_H265_PPS:
    160. 		ppsFrame = *pdata
    161. 	case utils.NALU_H265_SEI:
    162. 		seiFrame = *pdata
    163. 	case utils.NALU_H265_IFRAME:
    164. 		keyFrame = *pdata
    165. 	default:
    166. 	}
    167. }
    168.  
    169. //重要帧发送
    170. func sendH265ImportFrame(dc *webrtc.DataChannel, frametype uint16) {
    171. 	start := time.Now().UnixMilli()
    172. 	switch frametype {
    173. 	case utils.NALU_H265_VPS:
    174. 		SendH265FrameData(dc, &vpsFrame, start)
    175.  
    176. 	case utils.NALU_H265_SPS:
    177. 		SendH265FrameData(dc, &vpsFrame, start)
    178.  
    179. 	case utils.NALU_H265_PPS:
    180. 		SendH265FrameData(dc, &ppsFrame, start)
    181.  
    182. 	case utils.NALU_H265_SEI:
    183. 		SendH265FrameData(dc, &seiFrame, start)
    184.  
    185. 	case utils.NALU_H265_IFRAME:
    186. 		SendH265FrameData(dc, &keyFrame, start)
    187.  
    188. 	default:
    189. 	}
    190. }
    191.  
    192.  
    193. func SendH265FrameData(dc *webrtc.DataChannel, h265frame *rk1126.Mediadata, timestamp int64) {
    194. 	// fmt.Println("start SendH265FrameData ", dc)
    195.  
    196. 	if h265frame.Len > 0 && dc != nil && dc.ReadyState() == webrtc.DataChannelStateOpen {
    197. 		var frametypestr string
    198. 		data := h265frame.Data[0:h265frame.Len]
    199. 		// data := base64.StdEncoding.EncodeToString(buf)
    200.  
    201. 		glength := len(data)
    202. 		count := glength / MAXPACKETSIZE
    203. 		rem := glength % MAXPACKETSIZE
    204. 		temptype, frametype, err := utils.GetFrameType(data)
    205.  
    206. 		if err != nil {
    207.  
    208. 		} else {
    209. 			SaveFrameKeyData(h265frame, frametype)
    210. 			frametypestr, err = utils.GetFrameTypeName(frametype)
    211. 		}
    212. 		// string.split(",")
    213. 		// string.split(":")
    214. 		startstr := "h265 start ,FrameType:" + frametypestr + ",nalutype:" + strconv.Itoa(int(temptype)) + ",pts:" + strconv.FormatInt(timestamp, 10) + ",Packetslen:" + strconv.Itoa(glength) + ",packets:" + strconv.Itoa(count) + ",rem:" + strconv.Itoa(rem)
    215.  
    216. 		// startstr := fmt.Sprintf("h265 start ,FrameType:%s,pts:%lld,Packetslen:%d,packets:%d,rem:%d", frametypestr, h265frame.Timestamp.Milliseconds(), glength, count, rem)
    217.  
    218. 		dc.SendText(startstr)
    219. 		fmt.Println("SendH265FrameData start ", startstr)
    220. 		i := 0
    221. 		for i = 0; i < count; i++ {
    222. 			lenth := i * MAXPACKETSIZE
    223. 			// dc.SendText("jpeg ID:" + strconv.Itoa(i))
    224. 			dc.Send(data[lenth : lenth+MAXPACKETSIZE])
    225. 			//fmt.Println("send len ", lenth, " :", data[lenth:lenth+MAXPACKETSIZE])
    226. 		}
    227. 		if rem != 0 {
    228. 			// dc.SendText("jpeg ID:" + strconv.Itoa(i))
    229. 			dc.Send(data[glength-rem : glength])
    230. 			//fmt.Println("send len ", rem, " :", data[glength-rem:glength])
    231. 		}
    232. 		dc.SendText("h265 end")
    233. 		//fmt.Println("send h265 end ")
    234. 	}
    235. }

    在js里面实现了H265帧流的接收和处理

    1.  
    2. //webrtc datachannel send h265 stream
    3.  
    4. const START_STR="h265 start";
    5. const FRAME_TYPE_STR="FrameType";
    6. const PACKET_LEN_STR="Packetslen";
    7. const PACKET_COUNT_STR="packets";
    8. const PACKET_PTS="pts";
    9. const PACKET_REM_STR="rem";
    10. const KEY_FRAME_TYPE="H265_FRAME_I"
    11. var frameType="";
    12. var isKeyFrame=false;
    13. var pts=0;
    14. var h265DC;
    15. var bWorking=false;
    16. var h265dataFrame=[];
    17. var h265data;
    18.  
    19. var dataIndex=0;
    20.  
    21. var h265datalen=0;
    22. var packet=0;
    23. var expectLength = 4;
    24. var bFindFirstKeyFrame=false;
    25.  
    26.  
    27.  
    28.             //	startstr := "h265 start ,FrameType:" + frametypestr + ",Packetslen:" + strconv.Itoa(glength) + ",packets:" + strconv.Itoa(count) + ",rem:" + strconv.Itoa(rem)
    29.  
    30. function isString(str){
    31.     return (typeof str=='string')&&str.constructor==String;
    32. }
    33.  
    34. function hexToStr(hex,encoding) {
    35.     var trimedStr = hex.trim();
    36.     var rawStr = trimedStr.substr(0, 2).toLowerCase() === "0x" ? trimedStr.substr(2) : trimedStr;
    37.     var len = rawStr.length;
    38.     if (len % 2 !== 0) {
    39.       alert("Illegal Format ASCII Code!");
    40.       return "";
    41.     }
    42.     var curCharCode;
    43.     var resultStr = [];
    44.     for (var i = 0; i < len; i = i + 2) {
    45.       curCharCode = parseInt(rawStr.substr(i, 2), 16);
    46.       resultStr.push(curCharCode);
    47.     }
    48.     // encoding为空时默认为utf-8
    49.     var bytesView = new Uint8Array(resultStr);
    50.     var str = new TextDecoder(encoding).decode(bytesView);
    51.     return str;
    52.   }
    53.   function deepCopy(arr) {
    54.     const newArr = []
    55.     for(let i in arr) {
    56.         console.log(arr[i])
    57.         if (typeof arr[i] === 'object') {
    58.             newArr[i] = deepCopy(arr[i])
    59.         } else {
    60.             newArr[i] = arr[i]
    61.         }
    62.     }
    63.     console.log(newArr)
    64.     return newArr
    65.     
    66. }
    67.  
    68. function dump_hex(h265data,h265datalen){
    69.     // console.log(h265data.toString());
    70.     var str="0x"
    71.     for (var i = 0; i < h265datalen; i ++ ) {
    72.         var byte =h265data.slice(i,i+1)[0];
    73.  
    74.         str+=byte.toString(16)
    75.         str+=" "
    76.     //   console.log((h265datalen+i).toString(16)+" ");
    77.     }
    78.     console.log(str);
    79. }
    80. function appendBuffer (buffer1, buffer2) {
    81.     var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
    82.     tmp.set(new Uint8Array(buffer1), 0);
    83.     tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
    84.     return tmp.buffer;
    85. };
    86. function reportStream(size){
    87.  
    88. }
    89.  
    90. function stopH265(){
    91.     if(h265DC!==null){
    92.     h265DC.close();
    93.     }
    94. }
    95. var receivet1=new Date().getTime();
    96. var bRecH265=false;
    97. function initH265DC(pc,player) {
    98.     console.log("initH265DC",Date());
    99.     h265DC = pc.createDataChannel("h265");
    100.  
    101.     // var ctx = canvas.getContext("2d");
    102.     
    103.     h265DC.onmessage = function (event) {
    104.         // console.log(bRecH265,":",event.data)
    105.         if(bRecH265){
    106.             if(isString(event.data)) {
    107.                 console.log("reveive: "+event.data)
    108.                 if(event.data.indexOf("h265 end")!=-1){
    109.                     bRecH265=false;
    110.                     // console.log("frame ok",":",event.data," len:"+h265datalen)
    111.                     if(h265datalen>0){
    112.                         // const framepacket=new Uint8Array(h265data) 
    113.                         const t2 = new Date().getTime()-receivet1;
    114.  
    115.                         if(frameType==="H265_FRAME_VPS"||frameType==="H265_FRAME_SPS"||frameType==="H265_FRAME_PPS"||frameType==="H265_FRAME_SEI"||frameType==="H265_FRAME_P")
    116.                         console.log("receive time:"+t2+" len:"+h265datalen);
    117.                         if(frameType==="H265_FRAME_P"&&!bFindFirstKeyFrame){
    118.                             return
    119.                         }
    120.                         bFindFirstKeyFrame=true;
    121.                        // h265dataFrame.push(new Uint8Array(h265data))
    122.                         var dataFrame=new Uint8Array(h265data)//deepCopy(h265data)//h265dataFrame.shift()
    123.                         var data={
    124.                             pts: pts,
    125.                             size: h265datalen,
    126.                             iskeyframe: isKeyFrame,
    127.                             packet: dataFrame//
    128.                             // new Uint8Array(h265data)//h265data//new Uint8Array(h265data)
    129.                         };
    130.                         var req = {
    131.                             t: ksendPlayerVideoFrameReq,
    132.                             l: h265datalen,
    133.                             d: data
    134.                         };
    135.                         player.postMessage(req,[req.d.packet.buffer]);
    136.  
    137.                         h265data=null; 
    138.                         h265datalen=0;
    139.                         packet=0;    
    140.                         receivet1=new Date().getTime();
    141.                     }
    142.           
    143.                     return;
    144.                 }
    145.             }else{
    146.                 if (h265data != null) {
    147.  
    148.                     h265data=appendBuffer(h265data,event.data);
    149.                 } else if (event.data.byteLength < expectLength) {
    150.                     h265data = event.data.slice(0);
    151.  
    152.                 } else {
    153.  
    154.                     h265data=event.data;
    155.  
    156.                 }
    157.  
    158.                 h265datalen+=event.data.byteLength;
    159.                 packet++;
    160.                 console.log("packet: "+packet+": t len"+h265datalen)
    161.                 return;
    162.             }
    163.  
    164.         }
    165.         if(isString(event.data)) {
    166.             let startstring = event.data
    167.             // console.log("reveive: "+startstring)
    168.             if(startstring.indexOf("h265 start")!=-1){
    169.             console.log(event.data );
    170.             const startarray=startstring.split(",");
    171.             //	startstr := "h265 start ,FrameType:" + frametypestr + ",Packetslen:" + strconv.Itoa(glength) + ",packets:" + strconv.Itoa(count) + ",rem:" + strconv.Itoa(rem)
    172.  
    173.             for(let i=0;i
    174.                 const parakv=startarray[i].split(":");
    175.                 if(parakv!==null){
    176.                     switch(parakv[0]){
    177.                         case START_STR:
    178.                            break;
    179.                         case PACKET_PTS:
    180.                             pts=parseInt(parakv[1])
    181.                             break;   
    182.                         case FRAME_TYPE_STR:
    183.                             frameType=parakv[1]
    184.                             if(frameType.indexOf(KEY_FRAME_TYPE)!==-1){
    185.                                 isKeyFrame=true;
    186.                             }else{
    187.                                 isKeyFrame=false;
    188.                             }
    189.                             break;
    190.                         case PACKET_LEN_STR:
    191.                             break;
    192.                         case PACKET_COUNT_STR:
    193.                             break;
    194.                         case PACKET_REM_STR:
    195.                             break;                
    196.                     }
    197.  
    198.                 }
    199.             }
    200. 	
    201.             bRecH265=true;
    202.             packet=0;
    203.             return; 
    204.             }
    205.         }
    206.     };
    207.  
    208.     h265DC.onopen = function () {
    209.         console.log("h265 datachannel open");
    210.  
    211.  
    212.         bWorking = true;
    213.  
    214.     };
    215.  
    216.     h265DC.onclose = function () {
    217.         console.log("h265 datachannel close");
    218.         bWorking=false;
    219.        
    220.     };
    221. }
    222.  
    223. function handleUpdates(canvas, dc) {
    224.     setInterval(function () {
    225.         if (bWorking){
    226.         dc.send(JSON.stringify({ type: "h265" })); // frame update request
    227.         }
    228.     }, 500);
    229. };
    230.  
    231.  
    232.

    接下来就是在metaRTC中的移植，因信令和采集部分以前已经做好（详见metaRTC p2p自建信令系统_superxxd的博客-CSDN博客），实现起来也比较方便，datachannel的交互以前也做了一个实现（详见metaRTC datachannel 实现 reply_superxxd的博客-CSDN博客）应为go和c师出同门所以移植实现并不难

    1. //metaRTC 发送datachannel 的函数
    2. void g_ipc_rtcrecv_sendData(int peeruid,uint8* data,int len,int mediatype){
    3.  
    4. 	if(len<=0 || data==null) return;
    5. 	YangFrame H265Frame;
    6. 	//H265Frame.payload=MEMCALLOC(1,len);
    7. 	//if(H265Frame.payload==NULL) {
    8. 	//   printf("H265Frame.payload MEMCALLOC fail\n");
    9. 	//   return;
    10. 	//}
    11. 	
    12. 	//IpcRtcSession* rtcHandle=(IpcRtcSession*)user;
    13. 	for(int32_t i=0;ipushs.vec.vsize;i++){
    14. 		YangPeerConnection* rtc=rtcHandle->pushs.vec.payload[i];
    15. 		//找到本peer
    16.         if(rtc->peer.streamconfig.uid==peeruid){
    17.  
    18. 			//memcpy(H265Frame.payload,data,len);
    19.             H265Frame.payload=data;
    20.             G265Frame.mediaType=mediatype;
    21. 			H265Frame.nb=len;
    22. 			H265Frame.pts=H265Frame.dts=GETTIME();
    23. 			printf("datachannel send out %s\n",(char*)H265Frame.payload);
    24.             rtc->on_message(&rtc->peer,&H265Frame);
    25. 		    break;
    26. 		}
    27. 	}	
    28. 	//SAFE_MEMFREE(H265Frame.payload);
    29. }
    30. #define MAXPACKETSIZE 65536
    31. void SendH265FrameData(int peeruid, uint8* data,int len, int64 timestamp ) {
    32.  
    33. 	if(data!=null &&len >0)  {
    34. 		char frametypestr[20];
    35.         char *endchar="h265 end";
    36.         char startstr[200+1]; 
    37.         int   frametype=0;
    38.  
    39.  
    40.         int count=0,rem=0;
    41. 		count = len/ MAXPACKETSIZE;
    42. 		rem = glength % MAXPACKETSIZE;
    43. 		if(GetFrameType(data,&frametype)==0){
    44. 			SaveFrameKeyData(h265frame, frametype);
    45. 			GetFrameTypeName(frametype,&frametypestr);
    46. 		}
    47. 		snprintf(startstr,200,"h265 start ,FrameType:%s,nalutype:%d,pts:%lld,Packetslen:%d,packets:%d,rem:%d",frametypestr,temptype,timestamp,len, count,rem);
    48. //	YANG_DATA_CHANNEL_STRING = 51,
    49. //	YANG_DATA_CHANNEL_BINARY = 53,
    50. 		    g_ipc_rtcrecv_sendData(peeruid,startstr,strlen(startstr),YANG_DATA_CHANNEL_STRING );
    51. 		printf("SendH265FrameData start ", startstr);
    52. 		int i = 0,lenth=0;
    53. 		for i = 0; i < count; i++ {
    54. 			lenth = i * MAXPACKETSIZE
    55. 			g_ipc_rtcrecv_sendData(peeruid,data+lenth,MAXPACKETSIZE,YANG_DATA_CHANNEL_BINARY );
    56. 		}
    57. 		if rem != 0 {
    58. 			g_ipc_rtcrecv_sendData(peeruid,data+len-rem,rem,YANG_DATA_CHANNEL_BINARY );
    59. 		}
    60. 		g_ipc_rtcrecv_sendData(peeruid,endchar,strlen(endchar),YANG_DATA_CHANNEL_STRING );
    61. 	}
    62. }

          以上即为webrtc 播放器的核心实现，metaRTC是一款优秀的嵌入式webrtc 软件包，以后还会支持quic协议，我们的播放器软件也可以很快速的移植到这种传输协议。

     播放器解码等实现（详见基于webrtc的p2p H265播放器实现一_superxxd的博客-CSDN博客），实测效果可以见我的头条号

    用webrtc h265播放器体验新版《雪山飞孤》，打破传统，利-今日头条 (toutiao.com)

    906cec170ce24963a2ff11db710a1187.png

     

    195165614c214e82a2d8eae9b586f265.png

    3d35f08798704c17ae0b7374ba7de335.jpg 

    768f57991ecc4f2e849dd268aba95afb.jpg 

    6bfbc72249eb49d4822f3d69237920cd.jpg 

     

     

     

  • 相关阅读:
    MySQL中如何处理并发写入问题？
    Jenkins实践指南--pipeline概述
    【ESP32】10.PCF8591数模转换器实验（IIC总线/wire库）
    Java中Map的4种遍历方式
    水平直逼高级病理学家！清华团队提出AI基础模型ROAM，实现胶质瘤精准诊断
    [附源码]JAVA毕业设计健康生活网站（系统+LW）
    latex公式写法
    C#（三十八）之StreamWriter StreamWriter使用方法及与FileStream类的区别
    python 删除特定字符所在行
    CSS中如何实现一个自适应正方形（宽高相等）的元素？
  • 原文地址：https://blog.csdn.net/superxxd/article/details/126615220