Decouple capture timestamp and reference time

content/browser/renderer_host/media/video_capture_device_client.cc

 // Copyright 2015 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/browser/renderer_host/media/video_capture_device_client.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 67 matching lines @@
   // This should be on the platform auxiliary thread since
   // |external_jpeg_decoder_| need to be destructed on the same thread as
   // OnIncomingCapturedData.
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedData(
     const uint8_t* data,
     int length,
     const VideoCaptureFormat& frame_format,
     int rotation,
-    const base::TimeTicks& timestamp) {
+    base::TimeTicks reference_time,
+    base::TimeDelta timestamp) {
   TRACE_EVENT0("video", "VideoCaptureDeviceClient::OnIncomingCapturedData");
   DCHECK_EQ(media::PIXEL_STORAGE_CPU, frame_format.pixel_storage);
 
   if (last_captured_pixel_format_ != frame_format.pixel_format) {
     OnLog("Pixel format: " +
           media::VideoPixelFormatToString(frame_format.pixel_format));
     last_captured_pixel_format_ = frame_format.pixel_format;
 
     if (frame_format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
         !external_jpeg_decoder_initialized_) {
@@ skipping 118 matching lines @@
   DCHECK_GE(static_cast<size_t>(length), frame_format.ImageAllocationSize());
 
   if (external_jpeg_decoder_) {
     const VideoCaptureGpuJpegDecoder::STATUS status =
         external_jpeg_decoder_->GetStatus();
     if (status == VideoCaptureGpuJpegDecoder::FAILED) {
       external_jpeg_decoder_.reset();
     } else if (status == VideoCaptureGpuJpegDecoder::INIT_PASSED &&
         frame_format.pixel_format == media::PIXEL_FORMAT_MJPEG &&
         rotation == 0 && !flip) {
-      external_jpeg_decoder_->DecodeCapturedData(data, length, frame_format,
-                                                 timestamp, std::move(buffer));
+      // TODO(qiangchen): Pass timestamp into DecodeCapturedData.
+      external_jpeg_decoder_->DecodeCapturedData(
+          data, length, frame_format, reference_time, std::move(buffer));
       return;
     }
   }
 
   if (libyuv::ConvertToI420(data,
                             length,
                             y_plane_data,
                             yplane_stride,
                             u_plane_data,
                             uv_plane_stride,
                             v_plane_data,
                             uv_plane_stride,
                             crop_x,
                             crop_y,
                             frame_format.frame_size.width(),
                             (flip ? -1 : 1) * frame_format.frame_size.height(),
                             new_unrotated_width,
                             new_unrotated_height,
                             rotation_mode,
                             origin_colorspace) != 0) {
     DLOG(WARNING) << "Failed to convert buffer's pixel format to I420 from "
                   << media::VideoPixelFormatToString(frame_format.pixel_format);
     return;
   }
 
   const VideoCaptureFormat output_format = VideoCaptureFormat(
       dimensions, frame_format.frame_rate,
       media::PIXEL_FORMAT_I420, output_pixel_storage);
-  OnIncomingCapturedBuffer(std::move(buffer), output_format, timestamp);
+  OnIncomingCapturedBuffer(std::move(buffer), output_format, reference_time,
+                           timestamp);
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ReserveOutputBuffer(
     const gfx::Size& frame_size,
     media::VideoPixelFormat pixel_format,
     media::VideoPixelStorage pixel_storage) {
   DCHECK_GT(frame_size.width(), 0);
   DCHECK_GT(frame_size.height(), 0);
   // Currently, only I420 pixel format is supported.
@@ skipping 12 matching lines @@
   }
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
     return nullptr;
   return base::WrapUnique<Buffer>(
       new AutoReleaseBuffer(buffer_pool_, buffer_id));
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedBuffer(
     std::unique_ptr<Buffer> buffer,
     const VideoCaptureFormat& frame_format,
-    const base::TimeTicks& timestamp) {
+    base::TimeTicks reference_time,
+    base::TimeDelta timestamp) {
   // Currently, only I420 pixel format is supported.
   DCHECK_EQ(media::PIXEL_FORMAT_I420, frame_format.pixel_format);
 
   scoped_refptr<VideoFrame> frame;
   switch (frame_format.pixel_storage) {
     case media::PIXEL_STORAGE_GPUMEMORYBUFFER: {
       // Create a VideoFrame to set the correct storage_type and pixel_format.
       gfx::GpuMemoryBufferHandle handle;
       frame = VideoFrame::WrapExternalYuvGpuMemoryBuffers(
           media::PIXEL_FORMAT_I420, frame_format.frame_size,
           gfx::Rect(frame_format.frame_size), frame_format.frame_size, 0, 0, 0,
           reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kYPlane)),
           reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kUPlane)),
           reinterpret_cast<uint8_t*>(buffer->data(media::VideoFrame::kVPlane)),
-          handle, handle, handle, base::TimeDelta());
+          handle, handle, handle, timestamp);
       break;
     }
     case media::PIXEL_STORAGE_CPU:
       frame = VideoFrame::WrapExternalSharedMemory(
           media::PIXEL_FORMAT_I420, frame_format.frame_size,
           gfx::Rect(frame_format.frame_size), frame_format.frame_size,
           reinterpret_cast<uint8_t*>(buffer->data()),
           VideoFrame::AllocationSize(media::PIXEL_FORMAT_I420,
                                      frame_format.frame_size),
-          base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
+          base::SharedMemory::NULLHandle(), 0u, timestamp);
       break;
   }
   if (!frame)
     return;
   frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                frame_format.frame_rate);
-  OnIncomingCapturedVideoFrame(std::move(buffer), frame, timestamp);
+  OnIncomingCapturedVideoFrame(std::move(buffer), frame, reference_time);
 }
 
 void VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     std::unique_ptr<Buffer> buffer,
     const scoped_refptr<VideoFrame>& frame,
-    const base::TimeTicks& timestamp) {
+    base::TimeTicks reference_time) {
+  // TODO(qiangchen): Dive into DoIncomingCapturedVideoFrameOnIOThread to
+  // process timestamp.
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
+      BrowserThread::IO, FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
-          controller_,
-          base::Passed(&buffer),
-          frame,
-          timestamp));
+          controller_, base::Passed(&buffer), frame, reference_time));
 }
 
 std::unique_ptr<media::VideoCaptureDevice::Client::Buffer>
 VideoCaptureDeviceClient::ResurrectLastOutputBuffer(
     const gfx::Size& dimensions,
     media::VideoPixelFormat format,
     media::VideoPixelStorage storage) {
   const int buffer_id =
       buffer_pool_->ResurrectLastForProducer(dimensions, format, storage);
   if (buffer_id == VideoCaptureBufferPool::kInvalidId)
@@ skipping 68 matching lines @@
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kUPlane));
       *v_plane_data =
           reinterpret_cast<uint8_t*>(buffer->data(VideoFrame::kVPlane));
       return buffer;
   }
   NOTREACHED();
   return std::unique_ptr<Buffer>();
 }
 
 }  // namespace content