media: Clean up MediaCodecBridge and remove subclasses

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.MediaCodec.CryptoInfo;
 import android.media.MediaCodecInfo;
@@ skipping 15 matching lines @@
 import java.util.NoSuchElementException;
 
 /**
  * A collection of MediaCodec utility functions.
  */
 @JNINamespace("media")
 @MainDex
 class MediaCodecUtil {
     private static final String TAG = "cr_MediaCodecUtil";
 
-    // Codec direction.  Keep this in sync with media_codec_direction.h.
-    static final int MEDIA_CODEC_DECODER = 0;
-    static final int MEDIA_CODEC_ENCODER = 1;
-
     /**
      * Class to pass parameters from createDecoder()
      */
     public static class CodecCreationInfo {
         public MediaCodec mediaCodec;
         public boolean supportsAdaptivePlayback;
         public BitrateAdjustmentTypes bitrateAdjustmentType = BitrateAdjustmentTypes.NO_ADJUSTMENT;
     }
 
     public static final class MimeTypes {
@@ skipping 91 matching lines @@
      * @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, boolean requireSoftwareCodec) {
         MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
         for (MediaCodecInfo info : codecListHelper) {
-            int codecDirection = info.isEncoder() ? MEDIA_CODEC_ENCODER : MEDIA_CODEC_DECODER;
+            int codecDirection =
+                    info.isEncoder() ? MediaCodecDirection.ENCODER : MediaCodecDirection.DECODER;
             if (codecDirection != direction) continue;
 
             if (requireSoftwareCodec && !isSoftwareCodec(info.getName())) continue;
 
             for (String supportedType : info.getSupportedTypes()) {
                 if (supportedType.equalsIgnoreCase(mime)) return info.getName();
             }
         }
 
         Log.e(TAG, "Decoder for type %s is not supported on this device", mime);
@@ skipping 52 matching lines @@
         final int[][] bitrateMapping = {
                 {200, 10}, {800, 11}, {1800, 20}, {3600, 21}, {7200, 30}, {12000, 31}, {18000, 40},
                 {30000, 41}, {60000, 50}, {120000, 51}, {180000, 52},
         };
         VideoCapabilities videoCapabilities = codecCapabilities.getVideoCapabilities();
         for (int[] entry : bitrateMapping) {
             int bitrate = entry[0];
             int level = entry[1];
             if (videoCapabilities.getBitrateRange().contains(bitrate)) {
                 // Assume all platforms before N only support VP9 profile 0.
-                profileLevels.addCodecProfileLevel("VP9", 12 /* VP9PROFILE_PROFILE0 */, level);
+                profileLevels.addCodecProfileLevel(
+                        VideoCodec.kCodecVP9, VideoCodecProfile.VP9PROFILE_PROFILE0, level);
             }
         }
     }
 
     /**
       * Return an array of supported codecs and profiles.
       */
     @CalledByNative
     private static Object[] getSupportedCodecProfileLevels() {
         CodecProfileLevelList profileLevels = new CodecProfileLevelList();
@@ skipping 39 matching lines @@
 
         // 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, requireSoftwareCodec);
+                String decoderName = getDefaultCodecName(
+                        mime, MediaCodecDirection.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 {
                 if (requireSoftwareCodec) {
-                    String decoderName =
-                            getDefaultCodecName(mime, MEDIA_CODEC_DECODER, requireSoftwareCodec);
+                    String decoderName = getDefaultCodecName(
+                            mime, MediaCodecDirection.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, requireSoftwareCodec: %s",
                     mime, isSecure, requireSoftwareCodec ? "yes" : "no", e);
@@ skipping 313 matching lines @@
      * supported.
      * This method was introduced in Android N. Note that if platformSupportsCbcsEncryption
      * returns true, then this function will set the pattern.
      */
     static void setPatternIfSupported(CryptoInfo cryptoInfo, int encrypt, int skip) {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
             cryptoInfo.setPattern(new CryptoInfo.Pattern(encrypt, skip));
         }
     }
 }