package androidx.media3.exoplayer.video;

import androidx.media3.common.VideoSize;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.Clock;
import androidx.media3.common.util.LongArrayQueue;
import androidx.media3.common.util.TimedValueQueue;
import androidx.media3.exoplayer.ExoPlaybackException;
import androidx.media3.exoplayer.video.VideoFrameReleaseControl;

/* JADX INFO: loaded from: classes.dex */
final class VideoFrameRenderControl {
    private final FrameRenderer frameRenderer;
    private long outputStreamStartPositionUs;
    private final VideoFrameReleaseControl videoFrameReleaseControl;
    private final VideoFrameReleaseControl.FrameReleaseInfo videoFrameReleaseInfo = new VideoFrameReleaseControl.FrameReleaseInfo();
    private final TimedValueQueue<VideoSize> videoSizes = new TimedValueQueue<>();
    private final TimedValueQueue<Long> streamStartPositionsUs = new TimedValueQueue<>();
    private final LongArrayQueue presentationTimestampsUs = new LongArrayQueue();
    private long latestInputPresentationTimeUs = -9223372036854775807L;
    private VideoSize outputVideoSize = VideoSize.UNKNOWN;
    private long latestOutputPresentationTimeUs = -9223372036854775807L;
    private long lastPresentationTimeUs = -9223372036854775807L;

    public interface FrameRenderer {
        void dropFrame();

        void onVideoSizeChanged(VideoSize videoSize);

        void renderFrame(long j10, long j11, boolean z10);
    }

    public VideoFrameRenderControl(FrameRenderer frameRenderer, VideoFrameReleaseControl videoFrameReleaseControl) {
        this.frameRenderer = frameRenderer;
        this.videoFrameReleaseControl = videoFrameReleaseControl;
    }

    private void dropFrame() {
        this.presentationTimestampsUs.remove();
        this.frameRenderer.dropFrame();
    }

    private static <T> T getLastAndClear(TimedValueQueue<T> timedValueQueue) {
        Assertions.checkArgument(timedValueQueue.size() > 0);
        while (timedValueQueue.size() > 1) {
            timedValueQueue.pollFirst();
        }
        return (T) Assertions.checkNotNull(timedValueQueue.pollFirst());
    }

    private boolean maybeUpdateOutputStream(long j10) {
        Long lPollFloor = this.streamStartPositionsUs.pollFloor(j10);
        if (lPollFloor == null || lPollFloor.longValue() == this.outputStreamStartPositionUs) {
            return false;
        }
        this.outputStreamStartPositionUs = lPollFloor.longValue();
        return true;
    }

    private boolean maybeUpdateOutputVideoSize(long j10) {
        VideoSize videoSizePollFloor = this.videoSizes.pollFloor(j10);
        if (videoSizePollFloor == null || videoSizePollFloor.equals(VideoSize.UNKNOWN) || videoSizePollFloor.equals(this.outputVideoSize)) {
            return false;
        }
        this.outputVideoSize = videoSizePollFloor;
        return true;
    }

    private void renderFrame(boolean z10) {
        long jRemove = this.presentationTimestampsUs.remove();
        if (maybeUpdateOutputVideoSize(jRemove)) {
            this.frameRenderer.onVideoSizeChanged(this.outputVideoSize);
        }
        this.frameRenderer.renderFrame(z10 ? Clock.DEFAULT.nanoTime() : this.videoFrameReleaseInfo.getReleaseTimeNs(), jRemove, this.videoFrameReleaseControl.onFrameReleasedIsFirstFrame());
    }

    public void flush() {
        this.presentationTimestampsUs.clear();
        this.latestInputPresentationTimeUs = -9223372036854775807L;
        this.latestOutputPresentationTimeUs = -9223372036854775807L;
        this.lastPresentationTimeUs = -9223372036854775807L;
        if (this.streamStartPositionsUs.size() > 0) {
            this.outputStreamStartPositionUs = ((Long) getLastAndClear(this.streamStartPositionsUs)).longValue();
        }
        if (this.videoSizes.size() > 0) {
            this.videoSizes.add(0L, (VideoSize) getLastAndClear(this.videoSizes));
        }
    }

    public boolean isEnded() {
        long j10 = this.lastPresentationTimeUs;
        return j10 != -9223372036854775807L && this.latestOutputPresentationTimeUs == j10;
    }

    public void onFrameAvailableForRendering(long j10) {
        this.presentationTimestampsUs.add(j10);
        this.latestInputPresentationTimeUs = j10;
        this.lastPresentationTimeUs = -9223372036854775807L;
    }

    public void onStreamChanged(int i10, long j10) {
        if (this.presentationTimestampsUs.isEmpty()) {
            this.videoFrameReleaseControl.onStreamChanged(i10);
            this.outputStreamStartPositionUs = j10;
        } else {
            TimedValueQueue<Long> timedValueQueue = this.streamStartPositionsUs;
            long j11 = this.latestInputPresentationTimeUs;
            timedValueQueue.add(j11 == -9223372036854775807L ? -4611686018427387904L : j11 + 1, Long.valueOf(j10));
        }
    }

    public void onVideoSizeChanged(int i10, int i11) {
        TimedValueQueue<VideoSize> timedValueQueue = this.videoSizes;
        long j10 = this.latestInputPresentationTimeUs;
        timedValueQueue.add(j10 == -9223372036854775807L ? 0L : j10 + 1, new VideoSize(i10, i11));
    }

    public void render(long j10, long j11) throws ExoPlaybackException {
        VideoFrameRenderControl videoFrameRenderControl = this;
        while (!videoFrameRenderControl.presentationTimestampsUs.isEmpty()) {
            long jElement = videoFrameRenderControl.presentationTimestampsUs.element();
            if (videoFrameRenderControl.maybeUpdateOutputStream(jElement)) {
                videoFrameRenderControl.videoFrameReleaseControl.onStreamChanged(2);
            }
            int frameReleaseAction = videoFrameRenderControl.videoFrameReleaseControl.getFrameReleaseAction(jElement, j10, j11, videoFrameRenderControl.outputStreamStartPositionUs, false, false, videoFrameRenderControl.videoFrameReleaseInfo);
            if (frameReleaseAction == 0 || frameReleaseAction == 1) {
                videoFrameRenderControl = this;
                videoFrameRenderControl.latestOutputPresentationTimeUs = jElement;
                videoFrameRenderControl.renderFrame(frameReleaseAction == 0);
            } else if (frameReleaseAction == 2 || frameReleaseAction == 3) {
                videoFrameRenderControl = this;
                videoFrameRenderControl.latestOutputPresentationTimeUs = jElement;
                dropFrame();
            } else if (frameReleaseAction != 4) {
                if (frameReleaseAction != 5) {
                    throw new IllegalStateException(String.valueOf(frameReleaseAction));
                }
                return;
            } else {
                videoFrameRenderControl = this;
                videoFrameRenderControl.latestOutputPresentationTimeUs = jElement;
            }
        }
    }

    public void signalEndOfInput() {
        if (this.latestInputPresentationTimeUs == -9223372036854775807L) {
            this.latestInputPresentationTimeUs = Long.MIN_VALUE;
            this.latestOutputPresentationTimeUs = Long.MIN_VALUE;
        }
        this.lastPresentationTimeUs = this.latestInputPresentationTimeUs;
    }
}