Use MediaCodec.setOutputSurface() for fullscreen transitions on M.

media/gpu/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 "media/gpu/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 151 matching lines @@
     if (timer_avda_instances_.empty())
       io_timer_.Stop();
   }
 
   // |avda| would like to use |surface_id|.  If it is not busy, then mark it
   // as busy and return true.  If it is busy, then replace any existing waiter,
   // make |avda| the current waiter, and return false.  Any existing waiter
   // is assumed to be on the way out, so we fail its allocation request.
   bool AllocateSurface(int surface_id, AndroidVideoDecodeAccelerator* avda) {
     // Nobody has to wait for no surface.
-    if (surface_id == AndroidVideoDecodeAccelerator::Config::kNoSurfaceID)
+    if (surface_id == SurfaceManager::kNoSurfaceID)
       return true;
 
     auto iter = surface_waiter_map_.find(surface_id);
     if (iter == surface_waiter_map_.end()) {
       // SurfaceView isn't allocated.  Succeed.
       surface_waiter_map_[surface_id].owner = avda;
       return true;
     }
 
     // SurfaceView is already allocated.
@@ skipping 35 matching lines @@
     // Promote |waiter| to be the owner.
     iter->second.owner = waiter;
     iter->second.waiter = nullptr;
     waiter->OnSurfaceAvailable(true);
   }
 
   // On low end devices (< KitKat is always low-end due to buggy MediaCodec),
   // defer the surface creation until the codec is actually used if we know no
   // software fallback exists.
   bool ShouldDeferSurfaceCreation(int surface_id, VideoCodec codec) {
-    return surface_id == AndroidVideoDecodeAccelerator::Config::kNoSurfaceID &&
-           codec == kCodecH264 &&
+    return surface_id == SurfaceManager::kNoSurfaceID && codec == kCodecH264 &&
            g_avda_codec_allocator.Get().IsAnyRegisteredAVDA() &&
            (base::android::BuildInfo::GetInstance()->sdk_int() <= 18 ||
             base::SysInfo::IsLowEndDevice());
   }
 
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDAManager>;
 
   AVDAManager() {}
   ~AVDAManager() { NOTREACHED(); }
@@ skipping 62 matching lines @@
 AndroidVideoDecodeAccelerator::BitstreamRecord::~BitstreamRecord() {}
 
 AndroidVideoDecodeAccelerator::AndroidVideoDecodeAccelerator(
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const GetGLES2DecoderCallback& get_gles2_decoder_cb)
     : client_(NULL),
       make_context_current_cb_(make_context_current_cb),
       get_gles2_decoder_cb_(get_gles2_decoder_cb),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
+      picture_buffer_manager_(this),
       drain_type_(DRAIN_TYPE_NONE),
       media_drm_bridge_cdm_context_(nullptr),
       cdm_registration_id_(0),
       pending_input_buf_index_(-1),
       error_sequence_token_(0),
       defer_errors_(false),
       deferred_initialization_pending_(false),
       codec_needs_reset_(false),
       defer_surface_creation_(false),
+      surface_id_(SurfaceManager::kNoSurfaceID),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_manager.Get().StopTimer(this);
   g_avda_codec_allocator.Get().StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 58 matching lines @@
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     DLOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
+  // If SetSurface() was called before initialize, pick up the surface.
+  if (pending_surface_id_) {
+    surface_id_ = pending_surface_id_.value();
+    pending_surface_id_.reset();
+  }
+
   // If we're low on resources, we may decide to defer creation of the surface
   // until the codec is actually used.
-  if (g_avda_manager.Get().ShouldDeferSurfaceCreation(config_.surface_id,
+  if (g_avda_manager.Get().ShouldDeferSurfaceCreation(surface_id_,
                                                       codec_config_->codec_)) {
     DCHECK(!deferred_initialization_pending_);
 
     // We should never be here if a SurfaceView is required.
-    DCHECK_EQ(config_.surface_id, Config::kNoSurfaceID);
-    DCHECK(g_avda_manager.Get().AllocateSurface(config_.surface_id, this));
+    DCHECK_EQ(surface_id_, SurfaceManager::kNoSurfaceID);
+    DCHECK(g_avda_manager.Get().AllocateSurface(surface_id_, this));
 
     defer_surface_creation_ = true;
     NotifyInitializationComplete(true);
     return true;
   }
 
   // We signaled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
   if (config_.is_encrypted && !deferred_initialization_pending_) {
     DLOG(ERROR) << "Deferred initialization must be used for encrypted streams";
     return false;
   }
 
-  if (g_avda_manager.Get().AllocateSurface(config_.surface_id, this)) {
+  if (g_avda_manager.Get().AllocateSurface(surface_id_, this)) {
     // We have successfully owned the surface, so finish initialization now.
     return InitializePictureBufferManager();
   }
 
   // We have to wait for some other AVDA instance to free up the surface.
   // OnSurfaceAvailable will be called when it's available.
   return true;
 }
 
 void AndroidVideoDecodeAccelerator::OnSurfaceAvailable(bool success) {
   DCHECK(deferred_initialization_pending_);
   DCHECK(!defer_surface_creation_);
 
   if (!success || !InitializePictureBufferManager()) {
     NotifyInitializationComplete(false);
     deferred_initialization_pending_ = false;
   }
 }
 
 bool AndroidVideoDecodeAccelerator::InitializePictureBufferManager() {
   if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
-  codec_config_->surface_ =
-      picture_buffer_manager_.Initialize(this, config_.surface_id);
+  codec_config_->surface_ = picture_buffer_manager_.Initialize(surface_id_);
   if (codec_config_->surface_.IsEmpty())
     return false;
 
   on_destroying_surface_cb_ =
       base::Bind(&AndroidVideoDecodeAccelerator::OnDestroyingSurface,
                  weak_this_factory_.GetWeakPtr());
   AVDASurfaceTracker::GetInstance()->RegisterOnDestroyingSurfaceCallback(
       on_destroying_surface_cb_);
 
   if (!g_avda_codec_allocator.Get().StartThread(this))
@@ skipping 186 matching lines @@
   if (picturebuffers_requested_ && output_picture_buffers_.empty() &&
       !IsDrainingForResetOrDestroy()) {
     return false;
   }
   if (!output_picture_buffers_.empty() && free_picture_ids_.empty() &&
       !IsDrainingForResetOrDestroy()) {
     // Don't have any picture buffer to send. Need to wait.
     return false;
   }
 
+  // If we're waiting to switch surfaces pause output release until we have all
+  // picture buffers returned. This is so we can ensure the right flags are set
+  // on the picture buffers returned to the client.
+  if (pending_surface_id_) {
+    DCHECK_GE(base::android::BuildInfo::GetInstance()->sdk_int(), 23);
+    if (picture_buffer_manager_.ArePicturesOutstanding())
+      return false;
+    surface_id_ = pending_surface_id_.value();
+    codec_config_->surface_ =
+        picture_buffer_manager_.Initialize(pending_surface_id_.value());
+    media_codec_->SetSurface(codec_config_->surface_.j_surface().obj());
+    pending_surface_id_.reset();
+  }
+
   bool eos = false;
   base::TimeDelta presentation_timestamp;
   int32_t buf_index = 0;
   do {
     size_t offset = 0;
     size_t size = 0;
 
     TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutput");
     MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut, &buf_index, &offset, &size, &presentation_timestamp,
@@ skipping 567 matching lines @@
     // Postpone ResetCodecState() after the drain.
     StartCodecDrain(DRAIN_FOR_RESET);
   } else {
     ResetCodecState();
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                               weak_this_factory_.GetWeakPtr()));
   }
 }
 
+void AndroidVideoDecodeAccelerator::SetSurface(int32_t surface_id) {
+  if (surface_id == surface_id_)
+    return;
+
+  // Surface changes never take affect immediately, they will be handled during
+  // DequeOutput() once we get to a good switch point or immediately during an
+  // OnDestroyingSurface() call.
+  pending_surface_id_ = surface_id;
+}
+
 void AndroidVideoDecodeAccelerator::Destroy() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   picture_buffer_manager_.Destroy(output_picture_buffers_);
 
   client_ = nullptr;
 
   // Some VP8 files require a complete MediaCodec drain before we can call
   // MediaCodec.flush() or MediaCodec.release(). http://crbug.com/598963. In
@@ skipping 13 matching lines @@
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!on_destroying_surface_cb_.is_null()) {
     AVDASurfaceTracker::GetInstance()->UnregisterOnDestroyingSurfaceCallback(
         on_destroying_surface_cb_);
   }
 
   // We no longer care about |surface_id|, in case we did before.  It's okay
   // if we have no surface and/or weren't the owner or a waiter.
-  g_avda_manager.Get().DeallocateSurface(config_.surface_id, this);
+  g_avda_manager.Get().DeallocateSurface(surface_id_, this);
 
   // Note that async codec construction might still be in progress.  In that
   // case, the codec will be deleted when it completes once we invalidate all
   // our weak refs.
   weak_this_factory_.InvalidateWeakPtrs();
   if (media_codec_) {
     g_avda_manager.Get().StopTimer(this);
     ReleaseMediaCodec();
   }
 
@@ skipping 13 matching lines @@
 base::WeakPtr<gpu::gles2::GLES2Decoder>
 AndroidVideoDecodeAccelerator::GetGlDecoder() const {
   return get_gles2_decoder_cb_.Run();
 }
 
 void AndroidVideoDecodeAccelerator::OnDestroyingSurface(int surface_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::OnDestroyingSurface");
   DVLOG(1) << __FUNCTION__ << " surface_id: " << surface_id;
 
-  if (surface_id != config_.surface_id)
+  if (surface_id != surface_id_)
     return;
 
+  // If the API is available avoid having to restart the decoder in order to
+  // leave full screen. If we don't clear the surface immediately during this
+  // callback, the MediaCodec will throw an error as the surface is destroyed.
+  if (base::android::BuildInfo::GetInstance()->sdk_int() >= 23) {
+    // Since we can't wait for a transition, we must invalidate all outstanding
+    // picture buffers to avoid putting the GL system in a broken state.

[liberato (no reviews please), 2016/11/03 20:51:04]

we can almost un-overlay these things in the overlay candidate validator, except
that we'd have to ask GLStreamTextureImage a question.  that's likely a
performance problem, unfortunately.

if we could, somehow, fail the overlay promotion, then it would draw in the
normal path.

i'll give it some thought.  it'll probably turn out not to be worth the effort,
since DS will avoid it altogether.

+    picture_buffer_manager_.ReleaseCodecBuffers(output_picture_buffers_);
+
+    // Switch away from the surface being destroyed to a surface texture.
+    DCHECK_NE(surface_id_, SurfaceManager::kNoSurfaceID);
+
+    // The leaving full screen notification may come in before this point, so
+    // clear it if necessary.
+    if (pending_surface_id_) {

[liberato (no reviews please), 2016/11/03 20:51:04]

if it comes in later, then we might already be using surface texture.  in that
case, SetSurface should probably notice that we're already using surface texture
and not set |pending_surface_id_|.  otherwise, DequeueOutput will wait for
outstanding buffers.

[DaleCurtis, 2016/11/04 01:07:22]

This case is already handled in SetSurface and here?

+      DCHECK_EQ(pending_surface_id_.value(), SurfaceManager::kNoSurfaceID);
+      pending_surface_id_.reset();
+    }
+
+    surface_id_ = SurfaceManager::kNoSurfaceID;
+    codec_config_->surface_ =
+        picture_buffer_manager_.Initialize(SurfaceManager::kNoSurfaceID);
+    if (media_codec_)
+      media_codec_->SetSurface(codec_config_->surface_.j_surface().obj());
+    return;
+  }
+
   // If we're currently asynchronously configuring a codec, it will be destroyed
   // when configuration completes and it notices that |state_| has changed to
   // SURFACE_DESTROYED.
   state_ = SURFACE_DESTROYED;
   if (media_codec_) {
     ReleaseMediaCodec();
     picture_buffer_manager_.CodecChanged(media_codec_.get());
   }
   // If we're draining, signal completion now because the drain can no longer
   // proceed.
@@ skipping 254 matching lines @@
 
 bool AndroidVideoDecodeAccelerator::IsMediaCodecSoftwareDecodingForbidden()
     const {
   // Prevent MediaCodec from using its internal software decoders when we have
   // more secure and up to date versions in the renderer process.
   return !config_.is_encrypted && (codec_config_->codec_ == kCodecVP8 ||
                                    codec_config_->codec_ == kCodecVP9);
 }
 
 }  // namespace media