Delete VideoFrame default constructor, and IsZeroSize method.

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 353 matching lines @@
   }
   EncodedFrameObserver* encode_timing_proxy() { return &encode_timing_proxy_; }
 
   test::LayerFilteringTransport* const transport_;
   PacketReceiver* receiver_;
 
  private:
   struct FrameComparison {
     FrameComparison()
         : dropped(false),
+          input_time_ms(0),
           send_time_ms(0),
           recv_time_ms(0),
           render_time_ms(0),
           encoded_frame_size(0) {}
 
     FrameComparison(const VideoFrame& reference,
                     const VideoFrame& render,
                     bool dropped,
+                    int64_t input_time_ms,
                     int64_t send_time_ms,
                     int64_t recv_time_ms,
                     int64_t render_time_ms,
                     size_t encoded_frame_size)
         : reference(reference),
           render(render),
           dropped(dropped),
+          input_time_ms(input_time_ms),
           send_time_ms(send_time_ms),
           recv_time_ms(recv_time_ms),
           render_time_ms(render_time_ms),
           encoded_frame_size(encoded_frame_size) {}
 
-    VideoFrame reference;
-    VideoFrame render;
+    FrameComparison(bool dropped,
+                    int64_t input_time_ms,
+                    int64_t send_time_ms,
+                    int64_t recv_time_ms,
+                    int64_t render_time_ms,
+                    size_t encoded_frame_size)
+        : dropped(dropped),
+          input_time_ms(input_time_ms),
+          send_time_ms(send_time_ms),
+          recv_time_ms(recv_time_ms),
+          render_time_ms(render_time_ms),
+          encoded_frame_size(encoded_frame_size) {}
+
+    rtc::Optional<VideoFrame> reference;
+    rtc::Optional<VideoFrame> render;
     bool dropped;
+    int64_t input_time_ms;
     int64_t send_time_ms;
     int64_t recv_time_ms;
     int64_t render_time_ms;
     size_t encoded_frame_size;
   };
 
   struct Sample {
     Sample(int dropped,
            int64_t input_time_ms,
            int64_t send_time_ms,
@@ skipping 62 matching lines @@
     recv_times_.erase(reference_timestamp);
 
     // TODO(ivica): Make this work for > 2 streams.
     auto it = encoded_frame_sizes_.find(reference_timestamp);
     if (it == encoded_frame_sizes_.end())
       it = encoded_frame_sizes_.find(reference_timestamp - 1);
     size_t encoded_size = it == encoded_frame_sizes_.end() ? 0 : it->second;
     if (it != encoded_frame_sizes_.end())
       encoded_frame_sizes_.erase(it);
 
-    VideoFrame reference_copy;
-    VideoFrame render_copy;
-
     rtc::CritScope crit(&comparison_lock_);
     if (comparisons_.size() < kMaxComparisons) {
-      reference_copy = reference;
-      render_copy = render;
+      comparisons_.push_back(FrameComparison(reference, render, dropped,
+                                             reference.ntp_time_ms(),
+                                             send_time_ms, recv_time_ms,
+                                             render_time_ms, encoded_size));
     } else {
-      // Copy the time to ensure that delay calculations can still be made.
-      reference_copy.set_ntp_time_ms(reference.ntp_time_ms());
-      render_copy.set_ntp_time_ms(render.ntp_time_ms());
+      comparisons_.push_back(FrameComparison(dropped,
+                                             reference.ntp_time_ms(),
+                                             send_time_ms, recv_time_ms,
+                                             render_time_ms, encoded_size));
     }
-    comparisons_.push_back(FrameComparison(reference_copy, render_copy, dropped,
-                                           send_time_ms, recv_time_ms,
-                                           render_time_ms, encoded_size));
     comparison_available_event_.Set();
   }
 
   static bool PollStatsThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->PollStats();
   }
 
   bool PollStats() {
     if (done_.Wait(kSendStatsPollingIntervalMs))
       return false;
@@ skipping 16 matching lines @@
   }
 
   static bool FrameComparisonThread(void* obj) {
     return static_cast<VideoAnalyzer*>(obj)->CompareFrames();
   }
 
   bool CompareFrames() {
     if (AllFramesRecorded())
       return false;
 
-    VideoFrame reference;
-    VideoFrame render;
     FrameComparison comparison;
 
     if (!PopComparison(&comparison)) {
       // Wait until new comparison task is available, or test is done.
       // If done, wake up remaining threads waiting.
       comparison_available_event_.Wait(1000);
       if (AllFramesRecorded()) {
         comparison_available_event_.Set();
         return false;
       }
@@ skipping 75 matching lines @@
            test_label_.c_str(), dropped_frames_before_rendering_);
 
     EXPECT_GT(psnr_.Mean(), avg_psnr_threshold_);
     EXPECT_GT(ssim_.Mean(), avg_ssim_threshold_);
   }
 
   void PerformFrameComparison(const FrameComparison& comparison) {
     // Perform expensive psnr and ssim calculations while not holding lock.
     double psnr = -1.0;
     double ssim = -1.0;
-    if (!comparison.reference.IsZeroSize()) {
-      psnr = I420PSNR(&comparison.reference, &comparison.render);
-      ssim = I420SSIM(&comparison.reference, &comparison.render);
+    if (comparison.reference) {
+      psnr = I420PSNR(&*comparison.reference, &*comparison.render);
+      ssim = I420SSIM(&*comparison.reference, &*comparison.render);
     }
 
-    int64_t input_time_ms = comparison.reference.ntp_time_ms();
+    int64_t input_time_ms = comparison.reference->ntp_time_ms();
 
     rtc::CritScope crit(&comparison_lock_);
     if (graph_data_output_file_) {
       samples_.push_back(
           Sample(comparison.dropped, input_time_ms, comparison.send_time_ms,
                  comparison.recv_time_ms, comparison.render_time_ms,
                  comparison.encoded_frame_size, psnr, ssim));
     }
     if (psnr >= 0.0)
       psnr_.AddSample(psnr);
@@ skipping 842 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