Use microsecond timestamp in cricket::VideoFrame.

webrtc/media/engine/webrtcvideoframe.cc

 /*
  *  Copyright (c) 2011 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/media/engine/webrtcvideoframe.h"
 
 #include "libyuv/convert.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/media/base/videocapturer.h"
 #include "webrtc/media/base/videocommon.h"
 #include "webrtc/video_frame.h"
 
 using webrtc::kYPlane;
 using webrtc::kUPlane;
 using webrtc::kVPlane;
 
 namespace cricket {
 
-WebRtcVideoFrame::WebRtcVideoFrame():
-    time_stamp_ns_(0),
-    rotation_(webrtc::kVideoRotation_0) {}
+WebRtcVideoFrame::WebRtcVideoFrame()
+    : timestamp_us_(0), rotation_(webrtc::kVideoRotation_0) {}
+
+WebRtcVideoFrame::WebRtcVideoFrame(
+    const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer,
+    webrtc::VideoRotation rotation,
+    int64_t timestamp_us)
+    : video_frame_buffer_(buffer),
+      timestamp_us_(timestamp_us),
+      rotation_(rotation) {}
 
 WebRtcVideoFrame::WebRtcVideoFrame(
     const rtc::scoped_refptr<webrtc::VideoFrameBuffer>& buffer,
     int64_t time_stamp_ns,
     webrtc::VideoRotation rotation)
-    : video_frame_buffer_(buffer),
-      time_stamp_ns_(time_stamp_ns),
-      rotation_(rotation) {
-}
+    : WebRtcVideoFrame(buffer,
+                       rotation,
+                       time_stamp_ns / rtc::kNumNanosecsPerMicrosec) {}
 
 WebRtcVideoFrame::~WebRtcVideoFrame() {}
 
 bool WebRtcVideoFrame::Init(uint32_t format,
                             int w,
                             int h,
                             int dw,
                             int dh,
                             uint8_t* sample,
                             size_t sample_size,
                             int64_t time_stamp_ns,
                             webrtc::VideoRotation rotation) {
   return Reset(format, w, h, dw, dh, sample, sample_size,
-               time_stamp_ns, rotation,
+               time_stamp_ns / rtc::kNumNanosecsPerMicrosec, rotation,
                true /*apply_rotation*/);
 }
 
 bool WebRtcVideoFrame::Init(const CapturedFrame* frame, int dw, int dh,
                             bool apply_rotation) {
   return Reset(frame->fourcc, frame->width, frame->height, dw, dh,
                static_cast<uint8_t*>(frame->data), frame->data_size,
-               frame->time_stamp,
+               frame->time_stamp / rtc::kNumNanosecsPerMicrosec,
                frame->rotation, apply_rotation);
 }
 
 bool WebRtcVideoFrame::InitToBlack(int w, int h,
                                    int64_t time_stamp_ns) {
   InitToEmptyBuffer(w, h, time_stamp_ns);
   return SetToBlack();
 }
 
 int WebRtcVideoFrame::width() const {
@@ skipping 50 matching lines @@
 void* WebRtcVideoFrame::GetNativeHandle() const {
   return video_frame_buffer_ ? video_frame_buffer_->native_handle() : nullptr;
 }
 
 rtc::scoped_refptr<webrtc::VideoFrameBuffer>
 WebRtcVideoFrame::video_frame_buffer() const {
   return video_frame_buffer_;
 }
 
 VideoFrame* WebRtcVideoFrame::Copy() const {
-  WebRtcVideoFrame* new_frame = new WebRtcVideoFrame(
-      video_frame_buffer_, time_stamp_ns_, rotation_);
-  return new_frame;
+  return new WebRtcVideoFrame(video_frame_buffer_, rotation_, timestamp_us_);
 }
 
 size_t WebRtcVideoFrame::ConvertToRgbBuffer(uint32_t to_fourcc,
                                             uint8_t* buffer,
                                             size_t size,
                                             int stride_rgb) const {
   RTC_CHECK(video_frame_buffer_);
   RTC_CHECK(video_frame_buffer_->native_handle() == nullptr);
   return VideoFrame::ConvertToRgbBuffer(to_fourcc, buffer, size, stride_rgb);
 }
 
 bool WebRtcVideoFrame::Reset(uint32_t format,
                              int w,
                              int h,
                              int dw,
                              int dh,
                              uint8_t* sample,
                              size_t sample_size,
-                             int64_t time_stamp_ns,
+                             int64_t timestamp_us,
                              webrtc::VideoRotation rotation,
                              bool apply_rotation) {
   if (!Validate(format, w, h, sample, sample_size)) {
     return false;
   }
   // Translate aliases to standard enums (e.g., IYUV -> I420).
   format = CanonicalFourCC(format);
 
   // Set up a new buffer.
   // TODO(fbarchard): Support lazy allocation.
   int new_width = dw;
   int new_height = dh;
   // If rotated swap width, height.
   if (apply_rotation && (rotation == 90 || rotation == 270)) {
     new_width = dh;
     new_height = dw;
   }
 
-  InitToEmptyBuffer(new_width, new_height,
-                    time_stamp_ns);
+  InitToEmptyBuffer(new_width, new_height);
   rotation_ = apply_rotation ? webrtc::kVideoRotation_0 : rotation;
 
   int horiz_crop = ((w - dw) / 2) & ~1;
   // ARGB on Windows has negative height.
   // The sample's layout in memory is normal, so just correct crop.
   int vert_crop = ((abs(h) - dh) / 2) & ~1;
   // Conversion functions expect negative height to flip the image.
   int idh = (h < 0) ? -dh : dh;
   int r = libyuv::ConvertToI420(
       sample, sample_size,
       GetYPlane(), GetYPitch(),
       GetUPlane(), GetUPitch(),
       GetVPlane(), GetVPitch(),
       horiz_crop, vert_crop,
       w, h,
       dw, idh,
       static_cast<libyuv::RotationMode>(
           apply_rotation ? rotation : webrtc::kVideoRotation_0),
       format);
   if (r) {
     LOG(LS_ERROR) << "Error parsing format: " << GetFourccName(format)
                   << " return code : " << r;
     return false;
   }
+  timestamp_us_ = timestamp_us;
   return true;
 }
 
-VideoFrame* WebRtcVideoFrame::CreateEmptyFrame(
-    int w, int h,
-    int64_t time_stamp_ns) const {
+VideoFrame* WebRtcVideoFrame::CreateEmptyFrame(int w,
+                                               int h,
+                                               int64_t timestamp_us) const {
   WebRtcVideoFrame* frame = new WebRtcVideoFrame();
-  frame->InitToEmptyBuffer(w, h, time_stamp_ns);
+  frame->InitToEmptyBuffer(w, h, rtc::kNumNanosecsPerMicrosec * timestamp_us);
   return frame;
 }
 
+void WebRtcVideoFrame::InitToEmptyBuffer(int w, int h) {
+  video_frame_buffer_ = new rtc::RefCountedObject<webrtc::I420Buffer>(w, h);
+  rotation_ = webrtc::kVideoRotation_0;
+}
+
 void WebRtcVideoFrame::InitToEmptyBuffer(int w, int h,
                                          int64_t time_stamp_ns) {
   video_frame_buffer_ = new rtc::RefCountedObject<webrtc::I420Buffer>(w, h);
-  time_stamp_ns_ = time_stamp_ns;
+  SetTimeStamp(time_stamp_ns);
   rotation_ = webrtc::kVideoRotation_0;
 }
 
 const VideoFrame* WebRtcVideoFrame::GetCopyWithRotationApplied() const {
   // If the frame is not rotated, the caller should reuse this frame instead of
   // making a redundant copy.
   if (rotation() == webrtc::kVideoRotation_0) {
     return this;
   }
 
@@ skipping 10 matching lines @@
   int orig_height = height();
 
   int rotated_width = orig_width;
   int rotated_height = orig_height;
   if (rotation() == webrtc::kVideoRotation_90 ||
       rotation() == webrtc::kVideoRotation_270) {
     rotated_width = orig_height;
     rotated_height = orig_width;
   }
 
-  rotated_frame_.reset(CreateEmptyFrame(rotated_width, rotated_height,
-                                        GetTimeStamp()));
+  rotated_frame_.reset(
+      CreateEmptyFrame(rotated_width, rotated_height, timestamp_us_));
 
   // TODO(guoweis): Add a function in webrtc_libyuv.cc to convert from
   // VideoRotation to libyuv::RotationMode.
   int ret = libyuv::I420Rotate(
       GetYPlane(), GetYPitch(), GetUPlane(), GetUPitch(), GetVPlane(),
       GetVPitch(), rotated_frame_->GetYPlane(), rotated_frame_->GetYPitch(),
       rotated_frame_->GetUPlane(), rotated_frame_->GetUPitch(),
       rotated_frame_->GetVPlane(), rotated_frame_->GetVPitch(),
       orig_width, orig_height,
       static_cast<libyuv::RotationMode>(rotation()));
   if (ret == 0) {
     return rotated_frame_.get();
   }
   return nullptr;
 }
 
 }  // namespace cricket