ReleaseOutputBuffer to surface back and front buffers where possible.

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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/common/gpu/media/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 484 matching lines @@
 
   NOTIMPLEMENTED();
   NotifyInitializationComplete(false);
 
 #endif  // !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
 }
 
 void AndroidVideoDecodeAccelerator::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
-  if (state_ == ERROR || state_ == WAITING_FOR_CODEC) {
+  if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
     return;
-  }
 
+  strategy_->MaybeRenderEarly(pictures_out_for_display_);
   bool did_work = QueueInput();
   while (DequeueOutput())
     did_work = true;
+  strategy_->MaybeRenderEarly(pictures_out_for_display_);

[liberato (no reviews please), 2016/04/22 00:51:05]

i see why you'd want to call this periodically, but why twice?

[DaleCurtis, 2016/04/22 01:33:58]

I was thinking that there may be work after DequeueOutput() but after
consideration that case is already covered by SendDecodedFrameToClient().

 
   ManageTimer(did_work || start_timer);
 }
 
 bool AndroidVideoDecodeAccelerator::QueueInput() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::QueueInput");
   base::AutoReset<bool> auto_reset(&defer_errors_, true);
   if (bitstreams_notified_in_advance_.size() > kMaxBitstreamsNotifiedInAdvance)
     return false;
@@ skipping 290 matching lines @@
   free_picture_ids_.pop();
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
 
   const auto& i = output_picture_buffers_.find(picture_buffer_id);
   if (i == output_picture_buffers_.end()) {
     POST_ERROR(PLATFORM_FAILURE,
                "Can't find PictureBuffer id: " << picture_buffer_id);
     return;
   }
 
+  pictures_out_for_display_.push_back(picture_buffer_id);
+
   bool size_changed = false;
   if (i->second.size() != size_) {
     // Size may have changed due to resolution change since the last time this
     // PictureBuffer was used.
     strategy_->UpdatePictureBufferSize(&i->second, size_);
     size_changed = true;
   }
 
   // Connect the PictureBuffer to the decoded frame, via whatever
   // mechanism the strategy likes.
-  strategy_->UseCodecBufferForPictureBuffer(codec_buffer_index, i->second);
+  strategy_->UseCodecBufferForPictureBuffer(codec_buffer_index, i->second,
+                                            pictures_out_for_display_);
 
   const bool allow_overlay = strategy_->ArePicturesOverlayable();
 
   media::Picture picture(picture_buffer_id, bitstream_id, gfx::Rect(size_),
                          allow_overlay);
   picture.set_size_changed(size_changed);
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyPictureReady,
                             weak_this_factory_.GetWeakPtr(), picture));
@@ skipping 68 matching lines @@
   }
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::ReusePictureBuffer(
     int32_t picture_buffer_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   free_picture_ids_.push(picture_buffer_id);
+  pictures_out_for_display_.erase(
+      std::remove(pictures_out_for_display_.begin(),
+                  pictures_out_for_display_.end(), picture_buffer_id),
+      pictures_out_for_display_.end());
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
 
   OutputBufferMap::const_iterator i =
       output_picture_buffers_.find(picture_buffer_id);
   if (i == output_picture_buffers_.end()) {
     POST_ERROR(PLATFORM_FAILURE, "Can't find PictureBuffer id "
                                      << picture_buffer_id);
     return;
   }
 
-  strategy_->ReuseOnePictureBuffer(i->second);
+  strategy_->ReuseOnePictureBuffer(i->second, pictures_out_for_display_);
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DecodeBuffer(media::BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
@@ skipping 412 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace content