C++ RtcpHeader::getLength方法代码示例

int MediaStream::sendPLI() {
  RtcpHeader thePLI;
  thePLI.setPacketType(RTCP_PS_Feedback_PT);
  thePLI.setBlockCount(1);
  thePLI.setSSRC(this->getVideoSinkSSRC());
  thePLI.setSourceSSRC(this->getVideoSourceSSRC());
  thePLI.setLength(2);
  char *buf = reinterpret_cast<char*>(&thePLI);
  int len = (thePLI.getLength() + 1) * 4;
  sendPacketAsync(std::make_shared<DataPacket>(0, buf, len, VIDEO_PACKET));
  return len;
}

 int WebRtcConnection::sendPLI() {
   RtcpHeader thePLI;
   thePLI.setPacketType(RTCP_PS_Feedback_PT);
   thePLI.setBlockCount(1);
   thePLI.setSSRC(this->getVideoSinkSSRC());
   thePLI.setSourceSSRC(this->getVideoSourceSSRC());
   thePLI.setLength(2);
   char *buf = reinterpret_cast<char*>(&thePLI);
   int len = (thePLI.getLength()+1)*4;
   this->queueData(0, buf, len , videoTransport_, OTHER_PACKET);
   return len; 
   
 }

int ExternalOutput::sendFirPacket() {
    if (fbSink_ != NULL) {
      RtcpHeader thePLI;
      thePLI.setPacketType(RTCP_PS_Feedback_PT);
      thePLI.setBlockCount(1);
      thePLI.setSSRC(55543);
      thePLI.setSourceSSRC(videoSourceSsrc_);
      thePLI.setLength(2);
      char *buf = reinterpret_cast<char*>(&thePLI);
      int len = (thePLI.getLength() + 1) * 4;
      fbSink_->deliverFeedback(reinterpret_cast<char*>(buf), len);
      return len;
    }
    return -1;
}

  int RtcpForwarder::addNACK(char* buf, int len, uint16_t seqNum, uint16_t blp, uint32_t sourceSsrc, uint32_t sinkSsrc){
    buf+=len;
    ELOG_DEBUG("Setting PID %u, BLP %u", seqNum , blp);
    RtcpHeader theNACK;
    theNACK.setPacketType(RTCP_RTP_Feedback_PT);
    theNACK.setBlockCount(1);
    theNACK.setNackPid(seqNum);
    theNACK.setNackBlp(blp);
    theNACK.setSSRC(sinkSsrc);    
    theNACK.setSourceSSRC(sourceSsrc);
    theNACK.setLength(3);
    int nackLength = (theNACK.getLength()+1)*4;

    memcpy(buf, (uint8_t*)&theNACK, nackLength);
    return (len+nackLength); 
  }

int ExternalOutput::sendFirPacket() {
    if (fb_sink_ != nullptr) {
      RtcpHeader thePLI;
      thePLI.setPacketType(RTCP_PS_Feedback_PT);
      thePLI.setBlockCount(1);
      thePLI.setSSRC(55543);
      thePLI.setSourceSSRC(videoSourceSsrc_);
      thePLI.setLength(2);
      char *buf = reinterpret_cast<char*>(&thePLI);
      int len = (thePLI.getLength() + 1) * 4;
      std::shared_ptr<dataPacket> pli_packet = std::make_shared<dataPacket>(0, buf, len, VIDEO_PACKET);
      fb_sink_->deliverFeedback(pli_packet);
      return len;
    }
    return -1;
}

  int RtcpForwarder::addREMB(char* buf, int len, uint32_t bitrate){
    buf+=len;
    RtcpHeader theREMB;
    theREMB.setPacketType(RTCP_PS_Feedback_PT);
    theREMB.setBlockCount(RTCP_AFB);
    memcpy(&theREMB.report.rembPacket.uniqueid, "REMB", 4);

    theREMB.setSSRC(rtcpSink_->getVideoSinkSSRC());
    theREMB.setSourceSSRC(rtcpSource_->getVideoSourceSSRC());
    theREMB.setLength(5);
    theREMB.setREMBBitRate(bitrate);
    theREMB.setREMBNumSSRC(1);
    theREMB.setREMBFeedSSRC(rtcpSource_->getVideoSourceSSRC());
    int rembLength = (theREMB.getLength()+1)*4;

    memcpy(buf, (uint8_t*)&theREMB, rembLength);
    return (len+rembLength); 
  }

int SyntheticInput::deliverFeedback_(std::shared_ptr<DataPacket> fb_packet) {
  RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(fb_packet->data);
  if (chead->isFeedback()) {
    if (chead->getBlockCount() == 0 && (chead->getLength()+1) * 4  == fb_packet->length) {
      return 0;
    }
    char* moving_buf = fb_packet->data;
    int rtcp_length = 0;
    int total_length = 0;
    do {
      moving_buf += rtcp_length;
      chead = reinterpret_cast<RtcpHeader*>(moving_buf);
      rtcp_length = (ntohs(chead->length) + 1) * 4;
      total_length += rtcp_length;
      switch (chead->packettype) {
        case RTCP_RTP_Feedback_PT:
          // NACKs are already handled by WebRtcConnection. RRs won't be handled.
          total_packets_nacked_++;
          break;
        case RTCP_PS_Feedback_PT:
          switch (chead->getBlockCount()) {
            case RTCP_PLI_FMT:
            case RTCP_FIR_FMT:
              sendPLI();
              break;
            case RTCP_AFB:
              char *unique_id = reinterpret_cast<char*>(&chead->report.rembPacket.uniqueid);
              if (!strncmp(unique_id, "REMB", 4)) {
                uint64_t bitrate = chead->getBrMantis() << chead->getBrExp();
                calculateSizeAndPeriod(bitrate, kDefaultAudioBitrate);
              }
              break;
          }
      }
    } while (total_length < fb_packet->length);
  }
  return 0;
}

  int RtcpForwarder::analyzeFeedback(char *buf, int len) {
    RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(buf);
    if (chead->isFeedback()) {      
      if (chead->getBlockCount() == 0 && (chead->getLength()+1) * 4  == len){
        ELOG_DEBUG("Ignoring empty RR");
        return 0;
      }
      uint32_t sourceSsrc = chead->getSourceSSRC();
      // We try to add it just in case it is not there yet (otherwise its noop)
      this->addSourceSsrc(sourceSsrc);

      struct timeval now;
      gettimeofday(&now, NULL);
      char* movingBuf = buf;
      int rtcpLength = 0;
      int totalLength = 0;
      int currentBlock = 0;

      do {
        movingBuf+=rtcpLength;
        chead = reinterpret_cast<RtcpHeader*>(movingBuf);
        rtcpLength = (ntohs(chead->length)+1) * 4;
        totalLength += rtcpLength;
        switch(chead->packettype){
          case RTCP_SDES_PT:
            ELOG_DEBUG("SDES");
            break;
          case RTCP_BYE:
            ELOG_DEBUG("BYE");
            break;
          case RTCP_Receiver_PT:
            if (chead->getSourceSSRC() == rtcpSource_->getVideoSourceSSRC()){
              ELOG_DEBUG("Analyzing Video RR: PacketLost %u, Ratio %u, currentBlock %d, blocks %d, sourceSSRC %u, ssrc %u changed to %u", 
                  chead->getLostPackets(), 
                  chead->getFractionLost(), 
                  currentBlock, 
                  chead->getBlockCount(), 
                  chead->getSourceSSRC(), 
                  chead->getSSRC(),
                  rtcpSink_->getVideoSinkSSRC());
              chead->setSSRC(rtcpSink_->getVideoSinkSSRC());
            }else{
              ELOG_DEBUG("Analyzing Audio RR: PacketLost %u, Ratio %u, currentBlock %d, blocks %d, sourceSSRC %u, ssrc %u changed to %u", 
                  chead->getLostPackets(), 
                  chead->getFractionLost(), 
                  currentBlock, 
                  chead->getBlockCount(), 
                  chead->getSourceSSRC(), 
                  chead->getSSRC(),
                  rtcpSink_->getAudioSinkSSRC());
              chead->setSSRC(rtcpSink_->getAudioSinkSSRC());
            }
            break;
          case RTCP_RTP_Feedback_PT:
            ELOG_DEBUG("RTP FB: Usually NACKs: %u, currentBlock %d", chead->getBlockCount(), currentBlock);
            ELOG_DEBUG("NACK PID %u BLP %u", chead->getNackPid(), chead->getNackBlp());
            // We analyze NACK to avoid sending repeated NACKs
            break;
          case RTCP_PS_Feedback_PT:
            //            ELOG_DEBUG("RTCP PS FB TYPE: %u", chead->getBlockCount() );
            switch(chead->getBlockCount()){
              case RTCP_PLI_FMT:
                ELOG_DEBUG("PLI Message, currentBlock %d", currentBlock);
                // 1: PLI, 4: FIR
                break;
              case RTCP_SLI_FMT:
                ELOG_WARN("SLI Message");
                break;
              case RTCP_FIR_FMT:
                ELOG_WARN("FIR Message");
                break;
              case RTCP_AFB:
                {
                  char *uniqueId = (char*)&chead->report.rembPacket.uniqueid;
                  if (!strncmp(uniqueId,"REMB", 4)){
                    uint64_t bitrate = chead->getBrMantis() << chead->getBrExp();
                    uint64_t cappedBitrate = 0;
                    cappedBitrate = bitrate < maxVideoBw_? bitrate: maxVideoBw_;
                    if (bitrate < maxVideoBw_){
                      cappedBitrate = bitrate;
                    }else{
                      cappedBitrate = maxVideoBw_;
                    }
                    ELOG_DEBUG("Received REMB %lu, partnum %u, cappedBitrate %lu", bitrate, currentBlock, cappedBitrate);
                    chead->setREMBBitRate(cappedBitrate);
                  }
                  else{
                    ELOG_WARN("Unsupported AFB Packet not REMB")
                  }
                  break;
                }
              default:
                ELOG_WARN("Unsupported RTCP_PS FB TYPE %u",chead->getBlockCount());
                break;
            }
            break;
          default:
            ELOG_WARN("Unknown RTCP Packet, %d", chead->packettype);
            break;
        }
//.........这里部分代码省略.........

int RtcpAggregator::analyzeFeedback(char *buf, int len) {
  RtcpHeader *chead = reinterpret_cast<RtcpHeader*>(buf);
  if (chead->isFeedback()) {
    if (chead->getBlockCount() == 0 && (chead->getLength()+1) * 4  == len) {
      ELOG_DEBUG("Ignoring empty RR");
      return 0;
    }
    uint32_t sourceSsrc = chead->getSourceSSRC();
    // We try to add it just in case it is not there yet (otherwise its noop)
    this->addSourceSsrc(sourceSsrc);

    boost::mutex::scoped_lock mlock(mapLock_);
    boost::shared_ptr<RtcpData> theData = rtcpData_[sourceSsrc];
    boost::mutex::scoped_lock lock(theData->dataLock);
    uint64_t nowms = ClockUtils::timePointToMs(clock::now());
    char* movingBuf = buf;
    int rtcpLength = 0;
    int totalLength = 0;
    int partNum = 0;
    uint16_t currentNackPos = 0;
    uint16_t blp = 0;
    uint32_t lostPacketSeq = 0;
    uint32_t delay = 0;
    uint32_t calculatedlsr, calculateLastSr, extendedSeqNo;

    do {
      movingBuf += rtcpLength;
      chead = reinterpret_cast<RtcpHeader*>(movingBuf);
      rtcpLength = (ntohs(chead->length) + 1) * 4;
      totalLength += rtcpLength;
      switch (chead->packettype) {
        case RTCP_SDES_PT:
          ELOG_DEBUG("SDES");
          break;
        case RTCP_BYE:
          ELOG_DEBUG("BYE");
          break;
        case RTCP_Receiver_PT:
          theData->rrsReceivedInPeriod++;
          if (rtcpSource_->isVideoSourceSSRC(chead->getSourceSSRC())) {
            ELOG_DEBUG("Analyzing Video RR: PacketLost %u, Ratio %u, partNum %d, blocks %d, sourceSSRC %u, ssrc %u",
                        chead->getLostPackets(), chead->getFractionLost(), partNum, chead->getBlockCount(),
                        chead->getSourceSSRC(), chead->getSSRC());
          } else {
            ELOG_DEBUG("Analyzing Audio RR: PacketLost %u, Ratio %u, partNum %d, blocks %d, sourceSSRC %u, ssrc %u",
                        chead->getLostPackets(), chead->getFractionLost(), partNum, chead->getBlockCount(),
                        chead->getSourceSSRC(), chead->getSSRC());
          }
          theData->ratioLost = theData->ratioLost > chead->getFractionLost() ?
                                            theData->ratioLost : chead->getFractionLost();
          theData->totalPacketsLost = theData->totalPacketsLost > chead->getLostPackets() ?
                                            theData->totalPacketsLost : chead->getLostPackets();
          extendedSeqNo = chead->getSeqnumCycles();
          extendedSeqNo = (extendedSeqNo << 16) + chead->getHighestSeqnum();
          if (extendedSeqNo > theData->extendedSeqNo) {
            theData->extendedSeqNo = extendedSeqNo;
            theData->highestSeqNumReceived = chead->getHighestSeqnum();
            theData->seqNumCycles = chead->getSeqnumCycles();
          }
          theData->jitter = theData->jitter > chead->getJitter()? theData->jitter: chead->getJitter();
          calculateLastSr = chead->getLastSr();
          calculatedlsr = (chead->getDelaySinceLastSr() * 1000) / 65536;
          for (std::list<boost::shared_ptr<SrDelayData>>::iterator it = theData->senderReports.begin();
                        it != theData->senderReports.end(); ++it) {
            if ((*it)->sr_ntp == calculateLastSr) {
              uint64_t sentts = (*it)->sr_send_time;
              delay = nowms - sentts - calculatedlsr;
            }
          }

          if (theData->lastSr == 0 || theData->lastDelay < delay) {
            ELOG_DEBUG("Recording DLSR %u, lastSR %u last delay %u, calculated delay %u for SSRC %u",
                        chead->getDelaySinceLastSr(), chead->getLastSr(), theData->lastDelay, delay, sourceSsrc);
            theData->lastSr = chead->getLastSr();
            theData->delaySinceLastSr = chead->getDelaySinceLastSr();
            theData->last_sr_updated = nowms;
            theData->lastDelay = delay;
          } else {
            // ELOG_DEBUG("Not recording delay %u, lastDelay %u", delay, theData->lastDelay);
          }
          break;
        case RTCP_RTP_Feedback_PT:
          {
            ELOG_DEBUG("RTP FB: Usually NACKs: %u, partNum %d", chead->getBlockCount(), partNum);
            ELOG_DEBUG("NACK PID %u BLP %u", chead->getNackPid(), chead->getNackBlp());
            // We analyze NACK to avoid sending repeated NACKs
            blp = chead->getNackBlp();
            theData->shouldSendNACK = false;
            std::pair<std::set<uint32_t>::iterator, bool> ret;
            ret = theData->nackedPackets_.insert(chead->getNackPid());
            if (ret.second) {
              ELOG_DEBUG("We received PID NACK for unacked packet %u", chead->getNackPid());
              theData->shouldSendNACK = true;
            } else {
              if (theData->nackedPackets_.size() >= MAP_NACK_SIZE) {
                while (theData->nackedPackets_.size() >= MAP_NACK_SIZE) {
                  theData->nackedPackets_.erase(theData->nackedPackets_.begin());
                }
              }
              ELOG_DEBUG("We received PID NACK for ALREADY acked packet %u", chead->getNackPid());
//.........这里部分代码省略.........

void RtcpAggregator::checkRtcpFb() {
  boost::mutex::scoped_lock mlock(mapLock_);
  std::map<uint32_t, boost::shared_ptr<RtcpData>>::iterator it;
  for (it = rtcpData_.begin(); it != rtcpData_.end(); it++) {
    boost::shared_ptr<RtcpData> rtcpData = it->second;
    boost::mutex::scoped_lock lock(rtcpData->dataLock);
    uint32_t sourceSsrc = it->first;
    uint32_t sinkSsrc;
    uint64_t now = ClockUtils::timePointToMs(clock::now());

    unsigned int dt = now - rtcpData->last_rr_sent;
    unsigned int edlsr = now - rtcpData->last_sr_updated;
    unsigned int dt_scheduled = now - rtcpData->last_rr_was_scheduled;

    // Generate Full RTCP Packet
    if ((rtcpData->requestRr || dt >= rtcpData->nextPacketInMs ||rtcpData->shouldSendREMB) && rtcpData->lastSr > 0) {
      rtcpData->requestRr = false;
      RtcpHeader rtcpHead;
      rtcpHead.setPacketType(RTCP_Receiver_PT);
      if (sourceSsrc == rtcpSource_->getAudioSourceSSRC()) {
        sinkSsrc = rtcpSink_->getAudioSinkSSRC();
        ELOG_DEBUG("Sending Audio RR: PacketLost %u, Ratio %u, DLSR %u"
                   ", lastSR %u, DLSR Adjusted %u dt %u, rrsSinceLast %u highestSeqNum %u",
                  rtcpData->totalPacketsLost,
                  rtcpData->ratioLost,
                  rtcpData->delaySinceLastSr,
                  rtcpData->lastSr,
                  (rtcpData->delaySinceLastSr+edlsr),
                  dt,
                  rtcpData->rrsReceivedInPeriod,
                  rtcpData->highestSeqNumReceived);
        rtcpHead.setSSRC(rtcpSink_->getAudioSinkSSRC());
        rtcpHead.setSourceSSRC(rtcpSource_->getAudioSourceSSRC());
      } else {
        sinkSsrc = rtcpSink_->getVideoSinkSSRC();
        ELOG_DEBUG("Sending Video RR: SOurcessrc %u sinkSsrc %u PacketLost %u, Ratio %u, DLSR %u, lastSR %u"
                   ", DLSR Adjusted %u dt %u, rrsSinceLast %u highestSeqNum %u jitter %u",
                   sourceSsrc,
                   rtcpSink_->getVideoSinkSSRC(),
                   rtcpData->totalPacketsLost,
                   rtcpData->ratioLost,
                   rtcpData->delaySinceLastSr,
                   rtcpData->lastSr,
                   (rtcpData->delaySinceLastSr+edlsr),
                   dt, rtcpData->rrsReceivedInPeriod,
                   rtcpData->highestSeqNumReceived,
                   rtcpData->jitter);
        rtcpHead.setSSRC(rtcpSink_->getVideoSinkSSRC());
        rtcpHead.setSourceSSRC(rtcpSource_->getVideoSourceSSRC());
      }

      // rtcpHead.setFractionLost(rtcpData->ratioLost);
      // Calculate ratioLost
      uint32_t packetsReceivedinInterval = rtcpData->extendedSeqNo - rtcpData->prevExtendedSeqNo;
      uint32_t packetsLostInInterval = rtcpData->totalPacketsLost - rtcpData->prevTotalPacketsLost;
      double ratio = static_cast<double>(packetsLostInInterval/packetsReceivedinInterval);
      rtcpHead.setFractionLost(ratio*256);
      rtcpData->prevTotalPacketsLost = rtcpData->totalPacketsLost;
      rtcpData->prevExtendedSeqNo = rtcpData->extendedSeqNo;

      rtcpHead.setHighestSeqnum(rtcpData->highestSeqNumReceived);
      rtcpHead.setSeqnumCycles(rtcpData->seqNumCycles);
      rtcpHead.setLostPackets(rtcpData->totalPacketsLost);
      rtcpHead.setJitter(rtcpData->jitter);
      rtcpHead.setLastSr(rtcpData->lastSr);
      rtcpHead.setDelaySinceLastSr(rtcpData->delaySinceLastSr + ((edlsr*65536)/1000));
      rtcpHead.setLength(7);
      rtcpHead.setBlockCount(1);
      int length = (rtcpHead.getLength()+1)*4;
      memcpy(packet_, reinterpret_cast<uint8_t*>(&rtcpHead), length);
      if (rtcpData->shouldSendNACK) {
        ELOG_DEBUG("SEND NACK, SENDING with Seqno: %u", rtcpData->nackSeqnum);
        int theLen = this->addNACK(reinterpret_cast<char*>(packet_), length, rtcpData->nackSeqnum,
                        rtcpData->nackBlp, sourceSsrc, sinkSsrc);
        rtcpData->shouldSendNACK = false;
        rtcpData->nackSeqnum = 0;
        rtcpData->nackBlp = 0;
        length = theLen;
      }
      if (rtcpData->mediaType == VIDEO_TYPE) {
        unsigned int sincelastREMB = now - rtcpData->last_remb_sent;
        if (sincelastREMB > REMB_TIMEOUT) {
          // We dont have any more RRs, we follow what the publisher is doing to avoid congestion
          rtcpData->shouldSendREMB = true;
        }

        if (rtcpData->shouldSendREMB) {
          ELOG_DEBUG("Sending REMB, since last %u ms, sending with BW: %lu",
                      sincelastREMB, rtcpData->reportedBandwidth);
          int theLen = this->addREMB(reinterpret_cast<char*>(packet_), length, rtcpData->reportedBandwidth);
          rtcpData->shouldSendREMB = false;
          rtcpData->last_remb_sent = now;
          length = theLen;
        }
      }
      if  (rtcpSource_->isVideoSourceSSRC(sourceSsrc)) {
        rtcpSink_->deliverVideoData(std::make_shared<DataPacket>(0, reinterpret_cast<char*>(packet_),
              length, VIDEO_PACKET));
      } else {
        rtcpSink_->deliverAudioData(std::make_shared<DataPacket>(0, reinterpret_cast<char*>(packet_),
//.........这里部分代码省略.........