RTC Video Encoder: Use capturer timestamp

media/gpu/v4l2_video_encode_accelerator.cc

 // Copyright 2014 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 "media/gpu/v4l2_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 645 matching lines @@
     } else {
       memcpy(target_data, output_data, output_size);
     }
 
     DVLOG(3) << "Dequeue(): returning "
                 "bitstream_buffer_id="
              << output_record.buffer_ref->id << ", size=" << output_size
              << ", key_frame=" << key_frame;
     child_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&Client::BitstreamBufferReady, client_,
-                   output_record.buffer_ref->id, output_size, key_frame));
+        base::Bind(
+            &Client::BitstreamBufferReady, client_,
+            output_record.buffer_ref->id, output_size, key_frame,
+            base::TimeDelta::FromMicroseconds(

[Pawel Osciak, 2016/05/27 04:46:38]

Perhaps we could use Time::FromTimeVal()...

[shenghao, 2016/05/30 09:18:02]

Talked offline. Time::FromTimeVal() does not fit our use case here.

+                dqbuf.timestamp.tv_usec +
+                dqbuf.timestamp.tv_sec * base::Time::kMicrosecondsPerSecond)));
     output_record.at_device = false;
     output_record.buffer_ref.reset();
     free_output_buffers_.push_back(dqbuf.index);
     output_buffer_queued_count_--;
   }
 }
 
 bool V4L2VideoEncodeAccelerator::EnqueueInputRecord() {
   DVLOG(3) << "EnqueueInputRecord()";
   DCHECK(!free_input_buffers_.empty());
   DCHECK(!encoder_input_queue_.empty());
 
   // Enqueue an input (VIDEO_OUTPUT) buffer.
   scoped_refptr<media::VideoFrame> frame = encoder_input_queue_.front();
   const int index = free_input_buffers_.back();
   InputRecord& input_record = input_buffer_map_[index];
   DCHECK(!input_record.at_device);
   struct v4l2_buffer qbuf;
   struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
   memset(&qbuf, 0, sizeof(qbuf));
   memset(qbuf_planes, 0, sizeof(qbuf_planes));
   qbuf.index = index;
   qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   qbuf.m.planes = qbuf_planes;
+  qbuf.timestamp.tv_sec = static_cast<time_t>(frame->timestamp().InSeconds());

[Pawel Osciak, 2016/05/27 04:46:38]

... and Time::ToTimeVal().

[shenghao, 2016/05/30 09:18:02]

Talked offline. Time::ToTimeVal() does not fit our use case here.

+  qbuf.timestamp.tv_usec =
+      frame->timestamp().InMicroseconds() -
+      frame->timestamp().InSeconds() * base::Time::kMicrosecondsPerSecond;
 
   DCHECK_EQ(device_input_format_, frame->format());
   for (size_t i = 0; i < input_planes_count_; ++i) {
     qbuf.m.planes[i].bytesused = base::checked_cast<__u32>(
         media::VideoFrame::PlaneSize(frame->format(), i, input_allocated_size_)
             .GetArea());
 
     switch (input_memory_type_) {
       case V4L2_MEMORY_USERPTR:
         qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
@@ skipping 542 matching lines @@
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace media