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"
@@ skipping 202 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);
+  surface_ = strategy_->Initialize(this, config.surface_id);
+  if (surface_.IsEmpty()) {
+    LOG(ERROR) << "Failed to initialize the backing strategy. The returned "
+                  "Java surface is empty.";
+  }
 
-  surface_texture_ = strategy_->CreateSurfaceTexture();
-  on_frame_available_handler_ =
-      new OnFrameAvailableHandler(this, surface_texture_);
+  // TODO(watk,liberato): move this into the strategy.
+  scoped_refptr<gfx::SurfaceTexture> surface_texture =

[liberato (no reviews please), 2016/01/27 16:15:33]

i forgot about the onFrameAvailable listener.  not sure that we'll want to move
it into the strategy (both of them should use it).  comment is fine, though. 
sounds better than "TODO: do something", and there is work to be done here
later.

+      strategy_->GetSurfaceTexture();
+  if (surface_texture) {
+    on_frame_available_handler_ =
+        new OnFrameAvailableHandler(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 246 matching lines @@
             base::Bind(&AndroidVideoDecodeAccelerator::RequestPictureBuffers,
                        weak_this_factory_.GetWeakPtr()));
         return false;
       }
 
       case media::MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
         break;
 
       case media::MEDIA_CODEC_OK:
         DCHECK_GE(buf_index, 0);
-        DVLOG(3) << "AVDA::DequeueOutput: pts:" << presentation_timestamp
+        DVLOG(3) << __FUNCTION__ << ": pts:" << presentation_timestamp
                  << " buf_index:" << buf_index << " offset:" << offset
                  << " size:" << size << " eos:" << eos;
         break;
 
       default:
         NOTREACHED();
         break;
     }
   } while (buf_index < 0);
 
   if (eos) {
-    DVLOG(3) << "AVDA::DequeueOutput: Resetting codec state after EOS";
+    DVLOG(3) << __FUNCTION__ << ": Resetting codec state after EOS";
     ResetCodecState();
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyFlushDone,
                               weak_this_factory_.GetWeakPtr()));
     return false;
   }
 
   // Get the bitstream buffer id from the timestamp.
   auto it = bitstream_buffers_in_decoder_.find(presentation_timestamp);
@@ skipping 16 matching lines @@
             bitstreams_notified_in_advance_.begin(), ++bitstream_it);
         break;
       }
     }
   } else {
     // Normally we assume that the decoder makes at most one output frame for
     // each distinct input timestamp. However MediaCodecBridge uses timestamp
     // correction and provides a non-decreasing timestamp sequence, which might
     // result in timestamp duplicates. Discard the frame if we cannot get the
     // corresponding buffer id.
-    DVLOG(3) << "AVDA::DequeueOutput: Releasing buffer with unexpected PTS: "
+    DVLOG(3) << __FUNCTION__ << ": Releasing buffer with unexpected PTS: "
              << presentation_timestamp;
     media_codec_->ReleaseOutputBuffer(buf_index, false);
   }
 
   // We got a decoded frame, so try for another.
   return true;
 }
 
 void AndroidVideoDecodeAccelerator::SendDecodedFrameToClient(
     int32_t codec_buffer_index,
@@ skipping 17 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);
 
+  const bool allow_overlay = strategy_->PicturesAreOverlayable();
   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());
-
   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));
+      surface_.j_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