AI automatically translates all comments in the code into English (#3917)

src/Rtcp/Rtcp.cpp

@@ -69,7 +69,8 @@ static void setupHeader(RtcpHeader *rtcp, RtcpType type, size_t report_count, si
     if (report_count > 0x1F) {
         throw std::invalid_argument(StrPrinter << "rtcp report_count最大赋值为31,当前为:" << report_count);
     }
-    // items总个数
+    // items总个数  [AUTO-TRANSLATED:2d40d010]
+    // Total number of items
     rtcp->report_count = report_count;
     rtcp->pt = (uint8_t)type;
     rtcp->setSize(total_bytes);
@@ -149,7 +150,8 @@ string RtcpHeader::dumpString() const {
 }
 
 size_t RtcpHeader::getSize() const {
-    // 加上rtcp头长度
+    // 加上rtcp头长度  [AUTO-TRANSLATED:21a40b4b]
+    // Add rtcp header length
     return (1 + ntohs(length)) << 2;
 }
 
@@ -161,7 +163,8 @@ size_t RtcpHeader::getPaddingSize() const {
 }
 
 void RtcpHeader::setSize(size_t size) {
-    // 不包含rtcp头的长度
+    // 不包含rtcp头的长度  [AUTO-TRANSLATED:b26ad8ef]
+    // Length excluding rtcp header
     length = htons((uint16_t)((size >> 2) - 1));
 }
 
@@ -230,7 +233,8 @@ vector<RtcpHeader *> RtcpHeader::loadFromBytes(char *data, size_t len) {
             rtcp->net2Host(rtcp_len);
             ret.emplace_back(rtcp);
         } catch (std::exception &ex) {
-            // 不能处理的rtcp包，或者无法解析的rtcp包，忽略掉
+            // 不能处理的rtcp包，或者无法解析的rtcp包，忽略掉  [AUTO-TRANSLATED:752ec400]
+            // Ignore unprocessable rtcp packets or rtcp packets that cannot be parsed
             WarnL << ex.what() << ",长度为:" << rtcp_len;
         }
         ptr += rtcp_len;
@@ -273,8 +277,10 @@ string RtcpSR::getNtpStamp() const {
 
 uint64_t RtcpSR::getNtpUnixStampMS() const {
     if (ntpmsw < 0x83AA7E80) {
-        // ntp时间戳起始时间为1900年，但是utc时间戳起始时间为1970年，两者相差0x83AA7E80秒
-        // ntp时间戳不得早于1970年，否则无法转换为utc时间戳
+        // ntp时间戳起始时间为1900年，但是utc时间戳起始时间为1970年，两者相差0x83AA7E80秒  [AUTO-TRANSLATED:6b3ac2fa]
+        // The ntp timestamp starts from 1900, but the utc timestamp starts from 1970, with a difference of 0x83AA7E80 seconds
+        // ntp时间戳不得早于1970年，否则无法转换为utc时间戳  [AUTO-TRANSLATED:d70fc88c]
+        // The ntp timestamp must not be earlier than 1970, otherwise it cannot be converted to utc timestamp
         return 0;
     }
     struct timeval tv;
@@ -321,7 +327,10 @@ string RtcpSR::dumpString() const {
     }
 
 #define CHECK_REPORT_COUNT(item_count)                                                                                 \
-    /*修正个数，防止getItemList时内存越界*/                                                                \
+    /*修正个数，防止getItemList时内存越界
+     /*Correct the number to prevent memory overflow when getItemList
+     * [AUTO-TRANSLATED:852bd70e]
+     */                                                                \
     if (report_count != item_count) {                                                                                  \
         WarnL << rtcpTypeToStr((RtcpType)pt) << " report_count 字段不正确,已修正为:" << (int)report_count << " -> "    \
               << item_count;                                                                                           \
@@ -461,7 +470,8 @@ string SdesChunk::dumpString() const {
 std::shared_ptr<RtcpSdes> RtcpSdes::create(const std::vector<string> &item_text) {
     size_t item_total_size = 0;
     for (auto &text : item_text) {
-        // 统计所有SdesChunk对象占用的空间
+        // 统计所有SdesChunk对象占用的空间  [AUTO-TRANSLATED:87871205]
+        // Count the space occupied by all SdesChunk objects
         item_total_size += alignSize(SdesChunk::minSize() + (0xFF & text.size()));
     }
     auto real_size = sizeof(RtcpSdes) - sizeof(SdesChunk) + item_total_size;
@@ -471,7 +481,8 @@ std::shared_ptr<RtcpSdes> RtcpSdes::create(const std::vector<string> &item_text)
     auto item_ptr = &ptr->chunks;
     for (auto &text : item_text) {
         item_ptr->txt_len = (0xFF & text.size());
-        // 确保赋值\0为RTCP_SDES_END
+        // 确保赋值\0为RTCP_SDES_END  [AUTO-TRANSLATED:316be0a3]
+        // Ensure that the assignment \0 is RTCP_SDES_END
         memcpy(item_ptr->text, text.data(), item_ptr->txt_len + 1);
         item_ptr = (SdesChunk *)((char *)item_ptr + item_ptr->totalBytes());
     }
@@ -680,14 +691,16 @@ void RtcpBye::net2Host(size_t size) {
         ssrc[i] = ntohl(ssrc[i]);
         offset += sizeof(ssrc);
     }
-    // 修正ssrc个数
+    // 修正ssrc个数  [AUTO-TRANSLATED:57c74f58]
+    // Correct the number of ssrcs
     CHECK_REPORT_COUNT(i);
 
     if (offset < size) {
         uint8_t *reason_len_ptr = &reason_len + sizeof(ssrc) * (report_count - 1);
         if (reason_len_ptr + 1 + *reason_len_ptr > (uint8_t *)this + size) {
             WarnL << "invalid rtcp bye reason length";
-            // 修正reason_len长度
+            // 修正reason_len长度  [AUTO-TRANSLATED:1c0c9645]
+            // Correct the length of reason_len
             *reason_len_ptr = ((uint8_t *)this + size - reason_len_ptr - 1) & 0xFF;
         }
     }

src/Rtcp/RtcpContext.cpp

@@ -64,13 +64,16 @@ void RtcpContextForSend::onRtcp(RtcpHeader *rtcp) {
             if (it == _sender_report_ntp.end()) {
                 continue;
             }
-            // 发送sr到收到rr之间的时间戳增量
+            // 发送sr到收到rr之间的时间戳增量  [AUTO-TRANSLATED:da014bf1]
+            // Timestamp increment between sending sr and receiving rr
             auto ms_inc = getCurrentMillisecond() - it->second;
-            // rtp接收端收到sr包后，回复rr包的延时，已转换为毫秒
+            // rtp接收端收到sr包后，回复rr包的延时，已转换为毫秒  [AUTO-TRANSLATED:bfab8622]
+            // Delay of the rtp receiver replying to the rr packet after receiving the sr packet, converted to milliseconds
             auto delay_ms = (uint64_t)item->delay_since_last_sr * 1000 / 65536;
             auto rtt = (int)(ms_inc - delay_ms);
             if (rtt >= 0) {
-                // rtt不可能小于0
+                // rtt不可能小于0  [AUTO-TRANSLATED:34914014]
+                // RTT cannot be less than 0
                 _rtt[item->ssrc] = rtt;
                 // InfoL << "ssrc:" << item->ssrc << ",rtt:" << rtt;
             }
@@ -111,11 +114,13 @@ Buffer::Ptr RtcpContextForSend::createRtcpSR(uint32_t rtcp_ssrc) {
     rtcp->packet_count = htonl((uint32_t)_packets);
     rtcp->octet_count = htonl((uint32_t)_bytes);
 
-    // 记录上次发送的sender report信息，用于后续统计rtt
+    // 记录上次发送的sender report信息，用于后续统计rtt  [AUTO-TRANSLATED:1d22d2c8]
+    // Record the last sent sender report information for subsequent RTT statistics
     auto last_sr_lsr = ((ntohl(rtcp->ntpmsw) & 0xFFFF) << 16) | ((ntohl(rtcp->ntplsw) >> 16) & 0xFFFF);
     _sender_report_ntp[last_sr_lsr] = getCurrentMillisecond();
     if (_sender_report_ntp.size() >= 5) {
-        // 删除最早的sr rtcp
+        // 删除最早的sr rtcp  [AUTO-TRANSLATED:2457e08d]
+        // Delete the earliest sr rtcp
         _sender_report_ntp.erase(_sender_report_ntp.begin());
     }
 
@@ -141,7 +146,8 @@ toolkit::Buffer::Ptr RtcpContextForSend::createRtcpXRDLRR(uint32_t rtcp_ssrc, ui
         rtcp->items.dlrr = 0;
         WarnL;
     } else {
-        // now - Last SR time,单位毫秒
+        // now - Last SR time,单位毫秒  [AUTO-TRANSLATED:cc449199]
+        // now - Last SR time, in milliseconds
         auto delay = getCurrentMillisecond() - _xr_rrtr_recv_sys_stamp[rtp_ssrc];
         // in units of 1/65536 seconds
         auto dlsr = (uint32_t)(delay / 1000.0f * 65536);
@@ -155,38 +161,46 @@ toolkit::Buffer::Ptr RtcpContextForSend::createRtcpXRDLRR(uint32_t rtcp_ssrc, ui
 void RtcpContextForRecv::onRtp(
     uint16_t seq, uint32_t stamp, uint64_t ntp_stamp_ms, uint32_t sample_rate, size_t bytes) {
     {
-        // 接收者才做复杂的统计运算
+        // 接收者才做复杂的统计运算  [AUTO-TRANSLATED:853c68e0]
+        // The receiver performs complex statistical calculations
         auto sys_stamp = getCurrentMillisecond();
         if (_last_rtp_sys_stamp) {
-            // 计算时间戳抖动值
+            // 计算时间戳抖动值  [AUTO-TRANSLATED:cd3571b4]
+            // Calculate the timestamp jitter value
             double diff = double(
                 (int64_t(sys_stamp) - int64_t(_last_rtp_sys_stamp)) * (sample_rate / double(1000.0))
                 - (int64_t(stamp) - int64_t(_last_rtp_stamp)));
             if (diff < 0) {
                 diff = -diff;
             }
-            // 抖动单位为采样次数
+            // 抖动单位为采样次数  [AUTO-TRANSLATED:b713633a]
+            // Jitter unit is the number of samples
             _jitter += (diff - _jitter) / 16.0;
         } else {
             _jitter = 0;
         }
 
         if (_last_rtp_seq > 0xFF00 && seq < 0xFF && (!_seq_cycles || _packets - _last_cycle_packets > 0x1FFF)) {
-            // 上次seq大于0xFF00且本次seq小于0xFF，
-            // 且未发生回环或者距离上次回环间隔超过0x1FFF个包，则认为回环
+            // 上次seq大于0xFF00且本次seq小于0xFF，  [AUTO-TRANSLATED:82dd69fa]
+            // Last seq is greater than 0xFF00 and this seq is less than 0xFF,
+            // 且未发生回环或者距离上次回环间隔超过0x1FFF个包，则认为回环  [AUTO-TRANSLATED:2907b595]
+            // and no loopback occurs or the interval between the last loopback is greater than 0x1FFF packets, then it is considered a loopback
             ++_seq_cycles;
             _last_cycle_packets = _packets;
             _seq_max = seq;
         } else if (seq > _seq_max) {
-            // 本次回环前最大seq
+            // 本次回环前最大seq  [AUTO-TRANSLATED:c02f6a87]
+            // Maximum seq before this loopback
             _seq_max = seq;
         }
 
         if (!_seq_base) {
-            // 记录第一个rtp的seq
+            // 记录第一个rtp的seq  [AUTO-TRANSLATED:ce2bb7d7]
+            // Record the seq of the first rtp
             _seq_base = seq;
         } else if (!_seq_cycles && seq < _seq_base) {
-            // 未发生回环，那么取最新的seq为基准seq
+            // 未发生回环，那么取最新的seq为基准seq  [AUTO-TRANSLATED:721b37fc]
+            // If no loopback occurs, then take the latest seq as the base seq
             _seq_base = seq;
         }
 
@@ -258,7 +272,8 @@ Buffer::Ptr RtcpContextForRecv::createRtcpRR(uint32_t rtcp_ssrc, uint32_t rtp_ss
     item->jitter = htonl(uint32_t(_jitter));
     item->last_sr_stamp = htonl(_last_sr_lsr);
 
-    // now - Last SR time,单位毫秒
+    // now - Last SR time,单位毫秒  [AUTO-TRANSLATED:cc449199]
+    // now - Last SR time, in milliseconds
     auto delay = getCurrentMillisecond() - _last_sr_ntp_sys;
     // in units of 1/65536 seconds
     auto dlsr = (uint32_t)(delay / 1000.0f * 65536);

src/Rtcp/RtcpContext.h

@@ -29,22 +29,40 @@ public:
      * @param ntp_stamp_ms ntp时间戳
      * @param rtp rtp时间戳采样率，视频一般为90000，音频一般为采样率
      * @param bytes rtp数据长度
+     * Called when outputting or inputting rtp
+     * @param seq rtp's seq
+     * @param stamp rtp's timestamp, unit is sample number (not millisecond)
+     * @param ntp_stamp_ms ntp timestamp
+     * @param rtp rtp timestamp sampling rate, video is generally 90000, audio is generally sampling rate
+     * @param bytes rtp data length
+     
+     * [AUTO-TRANSLATED:745772b5]
      */
     virtual void onRtp(uint16_t seq, uint32_t stamp, uint64_t ntp_stamp_ms, uint32_t sample_rate, size_t bytes);
 
     /**
      * 输入sr rtcp包
      * @param rtcp 输入一个rtcp
+     * Input sr rtcp packet
+     * @param rtcp input an rtcp
+     
+     * [AUTO-TRANSLATED:46f309ec]
      */
     virtual void onRtcp(RtcpHeader *rtcp) = 0;
 
     /**
      * 计算总丢包数
+     * Calculate the total number of lost packets
+     
+     * [AUTO-TRANSLATED:084f3832]
      */
     virtual size_t getLost();
 
     /**
      * 返回理应收到的rtp数
+     * Return the number of rtp that should be received
+     
+     * [AUTO-TRANSLATED:ede367a0]
      */
     virtual size_t getExpectedPackets() const;
 
@@ -52,6 +70,11 @@ public:
      * 创建SR rtcp包
      * @param rtcp_ssrc rtcp的ssrc
      * @return rtcp包
+     * Create SR rtcp packet
+     * @param rtcp_ssrc rtcp's ssrc
+     * @return rtcp packet
+     
+     * [AUTO-TRANSLATED:a9ec36d0]
      */
     virtual toolkit::Buffer::Ptr createRtcpSR(uint32_t rtcp_ssrc);
 
@@ -59,6 +82,11 @@ public:
      * @brief 创建xr的dlrr包，用于接收者估算rtt
      *
      * @return toolkit::Buffer::Ptr
+     * @brief Create xr's dlrr packet, used by receiver to estimate rtt
+     *
+     * @return toolkit::Buffer::Ptr
+     
+     * [AUTO-TRANSLATED:a5094e1d]
      */
     virtual toolkit::Buffer::Ptr createRtcpXRDLRR(uint32_t rtcp_ssrc, uint32_t rtp_ssrc);
 
@@ -67,25 +95,40 @@ public:
      * @param rtcp_ssrc rtcp的ssrc
      * @param rtp_ssrc rtp的ssrc
      * @return rtcp包
+     * Create RR rtcp packet
+     * @param rtcp_ssrc rtcp's ssrc
+     * @param rtp_ssrc rtp's ssrc
+     * @return rtcp packet
+     
+     * [AUTO-TRANSLATED:81ebbf81]
      */
     virtual toolkit::Buffer::Ptr createRtcpRR(uint32_t rtcp_ssrc, uint32_t rtp_ssrc);
 
     /**
      * 上次结果与本次结果间应收包数
+     * Number of packets that should be received between the last result and the current result
+     
+     * [AUTO-TRANSLATED:3b2846ab]
      */
     virtual size_t getExpectedPacketsInterval();
 
     /**
      * 上次结果与本次结果间丢包个数
+     * Number of lost packets between the last result and the current result
+     
+     * [AUTO-TRANSLATED:fe5ac890]
      */
     virtual size_t getLostInterval();
 
 protected:
-    // 收到或发送的rtp的字节数
+    // 收到或发送的rtp的字节数  [AUTO-TRANSLATED:a38d88a9]
+    // Number of bytes of rtp received or sent
     size_t _bytes = 0;
-    // 收到或发送的rtp的个数
+    // 收到或发送的rtp的个数  [AUTO-TRANSLATED:b28c3c90]
+    // Number of rtp received or sent
     size_t _packets = 0;
-    // 上次的rtp时间戳,毫秒
+    // 上次的rtp时间戳,毫秒  [AUTO-TRANSLATED:99eecec6]
+    // Last rtp timestamp, milliseconds
     uint32_t _last_rtp_stamp = 0;
     uint64_t _last_ntp_stamp_ms = 0;
 };
@@ -102,6 +145,11 @@ public:
      * 获取rtt
      * @param ssrc rtp ssrc
      * @return rtt,单位毫秒
+     * Get rtt
+     * @param ssrc rtp ssrc
+     * @return rtt, unit is millisecond
+     
+     * [AUTO-TRANSLATED:f0885551]
      */
     uint32_t getRtt(uint32_t ssrc) const;
 
@@ -124,27 +172,38 @@ public:
     void onRtcp(RtcpHeader *rtcp) override;
 
 private:
-    // 时间戳抖动值
+    // 时间戳抖动值  [AUTO-TRANSLATED:8100680c]
+    // Timestamp jitter value
     double _jitter = 0;
-    // 第一个seq的值
+    // 第一个seq的值  [AUTO-TRANSLATED:d893719d]
+    // The value of the first seq
     uint16_t _seq_base = 0;
-    // rtp最大seq
+    // rtp最大seq  [AUTO-TRANSLATED:5cc9f775]
+    // Maximum rtp seq
     uint16_t _seq_max = 0;
-    // rtp回环次数
+    // rtp回环次数  [AUTO-TRANSLATED:9fe9c340]
+    // Rtp loopback times
     uint16_t _seq_cycles = 0;
-    // 上次回环发生时，记录的rtp包数
+    // 上次回环发生时，记录的rtp包数  [AUTO-TRANSLATED:c32cb555]
+    // Number of rtp packets recorded when the last loopback occurred
     size_t _last_cycle_packets = 0;
-    // 上次的seq
+    // 上次的seq  [AUTO-TRANSLATED:07364b7d]
+    // Last seq
     uint16_t _last_rtp_seq = 0;
-    // 上次的rtp的系统时间戳(毫秒)用于统计抖动
+    // 上次的rtp的系统时间戳(毫秒)用于统计抖动  [AUTO-TRANSLATED:b1e8c89b]
+    // Last rtp system timestamp (milliseconds) used for jitter statistics
     uint64_t _last_rtp_sys_stamp = 0;
-    // 上次统计的丢包总数
+    // 上次统计的丢包总数  [AUTO-TRANSLATED:242e75ed]
+    // Last total number of lost packets counted
     size_t _last_lost = 0;
-    // 上次统计应收rtp包总数
+    // 上次统计应收rtp包总数  [AUTO-TRANSLATED:eb2d5f4d]
+    // Last total number of rtp packets that should be received counted
     size_t _last_expected = 0;
-    // 上次收到sr包时计算出的Last SR timestamp
+    // 上次收到sr包时计算出的Last SR timestamp  [AUTO-TRANSLATED:fdec069e]
+    // Last SR timestamp calculated when the last SR packet was received
     uint32_t _last_sr_lsr = 0;
-    // 上次收到sr时的系统时间戳,单位毫秒
+    // 上次收到sr时的系统时间戳,单位毫秒  [AUTO-TRANSLATED:044fa0d5]
+    // System timestamp when the last SR was received, unit is millisecond
     uint64_t _last_sr_ntp_sys = 0;
 };
 

src/Rtcp/RtcpFCI.cpp

@@ -119,7 +119,8 @@ string FCI_REMB::create(const vector<uint32_t> &ssrcs, uint32_t bitrate) {
     // BR Mantissa (18 bits)
     thiz->bitrate[3] = (uint8_t)(mantissa);
 
-    // 设置ssrc列表
+    // 设置ssrc列表  [AUTO-TRANSLATED:51a0df3a]
+    // Set ssrc list
     int i = 0;
     for (auto ssrc : ssrcs) {
         thiz->ssrc_feedback[i++] = htonl(ssrc);
@@ -186,7 +187,8 @@ uint16_t FCI_NACK::getBlp() const {
 vector<bool> FCI_NACK::getBitArray() const {
     vector<bool> ret;
     ret.resize(kBitSize + 1);
-    // nack第一个包丢包
+    // nack第一个包丢包  [AUTO-TRANSLATED:357feeea]
+    // Nack the first packet loss
     ret[0] = true;
 
     auto blp_h = getBlp();
@@ -224,21 +226,28 @@ public:
     uint16_t symbol : 2;
     uint16_t run_length_high : 5;
 #else
-    // Run Length 高5位
+    // Run Length 高5位  [AUTO-TRANSLATED:a1426130]
+    // Run Length high 5 bits
     uint16_t run_length_high : 5;
-    // 参考SymbolStatus定义
+    // 参考SymbolStatus定义  [AUTO-TRANSLATED:0268c65e]
+    // Refer to SymbolStatus definition
     uint16_t symbol : 2;
-    // 固定为0
+    // 固定为0  [AUTO-TRANSLATED:7b516577]
+    // Fixed to 0
     uint16_t type : 1;
 #endif
-    // Run Length 低8位
+    // Run Length 低8位  [AUTO-TRANSLATED:8984c00d]
+    // Run Length low 8 bits
     uint16_t run_length_low : 8;
 
-    // 获取Run Length
+    // 获取Run Length  [AUTO-TRANSLATED:9fb792e6]
+    // Get Run Length
     uint16_t getRunLength() const;
-    // 构造函数
+    // 构造函数  [AUTO-TRANSLATED:b9f7407d]
+    // Constructor
     RunLengthChunk(SymbolStatus status, uint16_t run_length);
-    // 打印本对象
+    // 打印本对象  [AUTO-TRANSLATED:e8bd8207]
+    // Print this object
     string dumpString() const;
 };
 #pragma pack(pop)
@@ -276,21 +285,28 @@ public:
     uint16_t symbol : 1;
     uint16_t symbol_list_high : 6;
 #else
-    // symbol_list 高6位
+    // symbol_list 高6位  [AUTO-TRANSLATED:2ef1be51]
+    // symbol_list high 6 bits
     uint16_t symbol_list_high : 6;
-    // symbol_list中元素是1个还是2个bit
+    // symbol_list中元素是1个还是2个bit  [AUTO-TRANSLATED:0f56756f]
+    // Whether the element in symbol_list is 1 or 2 bits
     uint16_t symbol : 1;
-    // 固定为1
+    // 固定为1  [AUTO-TRANSLATED:1fb4c9c8]
+    // Fixed to 1
     uint16_t type : 1;
 #endif
-    // symbol_list 低8位
+    // symbol_list 低8位  [AUTO-TRANSLATED:257bf13b]
+    // symbol_list low 8 bits
     uint16_t symbol_list_low : 8;
 
-    // 获取symbollist
+    // 获取symbollist  [AUTO-TRANSLATED:a24b8d73]
+    // Get symbollist
     vector<SymbolStatus> getSymbolList() const;
-    // 构造函数
+    // 构造函数  [AUTO-TRANSLATED:b9f7407d]
+    // Constructor
     StatusVecChunk(bool symbol_bit, const vector<SymbolStatus> &status);
-    // 打印本对象
+    // 打印本对象  [AUTO-TRANSLATED:e8bd8207]
+    // Print this object
     string dumpString() const;
 };
 #pragma pack(pop)
@@ -321,13 +337,15 @@ vector<SymbolStatus> StatusVecChunk::getSymbolList() const {
     vector<SymbolStatus> ret;
     auto thiz = ntohs(*((uint16_t *)this));
     if (symbol == 0) {
-        // s = 0 时，表示symbollist的每一个bit能表示一个数据包的到达状态
+        // s = 0 时，表示symbollist的每一个bit能表示一个数据包的到达状态  [AUTO-TRANSLATED:89d8f104]
+        // When s = 0, each bit in symbollist represents the arrival status of a data packet
         for (int i = 13; i >= 0; --i) {
             SymbolStatus status = (SymbolStatus)((bool)(thiz & (1 << i)));
             ret.emplace_back(status);
         }
     } else {
-        // s = 1 时，表示symbollist每两个bit表示一个数据包的状态
+        // s = 1 时，表示symbollist每两个bit表示一个数据包的状态  [AUTO-TRANSLATED:fd7eb5fe]
+        // When s = 1, every two bits in symbollist represent the status of a data packet
         for (int i = 12; i >= 0; i -= 2) {
             SymbolStatus status = (SymbolStatus)((thiz & (3 << i)) >> i);
             ret.emplace_back(status);
@@ -398,29 +416,34 @@ static int16_t getRecvDelta(SymbolStatus status, uint8_t *&ptr, const uint8_t *e
     int16_t delta = 0;
     switch (status) {
     case SymbolStatus::not_received: {
-        // 丢包， recv delta为0个字节
+        // 丢包， recv delta为0个字节  [AUTO-TRANSLATED:4312b1ce]
+        // Packet loss, recv delta is 0 bytes
         break;
     }
     case SymbolStatus::small_delta: {
         CHECK(ptr + 1 <= end);
-        // 时间戳增量小于256， recv delta为1个字节
+        // 时间戳增量小于256， recv delta为1个字节  [AUTO-TRANSLATED:4b93efeb]
+        // Timestamp increment is less than 256, recv delta is 1 byte
         delta = *ptr;
         ptr += 1;
         break;
     }
     case SymbolStatus::large_delta: {
         CHECK(ptr + 2 <= end);
-        // 时间戳增量256~65535间，recv delta为2个字节
+        // 时间戳增量256~65535间，recv delta为2个字节  [AUTO-TRANSLATED:989c8340]
+        // Timestamp increment is between 256 and 65535, recv delta is 2 bytes
         delta = *ptr << 8 | *(ptr + 1);
         ptr += 2;
         break;
     }
     case SymbolStatus::reserved: {
-        // 没有时间戳
+        // 没有时间戳  [AUTO-TRANSLATED:0767909f]
+        // No timestamp
         break;
     }
     default:
-        // 这个逻辑分支不可达到
+        // 这个逻辑分支不可达到  [AUTO-TRANSLATED:451ba1eb]
+        // This logic branch cannot be reached
         CHECK(0);
         break;
     }
@@ -479,17 +502,20 @@ string FCI_TWCC::dumpString(size_t total_size) const {
 static void appendDeltaString(string &delta_str, FCI_TWCC::TwccPacketStatus &status, int count) {
     for (auto it = status.begin(); it != status.end() && count--;) {
         switch (it->second.first) {
-        // large delta模式先写高字节，再写低字节
+        // large delta模式先写高字节，再写低字节  [AUTO-TRANSLATED:cb25ff45]
+        // Large delta mode writes the high byte first, then the low byte
         case SymbolStatus::large_delta:
             delta_str.push_back((it->second.second >> 8) & 0xFF);
-            // small delta模式只写低字节
+            // small delta模式只写低字节  [AUTO-TRANSLATED:5caea5d6]
+            // Small delta mode only writes the low byte
         case SymbolStatus::small_delta:
             delta_str.push_back(it->second.second & 0xFF);
             break;
         default:
             break;
         }
-        // 移除已经处理过的数据
+        // 移除已经处理过的数据  [AUTO-TRANSLATED:106fb6db]
+        // Remove the data that has been processed
         it = status.erase(it);
     }
 }
@@ -508,21 +534,25 @@ string FCI_TWCC::create(uint32_t ref_time, uint8_t fb_pkt_count, TwccPacketStatu
     string delta_str;
     while (!status.empty()) {
         {
-            // 第一个rtp的状态
+            // 第一个rtp的状态  [AUTO-TRANSLATED:b0efb9ad]
+            // The status of the first rtp
             auto symbol = status.begin()->second.first;
             int16_t count = 0;
             for (auto &pr : status) {
                 if (pr.second.first != symbol) {
-                    // 状态发送变更了，本chunk结束
+                    // 状态发送变更了，本chunk结束  [AUTO-TRANSLATED:f1c2c6d1]
+                    // The status sending changed, this chunk ends
                     break;
                 }
                 if (++count >= (0xFFFF >> 3)) {
-                    // RunLengthChunk 13个bit表明rtp个数，最多可以表述0xFFFF >> 3个rtp状态
+                    // RunLengthChunk 13个bit表明rtp个数，最多可以表述0xFFFF >> 3个rtp状态  [AUTO-TRANSLATED:c6c4de01]
+                    // RunLengthChunk 13 bits indicate the number of rtp, at most 0xFFFF >> 3 rtp status can be expressed
                     break;
                 }
             }
             if (count >= 7) {
-                // 连续状态相同个数大于6个时，使用RunLengthChunk模式比较节省带宽
+                // 连续状态相同个数大于6个时，使用RunLengthChunk模式比较节省带宽  [AUTO-TRANSLATED:c243c73f]
+                // When the number of consecutive states is greater than 6, using RunLengthChunk mode is more bandwidth-saving
                 RunLengthChunk chunk(symbol, count);
                 fci.append((char *)&chunk, RunLengthChunk::kSize);
                 appendDeltaString(delta_str, status, count);
@@ -531,20 +561,25 @@ string FCI_TWCC::create(uint32_t ref_time, uint8_t fb_pkt_count, TwccPacketStatu
         }
 
         {
-            // StatusVecChunk模式
-            // symbol_list中元素是1个bit
+            // StatusVecChunk模式  [AUTO-TRANSLATED:612e548c]
+            // StatusVecChunk mode
+            // symbol_list中元素是1个bit  [AUTO-TRANSLATED:e5f8cbf8]
+            // Elements in symbol_list are 1 bit
             auto symbol = 0;
             vector<SymbolStatus> vec;
             for (auto &pr : status) {
                 vec.push_back(pr.second.first);
                 if (pr.second.first >= SymbolStatus::large_delta) {
-                    // symbol_list中元素是2个bit
+                    // symbol_list中元素是2个bit  [AUTO-TRANSLATED:43429094]
+                    // Elements in symbol_list are 2 bits
                     symbol = 1;
                 }
 
                 if (vec.size() << symbol >= 14) {
-                    // symbol为0时，最多存放14个rtp的状态
-                    // symbol为1时，最多存放7个rtp的状态
+                    // symbol为0时，最多存放14个rtp的状态  [AUTO-TRANSLATED:1da4fad6]
+                    // When symbol is 0, at most 14 RTP statuses can be stored
+                    // symbol为1时，最多存放7个rtp的状态  [AUTO-TRANSLATED:34f39e9a]
+                    // When symbol is 1, at most 7 RTP statuses can be stored
                     break;
                 }
             }
@@ -555,7 +590,8 @@ string FCI_TWCC::create(uint32_t ref_time, uint8_t fb_pkt_count, TwccPacketStatu
         }
     }
 
-    // recv delta部分
+    // recv delta部分  [AUTO-TRANSLATED:f7e0d5bc]
+    // recv delta part
     fci.append(delta_str);
     return fci;
 }

src/Rtcp/RtcpFCI.h

@@ -255,7 +255,8 @@ public:
     void check(size_t size);
     uint16_t getPid() const;
     uint16_t getBlp() const;
-    // 返回丢包列表，总长度17，第一个包必丢
+    // 返回丢包列表，总长度17，第一个包必丢  [AUTO-TRANSLATED:5d5cd4b8]
+    // Return the list of lost packets, total length 17, the first packet must be lost
     //  TODO: replace std::bitset
     std::vector<bool> getBitArray() const;
     std::string dumpString() const;
@@ -321,9 +322,11 @@ public:
 enum class SymbolStatus : uint8_t {
     // Packet not received
     not_received = 0,
-    // Packet received, small delta （所谓small detal是指能用一个字节表示的数值）
+    // Packet received, small delta （所谓small detal是指能用一个字节表示的数值）  [AUTO-TRANSLATED:50af3beb]
+    // Packet received, small delta (so-called small delta refers to a value that can be represented by one byte)
     small_delta = 1,
-    // Packet received, large ornegative delta （large即是能用两个字节表示的数值）
+    // Packet received, large ornegative delta （large即是能用两个字节表示的数值）  [AUTO-TRANSLATED:7a16594d]
+    // Packet received, large or negative delta (large is a value that can be represented by two bytes)
     large_delta = 2,
     // Reserved
     reserved = 3
@@ -359,7 +362,8 @@ public:
     void check(size_t size);
     std::string dumpString(size_t total_size) const;
     uint16_t getBaseSeq() const;
-    // 单位64ms
+    // 单位64ms  [AUTO-TRANSLATED:992ffed7]
+    // Unit 64ms
     uint32_t getReferenceTime() const;
     uint16_t getPacketCount() const;
     TwccPacketStatus getPacketChunkList(size_t total_size) const;
@@ -367,13 +371,17 @@ public:
     static std::string create(uint32_t ref_time, uint8_t fb_pkt_count, TwccPacketStatus &status);
 
 private:
-    // base sequence number,基础序号,本次反馈的第一个包的序号;也就是RTP扩展头的序列号
+    // base sequence number,基础序号,本次反馈的第一个包的序号;也就是RTP扩展头的序列号  [AUTO-TRANSLATED:4e43ffcc]
+    // base sequence number, basic sequence number, the sequence number of the first packet in this feedback; that is, the sequence number of the RTP extension header
     uint16_t base_seq;
-    // packet status count, 包个数,本次反馈包含多少个包的状态;从基础序号开始算
+    // packet status count, 包个数,本次反馈包含多少个包的状态;从基础序号开始算  [AUTO-TRANSLATED:533efb94]
+    // packet status count, number of packets, how many packet statuses are included in this feedback; counted from the base sequence number
     uint16_t pkt_status_count;
-    // reference time,基准时间,绝对时间;计算该包中每个媒体包的到达时间都要基于这个基准时间计算
+    // reference time,基准时间,绝对时间;计算该包中每个媒体包的到达时间都要基于这个基准时间计算  [AUTO-TRANSLATED:5265d98e]
+    // reference time, reference time, absolute time; the arrival time of each media packet in this packet is calculated based on this reference time
     uint8_t ref_time[3];
-    // feedback packet count,反馈包号,本包是第几个transport-cc包，每次加1                          |
+    // feedback packet count,反馈包号,本包是第几个transport-cc包，每次加1                          |  [AUTO-TRANSLATED:1ff6d73e]
+    // feedback packet count, feedback packet number, this packet is the nth transport-cc packet, incremented by 1 each time                          |
     uint8_t fb_pkt_count;
 };
 #pragma pack(pop)