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

webrtc/common_video/video_frame.cc

 /*
  *  Copyright (c) 2012 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.
  */
 
 #include "webrtc/video_frame.h"
 
 #include <string.h>
 
 #include <algorithm>  // swap
 
 #include "webrtc/base/bind.h"
 #include "webrtc/base/checks.h"
 
 namespace webrtc {
 
 // FFmpeg's decoder, used by H264DecoderImpl, requires up to 8 bytes padding due
 // to optimized bitstream readers. See avcodec_decode_video2.
 const size_t EncodedImage::kBufferPaddingBytesH264 = 8;
 
 VideoFrame::VideoFrame()
     : video_frame_buffer_(nullptr),
-      timestamp_(0),
+      timestamp_rtp_(0),
       ntp_time_ms_(0),
-      render_time_ms_(0),
+      timestamp_us_(0),
       rotation_(kVideoRotation_0) {}
 
 VideoFrame::VideoFrame(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
+                       webrtc::VideoRotation rotation,
+                       int64_t timestamp_us)
+    : video_frame_buffer_(buffer),
+      timestamp_rtp_(0),
+      ntp_time_ms_(0),
+      timestamp_us_(timestamp_us),
+      rotation_(rotation) {}
+
+VideoFrame::VideoFrame(const rtc::scoped_refptr<VideoFrameBuffer>& buffer,
                        uint32_t timestamp,
                        int64_t render_time_ms,
                        VideoRotation rotation)
     : video_frame_buffer_(buffer),
-      timestamp_(timestamp),
+      timestamp_rtp_(timestamp),
       ntp_time_ms_(0),
-      render_time_ms_(render_time_ms),
+      timestamp_us_(render_time_ms * rtc::kNumMicrosecsPerMillisec),
       rotation_(rotation) {
   RTC_DCHECK(buffer);
 }
 
 void VideoFrame::CreateEmptyFrame(int width,
                                   int height,
                                   int stride_y,
                                   int stride_u,
                                   int stride_v) {
   const int half_width = (width + 1) / 2;
   RTC_DCHECK_GT(width, 0);
   RTC_DCHECK_GT(height, 0);
   RTC_DCHECK_GE(stride_y, width);
   RTC_DCHECK_GE(stride_u, half_width);
   RTC_DCHECK_GE(stride_v, half_width);
 
   // Creating empty frame - reset all values.
-  timestamp_ = 0;
+  timestamp_rtp_ = 0;
   ntp_time_ms_ = 0;
-  render_time_ms_ = 0;
+  timestamp_us_ = 0;
   rotation_ = kVideoRotation_0;
 
   // Allocate a new buffer.
   video_frame_buffer_ = I420Buffer::Create(
       width, height, stride_y, stride_u, stride_v);
 }
 
 void VideoFrame::CreateFrame(const uint8_t* buffer_y,
                              const uint8_t* buffer_u,
                              const uint8_t* buffer_v,
@@ skipping 32 matching lines @@
   ShallowCopy(videoFrame);
 
   // If backed by a plain memory buffer, create a new, non-shared, copy.
   if (video_frame_buffer_ && !video_frame_buffer_->native_handle()) {
     video_frame_buffer_ = I420Buffer::Copy(video_frame_buffer_);
   }
 }
 
 void VideoFrame::ShallowCopy(const VideoFrame& videoFrame) {
   video_frame_buffer_ = videoFrame.video_frame_buffer();
-  timestamp_ = videoFrame.timestamp_;
+  timestamp_rtp_ = videoFrame.timestamp_rtp_;
   ntp_time_ms_ = videoFrame.ntp_time_ms_;
-  render_time_ms_ = videoFrame.render_time_ms_;
+  timestamp_us_ = videoFrame.timestamp_us_;
   rotation_ = videoFrame.rotation_;
 }
 
 // TODO(nisse): Delete. Besides test code, only one use, in
 // webrtcvideoengine2.cc:CreateBlackFrame.
 int VideoFrame::allocated_size(PlaneType type) const {
   const int plane_height = (type == kYPlane) ? height() : (height() + 1) / 2;
   int stride;
   switch (type) {
     case kYPlane:
@@ skipping 41 matching lines @@
     case kVideoCodecULPFEC:
     case kVideoCodecGeneric:
     case kVideoCodecUnknown:
       return 0;
   }
   RTC_NOTREACHED();
   return 0;
 }
 
 }  // namespace webrtc