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/audio/Ac3Util.java

@@ -0,0 +1,341 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.vungle.ads.internal.protos.Sdk;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import org.apache.http.HttpStatus;
+
+/* loaded from: classes4.dex */
+public final class Ac3Util {
+    private static final int AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT = 1536;
+    private static final int AUDIO_SAMPLES_PER_AUDIO_BLOCK = 256;
+    public static final int TRUEHD_RECHUNK_SAMPLE_COUNT = 16;
+    public static final int TRUEHD_SYNCFRAME_PREFIX_LENGTH = 10;
+    private static final int[] BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD = {1, 2, 3, 6};
+    private static final int[] SAMPLE_RATE_BY_FSCOD = {48000, 44100, 32000};
+    private static final int[] SAMPLE_RATE_BY_FSCOD2 = {24000, 22050, 16000};
+    private static final int[] CHANNEL_COUNT_BY_ACMOD = {2, 1, 2, 3, 3, 4, 4, 5};
+    private static final int[] BITRATE_BY_HALF_FRMSIZECOD = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, PsExtractor.AUDIO_STREAM, 224, 256, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 384, 448, 512, 576, 640};
+    private static final int[] SYNCFRAME_SIZE_WORDS_BY_HALF_FRMSIZECOD_44_1 = {69, 87, 104, 121, 139, 174, 208, 243, 278, 348, HttpStatus.SC_EXPECTATION_FAILED, 487, 557, 696, 835, 975, 1114, 1253, 1393};
+
+    private Ac3Util() {
+    }
+
+    public static int getAc3SyncframeAudioSampleCount() {
+        return AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT;
+    }
+
+    public static final class SyncFrameInfo {
+        public static final int STREAM_TYPE_TYPE0 = 0;
+        public static final int STREAM_TYPE_TYPE1 = 1;
+        public static final int STREAM_TYPE_TYPE2 = 2;
+        public static final int STREAM_TYPE_UNDEFINED = -1;
+        public final int channelCount;
+        public final int frameSize;
+        public final String mimeType;
+        public final int sampleCount;
+        public final int sampleRate;
+        public final int streamType;
+
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface StreamType {
+        }
+
+        private SyncFrameInfo(String str, int i, int i2, int i3, int i4, int i5) {
+            this.mimeType = str;
+            this.streamType = i;
+            this.channelCount = i2;
+            this.sampleRate = i3;
+            this.frameSize = i4;
+            this.sampleCount = i5;
+        }
+    }
+
+    public static Format parseAc3AnnexFFormat(ParsableByteArray parsableByteArray, String str, String str2, DrmInitData drmInitData) {
+        int i = SAMPLE_RATE_BY_FSCOD[(parsableByteArray.readUnsignedByte() & PsExtractor.AUDIO_STREAM) >> 6];
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i2 = CHANNEL_COUNT_BY_ACMOD[(readUnsignedByte & 56) >> 3];
+        if ((readUnsignedByte & 4) != 0) {
+            i2++;
+        }
+        return Format.createAudioSampleFormat(str, MimeTypes.AUDIO_AC3, null, -1, -1, i2, i, null, drmInitData, 0, str2);
+    }
+
+    public static Format parseEAc3AnnexFFormat(ParsableByteArray parsableByteArray, String str, String str2, DrmInitData drmInitData) {
+        parsableByteArray.skipBytes(2);
+        int i = SAMPLE_RATE_BY_FSCOD[(parsableByteArray.readUnsignedByte() & PsExtractor.AUDIO_STREAM) >> 6];
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i2 = CHANNEL_COUNT_BY_ACMOD[(readUnsignedByte & 14) >> 1];
+        if ((readUnsignedByte & 1) != 0) {
+            i2++;
+        }
+        if (((parsableByteArray.readUnsignedByte() & 30) >> 1) > 0 && (2 & parsableByteArray.readUnsignedByte()) != 0) {
+            i2 += 2;
+        }
+        return Format.createAudioSampleFormat(str, (parsableByteArray.bytesLeft() <= 0 || (parsableByteArray.readUnsignedByte() & 1) == 0) ? MimeTypes.AUDIO_E_AC3 : MimeTypes.AUDIO_E_AC3_JOC, null, -1, -1, i2, i, null, drmInitData, 0, str2);
+    }
+
+    public static SyncFrameInfo parseAc3SyncframeInfo(ParsableBitArray parsableBitArray) {
+        int ac3SyncframeSize;
+        int i;
+        int i2;
+        String str;
+        int i3;
+        int readBits;
+        int i4;
+        int i5;
+        int position = parsableBitArray.getPosition();
+        parsableBitArray.skipBits(40);
+        boolean z = parsableBitArray.readBits(5) == 16;
+        parsableBitArray.setPosition(position);
+        int i6 = -1;
+        if (z) {
+            parsableBitArray.skipBits(16);
+            int readBits2 = parsableBitArray.readBits(2);
+            if (readBits2 == 0) {
+                i6 = 0;
+            } else if (readBits2 == 1) {
+                i6 = 1;
+            } else if (readBits2 == 2) {
+                i6 = 2;
+            }
+            parsableBitArray.skipBits(3);
+            ac3SyncframeSize = (parsableBitArray.readBits(11) + 1) * 2;
+            int readBits3 = parsableBitArray.readBits(2);
+            if (readBits3 == 3) {
+                i4 = 6;
+                i = SAMPLE_RATE_BY_FSCOD2[parsableBitArray.readBits(2)];
+                readBits = 3;
+            } else {
+                readBits = parsableBitArray.readBits(2);
+                i4 = BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD[readBits];
+                i = SAMPLE_RATE_BY_FSCOD[readBits3];
+            }
+            i3 = i4 * 256;
+            int readBits4 = parsableBitArray.readBits(3);
+            boolean readBit = parsableBitArray.readBit();
+            i2 = CHANNEL_COUNT_BY_ACMOD[readBits4] + (readBit ? 1 : 0);
+            parsableBitArray.skipBits(10);
+            if (parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(8);
+            }
+            if (readBits4 == 0) {
+                parsableBitArray.skipBits(5);
+                if (parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+            }
+            if (i6 == 1 && parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(16);
+            }
+            if (parsableBitArray.readBit()) {
+                if (readBits4 > 2) {
+                    parsableBitArray.skipBits(2);
+                }
+                if ((readBits4 & 1) != 0 && readBits4 > 2) {
+                    parsableBitArray.skipBits(6);
+                }
+                if ((readBits4 & 4) != 0) {
+                    parsableBitArray.skipBits(6);
+                }
+                if (readBit && parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(5);
+                }
+                if (i6 == 0) {
+                    if (parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    if (readBits4 == 0 && parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    if (parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    int readBits5 = parsableBitArray.readBits(2);
+                    if (readBits5 == 1) {
+                        parsableBitArray.skipBits(5);
+                    } else if (readBits5 == 2) {
+                        parsableBitArray.skipBits(12);
+                    } else if (readBits5 == 3) {
+                        int readBits6 = parsableBitArray.readBits(5);
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(5);
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(4);
+                                }
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(4);
+                                }
+                            }
+                        }
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(5);
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(7);
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(8);
+                                }
+                            }
+                        }
+                        parsableBitArray.skipBits((readBits6 + 2) * 8);
+                        parsableBitArray.byteAlign();
+                    }
+                    if (readBits4 < 2) {
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(14);
+                        }
+                        if (readBits4 == 0 && parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(14);
+                        }
+                    }
+                    if (parsableBitArray.readBit()) {
+                        if (readBits == 0) {
+                            parsableBitArray.skipBits(5);
+                        } else {
+                            for (int i7 = 0; i7 < i4; i7++) {
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(5);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(5);
+                if (readBits4 == 2) {
+                    parsableBitArray.skipBits(4);
+                }
+                if (readBits4 >= 6) {
+                    parsableBitArray.skipBits(2);
+                }
+                if (parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+                if (readBits4 == 0 && parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+                i5 = 3;
+                if (readBits3 < 3) {
+                    parsableBitArray.skipBit();
+                }
+            } else {
+                i5 = 3;
+            }
+            if (i6 == 0 && readBits != i5) {
+                parsableBitArray.skipBit();
+            }
+            if (i6 == 2 && (readBits == i5 || parsableBitArray.readBit())) {
+                parsableBitArray.skipBits(6);
+            }
+            str = (parsableBitArray.readBit() && parsableBitArray.readBits(6) == 1 && parsableBitArray.readBits(8) == 1) ? MimeTypes.AUDIO_E_AC3_JOC : MimeTypes.AUDIO_E_AC3;
+        } else {
+            parsableBitArray.skipBits(32);
+            int readBits7 = parsableBitArray.readBits(2);
+            ac3SyncframeSize = getAc3SyncframeSize(readBits7, parsableBitArray.readBits(6));
+            parsableBitArray.skipBits(8);
+            int readBits8 = parsableBitArray.readBits(3);
+            if ((readBits8 & 1) != 0 && readBits8 != 1) {
+                parsableBitArray.skipBits(2);
+            }
+            if ((readBits8 & 4) != 0) {
+                parsableBitArray.skipBits(2);
+            }
+            if (readBits8 == 2) {
+                parsableBitArray.skipBits(2);
+            }
+            i = SAMPLE_RATE_BY_FSCOD[readBits7];
+            i2 = CHANNEL_COUNT_BY_ACMOD[readBits8] + (parsableBitArray.readBit() ? 1 : 0);
+            str = MimeTypes.AUDIO_AC3;
+            i3 = AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT;
+        }
+        return new SyncFrameInfo(str, i6, i2, i, ac3SyncframeSize, i3);
+    }
+
+    public static int parseAc3SyncframeSize(byte[] bArr) {
+        if (bArr.length < 5) {
+            return -1;
+        }
+        byte b = bArr[4];
+        return getAc3SyncframeSize((b & 192) >> 6, b & 63);
+    }
+
+    public static int parseEAc3SyncframeAudioSampleCount(ByteBuffer byteBuffer) {
+        return (((byteBuffer.get(byteBuffer.position() + 4) & 192) >> 6) != 3 ? BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD[(byteBuffer.get(byteBuffer.position() + 4) & 48) >> 4] : 6) * 256;
+    }
+
+    public static int findTrueHdSyncframeOffset(ByteBuffer byteBuffer) {
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit() - 10;
+        for (int i = position; i <= limit; i++) {
+            if ((byteBuffer.getInt(i + 4) & (-16777217)) == -1167101192) {
+                return i - position;
+            }
+        }
+        return -1;
+    }
+
+    public static int parseTrueHdSyncframeAudioSampleCount(byte[] bArr) {
+        if (bArr[4] == -8 && bArr[5] == 114 && bArr[6] == 111) {
+            byte b = bArr[7];
+            if ((b & 254) == 186) {
+                return 40 << ((bArr[(b & 255) == 187 ? '\t' : '\b'] >> 4) & 7);
+            }
+        }
+        return 0;
+    }
+
+    public static int parseTrueHdSyncframeAudioSampleCount(ByteBuffer byteBuffer, int i) {
+        return 40 << ((byteBuffer.get((byteBuffer.position() + i) + ((byteBuffer.get((byteBuffer.position() + i) + 7) & 255) == 187 ? 9 : 8)) >> 4) & 7);
+    }
+
+    private static int getAc3SyncframeSize(int i, int i2) {
+        int i3 = i2 / 2;
+        if (i < 0) {
+            return -1;
+        }
+        int[] iArr = SAMPLE_RATE_BY_FSCOD;
+        if (i >= iArr.length || i2 < 0) {
+            return -1;
+        }
+        int[] iArr2 = SYNCFRAME_SIZE_WORDS_BY_HALF_FRMSIZECOD_44_1;
+        if (i3 >= iArr2.length) {
+            return -1;
+        }
+        int i4 = iArr[i];
+        if (i4 == 44100) {
+            return (iArr2[i3] + (i2 % 2)) * 2;
+        }
+        int i5 = BITRATE_BY_HALF_FRMSIZECOD[i3];
+        return i4 == 32000 ? i5 * 6 : i5 * 4;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioAttributes.java

@@ -0,0 +1,69 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.TargetApi;
+import android.media.AudioAttributes;
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+
+/* loaded from: classes4.dex */
+public final class AudioAttributes {
+    public static final AudioAttributes DEFAULT = new Builder().build();
+    private android.media.AudioAttributes audioAttributesV21;
+    public final int contentType;
+    public final int flags;
+    public final int usage;
+
+    public final int hashCode() {
+        return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.contentType) * 31) + this.flags) * 31) + this.usage;
+    }
+
+    public static final class Builder {
+        private int contentType = 0;
+        private int flags = 0;
+        private int usage = 1;
+
+        public final Builder setContentType(int i) {
+            this.contentType = i;
+            return this;
+        }
+
+        public final Builder setFlags(int i) {
+            this.flags = i;
+            return this;
+        }
+
+        public final Builder setUsage(int i) {
+            this.usage = i;
+            return this;
+        }
+
+        public final AudioAttributes build() {
+            return new AudioAttributes(this.contentType, this.flags, this.usage);
+        }
+    }
+
+    private AudioAttributes(int i, int i2, int i3) {
+        this.contentType = i;
+        this.flags = i2;
+        this.usage = i3;
+    }
+
+    @TargetApi(21)
+    public final android.media.AudioAttributes getAudioAttributesV21() {
+        if (this.audioAttributesV21 == null) {
+            this.audioAttributesV21 = new AudioAttributes.Builder().setContentType(this.contentType).setFlags(this.flags).setUsage(this.usage).build();
+        }
+        return this.audioAttributesV21;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || AudioAttributes.class != obj.getClass()) {
+            return false;
+        }
+        AudioAttributes audioAttributes = (AudioAttributes) obj;
+        return this.contentType == audioAttributes.contentType && this.flags == audioAttributes.flags && this.usage == audioAttributes.usage;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioCapabilities.java

@@ -0,0 +1,65 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import java.util.Arrays;
+
+@TargetApi(21)
+/* loaded from: classes4.dex */
+public final class AudioCapabilities {
+    public static final AudioCapabilities DEFAULT_AUDIO_CAPABILITIES = new AudioCapabilities(new int[]{2}, 2);
+    private final int maxChannelCount;
+    private final int[] supportedEncodings;
+
+    public final int getMaxChannelCount() {
+        return this.maxChannelCount;
+    }
+
+    public static AudioCapabilities getCapabilities(Context context) {
+        return getCapabilities(context.registerReceiver(null, new IntentFilter("android.media.action.HDMI_AUDIO_PLUG")));
+    }
+
+    @SuppressLint({"InlinedApi"})
+    public static AudioCapabilities getCapabilities(Intent intent) {
+        return (intent == null || intent.getIntExtra("android.media.extra.AUDIO_PLUG_STATE", 0) == 0) ? DEFAULT_AUDIO_CAPABILITIES : new AudioCapabilities(intent.getIntArrayExtra("android.media.extra.ENCODINGS"), intent.getIntExtra("android.media.extra.MAX_CHANNEL_COUNT", 0));
+    }
+
+    public AudioCapabilities(int[] iArr, int i) {
+        if (iArr != null) {
+            int[] copyOf = Arrays.copyOf(iArr, iArr.length);
+            this.supportedEncodings = copyOf;
+            Arrays.sort(copyOf);
+        } else {
+            this.supportedEncodings = new int[0];
+        }
+        this.maxChannelCount = i;
+    }
+
+    public final boolean supportsEncoding(int i) {
+        return Arrays.binarySearch(this.supportedEncodings, i) >= 0;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AudioCapabilities)) {
+            return false;
+        }
+        AudioCapabilities audioCapabilities = (AudioCapabilities) obj;
+        return Arrays.equals(this.supportedEncodings, audioCapabilities.supportedEncodings) && this.maxChannelCount == audioCapabilities.maxChannelCount;
+    }
+
+    public final int hashCode() {
+        return this.maxChannelCount + (Arrays.hashCode(this.supportedEncodings) * 31);
+    }
+
+    public final String toString() {
+        return "AudioCapabilities[maxChannelCount=" + this.maxChannelCount + ", supportedEncodings=" + Arrays.toString(this.supportedEncodings) + v8.i.e;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioCapabilitiesReceiver.java

@@ -0,0 +1,60 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class AudioCapabilitiesReceiver {
+    AudioCapabilities audioCapabilities;
+    private final Context context;
+    private final Listener listener;
+    private final BroadcastReceiver receiver;
+
+    public interface Listener {
+        void onAudioCapabilitiesChanged(AudioCapabilities audioCapabilities);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public AudioCapabilitiesReceiver(Context context, Listener listener) {
+        this.context = (Context) Assertions.checkNotNull(context);
+        this.listener = (Listener) Assertions.checkNotNull(listener);
+        this.receiver = Util.SDK_INT >= 21 ? new HdmiAudioPlugBroadcastReceiver() : null;
+    }
+
+    public final AudioCapabilities register() {
+        BroadcastReceiver broadcastReceiver = this.receiver;
+        AudioCapabilities capabilities = AudioCapabilities.getCapabilities(broadcastReceiver == null ? null : this.context.registerReceiver(broadcastReceiver, new IntentFilter("android.media.action.HDMI_AUDIO_PLUG")));
+        this.audioCapabilities = capabilities;
+        return capabilities;
+    }
+
+    public final void unregister() {
+        BroadcastReceiver broadcastReceiver = this.receiver;
+        if (broadcastReceiver != null) {
+            this.context.unregisterReceiver(broadcastReceiver);
+        }
+    }
+
+    public final class HdmiAudioPlugBroadcastReceiver extends BroadcastReceiver {
+        private HdmiAudioPlugBroadcastReceiver() {
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public final void onReceive(Context context, Intent intent) {
+            if (isInitialStickyBroadcast()) {
+                return;
+            }
+            AudioCapabilities capabilities = AudioCapabilities.getCapabilities(intent);
+            if (capabilities.equals(AudioCapabilitiesReceiver.this.audioCapabilities)) {
+                return;
+            }
+            AudioCapabilitiesReceiver audioCapabilitiesReceiver = AudioCapabilitiesReceiver.this;
+            audioCapabilitiesReceiver.audioCapabilities = capabilities;
+            audioCapabilitiesReceiver.listener.onAudioCapabilitiesChanged(capabilities);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioDecoderException.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+/* loaded from: classes4.dex */
+public class AudioDecoderException extends Exception {
+    public AudioDecoderException(String str) {
+        super(str);
+    }
+
+    public AudioDecoderException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioProcessor.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public interface AudioProcessor {
+    public static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocateDirect(0).order(ByteOrder.nativeOrder());
+
+    boolean configure(int i, int i2, int i3) throws UnhandledFormatException;
+
+    void flush();
+
+    ByteBuffer getOutput();
+
+    int getOutputChannelCount();
+
+    int getOutputEncoding();
+
+    int getOutputSampleRateHz();
+
+    boolean isActive();
+
+    boolean isEnded();
+
+    void queueEndOfStream();
+
+    void queueInput(ByteBuffer byteBuffer);
+
+    void reset();
+
+    public static final class UnhandledFormatException extends Exception {
+        public UnhandledFormatException(int i, int i2, int i3) {
+            super("Unhandled format: " + i + " Hz, " + i2 + " channels in encoding " + i3);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioRendererEventListener.java

@@ -0,0 +1,103 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.os.Handler;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public interface AudioRendererEventListener {
+    void onAudioDecoderInitialized(String str, long j, long j2);
+
+    void onAudioDisabled(DecoderCounters decoderCounters);
+
+    void onAudioEnabled(DecoderCounters decoderCounters);
+
+    void onAudioInputFormatChanged(Format format);
+
+    void onAudioSessionId(int i);
+
+    void onAudioSinkUnderrun(int i, long j, long j2);
+
+    public static final class EventDispatcher {
+
+        @Nullable
+        private final Handler handler;
+
+        @Nullable
+        private final AudioRendererEventListener listener;
+
+        public EventDispatcher(@Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+            this.handler = audioRendererEventListener != null ? (Handler) Assertions.checkNotNull(handler) : null;
+            this.listener = audioRendererEventListener;
+        }
+
+        public final void enabled(final DecoderCounters decoderCounters) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioEnabled(decoderCounters);
+                    }
+                });
+            }
+        }
+
+        public final void decoderInitialized(final String str, final long j, final long j2) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioDecoderInitialized(str, j, j2);
+                    }
+                });
+            }
+        }
+
+        public final void inputFormatChanged(final Format format) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioInputFormatChanged(format);
+                    }
+                });
+            }
+        }
+
+        public final void audioTrackUnderrun(final int i, final long j, final long j2) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.4
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioSinkUnderrun(i, j, j2);
+                    }
+                });
+            }
+        }
+
+        public final void disabled(final DecoderCounters decoderCounters) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.5
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        decoderCounters.ensureUpdated();
+                        EventDispatcher.this.listener.onAudioDisabled(decoderCounters);
+                    }
+                });
+            }
+        }
+
+        public final void audioSessionId(final int i) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.6
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioSessionId(i);
+                    }
+                });
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioSink.java

@@ -0,0 +1,86 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public interface AudioSink {
+    public static final long CURRENT_POSITION_NOT_SET = Long.MIN_VALUE;
+
+    public interface Listener {
+        void onAudioSessionId(int i);
+
+        void onPositionDiscontinuity();
+
+        void onUnderrun(int i, long j, long j2);
+    }
+
+    void configure(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5, int i6) throws ConfigurationException;
+
+    void disableTunneling();
+
+    void enableTunnelingV21(int i);
+
+    long getCurrentPositionUs(boolean z);
+
+    PlaybackParameters getPlaybackParameters();
+
+    boolean handleBuffer(ByteBuffer byteBuffer, long j) throws InitializationException, WriteException;
+
+    void handleDiscontinuity();
+
+    boolean hasPendingData();
+
+    boolean isEncodingSupported(int i);
+
+    boolean isEnded();
+
+    void pause();
+
+    void play();
+
+    void playToEndOfStream() throws WriteException;
+
+    void release();
+
+    void reset();
+
+    void setAudioAttributes(AudioAttributes audioAttributes);
+
+    void setAudioSessionId(int i);
+
+    void setListener(Listener listener);
+
+    PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters);
+
+    void setVolume(float f);
+
+    public static final class ConfigurationException extends Exception {
+        public ConfigurationException(Throwable th) {
+            super(th);
+        }
+
+        public ConfigurationException(String str) {
+            super(str);
+        }
+    }
+
+    public static final class InitializationException extends Exception {
+        public final int audioTrackState;
+
+        public InitializationException(int i, int i2, int i3, int i4) {
+            super("AudioTrack init failed: " + i + ", Config(" + i2 + ", " + i3 + ", " + i4 + ")");
+            this.audioTrackState = i;
+        }
+    }
+
+    public static final class WriteException extends Exception {
+        public final int errorCode;
+
+        public WriteException(int i) {
+            super("AudioTrack write failed: " + i);
+            this.errorCode = i;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioTimestampPoller.java

@@ -0,0 +1,178 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.TargetApi;
+import android.media.AudioTimestamp;
+import android.media.AudioTrack;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+final class AudioTimestampPoller {
+    private static final int ERROR_POLL_INTERVAL_US = 500000;
+    private static final int FAST_POLL_INTERVAL_US = 5000;
+    private static final int INITIALIZING_DURATION_US = 500000;
+    private static final int SLOW_POLL_INTERVAL_US = 10000000;
+    private static final int STATE_ERROR = 4;
+    private static final int STATE_INITIALIZING = 0;
+    private static final int STATE_NO_TIMESTAMP = 3;
+    private static final int STATE_TIMESTAMP = 1;
+    private static final int STATE_TIMESTAMP_ADVANCING = 2;
+
+    @Nullable
+    private final AudioTimestampV19 audioTimestamp;
+    private long initialTimestampPositionFrames;
+    private long initializeSystemTimeUs;
+    private long lastTimestampSampleTimeUs;
+    private long sampleIntervalUs;
+    private int state;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    public final boolean hasTimestamp() {
+        int i = this.state;
+        return i == 1 || i == 2;
+    }
+
+    public final boolean isTimestampAdvancing() {
+        return this.state == 2;
+    }
+
+    public AudioTimestampPoller(AudioTrack audioTrack) {
+        if (Util.SDK_INT >= 19) {
+            this.audioTimestamp = new AudioTimestampV19(audioTrack);
+            reset();
+        } else {
+            this.audioTimestamp = null;
+            updateState(3);
+        }
+    }
+
+    public final boolean maybePollTimestamp(long j) {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        if (audioTimestampV19 == null || j - this.lastTimestampSampleTimeUs < this.sampleIntervalUs) {
+            return false;
+        }
+        this.lastTimestampSampleTimeUs = j;
+        boolean maybeUpdateTimestamp = audioTimestampV19.maybeUpdateTimestamp();
+        int i = this.state;
+        if (i != 0) {
+            if (i != 1) {
+                if (i != 2) {
+                    if (i != 3) {
+                        if (i != 4) {
+                            throw new IllegalStateException();
+                        }
+                    } else if (maybeUpdateTimestamp) {
+                        reset();
+                    }
+                } else if (!maybeUpdateTimestamp) {
+                    reset();
+                }
+            } else if (!maybeUpdateTimestamp) {
+                reset();
+            } else if (this.audioTimestamp.getTimestampPositionFrames() > this.initialTimestampPositionFrames) {
+                updateState(2);
+            }
+        } else if (maybeUpdateTimestamp) {
+            if (this.audioTimestamp.getTimestampSystemTimeUs() < this.initializeSystemTimeUs) {
+                return false;
+            }
+            this.initialTimestampPositionFrames = this.audioTimestamp.getTimestampPositionFrames();
+            updateState(1);
+        } else if (j - this.initializeSystemTimeUs > 500000) {
+            updateState(3);
+        }
+        return maybeUpdateTimestamp;
+    }
+
+    public final void rejectTimestamp() {
+        updateState(4);
+    }
+
+    public final void acceptTimestamp() {
+        if (this.state == 4) {
+            reset();
+        }
+    }
+
+    public final void reset() {
+        if (this.audioTimestamp != null) {
+            updateState(0);
+        }
+    }
+
+    public final long getTimestampSystemTimeUs() {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        return audioTimestampV19 != null ? audioTimestampV19.getTimestampSystemTimeUs() : C.TIME_UNSET;
+    }
+
+    public final long getTimestampPositionFrames() {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        if (audioTimestampV19 != null) {
+            return audioTimestampV19.getTimestampPositionFrames();
+        }
+        return -1L;
+    }
+
+    private void updateState(int i) {
+        this.state = i;
+        if (i == 0) {
+            this.lastTimestampSampleTimeUs = 0L;
+            this.initialTimestampPositionFrames = -1L;
+            this.initializeSystemTimeUs = System.nanoTime() / 1000;
+            this.sampleIntervalUs = 5000L;
+            return;
+        }
+        if (i == 1) {
+            this.sampleIntervalUs = 5000L;
+            return;
+        }
+        if (i == 2 || i == 3) {
+            this.sampleIntervalUs = 10000000L;
+        } else {
+            if (i != 4) {
+                throw new IllegalStateException();
+            }
+            this.sampleIntervalUs = 500000L;
+        }
+    }
+
+    @TargetApi(19)
+    public static final class AudioTimestampV19 {
+        private final AudioTimestamp audioTimestamp = new AudioTimestamp();
+        private final AudioTrack audioTrack;
+        private long lastTimestampPositionFrames;
+        private long lastTimestampRawPositionFrames;
+        private long rawTimestampFramePositionWrapCount;
+
+        public final long getTimestampPositionFrames() {
+            return this.lastTimestampPositionFrames;
+        }
+
+        public AudioTimestampV19(AudioTrack audioTrack) {
+            this.audioTrack = audioTrack;
+        }
+
+        public final boolean maybeUpdateTimestamp() {
+            boolean timestamp = this.audioTrack.getTimestamp(this.audioTimestamp);
+            if (timestamp) {
+                long j = this.audioTimestamp.framePosition;
+                if (this.lastTimestampRawPositionFrames > j) {
+                    this.rawTimestampFramePositionWrapCount++;
+                }
+                this.lastTimestampRawPositionFrames = j;
+                this.lastTimestampPositionFrames = j + (this.rawTimestampFramePositionWrapCount << 32);
+            }
+            return timestamp;
+        }
+
+        public final long getTimestampSystemTimeUs() {
+            return this.audioTimestamp.nanoTime / 1000;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioTrackPositionTracker.java

@@ -0,0 +1,292 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.media.AudioTrack;
+import android.os.SystemClock;
+import androidx.work.WorkRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+/* loaded from: classes4.dex */
+final class AudioTrackPositionTracker {
+    private static final long FORCE_RESET_WORKAROUND_TIMEOUT_MS = 200;
+    private static final long MAX_AUDIO_TIMESTAMP_OFFSET_US = 5000000;
+    private static final long MAX_LATENCY_US = 5000000;
+    private static final int MAX_PLAYHEAD_OFFSET_COUNT = 10;
+    private static final int MIN_LATENCY_SAMPLE_INTERVAL_US = 500000;
+    private static final int MIN_PLAYHEAD_OFFSET_SAMPLE_INTERVAL_US = 30000;
+    private static final int PLAYSTATE_PAUSED = 2;
+    private static final int PLAYSTATE_PLAYING = 3;
+    private static final int PLAYSTATE_STOPPED = 1;
+    private AudioTimestampPoller audioTimestampPoller;
+    private AudioTrack audioTrack;
+    private int bufferSize;
+    private long bufferSizeUs;
+    private long endPlaybackHeadPosition;
+    private long forceResetWorkaroundTimeMs;
+    private Method getLatencyMethod;
+    private boolean hasData;
+    private boolean isOutputPcm;
+    private long lastLatencySampleTimeUs;
+    private long lastPlayheadSampleTimeUs;
+    private long lastRawPlaybackHeadPosition;
+    private long latencyUs;
+    private final Listener listener;
+    private boolean needsPassthroughWorkarounds;
+    private int nextPlayheadOffsetIndex;
+    private int outputPcmFrameSize;
+    private int outputSampleRate;
+    private long passthroughWorkaroundPauseOffset;
+    private int playheadOffsetCount;
+    private final long[] playheadOffsets;
+    private long rawPlaybackHeadWrapCount;
+    private long smoothedPlayheadOffsetUs;
+    private long stopPlaybackHeadPosition;
+    private long stopTimestampUs;
+
+    public interface Listener {
+        void onInvalidLatency(long j);
+
+        void onPositionFramesMismatch(long j, long j2, long j3, long j4);
+
+        void onSystemTimeUsMismatch(long j, long j2, long j3, long j4);
+
+        void onUnderrun(int i, long j);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface PlayState {
+    }
+
+    private void resetSyncParams() {
+        this.smoothedPlayheadOffsetUs = 0L;
+        this.playheadOffsetCount = 0;
+        this.nextPlayheadOffsetIndex = 0;
+        this.lastPlayheadSampleTimeUs = 0L;
+    }
+
+    public AudioTrackPositionTracker(Listener listener) {
+        this.listener = (Listener) Assertions.checkNotNull(listener);
+        if (Util.SDK_INT >= 18) {
+            try {
+                this.getLatencyMethod = AudioTrack.class.getMethod("getLatency", null);
+            } catch (NoSuchMethodException unused) {
+            }
+        }
+        this.playheadOffsets = new long[10];
+    }
+
+    public final void setAudioTrack(AudioTrack audioTrack, int i, int i2, int i3) {
+        this.audioTrack = audioTrack;
+        this.outputPcmFrameSize = i2;
+        this.bufferSize = i3;
+        this.audioTimestampPoller = new AudioTimestampPoller(audioTrack);
+        this.outputSampleRate = audioTrack.getSampleRate();
+        this.needsPassthroughWorkarounds = needsPassthroughWorkarounds(i);
+        boolean isEncodingPcm = Util.isEncodingPcm(i);
+        this.isOutputPcm = isEncodingPcm;
+        this.bufferSizeUs = isEncodingPcm ? framesToDurationUs(i3 / i2) : -9223372036854775807L;
+        this.lastRawPlaybackHeadPosition = 0L;
+        this.rawPlaybackHeadWrapCount = 0L;
+        this.passthroughWorkaroundPauseOffset = 0L;
+        this.hasData = false;
+        this.stopTimestampUs = C.TIME_UNSET;
+        this.forceResetWorkaroundTimeMs = C.TIME_UNSET;
+        this.latencyUs = 0L;
+    }
+
+    public final long getCurrentPositionUs(boolean z) {
+        if (this.audioTrack.getPlayState() == 3) {
+            maybeSampleSyncParams();
+        }
+        long nanoTime = System.nanoTime() / 1000;
+        if (this.audioTimestampPoller.hasTimestamp()) {
+            long framesToDurationUs = framesToDurationUs(this.audioTimestampPoller.getTimestampPositionFrames());
+            return !this.audioTimestampPoller.isTimestampAdvancing() ? framesToDurationUs : framesToDurationUs + (nanoTime - this.audioTimestampPoller.getTimestampSystemTimeUs());
+        }
+        long playbackHeadPositionUs = this.playheadOffsetCount == 0 ? getPlaybackHeadPositionUs() : nanoTime + this.smoothedPlayheadOffsetUs;
+        return !z ? playbackHeadPositionUs - this.latencyUs : playbackHeadPositionUs;
+    }
+
+    public final void start() {
+        this.audioTimestampPoller.reset();
+    }
+
+    public final boolean isPlaying() {
+        return this.audioTrack.getPlayState() == 3;
+    }
+
+    public final boolean mayHandleBuffer(long j) {
+        Listener listener;
+        int playState = this.audioTrack.getPlayState();
+        if (this.needsPassthroughWorkarounds) {
+            if (playState == 2) {
+                this.hasData = false;
+                return false;
+            }
+            if (playState == 1 && getPlaybackHeadPosition() == 0) {
+                return false;
+            }
+        }
+        boolean z = this.hasData;
+        boolean hasPendingData = hasPendingData(j);
+        this.hasData = hasPendingData;
+        if (z && !hasPendingData && playState != 1 && (listener = this.listener) != null) {
+            listener.onUnderrun(this.bufferSize, C.usToMs(this.bufferSizeUs));
+        }
+        return true;
+    }
+
+    public final int getAvailableBufferSize(long j) {
+        return this.bufferSize - ((int) (j - (getPlaybackHeadPosition() * this.outputPcmFrameSize)));
+    }
+
+    public final boolean isStalled(long j) {
+        return this.forceResetWorkaroundTimeMs != C.TIME_UNSET && j > 0 && SystemClock.elapsedRealtime() - this.forceResetWorkaroundTimeMs >= FORCE_RESET_WORKAROUND_TIMEOUT_MS;
+    }
+
+    public final void handleEndOfStream(long j) {
+        this.stopPlaybackHeadPosition = getPlaybackHeadPosition();
+        this.stopTimestampUs = SystemClock.elapsedRealtime() * 1000;
+        this.endPlaybackHeadPosition = j;
+    }
+
+    public final boolean hasPendingData(long j) {
+        return j > getPlaybackHeadPosition() || forceHasPendingData();
+    }
+
+    public final boolean pause() {
+        resetSyncParams();
+        if (this.stopTimestampUs != C.TIME_UNSET) {
+            return false;
+        }
+        this.audioTimestampPoller.reset();
+        return true;
+    }
+
+    public final void reset() {
+        resetSyncParams();
+        this.audioTrack = null;
+        this.audioTimestampPoller = null;
+    }
+
+    private void maybeSampleSyncParams() {
+        long playbackHeadPositionUs = getPlaybackHeadPositionUs();
+        if (playbackHeadPositionUs == 0) {
+            return;
+        }
+        long nanoTime = System.nanoTime() / 1000;
+        if (nanoTime - this.lastPlayheadSampleTimeUs >= WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS) {
+            long[] jArr = this.playheadOffsets;
+            int i = this.nextPlayheadOffsetIndex;
+            jArr[i] = playbackHeadPositionUs - nanoTime;
+            this.nextPlayheadOffsetIndex = (i + 1) % 10;
+            int i2 = this.playheadOffsetCount;
+            if (i2 < 10) {
+                this.playheadOffsetCount = i2 + 1;
+            }
+            this.lastPlayheadSampleTimeUs = nanoTime;
+            this.smoothedPlayheadOffsetUs = 0L;
+            int i3 = 0;
+            while (true) {
+                int i4 = this.playheadOffsetCount;
+                if (i3 >= i4) {
+                    break;
+                }
+                this.smoothedPlayheadOffsetUs += this.playheadOffsets[i3] / i4;
+                i3++;
+            }
+        }
+        if (this.needsPassthroughWorkarounds) {
+            return;
+        }
+        maybePollAndCheckTimestamp(nanoTime, playbackHeadPositionUs);
+        maybeUpdateLatency(nanoTime);
+    }
+
+    private void maybePollAndCheckTimestamp(long j, long j2) {
+        if (this.audioTimestampPoller.maybePollTimestamp(j)) {
+            long timestampSystemTimeUs = this.audioTimestampPoller.getTimestampSystemTimeUs();
+            long timestampPositionFrames = this.audioTimestampPoller.getTimestampPositionFrames();
+            if (Math.abs(timestampSystemTimeUs - j) > 5000000) {
+                this.listener.onSystemTimeUsMismatch(timestampPositionFrames, timestampSystemTimeUs, j, j2);
+                this.audioTimestampPoller.rejectTimestamp();
+            } else if (Math.abs(framesToDurationUs(timestampPositionFrames) - j2) > 5000000) {
+                this.listener.onPositionFramesMismatch(timestampPositionFrames, timestampSystemTimeUs, j, j2);
+                this.audioTimestampPoller.rejectTimestamp();
+            } else {
+                this.audioTimestampPoller.acceptTimestamp();
+            }
+        }
+    }
+
+    private void maybeUpdateLatency(long j) {
+        Method method;
+        if (!this.isOutputPcm || (method = this.getLatencyMethod) == null || j - this.lastLatencySampleTimeUs < 500000) {
+            return;
+        }
+        try {
+            long intValue = (((Integer) method.invoke(this.audioTrack, null)).intValue() * 1000) - this.bufferSizeUs;
+            this.latencyUs = intValue;
+            long max = Math.max(intValue, 0L);
+            this.latencyUs = max;
+            if (max > 5000000) {
+                this.listener.onInvalidLatency(max);
+                this.latencyUs = 0L;
+            }
+        } catch (Exception unused) {
+            this.getLatencyMethod = null;
+        }
+        this.lastLatencySampleTimeUs = j;
+    }
+
+    private long framesToDurationUs(long j) {
+        return (j * 1000000) / this.outputSampleRate;
+    }
+
+    private boolean forceHasPendingData() {
+        return this.needsPassthroughWorkarounds && this.audioTrack.getPlayState() == 2 && getPlaybackHeadPosition() == 0;
+    }
+
+    private static boolean needsPassthroughWorkarounds(int i) {
+        return Util.SDK_INT < 23 && (i == 5 || i == 6);
+    }
+
+    private long getPlaybackHeadPositionUs() {
+        return framesToDurationUs(getPlaybackHeadPosition());
+    }
+
+    private long getPlaybackHeadPosition() {
+        if (this.stopTimestampUs != C.TIME_UNSET) {
+            return Math.min(this.endPlaybackHeadPosition, this.stopPlaybackHeadPosition + ((((SystemClock.elapsedRealtime() * 1000) - this.stopTimestampUs) * this.outputSampleRate) / 1000000));
+        }
+        int playState = this.audioTrack.getPlayState();
+        if (playState == 1) {
+            return 0L;
+        }
+        long playbackHeadPosition = this.audioTrack.getPlaybackHeadPosition() & 4294967295L;
+        if (this.needsPassthroughWorkarounds) {
+            if (playState == 2 && playbackHeadPosition == 0) {
+                this.passthroughWorkaroundPauseOffset = this.lastRawPlaybackHeadPosition;
+            }
+            playbackHeadPosition += this.passthroughWorkaroundPauseOffset;
+        }
+        if (Util.SDK_INT <= 28) {
+            if (playbackHeadPosition == 0 && this.lastRawPlaybackHeadPosition > 0 && playState == 3) {
+                if (this.forceResetWorkaroundTimeMs == C.TIME_UNSET) {
+                    this.forceResetWorkaroundTimeMs = SystemClock.elapsedRealtime();
+                }
+                return this.lastRawPlaybackHeadPosition;
+            }
+            this.forceResetWorkaroundTimeMs = C.TIME_UNSET;
+        }
+        if (this.lastRawPlaybackHeadPosition > playbackHeadPosition) {
+            this.rawPlaybackHeadWrapCount++;
+        }
+        this.lastRawPlaybackHeadPosition = playbackHeadPosition;
+        return playbackHeadPosition + (this.rawPlaybackHeadWrapCount << 32);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/ChannelMappingAudioProcessor.java

@@ -0,0 +1,146 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class ChannelMappingAudioProcessor implements AudioProcessor {
+    private boolean active;
+    private ByteBuffer buffer;
+    private int channelCount;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+
+    @Nullable
+    private int[] outputChannels;
+
+    @Nullable
+    private int[] pendingOutputChannels;
+    private int sampleRateHz;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.active;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public final void setChannelMap(@Nullable int[] iArr) {
+        this.pendingOutputChannels = iArr;
+    }
+
+    public ChannelMappingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        boolean z = !Arrays.equals(this.pendingOutputChannels, this.outputChannels);
+        int[] iArr = this.pendingOutputChannels;
+        this.outputChannels = iArr;
+        if (iArr == null) {
+            this.active = false;
+            return z;
+        }
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (!z && this.sampleRateHz == i && this.channelCount == i2) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.active = i2 != iArr.length;
+        int i4 = 0;
+        while (true) {
+            int[] iArr2 = this.outputChannels;
+            if (i4 >= iArr2.length) {
+                return true;
+            }
+            int i5 = iArr2[i4];
+            if (i5 >= i2) {
+                throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+            }
+            this.active = (i5 != i4) | this.active;
+            i4++;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        int[] iArr = this.outputChannels;
+        return iArr == null ? this.channelCount : iArr.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        Assertions.checkState(this.outputChannels != null);
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int length = ((limit - position) / (this.channelCount * 2)) * this.outputChannels.length * 2;
+        if (this.buffer.capacity() < length) {
+            this.buffer = ByteBuffer.allocateDirect(length).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        while (position < limit) {
+            for (int i : this.outputChannels) {
+                this.buffer.putShort(byteBuffer.getShort((i * 2) + position));
+            }
+            position += this.channelCount * 2;
+        }
+        byteBuffer.position(limit);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.outputChannels = null;
+        this.pendingOutputChannels = null;
+        this.active = false;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/DefaultAudioSink.java

@@ -0,0 +1,962 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.AudioAttributes;
+import android.media.AudioFormat;
+import android.media.AudioTrack;
+import android.os.ConditionVariable;
+import android.os.SystemClock;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public final class DefaultAudioSink implements AudioSink {
+    private static final int BUFFER_MULTIPLICATION_FACTOR = 4;
+    private static final int ERROR_BAD_VALUE = -2;
+    private static final long MAX_BUFFER_DURATION_US = 750000;
+    private static final long MIN_BUFFER_DURATION_US = 250000;
+    private static final int MODE_STATIC = 0;
+    private static final int MODE_STREAM = 1;
+    private static final long PASSTHROUGH_BUFFER_DURATION_US = 250000;
+    private static final int START_IN_SYNC = 1;
+    private static final int START_NEED_SYNC = 2;
+    private static final int START_NOT_SET = 0;
+    private static final int STATE_INITIALIZED = 1;
+    private static final String TAG = "AudioTrack";
+
+    @SuppressLint({"InlinedApi"})
+    private static final int WRITE_NON_BLOCKING = 1;
+    public static boolean enablePreV21AudioSessionWorkaround = false;
+    public static boolean failOnSpuriousAudioTimestamp = false;
+    private AudioProcessor[] activeAudioProcessors;
+
+    @Nullable
+    private PlaybackParameters afterDrainPlaybackParameters;
+    private AudioAttributes audioAttributes;
+
+    @Nullable
+    private final AudioCapabilities audioCapabilities;
+    private final AudioProcessorChain audioProcessorChain;
+    private int audioSessionId;
+    private AudioTrack audioTrack;
+    private final AudioTrackPositionTracker audioTrackPositionTracker;
+
+    @Nullable
+    private ByteBuffer avSyncHeader;
+    private int bufferSize;
+    private int bytesUntilNextAvSync;
+    private boolean canApplyPlaybackParameters;
+    private final ChannelMappingAudioProcessor channelMappingAudioProcessor;
+    private int drainingAudioProcessorIndex;
+    private final boolean enableConvertHighResIntPcmToFloat;
+    private int framesPerEncodedSample;
+    private boolean handledEndOfStream;
+
+    @Nullable
+    private ByteBuffer inputBuffer;
+    private int inputSampleRate;
+    private boolean isInputPcm;
+
+    @Nullable
+    private AudioTrack keepSessionIdAudioTrack;
+    private long lastFeedElapsedRealtimeMs;
+
+    @Nullable
+    private AudioSink.Listener listener;
+
+    @Nullable
+    private ByteBuffer outputBuffer;
+    private ByteBuffer[] outputBuffers;
+    private int outputChannelConfig;
+    private int outputEncoding;
+    private int outputPcmFrameSize;
+    private int outputSampleRate;
+    private int pcmFrameSize;
+    private PlaybackParameters playbackParameters;
+    private final ArrayDeque<PlaybackParametersCheckpoint> playbackParametersCheckpoints;
+    private long playbackParametersOffsetUs;
+    private long playbackParametersPositionUs;
+    private boolean playing;
+    private byte[] preV21OutputBuffer;
+    private int preV21OutputBufferOffset;
+    private boolean processingEnabled;
+    private final ConditionVariable releasingConditionVariable;
+    private boolean shouldConvertHighResIntPcmToFloat;
+    private int startMediaTimeState;
+    private long startMediaTimeUs;
+    private long submittedEncodedFrames;
+    private long submittedPcmBytes;
+    private final AudioProcessor[] toFloatPcmAvailableAudioProcessors;
+    private final AudioProcessor[] toIntPcmAvailableAudioProcessors;
+    private final TrimmingAudioProcessor trimmingAudioProcessor;
+    private boolean tunneling;
+    private float volume;
+    private long writtenEncodedFrames;
+    private long writtenPcmBytes;
+
+    public interface AudioProcessorChain {
+        PlaybackParameters applyPlaybackParameters(PlaybackParameters playbackParameters);
+
+        AudioProcessor[] getAudioProcessors();
+
+        long getMediaDuration(long j);
+
+        long getSkippedOutputFrameCount();
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface StartMediaTimeState {
+    }
+
+    private AudioProcessor[] getAvailableAudioProcessors() {
+        return this.shouldConvertHighResIntPcmToFloat ? this.toFloatPcmAvailableAudioProcessors : this.toIntPcmAvailableAudioProcessors;
+    }
+
+    private boolean isInitialized() {
+        return this.audioTrack != null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final PlaybackParameters getPlaybackParameters() {
+        return this.playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void handleDiscontinuity() {
+        if (this.startMediaTimeState == 1) {
+            this.startMediaTimeState = 2;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setListener(AudioSink.Listener listener) {
+        this.listener = listener;
+    }
+
+    public static final class InvalidAudioTrackTimestampException extends RuntimeException {
+        private InvalidAudioTrackTimestampException(String str) {
+            super(str);
+        }
+    }
+
+    public static class DefaultAudioProcessorChain implements AudioProcessorChain {
+        private final AudioProcessor[] audioProcessors;
+        private final SilenceSkippingAudioProcessor silenceSkippingAudioProcessor;
+        private final SonicAudioProcessor sonicAudioProcessor;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public AudioProcessor[] getAudioProcessors() {
+            return this.audioProcessors;
+        }
+
+        public DefaultAudioProcessorChain(AudioProcessor... audioProcessorArr) {
+            AudioProcessor[] audioProcessorArr2 = (AudioProcessor[]) Arrays.copyOf(audioProcessorArr, audioProcessorArr.length + 2);
+            this.audioProcessors = audioProcessorArr2;
+            SilenceSkippingAudioProcessor silenceSkippingAudioProcessor = new SilenceSkippingAudioProcessor();
+            this.silenceSkippingAudioProcessor = silenceSkippingAudioProcessor;
+            SonicAudioProcessor sonicAudioProcessor = new SonicAudioProcessor();
+            this.sonicAudioProcessor = sonicAudioProcessor;
+            audioProcessorArr2[audioProcessorArr.length] = silenceSkippingAudioProcessor;
+            audioProcessorArr2[audioProcessorArr.length + 1] = sonicAudioProcessor;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public PlaybackParameters applyPlaybackParameters(PlaybackParameters playbackParameters) {
+            this.silenceSkippingAudioProcessor.setEnabled(playbackParameters.skipSilence);
+            return new PlaybackParameters(this.sonicAudioProcessor.setSpeed(playbackParameters.speed), this.sonicAudioProcessor.setPitch(playbackParameters.pitch), playbackParameters.skipSilence);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public long getMediaDuration(long j) {
+            return this.sonicAudioProcessor.scaleDurationForSpeedup(j);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public long getSkippedOutputFrameCount() {
+            return this.silenceSkippingAudioProcessor.getSkippedFrames();
+        }
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessor[] audioProcessorArr) {
+        this(audioCapabilities, audioProcessorArr, false);
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessor[] audioProcessorArr, boolean z) {
+        this(audioCapabilities, new DefaultAudioProcessorChain(audioProcessorArr), z);
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessorChain audioProcessorChain, boolean z) {
+        this.audioCapabilities = audioCapabilities;
+        this.audioProcessorChain = (AudioProcessorChain) Assertions.checkNotNull(audioProcessorChain);
+        this.enableConvertHighResIntPcmToFloat = z;
+        this.releasingConditionVariable = new ConditionVariable(true);
+        this.audioTrackPositionTracker = new AudioTrackPositionTracker(new PositionTrackerListener());
+        ChannelMappingAudioProcessor channelMappingAudioProcessor = new ChannelMappingAudioProcessor();
+        this.channelMappingAudioProcessor = channelMappingAudioProcessor;
+        TrimmingAudioProcessor trimmingAudioProcessor = new TrimmingAudioProcessor();
+        this.trimmingAudioProcessor = trimmingAudioProcessor;
+        ArrayList arrayList = new ArrayList();
+        Collections.addAll(arrayList, new ResamplingAudioProcessor(), channelMappingAudioProcessor, trimmingAudioProcessor);
+        Collections.addAll(arrayList, audioProcessorChain.getAudioProcessors());
+        this.toIntPcmAvailableAudioProcessors = (AudioProcessor[]) arrayList.toArray(new AudioProcessor[arrayList.size()]);
+        this.toFloatPcmAvailableAudioProcessors = new AudioProcessor[]{new FloatResamplingAudioProcessor()};
+        this.volume = 1.0f;
+        this.startMediaTimeState = 0;
+        this.audioAttributes = AudioAttributes.DEFAULT;
+        this.audioSessionId = 0;
+        this.playbackParameters = PlaybackParameters.DEFAULT;
+        this.drainingAudioProcessorIndex = -1;
+        this.activeAudioProcessors = new AudioProcessor[0];
+        this.outputBuffers = new ByteBuffer[0];
+        this.playbackParametersCheckpoints = new ArrayDeque<>();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean isEncodingSupported(int i) {
+        if (Util.isEncodingPcm(i)) {
+            return i != 4 || Util.SDK_INT >= 21;
+        }
+        AudioCapabilities audioCapabilities = this.audioCapabilities;
+        return audioCapabilities != null && audioCapabilities.supportsEncoding(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final long getCurrentPositionUs(boolean z) {
+        if (!isInitialized() || this.startMediaTimeState == 0) {
+            return Long.MIN_VALUE;
+        }
+        return this.startMediaTimeUs + applySkipping(applySpeedup(Math.min(this.audioTrackPositionTracker.getCurrentPositionUs(z), framesToDurationUs(getWrittenFrames()))));
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:103:0x012b  */
+    /* JADX WARN: Removed duplicated region for block: B:106:0x0090  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x004b  */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x009b  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x00b2  */
+    /* JADX WARN: Removed duplicated region for block: B:44:0x00b5  */
+    /* JADX WARN: Removed duplicated region for block: B:45:0x00b8  */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x00ba  */
+    /* JADX WARN: Removed duplicated region for block: B:47:0x00bd  */
+    /* JADX WARN: Removed duplicated region for block: B:48:0x00c0  */
+    /* JADX WARN: Removed duplicated region for block: B:49:0x00c3  */
+    /* JADX WARN: Removed duplicated region for block: B:60:0x00e8  */
+    /* JADX WARN: Removed duplicated region for block: B:63:0x00f0  */
+    /* JADX WARN: Removed duplicated region for block: B:69:0x0104  */
+    /* JADX WARN: Removed duplicated region for block: B:80:0x0126  */
+    /* JADX WARN: Removed duplicated region for block: B:83:0x0130  */
+    /* JADX WARN: Removed duplicated region for block: B:85:0x0133  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void configure(int r18, int r19, int r20, int r21, @androidx.annotation.Nullable int[] r22, int r23, int r24) throws com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.ConfigurationException {
+        /*
+            Method dump skipped, instructions count: 410
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.configure(int, int, int, int, int[], int, int):void");
+    }
+
+    private void setupAudioProcessors() {
+        ArrayList arrayList = new ArrayList();
+        for (AudioProcessor audioProcessor : getAvailableAudioProcessors()) {
+            if (audioProcessor.isActive()) {
+                arrayList.add(audioProcessor);
+            } else {
+                audioProcessor.flush();
+            }
+        }
+        int size = arrayList.size();
+        this.activeAudioProcessors = (AudioProcessor[]) arrayList.toArray(new AudioProcessor[size]);
+        this.outputBuffers = new ByteBuffer[size];
+        flushAudioProcessors();
+    }
+
+    private void flushAudioProcessors() {
+        int i = 0;
+        while (true) {
+            AudioProcessor[] audioProcessorArr = this.activeAudioProcessors;
+            if (i >= audioProcessorArr.length) {
+                return;
+            }
+            AudioProcessor audioProcessor = audioProcessorArr[i];
+            audioProcessor.flush();
+            this.outputBuffers[i] = audioProcessor.getOutput();
+            i++;
+        }
+    }
+
+    private void initialize() throws AudioSink.InitializationException {
+        PlaybackParameters playbackParameters;
+        this.releasingConditionVariable.block();
+        AudioTrack initializeAudioTrack = initializeAudioTrack();
+        this.audioTrack = initializeAudioTrack;
+        int audioSessionId = initializeAudioTrack.getAudioSessionId();
+        if (enablePreV21AudioSessionWorkaround && Util.SDK_INT < 21) {
+            AudioTrack audioTrack = this.keepSessionIdAudioTrack;
+            if (audioTrack != null && audioSessionId != audioTrack.getAudioSessionId()) {
+                releaseKeepSessionIdAudioTrack();
+            }
+            if (this.keepSessionIdAudioTrack == null) {
+                this.keepSessionIdAudioTrack = initializeKeepSessionIdAudioTrack(audioSessionId);
+            }
+        }
+        if (this.audioSessionId != audioSessionId) {
+            this.audioSessionId = audioSessionId;
+            AudioSink.Listener listener = this.listener;
+            if (listener != null) {
+                listener.onAudioSessionId(audioSessionId);
+            }
+        }
+        if (this.canApplyPlaybackParameters) {
+            playbackParameters = this.audioProcessorChain.applyPlaybackParameters(this.playbackParameters);
+        } else {
+            playbackParameters = PlaybackParameters.DEFAULT;
+        }
+        this.playbackParameters = playbackParameters;
+        setupAudioProcessors();
+        this.audioTrackPositionTracker.setAudioTrack(this.audioTrack, this.outputEncoding, this.outputPcmFrameSize, this.bufferSize);
+        setVolumeInternal();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void play() {
+        this.playing = true;
+        if (isInitialized()) {
+            this.audioTrackPositionTracker.start();
+            this.audioTrack.play();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean handleBuffer(ByteBuffer byteBuffer, long j) throws AudioSink.InitializationException, AudioSink.WriteException {
+        ByteBuffer byteBuffer2 = this.inputBuffer;
+        Assertions.checkArgument(byteBuffer2 == null || byteBuffer == byteBuffer2);
+        if (!isInitialized()) {
+            initialize();
+            if (this.playing) {
+                play();
+            }
+        }
+        if (!this.audioTrackPositionTracker.mayHandleBuffer(getWrittenFrames())) {
+            return false;
+        }
+        if (this.inputBuffer == null) {
+            if (!byteBuffer.hasRemaining()) {
+                return true;
+            }
+            if (!this.isInputPcm && this.framesPerEncodedSample == 0) {
+                int framesPerEncodedSample = getFramesPerEncodedSample(this.outputEncoding, byteBuffer);
+                this.framesPerEncodedSample = framesPerEncodedSample;
+                if (framesPerEncodedSample == 0) {
+                    return true;
+                }
+            }
+            if (this.afterDrainPlaybackParameters != null) {
+                if (!drainAudioProcessorsToEndOfStream()) {
+                    return false;
+                }
+                PlaybackParameters playbackParameters = this.afterDrainPlaybackParameters;
+                this.afterDrainPlaybackParameters = null;
+                this.playbackParametersCheckpoints.add(new PlaybackParametersCheckpoint(this.audioProcessorChain.applyPlaybackParameters(playbackParameters), Math.max(0L, j), framesToDurationUs(getWrittenFrames())));
+                setupAudioProcessors();
+            }
+            if (this.startMediaTimeState == 0) {
+                this.startMediaTimeUs = Math.max(0L, j);
+                this.startMediaTimeState = 1;
+            } else {
+                long inputFramesToDurationUs = this.startMediaTimeUs + inputFramesToDurationUs(getSubmittedFrames());
+                if (this.startMediaTimeState == 1 && Math.abs(inputFramesToDurationUs - j) > 200000) {
+                    Log.e(TAG, "Discontinuity detected [expected " + inputFramesToDurationUs + ", got " + j + v8.i.e);
+                    this.startMediaTimeState = 2;
+                }
+                if (this.startMediaTimeState == 2) {
+                    this.startMediaTimeUs += j - inputFramesToDurationUs;
+                    this.startMediaTimeState = 1;
+                    AudioSink.Listener listener = this.listener;
+                    if (listener != null) {
+                        listener.onPositionDiscontinuity();
+                    }
+                }
+            }
+            if (this.isInputPcm) {
+                this.submittedPcmBytes += byteBuffer.remaining();
+            } else {
+                this.submittedEncodedFrames += this.framesPerEncodedSample;
+            }
+            this.inputBuffer = byteBuffer;
+        }
+        if (this.processingEnabled) {
+            processBuffers(j);
+        } else {
+            writeBuffer(this.inputBuffer, j);
+        }
+        if (!this.inputBuffer.hasRemaining()) {
+            this.inputBuffer = null;
+            return true;
+        }
+        if (!this.audioTrackPositionTracker.isStalled(getWrittenFrames())) {
+            return false;
+        }
+        Log.w(TAG, "Resetting stalled audio track");
+        reset();
+        return true;
+    }
+
+    private void processBuffers(long j) throws AudioSink.WriteException {
+        ByteBuffer byteBuffer;
+        int length = this.activeAudioProcessors.length;
+        int i = length;
+        while (i >= 0) {
+            if (i > 0) {
+                byteBuffer = this.outputBuffers[i - 1];
+            } else {
+                byteBuffer = this.inputBuffer;
+                if (byteBuffer == null) {
+                    byteBuffer = AudioProcessor.EMPTY_BUFFER;
+                }
+            }
+            if (i == length) {
+                writeBuffer(byteBuffer, j);
+            } else {
+                AudioProcessor audioProcessor = this.activeAudioProcessors[i];
+                audioProcessor.queueInput(byteBuffer);
+                ByteBuffer output = audioProcessor.getOutput();
+                this.outputBuffers[i] = output;
+                if (output.hasRemaining()) {
+                    i++;
+                }
+            }
+            if (byteBuffer.hasRemaining()) {
+                return;
+            } else {
+                i--;
+            }
+        }
+    }
+
+    private void writeBuffer(ByteBuffer byteBuffer, long j) throws AudioSink.WriteException {
+        if (byteBuffer.hasRemaining()) {
+            ByteBuffer byteBuffer2 = this.outputBuffer;
+            int i = 0;
+            if (byteBuffer2 != null) {
+                Assertions.checkArgument(byteBuffer2 == byteBuffer);
+            } else {
+                this.outputBuffer = byteBuffer;
+                if (Util.SDK_INT < 21) {
+                    int remaining = byteBuffer.remaining();
+                    byte[] bArr = this.preV21OutputBuffer;
+                    if (bArr == null || bArr.length < remaining) {
+                        this.preV21OutputBuffer = new byte[remaining];
+                    }
+                    int position = byteBuffer.position();
+                    byteBuffer.get(this.preV21OutputBuffer, 0, remaining);
+                    byteBuffer.position(position);
+                    this.preV21OutputBufferOffset = 0;
+                }
+            }
+            int remaining2 = byteBuffer.remaining();
+            if (Util.SDK_INT < 21) {
+                int availableBufferSize = this.audioTrackPositionTracker.getAvailableBufferSize(this.writtenPcmBytes);
+                if (availableBufferSize > 0) {
+                    i = this.audioTrack.write(this.preV21OutputBuffer, this.preV21OutputBufferOffset, Math.min(remaining2, availableBufferSize));
+                    if (i > 0) {
+                        this.preV21OutputBufferOffset += i;
+                        byteBuffer.position(byteBuffer.position() + i);
+                    }
+                }
+            } else if (this.tunneling) {
+                Assertions.checkState(j != C.TIME_UNSET);
+                i = writeNonBlockingWithAvSyncV21(this.audioTrack, byteBuffer, remaining2, j);
+            } else {
+                i = writeNonBlockingV21(this.audioTrack, byteBuffer, remaining2);
+            }
+            this.lastFeedElapsedRealtimeMs = SystemClock.elapsedRealtime();
+            if (i < 0) {
+                throw new AudioSink.WriteException(i);
+            }
+            boolean z = this.isInputPcm;
+            if (z) {
+                this.writtenPcmBytes += i;
+            }
+            if (i == remaining2) {
+                if (!z) {
+                    this.writtenEncodedFrames += this.framesPerEncodedSample;
+                }
+                this.outputBuffer = null;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void playToEndOfStream() throws AudioSink.WriteException {
+        if (!this.handledEndOfStream && isInitialized() && drainAudioProcessorsToEndOfStream()) {
+            this.audioTrackPositionTracker.handleEndOfStream(getWrittenFrames());
+            this.audioTrack.stop();
+            this.bytesUntilNextAvSync = 0;
+            this.handledEndOfStream = true;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0021  */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0038  */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:17:0x0032 -> B:7:0x0012). Please report as a decompilation issue!!! */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private boolean drainAudioProcessorsToEndOfStream() throws com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.WriteException {
+        /*
+            r9 = this;
+            int r0 = r9.drainingAudioProcessorIndex
+            r1 = 1
+            r2 = 0
+            r3 = -1
+            if (r0 != r3) goto L14
+            boolean r0 = r9.processingEnabled
+            if (r0 == 0) goto Ld
+            r0 = r2
+            goto L10
+        Ld:
+            com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor[] r0 = r9.activeAudioProcessors
+            int r0 = r0.length
+        L10:
+            r9.drainingAudioProcessorIndex = r0
+        L12:
+            r0 = r1
+            goto L15
+        L14:
+            r0 = r2
+        L15:
+            int r4 = r9.drainingAudioProcessorIndex
+            com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor[] r5 = r9.activeAudioProcessors
+            int r6 = r5.length
+            r7 = -9223372036854775807(0x8000000000000001, double:-4.9E-324)
+            if (r4 >= r6) goto L38
+            r4 = r5[r4]
+            if (r0 == 0) goto L28
+            r4.queueEndOfStream()
+        L28:
+            r9.processBuffers(r7)
+            boolean r0 = r4.isEnded()
+            if (r0 != 0) goto L32
+            return r2
+        L32:
+            int r0 = r9.drainingAudioProcessorIndex
+            int r0 = r0 + r1
+            r9.drainingAudioProcessorIndex = r0
+            goto L12
+        L38:
+            java.nio.ByteBuffer r0 = r9.outputBuffer
+            if (r0 == 0) goto L44
+            r9.writeBuffer(r0, r7)
+            java.nio.ByteBuffer r0 = r9.outputBuffer
+            if (r0 == 0) goto L44
+            return r2
+        L44:
+            r9.drainingAudioProcessorIndex = r3
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.drainAudioProcessorsToEndOfStream():boolean");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean isEnded() {
+        return !isInitialized() || (this.handledEndOfStream && !hasPendingData());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean hasPendingData() {
+        return isInitialized() && this.audioTrackPositionTracker.hasPendingData(getWrittenFrames());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        if (isInitialized() && !this.canApplyPlaybackParameters) {
+            PlaybackParameters playbackParameters2 = PlaybackParameters.DEFAULT;
+            this.playbackParameters = playbackParameters2;
+            return playbackParameters2;
+        }
+        PlaybackParameters playbackParameters3 = this.afterDrainPlaybackParameters;
+        if (playbackParameters3 == null) {
+            playbackParameters3 = !this.playbackParametersCheckpoints.isEmpty() ? this.playbackParametersCheckpoints.getLast().playbackParameters : this.playbackParameters;
+        }
+        if (!playbackParameters.equals(playbackParameters3)) {
+            if (isInitialized()) {
+                this.afterDrainPlaybackParameters = playbackParameters;
+            } else {
+                this.playbackParameters = this.audioProcessorChain.applyPlaybackParameters(playbackParameters);
+            }
+        }
+        return this.playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setAudioAttributes(AudioAttributes audioAttributes) {
+        if (this.audioAttributes.equals(audioAttributes)) {
+            return;
+        }
+        this.audioAttributes = audioAttributes;
+        if (this.tunneling) {
+            return;
+        }
+        reset();
+        this.audioSessionId = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setAudioSessionId(int i) {
+        if (this.audioSessionId != i) {
+            this.audioSessionId = i;
+            reset();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void enableTunnelingV21(int i) {
+        Assertions.checkState(Util.SDK_INT >= 21);
+        if (this.tunneling && this.audioSessionId == i) {
+            return;
+        }
+        this.tunneling = true;
+        this.audioSessionId = i;
+        reset();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void disableTunneling() {
+        if (this.tunneling) {
+            this.tunneling = false;
+            this.audioSessionId = 0;
+            reset();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setVolume(float f) {
+        if (this.volume != f) {
+            this.volume = f;
+            setVolumeInternal();
+        }
+    }
+
+    private void setVolumeInternal() {
+        if (isInitialized()) {
+            if (Util.SDK_INT >= 21) {
+                setVolumeInternalV21(this.audioTrack, this.volume);
+            } else {
+                setVolumeInternalV3(this.audioTrack, this.volume);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void pause() {
+        this.playing = false;
+        if (isInitialized() && this.audioTrackPositionTracker.pause()) {
+            this.audioTrack.pause();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void reset() {
+        if (isInitialized()) {
+            this.submittedPcmBytes = 0L;
+            this.submittedEncodedFrames = 0L;
+            this.writtenPcmBytes = 0L;
+            this.writtenEncodedFrames = 0L;
+            this.framesPerEncodedSample = 0;
+            PlaybackParameters playbackParameters = this.afterDrainPlaybackParameters;
+            if (playbackParameters != null) {
+                this.playbackParameters = playbackParameters;
+                this.afterDrainPlaybackParameters = null;
+            } else if (!this.playbackParametersCheckpoints.isEmpty()) {
+                this.playbackParameters = this.playbackParametersCheckpoints.getLast().playbackParameters;
+            }
+            this.playbackParametersCheckpoints.clear();
+            this.playbackParametersOffsetUs = 0L;
+            this.playbackParametersPositionUs = 0L;
+            this.inputBuffer = null;
+            this.outputBuffer = null;
+            flushAudioProcessors();
+            this.handledEndOfStream = false;
+            this.drainingAudioProcessorIndex = -1;
+            this.avSyncHeader = null;
+            this.bytesUntilNextAvSync = 0;
+            this.startMediaTimeState = 0;
+            if (this.audioTrackPositionTracker.isPlaying()) {
+                this.audioTrack.pause();
+            }
+            final AudioTrack audioTrack = this.audioTrack;
+            this.audioTrack = null;
+            this.audioTrackPositionTracker.reset();
+            this.releasingConditionVariable.close();
+            new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.1
+                @Override // java.lang.Thread, java.lang.Runnable
+                public void run() {
+                    try {
+                        audioTrack.flush();
+                        audioTrack.release();
+                    } finally {
+                        DefaultAudioSink.this.releasingConditionVariable.open();
+                    }
+                }
+            }.start();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void release() {
+        reset();
+        releaseKeepSessionIdAudioTrack();
+        for (AudioProcessor audioProcessor : this.toIntPcmAvailableAudioProcessors) {
+            audioProcessor.reset();
+        }
+        for (AudioProcessor audioProcessor2 : this.toFloatPcmAvailableAudioProcessors) {
+            audioProcessor2.reset();
+        }
+        this.audioSessionId = 0;
+        this.playing = false;
+    }
+
+    private void releaseKeepSessionIdAudioTrack() {
+        final AudioTrack audioTrack = this.keepSessionIdAudioTrack;
+        if (audioTrack == null) {
+            return;
+        }
+        this.keepSessionIdAudioTrack = null;
+        new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.2
+            @Override // java.lang.Thread, java.lang.Runnable
+            public void run() {
+                audioTrack.release();
+            }
+        }.start();
+    }
+
+    private long applySpeedup(long j) {
+        long j2;
+        long mediaDurationForPlayoutDuration;
+        PlaybackParametersCheckpoint playbackParametersCheckpoint = null;
+        while (!this.playbackParametersCheckpoints.isEmpty() && j >= this.playbackParametersCheckpoints.getFirst().positionUs) {
+            playbackParametersCheckpoint = this.playbackParametersCheckpoints.remove();
+        }
+        if (playbackParametersCheckpoint != null) {
+            this.playbackParameters = playbackParametersCheckpoint.playbackParameters;
+            this.playbackParametersPositionUs = playbackParametersCheckpoint.positionUs;
+            this.playbackParametersOffsetUs = playbackParametersCheckpoint.mediaTimeUs - this.startMediaTimeUs;
+        }
+        if (this.playbackParameters.speed == 1.0f) {
+            return (j + this.playbackParametersOffsetUs) - this.playbackParametersPositionUs;
+        }
+        if (this.playbackParametersCheckpoints.isEmpty()) {
+            j2 = this.playbackParametersOffsetUs;
+            mediaDurationForPlayoutDuration = this.audioProcessorChain.getMediaDuration(j - this.playbackParametersPositionUs);
+        } else {
+            j2 = this.playbackParametersOffsetUs;
+            mediaDurationForPlayoutDuration = Util.getMediaDurationForPlayoutDuration(j - this.playbackParametersPositionUs, this.playbackParameters.speed);
+        }
+        return j2 + mediaDurationForPlayoutDuration;
+    }
+
+    private long applySkipping(long j) {
+        return j + framesToDurationUs(this.audioProcessorChain.getSkippedOutputFrameCount());
+    }
+
+    private long inputFramesToDurationUs(long j) {
+        return (j * 1000000) / this.inputSampleRate;
+    }
+
+    private long framesToDurationUs(long j) {
+        return (j * 1000000) / this.outputSampleRate;
+    }
+
+    private long durationUsToFrames(long j) {
+        return (j * this.outputSampleRate) / 1000000;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public long getSubmittedFrames() {
+        return this.isInputPcm ? this.submittedPcmBytes / this.pcmFrameSize : this.submittedEncodedFrames;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public long getWrittenFrames() {
+        return this.isInputPcm ? this.writtenPcmBytes / this.outputPcmFrameSize : this.writtenEncodedFrames;
+    }
+
+    private AudioTrack initializeAudioTrack() throws AudioSink.InitializationException {
+        AudioTrack audioTrack;
+        if (Util.SDK_INT >= 21) {
+            audioTrack = createAudioTrackV21();
+        } else {
+            int streamTypeForAudioUsage = Util.getStreamTypeForAudioUsage(this.audioAttributes.usage);
+            if (this.audioSessionId == 0) {
+                audioTrack = new AudioTrack(streamTypeForAudioUsage, this.outputSampleRate, this.outputChannelConfig, this.outputEncoding, this.bufferSize, 1);
+            } else {
+                audioTrack = new AudioTrack(streamTypeForAudioUsage, this.outputSampleRate, this.outputChannelConfig, this.outputEncoding, this.bufferSize, 1, this.audioSessionId);
+            }
+        }
+        int state = audioTrack.getState();
+        if (state == 1) {
+            return audioTrack;
+        }
+        try {
+            audioTrack.release();
+        } catch (Exception unused) {
+        }
+        throw new AudioSink.InitializationException(state, this.outputSampleRate, this.outputChannelConfig, this.bufferSize);
+    }
+
+    @TargetApi(21)
+    private AudioTrack createAudioTrackV21() {
+        android.media.AudioAttributes audioAttributesV21;
+        if (this.tunneling) {
+            audioAttributesV21 = new AudioAttributes.Builder().setContentType(3).setFlags(16).setUsage(1).build();
+        } else {
+            audioAttributesV21 = this.audioAttributes.getAudioAttributesV21();
+        }
+        android.media.AudioAttributes audioAttributes = audioAttributesV21;
+        AudioFormat build = new AudioFormat.Builder().setChannelMask(this.outputChannelConfig).setEncoding(this.outputEncoding).setSampleRate(this.outputSampleRate).build();
+        int i = this.audioSessionId;
+        if (i == 0) {
+            i = 0;
+        }
+        return new AudioTrack(audioAttributes, build, this.bufferSize, 1, i);
+    }
+
+    private AudioTrack initializeKeepSessionIdAudioTrack(int i) {
+        return new AudioTrack(3, 4000, 4, 2, 2, 0, i);
+    }
+
+    private static int getFramesPerEncodedSample(int i, ByteBuffer byteBuffer) {
+        if (i == 7 || i == 8) {
+            return DtsUtil.parseDtsAudioSampleCount(byteBuffer);
+        }
+        if (i == 5) {
+            return Ac3Util.getAc3SyncframeAudioSampleCount();
+        }
+        if (i == 6) {
+            return Ac3Util.parseEAc3SyncframeAudioSampleCount(byteBuffer);
+        }
+        if (i == 14) {
+            int findTrueHdSyncframeOffset = Ac3Util.findTrueHdSyncframeOffset(byteBuffer);
+            if (findTrueHdSyncframeOffset == -1) {
+                return 0;
+            }
+            return Ac3Util.parseTrueHdSyncframeAudioSampleCount(byteBuffer, findTrueHdSyncframeOffset) * 16;
+        }
+        throw new IllegalStateException("Unexpected audio encoding: " + i);
+    }
+
+    @TargetApi(21)
+    private static int writeNonBlockingV21(AudioTrack audioTrack, ByteBuffer byteBuffer, int i) {
+        return audioTrack.write(byteBuffer, i, 1);
+    }
+
+    @TargetApi(21)
+    private int writeNonBlockingWithAvSyncV21(AudioTrack audioTrack, ByteBuffer byteBuffer, int i, long j) {
+        if (this.avSyncHeader == null) {
+            ByteBuffer allocate = ByteBuffer.allocate(16);
+            this.avSyncHeader = allocate;
+            allocate.order(ByteOrder.BIG_ENDIAN);
+            this.avSyncHeader.putInt(1431633921);
+        }
+        if (this.bytesUntilNextAvSync == 0) {
+            this.avSyncHeader.putInt(4, i);
+            this.avSyncHeader.putLong(8, j * 1000);
+            this.avSyncHeader.position(0);
+            this.bytesUntilNextAvSync = i;
+        }
+        int remaining = this.avSyncHeader.remaining();
+        if (remaining > 0) {
+            int write = audioTrack.write(this.avSyncHeader, remaining, 1);
+            if (write < 0) {
+                this.bytesUntilNextAvSync = 0;
+                return write;
+            }
+            if (write < remaining) {
+                return 0;
+            }
+        }
+        int writeNonBlockingV21 = writeNonBlockingV21(audioTrack, byteBuffer, i);
+        if (writeNonBlockingV21 < 0) {
+            this.bytesUntilNextAvSync = 0;
+            return writeNonBlockingV21;
+        }
+        this.bytesUntilNextAvSync -= writeNonBlockingV21;
+        return writeNonBlockingV21;
+    }
+
+    @TargetApi(21)
+    private static void setVolumeInternalV21(AudioTrack audioTrack, float f) {
+        audioTrack.setVolume(f);
+    }
+
+    private static void setVolumeInternalV3(AudioTrack audioTrack, float f) {
+        audioTrack.setStereoVolume(f, f);
+    }
+
+    public static final class PlaybackParametersCheckpoint {
+        private final long mediaTimeUs;
+        private final PlaybackParameters playbackParameters;
+        private final long positionUs;
+
+        private PlaybackParametersCheckpoint(PlaybackParameters playbackParameters, long j, long j2) {
+            this.playbackParameters = playbackParameters;
+            this.mediaTimeUs = j;
+            this.positionUs = j2;
+        }
+    }
+
+    public final class PositionTrackerListener implements AudioTrackPositionTracker.Listener {
+        private PositionTrackerListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onPositionFramesMismatch(long j, long j2, long j3, long j4) {
+            String str = "Spurious audio timestamp (frame position mismatch): " + j + ", " + j2 + ", " + j3 + ", " + j4 + ", " + DefaultAudioSink.this.getSubmittedFrames() + ", " + DefaultAudioSink.this.getWrittenFrames();
+            if (DefaultAudioSink.failOnSpuriousAudioTimestamp) {
+                throw new InvalidAudioTrackTimestampException(str);
+            }
+            Log.w(DefaultAudioSink.TAG, str);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onSystemTimeUsMismatch(long j, long j2, long j3, long j4) {
+            String str = "Spurious audio timestamp (system clock mismatch): " + j + ", " + j2 + ", " + j3 + ", " + j4 + ", " + DefaultAudioSink.this.getSubmittedFrames() + ", " + DefaultAudioSink.this.getWrittenFrames();
+            if (DefaultAudioSink.failOnSpuriousAudioTimestamp) {
+                throw new InvalidAudioTrackTimestampException(str);
+            }
+            Log.w(DefaultAudioSink.TAG, str);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onInvalidLatency(long j) {
+            Log.w(DefaultAudioSink.TAG, "Ignoring impossibly large audio latency: " + j);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onUnderrun(int i, long j) {
+            if (DefaultAudioSink.this.listener != null) {
+                DefaultAudioSink.this.listener.onUnderrun(i, j, SystemClock.elapsedRealtime() - DefaultAudioSink.this.lastFeedElapsedRealtimeMs);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/DtsUtil.java

@@ -0,0 +1,211 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import csdk.gluads.Consts;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class DtsUtil {
+    private static final byte FIRST_BYTE_14B_BE = 31;
+    private static final byte FIRST_BYTE_14B_LE = -1;
+    private static final byte FIRST_BYTE_BE = Byte.MAX_VALUE;
+    private static final byte FIRST_BYTE_LE = -2;
+    private static final int SYNC_VALUE_14B_BE = 536864768;
+    private static final int SYNC_VALUE_14B_LE = -14745368;
+    private static final int SYNC_VALUE_BE = 2147385345;
+    private static final int SYNC_VALUE_LE = -25230976;
+    private static final int[] CHANNELS_BY_AMODE = {1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8};
+    private static final int[] SAMPLE_RATE_BY_SFREQ = {-1, 8000, 16000, 32000, -1, -1, 11025, 22050, 44100, -1, -1, 12000, 24000, 48000, -1, -1};
+    private static final int[] TWICE_BITRATE_KBPS_BY_RATE = {64, 112, 128, PsExtractor.AUDIO_STREAM, 224, 256, 384, 448, 512, 640, 768, 896, 1024, 1152, 1280, 1536, 1920, 2048, IronSourceConstants.IS_AD_UNIT_CAPPED, 2560, 2688, 2816, 2823, 2944, 3072, 3840, 4096, Consts.GEMS_CUSTOM_DATA_LIMIT, 7680};
+
+    private DtsUtil() {
+    }
+
+    public static boolean isSyncWord(int i) {
+        return i == SYNC_VALUE_BE || i == SYNC_VALUE_LE || i == SYNC_VALUE_14B_BE || i == SYNC_VALUE_14B_LE;
+    }
+
+    public static Format parseDtsFormat(byte[] bArr, String str, String str2, DrmInitData drmInitData) {
+        ParsableBitArray normalizedFrameHeader = getNormalizedFrameHeader(bArr);
+        normalizedFrameHeader.skipBits(60);
+        int i = CHANNELS_BY_AMODE[normalizedFrameHeader.readBits(6)];
+        int i2 = SAMPLE_RATE_BY_SFREQ[normalizedFrameHeader.readBits(4)];
+        int readBits = normalizedFrameHeader.readBits(5);
+        int[] iArr = TWICE_BITRATE_KBPS_BY_RATE;
+        int i3 = readBits >= iArr.length ? -1 : (iArr[readBits] * 1000) / 2;
+        normalizedFrameHeader.skipBits(10);
+        return Format.createAudioSampleFormat(str, MimeTypes.AUDIO_DTS, null, i3, -1, i + (normalizedFrameHeader.readBits(2) > 0 ? 1 : 0), i2, null, drmInitData, 0, str2);
+    }
+
+    public static int parseDtsAudioSampleCount(byte[] bArr) {
+        int i;
+        byte b;
+        int i2;
+        byte b2;
+        byte b3 = bArr[0];
+        if (b3 != -2) {
+            if (b3 == -1) {
+                i = (bArr[4] & 7) << 4;
+                b2 = bArr[7];
+            } else if (b3 == 31) {
+                i = (bArr[5] & 7) << 4;
+                b2 = bArr[6];
+            } else {
+                i = (bArr[4] & 1) << 6;
+                b = bArr[5];
+            }
+            i2 = b2 & 60;
+            return (((i2 >> 2) | i) + 1) * 32;
+        }
+        i = (bArr[5] & 1) << 6;
+        b = bArr[4];
+        i2 = b & 252;
+        return (((i2 >> 2) | i) + 1) * 32;
+    }
+
+    public static int parseDtsAudioSampleCount(ByteBuffer byteBuffer) {
+        int i;
+        byte b;
+        int i2;
+        byte b2;
+        int position = byteBuffer.position();
+        byte b3 = byteBuffer.get(position);
+        if (b3 != -2) {
+            if (b3 == -1) {
+                i = (byteBuffer.get(position + 4) & 7) << 4;
+                b2 = byteBuffer.get(position + 7);
+            } else if (b3 == 31) {
+                i = (byteBuffer.get(position + 5) & 7) << 4;
+                b2 = byteBuffer.get(position + 6);
+            } else {
+                i = (byteBuffer.get(position + 4) & 1) << 6;
+                b = byteBuffer.get(position + 5);
+            }
+            i2 = b2 & 60;
+            return (((i2 >> 2) | i) + 1) * 32;
+        }
+        i = (byteBuffer.get(position + 5) & 1) << 6;
+        b = byteBuffer.get(position + 4);
+        i2 = b & 252;
+        return (((i2 >> 2) | i) + 1) * 32;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0060  */
+    /* JADX WARN: Removed duplicated region for block: B:13:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static int getDtsFrameSize(byte[] r7) {
+        /*
+            r0 = 0
+            r1 = r7[r0]
+            r2 = -2
+            r3 = 7
+            r4 = 6
+            r5 = 1
+            r6 = 4
+            if (r1 == r2) goto L4f
+            r2 = -1
+            if (r1 == r2) goto L3e
+            r2 = 31
+            if (r1 == r2) goto L26
+            r1 = 5
+            r1 = r7[r1]
+            r1 = r1 & 3
+            int r1 = r1 << 12
+            r2 = r7[r4]
+            r2 = r2 & 255(0xff, float:3.57E-43)
+            int r2 = r2 << r6
+            r1 = r1 | r2
+            r7 = r7[r3]
+        L20:
+            r7 = r7 & 240(0xf0, float:3.36E-43)
+            int r7 = r7 >> r6
+            r7 = r7 | r1
+            int r7 = r7 + r5
+            goto L5e
+        L26:
+            r0 = r7[r4]
+            r0 = r0 & 3
+            int r0 = r0 << 12
+            r1 = r7[r3]
+            r1 = r1 & 255(0xff, float:3.57E-43)
+            int r1 = r1 << r6
+            r0 = r0 | r1
+            r1 = 8
+            r7 = r7[r1]
+        L36:
+            r7 = r7 & 60
+            int r7 = r7 >> 2
+            r7 = r7 | r0
+            int r7 = r7 + r5
+            r0 = r5
+            goto L5e
+        L3e:
+            r0 = r7[r3]
+            r0 = r0 & 3
+            int r0 = r0 << 12
+            r1 = r7[r4]
+            r1 = r1 & 255(0xff, float:3.57E-43)
+            int r1 = r1 << r6
+            r0 = r0 | r1
+            r1 = 9
+            r7 = r7[r1]
+            goto L36
+        L4f:
+            r1 = r7[r6]
+            r1 = r1 & 3
+            int r1 = r1 << 12
+            r2 = r7[r3]
+            r2 = r2 & 255(0xff, float:3.57E-43)
+            int r2 = r2 << r6
+            r1 = r1 | r2
+            r7 = r7[r4]
+            goto L20
+        L5e:
+            if (r0 == 0) goto L64
+            int r7 = r7 * 16
+            int r7 = r7 / 14
+        L64:
+            return r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DtsUtil.getDtsFrameSize(byte[]):int");
+    }
+
+    private static ParsableBitArray getNormalizedFrameHeader(byte[] bArr) {
+        if (bArr[0] == Byte.MAX_VALUE) {
+            return new ParsableBitArray(bArr);
+        }
+        byte[] copyOf = Arrays.copyOf(bArr, bArr.length);
+        if (isLittleEndianFrameHeader(copyOf)) {
+            for (int i = 0; i < copyOf.length - 1; i += 2) {
+                byte b = copyOf[i];
+                int i2 = i + 1;
+                copyOf[i] = copyOf[i2];
+                copyOf[i2] = b;
+            }
+        }
+        ParsableBitArray parsableBitArray = new ParsableBitArray(copyOf);
+        if (copyOf[0] == 31) {
+            ParsableBitArray parsableBitArray2 = new ParsableBitArray(copyOf);
+            while (parsableBitArray2.bitsLeft() >= 16) {
+                parsableBitArray2.skipBits(2);
+                parsableBitArray.putInt(parsableBitArray2.readBits(14), 14);
+            }
+        }
+        parsableBitArray.reset(copyOf);
+        return parsableBitArray;
+    }
+
+    private static boolean isLittleEndianFrameHeader(byte[] bArr) {
+        byte b = bArr[0];
+        return b == -2 || b == -1;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/FloatResamplingAudioProcessor.java

@@ -0,0 +1,128 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+final class FloatResamplingAudioProcessor implements AudioProcessor {
+    private static final int FLOAT_NAN_AS_INT = Float.floatToIntBits(Float.NaN);
+    private static final double PCM_32_BIT_INT_TO_PCM_32_BIT_FLOAT_FACTOR = 4.656612875245797E-10d;
+    private ByteBuffer buffer;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private int sampleRateHz = -1;
+    private int channelCount = -1;
+    private int sourceEncoding = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 4;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public FloatResamplingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (!Util.isEncodingHighResolutionIntegerPcm(i3)) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.sourceEncoding == i3) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.sourceEncoding = i3;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return Util.isEncodingHighResolutionIntegerPcm(this.sourceEncoding);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        boolean z = this.sourceEncoding == 1073741824;
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int i = limit - position;
+        if (!z) {
+            i = (i / 3) * 4;
+        }
+        if (this.buffer.capacity() < i) {
+            this.buffer = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        if (z) {
+            while (position < limit) {
+                writePcm32BitFloat((byteBuffer.get(position) & 255) | ((byteBuffer.get(position + 1) & 255) << 8) | ((byteBuffer.get(position + 2) & 255) << 16) | ((byteBuffer.get(position + 3) & 255) << 24), this.buffer);
+                position += 4;
+            }
+        } else {
+            while (position < limit) {
+                writePcm32BitFloat(((byteBuffer.get(position) & 255) << 8) | ((byteBuffer.get(position + 1) & 255) << 16) | ((byteBuffer.get(position + 2) & 255) << 24), this.buffer);
+                position += 3;
+            }
+        }
+        byteBuffer.position(byteBuffer.limit());
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.sampleRateHz = -1;
+        this.channelCount = -1;
+        this.sourceEncoding = 0;
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+    }
+
+    private static void writePcm32BitFloat(int i, ByteBuffer byteBuffer) {
+        int floatToIntBits = Float.floatToIntBits((float) (i * PCM_32_BIT_INT_TO_PCM_32_BIT_FLOAT_FACTOR));
+        if (floatToIntBits == FLOAT_NAN_AS_INT) {
+            floatToIntBits = Float.floatToIntBits(0.0f);
+        }
+        byteBuffer.putInt(floatToIntBits);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/MediaCodecAudioRenderer.java

@@ -0,0 +1,418 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.media.MediaCodec;
+import android.media.MediaCrypto;
+import android.media.MediaFormat;
+import android.os.Handler;
+import android.view.Surface;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecInfo;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaFormatUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+import java.nio.ByteBuffer;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public class MediaCodecAudioRenderer extends MediaCodecRenderer implements MediaClock {
+    private boolean allowFirstBufferPositionDiscontinuity;
+    private boolean allowPositionDiscontinuity;
+    private final AudioSink audioSink;
+    private int channelCount;
+    private int codecMaxInputSize;
+    private boolean codecNeedsDiscardChannelsWorkaround;
+    private final Context context;
+    private long currentPositionUs;
+    private int encoderDelay;
+    private int encoderPadding;
+    private final AudioRendererEventListener.EventDispatcher eventDispatcher;
+    private boolean passthroughEnabled;
+    private MediaFormat passthroughMediaFormat;
+    private int pcmEncoding;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public int canKeepCodec(MediaCodec mediaCodec, MediaCodecInfo mediaCodecInfo, Format format, Format format2) {
+        return 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return this;
+    }
+
+    public void onAudioSessionId(int i) {
+    }
+
+    public void onAudioTrackPositionDiscontinuity() {
+    }
+
+    public void onAudioTrackUnderrun(int i, long j, long j2) {
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector) {
+        this(context, mediaCodecSelector, (DrmSessionManager<FrameworkMediaCrypto>) null, false);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z) {
+        this(context, mediaCodecSelector, drmSessionManager, z, null, null);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+        this(context, mediaCodecSelector, null, false, handler, audioRendererEventListener);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+        this(context, mediaCodecSelector, drmSessionManager, z, handler, audioRendererEventListener, null, new AudioProcessor[0]);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener, @Nullable AudioCapabilities audioCapabilities, AudioProcessor... audioProcessorArr) {
+        this(context, mediaCodecSelector, drmSessionManager, z, handler, audioRendererEventListener, new DefaultAudioSink(audioCapabilities, audioProcessorArr));
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener, AudioSink audioSink) {
+        super(1, mediaCodecSelector, drmSessionManager, z);
+        this.context = context.getApplicationContext();
+        this.audioSink = audioSink;
+        this.eventDispatcher = new AudioRendererEventListener.EventDispatcher(handler, audioRendererEventListener);
+        audioSink.setListener(new AudioSinkListener());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public int supportsFormat(MediaCodecSelector mediaCodecSelector, DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, Format format) throws MediaCodecUtil.DecoderQueryException {
+        boolean z;
+        int i;
+        int i2;
+        String str = format.sampleMimeType;
+        if (!MimeTypes.isAudio(str)) {
+            return 0;
+        }
+        int i3 = Util.SDK_INT >= 21 ? 32 : 0;
+        boolean supportsFormatDrm = BaseRenderer.supportsFormatDrm(drmSessionManager, format.drmInitData);
+        if (supportsFormatDrm && allowPassthrough(str) && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
+            return i3 | 12;
+        }
+        if ((MimeTypes.AUDIO_RAW.equals(str) && !this.audioSink.isEncodingSupported(format.pcmEncoding)) || !this.audioSink.isEncodingSupported(2)) {
+            return 1;
+        }
+        DrmInitData drmInitData = format.drmInitData;
+        if (drmInitData != null) {
+            z = false;
+            for (int i4 = 0; i4 < drmInitData.schemeDataCount; i4++) {
+                z |= drmInitData.get(i4).requiresSecureDecryption;
+            }
+        } else {
+            z = false;
+        }
+        MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(str, z);
+        if (decoderInfo == null) {
+            return (!z || mediaCodecSelector.getDecoderInfo(str, false) == null) ? 1 : 2;
+        }
+        if (supportsFormatDrm) {
+            return ((Util.SDK_INT < 21 || (((i = format.sampleRate) == -1 || decoderInfo.isAudioSampleRateSupportedV21(i)) && ((i2 = format.channelCount) == -1 || decoderInfo.isAudioChannelCountSupportedV21(i2)))) ? 4 : 3) | i3 | 8;
+        }
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public MediaCodecInfo getDecoderInfo(MediaCodecSelector mediaCodecSelector, Format format, boolean z) throws MediaCodecUtil.DecoderQueryException {
+        MediaCodecInfo passthroughDecoderInfo;
+        return (!allowPassthrough(format.sampleMimeType) || (passthroughDecoderInfo = mediaCodecSelector.getPassthroughDecoderInfo()) == null) ? super.getDecoderInfo(mediaCodecSelector, format, z) : passthroughDecoderInfo;
+    }
+
+    public boolean allowPassthrough(String str) {
+        int encoding = MimeTypes.getEncoding(str);
+        return encoding != 0 && this.audioSink.isEncodingSupported(encoding);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void configureCodec(MediaCodecInfo mediaCodecInfo, MediaCodec mediaCodec, Format format, MediaCrypto mediaCrypto) {
+        this.codecMaxInputSize = getCodecMaxInputSize(mediaCodecInfo, format, getStreamFormats());
+        this.codecNeedsDiscardChannelsWorkaround = codecNeedsDiscardChannelsWorkaround(mediaCodecInfo.name);
+        this.passthroughEnabled = mediaCodecInfo.passthrough;
+        String str = mediaCodecInfo.mimeType;
+        if (str == null) {
+            str = MimeTypes.AUDIO_RAW;
+        }
+        MediaFormat mediaFormat = getMediaFormat(format, str, this.codecMaxInputSize);
+        mediaCodec.configure(mediaFormat, (Surface) null, mediaCrypto, 0);
+        if (!this.passthroughEnabled) {
+            this.passthroughMediaFormat = null;
+        } else {
+            this.passthroughMediaFormat = mediaFormat;
+            mediaFormat.setString("mime", format.sampleMimeType);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onCodecInitialized(String str, long j, long j2) {
+        this.eventDispatcher.decoderInitialized(str, j, j2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onInputFormatChanged(Format format) throws ExoPlaybackException {
+        super.onInputFormatChanged(format);
+        this.eventDispatcher.inputFormatChanged(format);
+        this.pcmEncoding = MimeTypes.AUDIO_RAW.equals(format.sampleMimeType) ? format.pcmEncoding : 2;
+        this.channelCount = format.channelCount;
+        this.encoderDelay = format.encoderDelay;
+        this.encoderPadding = format.encoderPadding;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onOutputFormatChanged(MediaCodec mediaCodec, MediaFormat mediaFormat) throws ExoPlaybackException {
+        int i;
+        int[] iArr;
+        int i2;
+        MediaFormat mediaFormat2 = this.passthroughMediaFormat;
+        if (mediaFormat2 != null) {
+            i = MimeTypes.getEncoding(mediaFormat2.getString("mime"));
+            mediaFormat = this.passthroughMediaFormat;
+        } else {
+            i = this.pcmEncoding;
+        }
+        int i3 = i;
+        int integer = mediaFormat.getInteger("channel-count");
+        int integer2 = mediaFormat.getInteger("sample-rate");
+        if (this.codecNeedsDiscardChannelsWorkaround && integer == 6 && (i2 = this.channelCount) < 6) {
+            iArr = new int[i2];
+            for (int i4 = 0; i4 < this.channelCount; i4++) {
+                iArr[i4] = i4;
+            }
+        } else {
+            iArr = null;
+        }
+        try {
+            this.audioSink.configure(i3, integer, integer2, 0, iArr, this.encoderDelay, this.encoderPadding);
+        } catch (AudioSink.ConfigurationException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+        super.onEnabled(z);
+        this.eventDispatcher.enabled(this.decoderCounters);
+        int i = getConfiguration().tunnelingAudioSessionId;
+        if (i != 0) {
+            this.audioSink.enableTunnelingV21(i);
+        } else {
+            this.audioSink.disableTunneling();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+        super.onPositionReset(j, z);
+        this.audioSink.reset();
+        this.currentPositionUs = j;
+        this.allowFirstBufferPositionDiscontinuity = true;
+        this.allowPositionDiscontinuity = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStarted() {
+        super.onStarted();
+        this.audioSink.play();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStopped() {
+        updateCurrentPosition();
+        this.audioSink.pause();
+        super.onStopped();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onDisabled() {
+        try {
+            this.audioSink.release();
+            try {
+                super.onDisabled();
+            } finally {
+            }
+        } catch (Throwable th) {
+            try {
+                super.onDisabled();
+                throw th;
+            } finally {
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isEnded() {
+        return super.isEnded() && this.audioSink.isEnded();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isReady() {
+        return this.audioSink.hasPendingData() || super.isReady();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public long getPositionUs() {
+        if (getState() == 2) {
+            updateCurrentPosition();
+        }
+        return this.currentPositionUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        return this.audioSink.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters getPlaybackParameters() {
+        return this.audioSink.getPlaybackParameters();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onQueueInputBuffer(DecoderInputBuffer decoderInputBuffer) {
+        if (!this.allowFirstBufferPositionDiscontinuity || decoderInputBuffer.isDecodeOnly()) {
+            return;
+        }
+        if (Math.abs(decoderInputBuffer.timeUs - this.currentPositionUs) > 500000) {
+            this.currentPositionUs = decoderInputBuffer.timeUs;
+        }
+        this.allowFirstBufferPositionDiscontinuity = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public boolean processOutputBuffer(long j, long j2, MediaCodec mediaCodec, ByteBuffer byteBuffer, int i, int i2, long j3, boolean z) throws ExoPlaybackException {
+        if (this.passthroughEnabled && (i2 & 2) != 0) {
+            mediaCodec.releaseOutputBuffer(i, false);
+            return true;
+        }
+        if (z) {
+            mediaCodec.releaseOutputBuffer(i, false);
+            this.decoderCounters.skippedOutputBufferCount++;
+            this.audioSink.handleDiscontinuity();
+            return true;
+        }
+        try {
+            if (!this.audioSink.handleBuffer(byteBuffer, j3)) {
+                return false;
+            }
+            mediaCodec.releaseOutputBuffer(i, false);
+            this.decoderCounters.renderedOutputBufferCount++;
+            return true;
+        } catch (AudioSink.InitializationException | AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void renderToEndOfStream() throws ExoPlaybackException {
+        try {
+            this.audioSink.playToEndOfStream();
+        } catch (AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+        if (i == 2) {
+            this.audioSink.setVolume(((Float) obj).floatValue());
+        } else if (i == 3) {
+            this.audioSink.setAudioAttributes((AudioAttributes) obj);
+        } else {
+            super.handleMessage(i, obj);
+        }
+    }
+
+    public int getCodecMaxInputSize(MediaCodecInfo mediaCodecInfo, Format format, Format[] formatArr) {
+        return getCodecMaxInputSize(mediaCodecInfo, format);
+    }
+
+    private int getCodecMaxInputSize(MediaCodecInfo mediaCodecInfo, Format format) {
+        PackageManager packageManager;
+        int i = Util.SDK_INT;
+        if (i >= 24 || !"OMX.google.raw.decoder".equals(mediaCodecInfo.name) || (i == 23 && (packageManager = this.context.getPackageManager()) != null && packageManager.hasSystemFeature("android.software.leanback"))) {
+            return format.maxInputSize;
+        }
+        return -1;
+    }
+
+    @SuppressLint({"InlinedApi"})
+    public MediaFormat getMediaFormat(Format format, String str, int i) {
+        MediaFormat mediaFormat = new MediaFormat();
+        mediaFormat.setString("mime", str);
+        mediaFormat.setInteger("channel-count", format.channelCount);
+        mediaFormat.setInteger("sample-rate", format.sampleRate);
+        MediaFormatUtil.setCsdBuffers(mediaFormat, format.initializationData);
+        MediaFormatUtil.maybeSetInteger(mediaFormat, "max-input-size", i);
+        if (Util.SDK_INT >= 23) {
+            mediaFormat.setInteger(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY, 0);
+        }
+        return mediaFormat;
+    }
+
+    private void updateCurrentPosition() {
+        long currentPositionUs = this.audioSink.getCurrentPositionUs(isEnded());
+        if (currentPositionUs != Long.MIN_VALUE) {
+            if (!this.allowPositionDiscontinuity) {
+                currentPositionUs = Math.max(this.currentPositionUs, currentPositionUs);
+            }
+            this.currentPositionUs = currentPositionUs;
+            this.allowPositionDiscontinuity = false;
+        }
+    }
+
+    private static boolean areAdaptationCompatible(Format format, Format format2) {
+        return format.sampleMimeType.equals(format2.sampleMimeType) && format.channelCount == format2.channelCount && format.sampleRate == format2.sampleRate && format.encoderDelay == 0 && format.encoderPadding == 0 && format2.encoderDelay == 0 && format2.encoderPadding == 0 && format.initializationDataEquals(format2);
+    }
+
+    private static boolean codecNeedsDiscardChannelsWorkaround(String str) {
+        if (Util.SDK_INT < 24 && "OMX.SEC.aac.dec".equals(str) && "samsung".equals(Util.MANUFACTURER)) {
+            String str2 = Util.DEVICE;
+            if (str2.startsWith("zeroflte") || str2.startsWith("herolte") || str2.startsWith("heroqlte")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final class AudioSinkListener implements AudioSink.Listener {
+        private AudioSinkListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onAudioSessionId(int i) {
+            MediaCodecAudioRenderer.this.eventDispatcher.audioSessionId(i);
+            MediaCodecAudioRenderer.this.onAudioSessionId(i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onPositionDiscontinuity() {
+            MediaCodecAudioRenderer.this.onAudioTrackPositionDiscontinuity();
+            MediaCodecAudioRenderer.this.allowPositionDiscontinuity = true;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onUnderrun(int i, long j, long j2) {
+            MediaCodecAudioRenderer.this.eventDispatcher.audioTrackUnderrun(i, j, j2);
+            MediaCodecAudioRenderer.this.onAudioTrackUnderrun(i, j, j2);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/ResamplingAudioProcessor.java

@@ -0,0 +1,192 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+final class ResamplingAudioProcessor implements AudioProcessor {
+    private ByteBuffer buffer;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private int sampleRateHz = -1;
+    private int channelCount = -1;
+    private int encoding = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        int i = this.encoding;
+        return (i == 0 || i == 2) ? false : true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public ResamplingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 3 && i3 != 2 && i3 != Integer.MIN_VALUE && i3 != 1073741824) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.encoding == i3) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.encoding = i3;
+        return true;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:11:0x0045  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0083 A[ADDED_TO_REGION, LOOP:2: B:24:0x0083->B:25:0x0085, LOOP_START, PHI: r0
+  0x0083: PHI (r0v1 int) = (r0v0 int), (r0v2 int) binds: [B:10:0x0043, B:25:0x0085] A[DONT_GENERATE, DONT_INLINE]] */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x003c  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x002d  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void queueInput(java.nio.ByteBuffer r8) {
+        /*
+            r7 = this;
+            int r0 = r8.position()
+            int r1 = r8.limit()
+            int r2 = r1 - r0
+            int r3 = r7.encoding
+            r4 = 1073741824(0x40000000, float:2.0)
+            r5 = -2147483648(0xffffffff80000000, float:-0.0)
+            r6 = 3
+            if (r3 == r5) goto L23
+            if (r3 == r6) goto L20
+            if (r3 != r4) goto L1a
+            int r2 = r2 / 2
+            goto L25
+        L1a:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            r8.<init>()
+            throw r8
+        L20:
+            int r2 = r2 * 2
+            goto L25
+        L23:
+            int r2 = r2 / r6
+            goto L20
+        L25:
+            java.nio.ByteBuffer r3 = r7.buffer
+            int r3 = r3.capacity()
+            if (r3 >= r2) goto L3c
+            java.nio.ByteBuffer r2 = java.nio.ByteBuffer.allocateDirect(r2)
+            java.nio.ByteOrder r3 = java.nio.ByteOrder.nativeOrder()
+            java.nio.ByteBuffer r2 = r2.order(r3)
+            r7.buffer = r2
+            goto L41
+        L3c:
+            java.nio.ByteBuffer r2 = r7.buffer
+            r2.clear()
+        L41:
+            int r2 = r7.encoding
+            if (r2 == r5) goto L83
+            if (r2 == r6) goto L6a
+            if (r2 != r4) goto L64
+        L49:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 2
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 3
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            int r0 = r0 + 4
+            goto L49
+        L64:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            r8.<init>()
+            throw r8
+        L6a:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            r3 = 0
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            byte r3 = r8.get(r0)
+            r3 = r3 & 255(0xff, float:3.57E-43)
+            int r3 = r3 + (-128)
+            byte r3 = (byte) r3
+            r2.put(r3)
+            int r0 = r0 + 1
+            goto L6a
+        L83:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 1
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 2
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            int r0 = r0 + 3
+            goto L83
+        L9e:
+            int r0 = r8.limit()
+            r8.position(r0)
+            java.nio.ByteBuffer r8 = r7.buffer
+            r8.flip()
+            java.nio.ByteBuffer r8 = r7.buffer
+            r7.outputBuffer = r8
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.ResamplingAudioProcessor.queueInput(java.nio.ByteBuffer):void");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.sampleRateHz = -1;
+        this.channelCount = -1;
+        this.encoding = 0;
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SilenceSkippingAudioProcessor.java

@@ -0,0 +1,280 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public final class SilenceSkippingAudioProcessor implements AudioProcessor {
+    private static final long MINIMUM_SILENCE_DURATION_US = 150000;
+    private static final long PADDING_SILENCE_US = 20000;
+    private static final short SILENCE_THRESHOLD_LEVEL = 1024;
+    private static final byte SILENCE_THRESHOLD_LEVEL_MSB = 4;
+    private static final int STATE_MAYBE_SILENT = 1;
+    private static final int STATE_NOISY = 0;
+    private static final int STATE_SILENT = 2;
+    private ByteBuffer buffer;
+    private int bytesPerFrame;
+    private int channelCount;
+    private boolean enabled;
+    private boolean hasOutputNoise;
+    private boolean inputEnded;
+    private byte[] maybeSilenceBuffer;
+    private int maybeSilenceBufferSize;
+    private ByteBuffer outputBuffer;
+    private byte[] paddingBuffer;
+    private int paddingSize;
+    private int sampleRateHz;
+    private long skippedFrames;
+    private int state;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    public final long getSkippedFrames() {
+        return this.skippedFrames;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.sampleRateHz != -1 && this.enabled;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    public SilenceSkippingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.maybeSilenceBuffer = new byte[0];
+        this.paddingBuffer = new byte[0];
+    }
+
+    public final void setEnabled(boolean z) {
+        this.enabled = z;
+        flush();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.bytesPerFrame = i2 * 2;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        while (byteBuffer.hasRemaining() && !this.outputBuffer.hasRemaining()) {
+            int i = this.state;
+            if (i == 0) {
+                processNoisy(byteBuffer);
+            } else if (i == 1) {
+                processMaybeSilence(byteBuffer);
+            } else if (i == 2) {
+                processSilence(byteBuffer);
+            } else {
+                throw new IllegalStateException();
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+        int i = this.maybeSilenceBufferSize;
+        if (i > 0) {
+            output(this.maybeSilenceBuffer, i);
+        }
+        if (this.hasOutputNoise) {
+            return;
+        }
+        this.skippedFrames += this.paddingSize / this.bytesPerFrame;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        if (isActive()) {
+            int durationUsToFrames = durationUsToFrames(MINIMUM_SILENCE_DURATION_US) * this.bytesPerFrame;
+            if (this.maybeSilenceBuffer.length != durationUsToFrames) {
+                this.maybeSilenceBuffer = new byte[durationUsToFrames];
+            }
+            int durationUsToFrames2 = durationUsToFrames(PADDING_SILENCE_US) * this.bytesPerFrame;
+            this.paddingSize = durationUsToFrames2;
+            if (this.paddingBuffer.length != durationUsToFrames2) {
+                this.paddingBuffer = new byte[durationUsToFrames2];
+            }
+        }
+        this.state = 0;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+        this.skippedFrames = 0L;
+        this.maybeSilenceBufferSize = 0;
+        this.hasOutputNoise = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        this.enabled = false;
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.paddingSize = 0;
+        this.maybeSilenceBuffer = new byte[0];
+        this.paddingBuffer = new byte[0];
+    }
+
+    private void processNoisy(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        byteBuffer.limit(Math.min(limit, byteBuffer.position() + this.maybeSilenceBuffer.length));
+        int findNoiseLimit = findNoiseLimit(byteBuffer);
+        if (findNoiseLimit == byteBuffer.position()) {
+            this.state = 1;
+        } else {
+            byteBuffer.limit(findNoiseLimit);
+            output(byteBuffer);
+        }
+        byteBuffer.limit(limit);
+    }
+
+    private void processMaybeSilence(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        int findNoisePosition = findNoisePosition(byteBuffer);
+        int position = findNoisePosition - byteBuffer.position();
+        byte[] bArr = this.maybeSilenceBuffer;
+        int length = bArr.length;
+        int i = this.maybeSilenceBufferSize;
+        int i2 = length - i;
+        if (findNoisePosition < limit && position < i2) {
+            output(bArr, i);
+            this.maybeSilenceBufferSize = 0;
+            this.state = 0;
+            return;
+        }
+        int min = Math.min(position, i2);
+        byteBuffer.limit(byteBuffer.position() + min);
+        byteBuffer.get(this.maybeSilenceBuffer, this.maybeSilenceBufferSize, min);
+        int i3 = this.maybeSilenceBufferSize + min;
+        this.maybeSilenceBufferSize = i3;
+        byte[] bArr2 = this.maybeSilenceBuffer;
+        if (i3 == bArr2.length) {
+            if (this.hasOutputNoise) {
+                output(bArr2, this.paddingSize);
+                this.skippedFrames += (this.maybeSilenceBufferSize - (this.paddingSize * 2)) / this.bytesPerFrame;
+            } else {
+                this.skippedFrames += (i3 - this.paddingSize) / this.bytesPerFrame;
+            }
+            updatePaddingBuffer(byteBuffer, this.maybeSilenceBuffer, this.maybeSilenceBufferSize);
+            this.maybeSilenceBufferSize = 0;
+            this.state = 2;
+        }
+        byteBuffer.limit(limit);
+    }
+
+    private void processSilence(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        int findNoisePosition = findNoisePosition(byteBuffer);
+        byteBuffer.limit(findNoisePosition);
+        this.skippedFrames += byteBuffer.remaining() / this.bytesPerFrame;
+        updatePaddingBuffer(byteBuffer, this.paddingBuffer, this.paddingSize);
+        if (findNoisePosition < limit) {
+            output(this.paddingBuffer, this.paddingSize);
+            this.state = 0;
+            byteBuffer.limit(limit);
+        }
+    }
+
+    private void output(byte[] bArr, int i) {
+        prepareForOutput(i);
+        this.buffer.put(bArr, 0, i);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    private void output(ByteBuffer byteBuffer) {
+        prepareForOutput(byteBuffer.remaining());
+        this.buffer.put(byteBuffer);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    private void prepareForOutput(int i) {
+        if (this.buffer.capacity() < i) {
+            this.buffer = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        if (i > 0) {
+            this.hasOutputNoise = true;
+        }
+    }
+
+    private void updatePaddingBuffer(ByteBuffer byteBuffer, byte[] bArr, int i) {
+        int min = Math.min(byteBuffer.remaining(), this.paddingSize);
+        int i2 = this.paddingSize - min;
+        System.arraycopy(bArr, i - i2, this.paddingBuffer, 0, i2);
+        byteBuffer.position(byteBuffer.limit() - min);
+        byteBuffer.get(this.paddingBuffer, i2, min);
+    }
+
+    private int durationUsToFrames(long j) {
+        return (int) ((j * this.sampleRateHz) / 1000000);
+    }
+
+    private int findNoisePosition(ByteBuffer byteBuffer) {
+        for (int position = byteBuffer.position() + 1; position < byteBuffer.limit(); position += 2) {
+            if (Math.abs((int) byteBuffer.get(position)) > 4) {
+                int i = this.bytesPerFrame;
+                return i * (position / i);
+            }
+        }
+        return byteBuffer.limit();
+    }
+
+    private int findNoiseLimit(ByteBuffer byteBuffer) {
+        for (int limit = byteBuffer.limit() - 1; limit >= byteBuffer.position(); limit -= 2) {
+            if (Math.abs((int) byteBuffer.get(limit)) > 4) {
+                int i = this.bytesPerFrame;
+                return ((limit / i) * i) + i;
+            }
+        }
+        return byteBuffer.position();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SimpleDecoderAudioRenderer.java

@@ -0,0 +1,537 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.FormatHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleOutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TraceUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public abstract class SimpleDecoderAudioRenderer extends BaseRenderer implements MediaClock {
+    private static final int REINITIALIZATION_STATE_NONE = 0;
+    private static final int REINITIALIZATION_STATE_SIGNAL_END_OF_STREAM = 1;
+    private static final int REINITIALIZATION_STATE_WAIT_END_OF_STREAM = 2;
+    private boolean allowFirstBufferPositionDiscontinuity;
+    private boolean allowPositionDiscontinuity;
+    private final AudioSink audioSink;
+    private boolean audioTrackNeedsConfigure;
+    private long currentPositionUs;
+    private SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> decoder;
+    private DecoderCounters decoderCounters;
+    private boolean decoderReceivedBuffers;
+    private int decoderReinitializationState;
+    private DrmSession<ExoMediaCrypto> drmSession;
+    private final DrmSessionManager<ExoMediaCrypto> drmSessionManager;
+    private int encoderDelay;
+    private int encoderPadding;
+    private final AudioRendererEventListener.EventDispatcher eventDispatcher;
+    private final DecoderInputBuffer flagsOnlyBuffer;
+    private final FormatHolder formatHolder;
+    private DecoderInputBuffer inputBuffer;
+    private Format inputFormat;
+    private boolean inputStreamEnded;
+    private SimpleOutputBuffer outputBuffer;
+    private boolean outputStreamEnded;
+    private DrmSession<ExoMediaCrypto> pendingDrmSession;
+    private final boolean playClearSamplesWithoutKeys;
+    private boolean waitingForKeys;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ReinitializationState {
+    }
+
+    public abstract SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> createDecoder(Format format, ExoMediaCrypto exoMediaCrypto) throws AudioDecoderException;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return this;
+    }
+
+    public void onAudioSessionId(int i) {
+    }
+
+    public void onAudioTrackPositionDiscontinuity() {
+    }
+
+    public void onAudioTrackUnderrun(int i, long j, long j2) {
+    }
+
+    public abstract int supportsFormatInternal(DrmSessionManager<ExoMediaCrypto> drmSessionManager, Format format);
+
+    public SimpleDecoderAudioRenderer() {
+        this((Handler) null, (AudioRendererEventListener) null, new AudioProcessor[0]);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioProcessor... audioProcessorArr) {
+        this(handler, audioRendererEventListener, null, null, false, audioProcessorArr);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioCapabilities audioCapabilities) {
+        this(handler, audioRendererEventListener, audioCapabilities, null, false, new AudioProcessor[0]);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioCapabilities audioCapabilities, DrmSessionManager<ExoMediaCrypto> drmSessionManager, boolean z, AudioProcessor... audioProcessorArr) {
+        this(handler, audioRendererEventListener, drmSessionManager, z, new DefaultAudioSink(audioCapabilities, audioProcessorArr));
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, DrmSessionManager<ExoMediaCrypto> drmSessionManager, boolean z, AudioSink audioSink) {
+        super(1);
+        this.drmSessionManager = drmSessionManager;
+        this.playClearSamplesWithoutKeys = z;
+        this.eventDispatcher = new AudioRendererEventListener.EventDispatcher(handler, audioRendererEventListener);
+        this.audioSink = audioSink;
+        audioSink.setListener(new AudioSinkListener());
+        this.formatHolder = new FormatHolder();
+        this.flagsOnlyBuffer = DecoderInputBuffer.newFlagsOnlyInstance();
+        this.decoderReinitializationState = 0;
+        this.audioTrackNeedsConfigure = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public final int supportsFormat(Format format) {
+        int supportsFormatInternal = supportsFormatInternal(this.drmSessionManager, format);
+        if (supportsFormatInternal <= 2) {
+            return supportsFormatInternal;
+        }
+        return supportsFormatInternal | (Util.SDK_INT >= 21 ? 32 : 0) | 8;
+    }
+
+    public final boolean supportsOutputEncoding(int i) {
+        return this.audioSink.isEncodingSupported(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public void render(long j, long j2) throws ExoPlaybackException {
+        if (this.outputStreamEnded) {
+            try {
+                this.audioSink.playToEndOfStream();
+                return;
+            } catch (AudioSink.WriteException e) {
+                throw ExoPlaybackException.createForRenderer(e, getIndex());
+            }
+        }
+        if (this.inputFormat == null) {
+            this.flagsOnlyBuffer.clear();
+            int readSource = readSource(this.formatHolder, this.flagsOnlyBuffer, true);
+            if (readSource != -5) {
+                if (readSource == -4) {
+                    Assertions.checkState(this.flagsOnlyBuffer.isEndOfStream());
+                    this.inputStreamEnded = true;
+                    processEndOfStream();
+                    return;
+                }
+                return;
+            }
+            onInputFormatChanged(this.formatHolder.format);
+        }
+        maybeInitDecoder();
+        if (this.decoder != null) {
+            try {
+                TraceUtil.beginSection("drainAndFeed");
+                while (drainOutputBuffer()) {
+                }
+                while (feedInputBuffer()) {
+                }
+                TraceUtil.endSection();
+                this.decoderCounters.ensureUpdated();
+            } catch (AudioDecoderException | AudioSink.ConfigurationException | AudioSink.InitializationException | AudioSink.WriteException e2) {
+                throw ExoPlaybackException.createForRenderer(e2, getIndex());
+            }
+        }
+    }
+
+    public Format getOutputFormat() {
+        Format format = this.inputFormat;
+        return Format.createAudioSampleFormat(null, MimeTypes.AUDIO_RAW, null, -1, -1, format.channelCount, format.sampleRate, 2, null, null, 0, null);
+    }
+
+    private boolean drainOutputBuffer() throws ExoPlaybackException, AudioDecoderException, AudioSink.ConfigurationException, AudioSink.InitializationException, AudioSink.WriteException {
+        if (this.outputBuffer == null) {
+            SimpleOutputBuffer dequeueOutputBuffer = this.decoder.dequeueOutputBuffer();
+            this.outputBuffer = dequeueOutputBuffer;
+            if (dequeueOutputBuffer == null) {
+                return false;
+            }
+            this.decoderCounters.skippedOutputBufferCount += dequeueOutputBuffer.skippedOutputBufferCount;
+        }
+        if (this.outputBuffer.isEndOfStream()) {
+            if (this.decoderReinitializationState == 2) {
+                releaseDecoder();
+                maybeInitDecoder();
+                this.audioTrackNeedsConfigure = true;
+            } else {
+                this.outputBuffer.release();
+                this.outputBuffer = null;
+                processEndOfStream();
+            }
+            return false;
+        }
+        if (this.audioTrackNeedsConfigure) {
+            Format outputFormat = getOutputFormat();
+            this.audioSink.configure(outputFormat.pcmEncoding, outputFormat.channelCount, outputFormat.sampleRate, 0, null, this.encoderDelay, this.encoderPadding);
+            this.audioTrackNeedsConfigure = false;
+        }
+        AudioSink audioSink = this.audioSink;
+        SimpleOutputBuffer simpleOutputBuffer = this.outputBuffer;
+        if (!audioSink.handleBuffer(simpleOutputBuffer.data, simpleOutputBuffer.timeUs)) {
+            return false;
+        }
+        this.decoderCounters.renderedOutputBufferCount++;
+        this.outputBuffer.release();
+        this.outputBuffer = null;
+        return true;
+    }
+
+    private boolean feedInputBuffer() throws AudioDecoderException, ExoPlaybackException {
+        SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> simpleDecoder = this.decoder;
+        if (simpleDecoder == null || this.decoderReinitializationState == 2 || this.inputStreamEnded) {
+            return false;
+        }
+        if (this.inputBuffer == null) {
+            DecoderInputBuffer dequeueInputBuffer = simpleDecoder.dequeueInputBuffer();
+            this.inputBuffer = dequeueInputBuffer;
+            if (dequeueInputBuffer == null) {
+                return false;
+            }
+        }
+        if (this.decoderReinitializationState == 1) {
+            this.inputBuffer.setFlags(4);
+            this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+            this.inputBuffer = null;
+            this.decoderReinitializationState = 2;
+            return false;
+        }
+        int readSource = this.waitingForKeys ? -4 : readSource(this.formatHolder, this.inputBuffer, false);
+        if (readSource == -3) {
+            return false;
+        }
+        if (readSource == -5) {
+            onInputFormatChanged(this.formatHolder.format);
+            return true;
+        }
+        if (this.inputBuffer.isEndOfStream()) {
+            this.inputStreamEnded = true;
+            this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+            this.inputBuffer = null;
+            return false;
+        }
+        boolean shouldWaitForKeys = shouldWaitForKeys(this.inputBuffer.isEncrypted());
+        this.waitingForKeys = shouldWaitForKeys;
+        if (shouldWaitForKeys) {
+            return false;
+        }
+        this.inputBuffer.flip();
+        onQueueInputBuffer(this.inputBuffer);
+        this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+        this.decoderReceivedBuffers = true;
+        this.decoderCounters.inputBufferCount++;
+        this.inputBuffer = null;
+        return true;
+    }
+
+    private boolean shouldWaitForKeys(boolean z) throws ExoPlaybackException {
+        DrmSession<ExoMediaCrypto> drmSession = this.drmSession;
+        if (drmSession == null || (!z && this.playClearSamplesWithoutKeys)) {
+            return false;
+        }
+        int state = drmSession.getState();
+        if (state != 1) {
+            return state != 4;
+        }
+        throw ExoPlaybackException.createForRenderer(this.drmSession.getError(), getIndex());
+    }
+
+    private void processEndOfStream() throws ExoPlaybackException {
+        this.outputStreamEnded = true;
+        try {
+            this.audioSink.playToEndOfStream();
+        } catch (AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    private void flushDecoder() throws ExoPlaybackException {
+        this.waitingForKeys = false;
+        if (this.decoderReinitializationState != 0) {
+            releaseDecoder();
+            maybeInitDecoder();
+            return;
+        }
+        this.inputBuffer = null;
+        SimpleOutputBuffer simpleOutputBuffer = this.outputBuffer;
+        if (simpleOutputBuffer != null) {
+            simpleOutputBuffer.release();
+            this.outputBuffer = null;
+        }
+        this.decoder.flush();
+        this.decoderReceivedBuffers = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isEnded() {
+        return this.outputStreamEnded && this.audioSink.isEnded();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isReady() {
+        return this.audioSink.hasPendingData() || !(this.inputFormat == null || this.waitingForKeys || (!isSourceReady() && this.outputBuffer == null));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public long getPositionUs() {
+        if (getState() == 2) {
+            updateCurrentPosition();
+        }
+        return this.currentPositionUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        return this.audioSink.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters getPlaybackParameters() {
+        return this.audioSink.getPlaybackParameters();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+        DecoderCounters decoderCounters = new DecoderCounters();
+        this.decoderCounters = decoderCounters;
+        this.eventDispatcher.enabled(decoderCounters);
+        int i = getConfiguration().tunnelingAudioSessionId;
+        if (i != 0) {
+            this.audioSink.enableTunnelingV21(i);
+        } else {
+            this.audioSink.disableTunneling();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+        this.audioSink.reset();
+        this.currentPositionUs = j;
+        this.allowFirstBufferPositionDiscontinuity = true;
+        this.allowPositionDiscontinuity = true;
+        this.inputStreamEnded = false;
+        this.outputStreamEnded = false;
+        if (this.decoder != null) {
+            flushDecoder();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStarted() {
+        this.audioSink.play();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStopped() {
+        updateCurrentPosition();
+        this.audioSink.pause();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onDisabled() {
+        this.inputFormat = null;
+        this.audioTrackNeedsConfigure = true;
+        this.waitingForKeys = false;
+        try {
+            releaseDecoder();
+            this.audioSink.release();
+            try {
+                DrmSession<ExoMediaCrypto> drmSession = this.drmSession;
+                if (drmSession != null) {
+                    this.drmSessionManager.releaseSession(drmSession);
+                }
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession2 = this.pendingDrmSession;
+                    if (drmSession2 != null && drmSession2 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession2);
+                    }
+                } finally {
+                }
+            } catch (Throwable th) {
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession3 = this.pendingDrmSession;
+                    if (drmSession3 != null && drmSession3 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession3);
+                    }
+                    throw th;
+                } finally {
+                }
+            }
+        } catch (Throwable th2) {
+            try {
+                DrmSession<ExoMediaCrypto> drmSession4 = this.drmSession;
+                if (drmSession4 != null) {
+                    this.drmSessionManager.releaseSession(drmSession4);
+                }
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession5 = this.pendingDrmSession;
+                    if (drmSession5 != null && drmSession5 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession5);
+                    }
+                    throw th2;
+                } finally {
+                }
+            } catch (Throwable th3) {
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession6 = this.pendingDrmSession;
+                    if (drmSession6 != null && drmSession6 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession6);
+                    }
+                    throw th3;
+                } finally {
+                }
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+        if (i == 2) {
+            this.audioSink.setVolume(((Float) obj).floatValue());
+        } else if (i == 3) {
+            this.audioSink.setAudioAttributes((AudioAttributes) obj);
+        } else {
+            super.handleMessage(i, obj);
+        }
+    }
+
+    private void maybeInitDecoder() throws ExoPlaybackException {
+        ExoMediaCrypto exoMediaCrypto;
+        if (this.decoder != null) {
+            return;
+        }
+        DrmSession<ExoMediaCrypto> drmSession = this.pendingDrmSession;
+        this.drmSession = drmSession;
+        if (drmSession != null) {
+            exoMediaCrypto = drmSession.getMediaCrypto();
+            if (exoMediaCrypto == null && this.drmSession.getError() == null) {
+                return;
+            }
+        } else {
+            exoMediaCrypto = null;
+        }
+        try {
+            long elapsedRealtime = SystemClock.elapsedRealtime();
+            TraceUtil.beginSection("createAudioDecoder");
+            this.decoder = createDecoder(this.inputFormat, exoMediaCrypto);
+            TraceUtil.endSection();
+            long elapsedRealtime2 = SystemClock.elapsedRealtime();
+            this.eventDispatcher.decoderInitialized(this.decoder.getName(), elapsedRealtime2, elapsedRealtime2 - elapsedRealtime);
+            this.decoderCounters.decoderInitCount++;
+        } catch (AudioDecoderException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    private void releaseDecoder() {
+        SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> simpleDecoder = this.decoder;
+        if (simpleDecoder == null) {
+            return;
+        }
+        this.inputBuffer = null;
+        this.outputBuffer = null;
+        simpleDecoder.release();
+        this.decoder = null;
+        this.decoderCounters.decoderReleaseCount++;
+        this.decoderReinitializationState = 0;
+        this.decoderReceivedBuffers = false;
+    }
+
+    private void onInputFormatChanged(Format format) throws ExoPlaybackException {
+        Format format2 = this.inputFormat;
+        this.inputFormat = format;
+        if (!Util.areEqual(format.drmInitData, format2 == null ? null : format2.drmInitData)) {
+            if (this.inputFormat.drmInitData != null) {
+                DrmSessionManager<ExoMediaCrypto> drmSessionManager = this.drmSessionManager;
+                if (drmSessionManager == null) {
+                    throw ExoPlaybackException.createForRenderer(new IllegalStateException("Media requires a DrmSessionManager"), getIndex());
+                }
+                DrmSession<ExoMediaCrypto> acquireSession = drmSessionManager.acquireSession(Looper.myLooper(), this.inputFormat.drmInitData);
+                this.pendingDrmSession = acquireSession;
+                if (acquireSession == this.drmSession) {
+                    this.drmSessionManager.releaseSession(acquireSession);
+                }
+            } else {
+                this.pendingDrmSession = null;
+            }
+        }
+        if (this.decoderReceivedBuffers) {
+            this.decoderReinitializationState = 1;
+        } else {
+            releaseDecoder();
+            maybeInitDecoder();
+            this.audioTrackNeedsConfigure = true;
+        }
+        this.encoderDelay = format.encoderDelay;
+        this.encoderPadding = format.encoderPadding;
+        this.eventDispatcher.inputFormatChanged(format);
+    }
+
+    private void onQueueInputBuffer(DecoderInputBuffer decoderInputBuffer) {
+        if (!this.allowFirstBufferPositionDiscontinuity || decoderInputBuffer.isDecodeOnly()) {
+            return;
+        }
+        if (Math.abs(decoderInputBuffer.timeUs - this.currentPositionUs) > 500000) {
+            this.currentPositionUs = decoderInputBuffer.timeUs;
+        }
+        this.allowFirstBufferPositionDiscontinuity = false;
+    }
+
+    private void updateCurrentPosition() {
+        long currentPositionUs = this.audioSink.getCurrentPositionUs(isEnded());
+        if (currentPositionUs != Long.MIN_VALUE) {
+            if (!this.allowPositionDiscontinuity) {
+                currentPositionUs = Math.max(this.currentPositionUs, currentPositionUs);
+            }
+            this.currentPositionUs = currentPositionUs;
+            this.allowPositionDiscontinuity = false;
+        }
+    }
+
+    public final class AudioSinkListener implements AudioSink.Listener {
+        private AudioSinkListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onAudioSessionId(int i) {
+            SimpleDecoderAudioRenderer.this.eventDispatcher.audioSessionId(i);
+            SimpleDecoderAudioRenderer.this.onAudioSessionId(i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onPositionDiscontinuity() {
+            SimpleDecoderAudioRenderer.this.onAudioTrackPositionDiscontinuity();
+            SimpleDecoderAudioRenderer.this.allowPositionDiscontinuity = true;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onUnderrun(int i, long j, long j2) {
+            SimpleDecoderAudioRenderer.this.eventDispatcher.audioTrackUnderrun(i, j, j2);
+            SimpleDecoderAudioRenderer.this.onAudioTrackUnderrun(i, j, j2);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/Sonic.java

@@ -0,0 +1,402 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.nio.ShortBuffer;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class Sonic {
+    private static final int AMDF_FREQUENCY = 4000;
+    private static final int MAXIMUM_PITCH = 400;
+    private static final int MINIMUM_PITCH = 65;
+    private final int channelCount;
+    private final short[] downSampleBuffer;
+    private short[] inputBuffer;
+    private int inputFrameCount;
+    private final int inputSampleRateHz;
+    private int maxDiff;
+    private final int maxPeriod;
+    private final int maxRequiredFrameCount;
+    private int minDiff;
+    private final int minPeriod;
+    private int newRatePosition;
+    private int oldRatePosition;
+    private short[] outputBuffer;
+    private int outputFrameCount;
+    private final float pitch;
+    private short[] pitchBuffer;
+    private int pitchFrameCount;
+    private int prevMinDiff;
+    private int prevPeriod;
+    private final float rate;
+    private int remainingInputToCopyFrameCount;
+    private final float speed;
+
+    private boolean previousPeriodBetter(int i, int i2) {
+        return i != 0 && this.prevPeriod != 0 && i2 <= i * 3 && i * 2 > this.prevMinDiff * 3;
+    }
+
+    public final void flush() {
+        this.inputFrameCount = 0;
+        this.outputFrameCount = 0;
+        this.pitchFrameCount = 0;
+        this.oldRatePosition = 0;
+        this.newRatePosition = 0;
+        this.remainingInputToCopyFrameCount = 0;
+        this.prevPeriod = 0;
+        this.prevMinDiff = 0;
+        this.minDiff = 0;
+        this.maxDiff = 0;
+    }
+
+    public final int getFramesAvailable() {
+        return this.outputFrameCount;
+    }
+
+    public Sonic(int i, int i2, float f, float f2, int i3) {
+        this.inputSampleRateHz = i;
+        this.channelCount = i2;
+        this.speed = f;
+        this.pitch = f2;
+        this.rate = i / i3;
+        this.minPeriod = i / 400;
+        int i4 = i / 65;
+        this.maxPeriod = i4;
+        int i5 = i4 * 2;
+        this.maxRequiredFrameCount = i5;
+        this.downSampleBuffer = new short[i5];
+        this.inputBuffer = new short[i5 * i2];
+        this.outputBuffer = new short[i5 * i2];
+        this.pitchBuffer = new short[i5 * i2];
+    }
+
+    public final void queueInput(ShortBuffer shortBuffer) {
+        int remaining = shortBuffer.remaining();
+        int i = this.channelCount;
+        int i2 = remaining / i;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.inputBuffer, this.inputFrameCount, i2);
+        this.inputBuffer = ensureSpaceForAdditionalFrames;
+        shortBuffer.get(ensureSpaceForAdditionalFrames, this.inputFrameCount * this.channelCount, ((i * i2) * 2) / 2);
+        this.inputFrameCount += i2;
+        processStreamInput();
+    }
+
+    public final void getOutput(ShortBuffer shortBuffer) {
+        int min = Math.min(shortBuffer.remaining() / this.channelCount, this.outputFrameCount);
+        shortBuffer.put(this.outputBuffer, 0, this.channelCount * min);
+        int i = this.outputFrameCount - min;
+        this.outputFrameCount = i;
+        short[] sArr = this.outputBuffer;
+        int i2 = this.channelCount;
+        System.arraycopy(sArr, min * i2, sArr, 0, i * i2);
+    }
+
+    public final void queueEndOfStream() {
+        int i;
+        int i2 = this.inputFrameCount;
+        float f = this.speed;
+        float f2 = this.pitch;
+        int i3 = this.outputFrameCount + ((int) ((((i2 / (f / f2)) + this.pitchFrameCount) / (this.rate * f2)) + 0.5f));
+        this.inputBuffer = ensureSpaceForAdditionalFrames(this.inputBuffer, i2, (this.maxRequiredFrameCount * 2) + i2);
+        int i4 = 0;
+        while (true) {
+            i = this.maxRequiredFrameCount;
+            int i5 = this.channelCount;
+            if (i4 >= i * 2 * i5) {
+                break;
+            }
+            this.inputBuffer[(i5 * i2) + i4] = 0;
+            i4++;
+        }
+        this.inputFrameCount += i * 2;
+        processStreamInput();
+        if (this.outputFrameCount > i3) {
+            this.outputFrameCount = i3;
+        }
+        this.inputFrameCount = 0;
+        this.remainingInputToCopyFrameCount = 0;
+        this.pitchFrameCount = 0;
+    }
+
+    private short[] ensureSpaceForAdditionalFrames(short[] sArr, int i, int i2) {
+        int length = sArr.length;
+        int i3 = this.channelCount;
+        int i4 = length / i3;
+        return i + i2 <= i4 ? sArr : Arrays.copyOf(sArr, (((i4 * 3) / 2) + i2) * i3);
+    }
+
+    private void removeProcessedInputFrames(int i) {
+        int i2 = this.inputFrameCount - i;
+        short[] sArr = this.inputBuffer;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, sArr, 0, i3 * i2);
+        this.inputFrameCount = i2;
+    }
+
+    private void copyToOutput(short[] sArr, int i, int i2) {
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i2);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, ensureSpaceForAdditionalFrames, this.outputFrameCount * i3, i3 * i2);
+        this.outputFrameCount += i2;
+    }
+
+    private int copyInputToOutput(int i) {
+        int min = Math.min(this.maxRequiredFrameCount, this.remainingInputToCopyFrameCount);
+        copyToOutput(this.inputBuffer, i, min);
+        this.remainingInputToCopyFrameCount -= min;
+        return min;
+    }
+
+    private void downSampleInput(short[] sArr, int i, int i2) {
+        int i3 = this.maxRequiredFrameCount / i2;
+        int i4 = this.channelCount;
+        int i5 = i2 * i4;
+        int i6 = i * i4;
+        for (int i7 = 0; i7 < i3; i7++) {
+            int i8 = 0;
+            for (int i9 = 0; i9 < i5; i9++) {
+                i8 += sArr[(i7 * i5) + i6 + i9];
+            }
+            this.downSampleBuffer[i7] = (short) (i8 / i5);
+        }
+    }
+
+    private int findPitchPeriodInRange(short[] sArr, int i, int i2, int i3) {
+        int i4 = i * this.channelCount;
+        int i5 = 255;
+        int i6 = 1;
+        int i7 = 0;
+        int i8 = 0;
+        while (i2 <= i3) {
+            int i9 = 0;
+            for (int i10 = 0; i10 < i2; i10++) {
+                i9 += Math.abs(sArr[i4 + i10] - sArr[(i4 + i2) + i10]);
+            }
+            if (i9 * i7 < i6 * i2) {
+                i7 = i2;
+                i6 = i9;
+            }
+            if (i9 * i5 > i8 * i2) {
+                i5 = i2;
+                i8 = i9;
+            }
+            i2++;
+        }
+        this.minDiff = i6 / i7;
+        this.maxDiff = i8 / i5;
+        return i7;
+    }
+
+    private int findPitchPeriod(short[] sArr, int i) {
+        int i2;
+        int i3 = this.inputSampleRateHz;
+        int i4 = i3 > AMDF_FREQUENCY ? i3 / AMDF_FREQUENCY : 1;
+        if (this.channelCount == 1 && i4 == 1) {
+            i2 = findPitchPeriodInRange(sArr, i, this.minPeriod, this.maxPeriod);
+        } else {
+            downSampleInput(sArr, i, i4);
+            int findPitchPeriodInRange = findPitchPeriodInRange(this.downSampleBuffer, 0, this.minPeriod / i4, this.maxPeriod / i4);
+            if (i4 != 1) {
+                int i5 = findPitchPeriodInRange * i4;
+                int i6 = i4 * 4;
+                int i7 = i5 - i6;
+                int i8 = i5 + i6;
+                int i9 = this.minPeriod;
+                if (i7 < i9) {
+                    i7 = i9;
+                }
+                int i10 = this.maxPeriod;
+                if (i8 > i10) {
+                    i8 = i10;
+                }
+                if (this.channelCount == 1) {
+                    i2 = findPitchPeriodInRange(sArr, i, i7, i8);
+                } else {
+                    downSampleInput(sArr, i, 1);
+                    i2 = findPitchPeriodInRange(this.downSampleBuffer, 0, i7, i8);
+                }
+            } else {
+                i2 = findPitchPeriodInRange;
+            }
+        }
+        int i11 = previousPeriodBetter(this.minDiff, this.maxDiff) ? this.prevPeriod : i2;
+        this.prevMinDiff = this.minDiff;
+        this.prevPeriod = i2;
+        return i11;
+    }
+
+    private void moveNewSamplesToPitchBuffer(int i) {
+        int i2 = this.outputFrameCount - i;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.pitchBuffer, this.pitchFrameCount, i2);
+        this.pitchBuffer = ensureSpaceForAdditionalFrames;
+        short[] sArr = this.outputBuffer;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, ensureSpaceForAdditionalFrames, this.pitchFrameCount * i3, i3 * i2);
+        this.outputFrameCount = i;
+        this.pitchFrameCount += i2;
+    }
+
+    private void removePitchFrames(int i) {
+        if (i == 0) {
+            return;
+        }
+        short[] sArr = this.pitchBuffer;
+        int i2 = this.channelCount;
+        System.arraycopy(sArr, i * i2, sArr, 0, (this.pitchFrameCount - i) * i2);
+        this.pitchFrameCount -= i;
+    }
+
+    private short interpolate(short[] sArr, int i, int i2, int i3) {
+        short s = sArr[i];
+        short s2 = sArr[i + this.channelCount];
+        int i4 = this.newRatePosition * i2;
+        int i5 = this.oldRatePosition;
+        int i6 = i5 * i3;
+        int i7 = (i5 + 1) * i3;
+        int i8 = i7 - i4;
+        int i9 = i7 - i6;
+        return (short) (((s * i8) + ((i9 - i8) * s2)) / i9);
+    }
+
+    private void adjustRate(float f, int i) {
+        int i2;
+        int i3;
+        if (this.outputFrameCount == i) {
+            return;
+        }
+        int i4 = this.inputSampleRateHz;
+        int i5 = (int) (i4 / f);
+        while (true) {
+            if (i5 <= 16384 && i4 <= 16384) {
+                break;
+            }
+            i5 /= 2;
+            i4 /= 2;
+        }
+        moveNewSamplesToPitchBuffer(i);
+        int i6 = 0;
+        while (true) {
+            int i7 = this.pitchFrameCount;
+            if (i6 >= i7 - 1) {
+                removePitchFrames(i7 - 1);
+                return;
+            }
+            while (true) {
+                i2 = this.oldRatePosition;
+                int i8 = (i2 + 1) * i5;
+                i3 = this.newRatePosition;
+                if (i8 <= i3 * i4) {
+                    break;
+                }
+                this.outputBuffer = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, 1);
+                int i9 = 0;
+                while (true) {
+                    int i10 = this.channelCount;
+                    if (i9 < i10) {
+                        this.outputBuffer[(this.outputFrameCount * i10) + i9] = interpolate(this.pitchBuffer, (i10 * i6) + i9, i4, i5);
+                        i9++;
+                    }
+                }
+                this.newRatePosition++;
+                this.outputFrameCount++;
+            }
+            int i11 = i2 + 1;
+            this.oldRatePosition = i11;
+            if (i11 == i4) {
+                this.oldRatePosition = 0;
+                Assertions.checkState(i3 == i5);
+                this.newRatePosition = 0;
+            }
+            i6++;
+        }
+    }
+
+    private int skipPitchPeriod(short[] sArr, int i, float f, int i2) {
+        int i3;
+        if (f >= 2.0f) {
+            i3 = (int) (i2 / (f - 1.0f));
+        } else {
+            this.remainingInputToCopyFrameCount = (int) ((i2 * (2.0f - f)) / (f - 1.0f));
+            i3 = i2;
+        }
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i3);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        overlapAdd(i3, this.channelCount, ensureSpaceForAdditionalFrames, this.outputFrameCount, sArr, i, sArr, i + i2);
+        this.outputFrameCount += i3;
+        return i3;
+    }
+
+    private int insertPitchPeriod(short[] sArr, int i, float f, int i2) {
+        int i3;
+        if (f < 0.5f) {
+            i3 = (int) ((i2 * f) / (1.0f - f));
+        } else {
+            this.remainingInputToCopyFrameCount = (int) ((i2 * ((2.0f * f) - 1.0f)) / (1.0f - f));
+            i3 = i2;
+        }
+        int i4 = i2 + i3;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i4);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        int i5 = this.channelCount;
+        System.arraycopy(sArr, i * i5, ensureSpaceForAdditionalFrames, this.outputFrameCount * i5, i5 * i2);
+        overlapAdd(i3, this.channelCount, this.outputBuffer, this.outputFrameCount + i2, sArr, i + i2, sArr, i);
+        this.outputFrameCount += i4;
+        return i3;
+    }
+
+    private void changeSpeed(float f) {
+        int insertPitchPeriod;
+        int i = this.inputFrameCount;
+        if (i < this.maxRequiredFrameCount) {
+            return;
+        }
+        int i2 = 0;
+        do {
+            if (this.remainingInputToCopyFrameCount > 0) {
+                insertPitchPeriod = copyInputToOutput(i2);
+            } else {
+                int findPitchPeriod = findPitchPeriod(this.inputBuffer, i2);
+                if (f > 1.0d) {
+                    insertPitchPeriod = findPitchPeriod + skipPitchPeriod(this.inputBuffer, i2, f, findPitchPeriod);
+                } else {
+                    insertPitchPeriod = insertPitchPeriod(this.inputBuffer, i2, f, findPitchPeriod);
+                }
+            }
+            i2 += insertPitchPeriod;
+        } while (this.maxRequiredFrameCount + i2 <= i);
+        removeProcessedInputFrames(i2);
+    }
+
+    private void processStreamInput() {
+        int i = this.outputFrameCount;
+        float f = this.speed;
+        float f2 = this.pitch;
+        float f3 = f / f2;
+        float f4 = this.rate * f2;
+        double d = f3;
+        if (d > 1.00001d || d < 0.99999d) {
+            changeSpeed(f3);
+        } else {
+            copyToOutput(this.inputBuffer, 0, this.inputFrameCount);
+            this.inputFrameCount = 0;
+        }
+        if (f4 != 1.0f) {
+            adjustRate(f4, i);
+        }
+    }
+
+    private static void overlapAdd(int i, int i2, short[] sArr, int i3, short[] sArr2, int i4, short[] sArr3, int i5) {
+        for (int i6 = 0; i6 < i2; i6++) {
+            int i7 = (i3 * i2) + i6;
+            int i8 = (i5 * i2) + i6;
+            int i9 = (i4 * i2) + i6;
+            for (int i10 = 0; i10 < i; i10++) {
+                sArr[i7] = (short) (((sArr2[i9] * (i - i10)) + (sArr3[i8] * i10)) / i);
+                i7 += i2;
+                i9 += i2;
+                i8 += i2;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SonicAudioProcessor.java

@@ -0,0 +1,201 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+/* loaded from: classes4.dex */
+public final class SonicAudioProcessor implements AudioProcessor {
+    private static final float CLOSE_THRESHOLD = 0.01f;
+    public static final float MAXIMUM_PITCH = 8.0f;
+    public static final float MAXIMUM_SPEED = 8.0f;
+    public static final float MINIMUM_PITCH = 0.1f;
+    public static final float MINIMUM_SPEED = 0.1f;
+    private static final int MIN_BYTES_FOR_SPEEDUP_CALCULATION = 1024;
+    public static final int SAMPLE_RATE_NO_CHANGE = -1;
+    private ByteBuffer buffer;
+    private long inputBytes;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private long outputBytes;
+    private int pendingOutputSampleRateHz;
+    private ShortBuffer shortBuffer;
+
+    @Nullable
+    private Sonic sonic;
+    private float speed = 1.0f;
+    private float pitch = 1.0f;
+    private int channelCount = -1;
+    private int sampleRateHz = -1;
+    private int outputSampleRateHz = -1;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.outputSampleRateHz;
+    }
+
+    public final void setOutputSampleRateHz(int i) {
+        this.pendingOutputSampleRateHz = i;
+    }
+
+    public SonicAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.shortBuffer = byteBuffer.asShortBuffer();
+        this.outputBuffer = byteBuffer;
+        this.pendingOutputSampleRateHz = -1;
+    }
+
+    public final float setSpeed(float f) {
+        float constrainValue = Util.constrainValue(f, 0.1f, 8.0f);
+        if (this.speed != constrainValue) {
+            this.speed = constrainValue;
+            this.sonic = null;
+        }
+        flush();
+        return constrainValue;
+    }
+
+    public final float setPitch(float f) {
+        float constrainValue = Util.constrainValue(f, 0.1f, 8.0f);
+        if (this.pitch != constrainValue) {
+            this.pitch = constrainValue;
+            this.sonic = null;
+        }
+        flush();
+        return constrainValue;
+    }
+
+    public final long scaleDurationForSpeedup(long j) {
+        long j2 = this.outputBytes;
+        if (j2 < PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID) {
+            return (long) (this.speed * j);
+        }
+        int i = this.outputSampleRateHz;
+        int i2 = this.sampleRateHz;
+        if (i == i2) {
+            return Util.scaleLargeTimestamp(j, this.inputBytes, j2);
+        }
+        return Util.scaleLargeTimestamp(j, this.inputBytes * i, j2 * i2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        int i4 = this.pendingOutputSampleRateHz;
+        if (i4 == -1) {
+            i4 = i;
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.outputSampleRateHz == i4) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.outputSampleRateHz = i4;
+        this.sonic = null;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.sampleRateHz != -1 && (Math.abs(this.speed - 1.0f) >= CLOSE_THRESHOLD || Math.abs(this.pitch - 1.0f) >= CLOSE_THRESHOLD || this.outputSampleRateHz != this.sampleRateHz);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        Assertions.checkState(this.sonic != null);
+        if (byteBuffer.hasRemaining()) {
+            ShortBuffer asShortBuffer = byteBuffer.asShortBuffer();
+            int remaining = byteBuffer.remaining();
+            this.inputBytes += remaining;
+            this.sonic.queueInput(asShortBuffer);
+            byteBuffer.position(byteBuffer.position() + remaining);
+        }
+        int framesAvailable = this.sonic.getFramesAvailable() * this.channelCount * 2;
+        if (framesAvailable > 0) {
+            if (this.buffer.capacity() < framesAvailable) {
+                ByteBuffer order = ByteBuffer.allocateDirect(framesAvailable).order(ByteOrder.nativeOrder());
+                this.buffer = order;
+                this.shortBuffer = order.asShortBuffer();
+            } else {
+                this.buffer.clear();
+                this.shortBuffer.clear();
+            }
+            this.sonic.getOutput(this.shortBuffer);
+            this.outputBytes += framesAvailable;
+            this.buffer.limit(framesAvailable);
+            this.outputBuffer = this.buffer;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        Assertions.checkState(this.sonic != null);
+        this.sonic.queueEndOfStream();
+        this.inputEnded = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        Sonic sonic;
+        return this.inputEnded && ((sonic = this.sonic) == null || sonic.getFramesAvailable() == 0);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        if (isActive()) {
+            Sonic sonic = this.sonic;
+            if (sonic == null) {
+                this.sonic = new Sonic(this.sampleRateHz, this.channelCount, this.speed, this.pitch, this.outputSampleRateHz);
+            } else {
+                sonic.flush();
+            }
+        }
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputBytes = 0L;
+        this.outputBytes = 0L;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        this.speed = 1.0f;
+        this.pitch = 1.0f;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.outputSampleRateHz = -1;
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.shortBuffer = byteBuffer.asShortBuffer();
+        this.outputBuffer = byteBuffer;
+        this.pendingOutputSampleRateHz = -1;
+        this.sonic = null;
+        this.inputBytes = 0L;
+        this.outputBytes = 0L;
+        this.inputEnded = false;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/TrimmingAudioProcessor.java

@@ -0,0 +1,142 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+final class TrimmingAudioProcessor implements AudioProcessor {
+    private ByteBuffer buffer;
+    private int channelCount;
+    private byte[] endBuffer;
+    private int endBufferSize;
+    private boolean inputEnded;
+    private boolean isActive;
+    private ByteBuffer outputBuffer;
+    private int pendingTrimStartBytes;
+    private int sampleRateHz;
+    private int trimEndFrames;
+    private int trimStartFrames;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+        this.pendingTrimStartBytes = 0;
+        this.endBufferSize = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.isActive;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public final void setTrimFrameCount(int i, int i2) {
+        this.trimStartFrames = i;
+        this.trimEndFrames = i2;
+    }
+
+    public TrimmingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.endBuffer = new byte[0];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        this.channelCount = i2;
+        this.sampleRateHz = i;
+        int i4 = this.trimEndFrames;
+        this.endBuffer = new byte[i4 * i2 * 2];
+        this.endBufferSize = 0;
+        int i5 = this.trimStartFrames;
+        this.pendingTrimStartBytes = i2 * i5 * 2;
+        boolean z = this.isActive;
+        boolean z2 = (i5 == 0 && i4 == 0) ? false : true;
+        this.isActive = z2;
+        return z != z2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int i = limit - position;
+        int min = Math.min(i, this.pendingTrimStartBytes);
+        this.pendingTrimStartBytes -= min;
+        byteBuffer.position(position + min);
+        if (this.pendingTrimStartBytes > 0) {
+            return;
+        }
+        int i2 = i - min;
+        int length = (this.endBufferSize + i2) - this.endBuffer.length;
+        if (this.buffer.capacity() < length) {
+            this.buffer = ByteBuffer.allocateDirect(length).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        int constrainValue = Util.constrainValue(length, 0, this.endBufferSize);
+        this.buffer.put(this.endBuffer, 0, constrainValue);
+        int constrainValue2 = Util.constrainValue(length - constrainValue, 0, i2);
+        byteBuffer.limit(byteBuffer.position() + constrainValue2);
+        this.buffer.put(byteBuffer);
+        byteBuffer.limit(limit);
+        int i3 = i2 - constrainValue2;
+        int i4 = this.endBufferSize - constrainValue;
+        this.endBufferSize = i4;
+        byte[] bArr = this.endBuffer;
+        System.arraycopy(bArr, constrainValue, bArr, 0, i4);
+        byteBuffer.get(this.endBuffer, this.endBufferSize, i3);
+        this.endBufferSize += i3;
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.endBuffer = new byte[0];
+    }
+}