8-Onvif协议：IPC客户端之获取实时预览的url地址

已于 2024-06-07 17:30:51 修改
阅读量1.4k 收藏 15
点赞数 18
分类专栏： Onvif学习 文章标签： c++ 开源协议 xml http 网络协议
于 2024-06-07 14:59:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56438859/article/details/139527104
版权

文章目录

参考文章

https://blog.csdn.net/zhizhengguan/article/details/109387400

https://blog.csdn.net/benkaoya/article/details/72486624

一、简介

​

​ ONVIF规范中设备管理和控制部分所定义的接口均以Web Services的形式提供，而音视频流则通过RTP/RTSP进行。简单粗暴的理解：IPC的各种参数获取/配置都是通过ONVIF协议接口实现，而音视频流多媒体传输采用的是RTP/RTSP协议实现。要读取IPC的音视频流，概况起来是，先通过ONVIF接口获取IPC主/辅码流的RTSP地址，再利用FFmpeg接口（或其他开源方案）读取音视频流数据。
ONVIF协议接口在media.wsdl，文件地址为https://www.onvif.org/ver10/media/wsdl/media.wsdl
在这里插入图片描述

​ Onvif协议对前端摄像头的取流是通过标准RTSP协议，因此我们就需要通过Onvif协议获取到需要预览摄像头的RTSP的地址，将拿到的RTSP通过VLC或者其他的RTSP客户端取流预览前端摄像头。实现的功能如下图所示：

在这里插入图片描述

形如rtsp://192.168.1.137:554/stream1

二、获取实时预览url地址的流程

  1. 通过「设备发现」，得到 「设备服务地址」。
  2. 使用「设备服务地址」调用ONVIF_GetMediaCapabilities接口，得到「媒体服务地址」。
  3. 使用「媒体服务地址」调用ONVIF_GetMediaProfilesToken接口，得到主次码流的「媒体配置信息」，其中包含ProfileToken。
  4. 根据获取到的token调用对应的接口获取到RTSP地址。
  5. 获取到RTSP地址之后我们就可以用opencv或者ffmeg之类的看实时视频了。

注：获取的token包含了主码流、辅码流的token已经各种配置的token，可以根据自己需要自取；根据主、辅码流的toekn获取到的是对应主、辅码流的RTSP地址。主、辅码流的RTSP地址不同，但是差异可能不大。

VLC播放RTSP视频
RTSP是很成熟的多媒体传输协议，用于传输音视频流数据。我们不需要自己写代码来实现RTSP协议，有很多现成的开源方案可供我们使用，比如强大的FFmpeg。为了让大家对RTSP有个更好的认识，下面使用VLC media player播放RTSP视频流。

打开VLC media player播放器（我的版本是VLC media player 2.1.3）。

选择菜单【媒体】>【打开网络串流】，输入RTSP地址，点击【播放】，即可实时播放视频流媒体，如下图所示。

在这里插入图片描述
在这里插入图片描述

如果提示认证失败，那么URL就要加上用户名、密码，格式如：rtsp://username:password@100.100.100.5:554/av0_0

三、数据结构和函数

生成gSOAP框架的代码，项目文件结构和解决编译报错可以参考佬的这篇文章：

https://blog.csdn.net/zhizhengguan/article/details/109387400

1.数据结构

# 数据类型定义在client\application\soapStub.h

tt__StreamSetup              ttStreamSetup;
tt__Transport                ttTransport;
_trt__GetStreamUri           req;
_trt__GetStreamUriResponse   rep;

/* ../onvif_head/onvif.h:996 */
#ifndef SOAP_TYPE_tt__StreamSetup
#define SOAP_TYPE_tt__StreamSetup (734)
/* complex XML schema type 'tt:StreamSetup': */
class SOAP_CMAC tt__StreamSetup : public soap_dom_element {
      public:
        /// Required element 'tt:Stream' of XML schema type 'tt:StreamType'
        enum tt__StreamType Stream;
        /// Required element 'tt:Transport' of XML schema type 'tt:Transport'
        tt__Transport *Transport;
      public:
        /// Return unique type id SOAP_TYPE_tt__StreamSetup
        virtual long soap_type(void) const { return SOAP_TYPE_tt__StreamSetup; }
        /// (Re)set members to default values
        virtual void soap_default(struct soap*);
        /// Serialize object to prepare for SOAP 1.1/1.2 encoded output (or with SOAP_XML_GRAPH) by analyzing its (cyclic) structures
        virtual void soap_serialize(struct soap*) const;
        /// Output object in XML, compliant with SOAP 1.1 encoding style, return error code or SOAP_OK
        virtual int soap_put(struct soap*, const char *tag, const char *type) const;
        /// Output object in XML, with tag and optional id attribute and xsi:type, return error code or SOAP_OK
        virtual int soap_out(struct soap*, const char *tag, int id, const char *type) const;
        /// Get object from XML, compliant with SOAP 1.1 encoding style, return pointer to object or NULL on error
        virtual void *soap_get(struct soap*, const char *tag, const char *type);
        /// Get object from XML, with matching tag and type (NULL matches any tag and type), return pointer to object or NULL on error
        virtual void *soap_in(struct soap*, const char *tag, const char *type);
        /// Return a new object of type tt__StreamSetup, default initialized and not managed by a soap context
        virtual tt__StreamSetup *soap_alloc(void) const { return SOAP_NEW_UNMANAGED(tt__StreamSetup); }
      public:
        /// Constructor with default initializations
        tt__StreamSetup() : Stream(), Transport() { }
        /// Destructor
        virtual ~tt__StreamSetup() { }
        /// Friend allocator used by soap_new_tt__StreamSetup(struct soap*, int)
        friend SOAP_FMAC1 tt__StreamSetup * SOAP_FMAC2 soap_instantiate_tt__StreamSetup(struct soap*, int, const char*, const char*, size_t*);
};
#endif

/* ../onvif_head/onvif.h:998 */
#ifndef SOAP_TYPE_tt__Transport
#define SOAP_TYPE_tt__Transport (735)
/* Type tt__Transport is a recursive data type, (in)directly referencing itself through its (base or derived class) members */
/* complex XML schema type 'tt:Transport': */
class SOAP_CMAC tt__Transport : public soap_dom_element {
      public:
        /// Required element 'tt:Protocol' of XML schema type 'tt:TransportProtocol'
        enum tt__TransportProtocol Protocol;
        /// Optional element 'tt:Tunnel' of XML schema type 'tt:Transport'
        tt__Transport *Tunnel;
      public:
        /// Return unique type id SOAP_TYPE_tt__Transport
        virtual long soap_type(void) const { return SOAP_TYPE_tt__Transport; }
        /// (Re)set members to default values
        virtual void soap_default(struct soap*);
        /// Serialize object to prepare for SOAP 1.1/1.2 encoded output (or with SOAP_XML_GRAPH) by analyzing its (cyclic) structures
        virtual void soap_serialize(struct soap*) const;
        /// Output object in XML, compliant with SOAP 1.1 encoding style, return error code or SOAP_OK
        virtual int soap_put(struct soap*, const char *tag, const char *type) const;
        /// Output object in XML, with tag and optional id attribute and xsi:type, return error code or SOAP_OK
        virtual int soap_out(struct soap*, const char *tag, int id, const char *type) const;
        /// Get object from XML, compliant with SOAP 1.1 encoding style, return pointer to object or NULL on error
        virtual void *soap_get(struct soap*, const char *tag, const char *type);
        /// Get object from XML, with matching tag and type (NULL matches any tag and type), return pointer to object or NULL on error
        virtual void *soap_in(struct soap*, const char *tag, const char *type);
        /// Return a new object of type tt__Transport, default initialized and not managed by a soap context
        virtual tt__Transport *soap_alloc(void) const { return SOAP_NEW_UNMANAGED(tt__Transport); }
      public:
        /// Constructor with default initializations
        tt__Transport() : Protocol(), Tunnel() { }
        /// Destructor
        virtual ~tt__Transport() { }
        /// Friend allocator used by soap_new_tt__Transport(struct soap*, int)
        friend SOAP_FMAC1 tt__Transport * SOAP_FMAC2 soap_instantiate_tt__Transport(struct soap*, int, const char*, const char*, size_t*);
};
#endif

/* ../onvif_head/onvif.h:2146 */
#ifndef SOAP_TYPE__trt__GetStreamUri
#define SOAP_TYPE__trt__GetStreamUri (1309)
/* complex XML schema type 'trt:GetStreamUri': */
class SOAP_CMAC _trt__GetStreamUri {
      public:
        /// Required element 'trt:StreamSetup' of XML schema type 'tt:StreamSetup'
        tt__StreamSetup *StreamSetup;
        /// Required element 'trt:ProfileToken' of XML schema type 'tt:ReferenceToken'
        char *ProfileToken;
        /// Context that manages this object
        struct soap *soap;
      public:
        /// Return unique type id SOAP_TYPE__trt__GetStreamUri
        virtual long soap_type(void) const { return SOAP_TYPE__trt__GetStreamUri; }
        /// (Re)set members to default values
        virtual void soap_default(struct soap*);
        /// Serialize object to prepare for SOAP 1.1/1.2 encoded output (or with SOAP_XML_GRAPH) by analyzing its (cyclic) structures
        virtual void soap_serialize(struct soap*) const;
        /// Output object in XML, compliant with SOAP 1.1 encoding style, return error code or SOAP_OK
        virtual int soap_put(struct soap*, const char *tag, const char *type) const;
        /// Output object in XML, with tag and optional id attribute and xsi:type, return error code or SOAP_OK
        virtual int soap_out(struct soap*, const char *tag, int id, const char *type) const;
        /// Get object from XML, compliant with SOAP 1.1 encoding style, return pointer to object or NULL on error
        virtual void *soap_get(struct soap*, const char *tag, const char *type);
        /// Get object from XML, with matching tag and type (NULL matches any tag and type), return pointer to object or NULL on error
        virtual void *soap_in(struct soap*, const char *tag, const char *type);
        /// Return a new object of type _trt__GetStreamUri, default initialized and not managed by a soap context
        virtual _trt__GetStreamUri *soap_alloc(void) const { return SOAP_NEW_UNMANAGED(_trt__GetStreamUri); }
      public:
        /// Constructor with default initializations
        _trt__GetStreamUri() : StreamSetup(), ProfileToken(), soap() { }
        /// Destructor
        virtual ~_trt__GetStreamUri() { }
        /// Friend allocator used by soap_new__trt__GetStreamUri(struct soap*, int)
        friend SOAP_FMAC1 _trt__GetStreamUri * SOAP_FMAC2 soap_instantiate__trt__GetStreamUri(struct soap*, int, const char*, const char*, size_t*);
};
#endif

/* ../onvif_head/onvif.h:2148 */
#ifndef SOAP_TYPE__trt__GetStreamUriResponse
#define SOAP_TYPE__trt__GetStreamUriResponse (1310)
/* complex XML schema type 'trt:GetStreamUriResponse': */
class SOAP_CMAC _trt__GetStreamUriResponse {
      public:
        /// Required element 'trt:MediaUri' of XML schema type 'tt:MediaUri'
        tt__MediaUri *MediaUri;
        /// Context that manages this object
        struct soap *soap;
      public:
        /// Return unique type id SOAP_TYPE__trt__GetStreamUriResponse
        virtual long soap_type(void) const { return SOAP_TYPE__trt__GetStreamUriResponse; }
        /// (Re)set members to default values
        virtual void soap_default(struct soap*);
        /// Serialize object to prepare for SOAP 1.1/1.2 encoded output (or with SOAP_XML_GRAPH) by analyzing its (cyclic) structures
        virtual void soap_serialize(struct soap*) const;
        /// Output object in XML, compliant with SOAP 1.1 encoding style, return error code or SOAP_OK
        virtual int soap_put(struct soap*, const char *tag, const char *type) const;
        /// Output object in XML, with tag and optional id attribute and xsi:type, return error code or SOAP_OK
        virtual int soap_out(struct soap*, const char *tag, int id, const char *type) const;
        /// Get object from XML, compliant with SOAP 1.1 encoding style, return pointer to object or NULL on error
        virtual void *soap_get(struct soap*, const char *tag, const char *type);
        /// Get object from XML, with matching tag and type (NULL matches any tag and type), return pointer to object or NULL on error
        virtual void *soap_in(struct soap*, const char *tag, const char *type);
        /// Return a new object of type _trt__GetStreamUriResponse, default initialized and not managed by a soap context
        virtual _trt__GetStreamUriResponse *soap_alloc(void) const { return SOAP_NEW_UNMANAGED(_trt__GetStreamUriResponse); }
      public:
        /// Constructor with default initializations
        _trt__GetStreamUriResponse() : MediaUri(), soap() { }
        /// Destructor
        virtual ~_trt__GetStreamUriResponse() { }
        /// Friend allocator used by soap_new__trt__GetStreamUriResponse(struct soap*, int)
        friend SOAP_FMAC1 _trt__GetStreamUriResponse * SOAP_FMAC2 soap_instantiate__trt__GetStreamUriResponse(struct soap*, int, const char*, const char*, size_t*);
};
#endif

2.函数

函数声明：client\application\soapStub.h

/** Web service synchronous operation 'soap_call___trt__GetStreamUri' to the specified endpoint and SOAP Action header, returns SOAP_OK or error code */
SOAP_FMAC5 int SOAP_FMAC6 soap_call___trt__GetStreamUri(struct soap *soap, const char *soap_endpoint, const char *soap_action, _trt__GetStreamUri *trt__GetStreamUri, _trt__GetStreamUriResponse &trt__GetStreamUriResponse);

函数定义：client\application\soapClient.cpp

SOAP_FMAC5 int SOAP_FMAC6 soap_call___trt__GetStreamUri(struct soap *soap, const char *soap_endpoint, const char *soap_action, _trt__GetStreamUri *trt__GetStreamUri, _trt__GetStreamUriResponse &trt__GetStreamUriResponse)
{	if (soap_send___trt__GetStreamUri(soap, soap_endpoint, soap_action, trt__GetStreamUri) || soap_recv___trt__GetStreamUri(soap, trt__GetStreamUriResponse))
		return soap->error;
	return SOAP_OK;
}

四、功能实现（c++）

int ONVIF_GetMediaCapabilities(const std::string& deviceXAddr, std::string *mediaXAddr)
{
    int result = 0;
    struct soap *soap = nullptr;
    _tds__GetCapabilities            devinfo_req;
    _tds__GetCapabilitiesResponse    devinfo_resp;


            SOAP_ASSERT(!deviceXAddr.empty());
            SOAP_ASSERT(nullptr != (soap = ONVIF_soap_new(SOAP_SOCK_TIMEOUT)));

    result = soap_call___tds__GetCapabilities(soap, deviceXAddr.c_str(), NULL, &devinfo_req, devinfo_resp);
    SOAP_CHECK_ERROR(result, soap, "GetCapabilities");
    

    if(devinfo_resp.Capabilities->Media != nullptr)
    {
        *mediaXAddr=devinfo_resp.Capabilities->Media->XAddr;
    }
    else
    {
        *mediaXAddr="null";
    }
       

#if DEBUG
    std::cout << "---------------------ONVIF_GetPTZCapabilities------------------" << "\n";
    std::cout << "Media:" << *mediaXAddr << "\n";
    std::cout << "-------------------------------------------------------------" << "\n";
#endif

    EXIT:

    if (nullptr != soap) {
        ONVIF_soap_delete(soap);
    }
    return result;
}

bool ONVIF_GetMediaProfilesToken(const std::string& mediaXAddr, std::string *mediaprofilesToken)
{
    int result = 0;
    struct soap *soap = nullptr;
    _trt__GetProfiles           devinfo_req;
    _trt__GetProfilesResponse   devinfo_resp;

            SOAP_ASSERT(!mediaXAddr.empty());
            SOAP_ASSERT(nullptr != (soap = ONVIF_soap_new(SOAP_SOCK_TIMEOUT)));

    ONVIF_SetAuthInfo(soap, USERNAME, PASSWORD);
    result = soap_call___trt__GetProfiles(soap, mediaXAddr.c_str(), nullptr, &devinfo_req, devinfo_resp);
    SOAP_CHECK_ERROR(result, soap, "ONVIF_GetProfiles");

            SOAP_ASSERT(devinfo_resp.__sizeProfiles > 0);

    *mediaprofilesToken = (*devinfo_resp.Profiles)->token;
#if DEBUG
    std::cout << "-----------------ONVIF_GetMediaProfilesToken-----------------" << "\n";
    std::cout << *mediaprofilesToken << "\n";
    std::cout << "-------------------------------------------------------------" << "\n";
#endif 
    EXIT:
    if (nullptr != soap) {
        ONVIF_soap_delete(soap);
    }

    return result;
}

/************************************************************************
**函数：ONVIF_GetStreamUri
**功能：获取设备码流地址(RTSP)
**参数：
       [in]  MediaXAddr    - 媒体服务地址
       [in]  ProfileToken  - the media profile token
**返回：
       0表明成功，非0表明失败
**备注：
************************************************************************/
int ONVIF_GetStreamUri(const std::string&MediaXAddr, const std::string&ProfileToken, std::string *streamUri)
{
    int result = 0;
    struct soap *soap = nullptr;
    tt__StreamSetup              ttStreamSetup;
    tt__Transport                ttTransport;
    _trt__GetStreamUri           req;
    _trt__GetStreamUriResponse   rep;

     SOAP_ASSERT(!MediaXAddr.empty());
     SOAP_ASSERT(nullptr != (soap = ONVIF_soap_new(SOAP_SOCK_TIMEOUT)));


    ttStreamSetup.Stream                = tt__StreamType__RTP_Unicast;
    ttStreamSetup.Transport             = &ttTransport;
    ttStreamSetup.Transport->Protocol   = tt__TransportProtocol__RTSP;
    ttStreamSetup.Transport->Tunnel     = nullptr;
    req.StreamSetup                     = &ttStreamSetup;
    req.ProfileToken                    = const_cast<char *>(ProfileToken.c_str());

    ONVIF_SetAuthInfo(soap, USERNAME, PASSWORD);
    result = soap_call___trt__GetStreamUri(soap, MediaXAddr.c_str(), nullptr, &req, rep);
    SOAP_CHECK_ERROR(result, soap, "GetServices");



    if (nullptr != rep.MediaUri) {
        if (nullptr != rep.MediaUri->Uri) {
            *streamUri = rep.MediaUri->Uri;
#if DEBUG
            std::cout << "----------------------ONVIF_GetStreamUri---------------------" << "\n";
            std::cout << "RTSP URI：\t"<< *streamUri << "\n";
            std::cout << "-------------------------------------------------------------" << "\n";
#endif
        }
    }

    EXIT:

    if (nullptr != soap) {
        ONVIF_soap_delete(soap);
    }

    return result;
}
ONVIF协议及协议测试工具使用详解
dvlinker的技术专栏
07-21 9284
Onvif协议及协议测试工具使用详解
Onvif协议及协议测试工具使用详解
dvlinker的技术专栏
06-11 749
Onvif协议及协议测试工具使用详解
Android Onvif协议获取支持Onvif协议的流播放地址
gcfengcsdn的博客
04-01 2147
以下为上份工作 在android机顶盒内发现局域网内支持Onvif协议的摄像头地址。也是网络找的demo 修改后实现。 在此备份以备不时之需。 ONVIF协议的本质就是通过发送xml格式的文件 包含soap 以及指定的标签以实现进行某种操作的目的。 第一步是发现设备，通过发送搜索广播包到局域网的广播地址，等待支持onvif协议的设备回复报文。需要从报文中提取uuid和onvif设备的主地址。...
Onvif协议NVR开发方案指南
最新发布
_程序猿
02-23 975
【代码】Onvif协议NVR开发方案指南。
Onvif协议：IPC客户端开发之获取实时预览的Url地址
OceanStar的博客
10-30 4055
介绍 Onvif协议对前端摄像头的取流是通过标准Rtsp协议，因此我们就需要通过Onvif协议获取到需要预览摄像头的Rtsp的地址，将拿到的RTSP通过VLC或者其他的RTSP客户端取流预览前端摄像头。 编码流程 通过「设备发现」，得到 「设备服务地址」。 使用「设备服务地址」调用GetCapabilities接口，得到「媒体服务地址」。 使用「媒体服务地址」调用GetProfiles接口，得到主次码流的「媒体配置信息」，其中包含ProfileToken 根据获取到的token调用对应的接口获取到RTSP
ONVIF获取摄像头媒体地址
09-24
使用VS2013编译，onvif最新版本，gsoap 2.8.23 openssl 1.0.1
ONVIF协议了解
u014415274的博客
05-22 1万+
Onvif，即Open Network Video Interface Forum ，可以译为开放型网络视频接口论坛，是安迅士、博世、索尼在2008年共同成立的一个国际性、开发型网络视频产品标准网络接口的开发论坛，后来由于这个技术开发论坛共同制定的开发型行业标准，就用该论坛的大写字母命名，即ONVIF 网络视频标准规范，习惯简称为：ONVIF协议。
ONVIF协议--ONVIF WS-Discovery （设备发现协议）
积木的笔记
11-26 7545
ONVIF Discovery 协议介绍
网络摄像机（IPC）开发（5）：ONVIF获取rtsp流url
ProYuan的博客
10-12 5534
一、获取URL 通过GetStreamUri获取IPC的rtsp流url，这个url地址就是后面RTSP交互时，获取视频流的地址，同时，通过VLC等软件加载网络URL，也是可以播放视频流的。 二、获取编码参数实现 1、创建tcp socket，IP为192.168.100.123，端口：8099； 2、填写ProfileToken值为上篇博客获取编码参数的值token="000"，这里直接...
基于C#的onvif协议之抓图
04-25
2. **设备认证**：获取设备的详细信息，包括其ONVIF端点和服务URL。同时，确保有正确的凭证（如用户名和密码）进行身份验证。 3. **媒体服务接口**：与设备的媒体服务接口建立连接，获取摄像头的预览流信息。这通常...
LiveNVR Onvif/RTSP 流媒体服务使用说明书
精准搬砖
03-28 975
服务资源| QQ交流群：615081503简介LiveNVR 能够通过简单的网络摄像机通道配置，将传统监控行业里面的高清网络摄像机 IPCamera、NVR 等具有 RTSP/Onvif 协议输出的设备接入到 LiveNVR，LiveNVR 能够将这些设备源的音/视频数据进行采集、转换、输出，进行全平台终端直播（PC、Android、iOS、微信、H5），并且LiveNVR能够将视频源的直播数据对接到第三方 CDN 网络，实现安防设备互联网级别的直播分发。主要功能。
ONVIF客户端读取rtsp地址
02-11
Windows下采用VS2017做ONVIF协议的客户端，自己下载gsoap编译C语言框架开发，项目采用的是沃沃安的HDMI编码器作为服务器，实现搜索设备，获取设备信息，获取设备能力，读取音视频流地址，以及图像抓拍地址。可移植到ffmpeg或者VLC开发的播放器。
C# onvif获取摄像头rtsp视频流地址和抓拍图片地址
11-15
C#使用onvif协议获取网络摄像头rtsp视频流地址和图片地址，将rtsp视频流地址保存到本地mp4可以参考我的另一个资源
onvif获取摄像头的流媒体地址完整流程
weixin_33804990的博客
06-15 8996
linux设备上的Onvif 实现6：获取摄像头的流媒体地址完整流程   整体流程： Probe： 发现网络摄像头，获取webserver地址     http://192.168.15.240/onvif/device_service GetCapabilities：获取设备能力文件，从中识别出媒体信息地址URI：  http://192.168.15.240/onvif/Med...
Onvif协议客户端开发（6）--获取实时预览的Url地址
热门推荐
数据迷宫
10-04 1万+
获取实时预览的Url地址 一、介绍 Onvif协议对前端摄像头的取流是通过标准Rtsp协议，因此我们就需要通过Onvif协议获取到需要预览摄像头的Rtsp的地址，将拿到的RTSP通过VLC或者其他的RTSP客户端取流预览前端摄像头。 通过Onvif协议获取到前端摄像头的Rtsp地址，需要两个步骤： 1、获取到实时预览RTSP的地址的Token 2、根据获取到的token调用对应的接口获取到RTS...
ONVIF 摄像头视频流获取 - 步骤与Python例程
含光左卫的工作笔记集
08-02 2309
.基本流程 加入组播udp接口，查询子网内在线的ONVIF摄像头的设备地址： 设备地址形如：http://192.168.0.6/onvif/device_service 这一步，参看上一篇发文：[ONVIF系列 - 01] 简介 - 设备发现 - 相关工具-CSDN博客 查询mediaService Uri地址 mediaService地址形如: http://192.168.0.6/onvif/Media 查询用户的Profiles，得到一个我们需要的Profile
Onvif学习笔记3 - 获取相机视频流地址
bluish_white的博客
11-05 8164
流程 根据Onvif APG文档，视频流地址的获取分两个步骤：1、GetProfiles()；2、GetStreamURI()。 GetProfiles() 作为下一步的先决条件，GetProfiles的目的是获取Media Name和token。 首先需要定义两个结构体，用于信息的发送和接收： #include "soapStub.h" struct _trt__GetProfiles
ONVIF协议网络摄像机客户端使用gsoap获取RTSP流地址GStreamer拉流播放
jcf5832的博客
11-30 1737
gsoap获取RTSP流地址GStreamer拉流播放
gsoap-onvif项目：学习如何获取IPC设备信息
本项目为一个ONVIF客户端项目，旨在帮助开发者了解并掌握如何获取IP摄像头（IPC）的RTSP URL、视频配置、WSDL地址以及设备的能力（例如PTZ控制）。ONVIF（Open Network Video Interface Forum）是一种开放的行业论坛...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值