Add RtcpPacketTypeCounter stats to new API.

R=mflodman@webrtc.org, stefan@webrtc.org
BUG=1667,1788

Review URL: https://webrtc-codereview.appspot.com/37489004

Cr-Commit-Position: refs/heads/master@{#8429}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8429 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/video_engine/include/vie_rtp_rtcp.h

@@ -448,6 +448,12 @@ class WEBRTC_DLLEXPORT ViERTP_RTCP {
   virtual int DeregisterSendFrameCountObserver(
       int video_channel, FrameCountObserver* observer) = 0;
 
+  // Called when RTCP packet type counters might have been changed. User has to
+  // filter on SSRCs to determine whether it's status sent or received.
+  virtual int RegisterRtcpPacketTypeCounterObserver(
+      int video_channel,
+      RtcpPacketTypeCounterObserver* observer) = 0;
+
  protected:
   virtual ~ViERTP_RTCP() {}
 };

webrtc/video_engine/vie_channel.cc

@@ -1142,6 +1142,11 @@ void ViEChannel::RegisterReceiveChannelRtcpStatisticsCallback(
   rtp_rtcp_->RegisterRtcpStatisticsCallback(callback);
 }
 
+void ViEChannel::RegisterRtcpPacketTypeCounterObserver(
+    RtcpPacketTypeCounterObserver* observer) {
+  rtcp_packet_type_counter_observer_.Set(observer);
+}
+
 int32_t ViEChannel::GetRtpStatistics(size_t* bytes_sent,
                                      uint32_t* packets_sent,
                                      size_t* bytes_received,
@@ -1241,25 +1246,24 @@ void ViEChannel::RegisterReceiveChannelRtpStatisticsCallback(
 void ViEChannel::GetRtcpPacketTypeCounters(
     RtcpPacketTypeCounter* packets_sent,
     RtcpPacketTypeCounter* packets_received) const {
-  rtp_rtcp_->GetRtcpPacketTypeCounters(packets_sent, packets_received);
+  std::map<uint32_t, RtcpPacketTypeCounter> counter_map =
+      rtcp_packet_type_counter_observer_.GetPacketTypeCounterMap();
+  RtcpPacketTypeCounter sent_counter;
+  sent_counter.Add(counter_map[rtp_rtcp_->SSRC()]);
+  RtcpPacketTypeCounter received_counter;
+  received_counter.Add(counter_map[vie_receiver_.GetRemoteSsrc()]);
 
   CriticalSectionScoped cs(rtp_rtcp_cs_.get());
   for (std::list<RtpRtcp*>::const_iterator it = simulcast_rtp_rtcp_.begin();
        it != simulcast_rtp_rtcp_.end(); ++it) {
-    RtcpPacketTypeCounter sent;
-    RtcpPacketTypeCounter received;
-    (*it)->GetRtcpPacketTypeCounters(&sent, &received);
-    packets_sent->Add(sent);
-    packets_received->Add(received);
+    sent_counter.Add(counter_map[(*it)->SSRC()]);
   }
   for (std::list<RtpRtcp*>::const_iterator it = removed_rtp_rtcp_.begin();
        it != removed_rtp_rtcp_.end(); ++it) {
-    RtcpPacketTypeCounter sent;
-    RtcpPacketTypeCounter received;
-    (*it)->GetRtcpPacketTypeCounters(&sent, &received);
-    packets_sent->Add(sent);
-    packets_received->Add(received);
+    sent_counter.Add(counter_map[(*it)->SSRC()]);
   }
+  *packets_sent = sent_counter;
+  *packets_received = received_counter;
 }
 
 void ViEChannel::GetBandwidthUsage(uint32_t* total_bitrate_sent,
@@ -1694,6 +1698,8 @@ RtpRtcp::Configuration ViEChannel::CreateRtpRtcpConfiguration() {
   configuration.intra_frame_callback = intra_frame_observer_;
   configuration.bandwidth_callback = bandwidth_observer_.get();
   configuration.rtt_stats = rtt_stats_;
+  configuration.rtcp_packet_type_counter_observer =
+      &rtcp_packet_type_counter_observer_;
   configuration.paced_sender = paced_sender_;
   configuration.send_bitrate_observer = &send_bitrate_observer_;
   configuration.send_frame_count_observer = &send_frame_count_observer_;

webrtc/video_engine/vie_channel.h

@@ -358,6 +358,8 @@ class ViEChannel
       EncodedImageCallback* pre_decode_callback);
 
   void RegisterSendFrameCountObserver(FrameCountObserver* observer);
+  void RegisterRtcpPacketTypeCounterObserver(
+      RtcpPacketTypeCounterObserver* observer);
   void RegisterReceiveStatisticsProxy(
       ReceiveStatisticsProxy* receive_statistics_proxy);
   void ReceivedBWEPacket(int64_t arrival_time_ms, size_t payload_size,
@@ -455,6 +457,29 @@ class ViEChannel
     }
   } send_side_delay_observer_;
 
+  class RegisterableRtcpPacketTypeCounterObserver
+      : public RegisterableCallback<RtcpPacketTypeCounterObserver> {
+   public:
+    virtual void RtcpPacketTypesCounterUpdated(
+        uint32_t ssrc,
+        const RtcpPacketTypeCounter& packet_counter) override {
+      CriticalSectionScoped cs(critsect_.get());
+      if (callback_)
+        callback_->RtcpPacketTypesCounterUpdated(ssrc, packet_counter);
+      counter_map_[ssrc] = packet_counter;
+    }
+
+    virtual std::map<uint32_t, RtcpPacketTypeCounter> GetPacketTypeCounterMap()
+        const {
+      CriticalSectionScoped cs(critsect_.get());
+      return counter_map_;
+    }
+
+   private:
+    std::map<uint32_t, RtcpPacketTypeCounter> counter_map_
+        GUARDED_BY(critsect_);
+  } rtcp_packet_type_counter_observer_;
+
   int32_t channel_id_;
   int32_t engine_id_;
   uint32_t number_of_cores_;

webrtc/video_engine/vie_rtp_rtcp_impl.cc

@@ -1019,4 +1019,18 @@ int ViERTP_RTCPImpl::DeregisterSendFrameCountObserver(
   vie_channel->RegisterSendFrameCountObserver(NULL);
   return 0;
 }
+
+int ViERTP_RTCPImpl::RegisterRtcpPacketTypeCounterObserver(
+    int video_channel,
+    RtcpPacketTypeCounterObserver* observer) {
+  ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
+  ViEChannel* vie_channel = cs.Channel(video_channel);
+  if (!vie_channel) {
+    shared_data_->SetLastError(kViERtpRtcpInvalidChannelId);
+    return -1;
+  }
+  vie_channel->RegisterRtcpPacketTypeCounterObserver(observer);
+  return 0;
+}
+
 }  // namespace webrtc

webrtc/video_engine/vie_rtp_rtcp_impl.h

@@ -157,6 +157,9 @@ class ViERTP_RTCPImpl
       int channel, FrameCountObserver* callback);
   virtual int DeregisterSendFrameCountObserver(
       int channel, FrameCountObserver* callback);
+  virtual int RegisterRtcpPacketTypeCounterObserver(
+      int video_channel,
+      RtcpPacketTypeCounterObserver* observer) override;
 
  protected:
   explicit ViERTP_RTCPImpl(ViESharedData* shared_data);