ReleaseOutputBuffer to surface back and front buffers where possible.

content/common/gpu/media/android_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 58 matching lines @@
     // Return the GL texture target that the PictureBuffer textures use.
     virtual uint32_t GetTextureTarget() const = 0;
 
     // Return the size to use when requesting picture buffers.
     virtual gfx::Size GetPictureBufferSize() const = 0;
 
     // Make the provided PictureBuffer draw the image that is represented by
     // the decoded output buffer at codec_buffer_index.
     virtual void UseCodecBufferForPictureBuffer(
         int32_t codec_buffer_index,
-        const media::PictureBuffer& picture_buffer) = 0;
+        const media::PictureBuffer& picture_buffer,
+        const std::vector<int32_t>& pictures_out_for_display) = 0;

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

couldn't pictures_out_for_display be an implementation detail of the deferred
strategy, rather than passing it around?  i think that it gets all the callbacks
that it needs to keep it up to date.

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

Great suggestion. Done.

 
     // Notify strategy that a picture buffer has been assigned.
     virtual void AssignOnePictureBuffer(
         const media::PictureBuffer& picture_buffer,
         bool have_context) {}
 
     // Notify strategy that a picture buffer has been reused.
     virtual void ReuseOnePictureBuffer(
-        const media::PictureBuffer& picture_buffer) {}
+        const media::PictureBuffer& picture_buffer,
+        const std::vector<int32_t>& pictures_out_for_display) {}
+
+    // Attempts to free up codec output buffers by rendering early.
+    virtual void MaybeRenderEarly(
+        const std::vector<int32_t>& pictures_out_for_display) {}
 
     // Notify strategy that we have a new android MediaCodec instance.  This
     // happens when we're starting up or re-configuring mid-stream.  Any
     // previously provided codec should no longer be referenced.
     virtual void CodecChanged(media::VideoCodecBridge* codec) = 0;
 
     // Notify the strategy that a frame is available.  This callback can happen
     // on any thread at any time.
     virtual void OnFrameAvailable() = 0;
 
@@ skipping 211 matching lines @@
   State state_;
 
   // This map maintains the picture buffers passed to the client for decoding.
   // The key is the picture buffer id.
   OutputBufferMap output_picture_buffers_;
 
   // This keeps the free picture buffer ids which can be used for sending
   // decoded frames to the client.
   std::queue<int32_t> free_picture_ids_;
 
+  // Picture buffer IDs that are out for display. Stored in order of frames as
+  // they are returned from the decoder.
+  std::vector<int32_t> pictures_out_for_display_;
+
   // The low-level decoder which Android SDK provides.
   std::unique_ptr<media::VideoCodecBridge> media_codec_;
 
   // Set to true after requesting picture buffers to the client.
   bool picturebuffers_requested_;
 
   // The resolution of the stream.
   gfx::Size size_;
 
   // Encoded bitstream buffers to be passed to media codec, queued until an
@@ skipping 52 matching lines @@
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 
   friend class AndroidVideoDecodeAcceleratorTest;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_