Serialize usage of SurfaceView between AVDA instances.

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 231 matching lines @@
       io_timer_.Stop();
   }
 
   // Eventually, we should run the timer on this thread.  For now, we just keep
   // it as a convenience for construction.
   scoped_refptr<base::SingleThreadTaskRunner> ConstructionTaskRunner() {
     DCHECK(thread_checker_.CalledOnValidThread());
     return construction_thread_.task_runner();
   }
 
+  // |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)
+      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.
+    if (iter->second.waiter) {
+      // Some other AVDA is waiting.  |avda| will replace it, so notify it
+      // that it will fail.
+      iter->second.waiter->OnSurfaceAvailable(false);
+      iter->second.waiter = nullptr;
+    }
+
+    // |avda| is now waiting.
+    iter->second.waiter = avda;
+    return false;
+  }
+
+  // Clear any waiting request for |surface_id| by |avda|.  It is okay if
+  // |waiter| is not waiting and/or isn't the owner of |surface_id|.
+  void DeallocateSurface(int surface_id, AndroidVideoDecodeAccelerator* avda) {
+    SurfaceWaiterMap::iterator iter = surface_waiter_map_.find(surface_id);
+    if (iter == surface_waiter_map_.end())
+      return;
+
+    // If |avda| was waiting, then remove it without OnSurfaceAvailable.
+    if (iter->second.waiter == avda)
+      iter->second.waiter = nullptr;
+
+    // If |avda| is the owner, then let the waiter have it.
+    if (iter->second.owner != avda)
+      return;
+
+    AndroidVideoDecodeAccelerator* waiter = iter->second.waiter;
+    if (!waiter) {
+      // No waiter -- remove the record and return explicitly since |iter| is
+      // no longer valid.
+      surface_waiter_map_.erase(iter);
+      return;
+    }
+
+    // Promote |waiter| to be the owner.
+    iter->second.owner = waiter;
+    iter->second.waiter = nullptr;
+    waiter->OnSurfaceAvailable(true);
+  }
+
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDATimerManager>;
 
   AVDATimerManager() : construction_thread_("AVDAThread") {}
   ~AVDATimerManager() { NOTREACHED(); }
 
   void RunTimer() {
     {
       // Call out to all AVDA instances, some of which may attempt to remove
       // themselves from the list during this operation; those removals will be
@@ skipping 11 matching lines @@
     // TODO(dalecurtis): We may want to consider chunking this if task execution
     // takes too long for the combined timer.
   }
 
   // All AVDA instances that would like us to poll DoIOTask.
   std::set<AndroidVideoDecodeAccelerator*> timer_avda_instances_;
 
   // All AVDA instances that might like to use the construction thread.
   std::set<AndroidVideoDecodeAccelerator*> thread_avda_instances_;
 
+  struct OwnerRecord {
+    AndroidVideoDecodeAccelerator* owner = nullptr;
+    AndroidVideoDecodeAccelerator* waiter = nullptr;
+  };
+  // [surface id] = OwnerRecord for that surface.
+  using SurfaceWaiterMap = std::map<int, OwnerRecord>;
+  SurfaceWaiterMap surface_waiter_map_;
+
   // Since we can't delete while iterating when using a set, defer erasure until
   // after iteration complete.
   bool timer_running_ = false;
   std::set<AndroidVideoDecodeAccelerator*> pending_erase_;
 
   // Repeating timer responsible for draining pending IO to the codecs.
   base::RepeatingTimer io_timer_;
 
   base::Thread construction_thread_;
 
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(AVDATimerManager);
 };
 
 static base::LazyInstance<AVDATimerManager>::Leaky g_avda_timer =
     LAZY_INSTANCE_INITIALIZER;
 
 AndroidVideoDecodeAccelerator::CodecConfig::CodecConfig() {}
 
 AndroidVideoDecodeAccelerator::CodecConfig::~CodecConfig() {}
 
 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),
-      is_encrypted_(false),
       state_(NO_ERROR),
       picturebuffers_requested_(false),
       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),
-      surface_id_(media::VideoDecodeAccelerator::Config::kNoSurfaceID),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_timer.Pointer()->StopTimer(this);
   g_avda_timer.Pointer()->StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 15 matching lines @@
     return false;
   }
 
   if (config.output_mode != Config::OutputMode::ALLOCATE) {
     DLOG(ERROR) << "Only ALLOCATE OutputMode is supported by this VDA";
     return false;
   }
 
   DCHECK(client);
   client_ = client;
+  config_ = config;
   codec_config_ = new CodecConfig();
   codec_config_->codec_ = VideoCodecProfileToVideoCodec(config.profile);
   codec_config_->initial_expected_coded_size_ =
       config.initial_expected_coded_size;
-  is_encrypted_ = config.is_encrypted;
 
   // We signalled that we support deferred initialization, so see if the client
   // does also.
   deferred_initialization_pending_ = config.is_deferred_initialization_allowed;
 
-  if (is_encrypted_ && !deferred_initialization_pending_) {
+  if (config_.is_encrypted && !deferred_initialization_pending_) {
     DLOG(ERROR) << "Deferred initialization must be used for encrypted streams";
     return false;
   }
 
   if (codec_config_->codec_ != media::kCodecVP8 &&
       codec_config_->codec_ != media::kCodecVP9 &&
       codec_config_->codec_ != media::kCodecH264) {
     LOG(ERROR) << "Unsupported profile: " << config.profile;
     return false;
   }
 
   // Only use MediaCodec for VP8/9 if it's likely backed by hardware
   // or if the stream is encrypted.
   if ((codec_config_->codec_ == media::kCodecVP8 ||
        codec_config_->codec_ == media::kCodecVP9) &&
-      !is_encrypted_ &&
+      !config_.is_encrypted &&
       media::VideoCodecBridge::IsKnownUnaccelerated(
           codec_config_->codec_, media::MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
              << (codec_config_->codec_ == media::kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
@@ skipping 13 matching lines @@
   } else {
     DVLOG(1) << __FUNCTION__ << ", using copy back strategy.";
     strategy_.reset(new AndroidCopyingBackingStrategy(this));
   }
 
   if (!make_context_current_cb_.Run()) {
     LOG(ERROR) << "Failed to make this decoder's GL context current.";
     return false;
   }
 
-  surface_id_ = config.surface_id;
-  codec_config_->surface_ = strategy_->Initialize(surface_id_);
+  if (g_avda_timer.Pointer()->AllocateSurface(config_.surface_id, this)) {
+    // We have succesfully owned the surface, so finish initialization now.
+    return InitializeStrategy();
+  }
+
+  // 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_);
+
+  if (!success || !InitializeStrategy()) {
+    NotifyInitializationComplete(false);
+    deferred_initialization_pending_ = false;
+  }
+}
+
+bool AndroidVideoDecodeAccelerator::InitializeStrategy() {
+  codec_config_->surface_ = strategy_->Initialize(config_.surface_id);
   if (codec_config_->surface_.IsEmpty()) {
     LOG(ERROR) << "Failed to initialize the backing strategy. The returned "
                   "Java surface is empty.";
     return false;
   }
 
   on_destroying_surface_cb_ =
       base::Bind(&AndroidVideoDecodeAccelerator::OnDestroyingSurface,
                  weak_this_factory_.GetWeakPtr());
   AVDASurfaceTracker::GetInstance()->RegisterOnDestroyingSurfaceCallback(
       on_destroying_surface_cb_);
 
   // TODO(watk,liberato): move this into the strategy.
   scoped_refptr<gfx::SurfaceTexture> surface_texture =
       strategy_->GetSurfaceTexture();
   if (surface_texture) {
     on_frame_available_handler_ =
         new OnFrameAvailableHandler(this, surface_texture);
   }
 
   // Start the thread for async configuration, even if we don't need it now.
   // ResetCodecState might rebuild the codec later, for example.
   if (!g_avda_timer.Pointer()->StartThread(this)) {
     LOG(ERROR) << "Failed to start AVDA thread";
     return false;
   }
 
   // If we are encrypted, then we aren't able to create the codec yet.
-  if (is_encrypted_) {
-    InitializeCdm(config.cdm_id);
+  if (config_.is_encrypted) {
+    InitializeCdm();
     return true;
   }
 
   if (deferred_initialization_pending_) {
     ConfigureMediaCodecAsynchronously();
     return true;
   }
 
   // If the client doesn't support deferred initialization (WebRTC), then we
-  // should complete it now and return a meaningful result.
+  // should complete it now and return a meaningful result.  Note that it would
+  // be nice if we didn't have to worry about starting codec configuration at
+  // all (::Initialize or the wrapper can do it), but then they have to remember
+  // not to start codec config if we have to wait for the cdm.  It's somewhat
+  // clearer for us to handle both cases.
   return ConfigureMediaCodecSynchronously();
 }
 
 void AndroidVideoDecodeAccelerator::DoIOTask(bool start_timer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DoIOTask");
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC ||
       state_ == SURFACE_DESTROYED) {
     return;
   }
@@ skipping 728 matching lines @@
 
 void AndroidVideoDecodeAccelerator::ActualDestroy() {
   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_timer.Pointer()->DeallocateSurface(config_.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_timer.Pointer()->StopTimer(this);
     media_codec_.reset();
   }
   delete this;
 }
@@ skipping 38 matching lines @@
                     nullptr);
 
   return texture_ref;
 }
 
 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 != surface_id_)
+  if (surface_id != config_.surface_id)
     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_) {
     media_codec_.reset();
     strategy_->CodecChanged(media_codec_.get());
   }
@@ skipping 13 matching lines @@
     const ::tracked_objects::Location& from_here,
     media::VideoDecodeAccelerator::Error error) {
   base::MessageLoop::current()->PostDelayedTask(
       from_here,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyError,
                  weak_this_factory_.GetWeakPtr(), error, error_sequence_token_),
       (defer_errors_ ? ErrorPostingDelay() : base::TimeDelta()));
   state_ = ERROR;
 }
 
-void AndroidVideoDecodeAccelerator::InitializeCdm(int cdm_id) {
-  DVLOG(2) << __FUNCTION__ << ": " << cdm_id;
+void AndroidVideoDecodeAccelerator::InitializeCdm() {
+  DVLOG(2) << __FUNCTION__ << ": " << config_.cdm_id;
 
 #if !defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   NOTIMPLEMENTED();
   NotifyInitializationComplete(false);
 #else
   // Store the CDM to hold a reference to it.
-  cdm_for_reference_holding_only_ = media::MojoCdmService::LegacyGetCdm(cdm_id);
+  cdm_for_reference_holding_only_ =
+      media::MojoCdmService::LegacyGetCdm(config_.cdm_id);
   DCHECK(cdm_for_reference_holding_only_);
 
   // On Android platform the CdmContext must be a MediaDrmBridgeCdmContext.
   media_drm_bridge_cdm_context_ = static_cast<media::MediaDrmBridgeCdmContext*>(
       cdm_for_reference_holding_only_->GetCdmContext());
   DCHECK(media_drm_bridge_cdm_context_);
 
   // Register CDM callbacks. The callbacks registered will be posted back to
   // this thread via BindToCurrentLoop.
 
@@ skipping 184 matching lines @@
     if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
       capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
           SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
     }
   }
 
   return capabilities;
 }
 
 }  // namespace media