rtsp协议调试程序

最新推荐文章于 2021-08-04 12:49:21 发布
最新推荐文章于 2021-08-04 12:49:21 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： live555 文章标签： session ioc url socket struct null

最近碰到移植rtsp库到wince下，读不到数据，为了解决问题，写了一个小的rtsp客户端协议学习程序，实现基本的会话协议，OPTIONS,DESCRIBE,SETUP,PLAY等协议，将读取的数据存入到文件中去。程序代码贴在下面，这个代码能在ce和pc上跑。供大家分享下。

#ifdef _WIN32_WCE
#include "stdafx.h"
#endif

#ifndef _WIN32_WCE
#define WIN32_LEAN_AND_MEAN
#endif

#include <windows.h>
#include <commctrl.h>

#include <MMSystem.h>

#include <winsock2.h>

#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>

#ifdef _WIN32_WCE
#pragma comment(lib, "ws2.lib")
#else
#pragma comment(lib, "ws2_32.lib")
#endif

#define  PP_NAME "User-Agent:rtsp client(v1.0)"
#define  PP_CRLF "/r/n"

//测试之用

//打开连接
long InitSocket();

//关闭连接
long DeInitSocket();

//初始化tcp socket
long InitTCPSocket(int port);

//初始化udp socket
long InitUDPSocket(const char *ip, int port);

//取socket端口号
long GetSokcetPort(int sock, int *port);

//读取数据
long ReadSocket(int sock, char *buf, int len, int timeout);

//发送命令数据
long SendRTSPCmd(int sock, const char *cmd, const char *szparam);

//解析rtsp命令回应数据
long PraseRTSPCmd();
long PraseOptionCmd(const char *sz);
long PraseDescribeCmd(const char *sz);
long PraseSetupCmd(const char *sz, char *sess);
long PrasePlayCmd(const char *sz);
long GetResponseCode(const char *sz);  //取返回值

//
//字符串操作函数
static char* getLine(char* startOfLine);


//生成rtsp发送命令
char * GetRTSPCmd(const char *);
char * GetOptionCmd(char *url);
char * GetDescribeCmd(char *url);
char * GetPlayCmd(char *url, char *session, char *range);
char * GetSetupCmd(char *url, int port1, int port2);

char * GetReportCmd(char *);

//
//日志函数
long logwr(void *, int len);

//全局变量定义区
fd_set rfdsock;
//日志写入文件指针
FILE *fp = NULL;
//

//
//rtsp请求解析
long PraseURL(const char *url, char *szip, int *iport);
int _tmain(int argc, _TCHAR* argv[])
{
 int sockin, sc1, sc2;
 sockaddr_in addr;
 char *buf, *szcmd, *url;
 char szip[32];
 int nlen, iret, iport;
 int ip1, ip2;
 long lret;

 //初始化变量　
 FD_ZERO(&rfdsock);

 fp = fopen("1.txt", "w+");
 //分配缓冲区
 nlen = 10240;
 buf = (char*)malloc(nlen);

 //定义要连接的url
 //url = "rtsp://192.168.1.43:2554/realmp3.mp3";
 url = "rtsp://192.168.1.42/realmp3.mp3";
 //url = "rtsp://192.168.1.43/1.amr";
 //初始化sock
 InitSocket();

 //分析url请求，取出ip，端口
 lret = PraseURL(url, szip, &iport);


 //初始化与服务器连接的socket
 sockin = InitTCPSocket(0);

 //与服务器连接
 addr.sin_family = AF_INET;
 addr.sin_port = htons(iport);
 addr.sin_addr.s_addr = inet_addr(szip);
 iret = connect(sockin,(struct sockaddr*)&addr, sizeof addr);

 //发送option命令
 szcmd = GetOptionCmd(url);
 lret = SendRTSPCmd(sockin, "OPTIONS",szcmd);
 free(szcmd);

 lret = ReadSocket(sockin, buf, nlen,100);

 
 //发送DESCRIBE命令
 szcmd = GetDescribeCmd(url);
 lret = SendRTSPCmd(sockin, "DESCRIBE", szcmd);
 free(szcmd);
 lret = ReadSocket(sockin, buf,  nlen, 100);
 
 //解析Response
 lret = PraseDescribeCmd((const char*)buf);

 //创建客户端接收端口
 sc1 = InitUDPSocket(NULL, 6544);
 sc2 = InitUDPSocket(NULL, 6545);

 //将sock加入到要等待的队列
 
 FD_SET(sc1, &rfdsock );
 FD_SET(sc2, &rfdsock);


 lret = GetSokcetPort(sc1, &ip1);
 lret = GetSokcetPort(sc2, &ip2);

 //发送Setup命令，告诉服务器客户端的接受数据的端口
 szcmd = GetSetupCmd(url, ip1, ip2);
 //告诉服务器客户端的端口
 lret = SendRTSPCmd(sockin, "SETUP", szcmd);
 free(szcmd);
 lret = ReadSocket(sockin, buf, nlen, 100);
 //解析Response返回的命令串
 lret = PraseSetupCmd(buf, szip);

 char *session, *srange;
 session = szip;
 //发送PLAY命令
 srange  = "Range: npt=0.000-39.471/r/n";
 szcmd = GetPlayCmd(url, session, srange);
 lret = SendRTSPCmd(sockin, "PLAY", szcmd);
 free(szcmd);
 lret = ReadSocket(sockin, buf, nlen, 100);

 timeval tv;
 fd_set fr;

 int i;

 tv.tv_sec = 20;
 tv.tv_usec = 0;
 struct sockaddr_in addr2;
 int addrlen;
 addrlen = sizeof addr;

 //将数据写到文件中去
 FILE *ffp;
 ffp = fopen("1.mp3", "w+");

 //开始接受数据了
 while(true)
 {
  fr = rfdsock;
  lret  = select(0, &fr, NULL, NULL, &tv);

  if(lret == SOCKET_ERROR)
  {
   break;
  }
  else if(lret >0)
  {
   //判断是哪个socket可以读取数据了
   for(i = 0; i< 2;i ++)
   {
    if(FD_ISSET(rfdsock.fd_array[i], &fr)
     && FD_ISSET(rfdsock.fd_array[i], &rfdsock))
    {
     lret = recvfrom(rfdsock.fd_array[i], buf, nlen,0, (struct sockaddr*)&addr2, &addrlen );
     if(lret > 0 && ffp)
     {
      fwrite(buf, 1, lret, ffp);
     }
     else if(lret == SOCKET_ERROR)
     {
      break;
     }
    }
   }

  }
  else if(lret == 0)
   break;
 }
 fclose(ffp);

 //退出后的清理工作
 closesocket(sockin);
 closesocket(sc1);
 closesocket(sc2);

 fwrite("/r/nend", 1, 5, fp);
 fclose(fp);
 return 0;
}

long InitSocket()
{
 WSADATA ws;
 long lret  = -1;
 lret = WSAStartup(MAKEWORD(2,2), &ws);
 return 0;
}

long DeInitSocket()
{

 WSACleanup();
 return 0;
}

long InitTCPSocket( int port )
{
 long lret ;
 int sock;
 sockaddr_in addr;
 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

 //int flag = 1;
 //lret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&flag, sizeof flag);

 //addr.sin_family = AF_INET;
 //addr.sin_port = 0;
 //addr.sin_addr.s_addr = INADDR_ANY;
 //lret = bind(sock, (struct sockaddr*)&addr, sizeof addr);
 lret = sock;
 return lret;
}
#define   SIO_RCVALL                         _WSAIOW(IOC_VENDOR,1)  
#define   SIO_RCVALL_MCAST             _WSAIOW(IOC_VENDOR,2)  
#define   SIO_RCVALL_IGMPMCAST     _WSAIOW(IOC_VENDOR,3)  
#define   SIO_KEEPALIVE_VALS         _WSAIOW(IOC_VENDOR,4)  
#define   SIO_ABSORB_RTRALERT       _WSAIOW(IOC_VENDOR,5)  
#define   SIO_UCAST_IF                     _WSAIOW(IOC_VENDOR,6)  
#define   SIO_LIMIT_BROADCASTS     _WSAIOW(IOC_VENDOR,7)  
#define   SIO_INDEX_BIND                 _WSAIOW(IOC_VENDOR,8)  
#define   SIO_INDEX_MCASTIF           _WSAIOW(IOC_VENDOR,9)  
#define   SIO_INDEX_ADD_MCAST       _WSAIOW(IOC_VENDOR,10)  
#define   SIO_INDEX_DEL_MCAST       _WSAIOW(IOC_VENDOR,11)  
long InitUDPSocket(const char *ip,  int port )
{
 long lret;
 int sock;
 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
 int flag = 1;
 lret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&flag, sizeof flag);

 sockaddr_in addr;

 addr.sin_family = AF_INET;
 addr.sin_port = port;
 if(ip)
  addr.sin_addr.s_addr = inet_addr(ip);
 else
  addr.sin_addr.s_addr = INADDR_ANY;
 lret = bind(sock, (struct sockaddr*)&addr, sizeof addr);
 //设置非堵塞通讯
 //u_long arg = 2;
 //lret = ioctlsocket(sock, SIO_LIMIT_BROADCASTS, &arg);

 lret = sock;
 return lret;
}

long GetSokcetPort( int sock, int *port )
{
 long lret = -1;
 sockaddr_in addr;
 int nlen;
 nlen = sizeof addr;

 addr.sin_port = 0;

 *port = 0;

 if(getsockname(sock, (struct sockaddr*)&addr, &nlen) < 0)
  lret = -1;
 else
 {
  lret = 0;
  *port = addr.sin_port;
 }

 return lret;
}

long ReadSocket(int sock,  char *buf, int len, int timeout )
{
 long lret ;
 int iret;
 fd_set fr;
 timeval tm;
 tm.tv_sec = timeout;
 tm.tv_usec = 0;

 FD_ZERO(&fr);
 fr.fd_count = 1;
 fr.fd_array[0] = sock;

 lret = select(sock, &fr, NULL, NULL, &tm);

 if(lret > 0)
 {
  lret = recv(sock, buf, len, 0);
  if(lret == SOCKET_ERROR)
  {
  
  }
  else if(lret > 0)
  {
   logwr((void*)buf, lret);
  }
 }
 
 return lret;
}

long SendRTSPCmd( int sock, const char *cmd, const char *szparam )
{
 long lret;
 int ilen;
 ilen = strlen(szparam);
 lret = send(sock, szparam, ilen,0);
 if(lret == SOCKET_ERROR)
 {
  lret = WSAGetLastError();
 }
 logwr((void *)szparam, ilen);
 return lret;
}

char * GetRTSPCmd( const char * szName)
{
 char *str = NULL;
 char const*  cmdFmt = NULL;
 if(!strcmp(szName, "OPTIONS"))
 {
  cmdFmt =
   "OPTIONS %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "%s"
   "%s"
#ifdef SUPPORT_REAL_RTSP
   REAL_OPTIONS_HEADERS
#endif
   "/r/n";
 }
 else if(!strcmp(szName, "ANNOUNCE"))
 {
   cmdFmt =
   "ANNOUNCE %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Content-Type: application/sdp/r/n"
   "%s"
   "Content-length: %d/r/n/r/n"
   "%s";
 }
 else if(!strcmp(szName, "PLAY"))
 {
   cmdFmt =
   "PLAY %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "%s"
   "%s"
   "%s"
   "%s"
   "/r/n";

 }
 else if(!strcmp(szName, "PAUSE"))
 {
   cmdFmt =
   "PAUSE %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "%s"
   "%s"
   "/r/n";
 }
 else if(!strcmp(szName, "RECORD"))
 {
  cmdFmt =
   "RECORD %s%s%s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "Range: npt=0-/r/n"
   "%s"
   "%s"
   "/r/n";
 }
 else if(!strcmp(szName, "SET_PARAMETER"))
 {
   cmdFmt =
   "SET_PARAMETER %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "%s"
   "%s"
   "Content-length: %d/r/n/r/n"
   "%s: %s/r/n";
 }
 else if(!strcmp(szName, "GET_PARAMETER"))
 {
   cmdFmt =
   "GET_PARAMETER %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "%s"
   "%s"
   "Content-type: text/parameters/r/n"
   "Content-length: %d/r/n/r/n"
   "%s/r/n";
 }
 else if(!strcmp(szName, "TEARDOWN"))
 {
   cmdFmt =
   "TEARDOWN %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "Session: %s/r/n"
   "%s"
   "%s"
   "/r/n";
 }
 else if(!strcmp(szName, "DESCRIBE"))
 {
   cmdFmt =
   "DESCRIBE %s RTSP/1.0/r/n"
   "CSeq: %d/r/n"
   "%s"
   "%s"
   "%s"
 #ifdef SUPPORT_REAL_RTSP
   REAL_DESCRIBE_HEADERS
 #endif
   "/r/n";
 }
 else if(!strcmp(szName, "ANNOUNCE"))
 {
   cmdFmt =
  "ANNOUNCE %s RTSP/1.0/r/n"
  "CSeq: %d/r/n"
  "Content-Type: application/sdp/r/n"
  "%s"
  "Content-length: %d/r/n/r/n"
  "%s";
 }
 else if(!strcmp(szName, "SETUP"))
 {
  cmdFmt =
   "%s"
   "CSeq: %d/r/n"
   "%s"
   "%s"
   "%s"
   "%s"
   "/r/n";
 }
 str = (char*)cmdFmt;
 return str;
}

char * GetOptionCmd( char *url )
{
 int nlen, iret;
 char *ss;
 char *s = GetRTSPCmd("OPTIONS");
 
 nlen = strlen(s);
 iret = nlen + strlen(url) + strlen(PP_NAME) + 200;
 ss = (char*)malloc(iret);

 sprintf(ss, s, url, 1, PP_NAME, PP_CRLF);


 return ss;
}

char * GetDescribeCmd( char *url )
{
 int nlen, iret;
 char *ss;
 char *s = GetRTSPCmd("DESCRIBE");

 nlen = strlen(s);
 iret = nlen + strlen(url) + strlen(PP_NAME) + 200;
 ss = (char*)malloc(iret);

 sprintf(ss, s, url, 1, PP_NAME, PP_CRLF, PP_CRLF);

 return ss;
}
char * GetPlayCmd( char *url , char *session, char *range)
{
 int nlen, iret;
 char *ss;
 char *s = GetRTSPCmd("PLAY");

 nlen = strlen(s);
 iret = nlen + strlen(url) + strlen(PP_NAME) + 200;
 ss = (char*)malloc(iret);

 //char buf[128] = {0};
 //sprintf(buf, "Session: %s/r/n", session);

 sprintf(ss, s, url, 1, session, range, PP_NAME, PP_CRLF, PP_CRLF);

 return ss;
}

char * GetSetupCmd( char *url , int port1, int port2)
{
 int nlen, iret;
 char *ss;
 char *s = GetRTSPCmd("SETUP");

 nlen = strlen(s);
 iret = nlen + strlen(url) + strlen(PP_NAME) + 200;
 ss = (char*)malloc(iret);
 char buf[128] = {0};
 char buf2[128] = {0};
 if(port1 == 0)
  strcpy(buf, "Transport: RTP/AVP/TCP;unicast;interleaved=0-1");
 else
  sprintf(buf, "Transport: RTP/AVP;unicast;client_port=%d-%d/r/n", ntohs(port2), ntohs(port1));
 sprintf(buf2, "SETUP %s/streamid=0 RTSP/1.0/r/n", url);

 sprintf(ss, s, buf2, 1,  buf, PP_NAME, PP_CRLF, PP_CRLF);

 return ss;
}

long PraseURL( const char *url, char *szip, int *iport )
{
 long lret = -1;
 if(url)
 {
  //找到了rtsp这个标识符
  if(!_strnicmp(url, "rtsp://", 7))
  {
   //找ip
   char *s, *ss;
   s = (char*)url + strlen("rtsp://");
   ss = strchr(s, '/');

   strncpy(szip, s,  ss- s);
   szip[ss -s] = '/0';

   //查找下是否是有端口设置
   s = strchr(szip, ':');
   //有端口设置
   if(s)
   {
    ss = s;
    s ++;
    *iport = atoi(s);

    //同时修正ip地址
    szip[ss - szip] = '/0';
   }
   else
    *iport = 554;

   lret = 0;
  }
 }


 return lret;
}

long logwr( void *data, int len )
{
 long lret = -1;
 if(fp)
  lret = fwrite(data, 1, len, fp);

 return lret;
}


static char* getLine(char* startOfLine) {
 // returns the start of the next line, or NULL if none
 for (char* ptr = startOfLine; *ptr != '/0'; ++ptr) {
  // Check for the end of line: /r/n (but also accept /r or /n by itself):
  if (*ptr == '/r' || *ptr == '/n') {
   // We found the end of the line
   if (*ptr == '/r') {
    *ptr++ = '/0';
    if (*ptr == '/n') ++ptr;
   } else {
    *ptr++ = '/0';
   }
   return ptr;
  }
 }

 return NULL;
}

long GetResponseCode( const char *sz )
{
 long lret = -1;
 if(sz)
 {
  if(sscanf(sz, "%*s%u", &lret) != 1)
   ;
 }

 return lret;
}

long PraseDescribeCmd( const char *sz )
{
 long lret = -1;
 char *ss, *szst;
 szst = (char *)sz;
 int contentLength = -1;

 if(GetResponseCode(sz )== 200)
 {
  ss= getLine(szst);
  while(1)
  {
   ss = getLine(ss);
   if(ss == NULL)
    break;
   if (sscanf(ss, "Content-Length: %d", &contentLength) == 1
    || sscanf(ss, "Content-length: %d", &contentLength) == 1) {
     if (contentLength < 0) {
     }
   }
  }

 }

 return lret;
}

long PraseSetupCmd( const char *sz , char *sess)
{
 long lret = -1;
 char *ss, *szst;
 szst = (char *)sz;
 int contentLength = -1;
 
 if(GetResponseCode(sz )== 200)
 {
  ss= getLine(szst);
  while(1)
  {
   ss = getLine(ss);
   if(ss == NULL)
    break;
   if (sscanf(ss, "Session: %[^;]", sess) == 1)
   {
    lret = 1;
   }
  }

 }
 return lret;
}


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/nxjbill/archive/2010/01/05/5137178.aspx

maikforever
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rtsp 流测试工具
02-01
rtsp 流测试工具
rtsp 协议 详细讲解
weixin_34273479的博客
11-25 629
转载自:http://www.mikewootc.com/wiki/net/protocol/rtsp.html 目录: 概述 RTSP简介 协议特点 协议细节 典型的rtsp交互过程 RTSP消息格式 方法定义 消息头定义 状态码 rtsp中常用方法举例 SDP协议概述 简介 SDP协议格式 SDP协议举例说明 ...
记一RTSP调试记录
CoCo的专栏
11-19 1122
[1970-01-01 03:51:24.03 rtspserver/rtsp_server.c +776  rtsp_worker_create] create workers 0 [1970-01-01 03:51:24.04 rtspserver/server_client.c +133  receive_message] ########## RECEIVED ##########
rtsp视频调试开发
weixin_30701575的博客
08-08 226
http://218.204.223.237:8081/wap/ 转载于:https://www.cnblogs.com/scouser/p/3246984.html
rtsp协议 客户端 服务器 测试程序
01-06
这些程序可以帮助开发者验证RTSP协议的正确性，理解其工作流程，并调试可能存在的问题。 RTSP客户端程序的设计要点： 1. **请求构造**：客户端需要构建各种RTSP方法（如DESCRIBE, SETUP, PLAY等）的请求报文，并...
my_rtsp_test_海思推流_海思rtsp协议_海思rtsp_海思rtsp_rtsp_
09-29
在海思RTSP协议中，客户端和服务器之间的交互主要包括以下步骤： 1. **建立连接**：客户端通过发送RTSP的`OPTIONS`命令来查询服务器支持的RTSP方法和功能。 2. **描述资源**：服务器响应`OPTIONS`命令后，客户端会...
通过RTSP协议捕获大华摄像机视频
11-18
标题中的“通过RTSP协议捕获大华摄像机视频”是指使用Real-Time Streaming Protocol (RTSP) 协议从 Dahua 摄像机获取实时视频流的过程。RTSP是一种应用层协议，常用于控制多媒体数据的播放，比如在监控系统中远程...
RTSP取流程序
03-08
RTSP（Real-Time Streaming Protocol）...理解RTSP协议的工作原理以及QT中多媒体模块的使用，对于开发这样的程序至关重要。在实际项目中，还需要考虑性能优化、错误处理和用户体验等方面，以确保程序的稳定性和可靠性。
linux下rtsp服务器应用程序源码
02-23
RTSP协议包括多个命令，如DESCRIBE、SETUP、PLAY、PAUSE、TEARDOWN等。源码中会包含对这些命令的解析逻辑，理解这些命令的功能和响应机制是核心部分。例如，DESCRIBE用于获取媒体描述信息，SETUP建立传输通道，PLAY...
RTSP+流媒体服务器性能测试工具1
08-04
摘要：基于RTSP协议的流媒体应用日益增加，如何评测RTSP流媒体服务器的服务性能成为一个亟待解决的实际问题。本文在分析流媒体业务性能指标的基础上，设计和实现了
rtsp-test-server：提供一些测试rtsp流的简单服务器
03-03
基于GStreamer的简单RTSP服务器。 在线演示网址 rtsp：//ipcam.stream：8554 / bars rtsp：//ipcam.stream：8554 / white rtsp：//ipcam.stream：8554 /黑色 rtsp：//ipcam.stream：8554 / red rtsp：//ipcam.stream：8554 /绿色 rtsp：//ipcam.stream：8554 / blue rtsp：//ipcam.stream：8554 / bars-vp8 rtsp：//ipcam.stream：8554 / white-vp8 rtsp：//ipcam.stream：8554 / black-vp8 rtsp：//ipcam.stream：8554 / red-vp8 rtsp：//ipcam.stream：8554 / gree
RTSP测试服务器
09-11
live555里面编译出来的Rtsp服务器，里面包含有视频文件和流地址，免配置可直接用于测试rtsp客户端程序。
很好用的RTSP实现
10-21
很好用的RTSP资源在github上下载的，现在估计自己都找不到了！
rtsp 视频仿真工具
04-09
工具支持模拟 rtsp视频源， 格式支持 264， 265， ts, mp4等。可方便音视频开发时测试。
onvif_rtsp调试
happy_sand的专栏
09-01 601
经过一段时间的挣扎，终于将onvif获取参数，RTSP作为客户端已经可以从IPC处获取流问题解决了 总结一下，需要注意的问题大致有： 1 RTSP客户端从服务器获取流地址时，鉴权问题，需要用到MD5认证 2 ONVIF鉴权时，需要OPENSSL库的支持，网上有些说不需要直接用SHA1的方式鉴权，我尝试过，第一，使用稍微有点复杂，第二，如果不用soapC.c中还是会报一大堆符号找不到的错误，最
rtsp服务器性能测试工具,RTSP 流媒体服务器性能测试工具
weixin_39815345的博客
08-04 853
Abstract:The attention on the streaming media applications based on RTSP protocol is growing, so the main issue we address in this paper is how to evaluate the serving performance of RTSP streaming me...
RTSP服务器程序实现
sunshineywz的博客
09-23 1220
int UnitTest_rtspCmdOptions(rtsp_session_t *sessp) { char resp_buf[1024] = {0}; char *p = resp_buf; /* Send response message. */ sprintf(p, RTSP_VERSION" %d %s\r\n", 200, UnitTest_rt...
rtsp程序图
sunshineywz的博客
01-16 212
qmediaplayer rtsp
最新发布
06-25
以上就是使用QMediaPlayer实现RTSP流媒体播放的基本流程，需要注意的是，在真实的项目中，很可能因为网络环境、设备配置等问题导致播放失败或者播放卡顿的情况，需要通过一些调试技巧和优化手段来解决。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值