Get VideoCapturer stats via VideoTrackSourceInterface in StatsCollector,

webrtc/api/statscollector.cc

 /*
  *  Copyright 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 218 matching lines @@
                      (info.adapt_reason & 0x1) > 0);
   report->AddBoolean(StatsReport::kStatsValueNameViewLimitedResolution,
                      (info.adapt_reason & 0x4) > 0);
 
   const IntForAdd ints[] = {
     { StatsReport::kStatsValueNameAdaptationChanges, info.adapt_changes },
     { StatsReport::kStatsValueNameAvgEncodeMs, info.avg_encode_ms },
     { StatsReport::kStatsValueNameEncodeUsagePercent,
       info.encode_usage_percent },
     { StatsReport::kStatsValueNameFirsReceived, info.firs_rcvd },
-    { StatsReport::kStatsValueNameFrameHeightInput, info.input_frame_height },
     { StatsReport::kStatsValueNameFrameHeightSent, info.send_frame_height },
     { StatsReport::kStatsValueNameFrameRateInput, info.framerate_input },
     { StatsReport::kStatsValueNameFrameRateSent, info.framerate_sent },
-    { StatsReport::kStatsValueNameFrameWidthInput, info.input_frame_width },
     { StatsReport::kStatsValueNameFrameWidthSent, info.send_frame_width },
     { StatsReport::kStatsValueNameNacksReceived, info.nacks_rcvd },
     { StatsReport::kStatsValueNamePacketsLost, info.packets_lost },
     { StatsReport::kStatsValueNamePacketsSent, info.packets_sent },
     { StatsReport::kStatsValueNamePlisReceived, info.plis_rcvd },
   };
 
   for (const auto& i : ints)
     report->AddInt(i.name, i.value);
   report->AddString(StatsReport::kStatsValueNameMediaType, "video");
@@ skipping 213 matching lines @@
   if (pc_->session()) {
     // TODO(tommi): All of these hop over to the worker thread to fetch
     // information.  We could use an AsyncInvoker to run all of these and post
     // the information back to the signaling thread where we can create and
     // update stats reports.  That would also clean up the threading story a bit
     // since we'd be creating/updating the stats report objects consistently on
     // the same thread (this class has no locks right now).
     ExtractSessionInfo();
     ExtractVoiceInfo();
     ExtractVideoInfo(level);
+    ExtractCapturerInfo();
     ExtractDataInfo();
     UpdateTrackReports();
   }
 }
 
 StatsReport* StatsCollector::PrepareReport(
     bool local,
     uint32_t ssrc,
     const StatsReport::Id& transport_id,
     StatsReport::Direction direction) {
@@ skipping 334 matching lines @@
   if (video_info.bw_estimations.size() != 1) {
     LOG(LS_ERROR) << "BWEs count: " << video_info.bw_estimations.size();
   } else {
     StatsReport::Id report_id(StatsReport::NewBandwidthEstimationId());
     StatsReport* report = reports_.FindOrAddNew(report_id);
     ExtractStats(
         video_info.bw_estimations[0], stats_gathering_started_, level, report);
   }
 }
 
+void StatsCollector::ExtractCapturerInfo() {
+  RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
+
+  rtc::scoped_refptr<StreamCollectionInterface> streams = pc_->local_streams();
+  for (size_t i = 0; i < streams->count(); i++) {
+    for (auto track : streams->at(i)->GetVideoTracks()) {
+      VideoTrackSourceInterface* source = track->GetSource();
+      VideoTrackSourceInterface::VideoSourceInfo info;
+      if (source->GetInfo(&info)) {
+        // TODO(nisse): What id to use???

[pthatcher1, 2016/03/24 18:10:25]

Based on the code here:

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

The ID should be:

StatsReport::NewIdWithDirection(StatsReport::kStatsReportTypeSsrc,
rtc::ToString<uint32_t>(ssrc), StatsReport::kSend)

But to know the SSRC, you need to know the RtpSender object instead of the
StreamCollectionInterface, like so:

for (rtc::scoped_refptr<RtpSenderInterface> sender : pc_->GetSenders()) {
  uint32_t ssrc = sender->ssrc();
  rtc::scoped_refptr<MediaStreamTrackInterface> track = sender->track();
  if (!track || sender->track()->kind() !=
MediaStreamTrackInterface::kVideoKind) {
    continue;
  }
  StatsReport::Id stats_id =
StatsReport::NewIdWithDirection(StatsReport::kStatsReportTypeSsrc,
rtc::ToString<uint32_t>(ssrc), StatsReport::kSend);

  track->GetSource()->GetInfo(&info);
  ...
}



Now, there's just one problem:  RtpSender::GetTrack is a
MediaStreamTrackInterface, not a VideoTrackSourceInterface.


Have you considered moving this code to RtpSender by implementing an
RtpSender::GetStats?  That way you could do this:

sender->GetStats(&report);


And then the sender could do report->AddInt(...), etc.  In fact, it might be
worth moving the logic for the stats_id to the sender as well so that you would
just have:

for (rtc::scoped_refptr<RtpSenderInterface> sender : pc_->GetSenders()) {
  StatsReport* report = report_.FindOrAddNew(sender->stats_id());
  sender->GetStats(&report);
}

And you'd be done.

[nisse-webrtc, 2016/03/29 08:36:32]

Nice idea. I implemented that. A few questions: 

Do we really want to use StatsReport directly outside of the StatsCollector?
That seems like the most reasonable way if we want to provide some other stats
for AudioRtpSender. I named the RtpSender method ReportStats rather then
GetStats because I think the latter name is more appropriate for a method
populating a simple struct with values.

Do we need any synchronization in VideoRtpSender? Or is all relevant code
running on the same thread?

The current version will produce empty reports in some cases. E.g., if track_ is
NULL, or if GetSource()->GetStats(&stats) returns false (happens for remote
sources), VideoRtpSender::stats_id returns non-NULL, but ReportStats doesn't
fill out any values. To get that right, it would be nice with a single method
producing either both the id and the report, or nothing, but that collides a bit
with the use of FindOrAddNew. Not sure if it matters, maybe empty reports are
pruned later anyway?

+        StatsReport* report = reports_.FindOrAddNew(StatsReport::Id());
+        report->AddInt(StatsReport::kStatsValueNameFrameWidthInput,
+                       info.input_width);
+        report->AddInt(StatsReport::kStatsValueNameFrameHeightInput,
+                       info.input_height);
+      }
+    }
+  }
+}
+
 void StatsCollector::ExtractDataInfo() {
   RTC_DCHECK(pc_->session()->signaling_thread()->IsCurrent());
 
   rtc::Thread::ScopedDisallowBlockingCalls no_blocking_calls;
 
   for (const auto& dc : pc_->sctp_data_channels()) {
     StatsReport::Id id(StatsReport::NewTypedIntId(
         StatsReport::kStatsReportTypeDataChannel, dc->id()));
     StatsReport* report = reports_.ReplaceOrAddNew(id);
     report->set_timestamp(stats_gathering_started_);
@@ skipping 97 matching lines @@
     StatsReport* report = entry.second;
     report->set_timestamp(stats_gathering_started_);
   }
 }
 
 void StatsCollector::ClearUpdateStatsCacheForTest() {
   stats_gathering_started_ = 0;
 }
 
 }  // namespace webrtc