Set capture_time_ms using rtc::TimeMicros()

content/renderer/media/gpu/rtc_video_encoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/gpu/rtc_video_encoder.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 216 matching lines @@
   // we don't care about ordering.
   std::vector<int> input_buffers_free_;
 
   // The number of output buffers ready to be filled with output from the
   // encoder.
   int output_buffers_free_count_;
 
   // 15 bits running index of the VP8 frames. See VP8 RTP spec for details.
   uint16_t picture_id_;
 
+  // capture_time_ms_ field of the last returned webrtc::EncodedImage from

[mcasas, 2017/02/16 19:10:15]

nit : |capture_time_ms_|

[emircan, 2017/02/16 19:41:54]

Done.

+  // BitstreamBufferReady().
+  int64_t last_capture_time_ms_;
+
   // webrtc::VideoEncoder encode complete callback.
   webrtc::EncodedImageCallback* encoded_image_callback_;
 
   // The video codec type, as reported to WebRTC.
   const webrtc::VideoCodecType video_codec_type_;
 
   // Protect |status_|. |status_| is read or written on |gpu_task_runner_| in
   // Impl. It can be read in RTCVideoEncoder on other threads.
   mutable base::Lock status_lock_;
 
   // We cannot immediately return error conditions to the WebRTC user of this
   // class, as there is no error callback in the webrtc::VideoEncoder interface.
   // Instead, we cache an error status here and return it the next time an
   // interface entry point is called. This is protected by |status_lock_|.
   int32_t status_;
 
   DISALLOW_COPY_AND_ASSIGN(Impl);
 };
 
 RTCVideoEncoder::Impl::Impl(media::GpuVideoAcceleratorFactories* gpu_factories,
                             webrtc::VideoCodecType video_codec_type)
     : gpu_factories_(gpu_factories),
       async_waiter_(NULL),
       async_retval_(NULL),
       input_next_frame_(NULL),
       input_next_frame_keyframe_(false),
       output_buffers_free_count_(0),
+      last_capture_time_ms_(-1),
       encoded_image_callback_(nullptr),
       video_codec_type_(video_codec_type),
       status_(WEBRTC_VIDEO_CODEC_UNINITIALIZED) {
   thread_checker_.DetachFromThread();
   // Picture ID should start on a random number.
   picture_id_ = static_cast<uint16_t>(base::RandInt(0, 0x7FFF));
 }
 
 void RTCVideoEncoder::Impl::CreateAndInitializeVEA(
     const gfx::Size& input_visible_size,
@@ skipping 188 matching lines @@
     return;
   }
   base::SharedMemory* output_buffer = output_buffers_[bitstream_buffer_id];
   if (payload_size > output_buffer->mapped_size()) {
     LogAndNotifyError(FROM_HERE, "invalid payload_size",
                       media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   output_buffers_free_count_--;
 
-  // Derive the capture time (in ms) and RTP timestamp (in 90KHz ticks).
-  int64_t capture_time_us, capture_time_ms;
-  uint32_t rtp_timestamp;
+  // Derive the capture time in ms from system clock. Make sure that it is
+  // greater than the last.
+  const int64_t capture_time_us = rtc::TimeMicros();

[mcasas, 2017/02/16 19:10:15]

Could we do all these calcuations in ms and use 
rtc::TimeMillis() here instead?  Or would that lose
precious precision?

[emircan, 2017/02/16 19:41:54]

It would lose the precision in |rtp_timestamp| calculations as we are converting
to 90 kHz there. I don't want to change anything about |rtp_timestamp| in this
CL.

+  int64_t capture_time_ms =
+      capture_time_us / base::Time::kMicrosecondsPerMillisecond;
+  if (capture_time_ms <= last_capture_time_ms_)
+    capture_time_ms = last_capture_time_ms_ + 1;

[mcasas, 2017/02/16 19:10:15]

Maybe 
  capture_time_ms = std::min(capture_time_ms, last_capture_time_ms_ + 1);
 ?
(Assuming it's OK to use the updated value of
|capture_time_ms| in l.488).

[emircan, 2017/02/16 19:41:54]

That wouldn't work. Suppose there is a rapid succession of 3 calls within the
same P ms. They would be P, P, P. We want them to be P, P+1,P+2. std::max()
would work though. 
Note that we still would want to use |capture_time_us| below as I explained
before.

+  last_capture_time_ms_ = capture_time_ms;
 
-  if (!timestamp.is_zero()) {
-    capture_time_us = timestamp.InMicroseconds();;
-    capture_time_ms = timestamp.InMilliseconds();
-  } else {
-    // Fallback to the current time if encoder does not provide timestamp.
-    capture_time_us = rtc::TimeMicros();
-    capture_time_ms = capture_time_us / base::Time::kMicrosecondsPerMillisecond;
-  }
-  // RTP timestamp can wrap around. Get the lower 32 bits.
-  rtp_timestamp = static_cast<uint32_t>(
-      capture_time_us * 90 / base::Time::kMicrosecondsPerMillisecond);
+  // Fallback to the current time if encoder does not provide timestamp.
+  const int64_t encoder_time_us =
+      timestamp.is_zero() ? capture_time_us : timestamp.InMicroseconds();
+
+  // Derive the RTP timestamp (in 90KHz ticks).  It can wrap around, get the
+  // lower 32 bits.
+  const uint32_t rtp_timestamp = static_cast<uint32_t>(
+      encoder_time_us * 90 / base::Time::kMicrosecondsPerMillisecond);
 
   webrtc::EncodedImage image(
       reinterpret_cast<uint8_t*>(output_buffer->memory()), payload_size,
       output_buffer->mapped_size());
   image._encodedWidth = input_visible_size_.width();
   image._encodedHeight = input_visible_size_.height();
   image._timeStamp = rtp_timestamp;
   image.capture_time_ms_ = capture_time_ms;
   image._frameType =
       (key_frame ? webrtc::kVideoFrameKey : webrtc::kVideoFrameDelta);
@@ skipping 383 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
                         init_retval == WEBRTC_VIDEO_CODEC_OK);
   if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
     UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
                               profile,
                               media::VIDEO_CODEC_PROFILE_MAX + 1);
   }
 }
 
 }  // namespace content