[M54] Roll-up of fixes for VP8/VP9 stability on Android.

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 772 matching lines @@
 
   return true;
 }
 
 bool AndroidVideoDecodeAccelerator::DequeueOutput() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::DequeueOutput");
   base::AutoReset<bool> auto_reset(&defer_errors_, true);
   if (state_ == ERROR || state_ == WAITING_FOR_CODEC)
     return false;
-  if (picturebuffers_requested_ && output_picture_buffers_.empty())
+  // If we're draining for reset or destroy, then we don't need picture buffers
+  // since we won't send any decoded frames anyway.  There might not be any,
+  // since the pipeline might not be sending them back and / or they don't
+  // exist anymore.  From the pipeline's point of view, for Destroy at least,
+  // the VDA is already gone.
+  if (picturebuffers_requested_ && output_picture_buffers_.empty() &&
+      !IsDrainingForResetOrDestroy()) {
     return false;
-  if (!output_picture_buffers_.empty() && free_picture_ids_.empty()) {
+  }
+  if (!output_picture_buffers_.empty() && free_picture_ids_.empty() &&
+      !IsDrainingForResetOrDestroy()) {
     // Don't have any picture buffer to send. Need to wait.
     return false;
   }
 
   bool eos = false;
   base::TimeDelta presentation_timestamp;
   int32_t buf_index = 0;
   do {
     size_t offset = 0;
     size_t size = 0;
@@ skipping 900 matching lines @@
   SupportedProfiles& profiles = capabilities.supported_profiles;
 
   // Only support VP8 on Android versions where we don't have to synchronously
   // tear down the MediaCodec on surface destruction because VP8 requires
   // us to completely drain the decoder before releasing it, which is difficult
   // and time consuming to do while the surface is being destroyed.
   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 18 &&
       MediaCodecUtil::IsVp8DecoderAvailable()) {
     SupportedProfile profile;
     profile.profile = VP8PROFILE_ANY;
-    profile.min_resolution.SetSize(0, 0);
+    // Since there is little to no power benefit below 360p, don't advertise
+    // support for it.  Let libvpx decode it, and save a MediaCodec instance.
+    // Note that we allow it anyway for encrypted content, since we push a
+    // separate profile for that.
+    profile.min_resolution.SetSize(480, 360);
     profile.max_resolution.SetSize(3840, 2160);
     // If we know MediaCodec will just create a software codec, prefer our
     // internal software decoder instead. It's more up to date and secured
     // within the renderer sandbox. However if the content is encrypted, we
     // must use MediaCodec anyways since MediaDrm offers no way to decrypt
     // the buffers and let us use our internal software decoders.
     profile.encrypted_only =
         VideoCodecBridge::IsKnownUnaccelerated(kCodecVP8, MEDIA_CODEC_DECODER);
     profiles.push_back(profile);
+
+    // Always allow encrypted content, even at low resolutions.
+    profile.min_resolution.SetSize(0, 0);
+    profile.encrypted_only = true;
+    profiles.push_back(profile);
   }
 
   if (MediaCodecUtil::IsVp9DecoderAvailable()) {
-    SupportedProfile profile;
-    profile.min_resolution.SetSize(0, 0);
-    profile.max_resolution.SetSize(3840, 2160);
-    // If we know MediaCodec will just create a software codec, prefer our
-    // internal software decoder instead. It's more up to date and secured
-    // within the renderer sandbox. However if the content is encrypted, we
-    // must use MediaCodec anyways since MediaDrm offers no way to decrypt
-    // the buffers and let us use our internal software decoders.
-    profile.encrypted_only =
+    const VideoCodecProfile profile_types[] = {
+        VP9PROFILE_PROFILE0, VP9PROFILE_PROFILE1, VP9PROFILE_PROFILE2,
+        VP9PROFILE_PROFILE3, VIDEO_CODEC_PROFILE_UNKNOWN};
+    const bool is_known_unaccelerated =
         VideoCodecBridge::IsKnownUnaccelerated(kCodecVP9, MEDIA_CODEC_DECODER);
-    profile.profile = VP9PROFILE_PROFILE0;
-    profiles.push_back(profile);
-    profile.profile = VP9PROFILE_PROFILE1;
-    profiles.push_back(profile);
-    profile.profile = VP9PROFILE_PROFILE2;
-    profiles.push_back(profile);
-    profile.profile = VP9PROFILE_PROFILE3;
-    profiles.push_back(profile);
+    for (int i = 0; profile_types[i] != VIDEO_CODEC_PROFILE_UNKNOWN; i++) {
+      SupportedProfile profile;
+      // Limit to 360p, like we do for vp8.  See above.
+      profile.min_resolution.SetSize(480, 360);
+      profile.max_resolution.SetSize(3840, 2160);
+      // If we know MediaCodec will just create a software codec, prefer our
+      // internal software decoder instead. It's more up to date and secured
+      // within the renderer sandbox. However if the content is encrypted, we
+      // must use MediaCodec anyways since MediaDrm offers no way to decrypt
+      // the buffers and let us use our internal software decoders.
+      profile.encrypted_only = is_known_unaccelerated;
+      profile.profile = profile_types[i];
+      profiles.push_back(profile);
+
+      // Always allow encrypted content.
+      profile.min_resolution.SetSize(0, 0);
+      profile.encrypted_only = true;
+      profiles.push_back(profile);
+    }
   }
 
   for (const auto& supported_profile : kSupportedH264Profiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(0, 0);
     // Advertise support for 4k and let the MediaCodec fail when decoding if it
     // doesn't support the resolution. It's assumed that consumers won't have
     // software fallback for H264 on Android anyway.
     profile.max_resolution.SetSize(3840, 2160);
@@ skipping 23 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_ == media::kCodecVP8 ||
                                    codec_config_->codec_ == media::kCodecVP9);
 }
 
 }  // namespace media