Increase cases where back/front buffering early rendering occur.

media/gpu/android_deferred_rendering_backing_strategy.cc

 // Copyright 2015 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/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
@@ skipping 129 matching lines @@
                                   size.width(), size.height(), 1, 0, GL_RGBA,
                                   GL_UNSIGNED_BYTE, gfx::Rect());
 
     // Override the texture's service_id, so that it will use the one that
     // will be / is attached to the SurfaceTexture.
     DCHECK(shared_state_->surface_texture_service_id());
     texture_ref->texture()->SetUnownedServiceId(
         shared_state_->surface_texture_service_id());
 
     static_cast<AVDACodecImage*>(image.get())
-        ->SetTexture(texture_ref->texture());
+        ->set_texture(texture_ref->texture());
   } else {
     // Clear the unowned service_id, so that this texture is no longer going
     // to depend on the surface texture at all.
     texture_ref->texture()->SetUnownedServiceId(0);
   }
 
   // For SurfaceTexture we set the image to UNBOUND so that the implementation
   // will call CopyTexImage, which is where AVDACodecImage updates the
   // SurfaceTexture to the right frame.
   // For SurfaceView we set the image to be BOUND because ScheduleOverlayPlane
@@ skipping 15 matching lines @@
 
   // Notify the AVDACodecImage for picture_buffer that it should use the
   // decoded buffer codec_buf_index to render this frame.
   AVDACodecImage* avda_image =
       shared_state_->GetImageForPicture(picture_buffer.id());
   RETURN_IF_NULL(avda_image);
 
   // Note that this is not a race, since we do not re-use a PictureBuffer
   // until after the CC is done drawing it.
   pictures_out_for_display_.push_back(picture_buffer.id());
-  avda_image->SetMediaCodecBufferIndex(codec_buf_index);
-  avda_image->SetSize(state_provider_->GetSize());
+  avda_image->set_media_codec_buffer_index(codec_buf_index);
+  avda_image->set_size(state_provider_->GetSize());
 
   MaybeRenderEarly();
 }
 
 void AndroidDeferredRenderingBackingStrategy::AssignOnePictureBuffer(
     const media::PictureBuffer& picture_buffer,
     bool have_context) {
   // Attach a GLImage to each texture that will use the surface texture.
   // We use a refptr here in case SetImageForPicture fails.
   scoped_refptr<gpu::gles2::GLStreamTextureImage> gl_image =
@@ skipping 41 matching lines @@
   MaybeRenderEarly();
 }
 
 void AndroidDeferredRenderingBackingStrategy::ReleaseCodecBuffers(
     const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {
   for (const std::pair<int, media::PictureBuffer>& entry : buffers)
     ReleaseCodecBufferForPicture(entry.second);
 }
 
 void AndroidDeferredRenderingBackingStrategy::MaybeRenderEarly() {
-  // See if we can consume the front buffer / render to the SurfaceView.
-  if (pictures_out_for_display_.size() == 1u) {
-    AVDACodecImage* avda_image =
-        shared_state_->GetImageForPicture(*pictures_out_for_display_.begin());
-    RETURN_IF_NULL(avda_image);
-    avda_image->UpdateSurface(
-        AVDACodecImage::UpdateMode::RENDER_TO_FRONT_BUFFER);
-    return;
-  }
-
-  // Back buffer rendering is only available for surface textures.
-  if (!surface_texture_)
+  if (pictures_out_for_display_.empty())
     return;
 
-  // See if the back buffer is free. If so, then render the earliest frame.  The
-  // listing is in render order, so we can just use the first unrendered frame
-  // if there is back buffer space.
+  // See if we can consume the front buffer / render to the SurfaceView. Iterate
+  // in reverse to find the most recent front buffer. If none is found, the
+  // |front_index| will point to the beginning of the array.
+  size_t front_index = pictures_out_for_display_.size() - 1;
   AVDACodecImage* first_renderable_image = nullptr;
-  for (int id : pictures_out_for_display_) {
+  for (int i = front_index; i >= 0; --i) {
+    const int id = pictures_out_for_display_[i];
     AVDACodecImage* avda_image = shared_state_->GetImageForPicture(id);
     if (!avda_image)
       continue;
 
-    // If the back buffer is unavailable, there's nothing left to do.
-    if (avda_image->is_rendered_to_back_buffer())
-      return;
+    // If we find a front buffer, stop and indicate that front buffer rendering
+    // is not possible since another image is already in the front buffer.
+    if (avda_image->was_rendered_to_front_buffer()) {
+      first_renderable_image = nullptr;
+      break;
+    }
 
-    // If the image is rendered to the front buffer or has been dropped, it is
-    // not valid for rendering.
-    if (avda_image->is_rendered())
-      continue;
-
-    if (!first_renderable_image)
-      first_renderable_image = avda_image;
+    // Update the front buffer index as we move along to shorten the number of
+    // candidate images we look at for back buffer rendering.
+    front_index = i;
+    first_renderable_image = avda_image;
   }
 
   if (first_renderable_image) {
     first_renderable_image->UpdateSurface(
-        AVDACodecImage::UpdateMode::RENDER_TO_BACK_BUFFER);
+        AVDACodecImage::UpdateMode::RENDER_TO_FRONT_BUFFER);
   }
+
+  // Back buffer rendering is only available for surface textures. We'll always
+  // have at least one front buffer, so the next buffer must be the backbuffer.
+  size_t backbuffer_index = front_index + 1;
+  if (!surface_texture_ || backbuffer_index >= pictures_out_for_display_.size())
+    return;
+
+  // See if the back buffer is free. If so, then render the frame adjacent to
+  // the front buffer.  The listing is in render order, so we can just use the
+  // first unrendered frame if there is back buffer space.
+  first_renderable_image = shared_state_->GetImageForPicture(
+      pictures_out_for_display_[backbuffer_index]);
+  if (!first_renderable_image ||
+      first_renderable_image->was_rendered_to_back_buffer()) {
+    return;
+  }
+
+  // Due to the loop in the beginning this should never be true.
+  DCHECK(!first_renderable_image->was_rendered_to_front_buffer());
+  first_renderable_image->UpdateSurface(

[liberato (no reviews please), 2016/05/03 15:20:55]

this will force a wait for frame available after your other CL.  unsure if
that's a win or not, especially when we're on a device that often hits the
OnFrameAvailable timeout.  the alternative of waiting during drawing seems
worse, but we might not draw this frame at all and we're holding up frame
delivery and (potentially) the next draw here anyway.

the alternative is to do this only when the signal has arrived or the timeout
has elapsed.  in that case, consider having OnFrameAvailable post a task back to
the main thread to MaybeRenderEarly.

[DaleCurtis, 2016/05/03 21:13:34]

I don't follow. The render to front buffer above always waits since we release
to the front buffer, this on the other hand should release but not wait.

[liberato (no reviews please), 2016/05/03 21:31:49]

hrm, my comment was pretty jumbly.  sorry about that.

my concern is that we'll now incur a WaitForFrameAvailable for frames that we
don't ever draw, and we're still waiting on the critical path.

right now, this tries "render to front buffer" then "render to back buffer". 
however, it might do better to "render to back buffer" and "promote back buffer
to front buffer".  then it's easy to defer the promotion until after the frame
available has happened.

after your other CL (https://codereview.chromium.org/1924973004/), we'll have
that ability pretty easily.

might need to wait for your other CL to land, though.

[DaleCurtis, 2016/05/04 00:01:33]

So you're advocating that in the case where we have neither a front buffer nor a
back buffer, that we only render the back buffer and let the promotion happen
the next time this method is called or during the draw phase.

This seemed reasonable, so I tried it, but it has the opposite of the intended
effect, everything slows down since the MediaCodec is hitting the stalled state
for lack of buffers again.

[liberato (no reviews please), 2016/05/04 00:10:01]

hrm, that's unexpected, since we're still releasing the buffer from media
codec's point of view.  it must be resulting in fewer releases, meaning that
we're spending more time waiting to get the cpu back on the gpu main thread (or
that 10msec DoIOTask poll is too slow) than the frame available timer takes.

oh, well.  thanks for trying it out.

+      AVDACodecImage::UpdateMode::RENDER_TO_BACK_BUFFER);
 }
 
 void AndroidDeferredRenderingBackingStrategy::CodecChanged(
     media::VideoCodecBridge* codec) {
   media_codec_ = codec;
   shared_state_->CodecChanged(codec);
 }
 
 void AndroidDeferredRenderingBackingStrategy::OnFrameAvailable() {
   shared_state_->SignalFrameAvailable();
@@ skipping 133 matching lines @@
         return !feature_info->workarounds().avda_dont_copy_pictures;
       }
     }
   }
 
   // Assume so.
   return true;
 }
 
 }  // namespace media