RTC Video Encoder: Use capturer timestamp

media/gpu/vaapi_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/vaapi_video_encode_accelerator.h"
 
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 537 matching lines @@
           target_data, buffer->shm->size(), &data_size)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed downloading coded buffer");
     return;
   }
 
   DVLOGF(3) << "Returning bitstream buffer "
             << (encode_job->keyframe ? "(keyframe)" : "")
             << " id: " << buffer->id << " size: " << data_size;
 
   child_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_, buffer->id,
-                            data_size, encode_job->keyframe));
+      FROM_HERE,
+      base::Bind(&Client::BitstreamBufferReady, client_, buffer->id, data_size,
+                 encode_job->keyframe, encode_job->timestamp));
 }
 
 void VaapiVideoEncodeAccelerator::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DVLOGF(3) << "Frame timestamp: " << frame->timestamp().InMilliseconds()
             << " force_keyframe: " << force_keyframe;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiVideoEncodeAccelerator::EncodeTask,
                             base::Unretained(this), frame, force_keyframe));
 }
 
-bool VaapiVideoEncodeAccelerator::PrepareNextJob() {
+bool VaapiVideoEncodeAccelerator::PrepareNextJob(base::TimeDelta timestamp) {
   if (available_va_surface_ids_.size() < kMinSurfacesToEncode)
     return false;
 
   DCHECK(!current_encode_job_);
   current_encode_job_.reset(new EncodeJob());
 
   if (!vaapi_wrapper_->CreateCodedBuffer(output_buffer_byte_size_,
                                          &current_encode_job_->coded_buffer)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed creating coded buffer");
     return false;
   }
 
+  current_encode_job_->timestamp = timestamp;
+
   current_encode_job_->input_surface = new VASurface(
       available_va_surface_ids_.back(), coded_size_,
       vaapi_wrapper_->va_surface_format(), va_surface_release_cb_);
   available_va_surface_ids_.pop_back();
 
   current_encode_job_->recon_surface = new VASurface(
       available_va_surface_ids_.back(), coded_size_,
       vaapi_wrapper_->va_surface_format(), va_surface_release_cb_);
   available_va_surface_ids_.pop_back();
 
@@ skipping 15 matching lines @@
       make_linked_ptr(new InputFrameRef(frame, force_keyframe)));
   EncodeFrameTask();
 }
 
 void VaapiVideoEncodeAccelerator::EncodeFrameTask() {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (state_ != kEncoding || encoder_input_queue_.empty())
     return;
 
-  if (!PrepareNextJob()) {
+  if (!PrepareNextJob(encoder_input_queue_.front()->frame->timestamp())) {
     DVLOGF(4) << "Not ready for next frame yet";
     return;
   }
 
   linked_ptr<InputFrameRef> frame_ref = encoder_input_queue_.front();
   encoder_input_queue_.pop();
 
   if (!UploadFrame(frame_ref->frame)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed uploading source frame to HW.");
     return;
@@ skipping 419 matching lines @@
     client_ptr_factory_.reset();
   }
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {}
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {}
 
 }  // namespace media