Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/mediacodec/MediaCodecInfo.java

@@ -0,0 +1,250 @@
+package com.mbridge.msdk.playercommon.exoplayer2.mediacodec;
+
+import android.annotation.TargetApi;
+import android.graphics.Point;
+import android.media.MediaCodecInfo;
+import android.util.Log;
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public final class MediaCodecInfo {
+    public static final int MAX_SUPPORTED_INSTANCES_UNKNOWN = -1;
+    public static final String TAG = "MediaCodecInfo";
+    public final boolean adaptive;
+
+    @Nullable
+    public final MediaCodecInfo.CodecCapabilities capabilities;
+
+    @Nullable
+    public final String mimeType;
+    public final String name;
+    public final boolean passthrough;
+    public final boolean secure;
+    public final boolean tunneling;
+
+    public static MediaCodecInfo newPassthroughInstance(String str) {
+        return new MediaCodecInfo(str, null, null, true, false, false);
+    }
+
+    public static MediaCodecInfo newInstance(String str, String str2, MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return new MediaCodecInfo(str, str2, codecCapabilities, false, false, false);
+    }
+
+    public static MediaCodecInfo newInstance(String str, String str2, MediaCodecInfo.CodecCapabilities codecCapabilities, boolean z, boolean z2) {
+        return new MediaCodecInfo(str, str2, codecCapabilities, false, z, z2);
+    }
+
+    private MediaCodecInfo(String str, @Nullable String str2, @Nullable MediaCodecInfo.CodecCapabilities codecCapabilities, boolean z, boolean z2, boolean z3) {
+        this.name = (String) Assertions.checkNotNull(str);
+        this.mimeType = str2;
+        this.capabilities = codecCapabilities;
+        this.passthrough = z;
+        boolean z4 = true;
+        this.adaptive = (z2 || codecCapabilities == null || !isAdaptive(codecCapabilities)) ? false : true;
+        this.tunneling = codecCapabilities != null && isTunneling(codecCapabilities);
+        if (!z3 && (codecCapabilities == null || !isSecure(codecCapabilities))) {
+            z4 = false;
+        }
+        this.secure = z4;
+    }
+
+    public final MediaCodecInfo.CodecProfileLevel[] getProfileLevels() {
+        MediaCodecInfo.CodecProfileLevel[] codecProfileLevelArr;
+        MediaCodecInfo.CodecCapabilities codecCapabilities = this.capabilities;
+        return (codecCapabilities == null || (codecProfileLevelArr = codecCapabilities.profileLevels) == null) ? new MediaCodecInfo.CodecProfileLevel[0] : codecProfileLevelArr;
+    }
+
+    public final int getMaxSupportedInstances() {
+        MediaCodecInfo.CodecCapabilities codecCapabilities;
+        if (Util.SDK_INT < 23 || (codecCapabilities = this.capabilities) == null) {
+            return -1;
+        }
+        return getMaxSupportedInstancesV23(codecCapabilities);
+    }
+
+    public final boolean isCodecSupported(String str) {
+        String mediaMimeType;
+        if (str == null || this.mimeType == null || (mediaMimeType = MimeTypes.getMediaMimeType(str)) == null) {
+            return true;
+        }
+        if (!this.mimeType.equals(mediaMimeType)) {
+            logNoSupport("codec.mime " + str + ", " + mediaMimeType);
+            return false;
+        }
+        Pair<Integer, Integer> codecProfileAndLevel = MediaCodecUtil.getCodecProfileAndLevel(str);
+        if (codecProfileAndLevel == null) {
+            return true;
+        }
+        for (MediaCodecInfo.CodecProfileLevel codecProfileLevel : getProfileLevels()) {
+            if (codecProfileLevel.profile == ((Integer) codecProfileAndLevel.first).intValue() && codecProfileLevel.level >= ((Integer) codecProfileAndLevel.second).intValue()) {
+                return true;
+            }
+        }
+        logNoSupport("codec.profileLevel, " + str + ", " + mediaMimeType);
+        return false;
+    }
+
+    @TargetApi(21)
+    public final boolean isVideoSizeAndRateSupportedV21(int i, int i2, double d) {
+        MediaCodecInfo.CodecCapabilities codecCapabilities = this.capabilities;
+        if (codecCapabilities == null) {
+            logNoSupport("sizeAndRate.caps");
+            return false;
+        }
+        MediaCodecInfo.VideoCapabilities videoCapabilities = codecCapabilities.getVideoCapabilities();
+        if (videoCapabilities == null) {
+            logNoSupport("sizeAndRate.vCaps");
+            return false;
+        }
+        if (areSizeAndRateSupportedV21(videoCapabilities, i, i2, d)) {
+            return true;
+        }
+        if (i >= i2 || !areSizeAndRateSupportedV21(videoCapabilities, i2, i, d)) {
+            logNoSupport("sizeAndRate.support, " + i + "x" + i2 + "x" + d);
+            return false;
+        }
+        logAssumedSupport("sizeAndRate.rotated, " + i + "x" + i2 + "x" + d);
+        return true;
+    }
+
+    @TargetApi(21)
+    public final Point alignVideoSizeV21(int i, int i2) {
+        MediaCodecInfo.CodecCapabilities codecCapabilities = this.capabilities;
+        if (codecCapabilities == null) {
+            logNoSupport("align.caps");
+            return null;
+        }
+        MediaCodecInfo.VideoCapabilities videoCapabilities = codecCapabilities.getVideoCapabilities();
+        if (videoCapabilities == null) {
+            logNoSupport("align.vCaps");
+            return null;
+        }
+        int widthAlignment = videoCapabilities.getWidthAlignment();
+        int heightAlignment = videoCapabilities.getHeightAlignment();
+        return new Point(Util.ceilDivide(i, widthAlignment) * widthAlignment, Util.ceilDivide(i2, heightAlignment) * heightAlignment);
+    }
+
+    @TargetApi(21)
+    public final boolean isAudioSampleRateSupportedV21(int i) {
+        MediaCodecInfo.CodecCapabilities codecCapabilities = this.capabilities;
+        if (codecCapabilities == null) {
+            logNoSupport("sampleRate.caps");
+            return false;
+        }
+        MediaCodecInfo.AudioCapabilities audioCapabilities = codecCapabilities.getAudioCapabilities();
+        if (audioCapabilities == null) {
+            logNoSupport("sampleRate.aCaps");
+            return false;
+        }
+        if (audioCapabilities.isSampleRateSupported(i)) {
+            return true;
+        }
+        logNoSupport("sampleRate.support, " + i);
+        return false;
+    }
+
+    @TargetApi(21)
+    public final boolean isAudioChannelCountSupportedV21(int i) {
+        MediaCodecInfo.CodecCapabilities codecCapabilities = this.capabilities;
+        if (codecCapabilities == null) {
+            logNoSupport("channelCount.caps");
+            return false;
+        }
+        MediaCodecInfo.AudioCapabilities audioCapabilities = codecCapabilities.getAudioCapabilities();
+        if (audioCapabilities == null) {
+            logNoSupport("channelCount.aCaps");
+            return false;
+        }
+        if (adjustMaxInputChannelCount(this.name, this.mimeType, audioCapabilities.getMaxInputChannelCount()) >= i) {
+            return true;
+        }
+        logNoSupport("channelCount.support, " + i);
+        return false;
+    }
+
+    private void logNoSupport(String str) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("NoSupport [");
+        sb.append(str);
+        sb.append("] [");
+        sb.append(this.name);
+        sb.append(", ");
+        sb.append(this.mimeType);
+        sb.append("] [");
+        sb.append(Util.DEVICE_DEBUG_INFO);
+        sb.append(v8.i.e);
+    }
+
+    private void logAssumedSupport(String str) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("AssumedSupport [");
+        sb.append(str);
+        sb.append("] [");
+        sb.append(this.name);
+        sb.append(", ");
+        sb.append(this.mimeType);
+        sb.append("] [");
+        sb.append(Util.DEVICE_DEBUG_INFO);
+        sb.append(v8.i.e);
+    }
+
+    private static int adjustMaxInputChannelCount(String str, String str2, int i) {
+        int i2;
+        if (i > 1 || ((Util.SDK_INT >= 26 && i > 0) || MimeTypes.AUDIO_MPEG.equals(str2) || MimeTypes.AUDIO_AMR_NB.equals(str2) || MimeTypes.AUDIO_AMR_WB.equals(str2) || MimeTypes.AUDIO_AAC.equals(str2) || MimeTypes.AUDIO_VORBIS.equals(str2) || MimeTypes.AUDIO_OPUS.equals(str2) || MimeTypes.AUDIO_RAW.equals(str2) || MimeTypes.AUDIO_FLAC.equals(str2) || MimeTypes.AUDIO_ALAW.equals(str2) || MimeTypes.AUDIO_MLAW.equals(str2) || MimeTypes.AUDIO_MSGSM.equals(str2))) {
+            return i;
+        }
+        if (MimeTypes.AUDIO_AC3.equals(str2)) {
+            i2 = 6;
+        } else {
+            i2 = MimeTypes.AUDIO_E_AC3.equals(str2) ? 16 : 30;
+        }
+        Log.w(TAG, "AssumedMaxChannelAdjustment: " + str + ", [" + i + " to " + i2 + v8.i.e);
+        return i2;
+    }
+
+    private static boolean isAdaptive(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return Util.SDK_INT >= 19 && isAdaptiveV19(codecCapabilities);
+    }
+
+    @TargetApi(19)
+    private static boolean isAdaptiveV19(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return codecCapabilities.isFeatureSupported("adaptive-playback");
+    }
+
+    private static boolean isTunneling(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return Util.SDK_INT >= 21 && isTunnelingV21(codecCapabilities);
+    }
+
+    @TargetApi(21)
+    private static boolean isTunnelingV21(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return codecCapabilities.isFeatureSupported("tunneled-playback");
+    }
+
+    private static boolean isSecure(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return Util.SDK_INT >= 21 && isSecureV21(codecCapabilities);
+    }
+
+    @TargetApi(21)
+    private static boolean isSecureV21(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return codecCapabilities.isFeatureSupported("secure-playback");
+    }
+
+    @TargetApi(21)
+    private static boolean areSizeAndRateSupportedV21(MediaCodecInfo.VideoCapabilities videoCapabilities, int i, int i2, double d) {
+        if (d == -1.0d || d <= 0.0d) {
+            return videoCapabilities.isSizeSupported(i, i2);
+        }
+        return videoCapabilities.areSizeAndRateSupported(i, i2, d);
+    }
+
+    @TargetApi(23)
+    private static int getMaxSupportedInstancesV23(MediaCodecInfo.CodecCapabilities codecCapabilities) {
+        return codecCapabilities.getMaxSupportedInstances();
+    }
+}