😁博客主页😁：🚀https://blog.csdn.net/wkd_007🚀
🤑博客内容🤑：🍭嵌入式开发、Linux、C语言、C++、数据结构、音视频🍭
🤣本文内容🤣：🍭介绍怎么实现最简单的传输H264的RTSP服务器🍭
😎金句分享😎：🍭你不能选择最好的，但最好的会来选择你——泰戈尔🍭
⏰发布时间⏰： 2025-06-30

本文未经允许，不得转发！！！

目录

  • 🎄一、概述
  • 🎄二、实现步骤、实现细节
    • ✨2.1、使用RTSP服务的TCP套接字并监听
    • ✨2.2、接收客户端请求并处理RTSP命令
    • ✨2.3、读取H264并发送
  • 🎄三、传输H264的RTSP服务器的实现源码
  • 🎄四、总结

在这里插入图片描述

RTSP从零实践系列文章回顾：
【RTSP从零实践】1、根据RTSP协议实现一个RTSP服务
【RTSP从零实践】2、使用RTP协议封装并传输H264
【RTSP从零实践】3、实现最简单的传输H264的RTSP服务器
【RTSP从零实践】4、使用RTP协议封装并传输AAC

在这里插入图片描述

🎄一、概述

这篇文章主要就是介绍怎么通过RTSP协议通信，将H264视频数据封装成RTP包并发送的，目的是写一个最简单的RTSP服务器，熟悉RTSP协议处理、RTP协议封包。

包含了下面知识点：
1、RTSP协议的内容；
2、实现TCP协议实现RTSP；
3、RTP协议；
4、怎么实现RTP协议；

这些知识点都可以从上面 【RTSP从零实践】系列文章学习到，这篇文章不再赘述，只介绍步骤和代码。

在这里插入图片描述

🎄二、实现步骤、实现细节

这个小写介绍怎么实现的步骤、细节，下个小节会提供源码，可以结合着源码看帮助理解消化。

✨2.1、使用RTSP服务的TCP套接字并监听

RTSP协议是基于TCP作为传输层协议去实现的。

// 创建套接字
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0)
{perror("socket failed");return -1;
}// 设置套接字选项
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)))
{perror("setsockopt");return -1;
}address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY;
address.sin_port = htons(RTSP_PORT);// 绑定端口
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0)
{perror("bind failed");return -1;
}// 开始监听
if (listen(server_fd, MAX_CLIENTS) < 0)
{perror("listen");return -1;
}

✨2.2、接收客户端请求并处理RTSP命令

RTSP通信不直接传输音视频码流，会先进行一些命令通信，所以第二个步骤就是处理这些命令：

char response[1024] = {0}; // 构造响应
if (strcmp(method, "OPTIONS") == 0)
{rtsp_handle_OPTION(response, cseq);
}
else if (strcmp(method, "DESCRIBE") == 0)
{rtsp_handle_DESCRIBE(response, cseq);
}
else if (strcmp(method, "SETUP") == 0)
{rtsp_handle_SETUP(response, cseq, rtpPort);
}
else if (strcmp(method, "PLAY") == 0)
{rtsp_handle_PLAY(response, cseq);bSendFlag = RTP_PLAY;
}
else if (strcmp(method, "TEARDOWN") == 0)
{rtsp_handle_TEARDOWN(response, cseq);bSendFlag = RTP_STOP;
}
else
{snprintf(response, sizeof(response),"RTSP/1.0 501 Not Implemented\r\nCSeq: %d\r\n\r\n", cseq);
}

✨2.3、读取H264并发送

处理完RTSP命令后，就需要读取并发送RTP包了。

// h264
H264ReaderInfo_t h264Info;
if (H264_FileOpen(H264_FILE_NAME, &h264Info) < 0)
{printf("failed to open %s\n", H264_FILE_NAME);return NULL;
}H264Frame_t h264Frame;
h264Frame.pFrameBuf = (unsigned char *)malloc(1920 * 1080 * 4);while (pRtpSend->bPlayFlag)
{if (!H264_IsEndOfFile(&h264Info)){h264Frame.isLastFrame = 0;H264_GetFrame(&h264Frame, &h264Info);if (h264Frame.pFrameBuf != NULL){if (h264Frame.isLastFrame) // 最后一帧，移到开头重新读{printf("warning SeekFile 1\n");H264_SeekFile(&h264Info);}// printf("rtpSendH264Frame, frameNum=%d, time=%u\n", h264Info.frameNum, rtpPacket->rtpHeader.timestamp);rtpSendH264Frame(rtp_send_fd, cli_ip, rtpPort, rtpPacket,h264Frame.pFrameBuf + h264Frame.startcode_len,h264Frame.frame_len - h264Frame.startcode_len);rtpPacket->rtpHeader.timestamp += 90000 / FPS; // RTP 传输视频每秒 90k HZusleep(1000 * 1000 / FPS);}}else{printf("warning need SeekFile 1\n");}
}

在这里插入图片描述

🎄三、传输H264的RTSP服务器的实现源码

总共有5个源代码文件，具体如下：

1、H264Reader.h

/*** @file H264Reader.h* @author https://blog.csdn.net/wkd_007* @brief* @version 0.1* @date 2025-06-24** @copyright Copyright (c) 2025**/
#ifndef __H264_READER_H__
#define __H264_READER_H__#include <stdio.h>#define MAX_STARTCODE_LEN (4)typedef enum
{FALSE,TRUE,
} BOOL;typedef enum
{H264_NALU_TYPE_SLICE = 1,H264_NALU_TYPE_DPA = 2,H264_NALU_TYPE_DPB = 3,H264_NALU_TYPE_DPC = 4,H264_NALU_TYPE_IDR = 5,H264_NALU_TYPE_SEI = 6,H264_NALU_TYPE_SPS = 7,H264_NALU_TYPE_PPS = 8,H264_NALU_TYPE_AUD = 9,H264_NALU_TYPE_EOSEQ = 10,H264_NALU_TYPE_EOSTREAM = 11,H264_NALU_TYPE_FILL = 12,
} H264NaluType;typedef enum
{H264_NALU_PRIORITY_DISPOSABLE = 0,H264_NALU_PRIRITY_LOW = 1,H264_NALU_PRIORITY_HIGH = 2,H264_NALU_PRIORITY_HIGHEST = 3
} H264NaluPriority;typedef struct
{int startcode_len;        //! 4 for parameter sets and first slice in picture, 3 for everything else (suggested)int forbidden_bit;        //! should be always FALSEint nal_reference_idc;    //! H264_NALU_PRIORITY_xxxxint nal_unit_type;        //! H264_NALU_TYPE_xxxxBOOL isLastFrame;         //!int frame_len;            //!unsigned char *pFrameBuf; //!
} H264Frame_t;typedef struct H264ReaderInfo_s
{FILE *pFileFd;int frameNum;
} H264ReaderInfo_t;int H264_FileOpen(char *fileName, H264ReaderInfo_t *pH264Info);
int H264_FileClose(H264ReaderInfo_t *pH264Info);
int H264_GetFrame(H264Frame_t *pH264Frame, H264ReaderInfo_t *pH264Info);
BOOL H264_IsEndOfFile(const H264ReaderInfo_t *pH264Info);
void H264_SeekFile(H264ReaderInfo_t *pH264Info);#endif // __H264_READER_H__

2、H264Reader.c

/*** @file H264Reader.c* @author https://blog.csdn.net/wkd_007* @brief* @version 0.1* @date 2025-06-30** @copyright Copyright (c) 2025**/
#include "H264Reader.h"
#include <stdlib.h>#define MAX_FRAME_LEN (1920 * 1080 * 1.5) // 一帧数据最大字节数static BOOL findStartCode_001(unsigned char *Buf)
{// printf("[%d %d %d]\n", Buf[0], Buf[1], Buf[2]);return (Buf[0] == 0 && Buf[1] == 0 && Buf[2] == 1); // 0x000001?
}static BOOL findStartCode_0001(unsigned char *Buf)
{// printf("[%d %d %d %d]\n", Buf[0], Buf[1], Buf[2], Buf[3]);return (Buf[0] == 0 && Buf[1] == 0 && Buf[2] == 0 && Buf[3] == 1); // 0x00000001?
}int H264_FileOpen(char *fileName, H264ReaderInfo_t *pH264Info)
{pH264Info->pFileFd = fopen(fileName, "rb+");if (pH264Info->pFileFd == NULL){printf("[%s %d]Open file error\n", __FILE__, __LINE__);return -1;}pH264Info->frameNum = 0;return 0;
}int H264_FileClose(H264ReaderInfo_t *pH264Info)
{if (pH264Info->pFileFd != NULL){fclose(pH264Info->pFileFd);pH264Info->pFileFd = NULL;}return 0;
}BOOL H264_IsEndOfFile(const H264ReaderInfo_t *pH264Info)
{return feof(pH264Info->pFileFd);
}void H264_SeekFile(H264ReaderInfo_t *pH264Info)
{fseek(pH264Info->pFileFd, 0, SEEK_SET);pH264Info->frameNum = 0;
}/*** @brief 获取一阵h264视频帧** @param pH264Frame ：输出参数，使用后 pH264Frame->pFrameBuf 需要free* @param pH264Info ：输入参数* @return int*/
int H264_GetFrame(H264Frame_t *pH264Frame, H264ReaderInfo_t *pH264Info)
{int rewind = 0;if (pH264Info->pFileFd == NULL){printf("[%s %d]pFileFd error\n", __FILE__, __LINE__);return -1;}// 1.读取帧数据// unsigned char *pFrame = (unsigned char *)malloc(MAX_FRAME_LEN);unsigned char *pFrame = pH264Frame->pFrameBuf;int readLen = fread(pFrame, 1, MAX_FRAME_LEN, pH264Info->pFileFd);if (readLen <= 0){printf("[%s %d]fread error\n", __FILE__, __LINE__);// free(pFrame);return -1;}// 2.查找当前帧开始码int i = 0;for (; i < readLen - MAX_STARTCODE_LEN; i++){if (!findStartCode_0001(&pFrame[i])){if (!findStartCode_001(&pFrame[i])){continue;}else{pH264Frame->startcode_len = 3;break;}}else{pH264Frame->startcode_len = 4;break;}}if (i != 0) // 不是帧开头，偏移到帧开头重新读{printf("[%s %d]startcode error, i=%d\n", __FILE__, __LINE__, i);// free(pFrame);rewind = (-(readLen - i));fseek(pH264Info->pFileFd, rewind, SEEK_CUR);return -1;}// 3.查找下一帧开始码i += MAX_STARTCODE_LEN;for (; i < readLen - MAX_STARTCODE_LEN; i++){if (!findStartCode_0001(&pFrame[i])){if (!findStartCode_001(&pFrame[i])){continue;}else{break;}}else{break;}}if (i == (readLen - MAX_STARTCODE_LEN)){if (!feof(pH264Info->pFileFd)){printf("[%s %d]MAX_FRAME_LEN too small\n", __FILE__, __LINE__);// free(pFrame);return -1;}else{pH264Frame->isLastFrame = TRUE;}}// 4.填数据pH264Frame->forbidden_bit = pFrame[pH264Frame->startcode_len] & 0x80;     // 1 bitpH264Frame->nal_reference_idc = pFrame[pH264Frame->startcode_len] & 0x60; // 2 bitpH264Frame->nal_unit_type = pFrame[pH264Frame->startcode_len] & 0x1f;     // 5 bit, naluType 是开始码后一个字节的最后 5 位// pH264Frame->pFrameBuf = pFrame;pH264Frame->frame_len = i;// 5.文件读取指针偏移到下一帧位置rewind = (-(readLen - i));fseek(pH264Info->pFileFd, rewind, SEEK_CUR);pH264Info->frameNum++;return pH264Frame->frame_len;
}

3、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_H_

4、rtp.c

#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;
}

5、rtsp_h264_main.c

/*** @file rtsp_h264_main.c* @author https://blog.csdn.net/wkd_007* @brief* @version 0.1* @date 2025-06-30** @copyright Copyright (c) 2025**/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <fcntl.h>#include "rtp.h"
#include "H264Reader.h"#define H264_FILE_NAME "test.h264"
#define FPS 25#define RTSP_PORT 8554
#define RTP_PORT 55666
#define MAX_CLIENTS 5
#define SESSION_ID 10086001
#define SESSION_TIMEOUT 60typedef struct
{int rtpSendFd;int rtpPort;int bPlayFlag; // 播放标志char *cliIp;
} RTP_Send_t;typedef enum
{RTP_NULL,RTP_PLAY,RTP_PLAYING,RTP_STOP,
} RTP_PLAY_STATE;static int createUdpSocket()
{int fd = socket(AF_INET, SOCK_DGRAM, 0);if (fd < 0)return -1;int on = 1;setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on));return fd;
}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;              // startelse if (remainPktSize == 0 && i == pktNum - 1) // 最后一包数据rtpPacket->payload[1] |= 0x40;              // endmemcpy(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; // endmemcpy(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;
}void *sendRtp(void *arg)
{RTP_Send_t *pRtpSend = (RTP_Send_t *)arg;int rtp_send_fd = pRtpSend->rtpSendFd;int rtpPort = pRtpSend->rtpPort;char *cli_ip = pRtpSend->cliIp;struct RtpPacket *rtpPacket = (struct RtpPacket *)malloc(sizeof(struct RtpPacket) + (1920 * 1080 * 4));rtpHeaderInit(rtpPacket, 0, 0, 0, RTP_VESION, RTP_PAYLOAD_TYPE_H264, 0,0, 0, 0x88923423);// h264H264ReaderInfo_t h264Info;if (H264_FileOpen(H264_FILE_NAME, &h264Info) < 0){printf("failed to open %s\n", H264_FILE_NAME);return NULL;}H264Frame_t h264Frame;h264Frame.pFrameBuf = (unsigned char *)malloc(1920 * 1080 * 4);while (pRtpSend->bPlayFlag){if (!H264_IsEndOfFile(&h264Info)){h264Frame.isLastFrame = 0;H264_GetFrame(&h264Frame, &h264Info);if (h264Frame.pFrameBuf != NULL){if (h264Frame.isLastFrame) // 最后一帧，移到开头重新读{printf("warning SeekFile 1\n");H264_SeekFile(&h264Info);}// printf("rtpSendH264Frame, frameNum=%d, time=%u\n", h264Info.frameNum, rtpPacket->rtpHeader.timestamp);rtpSendH264Frame(rtp_send_fd, cli_ip, rtpPort, rtpPacket,h264Frame.pFrameBuf + h264Frame.startcode_len,h264Frame.frame_len - h264Frame.startcode_len);rtpPacket->rtpHeader.timestamp += 90000 / FPS; // RTP 传输视频每秒 90k HZusleep(1000 * 1000 / FPS);}}else{printf("warning need SeekFile 1\n");}}free(h264Frame.pFrameBuf);free(rtpPacket);H264_FileClose(&h264Info);
}// 解析RTSP请求
static void rtsp_request_parse(char *buffer, char *method, char *url, int *cseq, int *pRtpPort)
{char *line = strtok(buffer, "\r\n");sscanf(line, "%s %s RTSP/1.0", method, url);while ((line = strtok(NULL, "\r\n")) != NULL){if (strncmp(line, "CSeq:", 5) == 0){sscanf(line, "CSeq: %d", cseq);}char *pCliPort = strstr(line, "client_port=");if (pCliPort != NULL){int rtcpPort = 0;sscanf(pCliPort, "client_port=%d-%d", pRtpPort, &rtcpPort);// printf("rtpPort: %d-%d\n",*pRtpPort, rtcpPort);}}
}// 生成SDP描述
const char *generate_sdp()
{return "v=0\r\n""o=- 0 0 IN IP4 0.0.0.0\r\n""s=Example Stream\r\n""t=0 0\r\n""m=video 0 RTP/AVP 96\r\n""a=rtpmap:96 H264/90000\r\n""a=control:streamid=0\r\n";
}void rtsp_handle_OPTION(char *response, int cseq)
{sprintf(response,"RTSP/1.0 200 OK\r\n""CSeq: %d\r\n""Public: OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN\r\n\r\n",cseq);
}static void rtsp_handle_DESCRIBE(char *response, int cseq)
{sprintf(response,"RTSP/1.0 200 OK\r\n""CSeq: %d\r\n""Content-Type: application/sdp\r\n""Content-Length: %zu\r\n\r\n%s",cseq, strlen(generate_sdp()), generate_sdp());
}static void rtsp_handle_SETUP(char *response, int cseq, int rtpPort)
{sprintf(response,"RTSP/1.0 200 OK\r\n""CSeq: %d\r\n""Session: %u; timeout=%d\r\n""Transport: RTP/AVP;unicast;client_port=%d-%d;server_port=%d-%d\r\n\r\n",cseq, SESSION_ID, SESSION_TIMEOUT, rtpPort, rtpPort + 1, RTP_PORT, RTP_PORT + 1);
}static void rtsp_handle_PLAY(char *response, int cseq)
{sprintf(response,"RTSP/1.0 200 OK\r\n""CSeq: %d\r\n""Session: %u; timeout=%d\r\n""Range: npt=0.000-\r\n\r\n",cseq, SESSION_ID, SESSION_TIMEOUT);
}static void rtsp_handle_TEARDOWN(char *response, int cseq)
{sprintf(response,"RTSP/1.0 200 OK\r\n""CSeq: %d\r\n""Session: %d; timeout=%d\r\n\r\n",cseq, SESSION_ID, SESSION_TIMEOUT);
}// 处理客户端连接
int handle_client(int cli_fd, int rtp_send_fd, char *cli_ip)
{int client_sock = cli_fd;char buffer[1024] = {0};int cseq = 0;int rtpPort = 0;unsigned char bSendFlag = RTP_NULL;RTP_Send_t rtpSend;pthread_t thread_id;while (1){memset(buffer, 0, sizeof(buffer));int len = read(client_sock, buffer, sizeof(buffer) - 1);if (len <= 0)break;printf("C->S [%s]\n\n", buffer);char method[16] = {0};char url[128] = {0};rtsp_request_parse(buffer, method, url, &cseq, &rtpPort);char response[1024] = {0}; // 构造响应if (strcmp(method, "OPTIONS") == 0){rtsp_handle_OPTION(response, cseq);}else if (strcmp(method, "DESCRIBE") == 0){rtsp_handle_DESCRIBE(response, cseq);}else if (strcmp(method, "SETUP") == 0){rtsp_handle_SETUP(response, cseq, rtpPort);}else if (strcmp(method, "PLAY") == 0){rtsp_handle_PLAY(response, cseq);bSendFlag = RTP_PLAY;}else if (strcmp(method, "TEARDOWN") == 0){rtsp_handle_TEARDOWN(response, cseq);bSendFlag = RTP_STOP;}else{snprintf(response, sizeof(response),"RTSP/1.0 501 Not Implemented\r\nCSeq: %d\r\n\r\n", cseq);}write(client_sock, response, strlen(response));printf("S->C [%s]\n\n", response);if (bSendFlag == RTP_PLAY) // PLAY{rtpSend.rtpSendFd = rtp_send_fd;rtpSend.rtpPort = rtpPort;rtpSend.cliIp = cli_ip;rtpSend.bPlayFlag = 1;// 这里不使用线程的话，会一直无法处理 client_sock 发过来的 OPTION 消息，导致播放出问题if (pthread_create(&thread_id, NULL, (void *)sendRtp, (void *)&rtpSend) < 0){perror("pthread_create");}bSendFlag = RTP_PLAYING;}if (bSendFlag == RTP_STOP) // TEARDOWN{rtpSend.bPlayFlag = 0;pthread_join(thread_id); // 等待线程结束bSendFlag = RTP_NULL;break;}}printf("close ip=[%s] fd=[%d]\n", cli_ip, client_sock);close(client_sock);return 0;
}int main()
{int server_fd, client_fd;struct sockaddr_in address;int opt = 1;socklen_t addrlen = sizeof(address);// 创建套接字if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0){perror("socket failed");return -1;}// 设置套接字选项if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt))){perror("setsockopt");return -1;}address.sin_family = AF_INET;address.sin_addr.s_addr = INADDR_ANY;address.sin_port = htons(RTSP_PORT);// 绑定端口if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0){perror("bind failed");return -1;}// 开始监听if (listen(server_fd, MAX_CLIENTS) < 0){perror("listen");return -1;}// 用于发送 rtp 包的udp套接字int rtp_send_fd = createUdpSocket();if (rtp_send_fd < 0){printf("failed to create socket\n");return -1;}address.sin_port = htons(RTP_PORT);if (bind(rtp_send_fd, (struct sockaddr *)&address, sizeof(address)) < 0){perror("rtp_send_fd bind failed");return -1;}printf("RTSP Server listening on port %d\n", RTSP_PORT);// 主循环接受连接，目前处理一个客户端while (1){char cli_ip[40] = {0};if ((client_fd = accept(server_fd, (struct sockaddr *)&address, &addrlen)) < 0){perror("accept");return -1;}strncpy(cli_ip, inet_ntoa(address.sin_addr), sizeof(cli_ip));printf("handle cliend [%s]\n", cli_ip);handle_client(client_fd, rtp_send_fd, cli_ip);}return 0;
}

将上面代码保存在同一个目录后，并且在同目录里放一个.h264文件，然后运行 gcc *.c -lpthread 编译，再执行./a.out运行程序，下面是我运行的过程：
在这里插入图片描述

在这里插入图片描述

🎄四、总结

本文介绍了实现介绍怎么通过RTSP协议通信，将H264视频数据封装成RTP包并发送的，也提供了实现源码和运行结果，可以帮助读者快速了解怎样实现一个最简单的RTSP服务器。

在这里插入图片描述
如果文章有帮助的话，点赞👍、收藏⭐，支持一波，谢谢 😁😁😁

参考：
https://blog.csdn.net/huabiaochen/article/details/104557971

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若转载，请注明出处：http://www.pswp.cn/web/87028.shtml
繁体地址，请注明出处：http://hk.pswp.cn/web/87028.shtml
英文地址，请注明出处：http://en.pswp.cn/web/87028.shtml

如若内容造成侵权/违法违规/事实不符，请联系英文站点网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

零开始git使用教程-传html文件

零开始git使用教程-传html文件

1. 准备工作 (1) 确保你已经安装&#xff1a; Visual Studio (VS)&#xff08;任何版本&#xff0c;社区版也行&#xff09; Git&#xff08;去官网 git-scm.com 下载安装&#xff09; (2) 注册 Gitee/GitHub 账号 国内推荐 Gitee&#xff08;码云&#xff09;&#xff1a;…
阅读更多...
CPT204-Advanced OO Programming: Lists, Stacks, Queues, and Priority Queues

CPT204-Advanced OO Programming: Lists, Stacks, Queues, and Priority Queues

目录 1.Java 集合框架层次结构Java Collection Framework hierarchy 1.1Java 集合框架描述&#xff1a; 1.2数据结构Data structures 1.3 Java 集合框架支持两种类型的容器&#xff08;数据结构&#xff09;&#xff1a; 1.4 Java 集合框架的设计 2.Collection 2.1 Coll…
阅读更多...
【网络安全】Mysql注入中锁机制

【网络安全】Mysql注入中锁机制

前言 在sql注入的延时注入中&#xff0c;常见的函数有sleep()直接延时、BENCHMARK()通过让数据库进行大量的计算而达到延时的效果、笛卡尔积、正则匹配等&#xff0c;但还有一个常常被忽略的函数&#xff0c;也就是Mysql中的锁机制。虽然早些年就已经出现过相关的技术文章&…
阅读更多...
博途多重背景、参数实例

博途多重背景、参数实例

1&#xff1a;我们在博途中先新建一个工程&#xff0c;并且建立一个FB块名字为motor_fb&#xff0c;同样建立一个FC块名字为MOTOR_FC&#xff0c;里面写上我们电机程序里常用的逻辑控制。二者程序内容相同。下面是motor_fb块的程序截图: 2:我们再新建一个FB块&#xff0c;名字为…
阅读更多...
运维的利器–监控–zabbix–第三步：配置zabbix–中间件–Tomcat–步骤+验证

运维的利器–监控–zabbix–第三步：配置zabbix–中间件–Tomcat–步骤+验证

&#x1f3e0;个人主页&#xff1a;fo安方的博客✨ &#x1f482;个人简历&#xff1a;大家好&#xff0c;我是fo安方&#xff0c;目前中南大学MBA在读&#xff0c;也考取过HCIE Cloud Computing、CCIE Security、PMP、CISP、RHCE、CCNP RS、PEST 3等证书。&#x1f433; &…
阅读更多...
大模型在重症哮喘手术全流程风险预测与治疗方案制定中的应用研究

大模型在重症哮喘手术全流程风险预测与治疗方案制定中的应用研究

目录 一、引言 1.1 研究背景与意义 1.2 研究目标与方法 1.3 研究创新点 二、重症哮喘概述 2.1 定义与发病机制 2.2 分类与临床表现 2.3 诊断标准与方法 三、大模型技术原理与应用现状 3.1 大模型的基本原理 3.2 在医疗领域的应用案例分析 3.3 适用于重症哮喘预测的…
阅读更多...
Webpack的插件机制Tapable

Webpack的插件机制Tapable

Tapable 是一个轻量级的库&#xff0c;用于创建和管理插件钩子&#xff08;hooks&#xff09;&#xff0c;它在 Webpack 中广泛应用&#xff0c;用于实现插件系统。Tapable 提供了一种机制&#xff0c;允许插件在特定的生命周期阶段插入自定义逻辑&#xff0c;从而扩展应用程序…
阅读更多...
FRONT归因-两阶段训练流程

FRONT归因-两阶段训练流程

FRONT, Fine-Grained Grounded Citations归因 FRONT归因&#xff0c;首先从检索到的源文档中选择支持性引用&#xff0c;然后基于这些引用指导生成过程&#xff0c;确保生成回答有据可依&#xff0c;引用准确无误。 FRONT的特色在于两阶段归因训练&#xff0c;要点如下: 阶…
阅读更多...
单端转差分放大器AD8138

单端转差分放大器AD8138

根据 AD8138 的数据手册特性及参数&#xff0c;可以实现单端 5Vpp&#xff08;偏置 0V&#xff09;正弦波转差分 5Vpp&#xff08;共模 2.5V&#xff09;的功能&#xff0c;但需注意以下细节&#xff1a; 1. 信号幅度匹配性 输入信号&#xff1a;单端 5Vpp&#xff08;峰峰值…
阅读更多...
用R包mice进行多重插补

用R包mice进行多重插补

利用R包mice实现的链式方程多重插补方法来插补缺失的数据。 所有多重插补方法都遵循三个步骤 插补——与单次插补类似&#xff0c;对缺失值进行插补。但是&#xff0c;插补值会从分布中提取m次&#xff0c;而不是仅提取一次。此步骤结束时&#xff0c;应该有m 个完整的数据集…
阅读更多...
【专题】网络攻防技术期末复习资料

【专题】网络攻防技术期末复习资料

网络攻防技术期末复习资料 链接&#xff1a;https://blog.csdn.net/Pqf18064375973/article/details/148996272?sharetypeblogdetail&sharerId148996272&sharereferPC&sharesourcePqf18064375973&sharefrommp_from_link 网络安全威胁的成因。 分类&#xff1a…
阅读更多...
地震灾害的模拟

地震灾害的模拟

为确保地震灾害模拟的准确性和高效性&#xff0c;涉及的系统需要处理复杂的物理模型、数据输入和多层次的模拟过程。在技术设计方案中&#xff0c;我们将涵盖以下几个方面&#xff1a; 背景&#xff1a;描述该模拟系统的目的与应用场景。需求&#xff1a;列出系统的功能需求&a…
阅读更多...
9.9 《1/10成本实现GPT-3.5级表现！ChatGLM3-6B QLoRA微调实战：4bit量化+低秩适配全解析》

9.9 《1/10成本实现GPT-3.5级表现！ChatGLM3-6B QLoRA微调实战：4bit量化+低秩适配全解析》

1/10成本实现GPT-3.5级表现！ChatGLM3-6B QLoRA微调实战：4bit量化+低秩适配全解析 ChatGLM3-6B 微调入门实战：QLoRA 量化低秩适配技术 ▲ ChatGLM3-6B采用GLM架构改进版，支持32K上下文长度和代码生成能力 一、QLoRA 技术原理精要 QLoRA（Quantized Low-Rank Adaptation）…
阅读更多...
【Python基础】11 Python深度学习生态系统全景解析：从基础框架到专业应用的技术深度剖析（超长版，附多个代码及结果）

【Python基础】11 Python深度学习生态系统全景解析：从基础框架到专业应用的技术深度剖析（超长版，附多个代码及结果）

引言：Python在深度学习领域的统治地位 在人工智能浪潮席卷全球的今天，Python已经成为深度学习领域当之无愧的王者语言。这不仅仅是因为Python语法简洁易学，更重要的是围绕Python构建的深度学习生态系统的完整性和强大性。从Google的TensorFlow到Facebook的PyTorch，从科学计…
阅读更多...
RESTful API 设计原则深度解析

RESTful API 设计原则深度解析

在 Web 服务架构中&#xff0c;RESTful API作为一种轻量级、可扩展的接口设计风格&#xff0c;通过 HTTP 协议实现资源的标准化访问。本文从核心原则、URL 设计、HTTP 方法应用、状态管理及面试高频问题五个维度&#xff0c;结合工程实践与反例分析&#xff0c;系统解析 RESTfu…
阅读更多...
java web2（黑马）

java web2（黑马）

数据库设计 简介 1.软件的研发步骤 2.数据库设计概念 > 数据库设计就是根据业务系统的具体需求&#xff0c;结合我们所选用的DBMS&#xff0c;为这个业务系统构造出最优 的数据存储模型 > 建立数据库中的表结构以及表与表之间的关联关系的过程&#xff0c; > …
阅读更多...
Meta 宣布加入 Kotlin 基金会，将为 Kotlin 和 Android 生态提供全新支持

Meta 宣布加入 Kotlin 基金会，将为 Kotlin 和 Android 生态提供全新支持

近日 Meta 正式宣发加入了 Kotlin 基金会&#xff0c;如果你对 Meta 不熟悉&#xff0c;那么对于开源了 React Native 的 Facebook 应该不陌生了吧&#xff1f;现在它也正式加入了 Kotlin 领导者的阵营&#xff1a; Kotlin 基金会 是由 Jetbrains 和 Google 共同成立的基金会&a…
阅读更多...
缓存系统-淘汰策略

缓存系统-淘汰策略

目录 一、LRU&#xff08;最近最少使用&#xff09; 工作原理 操作流程 基本特征 二、LFU&#xff08;最不常使用&#xff09; 工作原理 操作流程 基本特征 三、ARC 自适应 工作原理 操作流程 基本特征 四、TTL&#xff08;生存时间&#xff09; 工作原理 操作流…
阅读更多...
TypeScript 安装使用教程

TypeScript 安装使用教程

一、TypeScript 简介 TypeScript 是由微软开发的开源编程语言&#xff0c;是 JavaScript 的超集&#xff0c;添加了静态类型、接口、枚举、类等特性&#xff0c;使开发大型应用更安全、可维护、可扩展。最终会被编译为标准的 JavaScript 代码在浏览器或 Node.js 中运行。 二、…
阅读更多...
强化学习系列--dpo损失函数

强化学习系列--dpo损失函数

DPO 概要 DPO&#xff08;Direct Preference Optimization&#xff0c;直接偏好优化&#xff09;是由斯坦福大学等研究团队于2023年提出的一种偏好优化算法&#xff0c;可用于LLM、VLM与MLLM的对齐训练。 算法基于PPO的RLHF基础上进行了大幅简化。DPO算法跳过了训练奖励模型这…
阅读更多...
最新文章

Copyright @ 2022~2023