AndroidVideoDecodeAccelerator can now render to a SurfaceView

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 "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/gpu_surface_lookup.h"
 #include "content/common/gpu/media/android_copying_backing_strategy.h"
 #include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/base/media_switches.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_decoder_config.h"
 #include "media/video/picture.h"
@@ skipping 185 matching lines @@
   if (!make_context_current_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
   if (!gl_decoder_) {
     LOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
-  strategy_->Initialize(this);
+  if (config.surface_id != VideoDecodeAccelerator::Config::kNullSurfaceID) {
+    DCHECK(UseDeferredRenderingStrategy());
+    surface_view_ =
+        GpuSurfaceLookup::GetInstance()->AcquireJavaSurface(config.surface_id);
+    if (surface_view_.IsEmpty()) {
+      LOG(ERROR) << "Java surface was empty. surface_id: " << config.surface_id;
+      return false;
+    }
+  } else {
+    // Create a detached SurfaceTexture. The backing strategy is responsible
+    // for attaching it. Detaching it will silently fail to delete texture 0.
+    surface_texture_ = gfx::SurfaceTexture::Create(0);
+    surface_texture_->DetachFromGLContext();
+    on_frame_available_handler_ =
+        new OnFrameAvailableHandler(this, surface_texture_);
+  }
 
-  surface_texture_ = strategy_->CreateSurfaceTexture();
-  on_frame_available_handler_ =
-      new OnFrameAvailableHandler(this, surface_texture_);
+  strategy_->Initialize(this, surface_texture_);
 
   // For encrypted streams we postpone configuration until MediaCrypto is
   // available.
   if (is_encrypted_)
     return true;
 
   return ConfigureMediaCodec();
 }
 
 void AndroidVideoDecodeAccelerator::SetCdm(int cdm_id) {
@@ skipping 333 matching lines @@
   if (i == output_picture_buffers_.end()) {
     POST_ERROR(PLATFORM_FAILURE,
                "Can't find PictureBuffer id: " << picture_buffer_id);
     return;
   }
 
   // Connect the PictureBuffer to the decoded frame, via whatever
   // mechanism the strategy likes.
   strategy_->UseCodecBufferForPictureBuffer(codec_buffer_index, i->second);
 
+  // SurfaceView video frames must always be overlayable because that's the only
+  // way to display them.
+  const bool allow_overlay = !surface_view_.IsEmpty();
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyPictureReady,
                             weak_this_factory_.GetWeakPtr(),
                             media::Picture(picture_buffer_id, bitstream_id,
-                                           gfx::Rect(size_), false)));
+                                           gfx::Rect(size_), allow_overlay)));
 }
 
 void AndroidVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (bitstream_buffer.id() != -1 && bitstream_buffer.size() == 0) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                    weak_this_factory_.GetWeakPtr(), bitstream_buffer.id()));
@@ skipping 75 matching lines @@
 }
 
 void AndroidVideoDecodeAccelerator::Flush() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Decode(media::BitstreamBuffer(-1, base::SharedMemoryHandle(), 0));
 }
 
 bool AndroidVideoDecodeAccelerator::ConfigureMediaCodec() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(surface_texture_.get());
   TRACE_EVENT0("media", "AVDA::ConfigureMediaCodec");
 
-  gfx::ScopedJavaSurface surface(surface_texture_.get());
+  gfx::ScopedJavaSurface surface;
+  jobject surface_obj;
+  if (surface_texture_) {

[liberato (no reviews please), 2016/01/26 21:48:45]

it might be simpler to hide all of this inside the deferred strategy, since the
copying strategy won't work with SurfaceViews anyway.

in other words, replace strategy::GetSurfaceTexture with GetScopedJavaSurface,
and let the strategy decide what it wants to do.  the copying strategy will
create an ST like it does now, then wrap it in a scoped java surface.  the
deferred strategy can either create/wrap an ST, or look up and wrap the SV if it
was given a non-null ID in Initialize().

as part of strategy::Initialize, it can be given the surface id directly to use
(or not) as it likes.

all that's left is whether to set allow_overlay, above.  the strategy can just
expose a getter for avda to use.

+    surface = gfx::ScopedJavaSurface(surface_texture_.get());
+    surface_obj = surface.j_surface().obj();
+  } else {
+    DCHECK(!surface_view_.IsEmpty());
+    surface_obj = surface_view_.j_surface().obj();
+  }
 
   jobject media_crypto = media_crypto_ ? media_crypto_->obj() : nullptr;
 
   // |needs_protected_surface_| implies encrypted stream.
   DCHECK(!needs_protected_surface_ || media_crypto);
 
   // Pass a dummy 320x240 canvas size and let the codec signal the real size
   // when it's known from the bitstream.
   media_codec_.reset(media::VideoCodecBridge::CreateDecoder(
-      codec_, needs_protected_surface_, gfx::Size(320, 240),
-      surface.j_surface().obj(), media_crypto));
+      codec_, needs_protected_surface_, gfx::Size(320, 240), surface_obj,
+      media_crypto));
   strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
   if (!media_codec_) {
     LOG(ERROR) << "Failed to create MediaCodec instance.";
     return false;
   }
 
   ManageTimer(true);
   return true;
 }
 
@@ skipping 257 matching lines @@
 
   if (UseDeferredRenderingStrategy()) {
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
         NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
   }
 
   return capabilities;
 }
 
 }  // namespace content