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

media/base/android/java/src/org/chromium/media/MediaCodecUtil.java

 // Copyright 2015 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.
 
 package org.chromium.media;
 
 import android.annotation.TargetApi;
 import android.media.MediaCodec;
 import android.media.MediaCodecInfo;
 import android.media.MediaCodecList;
@@ skipping 62 matching lines @@
         }
 
         private boolean hasNewMediaCodecList() {
             return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
         }
 
         private MediaCodecInfo[] mCodecList;
     }
 
     /**
+     * Return true if and only if name is a software codec.
+     * @param name The codec name, e.g. from MediaCodecInfo.getName().
+     */
+    public static boolean isSoftwareCodec(String name) {
+        // This is structured identically to libstagefright/OMXCodec.cpp .
+        if (name.startsWith("OMX.google.")) return true;
+
+        if (name.startsWith("OMX.")) return false;
+
+        return true;
+    }
+
+    /**
      * Get a name of default android codec.
      * @param mime MIME type of the media.
      * @param direction Whether this is encoder or decoder.
+     * @param requireSoftwareCodec Whether we require a software codec.
      * @return name of the codec.
      */
     @CalledByNative
-    private static String getDefaultCodecName(String mime, int direction) {
+    private static String getDefaultCodecName(
+            String mime, int direction, boolean requireSoftwareCodec) {
         MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
         int codecCount = codecListHelper.getCodecCount();
         for (int i = 0; i < codecCount; ++i) {
             MediaCodecInfo info = codecListHelper.getCodecInfoAt(i);
 
             int codecDirection = info.isEncoder() ? MEDIA_CODEC_ENCODER : MEDIA_CODEC_DECODER;
             if (codecDirection != direction) continue;
 
+            if (requireSoftwareCodec && !isSoftwareCodec(info.getName())) continue;
+
             String[] supportedTypes = info.getSupportedTypes();
             for (int j = 0; j < supportedTypes.length; ++j) {
                 if (supportedTypes[j].equalsIgnoreCase(mime)) return info.getName();
             }
         }
 
         Log.e(TAG, "Decoder for type %s is not supported on this device", mime);
         return "";
     }
 
@@ skipping 21 matching lines @@
     }
 
     /**
       * Check if a given MIME type can be decoded.
       * @param mime MIME type of the media.
       * @param secure Whether secure decoder is required.
       * @return true if system is able to decode, or false otherwise.
       */
     @CalledByNative
     private static boolean canDecode(String mime, boolean isSecure) {
-        CodecCreationInfo info = createDecoder(mime, isSecure);
+        // TODO(liberato): Should we insist on software here?
+        CodecCreationInfo info = createDecoder(mime, isSecure, false);
         if (info.mediaCodec == null) return false;
 
         try {
             info.mediaCodec.release();
         } catch (IllegalStateException e) {
             Log.e(TAG, "Cannot release media codec", e);
         }
         return true;
     }
 
     /**
      * Creates MediaCodec decoder.
      * @param mime MIME type of the media.
      * @param secure Whether secure decoder is required.
+     * @param requireSoftwareCodec Whether a software decoder is required.
      * @return CodecCreationInfo object
      */
-    static CodecCreationInfo createDecoder(String mime, boolean isSecure) {
+    static CodecCreationInfo createDecoder(
+            String mime, boolean isSecure, boolean requireSoftwareCodec) {
         // Always return a valid CodecCreationInfo, its |mediaCodec| field will be null
         // if we cannot create the codec.
         CodecCreationInfo result = new CodecCreationInfo();
 
         assert result.mediaCodec == null;
 
         // Creation of ".secure" codecs sometimes crash instead of throwing exceptions
         // on pre-JBMR2 devices.
         if (isSecure && Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) return result;
 
         // Do not create codec for blacklisted devices.
         if (!isDecoderSupportedForDevice(mime)) {
             Log.e(TAG, "Decoder for type %s is not supported on this device", mime);
             return result;
         }
 
         try {
             // |isSecure| only applies to video decoders.
             if (mime.startsWith("video") && isSecure) {
-                String decoderName = getDefaultCodecName(mime, MEDIA_CODEC_DECODER);
+                String decoderName =
+                        getDefaultCodecName(mime, MEDIA_CODEC_DECODER, requireSoftwareCodec);
                 if (decoderName.equals("")) return null;
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                     // To work around an issue that we cannot get the codec info from the secure
                     // decoder, create an insecure decoder first so that we can query its codec
                     // info. http://b/15587335.
                     // Futhermore, it is impossible to create an insecure decoder if the secure
                     // one is already created.
                     MediaCodec insecureCodec = MediaCodec.createByCodecName(decoderName);
                     result.supportsAdaptivePlayback =
                             codecSupportsAdaptivePlayback(insecureCodec, mime);
                     insecureCodec.release();
                 }
                 result.mediaCodec = MediaCodec.createByCodecName(decoderName + ".secure");
             } else {
-                result.mediaCodec = MediaCodec.createDecoderByType(mime);
+                if (requireSoftwareCodec) {
+                    String decoderName =
+                            getDefaultCodecName(mime, MEDIA_CODEC_DECODER, requireSoftwareCodec);
+                    result.mediaCodec = MediaCodec.createByCodecName(decoderName);
+                } else {
+                    result.mediaCodec = MediaCodec.createDecoderByType(mime);
+                }
                 result.supportsAdaptivePlayback =
                         codecSupportsAdaptivePlayback(result.mediaCodec, mime);
             }
         } catch (Exception e) {
-            Log.e(TAG, "Failed to create MediaCodec: %s, isSecure: %s", mime, isSecure, e);
+            Log.e(TAG, "Failed to create MediaCodec: %s, isSecure: %s, requireSoftwareCodec: %s",
+                    mime, isSecure, requireSoftwareCodec ? "yes" : "no", e);
             result.mediaCodec = null;
         }
         return result;
     }
 
     /**
      * This is a way to blacklist misbehaving devices.
      * Some devices cannot decode certain codecs, while other codecs work fine.
      * @param mime MIME type as passed to mediaCodec.createDecoderByType(mime).
      * @return true if this codec is supported for decoder on this device.
@@ skipping 109 matching lines @@
             MediaCodecInfo.CodecCapabilities capabilities = info.getCapabilitiesForType(mime);
             return (capabilities != null)
                     && capabilities.isFeatureSupported(
                                MediaCodecInfo.CodecCapabilities.FEATURE_AdaptivePlayback);
         } catch (IllegalArgumentException e) {
             Log.e(TAG, "Cannot retrieve codec information", e);
         }
         return false;
     }
 }