Use NTP time for video frame timestamp. Add tracing for timestamps.

content/renderer/media/rtc_video_capturer.cc

 // Copyright (c) 2012 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/rtc_video_capturer.h"
 
 #include "base/bind.h"
+#include "base/debug/trace_event.h"
 
 namespace content {
 
 RtcVideoCapturer::RtcVideoCapturer(
     const media::VideoCaptureSessionId id,
     VideoCaptureImplManager* vc_manager,
     bool is_screencast)
     : is_screencast_(is_screencast),
       delegate_(new RtcVideoCaptureDelegate(id, vc_manager)),
       state_(VIDEO_CAPTURE_STATE_STOPPED) {
+  base::Time::Exploded exploded;

[no longer working on chromium, 2013/04/05 08:56:34]

nit, initialize the value to {}

[justinlin, 2013/04/05 19:03:42]

Done.

+  exploded.year = 1900;
+  exploded.month = 1;
+  exploded.day_of_week = 0;
+  exploded.day_of_month = 1;
+  exploded.hour = 0;
+  exploded.minute = 0;
+  exploded.second = 0;
+  exploded.millisecond = 0;
+  ntp_epoch_ = base::Time::FromUTCExploded(exploded);
 }
 
 RtcVideoCapturer::~RtcVideoCapturer() {
   DCHECK(VIDEO_CAPTURE_STATE_STOPPED);
   DVLOG(3) << " RtcVideoCapturer::dtor";
 }
 
 cricket::CaptureState RtcVideoCapturer::Start(
     const cricket::VideoFormat& capture_format) {
   DVLOG(3) << " RtcVideoCapturer::Start ";
@@ skipping 65 matching lines @@
     const media::VideoCapture::VideoFrameBuffer& buf) {
   // Currently, |fourcc| is always I420.
   cricket::CapturedFrame frame;
   frame.width = buf.width;
   frame.height = buf.height;
   frame.fourcc = cricket::FOURCC_I420;
   frame.data_size = buf.buffer_size;
   // cricket::CapturedFrame time is in nanoseconds.
   frame.elapsed_time = (buf.timestamp - start_time_).InMicroseconds() *
       base::Time::kNanosecondsPerMicrosecond;
-  frame.time_stamp = frame.elapsed_time;
+  // Timestamp in NTP time (seconds since 0:00 UTC 1 January 1900) in ms.
+  frame.time_stamp = (buf.timestamp - ntp_epoch_).InMilliseconds();
   frame.data = buf.memory_pointer;
   frame.pixel_height = 1;
   frame.pixel_width = 1;
 
+  TRACE_EVENT_INSTANT2("rtc_video_capturer",
+                       "OnFrameCaptured",
+                       TRACE_EVENT_SCOPE_THREAD,
+                       "elapsed time",
+                       frame.elapsed_time,
+                       "timestamp",
+                       frame.time_stamp);
+
   // This signals to libJingle that a new VideoFrame is available.
   // libJingle have no assumptions on what thread this signal come from.
   SignalFrameCaptured(this, &frame);
 }
 
 void RtcVideoCapturer::OnStateChange(
     RtcVideoCaptureDelegate::CaptureState state) {
   cricket::CaptureState converted_state = cricket::CS_FAILED;
   switch (state) {
     case RtcVideoCaptureDelegate::CAPTURE_STOPPED:
       converted_state = cricket::CS_STOPPED;
       break;
     case RtcVideoCaptureDelegate::CAPTURE_RUNNING:
       converted_state = cricket::CS_RUNNING;
       break;
     case RtcVideoCaptureDelegate::CAPTURE_FAILED:
       converted_state = cricket::CS_FAILED;
       break;
     default:
       NOTREACHED();
       break;
   }
   SignalStateChange(this, converted_state);
 }
 
 }  // namespace content