SRT链路统计信息接口（Link Statistics）

最新推荐文章于 2023-02-28 19:44:38 发布
最新推荐文章于 2023-02-28 19:44:38 发布
阅读量814 收藏 2
点赞数
分类专栏： 网络通信 音视频传输协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014162133/article/details/106383366
版权

一.接口名称

// perfmon with Byte counters for better bitrate estimation.
SRT_API int srt_bstats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear);
// permon with Byte counters and instantaneous stats instead of moving averages for Snd/Rcvbuffer sizes.
SRT_API int srt_bistats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear, int instantaneous);

int srt_bstats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear) { return CUDT::bstats(u, perf, 0!=  clear); }
int srt_bistats(SRTSOCKET u, SRT_TRACEBSTATS * perf, int clear, int instantaneous) { return CUDT::bstats(u, perf, 0!=  clear, 0!= instantaneous); }

二.调用流程

int SrtTarget::Write(const char* data, size_t size, ostream &out_stats)
{
    static unsigned long counter = 1;

    int stat = srt_sendmsg2(m_sock, data, (int) size, nullptr);
    if (stat == SRT_ERROR)
    {
        return stat;
    }

    const bool need_bw_report = transmit_bw_report && (counter % transmit_bw_report) == transmit_bw_report - 1;
    const bool need_stats_report = transmit_stats_report && (counter % transmit_stats_report) == transmit_stats_report - 1;

    if (need_bw_report || need_stats_report)
    {
        CBytePerfMon perf;
        srt_bstats(m_sock, &perf, need_stats_report && !transmit_total_stats);
        if (stats_writer != nullptr)
        {
            if (need_bw_report)
                cerr << stats_writer->WriteBandwidth(perf.mbpsBandwidth) << std::flush;
            if (need_stats_report)
                out_stats << stats_writer->WriteStats(m_sock, perf) << std::flush;
        }
    }
    ++counter;
    return stat;
}

int SrtSource::Read(size_t chunk, bytevector& data, ostream &out_stats)
{
    static unsigned long counter = 1;

    if (data.size() < chunk)
        data.resize(chunk);

    const int stat = srt_recvmsg(m_sock, data.data(), (int) chunk);
    if (stat <= 0)
    {
        data.clear();
        return stat;
    }

    chunk = size_t(stat);
    if (chunk < data.size())
        data.resize(chunk);

    const bool need_bw_report = transmit_bw_report && (counter % transmit_bw_report) == transmit_bw_report - 1;
    const bool need_stats_report = transmit_stats_report && (counter % transmit_stats_report) == transmit_stats_report - 1;

    if (need_bw_report || need_stats_report)
    {
        CBytePerfMon perf;
        srt_bstats(m_sock, &perf, need_stats_report && !transmit_total_stats);
        if (stats_writer != nullptr) 
        {
            if (need_bw_report)
                cerr << stats_writer->WriteBandwidth(perf.mbpsBandwidth) << std::flush;
            if (need_stats_report)
                out_stats << stats_writer->WriteStats(m_sock, perf) << std::flush;
        }
    }
    ++counter;
    return stat;
}

三.接口内部实现

void CUDT::bstats(CBytePerfMon *perf, bool clear, bool instantaneous)
{
    if (!m_bConnected)
        throw CUDTException(MJ_CONNECTION, MN_NOCONN, 0);
    if (m_bBroken || m_bClosing)
        throw CUDTException(MJ_CONNECTION, MN_CONNLOST, 0);

    CGuard statsguard(m_StatsLock);

    uint64_t currtime = CTimer::getTime();
    perf->msTimeStamp = (currtime - m_stats.startTime) / 1000;

    perf->pktSent              = m_stats.traceSent;
    perf->pktRecv              = m_stats.traceRecv;
    perf->pktSndLoss           = m_stats.traceSndLoss;
    perf->pktRcvLoss           = m_stats.traceRcvLoss;
    perf->pktRetrans           = m_stats.traceRetrans;
    perf->pktRcvRetrans        = m_stats.traceRcvRetrans;
    perf->pktSentACK           = m_stats.sentACK;
    perf->pktRecvACK           = m_stats.recvACK;
    perf->pktSentNAK           = m_stats.sentNAK;
    perf->pktRecvNAK           = m_stats.recvNAK;
    perf->usSndDuration        = m_stats.sndDuration;
    perf->pktReorderDistance   = m_stats.traceReorderDistance;
    perf->pktReorderTolerance  = m_iReorderTolerance;
    perf->pktRcvAvgBelatedTime = m_stats.traceBelatedTime;
    perf->pktRcvBelated        = m_stats.traceRcvBelated;

    perf->pktSndFilterExtra  = m_stats.sndFilterExtra;
    perf->pktRcvFilterExtra  = m_stats.rcvFilterExtra;
    perf->pktRcvFilterSupply = m_stats.rcvFilterSupply;
    perf->pktRcvFilterLoss   = m_stats.rcvFilterLoss;

    /* perf byte counters include all headers (SRT+UDP+IP) */
    const int pktHdrSize = CPacket::HDR_SIZE + CPacket::UDP_HDR_SIZE;
    perf->byteSent       = m_stats.traceBytesSent + (m_stats.traceSent * pktHdrSize);
    perf->byteRecv       = m_stats.traceBytesRecv + (m_stats.traceRecv * pktHdrSize);
    perf->byteRetrans    = m_stats.traceBytesRetrans + (m_stats.traceRetrans * pktHdrSize);
#ifdef SRT_ENABLE_LOSTBYTESCOUNT
    perf->byteRcvLoss = m_stats.traceRcvBytesLoss + (m_stats.traceRcvLoss * pktHdrSize);
#endif

    perf->pktSndDrop  = m_stats.traceSndDrop;
    perf->pktRcvDrop  = m_stats.traceRcvDrop + m_stats.traceRcvUndecrypt;
    perf->byteSndDrop = m_stats.traceSndBytesDrop + (m_stats.traceSndDrop * pktHdrSize);
    perf->byteRcvDrop =
        m_stats.traceRcvBytesDrop + (m_stats.traceRcvDrop * pktHdrSize) + m_stats.traceRcvBytesUndecrypt;
    perf->pktRcvUndecrypt  = m_stats.traceRcvUndecrypt;
    perf->byteRcvUndecrypt = m_stats.traceRcvBytesUndecrypt;

    perf->pktSentTotal       = m_stats.sentTotal;
    perf->pktRecvTotal       = m_stats.recvTotal;
    perf->pktSndLossTotal    = m_stats.sndLossTotal;
    perf->pktRcvLossTotal    = m_stats.rcvLossTotal;
    perf->pktRetransTotal    = m_stats.retransTotal;
    perf->pktSentACKTotal    = m_stats.sentACKTotal;
    perf->pktRecvACKTotal    = m_stats.recvACKTotal;
    perf->pktSentNAKTotal    = m_stats.sentNAKTotal;
    perf->pktRecvNAKTotal    = m_stats.recvNAKTotal;
    perf->usSndDurationTotal = m_stats.m_sndDurationTotal;

    perf->byteSentTotal           = m_stats.bytesSentTotal + (m_stats.sentTotal * pktHdrSize);
    perf->byteRecvTotal           = m_stats.bytesRecvTotal + (m_stats.recvTotal * pktHdrSize);
    perf->byteRetransTotal        = m_stats.bytesRetransTotal + (m_stats.retransTotal * pktHdrSize);
    perf->pktSndFilterExtraTotal  = m_stats.sndFilterExtraTotal;
    perf->pktRcvFilterExtraTotal  = m_stats.rcvFilterExtraTotal;
    perf->pktRcvFilterSupplyTotal = m_stats.rcvFilterSupplyTotal;
    perf->pktRcvFilterLossTotal   = m_stats.rcvFilterLossTotal;

#ifdef SRT_ENABLE_LOSTBYTESCOUNT
    perf->byteRcvLossTotal = m_stats.rcvBytesLossTotal + (m_stats.rcvLossTotal * pktHdrSize);
#endif
    perf->pktSndDropTotal  = m_stats.sndDropTotal;
    perf->pktRcvDropTotal  = m_stats.rcvDropTotal + m_stats.m_rcvUndecryptTotal;
    perf->byteSndDropTotal = m_stats.sndBytesDropTotal + (m_stats.sndDropTotal * pktHdrSize);
    perf->byteRcvDropTotal =
        m_stats.rcvBytesDropTotal + (m_stats.rcvDropTotal * pktHdrSize) + m_stats.m_rcvBytesUndecryptTotal;
    perf->pktRcvUndecryptTotal  = m_stats.m_rcvUndecryptTotal;
    perf->byteRcvUndecryptTotal = m_stats.m_rcvBytesUndecryptTotal;
    //<

    double interval = double(currtime - m_stats.lastSampleTime);

    //>mod
    perf->mbpsSendRate = double(perf->byteSent) * 8.0 / interval;
    perf->mbpsRecvRate = double(perf->byteRecv) * 8.0 / interval;
    //<

    perf->usPktSndPeriod      = m_ullInterval_tk / double(m_ullCPUFrequency);
    perf->pktFlowWindow       = m_iFlowWindowSize;
    perf->pktCongestionWindow = (int)m_dCongestionWindow;
    perf->pktFlightSize       = CSeqNo::seqlen(m_iSndLastAck, CSeqNo::incseq(m_iSndCurrSeqNo)) - 1;
    perf->msRTT               = (double)m_iRTT / 1000.0;
    //>new
    perf->msSndTsbPdDelay = m_bPeerTsbPd ? m_iPeerTsbPdDelay_ms : 0;
    perf->msRcvTsbPdDelay = m_bTsbPd ? m_iTsbPdDelay_ms : 0;
    perf->byteMSS         = m_iMSS;

    perf->mbpsMaxBW = m_llMaxBW > 0 ? Bps2Mbps(m_llMaxBW) : m_CongCtl.ready() ? Bps2Mbps(m_CongCtl->sndBandwidth()) : 0;

    //<
    uint32_t availbw = (uint64_t)(m_iBandwidth == 1 ? m_RcvTimeWindow.getBandwidth() : m_iBandwidth);

    perf->mbpsBandwidth = Bps2Mbps(availbw * (m_iMaxSRTPayloadSize + pktHdrSize));

    if (pthread_mutex_trylock(&m_ConnectionLock) == 0)
    {
        if (m_pSndBuffer)
        {
#ifdef SRT_ENABLE_SNDBUFSZ_MAVG
            if (instantaneous)
            {
                /* Get instant SndBuf instead of moving average for application-based Algorithm
                   (such as NAE) in need of fast reaction to network condition changes. */
                perf->pktSndBuf = m_pSndBuffer->getCurrBufSize(Ref(perf->byteSndBuf), Ref(perf->msSndBuf));
            }
            else
            {
                perf->pktSndBuf = m_pSndBuffer->getAvgBufSize(Ref(perf->byteSndBuf), Ref(perf->msSndBuf));
            }
#else
            perf->pktSndBuf = m_pSndBuffer->getCurrBufSize(Ref(perf->byteSndBuf), Ref(perf->msSndBuf));
#endif
            perf->byteSndBuf += (perf->pktSndBuf * pktHdrSize);
            //<
            perf->byteAvailSndBuf = (m_iSndBufSize - perf->pktSndBuf) * m_iMSS;
        }
        else
        {
            perf->byteAvailSndBuf = 0;
            // new>
            perf->pktSndBuf  = 0;
            perf->byteSndBuf = 0;
            perf->msSndBuf   = 0;
            //<
        }

        if (m_pRcvBuffer)
        {
            perf->byteAvailRcvBuf = m_pRcvBuffer->getAvailBufSize() * m_iMSS;
            // new>
#ifdef SRT_ENABLE_RCVBUFSZ_MAVG
            if (instantaneous) // no need for historical API for Rcv side
            {
                perf->pktRcvBuf = m_pRcvBuffer->getRcvDataSize(perf->byteRcvBuf, perf->msRcvBuf);
            }
            else
            {
                perf->pktRcvBuf = m_pRcvBuffer->getRcvAvgDataSize(perf->byteRcvBuf, perf->msRcvBuf);
            }
#else
            perf->pktRcvBuf = m_pRcvBuffer->getRcvDataSize(perf->byteRcvBuf, perf->msRcvBuf);
#endif
            //<
        }
        else
        {
            perf->byteAvailRcvBuf = 0;
            // new>
            perf->pktRcvBuf  = 0;
            perf->byteRcvBuf = 0;
            perf->msRcvBuf   = 0;
            //<
        }

        pthread_mutex_unlock(&m_ConnectionLock);
    }
    else
    {
        perf->byteAvailSndBuf = 0;
        perf->byteAvailRcvBuf = 0;
        // new>
        perf->pktSndBuf  = 0;
        perf->byteSndBuf = 0;
        perf->msSndBuf   = 0;

        perf->byteRcvBuf = 0;
        perf->msRcvBuf   = 0;
        //<
    }

    if (clear)
    {
        m_stats.traceSndDrop           = 0;
        m_stats.traceRcvDrop           = 0;
        m_stats.traceSndBytesDrop      = 0;
        m_stats.traceRcvBytesDrop      = 0;
        m_stats.traceRcvUndecrypt      = 0;
        m_stats.traceRcvBytesUndecrypt = 0;
        // new>
        m_stats.traceBytesSent = m_stats.traceBytesRecv = m_stats.traceBytesRetrans = 0;
        //<
        m_stats.traceSent = m_stats.traceRecv = m_stats.traceSndLoss = m_stats.traceRcvLoss = m_stats.traceRetrans =
            m_stats.sentACK = m_stats.recvACK = m_stats.sentNAK = m_stats.recvNAK = 0;
        m_stats.sndDuration                                                       = 0;
        m_stats.traceRcvRetrans                                                   = 0;
        m_stats.traceRcvBelated                                                   = 0;
#ifdef SRT_ENABLE_LOSTBYTESCOUNT
        m_stats.traceRcvBytesLoss = 0;
#endif

        m_stats.sndFilterExtra = 0;
        m_stats.rcvFilterExtra = 0;

        m_stats.rcvFilterSupply = 0;
        m_stats.rcvFilterLoss   = 0;

        m_stats.lastSampleTime = currtime;
    }
}

参考资料：
https://github.com/Haivision/srt
[github releases]: https://github.com/Haivision/srt/releases

【SRT】FFmpeg 测试 SRT
突围
09-30 1592
SRT
建立数据库链路、统计表记录数、查看会话及最大会话数
Leon1509的专栏
06-27 368
1. 生成统计表数据SQL [code="sql"]select 'analyze table ' || table_name || ' compute statistics;' from user_tables where table_name like 'PR\_%\_%' escape '\' and tablespace_name = 'PR_DATA1'[/code] 2. 统计企...
13-实时统计：链路跟踪实时计算中的实用算法
最新发布
sucaiwa的博客
02-28 333
这节课我给你分享了四种实用的算法，这些都是我实践验证过的。你可以结合后面这张图来复习记忆。为了解决参数不同给网址聚类造成的难题，可以通过配置或数据特征过滤方式对URL进行整理，还可以通过时间块减少统计的结果数据量。为了梳理大量的错误日志，simhash算法是一个不错的选择，还可以搭配bitmap记录错误日志的出现频率。有了这些算法的帮助，用少量系统资源，即可实现线上服务的故障监控聚合分析功能，将服务的工作状态直观地展示出来。
SRT协议详解三 传输参数
相见不如怀念
05-22 7516
4.1. 参数名称解析 这一节，我将逐个向大家介绍会影响SRT传输性能的参数名称，他们包括：Round Trip Time（RTT，往返延时）、RTT Multiplier（RTT倍数）、Packet Loss Rate（丢包率）、Bandwidth Overhead（带宽开销）以及Latency（延时），SRT加密等。 4.1.1. Round Trip Time (RTT) RTT（往返延时）表示从发送端发送数据开始，到发送端收到来自接收端的确认（接收端收到数据后便立即发送确认），总共经历的时延。我们可
libsrt_操作及相关记录（一）
朱韦刚(zhuweigangzwg)的技术博客
10-10 3573
libsrt_操作及相关记录（一） 时间：2020年6月11日； 一：libsrt的相关链接： 1：https://www.srtalliance.org/（libstr的官网）； 2：https://github.com/Haivision/srt/（libsrt的源码下载地址）； 3：https://github.com/Haivision/srt/releases/（libsrt的 源码更新情况及相关添加情况和bug修改情况）； ...
srt2txt srt格式文件转txt
02-20
"用这款软件另存，没有时间信息" 指出，使用特定的srt2txt软件进行转换，会去除srt文件中的时间码，只保留文本内容。这可能是因为某些场景下，用户只需要文字内容，而不关心字幕的精确时间对应。例如，用于文本分析...
srt协议的caller模式的c语言源码
02-25
- **SRT库**：使用SRT协议需要包含SRT库，该库提供了接口供开发者调用，实现协议功能。 - **套接字编程**：SRT基于套接字编程，因此理解和掌握基本的socket编程是必要的。 - **事件驱动**：SRT API支持异步操作，...
srt-master.zip
05-11
SRT（Secure Reliable Transport）是一种高效、安全的实时传输协议，尤其适用于低延迟、高带宽效率和高可靠性要求的网络应用，如视频直播、在线会议等。在本压缩包"Srt-master.zip"中，包含了SRT的源代码，这为...
java程序B站json字幕转srt
09-27
Java程序用于将B站（哔哩哔哩）的JSON格式字幕转换为SRT字幕是一种常见的需求，尤其是在处理视频字幕同步时。这个程序利用了Java的强大处理能力，将B站特有的JSON格式解析，然后转化为SRT这种更为通用的字幕格式。...
RTSP/RTMP/HTTP/ QUIC/UDT/SRT
tklwj的专栏
12-29 2860
一、RTSP、RTMP、HTTP协议 这三个协议都属于互联网 TCP/IP 五层体系结构中应用层的协议。理论上这三种都可以用来做视频直播或点播。但通常来说，直播一般用 RTSP、RTMP。而点播用 HTTP。下面分别介绍下三者的特点。 1、RTSP（Real Time Streaming Protocol），RFC2326，实时流传输协议。 RTSP是TCP/IP协议体系中的一个应用层协议，...
srt-master下sendfile
Binary2014的博客
05-20 559
根据srt-master提供文件收发Demo（sendfile，recvfile） 1.构建发送服务 ./sendfile username@Ubuntu:~/srt/srt-master$ ./sendfile server is ready at port: 9000 2.构建接收服务 sample-usage: recvfile server_ip server_port remo...
SRT服务器搭建及测试
大道至简
03-24 8652
SRT服务器搭建及测试
SRT协议翻译
sweibd的专栏
04-19 2486
SRT协议 srt是基于UDT传输协议，是用户级别的协议，其保留UDT的核心思想和机制，但是做了多项改进，包括控制报文的修改，针对直播流改进了流控，改进了拥塞算法，报文加密算法。本文介绍srt协议本身。更多的相关实现在：https://github.com/Haivision/srt 简介 srt传输协议为不可靠网络提供安全，可靠的数据传输，如因特网。任何数据都可以在srt协议上传输，特别是对音视...
流媒体分析之srt协议ffmpeg 实现
u012794472的专栏
09-09 1756
1. mpegts 封装格式会后面系列文章中讲叙，在ffmpeg 中的封装实现接口如下：mpegtsenc.c。解封封装：FFmpeg-n4.3.3/libavformat/mpegts.c。srt 音视频数据是基于mpegts 封装的,ffmpeg 数据流程。
如何实现一个分布式统计和过滤的链路追踪
阿里巴巴中间件
06-04 668
首届云原生编程挑战赛正在报名中，初赛共有三个赛道，题目如下：赛道一：实现一个分布式统计和过滤的链路追踪赛道二：实现规模化容器静态布局和动态迁移赛道三：服务网格控制面分治体系构建本文主要针...
公网传输技术之SRT协议解析（下）
LiveVideoStack
05-17 598
本文将从SRT协议的工作流程入手，对SRT协议的数据包结构进行解析，之后举例介绍如何利用Wireshark软件进行抓包分析，从而排除链路故障或者获取链路信息。
SRT传输库评估
mediapro的博客
04-27 5086
SRT是Haivision开源的一套集FEC前向纠错、ACK、NAK选择性重传、JitterBuff、拥塞控制、传输安全保障等技术于一体的实时传输解决方案。方案基于UDP协议进行扩展，目前SRT在广电领域获得了不错的应用，因其弱网抵抗以及较好的实时性，必将取代基于TCP的RTMP伪直播方案。SRT方案使用C++开发，提供C风格接口，依赖OpenSSL\Pthreads库，官方编译脚本支持Windows、Linux、Mac\IOS系统，可自行参考移植到Android。
Windows平台SRT协议工具及库文件压缩包
资源摘要信息:"srtWindowsTools.zip" SRT流媒体协议是一个开放源代码的通信协议，主要用途是提供低延迟的视频流传输。该协议特别适合需要高效、可靠传输的实时视频应用，如远程视频监控、直播、视频会议等场景。SRT...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值