| // 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.media.MediaCodec; |
| import android.media.MediaCodec.CryptoInfo; |
| import android.media.MediaCodecInfo; |
| import android.media.MediaCodecInfo.CodecCapabilities; |
| import android.media.MediaCodecInfo.CodecProfileLevel; |
| import android.media.MediaCodecInfo.VideoCapabilities; |
| import android.media.MediaCodecList; |
| import android.media.MediaCrypto; |
| import android.media.MediaFormat; |
| import android.os.Build; |
| |
| import androidx.annotation.IntDef; |
| import androidx.annotation.Nullable; |
| |
| import org.chromium.base.Log; |
| import org.chromium.base.annotations.CalledByNative; |
| import org.chromium.base.annotations.JNINamespace; |
| import org.chromium.base.annotations.MainDex; |
| import org.chromium.base.compat.ApiHelperForN; |
| |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.util.Iterator; |
| import java.util.Locale; |
| import java.util.NoSuchElementException; |
| |
| /** |
| * A collection of MediaCodec utility functions. |
| */ |
| @JNINamespace("media") |
| @MainDex |
| class MediaCodecUtil { |
| private static final String TAG = "MediaCodecUtil"; |
| |
| /** |
| * Information returned by createDecoder() |
| */ |
| public static class CodecCreationInfo { |
| public MediaCodec mediaCodec; |
| public boolean supportsAdaptivePlayback; |
| public @BitrateAdjuster.Type int bitrateAdjuster = BitrateAdjuster.Type.NO_ADJUSTMENT; |
| } |
| |
| public static final class MimeTypes { |
| public static final String VIDEO_MP4 = "video/mp4"; |
| public static final String VIDEO_WEBM = "video/webm"; |
| public static final String VIDEO_H264 = "video/avc"; |
| public static final String VIDEO_DOLBY_VISION = "video/dolby-vision"; |
| public static final String VIDEO_HEVC = "video/hevc"; |
| public static final String VIDEO_VP8 = "video/x-vnd.on2.vp8"; |
| public static final String VIDEO_VP9 = "video/x-vnd.on2.vp9"; |
| public static final String VIDEO_AV1 = "video/av01"; |
| public static final String AUDIO_OPUS = "audio/opus"; |
| } |
| |
| /** |
| * Class to abstract platform version API differences for interacting with |
| * the MediaCodecList. |
| */ |
| private static class MediaCodecListHelper implements Iterable<MediaCodecInfo> { |
| public MediaCodecListHelper() { |
| try { |
| mCodecList = new MediaCodecList(MediaCodecList.ALL_CODECS).getCodecInfos(); |
| } catch (Throwable e) { |
| // Swallow the exception due to bad Android implementation and pretend |
| // MediaCodecList is not supported. |
| } |
| } |
| |
| @Override |
| public Iterator<MediaCodecInfo> iterator() { |
| return new CodecInfoIterator(); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private int getCodecCount() { |
| if (hasNewMediaCodecList()) return mCodecList.length; |
| try { |
| return MediaCodecList.getCodecCount(); |
| } catch (RuntimeException e) { |
| // Swallow the exception due to bad Android implementation and pretend |
| // MediaCodecList is not supported. |
| return 0; |
| } |
| } |
| |
| @SuppressWarnings("deprecation") |
| private MediaCodecInfo getCodecInfoAt(int index) { |
| if (hasNewMediaCodecList()) return mCodecList[index]; |
| return MediaCodecList.getCodecInfoAt(index); |
| } |
| |
| private boolean hasNewMediaCodecList() { |
| return mCodecList != null; |
| } |
| |
| private MediaCodecInfo[] mCodecList; |
| |
| private class CodecInfoIterator implements Iterator<MediaCodecInfo> { |
| private int mPosition; |
| |
| @Override |
| public boolean hasNext() { |
| return mPosition < getCodecCount(); |
| } |
| |
| @Override |
| public MediaCodecInfo next() { |
| if (mPosition == getCodecCount()) { |
| throw new NoSuchElementException(); |
| } |
| return getCodecInfoAt(mPosition++); |
| } |
| |
| @Override |
| public void remove() { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| } |
| |
| /** |
| * Return true if and only if info is a software codec. |
| */ |
| private static boolean isSoftwareCodec(MediaCodecInfo info) { |
| if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) return !info.isHardwareAccelerated(); |
| |
| String name = info.getName().toLowerCase(Locale.ROOT); |
| // This is taken from libstagefright/OMXCodec.cpp for pre codec2. |
| if (name.startsWith("omx.google.")) return true; |
| |
| // Codec2 names sw decoders this way. |
| // See hardware/google/av/codec2/vndk/C2Store.cpp. |
| if (name.startsWith("c2.google.") || name.startsWith("c2.android.")) return true; |
| |
| return false; |
| } |
| |
| /** |
| * 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, boolean requireSoftwareCodec) { |
| MediaCodecListHelper codecListHelper = new MediaCodecListHelper(); |
| for (MediaCodecInfo info : codecListHelper) { |
| int codecDirection = |
| info.isEncoder() ? MediaCodecDirection.ENCODER : MediaCodecDirection.DECODER; |
| if (codecDirection != direction) continue; |
| |
| if (requireSoftwareCodec && !isSoftwareCodec(info)) 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); |
| return ""; |
| } |
| |
| /** |
| * Get a list of encoder supported color formats for specified MIME type. |
| * @param mime MIME type of the media format. |
| * @return a list of encoder supported color formats. |
| */ |
| @CalledByNative |
| private static int[] getEncoderColorFormatsForMime(String mime) { |
| MediaCodecListHelper codecListHelper = new MediaCodecListHelper(); |
| for (MediaCodecInfo info : codecListHelper) { |
| if (!info.isEncoder()) continue; |
| |
| for (String supportedType : info.getSupportedTypes()) { |
| if (supportedType.equalsIgnoreCase(mime)) { |
| try { |
| return info.getCapabilitiesForType(supportedType).colorFormats; |
| } catch (IllegalArgumentException e) { |
| // Type is not supported. |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * 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) { |
| // Not supported on some devices. |
| if (!isDecoderSupportedForDevice(mime)) { |
| Log.e(TAG, "Decoder for type %s is not supported on this device", mime); |
| return false; |
| } |
| |
| MediaCodecListHelper codecListHelper = new MediaCodecListHelper(); |
| if (codecListHelper.hasNewMediaCodecList()) { |
| for (MediaCodecInfo info : codecListHelper) { |
| if (info.isEncoder()) continue; |
| |
| try { |
| CodecCapabilities caps = info.getCapabilitiesForType(mime); |
| if (caps != null) { |
| // There may be multiple entries in the list for the same family |
| // (e.g. OMX.qcom.video.decoder.avc and OMX.qcom.video.decoder.avc.secure), |
| // so return early if this one matches what we're looking for. |
| |
| // If a secure decoder is required, then FEATURE_SecurePlayback must be |
| // supported. |
| if (isSecure |
| && caps.isFeatureSupported( |
| CodecCapabilities.FEATURE_SecurePlayback)) { |
| return true; |
| } |
| |
| // If a secure decoder is not required, then make sure that |
| // FEATURE_SecurePlayback is not required. It may work for unsecure |
| // content, but keep scanning for another codec that supports |
| // unsecure content directly. |
| if (!isSecure |
| && !caps.isFeatureRequired( |
| CodecCapabilities.FEATURE_SecurePlayback)) { |
| return true; |
| } |
| } |
| } catch (IllegalArgumentException e) { |
| // Type is not supported. |
| } |
| } |
| |
| // Unable to find a match for |mime|, so not supported. |
| return false; |
| } |
| |
| // On older versions of Android attempt to create a decoder for the specified MIME type. |
| // TODO(liberato): Should we insist on software here? |
| CodecCreationInfo info = createDecoder(mime, isSecure ? CodecType.SECURE : CodecType.ANY); |
| if (info == null || info.mediaCodec == null) return false; |
| |
| try { |
| info.mediaCodec.release(); |
| } catch (IllegalStateException e) { |
| Log.e(TAG, "Cannot release media codec", e); |
| } |
| return true; |
| } |
| |
| /** |
| * 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. |
| */ |
| 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.VP9, VideoCodecProfile.VP9PROFILE_PROFILE0, level); |
| } |
| } |
| } |
| |
| /** |
| * 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()) { |
| if (!isDecoderSupportedForDevice(mime)) { |
| Log.w(TAG, "Decoder for type %s disabled on this device", mime); |
| continue; |
| } |
| |
| // 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 |
| try { |
| CodecCapabilities codecCapabilities = info.getCapabilitiesForType(mime); |
| if (mime.endsWith("vp9") && Build.VERSION.SDK_INT <= Build.VERSION_CODES.M) { |
| addVp9CodecProfileLevels(profileLevels, codecCapabilities); |
| continue; |
| } |
| for (CodecProfileLevel profileLevel : codecCapabilities.profileLevels) { |
| profileLevels.addCodecProfileLevel(mime, profileLevel); |
| } |
| } catch (IllegalArgumentException e) { |
| // Type is not supported. |
| } |
| } |
| } |
| return profileLevels.toArray(); |
| } |
| |
| /** |
| * Creates MediaCodec decoder. |
| * @param mime MIME type of the media. |
| * @param codecType Type of codec to create. |
| * @return CodecCreationInfo object |
| */ |
| static CodecCreationInfo createDecoder(String mime, int codecType) { |
| return createDecoder(mime,codecType,null); |
| } |
| |
| /** |
| * Creates MediaCodec decoder. |
| * @param mime MIME type of the media. |
| * @param codecType Type of codec to create. |
| * @param mediaCrypto Crypto of the media. |
| * @return CodecCreationInfo object |
| */ |
| static CodecCreationInfo createDecoder( |
| String mime, @CodecType int codecType, MediaCrypto mediaCrypto) { |
| // 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; |
| |
| // Do not create codec for unsupported devices. |
| if (!isDecoderSupportedForDevice(mime)) { |
| Log.e(TAG, "Decoder for type %s is not supported on this device", mime); |
| return result; |
| } |
| |
| try { |
| // "SECURE" only applies to video decoders. |
| // Use MediaCrypto.requiresSecureDecoderComponent() for audio: crbug.com/727918 |
| if ((mime.startsWith("video") && codecType == CodecType.SECURE) |
| || (mime.startsWith("audio") && mediaCrypto != null |
| && mediaCrypto.requiresSecureDecoderComponent(mime))) { |
| // Creating secure codecs is not supported directly on older |
| // versions of Android. Therefore, always get the non-secure |
| // codec name and append ".secure" to get the secure codec name. |
| // TODO(xhwang): Now b/15587335 is fixed, we should have better |
| // API support. |
| String decoderName = getDefaultCodecName(mime, MediaCodecDirection.DECODER, false); |
| if (decoderName.equals("")) return result; |
| |
| // 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 (codecType == CodecType.SOFTWARE) { |
| String decoderName = |
| getDefaultCodecName(mime, MediaCodecDirection.DECODER, true); |
| result.mediaCodec = MediaCodec.createByCodecName(decoderName); |
| } else if (mime.equals(MediaFormat.MIMETYPE_AUDIO_RAW)) { |
| result.mediaCodec = MediaCodec.createByCodecName("OMX.google.raw.decoder"); |
| } else { |
| result.mediaCodec = MediaCodec.createDecoderByType(mime); |
| } |
| result.supportsAdaptivePlayback = |
| codecSupportsAdaptivePlayback(result.mediaCodec, mime); |
| } |
| } catch (Exception e) { |
| Log.e(TAG, "Failed to create MediaCodec: %s, codecType: %d", mime, codecType, e); |
| result.mediaCodec = null; |
| } |
| return result; |
| } |
| |
| /** |
| * This is a way to handle misbehaving devices. |
| * Some devices cannot decode certain codecs, while other codecs work fine. |
| * |
| * Do not access MediaCodec or MediaCodecList in this function since it's |
| * used from the renderer process. |
| * |
| * @param mime MIME type as passed to mediaCodec.createDecoderByType(mime). |
| * @return true if this codec is supported for decoder on this device. |
| */ |
| @CalledByNative |
| static boolean isDecoderSupportedForDevice(String mime) { |
| // ************************************************************* |
| // *** DO NOT ADD ANY NEW CODECS WITHOUT UPDATING MIME_UTIL. *** |
| // ************************************************************* |
| if (mime.equals(MimeTypes.VIDEO_VP8)) { |
| if (Build.MANUFACTURER.toLowerCase(Locale.getDefault()).equals("samsung")) { |
| // Some Samsung devices cannot render VP8 video directly to the surface. |
| |
| // Samsung Galaxy S4 Mini. |
| // Only GT-I9190 was tested with Android 4.4.2 |
| // We block it and the popular GT-I9195 for all Android versions. |
| if (Build.MODEL.startsWith("GT-I9190") || Build.MODEL.startsWith("GT-I9195")) { |
| return false; |
| } |
| } |
| |
| // MediaTek decoders do not work properly on vp8. See http://crbug.com/446974 and |
| // http://crbug.com/597836. |
| if (Build.HARDWARE.startsWith("mt")) { |
| if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) return false; |
| |
| // The following chipsets have been confirmed by MediaTek to work on P+ |
| return Build.HARDWARE.startsWith("mt5599") || Build.HARDWARE.startsWith("mt5895") |
| || Build.HARDWARE.startsWith("mt8768") |
| || Build.HARDWARE.startsWith("mt5887"); |
| } |
| } else if (mime.equals(MimeTypes.VIDEO_VP9)) { |
| // Nexus Player VP9 decoder performs poorly at >= 1080p resolution. |
| if (Build.MODEL.equals("Nexus Player")) { |
| return false; |
| } |
| } else if (mime.equals(MimeTypes.VIDEO_AV1)) { |
| if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) return false; |
| } else if (mime.equals(MimeTypes.VIDEO_DOLBY_VISION)) { |
| if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) { |
| return false; |
| } |
| } |
| // ************************************************************* |
| // *** DO NOT ADD ANY NEW CODECS WITHOUT UPDATING MIME_UTIL. *** |
| // ************************************************************* |
| return true; |
| } |
| |
| /** |
| * Returns true if and only enabling adaptive playback is unsafe. On some |
| * device / os combinations, enabling it causes decoded frames to be |
| * unusable. For example, the S3 on 4.4.2 returns black and white, tiled |
| * frames when this is enabled. |
| */ |
| private static boolean isAdaptivePlaybackDenied(String mime) { |
| if (!mime.equals("video/avc") && !mime.equals("video/avc1")) { |
| return false; |
| } |
| |
| if (!Build.VERSION.RELEASE.equals("4.4.2")) { |
| return false; |
| } |
| |
| if (!Build.MANUFACTURER.toLowerCase(Locale.getDefault()).equals("samsung")) { |
| return false; |
| } |
| |
| return Build.MODEL.startsWith("GT-I9300") || // S3 (I9300 / I9300I) |
| Build.MODEL.startsWith("SCH-I535"); // S3 |
| } |
| |
| /** |
| * 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. |
| */ |
| private static boolean codecSupportsAdaptivePlayback(MediaCodec mediaCodec, String mime) { |
| if (mediaCodec == null) { |
| return false; |
| } |
| try { |
| MediaCodecInfo info = mediaCodec.getCodecInfo(); |
| if (info.isEncoder()) { |
| return false; |
| } |
| |
| if (isAdaptivePlaybackDenied(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; |
| } |
| |
| // List of supported HW encoders. |
| @IntDef({HWEncoder.QcomVp8, HWEncoder.QcomH264, HWEncoder.ExynosVp8, HWEncoder.ExynosVp9, |
| HWEncoder.ExynosH264, HWEncoder.MediatekH264, HWEncoder.HisiH264}) |
| @Retention(RetentionPolicy.SOURCE) |
| public @interface HWEncoder { |
| int QcomVp8 = 0; |
| int QcomH264 = 1; |
| int ExynosVp8 = 2; |
| int ExynosVp9 = 3; |
| int ExynosH264 = 4; |
| int MediatekH264 = 5; |
| int HisiH264 = 6; |
| int NUM_ENTRIES = 7; |
| } |
| |
| private static String getMimeForHWEncoder(@HWEncoder int decoder) { |
| switch (decoder) { |
| case HWEncoder.QcomVp8: |
| case HWEncoder.ExynosVp8: |
| return MimeTypes.VIDEO_VP8; |
| case HWEncoder.ExynosVp9: |
| return MimeTypes.VIDEO_VP9; |
| case HWEncoder.QcomH264: |
| case HWEncoder.ExynosH264: |
| case HWEncoder.MediatekH264: |
| case HWEncoder.HisiH264: |
| return MimeTypes.VIDEO_H264; |
| } |
| return ""; |
| } |
| |
| private static String getPrefixForHWEncoder(@HWEncoder int decoder) { |
| // NOTE: Prefixes must be lower case since the comparison is done in lower case. |
| switch (decoder) { |
| case HWEncoder.QcomVp8: |
| case HWEncoder.QcomH264: |
| return "qcom"; |
| case HWEncoder.ExynosVp8: |
| case HWEncoder.ExynosVp9: |
| case HWEncoder.ExynosH264: |
| return "exynos"; |
| case HWEncoder.MediatekH264: |
| return "mtk"; |
| case HWEncoder.HisiH264: |
| return "hisi"; |
| } |
| return ""; |
| } |
| |
| private static int getMinSDKForHWEncoder(@HWEncoder int decoder) { |
| switch (decoder) { |
| case HWEncoder.QcomVp8: |
| case HWEncoder.QcomH264: |
| case HWEncoder.ExynosH264: |
| return Build.VERSION_CODES.LOLLIPOP; |
| case HWEncoder.ExynosVp8: |
| case HWEncoder.ExynosVp9: |
| return Build.VERSION_CODES.M; |
| case HWEncoder.MediatekH264: |
| return Build.VERSION_CODES.O_MR1; |
| case HWEncoder.HisiH264: |
| return Build.VERSION_CODES.N; |
| } |
| return -1; |
| } |
| |
| private static @BitrateAdjuster.Type int getBitrateAdjusterTypeForHWEncoder( |
| @HWEncoder int decoder) { |
| switch (decoder) { |
| case HWEncoder.QcomVp8: |
| case HWEncoder.QcomH264: |
| case HWEncoder.ExynosVp8: |
| return BitrateAdjuster.Type.NO_ADJUSTMENT; |
| case HWEncoder.ExynosH264: |
| case HWEncoder.MediatekH264: |
| case HWEncoder.HisiH264: |
| return BitrateAdjuster.Type.FRAMERATE_ADJUSTMENT; |
| } |
| throw new IllegalArgumentException("Invalid HWEncoder decoder parameter."); |
| } |
| |
| /** |
| * Creates MediaCodec encoder. |
| * @param mime MIME type of the media. |
| * @return CodecCreationInfo object |
| */ |
| static CodecCreationInfo createEncoder(String mime) { |
| // Always return a valid CodecCreationInfo, its |mediaCodec| field will be null |
| // if we cannot create the codec. |
| CodecCreationInfo result = new CodecCreationInfo(); |
| |
| @Nullable |
| @HWEncoder |
| Integer encoderProperties = findHWEncoder(mime); |
| if (encoderProperties == null) return result; |
| |
| try { |
| result.mediaCodec = MediaCodec.createEncoderByType(mime); |
| result.supportsAdaptivePlayback = false; |
| result.bitrateAdjuster = getBitrateAdjusterTypeForHWEncoder(encoderProperties); |
| } catch (Exception e) { |
| Log.e(TAG, "Failed to create MediaCodec: %s", mime, e); |
| } |
| return result; |
| } |
| |
| /** |
| * This is a way to handle misbehaving devices. |
| * @param mime MIME type as passed to mediaCodec.createEncoderByType(mime). |
| * @return true if this codec is supported for encoder on this device. |
| */ |
| @CalledByNative |
| static boolean isEncoderSupportedByDevice(String mime) { |
| return findHWEncoder(mime) != null; |
| } |
| |
| /** |
| * Provides a way to avoid calling MediaCodec.setOutputSurface() on unsupported devices. |
| * @return true if setOutputSurface() is expected to work. |
| */ |
| @CalledByNative |
| static boolean isSetOutputSurfaceSupported() { |
| // All Huawei devices based on this processor will immediately hang during |
| // MediaCodec.setOutputSurface(). http://crbug.com/683401 |
| // Huawei P9 lite will, eventually, get the decoder into a bad state if SetSurface is called |
| // enough times (https://crbug.com/792261). |
| return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M |
| && !Build.HARDWARE.equalsIgnoreCase("hi6210sft") |
| && !Build.HARDWARE.equalsIgnoreCase("hi6250"); |
| } |
| |
| /** |
| * Find HW encoder with given MIME type. |
| * @param mime MIME type of the media. |
| * @return HWEncoder or null if not found. |
| */ |
| private static @Nullable @HWEncoder Integer findHWEncoder(String mime) { |
| MediaCodecListHelper codecListHelper = new MediaCodecListHelper(); |
| for (MediaCodecInfo info : codecListHelper) { |
| if (!info.isEncoder() || isSoftwareCodec(info)) continue; |
| |
| String encoderName = null; |
| for (String mimeType : info.getSupportedTypes()) { |
| if (mimeType.equalsIgnoreCase(mime)) { |
| encoderName = info.getName().toLowerCase(Locale.getDefault()); |
| break; |
| } |
| } |
| |
| if (encoderName == null) { |
| continue; // No HW support in this codec; try the next one. |
| } |
| |
| // Check if this is supported HW encoder. |
| for (@HWEncoder int codecProperties = 0; codecProperties < HWEncoder.NUM_ENTRIES; |
| codecProperties++) { |
| if (!mime.equalsIgnoreCase(getMimeForHWEncoder(codecProperties))) continue; |
| |
| String prefix = getPrefixForHWEncoder(codecProperties); |
| if (encoderName.startsWith("omx." + prefix + ".") |
| || encoderName.startsWith("c2." + prefix + ".")) { |
| if (Build.VERSION.SDK_INT < getMinSDKForHWEncoder(codecProperties)) { |
| Log.w(TAG, "Codec " + encoderName + " is disabled due to SDK version " |
| + Build.VERSION.SDK_INT); |
| continue; |
| } |
| Log.d(TAG, "Found target encoder for mime " + mime + " : " + encoderName); |
| return codecProperties; |
| } |
| } |
| } |
| |
| Log.w(TAG, "HW encoder for " + mime + " is not available on this device."); |
| return null; |
| } |
| |
| /** |
| * Returns true if and only if a platform with the given SDK API level supports the 'cbcs' |
| * encryption scheme, specifically AES CBC encryption with possibility of pattern encryption. |
| * While 'cbcs' scheme was originally implemented in N, there was a bug (in the |
| * DRM code) which means that it didn't really work properly until N-MR1). |
| */ |
| @CalledByNative |
| static boolean platformSupportsCbcsEncryption(int sdk) { |
| return sdk >= Build.VERSION_CODES.N_MR1; |
| } |
| |
| /** |
| * Sets the encryption pattern value if and only if CryptoInfo.setPattern method is |
| * 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) { |
| ApiHelperForN.setCryptoInfoPattern(cryptoInfo, encrypt, skip); |
| } |
| } |
| } |
