Avoid waiting on the SurfaceTexture until we need to.

media/gpu/avda_codec_image.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/avda_codec_image.h"
 
 #include <string.h>
 
 #include <memory>
 
-#include "base/metrics/histogram_macros.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "media/gpu/avda_shared_state.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_make_current.h"
 
 namespace media {
@@ skipping 196 matching lines @@
   if (update_mode == UpdateMode::DISCARD_CODEC_BUFFER) {
     if (codec_buffer_index_ != kUpdateOnly)
       media_codec_->ReleaseOutputBuffer(codec_buffer_index_, false);
     codec_buffer_index_ = kInvalidCodecBufferIndex;
     return;
   }
 
   DCHECK(update_mode == UpdateMode::RENDER_TO_BACK_BUFFER ||
          update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER);
 
-  // If we've already released to the back buffer, there's nothing left to do.
-  if (codec_buffer_index_ == kUpdateOnly)
-    return;
-
-  media_codec_->ReleaseOutputBuffer(codec_buffer_index_, true);
-  codec_buffer_index_ = kUpdateOnly;
-
-  // If we're using a SurfaceView we're done!
   if (!surface_texture_) {
+    DCHECK(update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER);
+    DCHECK_GE(codec_buffer_index_, 0);
+    media_codec_->ReleaseOutputBuffer(codec_buffer_index_, true);
     codec_buffer_index_ = kInvalidCodecBufferIndex;
     return;
   }
 
-  // This must be synchronous, so wait for OnFrameAvailable.
-  SCOPED_UMA_HISTOGRAM_TIMER("Media.AvdaCodecImage.WaitTimeForFrame");
-  shared_state_->WaitForFrameAvailable();
+  // If we've already released to the back buffer, there's nothing left to do,
+  // but wait for the previously released buffer if necessary.
+  if (codec_buffer_index_ != kUpdateOnly) {
+    DCHECK(surface_texture_);
+    DCHECK_GE(codec_buffer_index_, 0);
+    shared_state_->RenderCodecBufferToSurfaceTexture(media_codec_,
+                                                     codec_buffer_index_);
+    codec_buffer_index_ = kUpdateOnly;
+  }
+
+  // Only wait for the SurfaceTexture update if we're rendering to the front.
+  if (update_mode == UpdateMode::RENDER_TO_FRONT_BUFFER)
+    shared_state_->WaitForFrameAvailable();
 }
 
 void AVDACodecImage::AttachSurfaceTextureToContext() {
   DCHECK(surface_texture_);
 
   // We assume that the currently bound texture is the intended one.
 
   // Attach the surface texture to the first context we're bound on, so that
   // no context switch is needed later.
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
@@ skipping 24 matching lines @@
   if (surface_texture_)
     UpdateSurface(UpdateMode::RENDER_TO_FRONT_BUFFER);
   memcpy(matrix, gl_matrix_, sizeof(gl_matrix_));
 }
 
 bool AVDACodecImage::IsCodecBufferOutstanding() const {
   return codec_buffer_index_ != kInvalidCodecBufferIndex && media_codec_;
 }
 
 }  // namespace media