Introduce webrtc::VideoFrame::timestamp_us, and corresponding constructor.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 1569 matching lines @@
       frame_count_(0),
       cpu_restricted_frame_count_(0),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       parameters_(config, options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
-      last_frame_timestamp_ms_(0) {
+      last_frame_timestamp_us_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
   parameters_.conference_mode = send_params.conference_mode;
 
   sp.GetPrimarySsrcs(&parameters_.config.rtp.ssrcs);
   sp.GetFidSsrcs(parameters_.config.rtp.ssrcs,
                  &parameters_.config.rtp.rtx.ssrcs);
   parameters_.config.rtp.c_name = sp.cname;
   if (rtp_extensions) {
     parameters_.config.rtp.extensions = *rtp_extensions;
   }
@@ skipping 31 matching lines @@
   if (frame_count_ > kMinRequiredFrames) {
     RTC_LOGGED_HISTOGRAM_PERCENTAGE(
         "WebRTC.Video.CpuLimitedResolutionInPercent",
         cpu_restricted_frame_count_ * 100 / frame_count_);
   }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
     const VideoFrame& frame) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
-  webrtc::VideoFrame video_frame(frame.video_frame_buffer(), 0, 0,
-                                 frame.rotation());
+  webrtc::VideoFrame video_frame(frame.video_frame_buffer(),
+                                 frame.rotation(),
+                                 frame.timestamp_us());
+
   rtc::CritScope cs(&lock_);
 
   if (video_frame.width() != last_frame_info_.width ||
       video_frame.height() != last_frame_info_.height ||
       video_frame.rotation() != last_frame_info_.rotation ||
       video_frame.is_texture() != last_frame_info_.is_texture) {
     last_frame_info_.width = video_frame.width();
     last_frame_info_.height = video_frame.height();
     last_frame_info_.rotation = video_frame.rotation();
     last_frame_info_.is_texture = video_frame.is_texture();
     pending_encoder_reconfiguration_ = true;
 
     LOG(LS_INFO) << "Video frame parameters changed: dimensions="
                  << last_frame_info_.width << "x" << last_frame_info_.height
                  << ", rotation=" << last_frame_info_.rotation
                  << ", texture=" << last_frame_info_.is_texture;
   }
 
   if (stream_ == NULL) {
     // Frame input before send codecs are configured, dropping frame.
     return;
   }
 
-  int64_t frame_delta_ms = frame.GetTimeStamp() / rtc::kNumNanosecsPerMillisec;

[nisse-webrtc, 2016/08/26 11:39:51]

A bonus point is that this deletes one of the few uses of GetTimeStamp.

-
-  // frame->GetTimeStamp() is essentially a delta, align to webrtc time
-  if (!first_frame_timestamp_ms_) {
-    first_frame_timestamp_ms_ =
-        rtc::Optional<int64_t>(rtc::TimeMillis() - frame_delta_ms);
-  }
-
-  last_frame_timestamp_ms_ = *first_frame_timestamp_ms_ + frame_delta_ms;
-
-  video_frame.set_render_time_ms(last_frame_timestamp_ms_);
+  last_frame_timestamp_us_ = video_frame.timestamp_us();
 
   if (pending_encoder_reconfiguration_) {
     ReconfigureEncoder();
     pending_encoder_reconfiguration_ = false;
   }
 
   // Not sending, abort after reconfiguration. Reconfiguration should still
   // occur to permit sending this input as quickly as possible once we start
   // sending (without having to reconfigure then).
   if (!sending_) {
@@ skipping 28 matching lines @@
       VideoOptions old_options = parameters_.options;
       parameters_.options.SetAll(*options);
       // Reconfigure encoder settings on the naext frame or stream
       // recreation if the options changed.
       if (parameters_.options != old_options) {
         pending_encoder_reconfiguration_ = true;
       }
     }
 
     if (source_changing) {
-      // Reset timestamps to realign new incoming frames to a webrtc timestamp.
-      // A new source may have a different timestamp delta than the previous
-      // one.
-      first_frame_timestamp_ms_ = rtc::Optional<int64_t>();

[perkj_webrtc, 2016/08/26 15:38:52]

Are you saying that two different implementations of |source| now always must
have the same time  base and that they do in practice? 

Ie, switching from chrome camera - to screen cast and back to another camera? 
That is nice.

[nisse-webrtc, 2016/08/29 07:49:58]

I think so. Everything not using rtc::TimeMicros directly ought to use the
TimestampAligner logic to translate.

We could wait landing until after  https://codereview.chromium.org/2270723002/
(Chrome), if you like.
I think there could be time jumps on the order of a few ms, since capturer
sources may have different delays between attaching the timestamp and getting
here. But just dropping too early frames (which is done downstream) should
handle that well enough, I think.

If we think the black-frame logic will stay here, we could do the frame order
check here as well, since both need the same last_frame_timestamp_us state.

-
       if (source == nullptr && stream_ != nullptr) {
         LOG(LS_VERBOSE) << "Disabling capturer, sending black frame.";
         // Force this black frame not to be dropped due to timestamp order
         // check. As IncomingCapturedFrame will drop the frame if this frame's
         // timestamp is less than or equal to last frame's timestamp, it is
         // necessary to give this black frame a larger timestamp than the
         // previous one.
-        last_frame_timestamp_ms_ += 1;
+        last_frame_timestamp_us_ += rtc::kNumMicrosecsPerMillisec;
         rtc::scoped_refptr<webrtc::I420Buffer> black_buffer(
             webrtc::I420Buffer::Create(last_frame_info_.width,
                                        last_frame_info_.height));
         black_buffer->SetToBlack();
 
         stream_->Input()->IncomingCapturedFrame(webrtc::VideoFrame(
-            black_buffer,  0 /* timestamp (90 kHz) */,
-            last_frame_timestamp_ms_, last_frame_info_.rotation));
+            black_buffer, last_frame_info_.rotation,
+            last_frame_timestamp_us_));
       }
       source_ = source;
     }
   }
 
   // |source_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   if (source_changing && source_) {
     source_->AddOrUpdateSink(this, sink_wants_);
   }
@@ skipping 956 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket