golang rtsp拉流测试

已于 2023-04-13 17:19:38 修改
阅读量1.9k 收藏 4
点赞数 1
分类专栏： go 音视频 文章标签： golang unix 开发语言
于 2022-07-27 13:39:01 首次发布
MIT License
本文链接：https://blog.csdn.net/weixin_44328568/article/details/126012854
版权

rtsp拉流接收数据包

注：setup包含音视频时要setup 2次，且setup 的路径要对的上a=control:trackID=0
在这里插入图片描述

/*	
 * auth    : dujingning
 * date    : 2021.09.12
 * license : MIT
*/
package main

import (
	"encoding/binary"
	"flag"
	"fmt"
	"log"
	"net"
	"regexp"
	"strings"
	"time"
)

const (
	version   = "RTSP/1.0"
	UserAgent = "User-Agent: djav1.0.0"
	rtspUrl   = "rtsp://192.168.1.61:554/test"
	cseq      = "CSeq: "
	Accept    = "Accept: application/sdp"
	Transport = "Transport: RTP/AVP/TCP;unicast;interleaved=0-1"
	Range     = "Range: npt=0.000-"
	Session   = "Session: "
)

const (
	DESCRIBE      = "DESCRIBE"
	ANNOUNCE      = "ANNOUNCE"
	GET_PARAMETER = "GET_PARAMETER"
	OPTIONS       = "OPTIONS"
	PAUSE         = "PAUSE"
	PLAY          = "PLAY"
	RECORD        = "RECORD"
	REDIRECT      = "REDIRECT"
	SETUP         = "SETUP"
	SET_PARAMETER = "SET_PARAMETER"
	TEARDOWN      = "TEARDOWN"
)

var rtspUrlIn string

func option() string {
	return OPTIONS + " " + rtspUrlIn + " " + version + "\r\n" +
		cseq + "1" + "\r\n" +
		UserAgent + "\r\n\r\n"
}

func describe() string {
	return DESCRIBE + " " + rtspUrlIn + " " + version + "\r\n" +
		cseq + "2" + "\r\n" +
		UserAgent + "\r\n" +
		Accept + "\r\n\r\n"
}

func setup() string {
	return SETUP + " " + rtspUrlIn + "/streamid=0 " + version + "\r\n" +
		cseq + "3" + "\r\n" +
		UserAgent + "\r\n" +
		Transport + "\r\n\r\n"
}

func play(sessionid string) string {
	return PLAY + " " + rtspUrlIn + " " + version + "\r\n" +
		cseq + "4" + "\r\n" +
		UserAgent + "\r\n" +
		Session + sessionid + "\r\n" +
		Range + "\r\n\r\n"
}

func teardown(sessionid string) string {
	return TEARDOWN + " " + rtspUrlIn + " " + version + "\r\n" +
		cseq + "4" + "\r\n" +
		UserAgent + "\r\n" +
		Session + sessionid + "\r\n\r\n"
}

func sendAndRecv(conn net.Conn, trimmedInput string) string {
	//发送数据
	if _, err := conn.Write([]byte(trimmedInput)); err != nil {
		fmt.Printf("write failed , err : %v\n", err)
		return ""
	}
	fmt.Println(trimmedInput)

	//接受数据
	var recvData = make([]byte, 1024)
	if _, err := conn.Read(recvData); err != nil {
		fmt.Printf("Read failed , err : %v\n", err)
		return ""
	}
	fmt.Println(string(recvData))

	return string(recvData)
}

func Recv(conn net.Conn) string {
	//接受数据
	var recvData = make([]byte, 1024*1024)
	var sumData uint64 = 0

	timeStart := time.Now().Unix()
	defer func() {
		log.Println("Time Out, Fully Recved size :", float64(sumData)/float64(1024*1024), "MB / ", float64(sumData)/float64(1024), "KB   ", float64(sumData)/float64(1024)/float64((time.Now().Unix()-timeStart)), "  KB/s", "   timeSpend:", time.Now().Unix()-timeStart)
		if p := recover(); p != nil {
			fmt.Printf("panic: %s\n", p)
		}
	}()

	var rtpLen, counter int
	rtpLen = 0
	counter = 0
	for {

		/* 读取会出现粘包，多个rtp包在同一个rtsp头下面 */
		if readSize, err := conn.Read(recvData); err != nil {
			conn.SetReadDeadline(time.Now().Add(time.Duration(3) * time.Second))
			log.Printf("Read failed , err : %v\n", err)
			//break
		} else {

			sumData += uint64(readSize)
			conn.SetReadDeadline(time.Now().Add(time.Duration(10) * time.Second))

			//log.Println("Read OK, Recv size :", readSize)
			if 0x24 == recvData[0] {
				//log.Println("rtp data")					// rtsp协议头 4 字节
				contentLen := make([]byte, 2)
				contentLen[0] = recvData[2]
				contentLen[1] = recvData[3]

				rtpLen = int(binary.BigEndian.Uint16(contentLen))
				rtpInfo := ParseRTP(recvData[4 : rtpLen+4]) // rtp协议头 16 字节

				/*

						The RTP header has the following format:

						0                   1                   2                   3
						0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
					   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
					   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
					   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
					   |                           timestamp                           |
					   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
					   |           synchronization source (SSRC) identifier            |
					   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
					   |            contributing source (CSRC) identifiers             |
					   |                             ....                              |
					   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

				*/

				log.Println("version:", recvData[4]>>6, " pt:", (recvData[5]<<1)>>1, " X", (recvData[4]>>4)&0x01, " rtpPayload: ", len(rtpInfo.Payload))
				//log.Println("version:", rtpInfo.Version, " payloadType:", rtpInfo.PayloadType, " timestamp:", rtpInfo.Timestamp)

				if 72 == rtpInfo.PayloadType {
					log.Println("Sender Report----------  : ", rtpInfo.PayloadType)
				}

				if 97 == rtpInfo.PayloadType {
					contentLen := make([]byte, 2)
					contentLen[0] = recvData[0]
					contentLen[1] = recvData[1]
					//result := int(binary.BigEndian.Uint16(contentLen))
					//log.Println("rtp payload audio ~~~~~~~~~~~~  : ", rtpInfo.PayloadType, " rtpPayload: ", len(rtpInfo.Payload), " ADTS:", result)
				}

				//log.Println("rtp data  == rtpLen:", rtpLen, "\treadSize-4:", readSize, "\tequal?", rtpLen == readSize-4, " rtpVersion: ", rtpInfo.Version, " rtpExtension: ", rtpInfo.Extension, " rtpPayloadType: ", rtpInfo.PayloadType," rtpPayload: ", len(rtpInfo.Payload) )
			}

			if (rtpLen + 4) == readSize {
				//log.Println("same size~~~")
			} else {

				if 0x24 == recvData[rtpLen+4] {
					//log.Println("rtp data 粘包了了了了了了了")					// rtsp协议头 4 字节
					contentLen := make([]byte, 2)
					contentLen[0] = recvData[rtpLen+4+2]
					contentLen[1] = recvData[rtpLen+4+3]

					rtpLen2 := int(binary.BigEndian.Uint16(contentLen))
					rtpInfo := ParseRTP(recvData[rtpLen+4+4 : rtpLen+4+rtpLen2+4]) // rtp协议头 16 字节, 分片时注意每次rtsp都会占用4个字节

					if 72 == rtpInfo.PayloadType {
						log.Println("Sender Report~~~~~~~~~~~~  : ", rtpInfo.PayloadType)
					}

					//log.Println("rtp data  == rtpLen2:", rtpLen2, "\treadSize-4:", readSize -rtpLen-4 , " rtpVersion: ", rtpInfo.Version, " rtpExtension: ", rtpInfo.Extension, " rtpPayloadType: ", rtpInfo.PayloadType," rtpPayload: ", len(rtpInfo.Payload) )
				}

				//log.Println("not same size~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~=============================================================================================")
			}

			counter += readSize - 4
			if rtpLen == counter {
				//log.Println("a rtp pack Read OK, Recv sum size :", rtpLen)

				rtpLen = 0
				counter = 0
			}

			var size int = 0
			for size > readSize {
				if 0x24 == recvData[size] {
					contentLen := make([]byte, 2)
					contentLen[0] = recvData[size+2]
					contentLen[1] = recvData[size+3]
					rtpLen = int(binary.BigEndian.Uint16(contentLen))
					log.Println("rtp data???    rtpLen:", rtpLen, "\treadSize-4:", readSize-4, "\tequal?", rtpLen == readSize-4)
				}
				size += 1
			}
			/*
				if 0xc8 == recvData[5] {
					log.Println("Sender Report from Server")
				}

				if 28 == int16(recvData[3]) {

					log.Println("Read OK, Recv size :", readSize, "   首字节:", uint8(recvData[0]), "  channel：", uint8(recvData[1]), "  package type:", uint16(recvData[3]))
				}
			*/
		}
	}

	return string(recvData)
}

type Request struct {
	Method  string
	URL     string
	Version string
	Header  map[string]string
	Content string
	Body    string
}

func NewRequest(content string) *Request {
	lines := strings.Split(strings.TrimSpace(content), "\r\n")
	if len(lines) == 0 {
		return nil
	}
	items := regexp.MustCompile("\\s+").Split(strings.TrimSpace(lines[0]), -1) /*  \s+：匹配任意多个上面的字符 */
	if len(items) < 3 {
		return nil
	}
	if !strings.HasPrefix(items[2], "RTSP") {
		log.Printf("invalid rtsp request, line[0] %s", lines[0])
		return nil
	}
	header := make(map[string]string)
	for i := 1; i < len(lines); i++ {
		line := strings.TrimSpace(lines[i])
		headerItems := regexp.MustCompile(":\\s+").Split(line, 2)
		if len(headerItems) < 2 {
			continue
		}
		header[headerItems[0]] = headerItems[1]
	}
	return &Request{
		Method:  items[0],
		URL:     items[1],
		Version: items[2],
		Header:  header,
		Content: content,
		Body:    "",
	}
}

func getIpFromUrl(url string) string {
	m_ip := strings.Split(url, "/")
	log.Println(m_ip[2])
	return m_ip[2]
}

const (
	RTP_FIXED_HEADER_LENGTH = 12
)

type RTPInfo struct {
	Version        int
	Padding        bool
	Extension      bool
	CSRCCnt        int
	Marker         bool
	PayloadType    int
	SequenceNumber int
	Timestamp      int
	SSRC           int
	Payload        []byte
}

func ParseRTP(rtpBytes []byte) *RTPInfo {
	if len(rtpBytes) < RTP_FIXED_HEADER_LENGTH {
		return nil
	}
	firstByte := rtpBytes[0]
	secondByte := rtpBytes[1]
	info := &RTPInfo{
		Version:   int(firstByte >> 6),
		Padding:   (firstByte>>5)&1 == 1,
		Extension: (firstByte>>4)&1 == 1,
		CSRCCnt:   int(firstByte & 0x0f),

		Marker:         secondByte>>7 == 1,
		PayloadType:    int(secondByte & 0x7f),
		SequenceNumber: int(binary.BigEndian.Uint16(rtpBytes[2:])),
		Timestamp:      int(binary.BigEndian.Uint32(rtpBytes[4:])),
		SSRC:           int(binary.BigEndian.Uint32(rtpBytes[8:])),
	}
	offset := RTP_FIXED_HEADER_LENGTH
	end := len(rtpBytes)
	if end-offset >= 4*info.CSRCCnt {
		offset += 4 * info.CSRCCnt
	}
	if info.Extension && end-offset >= 4 {
		extLen := 4 * int(binary.BigEndian.Uint16(rtpBytes[offset+2:]))
		offset += 4
		if end-offset >= extLen {
			offset += extLen
		}
	}
	if info.Padding && end-offset > 0 {
		paddingLen := int(rtpBytes[end-1])
		if end-offset >= paddingLen {
			end -= paddingLen
		}
	}
	info.Payload = rtpBytes[offset:end]
	return info
}

var m_rtspUrl = flag.String("url", "rtsp url", "rtsp 地址，如：rtsp://127.0.0.1/stream")

/* go run .\rtsp.go --url=rtsp://192.168.1.61:554/test1 */
func main() {
	flag.Parse()
	var inputRtspUrl, serverIp string
	if "rtsp url" == *m_rtspUrl {
		fmt.Print("rtsp addr:")
		fmt.Scan(&inputRtspUrl)

		serverIp = getIpFromUrl(inputRtspUrl)
		rtspUrlIn = inputRtspUrl
	} else {
		serverIp = getIpFromUrl(*m_rtspUrl)
		rtspUrlIn = *m_rtspUrl
	}

	log.SetPrefix("[rtsp] ")
	log.SetFlags(log.Lshortfile | log.LstdFlags)

	//conn, err := net.Dial("tcp", "192.168.1.61:554")
	conn, err := net.Dial("tcp", serverIp)
	if err != nil {
		fmt.Printf("connect failed, err : %v\n", err.Error())
		return
	}
	defer conn.Close()

	// OPTIONS
	recvdata := sendAndRecv(conn, option())

	/*
		req := NewRequest(option())
		log.Println(req.Header)
		log.Println(req.URL)
		log.Println(req.Content)
		log.Println(req.Method)
	*/

	// 获取 Session ID
	s := strings.Split(recvdata, "\r\n")
	var Sessionid string
	for i := range s {
		if strings.Contains(s[i], "Session") {
			s = strings.Split(s[i], " ")
			//fmt.Println(s[1])
			Sessionid = s[1]
			break
		}
	}

	// DESCRIBE
	if strings.Contains(sendAndRecv(conn, describe()), "404") {
		log.Println("流不存在\r\n")
		sendAndRecv(conn, teardown(Sessionid))
		//time.Sleep(3 * time.Second)
		return
	}

	// SETUP
	sendAndRecv(conn, setup())

	// PLAY
	sendAndRecv(conn, play(Sessionid))

	// TEARDOWN
	defer sendAndRecv(conn, teardown(Sessionid))

	// rtp data
	Recv(conn)

	//time.Sleep(5 * time.Second)

	//conn.SetReadDeadline(time.Now().Add(time.Duration(2) * time.Second))

}
ThatJin
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
Web网页实现多路播放RTSP视频流（使用WebRTC）
郄梦岩的博客
08-03 6257
Web网页实现多路播放RTSP视频流（使用WebRTC）
golang rtsp流带声音 转码到web 无插件播放
03-25
golang rtsp 转码到web 无插件播放
基于easydarwin实现的rtsp拉流转发功能
02-10
基于easydarwin实现的rtsp拉流转发功能，仅仅同过一个进程，可以实现多路流的拉流转发，充分利用darwin原有框架的高性能架构。此版本是vs2015 windows下的。
rtsp-simple-proxy是一个简单，易于使用且零依赖的RTSP代理-Golang开发
05-26
rtsp-simple-proxy是一种简单，易于使用且零依赖的RTSP代理，该软件可接收一个或多个现有RTSP流并将其提供给其他用户。 通常在以下情况之一中部署代理：rtsp-simple-proxy rtsp-simple-proxy是一种简单，易于使用且零依赖的RTSP代理，该软件接收一个或多个现有RTSP流并将其生成。可供其他用户使用。 通常在以下情况之一中部署代理：当有多个用户正在接收流并且带宽受限时，因此该代理用于一次接收流。 然后，用户可以连接到代理而不是原始源。 当str之间有NAT /防火墙时
全面解析开源RTSP流媒体服务器：功能、性能与应用场景对比
最新发布
全世界的博客
05-28 1882
是一种网络传输协议，专门设计用于控制具有实时特性的数据传输，如音频和视频。RTSP提供了一个可扩展的框架，使实时数据的受控、点播成为可能。该协议用于建立和控制终端之间的媒体会话，允许客户端通过发送请求来控制媒体服务器上的媒体流，例如启动、停止和暂停媒体播放。RTSP通常与RTP（Real-time Transport Protocol）和RTCP（RTP Control Protocol）一起使用，以提供数据的实时传输和控制。控制能力：RTSP提供了一种可扩展的框架，使实时数据的受控、点播成为可能。
Go-码流操作
A Flying Bird
10-22 718
[]byte常见操作学习笔记
Golang 流媒体音视频网络传输开源项目-LAL
q191201771的专栏
02-22 3537
一. lal 简介 lal是开源直播流媒体网络传输项目，主要由三部分组成： lalserver：流媒体转发服务器。类似于nginx-rtmp-module等服务，但支持更多的协议，提供更丰富的功能。 demo：一些小应用，比如推、拉流客户端，压测工具，流分析工具，调度示例程序等。类似于ffmpeg、ffprobe等应用。 pkg：流媒体协议库。类似于ffmpeg的libavformat等库。 lal github地址： https://github.com/q191201771/lal 以下是lal
浏览器播放rtsp视频流：4、jsmpeg+go实现局域网下的rtsp视频流web端播放
逍遥游的博客
10-31 3127
之前的rtsp转webrtc的方案存在如下缺陷：1.只支持h264；2.受限于webrtc的理解难度以及搭建turn/stun的p2p服务等问题，对于局域网下的业务需求来说有些杀猪用牛刀的意思；3.ios不支持webrtc。基于以上原因，我又找到了一些其它的方案进行了测试，目前看jsmpeg的方案更加适合我们的需求，而且普通压缩大小为135kb，gzip方式压缩后仅仅42kb，在嵌入式场景下也可以使用。
golang 使用ffmpeg获取rtsp流截图,并生成缩略图
u013071014的博客
10-20 2958
golang直接使用命令调用ffmpeg 获取rtsp码流截图。使用imaging包将截图生成缩略图。
rtsp:Go 中的 rtsp 实现
06-15
时间 rtsp在 Go 中实现了 RTSP。 开发重点是来自安全摄像头的视频流，但该库的开发应适用于任何类型的流。 目前， rtp和rtcp作为子包实现，但一旦库成熟，这可能会改变。 执照 rtsp在 BSD 3-clause 许可下获得许可。 有关详细信息，请参阅 LICENSE.BSD。
web无插件播放rtsp流和配套golang 的rtsp转码服务
03-08
Golang程序（可能就是goRtsp.exe）作为一个中间层，它接收RTSP流，对视频流进行处理（例如，转码、切片），然后提供一个Web友好的格式，如HLS，使Web前端可以轻松地通过AJAX或Fetch API请求并播放这些流。...
即用型RTSP服务器，允许通过UDP和TCP读取和发布视频和音频流-Golang开发
05-26
rtsp-simple-server rtsp-simple-server是一个简单，易于使用且零依赖的RTSP服务器，该程序允许多个用户读取或发布实时视频和音频流。 RTSP是定义rtsp-simple-server的标准协议rtsp-simple-server是一种简单，易于使用且零依赖的RTSP服务器，该软件允许多个用户发布和读取实时视频和音频流。 RTSP是一种标准化协议，它定义了如何在服务器的帮助下执行这些操作，阅读器和发布者均联系了RTSP，以协商流协议。 然后，服务器负责将发布者流中继到阅读器。 该软件是与
golang使用bass库播放mp3文件
12-09
golang使用bass.dll播放mp3文件
RTSP流转RTMP源码（官方资源）
04-04
rtsp转rtmp程序，从rtsp摄像机获取流，转换为rtmp push到服务器（官方资源）
golang测试代码，简单串口服务测试
07-22
本项目涉及的是一个Golang实现的串口服务测试，主要关注的是如何使用Go进行串口通信以及进行测试。串口通信是计算机通信的一种方式，常用于设备间的短距离通信，如嵌入式系统、打印机、GPS模块等。 首先，我们要...
使用golang解析rtp成H264裸码流
qq_41681715的博客
04-25 1629
funcUnpackRTP2H264(rtpPayload[]byte)[]byte{ iflen(rtpPayload)<=0{ returnnil } varout[]byte fu_indicator:=rtpPayload[0]//获取第一个字节 fu_header:=rtpPayload[1]...
手把手教你rtsp流媒体分析（引导篇，欢迎订阅专栏）
weixin_44834554的博客
06-01 4128
在安防行业中，onvif协议与gb协议是两种标准，gb是国内安防行业的标准，onvif是国外的安防行业的标准，其中gb28181中视频流是ps流、由设备、下级平台推送到上级平台，具有上公有云的特点，而onvif视频流采用的是rtsp,通常用于内网访问，当需要rtsp流可以上公有云的话，可以使用r-rtsp，r-rtsp交互流程正好与rtsp流程相反，由服务端主动发起请求。本文主要讲解了RTSP的主要流程以及RTP,RTCP的包分析，本文主要介绍的H264的包结构，希望能够让你对rtsp有个深刻的认识。
golang 摄像头截图命令版本
小码农的博客
10-24 646
需要安装ffmpeg 使用ffmpeg命令进行画面生成对应的jpg图片。
推流与拉流简概
yinshipin007的博客
03-03 2521
它由rtmp：//开头，包含了上传服务器地址，上传目录名和上传节点，三部分组成。所有的rtmp地址都是这种结构组成，基本同一个平台不同直播的地址前两部分是不变的。★文末名片可以免费领取音视频开发学习资料，内容包括（FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）以及音视频学习路线图等等。rtsp://172.31.164.23:8554/live/audio是rtsp服务的url。这里我们模拟本地视频播放并推流到rtsp服务器,然后采用vlc客户端播放rtsp流。
golang rtsp服务器
03-16
Golang（又称Go）是一种开源的编程语言，它具有高效、简洁和并发性强的特点。RTSP（Real-Time Streaming Protocol）是一种用于实时传输音视频数据的网络协议。在Golang中，你可以使用第三方库来实现一个RTSP服务器。 一个常用的Golang库是"pion/rtsp"，它提供了一个完整的RTSP服务器实现。使用该库，你可以创建一个RTSP服务器，接收来自客户端的请求，并进行音视频数据的传输。 以下是使用"pion/rtsp"库实现一个简单的Golang RTSP服务器的示例代码： ```go package main import ( "fmt" "log" "net" "github.com/pion/rtsp/v2" ) func main() { // 创建一个RTSP服务器 server := rtsp.NewServer() // 处理客户端连接 server.OnNewConnection(func(conn net.Conn) { log.Printf("New connection: %s", conn.RemoteAddr().String()) }) // 处理客户端请求 server.OnRequest(func(request *rtsp.Request) { log.Printf("Received request: %s", request.Method) }) // 启动服务器 err := server.ListenAndServe(":8554") if err != nil { log.Fatal(err) } fmt.Println("RTSP server started") } ``` 上述代码创建了一个RTSP服务器，并监听在本地的8554端口。当有新的客户端连接时，会打印出连接信息；当收到客户端的请求时，会打印出请求方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值