Send RTCP packets via RtcpPacket callback

webrtc/modules/rtp_rtcp/source/rtcp_sender.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 131 matching lines @@
  void SendRtcpXrReceiverReferenceTime(bool enable);
 
  bool RtcpXrReceiverReferenceTime() const;
 
  void SetCsrcs(const std::vector<uint32_t>& csrcs);
 
  void SetTargetBitrate(unsigned int target_bitrate);
  bool SendFeedbackPacket(const rtcp::TransportFeedback& packet);
 
 private:
- struct RtcpContext;
+ class RtcpContext;
 

[åsapersson, 2015/11/16 14:54:39]

remove comment

[sprang_webrtc, 2015/12/01 10:23:06]

Done.

  // The BuildResult indicates the outcome of a call to a builder method,
  // constructing a part of an RTCP packet:
  //
  // kError
  //   Building RTCP packet failed, propagate error out to caller.
  // kAbort
  //   The (partial) block being build should not be included. Reset current
  //   buffer position to the state before the method call and proceed to the
  //   next packet type.
  // kTruncated
  //   There is not enough room in the buffer to fit the data being constructed.
  //   (IP packet is full). Proceed to the next packet type, and call this
  //   method again when a new buffer has been allocated.
  // TODO(sprang): Actually allocate multiple packets if needed.
  // kSuccess
  //   Data has been successfully placed in the buffer.
 
- enum class BuildResult { kError, kAborted, kTruncated, kSuccess };
-
- int32_t SendToNetwork(const uint8_t* dataBuffer, size_t length);
+ // Determine which RTCP messages should be sent and setup flags.
+ void PrepareReport(const std::set<RTCPPacketType>& packetTypes,
+                    const FeedbackState& feedback_state)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
  int32_t AddReportBlock(const RTCPReportBlock& report_block)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
- bool PrepareReport(const FeedbackState& feedback_state,
-                    uint32_t ssrc,
-                    StreamStatistician* statistician,
-                    RTCPReportBlock* report_block);
+ bool PrepareReportBlock(const FeedbackState& feedback_state,
+                         uint32_t ssrc,
+                         StreamStatistician* statistician,
+                         RTCPReportBlock* report_block)
+     EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);

[åsapersson, 2015/11/16 14:54:39]

lock needed?

[sprang_webrtc, 2015/12/01 10:23:06]

To read/update the flags. Problem?

[åsapersson, 2015/12/01 13:49:20]

But not needed for this function, right?

[sprang_webrtc, 2015/12/02 10:33:26]

Done.

 
- int PrepareRTCP(const FeedbackState& feedback_state,
-                 const std::set<RTCPPacketType>& packetTypes,
-                 int32_t nackSize,
-                 const uint16_t* nackList,
-                 bool repeat,
-                 uint64_t pictureID,
-                 uint8_t* rtcp_buffer,
-                 int buffer_size);
-
- BuildResult BuildSR(RtcpContext* context)
+ bool BuildSR(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildRR(RtcpContext* context)
+ bool BuildRR(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildSDES(RtcpContext* context)
+ bool BuildSDES(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildPLI(RtcpContext* context)
+ bool BuildPLI(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildREMB(RtcpContext* context)
+ bool BuildREMB(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildTMMBR(RtcpContext* context)
+ bool BuildTMMBR(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildTMMBN(RtcpContext* context)
+ bool BuildTMMBN(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildAPP(RtcpContext* context)
+ bool BuildAPP(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildVoIPMetric(RtcpContext* context)
+ bool BuildVoIPMetric(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildBYE(RtcpContext* context)
+ bool BuildBYE(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildFIR(RtcpContext* context)
+ bool BuildFIR(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildSLI(RtcpContext* context)
+ bool BuildSLI(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildRPSI(RtcpContext* context)
+ bool BuildRPSI(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildNACK(RtcpContext* context)
+ bool BuildNACK(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildReceiverReferenceTime(RtcpContext* context)
+ bool BuildReceiverReferenceTime(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
- BuildResult BuildDlrr(RtcpContext* context)
+ bool BuildDlrr(RtcpContext* context)
      EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
 
 private:
  const bool audio_;
  Clock* const clock_;
  RTCPMethod method_ GUARDED_BY(critical_section_rtcp_sender_);
 
  Transport* const transport_;
 
  rtc::scoped_ptr<CriticalSectionWrapper> critical_section_rtcp_sender_;
@@ skipping 76 matching lines @@
    ReportFlag(RTCPPacketType type, bool is_volatile)
        : type(type), is_volatile(is_volatile) {}
    bool operator<(const ReportFlag& flag) const { return type < flag.type; }
    bool operator==(const ReportFlag& flag) const { return type == flag.type; }
    const RTCPPacketType type;
    const bool is_volatile;
  };
 
  std::set<ReportFlag> report_flags_ GUARDED_BY(critical_section_rtcp_sender_);
 
- typedef BuildResult (RTCPSender::*Builder)(RtcpContext*);
+ typedef bool (RTCPSender::*Builder)(RtcpContext*);
  std::map<RTCPPacketType, Builder> builders_;
-
- class PacketBuiltCallback;
 };
 }  // namespace webrtc
 
 #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_