sneedmca/Rabbit-R1
1
0
Fork 0
mirror of https://github.com/Pinball3D/Rabbit-R1.git synced 2024-12-30 11:02:31 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions
Rabbit-R1/android (non root)/java/sources/androidx/media3/exoplayer/video/MediaCodecVideoRenderer.java

1607 lines
75 KiB
Java
Raw Normal View History

Source Files
2024-05-21 16:08:36 -05:00
package androidx.media3.exoplayer.video;
import android.content.Context;
import android.graphics.Point;
import android.hardware.display.DisplayManager;
import android.media.MediaCrypto;
import android.media.MediaFormat;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Pair;
import android.view.Display;
import android.view.Surface;
import androidx.media3.common.ColorInfo;
import androidx.media3.common.DebugViewProvider;
import androidx.media3.common.Effect;
import androidx.media3.common.Format;
import androidx.media3.common.FrameInfo;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.SurfaceInfo;
import androidx.media3.common.VideoFrameProcessingException;
import androidx.media3.common.VideoFrameProcessor;
import androidx.media3.common.VideoSize;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Log;
import androidx.media3.common.util.MediaFormatUtil;
import androidx.media3.common.util.Size;
import androidx.media3.common.util.TraceUtil;
import androidx.media3.common.util.Util;
import androidx.media3.decoder.DecoderInputBuffer;
import androidx.media3.exoplayer.DecoderReuseEvaluation;
import androidx.media3.exoplayer.ExoPlaybackException;
import androidx.media3.exoplayer.FormatHolder;
import androidx.media3.exoplayer.RendererCapabilities;
import androidx.media3.exoplayer.mediacodec.MediaCodecAdapter;
import androidx.media3.exoplayer.mediacodec.MediaCodecDecoderException;
import androidx.media3.exoplayer.mediacodec.MediaCodecInfo;
import androidx.media3.exoplayer.mediacodec.MediaCodecRenderer;
import androidx.media3.exoplayer.mediacodec.MediaCodecSelector;
import androidx.media3.exoplayer.mediacodec.MediaCodecUtil;
import androidx.media3.exoplayer.video.VideoRendererEventListener;
import androidx.work.WorkRequest;
import com.google.common.collect.ImmutableList;
import io.flutter.plugin.platform.PlatformPlugin;
import io.sentry.protocol.OperatingSystem;
import io.sentry.protocol.SentryThread;
import io.sentry.protocol.ViewHierarchyNode;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executor;
import org.checkerframework.checker.nullness.qual.EnsuresNonNull;
/* loaded from: classes2.dex */
public class MediaCodecVideoRenderer extends MediaCodecRenderer {
private static final int HEVC_MAX_INPUT_SIZE_THRESHOLD = 2097152;
private static final float INITIAL_FORMAT_MAX_INPUT_SIZE_SCALE_FACTOR = 1.5f;
private static final String KEY_CROP_BOTTOM = "crop-bottom";
private static final String KEY_CROP_LEFT = "crop-left";
private static final String KEY_CROP_RIGHT = "crop-right";
private static final String KEY_CROP_TOP = "crop-top";
private static final int[] STANDARD_LONG_EDGE_VIDEO_PX = {1920, 1600, 1440, PlatformPlugin.DEFAULT_SYSTEM_UI, 960, 854, 640, 540, 480};
private static final String TAG = "MediaCodecVideoRenderer";
private static final long TUNNELING_EOS_PRESENTATION_TIME_US = Long.MAX_VALUE;
private static boolean deviceNeedsSetOutputSurfaceWorkaround;
private static boolean evaluatedDeviceNeedsSetOutputSurfaceWorkaround;
private final long allowedJoiningTimeMs;
private int buffersInCodecCount;
private boolean codecHandlesHdr10PlusOutOfBandMetadata;
private CodecMaxValues codecMaxValues;
private boolean codecNeedsSetOutputSurfaceWorkaround;
private int consecutiveDroppedFrameCount;
private final Context context;
private VideoSize decodedVideoSize;
private final boolean deviceNeedsNoPostProcessWorkaround;
private Surface displaySurface;
private long droppedFrameAccumulationStartTimeMs;
private int droppedFrames;
private final VideoRendererEventListener.EventDispatcher eventDispatcher;
private VideoFrameMetadataListener frameMetadataListener;
private final VideoFrameReleaseHelper frameReleaseHelper;
private boolean haveReportedFirstFrameRenderedForCurrentSurface;
private long initialPositionUs;
private long joiningDeadlineMs;
private long lastBufferPresentationTimeUs;
private long lastFrameReleaseTimeNs;
private long lastRenderRealtimeUs;
private final int maxDroppedFramesToNotify;
private boolean mayRenderFirstFrameAfterEnableIfNotStarted;
private PlaceholderSurface placeholderSurface;
private boolean renderedFirstFrameAfterEnable;
private boolean renderedFirstFrameAfterReset;
private VideoSize reportedVideoSize;
private int scalingMode;
private long totalVideoFrameProcessingOffsetUs;
private boolean tunneling;
private int tunnelingAudioSessionId;
OnFrameRenderedListenerV23 tunnelingOnFrameRenderedListener;
private int videoFrameProcessingOffsetCount;
private final VideoFrameProcessorManager videoFrameProcessorManager;
private void clearReportedVideoSize() {
this.reportedVideoSize = null;
}
private static boolean isBufferLate(long j) {
return j < -30000;
}
private static boolean isBufferVeryLate(long j) {
return j < -500000;
}
@Override // androidx.media3.exoplayer.Renderer, androidx.media3.exoplayer.RendererCapabilities
public String getName() {
return TAG;
}
protected Surface getSurface() {
return this.displaySurface;
}
static /* synthetic */ boolean access$000() {
return codecAppliesRotation();
}
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector) {
this(context, mediaCodecSelector, 0L);
}
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector, long j) {
this(context, mediaCodecSelector, j, null, null, 0);
}
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector, long j, Handler handler, VideoRendererEventListener videoRendererEventListener, int i) {
this(context, MediaCodecAdapter.Factory.DEFAULT, mediaCodecSelector, j, false, handler, videoRendererEventListener, i, 30.0f);
}
public MediaCodecVideoRenderer(Context context, MediaCodecSelector mediaCodecSelector, long j, boolean z, Handler handler, VideoRendererEventListener videoRendererEventListener, int i) {
this(context, MediaCodecAdapter.Factory.DEFAULT, mediaCodecSelector, j, z, handler, videoRendererEventListener, i, 30.0f);
}
public MediaCodecVideoRenderer(Context context, MediaCodecAdapter.Factory factory, MediaCodecSelector mediaCodecSelector, long j, boolean z, Handler handler, VideoRendererEventListener videoRendererEventListener, int i) {
this(context, factory, mediaCodecSelector, j, z, handler, videoRendererEventListener, i, 30.0f);
}
public MediaCodecVideoRenderer(Context context, MediaCodecAdapter.Factory factory, MediaCodecSelector mediaCodecSelector, long j, boolean z, Handler handler, VideoRendererEventListener videoRendererEventListener, int i, float f) {
super(2, factory, mediaCodecSelector, z, f);
this.allowedJoiningTimeMs = j;
this.maxDroppedFramesToNotify = i;
Context applicationContext = context.getApplicationContext();
this.context = applicationContext;
VideoFrameReleaseHelper videoFrameReleaseHelper = new VideoFrameReleaseHelper(applicationContext);
this.frameReleaseHelper = videoFrameReleaseHelper;
this.eventDispatcher = new VideoRendererEventListener.EventDispatcher(handler, videoRendererEventListener);
this.videoFrameProcessorManager = new VideoFrameProcessorManager(videoFrameReleaseHelper, this);
this.deviceNeedsNoPostProcessWorkaround = deviceNeedsNoPostProcessWorkaround();
this.joiningDeadlineMs = -9223372036854775807L;
this.scalingMode = 1;
this.decodedVideoSize = VideoSize.UNKNOWN;
this.tunnelingAudioSessionId = 0;
clearReportedVideoSize();
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected int supportsFormat(MediaCodecSelector mediaCodecSelector, Format format) throws MediaCodecUtil.DecoderQueryException {
boolean z;
int i = 0;
if (!MimeTypes.isVideo(format.sampleMimeType)) {
return RendererCapabilities.create(0);
}
boolean z2 = format.drmInitData != null;
List<MediaCodecInfo> decoderInfos = getDecoderInfos(this.context, mediaCodecSelector, format, z2, false);
if (z2 && decoderInfos.isEmpty()) {
decoderInfos = getDecoderInfos(this.context, mediaCodecSelector, format, false, false);
}
if (decoderInfos.isEmpty()) {
return RendererCapabilities.create(1);
}
if (!supportsFormatDrm(format)) {
return RendererCapabilities.create(2);
}
MediaCodecInfo mediaCodecInfo = decoderInfos.get(0);
boolean isFormatSupported = mediaCodecInfo.isFormatSupported(format);
if (!isFormatSupported) {
for (int i2 = 1; i2 < decoderInfos.size(); i2++) {
MediaCodecInfo mediaCodecInfo2 = decoderInfos.get(i2);
if (mediaCodecInfo2.isFormatSupported(format)) {
z = false;
isFormatSupported = true;
mediaCodecInfo = mediaCodecInfo2;
break;
}
}
}
z = true;
int i3 = isFormatSupported ? 4 : 3;
int i4 = mediaCodecInfo.isSeamlessAdaptationSupported(format) ? 16 : 8;
int i5 = mediaCodecInfo.hardwareAccelerated ? 64 : 0;
int i6 = z ? 128 : 0;
if (Util.SDK_INT >= 26 && "video/dolby-vision".equals(format.sampleMimeType) && !Api26.doesDisplaySupportDolbyVision(this.context)) {
i6 = 256;
}
if (isFormatSupported) {
List<MediaCodecInfo> decoderInfos2 = getDecoderInfos(this.context, mediaCodecSelector, format, z2, true);
if (!decoderInfos2.isEmpty()) {
MediaCodecInfo mediaCodecInfo3 = MediaCodecUtil.getDecoderInfosSortedByFormatSupport(decoderInfos2, format).get(0);
if (mediaCodecInfo3.isFormatSupported(format) && mediaCodecInfo3.isSeamlessAdaptationSupported(format)) {
i = 32;
}
}
}
return RendererCapabilities.create(i3, i4, i, i5, i6);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected List<MediaCodecInfo> getDecoderInfos(MediaCodecSelector mediaCodecSelector, Format format, boolean z) throws MediaCodecUtil.DecoderQueryException {
return MediaCodecUtil.getDecoderInfosSortedByFormatSupport(getDecoderInfos(this.context, mediaCodecSelector, format, z, this.tunneling), format);
}
private static List<MediaCodecInfo> getDecoderInfos(Context context, MediaCodecSelector mediaCodecSelector, Format format, boolean z, boolean z2) throws MediaCodecUtil.DecoderQueryException {
if (format.sampleMimeType == null) {
return ImmutableList.of();
}
if (Util.SDK_INT >= 26 && "video/dolby-vision".equals(format.sampleMimeType) && !Api26.doesDisplaySupportDolbyVision(context)) {
List<MediaCodecInfo> alternativeDecoderInfos = MediaCodecUtil.getAlternativeDecoderInfos(mediaCodecSelector, format, z, z2);
if (!alternativeDecoderInfos.isEmpty()) {
return alternativeDecoderInfos;
}
}
return MediaCodecUtil.getDecoderInfosSoftMatch(mediaCodecSelector, format, z, z2);
}
/* JADX INFO: Access modifiers changed from: private */
/* loaded from: classes2.dex */
public static final class Api26 {
private Api26() {
}
public static boolean doesDisplaySupportDolbyVision(Context context) {
DisplayManager displayManager = (DisplayManager) context.getSystemService("display");
Display display = displayManager != null ? displayManager.getDisplay(0) : null;
if (display == null || !display.isHdr()) {
return false;
}
for (int i : display.getHdrCapabilities().getSupportedHdrTypes()) {
if (i == 1) {
return true;
}
}
return false;
}
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onEnabled(boolean z, boolean z2) throws ExoPlaybackException {
super.onEnabled(z, z2);
boolean z3 = getConfiguration().tunneling;
Assertions.checkState((z3 && this.tunnelingAudioSessionId == 0) ? false : true);
if (this.tunneling != z3) {
this.tunneling = z3;
releaseCodec();
}
this.eventDispatcher.enabled(this.decoderCounters);
this.mayRenderFirstFrameAfterEnableIfNotStarted = z2;
this.renderedFirstFrameAfterEnable = false;
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
super.onPositionReset(j, z);
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.flush();
}
clearRenderedFirstFrame();
this.frameReleaseHelper.onPositionReset();
this.lastBufferPresentationTimeUs = -9223372036854775807L;
this.initialPositionUs = -9223372036854775807L;
this.consecutiveDroppedFrameCount = 0;
if (z) {
setJoiningDeadlineMs();
} else {
this.joiningDeadlineMs = -9223372036854775807L;
}
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.Renderer
public boolean isEnded() {
boolean isEnded = super.isEnded();
return this.videoFrameProcessorManager.isEnabled() ? isEnded & this.videoFrameProcessorManager.releasedLastFrame() : isEnded;
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.Renderer
public boolean isReady() {
PlaceholderSurface placeholderSurface;
if (super.isReady() && ((!this.videoFrameProcessorManager.isEnabled() || this.videoFrameProcessorManager.isReady()) && (this.renderedFirstFrameAfterReset || (((placeholderSurface = this.placeholderSurface) != null && this.displaySurface == placeholderSurface) || getCodec() == null || this.tunneling)))) {
this.joiningDeadlineMs = -9223372036854775807L;
return true;
}
if (this.joiningDeadlineMs == -9223372036854775807L) {
return false;
}
if (SystemClock.elapsedRealtime() < this.joiningDeadlineMs) {
return true;
}
this.joiningDeadlineMs = -9223372036854775807L;
return false;
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onStarted() {
super.onStarted();
this.droppedFrames = 0;
this.droppedFrameAccumulationStartTimeMs = SystemClock.elapsedRealtime();
this.lastRenderRealtimeUs = SystemClock.elapsedRealtime() * 1000;
this.totalVideoFrameProcessingOffsetUs = 0L;
this.videoFrameProcessingOffsetCount = 0;
this.frameReleaseHelper.onStarted();
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onStopped() {
this.joiningDeadlineMs = -9223372036854775807L;
maybeNotifyDroppedFrames();
maybeNotifyVideoFrameProcessingOffset();
this.frameReleaseHelper.onStopped();
super.onStopped();
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onDisabled() {
clearReportedVideoSize();
clearRenderedFirstFrame();
this.haveReportedFirstFrameRenderedForCurrentSurface = false;
this.tunnelingOnFrameRenderedListener = null;
try {
super.onDisabled();
} finally {
this.eventDispatcher.disabled(this.decoderCounters);
this.eventDispatcher.videoSizeChanged(VideoSize.UNKNOWN);
}
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.BaseRenderer
public void onReset() {
try {
super.onReset();
} finally {
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.reset();
}
if (this.placeholderSurface != null) {
releasePlaceholderSurface();
}
}
}
@Override // androidx.media3.exoplayer.BaseRenderer, androidx.media3.exoplayer.PlayerMessage.Target
public void handleMessage(int i, Object obj) throws ExoPlaybackException {
Surface surface;
if (i == 1) {
setOutput(obj);
return;
}
if (i == 7) {
this.frameMetadataListener = (VideoFrameMetadataListener) obj;
return;
}
if (i == 10) {
int intValue = ((Integer) obj).intValue();
if (this.tunnelingAudioSessionId != intValue) {
this.tunnelingAudioSessionId = intValue;
if (this.tunneling) {
releaseCodec();
return;
}
return;
}
return;
}
if (i == 4) {
this.scalingMode = ((Integer) obj).intValue();
MediaCodecAdapter codec = getCodec();
if (codec != null) {
codec.setVideoScalingMode(this.scalingMode);
return;
}
return;
}
if (i == 5) {
this.frameReleaseHelper.setChangeFrameRateStrategy(((Integer) obj).intValue());
return;
}
if (i == 13) {
this.videoFrameProcessorManager.setVideoEffects((List) Assertions.checkNotNull(obj));
return;
}
if (i == 14) {
Size size = (Size) Assertions.checkNotNull(obj);
if (size.getWidth() == 0 || size.getHeight() == 0 || (surface = this.displaySurface) == null) {
return;
}
this.videoFrameProcessorManager.setOutputSurfaceInfo(surface, size);
return;
}
super.handleMessage(i, obj);
}
/* JADX WARN: Multi-variable type inference failed */
/* JADX WARN: Type inference failed for: r4v0, types: [androidx.media3.exoplayer.video.MediaCodecVideoRenderer] */
/* JADX WARN: Type inference failed for: r5v9, types: [android.view.Surface] */
private void setOutput(Object obj) throws ExoPlaybackException {
PlaceholderSurface placeholderSurface = obj instanceof Surface ? (Surface) obj : null;
if (placeholderSurface == null) {
PlaceholderSurface placeholderSurface2 = this.placeholderSurface;
if (placeholderSurface2 != null) {
placeholderSurface = placeholderSurface2;
} else {
MediaCodecInfo codecInfo = getCodecInfo();
if (codecInfo != null && shouldUsePlaceholderSurface(codecInfo)) {
placeholderSurface = PlaceholderSurface.newInstanceV17(this.context, codecInfo.secure);
this.placeholderSurface = placeholderSurface;
}
}
}
if (this.displaySurface == placeholderSurface) {
if (placeholderSurface == null || placeholderSurface == this.placeholderSurface) {
return;
}
maybeRenotifyVideoSizeChanged();
maybeRenotifyRenderedFirstFrame();
return;
}
this.displaySurface = placeholderSurface;
this.frameReleaseHelper.onSurfaceChanged(placeholderSurface);
this.haveReportedFirstFrameRenderedForCurrentSurface = false;
int state = getState();
MediaCodecAdapter codec = getCodec();
if (codec != null && !this.videoFrameProcessorManager.isEnabled()) {
if (Util.SDK_INT >= 23 && placeholderSurface != null && !this.codecNeedsSetOutputSurfaceWorkaround) {
setOutputSurfaceV23(codec, placeholderSurface);
} else {
releaseCodec();
maybeInitCodecOrBypass();
}
}
if (placeholderSurface != null && placeholderSurface != this.placeholderSurface) {
maybeRenotifyVideoSizeChanged();
clearRenderedFirstFrame();
if (state == 2) {
setJoiningDeadlineMs();
}
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.setOutputSurfaceInfo(placeholderSurface, Size.UNKNOWN);
return;
}
return;
}
clearReportedVideoSize();
clearRenderedFirstFrame();
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.clearOutputSurfaceInfo();
}
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected boolean shouldInitCodec(MediaCodecInfo mediaCodecInfo) {
return this.displaySurface != null || shouldUsePlaceholderSurface(mediaCodecInfo);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected boolean getCodecNeedsEosPropagation() {
return this.tunneling && Util.SDK_INT < 23;
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected MediaCodecAdapter.Configuration getMediaCodecConfiguration(MediaCodecInfo mediaCodecInfo, Format format, MediaCrypto mediaCrypto, float f) {
PlaceholderSurface placeholderSurface = this.placeholderSurface;
if (placeholderSurface != null && placeholderSurface.secure != mediaCodecInfo.secure) {
releasePlaceholderSurface();
}
String str = mediaCodecInfo.codecMimeType;
CodecMaxValues codecMaxValues = getCodecMaxValues(mediaCodecInfo, format, getStreamFormats());
this.codecMaxValues = codecMaxValues;
MediaFormat mediaFormat = getMediaFormat(format, str, codecMaxValues, f, this.deviceNeedsNoPostProcessWorkaround, this.tunneling ? this.tunnelingAudioSessionId : 0);
if (this.displaySurface == null) {
if (!shouldUsePlaceholderSurface(mediaCodecInfo)) {
throw new IllegalStateException();
}
if (this.placeholderSurface == null) {
this.placeholderSurface = PlaceholderSurface.newInstanceV17(this.context, mediaCodecInfo.secure);
}
this.displaySurface = this.placeholderSurface;
}
if (this.videoFrameProcessorManager.isEnabled()) {
mediaFormat = this.videoFrameProcessorManager.amendMediaFormatKeys(mediaFormat);
}
return MediaCodecAdapter.Configuration.createForVideoDecoding(mediaCodecInfo, mediaFormat, format, this.videoFrameProcessorManager.isEnabled() ? this.videoFrameProcessorManager.getInputSurface() : this.displaySurface, mediaCrypto);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected DecoderReuseEvaluation canReuseCodec(MediaCodecInfo mediaCodecInfo, Format format, Format format2) {
DecoderReuseEvaluation canReuseCodec = mediaCodecInfo.canReuseCodec(format, format2);
int i = canReuseCodec.discardReasons;
if (format2.width > this.codecMaxValues.width || format2.height > this.codecMaxValues.height) {
i |= 256;
}
if (getMaxInputSize(mediaCodecInfo, format2) > this.codecMaxValues.inputSize) {
i |= 64;
}
int i2 = i;
return new DecoderReuseEvaluation(mediaCodecInfo.name, format, format2, i2 != 0 ? 0 : canReuseCodec.result, i2);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.Renderer
public void render(long j, long j2) throws ExoPlaybackException {
super.render(j, j2);
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.releaseProcessedFrames(j, j2);
}
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
public void resetCodecStateForFlush() {
super.resetCodecStateForFlush();
this.buffersInCodecCount = 0;
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer, androidx.media3.exoplayer.Renderer
public void setPlaybackSpeed(float f, float f2) throws ExoPlaybackException {
super.setPlaybackSpeed(f, f2);
this.frameReleaseHelper.onPlaybackSpeed(f);
}
/* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
/* JADX WARN: Code restructure failed: missing block: B:55:0x007a, code lost:
if (r3.equals("video/av01") == false) goto L18;
*/
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
public static int getCodecMaxInputSize(androidx.media3.exoplayer.mediacodec.MediaCodecInfo r9, androidx.media3.common.Format r10) {
/*
Method dump skipped, instructions count: 276
To view this dump add '--comments-level debug' option
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.media3.exoplayer.video.MediaCodecVideoRenderer.getCodecMaxInputSize(androidx.media3.exoplayer.mediacodec.MediaCodecInfo, androidx.media3.common.Format):int");
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected float getCodecOperatingRateV23(float f, Format format, Format[] formatArr) {
float f2 = -1.0f;
for (Format format2 : formatArr) {
float f3 = format2.frameRate;
if (f3 != -1.0f) {
f2 = Math.max(f2, f3);
}
}
if (f2 == -1.0f) {
return -1.0f;
}
return f2 * f;
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onReadyToInitializeCodec(Format format) throws ExoPlaybackException {
if (this.videoFrameProcessorManager.isEnabled()) {
return;
}
this.videoFrameProcessorManager.maybeEnable(format, getOutputStreamOffsetUs());
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onCodecInitialized(String str, MediaCodecAdapter.Configuration configuration, long j, long j2) {
this.eventDispatcher.decoderInitialized(str, j, j2);
this.codecNeedsSetOutputSurfaceWorkaround = codecNeedsSetOutputSurfaceWorkaround(str);
this.codecHandlesHdr10PlusOutOfBandMetadata = ((MediaCodecInfo) Assertions.checkNotNull(getCodecInfo())).isHdr10PlusOutOfBandMetadataSupported();
if (Util.SDK_INT >= 23 && this.tunneling) {
this.tunnelingOnFrameRenderedListener = new OnFrameRenderedListenerV23((MediaCodecAdapter) Assertions.checkNotNull(getCodec()));
}
this.videoFrameProcessorManager.onCodecInitialized(str);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onCodecReleased(String str) {
this.eventDispatcher.decoderReleased(str);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onCodecError(Exception exc) {
Log.e(TAG, "Video codec error", exc);
this.eventDispatcher.videoCodecError(exc);
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
public DecoderReuseEvaluation onInputFormatChanged(FormatHolder formatHolder) throws ExoPlaybackException {
DecoderReuseEvaluation onInputFormatChanged = super.onInputFormatChanged(formatHolder);
this.eventDispatcher.inputFormatChanged(formatHolder.format, onInputFormatChanged);
return onInputFormatChanged;
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onQueueInputBuffer(DecoderInputBuffer decoderInputBuffer) throws ExoPlaybackException {
if (!this.tunneling) {
this.buffersInCodecCount++;
}
if (Util.SDK_INT >= 23 || !this.tunneling) {
return;
}
onProcessedTunneledBuffer(decoderInputBuffer.timeUs);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void onOutputFormatChanged(Format format, MediaFormat mediaFormat) {
int integer;
int integer2;
int i;
int i2;
MediaCodecAdapter codec = getCodec();
if (codec != null) {
codec.setVideoScalingMode(this.scalingMode);
}
int i3 = 0;
if (this.tunneling) {
i2 = format.width;
i = format.height;
} else {
Assertions.checkNotNull(mediaFormat);
boolean z = mediaFormat.containsKey(KEY_CROP_RIGHT) && mediaFormat.containsKey(KEY_CROP_LEFT) && mediaFormat.containsKey(KEY_CROP_BOTTOM) && mediaFormat.containsKey(KEY_CROP_TOP);
if (z) {
integer = (mediaFormat.getInteger(KEY_CROP_RIGHT) - mediaFormat.getInteger(KEY_CROP_LEFT)) + 1;
} else {
integer = mediaFormat.getInteger(ViewHierarchyNode.JsonKeys.WIDTH);
}
if (z) {
integer2 = (mediaFormat.getInteger(KEY_CROP_BOTTOM) - mediaFormat.getInteger(KEY_CROP_TOP)) + 1;
} else {
integer2 = mediaFormat.getInteger(ViewHierarchyNode.JsonKeys.HEIGHT);
}
int i4 = integer;
i = integer2;
i2 = i4;
}
float f = format.pixelWidthHeightRatio;
if (codecAppliesRotation()) {
if (format.rotationDegrees == 90 || format.rotationDegrees == 270) {
f = 1.0f / f;
int i5 = i;
i = i2;
i2 = i5;
}
} else if (!this.videoFrameProcessorManager.isEnabled()) {
i3 = format.rotationDegrees;
}
this.decodedVideoSize = new VideoSize(i2, i, i3, f);
this.frameReleaseHelper.onFormatChanged(format.frameRate);
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.setInputFormat(format.buildUpon().setWidth(i2).setHeight(i).setRotationDegrees(i3).setPixelWidthHeightRatio(f).build());
}
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected void handleInputBufferSupplementalData(DecoderInputBuffer decoderInputBuffer) throws ExoPlaybackException {
if (this.codecHandlesHdr10PlusOutOfBandMetadata) {
ByteBuffer byteBuffer = (ByteBuffer) Assertions.checkNotNull(decoderInputBuffer.supplementalData);
if (byteBuffer.remaining() >= 7) {
byte b = byteBuffer.get();
short s = byteBuffer.getShort();
short s2 = byteBuffer.getShort();
byte b2 = byteBuffer.get();
byte b3 = byteBuffer.get();
byteBuffer.position(0);
if (b == -75 && s == 60 && s2 == 1 && b2 == 4) {
if (b3 == 0 || b3 == 1) {
byte[] bArr = new byte[byteBuffer.remaining()];
byteBuffer.get(bArr);
byteBuffer.position(0);
setHdr10PlusInfoV29(getCodec(), bArr);
}
}
}
}
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected boolean processOutputBuffer(long j, long j2, MediaCodecAdapter mediaCodecAdapter, ByteBuffer byteBuffer, int i, int i2, int i3, long j3, boolean z, boolean z2, Format format) throws ExoPlaybackException {
Assertions.checkNotNull(mediaCodecAdapter);
if (this.initialPositionUs == -9223372036854775807L) {
this.initialPositionUs = j;
}
if (j3 != this.lastBufferPresentationTimeUs) {
if (!this.videoFrameProcessorManager.isEnabled()) {
this.frameReleaseHelper.onNextFrame(j3);
}
this.lastBufferPresentationTimeUs = j3;
}
long outputStreamOffsetUs = j3 - getOutputStreamOffsetUs();
if (z && !z2) {
skipOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
return true;
}
boolean z3 = false;
boolean z4 = getState() == 2;
long calculateEarlyTimeUs = calculateEarlyTimeUs(j, j2, SystemClock.elapsedRealtime() * 1000, j3, z4);
if (this.displaySurface == this.placeholderSurface) {
if (!isBufferLate(calculateEarlyTimeUs)) {
return false;
}
skipOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
updateVideoFrameProcessingOffsetCounters(calculateEarlyTimeUs);
return true;
}
if (shouldForceRender(j, calculateEarlyTimeUs)) {
if (!this.videoFrameProcessorManager.isEnabled()) {
z3 = true;
} else if (!this.videoFrameProcessorManager.maybeRegisterFrame(format, outputStreamOffsetUs, z2)) {
return false;
}
renderOutputBufferNow(mediaCodecAdapter, format, i, outputStreamOffsetUs, z3);
updateVideoFrameProcessingOffsetCounters(calculateEarlyTimeUs);
return true;
}
if (z4 && j != this.initialPositionUs) {
long nanoTime = System.nanoTime();
long adjustReleaseTime = this.frameReleaseHelper.adjustReleaseTime((calculateEarlyTimeUs * 1000) + nanoTime);
if (!this.videoFrameProcessorManager.isEnabled()) {
calculateEarlyTimeUs = (adjustReleaseTime - nanoTime) / 1000;
}
boolean z5 = this.joiningDeadlineMs != -9223372036854775807L;
if (shouldDropBuffersToKeyframe(calculateEarlyTimeUs, j2, z2) && maybeDropBuffersToKeyframe(j, z5)) {
return false;
}
if (shouldDropOutputBuffer(calculateEarlyTimeUs, j2, z2)) {
if (z5) {
skipOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
} else {
dropOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
}
updateVideoFrameProcessingOffsetCounters(calculateEarlyTimeUs);
return true;
}
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.releaseProcessedFrames(j, j2);
if (!this.videoFrameProcessorManager.maybeRegisterFrame(format, outputStreamOffsetUs, z2)) {
return false;
}
renderOutputBufferNow(mediaCodecAdapter, format, i, outputStreamOffsetUs, false);
return true;
}
if (Util.SDK_INT >= 21) {
if (calculateEarlyTimeUs < 50000) {
if (adjustReleaseTime == this.lastFrameReleaseTimeNs) {
skipOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
} else {
notifyFrameMetadataListener(outputStreamOffsetUs, adjustReleaseTime, format);
renderOutputBufferV21(mediaCodecAdapter, i, outputStreamOffsetUs, adjustReleaseTime);
}
updateVideoFrameProcessingOffsetCounters(calculateEarlyTimeUs);
this.lastFrameReleaseTimeNs = adjustReleaseTime;
return true;
}
} else if (calculateEarlyTimeUs < 30000) {
if (calculateEarlyTimeUs > 11000) {
try {
Thread.sleep((calculateEarlyTimeUs - WorkRequest.MIN_BACKOFF_MILLIS) / 1000);
} catch (InterruptedException unused) {
Thread.currentThread().interrupt();
return false;
}
}
notifyFrameMetadataListener(outputStreamOffsetUs, adjustReleaseTime, format);
renderOutputBuffer(mediaCodecAdapter, i, outputStreamOffsetUs);
updateVideoFrameProcessingOffsetCounters(calculateEarlyTimeUs);
return true;
}
}
return false;
}
/* JADX INFO: Access modifiers changed from: private */
public boolean shouldForceRender(long j, long j2) {
boolean z = getState() == 2;
boolean z2 = this.renderedFirstFrameAfterEnable ? !this.renderedFirstFrameAfterReset : z || this.mayRenderFirstFrameAfterEnableIfNotStarted;
long elapsedRealtime = (SystemClock.elapsedRealtime() * 1000) - this.lastRenderRealtimeUs;
if (this.joiningDeadlineMs == -9223372036854775807L && j >= getOutputStreamOffsetUs()) {
if (z2) {
return true;
}
if (z && shouldForceRenderOutputBuffer(j2, elapsedRealtime)) {
return true;
}
}
return false;
}
/* JADX INFO: Access modifiers changed from: private */
public long calculateEarlyTimeUs(long j, long j2, long j3, long j4, boolean z) {
long playbackSpeed = (long) ((j4 - j) / getPlaybackSpeed());
return z ? playbackSpeed - (j3 - j2) : playbackSpeed;
}
/* JADX INFO: Access modifiers changed from: private */
public void notifyFrameMetadataListener(long j, long j2, Format format) {
VideoFrameMetadataListener videoFrameMetadataListener = this.frameMetadataListener;
if (videoFrameMetadataListener != null) {
videoFrameMetadataListener.onVideoFrameAboutToBeRendered(j, j2, format, getCodecOutputMediaFormat());
}
}
protected void onProcessedTunneledBuffer(long j) throws ExoPlaybackException {
updateOutputFormatForTime(j);
maybeNotifyVideoSizeChanged(this.decodedVideoSize);
this.decoderCounters.renderedOutputBufferCount++;
maybeNotifyRenderedFirstFrame();
onProcessedOutputBuffer(j);
}
/* JADX INFO: Access modifiers changed from: private */
public void onProcessedTunneledEndOfStream() {
setPendingOutputEndOfStream();
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
public void onProcessedOutputBuffer(long j) {
super.onProcessedOutputBuffer(j);
if (this.tunneling) {
return;
}
this.buffersInCodecCount--;
}
/* JADX INFO: Access modifiers changed from: protected */
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
public void onProcessedStreamChange() {
super.onProcessedStreamChange();
clearRenderedFirstFrame();
}
protected boolean shouldDropOutputBuffer(long j, long j2, boolean z) {
return isBufferLate(j) && !z;
}
protected boolean shouldDropBuffersToKeyframe(long j, long j2, boolean z) {
return isBufferVeryLate(j) && !z;
}
protected boolean shouldForceRenderOutputBuffer(long j, long j2) {
return isBufferLate(j) && j2 > 100000;
}
protected void skipOutputBuffer(MediaCodecAdapter mediaCodecAdapter, int i, long j) {
TraceUtil.beginSection("skipVideoBuffer");
mediaCodecAdapter.releaseOutputBuffer(i, false);
TraceUtil.endSection();
this.decoderCounters.skippedOutputBufferCount++;
}
protected void dropOutputBuffer(MediaCodecAdapter mediaCodecAdapter, int i, long j) {
TraceUtil.beginSection("dropVideoBuffer");
mediaCodecAdapter.releaseOutputBuffer(i, false);
TraceUtil.endSection();
updateDroppedBufferCounters(0, 1);
}
protected boolean maybeDropBuffersToKeyframe(long j, boolean z) throws ExoPlaybackException {
int skipSource = skipSource(j);
if (skipSource == 0) {
return false;
}
if (z) {
this.decoderCounters.skippedInputBufferCount += skipSource;
this.decoderCounters.skippedOutputBufferCount += this.buffersInCodecCount;
} else {
this.decoderCounters.droppedToKeyframeCount++;
updateDroppedBufferCounters(skipSource, this.buffersInCodecCount);
}
flushOrReinitializeCodec();
if (this.videoFrameProcessorManager.isEnabled()) {
this.videoFrameProcessorManager.flush();
}
return true;
}
protected void updateDroppedBufferCounters(int i, int i2) {
this.decoderCounters.droppedInputBufferCount += i;
int i3 = i + i2;
this.decoderCounters.droppedBufferCount += i3;
this.droppedFrames += i3;
this.consecutiveDroppedFrameCount += i3;
this.decoderCounters.maxConsecutiveDroppedBufferCount = Math.max(this.consecutiveDroppedFrameCount, this.decoderCounters.maxConsecutiveDroppedBufferCount);
int i4 = this.maxDroppedFramesToNotify;
if (i4 <= 0 || this.droppedFrames < i4) {
return;
}
maybeNotifyDroppedFrames();
}
protected void updateVideoFrameProcessingOffsetCounters(long j) {
this.decoderCounters.addVideoFrameProcessingOffset(j);
this.totalVideoFrameProcessingOffsetUs += j;
this.videoFrameProcessingOffsetCount++;
}
protected Pair<ColorInfo, ColorInfo> experimentalGetVideoFrameProcessorColorConfiguration(ColorInfo colorInfo) {
if (!ColorInfo.isTransferHdr(colorInfo)) {
return Pair.create(ColorInfo.SDR_BT709_LIMITED, ColorInfo.SDR_BT709_LIMITED);
}
if (colorInfo.colorTransfer == 7) {
return Pair.create(colorInfo, colorInfo.buildUpon().setColorTransfer(6).build());
}
return Pair.create(colorInfo, colorInfo);
}
private void renderOutputBufferNow(MediaCodecAdapter mediaCodecAdapter, Format format, int i, long j, boolean z) {
long nanoTime;
if (this.videoFrameProcessorManager.isEnabled()) {
nanoTime = this.videoFrameProcessorManager.getCorrectedFramePresentationTimeUs(j, getOutputStreamOffsetUs()) * 1000;
} else {
nanoTime = System.nanoTime();
}
if (z) {
notifyFrameMetadataListener(j, nanoTime, format);
}
if (Util.SDK_INT >= 21) {
renderOutputBufferV21(mediaCodecAdapter, i, j, nanoTime);
} else {
renderOutputBuffer(mediaCodecAdapter, i, j);
}
}
protected void renderOutputBuffer(MediaCodecAdapter mediaCodecAdapter, int i, long j) {
TraceUtil.beginSection("releaseOutputBuffer");
mediaCodecAdapter.releaseOutputBuffer(i, true);
TraceUtil.endSection();
this.decoderCounters.renderedOutputBufferCount++;
this.consecutiveDroppedFrameCount = 0;
if (this.videoFrameProcessorManager.isEnabled()) {
return;
}
this.lastRenderRealtimeUs = SystemClock.elapsedRealtime() * 1000;
maybeNotifyVideoSizeChanged(this.decodedVideoSize);
maybeNotifyRenderedFirstFrame();
}
protected void renderOutputBufferV21(MediaCodecAdapter mediaCodecAdapter, int i, long j, long j2) {
TraceUtil.beginSection("releaseOutputBuffer");
mediaCodecAdapter.releaseOutputBuffer(i, j2);
TraceUtil.endSection();
this.decoderCounters.renderedOutputBufferCount++;
this.consecutiveDroppedFrameCount = 0;
if (this.videoFrameProcessorManager.isEnabled()) {
return;
}
this.lastRenderRealtimeUs = SystemClock.elapsedRealtime() * 1000;
maybeNotifyVideoSizeChanged(this.decodedVideoSize);
maybeNotifyRenderedFirstFrame();
}
private boolean shouldUsePlaceholderSurface(MediaCodecInfo mediaCodecInfo) {
return Util.SDK_INT >= 23 && !this.tunneling && !codecNeedsSetOutputSurfaceWorkaround(mediaCodecInfo.name) && (!mediaCodecInfo.secure || PlaceholderSurface.isSecureSupported(this.context));
}
private void releasePlaceholderSurface() {
Surface surface = this.displaySurface;
PlaceholderSurface placeholderSurface = this.placeholderSurface;
if (surface == placeholderSurface) {
this.displaySurface = null;
}
placeholderSurface.release();
this.placeholderSurface = null;
}
private void setJoiningDeadlineMs() {
this.joiningDeadlineMs = this.allowedJoiningTimeMs > 0 ? SystemClock.elapsedRealtime() + this.allowedJoiningTimeMs : -9223372036854775807L;
}
private void clearRenderedFirstFrame() {
MediaCodecAdapter codec;
this.renderedFirstFrameAfterReset = false;
if (Util.SDK_INT < 23 || !this.tunneling || (codec = getCodec()) == null) {
return;
}
this.tunnelingOnFrameRenderedListener = new OnFrameRenderedListenerV23(codec);
}
void maybeNotifyRenderedFirstFrame() {
this.renderedFirstFrameAfterEnable = true;
if (this.renderedFirstFrameAfterReset) {
return;
}
this.renderedFirstFrameAfterReset = true;
this.eventDispatcher.renderedFirstFrame(this.displaySurface);
this.haveReportedFirstFrameRenderedForCurrentSurface = true;
}
private void maybeRenotifyRenderedFirstFrame() {
if (this.haveReportedFirstFrameRenderedForCurrentSurface) {
this.eventDispatcher.renderedFirstFrame(this.displaySurface);
}
}
/* JADX INFO: Access modifiers changed from: private */
public void maybeNotifyVideoSizeChanged(VideoSize videoSize) {
if (videoSize.equals(VideoSize.UNKNOWN) || videoSize.equals(this.reportedVideoSize)) {
return;
}
this.reportedVideoSize = videoSize;
this.eventDispatcher.videoSizeChanged(videoSize);
}
private void maybeRenotifyVideoSizeChanged() {
VideoSize videoSize = this.reportedVideoSize;
if (videoSize != null) {
this.eventDispatcher.videoSizeChanged(videoSize);
}
}
private void maybeNotifyDroppedFrames() {
if (this.droppedFrames > 0) {
long elapsedRealtime = SystemClock.elapsedRealtime();
this.eventDispatcher.droppedFrames(this.droppedFrames, elapsedRealtime - this.droppedFrameAccumulationStartTimeMs);
this.droppedFrames = 0;
this.droppedFrameAccumulationStartTimeMs = elapsedRealtime;
}
}
private void maybeNotifyVideoFrameProcessingOffset() {
int i = this.videoFrameProcessingOffsetCount;
if (i != 0) {
this.eventDispatcher.reportVideoFrameProcessingOffset(this.totalVideoFrameProcessingOffsetUs, i);
this.totalVideoFrameProcessingOffsetUs = 0L;
this.videoFrameProcessingOffsetCount = 0;
}
}
private static void setHdr10PlusInfoV29(MediaCodecAdapter mediaCodecAdapter, byte[] bArr) {
Bundle bundle = new Bundle();
bundle.putByteArray("hdr10-plus-info", bArr);
mediaCodecAdapter.setParameters(bundle);
}
protected void setOutputSurfaceV23(MediaCodecAdapter mediaCodecAdapter, Surface surface) {
mediaCodecAdapter.setOutputSurface(surface);
}
private static void configureTunnelingV21(MediaFormat mediaFormat, int i) {
mediaFormat.setFeatureEnabled("tunneled-playback", true);
mediaFormat.setInteger("audio-session-id", i);
}
protected MediaFormat getMediaFormat(Format format, String str, CodecMaxValues codecMaxValues, float f, boolean z, int i) {
Pair<Integer, Integer> codecProfileAndLevel;
MediaFormat mediaFormat = new MediaFormat();
mediaFormat.setString("mime", str);
mediaFormat.setInteger(ViewHierarchyNode.JsonKeys.WIDTH, format.width);
mediaFormat.setInteger(ViewHierarchyNode.JsonKeys.HEIGHT, format.height);
MediaFormatUtil.setCsdBuffers(mediaFormat, format.initializationData);
MediaFormatUtil.maybeSetFloat(mediaFormat, "frame-rate", format.frameRate);
MediaFormatUtil.maybeSetInteger(mediaFormat, "rotation-degrees", format.rotationDegrees);
MediaFormatUtil.maybeSetColorInfo(mediaFormat, format.colorInfo);
if ("video/dolby-vision".equals(format.sampleMimeType) && (codecProfileAndLevel = MediaCodecUtil.getCodecProfileAndLevel(format)) != null) {
MediaFormatUtil.maybeSetInteger(mediaFormat, "profile", ((Integer) codecProfileAndLevel.first).intValue());
}
mediaFormat.setInteger("max-width", codecMaxValues.width);
mediaFormat.setInteger("max-height", codecMaxValues.height);
MediaFormatUtil.maybeSetInteger(mediaFormat, "max-input-size", codecMaxValues.inputSize);
if (Util.SDK_INT >= 23) {
mediaFormat.setInteger(SentryThread.JsonKeys.PRIORITY, 0);
if (f != -1.0f) {
mediaFormat.setFloat("operating-rate", f);
}
}
if (z) {
mediaFormat.setInteger("no-post-process", 1);
mediaFormat.setInteger("auto-frc", 0);
}
if (i != 0) {
configureTunnelingV21(mediaFormat, i);
}
return mediaFormat;
}
protected CodecMaxValues getCodecMaxValues(MediaCodecInfo mediaCodecInfo, Format format, Format[] formatArr) {
int codecMaxInputSize;
int i = format.width;
int i2 = format.height;
int maxInputSize = getMaxInputSize(mediaCodecInfo, format);
if (formatArr.length == 1) {
if (maxInputSize != -1 && (codecMaxInputSize = getCodecMaxInputSize(mediaCodecInfo, format)) != -1) {
maxInputSize = Math.min((int) (maxInputSize * INITIAL_FORMAT_MAX_INPUT_SIZE_SCALE_FACTOR), codecMaxInputSize);
}
return new CodecMaxValues(i, i2, maxInputSize);
}
int length = formatArr.length;
boolean z = false;
for (int i3 = 0; i3 < length; i3++) {
Format format2 = formatArr[i3];
if (format.colorInfo != null && format2.colorInfo == null) {
format2 = format2.buildUpon().setColorInfo(format.colorInfo).build();
}
if (mediaCodecInfo.canReuseCodec(format, format2).result != 0) {
z |= format2.width == -1 || format2.height == -1;
i = Math.max(i, format2.width);
i2 = Math.max(i2, format2.height);
maxInputSize = Math.max(maxInputSize, getMaxInputSize(mediaCodecInfo, format2));
}
}
if (z) {
Log.w(TAG, "Resolutions unknown. Codec max resolution: " + i + ViewHierarchyNode.JsonKeys.X + i2);
Point codecMaxSize = getCodecMaxSize(mediaCodecInfo, format);
if (codecMaxSize != null) {
i = Math.max(i, codecMaxSize.x);
i2 = Math.max(i2, codecMaxSize.y);
maxInputSize = Math.max(maxInputSize, getCodecMaxInputSize(mediaCodecInfo, format.buildUpon().setWidth(i).setHeight(i2).build()));
Log.w(TAG, "Codec max resolution adjusted to: " + i + ViewHierarchyNode.JsonKeys.X + i2);
}
}
return new CodecMaxValues(i, i2, maxInputSize);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecRenderer
protected MediaCodecDecoderException createDecoderException(Throwable th, MediaCodecInfo mediaCodecInfo) {
return new MediaCodecVideoDecoderException(th, mediaCodecInfo, this.displaySurface);
}
/* JADX INFO: Access modifiers changed from: private */
/* loaded from: classes2.dex */
public static final class VideoFrameProcessorManager {
private static final long EARLY_THRESHOLD_US = 50000;
private Pair<Long, Format> currentFrameFormat;
private Pair<Surface, Size> currentSurfaceAndSize;
private final VideoFrameReleaseHelper frameReleaseHelper;
private Handler handler;
private Format inputFormat;
private boolean pendingOutputSizeChange;
private boolean processedLastFrame;
private boolean registeredLastFrame;
private boolean releasedLastFrame;
private final MediaCodecVideoRenderer renderer;
private CopyOnWriteArrayList<Effect> videoEffects;
private VideoFrameProcessor videoFrameProcessor;
private final ArrayDeque<Long> processedFramesTimestampsUs = new ArrayDeque<>();
private final ArrayDeque<Pair<Long, Format>> pendingFrameFormats = new ArrayDeque<>();
private int videoFrameProcessorMaxPendingFrameCount = -1;
private boolean canEnableFrameProcessing = true;
private long lastCodecBufferPresentationTimestampUs = -9223372036854775807L;
private VideoSize processedFrameSize = VideoSize.UNKNOWN;
private long pendingOutputSizeChangeNotificationTimeUs = -9223372036854775807L;
private long initialStreamOffsetUs = -9223372036854775807L;
public boolean isEnabled() {
return this.videoFrameProcessor != null;
}
public boolean releasedLastFrame() {
return this.releasedLastFrame;
}
public VideoFrameProcessorManager(VideoFrameReleaseHelper videoFrameReleaseHelper, MediaCodecVideoRenderer mediaCodecVideoRenderer) {
this.frameReleaseHelper = videoFrameReleaseHelper;
this.renderer = mediaCodecVideoRenderer;
}
public void setVideoEffects(List<Effect> list) {
CopyOnWriteArrayList<Effect> copyOnWriteArrayList = this.videoEffects;
if (copyOnWriteArrayList == null) {
this.videoEffects = new CopyOnWriteArrayList<>(list);
} else {
copyOnWriteArrayList.clear();
this.videoEffects.addAll(list);
}
}
public boolean isReady() {
Pair<Surface, Size> pair = this.currentSurfaceAndSize;
return pair == null || !((Size) pair.second).equals(Size.UNKNOWN);
}
public void flush() {
Assertions.checkStateNotNull(this.videoFrameProcessor);
this.videoFrameProcessor.flush();
this.processedFramesTimestampsUs.clear();
this.handler.removeCallbacksAndMessages(null);
if (this.registeredLastFrame) {
this.registeredLastFrame = false;
this.processedLastFrame = false;
this.releasedLastFrame = false;
}
}
public boolean maybeEnable(final Format format, long j) throws ExoPlaybackException {
Assertions.checkState(!isEnabled());
if (!this.canEnableFrameProcessing) {
return false;
}
if (this.videoEffects == null) {
this.canEnableFrameProcessing = false;
return false;
}
this.handler = Util.createHandlerForCurrentLooper();
Pair<ColorInfo, ColorInfo> experimentalGetVideoFrameProcessorColorConfiguration = this.renderer.experimentalGetVideoFrameProcessorColorConfiguration(format.colorInfo);
try {
if (!MediaCodecVideoRenderer.access$000() && format.rotationDegrees != 0) {
this.videoEffects.add(0, VideoFrameProcessorAccessor.createRotationEffect(format.rotationDegrees));
}
VideoFrameProcessor.Factory frameProcessorFactory = VideoFrameProcessorAccessor.getFrameProcessorFactory();
Context context = this.renderer.context;
List<Effect> list = (List) Assertions.checkNotNull(this.videoEffects);
DebugViewProvider debugViewProvider = DebugViewProvider.NONE;
ColorInfo colorInfo = (ColorInfo) experimentalGetVideoFrameProcessorColorConfiguration.first;
ColorInfo colorInfo2 = (ColorInfo) experimentalGetVideoFrameProcessorColorConfiguration.second;
final Handler handler = this.handler;
Objects.requireNonNull(handler);
VideoFrameProcessor create = frameProcessorFactory.create(context, list, debugViewProvider, colorInfo, colorInfo2, false, new Executor() { // from class: androidx.media3.exoplayer.video.MediaCodecVideoRenderer$VideoFrameProcessorManager$$ExternalSyntheticLambda0
@Override // java.util.concurrent.Executor
public final void execute(Runnable runnable) {
handler.post(runnable);
}
}, new VideoFrameProcessor.Listener() { // from class: androidx.media3.exoplayer.video.MediaCodecVideoRenderer.VideoFrameProcessorManager.1
@Override // androidx.media3.common.VideoFrameProcessor.Listener
public void onOutputSizeChanged(int i, int i2) {
Assertions.checkStateNotNull(VideoFrameProcessorManager.this.inputFormat);
VideoFrameProcessorManager.this.processedFrameSize = new VideoSize(i, i2, 0, 1.0f);
VideoFrameProcessorManager.this.pendingOutputSizeChange = true;
}
@Override // androidx.media3.common.VideoFrameProcessor.Listener
public void onOutputFrameAvailableForRendering(long j2) {
if (VideoFrameProcessorManager.this.registeredLastFrame) {
Assertions.checkState(VideoFrameProcessorManager.this.lastCodecBufferPresentationTimestampUs != -9223372036854775807L);
}
VideoFrameProcessorManager.this.processedFramesTimestampsUs.add(Long.valueOf(j2));
if (VideoFrameProcessorManager.this.registeredLastFrame && j2 >= VideoFrameProcessorManager.this.lastCodecBufferPresentationTimestampUs) {
VideoFrameProcessorManager.this.processedLastFrame = true;
}
if (VideoFrameProcessorManager.this.pendingOutputSizeChange) {
VideoFrameProcessorManager.this.pendingOutputSizeChange = false;
VideoFrameProcessorManager.this.pendingOutputSizeChangeNotificationTimeUs = j2;
}
}
@Override // androidx.media3.common.VideoFrameProcessor.Listener
public void onError(VideoFrameProcessingException videoFrameProcessingException) {
VideoFrameProcessorManager.this.renderer.setPendingPlaybackException(VideoFrameProcessorManager.this.renderer.createRendererException(videoFrameProcessingException, format, PlaybackException.ERROR_CODE_VIDEO_FRAME_PROCESSING_FAILED));
}
@Override // androidx.media3.common.VideoFrameProcessor.Listener
public void onEnded() {
throw new IllegalStateException();
}
});
this.videoFrameProcessor = create;
create.registerInputStream(1);
this.initialStreamOffsetUs = j;
Pair<Surface, Size> pair = this.currentSurfaceAndSize;
if (pair != null) {
Size size = (Size) pair.second;
this.videoFrameProcessor.setOutputSurfaceInfo(new SurfaceInfo((Surface) this.currentSurfaceAndSize.first, size.getWidth(), size.getHeight()));
}
setInputFormat(format);
return true;
} catch (Exception e) {
throw this.renderer.createRendererException(e, format, 7000);
}
}
public long getCorrectedFramePresentationTimeUs(long j, long j2) {
Assertions.checkState(this.initialStreamOffsetUs != -9223372036854775807L);
return (j + j2) - this.initialStreamOffsetUs;
}
public Surface getInputSurface() {
return ((VideoFrameProcessor) Assertions.checkNotNull(this.videoFrameProcessor)).getInputSurface();
}
public void setOutputSurfaceInfo(Surface surface, Size size) {
Pair<Surface, Size> pair = this.currentSurfaceAndSize;
if (pair != null && ((Surface) pair.first).equals(surface) && ((Size) this.currentSurfaceAndSize.second).equals(size)) {
return;
}
this.currentSurfaceAndSize = Pair.create(surface, size);
if (isEnabled()) {
((VideoFrameProcessor) Assertions.checkNotNull(this.videoFrameProcessor)).setOutputSurfaceInfo(new SurfaceInfo(surface, size.getWidth(), size.getHeight()));
}
}
public void clearOutputSurfaceInfo() {
((VideoFrameProcessor) Assertions.checkNotNull(this.videoFrameProcessor)).setOutputSurfaceInfo(null);
this.currentSurfaceAndSize = null;
}
public void setInputFormat(Format format) {
((VideoFrameProcessor) Assertions.checkNotNull(this.videoFrameProcessor)).setInputFrameInfo(new FrameInfo.Builder(format.width, format.height).setPixelWidthHeightRatio(format.pixelWidthHeightRatio).build());
this.inputFormat = format;
if (this.registeredLastFrame) {
this.registeredLastFrame = false;
this.processedLastFrame = false;
this.releasedLastFrame = false;
}
}
public MediaFormat amendMediaFormatKeys(MediaFormat mediaFormat) {
if (Util.SDK_INT >= 29 && this.renderer.context.getApplicationContext().getApplicationInfo().targetSdkVersion >= 29) {
mediaFormat.setInteger("allow-frame-drop", 0);
}
return mediaFormat;
}
public void onCodecInitialized(String str) {
this.videoFrameProcessorMaxPendingFrameCount = Util.getMaxPendingFramesCountForMediaCodecDecoders(this.renderer.context, str, false);
}
public boolean maybeRegisterFrame(Format format, long j, boolean z) {
Assertions.checkStateNotNull(this.videoFrameProcessor);
Assertions.checkState(this.videoFrameProcessorMaxPendingFrameCount != -1);
if (this.videoFrameProcessor.getPendingInputFrameCount() >= this.videoFrameProcessorMaxPendingFrameCount) {
return false;
}
this.videoFrameProcessor.registerInputFrame();
Pair<Long, Format> pair = this.currentFrameFormat;
if (pair == null) {
this.currentFrameFormat = Pair.create(Long.valueOf(j), format);
} else if (!Util.areEqual(format, pair.second)) {
this.pendingFrameFormats.add(Pair.create(Long.valueOf(j), format));
}
if (z) {
this.registeredLastFrame = true;
this.lastCodecBufferPresentationTimestampUs = j;
}
return true;
}
public void releaseProcessedFrames(long j, long j2) {
Assertions.checkStateNotNull(this.videoFrameProcessor);
while (!this.processedFramesTimestampsUs.isEmpty()) {
boolean z = false;
boolean z2 = this.renderer.getState() == 2;
long longValue = ((Long) Assertions.checkNotNull(this.processedFramesTimestampsUs.peek())).longValue();
long j3 = longValue + this.initialStreamOffsetUs;
long calculateEarlyTimeUs = this.renderer.calculateEarlyTimeUs(j, j2, SystemClock.elapsedRealtime() * 1000, j3, z2);
if (this.processedLastFrame && this.processedFramesTimestampsUs.size() == 1) {
z = true;
}
if (this.renderer.shouldForceRender(j, calculateEarlyTimeUs)) {
releaseProcessedFrameInternal(-1L, z);
return;
}
if (!z2 || j == this.renderer.initialPositionUs || calculateEarlyTimeUs > EARLY_THRESHOLD_US) {
return;
}
this.frameReleaseHelper.onNextFrame(j3);
long adjustReleaseTime = this.frameReleaseHelper.adjustReleaseTime(System.nanoTime() + (calculateEarlyTimeUs * 1000));
if (this.renderer.shouldDropOutputBuffer((adjustReleaseTime - System.nanoTime()) / 1000, j2, z)) {
releaseProcessedFrameInternal(-2L, z);
} else {
if (!this.pendingFrameFormats.isEmpty() && j3 > ((Long) this.pendingFrameFormats.peek().first).longValue()) {
this.currentFrameFormat = this.pendingFrameFormats.remove();
}
this.renderer.notifyFrameMetadataListener(longValue, adjustReleaseTime, (Format) this.currentFrameFormat.second);
if (this.pendingOutputSizeChangeNotificationTimeUs >= j3) {
this.pendingOutputSizeChangeNotificationTimeUs = -9223372036854775807L;
this.renderer.maybeNotifyVideoSizeChanged(this.processedFrameSize);
}
releaseProcessedFrameInternal(adjustReleaseTime, z);
}
}
}
public void reset() {
((VideoFrameProcessor) Assertions.checkNotNull(this.videoFrameProcessor)).release();
this.videoFrameProcessor = null;
Handler handler = this.handler;
if (handler != null) {
handler.removeCallbacksAndMessages(null);
}
CopyOnWriteArrayList<Effect> copyOnWriteArrayList = this.videoEffects;
if (copyOnWriteArrayList != null) {
copyOnWriteArrayList.clear();
}
this.processedFramesTimestampsUs.clear();
this.canEnableFrameProcessing = true;
}
private void releaseProcessedFrameInternal(long j, boolean z) {
Assertions.checkStateNotNull(this.videoFrameProcessor);
this.videoFrameProcessor.renderOutputFrame(j);
this.processedFramesTimestampsUs.remove();
this.renderer.lastRenderRealtimeUs = SystemClock.elapsedRealtime() * 1000;
if (j != -2) {
this.renderer.maybeNotifyRenderedFirstFrame();
}
if (z) {
this.releasedLastFrame = true;
}
}
/* JADX INFO: Access modifiers changed from: private */
/* loaded from: classes2.dex */
public static final class VideoFrameProcessorAccessor {
private static Method buildScaleAndRotateTransformationMethod;
private static Method buildVideoFrameProcessorFactoryMethod;
private static Constructor<?> scaleAndRotateTransformationBuilderConstructor;
private static Method setRotationMethod;
private static Constructor<?> videoFrameProcessorFactoryBuilderConstructor;
private VideoFrameProcessorAccessor() {
}
public static Effect createRotationEffect(float f) throws Exception {
prepare();
Object newInstance = scaleAndRotateTransformationBuilderConstructor.newInstance(new Object[0]);
setRotationMethod.invoke(newInstance, Float.valueOf(f));
return (Effect) Assertions.checkNotNull(buildScaleAndRotateTransformationMethod.invoke(newInstance, new Object[0]));
}
public static VideoFrameProcessor.Factory getFrameProcessorFactory() throws Exception {
prepare();
return (VideoFrameProcessor.Factory) Assertions.checkNotNull(buildVideoFrameProcessorFactoryMethod.invoke(videoFrameProcessorFactoryBuilderConstructor.newInstance(new Object[0]), new Object[0]));
}
@EnsuresNonNull({"scaleAndRotateTransformationBuilderConstructor", "setRotationMethod", "buildScaleAndRotateTransformationMethod", "videoFrameProcessorFactoryBuilderConstructor", "buildVideoFrameProcessorFactoryMethod"})
private static void prepare() throws Exception {
if (scaleAndRotateTransformationBuilderConstructor == null || setRotationMethod == null || buildScaleAndRotateTransformationMethod == null) {
Class<?> cls = Class.forName("androidx.media3.effect.ScaleAndRotateTransformation$Builder");
scaleAndRotateTransformationBuilderConstructor = cls.getConstructor(new Class[0]);
setRotationMethod = cls.getMethod("setRotationDegrees", Float.TYPE);
buildScaleAndRotateTransformationMethod = cls.getMethod(OperatingSystem.JsonKeys.BUILD, new Class[0]);
}
if (videoFrameProcessorFactoryBuilderConstructor == null || buildVideoFrameProcessorFactoryMethod == null) {
Class<?> cls2 = Class.forName("androidx.media3.effect.DefaultVideoFrameProcessor$Factory$Builder");
videoFrameProcessorFactoryBuilderConstructor = cls2.getConstructor(new Class[0]);
buildVideoFrameProcessorFactoryMethod = cls2.getMethod(OperatingSystem.JsonKeys.BUILD, new Class[0]);
}
}
}
}
private static Point getCodecMaxSize(MediaCodecInfo mediaCodecInfo, Format format) {
boolean z = format.height > format.width;
int i = z ? format.height : format.width;
int i2 = z ? format.width : format.height;
float f = i2 / i;
for (int i3 : STANDARD_LONG_EDGE_VIDEO_PX) {
int i4 = (int) (i3 * f);
if (i3 <= i || i4 <= i2) {
break;
}
if (Util.SDK_INT >= 21) {
int i5 = z ? i4 : i3;
if (!z) {
i3 = i4;
}
Point alignVideoSizeV21 = mediaCodecInfo.alignVideoSizeV21(i5, i3);
if (mediaCodecInfo.isVideoSizeAndRateSupportedV21(alignVideoSizeV21.x, alignVideoSizeV21.y, format.frameRate)) {
return alignVideoSizeV21;
}
} else {
try {
int ceilDivide = Util.ceilDivide(i3, 16) * 16;
int ceilDivide2 = Util.ceilDivide(i4, 16) * 16;
if (ceilDivide * ceilDivide2 <= MediaCodecUtil.maxH264DecodableFrameSize()) {
int i6 = z ? ceilDivide2 : ceilDivide;
if (!z) {
ceilDivide = ceilDivide2;
}
return new Point(i6, ceilDivide);
}
} catch (MediaCodecUtil.DecoderQueryException unused) {
}
}
}
return null;
}
protected static int getMaxInputSize(MediaCodecInfo mediaCodecInfo, Format format) {
if (format.maxInputSize != -1) {
int size = format.initializationData.size();
int i = 0;
for (int i2 = 0; i2 < size; i2++) {
i += format.initializationData.get(i2).length;
}
return format.maxInputSize + i;
}
return getCodecMaxInputSize(mediaCodecInfo, format);
}
private static boolean codecAppliesRotation() {
return Util.SDK_INT >= 21;
}
private static boolean deviceNeedsNoPostProcessWorkaround() {
return "NVIDIA".equals(Util.MANUFACTURER);
}
protected boolean codecNeedsSetOutputSurfaceWorkaround(String str) {
if (str.startsWith("OMX.google")) {
return false;
}
synchronized (MediaCodecVideoRenderer.class) {
if (!evaluatedDeviceNeedsSetOutputSurfaceWorkaround) {
deviceNeedsSetOutputSurfaceWorkaround = evaluateDeviceNeedsSetOutputSurfaceWorkaround();
evaluatedDeviceNeedsSetOutputSurfaceWorkaround = true;
}
}
return deviceNeedsSetOutputSurfaceWorkaround;
}
/* JADX INFO: Access modifiers changed from: protected */
/* loaded from: classes2.dex */
public static final class CodecMaxValues {
public final int height;
public final int inputSize;
public final int width;
public CodecMaxValues(int i, int i2, int i3) {
this.width = i;
this.height = i2;
this.inputSize = i3;
}
}
private static int getMaxSampleSize(int i, int i2) {
return (i * 3) / (i2 * 2);
}
/* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
/* JADX WARN: Code restructure failed: missing block: B:448:0x0848, code lost:
if (r0.equals("PGN528") == false) goto L91;
*/
/* JADX WARN: Failed to find 'out' block for switch in B:47:0x089f. Please report as an issue. */
/*
Code decompiled incorrectly, please refer to instructions dump.
To view partially-correct add '--show-bad-code' argument
*/
private static boolean evaluateDeviceNeedsSetOutputSurfaceWorkaround() {
/*
Method dump skipped, instructions count: 3188
To view this dump add '--comments-level debug' option
*/
throw new UnsupportedOperationException("Method not decompiled: androidx.media3.exoplayer.video.MediaCodecVideoRenderer.evaluateDeviceNeedsSetOutputSurfaceWorkaround():boolean");
}
/* JADX INFO: Access modifiers changed from: private */
/* loaded from: classes2.dex */
public final class OnFrameRenderedListenerV23 implements MediaCodecAdapter.OnFrameRenderedListener, Handler.Callback {
private static final int HANDLE_FRAME_RENDERED = 0;
private final Handler handler;
public OnFrameRenderedListenerV23(MediaCodecAdapter mediaCodecAdapter) {
Handler createHandlerForCurrentLooper = Util.createHandlerForCurrentLooper(this);
this.handler = createHandlerForCurrentLooper;
mediaCodecAdapter.setOnFrameRenderedListener(this, createHandlerForCurrentLooper);
}
@Override // androidx.media3.exoplayer.mediacodec.MediaCodecAdapter.OnFrameRenderedListener
public void onFrameRendered(MediaCodecAdapter mediaCodecAdapter, long j, long j2) {
if (Util.SDK_INT < 30) {
this.handler.sendMessageAtFrontOfQueue(Message.obtain(this.handler, 0, (int) (j >> 32), (int) j));
} else {
handleFrameRendered(j);
}
}
@Override // android.os.Handler.Callback
public boolean handleMessage(Message message) {
if (message.what != 0) {
return false;
}
handleFrameRendered(Util.toLong(message.arg1, message.arg2));
return true;
}
private void handleFrameRendered(long j) {
if (this != MediaCodecVideoRenderer.this.tunnelingOnFrameRenderedListener || MediaCodecVideoRenderer.this.getCodec() == null) {
return;
}
if (j == Long.MAX_VALUE) {
MediaCodecVideoRenderer.this.onProcessedTunneledEndOfStream();
return;
}
try {
MediaCodecVideoRenderer.this.onProcessedTunneledBuffer(j);
} catch (ExoPlaybackException e) {
MediaCodecVideoRenderer.this.setPendingPlaybackException(e);
}
}
}
}
Reference in a new issue Copy permalink