Added VP8 simulcast tests. Fixed analyzer to correctly infer timestamps.

webrtc/video/video_quality_test.cc

 /*
  *  Copyright (c) 2015 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.
  */
 #include "webrtc/video/video_quality_test.h"
@@ skipping 115 matching lines @@
                       public rtc::VideoSinkInterface<VideoFrame>,
                       public EncodedFrameObserver {
  public:
   VideoAnalyzer(test::LayerFilteringTransport* transport,
                 const std::string& test_label,
                 double avg_psnr_threshold,
                 double avg_ssim_threshold,
                 int duration_frames,
                 FILE* graph_data_output_file,
                 const std::string& graph_title,
-                uint32_t ssrc_to_analyze)
+                uint32_t ssrc_to_analyze,
+                uint32_t selected_width,
+                uint32_t selected_height)
       : transport_(transport),
         receiver_(nullptr),
         send_stream_(nullptr),
         receive_stream_(nullptr),
         captured_frame_forwarder_(this),
         test_label_(test_label),
         graph_data_output_file_(graph_data_output_file),
         graph_title_(graph_title),
         ssrc_to_analyze_(ssrc_to_analyze),
+        selected_width_(selected_width),
+        selected_height_(selected_height),
         pre_encode_proxy_(this),
         encode_timing_proxy_(this),
         frames_to_process_(duration_frames),
         frames_recorded_(0),
         frames_processed_(0),
         dropped_frames_(0),
         dropped_frames_before_first_encode_(0),
         dropped_frames_before_rendering_(0),
         last_render_time_(0),
         rtp_timestamp_delta_(0),
@@ skipping 63 matching lines @@
                                const PacketTime& packet_time) override {
     // Ignore timestamps of RTCP packets. They're not synchronized with
     // RTP packet timestamps and so they would confuse wrap_handler_.
     if (RtpHeaderParser::IsRtcp(packet, length)) {
       return receiver_->DeliverPacket(media_type, packet, length, packet_time);
     }
 
     RtpUtility::RtpHeaderParser parser(packet, length);
     RTPHeader header;
     parser.Parse(&header);
-    if (!IsFlexfec(header.payloadType)) {
+    if (!IsFlexfec(header.payloadType) && header.ssrc != ssrc_to_analyze_) {
       // Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
       // (FlexFEC and media are sent on different SSRCs, which have different
       // timestamps spaces.)
+      // Also ignore packets from wrong SSRC.
       rtc::CritScope lock(&crit_);
       int64_t timestamp =
           wrap_handler_.Unwrap(header.timestamp - rtp_timestamp_delta_);
       recv_times_[timestamp] =
           Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
     }
 
     return receiver_->DeliverPacket(media_type, packet, length, packet_time);
   }
 
   void MeasuredEncodeTiming(int64_t ntp_time_ms, int encode_time_ms) {
     rtc::CritScope crit(&comparison_lock_);
     samples_encode_time_ms_[ntp_time_ms] = encode_time_ms;
   }
 
   void PreEncodeOnFrame(const VideoFrame& video_frame) {
     rtc::CritScope lock(&crit_);
-    if (!first_send_timestamp_ && rtp_timestamp_delta_ == 0) {
+    if (!first_encoded_timestamp_) {
       while (frames_.front().timestamp() != video_frame.timestamp()) {
         ++dropped_frames_before_first_encode_;
         frames_.pop_front();
         RTC_CHECK(!frames_.empty());
       }
-      first_send_timestamp_ = rtc::Optional<uint32_t>(video_frame.timestamp());
+      first_encoded_timestamp_ =
+          rtc::Optional<uint32_t>(video_frame.timestamp());
     }
   }
 
+  void PostEncodeFrameCallback(const EncodedFrame& encoded_frame) {
+    rtc::CritScope lock(&crit_);
+    if (!first_sent_timestamp_ &&
+        encoded_frame.encoded_width_ == selected_width_ &&
+        encoded_frame.encoded_height_ == selected_height_) {
+      first_sent_timestamp_ = rtc::Optional<uint32_t>(encoded_frame.timestamp_);
+    }
+  }
+
   bool SendRtp(const uint8_t* packet,
                size_t length,
                const PacketOptions& options) override {
     RtpUtility::RtpHeaderParser parser(packet, length);
     RTPHeader header;
     parser.Parse(&header);
 
     int64_t current_time =
         Clock::GetRealTimeClock()->CurrentNtpInMilliseconds();
     bool result = transport_->SendRtp(packet, length, options);
     {
       rtc::CritScope lock(&crit_);
+      if (rtp_timestamp_delta_ == 0 && header.ssrc == ssrc_to_analyze_) {
+        rtp_timestamp_delta_ = header.timestamp - *first_sent_timestamp_;
+      }
 
-      if (rtp_timestamp_delta_ == 0) {
-        rtp_timestamp_delta_ = header.timestamp - *first_send_timestamp_;
-        first_send_timestamp_ = rtc::Optional<uint32_t>();
-      }
-      if (!IsFlexfec(header.payloadType)) {
+      if (!IsFlexfec(header.payloadType) && header.ssrc == ssrc_to_analyze_) {
         // Ignore FlexFEC timestamps, to avoid collisions with media timestamps.
         // (FlexFEC and media are sent on different SSRCs, which have different
         // timestamps spaces.)
+        // Also ignore packets from wrong SSRC.
         int64_t timestamp =
             wrap_handler_.Unwrap(header.timestamp - rtp_timestamp_delta_);
         send_times_[timestamp] = current_time;
         if (!transport_->DiscardedLastPacket() &&
             header.ssrc == ssrc_to_analyze_) {
           encoded_frame_sizes_[timestamp] +=
               length - (header.headerLength + header.paddingLength);
         }
       }
     }
@@ skipping 179 matching lines @@
 
   // This class receives the send-side OnEncodeTiming and is provided to not
   // conflict with the receiver-side pre_decode_callback.
   class OnEncodeTimingProxy : public EncodedFrameObserver {
    public:
     explicit OnEncodeTimingProxy(VideoAnalyzer* parent) : parent_(parent) {}
 
     void OnEncodeTiming(int64_t ntp_time_ms, int encode_time_ms) override {
       parent_->MeasuredEncodeTiming(ntp_time_ms, encode_time_ms);
     }
-    void EncodedFrameCallback(const EncodedFrame& frame) override {}
+    void EncodedFrameCallback(const EncodedFrame& frame) override {
+      parent_->PostEncodeFrameCallback(frame);
+    }
 
    private:
     VideoAnalyzer* const parent_;
   };
 
   // This class receives the send-side OnFrame callback and is provided to not
   // conflict with the receiver-side renderer callback.
   class PreEncodeProxy : public rtc::VideoSinkInterface<VideoFrame> {
    public:
     explicit PreEncodeProxy(VideoAnalyzer* parent) : parent_(parent) {}
@@ skipping 289 matching lines @@
   // forwards the captured frames to the VideoSendStream.
   class CapturedFrameForwarder : public rtc::VideoSinkInterface<VideoFrame>,
                                  public rtc::VideoSourceInterface<VideoFrame> {
    public:
     explicit CapturedFrameForwarder(VideoAnalyzer* analyzer)
         : analyzer_(analyzer), send_stream_input_(nullptr) {}
 
    private:
     void OnFrame(const VideoFrame& video_frame) override {
       VideoFrame copy = video_frame;
+      // Frames from the capturer does not have a rtp timestamp.
+      // Create one so it can be used for comparison.
+      RTC_DCHECK_EQ(0, video_frame.timestamp());
       copy.set_timestamp(copy.ntp_time_ms() * 90);
-
-      analyzer_->AddCapturedFrameForComparison(video_frame);
+      analyzer_->AddCapturedFrameForComparison(copy);
       rtc::CritScope lock(&crit_);
       if (send_stream_input_)
         send_stream_input_->OnFrame(video_frame);
     }
 
     // Called when |send_stream_.SetSource()| is called.
     void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                          const rtc::VideoSinkWants& wants) override {
       rtc::CritScope lock(&crit_);
       RTC_DCHECK(!send_stream_input_ || send_stream_input_ == sink);
       send_stream_input_ = sink;
     }
 
     // Called by |send_stream_| when |send_stream_.SetSource()| is called.
     void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {
       rtc::CritScope lock(&crit_);
       RTC_DCHECK(sink == send_stream_input_);
       send_stream_input_ = nullptr;
     }
 
     VideoAnalyzer* const analyzer_;
     rtc::CriticalSection crit_;
     rtc::VideoSinkInterface<VideoFrame>* send_stream_input_ GUARDED_BY(crit_);
   };
 
   void AddCapturedFrameForComparison(const VideoFrame& video_frame) {
     rtc::CritScope lock(&crit_);
-    RTC_DCHECK_EQ(0, video_frame.timestamp());
-    // Frames from the capturer does not have a rtp timestamp. Create one so it
-    // can be used for comparison.
-    VideoFrame copy = video_frame;
-    copy.set_timestamp(copy.ntp_time_ms() * 90);
-    frames_.push_back(copy);
+    frames_.push_back(video_frame);
   }
 
   VideoSendStream* send_stream_;
   VideoReceiveStream* receive_stream_;
   CapturedFrameForwarder captured_frame_forwarder_;
   const std::string test_label_;
   FILE* const graph_data_output_file_;
   const std::string graph_title_;
   const uint32_t ssrc_to_analyze_;
+  const uint32_t selected_width_;
+  const uint32_t selected_height_;
   PreEncodeProxy pre_encode_proxy_;
   OnEncodeTimingProxy encode_timing_proxy_;
   std::vector<Sample> samples_ GUARDED_BY(comparison_lock_);
   std::map<int64_t, int> samples_encode_time_ms_ GUARDED_BY(comparison_lock_);
   test::Statistics sender_time_ GUARDED_BY(comparison_lock_);
   test::Statistics receiver_time_ GUARDED_BY(comparison_lock_);
   test::Statistics psnr_ GUARDED_BY(comparison_lock_);
   test::Statistics ssim_ GUARDED_BY(comparison_lock_);
   test::Statistics end_to_end_ GUARDED_BY(comparison_lock_);
   test::Statistics rendered_delta_ GUARDED_BY(comparison_lock_);
@@ skipping 14 matching lines @@
   int64_t last_render_time_;
   uint32_t rtp_timestamp_delta_;
 
   rtc::CriticalSection crit_;
   std::deque<VideoFrame> frames_ GUARDED_BY(crit_);
   rtc::Optional<VideoFrame> last_rendered_frame_ GUARDED_BY(crit_);
   rtc::TimestampWrapAroundHandler wrap_handler_ GUARDED_BY(crit_);
   std::map<int64_t, int64_t> send_times_ GUARDED_BY(crit_);
   std::map<int64_t, int64_t> recv_times_ GUARDED_BY(crit_);
   std::map<int64_t, size_t> encoded_frame_sizes_ GUARDED_BY(crit_);
-  rtc::Optional<uint32_t> first_send_timestamp_ GUARDED_BY(crit_);
+  rtc::Optional<uint32_t> first_encoded_timestamp_ GUARDED_BY(crit_);
+  rtc::Optional<uint32_t> first_sent_timestamp_ GUARDED_BY(crit_);
   const double avg_psnr_threshold_;
   const double avg_ssim_threshold_;
 
   rtc::CriticalSection comparison_lock_;
   std::vector<rtc::PlatformThread*> comparison_thread_pool_;
   rtc::PlatformThread stats_polling_thread_;
   rtc::Event comparison_available_event_;
   std::deque<FrameComparison> comparisons_ GUARDED_BY(comparison_lock_);
   rtc::Event done_;
 };
@@ skipping 423 matching lines @@
                         : params_.ss.num_spatial_layers - 1;
   bool disable_quality_check =
       selected_stream.width != params_.video.width ||
       selected_stream.height != params_.video.height ||
       (!params_.ss.spatial_layers.empty() &&
        params_.ss.spatial_layers[selected_sl].scaling_factor_num !=
            params_.ss.spatial_layers[selected_sl].scaling_factor_den);
   if (disable_quality_check) {
     fprintf(stderr,
             "Warning: Calculating PSNR and SSIM for downsized resolution "
-            "not implemented yet! Skipping PSNR and SSIM calculations!");
+            "not implemented yet! Skipping PSNR and SSIM calculations!\n");
   }
 
   VideoAnalyzer analyzer(
       &send_transport, params_.analyzer.test_label,
       disable_quality_check ? -1.1 : params_.analyzer.avg_psnr_threshold,
       disable_quality_check ? -1.1 : params_.analyzer.avg_ssim_threshold,
       params_.analyzer.test_durations_secs * params_.video.fps,
       graph_data_output_file, graph_title,
-      kVideoSendSsrcs[params_.ss.selected_stream]);
+      kVideoSendSsrcs[params_.ss.selected_stream],
+      static_cast<uint32_t>(selected_stream.width),
+      static_cast<uint32_t>(selected_stream.height));
 
   analyzer.SetReceiver(receiver_call_->Receiver());
   send_transport.SetReceiver(&analyzer);
   recv_transport.SetReceiver(sender_call_->Receiver());
 
   SetupVideo(&analyzer, &recv_transport);
   video_receive_configs_[params_.ss.selected_stream].renderer = &analyzer;
   video_send_config_.pre_encode_callback = analyzer.pre_encode_proxy();
   for (auto& config : video_receive_configs_)
     config.pre_decode_callback = &analyzer;
@@ skipping 236 matching lines @@
     std::ostringstream str;
     str << receive_logs_++;
     std::string path =
         params_.video.encoded_frame_base_path + "." + str.str() + ".recv.ivf";
     stream->EnableEncodedFrameRecording(rtc::CreatePlatformFile(path),
                                         10000000);
   }
 }
 
 }  // namespace webrtc