Use microsecond timestamp in cricket::VideoFrame.

webrtc/media/base/videocapturer.cc

 /*
  *  Copyright (c) 2010 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 206 matching lines @@
                                          wants.max_pixel_count_step_up);
   }
 }
 
 void VideoCapturer::OnFrameCaptured(VideoCapturer*,
                                     const CapturedFrame* captured_frame) {
   if (!broadcaster_.frame_wanted()) {
     return;
   }
 
+  int64_t timestamp_us =

[perkj_webrtc, 2016/04/08 08:22:48]

do this in the frame factory instead. 

[nisse-webrtc, 2016/04/08 09:15:43]

Moving the logic there makes sense, I'll give it a try. Main question is how it
affects chrome's farme factory, but hopefully it has usec timestamps in the
right timescale already.

+      captured_frame->time_stamp / rtc::kNumNanosecsPerMicrosec;
+
+  if (!timestamp_offset_valid_) {
+    timestamp_offset_ = rtc::TimeMicros() - timestamp_us;
+    timestamp_offset_valid_ = true;
+  }
+
+  // Add offset, to get time stamps with the same epoch as the
+  // system monotonic clock, rtc::TimeMicros().
+  timestamp_us += timestamp_offset_;
+
   // Use a temporary buffer to scale
   std::unique_ptr<uint8_t[]> scale_buffer;
   if (IsScreencast()) {
     int scaled_width, scaled_height;
     int desired_screencast_fps =
         capture_format_.get()
             ? VideoFormat::IntervalToFps(capture_format_->interval)
             : kDefaultScreencastFps;
     ComputeScale(captured_frame->width, captured_frame->height,
                  desired_screencast_fps, &scaled_width, &scaled_height);
@@ skipping 152 matching lines @@
                                          adapted_width, adapted_height));
 
   if (!adapted_frame) {
     // TODO(fbarchard): LOG more information about captured frame attributes.
     LOG(LS_ERROR) << "Couldn't convert to I420! "
                   << "From " << ToString(captured_frame) << " To "
                   << cropped_width << " x " << cropped_height;
     return;
   }
 
+  // Overrides the timestamp set by the FrameFactory.
+  // TODO(nisse): Arrange to either get the FrameFactory to set the
+  // timestamp with correct offset, or not set the timestamp at all.
+  adapted_frame->set_timestamp_us(timestamp_us);
+
   OnFrame(this, adapted_frame.get());
   UpdateInputSize(captured_frame);
 }
 
 void VideoCapturer::OnFrame(VideoCapturer* capturer, const VideoFrame* frame) {
   broadcaster_.OnFrame(*frame);

[perkj_webrtc, 2016/04/08 08:22:48]

Unfortunately there are capturers that does not use neither the OnFrameCaptured
or the frame factory. ie- the Chromoting capturer. 

It directly calls  OnFrame:
https://code.google.com/p/chromium/codesearch#chromium/src/remoting/protocol/...

[nisse-webrtc, 2016/04/08 09:15:43]

That code then has to produce the right timestamps. Do you know what chrome's
TimeTicks::Now() produces? For this to work out easily, it has to be the same as
rtc::TimeMicros().

 }
 
 void VideoCapturer::SetCaptureState(CaptureState state) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   if (state == capture_state_) {
     // Don't trigger a state changed callback if the state hasn't changed.
     return;
   }
   capture_state_ = state;
   SignalStateChange(this, capture_state_);
@@ skipping 130 matching lines @@
 void VideoCapturer::UpdateInputSize(const CapturedFrame* captured_frame) {
   // Update stats protected from fetches from different thread.
   rtc::CritScope cs(&frame_stats_crit_);
 
   input_size_valid_ = true;
   input_width_ = captured_frame->width;
   input_height_ = captured_frame->height;
 }
 
 }  // namespace cricket