Tighten up encode time measurement in VideoProcessor.

webrtc/modules/video_coding/codecs/test/videoprocessor.cc

 /*
  *  Copyright (c) 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 202 matching lines @@
   }
 
   rtc::scoped_refptr<VideoFrameBuffer> buffer(frame_reader_->ReadFrame());
   if (buffer) {
     // Use the frame number as "timestamp" to identify frames.
     VideoFrame source_frame(buffer, frame_number, 0, webrtc::kVideoRotation_0);
 
     // Ensure we have a new statistics data object we can fill.
     FrameStatistic& stat = stats_->NewFrame(frame_number);
 
-    encode_start_ns_ = rtc::TimeNanos();
-
     // Decide if we are going to force a keyframe.
     std::vector<FrameType> frame_types(1, kVideoFrameDelta);
     if (config_.keyframe_interval > 0 &&
         frame_number % config_.keyframe_interval == 0) {
       frame_types[0] = kVideoFrameKey;
     }
 
     // For dropped frames, we regard them as zero size encoded frames.
     encoded_frame_size_ = 0;
     encoded_frame_type_ = kVideoFrameDelta;
 
+    // For the highest measurement accuracy of the encode time, the start/stop
+    // time recordings should wrap the Encode call as tightly as possible.
+    encode_start_ns_ = rtc::TimeNanos();
     int32_t encode_result =
         encoder_->Encode(source_frame, nullptr, &frame_types);
 
     if (encode_result != WEBRTC_VIDEO_CODEC_OK) {
       fprintf(stderr, "Failed to encode frame %d, return code: %d\n",
               frame_number, encode_result);
     }
     stat.encode_return_code = encode_result;
 
     return true;
   } else {
     // Last frame has been reached.
     return false;
   }
 }
 
 void VideoProcessorImpl::FrameEncoded(
     webrtc::VideoCodecType codec,
     const EncodedImage& encoded_image,
     const webrtc::RTPFragmentationHeader* fragmentation) {
+  // For the highest measurement accuracy of the encode time, the start/stop
+  // time recordings should wrap the Encode call as tightly as possible.
+  int64_t encode_stop_ns = rtc::TimeNanos();
+
   // Timestamp is frame number, so this gives us #dropped frames.
   int num_dropped_from_prev_encode =
       encoded_image._timeStamp - prev_time_stamp_ - 1;
   num_dropped_frames_ += num_dropped_from_prev_encode;
   prev_time_stamp_ = encoded_image._timeStamp;
   if (num_dropped_from_prev_encode > 0) {
     // For dropped frames, we write out the last decoded frame to avoid getting
     // out of sync for the computation of PSNR and SSIM.
     for (int i = 0; i < num_dropped_from_prev_encode; i++) {
       frame_writer_->WriteFrame(last_successful_frame_buffer_.get());
     }
   }
   // Frame is not dropped, so update the encoded frame size
   // (encoder callback is only called for non-zero length frames).
   encoded_frame_size_ = encoded_image._length;
   encoded_frame_type_ = encoded_image._frameType;
-
-  int64_t encode_stop_ns = rtc::TimeNanos();
   int frame_number = encoded_image._timeStamp;
 
   FrameStatistic& stat = stats_->stats_[frame_number];
   stat.encode_time_in_us =
       GetElapsedTimeMicroseconds(encode_start_ns_, encode_stop_ns);
   stat.encoding_successful = true;
   stat.encoded_frame_length_in_bytes = encoded_image._length;
   stat.frame_number = encoded_image._timeStamp;
   stat.frame_type = encoded_image._frameType;
   stat.bit_rate_in_kbps = encoded_image._length * bit_rate_factor_;
@@ skipping 31 matching lines @@
   copied_image._size = copied_buffer_size;
   copied_image._buffer = copied_buffer.get();
 
   if (!exclude_this_frame) {
     stat.packets_dropped =
         packet_manipulator_->ManipulatePackets(&copied_image);
   }
 
   // Keep track of if frames are lost due to packet loss so we can tell
   // this to the encoder (this is handled by the RTP logic in the full stack).
-  decode_start_ns_ = rtc::TimeNanos();
   // TODO(kjellander): Pass fragmentation header to the decoder when
   // CL 172001 has been submitted and PacketManipulator supports this.
+
+  // For the highest measurement accuracy of the decode time, the start/stop
+  // time recordings should wrap the Decode call as tightly as possible.
+  decode_start_ns_ = rtc::TimeNanos();
   int32_t decode_result =
       decoder_->Decode(copied_image, last_frame_missing_, nullptr);
   stat.decode_return_code = decode_result;
 
   if (decode_result != WEBRTC_VIDEO_CODEC_OK) {
     // Write the last successful frame the output file to avoid getting it out
     // of sync with the source file for SSIM and PSNR comparisons.
     frame_writer_->WriteFrame(last_successful_frame_buffer_.get());
   }
 
   // Save status for losses so we can inform the decoder for the next frame.
   last_frame_missing_ = copied_image._length == 0;
 }
 
 void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
+  // For the highest measurement accuracy of the decode time, the start/stop
+  // time recordings should wrap the Decode call as tightly as possible.
   int64_t decode_stop_ns = rtc::TimeNanos();
 
   // Report stats.
   int frame_number = image.timestamp();
   FrameStatistic& stat = stats_->stats_[frame_number];
   stat.decode_time_in_us =
       GetElapsedTimeMicroseconds(decode_start_ns_, decode_stop_ns);
   stat.decoding_successful = true;
 
   // Check for resize action (either down or up).
@@ skipping 50 matching lines @@
 int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start,
                                                    int64_t stop) {
   int64_t encode_time = (stop - start) / rtc::kNumNanosecsPerMicrosec;
   RTC_DCHECK_GE(encode_time, std::numeric_limits<int>::min());
   RTC_DCHECK_LE(encode_time, std::numeric_limits<int>::max());
   return static_cast<int>(encode_time);
 }
 
 }  // namespace test
 }  // namespace webrtc