Add Discord community version (64-bit only)

- Added realracing3-community.apk (71.57 MB)
- Removed 32-bit support (armeabi-v7a)
- Only includes arm64-v8a libraries
- Decompiled source code included
- Added README-community.md with analysis

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/Buffer.java

@@ -0,0 +1,38 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public abstract class Buffer {
+    private int flags;
+
+    public final void addFlag(int i) {
+        this.flags = i | this.flags;
+    }
+
+    public void clear() {
+        this.flags = 0;
+    }
+
+    public final void clearFlag(int i) {
+        this.flags = (~i) & this.flags;
+    }
+
+    public final boolean getFlag(int i) {
+        return (this.flags & i) == i;
+    }
+
+    public final void setFlags(int i) {
+        this.flags = i;
+    }
+
+    public final boolean isDecodeOnly() {
+        return getFlag(Integer.MIN_VALUE);
+    }
+
+    public final boolean isEndOfStream() {
+        return getFlag(4);
+    }
+
+    public final boolean isKeyFrame() {
+        return getFlag(1);
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/CryptoInfo.java

@@ -0,0 +1,83 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import android.annotation.TargetApi;
+import android.media.MediaCodec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class CryptoInfo {
+    public int clearBlocks;
+    public int encryptedBlocks;
+    private final MediaCodec.CryptoInfo frameworkCryptoInfo;
+    public byte[] iv;
+    public byte[] key;
+    public int mode;
+    public int[] numBytesOfClearData;
+    public int[] numBytesOfEncryptedData;
+    public int numSubSamples;
+    private final PatternHolderV24 patternHolder;
+
+    @TargetApi(16)
+    public final MediaCodec.CryptoInfo getFrameworkCryptoInfoV16() {
+        return this.frameworkCryptoInfo;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public CryptoInfo() {
+        int i = Util.SDK_INT;
+        Object[] objArr = 0;
+        MediaCodec.CryptoInfo newFrameworkCryptoInfoV16 = i >= 16 ? newFrameworkCryptoInfoV16() : null;
+        this.frameworkCryptoInfo = newFrameworkCryptoInfoV16;
+        this.patternHolder = i >= 24 ? new PatternHolderV24(newFrameworkCryptoInfoV16) : null;
+    }
+
+    public final void set(int i, int[] iArr, int[] iArr2, byte[] bArr, byte[] bArr2, int i2, int i3, int i4) {
+        this.numSubSamples = i;
+        this.numBytesOfClearData = iArr;
+        this.numBytesOfEncryptedData = iArr2;
+        this.key = bArr;
+        this.iv = bArr2;
+        this.mode = i2;
+        this.encryptedBlocks = i3;
+        this.clearBlocks = i4;
+        if (Util.SDK_INT >= 16) {
+            updateFrameworkCryptoInfoV16();
+        }
+    }
+
+    @TargetApi(16)
+    private MediaCodec.CryptoInfo newFrameworkCryptoInfoV16() {
+        return new MediaCodec.CryptoInfo();
+    }
+
+    @TargetApi(16)
+    private void updateFrameworkCryptoInfoV16() {
+        MediaCodec.CryptoInfo cryptoInfo = this.frameworkCryptoInfo;
+        cryptoInfo.numSubSamples = this.numSubSamples;
+        cryptoInfo.numBytesOfClearData = this.numBytesOfClearData;
+        cryptoInfo.numBytesOfEncryptedData = this.numBytesOfEncryptedData;
+        cryptoInfo.key = this.key;
+        cryptoInfo.iv = this.iv;
+        cryptoInfo.mode = this.mode;
+        if (Util.SDK_INT >= 24) {
+            this.patternHolder.set(this.encryptedBlocks, this.clearBlocks);
+        }
+    }
+
+    @TargetApi(24)
+    public static final class PatternHolderV24 {
+        private final MediaCodec.CryptoInfo frameworkCryptoInfo;
+        private final MediaCodec.CryptoInfo.Pattern pattern;
+
+        private PatternHolderV24(MediaCodec.CryptoInfo cryptoInfo) {
+            this.frameworkCryptoInfo = cryptoInfo;
+            this.pattern = new MediaCodec.CryptoInfo.Pattern(0, 0);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void set(int i, int i2) {
+            this.pattern.set(i, i2);
+            this.frameworkCryptoInfo.setPattern(this.pattern);
+        }
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/Decoder.java

@@ -0,0 +1,18 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.lang.Exception;
+
+/* loaded from: classes4.dex */
+public interface Decoder<I, O, E extends Exception> {
+    I dequeueInputBuffer() throws Exception;
+
+    O dequeueOutputBuffer() throws Exception;
+
+    void flush();
+
+    String getName();
+
+    void queueInputBuffer(I i) throws Exception;
+
+    void release();
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/DecoderCounters.java

@@ -0,0 +1,29 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public final class DecoderCounters {
+    public int decoderInitCount;
+    public int decoderReleaseCount;
+    public int droppedBufferCount;
+    public int droppedToKeyframeCount;
+    public int inputBufferCount;
+    public int maxConsecutiveDroppedBufferCount;
+    public int renderedOutputBufferCount;
+    public int skippedInputBufferCount;
+    public int skippedOutputBufferCount;
+
+    public final synchronized void ensureUpdated() {
+    }
+
+    public final void merge(DecoderCounters decoderCounters) {
+        this.decoderInitCount += decoderCounters.decoderInitCount;
+        this.decoderReleaseCount += decoderCounters.decoderReleaseCount;
+        this.inputBufferCount += decoderCounters.inputBufferCount;
+        this.skippedInputBufferCount += decoderCounters.skippedInputBufferCount;
+        this.renderedOutputBufferCount += decoderCounters.renderedOutputBufferCount;
+        this.skippedOutputBufferCount += decoderCounters.skippedOutputBufferCount;
+        this.droppedBufferCount += decoderCounters.droppedBufferCount;
+        this.maxConsecutiveDroppedBufferCount = Math.max(this.maxConsecutiveDroppedBufferCount, decoderCounters.maxConsecutiveDroppedBufferCount);
+        this.droppedToKeyframeCount += decoderCounters.droppedToKeyframeCount;
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/DecoderInputBuffer.java

@@ -0,0 +1,82 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public class DecoderInputBuffer extends Buffer {
+    public static final int BUFFER_REPLACEMENT_MODE_DIRECT = 2;
+    public static final int BUFFER_REPLACEMENT_MODE_DISABLED = 0;
+    public static final int BUFFER_REPLACEMENT_MODE_NORMAL = 1;
+    private final int bufferReplacementMode;
+    public final CryptoInfo cryptoInfo = new CryptoInfo();
+    public ByteBuffer data;
+    public long timeUs;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface BufferReplacementMode {
+    }
+
+    public final boolean isFlagsOnly() {
+        return this.data == null && this.bufferReplacementMode == 0;
+    }
+
+    public static DecoderInputBuffer newFlagsOnlyInstance() {
+        return new DecoderInputBuffer(0);
+    }
+
+    public DecoderInputBuffer(int i) {
+        this.bufferReplacementMode = i;
+    }
+
+    public void ensureSpaceForWrite(int i) throws IllegalStateException {
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer == null) {
+            this.data = createReplacementByteBuffer(i);
+            return;
+        }
+        int capacity = byteBuffer.capacity();
+        int position = this.data.position();
+        int i2 = i + position;
+        if (capacity >= i2) {
+            return;
+        }
+        ByteBuffer createReplacementByteBuffer = createReplacementByteBuffer(i2);
+        if (position > 0) {
+            this.data.position(0);
+            this.data.limit(position);
+            createReplacementByteBuffer.put(this.data);
+        }
+        this.data = createReplacementByteBuffer;
+    }
+
+    public final boolean isEncrypted() {
+        return getFlag(1073741824);
+    }
+
+    public final void flip() {
+        this.data.flip();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Buffer
+    public void clear() {
+        super.clear();
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer != null) {
+            byteBuffer.clear();
+        }
+    }
+
+    private ByteBuffer createReplacementByteBuffer(int i) {
+        int i2 = this.bufferReplacementMode;
+        if (i2 == 1) {
+            return ByteBuffer.allocate(i);
+        }
+        if (i2 == 2) {
+            return ByteBuffer.allocateDirect(i);
+        }
+        ByteBuffer byteBuffer = this.data;
+        throw new IllegalStateException("Buffer too small (" + (byteBuffer == null ? 0 : byteBuffer.capacity()) + " < " + i + ")");
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/OutputBuffer.java

@@ -0,0 +1,9 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public abstract class OutputBuffer extends Buffer {
+    public int skippedOutputBufferCount;
+    public long timeUs;
+
+    public abstract void release();
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/SimpleDecoder.java

@@ -0,0 +1,249 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.lang.Exception;
+import java.util.ArrayDeque;
+
+/* loaded from: classes4.dex */
+public abstract class SimpleDecoder<I extends DecoderInputBuffer, O extends OutputBuffer, E extends Exception> implements Decoder<I, O, E> {
+    private int availableInputBufferCount;
+    private final I[] availableInputBuffers;
+    private int availableOutputBufferCount;
+    private final O[] availableOutputBuffers;
+    private final Thread decodeThread;
+    private I dequeuedInputBuffer;
+    private E exception;
+    private boolean flushed;
+    private final Object lock = new Object();
+    private final ArrayDeque<I> queuedInputBuffers = new ArrayDeque<>();
+    private final ArrayDeque<O> queuedOutputBuffers = new ArrayDeque<>();
+    private boolean released;
+    private int skippedOutputBufferCount;
+
+    public abstract I createInputBuffer();
+
+    public abstract O createOutputBuffer();
+
+    public abstract E createUnexpectedDecodeException(Throwable th);
+
+    public abstract E decode(I i, O o, boolean z);
+
+    public SimpleDecoder(I[] iArr, O[] oArr) {
+        this.availableInputBuffers = iArr;
+        this.availableInputBufferCount = iArr.length;
+        for (int i = 0; i < this.availableInputBufferCount; i++) {
+            this.availableInputBuffers[i] = createInputBuffer();
+        }
+        this.availableOutputBuffers = oArr;
+        this.availableOutputBufferCount = oArr.length;
+        for (int i2 = 0; i2 < this.availableOutputBufferCount; i2++) {
+            this.availableOutputBuffers[i2] = createOutputBuffer();
+        }
+        Thread thread = new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder.1
+            @Override // java.lang.Thread, java.lang.Runnable
+            public void run() {
+                SimpleDecoder.this.run();
+            }
+        };
+        this.decodeThread = thread;
+        thread.start();
+    }
+
+    public final void setInitialInputBufferSize(int i) {
+        Assertions.checkState(this.availableInputBufferCount == this.availableInputBuffers.length);
+        for (I i2 : this.availableInputBuffers) {
+            i2.ensureSpaceForWrite(i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final I dequeueInputBuffer() throws Exception {
+        I i;
+        synchronized (this.lock) {
+            maybeThrowException();
+            Assertions.checkState(this.dequeuedInputBuffer == null);
+            int i2 = this.availableInputBufferCount;
+            if (i2 == 0) {
+                i = null;
+            } else {
+                I[] iArr = this.availableInputBuffers;
+                int i3 = i2 - 1;
+                this.availableInputBufferCount = i3;
+                i = iArr[i3];
+            }
+            this.dequeuedInputBuffer = i;
+        }
+        return i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void queueInputBuffer(I i) throws Exception {
+        synchronized (this.lock) {
+            maybeThrowException();
+            Assertions.checkArgument(i == this.dequeuedInputBuffer);
+            this.queuedInputBuffers.addLast(i);
+            maybeNotifyDecodeLoop();
+            this.dequeuedInputBuffer = null;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final O dequeueOutputBuffer() throws Exception {
+        synchronized (this.lock) {
+            try {
+                maybeThrowException();
+                if (this.queuedOutputBuffers.isEmpty()) {
+                    return null;
+                }
+                return this.queuedOutputBuffers.removeFirst();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void releaseOutputBuffer(O o) {
+        synchronized (this.lock) {
+            releaseOutputBufferInternal(o);
+            maybeNotifyDecodeLoop();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void flush() {
+        synchronized (this.lock) {
+            try {
+                this.flushed = true;
+                this.skippedOutputBufferCount = 0;
+                I i = this.dequeuedInputBuffer;
+                if (i != null) {
+                    releaseInputBufferInternal(i);
+                    this.dequeuedInputBuffer = null;
+                }
+                while (!this.queuedInputBuffers.isEmpty()) {
+                    releaseInputBufferInternal(this.queuedInputBuffers.removeFirst());
+                }
+                while (!this.queuedOutputBuffers.isEmpty()) {
+                    releaseOutputBufferInternal(this.queuedOutputBuffers.removeFirst());
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public void release() {
+        synchronized (this.lock) {
+            this.released = true;
+            this.lock.notify();
+        }
+        try {
+            this.decodeThread.join();
+        } catch (InterruptedException unused) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private void maybeThrowException() throws Exception {
+        E e = this.exception;
+        if (e != null) {
+            throw e;
+        }
+    }
+
+    private void maybeNotifyDecodeLoop() {
+        if (canDecodeBuffer()) {
+            this.lock.notify();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void run() {
+        do {
+            try {
+            } catch (InterruptedException e) {
+                throw new IllegalStateException(e);
+            }
+        } while (decode());
+    }
+
+    private boolean decode() throws InterruptedException {
+        synchronized (this.lock) {
+            while (!this.released && !canDecodeBuffer()) {
+                try {
+                    this.lock.wait();
+                } finally {
+                }
+            }
+            if (this.released) {
+                return false;
+            }
+            I removeFirst = this.queuedInputBuffers.removeFirst();
+            O[] oArr = this.availableOutputBuffers;
+            int i = this.availableOutputBufferCount - 1;
+            this.availableOutputBufferCount = i;
+            O o = oArr[i];
+            boolean z = this.flushed;
+            this.flushed = false;
+            if (removeFirst.isEndOfStream()) {
+                o.addFlag(4);
+            } else {
+                if (removeFirst.isDecodeOnly()) {
+                    o.addFlag(Integer.MIN_VALUE);
+                }
+                try {
+                    this.exception = decode(removeFirst, o, z);
+                } catch (OutOfMemoryError e) {
+                    this.exception = createUnexpectedDecodeException(e);
+                } catch (RuntimeException e2) {
+                    this.exception = createUnexpectedDecodeException(e2);
+                }
+                if (this.exception != null) {
+                    synchronized (this.lock) {
+                    }
+                    return false;
+                }
+            }
+            synchronized (this.lock) {
+                try {
+                    if (this.flushed) {
+                        releaseOutputBufferInternal(o);
+                    } else if (o.isDecodeOnly()) {
+                        this.skippedOutputBufferCount++;
+                        releaseOutputBufferInternal(o);
+                    } else {
+                        o.skippedOutputBufferCount = this.skippedOutputBufferCount;
+                        this.skippedOutputBufferCount = 0;
+                        this.queuedOutputBuffers.addLast(o);
+                    }
+                    releaseInputBufferInternal(removeFirst);
+                } finally {
+                }
+            }
+            return true;
+        }
+    }
+
+    private boolean canDecodeBuffer() {
+        return !this.queuedInputBuffers.isEmpty() && this.availableOutputBufferCount > 0;
+    }
+
+    private void releaseInputBufferInternal(I i) {
+        i.clear();
+        I[] iArr = this.availableInputBuffers;
+        int i2 = this.availableInputBufferCount;
+        this.availableInputBufferCount = i2 + 1;
+        iArr[i2] = i;
+    }
+
+    private void releaseOutputBufferInternal(O o) {
+        o.clear();
+        O[] oArr = this.availableOutputBuffers;
+        int i = this.availableOutputBufferCount;
+        this.availableOutputBufferCount = i + 1;
+        oArr[i] = o;
+    }
+}

decompiled-community/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/SimpleOutputBuffer.java

@@ -0,0 +1,39 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public class SimpleOutputBuffer extends OutputBuffer {
+    public ByteBuffer data;
+    private final SimpleDecoder<?, SimpleOutputBuffer, ?> owner;
+
+    public SimpleOutputBuffer(SimpleDecoder<?, SimpleOutputBuffer, ?> simpleDecoder) {
+        this.owner = simpleDecoder;
+    }
+
+    public ByteBuffer init(long j, int i) {
+        this.timeUs = j;
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer == null || byteBuffer.capacity() < i) {
+            this.data = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        }
+        this.data.position(0);
+        this.data.limit(i);
+        return this.data;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Buffer
+    public void clear() {
+        super.clear();
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer != null) {
+            byteBuffer.clear();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer
+    public void release() {
+        this.owner.releaseOutputBuffer(this);
+    }
+}