Correct frame timestamps in VTVideoEncodeAccelerator

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 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/vt_video_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/mac/mac_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 24 matching lines @@
   InProgressFrameEncode(base::TimeDelta rtp_timestamp, base::TimeTicks ref_time)
       : timestamp(rtp_timestamp), reference_time(ref_time) {}
   const base::TimeDelta timestamp;
   const base::TimeTicks reference_time;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InProgressFrameEncode);
 };
 
 struct VTVideoEncodeAccelerator::EncodeOutput {
-  EncodeOutput(VTEncodeInfoFlags info_flags, CMSampleBufferRef sbuf)
-      : info(info_flags), sample_buffer(sbuf, base::scoped_policy::RETAIN) {}
+  EncodeOutput(VTEncodeInfoFlags info_flags,
+               CMSampleBufferRef sbuf,
+               base::TimeDelta timestamp)
+      : info(info_flags),
+        sample_buffer(sbuf, base::scoped_policy::RETAIN),
+        capture_timestamp(timestamp) {}
   const VTEncodeInfoFlags info;
   const base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer;
+  const base::TimeDelta capture_timestamp;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(EncodeOutput);
 };
 
 struct VTVideoEncodeAccelerator::BitstreamBufferRef {
   BitstreamBufferRef(int32_t id,
                      std::unique_ptr<base::SharedMemory> shm,
                      size_t size)
       : id(id), shm(std::move(shm)), size(size) {}
@@ skipping 327 matching lines @@
                                                    OSStatus status,
                                                    VTEncodeInfoFlags info,
                                                    CMSampleBufferRef sbuf) {
   // This function may be called asynchronously, on a different thread from the
   // one that calls VTCompressionSessionEncodeFrame.
   DVLOG(3) << __FUNCTION__;
 
   auto encoder = reinterpret_cast<VTVideoEncodeAccelerator*>(encoder_opaque);
   DCHECK(encoder);
 
-  // Release InProgressFrameEncode, since we don't have support to return
-  // timestamps at this point.
-  std::unique_ptr<InProgressFrameEncode> request(
+  // InProgressFrameEncode holds timestamp information of the encoded frame.
+  std::unique_ptr<InProgressFrameEncode> frame_info(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
-  request.reset();
 
   // EncodeOutput holds onto CMSampleBufferRef when posting task between
   // threads.
-  std::unique_ptr<EncodeOutput> encode_output(new EncodeOutput(info, sbuf));
+  std::unique_ptr<EncodeOutput> encode_output(
+      new EncodeOutput(info, sbuf, frame_info->timestamp));
 
   // This method is NOT called on |encoder_thread_|, so we still need to
   // post a task back to it to do work.
   encoder->encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::CompressionCallbackTask,
                             encoder->encoder_weak_ptr_, status,
                             base::Passed(&encode_output)));
 }
 
 void VTVideoEncodeAccelerator::CompressionCallbackTask(
@@ skipping 24 matching lines @@
     std::unique_ptr<EncodeOutput> encode_output,
     std::unique_ptr<VTVideoEncodeAccelerator::BitstreamBufferRef> buffer_ref) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (encode_output->info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped) {
     DVLOG(2) << " frame dropped";
     client_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id, 0,
-                   false, base::Time::Now() - base::Time()));
+                   false, encode_output->capture_timestamp));
     return;
   }
 
   auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
       CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
           encode_output->sample_buffer.get(), true),
       0));
   const bool keyframe = !CFDictionaryContainsKey(
       sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
 
   size_t used_buffer_size = 0;
   const bool copy_rv = media::video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
   }
   bitrate_adjuster_.Update(used_buffer_size);
 
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id,
-                 used_buffer_size, keyframe, base::Time::Now() - base::Time()));
+                 used_buffer_size, keyframe, encode_output->capture_timestamp));
 }
 
 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyCompressionSession();
 
   CFTypeRef attributes_keys[] = {kCVPixelBufferOpenGLCompatibilityKey,
                                  kCVPixelBufferIOSurfacePropertiesKey,
                                  kCVPixelBufferPixelFormatTypeKey};
@@ skipping 95 matching lines @@
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media