package com.ifpdos.player;

import android.content.Context;
import android.net.Uri;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import androidx.media3.common.Format;
import androidx.media3.common.MediaItem;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.Player;
import androidx.media3.common.Timeline;
import androidx.media3.common.TrackSelectionParameters;
import androidx.media3.common.Tracks;
import androidx.media3.common.VideoSize;
import androidx.media3.common.util.UnstableApi;
import androidx.media3.exoplayer.ExoPlayer;
import androidx.media3.exoplayer.RenderersFactory;
import androidx.media3.exoplayer.analytics.AnalyticsListener;
import androidx.media3.exoplayer.mediacodec.MediaCodecSelector;
import androidx.media3.exoplayer.source.DefaultMediaSourceFactory;
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector;
import androidx.media3.exoplayer.trackselection.TrackSelector;
import androidx.media3.extractor.DefaultExtractorsFactory;
import androidx.media3.extractor.ExtractorsFactory;
import androidx.media3.session.MediaSession;
import com.google.common.collect.ImmutableList;
import com.ifpdos.player.Media3Player;
import com.ifpdos.player.base.ListenerRegistrationGate;
import com.ifpdos.player.base.MediaListenerDispatcher;
import com.ifpdos.player.base.MediaMetaDataInfo;
import com.ifpdos.player.base.OnMediaPlayerListener;
import com.ifpdos.player.configure.Codec;
import com.ifpdos.player.configure.MimeConfig;
import java.util.ArrayList;
import java.util.List;
import o1.AbstractC0668d;
import okhttp3.HttpUrl;

/* JADX INFO: loaded from: classes.dex */
@UnstableApi
public final class Media3Player extends BasePlayer {
    public static final Companion Companion = new Companion(null);
    private static final int EXTRA_ILLEGAL_CONTAINED_MIME = 10002;
    private static final int EXTRA_ILLEGAL_SELECTED_MIME = 10001;
    private static final String TAG = "Media3Player";
    private final Context context;
    private final io.github.anilbeesetti.nextlib.media3ext.ffdecoder.b factory;
    private boolean isEnd;
    private boolean isReady;
    private boolean isSeeking;
    private boolean isStartPreparing;
    private boolean isUsedFFmpeg;
    private final ListenerRegistrationGate listenerRegistrationGate;
    private Uri mFileDescriptor;
    private final Handler mHandler;
    private final HandlerThread mHandlerThread;
    private final MediaListenerDispatcher mListenerDispatcher;
    private MediaSession mMediaSession;
    private final ExoPlayer mPlayer;
    private final Handler mTHandler;
    private final DefaultTrackSelector mTrackerSelector;
    private final MimeConfig mimeConfig;
    private final IPlayerConfigure playerConfigure;
    private final Media3RenderingStartDispatcher renderingStartDispatcher;
    private int retryCount;

    public static final class Companion {
        public /* synthetic */ Companion(kotlin.jvm.internal.g gVar) {
            this();
        }

        private Companion() {
        }
    }

    private static final class MediaSessionManager {
        public static final MediaSessionManager INSTANCE = new MediaSessionManager();
        private static Player currentPlayer;
        private static MediaSession session;

        private MediaSessionManager() {
        }

        public final synchronized MediaSession getOrCreateSession(Context context, Player player) {
            MediaSession mediaSessionBuild;
            try {
                kotlin.jvm.internal.l.e(context, "context");
                kotlin.jvm.internal.l.e(player, "player");
                if (session == null || !kotlin.jvm.internal.l.a(currentPlayer, player)) {
                    MediaSession mediaSession = session;
                    if (mediaSession != null) {
                        mediaSession.release();
                    }
                    currentPlayer = player;
                    mediaSessionBuild = new MediaSession.Builder(context, player).build();
                    session = mediaSessionBuild;
                    kotlin.jvm.internal.l.b(mediaSessionBuild);
                } else {
                    mediaSessionBuild = session;
                    kotlin.jvm.internal.l.b(mediaSessionBuild);
                }
            } catch (Throwable th) {
                throw th;
            }
            return mediaSessionBuild;
        }

        public final synchronized void release() {
            try {
                MediaSession mediaSession = session;
                if (mediaSession != null) {
                    mediaSession.release();
                }
                session = null;
                currentPlayer = null;
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    /* JADX INFO: renamed from: com.ifpdos.player.Media3Player$registerPlayerListeners$1, reason: invalid class name */
    public static final class AnonymousClass1 implements Player.Listener {
        AnonymousClass1() {
        }

        private final void checkAACCodecNameAsync(final Tracks tracks, final Uri uri) {
            Handler handler = Media3Player.this.mTHandler;
            final Media3Player media3Player = Media3Player.this;
            handler.post(new Runnable() { // from class: com.ifpdos.player.p
                @Override // java.lang.Runnable
                public final void run() {
                    Media3Player.AnonymousClass1.checkAACCodecNameAsync$lambda$8(uri, media3Player, tracks, this);
                }
            });
        }

        /* JADX INFO: Access modifiers changed from: private */
        /* JADX WARN: Removed duplicated region for block: B:30:0x00f8  */
        /*
            Code decompiled incorrectly, please refer to instructions dump.
            To view partially-correct add '--show-bad-code' argument
        */
        public static final void checkAACCodecNameAsync$lambda$8(android.net.Uri r10, final com.ifpdos.player.Media3Player r11, final androidx.media3.common.Tracks r12, final com.ifpdos.player.Media3Player.AnonymousClass1 r13) {
            /*
                Method dump skipped, instruction units count: 332
                To view this dump add '--comments-level debug' option
            */
            throw new UnsupportedOperationException("Method not decompiled: com.ifpdos.player.Media3Player.AnonymousClass1.checkAACCodecNameAsync$lambda$8(android.net.Uri, com.ifpdos.player.Media3Player, androidx.media3.common.Tracks, com.ifpdos.player.Media3Player$registerPlayerListeners$1):void");
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void checkAACCodecNameAsync$lambda$8$lambda$6$lambda$5(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mPlayer.setTrackSelectionParameters(this$0.mPlayer.getTrackSelectionParameters().buildUpon().setTrackTypeDisabled(1, true).build());
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void checkAACCodecNameAsync$lambda$8$lambda$7(AnonymousClass1 this$0, Tracks tracks, kotlin.jvm.internal.s containVideo) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            kotlin.jvm.internal.l.e(tracks, "$tracks");
            kotlin.jvm.internal.l.e(containVideo, "$containVideo");
            this$0.onContainDisabledAudioMeme(tracks, containVideo.f5100b);
        }

        private final void onContainDisabledAudioMeme(Tracks tracks, boolean z2) {
            ImmutableList groups = tracks.getGroups();
            kotlin.jvm.internal.l.d(groups, "getGroups(...)");
            int size = groups.size();
            boolean z3 = false;
            int i2 = 0;
            while (true) {
                if (i2 >= size) {
                    break;
                }
                Tracks.Group group = (Tracks.Group) groups.get(i2);
                if (group.getType() == 1 && group.isSelected()) {
                    z3 = true;
                    break;
                }
                i2++;
            }
            Log.d(Media3Player.TAG, "onContainDisabledAudioMeme: " + z3);
            if (z3) {
                return;
            }
            if (z2) {
                Handler handler = Media3Player.this.mHandler;
                final Media3Player media3Player = Media3Player.this;
                handler.post(new Runnable() { // from class: com.ifpdos.player.w
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onContainDisabledAudioMeme$lambda$2(media3Player);
                    }
                });
            } else {
                safeStop();
                Handler handler2 = Media3Player.this.mHandler;
                final Media3Player media3Player2 = Media3Player.this;
                handler2.post(new Runnable() { // from class: com.ifpdos.player.x
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onContainDisabledAudioMeme$lambda$3(media3Player2);
                    }
                });
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onContainDisabledAudioMeme$lambda$2(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onInfo(-5001, 1);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onContainDisabledAudioMeme$lambda$3(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onError(1, 1);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onPlaybackStateChanged$lambda$10(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onComplete();
            this$0.mListenerDispatcher.onBuffing(false);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onPlaybackStateChanged$lambda$11(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onBuffing(false);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onPlaybackStateChanged$lambda$12(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onBuffing(true);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onPlaybackStateChanged$lambda$9(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onBuffing(false);
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onTracksChanged$lambda$1(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.mListenerDispatcher.onError(BasePlayer.ERROR_FALLBACK_TO_PLATFORM_PLAYER, 1);
        }

        private final void safeStop() {
            try {
                Media3Player.this.mPlayer.stop();
            } catch (Throwable th) {
                Log.e(Media3Player.TAG, "safeStop: ", th);
            }
        }

        public void onEvents(Player player, Player.Events events) {
            kotlin.jvm.internal.l.e(player, "player");
            kotlin.jvm.internal.l.e(events, "events");
            super.onEvents(player, events);
            if (events.containsAny(new int[]{11, 0, 13})) {
                androidx.media3.common.util.Log.d(Media3Player.TAG, "updateTimeline: " + events);
                if (Media3Player.this.getDurationLong() == -9223372036854775807L) {
                    androidx.media3.common.util.Log.d(Media3Player.TAG, "updateTimeline: duration is unset");
                    return;
                }
                Media3Player.this.isEnd = false;
                if (Media3Player.this.isStartPreparing && !Media3Player.this.mPlayer.isReleased() && Media3Player.this.isReady) {
                    Media3Player.this.isStartPreparing = false;
                    Media3Player.this.retryCount = 0;
                    Media3Player.this.mListenerDispatcher.onPrepare();
                }
            }
        }

        public void onIsPlayingChanged(boolean z2) {
            super.onIsPlayingChanged(z2);
            Media3Player.this.mListenerDispatcher.onPlayingChanged(z2, Media3Player.this.isSeeking);
        }

        public void onPlaybackStateChanged(int i2) {
            super.onPlaybackStateChanged(i2);
            if (i2 == 1) {
                androidx.media3.common.util.Log.d(Media3Player.TAG, "onPlaybackStateChanged: STATE_IDLE");
                Handler handler = Media3Player.this.mHandler;
                final Media3Player media3Player = Media3Player.this;
                handler.post(new Runnable() { // from class: com.ifpdos.player.s
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onPlaybackStateChanged$lambda$11(media3Player);
                    }
                });
                return;
            }
            if (i2 == 2) {
                androidx.media3.common.util.Log.d(Media3Player.TAG, "onPlaybackStateChanged: STATE_BUFFERING");
                Handler handler2 = Media3Player.this.mHandler;
                final Media3Player media3Player2 = Media3Player.this;
                handler2.post(new Runnable() { // from class: com.ifpdos.player.t
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onPlaybackStateChanged$lambda$12(media3Player2);
                    }
                });
                return;
            }
            if (i2 != 3) {
                if (i2 != 4) {
                    return;
                }
                androidx.media3.common.util.Log.d(Media3Player.TAG, "onPlaybackStateChanged: STATE_ENDED");
                Media3Player.this.isEnd = true;
                Handler handler3 = Media3Player.this.mHandler;
                final Media3Player media3Player3 = Media3Player.this;
                handler3.post(new Runnable() { // from class: com.ifpdos.player.r
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onPlaybackStateChanged$lambda$10(media3Player3);
                    }
                });
                return;
            }
            androidx.media3.common.util.Log.d(Media3Player.TAG, "onPlaybackStateChanged: STATE_READY " + Media3Player.this.isStartPreparing + " ," + Media3Player.this.getDurationLong());
            Media3Player.this.isReady = true;
            if (Media3Player.this.isStartPreparing && Media3Player.this.getDurationLong() != -9223372036854775807L) {
                Media3Player.this.isStartPreparing = false;
                Media3Player.this.mListenerDispatcher.onPrepare();
            }
            if (Media3Player.this.isSeeking) {
                Media3Player.this.isSeeking = false;
                Media3Player.this.mListenerDispatcher.onSeekComplete();
            }
            Handler handler4 = Media3Player.this.mHandler;
            final Media3Player media3Player4 = Media3Player.this;
            handler4.post(new Runnable() { // from class: com.ifpdos.player.q
                @Override // java.lang.Runnable
                public final void run() {
                    Media3Player.AnonymousClass1.onPlaybackStateChanged$lambda$9(media3Player4);
                }
            });
        }

        public void onPlayerError(PlaybackException error) {
            kotlin.jvm.internal.l.e(error, "error");
            super.onPlayerError(error);
            Log.w(Media3Player.TAG, "onPlayerError(" + error.errorCode + "): ", (Throwable) error);
            Media3Player.this.isStartPreparing = false;
            if (error.errorCode == 2008) {
                Media3Player.this.mListenerDispatcher.onError(BasePlayer.ERROR_FALLBACK_TO_PLATFORM_PLAYER, error.errorCode);
                return;
            }
            if (error.errorCode == 1004 && Media3Player.this.mTrackerSelector.getParameters().tunnelingEnabled && Media3Player.this.retryCount < 2) {
                Log.w(Media3Player.TAG, "onPlayerError: " + error.errorCode + ", retry to play . isReady: " + Media3Player.this.isReady + ", isStartPreparing: " + Media3Player.this.isStartPreparing);
                Media3Player media3Player = Media3Player.this;
                media3Player.retryCount = media3Player.retryCount + 1;
                if (Media3Player.this.isReady) {
                    Media3Player.this.start();
                    return;
                } else {
                    Media3Player.this.prepare();
                    return;
                }
            }
            if (error.errorCode != 4003 || !Media3Player.this.mTrackerSelector.getParameters().tunnelingEnabled || Media3Player.this.retryCount >= 2) {
                Media3Player.this.mListenerDispatcher.onError(error.errorCode, error.errorCode);
                return;
            }
            Media3Player.this.mTrackerSelector.setParameters(Media3Player.this.mTrackerSelector.getParameters().buildUpon().setTunnelingEnabled(false).build());
            Log.w(Media3Player.TAG, "onPlayerError: " + error.errorCode + ", retry to play . isReady: " + Media3Player.this.isReady + ", isStartPreparing: " + Media3Player.this.isStartPreparing);
            Media3Player media3Player2 = Media3Player.this;
            media3Player2.retryCount = media3Player2.retryCount + 1;
            Media3Player.this.reset();
            Media3Player.this.prepare();
        }

        public void onTrackSelectionParametersChanged(TrackSelectionParameters parameters) {
            kotlin.jvm.internal.l.e(parameters, "parameters");
            super.onTrackSelectionParametersChanged(parameters);
            androidx.media3.common.util.Log.d(Media3Player.TAG, "onTrackSelectionParametersChanged: " + parameters);
        }

        public void onTracksChanged(Tracks tracks) {
            String str;
            kotlin.jvm.internal.l.e(tracks, "tracks");
            super.onTracksChanged(tracks);
            ImmutableList groups = tracks.getGroups();
            kotlin.jvm.internal.l.d(groups, "getGroups(...)");
            ArrayList arrayList = new ArrayList();
            int size = groups.size();
            boolean z2 = false;
            boolean z3 = false;
            boolean z4 = false;
            for (int i2 = 0; i2 < size; i2++) {
                Tracks.Group group = (Tracks.Group) groups.get(i2);
                int i3 = group.length;
                int i4 = 0;
                while (i4 < i3) {
                    Format trackFormat = group.getTrackFormat(i4);
                    kotlin.jvm.internal.l.d(trackFormat, "getTrackFormat(...)");
                    androidx.media3.common.util.Log.d(Media3Player.TAG, "onTracksChanged: " + trackFormat);
                    String str2 = trackFormat.sampleMimeType;
                    if (str2 != null) {
                        arrayList.add(str2);
                    }
                    String str3 = trackFormat.sampleMimeType;
                    ImmutableList immutableList = groups;
                    int i5 = size;
                    boolean z5 = z2;
                    boolean z6 = z3;
                    if (str3 != null && E1.g.y(str3, "audio", false, 2, null)) {
                        z5 = true;
                    }
                    String str4 = trackFormat.sampleMimeType;
                    Tracks.Group group2 = group;
                    z3 = (str4 == null || !E1.g.y(str4, "video", false, 2, null)) ? z6 : true;
                    if (AbstractC0668d.n(Media3Player.this.mimeConfig.getIllegalContainMimes(), trackFormat.sampleMimeType)) {
                        safeStop();
                        Media3Player.this.mListenerDispatcher.onError(1, 10002);
                    } else if (AbstractC0668d.n(Media3Player.this.mimeConfig.getDisableTracksMimes(), trackFormat.sampleMimeType)) {
                        if (!z4 && (str = trackFormat.sampleMimeType) != null && E1.g.y(str, "audio", false, 2, null)) {
                            z4 = true;
                        }
                        Log.d(Media3Player.TAG, "onTracksChanged: containDisabledAudioMime=" + z4);
                        Media3Player.this.mPlayer.setTrackSelectionParameters(Media3Player.this.mPlayer.getTrackSelectionParameters().buildUpon().setTrackTypeDisabled(1, true).build());
                    }
                    if (!(Media3Player.this.mimeConfig.getIllegalCodecNames().length == 0)) {
                        String[] illegalCodecNames = Media3Player.this.mimeConfig.getIllegalCodecNames();
                        Codec codec = Codec.INSTANCE;
                        if (AbstractC0668d.n(illegalCodecNames, codec.getCODEC_AAC_LC()) || AbstractC0668d.n(Media3Player.this.mimeConfig.getIllegalCodecNames(), codec.getCODEC_AAC_HE_V1()) || AbstractC0668d.n(Media3Player.this.mimeConfig.getIllegalCodecNames(), codec.getCODEC_AAC_LD()) || AbstractC0668d.n(Media3Player.this.mimeConfig.getIllegalCodecNames(), codec.getCODEC_AAC_HE_V2())) {
                            checkAACCodecNameAsync(tracks, Media3Player.this.mFileDescriptor);
                        }
                        if (AbstractC0668d.n(Media3Player.this.mimeConfig.getIllegalCodecNames(), trackFormat.codecs)) {
                            Log.w(Media3Player.TAG, "onTracksChanged: unsupported codecs=" + trackFormat.codecs);
                            Media3Player.this.mPlayer.setTrackSelectionParameters(Media3Player.this.mPlayer.getTrackSelectionParameters().buildUpon().setTrackTypeDisabled(1, true).build());
                            z4 = true;
                        }
                    }
                    String str5 = trackFormat.sampleMimeType;
                    if (str5 != null && str5.hashCode() == -53558318 && str5.equals("audio/mp4a-latm") && trackFormat.channelCount > 2) {
                        Media3Player.this.mTrackerSelector.setParameters(Media3Player.this.mTrackerSelector.getParameters().buildUpon().setTunnelingEnabled(false).build());
                    }
                    i4++;
                    groups = immutableList;
                    size = i5;
                    z2 = z5;
                    group = group2;
                }
            }
            if (!Media3Player.this.playerConfigure.switchToPlatformOnTracksChange(z2, z3, Media3Player.this.mTrackerSelector.getParameters().tunnelingEnabled, arrayList)) {
                if (z4) {
                    onContainDisabledAudioMeme(tracks, z3);
                }
            } else {
                safeStop();
                Handler handler = Media3Player.this.mHandler;
                final Media3Player media3Player = Media3Player.this;
                handler.post(new Runnable() { // from class: com.ifpdos.player.o
                    @Override // java.lang.Runnable
                    public final void run() {
                        Media3Player.AnonymousClass1.onTracksChanged$lambda$1(media3Player);
                    }
                });
            }
        }

        public void onVideoSizeChanged(VideoSize videoSize) {
            kotlin.jvm.internal.l.e(videoSize, "videoSize");
            super.onVideoSizeChanged(videoSize);
            Log.d(Media3Player.TAG, "onVideoSizeChanged: " + videoSize.width + "x" + videoSize.height);
            Media3Player.this.mListenerDispatcher.onVideoSizeChange();
        }
    }

    /* JADX INFO: renamed from: com.ifpdos.player.Media3Player$registerPlayerListeners$2, reason: invalid class name */
    public static final class AnonymousClass2 implements AnalyticsListener {
        AnonymousClass2() {
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static final void onRenderedFirstFrame$lambda$0(Media3Player this$0) {
            kotlin.jvm.internal.l.e(this$0, "this$0");
            this$0.renderingStartDispatcher.onRenderedFirstFrame();
        }

        public void onRenderedFirstFrame(AnalyticsListener.EventTime eventTime, Object output, long j2) {
            kotlin.jvm.internal.l.e(eventTime, "eventTime");
            kotlin.jvm.internal.l.e(output, "output");
            super.onRenderedFirstFrame(eventTime, output, j2);
            Log.d(Media3Player.TAG, "onRenderedFirstFrame");
            Handler handler = Media3Player.this.mHandler;
            final Media3Player media3Player = Media3Player.this;
            handler.post(new Runnable() { // from class: com.ifpdos.player.y
                @Override // java.lang.Runnable
                public final void run() {
                    Media3Player.AnonymousClass2.onRenderedFirstFrame$lambda$0(media3Player);
                }
            });
        }

        public void onVideoDecoderInitialized(AnalyticsListener.EventTime eventTime, String decoderName, long j2, long j3) {
            kotlin.jvm.internal.l.e(eventTime, "eventTime");
            kotlin.jvm.internal.l.e(decoderName, "decoderName");
            super.onVideoDecoderInitialized(eventTime, decoderName, j2, j3);
            Log.d(Media3Player.TAG, "onVideoDecoderInitialized: " + decoderName);
            if (E1.g.w(decoderName, "ffmpeg", true)) {
                Media3Player.this.isUsedFFmpeg = true;
            }
        }
    }

    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
    public Media3Player(Context context, IPlayerConfigure playerConfigure, MimeConfig mimeConfig) {
        super(context);
        kotlin.jvm.internal.l.e(context, "context");
        kotlin.jvm.internal.l.e(playerConfigure, "playerConfigure");
        kotlin.jvm.internal.l.e(mimeConfig, "mimeConfig");
        this.context = context;
        this.playerConfigure = playerConfigure;
        this.mimeConfig = mimeConfig;
        this.renderingStartDispatcher = new Media3RenderingStartDispatcher(new Media3Player$renderingStartDispatcher$1(this));
        this.mListenerDispatcher = new MediaListenerDispatcher();
        this.mHandler = new Handler(Looper.getMainLooper());
        HandlerThread handlerThread = new HandlerThread("media3-player-thread");
        handlerThread.start();
        this.mHandlerThread = handlerThread;
        this.mTHandler = new Handler(handlerThread.getLooper());
        this.listenerRegistrationGate = new ListenerRegistrationGate(new Media3Player$listenerRegistrationGate$1(this));
        RenderersFactory bVar = new io.github.anilbeesetti.nextlib.media3ext.ffdecoder.b(context);
        bVar.setExtensionRendererMode(1);
        bVar.setMediaCodecSelector(new MediaCodecSelector() { // from class: com.ifpdos.player.n
        });
        this.factory = bVar;
        TrackSelector defaultTrackSelector = new DefaultTrackSelector(context);
        this.mTrackerSelector = defaultTrackSelector;
        ExoPlayer.Builder trackSelector = new ExoPlayer.Builder(context, bVar).setTrackSelector(defaultTrackSelector);
        ExtractorsFactory defaultExtractorsFactory = new DefaultExtractorsFactory();
        defaultExtractorsFactory.setTsExtractorMode(0);
        defaultExtractorsFactory.setTsSupportDvhs(true);
        defaultExtractorsFactory.setTsExtractorTimestampSearchBytes(20971520);
        defaultExtractorsFactory.setTsEnablePTSDuration(true);
        defaultExtractorsFactory.setConstantBitrateSeekingEnabled(true);
        defaultExtractorsFactory.setMp4ExtractorFlags(256);
        defaultExtractorsFactory.setFragmentedMp4ExtractorFlags(512);
        defaultExtractorsFactory.setMp3ExtractorFlags(16);
        n1.s sVar = n1.s.f5871a;
        Player playerBuild = trackSelector.setMediaSourceFactory(new DefaultMediaSourceFactory(context, defaultExtractorsFactory)).build();
        kotlin.jvm.internal.l.d(playerBuild, "build(...)");
        this.mPlayer = playerBuild;
        defaultTrackSelector.setParameters(defaultTrackSelector.getParameters().buildUpon().setTunnelingEnabled(playerConfigure.isTunnelingEnable(context)).build());
        this.mMediaSession = MediaSessionManager.INSTANCE.getOrCreateSession(context, playerBuild);
    }

    private static final List factory$lambda$5$lambda$4(final Media3Player this$0, String mimeType, boolean z2, boolean z3) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        kotlin.jvm.internal.l.e(mimeType, "mimeType");
        androidx.media3.common.util.Log.d(TAG, "getDecoderInfos, mimeType: " + mimeType + ", requiresSecureDecoder: " + z2 + ", requiresTunnelingDecoder: " + z3);
        for (String str : this$0.mimeConfig.getIllegalSelectMimes()) {
            if (kotlin.jvm.internal.l.a(mimeType, str)) {
                throw new IllegalStateException("Illegal mime type: " + mimeType);
            }
        }
        if (this$0.switchToPlatformPlayer(mimeType)) {
            this$0.mHandler.post(new Runnable() { // from class: com.ifpdos.player.l
                @Override // java.lang.Runnable
                public final void run() {
                    Media3Player.factory$lambda$5$lambda$4$lambda$2(this.f3192b);
                }
            });
            return new ArrayList();
        }
        if (!this$0.playerConfigure.switchToMediaPlayer(mimeType)) {
            return MediaCodecSelector.DEFAULT.getDecoderInfos(mimeType, z2, z3);
        }
        this$0.mHandler.post(new Runnable() { // from class: com.ifpdos.player.m
            @Override // java.lang.Runnable
            public final void run() {
                Media3Player.factory$lambda$5$lambda$4$lambda$3(this.f3193b);
            }
        });
        return new ArrayList();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void factory$lambda$5$lambda$4$lambda$2(Media3Player this$0) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        this$0.mListenerDispatcher.onError(BasePlayer.ERROR_FALLBACK_TO_PLATFORM_PLAYER, 1);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static final void factory$lambda$5$lambda$4$lambda$3(Media3Player this$0) {
        kotlin.jvm.internal.l.e(this$0, "this$0");
        this$0.mListenerDispatcher.onError(BasePlayer.ERROR_FALLBACK_TO_MEDIA_PLAYER, 1);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final long getDurationLong() {
        Timeline currentTimeline = this.mPlayer.isCommandAvailable(17) ? this.mPlayer.getCurrentTimeline() : Timeline.EMPTY;
        kotlin.jvm.internal.l.b(currentTimeline);
        if (currentTimeline.isEmpty()) {
            return this.mPlayer.getContentDuration();
        }
        int currentMediaItemIndex = this.mPlayer.getCurrentMediaItemIndex();
        Timeline.Window window = new Timeline.Window();
        currentTimeline.getWindow(currentMediaItemIndex, window);
        return window.getDurationMs();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final void registerPlayerListeners() {
        this.mPlayer.addListener(new AnonymousClass1());
        this.mPlayer.addAnalyticsListener(new AnonymousClass2());
    }

    private final boolean switchToPlatformPlayer(String str) {
        return this.playerConfigure.switchToPlatformPlayer(str);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void addMediaListener(OnMediaPlayerListener onMediaPlayerListener) {
        kotlin.jvm.internal.l.e(onMediaPlayerListener, "onMediaPlayerListener");
        this.mListenerDispatcher.add(onMediaPlayerListener);
        onMediaPlayerListener.onPlayerKernelChanged(getPlayerKernel());
        this.listenerRegistrationGate.ensureRegistered();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getCurrentPosition() {
        return (int) this.mPlayer.getCurrentPosition();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getDuration() {
        return (int) getDurationLong();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public MediaMetaDataInfo getMetaDataInfo() {
        String str;
        Format videoFormat = this.mPlayer.getVideoFormat();
        if (videoFormat == null || (str = videoFormat.codecs) == null) {
            str = HttpUrl.FRAGMENT_ENCODE_SET;
        }
        return new MediaMetaDataInfo(str);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getVideoHeight() {
        return this.mPlayer.getVideoSize().height;
    }

    @Override // com.ifpdos.player.base.IPlayer
    public int getVideoWidth() {
        return this.mPlayer.getVideoSize().width;
    }

    @Override // com.ifpdos.player.base.IPlayer
    public boolean isPlaying() {
        return this.mPlayer.isPlaying() || this.mPlayer.getPlaybackState() == 2;
    }

    public final boolean isUsedFFmpeg() {
        return this.isUsedFFmpeg;
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void pause() {
        this.mPlayer.pause();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void prepare() {
        this.isReady = false;
        this.isStartPreparing = true;
        this.renderingStartDispatcher.reset();
        Log.d(TAG, "prepare: ");
        if (this.isUsedFFmpeg) {
            this.isUsedFFmpeg = false;
            this.mListenerDispatcher.onError(BasePlayer.ERROR_NEED_TO_RECREATE_SURFACE, -1);
        }
        this.mPlayer.prepare();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void release() {
        Log.d(TAG, "release: ");
        this.mPlayer.clearVideoSurface();
        this.mPlayer.release();
        MediaSessionManager.INSTANCE.release();
        this.mHandler.removeCallbacksAndMessages(null);
        this.mTHandler.removeCallbacksAndMessages(null);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void removeMediaListener(OnMediaPlayerListener onMediaPlayerListener) {
        kotlin.jvm.internal.l.e(onMediaPlayerListener, "onMediaPlayerListener");
        this.mListenerDispatcher.remove(onMediaPlayerListener);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void reset() {
        this.renderingStartDispatcher.reset();
        this.mPlayer.stop();
        ExoPlayer exoPlayer = this.mPlayer;
        exoPlayer.setTrackSelectionParameters(exoPlayer.getTrackSelectionParameters().buildUpon().setTrackTypeDisabled(1, false).build());
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void seekTo(int i2) {
        this.isSeeking = true;
        this.mPlayer.seekTo(i2);
    }

    @Override // com.ifpdos.player.BasePlayer, com.ifpdos.player.base.IPlayer
    public void setDataSource(Uri fileDescriptor) {
        kotlin.jvm.internal.l.e(fileDescriptor, "fileDescriptor");
        super.setDataSource(fileDescriptor);
        this.mFileDescriptor = fileDescriptor;
        this.mPlayer.setMediaItem(MediaItem.fromUri(fileDescriptor));
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void setDisplay(SurfaceHolder surface) {
        kotlin.jvm.internal.l.e(surface, "surface");
        this.mPlayer.setVideoSurfaceHolder(surface);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void setSurface(Surface surface) {
        kotlin.jvm.internal.l.e(surface, "surface");
        this.mPlayer.setVideoSurface(surface);
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void start() {
        if (this.isEnd) {
            this.mPlayer.seekTo(0L);
        }
        this.mPlayer.play();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void stop() {
        this.mPlayer.stop();
    }

    @Override // com.ifpdos.player.base.IPlayer
    public void seekTo(int i2, boolean z2) {
        this.isSeeking = true;
        this.mPlayer.seekTo(i2);
    }
}