HW Video: Make media::VideoFrame handle the sync point of the compositor as well as webgl

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/filters/gpu_video_decoder.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 407 matching lines @@
     // Texture in display. Postpone deletion until after it's returned to us.
     bool inserted = dismissed_picture_buffers_.insert(std::make_pair(
         id, buffer_to_dismiss)).second;
     DCHECK(inserted);
   }
 }
 
 static void ReadPixelsSyncInner(
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
     uint32 texture_id,
-    const gfx::Rect& visible_rect,
+    const scoped_refptr<VideoFrame>& frame,
     const SkBitmap& pixels,
     base::WaitableEvent* event) {
-  factories->ReadPixels(texture_id, visible_rect, pixels);
+  factories->ReadPixels(texture_id, frame, pixels);
   event->Signal();
 }
 
 static void ReadPixelsSync(
     const scoped_refptr<media::GpuVideoAcceleratorFactories>& factories,
     uint32 texture_id,
-    const gfx::Rect& visible_rect,
+    const scoped_refptr<VideoFrame>& frame,
     const SkBitmap& pixels) {
   base::WaitableEvent event(true, false);
   if (!factories->GetTaskRunner()->PostTask(FROM_HERE,
                                             base::Bind(&ReadPixelsSyncInner,
                                                        factories,
                                                        texture_id,
-                                                       visible_rect,
+                                                       frame,
                                                        pixels,
                                                        &event)))
     return;
   event.Wait();
 }
 
 void GpuVideoDecoder::PictureReady(const media::Picture& picture) {
   DVLOG(3) << "PictureReady()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
@@ skipping 17 matching lines @@
   scoped_refptr<VideoFrame> frame(VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new gpu::MailboxHolder(
           pb.texture_mailbox(), decoder_texture_target_, 0 /* sync_point */)),
       BindToCurrentLoop(base::Bind(&GpuVideoDecoder::ReusePictureBuffer,
                                    weak_this_,
                                    picture.picture_buffer_id())),
       pb.size(),
       visible_rect,
       natural_size,
       timestamp,
-      base::Bind(&ReadPixelsSync, factories_, pb.texture_id(), visible_rect)));
+      base::Bind(&ReadPixelsSync, factories_, pb.texture_id())));
   CHECK_GT(available_pictures_, 0);
   --available_pictures_;
   bool inserted =
       picture_buffers_at_display_.insert(picture.picture_buffer_id()).second;
   DCHECK(inserted);
 
   EnqueueFrameAndTriggerFrameDelivery(frame);
 }
 
 void GpuVideoDecoder::EnqueueFrameAndTriggerFrameDelivery(
@@ skipping 13 matching lines @@
   if (pending_decode_cb_.is_null())
     return;
 
   base::ResetAndReturn(&pending_decode_cb_)
       .Run(kOk, ready_video_frames_.front());
   ready_video_frames_.pop_front();
 }
 
 void GpuVideoDecoder::ReusePictureBuffer(
     int64 picture_buffer_id,
-    scoped_ptr<gpu::MailboxHolder> mailbox_holder) {
+    scoped_ptr<gpu::MailboxHolder> mailbox_holder,
+    const std::vector<uint32>& release_sync_points) {
   DVLOG(3) << "ReusePictureBuffer(" << picture_buffer_id << ")";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (!vda_)
     return;
 
   CHECK(!picture_buffers_at_display_.empty());
 
   size_t num_erased = picture_buffers_at_display_.erase(picture_buffer_id);
   DCHECK(num_erased);
 
   PictureBufferMap::iterator it =
       assigned_picture_buffers_.find(picture_buffer_id);
 
   if (it == assigned_picture_buffers_.end()) {
     // This picture was dismissed while in display, so we postponed deletion.
     it = dismissed_picture_buffers_.find(picture_buffer_id);
     DCHECK(it != dismissed_picture_buffers_.end());
     factories_->DeleteTexture(it->second.texture_id());
     dismissed_picture_buffers_.erase(it);
     return;
   }
 
-  factories_->WaitSyncPoint(mailbox_holder->sync_point);
+  for (size_t i = 0; i < release_sync_points.size(); i++)
+    factories_->WaitSyncPoint(release_sync_points[i]);
+
   ++available_pictures_;
 
   vda_->ReusePictureBuffer(picture_buffer_id);
 }
 
 GpuVideoDecoder::SHMBuffer* GpuVideoDecoder::GetSHM(size_t min_size) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (available_shm_segments_.empty() ||
       available_shm_segments_.back()->size < min_size) {
     size_t size_to_allocate = std::max(min_size, kSharedMemorySegmentBytes);
@@ skipping 93 matching lines @@
     return;
   }
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media