Reduce number of active codecs on low end devices.

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>
 
 #include "base/android/build_info.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
+#include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bind_to_current_loop.h"
@@ skipping 286 matching lines @@
       surface_waiter_map_.erase(iter);
       return;
     }
 
     // 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 && !thread_avda_instances_.empty() &&
+           (base::android::BuildInfo::GetInstance()->sdk_int() <= 18 ||
+            base::SysInfo::IsLowEndDevice());
+  }
+
  private:
   friend struct base::DefaultLazyInstanceTraits<AVDAManager>;
 
   AVDAManager()
       : construction_thread_("AVDAThread"), weak_this_factory_(this) {}
   ~AVDAManager() { NOTREACHED(); }
 
   void RunTimer() {
     {
       // Call out to all AVDA instances, some of which may attempt to remove
@@ skipping 81 matching lines @@
       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),
       codec_needs_reset_(false),
+      defer_surface_creation_(false),
       weak_this_factory_(this) {}
 
 AndroidVideoDecodeAccelerator::~AndroidVideoDecodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
   g_avda_manager.Get().StopTimer(this);
   g_avda_manager.Get().StopThread(this);
 
 #if defined(ENABLE_MOJO_MEDIA_IN_GPU_PROCESS)
   if (!media_drm_bridge_cdm_context_)
     return;
@@ skipping 26 matching lines @@
   }
 
   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;
 
-  // We signalled 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 (codec_config_->codec_ != kCodecVP8 &&
       codec_config_->codec_ != kCodecVP9 &&
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
       codec_config_->codec_ != kCodecHEVC &&
 #endif
       codec_config_->codec_ != 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 (IsMediaCodecSoftwareDecodingForbidden() &&
       VideoCodecBridge::IsKnownUnaccelerated(codec_config_->codec_,
                                              MEDIA_CODEC_DECODER)) {
     DVLOG(1) << "Initialization failed: "
              << (codec_config_->codec_ == kCodecVP8 ? "vp8" : "vp9")
              << " is not hardware accelerated";
     return false;
   }
 
   auto gles_decoder = get_gles2_decoder_cb_.Run();
   if (!gles_decoder) {
     LOG(ERROR) << "Failed to get gles2 decoder instance.";
     return false;
   }
 
-  if (!make_context_current_cb_.Run()) {
-    LOG(ERROR) << "Failed to make this decoder's GL context current.";
+  // 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,
+                                                      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));
+
+    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)) {
-    // We have succesfully owned the surface, so finish initialization now.
+    // 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);
   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_manager.Get().StartThread(this))
     return false;
 
   // If we are encrypted, then we aren't able to create the codec yet.
   if (config_.is_encrypted) {
     InitializeCdm();
     return true;
   }
 
-  if (deferred_initialization_pending_) {
+  if (deferred_initialization_pending_ || defer_surface_creation_) {
+    defer_surface_creation_ = false;
     ConfigureMediaCodecAsynchronously();
     return true;
   }
 
   // If the client doesn't support deferred initialization (WebRTC), then we
   // 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.
@@ skipping 217 matching lines @@
         }
 
         DVLOG(3) << __FUNCTION__
                  << " OUTPUT_FORMAT_CHANGED, new size: " << size_.ToString();
 
         // Don't request picture buffers if we already have some. This avoids
         // having to dismiss the existing buffers which may actively reference
         // decoded images. Breaking their connection to the decoded image will
         // cause rendering of black frames. Instead, we let the existing
         // PictureBuffers live on and we simply update their size the next time
-        // they're attachted to an image of the new resolution. See the
+        // they're attached to an image of the new resolution. See the
         // size update in |SendDecodedFrameToClient| and https://crbug/587994.
         if (output_picture_buffers_.empty() && !picturebuffers_requested_) {
           picturebuffers_requested_ = true;
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&AndroidVideoDecodeAccelerator::RequestPictureBuffers,
                          weak_this_factory_.GetWeakPtr()));
           return false;
         }
 
@@ skipping 117 matching lines @@
 
   // Connect the PictureBuffer to the decoded frame.
   picture_buffer_manager_.UseCodecBufferForPictureBuffer(codec_buffer_index,
                                                          picture_buffer);
 }
 
 void AndroidVideoDecodeAccelerator::Decode(
     const BitstreamBuffer& bitstream_buffer) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
+  if (defer_surface_creation_ && !InitializePictureBufferManager()) {
+    POST_ERROR(PLATFORM_FAILURE,
+               "Failed deferred surface and MediaCodec initialization.");
+    return;
+  }
+
   // If we previously deferred a codec restart, take care of it now. This can
   // happen on older devices where configuration changes require a codec reset.
   if (codec_needs_reset_) {
     DCHECK_EQ(drain_type_, DRAIN_TYPE_NONE);
     ResetCodecState();
   }
 
   if (bitstream_buffer.id() >= 0 && bitstream_buffer.size() > 0) {
     DecodeBuffer(bitstream_buffer);
     return;
@@ skipping 79 matching lines @@
   }
 
   picture_buffer_manager_.ReuseOnePictureBuffer(it->second);
   DoIOTask(true);
 }
 
 void AndroidVideoDecodeAccelerator::Flush() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (state_ == SURFACE_DESTROYED)
+  if (state_ == SURFACE_DESTROYED || defer_surface_creation_)
     NotifyFlushDone();
   else
     StartCodecDrain(DRAIN_FOR_FLUSH);
 }
 
 void AndroidVideoDecodeAccelerator::ConfigureMediaCodecAsynchronously() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // It's probably okay just to return here, since the codec will be configured
   // asynchronously.  It's unclear that any state for the new request could
@@ skipping 210 matching lines @@
   // We might increment error_sequence_token here to cancel any delayed errors,
   // but right now it's unclear that it's safe to do so.  If we are in an error
   // state because of a codec error, then it would be okay.  Otherwise, it's
   // less obvious that we are exiting the error state.  Since deferred errors
   // are only intended for fullscreen transitions right now, we take the more
   // conservative approach and let the errors post.
   // TODO(liberato): revisit this once we sort out the error state a bit more.
 
   // Flush the codec if possible, or create a new one if not.
   if (!did_codec_error_happen &&
-      !media::MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
+      !MediaCodecUtil::CodecNeedsFlushWorkaround(media_codec_.get())) {
     DVLOG(3) << __FUNCTION__ << " Flushing MediaCodec.";
     media_codec_->Flush();
     // Since we just flushed all the output buffers, make sure that nothing is
     // using them.
     picture_buffer_manager_.CodecChanged(media_codec_.get());
   } else {
     DVLOG(3) << __FUNCTION__
              << " Deleting the MediaCodec and creating a new one.";
     g_avda_manager.Get().StopTimer(this);
     ConfigureMediaCodecAsynchronously();
   }
 }
 
 void AndroidVideoDecodeAccelerator::Reset() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Reset");
 
+  if (defer_surface_creation_) {
+    DCHECK(!media_codec_);
+    DCHECK(pending_bitstream_records_.empty());
+    DCHECK_EQ(state_, NO_ERROR);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
+                              weak_this_factory_.GetWeakPtr()));
+    return;
+  }
+
   while (!pending_bitstream_records_.empty()) {
     int32_t bitstream_buffer_id =
         pending_bitstream_records_.front().buffer.id();
     pending_bitstream_records_.pop();
 
     if (bitstream_buffer_id != -1) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                      weak_this_factory_.GetWeakPtr(), bitstream_buffer_id));
@@ skipping 338 matching lines @@
   capabilities.flags =
       VideoDecodeAccelerator::Capabilities::SUPPORTS_DEFERRED_INITIALIZATION;
   capabilities.flags |=
       VideoDecodeAccelerator::Capabilities::NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
 
   // If we're using threaded texture mailboxes the COPY_REQUIRED flag must be
   // set on the video frames (http://crbug.com/582170), and SurfaceView output
   // is disabled (http://crbug.com/582170).
   if (gpu_preferences.enable_threaded_texture_mailboxes) {
     capabilities.flags |=
-        media::VideoDecodeAccelerator::Capabilities::REQUIRES_TEXTURE_COPY;
-  } else if (media::MediaCodecUtil::IsSurfaceViewOutputSupported()) {
-    capabilities.flags |= media::VideoDecodeAccelerator::Capabilities::
-        SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
+        VideoDecodeAccelerator::Capabilities::REQUIRES_TEXTURE_COPY;
+  } else if (MediaCodecUtil::IsSurfaceViewOutputSupported()) {
+    capabilities.flags |=
+        VideoDecodeAccelerator::Capabilities::SUPPORTS_EXTERNAL_OUTPUT_SURFACE;
   }
 
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   for (const auto& supported_profile : kSupportedHevcProfiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(0, 0);
     profile.max_resolution.SetSize(3840, 2160);
     profiles.push_back(profile);
   }
 #endif
 
   return capabilities;
 }
 
 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