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;
-
-  // 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>();
-
       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