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/util/CodecSpecificDataUtil.java

@@ -0,0 +1,200 @@
+package com.mbridge.msdk.playercommon.exoplayer2.util;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.ParserException;
+import java.util.ArrayList;
+
+/* loaded from: classes4.dex */
+public final class CodecSpecificDataUtil {
+    private static final int AUDIO_OBJECT_TYPE_AAC_LC = 2;
+    private static final int AUDIO_OBJECT_TYPE_ER_BSAC = 22;
+    private static final int AUDIO_OBJECT_TYPE_ESCAPE = 31;
+    private static final int AUDIO_OBJECT_TYPE_PS = 29;
+    private static final int AUDIO_OBJECT_TYPE_SBR = 5;
+    private static final int AUDIO_SPECIFIC_CONFIG_CHANNEL_CONFIGURATION_INVALID = -1;
+    private static final int AUDIO_SPECIFIC_CONFIG_FREQUENCY_INDEX_ARBITRARY = 15;
+    private static final byte[] NAL_START_CODE = {0, 0, 0, 1};
+    private static final int[] AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE = {96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350};
+    private static final int[] AUDIO_SPECIFIC_CONFIG_CHANNEL_COUNT_TABLE = {0, 1, 2, 3, 4, 5, 6, 8, -1, -1, -1, 7, 8, -1, 8, -1};
+
+    private CodecSpecificDataUtil() {
+    }
+
+    public static byte[] buildAacAudioSpecificConfig(int i, int i2, int i3) {
+        return new byte[]{(byte) (((i << 3) & 248) | ((i2 >> 1) & 7)), (byte) (((i2 << 7) & 128) | ((i3 << 3) & 120))};
+    }
+
+    public static Pair<Integer, Integer> parseAacAudioSpecificConfig(byte[] bArr) throws ParserException {
+        return parseAacAudioSpecificConfig(new ParsableBitArray(bArr), false);
+    }
+
+    public static Pair<Integer, Integer> parseAacAudioSpecificConfig(ParsableBitArray parsableBitArray, boolean z) throws ParserException {
+        int aacAudioObjectType = getAacAudioObjectType(parsableBitArray);
+        int aacSamplingFrequency = getAacSamplingFrequency(parsableBitArray);
+        int readBits = parsableBitArray.readBits(4);
+        if (aacAudioObjectType == 5 || aacAudioObjectType == 29) {
+            aacSamplingFrequency = getAacSamplingFrequency(parsableBitArray);
+            aacAudioObjectType = getAacAudioObjectType(parsableBitArray);
+            if (aacAudioObjectType == 22) {
+                readBits = parsableBitArray.readBits(4);
+            }
+        }
+        if (z) {
+            if (aacAudioObjectType != 1 && aacAudioObjectType != 2 && aacAudioObjectType != 3 && aacAudioObjectType != 4 && aacAudioObjectType != 6 && aacAudioObjectType != 7 && aacAudioObjectType != 17) {
+                switch (aacAudioObjectType) {
+                    case 19:
+                    case 20:
+                    case 21:
+                    case 22:
+                    case 23:
+                        break;
+                    default:
+                        throw new ParserException("Unsupported audio object type: " + aacAudioObjectType);
+                }
+            }
+            parseGaSpecificConfig(parsableBitArray, aacAudioObjectType, readBits);
+            switch (aacAudioObjectType) {
+                case 17:
+                case 19:
+                case 20:
+                case 21:
+                case 22:
+                case 23:
+                    int readBits2 = parsableBitArray.readBits(2);
+                    if (readBits2 == 2 || readBits2 == 3) {
+                        throw new ParserException("Unsupported epConfig: " + readBits2);
+                    }
+            }
+        }
+        int i = AUDIO_SPECIFIC_CONFIG_CHANNEL_COUNT_TABLE[readBits];
+        Assertions.checkArgument(i != -1);
+        return Pair.create(Integer.valueOf(aacSamplingFrequency), Integer.valueOf(i));
+    }
+
+    public static byte[] buildAacLcAudioSpecificConfig(int i, int i2) {
+        int i3 = 0;
+        int i4 = -1;
+        int i5 = 0;
+        while (true) {
+            int[] iArr = AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE;
+            if (i5 >= iArr.length) {
+                break;
+            }
+            if (i == iArr[i5]) {
+                i4 = i5;
+            }
+            i5++;
+        }
+        int i6 = -1;
+        while (true) {
+            int[] iArr2 = AUDIO_SPECIFIC_CONFIG_CHANNEL_COUNT_TABLE;
+            if (i3 >= iArr2.length) {
+                break;
+            }
+            if (i2 == iArr2[i3]) {
+                i6 = i3;
+            }
+            i3++;
+        }
+        if (i == -1 || i6 == -1) {
+            throw new IllegalArgumentException("Invalid sample rate or number of channels: " + i + ", " + i2);
+        }
+        return buildAacAudioSpecificConfig(2, i4, i6);
+    }
+
+    public static byte[] buildNalUnit(byte[] bArr, int i, int i2) {
+        byte[] bArr2 = NAL_START_CODE;
+        byte[] bArr3 = new byte[bArr2.length + i2];
+        System.arraycopy(bArr2, 0, bArr3, 0, bArr2.length);
+        System.arraycopy(bArr, i, bArr3, bArr2.length, i2);
+        return bArr3;
+    }
+
+    public static byte[][] splitNalUnits(byte[] bArr) {
+        if (!isNalStartCode(bArr, 0)) {
+            return null;
+        }
+        ArrayList arrayList = new ArrayList();
+        int i = 0;
+        do {
+            arrayList.add(Integer.valueOf(i));
+            i = findNalStartCode(bArr, i + NAL_START_CODE.length);
+        } while (i != -1);
+        byte[][] bArr2 = new byte[arrayList.size()][];
+        int i2 = 0;
+        while (i2 < arrayList.size()) {
+            int intValue = ((Integer) arrayList.get(i2)).intValue();
+            int intValue2 = (i2 < arrayList.size() + (-1) ? ((Integer) arrayList.get(i2 + 1)).intValue() : bArr.length) - intValue;
+            byte[] bArr3 = new byte[intValue2];
+            System.arraycopy(bArr, intValue, bArr3, 0, intValue2);
+            bArr2[i2] = bArr3;
+            i2++;
+        }
+        return bArr2;
+    }
+
+    private static int findNalStartCode(byte[] bArr, int i) {
+        int length = bArr.length - NAL_START_CODE.length;
+        while (i <= length) {
+            if (isNalStartCode(bArr, i)) {
+                return i;
+            }
+            i++;
+        }
+        return -1;
+    }
+
+    private static boolean isNalStartCode(byte[] bArr, int i) {
+        if (bArr.length - i <= NAL_START_CODE.length) {
+            return false;
+        }
+        int i2 = 0;
+        while (true) {
+            byte[] bArr2 = NAL_START_CODE;
+            if (i2 >= bArr2.length) {
+                return true;
+            }
+            if (bArr[i + i2] != bArr2[i2]) {
+                return false;
+            }
+            i2++;
+        }
+    }
+
+    private static int getAacAudioObjectType(ParsableBitArray parsableBitArray) {
+        int readBits = parsableBitArray.readBits(5);
+        return readBits == 31 ? parsableBitArray.readBits(6) + 32 : readBits;
+    }
+
+    private static int getAacSamplingFrequency(ParsableBitArray parsableBitArray) {
+        int readBits = parsableBitArray.readBits(4);
+        if (readBits == 15) {
+            return parsableBitArray.readBits(24);
+        }
+        Assertions.checkArgument(readBits < 13);
+        return AUDIO_SPECIFIC_CONFIG_SAMPLING_RATE_TABLE[readBits];
+    }
+
+    private static void parseGaSpecificConfig(ParsableBitArray parsableBitArray, int i, int i2) {
+        parsableBitArray.skipBits(1);
+        if (parsableBitArray.readBit()) {
+            parsableBitArray.skipBits(14);
+        }
+        boolean readBit = parsableBitArray.readBit();
+        if (i2 == 0) {
+            throw new UnsupportedOperationException();
+        }
+        if (i == 6 || i == 20) {
+            parsableBitArray.skipBits(3);
+        }
+        if (readBit) {
+            if (i == 22) {
+                parsableBitArray.skipBits(16);
+            }
+            if (i == 17 || i == 19 || i == 20 || i == 23) {
+                parsableBitArray.skipBits(3);
+            }
+            parsableBitArray.skipBits(1);
+        }
+    }
+}