RTCMediaStreamTrackStats.frameWidth/Height,framesPerSecond,framesDecoded

webrtc/api/rtcstatscollector_unittest.cc

 /*
  *  Copyright 2016 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 1399 matching lines @@
       .WillRepeatedly(Return(remote_streams));
 
   rtc::scoped_refptr<MediaStream> local_stream =
       MediaStream::Create("LocalStreamLabel");
   local_streams->AddStream(local_stream);
   rtc::scoped_refptr<MediaStream> remote_stream =
       MediaStream::Create("RemoteStreamLabel");
   remote_streams->AddStream(remote_stream);
 
   // Local video track
-  VideoTrackSourceInterface::Stats local_video_track_source_stats;
-  local_video_track_source_stats.input_width = 1234;
-  local_video_track_source_stats.input_height = 4321;
-  rtc::scoped_refptr<FakeVideoTrackSourceForStats> local_video_track_source =
-      new FakeVideoTrackSourceForStats(local_video_track_source_stats);
   rtc::scoped_refptr<FakeVideoTrackForStats> local_video_track =
       FakeVideoTrackForStats::Create(
           "LocalVideoTrackID",
           MediaStreamTrackInterface::TrackState::kLive,
-          local_video_track_source);
+          nullptr);
   local_stream->AddTrack(local_video_track);
 
   // Remote video track
-  VideoTrackSourceInterface::Stats remote_video_track_source_stats;
-  remote_video_track_source_stats.input_width = 1234;
-  remote_video_track_source_stats.input_height = 4321;
-  rtc::scoped_refptr<FakeVideoTrackSourceForStats> remote_video_track_source =
-      new FakeVideoTrackSourceForStats(remote_video_track_source_stats);
   rtc::scoped_refptr<FakeVideoTrackForStats> remote_video_track =
       FakeVideoTrackForStats::Create(
           "RemoteVideoTrackID",
           MediaStreamTrackInterface::TrackState::kEnded,
-          remote_video_track_source);
+          nullptr);
   remote_stream->AddTrack(remote_video_track);
 
   // RTP sender/receivers for local/remote track to wire up SSRCs.
   std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders;
   rtc::scoped_refptr<FakeRtpSender> rtp_sender =
       new FakeRtpSender(cricket::MEDIA_TYPE_VIDEO,
                         CreateRtpParametersWithSsrc(42));
   rtp_sender->SetTrack(local_video_track);
   rtp_senders.push_back(rtp_sender);
   std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers;
   rtc::scoped_refptr<FakeRtpReceiver> rtp_receiver =
       new FakeRtpReceiver(cricket::MEDIA_TYPE_VIDEO,
                           CreateRtpParametersWithSsrc(43));
   rtp_receiver->SetTrack(remote_video_track);
   rtp_receivers.push_back(rtp_receiver);
   EXPECT_CALL(test_->pc(), GetSenders()).WillRepeatedly(
       Return(rtp_senders));
   EXPECT_CALL(test_->pc(), GetReceivers()).WillRepeatedly(
       Return(rtp_receivers));
 
   // |VideoMediaInfo| for the above referenced SSRCs
   MockVideoMediaChannel* video_media_channel = new MockVideoMediaChannel();
   cricket::VideoChannel video_channel(
       test_->worker_thread(), test_->network_thread(), video_media_channel,
       nullptr, "VideoContentName", kDefaultRtcpEnabled, kDefaultSrtpRequired);
   cricket::VideoMediaInfo video_media_info;
   video_media_info.senders.push_back(cricket::VideoSenderInfo());
   video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
   video_media_info.senders[0].local_stats[0].ssrc = 42;
+  video_media_info.senders[0].send_frame_width = 1234;
+  video_media_info.senders[0].send_frame_height = 4321;
+  video_media_info.senders[0].framerate_sent = 55;
   video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
   video_media_info.receivers[0].local_stats.push_back(
       cricket::SsrcReceiverInfo());
   video_media_info.receivers[0].local_stats[0].ssrc = 43;
   video_media_info.receivers[0].local_stats.push_back(
       cricket::SsrcReceiverInfo());
   video_media_info.receivers[0].local_stats[1].ssrc = 44;
+  video_media_info.receivers[0].frame_width = 4321;
+  video_media_info.receivers[0].frame_height = 1234;
+  video_media_info.receivers[0].framerate_output = 66;
+  video_media_info.receivers[0].frames_decoded = 1337;
   EXPECT_CALL(*video_media_channel, GetStats(_))
       .WillOnce(DoAll(SetArgPointee<0>(video_media_info), Return(true)));
   SessionStats session_stats;
   session_stats.proxy_to_transport["VideoContentName"] = "TransportName";
   session_stats.transport_stats["TransportName"].transport_name =
       "TransportName";
   EXPECT_CALL(test_->session(), GetStats(_)).WillRepeatedly(Invoke(
       [&session_stats](const ChannelNamePairs&) {
         return std::unique_ptr<SessionStats>(new SessionStats(session_stats));
       }));
@@ skipping 26 matching lines @@
 
   RTCMediaStreamTrackStats expected_local_video_track(
       "RTCMediaStreamTrack_local_LocalVideoTrackID", report->timestamp_us());
   expected_local_video_track.track_identifier = local_video_track->id();
   expected_local_video_track.remote_source = false;
   expected_local_video_track.ended = false;
   expected_local_video_track.detached = false;
   expected_local_video_track.ssrc_ids = std::vector<std::string>({ "42" });
   expected_local_video_track.frame_width = 1234;
   expected_local_video_track.frame_height = 4321;
+  expected_local_video_track.frames_per_second = 55.0;
   ASSERT_TRUE(report->Get(expected_local_video_track.id()));
   EXPECT_EQ(expected_local_video_track,
             report->Get(expected_local_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 
   RTCMediaStreamTrackStats expected_remote_video_track(
       "RTCMediaStreamTrack_remote_RemoteVideoTrackID", report->timestamp_us());
   expected_remote_video_track.track_identifier = remote_video_track->id();
   expected_remote_video_track.remote_source = true;
   expected_remote_video_track.ended = true;
   expected_remote_video_track.detached = false;
   expected_remote_video_track.ssrc_ids =
       std::vector<std::string>({ "43", "44" });
-  expected_remote_video_track.frame_width = 1234;
-  expected_remote_video_track.frame_height = 4321;
+  expected_remote_video_track.frame_width = 4321;
+  expected_remote_video_track.frame_height = 1234;
+  expected_remote_video_track.frames_per_second = 66.0;
+  expected_remote_video_track.frames_decoded = 1337;
   ASSERT_TRUE(report->Get(expected_remote_video_track.id()));
   EXPECT_EQ(expected_remote_video_track,
             report->Get(expected_remote_video_track.id())->cast_to<
                 RTCMediaStreamTrackStats>());
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
   MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel();
   cricket::VoiceChannel voice_channel(
       test_->worker_thread(), test_->network_thread(), test_->media_engine(),
@@ skipping 551 matching lines @@
   rtc::scoped_refptr<FakeRTCStatsCollector> collector_;
 };
 
 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
   collector_->VerifyThreadUsageAndResultsMerging();
 }
 
 }  // namespace
 
 }  // namespace webrtc