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 72 matching lines @@
       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(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_) {
+    if (picture_buffer_manager_.HasUnrenderedPictures())
+      return false;
+    if (!UpdateSurface())
+      return false;
+  }
+
   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 210 matching lines @@
     const BitstreamBuffer& bitstream_buffer) {
   pending_bitstream_records_.push(BitstreamRecord(bitstream_buffer));
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount",
                  pending_bitstream_records_.size());
 
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::RequestPictureBuffers() {
   if (client_) {
-    client_->ProvidePictureBuffers(
-        kNumPictureBuffers, PIXEL_FORMAT_UNKNOWN, 1,
-        picture_buffer_manager_.GetPictureBufferSize(),
-        picture_buffer_manager_.GetTextureTarget());
+    // Allocate a picture buffer that is the actual frame size.  Note that it
+    // will be an external texture anyway, so it doesn't allocate an image of
+    // that size.  It's important to get the coded size right, so that
+    // VideoLayerImpl doesn't try to scale the texture when building the quad
+    // for it.
+    client_->ProvidePictureBuffers(kNumPictureBuffers, PIXEL_FORMAT_UNKNOWN, 1,
+                                   size_,
+                                   AVDAPictureBufferManager::kTextureTarget);
   }
 }
 
 void AndroidVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<PictureBuffer>& buffers) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(output_picture_buffers_.empty());
   DCHECK(free_picture_ids_.empty());
 
   if (buffers.size() < kNumPictureBuffers) {
     POST_ERROR(INVALID_ARGUMENT, "Not enough picture buffers assigned.");
     return;
   }
 
   const bool have_context = make_context_current_cb_.Run();
   LOG_IF(WARNING, !have_context)
       << "Failed to make GL context current for Assign, continuing.";
 
   for (size_t i = 0; i < buffers.size(); ++i) {
-    if (buffers[i].size() != picture_buffer_manager_.GetPictureBufferSize()) {
-      POST_ERROR(INVALID_ARGUMENT,
-                 "Invalid picture buffer size assigned. Wanted "
-                     << size_.ToString() << ", but got "
-                     << buffers[i].size().ToString());
-      return;
-    }
+    DCHECK(buffers[i].size() == size_);
     int32_t id = buffers[i].id();
     output_picture_buffers_.insert(std::make_pair(id, buffers[i]));
     free_picture_ids_.push(id);
 
     picture_buffer_manager_.AssignOnePictureBuffer(buffers[i], have_context);
   }
   TRACE_COUNTER1("media", "AVDA::FreePictureIds", free_picture_ids_.size());
   DoIOTask(true);
 }
 
@@ skipping 307 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_) {
+    pending_surface_id_.reset();
+    return;
+  }
+
+  // Surface changes never take effect 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 fullscreen. 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.
+    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 fullscreen notification may come in before this point.
+    if (pending_surface_id_)
+      DCHECK_EQ(pending_surface_id_.value(), SurfaceManager::kNoSurfaceID);
+
+    pending_surface_id_ = SurfaceManager::kNoSurfaceID;
+    UpdateSurface();
+    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 253 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);
 }
 
+bool AndroidVideoDecodeAccelerator::UpdateSurface() {
+  DCHECK(pending_surface_id_);
+  DCHECK_NE(surface_id_, pending_surface_id_.value());
+
+  // Ensure the current context is active when switching surfaces; we may need
+  // to create a new texture.
+  if (!make_context_current_cb_.Run()) {
+    POST_ERROR(PLATFORM_FAILURE,
+               "Failed to make this decoder's GL context current when "
+               "switching surfaces.");
+    return false;
+  }
+
+  surface_id_ = pending_surface_id_.value();
+  codec_config_->surface_ =
+      picture_buffer_manager_.Initialize(pending_surface_id_.value());
+  if (codec_config_->surface_.IsEmpty()) {
+    POST_ERROR(PLATFORM_FAILURE, "An error occurred while switching surfaces.");
+    return false;
+  }
+
+  if (media_codec_ &&
+      !media_codec_->SetSurface(codec_config_->surface_.j_surface().obj())) {
+    POST_ERROR(PLATFORM_FAILURE, "MediaCodec failed to switch surfaces.");
+    return false;
+  }
+
+  pending_surface_id_.reset();
+  return true;
+}
+
 }  // namespace media