Disable adaptive resolution support for MediaCodec use by AVDA.

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 <utility>
 
@@ skipping 542 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) {
+VideoCodecBridge* VideoCodecBridge::CreateDecoder(
+    const VideoCodec& codec,
+    bool is_secure,
+    const gfx::Size& size,
+    jobject surface,
+    jobject media_crypto,
+    bool allow_adaptive_playback) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
   scoped_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
   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(env, bridge->media_codec(),
-                                            j_format.obj(), surface,
-                                            media_crypto, 0)) {
+  if (!Java_MediaCodecBridge_configureVideo(
+          env, bridge->media_codec(), j_format.obj(), surface, media_crypto, 0,
+          allow_adaptive_playback)) {
     return nullptr;
   }
 
   return bridge->Start() ? bridge.release() : nullptr;
 }
 
 // static
 VideoCodecBridge* VideoCodecBridge::CreateEncoder(const VideoCodec& codec,
                                                   const gfx::Size& size,
                                                   int bit_rate,
@@ skipping 14 matching lines @@
 
   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)) {
+                                            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),
@@ skipping 13 matching lines @@
   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