RTSP协议的一些分析（五）——使用RTSP传输H.264裸码流

最新推荐文章于 2024-05-29 00:05:11 发布
最新推荐文章于 2024-05-29 00:05:11 发布
阅读量2.4k 收藏 7
点赞数
分类专栏： 音视频编解码 文章标签： rtsp h.264
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangguoyu8023/article/details/106502971
版权

        把RTSP协议的一些分析（三）——简单的rtsp服务器的实现和RTSP协议的一些分析（四）——RTP传输H.264结合在一起，就是本文的内容，这里不做多介绍，直接上代码。

        rtp.h

#ifndef _RTP_H_
#define _RTP_H_
#include <stdint.h>

#define RTP_VESION              2

#define RTP_PAYLOAD_TYPE_H264   96
#define RTP_PAYLOAD_TYPE_AAC    97

#define RTP_HEADER_SIZE         12
#define RTP_MAX_PKT_SIZE        1400

/*
 *
 *    0                   1                   2                   3
 *    7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |V=2|P|X|  CC   |M|     PT      |       sequence number         |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |                           timestamp                           |
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *   |           synchronization source (SSRC) identifier            |
 *   +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
 *   |            contributing source (CSRC) identifiers             |
 *   :                             ....                              :
 *   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 *
 */
struct RtpHeader
{
    /* byte 0 */
    uint8_t csrcLen:4;
    uint8_t extension:1;
    uint8_t padding:1;
    uint8_t version:2;

    /* byte 1 */
    uint8_t payloadType:7;
    uint8_t marker:1;
    
    /* bytes 2,3 */
    uint16_t seq;
    
    /* bytes 4-7 */
    uint32_t timestamp;
    
    /* bytes 8-11 */
    uint32_t ssrc;
};

struct RtpPacket
{
    struct RtpHeader rtpHeader;
    uint8_t payload[0];
};

void rtpHeaderInit(struct RtpPacket* rtpPacket, uint8_t csrcLen, uint8_t extension,
                    uint8_t padding, uint8_t version, uint8_t payloadType, uint8_t marker,
                   uint16_t seq, uint32_t timestamp, uint32_t ssrc);
int rtpSendPacket(int socket, char* ip, int16_t port, struct RtpPacket* rtpPacket, uint32_t dataSize);

#endif

       rtp.c

/*
 * 浣滆€咃細_JT_
 * 鍗氬锛歨ttps://blog.csdn.net/weixin_42462202
 */
 
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "rtp.h"

void rtpHeaderInit(struct RtpPacket* rtpPacket, uint8_t csrcLen, uint8_t extension,
                    uint8_t padding, uint8_t version, uint8_t payloadType, uint8_t marker,
                   uint16_t seq, uint32_t timestamp, uint32_t ssrc)
{
    rtpPacket->rtpHeader.csrcLen = csrcLen;
    rtpPacket->rtpHeader.extension = extension;
    rtpPacket->rtpHeader.padding = padding;
    rtpPacket->rtpHeader.version = version;
    rtpPacket->rtpHeader.payloadType =  payloadType;
    rtpPacket->rtpHeader.marker = marker;
    rtpPacket->rtpHeader.seq = seq;
    rtpPacket->rtpHeader.timestamp = timestamp;
    rtpPacket->rtpHeader.ssrc = ssrc;
}

int rtpSendPacket(int socket, char* ip, int16_t port, struct RtpPacket* rtpPacket, uint32_t dataSize)
{
    struct sockaddr_in addr;
    int ret;

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip);

    rtpPacket->rtpHeader.seq = htons(rtpPacket->rtpHeader.seq);
    rtpPacket->rtpHeader.timestamp = htonl(rtpPacket->rtpHeader.timestamp);
    rtpPacket->rtpHeader.ssrc = htonl(rtpPacket->rtpHeader.ssrc);

    ret = sendto(socket, (void*)rtpPacket, dataSize+RTP_HEADER_SIZE, 0,
                    (struct sockaddr*)&addr, sizeof(addr));

    rtpPacket->rtpHeader.seq = ntohs(rtpPacket->rtpHeader.seq);
    rtpPacket->rtpHeader.timestamp = ntohl(rtpPacket->rtpHeader.timestamp);
    rtpPacket->rtpHeader.ssrc = ntohl(rtpPacket->rtpHeader.ssrc);

    return ret;
}

       h264_rtsp_server.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>

#include <fcntl.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "rtp.h"

#define H264_FILE_NAME  "test.h264"
#define CLIENT_IP       "10.14.33.103"
#define CLIENT_PORT     9832

#define BUF_MAX_SIZE    (1024*1024)
#define SERVER_RTP_PORT  55532
#define SERVER_RTCP_PORT 55533
#define SERVER_PORT     8554

#define HDR_CSEQ 			"CSeq"
#define HDR_RANGE 			"Range"
#define HDR_SESSION 		"Session"
#define HDR_TRANSPORT 		"Transport"

#define RTSP_METHOD_OPTIONS  "OPTIONS"
#define RTSP_METHOD_DESCRIBE "DESCRIBE"
#define RTSP_METHOD_SETUP 	 "SETUP"
#define RTSP_METHOD_PLAY 	 "PLAY"

typedef struct _RTSP_HDR_PARAM_
{
	unsigned int rtsp_cseq;
	unsigned int rtsp_session;
	unsigned int rtsp_clientRtpPort;
	unsigned int rtsp_clientRtcpPort;
	unsigned char rtsp_method[20];
	char rtsp_InBuffer[BUF_MAX_SIZE]; /*接收缓冲区*/
	char rtsp_OutBuffer[BUF_MAX_SIZE];/*发送缓冲区*/
}RTSP_HDR_PARAM;


static int createTcpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

static int createUdpSocket()
{
    int sockfd;
    int on = 1;

    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd < 0)
        return -1;

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));

    return sockfd;
}

static int bindSocketAddr(int sockfd, const char* ip, int port)
{
    struct sockaddr_in addr;

    addr.sin_family 		= AF_INET;
    addr.sin_port 			= htons(port);
    addr.sin_addr.s_addr 	= inet_addr(ip);

    if(bind(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0)
        return -1;

    return 0;
}

static int acceptClient(int sockfd, char* ip, int* port)
{
    int clientfd;
    socklen_t len = 0;
    struct sockaddr_in addr;

    memset(&addr, 0, sizeof(addr));
    len = sizeof(addr);

    clientfd = accept(sockfd, (struct sockaddr *)&addr, &len);
    if(clientfd < 0)
        return -1;
    
    strcpy(ip, inet_ntoa(addr.sin_addr));
    *port = ntohs(addr.sin_port);

    return clientfd;
}

static int RTSP_HandleMethodOPTIONS(RTSP_HDR_PARAM* pstRtspHdrParam)
{
    sprintf(pstRtspHdrParam->rtsp_OutBuffer,
					"RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Public: OPTIONS, DESCRIBE, SETUP, PLAY\r\n"
                    "\r\n",
                    pstRtspHdrParam->rtsp_cseq);
                
    return 0;

}

static int RTSP_HandleMethodDESCRIBE(RTSP_HDR_PARAM* pstRtspHdrParam)
{
	char sdp[500];
    char localIp[100];
	char url[255];
    sscanf(pstRtspHdrParam->rtsp_InBuffer, "%*s %256s",url);
    sscanf(pstRtspHdrParam->rtsp_InBuffer, "DESCRIBE rtsp://%[^:]:", localIp);
    sprintf(sdp, "v=0\r\n"
                 "o=- 9%ld 1 IN IP4 %s\r\n"
                 "t=0 0\r\n"
                 "a=control:*\r\n"
                 "m=video 0 RTP/AVP 96\r\n"
                 "a=rtpmap:96 H264/90000\r\n"
                 "a=control:track0\r\n",
                 time(NULL), localIp);
    
    sprintf(pstRtspHdrParam->rtsp_OutBuffer, 
					"RTSP/1.0 200 OK\r\n"
					"CSeq: %d\r\n"
                    "Content-Base: %s\r\n"
                    "Content-type: application/sdp\r\n"
                    "Content-length: %d\r\n\r\n"
                    "%s",
                    pstRtspHdrParam->rtsp_cseq,
                    url,
                    strlen(sdp),
                    sdp);
    return 0;

}

static int RTSP_HandleMethodSETUP(RTSP_HDR_PARAM* pstRtspHdrParam)
{
	char *p = NULL;
	if((p = strstr(pstRtspHdrParam->rtsp_InBuffer,HDR_TRANSPORT)))
	{
		sscanf(p, "Transport: RTP/AVP;unicast;client_port=%d-%d\r\n",
			 &pstRtspHdrParam->rtsp_clientRtpPort, &pstRtspHdrParam->rtsp_clientRtcpPort);
	}

    sprintf(pstRtspHdrParam->rtsp_OutBuffer, 
    				"RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d\r\n"
                    "Session: 66334873\r\n"
                    "\r\n",
                    pstRtspHdrParam->rtsp_cseq,
                    pstRtspHdrParam->rtsp_clientRtpPort,
                    pstRtspHdrParam->rtsp_clientRtcpPort,
                    SERVER_RTP_PORT,
                    SERVER_RTCP_PORT);
    return 0;
}

static int RTSP_HandleMethodPLAY(RTSP_HDR_PARAM* pstRtspHdrParam)
{
    sprintf(pstRtspHdrParam->rtsp_OutBuffer, 
					"RTSP/1.0 200 OK\r\n"
                    "CSeq: %d\r\n"
                    "Range: npt=0.000-\r\n"
                    "Session: 66334873; timeout=60\r\n"
                    "\r\n",
                    pstRtspHdrParam->rtsp_cseq);
    return 0;
}


static int RTSP_HandleMethod(RTSP_HDR_PARAM* pstRtspHdrParam)
{
	if(!strcmp(pstRtspHdrParam->rtsp_method,RTSP_METHOD_OPTIONS))
	{
		if(RTSP_HandleMethodOPTIONS(pstRtspHdrParam))
		{
			printf("failed to handle OPTIONS\n");
			return -1;
		}
	}
	else if(!strcmp(pstRtspHdrParam->rtsp_method,RTSP_METHOD_DESCRIBE))
	{
		if(RTSP_HandleMethodDESCRIBE(pstRtspHdrParam))
		{
			printf("failed to handle DESCRIBE\n");
			return -1;
		}
	}
	else if(!strcmp(pstRtspHdrParam->rtsp_method,RTSP_METHOD_SETUP))
	{
		if(RTSP_HandleMethodSETUP(pstRtspHdrParam))
		{
			printf("failed to handle SETUP\n");
			return -1;
		}
	}
	else if(!strcmp(pstRtspHdrParam->rtsp_method,RTSP_METHOD_PLAY))
	{
		if(RTSP_HandleMethodPLAY(pstRtspHdrParam))
		{
			printf("failed to handle PLAY\n");
			return -1;
		}
	}

	return 0;

}

static inline int startCode4(char* buf)
{
    if(buf[0] == 0 && buf[1] == 0 && buf[2] == 0 && buf[3] == 1)
        return 1;
    else
        return 0;
}

static char* findNextStartCode(char* buf, int len)
{
    int i;

    if(len < 4)
        return NULL;

    for(i = 0; i < len-4; i++)
    {
        if(startCode4(buf))
            return buf;
        
        buf++;
    }

    return NULL;
}


static int getFrameFromH264File(int fd, char* frame, int size)
{
    int rSize, frameSize;
    char* nextStartCode;

    if(fd < 0)
        return fd;

    rSize = read(fd, frame, size);
    if(!startCode4(frame))
        return -1;
    
    nextStartCode = findNextStartCode(frame+4, rSize-4);
    if(!nextStartCode)
    {
        lseek(fd, 0, SEEK_SET);
        frameSize = rSize;
    }
    else
    {
        frameSize = (nextStartCode-frame);
        lseek(fd, frameSize-rSize, SEEK_CUR);
    }

    return frameSize;
}

static int rtpSendH264Frame(int socket, char* ip, int16_t port,
                            struct RtpPacket* rtpPacket, uint8_t* frame, uint32_t frameSize)
{
    uint8_t naluType; // nalu第一个字节
    int sendBytes = 0;
    int ret;

    naluType = frame[0];

    if (frameSize <= RTP_MAX_PKT_SIZE) // nalu长度小于最大包场：单一NALU单元模式
    {
        /*
         *   0 1 2 3 4 5 6 7 8 9
         *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         *  |F|NRI|  Type   | a single NAL unit ... |
         *  +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */
        memcpy(rtpPacket->payload, frame, frameSize);
        ret = rtpSendPacket(socket, ip, port, rtpPacket, frameSize);
        if(ret < 0)
            return -1;

        rtpPacket->rtpHeader.seq++;
        sendBytes += ret;
        if ((naluType & 0x1F) == 7 || (naluType & 0x1F) == 8) // 如果是SPS、PPS就不需要加时间戳
            goto out;
    }
    else // nalu长度小于最大包场：分片模式
    {
        /*
         *  0                   1                   2
         *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         * | FU indicator  |   FU header   |   FU payload   ...  |
         * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
         */

        /*
         *     FU Indicator
         *    0 1 2 3 4 5 6 7
         *   +-+-+-+-+-+-+-+-+
         *   |F|NRI|  Type   |
         *   +---------------+
         */

        /*
         *      FU Header
         *    0 1 2 3 4 5 6 7
         *   +-+-+-+-+-+-+-+-+
         *   |S|E|R|  Type   |
         *   +---------------+
         */

        int pktNum = frameSize / RTP_MAX_PKT_SIZE;       // 有几个完整的包
        int remainPktSize = frameSize % RTP_MAX_PKT_SIZE; // 剩余不完整包的大小
        int i, pos = 1;

        /* 发送完整的包 */
        for (i = 0; i < pktNum; i++)
        {
            rtpPacket->payload[0] = (naluType & 0x60) | 28;
            rtpPacket->payload[1] = naluType & 0x1F;
            
            if (i == 0) //第一包数据
                rtpPacket->payload[1] |= 0x80; // start
            else if (remainPktSize == 0 && i == pktNum - 1) //最后一包数据
                rtpPacket->payload[1] |= 0x40; // end

            memcpy(rtpPacket->payload+2, frame+pos, RTP_MAX_PKT_SIZE);
            ret = rtpSendPacket(socket, ip, port, rtpPacket, RTP_MAX_PKT_SIZE+2);
            if(ret < 0)
                return -1;

            rtpPacket->rtpHeader.seq++;
            sendBytes += ret;
            pos += RTP_MAX_PKT_SIZE;
        }

        /* 发送剩余的数据 */
        if (remainPktSize > 0)
        {
            rtpPacket->payload[0] = (naluType & 0x60) | 28;
            rtpPacket->payload[1] = naluType & 0x1F;
            rtpPacket->payload[1] |= 0x40; //end

            memcpy(rtpPacket->payload+2, frame+pos, remainPktSize+2);
            ret = rtpSendPacket(socket, ip, port, rtpPacket, remainPktSize+2);
            if(ret < 0)
                return -1;

            rtpPacket->rtpHeader.seq++;
            sendBytes += ret;
        }
    }

out:

    return sendBytes;
}

/*
*OPTIONS rtsp://10.1.74.190:8554 RTSP/1.0
*CSeq: 2
*User-Agent: LibVLC/3.0.4 (LIVE555 Streaming Media v2016.11.28)
*
*DESCRIBE rtsp://10.1.74.190:8554 RTSP/1.0
*CSeq: 3
*User-Agent: LibVLC/3.0.4 (LIVE555 Streaming Media v2016.11.28)
*Accept: application/sdp
*
*
*SETUP rtsp://10.1.74.190:8554/track0 RTSP/1.0
*CSeq: 4
*User-Agent: LibVLC/3.0.4 (LIVE555 Streaming Media v2016.11.28)
*Transport: RTP/AVP;unicast;client_port=63244-63245
*
*PLAY rtsp://10.1.74.190:8554 RTSP/1.0
*CSeq: 5
*User-Agent: LibVLC/3.0.4 (LIVE555 Streaming Media v2016.11.28)
*Session: 66334873
*Range: npt=0.000-
*
*/
static void doClient(int clientSockfd, const char* clientIP, int clientPort,
                        int serverRtpSockfd, int serverRtcpSockfd)
{
	int recvLen;
	int iRet = -1;
	char *p = NULL;
	RTSP_HDR_PARAM stRtspHdrParam;

	while(1)
    {
    	recvLen = recv(clientSockfd, stRtspHdrParam.rtsp_InBuffer, BUF_MAX_SIZE, 0);
		if(recvLen <= 0)
            goto out;
		stRtspHdrParam.rtsp_InBuffer[recvLen] = '\0';
		printf("---------------C->S--------------\n");
		printf("%s\n",stRtspHdrParam.rtsp_InBuffer);

		if (!sscanf(stRtspHdrParam.rtsp_InBuffer, "%s",stRtspHdrParam.rtsp_method))
	    {
	    	printf("prase url failed\n");
			goto out;
	    }

		if((p = strstr(stRtspHdrParam.rtsp_InBuffer,HDR_CSEQ)) != NULL)
		{		
			if(!sscanf(p, "%*s %d",&stRtspHdrParam.rtsp_cseq))
			{
				printf("prase Cseq failed\n");
				goto out;
			}
		}

		iRet = RTSP_HandleMethod(&stRtspHdrParam);
		if(iRet != 0)
		{
			printf("RTSP_HandleMethod failed\n");
			goto out;
		}
		
		printf("---------------S->C--------------\n");
		printf("%s\n",stRtspHdrParam.rtsp_OutBuffer);
		send(clientSockfd, stRtspHdrParam.rtsp_OutBuffer, strlen(stRtspHdrParam.rtsp_OutBuffer), 0);

		/* 开始播放，发送RTP包 */
		if(!strcmp(stRtspHdrParam.rtsp_method,RTSP_METHOD_PLAY))
		{
		 	int frameSize, startCode;
            char* frame = malloc(500000);
            struct RtpPacket* rtpPacket = (struct RtpPacket*)malloc(500000);
            int fd = open(H264_FILE_NAME, O_RDONLY);
			if(fd < 0)
			{
				printf("fd = %d\n",fd);
				goto out;
			}
            rtpHeaderInit(rtpPacket, 0, 0, 0, RTP_VESION, RTP_PAYLOAD_TYPE_H264, 0,
                            0, 0, 0x88923423);

            printf("start play\n");
            printf("client ip:%s\n", clientIP);
            printf("client port:%d\n", stRtspHdrParam.rtsp_clientRtpPort);

			while(1)
			{
				frameSize = getFrameFromH264File(fd, frame, 500000);
				if(frameSize < 0)
				{
					printf("read err\n");
					continue;
				}
		
				if(startCode4(frame))
					startCode = 4;
		
				frameSize -= startCode;
				rtpSendH264Frame(serverRtpSockfd, CLIENT_IP, stRtspHdrParam.rtsp_clientRtpPort,
									rtpPacket, frame+startCode, frameSize);
				rtpPacket->rtpHeader.timestamp += 90000/25;
		
				usleep(1000*1000/25);
			}
			free(frame);
            free(rtpPacket);
            goto out;
		}
		
	}

out:
	close(clientSockfd);

}

int main(int argc, char* argv[])
{
    int serverSockfd;
    int serverRtpSockfd, serverRtcpSockfd;
    int ret;

	/* 1. 创建TCP   socket */
    serverSockfd = createTcpSocket();
    if(serverSockfd < 0)
    {
        printf("failed to create tcp socket\n");
        return -1;
    }

	/* 2. 绑定TCP   socket */
	ret = bindSocketAddr(serverSockfd, "0.0.0.0", SERVER_PORT);
    if(ret < 0)
    {
        printf("failed to bind addr\n");
        return -1;
    }

	/* 3. 监听 */
    ret = listen(serverSockfd, 10);
    if(ret < 0)
    {
        printf("failed to listen\n");
        return -1;
    }


	/* 4. 创建UDP socket */
    serverRtpSockfd = createUdpSocket();
    serverRtcpSockfd = createUdpSocket();
    if(serverRtpSockfd < 0 || serverRtcpSockfd < 0)
    {
        printf("failed to create udp socket\n");
        return -1;
    }

	/* 5. 绑定UDP   socket */
	if(bindSocketAddr(serverRtpSockfd, "0.0.0.0", SERVER_RTP_PORT) < 0 ||
        bindSocketAddr(serverRtcpSockfd, "0.0.0.0", SERVER_RTCP_PORT) < 0)
    {
        printf("failed to bind addr\n");
        return -1;
    }

	while(1)
	{
		int clientSockfd;
		char clientIp[40];
		int clientPort;

		clientSockfd = acceptClient(serverSockfd, clientIp, &clientPort);
		if(clientSockfd < 0)
		{
			printf("failed to accept client\n");
			return -1;
		}

		printf("accept client;client ip:%s,client port:%d\n", clientIp, clientPort);

		doClient(clientSockfd, clientIp, clientPort, serverRtpSockfd, serverRtcpSockfd);

	}
		
}

 

 

风雨兼程8023
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
H264: [ RTP传H264裸流 ] ＞ 如何传(关注点:H264部分)
总是春的博客
05-22 452
H264: [ RTP传H264裸流 ] ＞ 如何传(关注点:H264部分)
rstp协议tcp_RTSP流媒体数据传输的两种方式（TCP和UDP）
weixin_36087045的博客
12-23 1497
通常情况下rtsp协议中数据传输的实现是UDP，因工作需要，想让rtsp的数据传输部分用TCP实现。DarwinStreamingServer服务器能自适应客户端发起的数据传输请求是用TCP方式，还是用UDP方式，这里唯一需要解决的是客户端协议的发起问题，而vlc支持RTSP over TCP的方式。剩下的问题就好办了，让vlc以TCP的方式发起连接即可。DSS的安装配置我就不介绍了，不懂的朋友网...
RTP封装&h264原理&实现传输h264的RTSP服务器
最新发布
control_0317的博客
05-29 667
实现：客户端建立与RTSP服务端的连接后，并且在RTSP服务端回复了客户端的Play请求以后，服务端需要源源不断的读取一个本地h264视频文件，并将读取到的h264视频流封装到RTP数据包中，再推送至客户端。这样我们就实现了一个简单的支持RTSP协议流媒体分发服务。
FFmpeg推送UDP裸流，播放端花屏问题
梦之风舞者
10-26 2024
1. 前言 最近在调试流媒体服务器的bug，准备尝试一些新的方法，测试用FFmpeg将rtsp流转为UDP裸流的时候，发现当rtsp流是主码流，也就是1280*720时，播放端容易花屏，当我将rtsp流切换为子码流是，应该是704*576，然后播放端再也没有出现过问题。 2. 问题总结 应该是播放端UDP缓冲区默认值正好介于900KB（1280*720）和396KB（804*576）之间，造成一部分数据丢失，所以播放端下方花屏越来越严重。因为这一区域的数据不断丢失。 3. 解决思路 播放端，应该.
H264 over RTP 的解包
Cloudy_cn的专栏
09-11 1638
前一版博文《H264 over RTP 的打包》已经详细介绍了发送端如何将H264视频帧打包到RTP进行传输，现在我们书接上文，介绍接收端收到RTP包后如何解包组装还原出来H264帧。从前文我们知道发送端发送一帧H264数据时会遍历H264帧逐个将NALU打包成RTP包（当然NALU大于MTU时会进行分片），每一帧数据对应的RTP包的时间戳都是相同的，最后一个RTP包的marked位为TRUE；因...
ONVIF网络摄像头(IPC)客户端开发—RTSP RTCP RTP加载H264视频流
Biao
10-05 6722
前言： RTSP,RTCP,RTP一般是一起使用，在FFmpeg和live555这些库中，它们为了更好的适用性，所以实现起来非常复杂，直接查看FFmpeg和Live555源代码来熟悉这些协议非常吃力，这里将它们独立出来实现，以便更好的理解协议。本文主要介绍RTSP,RTCP,RTP加载H264数据流。 说明： (1)大华IPC摄像头作为服务端 (2)在ubuntu16......
H264视频传输、编解码----RTSP协议
热门推荐
猿诗人的博客
01-28 1万+
RTSP(Real Time Streaming Protocol), 实时流传输协议, 它是TCP/IP协议体系中的一个应用层协议 它是对流媒体进行控制 的网络控制协议，可以对流媒体提供诸如播放、暂停、快进、停止等操作，它负责定义具体的控制消息、操作方法、状态码等，此外还描述了与RTP间的交互操作。 但是，实时流的传输并不是它负责，而是交给RTP、RTCP协议。 RTSP发送的指令一般通过
rtsp————总结资源
09-24
RTSP（Real Time Streaming Protocol，实时流传输协议）是一种用于控制多媒体数据流的协议，它在互联网上广泛应用于视频监控、在线直播等场景。本文将深入探讨如何将海康威视设备的RTSP流推送到H5页面，并讨论与之...
RTSP——client
02-11
RTSP（Real-Time Streaming Protocol，实时流协议）是一种应用层协议，主要用于控制音视频的实时传输。...通过分析和理解这段代码，我们可以深入学习RTSP和RTP协议的工作原理，以及如何处理H264视频数据的传输。
rtsp h265 hisi
06-28
在“rtsp h265 hisi”这个主题中，我们可以深入探讨RTSP协议与H265编码的结合使用，以及可能涉及到的硬件平台——如“hisi”，通常指的是华为海思的处理器，它们在多媒体处理方面有较强的能力。 首先，让我们来理解...
Android源码——RTSP播放器源码.zip
10-08
在Android平台上，RTSP（Real Time Streaming Protocol）是一种广泛用于实时流媒体传输的协议，它允许设备通过网络接收音频、视频和其他数据。本资源提供的"Android源码——RTSP播放器源码.zip"是一个实现RTSP播放...
h264裸流, 可用于rtmp和rtsp推流测试 猫和老鼠
11-29
h264裸流, 可用于rtmp和rtsp推流测试 猫和老鼠
RTSPAllTheThings：不推荐使用的RTSP媒体服务器-使用github.comaler9rtsp-simple-server代替
02-05
RTSP（Real-Time Streaming Protocol）是一种广泛用于视频流传输的协议，它允许客户端与服务器之间进行交互，实现实时音视频数据的传输。在本文中，我们将深入探讨RTSP媒体服务器，尤其是关于“RTSPAllTheThings”...
EasyRTSPLive摄像机NVR录像机RTSP协议实时流转RTMP协议直播流推送源码流程解析
Babosa的专栏
07-13 2816
在《海康大华等安防摄像机采用通用RTSP协议流转RTMP推送至Web无插件播放展示的流程方法》中，我们分析了整个将安防设备互联网化的主要思路，同时介绍了安防RTSP协议进行话联网化的RTMP输出的方法，这里我们主要介绍的就是其中描述的专门将RTSP流转换成RTMP推流的EasyRTSPLive的实现方法： EasyRTSPLive就是RTSP to RTMP，拉流IPC摄像机或者NVR硬盘录像机R...
ESP32-CAM网络摄像头系列-01-基于RTSP协议的局域网视频推流/拉流的简单实现
YANGJIERUN的博客
02-24 6355
【代码】基于RTSP协议的局域网视频拉流代码-Python3+Opencv实现。
RTSP协议的一些分析（四）——RTP传输H.264
yangguoyu8023的博客
06-01 1981
文章目录 一、RTP封装 1.1 RTP数据结构 1.2 RTP包的结构以及发包函数 1.3 源码 二、H.264的RTP打包 2.1H.264格式以及H.264的RTP打包方式 2.2 H.264 RTP包的时间戳计算 2.3 源码 三、H.264 RTP打包的sdp描述 四、测试 在写RTP传输H264之前，需要了解一些知识。1. RTP流的相关知识。2. H264、H265裸流NALU的格式。以上两点在网络流媒体（三）—RTP流有所介绍。 一、RTP封装 ...
rtsp视频流传输demo
李肖遥的专栏
07-29 1240
为提升全民收入【6天淘宝电商训练营】现面向全国公开招募200人统一培训淘宝开店赚钱技能不限年龄，不限经验，无需货源无论你是上班族、宝妈还是退休人员只要你想通过一技之长来提升收入就可以加入学习【特别提醒】此次培训将以线上视频+文字形式进行，共6天上课时间在晚上一对一讲师在线答疑+实操演练请放心扫码加入【报名通道】↓↓↓即将开讲仅限前200名，限时1元长按识别二维码添加老师......
rtsp建立交互流程及rtp打包h264码流
qq_32896111的博客
08-19 1147
环境： PC IP 192.168.135.171 板端IP：192.168.135.10 播放工具：VLC 开发板：海思hi3516ev200 应用概述： 海思板端使用sample_venc将从vi进来的视频进行h264编码，rtsp与客户端建立通信后，由rtp对h264码流进行打包并发送出去给VLC客户端播放。 文章说明： 该文是在网上一个大神的文章基础上修改的，我添加了一些wireshark...
一些rtsp实现的开源代码
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
03-18 1万+
一些rtsp实现的开源代码 2013-07-10 22:25 ⁄ 工业·编程 ⁄ 共 414字 ⁄ 字号 小 中 大 ⁄ 暂无评论 * live.com   C/S   C++   http://www.live555.com      * darwin     S     C++   http://www.opensource.apple.com/darwinsou
FFmpeg javaUDP 输出H264/265的码流 (传输协议RTP RTSP ONVIF)
03-27
FFmpeg是一个非常流行的音视频处理库，它支持各种音视频格式的编解码、转码、截取、合并等操作。其中，输出H.264/H.265的码流可以通过以下命令实现： ``` ffmpeg -i input.mp4 -codec:v libx264 -f rtp rtp://192.168.1.100:5000 ``` 其中，`input.mp4`是输入文件名，`libx264`是使用的视频编码器，`rtp`是输出协议，`192.168.1.100`是目标地址，`5000`是目标端口。 如果需要输出H.265的码流，只需要将`libx264`改成`libx265`即可。 对于RTSP和ONVIF协议，可以使用类似以下命令： ``` ffmpeg -i input.mp4 -codec:v libx264 -rtsp_transport tcp -f rtsp rtsp://192.168.1.100:554/live ``` 其中，`rtsp_transport`指定传输协议，`tcp`表示使用TCP传输，`rtsp`表示输出协议，`192.168.1.100`是目标地址，`554`是目标端口，`live`是流名。 注意：以上命令中的地址和端口需要根据实际情况修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值