Java CodecCapabilities类代码示例

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * Returns the name of the best decoder and its capabilities for the given mimeType.
 */
private static synchronized Pair<String, CodecCapabilities> getMediaCodecInfo(
    String mimeType, boolean secure) throws DecoderQueryException {
  CodecKey key = new CodecKey(mimeType, secure);
  if (codecs.containsKey(key)) {
    return codecs.get(key);
  }
  MediaCodecListCompat mediaCodecList = Util.SDK_INT >= 21
      ? new MediaCodecListCompatV21(secure) : new MediaCodecListCompatV16();
  Pair<String, CodecCapabilities> codecInfo = getMediaCodecInfo(key, mediaCodecList);
  // TODO: Verify this cannot occur on v22, and change >= to == [Internal: b/18678462].
  if (secure && codecInfo == null && Util.SDK_INT >= 21) {
    // Some devices don't list secure decoders on API level 21. Try the legacy path.
    mediaCodecList = new MediaCodecListCompatV16();
    codecInfo = getMediaCodecInfo(key, mediaCodecList);
    if (codecInfo != null) {
      Log.w(TAG, "MediaCodecList API didn't list secure decoder for: " + mimeType
          + ". Assuming: " + codecInfo.first);
    }
  }
  return codecInfo;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * @param profile An AVC profile constant from {@link CodecProfileLevel}.
 * @param level An AVC profile level from {@link CodecProfileLevel}.
 * @return Whether the specified profile is supported at the specified level.
 */
public static boolean isH264ProfileSupported(int profile, int level)
    throws DecoderQueryException {
  Pair<String, CodecCapabilities> info = getMediaCodecInfo(MimeTypes.VIDEO_H264, false);
  if (info == null) {
    return false;
  }

  CodecCapabilities capabilities = info.second;
  for (int i = 0; i < capabilities.profileLevels.length; i++) {
    CodecProfileLevel profileLevel = capabilities.profileLevels[i];
    if (profileLevel.profile == profile && profileLevel.level >= level) {
      return true;
    }
  }

  return false;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * Returns the name of the best decoder and its capabilities for the given mimeType.
 */
private static synchronized Pair<String, CodecCapabilities> getMediaCodecInfo(
    String mimeType, boolean secure) {
  CodecKey key = new CodecKey(mimeType, secure);
  if (codecs.containsKey(key)) {
    return codecs.get(key);
  }
  MediaCodecListCompat mediaCodecList = Util.SDK_INT >= 21
      ? new MediaCodecListCompatV21(secure) : new MediaCodecListCompatV16();
  Pair<String, CodecCapabilities> codecInfo = getMediaCodecInfo(key, mediaCodecList);
  // TODO: Verify this cannot occur on v22, and change >= to == [Internal: b/18678462].
  if (secure && codecInfo == null && Util.SDK_INT >= 21) {
    // Some devices don't list secure decoders on API level 21. Try the legacy path.
    mediaCodecList = new MediaCodecListCompatV16();
    codecInfo = getMediaCodecInfo(key, mediaCodecList);
    if (codecInfo != null) {
      Log.w(TAG, "MediaCodecList API didn't list secure decoder for: " + mimeType
          + ". Assuming: " + codecInfo.first);
    }
  }
  return codecInfo;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * @param profile An AVC profile constant from {@link CodecProfileLevel}.
 * @param level An AVC profile level from {@link CodecProfileLevel}.
 * @return Whether the specified profile is supported at the specified level.
 */
public static boolean isH264ProfileSupported(int profile, int level) {
  Pair<String, CodecCapabilities> info = getMediaCodecInfo(MimeTypes.VIDEO_H264, false);
  if (info == null) {
    return false;
  }

  CodecCapabilities capabilities = info.second;
  for (int i = 0; i < capabilities.profileLevels.length; i++) {
    CodecProfileLevel profileLevel = capabilities.profileLevels[i];
    if (profileLevel.profile == profile && profileLevel.level >= level) {
      return true;
    }
  }

  return false;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
  * Needed on M and older to get correct information about VP9 support.
  * @param profileLevels The CodecProfileLevelList to add supported profile levels to.
  * @param videoCapabilities The MediaCodecInfo.VideoCapabilities used to infer support.
  */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
private static void addVp9CodecProfileLevels(CodecProfileLevelList profileLevels,
        MediaCodecInfo.CodecCapabilities codecCapabilities) {
    // https://www.webmproject.org/vp9/levels
    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(
                    VideoCodec.CODEC_VP9, VideoCodecProfile.VP9PROFILE_PROFILE0, level);
        }
    }
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
  * Return an array of supported codecs and profiles.
  */
@CalledByNative
private static Object[] getSupportedCodecProfileLevels() {
    CodecProfileLevelList profileLevels = new CodecProfileLevelList();
    MediaCodecListHelper codecListHelper = new MediaCodecListHelper();
    for (MediaCodecInfo info : codecListHelper) {
        for (String mime : info.getSupportedTypes()) {
            // On versions L and M, VP9 codecCapabilities do not advertise profile level
            // support. In this case, estimate the level from MediaCodecInfo.VideoCapabilities
            // instead. Assume VP9 is not supported before L. For more information, consult
            // https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel.html
            CodecCapabilities codecCapabilities = info.getCapabilitiesForType(mime);
            if (mime.endsWith("vp9") && Build.VERSION_CODES.LOLLIPOP <= Build.VERSION.SDK_INT
                    && Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) {
                addVp9CodecProfileLevels(profileLevels, codecCapabilities);
                continue;
            }
            for (CodecProfileLevel profileLevel : codecCapabilities.profileLevels) {
                profileLevels.addCodecProfileLevel(mime, profileLevel);
            }
        }
    }
    return profileLevels.toArray();
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * Returns true if the given codec supports adaptive playback (dynamic resolution change).
 * @param mediaCodec the codec.
 * @param mime MIME type that corresponds to the codec creation.
 * @return true if this codec and mime type combination supports adaptive playback.
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
private static boolean codecSupportsAdaptivePlayback(MediaCodec mediaCodec, String mime) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT || mediaCodec == null) {
        return false;
    }
    try {
        MediaCodecInfo info = mediaCodec.getCodecInfo();
        if (info.isEncoder()) {
            return false;
        }

        if (isAdaptivePlaybackBlacklisted(mime)) {
            return false;
        }

        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;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * Returns the best decoder and its capabilities for the given mimeType. If there's no decoder
 * returns null.
 */
private static synchronized Pair<MediaCodecInfo, CodecCapabilities> getMediaCodecInfo(
    String mimeType) {
  Pair<MediaCodecInfo, CodecCapabilities> result = codecs.get(mimeType);
  if (result != null) {
    return result;
  }
  int numberOfCodecs = MediaCodecList.getCodecCount();
  // Note: MediaCodecList is sorted by the framework such that the best decoders come first.
  for (int i = 0; i < numberOfCodecs; i++) {
    MediaCodecInfo info = MediaCodecList.getCodecInfoAt(i);
    String codecName = info.getName();
    if (!info.isEncoder() && isOmxCodec(codecName)) {
      String[] supportedTypes = info.getSupportedTypes();
      for (int j = 0; j < supportedTypes.length; j++) {
        String supportedType = supportedTypes[j];
        if (supportedType.equalsIgnoreCase(mimeType)) {
          result = Pair.create(info, info.getCapabilitiesForType(supportedType));
          codecs.put(mimeType, result);
          return result;
        }
      }
    }
  }
  return null;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
/**
 * @param profile An AVC profile constant from {@link CodecProfileLevel}.
 * @param level An AVC profile level from {@link CodecProfileLevel}.
 * @return Whether the specified profile is supported at the specified level.
 */
public static boolean isH264ProfileSupported(int profile, int level) {
  Pair<MediaCodecInfo, CodecCapabilities> info = getMediaCodecInfo(MimeTypes.VIDEO_H264);
  if (info == null) {
    return false;
  }

  CodecCapabilities capabilities = info.second;
  for (int i = 0; i < capabilities.profileLevels.length; i++) {
    CodecProfileLevel profileLevel = capabilities.profileLevels[i];
    if (profileLevel.profile == profile && profileLevel.level >= level) {
      return true;
    }
  }

  return false;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
public static boolean decoderSupportsAdaptivePlayback(MediaCodecInfo decoderInfo) {
	// Possibly enable adaptive playback on KitKat and above
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
		if (isDecoderInList(blacklistedAdaptivePlaybackPrefixes, decoderInfo.getName())) {
			LimeLog.info("Decoder blacklisted for adaptive playback");
			return false;
		}

		try {
			if (decoderInfo.getCapabilitiesForType("video/avc").
					isFeatureSupported(CodecCapabilities.FEATURE_AdaptivePlayback))
			{
				// This will make getCapabilities() return that adaptive playback is supported
				LimeLog.info("Adaptive playback supported (FEATURE_AdaptivePlayback)");
				return true;
			}
		} catch (Exception e) {
			// Tolerate buggy codecs
		}
	}
	
	return false;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
@SuppressWarnings("RedundantThrows")
   public static String dumpDecoders() throws Exception {
	String str = "";
	for (MediaCodecInfo codecInfo : getMediaCodecList()) {
		// Skip encoders
		if (codecInfo.isEncoder()) {
			continue;
		}
		
		str += "Decoder: "+codecInfo.getName()+"\n";
		for (String type : codecInfo.getSupportedTypes()) {
			str += "\t"+type+"\n";
			CodecCapabilities caps = codecInfo.getCapabilitiesForType(type);
			
			for (CodecProfileLevel profile : caps.profileLevels) {
				str += "\t\t"+profile.profile+" "+profile.level+"\n";
			}
		}
	}
	return str;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
public static int getAVCLevel() {
    int maxAVCLevel = 0;
    if (VERSION.SDK_INT >= 16) {
        int mediaCodecListCount = MediaCodecList.getCodecCount();
        for (int i = 0; i < mediaCodecListCount; i++) {
            MediaCodecInfo mediaCodecInfo = MediaCodecList.getCodecInfoAt(i);
            if (!(mediaCodecInfo.isEncoder() || mediaCodecInfo.getName().startsWith("OMX.google") || mediaCodecInfo.getName().startsWith("OMX.TI."))) {
                Log.d(LOG_TAG, "getAVCLevel()->name:" + mediaCodecInfo.getName());
                for (String type : mediaCodecInfo.getSupportedTypes()) {
                    if (type.contains("avc")) {
                        Log.d(LOG_TAG, "getAVCLevel()->type:" + type);
                        try {
                            CodecCapabilities codecCapabilities = mediaCodecInfo.getCapabilitiesForType(type);
                            for (int colorFormat : codecCapabilities.colorFormats) {
                                Log.d(LOG_TAG, "getAVCLevel()->Color Format: " + colorFormat + " " + colorFormatToString(colorFormat));
                            }
                            for (CodecProfileLevel codecProfileLevel : codecCapabilities.profileLevels) {
                                String level = "unknown type";
                                String sprofile = "unknown type";
                                Log.d(LOG_TAG, "getAVCLevel()->Codec Profile Level:" + avcLevelToString(codecProfileLevel.level) + " profile:" + avcProfileToString(codecProfileLevel.profile));
                                if (codecProfileLevel.level > maxAVCLevel) {
                                    maxAVCLevel = codecProfileLevel.level;
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        Log.d(LOG_TAG, "getAVCLevel()->Max AVCLevel:" + maxAVCLevel + " " + avcProfileToString(maxAVCLevel));
    }
    return maxAVCLevel;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
public static int getProfile() {
    int maxProfile = 0;
    Log.d(LOG_TAG, "getProfile()->Build.VERSION.SDK_INT:" + String.valueOf(VERSION.SDK_INT));
    if (VERSION.SDK_INT >= 16) {
        int mediaCodecListCount = MediaCodecList.getCodecCount();
        for (int i = 0; i < mediaCodecListCount; i++) {
            MediaCodecInfo mediaCodecInfo = MediaCodecList.getCodecInfoAt(i);
            if (!(mediaCodecInfo.isEncoder() || mediaCodecInfo.getName().startsWith("OMX.google") || mediaCodecInfo.getName().startsWith("OMX.TI."))) {
                Log.d(LOG_TAG, "getProfile()->name:" + mediaCodecInfo.getName());
                for (String type : mediaCodecInfo.getSupportedTypes()) {
                    if (type.contains("avc")) {
                        Log.d(LOG_TAG, "getProfile()->type:" + type);
                        try {
                            CodecCapabilities codecCapabilities = mediaCodecInfo.getCapabilitiesForType(type);
                            for (int colorFormat : codecCapabilities.colorFormats) {
                                Log.d(LOG_TAG, "getProfile()->Color Format: " + colorFormat + " " + colorFormatToString(colorFormat));
                            }
                            for (CodecProfileLevel codecProfileLevel : codecCapabilities.profileLevels) {
                                String level = "unknown type";
                                String sprofile = "unknown type";
                                Log.d(LOG_TAG, "getProfile()->Codec Profile Level:" + avcLevelToString(codecProfileLevel.level) + " profile:" + avcProfileToString(codecProfileLevel.profile));
                                if (codecProfileLevel.profile > maxProfile) {
                                    maxProfile = codecProfileLevel.profile;
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
        Log.d(LOG_TAG, "getProfile()->Max profile:" + maxProfile + " " + avcProfileToString(maxProfile));
    }
    return maxProfile;
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
public void dumpProfileLevels(String mimeType) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
        return;

    try {
        CodecCapabilities caps = mCodecInfo
                .getCapabilitiesForType(mimeType);
        int maxProfile = 0;
        int maxLevel = 0;
        if (caps != null) {
            if (caps.profileLevels != null) {
                for (CodecProfileLevel profileLevel : caps.profileLevels) {
                    if (profileLevel == null)
                        continue;

                    maxProfile = Math.max(maxProfile, profileLevel.profile);
                    maxLevel = Math.max(maxLevel, profileLevel.level);
                }
            }
        }

        Log.i(TAG,
                String.format(Locale.US, "%s",
                        getProfileLevelName(maxProfile, maxLevel)));
    } catch (Throwable e) {
        Log.i(TAG, "profile-level: exception");
    }
}
 

import android.media.MediaCodecInfo.CodecCapabilities; //导入依赖的package包/类
static Integer selectColorFormat(int[] supportedColorFormats, CodecCapabilities capabilities) {
  for (int supportedColorFormat : supportedColorFormats) {
    for (int codecColorFormat : capabilities.colorFormats) {
      if (codecColorFormat == supportedColorFormat) {
        return codecColorFormat;
      }
    }
  }
  return null;
}