package io.flutter.embedding.engine.renderer;

import android.annotation.TargetApi;
import android.media.Image;
import android.media.ImageReader;
import android.os.Build;
import android.view.Surface;
import androidx.annotation.Keep;
import androidx.annotation.VisibleForTesting;
import io.flutter.view.TextureRegistry$ImageConsumer;
import io.flutter.view.TextureRegistry$SurfaceProducer;
import io.flutter.view.n;
import io.flutter.view.o;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Iterator;

/* JADX INFO: loaded from: classes.dex */
@Keep
@TargetApi(29)
final class FlutterRenderer$ImageReaderSurfaceProducer implements TextureRegistry$SurfaceProducer, TextureRegistry$ImageConsumer, n {
    private static final boolean CLEANUP_ON_MEMORY_PRESSURE = true;
    private static final int MAX_IMAGES = 5;
    private static final String TAG = "ImageReaderSurfaceProducer";
    private static final boolean VERBOSE_LOGS = false;
    private static final boolean trimOnMemoryPressure = true;
    private o callback;

    /* JADX INFO: renamed from: id, reason: collision with root package name */
    private final long f28011id;
    private boolean released;
    final /* synthetic */ j this$0;
    private boolean ignoringFence = false;
    private int requestedWidth = 1;
    private int requestedHeight = 1;
    private boolean createNewReader = true;
    private boolean notifiedDestroy = false;
    private long lastDequeueTime = 0;
    private long lastQueueTime = 0;
    private long lastScheduleTime = 0;
    private int numTrims = 0;
    private final Object lock = new Object();
    private final ArrayDeque<f> imageReaderQueue = new ArrayDeque<>();
    private final HashMap<ImageReader, f> perImageReaders = new HashMap<>();
    private d lastDequeuedImage = null;
    private f lastReaderDequeuedFrom = null;

    public FlutterRenderer$ImageReaderSurfaceProducer(j jVar, long j10) {
        this.this$0 = jVar;
        this.f28011id = j10;
    }

    public static /* synthetic */ o access$200(FlutterRenderer$ImageReaderSurfaceProducer flutterRenderer$ImageReaderSurfaceProducer) {
        flutterRenderer$ImageReaderSurfaceProducer.getClass();
        return null;
    }

    private void cleanup() {
        synchronized (this.lock) {
            try {
                for (f fVar : this.perImageReaders.values()) {
                    if (this.lastReaderDequeuedFrom == fVar) {
                        this.lastReaderDequeuedFrom = null;
                    }
                    fVar.f28024c = true;
                    fVar.f28022a.close();
                    fVar.f28023b.clear();
                }
                this.perImageReaders.clear();
                d dVar = this.lastDequeuedImage;
                if (dVar != null) {
                    dVar.f28019a.close();
                    this.lastDequeuedImage = null;
                }
                f fVar2 = this.lastReaderDequeuedFrom;
                if (fVar2 != null) {
                    fVar2.f28024c = true;
                    fVar2.f28022a.close();
                    fVar2.f28023b.clear();
                    this.lastReaderDequeuedFrom = null;
                }
                this.imageReaderQueue.clear();
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private ImageReader createImageReader() {
        int i10 = Build.VERSION.SDK_INT;
        if (i10 >= 33) {
            return createImageReader33();
        }
        if (i10 >= 29) {
            return createImageReader29();
        }
        throw new UnsupportedOperationException("ImageReaderPlatformViewRenderTarget requires API version 29+");
    }

    @TargetApi(29)
    private ImageReader createImageReader29() {
        return ImageReader.newInstance(this.requestedWidth, this.requestedHeight, 34, 5, 256L);
    }

    @TargetApi(33)
    private ImageReader createImageReader33() {
        io.flutter.embedding.android.d.k();
        ImageReader.Builder builderC = io.flutter.embedding.android.d.c(this.requestedWidth, this.requestedHeight);
        builderC.setMaxImages(5);
        builderC.setImageFormat(34);
        builderC.setUsage(256L);
        return builderC.build();
    }

    private f getActiveReader() {
        synchronized (this.lock) {
            try {
                if (!this.createNewReader) {
                    return this.imageReaderQueue.peekLast();
                }
                this.createNewReader = false;
                return getOrCreatePerImageReader(createImageReader());
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void lambda$dequeueImage$0() {
        if (this.released) {
            return;
        }
        this.this$0.f28049a.scheduleFrame();
    }

    private void maybeWaitOnFence(Image image) {
        if (image == null || this.ignoringFence) {
            return;
        }
        if (Build.VERSION.SDK_INT >= 33) {
            waitOnFence(image);
        } else {
            this.ignoringFence = true;
        }
    }

    private void releaseInternal() {
        cleanup();
        this.released = true;
        this.this$0.f(this);
        this.this$0.f28054f.remove(this);
    }

    @TargetApi(33)
    private void waitOnFence(Image image) {
        try {
            image.getFence().awaitForever();
        } catch (IOException unused) {
        }
    }

    @Override // io.flutter.view.TextureRegistry$ImageConsumer
    @TargetApi(29)
    public Image acquireLatestImage() {
        d dVarDequeueImage = dequeueImage();
        if (dVarDequeueImage == null) {
            return null;
        }
        Image image = dVarDequeueImage.f28019a;
        maybeWaitOnFence(image);
        return image;
    }

    public double deltaMillis(long j10) {
        return j10 / 1000000.0d;
    }

    public d dequeueImage() {
        d dVar;
        int i10;
        boolean z10;
        synchronized (this.lock) {
            try {
                Iterator<f> it = this.imageReaderQueue.iterator();
                dVar = null;
                while (true) {
                    if (!it.hasNext()) {
                        break;
                    }
                    f next = it.next();
                    ArrayDeque arrayDeque = next.f28023b;
                    d dVar2 = arrayDeque.isEmpty() ? null : (d) arrayDeque.removeFirst();
                    if (dVar2 == null) {
                        dVar = dVar2;
                    } else {
                        d dVar3 = this.lastDequeuedImage;
                        if (dVar3 != null) {
                            dVar3.f28019a.close();
                        }
                        this.lastDequeuedImage = dVar2;
                        this.lastReaderDequeuedFrom = next;
                        dVar = dVar2;
                    }
                }
                pruneImageReaderQueue();
                Iterator<f> it2 = this.imageReaderQueue.iterator();
                while (true) {
                    i10 = 0;
                    if (!it2.hasNext()) {
                        z10 = false;
                        break;
                    }
                    if (!it2.next().f28023b.isEmpty()) {
                        z10 = true;
                        break;
                    }
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        if (z10) {
            this.this$0.f28052d.post(new c(this, i10));
        }
        return dVar;
    }

    @VisibleForTesting
    public void disableFenceForTest() {
        this.ignoringFence = true;
    }

    public void finalize() throws Throwable {
        try {
            if (this.released) {
                return;
            }
            releaseInternal();
            j jVar = this.this$0;
            jVar.f28052d.post(new g6.l(this.f28011id, jVar.f28049a));
        } finally {
            super.finalize();
        }
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public int getHeight() {
        return this.requestedHeight;
    }

    public f getOrCreatePerImageReader(ImageReader imageReader) {
        f fVar = this.perImageReaders.get(imageReader);
        if (fVar != null) {
            return fVar;
        }
        f fVar2 = new f(this, imageReader);
        this.perImageReaders.put(imageReader, fVar2);
        this.imageReaderQueue.add(fVar2);
        return fVar2;
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public Surface getSurface() {
        return getActiveReader().f28022a.getSurface();
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public int getWidth() {
        return this.requestedWidth;
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public boolean handlesCropAndRotation() {
        return false;
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public long id() {
        return this.f28011id;
    }

    @VisibleForTesting
    public int numImageReaders() {
        int size;
        synchronized (this.lock) {
            size = this.imageReaderQueue.size();
        }
        return size;
    }

    @VisibleForTesting
    public int numImages() {
        int size;
        synchronized (this.lock) {
            try {
                Iterator<f> it = this.imageReaderQueue.iterator();
                size = 0;
                while (it.hasNext()) {
                    size += it.next().f28023b.size();
                }
            } catch (Throwable th) {
                throw th;
            }
        }
        return size;
    }

    @VisibleForTesting
    public int numTrims() {
        int i10;
        synchronized (this.lock) {
            i10 = this.numTrims;
        }
        return i10;
    }

    public void onImage(ImageReader imageReader, Image image) {
        d dVar;
        synchronized (this.lock) {
            f orCreatePerImageReader = getOrCreatePerImageReader(imageReader);
            if (orCreatePerImageReader.f28024c) {
                dVar = null;
            } else {
                FlutterRenderer$ImageReaderSurfaceProducer flutterRenderer$ImageReaderSurfaceProducer = orCreatePerImageReader.f28025d;
                System.nanoTime();
                d dVar2 = new d(flutterRenderer$ImageReaderSurfaceProducer, image);
                ArrayDeque arrayDeque = orCreatePerImageReader.f28023b;
                arrayDeque.add(dVar2);
                while (arrayDeque.size() > 2) {
                    ((d) arrayDeque.removeFirst()).f28019a.close();
                }
                dVar = dVar2;
            }
        }
        if (dVar == null) {
            return;
        }
        this.this$0.f28049a.scheduleFrame();
    }

    @Override // io.flutter.view.n
    public void onTrimMemory(int i10) {
        if (i10 < 40) {
            return;
        }
        synchronized (this.lock) {
            this.numTrims++;
        }
        cleanup();
        this.createNewReader = true;
    }

    public void pruneImageReaderQueue() {
        f fVarPeekFirst;
        while (this.imageReaderQueue.size() > 1 && (fVarPeekFirst = this.imageReaderQueue.peekFirst()) != null) {
            ArrayDeque arrayDeque = fVarPeekFirst.f28023b;
            if (!arrayDeque.isEmpty() || fVarPeekFirst.f28025d.lastReaderDequeuedFrom == fVarPeekFirst) {
                return;
            }
            this.imageReaderQueue.removeFirst();
            HashMap<ImageReader, f> map = this.perImageReaders;
            ImageReader imageReader = fVarPeekFirst.f28022a;
            map.remove(imageReader);
            fVarPeekFirst.f28024c = true;
            imageReader.close();
            arrayDeque.clear();
        }
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public void release() {
        if (this.released) {
            return;
        }
        releaseInternal();
        j jVar = this.this$0;
        jVar.f28049a.unregisterTexture(this.f28011id);
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public void scheduleFrame() {
        this.this$0.f28049a.scheduleFrame();
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public void setCallback(o oVar) {
    }

    @Override // io.flutter.view.TextureRegistry$SurfaceProducer
    public void setSize(int i10, int i11) {
        int iMax = Math.max(1, i10);
        int iMax2 = Math.max(1, i11);
        if (this.requestedWidth == iMax && this.requestedHeight == iMax2) {
            return;
        }
        this.createNewReader = true;
        this.requestedHeight = iMax2;
        this.requestedWidth = iMax;
    }
}