[M52] Make AVDA fall back to software decoding if needed.

media/base/android/sdk_media_codec_bridge.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/base/android/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
 #include <memory>
 #include <utility>
@@ skipping 63 matching lines @@
       return "video/x-vnd.on2.vp8";
     case kCodecVP9:
       return "video/x-vnd.on2.vp9";
     default:
       return std::string();
   }
 }
 
 SdkMediaCodecBridge::SdkMediaCodecBridge(const std::string& mime,
                                          bool is_secure,
-                                         MediaCodecDirection direction) {
+                                         MediaCodecDirection direction,
+                                         bool require_software_codec) {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   DCHECK(!mime.empty());
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
-  j_media_codec_.Reset(
-      Java_MediaCodecBridge_create(env, j_mime.obj(), is_secure, direction));
+  j_media_codec_.Reset(Java_MediaCodecBridge_create(
+      env, j_mime.obj(), is_secure, direction, require_software_codec));
 }
 
 SdkMediaCodecBridge::~SdkMediaCodecBridge() {
   JNIEnv* env = AttachCurrentThread();
   CHECK(env);
   if (j_media_codec_.obj())
     Java_MediaCodecBridge_release(env, j_media_codec_.obj());
 }
 
 MediaCodecStatus SdkMediaCodecBridge::Reset() {
@@ skipping 225 matching lines @@
     return MEDIA_CODEC_ERROR;
   const size_t total_capacity = env->GetDirectBufferCapacity(j_buffer.obj());
   CHECK_GE(total_capacity, offset);
   *addr = reinterpret_cast<const uint8_t*>(
               env->GetDirectBufferAddress(j_buffer.obj())) +
           offset;
   *capacity = total_capacity - offset;
   return MEDIA_CODEC_OK;
 }
 
+bool SdkMediaCodecBridge::IsSoftwareCodec() {
+  JNIEnv* env = AttachCurrentThread();
+  return Java_MediaCodecBridge_isSoftwareCodec(env, j_media_codec_.obj());
+}
+
 // static
 bool SdkMediaCodecBridge::RegisterSdkMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 // static
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
@@ skipping 10 matching lines @@
 
 // static
 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
 }
 
 AudioCodecBridge::AudioCodecBridge(const std::string& mime)
     // Audio codec doesn't care about security level and there is no need for
     // audio encoding yet.
-    : SdkMediaCodecBridge(mime, false, MEDIA_CODEC_DECODER) {}
+    : SdkMediaCodecBridge(mime, false, MEDIA_CODEC_DECODER, false) {}
 
 bool AudioCodecBridge::ConfigureAndStart(const AudioDecoderConfig& config,
                                          bool play_audio,
                                          jobject media_crypto) {
   const int channel_count =
       ChannelLayoutToChannelCount(config.channel_layout());
   const int64_t codec_delay_ns = base::Time::kNanosecondsPerSecond *
                                  config.codec_delay() /
                                  config.samples_per_second();
   const int64_t seek_preroll_ns =
@@ skipping 225 matching lines @@
 }
 
 // static
 bool VideoCodecBridge::IsKnownUnaccelerated(const VideoCodec& codec,
                                             MediaCodecDirection direction) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       VideoCodecToAndroidMimeType(codec), direction);
 }
 
 // static
-VideoCodecBridge* VideoCodecBridge::CreateDecoder(
-    const VideoCodec& codec,
-    bool is_secure,
-    const gfx::Size& size,
-    jobject surface,
-    jobject media_crypto,
-    bool allow_adaptive_playback) {
+VideoCodecBridge* VideoCodecBridge::CreateDecoder(const VideoCodec& codec,
+                                                  bool is_secure,
+                                                  const gfx::Size& size,
+                                                  jobject surface,
+                                                  jobject media_crypto,
+                                                  bool allow_adaptive_playback,
+                                                  bool require_software_codec) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
-  std::unique_ptr<VideoCodecBridge> bridge(
-      new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
+  std::unique_ptr<VideoCodecBridge> bridge(new VideoCodecBridge(
+      mime, is_secure, MEDIA_CODEC_DECODER, require_software_codec));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoDecoderFormat(
           env, j_mime.obj(), size.width(), size.height()));
   DCHECK(!j_format.is_null());
   if (!Java_MediaCodecBridge_configureVideo(
@@ skipping 13 matching lines @@
                                                   int i_frame_interval,
                                                   int color_format) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
   std::unique_ptr<VideoCodecBridge> bridge(
-      new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER));
+      new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER, false));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoEncoderFormat(
           env, j_mime.obj(), size.width(), size.height(), bit_rate, frame_rate,
           i_frame_interval, color_format));
   DCHECK(!j_format.is_null());
   if (!Java_MediaCodecBridge_configureVideo(env, bridge->media_codec(),
                                             j_format.obj(), nullptr, nullptr,
                                             kConfigureFlagEncode, true)) {
     return nullptr;
   }
 
   return bridge->Start() ? bridge.release() : nullptr;
 }
 
 VideoCodecBridge::VideoCodecBridge(const std::string& mime,
                                    bool is_secure,
-                                   MediaCodecDirection direction)
-    : SdkMediaCodecBridge(mime, is_secure, direction),
+                                   MediaCodecDirection direction,
+                                   bool require_software_codec)
+    : SdkMediaCodecBridge(mime, is_secure, direction, require_software_codec),
       adaptive_playback_supported_for_testing_(-1) {}
 
 void VideoCodecBridge::SetVideoBitrate(int bps) {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_setVideoBitrate(env, media_codec(), bps);
 }
 
 void VideoCodecBridge::RequestKeyFrameSoon() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec());
 }
 
 bool VideoCodecBridge::IsAdaptivePlaybackSupported(int width, int height) {
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media