package d3;

import a0.C0932r0;
import android.content.Context;
import android.media.MediaExtractor;
import android.media.MediaFormat;
import android.net.Uri;
import androidx.media3.common.Format;
import androidx.media3.common.util.Util;
import androidx.media3.datasource.ByteArrayDataSource;
import androidx.media3.datasource.DataSource;
import androidx.media3.datasource.DataSpec;
import androidx.media3.datasource.DefaultDataSource;
import androidx.media3.datasource.okhttp.OkHttpDataSource;
import androidx.media3.extractor.DefaultExtractorInput;
import androidx.media3.extractor.DefaultExtractorsFactory;
import androidx.media3.extractor.Extractor;
import androidx.media3.extractor.ExtractorInput;
import androidx.media3.extractor.PositionHolder;
import androidx.media3.extractor.ts.TsExtractor;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import x4.AbstractC3251q;
import x4.AbstractC3256v;

/* JADX INFO: loaded from: classes.dex */
public abstract class L {

    /* JADX INFO: renamed from: a, reason: collision with root package name */
    public static final w4.p f15193a = m1.g.k(new C0932r0(23));

    /* JADX INFO: renamed from: b, reason: collision with root package name */
    public static final w4.p f15194b = m1.g.k(new C0932r0(24));

    /* JADX INFO: renamed from: c, reason: collision with root package name */
    public static final byte[] f15195c = new byte[4096];

    public static int a(byte[] bArr, Uri uri) {
        Extractor extractor;
        Extractor[] extractorArrCreateExtractors = new DefaultExtractorsFactory().createExtractors(uri, x4.z.f26066a);
        kotlin.jvm.internal.o.g(extractorArrCreateExtractors, "createExtractors(...)");
        if (bArr.length >= 4 && bArr[0] == 26 && bArr[1] == 69 && bArr[2] == -33 && bArr[3] == -93) {
            int length = extractorArrCreateExtractors.length;
            int i6 = 0;
            while (true) {
                if (i6 >= length) {
                    i6 = -1;
                    break;
                }
                String simpleName = extractorArrCreateExtractors[i6].getClass().getSimpleName();
                if (S4.p.D0(simpleName, "Matroska", true) || S4.p.D0(simpleName, "Webm", true)) {
                    break;
                }
                i6++;
            }
            if (i6 >= 0) {
                Extractor extractor2 = extractorArrCreateExtractors[i6];
                kotlin.jvm.internal.o.g(extractor2, "get(...)");
                if (g(extractor2, bArr, uri)) {
                    return i6;
                }
            }
        }
        if (bArr.length != 0 && bArr[0] == 71) {
            int length2 = extractorArrCreateExtractors.length;
            int i7 = 0;
            while (true) {
                if (i7 >= length2) {
                    i7 = -1;
                    break;
                }
                if (S4.p.D0(extractorArrCreateExtractors[i7].getClass().getSimpleName(), "Ts", true)) {
                    break;
                }
                i7++;
            }
            if (i7 >= 0) {
                Extractor extractor3 = extractorArrCreateExtractors[i7];
                kotlin.jvm.internal.o.g(extractor3, "get(...)");
                if (g(extractor3, bArr, uri)) {
                    return i7;
                }
            }
        }
        if (bArr.length >= 8 && bArr[4] == 102 && bArr[5] == 116 && bArr[6] == 121 && bArr[7] == 112) {
            int length3 = extractorArrCreateExtractors.length;
            int i8 = 0;
            while (true) {
                if (i8 >= length3) {
                    i8 = -1;
                    break;
                }
                String simpleName2 = extractorArrCreateExtractors[i8].getClass().getSimpleName();
                if (S4.p.D0(simpleName2, "Mp4", true) || S4.p.D0(simpleName2, "Fragmented", true)) {
                    break;
                }
                i8++;
            }
            if (i8 >= 0) {
                Extractor extractor4 = extractorArrCreateExtractors[i8];
                kotlin.jvm.internal.o.g(extractor4, "get(...)");
                if (g(extractor4, bArr, uri)) {
                    return i8;
                }
            }
        }
        int length4 = extractorArrCreateExtractors.length;
        for (int i9 = 0; i9 < length4; i9++) {
            try {
                extractor = extractorArrCreateExtractors[i9];
                kotlin.jvm.internal.o.g(extractor, "get(...)");
            } catch (Exception unused) {
            }
            if (g(extractor, bArr, uri)) {
                return i9;
            }
        }
        return -1;
    }

    public static void b(DataSource dataSource) {
        try {
            dataSource.close();
        } catch (IOException unused) {
        }
    }

    public static byte[] c(Context context, Uri uri, int i6) throws IOException {
        String userAgent;
        OkHttpClient okHttpClient = (OkHttpClient) f15194b.getValue();
        try {
            userAgent = Util.getUserAgent(context, "DebridStream");
        } catch (Exception unused) {
            userAgent = "DebridStream/1.0";
        }
        kotlin.jvm.internal.o.e(userAgent);
        int i7 = i6 - 1;
        int i8 = 0;
        if (i7 < 0) {
            i7 = 0;
        }
        Request.Builder builder = new Request.Builder();
        String string = uri.toString();
        kotlin.jvm.internal.o.g(string, "toString(...)");
        builder.i(string);
        builder.e("User-Agent", userAgent);
        builder.e("Accept", "*/*");
        builder.e("Range", "bytes=0-" + i7);
        Response responseD = okHttpClient.a(builder.b()).d();
        try {
            if (!responseD.c() && responseD.f22143d != 206) {
                byte[] bArr = new byte[0];
                responseD.close();
                return bArr;
            }
            byte[] bArr2 = new byte[i6];
            ResponseBody responseBody = responseD.f22146j;
            if (responseBody != null) {
                InputStream inputStreamX = responseBody.c().x();
                while (i8 < i6) {
                    try {
                        int i9 = inputStreamX.read(bArr2, i8, i6 - i8);
                        if (i9 <= 0) {
                            break;
                        }
                        i8 += i9;
                    } finally {
                    }
                }
                inputStreamX.close();
            }
            byte[] bArrCopyOf = Arrays.copyOf(bArr2, i8);
            kotlin.jvm.internal.o.g(bArrCopyOf, "copyOf(...)");
            responseD.close();
            return bArrCopyOf;
        } finally {
        }
    }

    public static J d(Context context, Uri uri, boolean z6) {
        String lowerCase;
        byte[] bArrC;
        Extractor extractor;
        String scheme = uri.getScheme();
        if (scheme != null) {
            lowerCase = scheme.toLowerCase(Locale.ROOT);
            kotlin.jvm.internal.o.g(lowerCase, "toLowerCase(...)");
        } else {
            lowerCase = null;
        }
        boolean zC = kotlin.jvm.internal.o.c(lowerCase, "http");
        x4.z zVar = x4.z.f26066a;
        int i6 = 0;
        if (zC || kotlin.jvm.internal.o.c(lowerCase, "https")) {
            try {
                bArrC = c(context, uri, 98304);
            } catch (Exception unused) {
                bArrC = new byte[0];
            }
            if (bArrC.length == 0) {
                return new J(null, -1.0f);
            }
            int iA = a(bArrC, uri);
            if (iA < 0 && bArrC.length >= 97280) {
                try {
                    bArrC = c(context, uri, 393216);
                } catch (Exception unused2) {
                    bArrC = new byte[0];
                }
                if (bArrC.length != 0) {
                    iA = a(bArrC, uri);
                }
            }
            if (iA < 0) {
                return new J(null, -1.0f);
            }
            C1904m c1904m = new C1904m(bArrC, uri, new OkHttpDataSource.Factory((OkHttpClient) f15193a.getValue()));
            DataSpec dataSpecBuild = new DataSpec.Builder().setUri(uri).setPosition(0L).build();
            kotlin.jvm.internal.o.g(dataSpecBuild, "build(...)");
            c1904m.open(dataSpecBuild);
            DefaultExtractorInput defaultExtractorInput = new DefaultExtractorInput(c1904m, 0L, -1L);
            Extractor extractor2 = new DefaultExtractorsFactory().createExtractors(uri, zVar)[iA];
            kotlin.jvm.internal.o.g(extractor2, "get(...)");
            return e(context, uri, z6, extractor2, defaultExtractorInput, c1904m);
        }
        DefaultDataSource defaultDataSourceCreateDataSource = new DefaultDataSource.Factory(context).createDataSource();
        if (defaultDataSourceCreateDataSource == null) {
            return new J(null, -1.0f);
        }
        DataSpec dataSpecBuild2 = new DataSpec.Builder().setUri(uri).build();
        kotlin.jvm.internal.o.g(dataSpecBuild2, "build(...)");
        try {
            defaultDataSourceCreateDataSource.open(dataSpecBuild2);
            DefaultExtractorInput defaultExtractorInput2 = new DefaultExtractorInput(defaultDataSourceCreateDataSource, dataSpecBuild2.position, dataSpecBuild2.length);
            Extractor[] extractorArrCreateExtractors = new DefaultExtractorsFactory().createExtractors(uri, zVar);
            kotlin.jvm.internal.o.g(extractorArrCreateExtractors, "createExtractors(...)");
            int length = extractorArrCreateExtractors.length;
            while (true) {
                if (i6 >= length) {
                    extractor = null;
                    break;
                }
                Extractor extractor3 = extractorArrCreateExtractors[i6];
                kotlin.jvm.internal.o.e(extractor3);
                if (extractor3.sniff(defaultExtractorInput2)) {
                    extractor = extractor3;
                    break;
                }
                i6++;
            }
            if (extractor != null) {
                return e(context, uri, z6, extractor, defaultExtractorInput2, defaultDataSourceCreateDataSource);
            }
            b(defaultDataSourceCreateDataSource);
            return new J(null, -1.0f);
        } catch (IOException unused3) {
            return new J(null, -1.0f);
        }
    }

    /* JADX WARN: Removed duplicated region for block: B:18:0x003c  */
    /* JADX WARN: Removed duplicated region for block: B:19:0x003e  */
    /* JADX WARN: Removed duplicated region for block: B:21:0x0041 A[Catch: Exception -> 0x0034, all -> 0x005a, TryCatch #3 {all -> 0x005a, blocks: (B:4:0x001c, B:8:0x0026, B:16:0x0038, B:21:0x0041, B:23:0x004c, B:31:0x005d, B:38:0x006a, B:40:0x007e, B:43:0x0099, B:49:0x00a4, B:51:0x00af), top: B:157:0x001c }] */
    /* JADX WARN: Removed duplicated region for block: B:31:0x005d A[Catch: Exception -> 0x0034, all -> 0x005a, TRY_LEAVE, TryCatch #3 {all -> 0x005a, blocks: (B:4:0x001c, B:8:0x0026, B:16:0x0038, B:21:0x0041, B:23:0x004c, B:31:0x005d, B:38:0x006a, B:40:0x007e, B:43:0x0099, B:49:0x00a4, B:51:0x00af), top: B:157:0x001c }] */
    /* JADX WARN: Removed duplicated region for block: B:63:0x00ce  */
    /* JADX WARN: Removed duplicated region for block: B:64:0x00d2  */
    /* JADX WARN: Removed duplicated region for block: B:69:0x00e7  */
    /* JADX WARN: Removed duplicated region for block: B:71:0x00ed  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static J e(Context context, Uri uri, boolean z6, Extractor extractor, DefaultExtractorInput defaultExtractorInput, DataSource dataSource) {
        long j4;
        float f6;
        float f7;
        String lowerCase;
        int i6;
        int i7;
        long j6;
        I i8 = new I();
        extractor.init(i8);
        PositionHolder positionHolder = new PositionHolder();
        ExtractorInput defaultExtractorInput2 = defaultExtractorInput;
        int i9 = 0;
        while (true) {
            int i10 = 1;
            try {
                try {
                    i7 = extractor.read(defaultExtractorInput2, positionHolder);
                } finally {
                    try {
                        extractor.release();
                    } catch (Exception unused) {
                    }
                    b(dataSource);
                }
            } catch (Exception unused2) {
                j4 = 0;
            }
            if (i7 == -1) {
                break;
            }
            if (i7 == 1) {
                if (z6) {
                    if (i8.f15140a != null) {
                        break;
                    }
                    if (i8.f15140a == null) {
                    }
                } else {
                    if (i8.f15140a == null) {
                        j6 = positionHolder.position;
                        if (j6 < 0) {
                            break;
                        }
                        break;
                        break;
                    }
                    Format format = i8.f15140a;
                    kotlin.jvm.internal.o.e(format);
                    if (format.frameRate > 0.0f) {
                        break;
                    }
                    if (i8.f15141b.size() >= 130) {
                        break;
                    }
                    j6 = positionHolder.position;
                    if (j6 < 0 || i9 >= 48) {
                        break;
                    }
                    i9++;
                    try {
                        dataSource.close();
                        j4 = 0;
                        try {
                            dataSource.open(new DataSpec.Builder().setUri(uri).setPosition(j6).setLength(-1L).build());
                            defaultExtractorInput2 = new DefaultExtractorInput(dataSource, j6, -1L);
                        } catch (IOException | Exception unused3) {
                        }
                    } catch (IOException unused4) {
                        j4 = 0;
                    }
                }
                Format format2 = i8.f15140a;
                if (z6) {
                    ArrayList arrayList = i8.f15141b;
                    char c6 = 31;
                    if (format2 != null) {
                        float f8 = format2.frameRate;
                        if (f8 > 0.0f) {
                            f7 = f8;
                            f6 = 1000000.0f;
                        } else if (arrayList.size() < 130) {
                            f6 = 1000000.0f;
                            f7 = -1.0f;
                        } else {
                            List listW0 = AbstractC3251q.w0(arrayList);
                            if (31 < listW0.size()) {
                                int size = listW0.size();
                                long jLongValue = j4;
                                f6 = 1000000.0f;
                                for (int i11 = 31; i11 < size; i11++) {
                                    jLongValue = (((Number) listW0.get(i11)).longValue() - ((Number) listW0.get(i11 - 1)).longValue()) + jLongValue;
                                }
                                int size2 = listW0.size() - 31;
                                if (size2 < 1) {
                                    size2 = 1;
                                }
                                float f9 = jLongValue / size2;
                                if (f9 > 0.0f) {
                                    f7 = f(L4.a.u(1000000.0f / f9, 10.0f, 120.0f), f9);
                                }
                            }
                            f7 = -1.0f;
                        }
                        if (format2 != null && f7 <= 0.0f && i8.f15141b.isEmpty()) {
                            MediaExtractor mediaExtractor = new MediaExtractor();
                            Float fValueOf = null;
                            try {
                                try {
                                    String scheme = uri.getScheme();
                                    if (scheme != null) {
                                        lowerCase = scheme.toLowerCase(Locale.ROOT);
                                        kotlin.jvm.internal.o.g(lowerCase, "toLowerCase(...)");
                                    } else {
                                        lowerCase = null;
                                    }
                                    if (kotlin.jvm.internal.o.c(lowerCase, "http") || kotlin.jvm.internal.o.c(lowerCase, "https")) {
                                        mediaExtractor.setDataSource(uri.toString());
                                    } else {
                                        mediaExtractor.setDataSource(context, uri, (Map<String, String>) null);
                                    }
                                    int trackCount = mediaExtractor.getTrackCount();
                                    i6 = 0;
                                    while (true) {
                                        if (i6 >= trackCount) {
                                            i6 = -1;
                                            break;
                                        }
                                        MediaFormat trackFormat = mediaExtractor.getTrackFormat(i6);
                                        kotlin.jvm.internal.o.g(trackFormat, "getTrackFormat(...)");
                                        String string = trackFormat.getString("mime");
                                        if (string != null && S4.w.A0(string, "video/", false)) {
                                            break;
                                        }
                                        i6++;
                                    }
                                } catch (Exception unused5) {
                                    mediaExtractor.release();
                                }
                            } catch (Exception unused6) {
                            }
                            if (i6 >= 0) {
                                mediaExtractor.selectTrack(i6);
                                ArrayList arrayList2 = new ArrayList(TsExtractor.TS_STREAM_TYPE_HDMV_DTS);
                                while (arrayList2.size() < 130) {
                                    long sampleTime = mediaExtractor.getSampleTime();
                                    if (sampleTime < j4) {
                                        break;
                                    }
                                    arrayList2.add(Long.valueOf(sampleTime));
                                    if (!mediaExtractor.advance()) {
                                        break;
                                    }
                                }
                                mediaExtractor.release();
                                if (arrayList2.size() > 31) {
                                    AbstractC3256v.I(arrayList2);
                                    int size3 = arrayList2.size();
                                    int i12 = 31;
                                    long jLongValue2 = j4;
                                    while (i12 < size3) {
                                        long jLongValue3 = ((Number) arrayList2.get(i12)).longValue();
                                        Object obj = arrayList2.get(i12 - 1);
                                        kotlin.jvm.internal.o.g(obj, "get(...)");
                                        jLongValue2 += jLongValue3 - ((Number) obj).longValue();
                                        i12++;
                                        c6 = c6;
                                    }
                                    int size4 = arrayList2.size() - 31;
                                    if (size4 >= 1) {
                                        i10 = size4;
                                    }
                                    float f10 = jLongValue2 / i10;
                                    fValueOf = f10 <= 0.0f ? null : Float.valueOf(f(L4.a.u(f6 / f10, 10.0f, 120.0f), f10));
                                }
                            }
                            if (fValueOf != null) {
                                float fFloatValue = fValueOf.floatValue();
                                if (10.0f <= fFloatValue && fFloatValue <= 120.0f) {
                                    f7 = fFloatValue;
                                }
                            }
                        }
                    }
                } else {
                    f7 = -1.0f;
                }
                return new J(format2, f7);
            }
            j4 = 0;
            if (i8.f15140a != null) {
                if (!z6) {
                    Format format3 = i8.f15140a;
                    kotlin.jvm.internal.o.e(format3);
                    if (format3.frameRate <= 0.0f) {
                        if (!(i8.f15141b.size() >= 130)) {
                        }
                    }
                }
                Format format22 = i8.f15140a;
                if (z6) {
                }
                return new J(format22, f7);
            }
            continue;
        }
    }

    public static float f(float f6, float f7) {
        if (23.5f <= f6 && f6 <= 24.5f) {
            float fAbs = Math.abs(f7 - 41708.332f);
            float fAbs2 = Math.abs(f7 - 41666.668f);
            float f8 = fAbs <= fAbs2 ? 23.976025f : 24.0f;
            if (Math.min(fAbs, fAbs2) <= 120.0f) {
                return f8;
            }
        }
        return W.c.W(f6);
    }

    public static boolean g(Extractor extractor, byte[] bArr, Uri uri) {
        ByteArrayDataSource byteArrayDataSource = new ByteArrayDataSource(bArr);
        try {
            byteArrayDataSource.open(new DataSpec.Builder().setUri(uri).setPosition(0L).setLength(bArr.length).build());
            boolean zSniff = extractor.sniff(new DefaultExtractorInput(byteArrayDataSource, 0L, bArr.length));
            b(byteArrayDataSource);
            return zSniff;
        } catch (Exception unused) {
            b(byteArrayDataSource);
            return false;
        } catch (Throwable th) {
            b(byteArrayDataSource);
            throw th;
        }
    }
}