package tv.danmaku.ijk.media.player.ui;

import android.annotation.SuppressLint;
import android.content.Context;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.view.Surface;
import android.view.SurfaceHolder;
import androidx.annotation.NonNull;
import androidx.annotation.Size;
import androidx.media3.common.C;
import androidx.media3.common.Format;
import androidx.media3.common.MediaItem;
import androidx.media3.common.Metadata;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.PlaybackException;
import androidx.media3.common.PlaybackParameters;
import androidx.media3.common.Player;
import androidx.media3.common.TrackGroup;
import androidx.media3.common.TrackSelectionOverride;
import androidx.media3.common.Tracks;
import androidx.media3.common.VideoSize;
import androidx.media3.common.text.Cue;
import androidx.media3.common.text.CueGroup;
import androidx.media3.common.util.Assertions;
import androidx.media3.datasource.DataSource;
import androidx.media3.datasource.DefaultDataSource;
import androidx.media3.datasource.DefaultHttpDataSource;
import androidx.media3.datasource.okhttp.OkHttpDataSource;
import androidx.media3.exoplayer.DecoderCounters;
import androidx.media3.exoplayer.DefaultLivePlaybackSpeedControl;
import androidx.media3.exoplayer.DefaultLoadControl;
import androidx.media3.exoplayer.DefaultRenderersFactory;
import androidx.media3.exoplayer.ExoPlayer;
import androidx.media3.exoplayer.LoadControl;
import androidx.media3.exoplayer.SeekParameters;
import androidx.media3.exoplayer.analytics.AnalyticsListener;
import androidx.media3.exoplayer.dash.DashMediaSource;
import androidx.media3.exoplayer.hls.HlsMediaSource;
import androidx.media3.exoplayer.rtsp.RtspMediaSource;
import androidx.media3.exoplayer.source.LoadEventInfo;
import androidx.media3.exoplayer.source.MediaLoadData;
import androidx.media3.exoplayer.source.MediaSource;
import androidx.media3.exoplayer.source.ProgressiveMediaSource;
import androidx.media3.exoplayer.source.TrackGroupArray;
import androidx.media3.exoplayer.trackselection.AdaptiveTrackSelection;
import androidx.media3.exoplayer.trackselection.DefaultTrackSelector;
import androidx.media3.exoplayer.trackselection.MappingTrackSelector;
import androidx.media3.exoplayer.upstream.BandwidthMeter;
import androidx.media3.exoplayer.upstream.DefaultAllocator;
import androidx.media3.exoplayer.upstream.DefaultBandwidthMeter;
import androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy;
import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy;
import androidx.media3.exoplayer.util.SntpClient;
import com.google.common.collect.ImmutableList;
import com.pichillilorenzo.flutter_inappwebview_android.credential_database.URLProtectionSpaceContract;
import java.io.FileDescriptor;
import java.io.IOException;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import tv.danmaku.ijk.media.player.AbstractMediaPlayer;
import tv.danmaku.ijk.media.player.IMediaPlayer;
import tv.danmaku.ijk.media.player.misc.ExoTrackInfo;
import tv.danmaku.ijk.media.player.misc.ITrackInfo;

/* JADX INFO: loaded from: classes3.dex */
@SuppressLint({"UnsafeOptInUsageError"})
public class ExoPlaybackMediaPlayer extends AbstractMediaPlayer implements Player.Listener, AnalyticsListener, BandwidthMeter.EventListener {
    public static int ON_POSITION_DISCOUNTINUITY = 2702;
    private ImmutableList<Tracks.Group> allGroups;
    private String channelId;
    private DefaultBandwidthMeter defaultBandwidthMeter;
    protected boolean isLastReportedPlayWhenReady;
    protected Context mAppContext;
    protected String mDataSource;
    protected LoadControl mLoadControl;
    protected MediaSource mMediaSource;
    protected ExoPlayer mPlayer;
    protected DefaultRenderersFactory mRendererFactory;
    protected PlaybackParameters mSpeedPlaybackParameters;
    protected Surface mSurface;
    protected DefaultTrackSelector mTrackSelector;
    protected int mVideoHeight;
    protected int mVideoWidth;
    protected MediaItem mediaItem;
    private PrepareRunnable prepareRunnable;
    private String segmentFile;
    private ITrackInfo selectedVideoTrackInfo;
    protected Map<String, String> mHeaders = new HashMap();
    protected boolean isPreparing = true;
    protected boolean isBuffering = false;
    protected boolean isLooping = false;
    private int selectedAudioTrack = -1;
    private int selectedAudioGroupTrack = -1;
    private int selectedSubtitleTrack = -1;
    private int selectedSubtitleGroupTrack = -1;
    private int selectedVideoTrack = 0;
    private int selectedVideoGroupTrack = 0;
    List<ITrackInfo> trackInfoList = new ArrayList();
    protected boolean isCache = false;
    protected int audioSessionId = 0;
    private boolean isRemote = true;
    private boolean hasLoadedData = false;
    private boolean isSportsChannel = false;
    private final Handler mainHandler = new Handler(Looper.getMainLooper());
    private final Handler bufferHandler = new Handler(Looper.getMainLooper());
    private final Runnable bufferRunnable = new Runnable() { // from class: tv.danmaku.ijk.media.player.ui.ExoPlaybackMediaPlayer.3
        @Override // java.lang.Runnable
        public void run() {
            ExoPlayer exoPlayer = ExoPlaybackMediaPlayer.this.mPlayer;
            if (exoPlayer != null && exoPlayer.getPlaybackState() == 3) {
                Format videoFormat = ExoPlaybackMediaPlayer.this.getVideoFormat();
                if (videoFormat != null && !ExoPlaybackMediaPlayer.this.hasLoadedData && ExoPlaybackMediaPlayer.this.segmentFile != null) {
                    ExoPlaybackMediaPlayer.this.hasLoadedData = true;
                    ExoPlaybackMediaPlayer exoPlaybackMediaPlayer = ExoPlaybackMediaPlayer.this;
                    exoPlaybackMediaPlayer.notifyLoadedData(exoPlaybackMediaPlayer.segmentFile, videoFormat.bitrate, (int) videoFormat.frameRate, videoFormat.width, videoFormat.height, videoFormat.codecs);
                }
                long j10 = videoFormat != null ? videoFormat.bitrate : 0L;
                for (ITrackInfo iTrackInfo : ExoPlaybackMediaPlayer.this.trackInfoList) {
                    if (iTrackInfo.getTrackType() == 2) {
                        if (iTrackInfo.getBitrate() == j10) {
                            ExoPlaybackMediaPlayer.this.selectedVideoTrackInfo = iTrackInfo;
                            ExoPlaybackMediaPlayer.this.selectedVideoTrack = iTrackInfo.getIndex();
                            ExoPlaybackMediaPlayer.this.selectedVideoGroupTrack = iTrackInfo.getGroupIndex();
                            ExoPlaybackMediaPlayer.this.notifyVideoTrackSelect(iTrackInfo);
                        }
                    } else if (iTrackInfo.getTrackType() == 1) {
                        if (iTrackInfo.getIndex() == ExoPlaybackMediaPlayer.this.selectedAudioTrack && iTrackInfo.getGroupIndex() == ExoPlaybackMediaPlayer.this.selectedAudioGroupTrack) {
                            ExoPlaybackMediaPlayer.this.notifyAudioTrackSelect(iTrackInfo);
                        }
                    } else if (iTrackInfo.getTrackType() == 3 && iTrackInfo.getIndex() == ExoPlaybackMediaPlayer.this.selectedSubtitleTrack && iTrackInfo.getGroupIndex() == ExoPlaybackMediaPlayer.this.selectedSubtitleGroupTrack) {
                        ExoPlaybackMediaPlayer.this.notifySubtitleTrackSelect(iTrackInfo);
                    }
                }
            }
            ExoPlaybackMediaPlayer.this.bufferHandler.postDelayed(this, 1000L);
        }
    };
    long firstPositionMs = -1;
    int windowErrorCount = 0;
    private boolean isSeeking = false;
    protected int lastReportedPlaybackState = 1;

    public static class PrepareRunnable implements Runnable {
        private final WeakReference<ExoPlaybackMediaPlayer> ref;

        public PrepareRunnable(ExoPlaybackMediaPlayer exoPlaybackMediaPlayer) {
            this.ref = new WeakReference<>(exoPlaybackMediaPlayer);
        }

        @Override // java.lang.Runnable
        public void run() {
            ExoPlaybackMediaPlayer exoPlaybackMediaPlayer = this.ref.get();
            if (exoPlaybackMediaPlayer == null) {
                return;
            }
            exoPlaybackMediaPlayer.doPrepareAsyncInternal();
        }
    }

    public ExoPlaybackMediaPlayer(Context context) {
        this.mAppContext = context.getApplicationContext();
    }

    private MediaSource createTurboDash(Uri uri) {
        this.mediaItem = new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_MPD).setLiveConfiguration(new MediaItem.LiveConfiguration.Builder().setMinPlaybackSpeed(1.0f).setMaxPlaybackSpeed(1.0f).build()).build();
        return new DashMediaSource.Factory(getHttpDataSourceFactory()).setLoadErrorHandlingPolicy((LoadErrorHandlingPolicy) new DefaultLoadErrorHandlingPolicy() { // from class: tv.danmaku.ijk.media.player.ui.ExoPlaybackMediaPlayer.2
            @Override // androidx.media3.exoplayer.upstream.DefaultLoadErrorHandlingPolicy, androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
            public int getMinimumLoadableRetryCount(int i10) {
                return 1;
            }
        }).createMediaSource(this.mediaItem);
    }

    private String extractSegmentName(Uri uri) {
        int i10;
        if (uri == null) {
            return null;
        }
        String lastPathSegment = uri.getLastPathSegment();
        if (lastPathSegment != null && !lastPathSegment.isEmpty()) {
            int iIndexOf = lastPathSegment.indexOf(63);
            return iIndexOf > 0 ? lastPathSegment.substring(0, iIndexOf) : lastPathSegment;
        }
        String path = uri.getPath();
        if (path == null) {
            return null;
        }
        int iLastIndexOf = path.lastIndexOf(47);
        return (iLastIndexOf < 0 || (i10 = iLastIndexOf + 1) >= path.length()) ? path : path.substring(i10);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$onRenderedFirstFrame$0() {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return;
        }
        long currentPosition = exoPlayer.getCurrentPosition();
        if (currentPosition <= 0 || this.firstPositionMs != -1) {
            return;
        }
        this.firstPositionMs = currentPosition;
    }

    private void selectTrackInternal(int i10, int i11, int i12, boolean z10) {
        DefaultTrackSelector defaultTrackSelector;
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null || (defaultTrackSelector = (DefaultTrackSelector) exoPlayer.getTrackSelector()) == null || defaultTrackSelector.getCurrentMappedTrackInfo() == null) {
            return;
        }
        MappingTrackSelector.MappedTrackInfo mappedTrackInfo = (MappingTrackSelector.MappedTrackInfo) Assertions.checkNotNull(defaultTrackSelector.getCurrentMappedTrackInfo());
        DefaultTrackSelector.Parameters.Builder builderBuildUpon = defaultTrackSelector.getParameters().buildUpon();
        if (i10 == 1 || i10 == 2 || i10 == 3) {
            if (i10 == 1) {
                this.selectedAudioTrack = i12;
                this.selectedAudioGroupTrack = i11;
            } else if (i10 == 2) {
                this.selectedVideoTrack = i12;
                this.selectedVideoGroupTrack = i11;
            } else if (i10 == 3) {
                this.selectedSubtitleTrack = i12;
                this.selectedSubtitleGroupTrack = i11;
            }
            TrackGroup mediaTrackGroup = this.allGroups.get(i11).getMediaTrackGroup();
            int i13 = -1;
            for (int i14 = 0; i14 < mappedTrackInfo.getRendererCount(); i14++) {
                TrackGroupArray trackGroups = mappedTrackInfo.getTrackGroups(i14);
                int i15 = 0;
                while (true) {
                    if (i15 >= trackGroups.length) {
                        break;
                    }
                    if (trackGroups.get(i15) == mediaTrackGroup) {
                        i13 = i14;
                        break;
                    }
                    i15++;
                }
                if (i13 != -1) {
                    break;
                }
            }
            if (i13 != -1) {
                if (i10 == 1) {
                    TrackSelectionOverride trackSelectionOverride = new TrackSelectionOverride(mediaTrackGroup, ImmutableList.w(Integer.valueOf(i12)));
                    builderBuildUpon.clearOverridesOfType(1);
                    builderBuildUpon.addOverride(trackSelectionOverride);
                    builderBuildUpon.setRendererDisabled(i13, false);
                } else if (i10 == 3) {
                    TrackSelectionOverride trackSelectionOverride2 = new TrackSelectionOverride(mediaTrackGroup, ImmutableList.w(Integer.valueOf(i12)));
                    builderBuildUpon.clearOverridesOfType(3);
                    builderBuildUpon.addOverride(trackSelectionOverride2);
                    builderBuildUpon.setRendererDisabled(i13, false);
                } else {
                    TrackSelectionOverride trackSelectionOverride3 = new TrackSelectionOverride(mediaTrackGroup, ImmutableList.w(Integer.valueOf(i12)));
                    builderBuildUpon.clearOverridesOfType(2);
                    builderBuildUpon.addOverride(trackSelectionOverride3);
                    builderBuildUpon.setRendererDisabled(i13, false);
                }
            }
        }
        defaultTrackSelector.setParameters(builderBuildUpon.build());
    }

    public static int[] toFraction(float f10, float f11, int i10) {
        int i11 = 1;
        int i12 = f10 < 0.0f ? -1 : 1;
        float fAbs = Math.abs(f10);
        float f12 = 1;
        int i13 = 1;
        float fAbs2 = Math.abs(fAbs - (f12 / f12));
        int i14 = 1;
        while (true) {
            if (i11 > i10) {
                i11 = i13;
                break;
            }
            float f13 = i11;
            int iRound = Math.round(fAbs * f13);
            float fAbs3 = Math.abs(fAbs - (iRound / f13));
            if (fAbs3 < fAbs2 - f11) {
                if (fAbs3 < f11) {
                    i14 = iRound;
                    break;
                }
                i13 = i11;
                fAbs2 = fAbs3;
                i14 = iRound;
            }
            i11++;
        }
        return new int[]{i12 * i14, i11};
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void deselectTrack(int i10) {
        DefaultTrackSelector defaultTrackSelector;
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null || (defaultTrackSelector = (DefaultTrackSelector) exoPlayer.getTrackSelector()) == null) {
            return;
        }
        MappingTrackSelector.MappedTrackInfo mappedTrackInfo = (MappingTrackSelector.MappedTrackInfo) Assertions.checkNotNull(defaultTrackSelector.getCurrentMappedTrackInfo());
        DefaultTrackSelector.Parameters.Builder builderBuildUpon = defaultTrackSelector.getParameters().buildUpon();
        for (int i11 = 0; i11 < mappedTrackInfo.getRendererCount(); i11++) {
            if (mappedTrackInfo.getRendererType(i11) == 1) {
                builderBuildUpon.clearOverride(mappedTrackInfo.getTrackGroups(i11).get(i10 - 1)).setRendererDisabled(i11, true);
            }
        }
        defaultTrackSelector.setParameters(builderBuildUpon);
    }

    public void doPrepareAsyncInternal() {
        AdaptiveTrackSelection.Factory factory = new AdaptiveTrackSelection.Factory(8000, 10000, 5000, 0.5f);
        if (this.mTrackSelector == null) {
            DefaultTrackSelector defaultTrackSelector = new DefaultTrackSelector(this.mAppContext, factory);
            this.mTrackSelector = defaultTrackSelector;
            this.mTrackSelector.setParameters(defaultTrackSelector.buildUponParameters().clearOverrides().setSelectUndeterminedTextLanguage(true).setRendererDisabled(2, false).setRendererDisabled(1, false).setRendererDisabled(3, false).setForceHighestSupportedBitrate(true).clearVideoSizeConstraints().clearViewportSizeConstraints().setMaxVideoBitrate(Integer.MAX_VALUE).setAllowVideoNonSeamlessAdaptiveness(false).setExceedRendererCapabilitiesIfNecessary(false).build());
        }
        DefaultAllocator defaultAllocator = new DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE);
        if (this.mRendererFactory == null) {
            DefaultRenderersFactory defaultRenderersFactory = new DefaultRenderersFactory(this.mAppContext);
            this.mRendererFactory = defaultRenderersFactory;
            defaultRenderersFactory.setEnableDecoderFallback(false).setExtensionRendererMode(2);
        }
        if (this.mLoadControl == null) {
            this.mLoadControl = new DefaultLoadControl.Builder().setAllocator(defaultAllocator).setPrioritizeTimeOverSizeThresholds(false).build();
        }
        DefaultLivePlaybackSpeedControl defaultLivePlaybackSpeedControlBuild = new DefaultLivePlaybackSpeedControl.Builder().setFallbackMinPlaybackSpeed(1.0f).setFallbackMaxPlaybackSpeed(1.0f).build();
        ExoPlayer.Builder builder = new ExoPlayer.Builder(this.mAppContext, this.mRendererFactory);
        Looper mainLooper = Looper.getMainLooper();
        Objects.requireNonNull(mainLooper);
        this.mPlayer = builder.setLooper(mainLooper).setTrackSelector(this.mTrackSelector).setLivePlaybackSpeedControl(defaultLivePlaybackSpeedControlBuild).setBandwidthMeter(this.defaultBandwidthMeter).setLoadControl(this.mLoadControl).build();
        this.defaultBandwidthMeter.addEventListener(new Handler(Looper.getMainLooper()), this);
        this.mPlayer.clearMediaItems();
        this.mPlayer.setSeekParameters(SeekParameters.CLOSEST_SYNC);
        this.mPlayer.addAnalyticsListener(this);
        this.mPlayer.addListener(this);
        if (this.isLooping) {
            this.mPlayer.setRepeatMode(2);
        }
        Surface surface = this.mSurface;
        if (surface != null) {
            this.mPlayer.setVideoSurface(surface);
        }
        this.mPlayer.setPlayWhenReady(true);
        this.mPlayer.setMediaSource(this.mMediaSource);
        this.mPlayer.prepare();
        this.mPlayer.setVolume(1.0f);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getAudioSessionId() {
        ExoPlayer exoPlayer = this.mPlayer;
        return exoPlayer != null ? exoPlayer.getAudioSessionId() : this.audioSessionId;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getBufferedPosition() {
        try {
            ExoPlayer exoPlayer = this.mPlayer;
            if (exoPlayer == null) {
                return 0L;
            }
            return exoPlayer.getBufferedPosition() - this.firstPositionMs;
        } catch (Exception e10) {
            IjkPlayerRuntime.logError("getBufferedPosition error: " + e10.getMessage());
            return 0L;
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public boolean getCurrentFrame(Bitmap bitmap) {
        return false;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getCurrentPosition() {
        try {
            ExoPlayer exoPlayer = this.mPlayer;
            if (exoPlayer == null) {
                return 0L;
            }
            return this.isSeeking ? exoPlayer.getCurrentPosition() : exoPlayer.getCurrentPosition() - this.firstPositionMs;
        } catch (Exception unused) {
            return 0L;
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getDuration() {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return 0L;
        }
        return exoPlayer.getDuration();
    }

    public DataSource.Factory getHttpDataSourceFactory() {
        this.defaultBandwidthMeter = new DefaultBandwidthMeter.Builder(this.mAppContext).setSlidingWindowMaxWeight(3000).build();
        return new DefaultDataSource.Factory(this.mAppContext, new DefaultHttpDataSource.Factory().setConnectTimeoutMs(15000).setReadTimeoutMs(15000)).setTransferListener(this.defaultBandwidthMeter);
    }

    public DataSource.Factory getOkHttpDataSourceFactory() {
        this.defaultBandwidthMeter = new DefaultBandwidthMeter.Builder(this.mAppContext).setSlidingWindowMaxWeight(3000).build();
        return new OkHttpDataSource.Factory(IjkPlayerRuntime.getOkHttpClient()).setTransferListener(this.defaultBandwidthMeter);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getSelectedGroupTrack(int i10) {
        if (i10 == 2) {
            return this.selectedVideoGroupTrack;
        }
        if (i10 == 1) {
            return this.selectedAudioGroupTrack;
        }
        if (i10 == 3) {
            return this.selectedSubtitleGroupTrack;
        }
        return -1;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getSelectedTrack(int i10) {
        if (i10 == 2) {
            return this.selectedVideoTrack;
        }
        if (i10 == 1) {
            return this.selectedAudioTrack;
        }
        if (i10 == 3) {
            return this.selectedSubtitleTrack;
        }
        return -1;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public ITrackInfo getSelectedVideoTrackInfo() {
        return this.selectedVideoTrackInfo;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public float getSpeed() {
        return this.mPlayer.getPlaybackParameters().speed;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getTcpSpeed() {
        return 0L;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public List<ITrackInfo> getTrackInfo() {
        return this.trackInfoList;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getVideoCachedBytes() {
        return 0L;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public long getVideoCachedDuration() {
        return 0L;
    }

    public Format getVideoFormat() {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer != null) {
            return exoPlayer.getVideoFormat();
        }
        return null;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getVideoHeight() {
        return this.mVideoHeight;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getVideoSarDen() {
        return 1;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getVideoSarNum() {
        return 1;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public int getVideoWidth() {
        return this.mVideoWidth;
    }

    public boolean isCache() {
        return this.isCache;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public boolean isLooping() {
        return this.isLooping;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public boolean isPlayable() {
        return true;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public boolean isPlaying() {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return false;
        }
        int playbackState = exoPlayer.getPlaybackState();
        if (playbackState == 2 || playbackState == 3) {
            return this.mPlayer.getPlayWhenReady();
        }
        return false;
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onAudioDisabled(@NonNull AnalyticsListener.EventTime eventTime, @NonNull DecoderCounters decoderCounters) {
        this.audioSessionId = 0;
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onAudioSinkError(@NonNull AnalyticsListener.EventTime eventTime, @NonNull Exception exc) {
        super.onAudioSinkError(eventTime, exc);
        IjkPlayerRuntime.logError("onLiveAudioSinkError: " + exc.getMessage());
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onBandwidthEstimate(@NonNull AnalyticsListener.EventTime eventTime, int i10, long j10, long j11) {
    }

    @Override // androidx.media3.exoplayer.upstream.BandwidthMeter.EventListener
    public void onBandwidthSample(int i10, long j10, long j11) {
        ExoPlayer exoPlayer;
        if (i10 == 0 || (exoPlayer = this.mPlayer) == null) {
            return;
        }
        if (exoPlayer.getPlaybackState() == 3 || this.mPlayer.getPlaybackState() == 2) {
            notifyBitrateChange(i10, j10, j11);
        }
    }

    @Override // androidx.media3.common.Player.Listener
    public void onCues(@NonNull CueGroup cueGroup) {
        super.onCues(cueGroup);
        ImmutableList<Cue> immutableList = cueGroup.cues;
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onDrmKeysLoaded(@NonNull AnalyticsListener.EventTime eventTime) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onDrmKeysRemoved(@NonNull AnalyticsListener.EventTime eventTime) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onDrmKeysRestored(@NonNull AnalyticsListener.EventTime eventTime) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onDrmSessionManagerError(@NonNull AnalyticsListener.EventTime eventTime, @NonNull Exception exc) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onIsLoadingChanged(@NonNull AnalyticsListener.EventTime eventTime, boolean z10) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onLoadError(@NonNull AnalyticsListener.EventTime eventTime, @NonNull LoadEventInfo loadEventInfo, @NonNull MediaLoadData mediaLoadData, @NonNull IOException iOException, boolean z10) {
        super.onLoadError(eventTime, loadEventInfo, mediaLoadData, iOException, z10);
        IjkPlayerRuntime.logError("onLiveLoadError: " + iOException.getMessage() + ", wasCanceled: " + z10);
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onLoadStarted(@NonNull AnalyticsListener.EventTime eventTime, @NonNull LoadEventInfo loadEventInfo, @NonNull MediaLoadData mediaLoadData, int i10) {
        super.onLoadStarted(eventTime, loadEventInfo, mediaLoadData, i10);
        try {
            String strExtractSegmentName = extractSegmentName(loadEventInfo.dataSpec.uri);
            if (strExtractSegmentName == null) {
                return;
            }
            boolean zMatches = strExtractSegmentName.toLowerCase().matches(".*video.*-\\d+-\\d+\\.m4s$");
            synchronized (this) {
                if (zMatches) {
                    try {
                        if (this.segmentFile == null) {
                            this.segmentFile = strExtractSegmentName;
                        }
                    } catch (Throwable th) {
                        throw th;
                    }
                }
            }
        } catch (Exception e10) {
            IjkPlayerRuntime.logError("onLoadStarted extract segment error: " + e10.getMessage());
        }
    }

    @Override // androidx.media3.common.Player.Listener
    public void onMetadata(@NonNull Metadata metadata) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onPlayWhenReadyChanged(@NonNull AnalyticsListener.EventTime eventTime, boolean z10, int i10) {
    }

    @Override // androidx.media3.common.Player.Listener
    public void onPlaybackParametersChanged(@NonNull PlaybackParameters playbackParameters) {
    }

    @Override // androidx.media3.common.Player.Listener
    public void onPlaybackStateChanged(int i10) {
        onPlayWhenReadyChanged(this.isLastReportedPlayWhenReady, i10);
    }

    @Override // androidx.media3.common.Player.Listener
    public void onPlayerError(@NonNull PlaybackException playbackException) {
        int i10 = playbackException.errorCode;
        if (i10 != 1002 || this.mPlayer == null) {
            notifyOnError(i10, 1, playbackException.getMessage() != null ? playbackException.getMessage() : "");
            return;
        }
        IjkPlayerRuntime.saveLog("onPlayerError: Behind live window error");
        this.isPreparing = true;
        this.mPlayer.seekToDefaultPosition();
        this.mPlayer.prepare();
    }

    @Override // androidx.media3.common.Player.Listener
    public void onPositionDiscontinuity(@NonNull Player.PositionInfo positionInfo, @NonNull Player.PositionInfo positionInfo2, int i10) {
        notifyOnInfo(ON_POSITION_DISCOUNTINUITY, i10);
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onRenderedFirstFrame(@NonNull AnalyticsListener.EventTime eventTime, @NonNull Object obj, long j10) {
        this.isSeeking = false;
        new Handler(Looper.getMainLooper()).postDelayed(new a(this, 1), 1000L);
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onRepeatModeChanged(@NonNull AnalyticsListener.EventTime eventTime, int i10) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onShuffleModeChanged(@NonNull AnalyticsListener.EventTime eventTime, boolean z10) {
    }

    @Override // androidx.media3.common.Player.Listener
    public void onTracksChanged(@NonNull Tracks tracks) {
        super.onTracksChanged(tracks);
        this.allGroups = tracks.getGroups();
        this.trackInfoList.clear();
        this.trackInfoList.addAll(ExoTrackInfo.fromTrackInfo(this.allGroups));
        for (int i10 = 0; i10 < this.allGroups.size(); i10++) {
            Tracks.Group group = this.allGroups.get(i10);
            if (group.getType() == 1) {
                for (int i11 = 0; i11 < group.length; i11++) {
                    if (group.isTrackSelected(i11)) {
                        this.selectedAudioTrack = i11;
                        this.selectedAudioGroupTrack = i10;
                    }
                }
            }
            if (group.getType() == 2 && group.isSelected()) {
                for (int i12 = 0; i12 < group.length; i12++) {
                    if (group.isTrackSelected(i12)) {
                        this.selectedVideoTrack = i12;
                        this.selectedVideoGroupTrack = i10;
                        this.selectedVideoTrackInfo = null;
                        Iterator<ITrackInfo> it = this.trackInfoList.iterator();
                        while (true) {
                            if (it.hasNext()) {
                                ITrackInfo next = it.next();
                                if (next.getTrackType() == 2 && next.getIndex() == this.selectedVideoTrack && next.getGroupIndex() == this.selectedVideoGroupTrack) {
                                    this.selectedVideoTrackInfo = next;
                                    break;
                                }
                            }
                        }
                    }
                }
            }
            if (group.getType() == 3) {
                for (int i13 = 0; i13 < group.length; i13++) {
                    if (group.isTrackSelected(i13)) {
                        this.selectedSubtitleTrack = i13;
                        this.selectedSubtitleGroupTrack = i10;
                    }
                }
            }
        }
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onVideoDecoderInitialized(@NonNull AnalyticsListener.EventTime eventTime, @NonNull String str, long j10, long j11) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onVideoDisabled(@NonNull AnalyticsListener.EventTime eventTime, @NonNull DecoderCounters decoderCounters) {
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onVideoSizeChanged(@NonNull AnalyticsListener.EventTime eventTime, VideoSize videoSize) {
        this.mVideoWidth = videoSize.width;
        this.mVideoHeight = videoSize.height;
        int[] fraction = toFraction(videoSize.pixelWidthHeightRatio, 0.01f, 100);
        notifyOnVideoSizeChanged(videoSize.width, videoSize.height, fraction[0], fraction[1]);
        int i10 = videoSize.unappliedRotationDegrees;
        if (i10 > 0) {
            notifyOnInfo(10001, i10);
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void pause() throws IllegalStateException {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return;
        }
        exoPlayer.setPlayWhenReady(false);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void prepareAsync() throws IllegalStateException {
        if (this.mPlayer != null) {
            throw new IllegalStateException("can't prepare a prepared player");
        }
        PrepareRunnable prepareRunnable = this.prepareRunnable;
        if (prepareRunnable != null) {
            this.mainHandler.removeCallbacks(prepareRunnable);
        }
        PrepareRunnable prepareRunnable2 = new PrepareRunnable(this);
        this.prepareRunnable = prepareRunnable2;
        this.mainHandler.post(prepareRunnable2);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void release() {
        PrepareRunnable prepareRunnable = this.prepareRunnable;
        if (prepareRunnable != null) {
            this.mainHandler.removeCallbacks(prepareRunnable);
            this.prepareRunnable = null;
        }
        try {
            this.bufferHandler.removeCallbacks(this.bufferRunnable);
            DefaultBandwidthMeter defaultBandwidthMeter = this.defaultBandwidthMeter;
            if (defaultBandwidthMeter != null) {
                defaultBandwidthMeter.removeEventListener(this);
                this.defaultBandwidthMeter = null;
            }
        } catch (Throwable unused) {
        }
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer != null) {
            try {
                exoPlayer.removeListener(this);
            } catch (Throwable unused2) {
            }
            try {
                this.mPlayer.removeAnalyticsListener(this);
            } catch (Throwable unused3) {
            }
            try {
                this.mPlayer.setVideoSurface(null);
            } catch (Throwable unused4) {
            }
            try {
                this.mPlayer.stop();
            } catch (Throwable unused5) {
            }
            try {
                this.mPlayer.release();
            } catch (Throwable unused6) {
            }
            this.mPlayer = null;
        }
        reset();
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void reset() {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer != null) {
            exoPlayer.release();
            IjkPlayerRuntime.saveLog("live player release");
            this.mPlayer = null;
        }
        this.mSurface = null;
        this.mDataSource = null;
        this.mVideoWidth = 0;
        this.mVideoHeight = 0;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void seekTo(long j10) throws IllegalStateException {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return;
        }
        this.isSeeking = true;
        exoPlayer.seekTo(j10);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void selectTrack(int i10, int i11, int i12) {
        selectTrackInternal(i10, i11, i12, true);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setAudioStreamType(int i10) {
    }

    public void setCache(boolean z10) {
        this.isCache = z10;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setDataSource(FileDescriptor fileDescriptor) throws IllegalStateException, SecurityException, IllegalArgumentException {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setDisplay(SurfaceHolder surfaceHolder) {
        if (surfaceHolder == null) {
            setSurface(null);
        } else {
            setSurface(surfaceHolder.getSurface());
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setKeepInBackground(boolean z10) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setLogEnabled(boolean z10) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setLooping(boolean z10) {
        this.isLooping = z10;
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setOption(int i10, String str, long j10) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setScreenOnWhilePlaying(boolean z10) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setSpeed(float f10) {
        if (this.mPlayer != null) {
            this.mPlayer.setPlaybackParameters(new PlaybackParameters(f10));
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setSurface(Surface surface) {
        this.mSurface = surface;
        if (this.mPlayer != null) {
            if (surface != null && !surface.isValid()) {
                this.mSurface = null;
            }
            this.mPlayer.setVideoSurface(surface);
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setVolume(float f10, float f11) {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer != null) {
            exoPlayer.setVolume((f10 + f11) / 2.0f);
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setWakeMode(Context context, int i10) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void start() throws IllegalStateException {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return;
        }
        exoPlayer.setPlayWhenReady(true);
        this.mPlayer.seekToDefaultPosition();
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void stop() throws IllegalStateException {
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer == null) {
            return;
        }
        exoPlayer.release();
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onMetadata(@NonNull AnalyticsListener.EventTime eventTime, @NonNull Metadata metadata) {
    }

    @Override // androidx.media3.common.Player.Listener
    @SuppressLint({"SwitchIntDef"})
    public void onPlayWhenReadyChanged(boolean z10, int i10) {
        if (this.isLastReportedPlayWhenReady != z10 || this.lastReportedPlaybackState != i10) {
            if (this.isPreparing && i10 == 3) {
                IjkPlayerRuntime.saveLog("playbackState: STATE_READY");
                notifyOnPrepared();
                if (this.mPlayer != null) {
                    this.bufferHandler.removeCallbacks(this.bufferRunnable);
                    this.bufferHandler.post(this.bufferRunnable);
                }
                this.isPreparing = false;
            }
            if (i10 == 1) {
                IjkPlayerRuntime.saveLog("playbackState: STATE_IDLE");
            } else if (i10 == 2) {
                IjkPlayerRuntime.saveLog("playbackState: STATE_BUFFERING");
                this.isBuffering = true;
                ExoPlayer exoPlayer = this.mPlayer;
                if (exoPlayer != null) {
                    notifyOnBufferingUpdate(exoPlayer.getBufferedPosition());
                    notifyOnInfo(IMediaPlayer.MEDIA_INFO_BUFFERING_START, 0);
                }
            } else if (i10 == 3) {
                IjkPlayerRuntime.saveLog("playbackState: STATE_READY");
                this.isBuffering = false;
                this.windowErrorCount = 0;
                notifyOnInfo(IMediaPlayer.MEDIA_INFO_BUFFERING_END, 0);
                if (z10) {
                    notifyOnInfo(3, 0);
                }
            } else if (i10 == 4) {
                IjkPlayerRuntime.saveLog("playbackState: STATE_ENDED");
                notifyOnCompletion();
            }
        }
        this.isLastReportedPlayWhenReady = z10;
        this.lastReportedPlaybackState = i10;
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onPlaybackParametersChanged(@NonNull AnalyticsListener.EventTime eventTime, @NonNull PlaybackParameters playbackParameters) {
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void selectTrack(int i10) {
        DefaultTrackSelector defaultTrackSelector = (DefaultTrackSelector) this.mPlayer.getTrackSelector();
        if (defaultTrackSelector == null) {
            return;
        }
        MappingTrackSelector.MappedTrackInfo mappedTrackInfo = (MappingTrackSelector.MappedTrackInfo) Assertions.checkNotNull(defaultTrackSelector.getCurrentMappedTrackInfo());
        DefaultTrackSelector.Parameters.Builder builderBuildUpon = defaultTrackSelector.getParameters().buildUpon();
        for (int i11 = 0; i11 < mappedTrackInfo.getRendererCount(); i11++) {
            if (mappedTrackInfo.getRendererType(i11) == 1) {
                int i12 = i10 - 1;
                builderBuildUpon.clearOverride(mappedTrackInfo.getTrackGroups(i11).get(i12)).setRendererDisabled(i11, false);
                ArrayList arrayList = new ArrayList();
                arrayList.add(0);
                builderBuildUpon.addOverride(new TrackSelectionOverride(mappedTrackInfo.getTrackGroups(i11).get(i12), arrayList));
            }
        }
        defaultTrackSelector.setParameters(builderBuildUpon);
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setDataSource(Context context, Uri uri, Map<String, String> map) {
        boolean z10 = false;
        this.hasLoadedData = false;
        if (map != null) {
            this.mHeaders.clear();
            this.mHeaders.putAll(map);
        }
        this.mDataSource = uri.toString();
        this.firstPositionMs = -1L;
        IjkPlayerRuntime.logDebug("setLiveDataSource: " + this.mDataSource);
        this.isRemote = (this.mDataSource.contains("127.0.0.1") || this.mDataSource.contains("192.168.")) ? false : true;
        SntpClient.setTimeoutMs(300);
        SntpClient.initialize(null, new SntpClient.InitializationCallback() { // from class: tv.danmaku.ijk.media.player.ui.ExoPlaybackMediaPlayer.1
            @Override // androidx.media3.exoplayer.util.SntpClient.InitializationCallback
            public void onInitializationFailed(@NonNull IOException iOException) {
            }

            @Override // androidx.media3.exoplayer.util.SntpClient.InitializationCallback
            public void onInitialized() {
            }
        });
        if (map != null) {
            String str = map.get(URLProtectionSpaceContract.FeedEntry.COLUMN_NAME_PROTOCOL);
            if (str != null && str.equals("1")) {
                z10 = true;
            }
            String str2 = map.get("is_sports");
            if (str2 != null && str2.equals("1")) {
                this.isSportsChannel = true;
            }
            this.channelId = map.get("channel_id");
        }
        if (!this.isRemote) {
            if (!z10) {
                this.mMediaSource = createTurboDash(uri);
                return;
            } else {
                this.mediaItem = new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_M3U8).build();
                this.mMediaSource = new HlsMediaSource.Factory(getHttpDataSourceFactory()).createMediaSource(this.mediaItem);
                return;
            }
        }
        if (this.mDataSource.endsWith(".mpd") || this.mDataSource.contains(".mpd?")) {
            this.mediaItem = new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_MPD).build();
            this.mMediaSource = new DashMediaSource.Factory(getOkHttpDataSourceFactory()).createMediaSource(this.mediaItem);
            return;
        }
        if (this.mDataSource.endsWith("m3u8") || this.mDataSource.contains("m3u8?")) {
            this.mediaItem = new MediaItem.Builder().setUri(uri).setMimeType(MimeTypes.APPLICATION_M3U8).build();
            this.mMediaSource = new HlsMediaSource.Factory(getOkHttpDataSourceFactory()).createMediaSource(this.mediaItem);
        } else if (!this.mDataSource.contains("rtsp://")) {
            this.mediaItem = new MediaItem.Builder().setUri(uri).build();
            this.mMediaSource = new ProgressiveMediaSource.Factory(getOkHttpDataSourceFactory()).createMediaSource(this.mediaItem);
        } else {
            this.mediaItem = new MediaItem.Builder().setUri(uri).build();
            this.defaultBandwidthMeter = new DefaultBandwidthMeter.Builder(this.mAppContext).setSlidingWindowMaxWeight(3000).build();
            this.mMediaSource = new RtspMediaSource.Factory().createMediaSource(this.mediaItem);
        }
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setOption(int i10, String str, String str2) {
    }

    public void setSpeed(@Size(min = 0) float f10, @Size(min = 0) float f11) {
        PlaybackParameters playbackParameters = new PlaybackParameters(f10, f11);
        this.mSpeedPlaybackParameters = playbackParameters;
        ExoPlayer exoPlayer = this.mPlayer;
        if (exoPlayer != null) {
            exoPlayer.setPlaybackParameters(playbackParameters);
        }
    }

    @Override // androidx.media3.exoplayer.analytics.AnalyticsListener
    public void onPlayerError(@NonNull AnalyticsListener.EventTime eventTime, @NonNull PlaybackException playbackException) {
        super.onPlayerError(eventTime, playbackException);
        if (playbackException.errorCode == 1002 && this.windowErrorCount < 3 && this.mPlayer != null) {
            IjkPlayerRuntime.logError("onPlayerError: Behind live window error");
            this.windowErrorCount++;
            this.isPreparing = true;
            this.mPlayer.seekToDefaultPosition();
            this.mPlayer.prepare();
            return;
        }
        IjkPlayerRuntime.logError("onLivePlayerError: " + playbackException.errorCode + ", " + playbackException.getMessage());
        notifyOnError(playbackException.errorCode, 1, playbackException.getMessage() != null ? playbackException.getMessage() : "");
    }

    @Override // tv.danmaku.ijk.media.player.IMediaPlayer
    public void setDataSource(String str) {
        setDataSource(this.mAppContext, Uri.parse(str), null);
    }
}
