Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/com/mbridge/msdk/playercommon/BuildConfig.java

@@ -0,0 +1,9 @@
+package com.mbridge.msdk.playercommon;
+
+/* loaded from: classes4.dex */
+public final class BuildConfig {
+    public static final String BUILD_TYPE = "release";
+    public static final boolean DEBUG = false;
+    public static final String FLAVOR = "oversea";
+    public static final String LIBRARY_PACKAGE_NAME = "com.mbridge.msdk.playercommon";
+}

decompiled/sources/com/mbridge/msdk/playercommon/DefaultVideoPlayerStatusListener.java

@@ -0,0 +1,48 @@
+package com.mbridge.msdk.playercommon;
+
+import com.mbridge.msdk.foundation.tools.af;
+
+/* loaded from: classes4.dex */
+public class DefaultVideoPlayerStatusListener implements VideoPlayerStatusListener {
+    protected static final String TAG = "DefaultVideoPlayerStatusListener";
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlayStarted(int i) {
+        af.a(TAG, "onPlayStarted:" + i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlayCompleted() {
+        af.a(TAG, "onPlayCompleted");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlayError(String str) {
+        af.a(TAG, "onPlayError:" + str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlayProgress(int i, int i2) {
+        af.a(TAG, "onPlayProgress:" + i + ",allDuration:" + i2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onBufferingStart(String str) {
+        af.a(TAG, "OnBufferingStart:" + str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onBufferingEnd() {
+        af.a(TAG, "OnBufferingEnd");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlaySetDataSourceError(String str) {
+        af.a(TAG, "onPlaySetDataSourceError:" + str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.VideoPlayerStatusListener
+    public void onPlayProgressMS(int i, int i2) {
+        af.a(TAG, "onPlayProgressMS:");
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/PlayerErrorConstant.java

@@ -0,0 +1,16 @@
+package com.mbridge.msdk.playercommon;
+
+/* loaded from: classes4.dex */
+public class PlayerErrorConstant {
+    public static final String ILLEGAL_VIDEO_ADDRESS = "illegal video address";
+    public static final String MEDIAPLAYER_INIT_FAILED = "MediaPlayer init error";
+    public static final String MEDIAPLAYER_NO_INIT = "MediaPlayer need to init ";
+    public static final String PLAYERING_TIMEOUT = "play buffering tiemout";
+    public static final String PLAY_CANNOT_PALY = "mediaplayer cannot play";
+    public static final String PLAY_DOWNLOAD_TASK_ILLEGAL = "download task is null";
+    public static final String PLAY_FILE_SIZE_ILLEGAL = "file size is null";
+    public static final String PLAY_URL_ILLEGAL = "play url is null";
+    public static final String PREPARE_TIMEOUT = "mediaplayer prepare timeout";
+    public static final String SET_DATA_SOURCE_ERROR = "set data source error";
+    public static final String UNKNOW_ERROR = "unknow error";
+}

decompiled/sources/com/mbridge/msdk/playercommon/PlayerView.java

@@ -0,0 +1,599 @@
+package com.mbridge.msdk.playercommon;
+
+import android.content.Context;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.LinearLayout;
+import com.iab.omid.library.mmadbridge.adsession.media.MediaEvents;
+import com.mbridge.msdk.foundation.controller.c;
+import com.mbridge.msdk.foundation.d.b;
+import com.mbridge.msdk.foundation.same.a;
+import com.mbridge.msdk.foundation.tools.af;
+import com.mbridge.msdk.foundation.tools.ah;
+import com.mbridge.msdk.foundation.tools.ak;
+import com.mbridge.msdk.foundation.tools.x;
+import com.mbridge.msdk.playercommon.exoplayer2.text.ttml.TtmlNode;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+public class PlayerView extends LinearLayout {
+    public static final String TAG = "PlayerView";
+    private boolean hadOMPause;
+    private boolean isBTVideo;
+    private boolean isBTVideoPlaying;
+    private boolean mHasReportedData;
+    private boolean mInitState;
+    private boolean mIsCovered;
+    private boolean mIsFirstCreateHolder;
+    private boolean mIsNeedToRepeatPrepare;
+    private boolean mIsSurfaceHolderDestoryed;
+    private LinearLayout mLlSurContainer;
+    private LinearLayout mLoadingView;
+    private String mPlayUrl;
+    private SurfaceHolder mSurfaceHolder;
+    private VideoFeedsPlayer mVideoFeedsPlayer;
+    private OnPlayerViewVisibleListener onPlayerViewVisibleListener;
+    protected int orientation;
+    private MediaEvents videoEvents;
+    protected float xInScreen;
+    protected float yInScreen;
+
+    public interface OnPlayerViewVisibleListener {
+        void playerViewVisibleCallback();
+    }
+
+    public MediaEvents getVideoEvents() {
+        return this.videoEvents;
+    }
+
+    public void setIsBTVideo(boolean z) {
+        this.isBTVideo = z;
+    }
+
+    public void setIsBTVideoPlaying(boolean z) {
+        this.isBTVideoPlaying = z;
+    }
+
+    public void setNotifyListener(OnPlayerViewVisibleListener onPlayerViewVisibleListener) {
+        this.onPlayerViewVisibleListener = onPlayerViewVisibleListener;
+    }
+
+    public void setVideoEvents(MediaEvents mediaEvents) {
+        this.videoEvents = mediaEvents;
+    }
+
+    public PlayerView(Context context) {
+        super(context);
+        this.mInitState = false;
+        this.mIsFirstCreateHolder = true;
+        this.mIsSurfaceHolderDestoryed = false;
+        this.mIsCovered = false;
+        this.mIsNeedToRepeatPrepare = false;
+        this.isBTVideo = false;
+        this.isBTVideoPlaying = false;
+        this.orientation = 1;
+        this.mHasReportedData = false;
+        this.hadOMPause = false;
+        init();
+    }
+
+    public PlayerView(Context context, AttributeSet attributeSet) {
+        super(context, attributeSet);
+        this.mInitState = false;
+        this.mIsFirstCreateHolder = true;
+        this.mIsSurfaceHolderDestoryed = false;
+        this.mIsCovered = false;
+        this.mIsNeedToRepeatPrepare = false;
+        this.isBTVideo = false;
+        this.isBTVideoPlaying = false;
+        this.orientation = 1;
+        this.mHasReportedData = false;
+        this.hadOMPause = false;
+        init();
+    }
+
+    private void init() {
+        try {
+            initView();
+            initPlayer();
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void initPlayer() {
+        this.mVideoFeedsPlayer = new VideoFeedsPlayer();
+    }
+
+    public void addSurfaceView() {
+        try {
+            af.c(TAG, "addSurfaceView");
+            SurfaceView surfaceView = new SurfaceView(getContext().getApplicationContext());
+            SurfaceHolder holder = surfaceView.getHolder();
+            this.mSurfaceHolder = holder;
+            holder.setType(3);
+            this.mSurfaceHolder.setKeepScreenOn(true);
+            this.mSurfaceHolder.addCallback(new MySurfaceHoldeCallback());
+            this.mLlSurContainer.addView(surfaceView, -1, -1);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void removeSurface() {
+        try {
+            af.c(TAG, "removeSurface");
+            this.mLlSurContainer.removeAllViews();
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void initView() {
+        View inflate = LayoutInflater.from(getContext()).inflate(x.a(getContext(), "mbridge_playercommon_player_view", TtmlNode.TAG_LAYOUT), (ViewGroup) null);
+        if (inflate != null) {
+            this.mLlSurContainer = (LinearLayout) inflate.findViewById(x.a(getContext(), "mbridge_playercommon_ll_sur_container", "id"));
+            this.mLoadingView = (LinearLayout) inflate.findViewById(x.a(getContext(), "mbridge_playercommon_ll_loading", "id"));
+            addSurfaceView();
+            addView(inflate, -1, -1);
+        }
+    }
+
+    public boolean initVFPData(String str, String str2, VideoPlayerStatusListener videoPlayerStatusListener) {
+        if (TextUtils.isEmpty(str)) {
+            af.c(TAG, "playUrl==null");
+            return false;
+        }
+        this.mPlayUrl = str;
+        this.mVideoFeedsPlayer.initPlayer(getContext(), this.mLoadingView, str, videoPlayerStatusListener);
+        this.mInitState = true;
+        return true;
+    }
+
+    public boolean playVideo(int i) {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer == null) {
+                af.c(TAG, "player init error 播放失败");
+                return false;
+            }
+            if (!this.mInitState) {
+                af.c(TAG, "vfp init failed 播放失败");
+                return false;
+            }
+            videoFeedsPlayer.play(this.mPlayUrl, i);
+            this.mIsNeedToRepeatPrepare = false;
+            return true;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage(), th);
+            return false;
+        }
+    }
+
+    public boolean playVideo() {
+        return playVideo(0);
+    }
+
+    public float getVolume() {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            return videoFeedsPlayer.getVolume();
+        }
+        return 0.0f;
+    }
+
+    public void onPause() {
+        try {
+            pause();
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.setIsFrontDesk(false);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void pause() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.pause();
+            }
+            pauseOmsdk();
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void pauseOmsdk() {
+        try {
+            if (this.videoEvents == null || this.hadOMPause) {
+                return;
+            }
+            af.a("omsdk", "play view:  pause");
+            this.hadOMPause = true;
+            this.videoEvents.pause();
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void resumeOMSDK() {
+        try {
+            MediaEvents mediaEvents = this.videoEvents;
+            if (mediaEvents != null) {
+                this.hadOMPause = false;
+                mediaEvents.resume();
+                af.a("omsdk", "play view:  resume");
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void resumeStart() {
+        try {
+            start(true);
+            resumeOMSDK();
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void setDataSource() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.showLoading();
+                this.mVideoFeedsPlayer.setDataSource();
+                this.mIsNeedToRepeatPrepare = false;
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start(boolean z) {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer == null || this.mIsCovered) {
+                return;
+            }
+            videoFeedsPlayer.start(z);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void prepare() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.prepare();
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start(int i) {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.start(i);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void justSeekTo(int i) {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.justSeekTo(i);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void seekTo(int i) {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.seekTo(i);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void stop() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.stop();
+            }
+            if (this.videoEvents != null) {
+                this.videoEvents = null;
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void openSound() {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.openSound();
+        }
+    }
+
+    public void closeSound() {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.closeSound();
+        }
+    }
+
+    public void setDesk(boolean z) {
+        this.mVideoFeedsPlayer.setIsFrontDesk(z);
+    }
+
+    public void onResume() {
+        try {
+            this.mVideoFeedsPlayer.setIsFrontDesk(true);
+            if (this.mVideoFeedsPlayer != null && !this.mIsSurfaceHolderDestoryed && !isComplete() && !this.mIsCovered) {
+                af.c(TAG, "onresume========");
+                if (this.mVideoFeedsPlayer.hasPrepare()) {
+                    resumeStart();
+                } else {
+                    playVideo(0);
+                }
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void coverUnlockResume() {
+        try {
+            this.mVideoFeedsPlayer.setIsFrontDesk(true);
+            if (this.mVideoFeedsPlayer != null) {
+                af.c(TAG, "coverUnlockResume========");
+                if (this.mVideoFeedsPlayer.hasPrepare() && !this.mIsNeedToRepeatPrepare) {
+                    start(true);
+                }
+                playVideo(0);
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public void release() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                videoFeedsPlayer.releasePlayer();
+            }
+            if (this.mSurfaceHolder != null) {
+                af.b(TAG, "mSurfaceHolder release");
+                this.mSurfaceHolder.getSurface().release();
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public int getCurPosition() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                return videoFeedsPlayer.getCurPosition();
+            }
+            return 0;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            return 0;
+        }
+    }
+
+    public int getDuration() {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            return videoFeedsPlayer.getDuration();
+        }
+        return 0;
+    }
+
+    public class MySurfaceHoldeCallback implements SurfaceHolder.Callback {
+        private MySurfaceHoldeCallback() {
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public void surfaceCreated(SurfaceHolder surfaceHolder) {
+            try {
+                af.c(PlayerView.TAG, "surfaceCreated");
+                if (PlayerView.this.mVideoFeedsPlayer == null || surfaceHolder == null) {
+                    return;
+                }
+                PlayerView.this.mSurfaceHolder = surfaceHolder;
+                PlayerView.this.mVideoFeedsPlayer.setDisplay(surfaceHolder);
+            } catch (Exception e) {
+                af.b(PlayerView.TAG, e.getMessage());
+            }
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
+            try {
+                af.c(PlayerView.TAG, "surfaceDestroyed ");
+                PlayerView.this.mIsSurfaceHolderDestoryed = true;
+                PlayerView.this.mIsNeedToRepeatPrepare = true;
+                PlayerView.this.mVideoFeedsPlayer.pause();
+                PlayerView.this.pauseOmsdk();
+            } catch (Exception e) {
+                af.b(PlayerView.TAG, e.getMessage());
+            }
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i2, int i3) {
+            try {
+                af.c(PlayerView.TAG, "surfaceChanged");
+                if (PlayerView.this.mIsSurfaceHolderDestoryed && !PlayerView.this.mIsCovered && !PlayerView.this.isComplete() && !PlayerView.this.isBTVideo && !b.c) {
+                    if (PlayerView.this.mVideoFeedsPlayer.hasPrepare()) {
+                        af.c(PlayerView.TAG, "surfaceChanged  start====");
+                        PlayerView.this.resumeStart();
+                    } else {
+                        af.c(PlayerView.TAG, "surfaceChanged  PLAY====");
+                        PlayerView.this.playVideo(0);
+                        PlayerView.this.resumeOMSDK();
+                    }
+                    if (PlayerView.this.isBTVideo) {
+                        if (PlayerView.this.isBTVideoPlaying) {
+                            if (!PlayerView.this.mVideoFeedsPlayer.hasPrepare()) {
+                                PlayerView.this.mVideoFeedsPlayer.prepare();
+                            }
+                            PlayerView.this.mVideoFeedsPlayer.start(false);
+                            PlayerView.this.resumeOMSDK();
+                        } else {
+                            PlayerView.this.pause();
+                        }
+                    }
+                }
+                PlayerView.this.mIsSurfaceHolderDestoryed = false;
+            } catch (Exception e) {
+                af.b(PlayerView.TAG, e.getMessage());
+            }
+        }
+    }
+
+    public boolean isComplete() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                return videoFeedsPlayer.isComplete();
+            }
+            return false;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage(), th);
+            return false;
+        }
+    }
+
+    public void initBufferIngParam(int i) {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.initBufferIngParam(i);
+        }
+    }
+
+    public boolean isPlayIng() {
+        try {
+            VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+            if (videoFeedsPlayer != null) {
+                return videoFeedsPlayer.isPlayIng();
+            }
+            return false;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            return false;
+        }
+    }
+
+    public void setIsCovered(boolean z) {
+        try {
+            this.mIsCovered = z;
+            af.b(TAG, "mIsCovered:" + z);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public boolean isSilent() {
+        return this.mVideoFeedsPlayer.isSilent();
+    }
+
+    public void setVolume(float f, float f2) {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.setVolume(f, f2);
+        }
+    }
+
+    public void setPlaybackParams(float f) {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.setPlaybackParams(f);
+        }
+    }
+
+    @Override // android.view.ViewGroup
+    public boolean onInterceptTouchEvent(MotionEvent motionEvent) {
+        this.xInScreen = motionEvent.getRawX();
+        this.yInScreen = motionEvent.getRawY();
+        return super.onInterceptTouchEvent(motionEvent);
+    }
+
+    public JSONObject buildH5JsonObject(int i) {
+        JSONObject jSONObject;
+        JSONObject jSONObject2 = new JSONObject();
+        try {
+            jSONObject = new JSONObject();
+        } catch (JSONException e) {
+            e = e;
+        }
+        try {
+            jSONObject.put(a.h, ak.b(c.m().c(), this.xInScreen));
+            jSONObject.put(a.i, ak.b(c.m().c(), this.yInScreen));
+            jSONObject.put(a.m, i);
+            try {
+                this.orientation = getContext().getResources().getConfiguration().orientation;
+            } catch (Exception e2) {
+                e2.printStackTrace();
+            }
+            jSONObject.put(a.k, this.orientation);
+            jSONObject.put(a.l, ak.d(getContext()));
+            return jSONObject;
+        } catch (JSONException e3) {
+            e = e3;
+            jSONObject2 = jSONObject;
+            e.printStackTrace();
+            return jSONObject2;
+        }
+    }
+
+    @Override // android.view.View
+    public void onVisibilityChanged(View view, int i) {
+        super.onVisibilityChanged(view, i);
+        try {
+            if (ah.a().a("i_l_s_t_r_i", false) && i == 0 && !this.mHasReportedData) {
+                this.mHasReportedData = true;
+                OnPlayerViewVisibleListener onPlayerViewVisibleListener = this.onPlayerViewVisibleListener;
+                if (onPlayerViewVisibleListener != null) {
+                    onPlayerViewVisibleListener.playerViewVisibleCallback();
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void seekToEndFrame() {
+        VideoFeedsPlayer videoFeedsPlayer = this.mVideoFeedsPlayer;
+        if (videoFeedsPlayer != null) {
+            videoFeedsPlayer.seekToEndFrame();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/R.java

@@ -0,0 +1,182 @@
+package com.mbridge.msdk.playercommon;
+
+/* loaded from: classes4.dex */
+public final class R {
+
+    public static final class attr {
+        public static int corner = 0x7f0400b4;
+
+        private attr() {
+        }
+    }
+
+    public static final class color {
+        public static int mbridge_black = 0x7f0600ab;
+        public static int mbridge_black_66 = 0x7f0600ac;
+        public static int mbridge_black_alpha_50 = 0x7f0600ad;
+        public static int mbridge_cm_feedback_dialog_chice_bg_pressed = 0x7f0600ae;
+        public static int mbridge_cm_feedback_rb_text_color_color_list = 0x7f0600af;
+        public static int mbridge_common_white = 0x7f0600b3;
+        public static int mbridge_cpb_blue = 0x7f0600b4;
+        public static int mbridge_cpb_blue_dark = 0x7f0600b5;
+        public static int mbridge_cpb_green = 0x7f0600b6;
+        public static int mbridge_cpb_green_dark = 0x7f0600b7;
+        public static int mbridge_cpb_grey = 0x7f0600b8;
+        public static int mbridge_cpb_red = 0x7f0600b9;
+        public static int mbridge_cpb_red_dark = 0x7f0600ba;
+        public static int mbridge_cpb_white = 0x7f0600bb;
+        public static int mbridge_dd_grey = 0x7f0600bc;
+        public static int mbridge_ee_grey = 0x7f0600bd;
+        public static int mbridge_purple_200 = 0x7f0600c7;
+        public static int mbridge_purple_500 = 0x7f0600c8;
+        public static int mbridge_purple_700 = 0x7f0600c9;
+        public static int mbridge_teal_200 = 0x7f0600da;
+        public static int mbridge_teal_700 = 0x7f0600db;
+        public static int mbridge_video_common_alertview_bg = 0x7f0600dc;
+        public static int mbridge_video_common_alertview_cancel_button_bg_default = 0x7f0600dd;
+        public static int mbridge_video_common_alertview_cancel_button_bg_pressed = 0x7f0600de;
+        public static int mbridge_video_common_alertview_cancel_button_textcolor = 0x7f0600df;
+        public static int mbridge_video_common_alertview_confirm_button_bg_default = 0x7f0600e0;
+        public static int mbridge_video_common_alertview_confirm_button_bg_pressed = 0x7f0600e1;
+        public static int mbridge_video_common_alertview_confirm_button_textcolor = 0x7f0600e2;
+        public static int mbridge_video_common_alertview_content_textcolor = 0x7f0600e3;
+        public static int mbridge_video_common_alertview_feedback_rb_bg = 0x7f0600e4;
+        public static int mbridge_video_common_alertview_title_textcolor = 0x7f0600e5;
+        public static int mbridge_white = 0x7f0600e6;
+
+        private color() {
+        }
+    }
+
+    public static final class dimen {
+        public static int mbridge_video_common_alertview_bg_padding = 0x7f0700fa;
+        public static int mbridge_video_common_alertview_button_height = 0x7f0700fb;
+        public static int mbridge_video_common_alertview_button_margintop = 0x7f0700fc;
+        public static int mbridge_video_common_alertview_button_radius = 0x7f0700fd;
+        public static int mbridge_video_common_alertview_button_textsize = 0x7f0700fe;
+        public static int mbridge_video_common_alertview_button_width = 0x7f0700ff;
+        public static int mbridge_video_common_alertview_content_margintop = 0x7f070100;
+        public static int mbridge_video_common_alertview_content_size = 0x7f070101;
+        public static int mbridge_video_common_alertview_contentview_maxwidth = 0x7f070102;
+        public static int mbridge_video_common_alertview_contentview_minwidth = 0x7f070103;
+        public static int mbridge_video_common_alertview_title_size = 0x7f070104;
+
+        private dimen() {
+        }
+    }
+
+    public static final class drawable {
+        public static int mbridge_cm_alertview_bg = 0x7f0801a2;
+        public static int mbridge_cm_alertview_cancel_bg = 0x7f0801a3;
+        public static int mbridge_cm_alertview_cancel_bg_nor = 0x7f0801a4;
+        public static int mbridge_cm_alertview_cancel_bg_pressed = 0x7f0801a5;
+        public static int mbridge_cm_alertview_confirm_bg = 0x7f0801a6;
+        public static int mbridge_cm_alertview_confirm_bg_nor = 0x7f0801a7;
+        public static int mbridge_cm_alertview_confirm_bg_pressed = 0x7f0801a8;
+        public static int mbridge_cm_backward = 0x7f0801a9;
+        public static int mbridge_cm_backward_disabled = 0x7f0801aa;
+        public static int mbridge_cm_backward_nor = 0x7f0801ab;
+        public static int mbridge_cm_backward_selected = 0x7f0801ac;
+        public static int mbridge_cm_browser = 0x7f0801ad;
+        public static int mbridge_cm_btn_shake = 0x7f0801ae;
+        public static int mbridge_cm_circle_50black = 0x7f0801af;
+        public static int mbridge_cm_end_animation = 0x7f0801b0;
+        public static int mbridge_cm_exits = 0x7f0801b1;
+        public static int mbridge_cm_exits_nor = 0x7f0801b2;
+        public static int mbridge_cm_exits_selected = 0x7f0801b3;
+        public static int mbridge_cm_feedback_btn_bg = 0x7f0801b4;
+        public static int mbridge_cm_feedback_choice_btn_bg = 0x7f0801b5;
+        public static int mbridge_cm_feedback_choice_btn_bg_nor = 0x7f0801b6;
+        public static int mbridge_cm_feedback_choice_btn_bg_pressed = 0x7f0801b7;
+        public static int mbridge_cm_feedback_dialog_view_bg = 0x7f0801b8;
+        public static int mbridge_cm_feedback_dialog_view_btn_bg = 0x7f0801b9;
+        public static int mbridge_cm_forward = 0x7f0801ba;
+        public static int mbridge_cm_forward_disabled = 0x7f0801bb;
+        public static int mbridge_cm_forward_nor = 0x7f0801bc;
+        public static int mbridge_cm_forward_selected = 0x7f0801bd;
+        public static int mbridge_cm_head = 0x7f0801be;
+        public static int mbridge_cm_highlight = 0x7f0801bf;
+        public static int mbridge_cm_progress = 0x7f0801c0;
+        public static int mbridge_cm_progress_drawable = 0x7f0801c1;
+        public static int mbridge_cm_progress_icon = 0x7f0801c2;
+        public static int mbridge_cm_refresh = 0x7f0801c3;
+        public static int mbridge_cm_refresh_nor = 0x7f0801c4;
+        public static int mbridge_cm_refresh_selected = 0x7f0801c5;
+        public static int mbridge_cm_tail = 0x7f0801c6;
+        public static int mbridge_download_message_dialog_star_sel = 0x7f0801c9;
+        public static int mbridge_download_message_dilaog_star_nor = 0x7f0801ca;
+        public static int mbridge_shape_btn = 0x7f08021c;
+        public static int mbridge_shape_line = 0x7f08021e;
+
+        private drawable() {
+        }
+    }
+
+    public static final class id {
+        public static int mbridge_interstitial_pb = 0x7f0a0187;
+        public static int mbridge_playercommon_ll_loading = 0x7f0a01b8;
+        public static int mbridge_playercommon_ll_sur_container = 0x7f0a01b9;
+        public static int mbridge_playercommon_rl_root = 0x7f0a01ba;
+        public static int mbridge_progressBar = 0x7f0a01bc;
+        public static int mbridge_video_common_alertview_cancel_button = 0x7f0a020d;
+        public static int mbridge_video_common_alertview_confirm_button = 0x7f0a020e;
+        public static int mbridge_video_common_alertview_contentview = 0x7f0a020f;
+        public static int mbridge_video_common_alertview_contentview_scrollview = 0x7f0a0210;
+        public static int mbridge_video_common_alertview_private_action_button = 0x7f0a0211;
+        public static int mbridge_video_common_alertview_titleview = 0x7f0a0212;
+
+        private id() {
+        }
+    }
+
+    public static final class layout {
+        public static int mbridge_cm_alertview = 0x7f0d0066;
+        public static int mbridge_cm_feedback_notice_layout = 0x7f0d0067;
+        public static int mbridge_cm_feedbackview = 0x7f0d0068;
+        public static int mbridge_cm_loading_layout = 0x7f0d0069;
+        public static int mbridge_playercommon_player_view = 0x7f0d0073;
+
+        private layout() {
+        }
+    }
+
+    public static final class string {
+        public static int mbridge_cm_feedback_btn_text = 0x7f12013c;
+        public static int mbridge_cm_feedback_dialog_close_close = 0x7f12013d;
+        public static int mbridge_cm_feedback_dialog_close_submit = 0x7f12013e;
+        public static int mbridge_cm_feedback_dialog_content_fraud = 0x7f12013f;
+        public static int mbridge_cm_feedback_dialog_content_misleading = 0x7f120140;
+        public static int mbridge_cm_feedback_dialog_content_not_play = 0x7f120141;
+        public static int mbridge_cm_feedback_dialog_content_other = 0x7f120142;
+        public static int mbridge_cm_feedback_dialog_content_por_violence = 0x7f120143;
+        public static int mbridge_cm_feedback_dialog_content_sound_problems = 0x7f120144;
+        public static int mbridge_cm_feedback_dialog_privacy_des = 0x7f120145;
+        public static int mbridge_cm_feedback_dialog_submit_notice = 0x7f120146;
+        public static int mbridge_cm_feedback_dialog_title = 0x7f120147;
+
+        private string() {
+        }
+    }
+
+    public static final class style {
+        public static int AppBaseTheme = 0x7f130005;
+        public static int MBridgeAppTheme = 0x7f1300ec;
+        public static int mbridge_common_activity_style = 0x7f1301f8;
+        public static int mbridge_transparent_common_activity_style = 0x7f1301fa;
+        public static int myDialog = 0x7f1301fc;
+
+        private style() {
+        }
+    }
+
+    public static final class styleable {
+        public static int[] RoundRectImageView = {com.ea.games.r3_row.R.attr.corner};
+        public static int RoundRectImageView_corner;
+
+        private styleable() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/VideoFeedsPlayer.java

@@ -0,0 +1,966 @@
+package com.mbridge.msdk.playercommon;
+
+import android.content.Context;
+import android.net.Uri;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.text.TextUtils;
+import android.view.SurfaceHolder;
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.mbridge.msdk.foundation.tools.ab;
+import com.mbridge.msdk.foundation.tools.af;
+import com.mbridge.msdk.playercommon.exoplayer2.DefaultLoadControl;
+import com.mbridge.msdk.playercommon.exoplayer2.DefaultRenderersFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlayerFactory;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.SimpleExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ExtractorMediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.DefaultTrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DefaultDataSourceFactory;
+import java.lang.ref.WeakReference;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/* loaded from: classes4.dex */
+public class VideoFeedsPlayer implements Player.EventListener {
+    public static final int INTERVAL_TIME_PLAY_TIME_CD_THREAD = 1000;
+    public static final String TAG = "VideoFeedsPlayer";
+    private SimpleExoPlayer exoPlayer;
+    private Timer mBufferTimeoutTimer;
+    private long mCurrentPosition;
+    private View mFullScreenLoadingView;
+    private volatile VideoPlayerStatusListener mInnerVFPLisener;
+    private boolean mIsSilent;
+    private WeakReference<View> mLoadingView;
+    private volatile VideoPlayerStatusListener mOutterVFListener;
+    private String mPlayUrl;
+    private SurfaceHolder mSurfaceHolder;
+    private MediaSource mediaSource;
+    private boolean mIsComplete = false;
+    private boolean mIsPlaying = false;
+    private boolean mHasPrepare = false;
+    private boolean mIsBuffering = false;
+    private boolean mIsNeedBufferingTimeout = false;
+    private boolean mIsFrontDesk = true;
+    private int mBufferTime = 5;
+    private Object mLock = new Object();
+    private boolean isStart = false;
+    private final Handler mHandler = new Handler(Looper.getMainLooper()) { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.1
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            super.handleMessage(message);
+        }
+    };
+    private Runnable playProgressRunnable = new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.2
+        @Override // java.lang.Runnable
+        public void run() {
+            long j;
+            try {
+                if (VideoFeedsPlayer.this.exoPlayer == null || !VideoFeedsPlayer.this.exoPlayerIsPlaying()) {
+                    return;
+                }
+                VideoFeedsPlayer videoFeedsPlayer = VideoFeedsPlayer.this;
+                videoFeedsPlayer.mCurrentPosition = videoFeedsPlayer.exoPlayer.getCurrentPosition();
+                float f = VideoFeedsPlayer.this.mCurrentPosition % 1000;
+                int round = Math.round(VideoFeedsPlayer.this.mCurrentPosition / 1000.0f);
+                af.c(VideoFeedsPlayer.TAG, "currentPosition:" + round + " mCurrentPosition:" + VideoFeedsPlayer.this.mCurrentPosition);
+                if (VideoFeedsPlayer.this.exoPlayer == null || VideoFeedsPlayer.this.exoPlayer.getDuration() <= 0) {
+                    j = 0;
+                } else {
+                    j = VideoFeedsPlayer.this.exoPlayer.getDuration() / 1000;
+                    if (f > 0.0f && f < 500.0f) {
+                        round++;
+                    }
+                }
+                if (round >= 0 && j > 0 && round < 1 + j) {
+                    VideoFeedsPlayer.this.postOnPlayProgressOnMainThread(round, (int) j);
+                }
+                VideoFeedsPlayer.this.mIsComplete = false;
+                if (!VideoFeedsPlayer.this.mIsBuffering) {
+                    VideoFeedsPlayer.this.hideLoading();
+                }
+                VideoFeedsPlayer.this.mHandler.postDelayed(this, 1000L);
+            } catch (Exception e) {
+                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+            }
+        }
+    };
+
+    public int getCurPosition() {
+        return (int) this.mCurrentPosition;
+    }
+
+    public boolean hasPrepare() {
+        return this.mHasPrepare;
+    }
+
+    public boolean isComplete() {
+        return this.mIsComplete;
+    }
+
+    public boolean isSilent() {
+        return this.mIsSilent;
+    }
+
+    public void onBufferingUpdate(int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onLoadingChanged(boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPositionDiscontinuity(int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onRepeatModeChanged(int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onSeekProcessed() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onShuffleModeEnabledChanged(boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onTimelineChanged(Timeline timeline, @Nullable Object obj, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onTracksChanged(TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+    }
+
+    public void setIsComplete(boolean z) {
+        this.mIsComplete = z;
+    }
+
+    public void setSelfVideoFeedsPlayerListener(VideoPlayerStatusListener videoPlayerStatusListener) {
+        this.mInnerVFPLisener = videoPlayerStatusListener;
+    }
+
+    public void setVideoFeedsPlayerListener(VideoPlayerStatusListener videoPlayerStatusListener) {
+        this.mOutterVFListener = videoPlayerStatusListener;
+    }
+
+    public boolean initPlayer(Context context, View view, String str, VideoPlayerStatusListener videoPlayerStatusListener) {
+        try {
+            if (view == null) {
+                af.c(TAG, "loadingView is NULL");
+                postOnPlayErrorOnMainThread(PlayerErrorConstant.MEDIAPLAYER_INIT_FAILED);
+                return false;
+            }
+            this.mOutterVFListener = videoPlayerStatusListener;
+            this.mLoadingView = new WeakReference<>(view);
+            this.exoPlayer = ExoPlayerFactory.newSimpleInstance(new DefaultRenderersFactory(context), new DefaultTrackSelector(), new DefaultLoadControl());
+            this.mediaSource = new ExtractorMediaSource.Factory(new DefaultDataSourceFactory(context, "MBridge_ExoPlayer")).createMediaSource(Uri.parse(str));
+            this.exoPlayer.setRepeatMode(0);
+            this.exoPlayer.prepare(this.mediaSource);
+            this.exoPlayer.addListener(this);
+            return true;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            postOnPlayErrorOnMainThread(th.toString());
+            return false;
+        }
+    }
+
+    public void setDisplay(SurfaceHolder surfaceHolder) {
+        try {
+            this.exoPlayer.getVideoComponent().setVideoSurfaceHolder(surfaceHolder);
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            postOnPlayErrorOnMainThread(th.toString());
+        }
+    }
+
+    public void play(String str, int i) {
+        try {
+            synchronized (this.mLock) {
+                try {
+                    af.b(TAG, "Start Play currentionPosition:" + this.mCurrentPosition);
+                    if (i > 0) {
+                        this.mCurrentPosition = i;
+                    }
+                    if (TextUtils.isEmpty(str)) {
+                        postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_URL_ILLEGAL);
+                        return;
+                    }
+                    this.mPlayUrl = str;
+                    this.mHasPrepare = false;
+                    this.mIsFrontDesk = true;
+                    showLoading();
+                    setDataSource();
+                    af.c(TAG, "mPlayUrl:" + this.mPlayUrl);
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            releasePlayer();
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_CANNOT_PALY);
+        }
+    }
+
+    public void play(String str, SurfaceHolder surfaceHolder) {
+        try {
+            synchronized (this.mLock) {
+                try {
+                    if (TextUtils.isEmpty(str)) {
+                        postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_URL_ILLEGAL);
+                        return;
+                    }
+                    this.mPlayUrl = str;
+                    this.mHasPrepare = false;
+                    this.mIsFrontDesk = true;
+                    this.mSurfaceHolder = surfaceHolder;
+                    showLoading();
+                    setDataSource();
+                    af.c(TAG, "mPlayUrl:" + this.mPlayUrl);
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            releasePlayer();
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_CANNOT_PALY);
+        }
+    }
+
+    private void startPlayProgressTimer() {
+        try {
+            cancelPlayProgressTimer();
+            this.mHandler.post(this.playProgressRunnable);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void cancelPlayProgressTimer() {
+        try {
+            this.mHandler.removeCallbacks(this.playProgressRunnable);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void cancelBufferTimeoutTimer() {
+        try {
+            Timer timer = this.mBufferTimeoutTimer;
+            if (timer != null) {
+                timer.cancel();
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void startBufferIngTimer(final String str) {
+        if (!this.mIsNeedBufferingTimeout) {
+            af.b(TAG, "不需要缓冲超时功能");
+            return;
+        }
+        cancelBufferTimeoutTimer();
+        Timer timer = new Timer();
+        this.mBufferTimeoutTimer = timer;
+        timer.schedule(new TimerTask() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.3
+            @Override // java.util.TimerTask, java.lang.Runnable
+            public void run() {
+                try {
+                    if (VideoFeedsPlayer.this.mHasPrepare && !VideoFeedsPlayer.this.mIsBuffering) {
+                        return;
+                    }
+                    af.b(VideoFeedsPlayer.TAG, "缓冲超时");
+                    VideoFeedsPlayer.this.postOnBufferingStarOnMainThread(str);
+                } catch (Exception e) {
+                    af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                }
+            }
+        }, this.mBufferTime * 1000);
+    }
+
+    public void initBufferIngParam(int i) {
+        if (i > 0) {
+            this.mBufferTime = i;
+        }
+        this.mIsNeedBufferingTimeout = true;
+        af.c(TAG, "mIsNeedBufferingTimeout:" + this.mIsNeedBufferingTimeout + "  mMaxBufferTime:" + this.mBufferTime);
+    }
+
+    public void onCompletion() {
+        try {
+            this.mIsComplete = true;
+            this.mIsPlaying = false;
+            this.mCurrentPosition = 0L;
+            hideLoading();
+            postOnPlayCompletedOnMainThread();
+            af.c(TAG, "======onCompletion");
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void onPrepared() {
+        try {
+            af.c(TAG, "onPrepared:" + this.mHasPrepare);
+            this.mHasPrepare = true;
+            boolean z = this.mIsFrontDesk;
+            if (!z) {
+                af.b(TAG, "At background, Do not process");
+                if (this.exoPlayer != null) {
+                    pause();
+                    return;
+                }
+                return;
+            }
+            if (z) {
+                hideLoading();
+                SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+                if (simpleExoPlayer != null) {
+                    this.mIsPlaying = true;
+                    if (!this.isStart) {
+                        postOnPlayStartOnMainThread(simpleExoPlayer.getDuration() / 1000);
+                        af.c(TAG, "onPlayStarted()，getCurrentPosition:" + this.exoPlayer.getCurrentPosition());
+                        this.isStart = true;
+                    }
+                }
+                postOnBufferinEndOnMainThread();
+                startPlayProgressTimer();
+                af.c(TAG, "onPrepare mCurrentPosition:" + this.mCurrentPosition + " onPrepare mHasPrepare：" + this.mHasPrepare);
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public void showLoading() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler == null) {
+                return;
+            }
+            handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.4
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (VideoFeedsPlayer.this.mFullScreenLoadingView != null) {
+                        VideoFeedsPlayer.this.mFullScreenLoadingView.setVisibility(0);
+                    }
+                }
+            });
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void hideLoading() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler == null) {
+                return;
+            }
+            handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.5
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (VideoFeedsPlayer.this.mLoadingView != null && VideoFeedsPlayer.this.mLoadingView.get() != null) {
+                        ((View) VideoFeedsPlayer.this.mLoadingView.get()).setVisibility(8);
+                    }
+                    if (VideoFeedsPlayer.this.mFullScreenLoadingView != null) {
+                        VideoFeedsPlayer.this.mFullScreenLoadingView.setVisibility(8);
+                    }
+                }
+            });
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnPlayProgressOnMainThread(final int i, final int i2) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.6
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onPlayProgress(i, i2);
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onPlayProgress(i, i2);
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnBufferingStarOnMainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.7
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onBufferingStart(str);
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onBufferingStart(str);
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnBufferinEndOnMainThread() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.8
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onBufferingEnd();
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onBufferingEnd();
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlayStartOnMainThread(final long j) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.9
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        int i = (int) j;
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onPlayStarted(i);
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onPlayStarted(i);
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlayErrorOnMainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.10
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onPlayError(str);
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onPlayError(str);
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+            i.a(94, this.mPlayUrl, str);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlaySetDataSourceError2MainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.11
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onPlaySetDataSourceError(str);
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onPlaySetDataSourceError(str);
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlayCompletedOnMainThread() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoFeedsPlayer.12
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoFeedsPlayer.this.mOutterVFListener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mOutterVFListener.onPlayCompleted();
+                            } catch (Exception e) {
+                                af.b(VideoFeedsPlayer.TAG, e.getMessage());
+                            }
+                        }
+                        if (VideoFeedsPlayer.this.mInnerVFPLisener != null) {
+                            try {
+                                VideoFeedsPlayer.this.mInnerVFPLisener.onPlayCompleted();
+                            } catch (Exception e2) {
+                                af.b(VideoFeedsPlayer.TAG, e2.getMessage());
+                            }
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void pause() {
+        try {
+            if (this.mHasPrepare && this.exoPlayer != null && exoPlayerIsPlaying()) {
+                af.c(TAG, "pause isPalying:" + exoPlayerIsPlaying() + " mIsPlaying:" + this.mIsPlaying);
+                hideLoading();
+                this.exoPlayer.setPlayWhenReady(false);
+                this.mIsPlaying = false;
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void prepare() {
+        SimpleExoPlayer simpleExoPlayer;
+        try {
+            if (this.mHasPrepare || (simpleExoPlayer = this.exoPlayer) == null) {
+                return;
+            }
+            simpleExoPlayer.prepare(this.mediaSource);
+            this.mHasPrepare = true;
+            this.mIsPlaying = false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void stop() {
+        try {
+            if (this.mHasPrepare && this.exoPlayer != null && exoPlayerIsPlaying()) {
+                hideLoading();
+                this.exoPlayer.stop();
+                this.mHasPrepare = false;
+                this.mIsPlaying = false;
+                this.mIsComplete = true;
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start(boolean z) {
+        try {
+            if (!this.mHasPrepare) {
+                af.c(TAG, "!mHasPrepare");
+                return;
+            }
+            if (this.exoPlayer == null || exoPlayerIsPlaying()) {
+                return;
+            }
+            showLoading();
+            play();
+            this.mIsPlaying = true;
+            if (z) {
+                startPlayProgressTimer();
+            }
+            af.c(TAG, "start");
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start(int i) {
+        try {
+            if (this.mHasPrepare) {
+                if (this.exoPlayer != null && !exoPlayerIsPlaying()) {
+                    if (i > 0) {
+                        this.exoPlayer.seekTo(i);
+                        play();
+                    } else {
+                        play();
+                        this.mIsPlaying = true;
+                        af.c(TAG, "=========start 指定进度");
+                    }
+                }
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void justSeekTo(int i) {
+        try {
+            this.mCurrentPosition = i;
+            if (this.mHasPrepare) {
+                return;
+            }
+            af.a(TAG, "seekTo return mHasPrepare false");
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void seekTo(int i) {
+        long j = i;
+        try {
+            this.mCurrentPosition = j;
+            if (!this.mHasPrepare) {
+                af.a(TAG, "seekTo return mHasPrepare false");
+                return;
+            }
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer != null) {
+                simpleExoPlayer.seekTo(j);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void setDataSource() {
+        try {
+            af.c(TAG, "setDataSource");
+            if (this.exoPlayer != null) {
+                SurfaceHolder surfaceHolder = this.mSurfaceHolder;
+                if (surfaceHolder != null) {
+                    setDisplay(surfaceHolder);
+                }
+                this.mHasPrepare = false;
+                this.exoPlayer.prepare(this.mediaSource);
+                this.exoPlayer.setPlayWhenReady(true);
+                startBufferIngTimer(PlayerErrorConstant.PREPARE_TIMEOUT);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.ILLEGAL_VIDEO_ADDRESS);
+            postOnPlaySetDataSourceError2MainThread(PlayerErrorConstant.ILLEGAL_VIDEO_ADDRESS);
+        }
+    }
+
+    public void releasePlayer() {
+        try {
+            af.c(TAG, "release");
+            cancelPlayProgressTimer();
+            cancelBufferTimeoutTimer();
+            if (this.exoPlayer != null) {
+                stop();
+                this.exoPlayer.removeListener(this);
+                this.exoPlayer.release();
+                this.mInnerVFPLisener = null;
+                this.mOutterVFListener = null;
+            }
+            hideLoading();
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public void closeSound() {
+        try {
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer == null) {
+                return;
+            }
+            simpleExoPlayer.setVolume(0.0f);
+            this.mIsSilent = true;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void openSound() {
+        try {
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer == null) {
+                return;
+            }
+            simpleExoPlayer.setVolume(1.0f);
+            this.mIsSilent = false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public float getVolume() {
+        SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+        if (simpleExoPlayer != null) {
+            return simpleExoPlayer.getVolume();
+        }
+        return 0.0f;
+    }
+
+    public boolean isPlayIng() {
+        try {
+            if (this.exoPlayer != null) {
+                return exoPlayerIsPlaying();
+            }
+            return false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            return false;
+        }
+    }
+
+    public boolean onError(int i, String str) {
+        try {
+            af.b(TAG, "onError what: " + i + " extra: " + str);
+            hideLoading();
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+        if (!this.mIsFrontDesk && "MIX 3".equalsIgnoreCase(ab.h()) && ab.x().equalsIgnoreCase("Xiaomi")) {
+            return true;
+        }
+        this.mHasPrepare = false;
+        postOnPlayErrorOnMainThread(str);
+        return true;
+    }
+
+    public void setIsFrontDesk(boolean z) {
+        try {
+            this.mIsFrontDesk = z;
+            StringBuilder sb = new StringBuilder();
+            sb.append("isFrontDesk: ");
+            sb.append(z ? "frontStage" : "backStage");
+            af.b(TAG, sb.toString());
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void setFullScreenLoadingView(View view) {
+        if (view != null) {
+            try {
+                this.mFullScreenLoadingView = view;
+            } catch (Exception e) {
+                af.b(TAG, e.getMessage());
+            }
+        }
+    }
+
+    public boolean fullScreenLoadingViewisVisible() {
+        try {
+            View view = this.mFullScreenLoadingView;
+            if (view != null) {
+                return view.getVisibility() == 0;
+            }
+            return false;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            return false;
+        }
+    }
+
+    public boolean halfLoadingViewisVisible() {
+        try {
+            WeakReference<View> weakReference = this.mLoadingView;
+            if (weakReference == null || weakReference.get() == null) {
+                return false;
+            }
+            return this.mLoadingView.get().getVisibility() == 0;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            return false;
+        }
+    }
+
+    public int getDuration() {
+        SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+        if (simpleExoPlayer == null) {
+            return 0;
+        }
+        simpleExoPlayer.getDuration();
+        return 0;
+    }
+
+    public void setVolume(float f, float f2) {
+        try {
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer != null) {
+                simpleExoPlayer.setVolume(f2);
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public void setPlaybackParams(float f) {
+        try {
+            if (exoPlayerIsPlaying()) {
+                this.exoPlayer.setPlaybackParameters(new PlaybackParameters(f));
+            } else {
+                this.exoPlayer.setPlaybackParameters(new PlaybackParameters(f));
+                this.exoPlayer.stop();
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public boolean exoPlayerIsPlaying() {
+        return this.exoPlayer.getPlaybackState() == 3 && this.exoPlayer.getPlayWhenReady();
+    }
+
+    public void play() {
+        this.exoPlayer.setPlayWhenReady(true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlayerStateChanged(boolean z, int i) {
+        af.b(TAG, "onPlaybackStateChanged : " + i);
+        if (i == 1) {
+            af.b(TAG, "onPlaybackStateChanged : IDLE");
+            return;
+        }
+        if (i == 2) {
+            af.b(TAG, "onPlaybackStateChanged : Buffering");
+            this.mIsBuffering = true;
+            showLoading();
+            startBufferIngTimer(PlayerErrorConstant.PLAYERING_TIMEOUT);
+            return;
+        }
+        if (i != 3) {
+            if (i != 4) {
+                return;
+            }
+            af.b(TAG, "onPlaybackStateChanged : Ended : PLAY ENDED");
+            cancelPlayProgressTimer();
+            onCompletion();
+            return;
+        }
+        af.b(TAG, "onPlaybackStateChanged : READY");
+        this.mIsBuffering = false;
+        hideLoading();
+        postOnBufferinEndOnMainThread();
+        onPrepared();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlayerError(ExoPlaybackException exoPlaybackException) {
+        String str;
+        if (exoPlaybackException != null) {
+            int i = exoPlaybackException.type;
+            if (i == 0) {
+                str = "Play error, because have a SourceException.";
+            } else if (i == 1) {
+                str = "Play error, because have a RendererException.";
+            } else if (i == 2) {
+                str = "Play error, because have a UnexpectedException.";
+            }
+            if (exoPlaybackException.getCause() != null && !TextUtils.isEmpty(exoPlaybackException.getCause().getMessage())) {
+                str = exoPlaybackException.getCause().getMessage();
+            }
+            af.b(TAG, "onPlayerError : " + str);
+            onError(exoPlaybackException.type, str);
+        }
+        str = "Play error and ExoPlayer have not message.";
+        if (exoPlaybackException.getCause() != null) {
+            str = exoPlaybackException.getCause().getMessage();
+        }
+        af.b(TAG, "onPlayerError : " + str);
+        onError(exoPlaybackException.type, str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
+        af.b(TAG, "onPlaybackParametersChanged : " + playbackParameters.speed);
+    }
+
+    public void seekToEndFrame() {
+        SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+        if (simpleExoPlayer != null) {
+            simpleExoPlayer.seekTo(simpleExoPlayer.getCurrentPosition() - 500);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/VideoNativePlayer.java

@@ -0,0 +1,842 @@
+package com.mbridge.msdk.playercommon;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.text.TextUtils;
+import android.view.Surface;
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.foundation.same.report.i;
+import com.mbridge.msdk.foundation.tools.af;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.SimpleExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/* loaded from: classes4.dex */
+public class VideoNativePlayer implements Player.EventListener {
+    public static final int INTERVAL_TIME_PLAY_TIME_CD_THREAD = 1000;
+    public static final int INTERVAL_TIME_PLAY_TIME_PROGRESS = 100;
+    public static final String TAG = "VideoNativePlayer";
+    private SimpleExoPlayer exoPlayer;
+    private Timer mBufferTimeoutTimer;
+    private long mCurrentPosition;
+    private VideoPlayerStatusListener mInnerVFPLisener;
+    private View mLoadingView;
+    private String mNetUrl;
+    private VideoPlayerStatusListener mOutterVFListener;
+    private String mPlayUrl;
+    private Surface mSurfaceHolder;
+    private MediaSource mediaSource;
+    private boolean mIsComplete = false;
+    private boolean mIsPlaying = false;
+    private boolean mHasPrepare = false;
+    private boolean mIsStartPlay = true;
+    private boolean mIsAllowLoopPlay = true;
+    private boolean mHasChaoDi = false;
+    private boolean mIsBuffering = false;
+    private boolean mIsNeedBufferingTimeout = false;
+    private boolean mIsFrontDesk = true;
+    private int mBufferTime = 5;
+    private boolean mIsOpenSound = true;
+    private final Handler mHandler = new Handler(Looper.getMainLooper()) { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.1
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            super.handleMessage(message);
+        }
+    };
+    private Runnable playProgressRunnable = new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.2
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                if (VideoNativePlayer.this.exoPlayer == null || !VideoNativePlayer.this.exoPlayerIsPlaying()) {
+                    return;
+                }
+                VideoNativePlayer videoNativePlayer = VideoNativePlayer.this;
+                videoNativePlayer.mCurrentPosition = videoNativePlayer.exoPlayer.getCurrentPosition();
+                int i = (int) (VideoNativePlayer.this.mCurrentPosition / 1000);
+                af.c(VideoNativePlayer.TAG, "currentPosition:" + i + " mCurrentPosition:" + VideoNativePlayer.this.mCurrentPosition);
+                int duration = (VideoNativePlayer.this.exoPlayer == null || VideoNativePlayer.this.exoPlayer.getDuration() <= 0) ? 0 : (int) (VideoNativePlayer.this.exoPlayer.getDuration() / 1000);
+                if (VideoNativePlayer.this.mIsStartPlay) {
+                    VideoNativePlayer.this.postOnPlayStartOnMainThread(duration);
+                    af.c(VideoNativePlayer.TAG, "onPlayStarted()");
+                    VideoNativePlayer.this.mIsStartPlay = false;
+                }
+                if (i >= 0 && duration > 0 && VideoNativePlayer.this.exoPlayerIsPlaying()) {
+                    VideoNativePlayer.this.postOnPlayProgressOnMainThread(i, duration);
+                }
+                VideoNativePlayer.this.mIsComplete = false;
+                if (!VideoNativePlayer.this.mIsBuffering) {
+                    VideoNativePlayer.this.hideLoading();
+                }
+                VideoNativePlayer.this.mHandler.postDelayed(this, 1000L);
+            } catch (Exception e) {
+                af.b(VideoNativePlayer.TAG, e.getMessage());
+            }
+        }
+    };
+    private Runnable playProgressMSRunnable = new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.3
+        @Override // java.lang.Runnable
+        public void run() {
+            try {
+                if (VideoNativePlayer.this.exoPlayer == null || !VideoNativePlayer.this.exoPlayerIsPlaying()) {
+                    return;
+                }
+                VideoNativePlayer videoNativePlayer = VideoNativePlayer.this;
+                videoNativePlayer.mCurrentPosition = videoNativePlayer.exoPlayer.getCurrentPosition();
+                long j = VideoNativePlayer.this.mCurrentPosition / 100;
+                long duration = (VideoNativePlayer.this.exoPlayer == null || VideoNativePlayer.this.exoPlayer.getDuration() <= 0) ? 0L : VideoNativePlayer.this.exoPlayer.getDuration() / 100;
+                if (j >= 0 && duration > 0 && VideoNativePlayer.this.exoPlayerIsPlaying()) {
+                    VideoNativePlayer videoNativePlayer2 = VideoNativePlayer.this;
+                    videoNativePlayer2.postOnPlayProgressMSOnMainThread(videoNativePlayer2.mCurrentPosition / 100, duration);
+                }
+                VideoNativePlayer.this.mHandler.postDelayed(this, 100L);
+            } catch (Exception e) {
+                af.b(VideoNativePlayer.TAG, e.getMessage());
+            }
+        }
+    };
+
+    public int getCurPosition() {
+        return (int) this.mCurrentPosition;
+    }
+
+    public boolean hasPrepare() {
+        return this.mHasPrepare;
+    }
+
+    public boolean isComplete() {
+        return this.mIsComplete;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onLoadingChanged(boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onRepeatModeChanged(int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onSeekProcessed() {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onShuffleModeEnabledChanged(boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onTimelineChanged(Timeline timeline, @Nullable Object obj, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onTracksChanged(TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+    }
+
+    public void setIsComplete(boolean z) {
+        this.mIsComplete = z;
+    }
+
+    public void setSelfVideoFeedsPlayerListener(VideoPlayerStatusListener videoPlayerStatusListener) {
+        this.mInnerVFPLisener = videoPlayerStatusListener;
+    }
+
+    public void setVideoFeedsPlayerListener(VideoPlayerStatusListener videoPlayerStatusListener) {
+        this.mOutterVFListener = videoPlayerStatusListener;
+    }
+
+    public void play(Context context, String str, int i) {
+        try {
+            af.b(TAG, "进来播放 currentionPosition:" + this.mCurrentPosition);
+            this.mCurrentPosition = (long) i;
+            if (TextUtils.isEmpty(str)) {
+                postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_URL_ILLEGAL);
+                return;
+            }
+            showLoading();
+            this.mPlayUrl = str;
+            this.mHasPrepare = false;
+            this.mIsFrontDesk = true;
+            setDataSource(context);
+            af.c(TAG, "mPlayUrl:" + this.mPlayUrl);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            releasePlayer();
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_CANNOT_PALY);
+        }
+    }
+
+    public void play(Context context, String str, Surface surface) {
+        try {
+            if (TextUtils.isEmpty(str)) {
+                postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_URL_ILLEGAL);
+                return;
+            }
+            showLoading();
+            this.mPlayUrl = str;
+            this.mHasPrepare = false;
+            this.mIsFrontDesk = true;
+            this.mSurfaceHolder = surface;
+            setDataSource(context);
+            af.c(TAG, "mPlayUrl:" + this.mPlayUrl);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            releasePlayer();
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_CANNOT_PALY);
+        }
+    }
+
+    public void replaySameSource(Context context, String str, Surface surface) {
+        MediaSource mediaSource;
+        try {
+            showLoading();
+            this.mHasPrepare = false;
+            this.mIsFrontDesk = true;
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer != null && (mediaSource = this.mediaSource) != null) {
+                simpleExoPlayer.prepare(mediaSource);
+                this.exoPlayer.setPlayWhenReady(true);
+            } else {
+                play(context, str, surface);
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            releasePlayer();
+            hideLoading();
+            postOnPlayErrorOnMainThread(PlayerErrorConstant.PLAY_CANNOT_PALY);
+        }
+    }
+
+    private void startPlayProgressTimer() {
+        try {
+            cancelPlayProgressTimer();
+            this.mHandler.post(this.playProgressRunnable);
+            this.mHandler.post(this.playProgressMSRunnable);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void cancelPlayProgressTimer() {
+        try {
+            this.mHandler.removeCallbacks(this.playProgressRunnable);
+            this.mHandler.removeCallbacks(this.playProgressMSRunnable);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void cancelBufferTimeoutTimer() {
+        try {
+            Timer timer = this.mBufferTimeoutTimer;
+            if (timer != null) {
+                timer.cancel();
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void startBufferingTimer(final String str) {
+        if (!this.mIsNeedBufferingTimeout) {
+            af.b(TAG, "不需要缓冲超时功能");
+            return;
+        }
+        cancelBufferTimeoutTimer();
+        Timer timer = new Timer();
+        this.mBufferTimeoutTimer = timer;
+        timer.schedule(new TimerTask() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.4
+            @Override // java.util.TimerTask, java.lang.Runnable
+            public void run() {
+                try {
+                    if (VideoNativePlayer.this.mHasPrepare && !VideoNativePlayer.this.mIsBuffering) {
+                        return;
+                    }
+                    af.b(VideoNativePlayer.TAG, "缓冲超时");
+                    VideoNativePlayer.this.postOnBufferingStarOnMainThread(str);
+                } catch (Exception e) {
+                    af.b(VideoNativePlayer.TAG, e.getMessage());
+                }
+            }
+        }, this.mBufferTime * 1000);
+    }
+
+    public void initBufferIngParam(int i) {
+        if (i > 0) {
+            this.mBufferTime = i;
+        }
+        this.mIsNeedBufferingTimeout = true;
+        af.c(TAG, "mIsNeedBufferingTimeout:" + this.mIsNeedBufferingTimeout + "  mMaxBufferTime:" + this.mBufferTime);
+    }
+
+    public void onCompletion() {
+        try {
+            this.mIsComplete = true;
+            this.mIsPlaying = false;
+            this.mCurrentPosition = 0L;
+            hideLoading();
+            postOnPlayCompletedOnMainThread();
+            af.c(TAG, "======onCompletion");
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void onPrepared() {
+        try {
+            af.c(TAG, "onPrepared:" + this.mHasPrepare);
+            if (this.mIsFrontDesk) {
+                this.mHasPrepare = true;
+                postOnBufferinEndOnMainThread();
+                startPlayProgressTimer();
+                if (this.exoPlayer != null) {
+                    this.mIsPlaying = true;
+                }
+                af.c(TAG, "onprepare mCurrentPosition:" + this.mCurrentPosition + " mHasPrepare：" + this.mHasPrepare);
+                return;
+            }
+            af.b(TAG, "At background, Do not process");
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+        }
+    }
+
+    public void showLoading() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler == null) {
+                return;
+            }
+            handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.5
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (VideoNativePlayer.this.mLoadingView != null) {
+                        VideoNativePlayer.this.mLoadingView.setVisibility(0);
+                    }
+                }
+            });
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void hideLoading() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler == null) {
+                return;
+            }
+            handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.6
+                @Override // java.lang.Runnable
+                public void run() {
+                    if (VideoNativePlayer.this.mLoadingView != null) {
+                        VideoNativePlayer.this.mLoadingView.setVisibility(8);
+                    }
+                }
+            });
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnPlayProgressOnMainThread(final int i, final int i2) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.7
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlayProgress(i, i2);
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlayProgress(i, i2);
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnPlayProgressMSOnMainThread(final long j, final long j2) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.8
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlayProgressMS((int) j, (int) j2);
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlayProgressMS((int) j, (int) j2);
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnBufferingStarOnMainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.9
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onBufferingStart(str);
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onBufferingStart(str);
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnBufferinEndOnMainThread() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.10
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onBufferingEnd();
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onBufferingEnd();
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void postOnPlayStartOnMainThread(final int i) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.11
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlayStarted(i);
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlayStarted(i);
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlayErrorOnMainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.12
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlayError(str);
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlayError(str);
+                        }
+                    }
+                });
+            }
+            i.a(42, this.mPlayUrl, str);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlaySetDataSourceError2MainThread(final String str) {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.13
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlaySetDataSourceError(str);
+                        }
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlaySetDataSourceError(str);
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    private void postOnPlayCompletedOnMainThread() {
+        try {
+            Handler handler = this.mHandler;
+            if (handler != null) {
+                handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.VideoNativePlayer.14
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        if (VideoNativePlayer.this.mOutterVFListener != null) {
+                            VideoNativePlayer.this.mOutterVFListener.onPlayCompleted();
+                        }
+                        if (VideoNativePlayer.this.mInnerVFPLisener != null) {
+                            VideoNativePlayer.this.mInnerVFPLisener.onPlayCompleted();
+                        }
+                    }
+                });
+            }
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void pause() {
+        try {
+            af.c(TAG, "player pause");
+            if (!this.mHasPrepare) {
+                af.c(TAG, "pause !mHasPrepare retrun");
+                return;
+            }
+            if (this.exoPlayer == null || !exoPlayerIsPlaying()) {
+                return;
+            }
+            af.c(TAG, "pause " + this.mIsPlaying);
+            hideLoading();
+            this.exoPlayer.setPlayWhenReady(false);
+            this.mIsPlaying = false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void stop() {
+        try {
+            if (!this.mHasPrepare) {
+                af.c(TAG, "stop !mHasPrepare retrun");
+                return;
+            }
+            if (this.exoPlayer == null || !exoPlayerIsPlaying()) {
+                return;
+            }
+            hideLoading();
+            this.exoPlayer.stop();
+            cancelPlayProgressTimer();
+            this.mIsPlaying = false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start() {
+        start((Surface) null);
+    }
+
+    public void start(Surface surface) {
+        try {
+            if (!this.mHasPrepare) {
+                af.c(TAG, "start !mHasPrepare retrun");
+                return;
+            }
+            boolean z = true;
+            if (this.exoPlayer != null && !exoPlayerIsPlaying()) {
+                showLoading();
+                if (surface != null) {
+                    this.mSurfaceHolder = surface;
+                    this.exoPlayer.setVideoSurface(surface);
+                }
+                play();
+                startPlayProgressTimer();
+                this.mIsPlaying = true;
+                return;
+            }
+            StringBuilder sb = new StringBuilder();
+            sb.append("exoplayer is null : ");
+            if (this.exoPlayer != null) {
+                z = false;
+            }
+            sb.append(z);
+            af.c(TAG, sb.toString());
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void play() {
+        try {
+            this.exoPlayer.setPlayWhenReady(true);
+            startPlayProgressTimer();
+            this.mIsPlaying = true;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void start(int i) {
+        try {
+            if (!this.mHasPrepare) {
+                af.c(TAG, "start mHasprepare is false return");
+                return;
+            }
+            if (this.exoPlayer == null || exoPlayerIsPlaying()) {
+                return;
+            }
+            if (i > 0) {
+                this.exoPlayer.seekTo(i);
+            }
+            play();
+            startPlayProgressTimer();
+            this.mIsPlaying = true;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public boolean initParameter(String str, boolean z, boolean z2, View view, VideoPlayerStatusListener videoPlayerStatusListener) {
+        try {
+            if (TextUtils.isEmpty(str)) {
+                af.c(TAG, "netUrl为空 return");
+                postOnPlayErrorOnMainThread(PlayerErrorConstant.MEDIAPLAYER_INIT_FAILED);
+                return false;
+            }
+            if (view == null) {
+                af.c(TAG, "loadingView为空 return");
+                postOnPlayErrorOnMainThread(PlayerErrorConstant.MEDIAPLAYER_INIT_FAILED);
+                return false;
+            }
+            this.mIsOpenSound = z;
+            this.mIsAllowLoopPlay = z2;
+            this.mLoadingView = view;
+            this.mNetUrl = str;
+            this.mOutterVFListener = videoPlayerStatusListener;
+            return true;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            postOnPlayErrorOnMainThread(th.toString());
+            return false;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0093  */
+    /* JADX WARN: Removed duplicated region for block: B:21:0x0095  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void setDataSource(android.content.Context r7) {
+        /*
+            Method dump skipped, instructions count: 295
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.VideoNativePlayer.setDataSource(android.content.Context):void");
+    }
+
+    public void releasePlayer() {
+        try {
+            af.c(TAG, "releasePlayer");
+            cancelPlayProgressTimer();
+            cancelBufferTimeoutTimer();
+            if (this.exoPlayer != null) {
+                stop();
+                this.exoPlayer.removeListener(this);
+                this.exoPlayer.release();
+                this.exoPlayer = null;
+                this.mIsPlaying = false;
+            }
+            if (this.mOutterVFListener != null) {
+                this.mOutterVFListener = null;
+            }
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage(), th);
+        }
+        hideLoading();
+    }
+
+    public void closeSound() {
+        try {
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer == null) {
+                return;
+            }
+            simpleExoPlayer.setVolume(0.0f);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public void openSound() {
+        try {
+            SimpleExoPlayer simpleExoPlayer = this.exoPlayer;
+            if (simpleExoPlayer == null) {
+                return;
+            }
+            simpleExoPlayer.setVolume(1.0f);
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public boolean isPlayIng() {
+        try {
+            if (this.exoPlayer != null) {
+                return exoPlayerIsPlaying();
+            }
+            return false;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            return false;
+        }
+    }
+
+    public boolean onError(int i, String str) {
+        try {
+            af.b(TAG, "onError what:" + i + " extra:" + str);
+            hideLoading();
+            this.mHasPrepare = false;
+            this.mIsPlaying = false;
+            postOnPlayErrorOnMainThread(str);
+            return true;
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+            return true;
+        }
+    }
+
+    public void setIsFrontDesk(boolean z) {
+        try {
+            this.mIsFrontDesk = z;
+            StringBuilder sb = new StringBuilder();
+            sb.append("isFrontDesk: ");
+            sb.append(z ? "frontStage" : "backStage");
+            af.b(TAG, sb.toString());
+        } catch (Exception e) {
+            af.b(TAG, e.getMessage());
+        }
+    }
+
+    public boolean isPlaying() {
+        return exoPlayerIsPlaying();
+    }
+
+    public boolean loadingViewIsVisible() {
+        try {
+            View view = this.mLoadingView;
+            if (view != null) {
+                return view.getVisibility() == 0;
+            }
+            return false;
+        } catch (Throwable th) {
+            af.b(TAG, th.getMessage());
+            return false;
+        }
+    }
+
+    public boolean exoPlayerIsPlaying() {
+        return this.exoPlayer.getPlaybackState() == 3 && this.exoPlayer.getPlayWhenReady();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlayerStateChanged(boolean z, int i) {
+        af.b(TAG, "onPlaybackStateChanged : " + i);
+        if (i == 1) {
+            af.b(TAG, "onPlaybackStateChanged : IDLE");
+            return;
+        }
+        if (i == 2) {
+            af.b(TAG, "onPlaybackStateChanged : Buffering");
+            this.mIsBuffering = true;
+            showLoading();
+            startBufferingTimer(PlayerErrorConstant.PLAYERING_TIMEOUT);
+            return;
+        }
+        if (i == 3) {
+            af.b(TAG, "onPlaybackStateChanged : READY");
+            this.mIsBuffering = false;
+            hideLoading();
+            postOnBufferinEndOnMainThread();
+            onPrepared();
+            return;
+        }
+        if (i != 4) {
+            return;
+        }
+        af.b(TAG, "onPlaybackStateChanged : Ended : PLAY ENDED");
+        cancelPlayProgressTimer();
+        onCompletion();
+        if (this.mIsAllowLoopPlay) {
+            return;
+        }
+        this.mHasPrepare = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlayerError(ExoPlaybackException exoPlaybackException) {
+        String str;
+        if (exoPlaybackException != null) {
+            int i = exoPlaybackException.type;
+            if (i == 0) {
+                str = "Play error, because have a SourceException.";
+            } else if (i == 1) {
+                str = "Play error, because have a RendererException.";
+            } else if (i == 2) {
+                str = "Play error, because have a UnexpectedException.";
+            }
+            if (exoPlaybackException.getCause() != null && !TextUtils.isEmpty(exoPlaybackException.getCause().getMessage())) {
+                str = exoPlaybackException.getCause().getMessage();
+            }
+            af.b(TAG, "onPlayerError : " + str);
+            onError(exoPlaybackException.type, str);
+        }
+        str = "Play error and ExoPlayer have not message.";
+        if (exoPlaybackException.getCause() != null) {
+            str = exoPlaybackException.getCause().getMessage();
+        }
+        af.b(TAG, "onPlayerError : " + str);
+        onError(exoPlaybackException.type, str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
+        af.b(TAG, "onPlaybackParametersChanged : " + playbackParameters.speed);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public void onPositionDiscontinuity(int i) {
+        af.b(TAG, "onPositionDiscontinuity : " + i);
+        if (i == 0) {
+            onCompletion();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/VideoPlayerStatusListener.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.playercommon;
+
+/* loaded from: classes4.dex */
+public interface VideoPlayerStatusListener {
+    void onBufferingEnd();
+
+    void onBufferingStart(String str);
+
+    void onPlayCompleted();
+
+    void onPlayError(String str);
+
+    void onPlayProgress(int i, int i2);
+
+    void onPlayProgressMS(int i, int i2);
+
+    void onPlaySetDataSourceError(String str);
+
+    void onPlayStarted(int i);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/BaseRenderer.java

@@ -0,0 +1,203 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public abstract class BaseRenderer implements Renderer, RendererCapabilities {
+    private RendererConfiguration configuration;
+    private int index;
+    private boolean readEndOfStream = true;
+    private int state;
+    private SampleStream stream;
+    private Format[] streamFormats;
+    private boolean streamIsFinal;
+    private long streamOffsetUs;
+    private final int trackType;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final RendererCapabilities getCapabilities() {
+        return this;
+    }
+
+    public final RendererConfiguration getConfiguration() {
+        return this.configuration;
+    }
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final int getState() {
+        return this.state;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final SampleStream getStream() {
+        return this.stream;
+    }
+
+    public final Format[] getStreamFormats() {
+        return this.streamFormats;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer, com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public final int getTrackType() {
+        return this.trackType;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean hasReadStreamToEnd() {
+        return this.readEndOfStream;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean isCurrentStreamFinal() {
+        return this.streamIsFinal;
+    }
+
+    public void onDisabled() {
+    }
+
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+    }
+
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+    }
+
+    public void onStarted() throws ExoPlaybackException {
+    }
+
+    public void onStopped() throws ExoPlaybackException {
+    }
+
+    public void onStreamChanged(Format[] formatArr, long j) throws ExoPlaybackException {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void setCurrentStreamFinal() {
+        this.streamIsFinal = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void setIndex(int i) {
+        this.index = i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public int supportsMixedMimeTypeAdaptation() throws ExoPlaybackException {
+        return 0;
+    }
+
+    public BaseRenderer(int i) {
+        this.trackType = i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void enable(RendererConfiguration rendererConfiguration, Format[] formatArr, SampleStream sampleStream, long j, boolean z, long j2) throws ExoPlaybackException {
+        Assertions.checkState(this.state == 0);
+        this.configuration = rendererConfiguration;
+        this.state = 1;
+        onEnabled(z);
+        replaceStream(formatArr, sampleStream, j2);
+        onPositionReset(j, z);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void start() throws ExoPlaybackException {
+        Assertions.checkState(this.state == 1);
+        this.state = 2;
+        onStarted();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void replaceStream(Format[] formatArr, SampleStream sampleStream, long j) throws ExoPlaybackException {
+        Assertions.checkState(!this.streamIsFinal);
+        this.stream = sampleStream;
+        this.readEndOfStream = false;
+        this.streamFormats = formatArr;
+        this.streamOffsetUs = j;
+        onStreamChanged(formatArr, j);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void maybeThrowStreamError() throws IOException {
+        this.stream.maybeThrowError();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void resetPosition(long j) throws ExoPlaybackException {
+        this.streamIsFinal = false;
+        this.readEndOfStream = false;
+        onPositionReset(j, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void stop() throws ExoPlaybackException {
+        Assertions.checkState(this.state == 2);
+        this.state = 1;
+        onStopped();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void disable() {
+        Assertions.checkState(this.state == 1);
+        this.state = 0;
+        this.stream = null;
+        this.streamFormats = null;
+        this.streamIsFinal = false;
+        onDisabled();
+    }
+
+    public final int readSource(FormatHolder formatHolder, DecoderInputBuffer decoderInputBuffer, boolean z) {
+        int readData = this.stream.readData(formatHolder, decoderInputBuffer, z);
+        if (readData == -4) {
+            if (decoderInputBuffer.isEndOfStream()) {
+                this.readEndOfStream = true;
+                return this.streamIsFinal ? -4 : -3;
+            }
+            decoderInputBuffer.timeUs += this.streamOffsetUs;
+        } else if (readData == -5) {
+            Format format = formatHolder.format;
+            long j = format.subsampleOffsetUs;
+            if (j != Long.MAX_VALUE) {
+                formatHolder.format = format.copyWithSubsampleOffsetUs(j + this.streamOffsetUs);
+            }
+        }
+        return readData;
+    }
+
+    public int skipSource(long j) {
+        return this.stream.skipData(j - this.streamOffsetUs);
+    }
+
+    public final boolean isSourceReady() {
+        return this.readEndOfStream ? this.streamIsFinal : this.stream.isReady();
+    }
+
+    public static boolean supportsFormatDrm(@Nullable DrmSessionManager<?> drmSessionManager, @Nullable DrmInitData drmInitData) {
+        if (drmInitData == null) {
+            return true;
+        }
+        if (drmSessionManager == null) {
+            return false;
+        }
+        return drmSessionManager.canAcquireSession(drmInitData);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/C.java

@@ -0,0 +1,233 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.media.AudioManager;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class C {
+    public static final String ASCII_NAME = "US-ASCII";
+    public static final int AUDIO_SESSION_ID_UNSET = 0;
+    public static final int BUFFER_FLAG_DECODE_ONLY = Integer.MIN_VALUE;
+    public static final int BUFFER_FLAG_ENCRYPTED = 1073741824;
+    public static final int BUFFER_FLAG_END_OF_STREAM = 4;
+    public static final int BUFFER_FLAG_KEY_FRAME = 1;
+    public static final String CENC_TYPE_cbc1 = "cbc1";
+    public static final String CENC_TYPE_cbcs = "cbcs";
+    public static final String CENC_TYPE_cenc = "cenc";
+    public static final String CENC_TYPE_cens = "cens";
+    public static final int CHANNEL_OUT_7POINT1_SURROUND;
+    public static final UUID CLEARKEY_UUID;
+    public static final int COLOR_RANGE_FULL = 1;
+    public static final int COLOR_RANGE_LIMITED = 2;
+    public static final int COLOR_SPACE_BT2020 = 6;
+    public static final int COLOR_SPACE_BT601 = 2;
+    public static final int COLOR_SPACE_BT709 = 1;
+    public static final int COLOR_TRANSFER_HLG = 7;
+    public static final int COLOR_TRANSFER_SDR = 3;
+    public static final int COLOR_TRANSFER_ST2084 = 6;
+    public static final UUID COMMON_PSSH_UUID;
+    public static final int CONTENT_TYPE_MOVIE = 3;
+    public static final int CONTENT_TYPE_MUSIC = 2;
+    public static final int CONTENT_TYPE_SONIFICATION = 4;
+    public static final int CONTENT_TYPE_SPEECH = 1;
+    public static final int CONTENT_TYPE_UNKNOWN = 0;
+    public static final int CRYPTO_MODE_AES_CBC = 2;
+    public static final int CRYPTO_MODE_AES_CTR = 1;
+    public static final int CRYPTO_MODE_UNENCRYPTED = 0;
+    public static final int DATA_TYPE_AD = 6;
+    public static final int DATA_TYPE_CUSTOM_BASE = 10000;
+    public static final int DATA_TYPE_DRM = 3;
+    public static final int DATA_TYPE_MANIFEST = 4;
+    public static final int DATA_TYPE_MEDIA = 1;
+    public static final int DATA_TYPE_MEDIA_INITIALIZATION = 2;
+    public static final int DATA_TYPE_TIME_SYNCHRONIZATION = 5;
+    public static final int DATA_TYPE_UNKNOWN = 0;
+    public static final int DEFAULT_AUDIO_BUFFER_SIZE = 3538944;
+    public static final int DEFAULT_BUFFER_SEGMENT_SIZE = 65536;
+    public static final int DEFAULT_METADATA_BUFFER_SIZE = 131072;
+    public static final int DEFAULT_MUXED_BUFFER_SIZE = 16777216;
+    public static final int DEFAULT_TEXT_BUFFER_SIZE = 131072;
+    public static final int DEFAULT_VIDEO_BUFFER_SIZE = 13107200;
+    public static final int ENCODING_AC3 = 5;
+    public static final int ENCODING_DOLBY_TRUEHD = 14;
+    public static final int ENCODING_DTS = 7;
+    public static final int ENCODING_DTS_HD = 8;
+    public static final int ENCODING_E_AC3 = 6;
+    public static final int ENCODING_INVALID = 0;
+    public static final int ENCODING_PCM_16BIT = 2;
+    public static final int ENCODING_PCM_24BIT = Integer.MIN_VALUE;
+    public static final int ENCODING_PCM_32BIT = 1073741824;
+    public static final int ENCODING_PCM_8BIT = 3;
+    public static final int ENCODING_PCM_FLOAT = 4;
+    public static final int FLAG_AUDIBILITY_ENFORCED = 1;
+    public static final int INDEX_UNSET = -1;
+    public static final String LANGUAGE_UNDETERMINED = "und";
+    public static final int LENGTH_UNSET = -1;
+    public static final long MICROS_PER_SECOND = 1000000;
+    public static final int MSG_CUSTOM_BASE = 10000;
+    public static final int MSG_SET_AUDIO_ATTRIBUTES = 3;
+    public static final int MSG_SET_SCALING_MODE = 4;
+    public static final int MSG_SET_SURFACE = 1;
+    public static final int MSG_SET_VOLUME = 2;
+    public static final long NANOS_PER_SECOND = 1000000000;
+    public static final int PERCENTAGE_UNSET = -1;
+    public static final UUID PLAYREADY_UUID;
+    public static final int POSITION_UNSET = -1;
+    public static final int PRIORITY_DOWNLOAD = -1000;
+    public static final int PRIORITY_PLAYBACK = 0;
+    public static final int RESULT_BUFFER_READ = -4;
+    public static final int RESULT_END_OF_INPUT = -1;
+    public static final int RESULT_FORMAT_READ = -5;
+    public static final int RESULT_MAX_LENGTH_EXCEEDED = -2;
+    public static final int RESULT_NOTHING_READ = -3;
+    public static final String SANS_SERIF_NAME = "sans-serif";
+    public static final int SELECTION_FLAG_AUTOSELECT = 4;
+    public static final int SELECTION_FLAG_DEFAULT = 1;
+    public static final int SELECTION_FLAG_FORCED = 2;
+    public static final int SELECTION_REASON_ADAPTIVE = 3;
+    public static final int SELECTION_REASON_CUSTOM_BASE = 10000;
+    public static final int SELECTION_REASON_INITIAL = 1;
+    public static final int SELECTION_REASON_MANUAL = 2;
+    public static final int SELECTION_REASON_TRICK_PLAY = 4;
+    public static final int SELECTION_REASON_UNKNOWN = 0;
+    public static final String SERIF_NAME = "serif";
+    public static final int STEREO_MODE_LEFT_RIGHT = 2;
+    public static final int STEREO_MODE_MONO = 0;
+    public static final int STEREO_MODE_STEREO_MESH = 3;
+    public static final int STEREO_MODE_TOP_BOTTOM = 1;
+    public static final int STREAM_TYPE_ALARM = 4;
+    public static final int STREAM_TYPE_DEFAULT = 3;
+    public static final int STREAM_TYPE_DTMF = 8;
+    public static final int STREAM_TYPE_MUSIC = 3;
+    public static final int STREAM_TYPE_NOTIFICATION = 5;
+    public static final int STREAM_TYPE_RING = 2;
+    public static final int STREAM_TYPE_SYSTEM = 1;
+    public static final int STREAM_TYPE_USE_DEFAULT = Integer.MIN_VALUE;
+    public static final int STREAM_TYPE_VOICE_CALL = 0;
+    public static final long TIME_END_OF_SOURCE = Long.MIN_VALUE;
+    public static final long TIME_UNSET = -9223372036854775807L;
+    public static final int TRACK_TYPE_AUDIO = 1;
+    public static final int TRACK_TYPE_CUSTOM_BASE = 10000;
+    public static final int TRACK_TYPE_DEFAULT = 0;
+    public static final int TRACK_TYPE_METADATA = 4;
+    public static final int TRACK_TYPE_NONE = 5;
+    public static final int TRACK_TYPE_TEXT = 3;
+    public static final int TRACK_TYPE_UNKNOWN = -1;
+    public static final int TRACK_TYPE_VIDEO = 2;
+    public static final int TYPE_DASH = 0;
+    public static final int TYPE_HLS = 2;
+    public static final int TYPE_OTHER = 3;
+    public static final int TYPE_SS = 1;
+    public static final int USAGE_ALARM = 4;
+    public static final int USAGE_ASSISTANCE_ACCESSIBILITY = 11;
+    public static final int USAGE_ASSISTANCE_NAVIGATION_GUIDANCE = 12;
+    public static final int USAGE_ASSISTANCE_SONIFICATION = 13;
+    public static final int USAGE_GAME = 14;
+    public static final int USAGE_MEDIA = 1;
+    public static final int USAGE_NOTIFICATION = 5;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_DELAYED = 9;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_INSTANT = 8;
+    public static final int USAGE_NOTIFICATION_COMMUNICATION_REQUEST = 7;
+    public static final int USAGE_NOTIFICATION_EVENT = 10;
+    public static final int USAGE_NOTIFICATION_RINGTONE = 6;
+    public static final int USAGE_UNKNOWN = 0;
+    public static final int USAGE_VOICE_COMMUNICATION = 2;
+    public static final int USAGE_VOICE_COMMUNICATION_SIGNALLING = 3;
+    public static final String UTF16_NAME = "UTF-16";
+    public static final String UTF8_NAME = "UTF-8";
+    public static final UUID UUID_NIL;
+    public static final int VIDEO_SCALING_MODE_DEFAULT = 1;
+    public static final int VIDEO_SCALING_MODE_SCALE_TO_FIT = 1;
+    public static final int VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING = 2;
+    public static final UUID WIDEVINE_UUID;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AudioContentType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AudioFlags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface AudioUsage {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface BufferFlags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ColorRange {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ColorSpace {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ColorTransfer {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ContentType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface CryptoMode {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Encoding {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface PcmEncoding {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface SelectionFlags {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface StereoMode {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface StreamType {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface VideoScalingMode {
+    }
+
+    private C() {
+    }
+
+    public static long msToUs(long j) {
+        return (j == TIME_UNSET || j == Long.MIN_VALUE) ? j : j * 1000;
+    }
+
+    static {
+        CHANNEL_OUT_7POINT1_SURROUND = Util.SDK_INT < 23 ? 1020 : 6396;
+        UUID_NIL = new UUID(0L, 0L);
+        COMMON_PSSH_UUID = new UUID(1186680826959645954L, -5988876978535335093L);
+        CLEARKEY_UUID = new UUID(-2129748144642739255L, 8654423357094679310L);
+        WIDEVINE_UUID = new UUID(-1301668207276963122L, -6645017420763422227L);
+        PLAYREADY_UUID = new UUID(-7348484286925749626L, -6083546864340672619L);
+    }
+
+    public static long usToMs(long j) {
+        return (j == TIME_UNSET || j == Long.MIN_VALUE) ? j : j / 1000;
+    }
+
+    @TargetApi(21)
+    public static int generateAudioSessionIdV21(Context context) {
+        return ((AudioManager) context.getSystemService("audio")).generateAudioSessionId();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ControlDispatcher.java

@@ -0,0 +1,14 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public interface ControlDispatcher {
+    boolean dispatchSeekTo(Player player, int i, long j);
+
+    boolean dispatchSetPlayWhenReady(Player player, boolean z);
+
+    boolean dispatchSetRepeatMode(Player player, int i);
+
+    boolean dispatchSetShuffleModeEnabled(Player player, boolean z);
+
+    boolean dispatchStop(Player player, boolean z);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/DefaultControlDispatcher.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public class DefaultControlDispatcher implements ControlDispatcher {
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ControlDispatcher
+    public boolean dispatchSetPlayWhenReady(Player player, boolean z) {
+        player.setPlayWhenReady(z);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ControlDispatcher
+    public boolean dispatchSeekTo(Player player, int i, long j) {
+        player.seekTo(i, j);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ControlDispatcher
+    public boolean dispatchSetRepeatMode(Player player, int i) {
+        player.setRepeatMode(i);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ControlDispatcher
+    public boolean dispatchSetShuffleModeEnabled(Player player, boolean z) {
+        player.setShuffleModeEnabled(z);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ControlDispatcher
+    public boolean dispatchStop(Player player, boolean z) {
+        player.stop(z);
+        return true;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/DefaultLoadControl.java

@@ -0,0 +1,208 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DefaultAllocator;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.PriorityTaskManager;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public class DefaultLoadControl implements LoadControl {
+    public static final int DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS = 5000;
+    public static final int DEFAULT_BUFFER_FOR_PLAYBACK_MS = 2500;
+    public static final int DEFAULT_MAX_BUFFER_MS = 50000;
+    public static final int DEFAULT_MIN_BUFFER_MS = 15000;
+    public static final boolean DEFAULT_PRIORITIZE_TIME_OVER_SIZE_THRESHOLDS = true;
+    public static final int DEFAULT_TARGET_BUFFER_BYTES = -1;
+    private final DefaultAllocator allocator;
+    private final long bufferForPlaybackAfterRebufferUs;
+    private final long bufferForPlaybackUs;
+    private boolean isBuffering;
+    private final long maxBufferUs;
+    private final long minBufferUs;
+    private final boolean prioritizeTimeOverSizeThresholds;
+    private final PriorityTaskManager priorityTaskManager;
+    private final int targetBufferBytesOverwrite;
+    private int targetBufferSize;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public Allocator getAllocator() {
+        return this.allocator;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public long getBackBufferDurationUs() {
+        return 0L;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public boolean retainBackBufferFromKeyframe() {
+        return false;
+    }
+
+    public static final class Builder {
+        private DefaultAllocator allocator = null;
+        private int minBufferMs = DefaultLoadControl.DEFAULT_MIN_BUFFER_MS;
+        private int maxBufferMs = 50000;
+        private int bufferForPlaybackMs = 2500;
+        private int bufferForPlaybackAfterRebufferMs = 5000;
+        private int targetBufferBytes = -1;
+        private boolean prioritizeTimeOverSizeThresholds = true;
+        private PriorityTaskManager priorityTaskManager = null;
+
+        public final Builder setAllocator(DefaultAllocator defaultAllocator) {
+            this.allocator = defaultAllocator;
+            return this;
+        }
+
+        public final Builder setBufferDurationsMs(int i, int i2, int i3, int i4) {
+            this.minBufferMs = i;
+            this.maxBufferMs = i2;
+            this.bufferForPlaybackMs = i3;
+            this.bufferForPlaybackAfterRebufferMs = i4;
+            return this;
+        }
+
+        public final Builder setPrioritizeTimeOverSizeThresholds(boolean z) {
+            this.prioritizeTimeOverSizeThresholds = z;
+            return this;
+        }
+
+        public final Builder setPriorityTaskManager(PriorityTaskManager priorityTaskManager) {
+            this.priorityTaskManager = priorityTaskManager;
+            return this;
+        }
+
+        public final Builder setTargetBufferBytes(int i) {
+            this.targetBufferBytes = i;
+            return this;
+        }
+
+        public final DefaultLoadControl createDefaultLoadControl() {
+            if (this.allocator == null) {
+                this.allocator = new DefaultAllocator(true, 65536);
+            }
+            return new DefaultLoadControl(this.allocator, this.minBufferMs, this.maxBufferMs, this.bufferForPlaybackMs, this.bufferForPlaybackAfterRebufferMs, this.targetBufferBytes, this.prioritizeTimeOverSizeThresholds, this.priorityTaskManager);
+        }
+    }
+
+    public DefaultLoadControl() {
+        this(new DefaultAllocator(true, 65536));
+    }
+
+    @Deprecated
+    public DefaultLoadControl(DefaultAllocator defaultAllocator) {
+        this(defaultAllocator, DEFAULT_MIN_BUFFER_MS, 50000, 2500, 5000, -1, true);
+    }
+
+    @Deprecated
+    public DefaultLoadControl(DefaultAllocator defaultAllocator, int i, int i2, int i3, int i4, int i5, boolean z) {
+        this(defaultAllocator, i, i2, i3, i4, i5, z, null);
+    }
+
+    @Deprecated
+    public DefaultLoadControl(DefaultAllocator defaultAllocator, int i, int i2, int i3, int i4, int i5, boolean z, PriorityTaskManager priorityTaskManager) {
+        assertGreaterOrEqual(i3, 0, "bufferForPlaybackMs", "0");
+        assertGreaterOrEqual(i4, 0, "bufferForPlaybackAfterRebufferMs", "0");
+        assertGreaterOrEqual(i, i3, "minBufferMs", "bufferForPlaybackMs");
+        assertGreaterOrEqual(i, i4, "minBufferMs", "bufferForPlaybackAfterRebufferMs");
+        assertGreaterOrEqual(i2, i, "maxBufferMs", "minBufferMs");
+        this.allocator = defaultAllocator;
+        this.minBufferUs = i * 1000;
+        this.maxBufferUs = i2 * 1000;
+        this.bufferForPlaybackUs = i3 * 1000;
+        this.bufferForPlaybackAfterRebufferUs = i4 * 1000;
+        this.targetBufferBytesOverwrite = i5;
+        this.prioritizeTimeOverSizeThresholds = z;
+        this.priorityTaskManager = priorityTaskManager;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public void onPrepared() {
+        reset(false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public void onTracksSelected(Renderer[] rendererArr, TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+        int i = this.targetBufferBytesOverwrite;
+        if (i == -1) {
+            i = calculateTargetBufferSize(rendererArr, trackSelectionArray);
+        }
+        this.targetBufferSize = i;
+        this.allocator.setTargetBufferSize(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public void onStopped() {
+        reset(true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public void onReleased() {
+        reset(true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public boolean shouldContinueLoading(long j, float f) {
+        boolean z;
+        boolean z2 = true;
+        boolean z3 = this.allocator.getTotalBytesAllocated() >= this.targetBufferSize;
+        boolean z4 = this.isBuffering;
+        long j2 = this.minBufferUs;
+        if (f > 1.0f) {
+            j2 = Math.min(Util.getMediaDurationForPlayoutDuration(j2, f), this.maxBufferUs);
+        }
+        if (j < j2) {
+            if (!this.prioritizeTimeOverSizeThresholds && z3) {
+                z2 = false;
+            }
+            this.isBuffering = z2;
+        } else if (j > this.maxBufferUs || z3) {
+            this.isBuffering = false;
+        }
+        PriorityTaskManager priorityTaskManager = this.priorityTaskManager;
+        if (priorityTaskManager != null && (z = this.isBuffering) != z4) {
+            if (z) {
+                priorityTaskManager.add(0);
+            } else {
+                priorityTaskManager.remove(0);
+            }
+        }
+        return this.isBuffering;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.LoadControl
+    public boolean shouldStartPlayback(long j, float f, boolean z) {
+        long playoutDurationForMediaDuration = Util.getPlayoutDurationForMediaDuration(j, f);
+        long j2 = z ? this.bufferForPlaybackAfterRebufferUs : this.bufferForPlaybackUs;
+        return j2 <= 0 || playoutDurationForMediaDuration >= j2 || (!this.prioritizeTimeOverSizeThresholds && this.allocator.getTotalBytesAllocated() >= this.targetBufferSize);
+    }
+
+    public int calculateTargetBufferSize(Renderer[] rendererArr, TrackSelectionArray trackSelectionArray) {
+        int i = 0;
+        for (int i2 = 0; i2 < rendererArr.length; i2++) {
+            if (trackSelectionArray.get(i2) != null) {
+                i += Util.getDefaultBufferSize(rendererArr[i2].getTrackType());
+            }
+        }
+        return i;
+    }
+
+    private void reset(boolean z) {
+        this.targetBufferSize = 0;
+        PriorityTaskManager priorityTaskManager = this.priorityTaskManager;
+        if (priorityTaskManager != null && this.isBuffering) {
+            priorityTaskManager.remove(0);
+        }
+        this.isBuffering = false;
+        if (z) {
+            this.allocator.reset();
+        }
+    }
+
+    private static void assertGreaterOrEqual(int i, int i2, String str, String str2) {
+        Assertions.checkArgument(i >= i2, str + " cannot be less than " + str2);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/DefaultMediaClock.java

@@ -0,0 +1,112 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.StandaloneMediaClock;
+
+/* loaded from: classes4.dex */
+final class DefaultMediaClock implements MediaClock {
+    private final PlaybackParameterListener listener;
+
+    @Nullable
+    private MediaClock rendererClock;
+
+    @Nullable
+    private Renderer rendererClockSource;
+    private final StandaloneMediaClock standaloneMediaClock;
+
+    public interface PlaybackParameterListener {
+        void onPlaybackParametersChanged(PlaybackParameters playbackParameters);
+    }
+
+    public final void onRendererDisabled(Renderer renderer) {
+        if (renderer == this.rendererClockSource) {
+            this.rendererClock = null;
+            this.rendererClockSource = null;
+        }
+    }
+
+    public DefaultMediaClock(PlaybackParameterListener playbackParameterListener, Clock clock) {
+        this.listener = playbackParameterListener;
+        this.standaloneMediaClock = new StandaloneMediaClock(clock);
+    }
+
+    public final void start() {
+        this.standaloneMediaClock.start();
+    }
+
+    public final void stop() {
+        this.standaloneMediaClock.stop();
+    }
+
+    public final void resetPosition(long j) {
+        this.standaloneMediaClock.resetPosition(j);
+    }
+
+    public final void onRendererEnabled(Renderer renderer) throws ExoPlaybackException {
+        MediaClock mediaClock;
+        MediaClock mediaClock2 = renderer.getMediaClock();
+        if (mediaClock2 == null || mediaClock2 == (mediaClock = this.rendererClock)) {
+            return;
+        }
+        if (mediaClock != null) {
+            throw ExoPlaybackException.createForUnexpected(new IllegalStateException("Multiple renderer media clocks enabled."));
+        }
+        this.rendererClock = mediaClock2;
+        this.rendererClockSource = renderer;
+        mediaClock2.setPlaybackParameters(this.standaloneMediaClock.getPlaybackParameters());
+        ensureSynced();
+    }
+
+    public final long syncAndGetPositionUs() {
+        if (isUsingRendererClock()) {
+            ensureSynced();
+            return this.rendererClock.getPositionUs();
+        }
+        return this.standaloneMediaClock.getPositionUs();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public final long getPositionUs() {
+        if (isUsingRendererClock()) {
+            return this.rendererClock.getPositionUs();
+        }
+        return this.standaloneMediaClock.getPositionUs();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public final PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        MediaClock mediaClock = this.rendererClock;
+        if (mediaClock != null) {
+            playbackParameters = mediaClock.setPlaybackParameters(playbackParameters);
+        }
+        this.standaloneMediaClock.setPlaybackParameters(playbackParameters);
+        this.listener.onPlaybackParametersChanged(playbackParameters);
+        return playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public final PlaybackParameters getPlaybackParameters() {
+        MediaClock mediaClock = this.rendererClock;
+        if (mediaClock != null) {
+            return mediaClock.getPlaybackParameters();
+        }
+        return this.standaloneMediaClock.getPlaybackParameters();
+    }
+
+    private void ensureSynced() {
+        this.standaloneMediaClock.resetPosition(this.rendererClock.getPositionUs());
+        PlaybackParameters playbackParameters = this.rendererClock.getPlaybackParameters();
+        if (playbackParameters.equals(this.standaloneMediaClock.getPlaybackParameters())) {
+            return;
+        }
+        this.standaloneMediaClock.setPlaybackParameters(playbackParameters);
+        this.listener.onPlaybackParametersChanged(playbackParameters);
+    }
+
+    private boolean isUsingRendererClock() {
+        Renderer renderer = this.rendererClockSource;
+        return (renderer == null || renderer.isEnded() || (!this.rendererClockSource.isReady() && this.rendererClockSource.hasReadStreamToEnd())) ? false : true;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/DefaultRenderersFactory.java

@@ -0,0 +1,173 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioCapabilities;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.MediaCodecAudioRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.text.TextOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.text.TextRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.video.MediaCodecVideoRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+
+/* loaded from: classes4.dex */
+public class DefaultRenderersFactory implements RenderersFactory {
+    public static final long DEFAULT_ALLOWED_VIDEO_JOINING_TIME_MS = 5000;
+    public static final int EXTENSION_RENDERER_MODE_OFF = 0;
+    public static final int EXTENSION_RENDERER_MODE_ON = 1;
+    public static final int EXTENSION_RENDERER_MODE_PREFER = 2;
+    protected static final int MAX_DROPPED_VIDEO_FRAME_COUNT_TO_NOTIFY = 50;
+    private static final String TAG = "DefaultRenderersFactory";
+    private final long allowedVideoJoiningTimeMs;
+    private final Context context;
+
+    @Nullable
+    private final DrmSessionManager<FrameworkMediaCrypto> drmSessionManager;
+    private final int extensionRendererMode;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ExtensionRendererMode {
+    }
+
+    public AudioProcessor[] buildAudioProcessors() {
+        return new AudioProcessor[0];
+    }
+
+    public void buildMiscellaneousRenderers(Context context, Handler handler, int i, ArrayList<Renderer> arrayList) {
+    }
+
+    public DefaultRenderersFactory(Context context) {
+        this(context, 0);
+    }
+
+    @Deprecated
+    public DefaultRenderersFactory(Context context, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        this(context, drmSessionManager, 0);
+    }
+
+    public DefaultRenderersFactory(Context context, int i) {
+        this(context, null, i, 5000L);
+    }
+
+    @Deprecated
+    public DefaultRenderersFactory(Context context, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, int i) {
+        this(context, drmSessionManager, i, 5000L);
+    }
+
+    public DefaultRenderersFactory(Context context, int i, long j) {
+        this(context, null, i, j);
+    }
+
+    @Deprecated
+    public DefaultRenderersFactory(Context context, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, int i, long j) {
+        this.context = context;
+        this.extensionRendererMode = i;
+        this.allowedVideoJoiningTimeMs = j;
+        this.drmSessionManager = drmSessionManager;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RenderersFactory
+    public Renderer[] createRenderers(Handler handler, VideoRendererEventListener videoRendererEventListener, AudioRendererEventListener audioRendererEventListener, TextOutput textOutput, MetadataOutput metadataOutput, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        DrmSessionManager<FrameworkMediaCrypto> drmSessionManager2 = drmSessionManager == null ? this.drmSessionManager : drmSessionManager;
+        ArrayList<Renderer> arrayList = new ArrayList<>();
+        DrmSessionManager<FrameworkMediaCrypto> drmSessionManager3 = drmSessionManager2;
+        buildVideoRenderers(this.context, drmSessionManager3, this.allowedVideoJoiningTimeMs, handler, videoRendererEventListener, this.extensionRendererMode, arrayList);
+        buildAudioRenderers(this.context, drmSessionManager3, buildAudioProcessors(), handler, audioRendererEventListener, this.extensionRendererMode, arrayList);
+        buildTextRenderers(this.context, textOutput, handler.getLooper(), this.extensionRendererMode, arrayList);
+        buildMetadataRenderers(this.context, metadataOutput, handler.getLooper(), this.extensionRendererMode, arrayList);
+        buildMiscellaneousRenderers(this.context, handler, this.extensionRendererMode, arrayList);
+        return (Renderer[]) arrayList.toArray(new Renderer[arrayList.size()]);
+    }
+
+    public void buildVideoRenderers(Context context, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, long j, Handler handler, VideoRendererEventListener videoRendererEventListener, int i, ArrayList<Renderer> arrayList) {
+        arrayList.add(new MediaCodecVideoRenderer(context, MediaCodecSelector.DEFAULT, j, drmSessionManager, false, handler, videoRendererEventListener, 50));
+        if (i == 0) {
+            return;
+        }
+        int size = arrayList.size();
+        if (i == 2) {
+            size--;
+        }
+        try {
+            arrayList.add(size, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.vp9.LibvpxVideoRenderer").getConstructor(Boolean.TYPE, Long.TYPE, Handler.class, VideoRendererEventListener.class, Integer.TYPE).newInstance(Boolean.TRUE, Long.valueOf(j), handler, videoRendererEventListener, 50));
+        } catch (ClassNotFoundException unused) {
+        } catch (Exception e) {
+            throw new RuntimeException("Error instantiating VP9 extension", e);
+        }
+    }
+
+    public void buildAudioRenderers(Context context, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, AudioProcessor[] audioProcessorArr, Handler handler, AudioRendererEventListener audioRendererEventListener, int i, ArrayList<Renderer> arrayList) {
+        AudioProcessor[] audioProcessorArr2;
+        int i2;
+        arrayList.add(new MediaCodecAudioRenderer(context, MediaCodecSelector.DEFAULT, drmSessionManager, false, handler, audioRendererEventListener, AudioCapabilities.getCapabilities(context), audioProcessorArr));
+        if (i == 0) {
+            return;
+        }
+        int size = arrayList.size();
+        if (i == 2) {
+            size--;
+        }
+        try {
+            try {
+                audioProcessorArr2 = audioProcessorArr;
+                try {
+                    i2 = size + 1;
+                    try {
+                        arrayList.add(size, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.opus.LibopusAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+                    } catch (ClassNotFoundException unused) {
+                        size = i2;
+                        i2 = size;
+                        try {
+                            int i3 = i2 + 1;
+                            try {
+                                arrayList.add(i2, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.flac.LibflacAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+                            } catch (ClassNotFoundException unused2) {
+                                i2 = i3;
+                                i3 = i2;
+                                arrayList.add(i3, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.ffmpeg.FfmpegAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+                            }
+                            arrayList.add(i3, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.ffmpeg.FfmpegAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+                        } catch (Exception e) {
+                            throw new RuntimeException("Error instantiating FLAC extension", e);
+                        }
+                    }
+                } catch (ClassNotFoundException unused3) {
+                }
+            } catch (Exception e2) {
+                throw new RuntimeException("Error instantiating Opus extension", e2);
+            }
+        } catch (ClassNotFoundException unused4) {
+            audioProcessorArr2 = audioProcessorArr;
+        }
+        try {
+            int i32 = i2 + 1;
+            arrayList.add(i2, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.flac.LibflacAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+        } catch (ClassNotFoundException unused5) {
+        }
+        try {
+            arrayList.add(i32, (Renderer) Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.ffmpeg.FfmpegAudioRenderer").getConstructor(Handler.class, AudioRendererEventListener.class, AudioProcessor[].class).newInstance(handler, audioRendererEventListener, audioProcessorArr2));
+        } catch (ClassNotFoundException unused6) {
+        } catch (Exception e3) {
+            throw new RuntimeException("Error instantiating FFmpeg extension", e3);
+        }
+    }
+
+    public void buildTextRenderers(Context context, TextOutput textOutput, Looper looper, int i, ArrayList<Renderer> arrayList) {
+        arrayList.add(new TextRenderer(textOutput, looper));
+    }
+
+    public void buildMetadataRenderers(Context context, MetadataOutput metadataOutput, Looper looper, int i, ArrayList<Renderer> arrayList) {
+        arrayList.add(new MetadataRenderer(metadataOutput, looper));
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ExoPlaybackException.java

@@ -0,0 +1,52 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class ExoPlaybackException extends Exception {
+    public static final int TYPE_RENDERER = 1;
+    public static final int TYPE_SOURCE = 0;
+    public static final int TYPE_UNEXPECTED = 2;
+    public final int rendererIndex;
+    public final int type;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Type {
+    }
+
+    public static ExoPlaybackException createForRenderer(Exception exc, int i) {
+        return new ExoPlaybackException(1, null, exc, i);
+    }
+
+    public static ExoPlaybackException createForSource(IOException iOException) {
+        return new ExoPlaybackException(0, null, iOException, -1);
+    }
+
+    public static ExoPlaybackException createForUnexpected(RuntimeException runtimeException) {
+        return new ExoPlaybackException(2, null, runtimeException, -1);
+    }
+
+    private ExoPlaybackException(int i, String str, Throwable th, int i2) {
+        super(str, th);
+        this.type = i;
+        this.rendererIndex = i2;
+    }
+
+    public final IOException getSourceException() {
+        Assertions.checkState(this.type == 0);
+        return (IOException) getCause();
+    }
+
+    public final Exception getRendererException() {
+        Assertions.checkState(this.type == 1);
+        return (Exception) getCause();
+    }
+
+    public final RuntimeException getUnexpectedException() {
+        Assertions.checkState(this.type == 2);
+        return (RuntimeException) getCause();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ExoPlayer.java

@@ -0,0 +1,70 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.os.Looper;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+
+/* loaded from: classes4.dex */
+public interface ExoPlayer extends Player {
+
+    @Deprecated
+    public static final int REPEAT_MODE_ALL = 2;
+
+    @Deprecated
+    public static final int REPEAT_MODE_OFF = 0;
+
+    @Deprecated
+    public static final int REPEAT_MODE_ONE = 1;
+
+    @Deprecated
+    public static final int STATE_BUFFERING = 2;
+
+    @Deprecated
+    public static final int STATE_ENDED = 4;
+
+    @Deprecated
+    public static final int STATE_IDLE = 1;
+
+    @Deprecated
+    public static final int STATE_READY = 3;
+
+    @Deprecated
+    public interface EventListener extends Player.EventListener {
+    }
+
+    @Deprecated
+    public interface ExoPlayerComponent extends PlayerMessage.Target {
+    }
+
+    @Deprecated
+    void blockingSendMessages(ExoPlayerMessage... exoPlayerMessageArr);
+
+    PlayerMessage createMessage(PlayerMessage.Target target);
+
+    Looper getPlaybackLooper();
+
+    void prepare(MediaSource mediaSource);
+
+    void prepare(MediaSource mediaSource, boolean z, boolean z2);
+
+    @Deprecated
+    void sendMessages(ExoPlayerMessage... exoPlayerMessageArr);
+
+    void setSeekParameters(@Nullable SeekParameters seekParameters);
+
+    @Deprecated
+    public static final class ExoPlayerMessage {
+        public final Object message;
+        public final int messageType;
+        public final PlayerMessage.Target target;
+
+        @Deprecated
+        public ExoPlayerMessage(PlayerMessage.Target target, int i, Object obj) {
+            this.target = target;
+            this.messageType = i;
+            this.message = obj;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ExoPlayerFactory.java

@@ -0,0 +1,67 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsCollector;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+
+/* loaded from: classes4.dex */
+public final class ExoPlayerFactory {
+    private ExoPlayerFactory() {
+    }
+
+    @Deprecated
+    public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector, LoadControl loadControl) {
+        return newSimpleInstance(new DefaultRenderersFactory(context), trackSelector, loadControl);
+    }
+
+    @Deprecated
+    public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        return newSimpleInstance(new DefaultRenderersFactory(context), trackSelector, loadControl, drmSessionManager);
+    }
+
+    @Deprecated
+    public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, int i) {
+        return newSimpleInstance(new DefaultRenderersFactory(context, i), trackSelector, loadControl, drmSessionManager);
+    }
+
+    @Deprecated
+    public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, int i, long j) {
+        return newSimpleInstance(new DefaultRenderersFactory(context, i, j), trackSelector, loadControl, drmSessionManager);
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(Context context, TrackSelector trackSelector) {
+        return newSimpleInstance(new DefaultRenderersFactory(context), trackSelector);
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(RenderersFactory renderersFactory, TrackSelector trackSelector) {
+        return newSimpleInstance(renderersFactory, trackSelector, new DefaultLoadControl());
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(RenderersFactory renderersFactory, TrackSelector trackSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        return newSimpleInstance(renderersFactory, trackSelector, new DefaultLoadControl(), drmSessionManager);
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl) {
+        return new SimpleExoPlayer(renderersFactory, trackSelector, loadControl, null);
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        return new SimpleExoPlayer(renderersFactory, trackSelector, loadControl, drmSessionManager);
+    }
+
+    public static SimpleExoPlayer newSimpleInstance(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, AnalyticsCollector.Factory factory) {
+        return new SimpleExoPlayer(renderersFactory, trackSelector, loadControl, drmSessionManager, factory);
+    }
+
+    public static ExoPlayer newInstance(Renderer[] rendererArr, TrackSelector trackSelector) {
+        return newInstance(rendererArr, trackSelector, new DefaultLoadControl());
+    }
+
+    public static ExoPlayer newInstance(Renderer[] rendererArr, TrackSelector trackSelector, LoadControl loadControl) {
+        return new ExoPlayerImpl(rendererArr, trackSelector, loadControl, Clock.DEFAULT);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ExoPlayerImpl.java

@@ -0,0 +1,652 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.annotation.SuppressLint;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import com.mbridge.msdk.foundation.tools.af;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectorResult;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes4.dex */
+final class ExoPlayerImpl implements ExoPlayer {
+    private static final String TAG = "ExoPlayerImpl";
+    private final TrackSelectorResult emptyTrackSelectorResult;
+    private final Handler eventHandler;
+    private boolean hasPendingPrepare;
+    private boolean hasPendingSeek;
+    private final ExoPlayerImplInternal internalPlayer;
+    private final Handler internalPlayerHandler;
+    private final CopyOnWriteArraySet<Player.EventListener> listeners;
+    private int maskingPeriodIndex;
+    private int maskingWindowIndex;
+    private long maskingWindowPositionMs;
+    private int pendingOperationAcks;
+    private final ArrayDeque<PlaybackInfoUpdate> pendingPlaybackInfoUpdates;
+    private final Timeline.Period period;
+    private boolean playWhenReady;
+
+    @Nullable
+    private ExoPlaybackException playbackError;
+    private PlaybackInfo playbackInfo;
+    private PlaybackParameters playbackParameters;
+    private final Renderer[] renderers;
+    private int repeatMode;
+    private boolean shuffleModeEnabled;
+    private final TrackSelector trackSelector;
+    private final Timeline.Window window;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean getPlayWhenReady() {
+        return this.playWhenReady;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    @Nullable
+    public final ExoPlaybackException getPlaybackError() {
+        return this.playbackError;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final PlaybackParameters getPlaybackParameters() {
+        return this.playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getRepeatMode() {
+        return this.repeatMode;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean getShuffleModeEnabled() {
+        return this.shuffleModeEnabled;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final Player.TextComponent getTextComponent() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final Player.VideoComponent getVideoComponent() {
+        return null;
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public ExoPlayerImpl(Renderer[] rendererArr, TrackSelector trackSelector, LoadControl loadControl, Clock clock) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Init ");
+        sb.append(Integer.toHexString(System.identityHashCode(this)));
+        sb.append(" [");
+        sb.append(ExoPlayerLibraryInfo.VERSION_SLASHY);
+        sb.append("] [");
+        sb.append(Util.DEVICE_DEBUG_INFO);
+        sb.append(v8.i.e);
+        Assertions.checkState(rendererArr.length > 0);
+        this.renderers = (Renderer[]) Assertions.checkNotNull(rendererArr);
+        this.trackSelector = (TrackSelector) Assertions.checkNotNull(trackSelector);
+        this.playWhenReady = false;
+        this.repeatMode = 0;
+        this.shuffleModeEnabled = false;
+        this.listeners = new CopyOnWriteArraySet<>();
+        TrackSelectorResult trackSelectorResult = new TrackSelectorResult(new RendererConfiguration[rendererArr.length], new TrackSelection[rendererArr.length], null);
+        this.emptyTrackSelectorResult = trackSelectorResult;
+        this.window = new Timeline.Window();
+        this.period = new Timeline.Period();
+        this.playbackParameters = PlaybackParameters.DEFAULT;
+        Handler handler = new Handler(Looper.myLooper() != null ? Looper.myLooper() : Looper.getMainLooper()) { // from class: com.mbridge.msdk.playercommon.exoplayer2.ExoPlayerImpl.1
+            @Override // android.os.Handler
+            public void handleMessage(Message message) {
+                ExoPlayerImpl.this.handleEvent(message);
+            }
+        };
+        this.eventHandler = handler;
+        this.playbackInfo = new PlaybackInfo(Timeline.EMPTY, 0L, TrackGroupArray.EMPTY, trackSelectorResult);
+        this.pendingPlaybackInfoUpdates = new ArrayDeque<>();
+        ExoPlayerImplInternal exoPlayerImplInternal = new ExoPlayerImplInternal(rendererArr, trackSelector, trackSelectorResult, loadControl, this.playWhenReady, this.repeatMode, this.shuffleModeEnabled, handler, this, clock);
+        this.internalPlayer = exoPlayerImplInternal;
+        this.internalPlayerHandler = new Handler(exoPlayerImplInternal.getPlaybackLooper());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final Looper getPlaybackLooper() {
+        return this.internalPlayer.getPlaybackLooper();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void addListener(Player.EventListener eventListener) {
+        this.listeners.add(eventListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void removeListener(Player.EventListener eventListener) {
+        this.listeners.remove(eventListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getPlaybackState() {
+        return this.playbackInfo.playbackState;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final void prepare(MediaSource mediaSource) {
+        prepare(mediaSource, true, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final void prepare(MediaSource mediaSource, boolean z, boolean z2) {
+        this.playbackError = null;
+        PlaybackInfo resetPlaybackInfo = getResetPlaybackInfo(z, z2, 2);
+        this.hasPendingPrepare = true;
+        this.pendingOperationAcks++;
+        this.internalPlayer.prepare(mediaSource, z, z2);
+        updatePlaybackInfo(resetPlaybackInfo, false, 4, 1, false, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void setPlayWhenReady(boolean z) {
+        if (this.playWhenReady != z) {
+            this.playWhenReady = z;
+            this.internalPlayer.setPlayWhenReady(z);
+            updatePlaybackInfo(this.playbackInfo, false, 4, 1, false, true);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void setRepeatMode(int i) {
+        if (this.repeatMode != i) {
+            this.repeatMode = i;
+            this.internalPlayer.setRepeatMode(i);
+            Iterator<Player.EventListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                it.next().onRepeatModeChanged(i);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void setShuffleModeEnabled(boolean z) {
+        if (this.shuffleModeEnabled != z) {
+            this.shuffleModeEnabled = z;
+            this.internalPlayer.setShuffleModeEnabled(z);
+            Iterator<Player.EventListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                it.next().onShuffleModeEnabledChanged(z);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean isLoading() {
+        return this.playbackInfo.isLoading;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void seekToDefaultPosition() {
+        seekToDefaultPosition(getCurrentWindowIndex());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void seekToDefaultPosition(int i) {
+        seekTo(i, C.TIME_UNSET);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void seekTo(long j) {
+        seekTo(getCurrentWindowIndex(), j);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void seekTo(int i, long j) {
+        Timeline timeline = this.playbackInfo.timeline;
+        if (i < 0 || (!timeline.isEmpty() && i >= timeline.getWindowCount())) {
+            throw new IllegalSeekPositionException(timeline, i, j);
+        }
+        this.hasPendingSeek = true;
+        this.pendingOperationAcks++;
+        if (isPlayingAd()) {
+            Log.w(TAG, "seekTo ignored because an ad is playing");
+            this.eventHandler.obtainMessage(0, 1, -1, this.playbackInfo).sendToTarget();
+            return;
+        }
+        this.maskingWindowIndex = i;
+        if (timeline.isEmpty()) {
+            this.maskingWindowPositionMs = j == C.TIME_UNSET ? 0L : j;
+            this.maskingPeriodIndex = 0;
+        } else {
+            long defaultPositionUs = j == C.TIME_UNSET ? timeline.getWindow(i, this.window).getDefaultPositionUs() : C.msToUs(j);
+            Pair<Integer, Long> periodPosition = timeline.getPeriodPosition(this.window, this.period, i, defaultPositionUs);
+            this.maskingWindowPositionMs = C.usToMs(defaultPositionUs);
+            this.maskingPeriodIndex = ((Integer) periodPosition.first).intValue();
+        }
+        this.internalPlayer.seekTo(timeline, i, C.msToUs(j));
+        Iterator<Player.EventListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onPositionDiscontinuity(1);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void setPlaybackParameters(@Nullable PlaybackParameters playbackParameters) {
+        if (playbackParameters == null) {
+            playbackParameters = PlaybackParameters.DEFAULT;
+        }
+        this.internalPlayer.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final void setSeekParameters(@Nullable SeekParameters seekParameters) {
+        if (seekParameters == null) {
+            seekParameters = SeekParameters.DEFAULT;
+        }
+        this.internalPlayer.setSeekParameters(seekParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    @Nullable
+    public final Object getCurrentTag() {
+        int currentWindowIndex = getCurrentWindowIndex();
+        if (currentWindowIndex > this.playbackInfo.timeline.getWindowCount()) {
+            return null;
+        }
+        return this.playbackInfo.timeline.getWindow(currentWindowIndex, this.window, true).tag;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void stop() {
+        stop(false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void stop(boolean z) {
+        if (z) {
+            this.playbackError = null;
+        }
+        PlaybackInfo resetPlaybackInfo = getResetPlaybackInfo(z, z, 1);
+        this.pendingOperationAcks++;
+        this.internalPlayer.stop(z);
+        updatePlaybackInfo(resetPlaybackInfo, false, 4, 1, false, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final void release() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("Release ");
+        sb.append(Integer.toHexString(System.identityHashCode(this)));
+        sb.append(" [");
+        sb.append(ExoPlayerLibraryInfo.VERSION_SLASHY);
+        sb.append("] [");
+        sb.append(Util.DEVICE_DEBUG_INFO);
+        sb.append("] [");
+        sb.append(ExoPlayerLibraryInfo.registeredModules());
+        sb.append(v8.i.e);
+        this.internalPlayer.release();
+        this.eventHandler.removeCallbacksAndMessages(null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final void sendMessages(ExoPlayer.ExoPlayerMessage... exoPlayerMessageArr) {
+        for (ExoPlayer.ExoPlayerMessage exoPlayerMessage : exoPlayerMessageArr) {
+            createMessage(exoPlayerMessage.target).setType(exoPlayerMessage.messageType).setPayload(exoPlayerMessage.message).send();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final PlayerMessage createMessage(PlayerMessage.Target target) {
+        return new PlayerMessage(this.internalPlayer, target, this.playbackInfo.timeline, getCurrentWindowIndex(), this.internalPlayerHandler);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public final void blockingSendMessages(ExoPlayer.ExoPlayerMessage... exoPlayerMessageArr) {
+        ArrayList<PlayerMessage> arrayList = new ArrayList();
+        for (ExoPlayer.ExoPlayerMessage exoPlayerMessage : exoPlayerMessageArr) {
+            arrayList.add(createMessage(exoPlayerMessage.target).setType(exoPlayerMessage.messageType).setPayload(exoPlayerMessage.message).send());
+        }
+        boolean z = false;
+        for (PlayerMessage playerMessage : arrayList) {
+            boolean z2 = true;
+            while (z2) {
+                try {
+                    playerMessage.blockUntilDelivered();
+                    z2 = false;
+                } catch (InterruptedException unused) {
+                    z = true;
+                } catch (TimeoutException e) {
+                    af.b(TAG, e.getMessage());
+                }
+            }
+        }
+        if (z) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getCurrentPeriodIndex() {
+        return shouldMaskPosition() ? this.maskingPeriodIndex : this.playbackInfo.periodId.periodIndex;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getCurrentWindowIndex() {
+        if (shouldMaskPosition()) {
+            return this.maskingWindowIndex;
+        }
+        PlaybackInfo playbackInfo = this.playbackInfo;
+        return playbackInfo.timeline.getPeriod(playbackInfo.periodId.periodIndex, this.period).windowIndex;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getNextWindowIndex() {
+        Timeline timeline = this.playbackInfo.timeline;
+        if (timeline.isEmpty()) {
+            return -1;
+        }
+        return timeline.getNextWindowIndex(getCurrentWindowIndex(), this.repeatMode, this.shuffleModeEnabled);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getPreviousWindowIndex() {
+        Timeline timeline = this.playbackInfo.timeline;
+        if (timeline.isEmpty()) {
+            return -1;
+        }
+        return timeline.getPreviousWindowIndex(getCurrentWindowIndex(), this.repeatMode, this.shuffleModeEnabled);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final long getDuration() {
+        Timeline timeline = this.playbackInfo.timeline;
+        if (timeline.isEmpty()) {
+            return C.TIME_UNSET;
+        }
+        if (isPlayingAd()) {
+            MediaSource.MediaPeriodId mediaPeriodId = this.playbackInfo.periodId;
+            timeline.getPeriod(mediaPeriodId.periodIndex, this.period);
+            return C.usToMs(this.period.getAdDurationUs(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup));
+        }
+        return timeline.getWindow(getCurrentWindowIndex(), this.window).getDurationMs();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final long getCurrentPosition() {
+        return shouldMaskPosition() ? this.maskingWindowPositionMs : playbackInfoPositionUsToWindowPositionMs(this.playbackInfo.positionUs);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final long getBufferedPosition() {
+        return shouldMaskPosition() ? this.maskingWindowPositionMs : playbackInfoPositionUsToWindowPositionMs(this.playbackInfo.bufferedPositionUs);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getBufferedPercentage() {
+        long bufferedPosition = getBufferedPosition();
+        long duration = getDuration();
+        if (bufferedPosition == C.TIME_UNSET || duration == C.TIME_UNSET) {
+            return 0;
+        }
+        if (duration == 0) {
+            return 100;
+        }
+        return Util.constrainValue((int) ((bufferedPosition * 100) / duration), 0, 100);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean isCurrentWindowDynamic() {
+        Timeline timeline = this.playbackInfo.timeline;
+        return !timeline.isEmpty() && timeline.getWindow(getCurrentWindowIndex(), this.window).isDynamic;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean isCurrentWindowSeekable() {
+        Timeline timeline = this.playbackInfo.timeline;
+        return !timeline.isEmpty() && timeline.getWindow(getCurrentWindowIndex(), this.window).isSeekable;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final boolean isPlayingAd() {
+        return !shouldMaskPosition() && this.playbackInfo.periodId.isAd();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getCurrentAdGroupIndex() {
+        if (isPlayingAd()) {
+            return this.playbackInfo.periodId.adGroupIndex;
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getCurrentAdIndexInAdGroup() {
+        if (isPlayingAd()) {
+            return this.playbackInfo.periodId.adIndexInAdGroup;
+        }
+        return -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final long getContentPosition() {
+        if (isPlayingAd()) {
+            PlaybackInfo playbackInfo = this.playbackInfo;
+            playbackInfo.timeline.getPeriod(playbackInfo.periodId.periodIndex, this.period);
+            return this.period.getPositionInWindowMs() + C.usToMs(this.playbackInfo.contentPositionUs);
+        }
+        return getCurrentPosition();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getRendererCount() {
+        return this.renderers.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final int getRendererType(int i) {
+        return this.renderers[i].getTrackType();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final TrackGroupArray getCurrentTrackGroups() {
+        return this.playbackInfo.trackGroups;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final TrackSelectionArray getCurrentTrackSelections() {
+        return this.playbackInfo.trackSelectorResult.selections;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final Timeline getCurrentTimeline() {
+        return this.playbackInfo.timeline;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public final Object getCurrentManifest() {
+        return this.playbackInfo.manifest;
+    }
+
+    public final void handleEvent(Message message) {
+        int i = message.what;
+        if (i == 0) {
+            PlaybackInfo playbackInfo = (PlaybackInfo) message.obj;
+            int i2 = message.arg1;
+            int i3 = message.arg2;
+            handlePlaybackInfo(playbackInfo, i2, i3 != -1, i3);
+            return;
+        }
+        if (i != 1) {
+            if (i == 2) {
+                ExoPlaybackException exoPlaybackException = (ExoPlaybackException) message.obj;
+                this.playbackError = exoPlaybackException;
+                Iterator<Player.EventListener> it = this.listeners.iterator();
+                while (it.hasNext()) {
+                    it.next().onPlayerError(exoPlaybackException);
+                }
+                return;
+            }
+            throw new IllegalStateException();
+        }
+        PlaybackParameters playbackParameters = (PlaybackParameters) message.obj;
+        if (this.playbackParameters.equals(playbackParameters)) {
+            return;
+        }
+        this.playbackParameters = playbackParameters;
+        Iterator<Player.EventListener> it2 = this.listeners.iterator();
+        while (it2.hasNext()) {
+            it2.next().onPlaybackParametersChanged(playbackParameters);
+        }
+    }
+
+    private void handlePlaybackInfo(PlaybackInfo playbackInfo, int i, boolean z, int i2) {
+        int i3 = this.pendingOperationAcks - i;
+        this.pendingOperationAcks = i3;
+        if (i3 == 0) {
+            if (playbackInfo.startPositionUs == C.TIME_UNSET) {
+                playbackInfo = playbackInfo.fromNewPosition(playbackInfo.periodId, 0L, playbackInfo.contentPositionUs);
+            }
+            PlaybackInfo playbackInfo2 = playbackInfo;
+            if ((!this.playbackInfo.timeline.isEmpty() || this.hasPendingPrepare) && playbackInfo2.timeline.isEmpty()) {
+                this.maskingPeriodIndex = 0;
+                this.maskingWindowIndex = 0;
+                this.maskingWindowPositionMs = 0L;
+            }
+            int i4 = this.hasPendingPrepare ? 0 : 2;
+            boolean z2 = this.hasPendingSeek;
+            this.hasPendingPrepare = false;
+            this.hasPendingSeek = false;
+            updatePlaybackInfo(playbackInfo2, z, i2, i4, z2, false);
+        }
+    }
+
+    private PlaybackInfo getResetPlaybackInfo(boolean z, boolean z2, int i) {
+        if (z) {
+            this.maskingWindowIndex = 0;
+            this.maskingPeriodIndex = 0;
+            this.maskingWindowPositionMs = 0L;
+        } else {
+            this.maskingWindowIndex = getCurrentWindowIndex();
+            this.maskingPeriodIndex = getCurrentPeriodIndex();
+            this.maskingWindowPositionMs = getCurrentPosition();
+        }
+        Timeline timeline = z2 ? Timeline.EMPTY : this.playbackInfo.timeline;
+        Object obj = z2 ? null : this.playbackInfo.manifest;
+        PlaybackInfo playbackInfo = this.playbackInfo;
+        return new PlaybackInfo(timeline, obj, playbackInfo.periodId, playbackInfo.startPositionUs, playbackInfo.contentPositionUs, i, false, z2 ? TrackGroupArray.EMPTY : playbackInfo.trackGroups, z2 ? this.emptyTrackSelectorResult : playbackInfo.trackSelectorResult);
+    }
+
+    private void updatePlaybackInfo(PlaybackInfo playbackInfo, boolean z, int i, int i2, boolean z2, boolean z3) {
+        boolean z4 = !this.pendingPlaybackInfoUpdates.isEmpty();
+        this.pendingPlaybackInfoUpdates.addLast(new PlaybackInfoUpdate(playbackInfo, this.playbackInfo, this.listeners, this.trackSelector, z, i, i2, z2, this.playWhenReady, z3));
+        this.playbackInfo = playbackInfo;
+        if (z4) {
+            return;
+        }
+        while (!this.pendingPlaybackInfoUpdates.isEmpty()) {
+            this.pendingPlaybackInfoUpdates.peekFirst().notifyListeners();
+            this.pendingPlaybackInfoUpdates.removeFirst();
+        }
+    }
+
+    private long playbackInfoPositionUsToWindowPositionMs(long j) {
+        long usToMs = C.usToMs(j);
+        if (this.playbackInfo.periodId.isAd()) {
+            return usToMs;
+        }
+        PlaybackInfo playbackInfo = this.playbackInfo;
+        playbackInfo.timeline.getPeriod(playbackInfo.periodId.periodIndex, this.period);
+        return usToMs + this.period.getPositionInWindowMs();
+    }
+
+    private boolean shouldMaskPosition() {
+        return this.playbackInfo.timeline.isEmpty() || this.pendingOperationAcks > 0;
+    }
+
+    public static final class PlaybackInfoUpdate {
+        private final boolean isLoadingChanged;
+        private final Set<Player.EventListener> listeners;
+        private final boolean playWhenReady;
+        private final PlaybackInfo playbackInfo;
+        private final boolean playbackStateOrPlayWhenReadyChanged;
+        private final boolean positionDiscontinuity;
+        private final int positionDiscontinuityReason;
+        private final boolean seekProcessed;
+        private final int timelineChangeReason;
+        private final boolean timelineOrManifestChanged;
+        private final TrackSelector trackSelector;
+        private final boolean trackSelectorResultChanged;
+
+        public PlaybackInfoUpdate(PlaybackInfo playbackInfo, PlaybackInfo playbackInfo2, Set<Player.EventListener> set, TrackSelector trackSelector, boolean z, int i, int i2, boolean z2, boolean z3, boolean z4) {
+            this.playbackInfo = playbackInfo;
+            this.listeners = set;
+            this.trackSelector = trackSelector;
+            this.positionDiscontinuity = z;
+            this.positionDiscontinuityReason = i;
+            this.timelineChangeReason = i2;
+            this.seekProcessed = z2;
+            this.playWhenReady = z3;
+            this.playbackStateOrPlayWhenReadyChanged = z4 || playbackInfo2.playbackState != playbackInfo.playbackState;
+            this.timelineOrManifestChanged = (playbackInfo2.timeline == playbackInfo.timeline && playbackInfo2.manifest == playbackInfo.manifest) ? false : true;
+            this.isLoadingChanged = playbackInfo2.isLoading != playbackInfo.isLoading;
+            this.trackSelectorResultChanged = playbackInfo2.trackSelectorResult != playbackInfo.trackSelectorResult;
+        }
+
+        public final void notifyListeners() {
+            if (this.timelineOrManifestChanged || this.timelineChangeReason == 0) {
+                for (Player.EventListener eventListener : this.listeners) {
+                    PlaybackInfo playbackInfo = this.playbackInfo;
+                    eventListener.onTimelineChanged(playbackInfo.timeline, playbackInfo.manifest, this.timelineChangeReason);
+                }
+            }
+            if (this.positionDiscontinuity) {
+                Iterator<Player.EventListener> it = this.listeners.iterator();
+                while (it.hasNext()) {
+                    it.next().onPositionDiscontinuity(this.positionDiscontinuityReason);
+                }
+            }
+            if (this.trackSelectorResultChanged) {
+                this.trackSelector.onSelectionActivated(this.playbackInfo.trackSelectorResult.info);
+                for (Player.EventListener eventListener2 : this.listeners) {
+                    PlaybackInfo playbackInfo2 = this.playbackInfo;
+                    eventListener2.onTracksChanged(playbackInfo2.trackGroups, playbackInfo2.trackSelectorResult.selections);
+                }
+            }
+            if (this.isLoadingChanged) {
+                Iterator<Player.EventListener> it2 = this.listeners.iterator();
+                while (it2.hasNext()) {
+                    it2.next().onLoadingChanged(this.playbackInfo.isLoading);
+                }
+            }
+            if (this.playbackStateOrPlayWhenReadyChanged) {
+                Iterator<Player.EventListener> it3 = this.listeners.iterator();
+                while (it3.hasNext()) {
+                    it3.next().onPlayerStateChanged(this.playWhenReady, this.playbackInfo.playbackState);
+                }
+            }
+            if (this.seekProcessed) {
+                Iterator<Player.EventListener> it4 = this.listeners.iterator();
+                while (it4.hasNext()) {
+                    it4.next().onSeekProcessed();
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ExoPlayerLibraryInfo.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import java.util.HashSet;
+
+/* loaded from: classes4.dex */
+public final class ExoPlayerLibraryInfo {
+    public static final boolean ASSERTIONS_ENABLED = true;
+    public static final String TAG = "ExoPlayer";
+    public static final boolean TRACE_ENABLED = true;
+    public static final String VERSION = "2.8.4";
+    public static final int VERSION_INT = 2008004;
+    public static final String VERSION_SLASHY = "ExoPlayerLib/2.8.4";
+    private static final HashSet<String> registeredModules = new HashSet<>();
+    private static String registeredModulesString = "goog.exo.core";
+
+    private ExoPlayerLibraryInfo() {
+    }
+
+    public static synchronized String registeredModules() {
+        String str;
+        synchronized (ExoPlayerLibraryInfo.class) {
+            str = registeredModulesString;
+        }
+        return str;
+    }
+
+    public static synchronized void registerModule(String str) {
+        synchronized (ExoPlayerLibraryInfo.class) {
+            if (registeredModules.add(str)) {
+                registeredModulesString += ", " + str;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/Format.java

@@ -0,0 +1,411 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.mbridge.msdk.playercommon.exoplayer2.video.ColorInfo;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/* loaded from: classes4.dex */
+public final class Format implements Parcelable {
+    public static final Parcelable.Creator<Format> CREATOR = new Parcelable.Creator<Format>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.Format.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public Format createFromParcel(Parcel parcel) {
+            return new Format(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public Format[] newArray(int i) {
+            return new Format[i];
+        }
+    };
+    public static final int NO_VALUE = -1;
+    public static final long OFFSET_SAMPLE_RELATIVE = Long.MAX_VALUE;
+    public final int accessibilityChannel;
+    public final int bitrate;
+    public final int channelCount;
+
+    @Nullable
+    public final String codecs;
+
+    @Nullable
+    public final ColorInfo colorInfo;
+
+    @Nullable
+    public final String containerMimeType;
+
+    @Nullable
+    public final DrmInitData drmInitData;
+    public final int encoderDelay;
+    public final int encoderPadding;
+    public final float frameRate;
+    private int hashCode;
+    public final int height;
+
+    @Nullable
+    public final String id;
+    public final List<byte[]> initializationData;
+
+    @Nullable
+    public final String language;
+    public final int maxInputSize;
+
+    @Nullable
+    public final Metadata metadata;
+    public final int pcmEncoding;
+    public final float pixelWidthHeightRatio;
+
+    @Nullable
+    public final byte[] projectionData;
+    public final int rotationDegrees;
+
+    @Nullable
+    public final String sampleMimeType;
+    public final int sampleRate;
+    public final int selectionFlags;
+    public final int stereoMode;
+    public final long subsampleOffsetUs;
+    public final int width;
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    public final int getPixelCount() {
+        int i;
+        int i2 = this.width;
+        if (i2 == -1 || (i = this.height) == -1) {
+            return -1;
+        }
+        return i2 * i;
+    }
+
+    public static Format createVideoContainerFormat(@Nullable String str, @Nullable String str2, String str3, String str4, int i, int i2, int i3, float f, List<byte[]> list, int i4) {
+        return new Format(str, str2, str3, str4, i, -1, i2, i3, f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, i4, null, -1, Long.MAX_VALUE, list, null, null);
+    }
+
+    public static Format createVideoSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, float f, List<byte[]> list, @Nullable DrmInitData drmInitData) {
+        return createVideoSampleFormat(str, str2, str3, i, i2, i3, i4, f, list, -1, -1.0f, drmInitData);
+    }
+
+    public static Format createVideoSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, float f, List<byte[]> list, int i5, float f2, @Nullable DrmInitData drmInitData) {
+        return createVideoSampleFormat(str, str2, str3, i, i2, i3, i4, f, list, i5, f2, null, -1, null, drmInitData);
+    }
+
+    public static Format createVideoSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, float f, List<byte[]> list, int i5, float f2, byte[] bArr, int i6, @Nullable ColorInfo colorInfo, @Nullable DrmInitData drmInitData) {
+        return new Format(str, null, str2, str3, i, i2, i3, i4, f, i5, f2, bArr, i6, colorInfo, -1, -1, -1, -1, -1, 0, null, -1, Long.MAX_VALUE, list, drmInitData, null);
+    }
+
+    public static Format createAudioContainerFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4, int i, int i2, int i3, List<byte[]> list, int i4, @Nullable String str5) {
+        return new Format(str, str2, str3, str4, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, i2, i3, -1, -1, -1, i4, str5, -1, Long.MAX_VALUE, list, null, null);
+    }
+
+    public static Format createAudioSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, List<byte[]> list, @Nullable DrmInitData drmInitData, int i5, @Nullable String str4) {
+        return createAudioSampleFormat(str, str2, str3, i, i2, i3, i4, -1, list, drmInitData, i5, str4);
+    }
+
+    public static Format createAudioSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, int i5, List<byte[]> list, @Nullable DrmInitData drmInitData, int i6, @Nullable String str4) {
+        return createAudioSampleFormat(str, str2, str3, i, i2, i3, i4, i5, -1, -1, list, drmInitData, i6, str4, null);
+    }
+
+    public static Format createAudioSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, int i5, int i6, int i7, List<byte[]> list, @Nullable DrmInitData drmInitData, int i8, @Nullable String str4, @Nullable Metadata metadata) {
+        return new Format(str, null, str2, str3, i, i2, -1, -1, -1.0f, -1, -1.0f, null, -1, null, i3, i4, i5, i6, i7, i8, str4, -1, Long.MAX_VALUE, list, drmInitData, metadata);
+    }
+
+    public static Format createTextContainerFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4, int i, int i2, @Nullable String str5) {
+        return createTextContainerFormat(str, str2, str3, str4, i, i2, str5, -1);
+    }
+
+    public static Format createTextContainerFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4, int i, int i2, @Nullable String str5, int i3) {
+        return new Format(str, str2, str3, str4, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, i2, str5, i3, Long.MAX_VALUE, null, null, null);
+    }
+
+    public static Format createTextSampleFormat(@Nullable String str, String str2, int i, @Nullable String str3) {
+        return createTextSampleFormat(str, str2, i, str3, null);
+    }
+
+    public static Format createTextSampleFormat(@Nullable String str, String str2, int i, @Nullable String str3, @Nullable DrmInitData drmInitData) {
+        return createTextSampleFormat(str, str2, null, -1, i, str3, -1, drmInitData, Long.MAX_VALUE, Collections.emptyList());
+    }
+
+    public static Format createTextSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, @Nullable String str4, int i3, @Nullable DrmInitData drmInitData) {
+        return createTextSampleFormat(str, str2, str3, i, i2, str4, i3, drmInitData, Long.MAX_VALUE, Collections.emptyList());
+    }
+
+    public static Format createTextSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, @Nullable String str4, @Nullable DrmInitData drmInitData, long j) {
+        return createTextSampleFormat(str, str2, str3, i, i2, str4, -1, drmInitData, j, Collections.emptyList());
+    }
+
+    public static Format createTextSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, @Nullable String str4, int i3, @Nullable DrmInitData drmInitData, long j, List<byte[]> list) {
+        return new Format(str, null, str2, str3, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, i2, str4, i3, j, list, drmInitData, null);
+    }
+
+    public static Format createImageSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, List<byte[]> list, @Nullable String str4, @Nullable DrmInitData drmInitData) {
+        return new Format(str, null, str2, str3, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, i2, str4, -1, Long.MAX_VALUE, list, drmInitData, null);
+    }
+
+    public static Format createContainerFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4, int i, int i2, @Nullable String str5) {
+        return new Format(str, str2, str3, str4, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, i2, str5, -1, Long.MAX_VALUE, null, null, null);
+    }
+
+    public static Format createSampleFormat(@Nullable String str, @Nullable String str2, long j) {
+        return new Format(str, null, str2, null, -1, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, 0, null, -1, j, null, null, null);
+    }
+
+    public static Format createSampleFormat(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, @Nullable DrmInitData drmInitData) {
+        return new Format(str, null, str2, str3, i, -1, -1, -1, -1.0f, -1, -1.0f, null, -1, null, -1, -1, -1, -1, -1, 0, null, -1, Long.MAX_VALUE, null, drmInitData, null);
+    }
+
+    public Format(@Nullable String str, @Nullable String str2, @Nullable String str3, @Nullable String str4, int i, int i2, int i3, int i4, float f, int i5, float f2, @Nullable byte[] bArr, int i6, @Nullable ColorInfo colorInfo, int i7, int i8, int i9, int i10, int i11, int i12, @Nullable String str5, int i13, long j, @Nullable List<byte[]> list, @Nullable DrmInitData drmInitData, @Nullable Metadata metadata) {
+        this.id = str;
+        this.containerMimeType = str2;
+        this.sampleMimeType = str3;
+        this.codecs = str4;
+        this.bitrate = i;
+        this.maxInputSize = i2;
+        this.width = i3;
+        this.height = i4;
+        this.frameRate = f;
+        int i14 = i5;
+        this.rotationDegrees = i14 == -1 ? 0 : i14;
+        this.pixelWidthHeightRatio = f2 == -1.0f ? 1.0f : f2;
+        this.projectionData = bArr;
+        this.stereoMode = i6;
+        this.colorInfo = colorInfo;
+        this.channelCount = i7;
+        this.sampleRate = i8;
+        this.pcmEncoding = i9;
+        int i15 = i10;
+        this.encoderDelay = i15 == -1 ? 0 : i15;
+        this.encoderPadding = i11 != -1 ? i11 : 0;
+        this.selectionFlags = i12;
+        this.language = str5;
+        this.accessibilityChannel = i13;
+        this.subsampleOffsetUs = j;
+        this.initializationData = list == null ? Collections.emptyList() : list;
+        this.drmInitData = drmInitData;
+        this.metadata = metadata;
+    }
+
+    public Format(Parcel parcel) {
+        this.id = parcel.readString();
+        this.containerMimeType = parcel.readString();
+        this.sampleMimeType = parcel.readString();
+        this.codecs = parcel.readString();
+        this.bitrate = parcel.readInt();
+        this.maxInputSize = parcel.readInt();
+        this.width = parcel.readInt();
+        this.height = parcel.readInt();
+        this.frameRate = parcel.readFloat();
+        this.rotationDegrees = parcel.readInt();
+        this.pixelWidthHeightRatio = parcel.readFloat();
+        this.projectionData = Util.readBoolean(parcel) ? parcel.createByteArray() : null;
+        this.stereoMode = parcel.readInt();
+        this.colorInfo = (ColorInfo) parcel.readParcelable(ColorInfo.class.getClassLoader());
+        this.channelCount = parcel.readInt();
+        this.sampleRate = parcel.readInt();
+        this.pcmEncoding = parcel.readInt();
+        this.encoderDelay = parcel.readInt();
+        this.encoderPadding = parcel.readInt();
+        this.selectionFlags = parcel.readInt();
+        this.language = parcel.readString();
+        this.accessibilityChannel = parcel.readInt();
+        this.subsampleOffsetUs = parcel.readLong();
+        int readInt = parcel.readInt();
+        this.initializationData = new ArrayList(readInt);
+        for (int i = 0; i < readInt; i++) {
+            this.initializationData.add(parcel.createByteArray());
+        }
+        this.drmInitData = (DrmInitData) parcel.readParcelable(DrmInitData.class.getClassLoader());
+        this.metadata = (Metadata) parcel.readParcelable(Metadata.class.getClassLoader());
+    }
+
+    public final Format copyWithMaxInputSize(int i) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, i, this.width, this.height, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, this.selectionFlags, this.language, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, this.drmInitData, this.metadata);
+    }
+
+    public final Format copyWithSubsampleOffsetUs(long j) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, this.maxInputSize, this.width, this.height, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, this.selectionFlags, this.language, this.accessibilityChannel, j, this.initializationData, this.drmInitData, this.metadata);
+    }
+
+    public final Format copyWithContainerInfo(@Nullable String str, @Nullable String str2, @Nullable String str3, int i, int i2, int i3, int i4, @Nullable String str4) {
+        return new Format(str, this.containerMimeType, str2, str3, i, this.maxInputSize, i2, i3, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, i4, str4, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, this.drmInitData, this.metadata);
+    }
+
+    public final Format copyWithManifestFormatInfo(Format format) {
+        if (this == format) {
+            return this;
+        }
+        String str = format.id;
+        String str2 = this.codecs;
+        if (str2 == null) {
+            str2 = format.codecs;
+        }
+        String str3 = str2;
+        int i = this.bitrate;
+        if (i == -1) {
+            i = format.bitrate;
+        }
+        int i2 = i;
+        float f = this.frameRate;
+        if (f == -1.0f) {
+            f = format.frameRate;
+        }
+        float f2 = f;
+        int i3 = this.selectionFlags | format.selectionFlags;
+        String str4 = this.language;
+        if (str4 == null) {
+            str4 = format.language;
+        }
+        return new Format(str, this.containerMimeType, this.sampleMimeType, str3, i2, this.maxInputSize, this.width, this.height, f2, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, i3, str4, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, DrmInitData.createSessionCreationData(format.drmInitData, this.drmInitData), this.metadata);
+    }
+
+    public final Format copyWithGaplessInfo(int i, int i2) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, this.maxInputSize, this.width, this.height, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, i, i2, this.selectionFlags, this.language, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, this.drmInitData, this.metadata);
+    }
+
+    public final Format copyWithDrmInitData(@Nullable DrmInitData drmInitData) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, this.maxInputSize, this.width, this.height, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, this.selectionFlags, this.language, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, drmInitData, this.metadata);
+    }
+
+    public final Format copyWithMetadata(@Nullable Metadata metadata) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, this.maxInputSize, this.width, this.height, this.frameRate, this.rotationDegrees, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, this.selectionFlags, this.language, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, this.drmInitData, metadata);
+    }
+
+    public final Format copyWithRotationDegrees(int i) {
+        return new Format(this.id, this.containerMimeType, this.sampleMimeType, this.codecs, this.bitrate, this.maxInputSize, this.width, this.height, this.frameRate, i, this.pixelWidthHeightRatio, this.projectionData, this.stereoMode, this.colorInfo, this.channelCount, this.sampleRate, this.pcmEncoding, this.encoderDelay, this.encoderPadding, this.selectionFlags, this.language, this.accessibilityChannel, this.subsampleOffsetUs, this.initializationData, this.drmInitData, this.metadata);
+    }
+
+    public final String toString() {
+        return "Format(" + this.id + ", " + this.containerMimeType + ", " + this.sampleMimeType + ", " + this.bitrate + ", " + this.language + ", [" + this.width + ", " + this.height + ", " + this.frameRate + "], [" + this.channelCount + ", " + this.sampleRate + "])";
+    }
+
+    public final int hashCode() {
+        if (this.hashCode == 0) {
+            String str = this.id;
+            int hashCode = (IronSourceError.ERROR_NON_EXISTENT_INSTANCE + (str == null ? 0 : str.hashCode())) * 31;
+            String str2 = this.containerMimeType;
+            int hashCode2 = (hashCode + (str2 == null ? 0 : str2.hashCode())) * 31;
+            String str3 = this.sampleMimeType;
+            int hashCode3 = (hashCode2 + (str3 == null ? 0 : str3.hashCode())) * 31;
+            String str4 = this.codecs;
+            int hashCode4 = (((((((((((hashCode3 + (str4 == null ? 0 : str4.hashCode())) * 31) + this.bitrate) * 31) + this.width) * 31) + this.height) * 31) + this.channelCount) * 31) + this.sampleRate) * 31;
+            String str5 = this.language;
+            int hashCode5 = (((hashCode4 + (str5 == null ? 0 : str5.hashCode())) * 31) + this.accessibilityChannel) * 31;
+            DrmInitData drmInitData = this.drmInitData;
+            int hashCode6 = (hashCode5 + (drmInitData == null ? 0 : drmInitData.hashCode())) * 31;
+            Metadata metadata = this.metadata;
+            this.hashCode = hashCode6 + (metadata != null ? metadata.hashCode() : 0);
+        }
+        return this.hashCode;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || Format.class != obj.getClass()) {
+            return false;
+        }
+        Format format = (Format) obj;
+        return this.bitrate == format.bitrate && this.maxInputSize == format.maxInputSize && this.width == format.width && this.height == format.height && this.frameRate == format.frameRate && this.rotationDegrees == format.rotationDegrees && this.pixelWidthHeightRatio == format.pixelWidthHeightRatio && this.stereoMode == format.stereoMode && this.channelCount == format.channelCount && this.sampleRate == format.sampleRate && this.pcmEncoding == format.pcmEncoding && this.encoderDelay == format.encoderDelay && this.encoderPadding == format.encoderPadding && this.subsampleOffsetUs == format.subsampleOffsetUs && this.selectionFlags == format.selectionFlags && Util.areEqual(this.id, format.id) && Util.areEqual(this.language, format.language) && this.accessibilityChannel == format.accessibilityChannel && Util.areEqual(this.containerMimeType, format.containerMimeType) && Util.areEqual(this.sampleMimeType, format.sampleMimeType) && Util.areEqual(this.codecs, format.codecs) && Util.areEqual(this.drmInitData, format.drmInitData) && Util.areEqual(this.metadata, format.metadata) && Util.areEqual(this.colorInfo, format.colorInfo) && Arrays.equals(this.projectionData, format.projectionData) && initializationDataEquals(format);
+    }
+
+    public final boolean initializationDataEquals(Format format) {
+        if (this.initializationData.size() != format.initializationData.size()) {
+            return false;
+        }
+        for (int i = 0; i < this.initializationData.size(); i++) {
+            if (!Arrays.equals(this.initializationData.get(i), format.initializationData.get(i))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static String toLogString(Format format) {
+        if (format == null) {
+            return "null";
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append("id=");
+        sb.append(format.id);
+        sb.append(", mimeType=");
+        sb.append(format.sampleMimeType);
+        if (format.bitrate != -1) {
+            sb.append(", bitrate=");
+            sb.append(format.bitrate);
+        }
+        if (format.width != -1 && format.height != -1) {
+            sb.append(", res=");
+            sb.append(format.width);
+            sb.append("x");
+            sb.append(format.height);
+        }
+        if (format.frameRate != -1.0f) {
+            sb.append(", fps=");
+            sb.append(format.frameRate);
+        }
+        if (format.channelCount != -1) {
+            sb.append(", channels=");
+            sb.append(format.channelCount);
+        }
+        if (format.sampleRate != -1) {
+            sb.append(", sample_rate=");
+            sb.append(format.sampleRate);
+        }
+        if (format.language != null) {
+            sb.append(", language=");
+            sb.append(format.language);
+        }
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeString(this.id);
+        parcel.writeString(this.containerMimeType);
+        parcel.writeString(this.sampleMimeType);
+        parcel.writeString(this.codecs);
+        parcel.writeInt(this.bitrate);
+        parcel.writeInt(this.maxInputSize);
+        parcel.writeInt(this.width);
+        parcel.writeInt(this.height);
+        parcel.writeFloat(this.frameRate);
+        parcel.writeInt(this.rotationDegrees);
+        parcel.writeFloat(this.pixelWidthHeightRatio);
+        Util.writeBoolean(parcel, this.projectionData != null);
+        byte[] bArr = this.projectionData;
+        if (bArr != null) {
+            parcel.writeByteArray(bArr);
+        }
+        parcel.writeInt(this.stereoMode);
+        parcel.writeParcelable(this.colorInfo, i);
+        parcel.writeInt(this.channelCount);
+        parcel.writeInt(this.sampleRate);
+        parcel.writeInt(this.pcmEncoding);
+        parcel.writeInt(this.encoderDelay);
+        parcel.writeInt(this.encoderPadding);
+        parcel.writeInt(this.selectionFlags);
+        parcel.writeString(this.language);
+        parcel.writeInt(this.accessibilityChannel);
+        parcel.writeLong(this.subsampleOffsetUs);
+        int size = this.initializationData.size();
+        parcel.writeInt(size);
+        for (int i2 = 0; i2 < size; i2++) {
+            parcel.writeByteArray(this.initializationData.get(i2));
+        }
+        parcel.writeParcelable(this.drmInitData, 0);
+        parcel.writeParcelable(this.metadata, 0);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/FormatHolder.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public final class FormatHolder {
+    public Format format;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/IllegalSeekPositionException.java

@@ -0,0 +1,14 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public final class IllegalSeekPositionException extends IllegalStateException {
+    public final long positionMs;
+    public final Timeline timeline;
+    public final int windowIndex;
+
+    public IllegalSeekPositionException(Timeline timeline, int i, long j) {
+        this.timeline = timeline;
+        this.windowIndex = i;
+        this.positionMs = j;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/LoadControl.java

@@ -0,0 +1,26 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+
+/* loaded from: classes4.dex */
+public interface LoadControl {
+    Allocator getAllocator();
+
+    long getBackBufferDurationUs();
+
+    void onPrepared();
+
+    void onReleased();
+
+    void onStopped();
+
+    void onTracksSelected(Renderer[] rendererArr, TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray);
+
+    boolean retainBackBufferFromKeyframe();
+
+    boolean shouldContinueLoading(long j, float f);
+
+    boolean shouldStartPlayback(long j, float f, boolean z);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/MediaPeriodHolder.java

@@ -0,0 +1,234 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.util.Log;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ClippingMediaPeriod;
+import com.mbridge.msdk.playercommon.exoplayer2.source.EmptySampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaPeriod;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelection;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectorResult;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+final class MediaPeriodHolder {
+    private static final String TAG = "MediaPeriodHolder";
+    public boolean hasEnabledTracks;
+    public MediaPeriodInfo info;
+    public final boolean[] mayRetainStreamFlags;
+    public final MediaPeriod mediaPeriod;
+    private final MediaSource mediaSource;
+    public MediaPeriodHolder next;
+    private TrackSelectorResult periodTrackSelectorResult;
+    public boolean prepared;
+    private final RendererCapabilities[] rendererCapabilities;
+    public long rendererPositionOffsetUs;
+    public final SampleStream[] sampleStreams;
+    public TrackGroupArray trackGroups;
+    private final TrackSelector trackSelector;
+    public TrackSelectorResult trackSelectorResult;
+    public final Object uid;
+
+    public final long getRendererOffset() {
+        return this.rendererPositionOffsetUs;
+    }
+
+    public MediaPeriodHolder(RendererCapabilities[] rendererCapabilitiesArr, long j, TrackSelector trackSelector, Allocator allocator, MediaSource mediaSource, Object obj, MediaPeriodInfo mediaPeriodInfo) {
+        this.rendererCapabilities = rendererCapabilitiesArr;
+        this.rendererPositionOffsetUs = j - mediaPeriodInfo.startPositionUs;
+        this.trackSelector = trackSelector;
+        this.mediaSource = mediaSource;
+        this.uid = Assertions.checkNotNull(obj);
+        this.info = mediaPeriodInfo;
+        this.sampleStreams = new SampleStream[rendererCapabilitiesArr.length];
+        this.mayRetainStreamFlags = new boolean[rendererCapabilitiesArr.length];
+        MediaPeriod createPeriod = mediaSource.createPeriod(mediaPeriodInfo.id, allocator);
+        long j2 = mediaPeriodInfo.endPositionUs;
+        this.mediaPeriod = j2 != Long.MIN_VALUE ? new ClippingMediaPeriod(createPeriod, true, 0L, j2) : createPeriod;
+    }
+
+    public final long toRendererTime(long j) {
+        return j + getRendererOffset();
+    }
+
+    public final long toPeriodTime(long j) {
+        return j - getRendererOffset();
+    }
+
+    public final boolean isFullyBuffered() {
+        return this.prepared && (!this.hasEnabledTracks || this.mediaPeriod.getBufferedPositionUs() == Long.MIN_VALUE);
+    }
+
+    public final long getDurationUs() {
+        return this.info.durationUs;
+    }
+
+    public final long getBufferedPositionUs(boolean z) {
+        if (!this.prepared) {
+            return this.info.startPositionUs;
+        }
+        long bufferedPositionUs = this.mediaPeriod.getBufferedPositionUs();
+        return (bufferedPositionUs == Long.MIN_VALUE && z) ? this.info.durationUs : bufferedPositionUs;
+    }
+
+    public final long getNextLoadPositionUs() {
+        if (this.prepared) {
+            return this.mediaPeriod.getNextLoadPositionUs();
+        }
+        return 0L;
+    }
+
+    public final void handlePrepared(float f) throws ExoPlaybackException {
+        this.prepared = true;
+        this.trackGroups = this.mediaPeriod.getTrackGroups();
+        selectTracks(f);
+        long applyTrackSelection = applyTrackSelection(this.info.startPositionUs, false);
+        long j = this.rendererPositionOffsetUs;
+        MediaPeriodInfo mediaPeriodInfo = this.info;
+        this.rendererPositionOffsetUs = j + (mediaPeriodInfo.startPositionUs - applyTrackSelection);
+        this.info = mediaPeriodInfo.copyWithStartPositionUs(applyTrackSelection);
+    }
+
+    public final void reevaluateBuffer(long j) {
+        if (this.prepared) {
+            this.mediaPeriod.reevaluateBuffer(toPeriodTime(j));
+        }
+    }
+
+    public final void continueLoading(long j) {
+        this.mediaPeriod.continueLoading(toPeriodTime(j));
+    }
+
+    public final boolean selectTracks(float f) throws ExoPlaybackException {
+        TrackSelectorResult selectTracks = this.trackSelector.selectTracks(this.rendererCapabilities, this.trackGroups);
+        if (selectTracks.isEquivalent(this.periodTrackSelectorResult)) {
+            return false;
+        }
+        this.trackSelectorResult = selectTracks;
+        for (TrackSelection trackSelection : selectTracks.selections.getAll()) {
+            if (trackSelection != null) {
+                trackSelection.onPlaybackSpeed(f);
+            }
+        }
+        return true;
+    }
+
+    public final long applyTrackSelection(long j, boolean z) {
+        return applyTrackSelection(j, z, new boolean[this.rendererCapabilities.length]);
+    }
+
+    public final long applyTrackSelection(long j, boolean z, boolean[] zArr) {
+        int i = 0;
+        while (true) {
+            TrackSelectorResult trackSelectorResult = this.trackSelectorResult;
+            boolean z2 = true;
+            if (i >= trackSelectorResult.length) {
+                break;
+            }
+            boolean[] zArr2 = this.mayRetainStreamFlags;
+            if (z || !trackSelectorResult.isEquivalent(this.periodTrackSelectorResult, i)) {
+                z2 = false;
+            }
+            zArr2[i] = z2;
+            i++;
+        }
+        disassociateNoSampleRenderersWithEmptySampleStream(this.sampleStreams);
+        updatePeriodTrackSelectorResult(this.trackSelectorResult);
+        TrackSelectionArray trackSelectionArray = this.trackSelectorResult.selections;
+        long selectTracks = this.mediaPeriod.selectTracks(trackSelectionArray.getAll(), this.mayRetainStreamFlags, this.sampleStreams, zArr, j);
+        associateNoSampleRenderersWithEmptySampleStream(this.sampleStreams);
+        this.hasEnabledTracks = false;
+        int i2 = 0;
+        while (true) {
+            SampleStream[] sampleStreamArr = this.sampleStreams;
+            if (i2 >= sampleStreamArr.length) {
+                return selectTracks;
+            }
+            if (sampleStreamArr[i2] != null) {
+                Assertions.checkState(this.trackSelectorResult.isRendererEnabled(i2));
+                if (this.rendererCapabilities[i2].getTrackType() != 5) {
+                    this.hasEnabledTracks = true;
+                }
+            } else {
+                Assertions.checkState(trackSelectionArray.get(i2) == null);
+            }
+            i2++;
+        }
+    }
+
+    public final void release() {
+        updatePeriodTrackSelectorResult(null);
+        try {
+            if (this.info.endPositionUs != Long.MIN_VALUE) {
+                this.mediaSource.releasePeriod(((ClippingMediaPeriod) this.mediaPeriod).mediaPeriod);
+            } else {
+                this.mediaSource.releasePeriod(this.mediaPeriod);
+            }
+        } catch (RuntimeException e) {
+            Log.e(TAG, "Period release failed.", e);
+        }
+    }
+
+    private void updatePeriodTrackSelectorResult(TrackSelectorResult trackSelectorResult) {
+        TrackSelectorResult trackSelectorResult2 = this.periodTrackSelectorResult;
+        if (trackSelectorResult2 != null) {
+            disableTrackSelectionsInResult(trackSelectorResult2);
+        }
+        this.periodTrackSelectorResult = trackSelectorResult;
+        if (trackSelectorResult != null) {
+            enableTrackSelectionsInResult(trackSelectorResult);
+        }
+    }
+
+    private void enableTrackSelectionsInResult(TrackSelectorResult trackSelectorResult) {
+        for (int i = 0; i < trackSelectorResult.length; i++) {
+            boolean isRendererEnabled = trackSelectorResult.isRendererEnabled(i);
+            TrackSelection trackSelection = trackSelectorResult.selections.get(i);
+            if (isRendererEnabled && trackSelection != null) {
+                trackSelection.enable();
+            }
+        }
+    }
+
+    private void disableTrackSelectionsInResult(TrackSelectorResult trackSelectorResult) {
+        for (int i = 0; i < trackSelectorResult.length; i++) {
+            boolean isRendererEnabled = trackSelectorResult.isRendererEnabled(i);
+            TrackSelection trackSelection = trackSelectorResult.selections.get(i);
+            if (isRendererEnabled && trackSelection != null) {
+                trackSelection.disable();
+            }
+        }
+    }
+
+    private void disassociateNoSampleRenderersWithEmptySampleStream(SampleStream[] sampleStreamArr) {
+        int i = 0;
+        while (true) {
+            RendererCapabilities[] rendererCapabilitiesArr = this.rendererCapabilities;
+            if (i >= rendererCapabilitiesArr.length) {
+                return;
+            }
+            if (rendererCapabilitiesArr[i].getTrackType() == 5) {
+                sampleStreamArr[i] = null;
+            }
+            i++;
+        }
+    }
+
+    private void associateNoSampleRenderersWithEmptySampleStream(SampleStream[] sampleStreamArr) {
+        int i = 0;
+        while (true) {
+            RendererCapabilities[] rendererCapabilitiesArr = this.rendererCapabilities;
+            if (i >= rendererCapabilitiesArr.length) {
+                return;
+            }
+            if (rendererCapabilitiesArr[i].getTrackType() == 5 && this.trackSelectorResult.isRendererEnabled(i)) {
+                sampleStreamArr[i] = new EmptySampleStream();
+            }
+            i++;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/MediaPeriodInfo.java

@@ -0,0 +1,32 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+
+/* loaded from: classes4.dex */
+final class MediaPeriodInfo {
+    public final long contentPositionUs;
+    public final long durationUs;
+    public final long endPositionUs;
+    public final MediaSource.MediaPeriodId id;
+    public final boolean isFinal;
+    public final boolean isLastInTimelinePeriod;
+    public final long startPositionUs;
+
+    public MediaPeriodInfo(MediaSource.MediaPeriodId mediaPeriodId, long j, long j2, long j3, long j4, boolean z, boolean z2) {
+        this.id = mediaPeriodId;
+        this.startPositionUs = j;
+        this.endPositionUs = j2;
+        this.contentPositionUs = j3;
+        this.durationUs = j4;
+        this.isLastInTimelinePeriod = z;
+        this.isFinal = z2;
+    }
+
+    public final MediaPeriodInfo copyWithPeriodIndex(int i) {
+        return new MediaPeriodInfo(this.id.copyWithPeriodIndex(i), this.startPositionUs, this.endPositionUs, this.contentPositionUs, this.durationUs, this.isLastInTimelinePeriod, this.isFinal);
+    }
+
+    public final MediaPeriodInfo copyWithStartPositionUs(long j) {
+        return new MediaPeriodInfo(this.id, j, this.endPositionUs, this.contentPositionUs, this.durationUs, this.isLastInTimelinePeriod, this.isFinal);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/MediaPeriodQueue.java

@@ -0,0 +1,432 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaPeriod;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.Allocator;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+final class MediaPeriodQueue {
+    private static final int MAXIMUM_BUFFER_AHEAD_PERIODS = 100;
+    private int length;
+    private MediaPeriodHolder loading;
+    private long nextWindowSequenceNumber;
+    private Object oldFrontPeriodUid;
+    private long oldFrontPeriodWindowSequenceNumber;
+    private MediaPeriodHolder playing;
+    private MediaPeriodHolder reading;
+    private int repeatMode;
+    private boolean shuffleModeEnabled;
+    private Timeline timeline;
+    private final Timeline.Period period = new Timeline.Period();
+    private final Timeline.Window window = new Timeline.Window();
+
+    public final MediaPeriodHolder getLoadingPeriod() {
+        return this.loading;
+    }
+
+    public final MediaPeriodHolder getPlayingPeriod() {
+        return this.playing;
+    }
+
+    public final MediaPeriodHolder getReadingPeriod() {
+        return this.reading;
+    }
+
+    public final boolean hasPlayingPeriod() {
+        return this.playing != null;
+    }
+
+    public final void setTimeline(Timeline timeline) {
+        this.timeline = timeline;
+    }
+
+    public final boolean updateRepeatMode(int i) {
+        this.repeatMode = i;
+        return updateForPlaybackModeChange();
+    }
+
+    public final boolean updateShuffleModeEnabled(boolean z) {
+        this.shuffleModeEnabled = z;
+        return updateForPlaybackModeChange();
+    }
+
+    public final boolean isLoading(MediaPeriod mediaPeriod) {
+        MediaPeriodHolder mediaPeriodHolder = this.loading;
+        return mediaPeriodHolder != null && mediaPeriodHolder.mediaPeriod == mediaPeriod;
+    }
+
+    public final void reevaluateBuffer(long j) {
+        MediaPeriodHolder mediaPeriodHolder = this.loading;
+        if (mediaPeriodHolder != null) {
+            mediaPeriodHolder.reevaluateBuffer(j);
+        }
+    }
+
+    public final boolean shouldLoadNextMediaPeriod() {
+        MediaPeriodHolder mediaPeriodHolder = this.loading;
+        return mediaPeriodHolder == null || (!mediaPeriodHolder.info.isFinal && mediaPeriodHolder.isFullyBuffered() && this.loading.info.durationUs != C.TIME_UNSET && this.length < 100);
+    }
+
+    @Nullable
+    public final MediaPeriodInfo getNextMediaPeriodInfo(long j, PlaybackInfo playbackInfo) {
+        MediaPeriodHolder mediaPeriodHolder = this.loading;
+        if (mediaPeriodHolder == null) {
+            return getFirstMediaPeriodInfo(playbackInfo);
+        }
+        return getFollowingMediaPeriodInfo(mediaPeriodHolder, j);
+    }
+
+    public final MediaPeriod enqueueNextMediaPeriod(RendererCapabilities[] rendererCapabilitiesArr, TrackSelector trackSelector, Allocator allocator, MediaSource mediaSource, Object obj, MediaPeriodInfo mediaPeriodInfo) {
+        long rendererOffset;
+        MediaPeriodHolder mediaPeriodHolder = this.loading;
+        if (mediaPeriodHolder == null) {
+            rendererOffset = mediaPeriodInfo.startPositionUs;
+        } else {
+            rendererOffset = mediaPeriodHolder.getRendererOffset() + this.loading.info.durationUs;
+        }
+        MediaPeriodHolder mediaPeriodHolder2 = new MediaPeriodHolder(rendererCapabilitiesArr, rendererOffset, trackSelector, allocator, mediaSource, obj, mediaPeriodInfo);
+        if (this.loading != null) {
+            Assertions.checkState(hasPlayingPeriod());
+            this.loading.next = mediaPeriodHolder2;
+        }
+        this.oldFrontPeriodUid = null;
+        this.loading = mediaPeriodHolder2;
+        this.length++;
+        return mediaPeriodHolder2.mediaPeriod;
+    }
+
+    public final MediaPeriodHolder getFrontPeriod() {
+        return hasPlayingPeriod() ? this.playing : this.loading;
+    }
+
+    public final MediaPeriodHolder advanceReadingPeriod() {
+        MediaPeriodHolder mediaPeriodHolder = this.reading;
+        Assertions.checkState((mediaPeriodHolder == null || mediaPeriodHolder.next == null) ? false : true);
+        MediaPeriodHolder mediaPeriodHolder2 = this.reading.next;
+        this.reading = mediaPeriodHolder2;
+        return mediaPeriodHolder2;
+    }
+
+    public final MediaPeriodHolder advancePlayingPeriod() {
+        MediaPeriodHolder mediaPeriodHolder = this.playing;
+        if (mediaPeriodHolder != null) {
+            if (mediaPeriodHolder == this.reading) {
+                this.reading = mediaPeriodHolder.next;
+            }
+            mediaPeriodHolder.release();
+            int i = this.length - 1;
+            this.length = i;
+            if (i == 0) {
+                this.loading = null;
+                MediaPeriodHolder mediaPeriodHolder2 = this.playing;
+                this.oldFrontPeriodUid = mediaPeriodHolder2.uid;
+                this.oldFrontPeriodWindowSequenceNumber = mediaPeriodHolder2.info.id.windowSequenceNumber;
+            }
+            this.playing = this.playing.next;
+        } else {
+            MediaPeriodHolder mediaPeriodHolder3 = this.loading;
+            this.playing = mediaPeriodHolder3;
+            this.reading = mediaPeriodHolder3;
+        }
+        return this.playing;
+    }
+
+    public final boolean removeAfter(MediaPeriodHolder mediaPeriodHolder) {
+        boolean z = false;
+        Assertions.checkState(mediaPeriodHolder != null);
+        this.loading = mediaPeriodHolder;
+        while (true) {
+            mediaPeriodHolder = mediaPeriodHolder.next;
+            if (mediaPeriodHolder != null) {
+                if (mediaPeriodHolder == this.reading) {
+                    this.reading = this.playing;
+                    z = true;
+                }
+                mediaPeriodHolder.release();
+                this.length--;
+            } else {
+                this.loading.next = null;
+                return z;
+            }
+        }
+    }
+
+    public final void clear(boolean z) {
+        MediaPeriodHolder frontPeriod = getFrontPeriod();
+        if (frontPeriod != null) {
+            this.oldFrontPeriodUid = z ? frontPeriod.uid : null;
+            this.oldFrontPeriodWindowSequenceNumber = frontPeriod.info.id.windowSequenceNumber;
+            frontPeriod.release();
+            removeAfter(frontPeriod);
+        } else if (!z) {
+            this.oldFrontPeriodUid = null;
+        }
+        this.playing = null;
+        this.loading = null;
+        this.reading = null;
+        this.length = 0;
+    }
+
+    public final boolean updateQueuedPeriods(MediaSource.MediaPeriodId mediaPeriodId, long j) {
+        int i = mediaPeriodId.periodIndex;
+        MediaPeriodHolder mediaPeriodHolder = null;
+        int i2 = i;
+        for (MediaPeriodHolder frontPeriod = getFrontPeriod(); frontPeriod != null; frontPeriod = frontPeriod.next) {
+            if (mediaPeriodHolder == null) {
+                frontPeriod.info = getUpdatedMediaPeriodInfo(frontPeriod.info, i2);
+            } else {
+                if (i2 == -1 || !frontPeriod.uid.equals(this.timeline.getPeriod(i2, this.period, true).uid)) {
+                    return true ^ removeAfter(mediaPeriodHolder);
+                }
+                MediaPeriodInfo followingMediaPeriodInfo = getFollowingMediaPeriodInfo(mediaPeriodHolder, j);
+                if (followingMediaPeriodInfo == null) {
+                    return true ^ removeAfter(mediaPeriodHolder);
+                }
+                frontPeriod.info = getUpdatedMediaPeriodInfo(frontPeriod.info, i2);
+                if (!canKeepMediaPeriodHolder(frontPeriod, followingMediaPeriodInfo)) {
+                    return true ^ removeAfter(mediaPeriodHolder);
+                }
+            }
+            if (frontPeriod.info.isLastInTimelinePeriod) {
+                i2 = this.timeline.getNextPeriodIndex(i2, this.period, this.window, this.repeatMode, this.shuffleModeEnabled);
+            }
+            mediaPeriodHolder = frontPeriod;
+        }
+        return true;
+    }
+
+    public final MediaPeriodInfo getUpdatedMediaPeriodInfo(MediaPeriodInfo mediaPeriodInfo, int i) {
+        return getUpdatedMediaPeriodInfo(mediaPeriodInfo, mediaPeriodInfo.id.copyWithPeriodIndex(i));
+    }
+
+    public final MediaSource.MediaPeriodId resolveMediaPeriodIdForAds(int i, long j) {
+        return resolveMediaPeriodIdForAds(i, j, resolvePeriodIndexToWindowSequenceNumber(i));
+    }
+
+    private MediaSource.MediaPeriodId resolveMediaPeriodIdForAds(int i, long j, long j2) {
+        this.timeline.getPeriod(i, this.period);
+        int adGroupIndexForPositionUs = this.period.getAdGroupIndexForPositionUs(j);
+        if (adGroupIndexForPositionUs == -1) {
+            return new MediaSource.MediaPeriodId(i, j2);
+        }
+        return new MediaSource.MediaPeriodId(i, adGroupIndexForPositionUs, this.period.getFirstAdIndexToPlay(adGroupIndexForPositionUs), j2);
+    }
+
+    private long resolvePeriodIndexToWindowSequenceNumber(int i) {
+        int indexOfPeriod;
+        Object obj = this.timeline.getPeriod(i, this.period, true).uid;
+        int i2 = this.period.windowIndex;
+        Object obj2 = this.oldFrontPeriodUid;
+        if (obj2 != null && (indexOfPeriod = this.timeline.getIndexOfPeriod(obj2)) != -1 && this.timeline.getPeriod(indexOfPeriod, this.period).windowIndex == i2) {
+            return this.oldFrontPeriodWindowSequenceNumber;
+        }
+        for (MediaPeriodHolder frontPeriod = getFrontPeriod(); frontPeriod != null; frontPeriod = frontPeriod.next) {
+            if (frontPeriod.uid.equals(obj)) {
+                return frontPeriod.info.id.windowSequenceNumber;
+            }
+        }
+        for (MediaPeriodHolder frontPeriod2 = getFrontPeriod(); frontPeriod2 != null; frontPeriod2 = frontPeriod2.next) {
+            int indexOfPeriod2 = this.timeline.getIndexOfPeriod(frontPeriod2.uid);
+            if (indexOfPeriod2 != -1 && this.timeline.getPeriod(indexOfPeriod2, this.period).windowIndex == i2) {
+                return frontPeriod2.info.id.windowSequenceNumber;
+            }
+        }
+        long j = this.nextWindowSequenceNumber;
+        this.nextWindowSequenceNumber = 1 + j;
+        return j;
+    }
+
+    private boolean canKeepMediaPeriodHolder(MediaPeriodHolder mediaPeriodHolder, MediaPeriodInfo mediaPeriodInfo) {
+        MediaPeriodInfo mediaPeriodInfo2 = mediaPeriodHolder.info;
+        return mediaPeriodInfo2.startPositionUs == mediaPeriodInfo.startPositionUs && mediaPeriodInfo2.endPositionUs == mediaPeriodInfo.endPositionUs && mediaPeriodInfo2.id.equals(mediaPeriodInfo.id);
+    }
+
+    private boolean updateForPlaybackModeChange() {
+        MediaPeriodHolder mediaPeriodHolder;
+        MediaPeriodHolder frontPeriod = getFrontPeriod();
+        if (frontPeriod == null) {
+            return true;
+        }
+        while (true) {
+            int nextPeriodIndex = this.timeline.getNextPeriodIndex(frontPeriod.info.id.periodIndex, this.period, this.window, this.repeatMode, this.shuffleModeEnabled);
+            while (true) {
+                mediaPeriodHolder = frontPeriod.next;
+                if (mediaPeriodHolder == null || frontPeriod.info.isLastInTimelinePeriod) {
+                    break;
+                }
+                frontPeriod = mediaPeriodHolder;
+            }
+            if (nextPeriodIndex == -1 || mediaPeriodHolder == null || mediaPeriodHolder.info.id.periodIndex != nextPeriodIndex) {
+                break;
+            }
+            frontPeriod = mediaPeriodHolder;
+        }
+        boolean removeAfter = removeAfter(frontPeriod);
+        MediaPeriodInfo mediaPeriodInfo = frontPeriod.info;
+        frontPeriod.info = getUpdatedMediaPeriodInfo(mediaPeriodInfo, mediaPeriodInfo.id);
+        return (removeAfter && hasPlayingPeriod()) ? false : true;
+    }
+
+    private MediaPeriodInfo getFirstMediaPeriodInfo(PlaybackInfo playbackInfo) {
+        return getMediaPeriodInfo(playbackInfo.periodId, playbackInfo.contentPositionUs, playbackInfo.startPositionUs);
+    }
+
+    @Nullable
+    private MediaPeriodInfo getFollowingMediaPeriodInfo(MediaPeriodHolder mediaPeriodHolder, long j) {
+        int i;
+        long j2;
+        long j3;
+        MediaPeriodInfo mediaPeriodInfo = mediaPeriodHolder.info;
+        if (mediaPeriodInfo.isLastInTimelinePeriod) {
+            int nextPeriodIndex = this.timeline.getNextPeriodIndex(mediaPeriodInfo.id.periodIndex, this.period, this.window, this.repeatMode, this.shuffleModeEnabled);
+            if (nextPeriodIndex == -1) {
+                return null;
+            }
+            int i2 = this.timeline.getPeriod(nextPeriodIndex, this.period, true).windowIndex;
+            Object obj = this.period.uid;
+            long j4 = mediaPeriodInfo.id.windowSequenceNumber;
+            long j5 = 0;
+            if (this.timeline.getWindow(i2, this.window).firstPeriodIndex == nextPeriodIndex) {
+                Pair<Integer, Long> periodPosition = this.timeline.getPeriodPosition(this.window, this.period, i2, C.TIME_UNSET, Math.max(0L, (mediaPeriodHolder.getRendererOffset() + mediaPeriodInfo.durationUs) - j));
+                if (periodPosition == null) {
+                    return null;
+                }
+                int intValue = ((Integer) periodPosition.first).intValue();
+                long longValue = ((Long) periodPosition.second).longValue();
+                MediaPeriodHolder mediaPeriodHolder2 = mediaPeriodHolder.next;
+                if (mediaPeriodHolder2 == null || !mediaPeriodHolder2.uid.equals(obj)) {
+                    j3 = this.nextWindowSequenceNumber;
+                    this.nextWindowSequenceNumber = 1 + j3;
+                } else {
+                    j3 = mediaPeriodHolder.next.info.id.windowSequenceNumber;
+                }
+                j5 = longValue;
+                j2 = j3;
+                i = intValue;
+            } else {
+                i = nextPeriodIndex;
+                j2 = j4;
+            }
+            long j6 = j5;
+            return getMediaPeriodInfo(resolveMediaPeriodIdForAds(i, j6, j2), j6, j5);
+        }
+        MediaSource.MediaPeriodId mediaPeriodId = mediaPeriodInfo.id;
+        this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period);
+        if (mediaPeriodId.isAd()) {
+            int i3 = mediaPeriodId.adGroupIndex;
+            int adCountInAdGroup = this.period.getAdCountInAdGroup(i3);
+            if (adCountInAdGroup == -1) {
+                return null;
+            }
+            int nextAdIndexToPlay = this.period.getNextAdIndexToPlay(i3, mediaPeriodId.adIndexInAdGroup);
+            if (nextAdIndexToPlay < adCountInAdGroup) {
+                if (this.period.isAdAvailable(i3, nextAdIndexToPlay)) {
+                    return getMediaPeriodInfoForAd(mediaPeriodId.periodIndex, i3, nextAdIndexToPlay, mediaPeriodInfo.contentPositionUs, mediaPeriodId.windowSequenceNumber);
+                }
+                return null;
+            }
+            return getMediaPeriodInfoForContent(mediaPeriodId.periodIndex, mediaPeriodInfo.contentPositionUs, mediaPeriodId.windowSequenceNumber);
+        }
+        long j7 = mediaPeriodInfo.endPositionUs;
+        if (j7 != Long.MIN_VALUE) {
+            int adGroupIndexForPositionUs = this.period.getAdGroupIndexForPositionUs(j7);
+            if (adGroupIndexForPositionUs == -1) {
+                return getMediaPeriodInfoForContent(mediaPeriodId.periodIndex, mediaPeriodInfo.endPositionUs, mediaPeriodId.windowSequenceNumber);
+            }
+            int firstAdIndexToPlay = this.period.getFirstAdIndexToPlay(adGroupIndexForPositionUs);
+            if (this.period.isAdAvailable(adGroupIndexForPositionUs, firstAdIndexToPlay)) {
+                return getMediaPeriodInfoForAd(mediaPeriodId.periodIndex, adGroupIndexForPositionUs, firstAdIndexToPlay, mediaPeriodInfo.endPositionUs, mediaPeriodId.windowSequenceNumber);
+            }
+            return null;
+        }
+        int adGroupCount = this.period.getAdGroupCount();
+        if (adGroupCount == 0) {
+            return null;
+        }
+        int i4 = adGroupCount - 1;
+        if (this.period.getAdGroupTimeUs(i4) != Long.MIN_VALUE || this.period.hasPlayedAdGroup(i4)) {
+            return null;
+        }
+        int firstAdIndexToPlay2 = this.period.getFirstAdIndexToPlay(i4);
+        if (!this.period.isAdAvailable(i4, firstAdIndexToPlay2)) {
+            return null;
+        }
+        return getMediaPeriodInfoForAd(mediaPeriodId.periodIndex, i4, firstAdIndexToPlay2, this.period.getDurationUs(), mediaPeriodId.windowSequenceNumber);
+    }
+
+    private MediaPeriodInfo getUpdatedMediaPeriodInfo(MediaPeriodInfo mediaPeriodInfo, MediaSource.MediaPeriodId mediaPeriodId) {
+        long j;
+        long durationUs;
+        long j2 = mediaPeriodInfo.startPositionUs;
+        long j3 = mediaPeriodInfo.endPositionUs;
+        boolean isLastInPeriod = isLastInPeriod(mediaPeriodId, j3);
+        boolean isLastInTimeline = isLastInTimeline(mediaPeriodId, isLastInPeriod);
+        this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period);
+        if (mediaPeriodId.isAd()) {
+            durationUs = this.period.getAdDurationUs(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup);
+        } else if (j3 == Long.MIN_VALUE) {
+            durationUs = this.period.getDurationUs();
+        } else {
+            j = j3;
+            return new MediaPeriodInfo(mediaPeriodId, j2, j3, mediaPeriodInfo.contentPositionUs, j, isLastInPeriod, isLastInTimeline);
+        }
+        j = durationUs;
+        return new MediaPeriodInfo(mediaPeriodId, j2, j3, mediaPeriodInfo.contentPositionUs, j, isLastInPeriod, isLastInTimeline);
+    }
+
+    private MediaPeriodInfo getMediaPeriodInfo(MediaSource.MediaPeriodId mediaPeriodId, long j, long j2) {
+        this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period);
+        if (mediaPeriodId.isAd()) {
+            if (this.period.isAdAvailable(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup)) {
+                return getMediaPeriodInfoForAd(mediaPeriodId.periodIndex, mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup, j, mediaPeriodId.windowSequenceNumber);
+            }
+            return null;
+        }
+        return getMediaPeriodInfoForContent(mediaPeriodId.periodIndex, j2, mediaPeriodId.windowSequenceNumber);
+    }
+
+    private MediaPeriodInfo getMediaPeriodInfoForAd(int i, int i2, int i3, long j, long j2) {
+        MediaSource.MediaPeriodId mediaPeriodId = new MediaSource.MediaPeriodId(i, i2, i3, j2);
+        boolean isLastInPeriod = isLastInPeriod(mediaPeriodId, Long.MIN_VALUE);
+        boolean isLastInTimeline = isLastInTimeline(mediaPeriodId, isLastInPeriod);
+        return new MediaPeriodInfo(mediaPeriodId, i3 == this.period.getFirstAdIndexToPlay(i2) ? this.period.getAdResumePositionUs() : 0L, Long.MIN_VALUE, j, this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period).getAdDurationUs(mediaPeriodId.adGroupIndex, mediaPeriodId.adIndexInAdGroup), isLastInPeriod, isLastInTimeline);
+    }
+
+    private MediaPeriodInfo getMediaPeriodInfoForContent(int i, long j, long j2) {
+        MediaSource.MediaPeriodId mediaPeriodId = new MediaSource.MediaPeriodId(i, j2);
+        this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period);
+        int adGroupIndexAfterPositionUs = this.period.getAdGroupIndexAfterPositionUs(j);
+        long adGroupTimeUs = adGroupIndexAfterPositionUs == -1 ? Long.MIN_VALUE : this.period.getAdGroupTimeUs(adGroupIndexAfterPositionUs);
+        boolean isLastInPeriod = isLastInPeriod(mediaPeriodId, adGroupTimeUs);
+        return new MediaPeriodInfo(mediaPeriodId, j, adGroupTimeUs, C.TIME_UNSET, adGroupTimeUs == Long.MIN_VALUE ? this.period.getDurationUs() : adGroupTimeUs, isLastInPeriod, isLastInTimeline(mediaPeriodId, isLastInPeriod));
+    }
+
+    private boolean isLastInPeriod(MediaSource.MediaPeriodId mediaPeriodId, long j) {
+        int adGroupCount = this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period).getAdGroupCount();
+        if (adGroupCount == 0) {
+            return true;
+        }
+        int i = adGroupCount - 1;
+        boolean isAd = mediaPeriodId.isAd();
+        if (this.period.getAdGroupTimeUs(i) != Long.MIN_VALUE) {
+            return !isAd && j == Long.MIN_VALUE;
+        }
+        int adCountInAdGroup = this.period.getAdCountInAdGroup(i);
+        if (adCountInAdGroup == -1) {
+            return false;
+        }
+        if (isAd && mediaPeriodId.adGroupIndex == i && mediaPeriodId.adIndexInAdGroup == adCountInAdGroup - 1) {
+            return true;
+        }
+        return !isAd && this.period.getFirstAdIndexToPlay(i) == adCountInAdGroup;
+    }
+
+    private boolean isLastInTimeline(MediaSource.MediaPeriodId mediaPeriodId, boolean z) {
+        return !this.timeline.getWindow(this.timeline.getPeriod(mediaPeriodId.periodIndex, this.period).windowIndex, this.window).isDynamic && this.timeline.isLastPeriod(mediaPeriodId.periodIndex, this.period, this.window, this.repeatMode, this.shuffleModeEnabled) && z;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/NoSampleRenderer.java

@@ -0,0 +1,160 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public abstract class NoSampleRenderer implements Renderer, RendererCapabilities {
+    private RendererConfiguration configuration;
+    private int index;
+    private int state;
+    private SampleStream stream;
+    private boolean streamIsFinal;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final RendererCapabilities getCapabilities() {
+        return this;
+    }
+
+    public final RendererConfiguration getConfiguration() {
+        return this.configuration;
+    }
+
+    public final int getIndex() {
+        return this.index;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final int getState() {
+        return this.state;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final SampleStream getStream() {
+        return this.stream;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer, com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public final int getTrackType() {
+        return 5;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean hasReadStreamToEnd() {
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final boolean isCurrentStreamFinal() {
+        return this.streamIsFinal;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isEnded() {
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isReady() {
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void maybeThrowStreamError() throws IOException {
+    }
+
+    public void onDisabled() {
+    }
+
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+    }
+
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+    }
+
+    public void onRendererOffsetChanged(long j) throws ExoPlaybackException {
+    }
+
+    public void onStarted() throws ExoPlaybackException {
+    }
+
+    public void onStopped() throws ExoPlaybackException {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void setCurrentStreamFinal() {
+        this.streamIsFinal = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void setIndex(int i) {
+        this.index = i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public int supportsFormat(Format format) throws ExoPlaybackException {
+        return 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public int supportsMixedMimeTypeAdaptation() throws ExoPlaybackException {
+        return 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void enable(RendererConfiguration rendererConfiguration, Format[] formatArr, SampleStream sampleStream, long j, boolean z, long j2) throws ExoPlaybackException {
+        Assertions.checkState(this.state == 0);
+        this.configuration = rendererConfiguration;
+        this.state = 1;
+        onEnabled(z);
+        replaceStream(formatArr, sampleStream, j2);
+        onPositionReset(j, z);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void start() throws ExoPlaybackException {
+        Assertions.checkState(this.state == 1);
+        this.state = 2;
+        onStarted();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void replaceStream(Format[] formatArr, SampleStream sampleStream, long j) throws ExoPlaybackException {
+        Assertions.checkState(!this.streamIsFinal);
+        this.stream = sampleStream;
+        onRendererOffsetChanged(j);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void resetPosition(long j) throws ExoPlaybackException {
+        this.streamIsFinal = false;
+        onPositionReset(j, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void stop() throws ExoPlaybackException {
+        Assertions.checkState(this.state == 2);
+        this.state = 1;
+        onStopped();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public final void disable() {
+        Assertions.checkState(this.state == 1);
+        this.state = 0;
+        this.stream = null;
+        this.streamIsFinal = false;
+        onDisabled();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/ParserException.java

@@ -0,0 +1,21 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public class ParserException extends IOException {
+    public ParserException() {
+    }
+
+    public ParserException(String str) {
+        super(str);
+    }
+
+    public ParserException(Throwable th) {
+        super(th);
+    }
+
+    public ParserException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/PlaybackInfo.java

@@ -0,0 +1,80 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectorResult;
+
+/* loaded from: classes4.dex */
+final class PlaybackInfo {
+    public volatile long bufferedPositionUs;
+    public final long contentPositionUs;
+    public final boolean isLoading;
+
+    @Nullable
+    public final Object manifest;
+    public final MediaSource.MediaPeriodId periodId;
+    public final int playbackState;
+    public volatile long positionUs;
+    public final long startPositionUs;
+    public final Timeline timeline;
+    public final TrackGroupArray trackGroups;
+    public final TrackSelectorResult trackSelectorResult;
+
+    public PlaybackInfo(Timeline timeline, long j, TrackGroupArray trackGroupArray, TrackSelectorResult trackSelectorResult) {
+        this(timeline, null, new MediaSource.MediaPeriodId(0), j, C.TIME_UNSET, 1, false, trackGroupArray, trackSelectorResult);
+    }
+
+    public PlaybackInfo(Timeline timeline, @Nullable Object obj, MediaSource.MediaPeriodId mediaPeriodId, long j, long j2, int i, boolean z, TrackGroupArray trackGroupArray, TrackSelectorResult trackSelectorResult) {
+        this.timeline = timeline;
+        this.manifest = obj;
+        this.periodId = mediaPeriodId;
+        this.startPositionUs = j;
+        this.contentPositionUs = j2;
+        this.positionUs = j;
+        this.bufferedPositionUs = j;
+        this.playbackState = i;
+        this.isLoading = z;
+        this.trackGroups = trackGroupArray;
+        this.trackSelectorResult = trackSelectorResult;
+    }
+
+    public final PlaybackInfo fromNewPosition(MediaSource.MediaPeriodId mediaPeriodId, long j, long j2) {
+        return new PlaybackInfo(this.timeline, this.manifest, mediaPeriodId, j, mediaPeriodId.isAd() ? j2 : -9223372036854775807L, this.playbackState, this.isLoading, this.trackGroups, this.trackSelectorResult);
+    }
+
+    public final PlaybackInfo copyWithPeriodIndex(int i) {
+        PlaybackInfo playbackInfo = new PlaybackInfo(this.timeline, this.manifest, this.periodId.copyWithPeriodIndex(i), this.startPositionUs, this.contentPositionUs, this.playbackState, this.isLoading, this.trackGroups, this.trackSelectorResult);
+        copyMutablePositions(this, playbackInfo);
+        return playbackInfo;
+    }
+
+    public final PlaybackInfo copyWithTimeline(Timeline timeline, Object obj) {
+        PlaybackInfo playbackInfo = new PlaybackInfo(timeline, obj, this.periodId, this.startPositionUs, this.contentPositionUs, this.playbackState, this.isLoading, this.trackGroups, this.trackSelectorResult);
+        copyMutablePositions(this, playbackInfo);
+        return playbackInfo;
+    }
+
+    public final PlaybackInfo copyWithPlaybackState(int i) {
+        PlaybackInfo playbackInfo = new PlaybackInfo(this.timeline, this.manifest, this.periodId, this.startPositionUs, this.contentPositionUs, i, this.isLoading, this.trackGroups, this.trackSelectorResult);
+        copyMutablePositions(this, playbackInfo);
+        return playbackInfo;
+    }
+
+    public final PlaybackInfo copyWithIsLoading(boolean z) {
+        PlaybackInfo playbackInfo = new PlaybackInfo(this.timeline, this.manifest, this.periodId, this.startPositionUs, this.contentPositionUs, this.playbackState, z, this.trackGroups, this.trackSelectorResult);
+        copyMutablePositions(this, playbackInfo);
+        return playbackInfo;
+    }
+
+    public final PlaybackInfo copyWithTrackInfo(TrackGroupArray trackGroupArray, TrackSelectorResult trackSelectorResult) {
+        PlaybackInfo playbackInfo = new PlaybackInfo(this.timeline, this.manifest, this.periodId, this.startPositionUs, this.contentPositionUs, this.playbackState, this.isLoading, trackGroupArray, trackSelectorResult);
+        copyMutablePositions(this, playbackInfo);
+        return playbackInfo;
+    }
+
+    private static void copyMutablePositions(PlaybackInfo playbackInfo, PlaybackInfo playbackInfo2) {
+        playbackInfo2.positionUs = playbackInfo.positionUs;
+        playbackInfo2.bufferedPositionUs = playbackInfo.bufferedPositionUs;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/PlaybackParameters.java

@@ -0,0 +1,50 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public final class PlaybackParameters {
+    public static final PlaybackParameters DEFAULT = new PlaybackParameters(1.0f);
+    public final float pitch;
+    private final int scaledUsPerMs;
+    public final boolean skipSilence;
+    public final float speed;
+
+    public final long getMediaTimeUsForPlayoutTimeMs(long j) {
+        return j * this.scaledUsPerMs;
+    }
+
+    public PlaybackParameters(float f) {
+        this(f, 1.0f, false);
+    }
+
+    public PlaybackParameters(float f, float f2) {
+        this(f, f2, false);
+    }
+
+    public PlaybackParameters(float f, float f2, boolean z) {
+        Assertions.checkArgument(f > 0.0f);
+        Assertions.checkArgument(f2 > 0.0f);
+        this.speed = f;
+        this.pitch = f2;
+        this.skipSilence = z;
+        this.scaledUsPerMs = Math.round(f * 1000.0f);
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || PlaybackParameters.class != obj.getClass()) {
+            return false;
+        }
+        PlaybackParameters playbackParameters = (PlaybackParameters) obj;
+        return this.speed == playbackParameters.speed && this.pitch == playbackParameters.pitch && this.skipSilence == playbackParameters.skipSilence;
+    }
+
+    public final int hashCode() {
+        return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + Float.floatToRawIntBits(this.speed)) * 31) + Float.floatToRawIntBits(this.pitch)) * 31) + (this.skipSilence ? 1 : 0);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/PlaybackPreparer.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public interface PlaybackPreparer {
+    void preparePlayback();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/Player.java

@@ -0,0 +1,238 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.TextureView;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.text.TextOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public interface Player {
+    public static final int DISCONTINUITY_REASON_AD_INSERTION = 3;
+    public static final int DISCONTINUITY_REASON_INTERNAL = 4;
+    public static final int DISCONTINUITY_REASON_PERIOD_TRANSITION = 0;
+    public static final int DISCONTINUITY_REASON_SEEK = 1;
+    public static final int DISCONTINUITY_REASON_SEEK_ADJUSTMENT = 2;
+    public static final int REPEAT_MODE_ALL = 2;
+    public static final int REPEAT_MODE_OFF = 0;
+    public static final int REPEAT_MODE_ONE = 1;
+    public static final int STATE_BUFFERING = 2;
+    public static final int STATE_ENDED = 4;
+    public static final int STATE_IDLE = 1;
+    public static final int STATE_READY = 3;
+    public static final int TIMELINE_CHANGE_REASON_DYNAMIC = 2;
+    public static final int TIMELINE_CHANGE_REASON_PREPARED = 0;
+    public static final int TIMELINE_CHANGE_REASON_RESET = 1;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface DiscontinuityReason {
+    }
+
+    public interface EventListener {
+        void onLoadingChanged(boolean z);
+
+        void onPlaybackParametersChanged(PlaybackParameters playbackParameters);
+
+        void onPlayerError(ExoPlaybackException exoPlaybackException);
+
+        void onPlayerStateChanged(boolean z, int i);
+
+        void onPositionDiscontinuity(int i);
+
+        void onRepeatModeChanged(int i);
+
+        void onSeekProcessed();
+
+        void onShuffleModeEnabledChanged(boolean z);
+
+        void onTimelineChanged(Timeline timeline, @Nullable Object obj, int i);
+
+        void onTracksChanged(TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface RepeatMode {
+    }
+
+    public interface TextComponent {
+        void addTextOutput(TextOutput textOutput);
+
+        void removeTextOutput(TextOutput textOutput);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface TimelineChangeReason {
+    }
+
+    public interface VideoComponent {
+        void addVideoListener(VideoListener videoListener);
+
+        void clearVideoSurface();
+
+        void clearVideoSurface(Surface surface);
+
+        void clearVideoSurfaceHolder(SurfaceHolder surfaceHolder);
+
+        void clearVideoSurfaceView(SurfaceView surfaceView);
+
+        void clearVideoTextureView(TextureView textureView);
+
+        int getVideoScalingMode();
+
+        void removeVideoListener(VideoListener videoListener);
+
+        void setVideoScalingMode(int i);
+
+        void setVideoSurface(Surface surface);
+
+        void setVideoSurfaceHolder(SurfaceHolder surfaceHolder);
+
+        void setVideoSurfaceView(SurfaceView surfaceView);
+
+        void setVideoTextureView(TextureView textureView);
+    }
+
+    void addListener(EventListener eventListener);
+
+    int getBufferedPercentage();
+
+    long getBufferedPosition();
+
+    long getContentPosition();
+
+    int getCurrentAdGroupIndex();
+
+    int getCurrentAdIndexInAdGroup();
+
+    @Nullable
+    Object getCurrentManifest();
+
+    int getCurrentPeriodIndex();
+
+    long getCurrentPosition();
+
+    @Nullable
+    Object getCurrentTag();
+
+    Timeline getCurrentTimeline();
+
+    TrackGroupArray getCurrentTrackGroups();
+
+    TrackSelectionArray getCurrentTrackSelections();
+
+    int getCurrentWindowIndex();
+
+    long getDuration();
+
+    int getNextWindowIndex();
+
+    boolean getPlayWhenReady();
+
+    @Nullable
+    ExoPlaybackException getPlaybackError();
+
+    PlaybackParameters getPlaybackParameters();
+
+    int getPlaybackState();
+
+    int getPreviousWindowIndex();
+
+    int getRendererCount();
+
+    int getRendererType(int i);
+
+    int getRepeatMode();
+
+    boolean getShuffleModeEnabled();
+
+    @Nullable
+    TextComponent getTextComponent();
+
+    @Nullable
+    VideoComponent getVideoComponent();
+
+    boolean isCurrentWindowDynamic();
+
+    boolean isCurrentWindowSeekable();
+
+    boolean isLoading();
+
+    boolean isPlayingAd();
+
+    void release();
+
+    void removeListener(EventListener eventListener);
+
+    void seekTo(int i, long j);
+
+    void seekTo(long j);
+
+    void seekToDefaultPosition();
+
+    void seekToDefaultPosition(int i);
+
+    void setPlayWhenReady(boolean z);
+
+    void setPlaybackParameters(@Nullable PlaybackParameters playbackParameters);
+
+    void setRepeatMode(int i);
+
+    void setShuffleModeEnabled(boolean z);
+
+    void stop();
+
+    void stop(boolean z);
+
+    public static abstract class DefaultEventListener implements EventListener {
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onLoadingChanged(boolean z) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onPlayerError(ExoPlaybackException exoPlaybackException) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onPlayerStateChanged(boolean z, int i) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onPositionDiscontinuity(int i) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onRepeatModeChanged(int i) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onSeekProcessed() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onShuffleModeEnabledChanged(boolean z) {
+        }
+
+        @Deprecated
+        public void onTimelineChanged(Timeline timeline, @Nullable Object obj) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onTracksChanged(TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+        public void onTimelineChanged(Timeline timeline, @Nullable Object obj, int i) {
+            onTimelineChanged(timeline, obj);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/PlayerMessage.java

@@ -0,0 +1,164 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.os.Handler;
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes4.dex */
+public final class PlayerMessage {
+    private Handler handler;
+    private boolean isCanceled;
+    private boolean isDelivered;
+    private boolean isProcessed;
+    private boolean isSent;
+    private Object payload;
+    private final Sender sender;
+    private final Target target;
+    private final Timeline timeline;
+    private int type;
+    private int windowIndex;
+    private long positionMs = C.TIME_UNSET;
+    private boolean deleteAfterDelivery = true;
+
+    public interface Sender {
+        void sendMessage(PlayerMessage playerMessage);
+    }
+
+    public interface Target {
+        void handleMessage(int i, Object obj) throws ExoPlaybackException;
+    }
+
+    public final boolean getDeleteAfterDelivery() {
+        return this.deleteAfterDelivery;
+    }
+
+    public final Handler getHandler() {
+        return this.handler;
+    }
+
+    public final Object getPayload() {
+        return this.payload;
+    }
+
+    public final long getPositionMs() {
+        return this.positionMs;
+    }
+
+    public final Target getTarget() {
+        return this.target;
+    }
+
+    public final Timeline getTimeline() {
+        return this.timeline;
+    }
+
+    public final int getType() {
+        return this.type;
+    }
+
+    public final int getWindowIndex() {
+        return this.windowIndex;
+    }
+
+    public PlayerMessage(Sender sender, Target target, Timeline timeline, int i, Handler handler) {
+        this.sender = sender;
+        this.target = target;
+        this.timeline = timeline;
+        this.handler = handler;
+        this.windowIndex = i;
+    }
+
+    public final PlayerMessage setType(int i) {
+        Assertions.checkState(!this.isSent);
+        this.type = i;
+        return this;
+    }
+
+    public final PlayerMessage setPayload(@Nullable Object obj) {
+        Assertions.checkState(!this.isSent);
+        this.payload = obj;
+        return this;
+    }
+
+    public final PlayerMessage setHandler(Handler handler) {
+        Assertions.checkState(!this.isSent);
+        this.handler = handler;
+        return this;
+    }
+
+    public final PlayerMessage setPosition(long j) {
+        Assertions.checkState(!this.isSent);
+        this.positionMs = j;
+        return this;
+    }
+
+    public final PlayerMessage setPosition(int i, long j) {
+        Assertions.checkState(!this.isSent);
+        Assertions.checkArgument(j != C.TIME_UNSET);
+        if (i < 0 || (!this.timeline.isEmpty() && i >= this.timeline.getWindowCount())) {
+            throw new IllegalSeekPositionException(this.timeline, i, j);
+        }
+        this.windowIndex = i;
+        this.positionMs = j;
+        return this;
+    }
+
+    public final PlayerMessage setDeleteAfterDelivery(boolean z) {
+        Assertions.checkState(!this.isSent);
+        this.deleteAfterDelivery = z;
+        return this;
+    }
+
+    public final PlayerMessage send() {
+        Assertions.checkState(!this.isSent);
+        if (this.positionMs == C.TIME_UNSET) {
+            Assertions.checkArgument(this.deleteAfterDelivery);
+        }
+        this.isSent = true;
+        this.sender.sendMessage(this);
+        return this;
+    }
+
+    public final synchronized PlayerMessage cancel() {
+        Assertions.checkState(this.isSent);
+        this.isCanceled = true;
+        markAsProcessed(false);
+        return this;
+    }
+
+    public final synchronized boolean isCanceled() {
+        return this.isCanceled;
+    }
+
+    public final synchronized boolean blockUntilDelivered() throws InterruptedException, TimeoutException {
+        boolean z;
+        try {
+            Assertions.checkState(this.isSent);
+            Assertions.checkState(this.handler.getLooper().getThread() != Thread.currentThread());
+            long j = 500;
+            long elapsedRealtime = SystemClock.elapsedRealtime() + 500;
+            while (true) {
+                z = this.isProcessed;
+                if (z || j <= 0) {
+                    break;
+                }
+                wait(j);
+                j = elapsedRealtime - SystemClock.elapsedRealtime();
+            }
+            if (!z) {
+                throw new TimeoutException("Message delivery time out");
+            }
+        } catch (Throwable th) {
+            throw th;
+        }
+        return this.isDelivered;
+    }
+
+    public final synchronized void markAsProcessed(boolean z) {
+        this.isDelivered = z | this.isDelivered;
+        this.isProcessed = true;
+        notifyAll();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/Renderer.java

@@ -0,0 +1,57 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage;
+import com.mbridge.msdk.playercommon.exoplayer2.source.SampleStream;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import java.io.IOException;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public interface Renderer extends PlayerMessage.Target {
+    public static final int STATE_DISABLED = 0;
+    public static final int STATE_ENABLED = 1;
+    public static final int STATE_STARTED = 2;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    void disable();
+
+    void enable(RendererConfiguration rendererConfiguration, Format[] formatArr, SampleStream sampleStream, long j, boolean z, long j2) throws ExoPlaybackException;
+
+    RendererCapabilities getCapabilities();
+
+    MediaClock getMediaClock();
+
+    int getState();
+
+    SampleStream getStream();
+
+    int getTrackType();
+
+    boolean hasReadStreamToEnd();
+
+    boolean isCurrentStreamFinal();
+
+    boolean isEnded();
+
+    boolean isReady();
+
+    void maybeThrowStreamError() throws IOException;
+
+    void render(long j, long j2) throws ExoPlaybackException;
+
+    void replaceStream(Format[] formatArr, SampleStream sampleStream, long j) throws ExoPlaybackException;
+
+    void resetPosition(long j) throws ExoPlaybackException;
+
+    void setCurrentStreamFinal();
+
+    void setIndex(int i);
+
+    void start() throws ExoPlaybackException;
+
+    void stop() throws ExoPlaybackException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/RendererCapabilities.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+/* loaded from: classes4.dex */
+public interface RendererCapabilities {
+    public static final int ADAPTIVE_NOT_SEAMLESS = 8;
+    public static final int ADAPTIVE_NOT_SUPPORTED = 0;
+    public static final int ADAPTIVE_SEAMLESS = 16;
+    public static final int ADAPTIVE_SUPPORT_MASK = 24;
+    public static final int FORMAT_EXCEEDS_CAPABILITIES = 3;
+    public static final int FORMAT_HANDLED = 4;
+    public static final int FORMAT_SUPPORT_MASK = 7;
+    public static final int FORMAT_UNSUPPORTED_DRM = 2;
+    public static final int FORMAT_UNSUPPORTED_SUBTYPE = 1;
+    public static final int FORMAT_UNSUPPORTED_TYPE = 0;
+    public static final int TUNNELING_NOT_SUPPORTED = 0;
+    public static final int TUNNELING_SUPPORTED = 32;
+    public static final int TUNNELING_SUPPORT_MASK = 32;
+
+    int getTrackType();
+
+    int supportsFormat(Format format) throws ExoPlaybackException;
+
+    int supportsMixedMimeTypeAdaptation() throws ExoPlaybackException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/RendererConfiguration.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+
+/* loaded from: classes4.dex */
+public final class RendererConfiguration {
+    public static final RendererConfiguration DEFAULT = new RendererConfiguration(0);
+    public final int tunnelingAudioSessionId;
+
+    public final int hashCode() {
+        return this.tunnelingAudioSessionId;
+    }
+
+    public RendererConfiguration(int i) {
+        this.tunnelingAudioSessionId = i;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        return obj != null && RendererConfiguration.class == obj.getClass() && this.tunnelingAudioSessionId == ((RendererConfiguration) obj).tunnelingAudioSessionId;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/RenderersFactory.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.os.Handler;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.text.TextOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener;
+
+/* loaded from: classes4.dex */
+public interface RenderersFactory {
+    Renderer[] createRenderers(Handler handler, VideoRendererEventListener videoRendererEventListener, AudioRendererEventListener audioRendererEventListener, TextOutput textOutput, MetadataOutput metadataOutput, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/SeekParameters.java

@@ -0,0 +1,46 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public final class SeekParameters {
+    public static final SeekParameters CLOSEST_SYNC;
+    public static final SeekParameters DEFAULT;
+    public static final SeekParameters EXACT;
+    public static final SeekParameters NEXT_SYNC;
+    public static final SeekParameters PREVIOUS_SYNC;
+    public final long toleranceAfterUs;
+    public final long toleranceBeforeUs;
+
+    public final int hashCode() {
+        return (((int) this.toleranceBeforeUs) * 31) + ((int) this.toleranceAfterUs);
+    }
+
+    static {
+        SeekParameters seekParameters = new SeekParameters(0L, 0L);
+        EXACT = seekParameters;
+        CLOSEST_SYNC = new SeekParameters(Long.MAX_VALUE, Long.MAX_VALUE);
+        PREVIOUS_SYNC = new SeekParameters(Long.MAX_VALUE, 0L);
+        NEXT_SYNC = new SeekParameters(0L, Long.MAX_VALUE);
+        DEFAULT = seekParameters;
+    }
+
+    public SeekParameters(long j, long j2) {
+        Assertions.checkArgument(j >= 0);
+        Assertions.checkArgument(j2 >= 0);
+        this.toleranceBeforeUs = j;
+        this.toleranceAfterUs = j2;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || SeekParameters.class != obj.getClass()) {
+            return false;
+        }
+        SeekParameters seekParameters = (SeekParameters) obj;
+        return this.toleranceBeforeUs == seekParameters.toleranceBeforeUs && this.toleranceAfterUs == seekParameters.toleranceAfterUs;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/SimpleExoPlayer.java

@@ -0,0 +1,931 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.annotation.TargetApi;
+import android.graphics.SurfaceTexture;
+import android.media.PlaybackParams;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.TextureView;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage;
+import com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsCollector;
+import com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioAttributes;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.text.Cue;
+import com.mbridge.msdk.playercommon.exoplayer2.text.TextOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.TimeoutException;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public class SimpleExoPlayer implements ExoPlayer, Player.TextComponent, Player.VideoComponent {
+    private static final String TAG = "SimpleExoPlayer";
+    private final AnalyticsCollector analyticsCollector;
+    private AudioAttributes audioAttributes;
+    private final CopyOnWriteArraySet<AudioRendererEventListener> audioDebugListeners;
+    private DecoderCounters audioDecoderCounters;
+    private Format audioFormat;
+    private int audioSessionId;
+    private float audioVolume;
+    private final ComponentListener componentListener;
+    private List<Cue> currentCues;
+    private final Handler eventHandler;
+    private MediaSource mediaSource;
+    private final CopyOnWriteArraySet<MetadataOutput> metadataOutputs;
+    private boolean ownsSurface;
+    private final ExoPlayer player;
+    protected final Renderer[] renderers;
+    private Surface surface;
+    private SurfaceHolder surfaceHolder;
+    private final CopyOnWriteArraySet<TextOutput> textOutputs;
+    private TextureView textureView;
+    private final CopyOnWriteArraySet<VideoRendererEventListener> videoDebugListeners;
+    private DecoderCounters videoDecoderCounters;
+    private Format videoFormat;
+    private final CopyOnWriteArraySet<com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener> videoListeners;
+    private int videoScalingMode;
+
+    @Deprecated
+    public interface VideoListener extends com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener {
+    }
+
+    public AnalyticsCollector getAnalyticsCollector() {
+        return this.analyticsCollector;
+    }
+
+    public AudioAttributes getAudioAttributes() {
+        return this.audioAttributes;
+    }
+
+    public DecoderCounters getAudioDecoderCounters() {
+        return this.audioDecoderCounters;
+    }
+
+    public Format getAudioFormat() {
+        return this.audioFormat;
+    }
+
+    public int getAudioSessionId() {
+        return this.audioSessionId;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public Player.TextComponent getTextComponent() {
+        return this;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public Player.VideoComponent getVideoComponent() {
+        return this;
+    }
+
+    public DecoderCounters getVideoDecoderCounters() {
+        return this.videoDecoderCounters;
+    }
+
+    public Format getVideoFormat() {
+        return this.videoFormat;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public int getVideoScalingMode() {
+        return this.videoScalingMode;
+    }
+
+    public float getVolume() {
+        return this.audioVolume;
+    }
+
+    public SimpleExoPlayer(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager) {
+        this(renderersFactory, trackSelector, loadControl, drmSessionManager, new AnalyticsCollector.Factory());
+    }
+
+    public SimpleExoPlayer(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, AnalyticsCollector.Factory factory) {
+        this(renderersFactory, trackSelector, loadControl, drmSessionManager, factory, Clock.DEFAULT);
+    }
+
+    public SimpleExoPlayer(RenderersFactory renderersFactory, TrackSelector trackSelector, LoadControl loadControl, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, AnalyticsCollector.Factory factory, Clock clock) {
+        ComponentListener componentListener = new ComponentListener();
+        this.componentListener = componentListener;
+        this.videoListeners = new CopyOnWriteArraySet<>();
+        this.textOutputs = new CopyOnWriteArraySet<>();
+        this.metadataOutputs = new CopyOnWriteArraySet<>();
+        CopyOnWriteArraySet<VideoRendererEventListener> copyOnWriteArraySet = new CopyOnWriteArraySet<>();
+        this.videoDebugListeners = copyOnWriteArraySet;
+        CopyOnWriteArraySet<AudioRendererEventListener> copyOnWriteArraySet2 = new CopyOnWriteArraySet<>();
+        this.audioDebugListeners = copyOnWriteArraySet2;
+        Handler handler = new Handler(Looper.myLooper() != null ? Looper.myLooper() : Looper.getMainLooper());
+        this.eventHandler = handler;
+        Renderer[] createRenderers = renderersFactory.createRenderers(handler, componentListener, componentListener, componentListener, componentListener, drmSessionManager);
+        this.renderers = createRenderers;
+        this.audioVolume = 1.0f;
+        this.audioSessionId = 0;
+        this.audioAttributes = AudioAttributes.DEFAULT;
+        this.videoScalingMode = 1;
+        this.currentCues = Collections.emptyList();
+        ExoPlayer createExoPlayerImpl = createExoPlayerImpl(createRenderers, trackSelector, loadControl, clock);
+        this.player = createExoPlayerImpl;
+        AnalyticsCollector createAnalyticsCollector = factory.createAnalyticsCollector(createExoPlayerImpl, clock);
+        this.analyticsCollector = createAnalyticsCollector;
+        addListener(createAnalyticsCollector);
+        copyOnWriteArraySet.add(createAnalyticsCollector);
+        copyOnWriteArraySet2.add(createAnalyticsCollector);
+        addMetadataOutput(createAnalyticsCollector);
+        if (drmSessionManager instanceof DefaultDrmSessionManager) {
+            ((DefaultDrmSessionManager) drmSessionManager).addListener(handler, createAnalyticsCollector);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void setVideoScalingMode(int i) {
+        this.videoScalingMode = i;
+        for (Renderer renderer : this.renderers) {
+            if (renderer.getTrackType() == 2) {
+                this.player.createMessage(renderer).setType(4).setPayload(Integer.valueOf(i)).send();
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void clearVideoSurface() {
+        setVideoSurface(null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void setVideoSurface(Surface surface) {
+        removeSurfaceCallbacks();
+        setVideoSurfaceInternal(surface, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void clearVideoSurface(Surface surface) {
+        if (surface == null || surface != this.surface) {
+            return;
+        }
+        setVideoSurface(null);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:6:0x0017, code lost:
+    
+        if (r2.isValid() != false) goto L11;
+     */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public void setVideoSurfaceHolder(android.view.SurfaceHolder r2) {
+        /*
+            r1 = this;
+            r1.removeSurfaceCallbacks()
+            r1.surfaceHolder = r2
+            if (r2 != 0) goto L8
+            goto L1a
+        L8:
+            com.mbridge.msdk.playercommon.exoplayer2.SimpleExoPlayer$ComponentListener r0 = r1.componentListener
+            r2.addCallback(r0)
+            android.view.Surface r2 = r2.getSurface()
+            if (r2 == 0) goto L1a
+            boolean r0 = r2.isValid()
+            if (r0 == 0) goto L1a
+            goto L1b
+        L1a:
+            r2 = 0
+        L1b:
+            r0 = 0
+            r1.setVideoSurfaceInternal(r2, r0)
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.SimpleExoPlayer.setVideoSurfaceHolder(android.view.SurfaceHolder):void");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void clearVideoSurfaceHolder(SurfaceHolder surfaceHolder) {
+        if (surfaceHolder == null || surfaceHolder != this.surfaceHolder) {
+            return;
+        }
+        setVideoSurfaceHolder(null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void setVideoSurfaceView(SurfaceView surfaceView) {
+        setVideoSurfaceHolder(surfaceView == null ? null : surfaceView.getHolder());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void clearVideoSurfaceView(SurfaceView surfaceView) {
+        clearVideoSurfaceHolder(surfaceView == null ? null : surfaceView.getHolder());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void setVideoTextureView(TextureView textureView) {
+        removeSurfaceCallbacks();
+        this.textureView = textureView;
+        Surface surface = null;
+        if (textureView != null) {
+            if (textureView.getSurfaceTextureListener() != null) {
+                Log.w(TAG, "Replacing existing SurfaceTextureListener.");
+            }
+            textureView.setSurfaceTextureListener(this.componentListener);
+            SurfaceTexture surfaceTexture = textureView.isAvailable() ? textureView.getSurfaceTexture() : null;
+            if (surfaceTexture != null) {
+                surface = new Surface(surfaceTexture);
+            }
+        }
+        setVideoSurfaceInternal(surface, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void clearVideoTextureView(TextureView textureView) {
+        if (textureView == null || textureView != this.textureView) {
+            return;
+        }
+        setVideoTextureView(null);
+    }
+
+    @Deprecated
+    public void setAudioStreamType(int i) {
+        int audioUsageForStreamType = Util.getAudioUsageForStreamType(i);
+        setAudioAttributes(new AudioAttributes.Builder().setUsage(audioUsageForStreamType).setContentType(Util.getAudioContentTypeForStreamType(i)).build());
+    }
+
+    @Deprecated
+    public int getAudioStreamType() {
+        return Util.getStreamTypeForAudioUsage(this.audioAttributes.usage);
+    }
+
+    public void addAnalyticsListener(AnalyticsListener analyticsListener) {
+        this.analyticsCollector.addListener(analyticsListener);
+    }
+
+    public void removeAnalyticsListener(AnalyticsListener analyticsListener) {
+        this.analyticsCollector.removeListener(analyticsListener);
+    }
+
+    public void setAudioAttributes(AudioAttributes audioAttributes) {
+        this.audioAttributes = audioAttributes;
+        for (Renderer renderer : this.renderers) {
+            if (renderer.getTrackType() == 1) {
+                this.player.createMessage(renderer).setType(3).setPayload(audioAttributes).send();
+            }
+        }
+    }
+
+    public void setVolume(float f) {
+        this.audioVolume = f;
+        for (Renderer renderer : this.renderers) {
+            if (renderer.getTrackType() == 1) {
+                this.player.createMessage(renderer).setType(2).setPayload(Float.valueOf(f)).send();
+            }
+        }
+    }
+
+    @TargetApi(23)
+    @Deprecated
+    public void setPlaybackParams(@Nullable PlaybackParams playbackParams) {
+        PlaybackParameters playbackParameters;
+        if (playbackParams != null) {
+            playbackParams.allowDefaults();
+            playbackParameters = new PlaybackParameters(playbackParams.getSpeed(), playbackParams.getPitch());
+        } else {
+            playbackParameters = null;
+        }
+        setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void addVideoListener(com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener videoListener) {
+        this.videoListeners.add(videoListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.VideoComponent
+    public void removeVideoListener(com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener videoListener) {
+        this.videoListeners.remove(videoListener);
+    }
+
+    @Deprecated
+    public void setVideoListener(VideoListener videoListener) {
+        this.videoListeners.clear();
+        if (videoListener != null) {
+            addVideoListener(videoListener);
+        }
+    }
+
+    @Deprecated
+    public void clearVideoListener(VideoListener videoListener) {
+        removeVideoListener(videoListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.TextComponent
+    public void addTextOutput(TextOutput textOutput) {
+        if (!this.currentCues.isEmpty()) {
+            textOutput.onCues(this.currentCues);
+        }
+        this.textOutputs.add(textOutput);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.TextComponent
+    public void removeTextOutput(TextOutput textOutput) {
+        this.textOutputs.remove(textOutput);
+    }
+
+    @Deprecated
+    public void setTextOutput(TextOutput textOutput) {
+        this.textOutputs.clear();
+        if (textOutput != null) {
+            addTextOutput(textOutput);
+        }
+    }
+
+    @Deprecated
+    public void clearTextOutput(TextOutput textOutput) {
+        removeTextOutput(textOutput);
+    }
+
+    public void addMetadataOutput(MetadataOutput metadataOutput) {
+        this.metadataOutputs.add(metadataOutput);
+    }
+
+    public void removeMetadataOutput(MetadataOutput metadataOutput) {
+        this.metadataOutputs.remove(metadataOutput);
+    }
+
+    @Deprecated
+    public void setMetadataOutput(MetadataOutput metadataOutput) {
+        this.metadataOutputs.retainAll(Collections.singleton(this.analyticsCollector));
+        if (metadataOutput != null) {
+            addMetadataOutput(metadataOutput);
+        }
+    }
+
+    @Deprecated
+    public void clearMetadataOutput(MetadataOutput metadataOutput) {
+        removeMetadataOutput(metadataOutput);
+    }
+
+    @Deprecated
+    public void setVideoDebugListener(VideoRendererEventListener videoRendererEventListener) {
+        this.videoDebugListeners.retainAll(Collections.singleton(this.analyticsCollector));
+        if (videoRendererEventListener != null) {
+            addVideoDebugListener(videoRendererEventListener);
+        }
+    }
+
+    @Deprecated
+    public void addVideoDebugListener(VideoRendererEventListener videoRendererEventListener) {
+        this.videoDebugListeners.add(videoRendererEventListener);
+    }
+
+    @Deprecated
+    public void removeVideoDebugListener(VideoRendererEventListener videoRendererEventListener) {
+        this.videoDebugListeners.remove(videoRendererEventListener);
+    }
+
+    @Deprecated
+    public void setAudioDebugListener(AudioRendererEventListener audioRendererEventListener) {
+        this.audioDebugListeners.retainAll(Collections.singleton(this.analyticsCollector));
+        if (audioRendererEventListener != null) {
+            addAudioDebugListener(audioRendererEventListener);
+        }
+    }
+
+    @Deprecated
+    public void addAudioDebugListener(AudioRendererEventListener audioRendererEventListener) {
+        this.audioDebugListeners.add(audioRendererEventListener);
+    }
+
+    @Deprecated
+    public void removeAudioDebugListener(AudioRendererEventListener audioRendererEventListener) {
+        this.audioDebugListeners.remove(audioRendererEventListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public Looper getPlaybackLooper() {
+        return this.player.getPlaybackLooper();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void addListener(Player.EventListener eventListener) {
+        this.player.addListener(eventListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void removeListener(Player.EventListener eventListener) {
+        this.player.removeListener(eventListener);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getPlaybackState() {
+        return this.player.getPlaybackState();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public ExoPlaybackException getPlaybackError() {
+        return this.player.getPlaybackError();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public void prepare(MediaSource mediaSource) {
+        prepare(mediaSource, true, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public void prepare(MediaSource mediaSource, boolean z, boolean z2) {
+        MediaSource mediaSource2 = this.mediaSource;
+        if (mediaSource2 != mediaSource) {
+            if (mediaSource2 != null) {
+                mediaSource2.removeEventListener(this.analyticsCollector);
+                this.analyticsCollector.resetForNewMediaSource();
+            }
+            mediaSource.addEventListener(this.eventHandler, this.analyticsCollector);
+            this.mediaSource = mediaSource;
+        }
+        this.player.prepare(mediaSource, z, z2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void setPlayWhenReady(boolean z) {
+        this.player.setPlayWhenReady(z);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean getPlayWhenReady() {
+        return this.player.getPlayWhenReady();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getRepeatMode() {
+        return this.player.getRepeatMode();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void setRepeatMode(int i) {
+        this.player.setRepeatMode(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void setShuffleModeEnabled(boolean z) {
+        this.player.setShuffleModeEnabled(z);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean getShuffleModeEnabled() {
+        return this.player.getShuffleModeEnabled();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean isLoading() {
+        return this.player.isLoading();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void seekToDefaultPosition() {
+        this.analyticsCollector.notifySeekStarted();
+        this.player.seekToDefaultPosition();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void seekToDefaultPosition(int i) {
+        this.analyticsCollector.notifySeekStarted();
+        this.player.seekToDefaultPosition(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void seekTo(long j) {
+        this.analyticsCollector.notifySeekStarted();
+        this.player.seekTo(j);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void seekTo(int i, long j) {
+        this.analyticsCollector.notifySeekStarted();
+        this.player.seekTo(i, j);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void setPlaybackParameters(@Nullable PlaybackParameters playbackParameters) {
+        this.player.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public PlaybackParameters getPlaybackParameters() {
+        return this.player.getPlaybackParameters();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public void setSeekParameters(@Nullable SeekParameters seekParameters) {
+        this.player.setSeekParameters(seekParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    @Nullable
+    public Object getCurrentTag() {
+        return this.player.getCurrentTag();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void stop() {
+        stop(false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void stop(boolean z) {
+        this.player.stop(z);
+        MediaSource mediaSource = this.mediaSource;
+        if (mediaSource != null) {
+            mediaSource.removeEventListener(this.analyticsCollector);
+            this.mediaSource = null;
+            this.analyticsCollector.resetForNewMediaSource();
+        }
+        this.currentCues = Collections.emptyList();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public void release() {
+        this.player.release();
+        removeSurfaceCallbacks();
+        Surface surface = this.surface;
+        if (surface != null) {
+            if (this.ownsSurface) {
+                surface.release();
+            }
+            this.surface = null;
+        }
+        MediaSource mediaSource = this.mediaSource;
+        if (mediaSource != null) {
+            mediaSource.removeEventListener(this.analyticsCollector);
+        }
+        this.currentCues = Collections.emptyList();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public void sendMessages(ExoPlayer.ExoPlayerMessage... exoPlayerMessageArr) {
+        this.player.sendMessages(exoPlayerMessageArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public PlayerMessage createMessage(PlayerMessage.Target target) {
+        return this.player.createMessage(target);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.ExoPlayer
+    public void blockingSendMessages(ExoPlayer.ExoPlayerMessage... exoPlayerMessageArr) {
+        this.player.blockingSendMessages(exoPlayerMessageArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getRendererCount() {
+        return this.player.getRendererCount();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getRendererType(int i) {
+        return this.player.getRendererType(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public TrackGroupArray getCurrentTrackGroups() {
+        return this.player.getCurrentTrackGroups();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public TrackSelectionArray getCurrentTrackSelections() {
+        return this.player.getCurrentTrackSelections();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public Timeline getCurrentTimeline() {
+        return this.player.getCurrentTimeline();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public Object getCurrentManifest() {
+        return this.player.getCurrentManifest();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getCurrentPeriodIndex() {
+        return this.player.getCurrentPeriodIndex();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getCurrentWindowIndex() {
+        return this.player.getCurrentWindowIndex();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getNextWindowIndex() {
+        return this.player.getNextWindowIndex();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getPreviousWindowIndex() {
+        return this.player.getPreviousWindowIndex();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public long getDuration() {
+        return this.player.getDuration();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public long getCurrentPosition() {
+        return this.player.getCurrentPosition();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public long getBufferedPosition() {
+        return this.player.getBufferedPosition();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getBufferedPercentage() {
+        return this.player.getBufferedPercentage();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean isCurrentWindowDynamic() {
+        return this.player.isCurrentWindowDynamic();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean isCurrentWindowSeekable() {
+        return this.player.isCurrentWindowSeekable();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public boolean isPlayingAd() {
+        return this.player.isPlayingAd();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getCurrentAdGroupIndex() {
+        return this.player.getCurrentAdGroupIndex();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public int getCurrentAdIndexInAdGroup() {
+        return this.player.getCurrentAdIndexInAdGroup();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player
+    public long getContentPosition() {
+        return this.player.getContentPosition();
+    }
+
+    public ExoPlayer createExoPlayerImpl(Renderer[] rendererArr, TrackSelector trackSelector, LoadControl loadControl, Clock clock) {
+        return new ExoPlayerImpl(rendererArr, trackSelector, loadControl, clock);
+    }
+
+    private void removeSurfaceCallbacks() {
+        TextureView textureView = this.textureView;
+        if (textureView != null) {
+            if (textureView.getSurfaceTextureListener() != this.componentListener) {
+                Log.w(TAG, "SurfaceTextureListener already unset or replaced.");
+            } else {
+                this.textureView.setSurfaceTextureListener(null);
+            }
+            this.textureView = null;
+        }
+        SurfaceHolder surfaceHolder = this.surfaceHolder;
+        if (surfaceHolder != null) {
+            surfaceHolder.removeCallback(this.componentListener);
+            this.surfaceHolder = null;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void setVideoSurfaceInternal(Surface surface, boolean z) {
+        ArrayList arrayList = new ArrayList();
+        for (Renderer renderer : this.renderers) {
+            if (renderer.getTrackType() == 2) {
+                arrayList.add(this.player.createMessage(renderer).setType(1).setPayload(surface).send());
+            }
+        }
+        Surface surface2 = this.surface;
+        if (surface2 != null && surface2 != surface) {
+            try {
+                Iterator it = arrayList.iterator();
+                while (it.hasNext()) {
+                    ((PlayerMessage) it.next()).blockUntilDelivered();
+                }
+            } catch (InterruptedException unused) {
+                Thread.currentThread().interrupt();
+            } catch (TimeoutException unused2) {
+                this.player.stop(false);
+            }
+            if (this.ownsSurface) {
+                this.surface.release();
+            }
+        }
+        this.surface = surface;
+        this.ownsSurface = z;
+    }
+
+    public final class ComponentListener implements SurfaceHolder.Callback, TextureView.SurfaceTextureListener, AudioRendererEventListener, MetadataOutput, TextOutput, VideoRendererEventListener {
+        @Override // android.view.TextureView.SurfaceTextureListener
+        public final void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int i, int i2) {
+        }
+
+        @Override // android.view.TextureView.SurfaceTextureListener
+        public final void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public final void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i2, int i3) {
+        }
+
+        private ComponentListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onVideoEnabled(DecoderCounters decoderCounters) {
+            SimpleExoPlayer.this.videoDecoderCounters = decoderCounters;
+            Iterator it = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((VideoRendererEventListener) it.next()).onVideoEnabled(decoderCounters);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onVideoDecoderInitialized(String str, long j, long j2) {
+            Iterator it = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((VideoRendererEventListener) it.next()).onVideoDecoderInitialized(str, j, j2);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onVideoInputFormatChanged(Format format) {
+            SimpleExoPlayer.this.videoFormat = format;
+            Iterator it = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((VideoRendererEventListener) it.next()).onVideoInputFormatChanged(format);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onDroppedFrames(int i, long j) {
+            Iterator it = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((VideoRendererEventListener) it.next()).onDroppedFrames(i, j);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onVideoSizeChanged(int i, int i2, int i3, float f) {
+            Iterator it = SimpleExoPlayer.this.videoListeners.iterator();
+            while (it.hasNext()) {
+                ((com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener) it.next()).onVideoSizeChanged(i, i2, i3, f);
+            }
+            Iterator it2 = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it2.hasNext()) {
+                ((VideoRendererEventListener) it2.next()).onVideoSizeChanged(i, i2, i3, f);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onRenderedFirstFrame(Surface surface) {
+            if (SimpleExoPlayer.this.surface == surface) {
+                Iterator it = SimpleExoPlayer.this.videoListeners.iterator();
+                while (it.hasNext()) {
+                    ((com.mbridge.msdk.playercommon.exoplayer2.video.VideoListener) it.next()).onRenderedFirstFrame();
+                }
+            }
+            Iterator it2 = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it2.hasNext()) {
+                ((VideoRendererEventListener) it2.next()).onRenderedFirstFrame(surface);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+        public final void onVideoDisabled(DecoderCounters decoderCounters) {
+            Iterator it = SimpleExoPlayer.this.videoDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((VideoRendererEventListener) it.next()).onVideoDisabled(decoderCounters);
+            }
+            SimpleExoPlayer.this.videoFormat = null;
+            SimpleExoPlayer.this.videoDecoderCounters = null;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioEnabled(DecoderCounters decoderCounters) {
+            SimpleExoPlayer.this.audioDecoderCounters = decoderCounters;
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioEnabled(decoderCounters);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioSessionId(int i) {
+            SimpleExoPlayer.this.audioSessionId = i;
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioSessionId(i);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioDecoderInitialized(String str, long j, long j2) {
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioDecoderInitialized(str, j, j2);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioInputFormatChanged(Format format) {
+            SimpleExoPlayer.this.audioFormat = format;
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioInputFormatChanged(format);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioSinkUnderrun(int i, long j, long j2) {
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioSinkUnderrun(i, j, j2);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+        public final void onAudioDisabled(DecoderCounters decoderCounters) {
+            Iterator it = SimpleExoPlayer.this.audioDebugListeners.iterator();
+            while (it.hasNext()) {
+                ((AudioRendererEventListener) it.next()).onAudioDisabled(decoderCounters);
+            }
+            SimpleExoPlayer.this.audioFormat = null;
+            SimpleExoPlayer.this.audioDecoderCounters = null;
+            SimpleExoPlayer.this.audioSessionId = 0;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.text.TextOutput
+        public final void onCues(List<Cue> list) {
+            SimpleExoPlayer.this.currentCues = list;
+            Iterator it = SimpleExoPlayer.this.textOutputs.iterator();
+            while (it.hasNext()) {
+                ((TextOutput) it.next()).onCues(list);
+            }
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput
+        public final void onMetadata(Metadata metadata) {
+            Iterator it = SimpleExoPlayer.this.metadataOutputs.iterator();
+            while (it.hasNext()) {
+                ((MetadataOutput) it.next()).onMetadata(metadata);
+            }
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public final void surfaceCreated(SurfaceHolder surfaceHolder) {
+            SimpleExoPlayer.this.setVideoSurfaceInternal(surfaceHolder.getSurface(), false);
+        }
+
+        @Override // android.view.SurfaceHolder.Callback
+        public final void surfaceDestroyed(SurfaceHolder surfaceHolder) {
+            SimpleExoPlayer.this.setVideoSurfaceInternal(null, false);
+        }
+
+        @Override // android.view.TextureView.SurfaceTextureListener
+        public final void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int i, int i2) {
+            SimpleExoPlayer.this.setVideoSurfaceInternal(new Surface(surfaceTexture), true);
+        }
+
+        @Override // android.view.TextureView.SurfaceTextureListener
+        public final boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
+            SimpleExoPlayer.this.setVideoSurfaceInternal(null, true);
+            return true;
+        }
+    }
+
+    public final boolean isPlaying() {
+        return getPlaybackState() == 3 && getPlayWhenReady();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/Timeline.java

@@ -0,0 +1,283 @@
+package com.mbridge.msdk.playercommon.exoplayer2;
+
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.source.ads.AdPlaybackState;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public abstract class Timeline {
+    public static final Timeline EMPTY = new Timeline() { // from class: com.mbridge.msdk.playercommon.exoplayer2.Timeline.1
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Timeline
+        public int getIndexOfPeriod(Object obj) {
+            return -1;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Timeline
+        public int getPeriodCount() {
+            return 0;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Timeline
+        public int getWindowCount() {
+            return 0;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Timeline
+        public Window getWindow(int i, Window window, boolean z, long j) {
+            throw new IndexOutOfBoundsException();
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.Timeline
+        public Period getPeriod(int i, Period period, boolean z) {
+            throw new IndexOutOfBoundsException();
+        }
+    };
+
+    public abstract int getIndexOfPeriod(Object obj);
+
+    public abstract Period getPeriod(int i, Period period, boolean z);
+
+    public abstract int getPeriodCount();
+
+    public abstract Window getWindow(int i, Window window, boolean z, long j);
+
+    public abstract int getWindowCount();
+
+    public static final class Window {
+        public long defaultPositionUs;
+        public long durationUs;
+        public int firstPeriodIndex;
+        public boolean isDynamic;
+        public boolean isSeekable;
+        public int lastPeriodIndex;
+        public long positionInFirstPeriodUs;
+        public long presentationStartTimeMs;
+
+        @Nullable
+        public Object tag;
+        public long windowStartTimeMs;
+
+        public final long getDefaultPositionUs() {
+            return this.defaultPositionUs;
+        }
+
+        public final long getDurationUs() {
+            return this.durationUs;
+        }
+
+        public final long getPositionInFirstPeriodUs() {
+            return this.positionInFirstPeriodUs;
+        }
+
+        public final Window set(@Nullable Object obj, long j, long j2, boolean z, boolean z2, long j3, long j4, int i, int i2, long j5) {
+            this.tag = obj;
+            this.presentationStartTimeMs = j;
+            this.windowStartTimeMs = j2;
+            this.isSeekable = z;
+            this.isDynamic = z2;
+            this.defaultPositionUs = j3;
+            this.durationUs = j4;
+            this.firstPeriodIndex = i;
+            this.lastPeriodIndex = i2;
+            this.positionInFirstPeriodUs = j5;
+            return this;
+        }
+
+        public final long getDefaultPositionMs() {
+            return C.usToMs(this.defaultPositionUs);
+        }
+
+        public final long getDurationMs() {
+            return C.usToMs(this.durationUs);
+        }
+
+        public final long getPositionInFirstPeriodMs() {
+            return C.usToMs(this.positionInFirstPeriodUs);
+        }
+    }
+
+    public static final class Period {
+        private AdPlaybackState adPlaybackState;
+        public long durationUs;
+        public Object id;
+        private long positionInWindowUs;
+        public Object uid;
+        public int windowIndex;
+
+        public final long getDurationUs() {
+            return this.durationUs;
+        }
+
+        public final long getPositionInWindowUs() {
+            return this.positionInWindowUs;
+        }
+
+        public final Period set(Object obj, Object obj2, int i, long j, long j2, AdPlaybackState adPlaybackState) {
+            this.id = obj;
+            this.uid = obj2;
+            this.windowIndex = i;
+            this.durationUs = j;
+            this.positionInWindowUs = j2;
+            this.adPlaybackState = adPlaybackState;
+            return this;
+        }
+
+        public final Period set(Object obj, Object obj2, int i, long j, long j2) {
+            return set(obj, obj2, i, j, j2, AdPlaybackState.NONE);
+        }
+
+        public final long getDurationMs() {
+            return C.usToMs(this.durationUs);
+        }
+
+        public final long getPositionInWindowMs() {
+            return C.usToMs(this.positionInWindowUs);
+        }
+
+        public final int getAdGroupCount() {
+            return this.adPlaybackState.adGroupCount;
+        }
+
+        public final long getAdGroupTimeUs(int i) {
+            return this.adPlaybackState.adGroupTimesUs[i];
+        }
+
+        public final int getFirstAdIndexToPlay(int i) {
+            return this.adPlaybackState.adGroups[i].getFirstAdIndexToPlay();
+        }
+
+        public final int getNextAdIndexToPlay(int i, int i2) {
+            return this.adPlaybackState.adGroups[i].getNextAdIndexToPlay(i2);
+        }
+
+        public final boolean hasPlayedAdGroup(int i) {
+            return !this.adPlaybackState.adGroups[i].hasUnplayedAds();
+        }
+
+        public final int getAdGroupIndexForPositionUs(long j) {
+            return this.adPlaybackState.getAdGroupIndexForPositionUs(j);
+        }
+
+        public final int getAdGroupIndexAfterPositionUs(long j) {
+            return this.adPlaybackState.getAdGroupIndexAfterPositionUs(j);
+        }
+
+        public final int getAdCountInAdGroup(int i) {
+            return this.adPlaybackState.adGroups[i].count;
+        }
+
+        public final boolean isAdAvailable(int i, int i2) {
+            AdPlaybackState.AdGroup adGroup = this.adPlaybackState.adGroups[i];
+            return (adGroup.count == -1 || adGroup.states[i2] == 0) ? false : true;
+        }
+
+        public final long getAdDurationUs(int i, int i2) {
+            AdPlaybackState.AdGroup adGroup = this.adPlaybackState.adGroups[i];
+            return adGroup.count != -1 ? adGroup.durationsUs[i2] : C.TIME_UNSET;
+        }
+
+        public final long getAdResumePositionUs() {
+            return this.adPlaybackState.adResumePositionUs;
+        }
+    }
+
+    public final boolean isEmpty() {
+        return getWindowCount() == 0;
+    }
+
+    public int getNextWindowIndex(int i, int i2, boolean z) {
+        if (i2 == 0) {
+            if (i == getLastWindowIndex(z)) {
+                return -1;
+            }
+            return i + 1;
+        }
+        if (i2 == 1) {
+            return i;
+        }
+        if (i2 == 2) {
+            return i == getLastWindowIndex(z) ? getFirstWindowIndex(z) : i + 1;
+        }
+        throw new IllegalStateException();
+    }
+
+    public int getPreviousWindowIndex(int i, int i2, boolean z) {
+        if (i2 == 0) {
+            if (i == getFirstWindowIndex(z)) {
+                return -1;
+            }
+            return i - 1;
+        }
+        if (i2 == 1) {
+            return i;
+        }
+        if (i2 == 2) {
+            return i == getFirstWindowIndex(z) ? getLastWindowIndex(z) : i - 1;
+        }
+        throw new IllegalStateException();
+    }
+
+    public int getLastWindowIndex(boolean z) {
+        if (isEmpty()) {
+            return -1;
+        }
+        return getWindowCount() - 1;
+    }
+
+    public int getFirstWindowIndex(boolean z) {
+        return isEmpty() ? -1 : 0;
+    }
+
+    public final Window getWindow(int i, Window window) {
+        return getWindow(i, window, false);
+    }
+
+    public final Window getWindow(int i, Window window, boolean z) {
+        return getWindow(i, window, z, 0L);
+    }
+
+    public final int getNextPeriodIndex(int i, Period period, Window window, int i2, boolean z) {
+        int i3 = getPeriod(i, period).windowIndex;
+        if (getWindow(i3, window).lastPeriodIndex != i) {
+            return i + 1;
+        }
+        int nextWindowIndex = getNextWindowIndex(i3, i2, z);
+        if (nextWindowIndex == -1) {
+            return -1;
+        }
+        return getWindow(nextWindowIndex, window).firstPeriodIndex;
+    }
+
+    public final boolean isLastPeriod(int i, Period period, Window window, int i2, boolean z) {
+        return getNextPeriodIndex(i, period, window, i2, z) == -1;
+    }
+
+    public final Pair<Integer, Long> getPeriodPosition(Window window, Period period, int i, long j) {
+        return getPeriodPosition(window, period, i, j, 0L);
+    }
+
+    public final Pair<Integer, Long> getPeriodPosition(Window window, Period period, int i, long j, long j2) {
+        Assertions.checkIndex(i, 0, getWindowCount());
+        getWindow(i, window, false, j2);
+        if (j == C.TIME_UNSET) {
+            j = window.getDefaultPositionUs();
+            if (j == C.TIME_UNSET) {
+                return null;
+            }
+        }
+        int i2 = window.firstPeriodIndex;
+        long positionInFirstPeriodUs = window.getPositionInFirstPeriodUs() + j;
+        long durationUs = getPeriod(i2, period).getDurationUs();
+        while (durationUs != C.TIME_UNSET && positionInFirstPeriodUs >= durationUs && i2 < window.lastPeriodIndex) {
+            positionInFirstPeriodUs -= durationUs;
+            i2++;
+            durationUs = getPeriod(i2, period).getDurationUs();
+        }
+        return Pair.create(Integer.valueOf(i2), Long.valueOf(positionInFirstPeriodUs));
+    }
+
+    public final Period getPeriod(int i, Period period) {
+        return getPeriod(i, period, false);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/analytics/AnalyticsCollector.java

@@ -0,0 +1,647 @@
+package com.mbridge.msdk.playercommon.exoplayer2.analytics;
+
+import android.net.NetworkInfo;
+import android.view.Surface;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.Player;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.BandwidthMeter;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Clock;
+import com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+/* loaded from: classes4.dex */
+public class AnalyticsCollector implements Player.EventListener, AudioRendererEventListener, DefaultDrmSessionEventListener, MetadataOutput, MediaSourceEventListener, BandwidthMeter.EventListener, VideoRendererEventListener {
+    private final Clock clock;
+
+    @Nullable
+    private Player player;
+    private final CopyOnWriteArraySet<AnalyticsListener> listeners = new CopyOnWriteArraySet<>();
+    private final MediaPeriodQueueTracker mediaPeriodQueueTracker = new MediaPeriodQueueTracker();
+    private final Timeline.Window window = new Timeline.Window();
+
+    public static class Factory {
+        public AnalyticsCollector createAnalyticsCollector(@Nullable Player player, Clock clock) {
+            return new AnalyticsCollector(player, clock);
+        }
+    }
+
+    public AnalyticsCollector(@Nullable Player player, Clock clock) {
+        this.player = player;
+        this.clock = (Clock) Assertions.checkNotNull(clock);
+    }
+
+    public void addListener(AnalyticsListener analyticsListener) {
+        this.listeners.add(analyticsListener);
+    }
+
+    public void removeListener(AnalyticsListener analyticsListener) {
+        this.listeners.remove(analyticsListener);
+    }
+
+    public void setPlayer(Player player) {
+        Assertions.checkState(this.player == null);
+        this.player = (Player) Assertions.checkNotNull(player);
+    }
+
+    public final void notifySeekStarted() {
+        if (this.mediaPeriodQueueTracker.isSeeking()) {
+            return;
+        }
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        this.mediaPeriodQueueTracker.onSeekStarted();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onSeekStarted(generatePlayingMediaPeriodEventTime);
+        }
+    }
+
+    public final void notifyViewportSizeChanged(int i, int i2) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onViewportSizeChange(generatePlayingMediaPeriodEventTime, i, i2);
+        }
+    }
+
+    public final void notifyNetworkTypeChanged(@Nullable NetworkInfo networkInfo) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onNetworkTypeChanged(generatePlayingMediaPeriodEventTime, networkInfo);
+        }
+    }
+
+    public final void resetForNewMediaSource() {
+        for (WindowAndMediaPeriodId windowAndMediaPeriodId : new ArrayList(this.mediaPeriodQueueTracker.activeMediaPeriods)) {
+            onMediaPeriodReleased(windowAndMediaPeriodId.windowIndex, windowAndMediaPeriodId.mediaPeriodId);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.metadata.MetadataOutput
+    public final void onMetadata(Metadata metadata) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onMetadata(generatePlayingMediaPeriodEventTime, metadata);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioEnabled(DecoderCounters decoderCounters) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderEnabled(generatePlayingMediaPeriodEventTime, 1, decoderCounters);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioSessionId(int i) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onAudioSessionId(generateReadingMediaPeriodEventTime, i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioDecoderInitialized(String str, long j, long j2) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderInitialized(generateReadingMediaPeriodEventTime, 1, str, j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioInputFormatChanged(Format format) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderInputFormatChanged(generateReadingMediaPeriodEventTime, 1, format);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioSinkUnderrun(int i, long j, long j2) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onAudioUnderrun(generateReadingMediaPeriodEventTime, i, j, j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener
+    public final void onAudioDisabled(DecoderCounters decoderCounters) {
+        AnalyticsListener.EventTime generateLastReportedPlayingMediaPeriodEventTime = generateLastReportedPlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderDisabled(generateLastReportedPlayingMediaPeriodEventTime, 1, decoderCounters);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onVideoEnabled(DecoderCounters decoderCounters) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderEnabled(generatePlayingMediaPeriodEventTime, 2, decoderCounters);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onVideoDecoderInitialized(String str, long j, long j2) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderInitialized(generateReadingMediaPeriodEventTime, 2, str, j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onVideoInputFormatChanged(Format format) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderInputFormatChanged(generateReadingMediaPeriodEventTime, 2, format);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onDroppedFrames(int i, long j) {
+        AnalyticsListener.EventTime generateLastReportedPlayingMediaPeriodEventTime = generateLastReportedPlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDroppedVideoFrames(generateLastReportedPlayingMediaPeriodEventTime, i, j);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onVideoSizeChanged(int i, int i2, int i3, float f) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onVideoSizeChanged(generateReadingMediaPeriodEventTime, i, i2, i3, f);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onRenderedFirstFrame(Surface surface) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onRenderedFirstFrame(generateReadingMediaPeriodEventTime, surface);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.video.VideoRendererEventListener
+    public final void onVideoDisabled(DecoderCounters decoderCounters) {
+        AnalyticsListener.EventTime generateLastReportedPlayingMediaPeriodEventTime = generateLastReportedPlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDecoderDisabled(generateLastReportedPlayingMediaPeriodEventTime, 2, decoderCounters);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onMediaPeriodCreated(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+        this.mediaPeriodQueueTracker.onMediaPeriodCreated(i, mediaPeriodId);
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onMediaPeriodCreated(generateEventTime);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onMediaPeriodReleased(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+        this.mediaPeriodQueueTracker.onMediaPeriodReleased(i, mediaPeriodId);
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onMediaPeriodReleased(generateEventTime);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onLoadStarted(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onLoadStarted(generateEventTime, loadEventInfo, mediaLoadData);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onLoadCompleted(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onLoadCompleted(generateEventTime, loadEventInfo, mediaLoadData);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onLoadCanceled(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onLoadCanceled(generateEventTime, loadEventInfo, mediaLoadData);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onLoadError(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData, IOException iOException, boolean z) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onLoadError(generateEventTime, loadEventInfo, mediaLoadData, iOException, z);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onReadingStarted(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+        this.mediaPeriodQueueTracker.onReadingStarted(i, mediaPeriodId);
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onReadingStarted(generateEventTime);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onUpstreamDiscarded(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onUpstreamDiscarded(generateEventTime, mediaLoadData);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener
+    public final void onDownstreamFormatChanged(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+        AnalyticsListener.EventTime generateEventTime = generateEventTime(i, mediaPeriodId);
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDownstreamFormatChanged(generateEventTime, mediaLoadData);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onTimelineChanged(Timeline timeline, @Nullable Object obj, int i) {
+        this.mediaPeriodQueueTracker.onTimelineChanged(timeline);
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onTimelineChanged(generatePlayingMediaPeriodEventTime, i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onTracksChanged(TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onTracksChanged(generatePlayingMediaPeriodEventTime, trackGroupArray, trackSelectionArray);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onLoadingChanged(boolean z) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onLoadingChanged(generatePlayingMediaPeriodEventTime, z);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onPlayerStateChanged(boolean z, int i) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onPlayerStateChanged(generatePlayingMediaPeriodEventTime, z, i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onRepeatModeChanged(int i) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onRepeatModeChanged(generatePlayingMediaPeriodEventTime, i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onShuffleModeEnabledChanged(boolean z) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onShuffleModeChanged(generatePlayingMediaPeriodEventTime, z);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onPlayerError(ExoPlaybackException exoPlaybackException) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onPlayerError(generatePlayingMediaPeriodEventTime, exoPlaybackException);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onPositionDiscontinuity(int i) {
+        this.mediaPeriodQueueTracker.onPositionDiscontinuity(i);
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onPositionDiscontinuity(generatePlayingMediaPeriodEventTime, i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onPlaybackParametersChanged(PlaybackParameters playbackParameters) {
+        AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onPlaybackParametersChanged(generatePlayingMediaPeriodEventTime, playbackParameters);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Player.EventListener
+    public final void onSeekProcessed() {
+        if (this.mediaPeriodQueueTracker.isSeeking()) {
+            this.mediaPeriodQueueTracker.onSeekProcessed();
+            AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime = generatePlayingMediaPeriodEventTime();
+            Iterator<AnalyticsListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                it.next().onSeekProcessed(generatePlayingMediaPeriodEventTime);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.upstream.BandwidthMeter.EventListener
+    public final void onBandwidthSample(int i, long j, long j2) {
+        AnalyticsListener.EventTime generateLoadingMediaPeriodEventTime = generateLoadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onBandwidthEstimate(generateLoadingMediaPeriodEventTime, i, j, j2);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+    public final void onDrmKeysLoaded() {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDrmKeysLoaded(generateReadingMediaPeriodEventTime);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+    public final void onDrmSessionManagerError(Exception exc) {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDrmSessionManagerError(generateReadingMediaPeriodEventTime, exc);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+    public final void onDrmKeysRestored() {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDrmKeysRestored(generateReadingMediaPeriodEventTime);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+    public final void onDrmKeysRemoved() {
+        AnalyticsListener.EventTime generateReadingMediaPeriodEventTime = generateReadingMediaPeriodEventTime();
+        Iterator<AnalyticsListener> it = this.listeners.iterator();
+        while (it.hasNext()) {
+            it.next().onDrmKeysRemoved(generateReadingMediaPeriodEventTime);
+        }
+    }
+
+    public Set<AnalyticsListener> getListeners() {
+        return Collections.unmodifiableSet(this.listeners);
+    }
+
+    public AnalyticsListener.EventTime generateEventTime(int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId) {
+        long defaultPositionMs;
+        long j;
+        Assertions.checkNotNull(this.player);
+        long elapsedRealtime = this.clock.elapsedRealtime();
+        Timeline currentTimeline = this.player.getCurrentTimeline();
+        long j2 = 0;
+        if (i == this.player.getCurrentWindowIndex()) {
+            if (mediaPeriodId != null && mediaPeriodId.isAd()) {
+                if (this.player.getCurrentAdGroupIndex() == mediaPeriodId.adGroupIndex && this.player.getCurrentAdIndexInAdGroup() == mediaPeriodId.adIndexInAdGroup) {
+                    j2 = this.player.getCurrentPosition();
+                }
+                j = j2;
+            } else {
+                defaultPositionMs = this.player.getContentPosition();
+                j = defaultPositionMs;
+            }
+        } else {
+            if (i < currentTimeline.getWindowCount() && (mediaPeriodId == null || !mediaPeriodId.isAd())) {
+                defaultPositionMs = currentTimeline.getWindow(i, this.window).getDefaultPositionMs();
+                j = defaultPositionMs;
+            }
+            j = j2;
+        }
+        return new AnalyticsListener.EventTime(elapsedRealtime, currentTimeline, i, mediaPeriodId, j, this.player.getCurrentPosition(), this.player.getBufferedPosition() - this.player.getContentPosition());
+    }
+
+    private AnalyticsListener.EventTime generateEventTime(@Nullable WindowAndMediaPeriodId windowAndMediaPeriodId) {
+        if (windowAndMediaPeriodId == null) {
+            int currentWindowIndex = ((Player) Assertions.checkNotNull(this.player)).getCurrentWindowIndex();
+            return generateEventTime(currentWindowIndex, this.mediaPeriodQueueTracker.tryResolveWindowIndex(currentWindowIndex));
+        }
+        return generateEventTime(windowAndMediaPeriodId.windowIndex, windowAndMediaPeriodId.mediaPeriodId);
+    }
+
+    private AnalyticsListener.EventTime generateLastReportedPlayingMediaPeriodEventTime() {
+        return generateEventTime(this.mediaPeriodQueueTracker.getLastReportedPlayingMediaPeriod());
+    }
+
+    private AnalyticsListener.EventTime generatePlayingMediaPeriodEventTime() {
+        return generateEventTime(this.mediaPeriodQueueTracker.getPlayingMediaPeriod());
+    }
+
+    private AnalyticsListener.EventTime generateReadingMediaPeriodEventTime() {
+        return generateEventTime(this.mediaPeriodQueueTracker.getReadingMediaPeriod());
+    }
+
+    private AnalyticsListener.EventTime generateLoadingMediaPeriodEventTime() {
+        return generateEventTime(this.mediaPeriodQueueTracker.getLoadingMediaPeriod());
+    }
+
+    public static final class MediaPeriodQueueTracker {
+        private boolean isSeeking;
+        private WindowAndMediaPeriodId lastReportedPlayingMediaPeriod;
+        private WindowAndMediaPeriodId readingMediaPeriod;
+        private final ArrayList<WindowAndMediaPeriodId> activeMediaPeriods = new ArrayList<>();
+        private final Timeline.Period period = new Timeline.Period();
+        private Timeline timeline = Timeline.EMPTY;
+
+        @Nullable
+        public final WindowAndMediaPeriodId getLastReportedPlayingMediaPeriod() {
+            return this.lastReportedPlayingMediaPeriod;
+        }
+
+        @Nullable
+        public final WindowAndMediaPeriodId getReadingMediaPeriod() {
+            return this.readingMediaPeriod;
+        }
+
+        public final boolean isSeeking() {
+            return this.isSeeking;
+        }
+
+        public final void onSeekStarted() {
+            this.isSeeking = true;
+        }
+
+        @Nullable
+        public final WindowAndMediaPeriodId getPlayingMediaPeriod() {
+            if (this.activeMediaPeriods.isEmpty() || this.timeline.isEmpty() || this.isSeeking) {
+                return null;
+            }
+            return this.activeMediaPeriods.get(0);
+        }
+
+        @Nullable
+        public final WindowAndMediaPeriodId getLoadingMediaPeriod() {
+            if (this.activeMediaPeriods.isEmpty()) {
+                return null;
+            }
+            return this.activeMediaPeriods.get(r0.size() - 1);
+        }
+
+        @Nullable
+        public final MediaSource.MediaPeriodId tryResolveWindowIndex(int i) {
+            Timeline timeline = this.timeline;
+            if (timeline == null) {
+                return null;
+            }
+            int periodCount = timeline.getPeriodCount();
+            MediaSource.MediaPeriodId mediaPeriodId = null;
+            for (int i2 = 0; i2 < this.activeMediaPeriods.size(); i2++) {
+                WindowAndMediaPeriodId windowAndMediaPeriodId = this.activeMediaPeriods.get(i2);
+                int i3 = windowAndMediaPeriodId.mediaPeriodId.periodIndex;
+                if (i3 < periodCount && this.timeline.getPeriod(i3, this.period).windowIndex == i) {
+                    if (mediaPeriodId != null) {
+                        return null;
+                    }
+                    mediaPeriodId = windowAndMediaPeriodId.mediaPeriodId;
+                }
+            }
+            return mediaPeriodId;
+        }
+
+        public final void onPositionDiscontinuity(int i) {
+            updateLastReportedPlayingMediaPeriod();
+        }
+
+        public final void onTimelineChanged(Timeline timeline) {
+            for (int i = 0; i < this.activeMediaPeriods.size(); i++) {
+                ArrayList<WindowAndMediaPeriodId> arrayList = this.activeMediaPeriods;
+                arrayList.set(i, updateMediaPeriodToNewTimeline(arrayList.get(i), timeline));
+            }
+            WindowAndMediaPeriodId windowAndMediaPeriodId = this.readingMediaPeriod;
+            if (windowAndMediaPeriodId != null) {
+                this.readingMediaPeriod = updateMediaPeriodToNewTimeline(windowAndMediaPeriodId, timeline);
+            }
+            this.timeline = timeline;
+            updateLastReportedPlayingMediaPeriod();
+        }
+
+        public final void onSeekProcessed() {
+            this.isSeeking = false;
+            updateLastReportedPlayingMediaPeriod();
+        }
+
+        public final void onMediaPeriodCreated(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+            this.activeMediaPeriods.add(new WindowAndMediaPeriodId(i, mediaPeriodId));
+            if (this.activeMediaPeriods.size() != 1 || this.timeline.isEmpty()) {
+                return;
+            }
+            updateLastReportedPlayingMediaPeriod();
+        }
+
+        public final void onMediaPeriodReleased(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+            WindowAndMediaPeriodId windowAndMediaPeriodId = new WindowAndMediaPeriodId(i, mediaPeriodId);
+            this.activeMediaPeriods.remove(windowAndMediaPeriodId);
+            if (windowAndMediaPeriodId.equals(this.readingMediaPeriod)) {
+                this.readingMediaPeriod = this.activeMediaPeriods.isEmpty() ? null : this.activeMediaPeriods.get(0);
+            }
+        }
+
+        public final void onReadingStarted(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+            this.readingMediaPeriod = new WindowAndMediaPeriodId(i, mediaPeriodId);
+        }
+
+        private void updateLastReportedPlayingMediaPeriod() {
+            if (this.activeMediaPeriods.isEmpty()) {
+                return;
+            }
+            this.lastReportedPlayingMediaPeriod = this.activeMediaPeriods.get(0);
+        }
+
+        private WindowAndMediaPeriodId updateMediaPeriodToNewTimeline(WindowAndMediaPeriodId windowAndMediaPeriodId, Timeline timeline) {
+            int indexOfPeriod;
+            return (timeline.isEmpty() || this.timeline.isEmpty() || (indexOfPeriod = timeline.getIndexOfPeriod(this.timeline.getPeriod(windowAndMediaPeriodId.mediaPeriodId.periodIndex, this.period, true).uid)) == -1) ? windowAndMediaPeriodId : new WindowAndMediaPeriodId(timeline.getPeriod(indexOfPeriod, this.period).windowIndex, windowAndMediaPeriodId.mediaPeriodId.copyWithPeriodIndex(indexOfPeriod));
+        }
+    }
+
+    public static final class WindowAndMediaPeriodId {
+        public final MediaSource.MediaPeriodId mediaPeriodId;
+        public final int windowIndex;
+
+        public WindowAndMediaPeriodId(int i, MediaSource.MediaPeriodId mediaPeriodId) {
+            this.windowIndex = i;
+            this.mediaPeriodId = mediaPeriodId;
+        }
+
+        public final boolean equals(@Nullable Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || WindowAndMediaPeriodId.class != obj.getClass()) {
+                return false;
+            }
+            WindowAndMediaPeriodId windowAndMediaPeriodId = (WindowAndMediaPeriodId) obj;
+            return this.windowIndex == windowAndMediaPeriodId.windowIndex && this.mediaPeriodId.equals(windowAndMediaPeriodId.mediaPeriodId);
+        }
+
+        public final int hashCode() {
+            return (this.windowIndex * 31) + this.mediaPeriodId.hashCode();
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/analytics/AnalyticsListener.java

@@ -0,0 +1,115 @@
+package com.mbridge.msdk.playercommon.exoplayer2.analytics;
+
+import android.net.NetworkInfo;
+import android.view.Surface;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.Timeline;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSource;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface AnalyticsListener {
+    void onAudioSessionId(EventTime eventTime, int i);
+
+    void onAudioUnderrun(EventTime eventTime, int i, long j, long j2);
+
+    void onBandwidthEstimate(EventTime eventTime, int i, long j, long j2);
+
+    void onDecoderDisabled(EventTime eventTime, int i, DecoderCounters decoderCounters);
+
+    void onDecoderEnabled(EventTime eventTime, int i, DecoderCounters decoderCounters);
+
+    void onDecoderInitialized(EventTime eventTime, int i, String str, long j);
+
+    void onDecoderInputFormatChanged(EventTime eventTime, int i, Format format);
+
+    void onDownstreamFormatChanged(EventTime eventTime, MediaSourceEventListener.MediaLoadData mediaLoadData);
+
+    void onDrmKeysLoaded(EventTime eventTime);
+
+    void onDrmKeysRemoved(EventTime eventTime);
+
+    void onDrmKeysRestored(EventTime eventTime);
+
+    void onDrmSessionManagerError(EventTime eventTime, Exception exc);
+
+    void onDroppedVideoFrames(EventTime eventTime, int i, long j);
+
+    void onLoadCanceled(EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData);
+
+    void onLoadCompleted(EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData);
+
+    void onLoadError(EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData, IOException iOException, boolean z);
+
+    void onLoadStarted(EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData);
+
+    void onLoadingChanged(EventTime eventTime, boolean z);
+
+    void onMediaPeriodCreated(EventTime eventTime);
+
+    void onMediaPeriodReleased(EventTime eventTime);
+
+    void onMetadata(EventTime eventTime, Metadata metadata);
+
+    void onNetworkTypeChanged(EventTime eventTime, @Nullable NetworkInfo networkInfo);
+
+    void onPlaybackParametersChanged(EventTime eventTime, PlaybackParameters playbackParameters);
+
+    void onPlayerError(EventTime eventTime, ExoPlaybackException exoPlaybackException);
+
+    void onPlayerStateChanged(EventTime eventTime, boolean z, int i);
+
+    void onPositionDiscontinuity(EventTime eventTime, int i);
+
+    void onReadingStarted(EventTime eventTime);
+
+    void onRenderedFirstFrame(EventTime eventTime, Surface surface);
+
+    void onRepeatModeChanged(EventTime eventTime, int i);
+
+    void onSeekProcessed(EventTime eventTime);
+
+    void onSeekStarted(EventTime eventTime);
+
+    void onShuffleModeChanged(EventTime eventTime, boolean z);
+
+    void onTimelineChanged(EventTime eventTime, int i);
+
+    void onTracksChanged(EventTime eventTime, TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray);
+
+    void onUpstreamDiscarded(EventTime eventTime, MediaSourceEventListener.MediaLoadData mediaLoadData);
+
+    void onVideoSizeChanged(EventTime eventTime, int i, int i2, int i3, float f);
+
+    void onViewportSizeChange(EventTime eventTime, int i, int i2);
+
+    public static final class EventTime {
+        public final long currentPlaybackPositionMs;
+        public final long eventPlaybackPositionMs;
+
+        @Nullable
+        public final MediaSource.MediaPeriodId mediaPeriodId;
+        public final long realtimeMs;
+        public final Timeline timeline;
+        public final long totalBufferedDurationMs;
+        public final int windowIndex;
+
+        public EventTime(long j, Timeline timeline, int i, @Nullable MediaSource.MediaPeriodId mediaPeriodId, long j2, long j3, long j4) {
+            this.realtimeMs = j;
+            this.timeline = timeline;
+            this.windowIndex = i;
+            this.mediaPeriodId = mediaPeriodId;
+            this.eventPlaybackPositionMs = j2;
+            this.currentPlaybackPositionMs = j3;
+            this.totalBufferedDurationMs = j4;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/analytics/DefaultAnalyticsListener.java

@@ -0,0 +1,165 @@
+package com.mbridge.msdk.playercommon.exoplayer2.analytics;
+
+import android.net.NetworkInfo;
+import android.view.Surface;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.metadata.Metadata;
+import com.mbridge.msdk.playercommon.exoplayer2.source.MediaSourceEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.source.TrackGroupArray;
+import com.mbridge.msdk.playercommon.exoplayer2.trackselection.TrackSelectionArray;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public abstract class DefaultAnalyticsListener implements AnalyticsListener {
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onAudioSessionId(AnalyticsListener.EventTime eventTime, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onAudioUnderrun(AnalyticsListener.EventTime eventTime, int i, long j, long j2) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onBandwidthEstimate(AnalyticsListener.EventTime eventTime, int i, long j, long j2) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDecoderDisabled(AnalyticsListener.EventTime eventTime, int i, DecoderCounters decoderCounters) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDecoderEnabled(AnalyticsListener.EventTime eventTime, int i, DecoderCounters decoderCounters) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDecoderInitialized(AnalyticsListener.EventTime eventTime, int i, String str, long j) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDecoderInputFormatChanged(AnalyticsListener.EventTime eventTime, int i, Format format) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDownstreamFormatChanged(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDrmKeysLoaded(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDrmKeysRemoved(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDrmKeysRestored(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDrmSessionManagerError(AnalyticsListener.EventTime eventTime, Exception exc) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onDroppedVideoFrames(AnalyticsListener.EventTime eventTime, int i, long j) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onLoadCanceled(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onLoadCompleted(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onLoadError(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData, IOException iOException, boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onLoadStarted(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.LoadEventInfo loadEventInfo, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onLoadingChanged(AnalyticsListener.EventTime eventTime, boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onMediaPeriodCreated(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onMediaPeriodReleased(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onMetadata(AnalyticsListener.EventTime eventTime, Metadata metadata) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onNetworkTypeChanged(AnalyticsListener.EventTime eventTime, NetworkInfo networkInfo) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onPlaybackParametersChanged(AnalyticsListener.EventTime eventTime, PlaybackParameters playbackParameters) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onPlayerError(AnalyticsListener.EventTime eventTime, ExoPlaybackException exoPlaybackException) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onPlayerStateChanged(AnalyticsListener.EventTime eventTime, boolean z, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onPositionDiscontinuity(AnalyticsListener.EventTime eventTime, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onReadingStarted(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onRenderedFirstFrame(AnalyticsListener.EventTime eventTime, Surface surface) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onRepeatModeChanged(AnalyticsListener.EventTime eventTime, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onSeekProcessed(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onSeekStarted(AnalyticsListener.EventTime eventTime) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onShuffleModeChanged(AnalyticsListener.EventTime eventTime, boolean z) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onTimelineChanged(AnalyticsListener.EventTime eventTime, int i) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onTracksChanged(AnalyticsListener.EventTime eventTime, TrackGroupArray trackGroupArray, TrackSelectionArray trackSelectionArray) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onUpstreamDiscarded(AnalyticsListener.EventTime eventTime, MediaSourceEventListener.MediaLoadData mediaLoadData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onVideoSizeChanged(AnalyticsListener.EventTime eventTime, int i, int i2, int i3, float f) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.analytics.AnalyticsListener
+    public void onViewportSizeChange(AnalyticsListener.EventTime eventTime, int i, int i2) {
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/Ac3Util.java

@@ -0,0 +1,341 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import com.vungle.ads.internal.protos.Sdk;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import org.apache.http.HttpStatus;
+
+/* loaded from: classes4.dex */
+public final class Ac3Util {
+    private static final int AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT = 1536;
+    private static final int AUDIO_SAMPLES_PER_AUDIO_BLOCK = 256;
+    public static final int TRUEHD_RECHUNK_SAMPLE_COUNT = 16;
+    public static final int TRUEHD_SYNCFRAME_PREFIX_LENGTH = 10;
+    private static final int[] BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD = {1, 2, 3, 6};
+    private static final int[] SAMPLE_RATE_BY_FSCOD = {48000, 44100, 32000};
+    private static final int[] SAMPLE_RATE_BY_FSCOD2 = {24000, 22050, 16000};
+    private static final int[] CHANNEL_COUNT_BY_ACMOD = {2, 1, 2, 3, 3, 4, 4, 5};
+    private static final int[] BITRATE_BY_HALF_FRMSIZECOD = {32, 40, 48, 56, 64, 80, 96, 112, 128, 160, PsExtractor.AUDIO_STREAM, 224, 256, Sdk.SDKError.Reason.WEBVIEW_ERROR_VALUE, 384, 448, 512, 576, 640};
+    private static final int[] SYNCFRAME_SIZE_WORDS_BY_HALF_FRMSIZECOD_44_1 = {69, 87, 104, 121, 139, 174, 208, 243, 278, 348, HttpStatus.SC_EXPECTATION_FAILED, 487, 557, 696, 835, 975, 1114, 1253, 1393};
+
+    private Ac3Util() {
+    }
+
+    public static int getAc3SyncframeAudioSampleCount() {
+        return AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT;
+    }
+
+    public static final class SyncFrameInfo {
+        public static final int STREAM_TYPE_TYPE0 = 0;
+        public static final int STREAM_TYPE_TYPE1 = 1;
+        public static final int STREAM_TYPE_TYPE2 = 2;
+        public static final int STREAM_TYPE_UNDEFINED = -1;
+        public final int channelCount;
+        public final int frameSize;
+        public final String mimeType;
+        public final int sampleCount;
+        public final int sampleRate;
+        public final int streamType;
+
+        @Retention(RetentionPolicy.SOURCE)
+        public @interface StreamType {
+        }
+
+        private SyncFrameInfo(String str, int i, int i2, int i3, int i4, int i5) {
+            this.mimeType = str;
+            this.streamType = i;
+            this.channelCount = i2;
+            this.sampleRate = i3;
+            this.frameSize = i4;
+            this.sampleCount = i5;
+        }
+    }
+
+    public static Format parseAc3AnnexFFormat(ParsableByteArray parsableByteArray, String str, String str2, DrmInitData drmInitData) {
+        int i = SAMPLE_RATE_BY_FSCOD[(parsableByteArray.readUnsignedByte() & PsExtractor.AUDIO_STREAM) >> 6];
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i2 = CHANNEL_COUNT_BY_ACMOD[(readUnsignedByte & 56) >> 3];
+        if ((readUnsignedByte & 4) != 0) {
+            i2++;
+        }
+        return Format.createAudioSampleFormat(str, MimeTypes.AUDIO_AC3, null, -1, -1, i2, i, null, drmInitData, 0, str2);
+    }
+
+    public static Format parseEAc3AnnexFFormat(ParsableByteArray parsableByteArray, String str, String str2, DrmInitData drmInitData) {
+        parsableByteArray.skipBytes(2);
+        int i = SAMPLE_RATE_BY_FSCOD[(parsableByteArray.readUnsignedByte() & PsExtractor.AUDIO_STREAM) >> 6];
+        int readUnsignedByte = parsableByteArray.readUnsignedByte();
+        int i2 = CHANNEL_COUNT_BY_ACMOD[(readUnsignedByte & 14) >> 1];
+        if ((readUnsignedByte & 1) != 0) {
+            i2++;
+        }
+        if (((parsableByteArray.readUnsignedByte() & 30) >> 1) > 0 && (2 & parsableByteArray.readUnsignedByte()) != 0) {
+            i2 += 2;
+        }
+        return Format.createAudioSampleFormat(str, (parsableByteArray.bytesLeft() <= 0 || (parsableByteArray.readUnsignedByte() & 1) == 0) ? MimeTypes.AUDIO_E_AC3 : MimeTypes.AUDIO_E_AC3_JOC, null, -1, -1, i2, i, null, drmInitData, 0, str2);
+    }
+
+    public static SyncFrameInfo parseAc3SyncframeInfo(ParsableBitArray parsableBitArray) {
+        int ac3SyncframeSize;
+        int i;
+        int i2;
+        String str;
+        int i3;
+        int readBits;
+        int i4;
+        int i5;
+        int position = parsableBitArray.getPosition();
+        parsableBitArray.skipBits(40);
+        boolean z = parsableBitArray.readBits(5) == 16;
+        parsableBitArray.setPosition(position);
+        int i6 = -1;
+        if (z) {
+            parsableBitArray.skipBits(16);
+            int readBits2 = parsableBitArray.readBits(2);
+            if (readBits2 == 0) {
+                i6 = 0;
+            } else if (readBits2 == 1) {
+                i6 = 1;
+            } else if (readBits2 == 2) {
+                i6 = 2;
+            }
+            parsableBitArray.skipBits(3);
+            ac3SyncframeSize = (parsableBitArray.readBits(11) + 1) * 2;
+            int readBits3 = parsableBitArray.readBits(2);
+            if (readBits3 == 3) {
+                i4 = 6;
+                i = SAMPLE_RATE_BY_FSCOD2[parsableBitArray.readBits(2)];
+                readBits = 3;
+            } else {
+                readBits = parsableBitArray.readBits(2);
+                i4 = BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD[readBits];
+                i = SAMPLE_RATE_BY_FSCOD[readBits3];
+            }
+            i3 = i4 * 256;
+            int readBits4 = parsableBitArray.readBits(3);
+            boolean readBit = parsableBitArray.readBit();
+            i2 = CHANNEL_COUNT_BY_ACMOD[readBits4] + (readBit ? 1 : 0);
+            parsableBitArray.skipBits(10);
+            if (parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(8);
+            }
+            if (readBits4 == 0) {
+                parsableBitArray.skipBits(5);
+                if (parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+            }
+            if (i6 == 1 && parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(16);
+            }
+            if (parsableBitArray.readBit()) {
+                if (readBits4 > 2) {
+                    parsableBitArray.skipBits(2);
+                }
+                if ((readBits4 & 1) != 0 && readBits4 > 2) {
+                    parsableBitArray.skipBits(6);
+                }
+                if ((readBits4 & 4) != 0) {
+                    parsableBitArray.skipBits(6);
+                }
+                if (readBit && parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(5);
+                }
+                if (i6 == 0) {
+                    if (parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    if (readBits4 == 0 && parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    if (parsableBitArray.readBit()) {
+                        parsableBitArray.skipBits(6);
+                    }
+                    int readBits5 = parsableBitArray.readBits(2);
+                    if (readBits5 == 1) {
+                        parsableBitArray.skipBits(5);
+                    } else if (readBits5 == 2) {
+                        parsableBitArray.skipBits(12);
+                    } else if (readBits5 == 3) {
+                        int readBits6 = parsableBitArray.readBits(5);
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(5);
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(4);
+                            }
+                            if (parsableBitArray.readBit()) {
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(4);
+                                }
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(4);
+                                }
+                            }
+                        }
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(5);
+                            if (parsableBitArray.readBit()) {
+                                parsableBitArray.skipBits(7);
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(8);
+                                }
+                            }
+                        }
+                        parsableBitArray.skipBits((readBits6 + 2) * 8);
+                        parsableBitArray.byteAlign();
+                    }
+                    if (readBits4 < 2) {
+                        if (parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(14);
+                        }
+                        if (readBits4 == 0 && parsableBitArray.readBit()) {
+                            parsableBitArray.skipBits(14);
+                        }
+                    }
+                    if (parsableBitArray.readBit()) {
+                        if (readBits == 0) {
+                            parsableBitArray.skipBits(5);
+                        } else {
+                            for (int i7 = 0; i7 < i4; i7++) {
+                                if (parsableBitArray.readBit()) {
+                                    parsableBitArray.skipBits(5);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (parsableBitArray.readBit()) {
+                parsableBitArray.skipBits(5);
+                if (readBits4 == 2) {
+                    parsableBitArray.skipBits(4);
+                }
+                if (readBits4 >= 6) {
+                    parsableBitArray.skipBits(2);
+                }
+                if (parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+                if (readBits4 == 0 && parsableBitArray.readBit()) {
+                    parsableBitArray.skipBits(8);
+                }
+                i5 = 3;
+                if (readBits3 < 3) {
+                    parsableBitArray.skipBit();
+                }
+            } else {
+                i5 = 3;
+            }
+            if (i6 == 0 && readBits != i5) {
+                parsableBitArray.skipBit();
+            }
+            if (i6 == 2 && (readBits == i5 || parsableBitArray.readBit())) {
+                parsableBitArray.skipBits(6);
+            }
+            str = (parsableBitArray.readBit() && parsableBitArray.readBits(6) == 1 && parsableBitArray.readBits(8) == 1) ? MimeTypes.AUDIO_E_AC3_JOC : MimeTypes.AUDIO_E_AC3;
+        } else {
+            parsableBitArray.skipBits(32);
+            int readBits7 = parsableBitArray.readBits(2);
+            ac3SyncframeSize = getAc3SyncframeSize(readBits7, parsableBitArray.readBits(6));
+            parsableBitArray.skipBits(8);
+            int readBits8 = parsableBitArray.readBits(3);
+            if ((readBits8 & 1) != 0 && readBits8 != 1) {
+                parsableBitArray.skipBits(2);
+            }
+            if ((readBits8 & 4) != 0) {
+                parsableBitArray.skipBits(2);
+            }
+            if (readBits8 == 2) {
+                parsableBitArray.skipBits(2);
+            }
+            i = SAMPLE_RATE_BY_FSCOD[readBits7];
+            i2 = CHANNEL_COUNT_BY_ACMOD[readBits8] + (parsableBitArray.readBit() ? 1 : 0);
+            str = MimeTypes.AUDIO_AC3;
+            i3 = AC3_SYNCFRAME_AUDIO_SAMPLE_COUNT;
+        }
+        return new SyncFrameInfo(str, i6, i2, i, ac3SyncframeSize, i3);
+    }
+
+    public static int parseAc3SyncframeSize(byte[] bArr) {
+        if (bArr.length < 5) {
+            return -1;
+        }
+        byte b = bArr[4];
+        return getAc3SyncframeSize((b & 192) >> 6, b & 63);
+    }
+
+    public static int parseEAc3SyncframeAudioSampleCount(ByteBuffer byteBuffer) {
+        return (((byteBuffer.get(byteBuffer.position() + 4) & 192) >> 6) != 3 ? BLOCKS_PER_SYNCFRAME_BY_NUMBLKSCOD[(byteBuffer.get(byteBuffer.position() + 4) & 48) >> 4] : 6) * 256;
+    }
+
+    public static int findTrueHdSyncframeOffset(ByteBuffer byteBuffer) {
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit() - 10;
+        for (int i = position; i <= limit; i++) {
+            if ((byteBuffer.getInt(i + 4) & (-16777217)) == -1167101192) {
+                return i - position;
+            }
+        }
+        return -1;
+    }
+
+    public static int parseTrueHdSyncframeAudioSampleCount(byte[] bArr) {
+        if (bArr[4] == -8 && bArr[5] == 114 && bArr[6] == 111) {
+            byte b = bArr[7];
+            if ((b & 254) == 186) {
+                return 40 << ((bArr[(b & 255) == 187 ? '\t' : '\b'] >> 4) & 7);
+            }
+        }
+        return 0;
+    }
+
+    public static int parseTrueHdSyncframeAudioSampleCount(ByteBuffer byteBuffer, int i) {
+        return 40 << ((byteBuffer.get((byteBuffer.position() + i) + ((byteBuffer.get((byteBuffer.position() + i) + 7) & 255) == 187 ? 9 : 8)) >> 4) & 7);
+    }
+
+    private static int getAc3SyncframeSize(int i, int i2) {
+        int i3 = i2 / 2;
+        if (i < 0) {
+            return -1;
+        }
+        int[] iArr = SAMPLE_RATE_BY_FSCOD;
+        if (i >= iArr.length || i2 < 0) {
+            return -1;
+        }
+        int[] iArr2 = SYNCFRAME_SIZE_WORDS_BY_HALF_FRMSIZECOD_44_1;
+        if (i3 >= iArr2.length) {
+            return -1;
+        }
+        int i4 = iArr[i];
+        if (i4 == 44100) {
+            return (iArr2[i3] + (i2 % 2)) * 2;
+        }
+        int i5 = BITRATE_BY_HALF_FRMSIZECOD[i3];
+        return i4 == 32000 ? i5 * 6 : i5 * 4;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioAttributes.java

@@ -0,0 +1,69 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.TargetApi;
+import android.media.AudioAttributes;
+import androidx.annotation.Nullable;
+import com.ironsource.mediationsdk.logger.IronSourceError;
+
+/* loaded from: classes4.dex */
+public final class AudioAttributes {
+    public static final AudioAttributes DEFAULT = new Builder().build();
+    private android.media.AudioAttributes audioAttributesV21;
+    public final int contentType;
+    public final int flags;
+    public final int usage;
+
+    public final int hashCode() {
+        return ((((IronSourceError.ERROR_NON_EXISTENT_INSTANCE + this.contentType) * 31) + this.flags) * 31) + this.usage;
+    }
+
+    public static final class Builder {
+        private int contentType = 0;
+        private int flags = 0;
+        private int usage = 1;
+
+        public final Builder setContentType(int i) {
+            this.contentType = i;
+            return this;
+        }
+
+        public final Builder setFlags(int i) {
+            this.flags = i;
+            return this;
+        }
+
+        public final Builder setUsage(int i) {
+            this.usage = i;
+            return this;
+        }
+
+        public final AudioAttributes build() {
+            return new AudioAttributes(this.contentType, this.flags, this.usage);
+        }
+    }
+
+    private AudioAttributes(int i, int i2, int i3) {
+        this.contentType = i;
+        this.flags = i2;
+        this.usage = i3;
+    }
+
+    @TargetApi(21)
+    public final android.media.AudioAttributes getAudioAttributesV21() {
+        if (this.audioAttributesV21 == null) {
+            this.audioAttributesV21 = new AudioAttributes.Builder().setContentType(this.contentType).setFlags(this.flags).setUsage(this.usage).build();
+        }
+        return this.audioAttributesV21;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || AudioAttributes.class != obj.getClass()) {
+            return false;
+        }
+        AudioAttributes audioAttributes = (AudioAttributes) obj;
+        return this.contentType == audioAttributes.contentType && this.flags == audioAttributes.flags && this.usage == audioAttributes.usage;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioCapabilities.java

@@ -0,0 +1,65 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import java.util.Arrays;
+
+@TargetApi(21)
+/* loaded from: classes4.dex */
+public final class AudioCapabilities {
+    public static final AudioCapabilities DEFAULT_AUDIO_CAPABILITIES = new AudioCapabilities(new int[]{2}, 2);
+    private final int maxChannelCount;
+    private final int[] supportedEncodings;
+
+    public final int getMaxChannelCount() {
+        return this.maxChannelCount;
+    }
+
+    public static AudioCapabilities getCapabilities(Context context) {
+        return getCapabilities(context.registerReceiver(null, new IntentFilter("android.media.action.HDMI_AUDIO_PLUG")));
+    }
+
+    @SuppressLint({"InlinedApi"})
+    public static AudioCapabilities getCapabilities(Intent intent) {
+        return (intent == null || intent.getIntExtra("android.media.extra.AUDIO_PLUG_STATE", 0) == 0) ? DEFAULT_AUDIO_CAPABILITIES : new AudioCapabilities(intent.getIntArrayExtra("android.media.extra.ENCODINGS"), intent.getIntExtra("android.media.extra.MAX_CHANNEL_COUNT", 0));
+    }
+
+    public AudioCapabilities(int[] iArr, int i) {
+        if (iArr != null) {
+            int[] copyOf = Arrays.copyOf(iArr, iArr.length);
+            this.supportedEncodings = copyOf;
+            Arrays.sort(copyOf);
+        } else {
+            this.supportedEncodings = new int[0];
+        }
+        this.maxChannelCount = i;
+    }
+
+    public final boolean supportsEncoding(int i) {
+        return Arrays.binarySearch(this.supportedEncodings, i) >= 0;
+    }
+
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (!(obj instanceof AudioCapabilities)) {
+            return false;
+        }
+        AudioCapabilities audioCapabilities = (AudioCapabilities) obj;
+        return Arrays.equals(this.supportedEncodings, audioCapabilities.supportedEncodings) && this.maxChannelCount == audioCapabilities.maxChannelCount;
+    }
+
+    public final int hashCode() {
+        return this.maxChannelCount + (Arrays.hashCode(this.supportedEncodings) * 31);
+    }
+
+    public final String toString() {
+        return "AudioCapabilities[maxChannelCount=" + this.maxChannelCount + ", supportedEncodings=" + Arrays.toString(this.supportedEncodings) + v8.i.e;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioCapabilitiesReceiver.java

@@ -0,0 +1,60 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class AudioCapabilitiesReceiver {
+    AudioCapabilities audioCapabilities;
+    private final Context context;
+    private final Listener listener;
+    private final BroadcastReceiver receiver;
+
+    public interface Listener {
+        void onAudioCapabilitiesChanged(AudioCapabilities audioCapabilities);
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public AudioCapabilitiesReceiver(Context context, Listener listener) {
+        this.context = (Context) Assertions.checkNotNull(context);
+        this.listener = (Listener) Assertions.checkNotNull(listener);
+        this.receiver = Util.SDK_INT >= 21 ? new HdmiAudioPlugBroadcastReceiver() : null;
+    }
+
+    public final AudioCapabilities register() {
+        BroadcastReceiver broadcastReceiver = this.receiver;
+        AudioCapabilities capabilities = AudioCapabilities.getCapabilities(broadcastReceiver == null ? null : this.context.registerReceiver(broadcastReceiver, new IntentFilter("android.media.action.HDMI_AUDIO_PLUG")));
+        this.audioCapabilities = capabilities;
+        return capabilities;
+    }
+
+    public final void unregister() {
+        BroadcastReceiver broadcastReceiver = this.receiver;
+        if (broadcastReceiver != null) {
+            this.context.unregisterReceiver(broadcastReceiver);
+        }
+    }
+
+    public final class HdmiAudioPlugBroadcastReceiver extends BroadcastReceiver {
+        private HdmiAudioPlugBroadcastReceiver() {
+        }
+
+        @Override // android.content.BroadcastReceiver
+        public final void onReceive(Context context, Intent intent) {
+            if (isInitialStickyBroadcast()) {
+                return;
+            }
+            AudioCapabilities capabilities = AudioCapabilities.getCapabilities(intent);
+            if (capabilities.equals(AudioCapabilitiesReceiver.this.audioCapabilities)) {
+                return;
+            }
+            AudioCapabilitiesReceiver audioCapabilitiesReceiver = AudioCapabilitiesReceiver.this;
+            audioCapabilitiesReceiver.audioCapabilities = capabilities;
+            audioCapabilitiesReceiver.listener.onAudioCapabilitiesChanged(capabilities);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioDecoderException.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+/* loaded from: classes4.dex */
+public class AudioDecoderException extends Exception {
+    public AudioDecoderException(String str) {
+        super(str);
+    }
+
+    public AudioDecoderException(String str, Throwable th) {
+        super(str, th);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioProcessor.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public interface AudioProcessor {
+    public static final ByteBuffer EMPTY_BUFFER = ByteBuffer.allocateDirect(0).order(ByteOrder.nativeOrder());
+
+    boolean configure(int i, int i2, int i3) throws UnhandledFormatException;
+
+    void flush();
+
+    ByteBuffer getOutput();
+
+    int getOutputChannelCount();
+
+    int getOutputEncoding();
+
+    int getOutputSampleRateHz();
+
+    boolean isActive();
+
+    boolean isEnded();
+
+    void queueEndOfStream();
+
+    void queueInput(ByteBuffer byteBuffer);
+
+    void reset();
+
+    public static final class UnhandledFormatException extends Exception {
+        public UnhandledFormatException(int i, int i2, int i3) {
+            super("Unhandled format: " + i + " Hz, " + i2 + " channels in encoding " + i3);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioRendererEventListener.java

@@ -0,0 +1,103 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.os.Handler;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+/* loaded from: classes4.dex */
+public interface AudioRendererEventListener {
+    void onAudioDecoderInitialized(String str, long j, long j2);
+
+    void onAudioDisabled(DecoderCounters decoderCounters);
+
+    void onAudioEnabled(DecoderCounters decoderCounters);
+
+    void onAudioInputFormatChanged(Format format);
+
+    void onAudioSessionId(int i);
+
+    void onAudioSinkUnderrun(int i, long j, long j2);
+
+    public static final class EventDispatcher {
+
+        @Nullable
+        private final Handler handler;
+
+        @Nullable
+        private final AudioRendererEventListener listener;
+
+        public EventDispatcher(@Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+            this.handler = audioRendererEventListener != null ? (Handler) Assertions.checkNotNull(handler) : null;
+            this.listener = audioRendererEventListener;
+        }
+
+        public final void enabled(final DecoderCounters decoderCounters) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioEnabled(decoderCounters);
+                    }
+                });
+            }
+        }
+
+        public final void decoderInitialized(final String str, final long j, final long j2) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioDecoderInitialized(str, j, j2);
+                    }
+                });
+            }
+        }
+
+        public final void inputFormatChanged(final Format format) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioInputFormatChanged(format);
+                    }
+                });
+            }
+        }
+
+        public final void audioTrackUnderrun(final int i, final long j, final long j2) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.4
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioSinkUnderrun(i, j, j2);
+                    }
+                });
+            }
+        }
+
+        public final void disabled(final DecoderCounters decoderCounters) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.5
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        decoderCounters.ensureUpdated();
+                        EventDispatcher.this.listener.onAudioDisabled(decoderCounters);
+                    }
+                });
+            }
+        }
+
+        public final void audioSessionId(final int i) {
+            if (this.listener != null) {
+                this.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener.EventDispatcher.6
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        EventDispatcher.this.listener.onAudioSessionId(i);
+                    }
+                });
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioSink.java

@@ -0,0 +1,86 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public interface AudioSink {
+    public static final long CURRENT_POSITION_NOT_SET = Long.MIN_VALUE;
+
+    public interface Listener {
+        void onAudioSessionId(int i);
+
+        void onPositionDiscontinuity();
+
+        void onUnderrun(int i, long j, long j2);
+    }
+
+    void configure(int i, int i2, int i3, int i4, @Nullable int[] iArr, int i5, int i6) throws ConfigurationException;
+
+    void disableTunneling();
+
+    void enableTunnelingV21(int i);
+
+    long getCurrentPositionUs(boolean z);
+
+    PlaybackParameters getPlaybackParameters();
+
+    boolean handleBuffer(ByteBuffer byteBuffer, long j) throws InitializationException, WriteException;
+
+    void handleDiscontinuity();
+
+    boolean hasPendingData();
+
+    boolean isEncodingSupported(int i);
+
+    boolean isEnded();
+
+    void pause();
+
+    void play();
+
+    void playToEndOfStream() throws WriteException;
+
+    void release();
+
+    void reset();
+
+    void setAudioAttributes(AudioAttributes audioAttributes);
+
+    void setAudioSessionId(int i);
+
+    void setListener(Listener listener);
+
+    PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters);
+
+    void setVolume(float f);
+
+    public static final class ConfigurationException extends Exception {
+        public ConfigurationException(Throwable th) {
+            super(th);
+        }
+
+        public ConfigurationException(String str) {
+            super(str);
+        }
+    }
+
+    public static final class InitializationException extends Exception {
+        public final int audioTrackState;
+
+        public InitializationException(int i, int i2, int i3, int i4) {
+            super("AudioTrack init failed: " + i + ", Config(" + i2 + ", " + i3 + ", " + i4 + ")");
+            this.audioTrackState = i;
+        }
+    }
+
+    public static final class WriteException extends Exception {
+        public final int errorCode;
+
+        public WriteException(int i) {
+            super("AudioTrack write failed: " + i);
+            this.errorCode = i;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioTimestampPoller.java

@@ -0,0 +1,178 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.TargetApi;
+import android.media.AudioTimestamp;
+import android.media.AudioTrack;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+final class AudioTimestampPoller {
+    private static final int ERROR_POLL_INTERVAL_US = 500000;
+    private static final int FAST_POLL_INTERVAL_US = 5000;
+    private static final int INITIALIZING_DURATION_US = 500000;
+    private static final int SLOW_POLL_INTERVAL_US = 10000000;
+    private static final int STATE_ERROR = 4;
+    private static final int STATE_INITIALIZING = 0;
+    private static final int STATE_NO_TIMESTAMP = 3;
+    private static final int STATE_TIMESTAMP = 1;
+    private static final int STATE_TIMESTAMP_ADVANCING = 2;
+
+    @Nullable
+    private final AudioTimestampV19 audioTimestamp;
+    private long initialTimestampPositionFrames;
+    private long initializeSystemTimeUs;
+    private long lastTimestampSampleTimeUs;
+    private long sampleIntervalUs;
+    private int state;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    public final boolean hasTimestamp() {
+        int i = this.state;
+        return i == 1 || i == 2;
+    }
+
+    public final boolean isTimestampAdvancing() {
+        return this.state == 2;
+    }
+
+    public AudioTimestampPoller(AudioTrack audioTrack) {
+        if (Util.SDK_INT >= 19) {
+            this.audioTimestamp = new AudioTimestampV19(audioTrack);
+            reset();
+        } else {
+            this.audioTimestamp = null;
+            updateState(3);
+        }
+    }
+
+    public final boolean maybePollTimestamp(long j) {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        if (audioTimestampV19 == null || j - this.lastTimestampSampleTimeUs < this.sampleIntervalUs) {
+            return false;
+        }
+        this.lastTimestampSampleTimeUs = j;
+        boolean maybeUpdateTimestamp = audioTimestampV19.maybeUpdateTimestamp();
+        int i = this.state;
+        if (i != 0) {
+            if (i != 1) {
+                if (i != 2) {
+                    if (i != 3) {
+                        if (i != 4) {
+                            throw new IllegalStateException();
+                        }
+                    } else if (maybeUpdateTimestamp) {
+                        reset();
+                    }
+                } else if (!maybeUpdateTimestamp) {
+                    reset();
+                }
+            } else if (!maybeUpdateTimestamp) {
+                reset();
+            } else if (this.audioTimestamp.getTimestampPositionFrames() > this.initialTimestampPositionFrames) {
+                updateState(2);
+            }
+        } else if (maybeUpdateTimestamp) {
+            if (this.audioTimestamp.getTimestampSystemTimeUs() < this.initializeSystemTimeUs) {
+                return false;
+            }
+            this.initialTimestampPositionFrames = this.audioTimestamp.getTimestampPositionFrames();
+            updateState(1);
+        } else if (j - this.initializeSystemTimeUs > 500000) {
+            updateState(3);
+        }
+        return maybeUpdateTimestamp;
+    }
+
+    public final void rejectTimestamp() {
+        updateState(4);
+    }
+
+    public final void acceptTimestamp() {
+        if (this.state == 4) {
+            reset();
+        }
+    }
+
+    public final void reset() {
+        if (this.audioTimestamp != null) {
+            updateState(0);
+        }
+    }
+
+    public final long getTimestampSystemTimeUs() {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        return audioTimestampV19 != null ? audioTimestampV19.getTimestampSystemTimeUs() : C.TIME_UNSET;
+    }
+
+    public final long getTimestampPositionFrames() {
+        AudioTimestampV19 audioTimestampV19 = this.audioTimestamp;
+        if (audioTimestampV19 != null) {
+            return audioTimestampV19.getTimestampPositionFrames();
+        }
+        return -1L;
+    }
+
+    private void updateState(int i) {
+        this.state = i;
+        if (i == 0) {
+            this.lastTimestampSampleTimeUs = 0L;
+            this.initialTimestampPositionFrames = -1L;
+            this.initializeSystemTimeUs = System.nanoTime() / 1000;
+            this.sampleIntervalUs = 5000L;
+            return;
+        }
+        if (i == 1) {
+            this.sampleIntervalUs = 5000L;
+            return;
+        }
+        if (i == 2 || i == 3) {
+            this.sampleIntervalUs = 10000000L;
+        } else {
+            if (i != 4) {
+                throw new IllegalStateException();
+            }
+            this.sampleIntervalUs = 500000L;
+        }
+    }
+
+    @TargetApi(19)
+    public static final class AudioTimestampV19 {
+        private final AudioTimestamp audioTimestamp = new AudioTimestamp();
+        private final AudioTrack audioTrack;
+        private long lastTimestampPositionFrames;
+        private long lastTimestampRawPositionFrames;
+        private long rawTimestampFramePositionWrapCount;
+
+        public final long getTimestampPositionFrames() {
+            return this.lastTimestampPositionFrames;
+        }
+
+        public AudioTimestampV19(AudioTrack audioTrack) {
+            this.audioTrack = audioTrack;
+        }
+
+        public final boolean maybeUpdateTimestamp() {
+            boolean timestamp = this.audioTrack.getTimestamp(this.audioTimestamp);
+            if (timestamp) {
+                long j = this.audioTimestamp.framePosition;
+                if (this.lastTimestampRawPositionFrames > j) {
+                    this.rawTimestampFramePositionWrapCount++;
+                }
+                this.lastTimestampRawPositionFrames = j;
+                this.lastTimestampPositionFrames = j + (this.rawTimestampFramePositionWrapCount << 32);
+            }
+            return timestamp;
+        }
+
+        public final long getTimestampSystemTimeUs() {
+            return this.audioTimestamp.nanoTime / 1000;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/AudioTrackPositionTracker.java

@@ -0,0 +1,292 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.media.AudioTrack;
+import android.os.SystemClock;
+import androidx.work.WorkRequest;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.reflect.Method;
+
+/* loaded from: classes4.dex */
+final class AudioTrackPositionTracker {
+    private static final long FORCE_RESET_WORKAROUND_TIMEOUT_MS = 200;
+    private static final long MAX_AUDIO_TIMESTAMP_OFFSET_US = 5000000;
+    private static final long MAX_LATENCY_US = 5000000;
+    private static final int MAX_PLAYHEAD_OFFSET_COUNT = 10;
+    private static final int MIN_LATENCY_SAMPLE_INTERVAL_US = 500000;
+    private static final int MIN_PLAYHEAD_OFFSET_SAMPLE_INTERVAL_US = 30000;
+    private static final int PLAYSTATE_PAUSED = 2;
+    private static final int PLAYSTATE_PLAYING = 3;
+    private static final int PLAYSTATE_STOPPED = 1;
+    private AudioTimestampPoller audioTimestampPoller;
+    private AudioTrack audioTrack;
+    private int bufferSize;
+    private long bufferSizeUs;
+    private long endPlaybackHeadPosition;
+    private long forceResetWorkaroundTimeMs;
+    private Method getLatencyMethod;
+    private boolean hasData;
+    private boolean isOutputPcm;
+    private long lastLatencySampleTimeUs;
+    private long lastPlayheadSampleTimeUs;
+    private long lastRawPlaybackHeadPosition;
+    private long latencyUs;
+    private final Listener listener;
+    private boolean needsPassthroughWorkarounds;
+    private int nextPlayheadOffsetIndex;
+    private int outputPcmFrameSize;
+    private int outputSampleRate;
+    private long passthroughWorkaroundPauseOffset;
+    private int playheadOffsetCount;
+    private final long[] playheadOffsets;
+    private long rawPlaybackHeadWrapCount;
+    private long smoothedPlayheadOffsetUs;
+    private long stopPlaybackHeadPosition;
+    private long stopTimestampUs;
+
+    public interface Listener {
+        void onInvalidLatency(long j);
+
+        void onPositionFramesMismatch(long j, long j2, long j3, long j4);
+
+        void onSystemTimeUsMismatch(long j, long j2, long j3, long j4);
+
+        void onUnderrun(int i, long j);
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface PlayState {
+    }
+
+    private void resetSyncParams() {
+        this.smoothedPlayheadOffsetUs = 0L;
+        this.playheadOffsetCount = 0;
+        this.nextPlayheadOffsetIndex = 0;
+        this.lastPlayheadSampleTimeUs = 0L;
+    }
+
+    public AudioTrackPositionTracker(Listener listener) {
+        this.listener = (Listener) Assertions.checkNotNull(listener);
+        if (Util.SDK_INT >= 18) {
+            try {
+                this.getLatencyMethod = AudioTrack.class.getMethod("getLatency", null);
+            } catch (NoSuchMethodException unused) {
+            }
+        }
+        this.playheadOffsets = new long[10];
+    }
+
+    public final void setAudioTrack(AudioTrack audioTrack, int i, int i2, int i3) {
+        this.audioTrack = audioTrack;
+        this.outputPcmFrameSize = i2;
+        this.bufferSize = i3;
+        this.audioTimestampPoller = new AudioTimestampPoller(audioTrack);
+        this.outputSampleRate = audioTrack.getSampleRate();
+        this.needsPassthroughWorkarounds = needsPassthroughWorkarounds(i);
+        boolean isEncodingPcm = Util.isEncodingPcm(i);
+        this.isOutputPcm = isEncodingPcm;
+        this.bufferSizeUs = isEncodingPcm ? framesToDurationUs(i3 / i2) : -9223372036854775807L;
+        this.lastRawPlaybackHeadPosition = 0L;
+        this.rawPlaybackHeadWrapCount = 0L;
+        this.passthroughWorkaroundPauseOffset = 0L;
+        this.hasData = false;
+        this.stopTimestampUs = C.TIME_UNSET;
+        this.forceResetWorkaroundTimeMs = C.TIME_UNSET;
+        this.latencyUs = 0L;
+    }
+
+    public final long getCurrentPositionUs(boolean z) {
+        if (this.audioTrack.getPlayState() == 3) {
+            maybeSampleSyncParams();
+        }
+        long nanoTime = System.nanoTime() / 1000;
+        if (this.audioTimestampPoller.hasTimestamp()) {
+            long framesToDurationUs = framesToDurationUs(this.audioTimestampPoller.getTimestampPositionFrames());
+            return !this.audioTimestampPoller.isTimestampAdvancing() ? framesToDurationUs : framesToDurationUs + (nanoTime - this.audioTimestampPoller.getTimestampSystemTimeUs());
+        }
+        long playbackHeadPositionUs = this.playheadOffsetCount == 0 ? getPlaybackHeadPositionUs() : nanoTime + this.smoothedPlayheadOffsetUs;
+        return !z ? playbackHeadPositionUs - this.latencyUs : playbackHeadPositionUs;
+    }
+
+    public final void start() {
+        this.audioTimestampPoller.reset();
+    }
+
+    public final boolean isPlaying() {
+        return this.audioTrack.getPlayState() == 3;
+    }
+
+    public final boolean mayHandleBuffer(long j) {
+        Listener listener;
+        int playState = this.audioTrack.getPlayState();
+        if (this.needsPassthroughWorkarounds) {
+            if (playState == 2) {
+                this.hasData = false;
+                return false;
+            }
+            if (playState == 1 && getPlaybackHeadPosition() == 0) {
+                return false;
+            }
+        }
+        boolean z = this.hasData;
+        boolean hasPendingData = hasPendingData(j);
+        this.hasData = hasPendingData;
+        if (z && !hasPendingData && playState != 1 && (listener = this.listener) != null) {
+            listener.onUnderrun(this.bufferSize, C.usToMs(this.bufferSizeUs));
+        }
+        return true;
+    }
+
+    public final int getAvailableBufferSize(long j) {
+        return this.bufferSize - ((int) (j - (getPlaybackHeadPosition() * this.outputPcmFrameSize)));
+    }
+
+    public final boolean isStalled(long j) {
+        return this.forceResetWorkaroundTimeMs != C.TIME_UNSET && j > 0 && SystemClock.elapsedRealtime() - this.forceResetWorkaroundTimeMs >= FORCE_RESET_WORKAROUND_TIMEOUT_MS;
+    }
+
+    public final void handleEndOfStream(long j) {
+        this.stopPlaybackHeadPosition = getPlaybackHeadPosition();
+        this.stopTimestampUs = SystemClock.elapsedRealtime() * 1000;
+        this.endPlaybackHeadPosition = j;
+    }
+
+    public final boolean hasPendingData(long j) {
+        return j > getPlaybackHeadPosition() || forceHasPendingData();
+    }
+
+    public final boolean pause() {
+        resetSyncParams();
+        if (this.stopTimestampUs != C.TIME_UNSET) {
+            return false;
+        }
+        this.audioTimestampPoller.reset();
+        return true;
+    }
+
+    public final void reset() {
+        resetSyncParams();
+        this.audioTrack = null;
+        this.audioTimestampPoller = null;
+    }
+
+    private void maybeSampleSyncParams() {
+        long playbackHeadPositionUs = getPlaybackHeadPositionUs();
+        if (playbackHeadPositionUs == 0) {
+            return;
+        }
+        long nanoTime = System.nanoTime() / 1000;
+        if (nanoTime - this.lastPlayheadSampleTimeUs >= WorkRequest.DEFAULT_BACKOFF_DELAY_MILLIS) {
+            long[] jArr = this.playheadOffsets;
+            int i = this.nextPlayheadOffsetIndex;
+            jArr[i] = playbackHeadPositionUs - nanoTime;
+            this.nextPlayheadOffsetIndex = (i + 1) % 10;
+            int i2 = this.playheadOffsetCount;
+            if (i2 < 10) {
+                this.playheadOffsetCount = i2 + 1;
+            }
+            this.lastPlayheadSampleTimeUs = nanoTime;
+            this.smoothedPlayheadOffsetUs = 0L;
+            int i3 = 0;
+            while (true) {
+                int i4 = this.playheadOffsetCount;
+                if (i3 >= i4) {
+                    break;
+                }
+                this.smoothedPlayheadOffsetUs += this.playheadOffsets[i3] / i4;
+                i3++;
+            }
+        }
+        if (this.needsPassthroughWorkarounds) {
+            return;
+        }
+        maybePollAndCheckTimestamp(nanoTime, playbackHeadPositionUs);
+        maybeUpdateLatency(nanoTime);
+    }
+
+    private void maybePollAndCheckTimestamp(long j, long j2) {
+        if (this.audioTimestampPoller.maybePollTimestamp(j)) {
+            long timestampSystemTimeUs = this.audioTimestampPoller.getTimestampSystemTimeUs();
+            long timestampPositionFrames = this.audioTimestampPoller.getTimestampPositionFrames();
+            if (Math.abs(timestampSystemTimeUs - j) > 5000000) {
+                this.listener.onSystemTimeUsMismatch(timestampPositionFrames, timestampSystemTimeUs, j, j2);
+                this.audioTimestampPoller.rejectTimestamp();
+            } else if (Math.abs(framesToDurationUs(timestampPositionFrames) - j2) > 5000000) {
+                this.listener.onPositionFramesMismatch(timestampPositionFrames, timestampSystemTimeUs, j, j2);
+                this.audioTimestampPoller.rejectTimestamp();
+            } else {
+                this.audioTimestampPoller.acceptTimestamp();
+            }
+        }
+    }
+
+    private void maybeUpdateLatency(long j) {
+        Method method;
+        if (!this.isOutputPcm || (method = this.getLatencyMethod) == null || j - this.lastLatencySampleTimeUs < 500000) {
+            return;
+        }
+        try {
+            long intValue = (((Integer) method.invoke(this.audioTrack, null)).intValue() * 1000) - this.bufferSizeUs;
+            this.latencyUs = intValue;
+            long max = Math.max(intValue, 0L);
+            this.latencyUs = max;
+            if (max > 5000000) {
+                this.listener.onInvalidLatency(max);
+                this.latencyUs = 0L;
+            }
+        } catch (Exception unused) {
+            this.getLatencyMethod = null;
+        }
+        this.lastLatencySampleTimeUs = j;
+    }
+
+    private long framesToDurationUs(long j) {
+        return (j * 1000000) / this.outputSampleRate;
+    }
+
+    private boolean forceHasPendingData() {
+        return this.needsPassthroughWorkarounds && this.audioTrack.getPlayState() == 2 && getPlaybackHeadPosition() == 0;
+    }
+
+    private static boolean needsPassthroughWorkarounds(int i) {
+        return Util.SDK_INT < 23 && (i == 5 || i == 6);
+    }
+
+    private long getPlaybackHeadPositionUs() {
+        return framesToDurationUs(getPlaybackHeadPosition());
+    }
+
+    private long getPlaybackHeadPosition() {
+        if (this.stopTimestampUs != C.TIME_UNSET) {
+            return Math.min(this.endPlaybackHeadPosition, this.stopPlaybackHeadPosition + ((((SystemClock.elapsedRealtime() * 1000) - this.stopTimestampUs) * this.outputSampleRate) / 1000000));
+        }
+        int playState = this.audioTrack.getPlayState();
+        if (playState == 1) {
+            return 0L;
+        }
+        long playbackHeadPosition = this.audioTrack.getPlaybackHeadPosition() & 4294967295L;
+        if (this.needsPassthroughWorkarounds) {
+            if (playState == 2 && playbackHeadPosition == 0) {
+                this.passthroughWorkaroundPauseOffset = this.lastRawPlaybackHeadPosition;
+            }
+            playbackHeadPosition += this.passthroughWorkaroundPauseOffset;
+        }
+        if (Util.SDK_INT <= 28) {
+            if (playbackHeadPosition == 0 && this.lastRawPlaybackHeadPosition > 0 && playState == 3) {
+                if (this.forceResetWorkaroundTimeMs == C.TIME_UNSET) {
+                    this.forceResetWorkaroundTimeMs = SystemClock.elapsedRealtime();
+                }
+                return this.lastRawPlaybackHeadPosition;
+            }
+            this.forceResetWorkaroundTimeMs = C.TIME_UNSET;
+        }
+        if (this.lastRawPlaybackHeadPosition > playbackHeadPosition) {
+            this.rawPlaybackHeadWrapCount++;
+        }
+        this.lastRawPlaybackHeadPosition = playbackHeadPosition;
+        return playbackHeadPosition + (this.rawPlaybackHeadWrapCount << 32);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/ChannelMappingAudioProcessor.java

@@ -0,0 +1,146 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class ChannelMappingAudioProcessor implements AudioProcessor {
+    private boolean active;
+    private ByteBuffer buffer;
+    private int channelCount;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+
+    @Nullable
+    private int[] outputChannels;
+
+    @Nullable
+    private int[] pendingOutputChannels;
+    private int sampleRateHz;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.active;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public final void setChannelMap(@Nullable int[] iArr) {
+        this.pendingOutputChannels = iArr;
+    }
+
+    public ChannelMappingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        boolean z = !Arrays.equals(this.pendingOutputChannels, this.outputChannels);
+        int[] iArr = this.pendingOutputChannels;
+        this.outputChannels = iArr;
+        if (iArr == null) {
+            this.active = false;
+            return z;
+        }
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (!z && this.sampleRateHz == i && this.channelCount == i2) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.active = i2 != iArr.length;
+        int i4 = 0;
+        while (true) {
+            int[] iArr2 = this.outputChannels;
+            if (i4 >= iArr2.length) {
+                return true;
+            }
+            int i5 = iArr2[i4];
+            if (i5 >= i2) {
+                throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+            }
+            this.active = (i5 != i4) | this.active;
+            i4++;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        int[] iArr = this.outputChannels;
+        return iArr == null ? this.channelCount : iArr.length;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        Assertions.checkState(this.outputChannels != null);
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int length = ((limit - position) / (this.channelCount * 2)) * this.outputChannels.length * 2;
+        if (this.buffer.capacity() < length) {
+            this.buffer = ByteBuffer.allocateDirect(length).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        while (position < limit) {
+            for (int i : this.outputChannels) {
+                this.buffer.putShort(byteBuffer.getShort((i * 2) + position));
+            }
+            position += this.channelCount * 2;
+        }
+        byteBuffer.position(limit);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.outputChannels = null;
+        this.pendingOutputChannels = null;
+        this.active = false;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/DefaultAudioSink.java

@@ -0,0 +1,962 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.AudioAttributes;
+import android.media.AudioFormat;
+import android.media.AudioTrack;
+import android.os.ConditionVariable;
+import android.os.SystemClock;
+import android.util.Log;
+import androidx.annotation.Nullable;
+import com.ironsource.v8;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+
+/* loaded from: classes4.dex */
+public final class DefaultAudioSink implements AudioSink {
+    private static final int BUFFER_MULTIPLICATION_FACTOR = 4;
+    private static final int ERROR_BAD_VALUE = -2;
+    private static final long MAX_BUFFER_DURATION_US = 750000;
+    private static final long MIN_BUFFER_DURATION_US = 250000;
+    private static final int MODE_STATIC = 0;
+    private static final int MODE_STREAM = 1;
+    private static final long PASSTHROUGH_BUFFER_DURATION_US = 250000;
+    private static final int START_IN_SYNC = 1;
+    private static final int START_NEED_SYNC = 2;
+    private static final int START_NOT_SET = 0;
+    private static final int STATE_INITIALIZED = 1;
+    private static final String TAG = "AudioTrack";
+
+    @SuppressLint({"InlinedApi"})
+    private static final int WRITE_NON_BLOCKING = 1;
+    public static boolean enablePreV21AudioSessionWorkaround = false;
+    public static boolean failOnSpuriousAudioTimestamp = false;
+    private AudioProcessor[] activeAudioProcessors;
+
+    @Nullable
+    private PlaybackParameters afterDrainPlaybackParameters;
+    private AudioAttributes audioAttributes;
+
+    @Nullable
+    private final AudioCapabilities audioCapabilities;
+    private final AudioProcessorChain audioProcessorChain;
+    private int audioSessionId;
+    private AudioTrack audioTrack;
+    private final AudioTrackPositionTracker audioTrackPositionTracker;
+
+    @Nullable
+    private ByteBuffer avSyncHeader;
+    private int bufferSize;
+    private int bytesUntilNextAvSync;
+    private boolean canApplyPlaybackParameters;
+    private final ChannelMappingAudioProcessor channelMappingAudioProcessor;
+    private int drainingAudioProcessorIndex;
+    private final boolean enableConvertHighResIntPcmToFloat;
+    private int framesPerEncodedSample;
+    private boolean handledEndOfStream;
+
+    @Nullable
+    private ByteBuffer inputBuffer;
+    private int inputSampleRate;
+    private boolean isInputPcm;
+
+    @Nullable
+    private AudioTrack keepSessionIdAudioTrack;
+    private long lastFeedElapsedRealtimeMs;
+
+    @Nullable
+    private AudioSink.Listener listener;
+
+    @Nullable
+    private ByteBuffer outputBuffer;
+    private ByteBuffer[] outputBuffers;
+    private int outputChannelConfig;
+    private int outputEncoding;
+    private int outputPcmFrameSize;
+    private int outputSampleRate;
+    private int pcmFrameSize;
+    private PlaybackParameters playbackParameters;
+    private final ArrayDeque<PlaybackParametersCheckpoint> playbackParametersCheckpoints;
+    private long playbackParametersOffsetUs;
+    private long playbackParametersPositionUs;
+    private boolean playing;
+    private byte[] preV21OutputBuffer;
+    private int preV21OutputBufferOffset;
+    private boolean processingEnabled;
+    private final ConditionVariable releasingConditionVariable;
+    private boolean shouldConvertHighResIntPcmToFloat;
+    private int startMediaTimeState;
+    private long startMediaTimeUs;
+    private long submittedEncodedFrames;
+    private long submittedPcmBytes;
+    private final AudioProcessor[] toFloatPcmAvailableAudioProcessors;
+    private final AudioProcessor[] toIntPcmAvailableAudioProcessors;
+    private final TrimmingAudioProcessor trimmingAudioProcessor;
+    private boolean tunneling;
+    private float volume;
+    private long writtenEncodedFrames;
+    private long writtenPcmBytes;
+
+    public interface AudioProcessorChain {
+        PlaybackParameters applyPlaybackParameters(PlaybackParameters playbackParameters);
+
+        AudioProcessor[] getAudioProcessors();
+
+        long getMediaDuration(long j);
+
+        long getSkippedOutputFrameCount();
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface StartMediaTimeState {
+    }
+
+    private AudioProcessor[] getAvailableAudioProcessors() {
+        return this.shouldConvertHighResIntPcmToFloat ? this.toFloatPcmAvailableAudioProcessors : this.toIntPcmAvailableAudioProcessors;
+    }
+
+    private boolean isInitialized() {
+        return this.audioTrack != null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final PlaybackParameters getPlaybackParameters() {
+        return this.playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void handleDiscontinuity() {
+        if (this.startMediaTimeState == 1) {
+            this.startMediaTimeState = 2;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setListener(AudioSink.Listener listener) {
+        this.listener = listener;
+    }
+
+    public static final class InvalidAudioTrackTimestampException extends RuntimeException {
+        private InvalidAudioTrackTimestampException(String str) {
+            super(str);
+        }
+    }
+
+    public static class DefaultAudioProcessorChain implements AudioProcessorChain {
+        private final AudioProcessor[] audioProcessors;
+        private final SilenceSkippingAudioProcessor silenceSkippingAudioProcessor;
+        private final SonicAudioProcessor sonicAudioProcessor;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public AudioProcessor[] getAudioProcessors() {
+            return this.audioProcessors;
+        }
+
+        public DefaultAudioProcessorChain(AudioProcessor... audioProcessorArr) {
+            AudioProcessor[] audioProcessorArr2 = (AudioProcessor[]) Arrays.copyOf(audioProcessorArr, audioProcessorArr.length + 2);
+            this.audioProcessors = audioProcessorArr2;
+            SilenceSkippingAudioProcessor silenceSkippingAudioProcessor = new SilenceSkippingAudioProcessor();
+            this.silenceSkippingAudioProcessor = silenceSkippingAudioProcessor;
+            SonicAudioProcessor sonicAudioProcessor = new SonicAudioProcessor();
+            this.sonicAudioProcessor = sonicAudioProcessor;
+            audioProcessorArr2[audioProcessorArr.length] = silenceSkippingAudioProcessor;
+            audioProcessorArr2[audioProcessorArr.length + 1] = sonicAudioProcessor;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public PlaybackParameters applyPlaybackParameters(PlaybackParameters playbackParameters) {
+            this.silenceSkippingAudioProcessor.setEnabled(playbackParameters.skipSilence);
+            return new PlaybackParameters(this.sonicAudioProcessor.setSpeed(playbackParameters.speed), this.sonicAudioProcessor.setPitch(playbackParameters.pitch), playbackParameters.skipSilence);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public long getMediaDuration(long j) {
+            return this.sonicAudioProcessor.scaleDurationForSpeedup(j);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.AudioProcessorChain
+        public long getSkippedOutputFrameCount() {
+            return this.silenceSkippingAudioProcessor.getSkippedFrames();
+        }
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessor[] audioProcessorArr) {
+        this(audioCapabilities, audioProcessorArr, false);
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessor[] audioProcessorArr, boolean z) {
+        this(audioCapabilities, new DefaultAudioProcessorChain(audioProcessorArr), z);
+    }
+
+    public DefaultAudioSink(@Nullable AudioCapabilities audioCapabilities, AudioProcessorChain audioProcessorChain, boolean z) {
+        this.audioCapabilities = audioCapabilities;
+        this.audioProcessorChain = (AudioProcessorChain) Assertions.checkNotNull(audioProcessorChain);
+        this.enableConvertHighResIntPcmToFloat = z;
+        this.releasingConditionVariable = new ConditionVariable(true);
+        this.audioTrackPositionTracker = new AudioTrackPositionTracker(new PositionTrackerListener());
+        ChannelMappingAudioProcessor channelMappingAudioProcessor = new ChannelMappingAudioProcessor();
+        this.channelMappingAudioProcessor = channelMappingAudioProcessor;
+        TrimmingAudioProcessor trimmingAudioProcessor = new TrimmingAudioProcessor();
+        this.trimmingAudioProcessor = trimmingAudioProcessor;
+        ArrayList arrayList = new ArrayList();
+        Collections.addAll(arrayList, new ResamplingAudioProcessor(), channelMappingAudioProcessor, trimmingAudioProcessor);
+        Collections.addAll(arrayList, audioProcessorChain.getAudioProcessors());
+        this.toIntPcmAvailableAudioProcessors = (AudioProcessor[]) arrayList.toArray(new AudioProcessor[arrayList.size()]);
+        this.toFloatPcmAvailableAudioProcessors = new AudioProcessor[]{new FloatResamplingAudioProcessor()};
+        this.volume = 1.0f;
+        this.startMediaTimeState = 0;
+        this.audioAttributes = AudioAttributes.DEFAULT;
+        this.audioSessionId = 0;
+        this.playbackParameters = PlaybackParameters.DEFAULT;
+        this.drainingAudioProcessorIndex = -1;
+        this.activeAudioProcessors = new AudioProcessor[0];
+        this.outputBuffers = new ByteBuffer[0];
+        this.playbackParametersCheckpoints = new ArrayDeque<>();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean isEncodingSupported(int i) {
+        if (Util.isEncodingPcm(i)) {
+            return i != 4 || Util.SDK_INT >= 21;
+        }
+        AudioCapabilities audioCapabilities = this.audioCapabilities;
+        return audioCapabilities != null && audioCapabilities.supportsEncoding(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final long getCurrentPositionUs(boolean z) {
+        if (!isInitialized() || this.startMediaTimeState == 0) {
+            return Long.MIN_VALUE;
+        }
+        return this.startMediaTimeUs + applySkipping(applySpeedup(Math.min(this.audioTrackPositionTracker.getCurrentPositionUs(z), framesToDurationUs(getWrittenFrames()))));
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:103:0x012b  */
+    /* JADX WARN: Removed duplicated region for block: B:106:0x0090  */
+    /* JADX WARN: Removed duplicated region for block: B:22:0x004b  */
+    /* JADX WARN: Removed duplicated region for block: B:41:0x009b  */
+    /* JADX WARN: Removed duplicated region for block: B:43:0x00b2  */
+    /* JADX WARN: Removed duplicated region for block: B:44:0x00b5  */
+    /* JADX WARN: Removed duplicated region for block: B:45:0x00b8  */
+    /* JADX WARN: Removed duplicated region for block: B:46:0x00ba  */
+    /* JADX WARN: Removed duplicated region for block: B:47:0x00bd  */
+    /* JADX WARN: Removed duplicated region for block: B:48:0x00c0  */
+    /* JADX WARN: Removed duplicated region for block: B:49:0x00c3  */
+    /* JADX WARN: Removed duplicated region for block: B:60:0x00e8  */
+    /* JADX WARN: Removed duplicated region for block: B:63:0x00f0  */
+    /* JADX WARN: Removed duplicated region for block: B:69:0x0104  */
+    /* JADX WARN: Removed duplicated region for block: B:80:0x0126  */
+    /* JADX WARN: Removed duplicated region for block: B:83:0x0130  */
+    /* JADX WARN: Removed duplicated region for block: B:85:0x0133  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void configure(int r18, int r19, int r20, int r21, @androidx.annotation.Nullable int[] r22, int r23, int r24) throws com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.ConfigurationException {
+        /*
+            Method dump skipped, instructions count: 410
+            To view this dump add '--comments-level debug' option
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.configure(int, int, int, int, int[], int, int):void");
+    }
+
+    private void setupAudioProcessors() {
+        ArrayList arrayList = new ArrayList();
+        for (AudioProcessor audioProcessor : getAvailableAudioProcessors()) {
+            if (audioProcessor.isActive()) {
+                arrayList.add(audioProcessor);
+            } else {
+                audioProcessor.flush();
+            }
+        }
+        int size = arrayList.size();
+        this.activeAudioProcessors = (AudioProcessor[]) arrayList.toArray(new AudioProcessor[size]);
+        this.outputBuffers = new ByteBuffer[size];
+        flushAudioProcessors();
+    }
+
+    private void flushAudioProcessors() {
+        int i = 0;
+        while (true) {
+            AudioProcessor[] audioProcessorArr = this.activeAudioProcessors;
+            if (i >= audioProcessorArr.length) {
+                return;
+            }
+            AudioProcessor audioProcessor = audioProcessorArr[i];
+            audioProcessor.flush();
+            this.outputBuffers[i] = audioProcessor.getOutput();
+            i++;
+        }
+    }
+
+    private void initialize() throws AudioSink.InitializationException {
+        PlaybackParameters playbackParameters;
+        this.releasingConditionVariable.block();
+        AudioTrack initializeAudioTrack = initializeAudioTrack();
+        this.audioTrack = initializeAudioTrack;
+        int audioSessionId = initializeAudioTrack.getAudioSessionId();
+        if (enablePreV21AudioSessionWorkaround && Util.SDK_INT < 21) {
+            AudioTrack audioTrack = this.keepSessionIdAudioTrack;
+            if (audioTrack != null && audioSessionId != audioTrack.getAudioSessionId()) {
+                releaseKeepSessionIdAudioTrack();
+            }
+            if (this.keepSessionIdAudioTrack == null) {
+                this.keepSessionIdAudioTrack = initializeKeepSessionIdAudioTrack(audioSessionId);
+            }
+        }
+        if (this.audioSessionId != audioSessionId) {
+            this.audioSessionId = audioSessionId;
+            AudioSink.Listener listener = this.listener;
+            if (listener != null) {
+                listener.onAudioSessionId(audioSessionId);
+            }
+        }
+        if (this.canApplyPlaybackParameters) {
+            playbackParameters = this.audioProcessorChain.applyPlaybackParameters(this.playbackParameters);
+        } else {
+            playbackParameters = PlaybackParameters.DEFAULT;
+        }
+        this.playbackParameters = playbackParameters;
+        setupAudioProcessors();
+        this.audioTrackPositionTracker.setAudioTrack(this.audioTrack, this.outputEncoding, this.outputPcmFrameSize, this.bufferSize);
+        setVolumeInternal();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void play() {
+        this.playing = true;
+        if (isInitialized()) {
+            this.audioTrackPositionTracker.start();
+            this.audioTrack.play();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean handleBuffer(ByteBuffer byteBuffer, long j) throws AudioSink.InitializationException, AudioSink.WriteException {
+        ByteBuffer byteBuffer2 = this.inputBuffer;
+        Assertions.checkArgument(byteBuffer2 == null || byteBuffer == byteBuffer2);
+        if (!isInitialized()) {
+            initialize();
+            if (this.playing) {
+                play();
+            }
+        }
+        if (!this.audioTrackPositionTracker.mayHandleBuffer(getWrittenFrames())) {
+            return false;
+        }
+        if (this.inputBuffer == null) {
+            if (!byteBuffer.hasRemaining()) {
+                return true;
+            }
+            if (!this.isInputPcm && this.framesPerEncodedSample == 0) {
+                int framesPerEncodedSample = getFramesPerEncodedSample(this.outputEncoding, byteBuffer);
+                this.framesPerEncodedSample = framesPerEncodedSample;
+                if (framesPerEncodedSample == 0) {
+                    return true;
+                }
+            }
+            if (this.afterDrainPlaybackParameters != null) {
+                if (!drainAudioProcessorsToEndOfStream()) {
+                    return false;
+                }
+                PlaybackParameters playbackParameters = this.afterDrainPlaybackParameters;
+                this.afterDrainPlaybackParameters = null;
+                this.playbackParametersCheckpoints.add(new PlaybackParametersCheckpoint(this.audioProcessorChain.applyPlaybackParameters(playbackParameters), Math.max(0L, j), framesToDurationUs(getWrittenFrames())));
+                setupAudioProcessors();
+            }
+            if (this.startMediaTimeState == 0) {
+                this.startMediaTimeUs = Math.max(0L, j);
+                this.startMediaTimeState = 1;
+            } else {
+                long inputFramesToDurationUs = this.startMediaTimeUs + inputFramesToDurationUs(getSubmittedFrames());
+                if (this.startMediaTimeState == 1 && Math.abs(inputFramesToDurationUs - j) > 200000) {
+                    Log.e(TAG, "Discontinuity detected [expected " + inputFramesToDurationUs + ", got " + j + v8.i.e);
+                    this.startMediaTimeState = 2;
+                }
+                if (this.startMediaTimeState == 2) {
+                    this.startMediaTimeUs += j - inputFramesToDurationUs;
+                    this.startMediaTimeState = 1;
+                    AudioSink.Listener listener = this.listener;
+                    if (listener != null) {
+                        listener.onPositionDiscontinuity();
+                    }
+                }
+            }
+            if (this.isInputPcm) {
+                this.submittedPcmBytes += byteBuffer.remaining();
+            } else {
+                this.submittedEncodedFrames += this.framesPerEncodedSample;
+            }
+            this.inputBuffer = byteBuffer;
+        }
+        if (this.processingEnabled) {
+            processBuffers(j);
+        } else {
+            writeBuffer(this.inputBuffer, j);
+        }
+        if (!this.inputBuffer.hasRemaining()) {
+            this.inputBuffer = null;
+            return true;
+        }
+        if (!this.audioTrackPositionTracker.isStalled(getWrittenFrames())) {
+            return false;
+        }
+        Log.w(TAG, "Resetting stalled audio track");
+        reset();
+        return true;
+    }
+
+    private void processBuffers(long j) throws AudioSink.WriteException {
+        ByteBuffer byteBuffer;
+        int length = this.activeAudioProcessors.length;
+        int i = length;
+        while (i >= 0) {
+            if (i > 0) {
+                byteBuffer = this.outputBuffers[i - 1];
+            } else {
+                byteBuffer = this.inputBuffer;
+                if (byteBuffer == null) {
+                    byteBuffer = AudioProcessor.EMPTY_BUFFER;
+                }
+            }
+            if (i == length) {
+                writeBuffer(byteBuffer, j);
+            } else {
+                AudioProcessor audioProcessor = this.activeAudioProcessors[i];
+                audioProcessor.queueInput(byteBuffer);
+                ByteBuffer output = audioProcessor.getOutput();
+                this.outputBuffers[i] = output;
+                if (output.hasRemaining()) {
+                    i++;
+                }
+            }
+            if (byteBuffer.hasRemaining()) {
+                return;
+            } else {
+                i--;
+            }
+        }
+    }
+
+    private void writeBuffer(ByteBuffer byteBuffer, long j) throws AudioSink.WriteException {
+        if (byteBuffer.hasRemaining()) {
+            ByteBuffer byteBuffer2 = this.outputBuffer;
+            int i = 0;
+            if (byteBuffer2 != null) {
+                Assertions.checkArgument(byteBuffer2 == byteBuffer);
+            } else {
+                this.outputBuffer = byteBuffer;
+                if (Util.SDK_INT < 21) {
+                    int remaining = byteBuffer.remaining();
+                    byte[] bArr = this.preV21OutputBuffer;
+                    if (bArr == null || bArr.length < remaining) {
+                        this.preV21OutputBuffer = new byte[remaining];
+                    }
+                    int position = byteBuffer.position();
+                    byteBuffer.get(this.preV21OutputBuffer, 0, remaining);
+                    byteBuffer.position(position);
+                    this.preV21OutputBufferOffset = 0;
+                }
+            }
+            int remaining2 = byteBuffer.remaining();
+            if (Util.SDK_INT < 21) {
+                int availableBufferSize = this.audioTrackPositionTracker.getAvailableBufferSize(this.writtenPcmBytes);
+                if (availableBufferSize > 0) {
+                    i = this.audioTrack.write(this.preV21OutputBuffer, this.preV21OutputBufferOffset, Math.min(remaining2, availableBufferSize));
+                    if (i > 0) {
+                        this.preV21OutputBufferOffset += i;
+                        byteBuffer.position(byteBuffer.position() + i);
+                    }
+                }
+            } else if (this.tunneling) {
+                Assertions.checkState(j != C.TIME_UNSET);
+                i = writeNonBlockingWithAvSyncV21(this.audioTrack, byteBuffer, remaining2, j);
+            } else {
+                i = writeNonBlockingV21(this.audioTrack, byteBuffer, remaining2);
+            }
+            this.lastFeedElapsedRealtimeMs = SystemClock.elapsedRealtime();
+            if (i < 0) {
+                throw new AudioSink.WriteException(i);
+            }
+            boolean z = this.isInputPcm;
+            if (z) {
+                this.writtenPcmBytes += i;
+            }
+            if (i == remaining2) {
+                if (!z) {
+                    this.writtenEncodedFrames += this.framesPerEncodedSample;
+                }
+                this.outputBuffer = null;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void playToEndOfStream() throws AudioSink.WriteException {
+        if (!this.handledEndOfStream && isInitialized() && drainAudioProcessorsToEndOfStream()) {
+            this.audioTrackPositionTracker.handleEndOfStream(getWrittenFrames());
+            this.audioTrack.stop();
+            this.bytesUntilNextAvSync = 0;
+            this.handledEndOfStream = true;
+        }
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0021  */
+    /* JADX WARN: Removed duplicated region for block: B:18:0x0038  */
+    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:17:0x0032 -> B:7:0x0012). Please report as a decompilation issue!!! */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private boolean drainAudioProcessorsToEndOfStream() throws com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.WriteException {
+        /*
+            r9 = this;
+            int r0 = r9.drainingAudioProcessorIndex
+            r1 = 1
+            r2 = 0
+            r3 = -1
+            if (r0 != r3) goto L14
+            boolean r0 = r9.processingEnabled
+            if (r0 == 0) goto Ld
+            r0 = r2
+            goto L10
+        Ld:
+            com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor[] r0 = r9.activeAudioProcessors
+            int r0 = r0.length
+        L10:
+            r9.drainingAudioProcessorIndex = r0
+        L12:
+            r0 = r1
+            goto L15
+        L14:
+            r0 = r2
+        L15:
+            int r4 = r9.drainingAudioProcessorIndex
+            com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor[] r5 = r9.activeAudioProcessors
+            int r6 = r5.length
+            r7 = -9223372036854775807(0x8000000000000001, double:-4.9E-324)
+            if (r4 >= r6) goto L38
+            r4 = r5[r4]
+            if (r0 == 0) goto L28
+            r4.queueEndOfStream()
+        L28:
+            r9.processBuffers(r7)
+            boolean r0 = r4.isEnded()
+            if (r0 != 0) goto L32
+            return r2
+        L32:
+            int r0 = r9.drainingAudioProcessorIndex
+            int r0 = r0 + r1
+            r9.drainingAudioProcessorIndex = r0
+            goto L12
+        L38:
+            java.nio.ByteBuffer r0 = r9.outputBuffer
+            if (r0 == 0) goto L44
+            r9.writeBuffer(r0, r7)
+            java.nio.ByteBuffer r0 = r9.outputBuffer
+            if (r0 == 0) goto L44
+            return r2
+        L44:
+            r9.drainingAudioProcessorIndex = r3
+            return r1
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.drainAudioProcessorsToEndOfStream():boolean");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean isEnded() {
+        return !isInitialized() || (this.handledEndOfStream && !hasPendingData());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final boolean hasPendingData() {
+        return isInitialized() && this.audioTrackPositionTracker.hasPendingData(getWrittenFrames());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        if (isInitialized() && !this.canApplyPlaybackParameters) {
+            PlaybackParameters playbackParameters2 = PlaybackParameters.DEFAULT;
+            this.playbackParameters = playbackParameters2;
+            return playbackParameters2;
+        }
+        PlaybackParameters playbackParameters3 = this.afterDrainPlaybackParameters;
+        if (playbackParameters3 == null) {
+            playbackParameters3 = !this.playbackParametersCheckpoints.isEmpty() ? this.playbackParametersCheckpoints.getLast().playbackParameters : this.playbackParameters;
+        }
+        if (!playbackParameters.equals(playbackParameters3)) {
+            if (isInitialized()) {
+                this.afterDrainPlaybackParameters = playbackParameters;
+            } else {
+                this.playbackParameters = this.audioProcessorChain.applyPlaybackParameters(playbackParameters);
+            }
+        }
+        return this.playbackParameters;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setAudioAttributes(AudioAttributes audioAttributes) {
+        if (this.audioAttributes.equals(audioAttributes)) {
+            return;
+        }
+        this.audioAttributes = audioAttributes;
+        if (this.tunneling) {
+            return;
+        }
+        reset();
+        this.audioSessionId = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setAudioSessionId(int i) {
+        if (this.audioSessionId != i) {
+            this.audioSessionId = i;
+            reset();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void enableTunnelingV21(int i) {
+        Assertions.checkState(Util.SDK_INT >= 21);
+        if (this.tunneling && this.audioSessionId == i) {
+            return;
+        }
+        this.tunneling = true;
+        this.audioSessionId = i;
+        reset();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void disableTunneling() {
+        if (this.tunneling) {
+            this.tunneling = false;
+            this.audioSessionId = 0;
+            reset();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void setVolume(float f) {
+        if (this.volume != f) {
+            this.volume = f;
+            setVolumeInternal();
+        }
+    }
+
+    private void setVolumeInternal() {
+        if (isInitialized()) {
+            if (Util.SDK_INT >= 21) {
+                setVolumeInternalV21(this.audioTrack, this.volume);
+            } else {
+                setVolumeInternalV3(this.audioTrack, this.volume);
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void pause() {
+        this.playing = false;
+        if (isInitialized() && this.audioTrackPositionTracker.pause()) {
+            this.audioTrack.pause();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void reset() {
+        if (isInitialized()) {
+            this.submittedPcmBytes = 0L;
+            this.submittedEncodedFrames = 0L;
+            this.writtenPcmBytes = 0L;
+            this.writtenEncodedFrames = 0L;
+            this.framesPerEncodedSample = 0;
+            PlaybackParameters playbackParameters = this.afterDrainPlaybackParameters;
+            if (playbackParameters != null) {
+                this.playbackParameters = playbackParameters;
+                this.afterDrainPlaybackParameters = null;
+            } else if (!this.playbackParametersCheckpoints.isEmpty()) {
+                this.playbackParameters = this.playbackParametersCheckpoints.getLast().playbackParameters;
+            }
+            this.playbackParametersCheckpoints.clear();
+            this.playbackParametersOffsetUs = 0L;
+            this.playbackParametersPositionUs = 0L;
+            this.inputBuffer = null;
+            this.outputBuffer = null;
+            flushAudioProcessors();
+            this.handledEndOfStream = false;
+            this.drainingAudioProcessorIndex = -1;
+            this.avSyncHeader = null;
+            this.bytesUntilNextAvSync = 0;
+            this.startMediaTimeState = 0;
+            if (this.audioTrackPositionTracker.isPlaying()) {
+                this.audioTrack.pause();
+            }
+            final AudioTrack audioTrack = this.audioTrack;
+            this.audioTrack = null;
+            this.audioTrackPositionTracker.reset();
+            this.releasingConditionVariable.close();
+            new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.1
+                @Override // java.lang.Thread, java.lang.Runnable
+                public void run() {
+                    try {
+                        audioTrack.flush();
+                        audioTrack.release();
+                    } finally {
+                        DefaultAudioSink.this.releasingConditionVariable.open();
+                    }
+                }
+            }.start();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink
+    public final void release() {
+        reset();
+        releaseKeepSessionIdAudioTrack();
+        for (AudioProcessor audioProcessor : this.toIntPcmAvailableAudioProcessors) {
+            audioProcessor.reset();
+        }
+        for (AudioProcessor audioProcessor2 : this.toFloatPcmAvailableAudioProcessors) {
+            audioProcessor2.reset();
+        }
+        this.audioSessionId = 0;
+        this.playing = false;
+    }
+
+    private void releaseKeepSessionIdAudioTrack() {
+        final AudioTrack audioTrack = this.keepSessionIdAudioTrack;
+        if (audioTrack == null) {
+            return;
+        }
+        this.keepSessionIdAudioTrack = null;
+        new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.audio.DefaultAudioSink.2
+            @Override // java.lang.Thread, java.lang.Runnable
+            public void run() {
+                audioTrack.release();
+            }
+        }.start();
+    }
+
+    private long applySpeedup(long j) {
+        long j2;
+        long mediaDurationForPlayoutDuration;
+        PlaybackParametersCheckpoint playbackParametersCheckpoint = null;
+        while (!this.playbackParametersCheckpoints.isEmpty() && j >= this.playbackParametersCheckpoints.getFirst().positionUs) {
+            playbackParametersCheckpoint = this.playbackParametersCheckpoints.remove();
+        }
+        if (playbackParametersCheckpoint != null) {
+            this.playbackParameters = playbackParametersCheckpoint.playbackParameters;
+            this.playbackParametersPositionUs = playbackParametersCheckpoint.positionUs;
+            this.playbackParametersOffsetUs = playbackParametersCheckpoint.mediaTimeUs - this.startMediaTimeUs;
+        }
+        if (this.playbackParameters.speed == 1.0f) {
+            return (j + this.playbackParametersOffsetUs) - this.playbackParametersPositionUs;
+        }
+        if (this.playbackParametersCheckpoints.isEmpty()) {
+            j2 = this.playbackParametersOffsetUs;
+            mediaDurationForPlayoutDuration = this.audioProcessorChain.getMediaDuration(j - this.playbackParametersPositionUs);
+        } else {
+            j2 = this.playbackParametersOffsetUs;
+            mediaDurationForPlayoutDuration = Util.getMediaDurationForPlayoutDuration(j - this.playbackParametersPositionUs, this.playbackParameters.speed);
+        }
+        return j2 + mediaDurationForPlayoutDuration;
+    }
+
+    private long applySkipping(long j) {
+        return j + framesToDurationUs(this.audioProcessorChain.getSkippedOutputFrameCount());
+    }
+
+    private long inputFramesToDurationUs(long j) {
+        return (j * 1000000) / this.inputSampleRate;
+    }
+
+    private long framesToDurationUs(long j) {
+        return (j * 1000000) / this.outputSampleRate;
+    }
+
+    private long durationUsToFrames(long j) {
+        return (j * this.outputSampleRate) / 1000000;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public long getSubmittedFrames() {
+        return this.isInputPcm ? this.submittedPcmBytes / this.pcmFrameSize : this.submittedEncodedFrames;
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public long getWrittenFrames() {
+        return this.isInputPcm ? this.writtenPcmBytes / this.outputPcmFrameSize : this.writtenEncodedFrames;
+    }
+
+    private AudioTrack initializeAudioTrack() throws AudioSink.InitializationException {
+        AudioTrack audioTrack;
+        if (Util.SDK_INT >= 21) {
+            audioTrack = createAudioTrackV21();
+        } else {
+            int streamTypeForAudioUsage = Util.getStreamTypeForAudioUsage(this.audioAttributes.usage);
+            if (this.audioSessionId == 0) {
+                audioTrack = new AudioTrack(streamTypeForAudioUsage, this.outputSampleRate, this.outputChannelConfig, this.outputEncoding, this.bufferSize, 1);
+            } else {
+                audioTrack = new AudioTrack(streamTypeForAudioUsage, this.outputSampleRate, this.outputChannelConfig, this.outputEncoding, this.bufferSize, 1, this.audioSessionId);
+            }
+        }
+        int state = audioTrack.getState();
+        if (state == 1) {
+            return audioTrack;
+        }
+        try {
+            audioTrack.release();
+        } catch (Exception unused) {
+        }
+        throw new AudioSink.InitializationException(state, this.outputSampleRate, this.outputChannelConfig, this.bufferSize);
+    }
+
+    @TargetApi(21)
+    private AudioTrack createAudioTrackV21() {
+        android.media.AudioAttributes audioAttributesV21;
+        if (this.tunneling) {
+            audioAttributesV21 = new AudioAttributes.Builder().setContentType(3).setFlags(16).setUsage(1).build();
+        } else {
+            audioAttributesV21 = this.audioAttributes.getAudioAttributesV21();
+        }
+        android.media.AudioAttributes audioAttributes = audioAttributesV21;
+        AudioFormat build = new AudioFormat.Builder().setChannelMask(this.outputChannelConfig).setEncoding(this.outputEncoding).setSampleRate(this.outputSampleRate).build();
+        int i = this.audioSessionId;
+        if (i == 0) {
+            i = 0;
+        }
+        return new AudioTrack(audioAttributes, build, this.bufferSize, 1, i);
+    }
+
+    private AudioTrack initializeKeepSessionIdAudioTrack(int i) {
+        return new AudioTrack(3, 4000, 4, 2, 2, 0, i);
+    }
+
+    private static int getFramesPerEncodedSample(int i, ByteBuffer byteBuffer) {
+        if (i == 7 || i == 8) {
+            return DtsUtil.parseDtsAudioSampleCount(byteBuffer);
+        }
+        if (i == 5) {
+            return Ac3Util.getAc3SyncframeAudioSampleCount();
+        }
+        if (i == 6) {
+            return Ac3Util.parseEAc3SyncframeAudioSampleCount(byteBuffer);
+        }
+        if (i == 14) {
+            int findTrueHdSyncframeOffset = Ac3Util.findTrueHdSyncframeOffset(byteBuffer);
+            if (findTrueHdSyncframeOffset == -1) {
+                return 0;
+            }
+            return Ac3Util.parseTrueHdSyncframeAudioSampleCount(byteBuffer, findTrueHdSyncframeOffset) * 16;
+        }
+        throw new IllegalStateException("Unexpected audio encoding: " + i);
+    }
+
+    @TargetApi(21)
+    private static int writeNonBlockingV21(AudioTrack audioTrack, ByteBuffer byteBuffer, int i) {
+        return audioTrack.write(byteBuffer, i, 1);
+    }
+
+    @TargetApi(21)
+    private int writeNonBlockingWithAvSyncV21(AudioTrack audioTrack, ByteBuffer byteBuffer, int i, long j) {
+        if (this.avSyncHeader == null) {
+            ByteBuffer allocate = ByteBuffer.allocate(16);
+            this.avSyncHeader = allocate;
+            allocate.order(ByteOrder.BIG_ENDIAN);
+            this.avSyncHeader.putInt(1431633921);
+        }
+        if (this.bytesUntilNextAvSync == 0) {
+            this.avSyncHeader.putInt(4, i);
+            this.avSyncHeader.putLong(8, j * 1000);
+            this.avSyncHeader.position(0);
+            this.bytesUntilNextAvSync = i;
+        }
+        int remaining = this.avSyncHeader.remaining();
+        if (remaining > 0) {
+            int write = audioTrack.write(this.avSyncHeader, remaining, 1);
+            if (write < 0) {
+                this.bytesUntilNextAvSync = 0;
+                return write;
+            }
+            if (write < remaining) {
+                return 0;
+            }
+        }
+        int writeNonBlockingV21 = writeNonBlockingV21(audioTrack, byteBuffer, i);
+        if (writeNonBlockingV21 < 0) {
+            this.bytesUntilNextAvSync = 0;
+            return writeNonBlockingV21;
+        }
+        this.bytesUntilNextAvSync -= writeNonBlockingV21;
+        return writeNonBlockingV21;
+    }
+
+    @TargetApi(21)
+    private static void setVolumeInternalV21(AudioTrack audioTrack, float f) {
+        audioTrack.setVolume(f);
+    }
+
+    private static void setVolumeInternalV3(AudioTrack audioTrack, float f) {
+        audioTrack.setStereoVolume(f, f);
+    }
+
+    public static final class PlaybackParametersCheckpoint {
+        private final long mediaTimeUs;
+        private final PlaybackParameters playbackParameters;
+        private final long positionUs;
+
+        private PlaybackParametersCheckpoint(PlaybackParameters playbackParameters, long j, long j2) {
+            this.playbackParameters = playbackParameters;
+            this.mediaTimeUs = j;
+            this.positionUs = j2;
+        }
+    }
+
+    public final class PositionTrackerListener implements AudioTrackPositionTracker.Listener {
+        private PositionTrackerListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onPositionFramesMismatch(long j, long j2, long j3, long j4) {
+            String str = "Spurious audio timestamp (frame position mismatch): " + j + ", " + j2 + ", " + j3 + ", " + j4 + ", " + DefaultAudioSink.this.getSubmittedFrames() + ", " + DefaultAudioSink.this.getWrittenFrames();
+            if (DefaultAudioSink.failOnSpuriousAudioTimestamp) {
+                throw new InvalidAudioTrackTimestampException(str);
+            }
+            Log.w(DefaultAudioSink.TAG, str);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onSystemTimeUsMismatch(long j, long j2, long j3, long j4) {
+            String str = "Spurious audio timestamp (system clock mismatch): " + j + ", " + j2 + ", " + j3 + ", " + j4 + ", " + DefaultAudioSink.this.getSubmittedFrames() + ", " + DefaultAudioSink.this.getWrittenFrames();
+            if (DefaultAudioSink.failOnSpuriousAudioTimestamp) {
+                throw new InvalidAudioTrackTimestampException(str);
+            }
+            Log.w(DefaultAudioSink.TAG, str);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onInvalidLatency(long j) {
+            Log.w(DefaultAudioSink.TAG, "Ignoring impossibly large audio latency: " + j);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioTrackPositionTracker.Listener
+        public final void onUnderrun(int i, long j) {
+            if (DefaultAudioSink.this.listener != null) {
+                DefaultAudioSink.this.listener.onUnderrun(i, j, SystemClock.elapsedRealtime() - DefaultAudioSink.this.lastFeedElapsedRealtimeMs);
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/DtsUtil.java

@@ -0,0 +1,211 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.ironsource.mediationsdk.utils.IronSourceConstants;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableBitArray;
+import csdk.gluads.Consts;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class DtsUtil {
+    private static final byte FIRST_BYTE_14B_BE = 31;
+    private static final byte FIRST_BYTE_14B_LE = -1;
+    private static final byte FIRST_BYTE_BE = Byte.MAX_VALUE;
+    private static final byte FIRST_BYTE_LE = -2;
+    private static final int SYNC_VALUE_14B_BE = 536864768;
+    private static final int SYNC_VALUE_14B_LE = -14745368;
+    private static final int SYNC_VALUE_BE = 2147385345;
+    private static final int SYNC_VALUE_LE = -25230976;
+    private static final int[] CHANNELS_BY_AMODE = {1, 2, 2, 2, 2, 3, 3, 4, 4, 5, 6, 6, 6, 7, 8, 8};
+    private static final int[] SAMPLE_RATE_BY_SFREQ = {-1, 8000, 16000, 32000, -1, -1, 11025, 22050, 44100, -1, -1, 12000, 24000, 48000, -1, -1};
+    private static final int[] TWICE_BITRATE_KBPS_BY_RATE = {64, 112, 128, PsExtractor.AUDIO_STREAM, 224, 256, 384, 448, 512, 640, 768, 896, 1024, 1152, 1280, 1536, 1920, 2048, IronSourceConstants.IS_AD_UNIT_CAPPED, 2560, 2688, 2816, 2823, 2944, 3072, 3840, 4096, Consts.GEMS_CUSTOM_DATA_LIMIT, 7680};
+
+    private DtsUtil() {
+    }
+
+    public static boolean isSyncWord(int i) {
+        return i == SYNC_VALUE_BE || i == SYNC_VALUE_LE || i == SYNC_VALUE_14B_BE || i == SYNC_VALUE_14B_LE;
+    }
+
+    public static Format parseDtsFormat(byte[] bArr, String str, String str2, DrmInitData drmInitData) {
+        ParsableBitArray normalizedFrameHeader = getNormalizedFrameHeader(bArr);
+        normalizedFrameHeader.skipBits(60);
+        int i = CHANNELS_BY_AMODE[normalizedFrameHeader.readBits(6)];
+        int i2 = SAMPLE_RATE_BY_SFREQ[normalizedFrameHeader.readBits(4)];
+        int readBits = normalizedFrameHeader.readBits(5);
+        int[] iArr = TWICE_BITRATE_KBPS_BY_RATE;
+        int i3 = readBits >= iArr.length ? -1 : (iArr[readBits] * 1000) / 2;
+        normalizedFrameHeader.skipBits(10);
+        return Format.createAudioSampleFormat(str, MimeTypes.AUDIO_DTS, null, i3, -1, i + (normalizedFrameHeader.readBits(2) > 0 ? 1 : 0), i2, null, drmInitData, 0, str2);
+    }
+
+    public static int parseDtsAudioSampleCount(byte[] bArr) {
+        int i;
+        byte b;
+        int i2;
+        byte b2;
+        byte b3 = bArr[0];
+        if (b3 != -2) {
+            if (b3 == -1) {
+                i = (bArr[4] & 7) << 4;
+                b2 = bArr[7];
+            } else if (b3 == 31) {
+                i = (bArr[5] & 7) << 4;
+                b2 = bArr[6];
+            } else {
+                i = (bArr[4] & 1) << 6;
+                b = bArr[5];
+            }
+            i2 = b2 & 60;
+            return (((i2 >> 2) | i) + 1) * 32;
+        }
+        i = (bArr[5] & 1) << 6;
+        b = bArr[4];
+        i2 = b & 252;
+        return (((i2 >> 2) | i) + 1) * 32;
+    }
+
+    public static int parseDtsAudioSampleCount(ByteBuffer byteBuffer) {
+        int i;
+        byte b;
+        int i2;
+        byte b2;
+        int position = byteBuffer.position();
+        byte b3 = byteBuffer.get(position);
+        if (b3 != -2) {
+            if (b3 == -1) {
+                i = (byteBuffer.get(position + 4) & 7) << 4;
+                b2 = byteBuffer.get(position + 7);
+            } else if (b3 == 31) {
+                i = (byteBuffer.get(position + 5) & 7) << 4;
+                b2 = byteBuffer.get(position + 6);
+            } else {
+                i = (byteBuffer.get(position + 4) & 1) << 6;
+                b = byteBuffer.get(position + 5);
+            }
+            i2 = b2 & 60;
+            return (((i2 >> 2) | i) + 1) * 32;
+        }
+        i = (byteBuffer.get(position + 5) & 1) << 6;
+        b = byteBuffer.get(position + 4);
+        i2 = b & 252;
+        return (((i2 >> 2) | i) + 1) * 32;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:10:0x0060  */
+    /* JADX WARN: Removed duplicated region for block: B:13:? A[RETURN, SYNTHETIC] */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public static int getDtsFrameSize(byte[] r7) {
+        /*
+            r0 = 0
+            r1 = r7[r0]
+            r2 = -2
+            r3 = 7
+            r4 = 6
+            r5 = 1
+            r6 = 4
+            if (r1 == r2) goto L4f
+            r2 = -1
+            if (r1 == r2) goto L3e
+            r2 = 31
+            if (r1 == r2) goto L26
+            r1 = 5
+            r1 = r7[r1]
+            r1 = r1 & 3
+            int r1 = r1 << 12
+            r2 = r7[r4]
+            r2 = r2 & 255(0xff, float:3.57E-43)
+            int r2 = r2 << r6
+            r1 = r1 | r2
+            r7 = r7[r3]
+        L20:
+            r7 = r7 & 240(0xf0, float:3.36E-43)
+            int r7 = r7 >> r6
+            r7 = r7 | r1
+            int r7 = r7 + r5
+            goto L5e
+        L26:
+            r0 = r7[r4]
+            r0 = r0 & 3
+            int r0 = r0 << 12
+            r1 = r7[r3]
+            r1 = r1 & 255(0xff, float:3.57E-43)
+            int r1 = r1 << r6
+            r0 = r0 | r1
+            r1 = 8
+            r7 = r7[r1]
+        L36:
+            r7 = r7 & 60
+            int r7 = r7 >> 2
+            r7 = r7 | r0
+            int r7 = r7 + r5
+            r0 = r5
+            goto L5e
+        L3e:
+            r0 = r7[r3]
+            r0 = r0 & 3
+            int r0 = r0 << 12
+            r1 = r7[r4]
+            r1 = r1 & 255(0xff, float:3.57E-43)
+            int r1 = r1 << r6
+            r0 = r0 | r1
+            r1 = 9
+            r7 = r7[r1]
+            goto L36
+        L4f:
+            r1 = r7[r6]
+            r1 = r1 & 3
+            int r1 = r1 << 12
+            r2 = r7[r3]
+            r2 = r2 & 255(0xff, float:3.57E-43)
+            int r2 = r2 << r6
+            r1 = r1 | r2
+            r7 = r7[r4]
+            goto L20
+        L5e:
+            if (r0 == 0) goto L64
+            int r7 = r7 * 16
+            int r7 = r7 / 14
+        L64:
+            return r7
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.DtsUtil.getDtsFrameSize(byte[]):int");
+    }
+
+    private static ParsableBitArray getNormalizedFrameHeader(byte[] bArr) {
+        if (bArr[0] == Byte.MAX_VALUE) {
+            return new ParsableBitArray(bArr);
+        }
+        byte[] copyOf = Arrays.copyOf(bArr, bArr.length);
+        if (isLittleEndianFrameHeader(copyOf)) {
+            for (int i = 0; i < copyOf.length - 1; i += 2) {
+                byte b = copyOf[i];
+                int i2 = i + 1;
+                copyOf[i] = copyOf[i2];
+                copyOf[i2] = b;
+            }
+        }
+        ParsableBitArray parsableBitArray = new ParsableBitArray(copyOf);
+        if (copyOf[0] == 31) {
+            ParsableBitArray parsableBitArray2 = new ParsableBitArray(copyOf);
+            while (parsableBitArray2.bitsLeft() >= 16) {
+                parsableBitArray2.skipBits(2);
+                parsableBitArray.putInt(parsableBitArray2.readBits(14), 14);
+            }
+        }
+        parsableBitArray.reset(copyOf);
+        return parsableBitArray;
+    }
+
+    private static boolean isLittleEndianFrameHeader(byte[] bArr) {
+        byte b = bArr[0];
+        return b == -2 || b == -1;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/FloatResamplingAudioProcessor.java

@@ -0,0 +1,128 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+final class FloatResamplingAudioProcessor implements AudioProcessor {
+    private static final int FLOAT_NAN_AS_INT = Float.floatToIntBits(Float.NaN);
+    private static final double PCM_32_BIT_INT_TO_PCM_32_BIT_FLOAT_FACTOR = 4.656612875245797E-10d;
+    private ByteBuffer buffer;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private int sampleRateHz = -1;
+    private int channelCount = -1;
+    private int sourceEncoding = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 4;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public FloatResamplingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (!Util.isEncodingHighResolutionIntegerPcm(i3)) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.sourceEncoding == i3) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.sourceEncoding = i3;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return Util.isEncodingHighResolutionIntegerPcm(this.sourceEncoding);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        boolean z = this.sourceEncoding == 1073741824;
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int i = limit - position;
+        if (!z) {
+            i = (i / 3) * 4;
+        }
+        if (this.buffer.capacity() < i) {
+            this.buffer = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        if (z) {
+            while (position < limit) {
+                writePcm32BitFloat((byteBuffer.get(position) & 255) | ((byteBuffer.get(position + 1) & 255) << 8) | ((byteBuffer.get(position + 2) & 255) << 16) | ((byteBuffer.get(position + 3) & 255) << 24), this.buffer);
+                position += 4;
+            }
+        } else {
+            while (position < limit) {
+                writePcm32BitFloat(((byteBuffer.get(position) & 255) << 8) | ((byteBuffer.get(position + 1) & 255) << 16) | ((byteBuffer.get(position + 2) & 255) << 24), this.buffer);
+                position += 3;
+            }
+        }
+        byteBuffer.position(byteBuffer.limit());
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.sampleRateHz = -1;
+        this.channelCount = -1;
+        this.sourceEncoding = 0;
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+    }
+
+    private static void writePcm32BitFloat(int i, ByteBuffer byteBuffer) {
+        int floatToIntBits = Float.floatToIntBits((float) (i * PCM_32_BIT_INT_TO_PCM_32_BIT_FLOAT_FACTOR));
+        if (floatToIntBits == FLOAT_NAN_AS_INT) {
+            floatToIntBits = Float.floatToIntBits(0.0f);
+        }
+        byteBuffer.putInt(floatToIntBits);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/MediaCodecAudioRenderer.java

@@ -0,0 +1,418 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.media.MediaCodec;
+import android.media.MediaCrypto;
+import android.media.MediaFormat;
+import android.os.Handler;
+import android.view.Surface;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecInfo;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecSelector;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaFormatUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import com.unity3d.ads.core.domain.HandleInvocationsFromAdViewer;
+import java.nio.ByteBuffer;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public class MediaCodecAudioRenderer extends MediaCodecRenderer implements MediaClock {
+    private boolean allowFirstBufferPositionDiscontinuity;
+    private boolean allowPositionDiscontinuity;
+    private final AudioSink audioSink;
+    private int channelCount;
+    private int codecMaxInputSize;
+    private boolean codecNeedsDiscardChannelsWorkaround;
+    private final Context context;
+    private long currentPositionUs;
+    private int encoderDelay;
+    private int encoderPadding;
+    private final AudioRendererEventListener.EventDispatcher eventDispatcher;
+    private boolean passthroughEnabled;
+    private MediaFormat passthroughMediaFormat;
+    private int pcmEncoding;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public int canKeepCodec(MediaCodec mediaCodec, MediaCodecInfo mediaCodecInfo, Format format, Format format2) {
+        return 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return this;
+    }
+
+    public void onAudioSessionId(int i) {
+    }
+
+    public void onAudioTrackPositionDiscontinuity() {
+    }
+
+    public void onAudioTrackUnderrun(int i, long j, long j2) {
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector) {
+        this(context, mediaCodecSelector, (DrmSessionManager<FrameworkMediaCrypto>) null, false);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z) {
+        this(context, mediaCodecSelector, drmSessionManager, z, null, null);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+        this(context, mediaCodecSelector, null, false, handler, audioRendererEventListener);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener) {
+        this(context, mediaCodecSelector, drmSessionManager, z, handler, audioRendererEventListener, null, new AudioProcessor[0]);
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener, @Nullable AudioCapabilities audioCapabilities, AudioProcessor... audioProcessorArr) {
+        this(context, mediaCodecSelector, drmSessionManager, z, handler, audioRendererEventListener, new DefaultAudioSink(audioCapabilities, audioProcessorArr));
+    }
+
+    public MediaCodecAudioRenderer(Context context, MediaCodecSelector mediaCodecSelector, @Nullable DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, boolean z, @Nullable Handler handler, @Nullable AudioRendererEventListener audioRendererEventListener, AudioSink audioSink) {
+        super(1, mediaCodecSelector, drmSessionManager, z);
+        this.context = context.getApplicationContext();
+        this.audioSink = audioSink;
+        this.eventDispatcher = new AudioRendererEventListener.EventDispatcher(handler, audioRendererEventListener);
+        audioSink.setListener(new AudioSinkListener());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public int supportsFormat(MediaCodecSelector mediaCodecSelector, DrmSessionManager<FrameworkMediaCrypto> drmSessionManager, Format format) throws MediaCodecUtil.DecoderQueryException {
+        boolean z;
+        int i;
+        int i2;
+        String str = format.sampleMimeType;
+        if (!MimeTypes.isAudio(str)) {
+            return 0;
+        }
+        int i3 = Util.SDK_INT >= 21 ? 32 : 0;
+        boolean supportsFormatDrm = BaseRenderer.supportsFormatDrm(drmSessionManager, format.drmInitData);
+        if (supportsFormatDrm && allowPassthrough(str) && mediaCodecSelector.getPassthroughDecoderInfo() != null) {
+            return i3 | 12;
+        }
+        if ((MimeTypes.AUDIO_RAW.equals(str) && !this.audioSink.isEncodingSupported(format.pcmEncoding)) || !this.audioSink.isEncodingSupported(2)) {
+            return 1;
+        }
+        DrmInitData drmInitData = format.drmInitData;
+        if (drmInitData != null) {
+            z = false;
+            for (int i4 = 0; i4 < drmInitData.schemeDataCount; i4++) {
+                z |= drmInitData.get(i4).requiresSecureDecryption;
+            }
+        } else {
+            z = false;
+        }
+        MediaCodecInfo decoderInfo = mediaCodecSelector.getDecoderInfo(str, z);
+        if (decoderInfo == null) {
+            return (!z || mediaCodecSelector.getDecoderInfo(str, false) == null) ? 1 : 2;
+        }
+        if (supportsFormatDrm) {
+            return ((Util.SDK_INT < 21 || (((i = format.sampleRate) == -1 || decoderInfo.isAudioSampleRateSupportedV21(i)) && ((i2 = format.channelCount) == -1 || decoderInfo.isAudioChannelCountSupportedV21(i2)))) ? 4 : 3) | i3 | 8;
+        }
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public MediaCodecInfo getDecoderInfo(MediaCodecSelector mediaCodecSelector, Format format, boolean z) throws MediaCodecUtil.DecoderQueryException {
+        MediaCodecInfo passthroughDecoderInfo;
+        return (!allowPassthrough(format.sampleMimeType) || (passthroughDecoderInfo = mediaCodecSelector.getPassthroughDecoderInfo()) == null) ? super.getDecoderInfo(mediaCodecSelector, format, z) : passthroughDecoderInfo;
+    }
+
+    public boolean allowPassthrough(String str) {
+        int encoding = MimeTypes.getEncoding(str);
+        return encoding != 0 && this.audioSink.isEncodingSupported(encoding);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void configureCodec(MediaCodecInfo mediaCodecInfo, MediaCodec mediaCodec, Format format, MediaCrypto mediaCrypto) {
+        this.codecMaxInputSize = getCodecMaxInputSize(mediaCodecInfo, format, getStreamFormats());
+        this.codecNeedsDiscardChannelsWorkaround = codecNeedsDiscardChannelsWorkaround(mediaCodecInfo.name);
+        this.passthroughEnabled = mediaCodecInfo.passthrough;
+        String str = mediaCodecInfo.mimeType;
+        if (str == null) {
+            str = MimeTypes.AUDIO_RAW;
+        }
+        MediaFormat mediaFormat = getMediaFormat(format, str, this.codecMaxInputSize);
+        mediaCodec.configure(mediaFormat, (Surface) null, mediaCrypto, 0);
+        if (!this.passthroughEnabled) {
+            this.passthroughMediaFormat = null;
+        } else {
+            this.passthroughMediaFormat = mediaFormat;
+            mediaFormat.setString("mime", format.sampleMimeType);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onCodecInitialized(String str, long j, long j2) {
+        this.eventDispatcher.decoderInitialized(str, j, j2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onInputFormatChanged(Format format) throws ExoPlaybackException {
+        super.onInputFormatChanged(format);
+        this.eventDispatcher.inputFormatChanged(format);
+        this.pcmEncoding = MimeTypes.AUDIO_RAW.equals(format.sampleMimeType) ? format.pcmEncoding : 2;
+        this.channelCount = format.channelCount;
+        this.encoderDelay = format.encoderDelay;
+        this.encoderPadding = format.encoderPadding;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onOutputFormatChanged(MediaCodec mediaCodec, MediaFormat mediaFormat) throws ExoPlaybackException {
+        int i;
+        int[] iArr;
+        int i2;
+        MediaFormat mediaFormat2 = this.passthroughMediaFormat;
+        if (mediaFormat2 != null) {
+            i = MimeTypes.getEncoding(mediaFormat2.getString("mime"));
+            mediaFormat = this.passthroughMediaFormat;
+        } else {
+            i = this.pcmEncoding;
+        }
+        int i3 = i;
+        int integer = mediaFormat.getInteger("channel-count");
+        int integer2 = mediaFormat.getInteger("sample-rate");
+        if (this.codecNeedsDiscardChannelsWorkaround && integer == 6 && (i2 = this.channelCount) < 6) {
+            iArr = new int[i2];
+            for (int i4 = 0; i4 < this.channelCount; i4++) {
+                iArr[i4] = i4;
+            }
+        } else {
+            iArr = null;
+        }
+        try {
+            this.audioSink.configure(i3, integer, integer2, 0, iArr, this.encoderDelay, this.encoderPadding);
+        } catch (AudioSink.ConfigurationException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+        super.onEnabled(z);
+        this.eventDispatcher.enabled(this.decoderCounters);
+        int i = getConfiguration().tunnelingAudioSessionId;
+        if (i != 0) {
+            this.audioSink.enableTunnelingV21(i);
+        } else {
+            this.audioSink.disableTunneling();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+        super.onPositionReset(j, z);
+        this.audioSink.reset();
+        this.currentPositionUs = j;
+        this.allowFirstBufferPositionDiscontinuity = true;
+        this.allowPositionDiscontinuity = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStarted() {
+        super.onStarted();
+        this.audioSink.play();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStopped() {
+        updateCurrentPosition();
+        this.audioSink.pause();
+        super.onStopped();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onDisabled() {
+        try {
+            this.audioSink.release();
+            try {
+                super.onDisabled();
+            } finally {
+            }
+        } catch (Throwable th) {
+            try {
+                super.onDisabled();
+                throw th;
+            } finally {
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isEnded() {
+        return super.isEnded() && this.audioSink.isEnded();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isReady() {
+        return this.audioSink.hasPendingData() || super.isReady();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public long getPositionUs() {
+        if (getState() == 2) {
+            updateCurrentPosition();
+        }
+        return this.currentPositionUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        return this.audioSink.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters getPlaybackParameters() {
+        return this.audioSink.getPlaybackParameters();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void onQueueInputBuffer(DecoderInputBuffer decoderInputBuffer) {
+        if (!this.allowFirstBufferPositionDiscontinuity || decoderInputBuffer.isDecodeOnly()) {
+            return;
+        }
+        if (Math.abs(decoderInputBuffer.timeUs - this.currentPositionUs) > 500000) {
+            this.currentPositionUs = decoderInputBuffer.timeUs;
+        }
+        this.allowFirstBufferPositionDiscontinuity = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public boolean processOutputBuffer(long j, long j2, MediaCodec mediaCodec, ByteBuffer byteBuffer, int i, int i2, long j3, boolean z) throws ExoPlaybackException {
+        if (this.passthroughEnabled && (i2 & 2) != 0) {
+            mediaCodec.releaseOutputBuffer(i, false);
+            return true;
+        }
+        if (z) {
+            mediaCodec.releaseOutputBuffer(i, false);
+            this.decoderCounters.skippedOutputBufferCount++;
+            this.audioSink.handleDiscontinuity();
+            return true;
+        }
+        try {
+            if (!this.audioSink.handleBuffer(byteBuffer, j3)) {
+                return false;
+            }
+            mediaCodec.releaseOutputBuffer(i, false);
+            this.decoderCounters.renderedOutputBufferCount++;
+            return true;
+        } catch (AudioSink.InitializationException | AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.mediacodec.MediaCodecRenderer
+    public void renderToEndOfStream() throws ExoPlaybackException {
+        try {
+            this.audioSink.playToEndOfStream();
+        } catch (AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+        if (i == 2) {
+            this.audioSink.setVolume(((Float) obj).floatValue());
+        } else if (i == 3) {
+            this.audioSink.setAudioAttributes((AudioAttributes) obj);
+        } else {
+            super.handleMessage(i, obj);
+        }
+    }
+
+    public int getCodecMaxInputSize(MediaCodecInfo mediaCodecInfo, Format format, Format[] formatArr) {
+        return getCodecMaxInputSize(mediaCodecInfo, format);
+    }
+
+    private int getCodecMaxInputSize(MediaCodecInfo mediaCodecInfo, Format format) {
+        PackageManager packageManager;
+        int i = Util.SDK_INT;
+        if (i >= 24 || !"OMX.google.raw.decoder".equals(mediaCodecInfo.name) || (i == 23 && (packageManager = this.context.getPackageManager()) != null && packageManager.hasSystemFeature("android.software.leanback"))) {
+            return format.maxInputSize;
+        }
+        return -1;
+    }
+
+    @SuppressLint({"InlinedApi"})
+    public MediaFormat getMediaFormat(Format format, String str, int i) {
+        MediaFormat mediaFormat = new MediaFormat();
+        mediaFormat.setString("mime", str);
+        mediaFormat.setInteger("channel-count", format.channelCount);
+        mediaFormat.setInteger("sample-rate", format.sampleRate);
+        MediaFormatUtil.setCsdBuffers(mediaFormat, format.initializationData);
+        MediaFormatUtil.maybeSetInteger(mediaFormat, "max-input-size", i);
+        if (Util.SDK_INT >= 23) {
+            mediaFormat.setInteger(HandleInvocationsFromAdViewer.KEY_DOWNLOAD_PRIORITY, 0);
+        }
+        return mediaFormat;
+    }
+
+    private void updateCurrentPosition() {
+        long currentPositionUs = this.audioSink.getCurrentPositionUs(isEnded());
+        if (currentPositionUs != Long.MIN_VALUE) {
+            if (!this.allowPositionDiscontinuity) {
+                currentPositionUs = Math.max(this.currentPositionUs, currentPositionUs);
+            }
+            this.currentPositionUs = currentPositionUs;
+            this.allowPositionDiscontinuity = false;
+        }
+    }
+
+    private static boolean areAdaptationCompatible(Format format, Format format2) {
+        return format.sampleMimeType.equals(format2.sampleMimeType) && format.channelCount == format2.channelCount && format.sampleRate == format2.sampleRate && format.encoderDelay == 0 && format.encoderPadding == 0 && format2.encoderDelay == 0 && format2.encoderPadding == 0 && format.initializationDataEquals(format2);
+    }
+
+    private static boolean codecNeedsDiscardChannelsWorkaround(String str) {
+        if (Util.SDK_INT < 24 && "OMX.SEC.aac.dec".equals(str) && "samsung".equals(Util.MANUFACTURER)) {
+            String str2 = Util.DEVICE;
+            if (str2.startsWith("zeroflte") || str2.startsWith("herolte") || str2.startsWith("heroqlte")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public final class AudioSinkListener implements AudioSink.Listener {
+        private AudioSinkListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onAudioSessionId(int i) {
+            MediaCodecAudioRenderer.this.eventDispatcher.audioSessionId(i);
+            MediaCodecAudioRenderer.this.onAudioSessionId(i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onPositionDiscontinuity() {
+            MediaCodecAudioRenderer.this.onAudioTrackPositionDiscontinuity();
+            MediaCodecAudioRenderer.this.allowPositionDiscontinuity = true;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onUnderrun(int i, long j, long j2) {
+            MediaCodecAudioRenderer.this.eventDispatcher.audioTrackUnderrun(i, j, j2);
+            MediaCodecAudioRenderer.this.onAudioTrackUnderrun(i, j, j2);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/ResamplingAudioProcessor.java

@@ -0,0 +1,192 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+final class ResamplingAudioProcessor implements AudioProcessor {
+    private ByteBuffer buffer;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private int sampleRateHz = -1;
+    private int channelCount = -1;
+    private int encoding = 0;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        int i = this.encoding;
+        return (i == 0 || i == 2) ? false : true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public ResamplingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 3 && i3 != 2 && i3 != Integer.MIN_VALUE && i3 != 1073741824) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.encoding == i3) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.encoding = i3;
+        return true;
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:11:0x0045  */
+    /* JADX WARN: Removed duplicated region for block: B:24:0x0083 A[ADDED_TO_REGION, LOOP:2: B:24:0x0083->B:25:0x0085, LOOP_START, PHI: r0
+  0x0083: PHI (r0v1 int) = (r0v0 int), (r0v2 int) binds: [B:10:0x0043, B:25:0x0085] A[DONT_GENERATE, DONT_INLINE]] */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x003c  */
+    /* JADX WARN: Removed duplicated region for block: B:8:0x002d  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final void queueInput(java.nio.ByteBuffer r8) {
+        /*
+            r7 = this;
+            int r0 = r8.position()
+            int r1 = r8.limit()
+            int r2 = r1 - r0
+            int r3 = r7.encoding
+            r4 = 1073741824(0x40000000, float:2.0)
+            r5 = -2147483648(0xffffffff80000000, float:-0.0)
+            r6 = 3
+            if (r3 == r5) goto L23
+            if (r3 == r6) goto L20
+            if (r3 != r4) goto L1a
+            int r2 = r2 / 2
+            goto L25
+        L1a:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            r8.<init>()
+            throw r8
+        L20:
+            int r2 = r2 * 2
+            goto L25
+        L23:
+            int r2 = r2 / r6
+            goto L20
+        L25:
+            java.nio.ByteBuffer r3 = r7.buffer
+            int r3 = r3.capacity()
+            if (r3 >= r2) goto L3c
+            java.nio.ByteBuffer r2 = java.nio.ByteBuffer.allocateDirect(r2)
+            java.nio.ByteOrder r3 = java.nio.ByteOrder.nativeOrder()
+            java.nio.ByteBuffer r2 = r2.order(r3)
+            r7.buffer = r2
+            goto L41
+        L3c:
+            java.nio.ByteBuffer r2 = r7.buffer
+            r2.clear()
+        L41:
+            int r2 = r7.encoding
+            if (r2 == r5) goto L83
+            if (r2 == r6) goto L6a
+            if (r2 != r4) goto L64
+        L49:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 2
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 3
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            int r0 = r0 + 4
+            goto L49
+        L64:
+            java.lang.IllegalStateException r8 = new java.lang.IllegalStateException
+            r8.<init>()
+            throw r8
+        L6a:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            r3 = 0
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            byte r3 = r8.get(r0)
+            r3 = r3 & 255(0xff, float:3.57E-43)
+            int r3 = r3 + (-128)
+            byte r3 = (byte) r3
+            r2.put(r3)
+            int r0 = r0 + 1
+            goto L6a
+        L83:
+            if (r0 >= r1) goto L9e
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 1
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            java.nio.ByteBuffer r2 = r7.buffer
+            int r3 = r0 + 2
+            byte r3 = r8.get(r3)
+            r2.put(r3)
+            int r0 = r0 + 3
+            goto L83
+        L9e:
+            int r0 = r8.limit()
+            r8.position(r0)
+            java.nio.ByteBuffer r8 = r7.buffer
+            r8.flip()
+            java.nio.ByteBuffer r8 = r7.buffer
+            r7.outputBuffer = r8
+            return
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.audio.ResamplingAudioProcessor.queueInput(java.nio.ByteBuffer):void");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.sampleRateHz = -1;
+        this.channelCount = -1;
+        this.encoding = 0;
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SilenceSkippingAudioProcessor.java

@@ -0,0 +1,280 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public final class SilenceSkippingAudioProcessor implements AudioProcessor {
+    private static final long MINIMUM_SILENCE_DURATION_US = 150000;
+    private static final long PADDING_SILENCE_US = 20000;
+    private static final short SILENCE_THRESHOLD_LEVEL = 1024;
+    private static final byte SILENCE_THRESHOLD_LEVEL_MSB = 4;
+    private static final int STATE_MAYBE_SILENT = 1;
+    private static final int STATE_NOISY = 0;
+    private static final int STATE_SILENT = 2;
+    private ByteBuffer buffer;
+    private int bytesPerFrame;
+    private int channelCount;
+    private boolean enabled;
+    private boolean hasOutputNoise;
+    private boolean inputEnded;
+    private byte[] maybeSilenceBuffer;
+    private int maybeSilenceBufferSize;
+    private ByteBuffer outputBuffer;
+    private byte[] paddingBuffer;
+    private int paddingSize;
+    private int sampleRateHz;
+    private long skippedFrames;
+    private int state;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    public final long getSkippedFrames() {
+        return this.skippedFrames;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.sampleRateHz != -1 && this.enabled;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    public SilenceSkippingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.maybeSilenceBuffer = new byte[0];
+        this.paddingBuffer = new byte[0];
+    }
+
+    public final void setEnabled(boolean z) {
+        this.enabled = z;
+        flush();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.bytesPerFrame = i2 * 2;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        while (byteBuffer.hasRemaining() && !this.outputBuffer.hasRemaining()) {
+            int i = this.state;
+            if (i == 0) {
+                processNoisy(byteBuffer);
+            } else if (i == 1) {
+                processMaybeSilence(byteBuffer);
+            } else if (i == 2) {
+                processSilence(byteBuffer);
+            } else {
+                throw new IllegalStateException();
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+        int i = this.maybeSilenceBufferSize;
+        if (i > 0) {
+            output(this.maybeSilenceBuffer, i);
+        }
+        if (this.hasOutputNoise) {
+            return;
+        }
+        this.skippedFrames += this.paddingSize / this.bytesPerFrame;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        if (isActive()) {
+            int durationUsToFrames = durationUsToFrames(MINIMUM_SILENCE_DURATION_US) * this.bytesPerFrame;
+            if (this.maybeSilenceBuffer.length != durationUsToFrames) {
+                this.maybeSilenceBuffer = new byte[durationUsToFrames];
+            }
+            int durationUsToFrames2 = durationUsToFrames(PADDING_SILENCE_US) * this.bytesPerFrame;
+            this.paddingSize = durationUsToFrames2;
+            if (this.paddingBuffer.length != durationUsToFrames2) {
+                this.paddingBuffer = new byte[durationUsToFrames2];
+            }
+        }
+        this.state = 0;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+        this.skippedFrames = 0L;
+        this.maybeSilenceBufferSize = 0;
+        this.hasOutputNoise = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        this.enabled = false;
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.paddingSize = 0;
+        this.maybeSilenceBuffer = new byte[0];
+        this.paddingBuffer = new byte[0];
+    }
+
+    private void processNoisy(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        byteBuffer.limit(Math.min(limit, byteBuffer.position() + this.maybeSilenceBuffer.length));
+        int findNoiseLimit = findNoiseLimit(byteBuffer);
+        if (findNoiseLimit == byteBuffer.position()) {
+            this.state = 1;
+        } else {
+            byteBuffer.limit(findNoiseLimit);
+            output(byteBuffer);
+        }
+        byteBuffer.limit(limit);
+    }
+
+    private void processMaybeSilence(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        int findNoisePosition = findNoisePosition(byteBuffer);
+        int position = findNoisePosition - byteBuffer.position();
+        byte[] bArr = this.maybeSilenceBuffer;
+        int length = bArr.length;
+        int i = this.maybeSilenceBufferSize;
+        int i2 = length - i;
+        if (findNoisePosition < limit && position < i2) {
+            output(bArr, i);
+            this.maybeSilenceBufferSize = 0;
+            this.state = 0;
+            return;
+        }
+        int min = Math.min(position, i2);
+        byteBuffer.limit(byteBuffer.position() + min);
+        byteBuffer.get(this.maybeSilenceBuffer, this.maybeSilenceBufferSize, min);
+        int i3 = this.maybeSilenceBufferSize + min;
+        this.maybeSilenceBufferSize = i3;
+        byte[] bArr2 = this.maybeSilenceBuffer;
+        if (i3 == bArr2.length) {
+            if (this.hasOutputNoise) {
+                output(bArr2, this.paddingSize);
+                this.skippedFrames += (this.maybeSilenceBufferSize - (this.paddingSize * 2)) / this.bytesPerFrame;
+            } else {
+                this.skippedFrames += (i3 - this.paddingSize) / this.bytesPerFrame;
+            }
+            updatePaddingBuffer(byteBuffer, this.maybeSilenceBuffer, this.maybeSilenceBufferSize);
+            this.maybeSilenceBufferSize = 0;
+            this.state = 2;
+        }
+        byteBuffer.limit(limit);
+    }
+
+    private void processSilence(ByteBuffer byteBuffer) {
+        int limit = byteBuffer.limit();
+        int findNoisePosition = findNoisePosition(byteBuffer);
+        byteBuffer.limit(findNoisePosition);
+        this.skippedFrames += byteBuffer.remaining() / this.bytesPerFrame;
+        updatePaddingBuffer(byteBuffer, this.paddingBuffer, this.paddingSize);
+        if (findNoisePosition < limit) {
+            output(this.paddingBuffer, this.paddingSize);
+            this.state = 0;
+            byteBuffer.limit(limit);
+        }
+    }
+
+    private void output(byte[] bArr, int i) {
+        prepareForOutput(i);
+        this.buffer.put(bArr, 0, i);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    private void output(ByteBuffer byteBuffer) {
+        prepareForOutput(byteBuffer.remaining());
+        this.buffer.put(byteBuffer);
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    private void prepareForOutput(int i) {
+        if (this.buffer.capacity() < i) {
+            this.buffer = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        if (i > 0) {
+            this.hasOutputNoise = true;
+        }
+    }
+
+    private void updatePaddingBuffer(ByteBuffer byteBuffer, byte[] bArr, int i) {
+        int min = Math.min(byteBuffer.remaining(), this.paddingSize);
+        int i2 = this.paddingSize - min;
+        System.arraycopy(bArr, i - i2, this.paddingBuffer, 0, i2);
+        byteBuffer.position(byteBuffer.limit() - min);
+        byteBuffer.get(this.paddingBuffer, i2, min);
+    }
+
+    private int durationUsToFrames(long j) {
+        return (int) ((j * this.sampleRateHz) / 1000000);
+    }
+
+    private int findNoisePosition(ByteBuffer byteBuffer) {
+        for (int position = byteBuffer.position() + 1; position < byteBuffer.limit(); position += 2) {
+            if (Math.abs((int) byteBuffer.get(position)) > 4) {
+                int i = this.bytesPerFrame;
+                return i * (position / i);
+            }
+        }
+        return byteBuffer.limit();
+    }
+
+    private int findNoiseLimit(ByteBuffer byteBuffer) {
+        for (int limit = byteBuffer.limit() - 1; limit >= byteBuffer.position(); limit -= 2) {
+            if (Math.abs((int) byteBuffer.get(limit)) > 4) {
+                int i = this.bytesPerFrame;
+                return ((limit / i) * i) + i;
+            }
+        }
+        return byteBuffer.position();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SimpleDecoderAudioRenderer.java

@@ -0,0 +1,537 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer;
+import com.mbridge.msdk.playercommon.exoplayer2.ExoPlaybackException;
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.FormatHolder;
+import com.mbridge.msdk.playercommon.exoplayer2.PlaybackParameters;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioRendererEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderCounters;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleOutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock;
+import com.mbridge.msdk.playercommon.exoplayer2.util.MimeTypes;
+import com.mbridge.msdk.playercommon.exoplayer2.util.TraceUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public abstract class SimpleDecoderAudioRenderer extends BaseRenderer implements MediaClock {
+    private static final int REINITIALIZATION_STATE_NONE = 0;
+    private static final int REINITIALIZATION_STATE_SIGNAL_END_OF_STREAM = 1;
+    private static final int REINITIALIZATION_STATE_WAIT_END_OF_STREAM = 2;
+    private boolean allowFirstBufferPositionDiscontinuity;
+    private boolean allowPositionDiscontinuity;
+    private final AudioSink audioSink;
+    private boolean audioTrackNeedsConfigure;
+    private long currentPositionUs;
+    private SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> decoder;
+    private DecoderCounters decoderCounters;
+    private boolean decoderReceivedBuffers;
+    private int decoderReinitializationState;
+    private DrmSession<ExoMediaCrypto> drmSession;
+    private final DrmSessionManager<ExoMediaCrypto> drmSessionManager;
+    private int encoderDelay;
+    private int encoderPadding;
+    private final AudioRendererEventListener.EventDispatcher eventDispatcher;
+    private final DecoderInputBuffer flagsOnlyBuffer;
+    private final FormatHolder formatHolder;
+    private DecoderInputBuffer inputBuffer;
+    private Format inputFormat;
+    private boolean inputStreamEnded;
+    private SimpleOutputBuffer outputBuffer;
+    private boolean outputStreamEnded;
+    private DrmSession<ExoMediaCrypto> pendingDrmSession;
+    private final boolean playClearSamplesWithoutKeys;
+    private boolean waitingForKeys;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface ReinitializationState {
+    }
+
+    public abstract SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> createDecoder(Format format, ExoMediaCrypto exoMediaCrypto) throws AudioDecoderException;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public MediaClock getMediaClock() {
+        return this;
+    }
+
+    public void onAudioSessionId(int i) {
+    }
+
+    public void onAudioTrackPositionDiscontinuity() {
+    }
+
+    public void onAudioTrackUnderrun(int i, long j, long j2) {
+    }
+
+    public abstract int supportsFormatInternal(DrmSessionManager<ExoMediaCrypto> drmSessionManager, Format format);
+
+    public SimpleDecoderAudioRenderer() {
+        this((Handler) null, (AudioRendererEventListener) null, new AudioProcessor[0]);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioProcessor... audioProcessorArr) {
+        this(handler, audioRendererEventListener, null, null, false, audioProcessorArr);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioCapabilities audioCapabilities) {
+        this(handler, audioRendererEventListener, audioCapabilities, null, false, new AudioProcessor[0]);
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, AudioCapabilities audioCapabilities, DrmSessionManager<ExoMediaCrypto> drmSessionManager, boolean z, AudioProcessor... audioProcessorArr) {
+        this(handler, audioRendererEventListener, drmSessionManager, z, new DefaultAudioSink(audioCapabilities, audioProcessorArr));
+    }
+
+    public SimpleDecoderAudioRenderer(Handler handler, AudioRendererEventListener audioRendererEventListener, DrmSessionManager<ExoMediaCrypto> drmSessionManager, boolean z, AudioSink audioSink) {
+        super(1);
+        this.drmSessionManager = drmSessionManager;
+        this.playClearSamplesWithoutKeys = z;
+        this.eventDispatcher = new AudioRendererEventListener.EventDispatcher(handler, audioRendererEventListener);
+        this.audioSink = audioSink;
+        audioSink.setListener(new AudioSinkListener());
+        this.formatHolder = new FormatHolder();
+        this.flagsOnlyBuffer = DecoderInputBuffer.newFlagsOnlyInstance();
+        this.decoderReinitializationState = 0;
+        this.audioTrackNeedsConfigure = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.RendererCapabilities
+    public final int supportsFormat(Format format) {
+        int supportsFormatInternal = supportsFormatInternal(this.drmSessionManager, format);
+        if (supportsFormatInternal <= 2) {
+            return supportsFormatInternal;
+        }
+        return supportsFormatInternal | (Util.SDK_INT >= 21 ? 32 : 0) | 8;
+    }
+
+    public final boolean supportsOutputEncoding(int i) {
+        return this.audioSink.isEncodingSupported(i);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public void render(long j, long j2) throws ExoPlaybackException {
+        if (this.outputStreamEnded) {
+            try {
+                this.audioSink.playToEndOfStream();
+                return;
+            } catch (AudioSink.WriteException e) {
+                throw ExoPlaybackException.createForRenderer(e, getIndex());
+            }
+        }
+        if (this.inputFormat == null) {
+            this.flagsOnlyBuffer.clear();
+            int readSource = readSource(this.formatHolder, this.flagsOnlyBuffer, true);
+            if (readSource != -5) {
+                if (readSource == -4) {
+                    Assertions.checkState(this.flagsOnlyBuffer.isEndOfStream());
+                    this.inputStreamEnded = true;
+                    processEndOfStream();
+                    return;
+                }
+                return;
+            }
+            onInputFormatChanged(this.formatHolder.format);
+        }
+        maybeInitDecoder();
+        if (this.decoder != null) {
+            try {
+                TraceUtil.beginSection("drainAndFeed");
+                while (drainOutputBuffer()) {
+                }
+                while (feedInputBuffer()) {
+                }
+                TraceUtil.endSection();
+                this.decoderCounters.ensureUpdated();
+            } catch (AudioDecoderException | AudioSink.ConfigurationException | AudioSink.InitializationException | AudioSink.WriteException e2) {
+                throw ExoPlaybackException.createForRenderer(e2, getIndex());
+            }
+        }
+    }
+
+    public Format getOutputFormat() {
+        Format format = this.inputFormat;
+        return Format.createAudioSampleFormat(null, MimeTypes.AUDIO_RAW, null, -1, -1, format.channelCount, format.sampleRate, 2, null, null, 0, null);
+    }
+
+    private boolean drainOutputBuffer() throws ExoPlaybackException, AudioDecoderException, AudioSink.ConfigurationException, AudioSink.InitializationException, AudioSink.WriteException {
+        if (this.outputBuffer == null) {
+            SimpleOutputBuffer dequeueOutputBuffer = this.decoder.dequeueOutputBuffer();
+            this.outputBuffer = dequeueOutputBuffer;
+            if (dequeueOutputBuffer == null) {
+                return false;
+            }
+            this.decoderCounters.skippedOutputBufferCount += dequeueOutputBuffer.skippedOutputBufferCount;
+        }
+        if (this.outputBuffer.isEndOfStream()) {
+            if (this.decoderReinitializationState == 2) {
+                releaseDecoder();
+                maybeInitDecoder();
+                this.audioTrackNeedsConfigure = true;
+            } else {
+                this.outputBuffer.release();
+                this.outputBuffer = null;
+                processEndOfStream();
+            }
+            return false;
+        }
+        if (this.audioTrackNeedsConfigure) {
+            Format outputFormat = getOutputFormat();
+            this.audioSink.configure(outputFormat.pcmEncoding, outputFormat.channelCount, outputFormat.sampleRate, 0, null, this.encoderDelay, this.encoderPadding);
+            this.audioTrackNeedsConfigure = false;
+        }
+        AudioSink audioSink = this.audioSink;
+        SimpleOutputBuffer simpleOutputBuffer = this.outputBuffer;
+        if (!audioSink.handleBuffer(simpleOutputBuffer.data, simpleOutputBuffer.timeUs)) {
+            return false;
+        }
+        this.decoderCounters.renderedOutputBufferCount++;
+        this.outputBuffer.release();
+        this.outputBuffer = null;
+        return true;
+    }
+
+    private boolean feedInputBuffer() throws AudioDecoderException, ExoPlaybackException {
+        SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> simpleDecoder = this.decoder;
+        if (simpleDecoder == null || this.decoderReinitializationState == 2 || this.inputStreamEnded) {
+            return false;
+        }
+        if (this.inputBuffer == null) {
+            DecoderInputBuffer dequeueInputBuffer = simpleDecoder.dequeueInputBuffer();
+            this.inputBuffer = dequeueInputBuffer;
+            if (dequeueInputBuffer == null) {
+                return false;
+            }
+        }
+        if (this.decoderReinitializationState == 1) {
+            this.inputBuffer.setFlags(4);
+            this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+            this.inputBuffer = null;
+            this.decoderReinitializationState = 2;
+            return false;
+        }
+        int readSource = this.waitingForKeys ? -4 : readSource(this.formatHolder, this.inputBuffer, false);
+        if (readSource == -3) {
+            return false;
+        }
+        if (readSource == -5) {
+            onInputFormatChanged(this.formatHolder.format);
+            return true;
+        }
+        if (this.inputBuffer.isEndOfStream()) {
+            this.inputStreamEnded = true;
+            this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+            this.inputBuffer = null;
+            return false;
+        }
+        boolean shouldWaitForKeys = shouldWaitForKeys(this.inputBuffer.isEncrypted());
+        this.waitingForKeys = shouldWaitForKeys;
+        if (shouldWaitForKeys) {
+            return false;
+        }
+        this.inputBuffer.flip();
+        onQueueInputBuffer(this.inputBuffer);
+        this.decoder.queueInputBuffer((SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException>) this.inputBuffer);
+        this.decoderReceivedBuffers = true;
+        this.decoderCounters.inputBufferCount++;
+        this.inputBuffer = null;
+        return true;
+    }
+
+    private boolean shouldWaitForKeys(boolean z) throws ExoPlaybackException {
+        DrmSession<ExoMediaCrypto> drmSession = this.drmSession;
+        if (drmSession == null || (!z && this.playClearSamplesWithoutKeys)) {
+            return false;
+        }
+        int state = drmSession.getState();
+        if (state != 1) {
+            return state != 4;
+        }
+        throw ExoPlaybackException.createForRenderer(this.drmSession.getError(), getIndex());
+    }
+
+    private void processEndOfStream() throws ExoPlaybackException {
+        this.outputStreamEnded = true;
+        try {
+            this.audioSink.playToEndOfStream();
+        } catch (AudioSink.WriteException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    private void flushDecoder() throws ExoPlaybackException {
+        this.waitingForKeys = false;
+        if (this.decoderReinitializationState != 0) {
+            releaseDecoder();
+            maybeInitDecoder();
+            return;
+        }
+        this.inputBuffer = null;
+        SimpleOutputBuffer simpleOutputBuffer = this.outputBuffer;
+        if (simpleOutputBuffer != null) {
+            simpleOutputBuffer.release();
+            this.outputBuffer = null;
+        }
+        this.decoder.flush();
+        this.decoderReceivedBuffers = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isEnded() {
+        return this.outputStreamEnded && this.audioSink.isEnded();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.Renderer
+    public boolean isReady() {
+        return this.audioSink.hasPendingData() || !(this.inputFormat == null || this.waitingForKeys || (!isSourceReady() && this.outputBuffer == null));
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public long getPositionUs() {
+        if (getState() == 2) {
+            updateCurrentPosition();
+        }
+        return this.currentPositionUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters setPlaybackParameters(PlaybackParameters playbackParameters) {
+        return this.audioSink.setPlaybackParameters(playbackParameters);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.util.MediaClock
+    public PlaybackParameters getPlaybackParameters() {
+        return this.audioSink.getPlaybackParameters();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onEnabled(boolean z) throws ExoPlaybackException {
+        DecoderCounters decoderCounters = new DecoderCounters();
+        this.decoderCounters = decoderCounters;
+        this.eventDispatcher.enabled(decoderCounters);
+        int i = getConfiguration().tunnelingAudioSessionId;
+        if (i != 0) {
+            this.audioSink.enableTunnelingV21(i);
+        } else {
+            this.audioSink.disableTunneling();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onPositionReset(long j, boolean z) throws ExoPlaybackException {
+        this.audioSink.reset();
+        this.currentPositionUs = j;
+        this.allowFirstBufferPositionDiscontinuity = true;
+        this.allowPositionDiscontinuity = true;
+        this.inputStreamEnded = false;
+        this.outputStreamEnded = false;
+        if (this.decoder != null) {
+            flushDecoder();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStarted() {
+        this.audioSink.play();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onStopped() {
+        updateCurrentPosition();
+        this.audioSink.pause();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer
+    public void onDisabled() {
+        this.inputFormat = null;
+        this.audioTrackNeedsConfigure = true;
+        this.waitingForKeys = false;
+        try {
+            releaseDecoder();
+            this.audioSink.release();
+            try {
+                DrmSession<ExoMediaCrypto> drmSession = this.drmSession;
+                if (drmSession != null) {
+                    this.drmSessionManager.releaseSession(drmSession);
+                }
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession2 = this.pendingDrmSession;
+                    if (drmSession2 != null && drmSession2 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession2);
+                    }
+                } finally {
+                }
+            } catch (Throwable th) {
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession3 = this.pendingDrmSession;
+                    if (drmSession3 != null && drmSession3 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession3);
+                    }
+                    throw th;
+                } finally {
+                }
+            }
+        } catch (Throwable th2) {
+            try {
+                DrmSession<ExoMediaCrypto> drmSession4 = this.drmSession;
+                if (drmSession4 != null) {
+                    this.drmSessionManager.releaseSession(drmSession4);
+                }
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession5 = this.pendingDrmSession;
+                    if (drmSession5 != null && drmSession5 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession5);
+                    }
+                    throw th2;
+                } finally {
+                }
+            } catch (Throwable th3) {
+                try {
+                    DrmSession<ExoMediaCrypto> drmSession6 = this.pendingDrmSession;
+                    if (drmSession6 != null && drmSession6 != this.drmSession) {
+                        this.drmSessionManager.releaseSession(drmSession6);
+                    }
+                    throw th3;
+                } finally {
+                }
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.BaseRenderer, com.mbridge.msdk.playercommon.exoplayer2.PlayerMessage.Target
+    public void handleMessage(int i, Object obj) throws ExoPlaybackException {
+        if (i == 2) {
+            this.audioSink.setVolume(((Float) obj).floatValue());
+        } else if (i == 3) {
+            this.audioSink.setAudioAttributes((AudioAttributes) obj);
+        } else {
+            super.handleMessage(i, obj);
+        }
+    }
+
+    private void maybeInitDecoder() throws ExoPlaybackException {
+        ExoMediaCrypto exoMediaCrypto;
+        if (this.decoder != null) {
+            return;
+        }
+        DrmSession<ExoMediaCrypto> drmSession = this.pendingDrmSession;
+        this.drmSession = drmSession;
+        if (drmSession != null) {
+            exoMediaCrypto = drmSession.getMediaCrypto();
+            if (exoMediaCrypto == null && this.drmSession.getError() == null) {
+                return;
+            }
+        } else {
+            exoMediaCrypto = null;
+        }
+        try {
+            long elapsedRealtime = SystemClock.elapsedRealtime();
+            TraceUtil.beginSection("createAudioDecoder");
+            this.decoder = createDecoder(this.inputFormat, exoMediaCrypto);
+            TraceUtil.endSection();
+            long elapsedRealtime2 = SystemClock.elapsedRealtime();
+            this.eventDispatcher.decoderInitialized(this.decoder.getName(), elapsedRealtime2, elapsedRealtime2 - elapsedRealtime);
+            this.decoderCounters.decoderInitCount++;
+        } catch (AudioDecoderException e) {
+            throw ExoPlaybackException.createForRenderer(e, getIndex());
+        }
+    }
+
+    private void releaseDecoder() {
+        SimpleDecoder<DecoderInputBuffer, ? extends SimpleOutputBuffer, ? extends AudioDecoderException> simpleDecoder = this.decoder;
+        if (simpleDecoder == null) {
+            return;
+        }
+        this.inputBuffer = null;
+        this.outputBuffer = null;
+        simpleDecoder.release();
+        this.decoder = null;
+        this.decoderCounters.decoderReleaseCount++;
+        this.decoderReinitializationState = 0;
+        this.decoderReceivedBuffers = false;
+    }
+
+    private void onInputFormatChanged(Format format) throws ExoPlaybackException {
+        Format format2 = this.inputFormat;
+        this.inputFormat = format;
+        if (!Util.areEqual(format.drmInitData, format2 == null ? null : format2.drmInitData)) {
+            if (this.inputFormat.drmInitData != null) {
+                DrmSessionManager<ExoMediaCrypto> drmSessionManager = this.drmSessionManager;
+                if (drmSessionManager == null) {
+                    throw ExoPlaybackException.createForRenderer(new IllegalStateException("Media requires a DrmSessionManager"), getIndex());
+                }
+                DrmSession<ExoMediaCrypto> acquireSession = drmSessionManager.acquireSession(Looper.myLooper(), this.inputFormat.drmInitData);
+                this.pendingDrmSession = acquireSession;
+                if (acquireSession == this.drmSession) {
+                    this.drmSessionManager.releaseSession(acquireSession);
+                }
+            } else {
+                this.pendingDrmSession = null;
+            }
+        }
+        if (this.decoderReceivedBuffers) {
+            this.decoderReinitializationState = 1;
+        } else {
+            releaseDecoder();
+            maybeInitDecoder();
+            this.audioTrackNeedsConfigure = true;
+        }
+        this.encoderDelay = format.encoderDelay;
+        this.encoderPadding = format.encoderPadding;
+        this.eventDispatcher.inputFormatChanged(format);
+    }
+
+    private void onQueueInputBuffer(DecoderInputBuffer decoderInputBuffer) {
+        if (!this.allowFirstBufferPositionDiscontinuity || decoderInputBuffer.isDecodeOnly()) {
+            return;
+        }
+        if (Math.abs(decoderInputBuffer.timeUs - this.currentPositionUs) > 500000) {
+            this.currentPositionUs = decoderInputBuffer.timeUs;
+        }
+        this.allowFirstBufferPositionDiscontinuity = false;
+    }
+
+    private void updateCurrentPosition() {
+        long currentPositionUs = this.audioSink.getCurrentPositionUs(isEnded());
+        if (currentPositionUs != Long.MIN_VALUE) {
+            if (!this.allowPositionDiscontinuity) {
+                currentPositionUs = Math.max(this.currentPositionUs, currentPositionUs);
+            }
+            this.currentPositionUs = currentPositionUs;
+            this.allowPositionDiscontinuity = false;
+        }
+    }
+
+    public final class AudioSinkListener implements AudioSink.Listener {
+        private AudioSinkListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onAudioSessionId(int i) {
+            SimpleDecoderAudioRenderer.this.eventDispatcher.audioSessionId(i);
+            SimpleDecoderAudioRenderer.this.onAudioSessionId(i);
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onPositionDiscontinuity() {
+            SimpleDecoderAudioRenderer.this.onAudioTrackPositionDiscontinuity();
+            SimpleDecoderAudioRenderer.this.allowPositionDiscontinuity = true;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioSink.Listener
+        public final void onUnderrun(int i, long j, long j2) {
+            SimpleDecoderAudioRenderer.this.eventDispatcher.audioTrackUnderrun(i, j, j2);
+            SimpleDecoderAudioRenderer.this.onAudioTrackUnderrun(i, j, j2);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/Sonic.java

@@ -0,0 +1,402 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.nio.ShortBuffer;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+final class Sonic {
+    private static final int AMDF_FREQUENCY = 4000;
+    private static final int MAXIMUM_PITCH = 400;
+    private static final int MINIMUM_PITCH = 65;
+    private final int channelCount;
+    private final short[] downSampleBuffer;
+    private short[] inputBuffer;
+    private int inputFrameCount;
+    private final int inputSampleRateHz;
+    private int maxDiff;
+    private final int maxPeriod;
+    private final int maxRequiredFrameCount;
+    private int minDiff;
+    private final int minPeriod;
+    private int newRatePosition;
+    private int oldRatePosition;
+    private short[] outputBuffer;
+    private int outputFrameCount;
+    private final float pitch;
+    private short[] pitchBuffer;
+    private int pitchFrameCount;
+    private int prevMinDiff;
+    private int prevPeriod;
+    private final float rate;
+    private int remainingInputToCopyFrameCount;
+    private final float speed;
+
+    private boolean previousPeriodBetter(int i, int i2) {
+        return i != 0 && this.prevPeriod != 0 && i2 <= i * 3 && i * 2 > this.prevMinDiff * 3;
+    }
+
+    public final void flush() {
+        this.inputFrameCount = 0;
+        this.outputFrameCount = 0;
+        this.pitchFrameCount = 0;
+        this.oldRatePosition = 0;
+        this.newRatePosition = 0;
+        this.remainingInputToCopyFrameCount = 0;
+        this.prevPeriod = 0;
+        this.prevMinDiff = 0;
+        this.minDiff = 0;
+        this.maxDiff = 0;
+    }
+
+    public final int getFramesAvailable() {
+        return this.outputFrameCount;
+    }
+
+    public Sonic(int i, int i2, float f, float f2, int i3) {
+        this.inputSampleRateHz = i;
+        this.channelCount = i2;
+        this.speed = f;
+        this.pitch = f2;
+        this.rate = i / i3;
+        this.minPeriod = i / 400;
+        int i4 = i / 65;
+        this.maxPeriod = i4;
+        int i5 = i4 * 2;
+        this.maxRequiredFrameCount = i5;
+        this.downSampleBuffer = new short[i5];
+        this.inputBuffer = new short[i5 * i2];
+        this.outputBuffer = new short[i5 * i2];
+        this.pitchBuffer = new short[i5 * i2];
+    }
+
+    public final void queueInput(ShortBuffer shortBuffer) {
+        int remaining = shortBuffer.remaining();
+        int i = this.channelCount;
+        int i2 = remaining / i;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.inputBuffer, this.inputFrameCount, i2);
+        this.inputBuffer = ensureSpaceForAdditionalFrames;
+        shortBuffer.get(ensureSpaceForAdditionalFrames, this.inputFrameCount * this.channelCount, ((i * i2) * 2) / 2);
+        this.inputFrameCount += i2;
+        processStreamInput();
+    }
+
+    public final void getOutput(ShortBuffer shortBuffer) {
+        int min = Math.min(shortBuffer.remaining() / this.channelCount, this.outputFrameCount);
+        shortBuffer.put(this.outputBuffer, 0, this.channelCount * min);
+        int i = this.outputFrameCount - min;
+        this.outputFrameCount = i;
+        short[] sArr = this.outputBuffer;
+        int i2 = this.channelCount;
+        System.arraycopy(sArr, min * i2, sArr, 0, i * i2);
+    }
+
+    public final void queueEndOfStream() {
+        int i;
+        int i2 = this.inputFrameCount;
+        float f = this.speed;
+        float f2 = this.pitch;
+        int i3 = this.outputFrameCount + ((int) ((((i2 / (f / f2)) + this.pitchFrameCount) / (this.rate * f2)) + 0.5f));
+        this.inputBuffer = ensureSpaceForAdditionalFrames(this.inputBuffer, i2, (this.maxRequiredFrameCount * 2) + i2);
+        int i4 = 0;
+        while (true) {
+            i = this.maxRequiredFrameCount;
+            int i5 = this.channelCount;
+            if (i4 >= i * 2 * i5) {
+                break;
+            }
+            this.inputBuffer[(i5 * i2) + i4] = 0;
+            i4++;
+        }
+        this.inputFrameCount += i * 2;
+        processStreamInput();
+        if (this.outputFrameCount > i3) {
+            this.outputFrameCount = i3;
+        }
+        this.inputFrameCount = 0;
+        this.remainingInputToCopyFrameCount = 0;
+        this.pitchFrameCount = 0;
+    }
+
+    private short[] ensureSpaceForAdditionalFrames(short[] sArr, int i, int i2) {
+        int length = sArr.length;
+        int i3 = this.channelCount;
+        int i4 = length / i3;
+        return i + i2 <= i4 ? sArr : Arrays.copyOf(sArr, (((i4 * 3) / 2) + i2) * i3);
+    }
+
+    private void removeProcessedInputFrames(int i) {
+        int i2 = this.inputFrameCount - i;
+        short[] sArr = this.inputBuffer;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, sArr, 0, i3 * i2);
+        this.inputFrameCount = i2;
+    }
+
+    private void copyToOutput(short[] sArr, int i, int i2) {
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i2);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, ensureSpaceForAdditionalFrames, this.outputFrameCount * i3, i3 * i2);
+        this.outputFrameCount += i2;
+    }
+
+    private int copyInputToOutput(int i) {
+        int min = Math.min(this.maxRequiredFrameCount, this.remainingInputToCopyFrameCount);
+        copyToOutput(this.inputBuffer, i, min);
+        this.remainingInputToCopyFrameCount -= min;
+        return min;
+    }
+
+    private void downSampleInput(short[] sArr, int i, int i2) {
+        int i3 = this.maxRequiredFrameCount / i2;
+        int i4 = this.channelCount;
+        int i5 = i2 * i4;
+        int i6 = i * i4;
+        for (int i7 = 0; i7 < i3; i7++) {
+            int i8 = 0;
+            for (int i9 = 0; i9 < i5; i9++) {
+                i8 += sArr[(i7 * i5) + i6 + i9];
+            }
+            this.downSampleBuffer[i7] = (short) (i8 / i5);
+        }
+    }
+
+    private int findPitchPeriodInRange(short[] sArr, int i, int i2, int i3) {
+        int i4 = i * this.channelCount;
+        int i5 = 255;
+        int i6 = 1;
+        int i7 = 0;
+        int i8 = 0;
+        while (i2 <= i3) {
+            int i9 = 0;
+            for (int i10 = 0; i10 < i2; i10++) {
+                i9 += Math.abs(sArr[i4 + i10] - sArr[(i4 + i2) + i10]);
+            }
+            if (i9 * i7 < i6 * i2) {
+                i7 = i2;
+                i6 = i9;
+            }
+            if (i9 * i5 > i8 * i2) {
+                i5 = i2;
+                i8 = i9;
+            }
+            i2++;
+        }
+        this.minDiff = i6 / i7;
+        this.maxDiff = i8 / i5;
+        return i7;
+    }
+
+    private int findPitchPeriod(short[] sArr, int i) {
+        int i2;
+        int i3 = this.inputSampleRateHz;
+        int i4 = i3 > AMDF_FREQUENCY ? i3 / AMDF_FREQUENCY : 1;
+        if (this.channelCount == 1 && i4 == 1) {
+            i2 = findPitchPeriodInRange(sArr, i, this.minPeriod, this.maxPeriod);
+        } else {
+            downSampleInput(sArr, i, i4);
+            int findPitchPeriodInRange = findPitchPeriodInRange(this.downSampleBuffer, 0, this.minPeriod / i4, this.maxPeriod / i4);
+            if (i4 != 1) {
+                int i5 = findPitchPeriodInRange * i4;
+                int i6 = i4 * 4;
+                int i7 = i5 - i6;
+                int i8 = i5 + i6;
+                int i9 = this.minPeriod;
+                if (i7 < i9) {
+                    i7 = i9;
+                }
+                int i10 = this.maxPeriod;
+                if (i8 > i10) {
+                    i8 = i10;
+                }
+                if (this.channelCount == 1) {
+                    i2 = findPitchPeriodInRange(sArr, i, i7, i8);
+                } else {
+                    downSampleInput(sArr, i, 1);
+                    i2 = findPitchPeriodInRange(this.downSampleBuffer, 0, i7, i8);
+                }
+            } else {
+                i2 = findPitchPeriodInRange;
+            }
+        }
+        int i11 = previousPeriodBetter(this.minDiff, this.maxDiff) ? this.prevPeriod : i2;
+        this.prevMinDiff = this.minDiff;
+        this.prevPeriod = i2;
+        return i11;
+    }
+
+    private void moveNewSamplesToPitchBuffer(int i) {
+        int i2 = this.outputFrameCount - i;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.pitchBuffer, this.pitchFrameCount, i2);
+        this.pitchBuffer = ensureSpaceForAdditionalFrames;
+        short[] sArr = this.outputBuffer;
+        int i3 = this.channelCount;
+        System.arraycopy(sArr, i * i3, ensureSpaceForAdditionalFrames, this.pitchFrameCount * i3, i3 * i2);
+        this.outputFrameCount = i;
+        this.pitchFrameCount += i2;
+    }
+
+    private void removePitchFrames(int i) {
+        if (i == 0) {
+            return;
+        }
+        short[] sArr = this.pitchBuffer;
+        int i2 = this.channelCount;
+        System.arraycopy(sArr, i * i2, sArr, 0, (this.pitchFrameCount - i) * i2);
+        this.pitchFrameCount -= i;
+    }
+
+    private short interpolate(short[] sArr, int i, int i2, int i3) {
+        short s = sArr[i];
+        short s2 = sArr[i + this.channelCount];
+        int i4 = this.newRatePosition * i2;
+        int i5 = this.oldRatePosition;
+        int i6 = i5 * i3;
+        int i7 = (i5 + 1) * i3;
+        int i8 = i7 - i4;
+        int i9 = i7 - i6;
+        return (short) (((s * i8) + ((i9 - i8) * s2)) / i9);
+    }
+
+    private void adjustRate(float f, int i) {
+        int i2;
+        int i3;
+        if (this.outputFrameCount == i) {
+            return;
+        }
+        int i4 = this.inputSampleRateHz;
+        int i5 = (int) (i4 / f);
+        while (true) {
+            if (i5 <= 16384 && i4 <= 16384) {
+                break;
+            }
+            i5 /= 2;
+            i4 /= 2;
+        }
+        moveNewSamplesToPitchBuffer(i);
+        int i6 = 0;
+        while (true) {
+            int i7 = this.pitchFrameCount;
+            if (i6 >= i7 - 1) {
+                removePitchFrames(i7 - 1);
+                return;
+            }
+            while (true) {
+                i2 = this.oldRatePosition;
+                int i8 = (i2 + 1) * i5;
+                i3 = this.newRatePosition;
+                if (i8 <= i3 * i4) {
+                    break;
+                }
+                this.outputBuffer = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, 1);
+                int i9 = 0;
+                while (true) {
+                    int i10 = this.channelCount;
+                    if (i9 < i10) {
+                        this.outputBuffer[(this.outputFrameCount * i10) + i9] = interpolate(this.pitchBuffer, (i10 * i6) + i9, i4, i5);
+                        i9++;
+                    }
+                }
+                this.newRatePosition++;
+                this.outputFrameCount++;
+            }
+            int i11 = i2 + 1;
+            this.oldRatePosition = i11;
+            if (i11 == i4) {
+                this.oldRatePosition = 0;
+                Assertions.checkState(i3 == i5);
+                this.newRatePosition = 0;
+            }
+            i6++;
+        }
+    }
+
+    private int skipPitchPeriod(short[] sArr, int i, float f, int i2) {
+        int i3;
+        if (f >= 2.0f) {
+            i3 = (int) (i2 / (f - 1.0f));
+        } else {
+            this.remainingInputToCopyFrameCount = (int) ((i2 * (2.0f - f)) / (f - 1.0f));
+            i3 = i2;
+        }
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i3);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        overlapAdd(i3, this.channelCount, ensureSpaceForAdditionalFrames, this.outputFrameCount, sArr, i, sArr, i + i2);
+        this.outputFrameCount += i3;
+        return i3;
+    }
+
+    private int insertPitchPeriod(short[] sArr, int i, float f, int i2) {
+        int i3;
+        if (f < 0.5f) {
+            i3 = (int) ((i2 * f) / (1.0f - f));
+        } else {
+            this.remainingInputToCopyFrameCount = (int) ((i2 * ((2.0f * f) - 1.0f)) / (1.0f - f));
+            i3 = i2;
+        }
+        int i4 = i2 + i3;
+        short[] ensureSpaceForAdditionalFrames = ensureSpaceForAdditionalFrames(this.outputBuffer, this.outputFrameCount, i4);
+        this.outputBuffer = ensureSpaceForAdditionalFrames;
+        int i5 = this.channelCount;
+        System.arraycopy(sArr, i * i5, ensureSpaceForAdditionalFrames, this.outputFrameCount * i5, i5 * i2);
+        overlapAdd(i3, this.channelCount, this.outputBuffer, this.outputFrameCount + i2, sArr, i + i2, sArr, i);
+        this.outputFrameCount += i4;
+        return i3;
+    }
+
+    private void changeSpeed(float f) {
+        int insertPitchPeriod;
+        int i = this.inputFrameCount;
+        if (i < this.maxRequiredFrameCount) {
+            return;
+        }
+        int i2 = 0;
+        do {
+            if (this.remainingInputToCopyFrameCount > 0) {
+                insertPitchPeriod = copyInputToOutput(i2);
+            } else {
+                int findPitchPeriod = findPitchPeriod(this.inputBuffer, i2);
+                if (f > 1.0d) {
+                    insertPitchPeriod = findPitchPeriod + skipPitchPeriod(this.inputBuffer, i2, f, findPitchPeriod);
+                } else {
+                    insertPitchPeriod = insertPitchPeriod(this.inputBuffer, i2, f, findPitchPeriod);
+                }
+            }
+            i2 += insertPitchPeriod;
+        } while (this.maxRequiredFrameCount + i2 <= i);
+        removeProcessedInputFrames(i2);
+    }
+
+    private void processStreamInput() {
+        int i = this.outputFrameCount;
+        float f = this.speed;
+        float f2 = this.pitch;
+        float f3 = f / f2;
+        float f4 = this.rate * f2;
+        double d = f3;
+        if (d > 1.00001d || d < 0.99999d) {
+            changeSpeed(f3);
+        } else {
+            copyToOutput(this.inputBuffer, 0, this.inputFrameCount);
+            this.inputFrameCount = 0;
+        }
+        if (f4 != 1.0f) {
+            adjustRate(f4, i);
+        }
+    }
+
+    private static void overlapAdd(int i, int i2, short[] sArr, int i3, short[] sArr2, int i4, short[] sArr3, int i5) {
+        for (int i6 = 0; i6 < i2; i6++) {
+            int i7 = (i3 * i2) + i6;
+            int i8 = (i5 * i2) + i6;
+            int i9 = (i4 * i2) + i6;
+            for (int i10 = 0; i10 < i; i10++) {
+                sArr[i7] = (short) (((sArr2[i9] * (i - i10)) + (sArr3[i8] * i10)) / i);
+                i7 += i2;
+                i9 += i2;
+                i8 += i2;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/SonicAudioProcessor.java

@@ -0,0 +1,201 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import android.support.v4.media.session.PlaybackStateCompat;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+
+/* loaded from: classes4.dex */
+public final class SonicAudioProcessor implements AudioProcessor {
+    private static final float CLOSE_THRESHOLD = 0.01f;
+    public static final float MAXIMUM_PITCH = 8.0f;
+    public static final float MAXIMUM_SPEED = 8.0f;
+    public static final float MINIMUM_PITCH = 0.1f;
+    public static final float MINIMUM_SPEED = 0.1f;
+    private static final int MIN_BYTES_FOR_SPEEDUP_CALCULATION = 1024;
+    public static final int SAMPLE_RATE_NO_CHANGE = -1;
+    private ByteBuffer buffer;
+    private long inputBytes;
+    private boolean inputEnded;
+    private ByteBuffer outputBuffer;
+    private long outputBytes;
+    private int pendingOutputSampleRateHz;
+    private ShortBuffer shortBuffer;
+
+    @Nullable
+    private Sonic sonic;
+    private float speed = 1.0f;
+    private float pitch = 1.0f;
+    private int channelCount = -1;
+    private int sampleRateHz = -1;
+    private int outputSampleRateHz = -1;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.outputSampleRateHz;
+    }
+
+    public final void setOutputSampleRateHz(int i) {
+        this.pendingOutputSampleRateHz = i;
+    }
+
+    public SonicAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.shortBuffer = byteBuffer.asShortBuffer();
+        this.outputBuffer = byteBuffer;
+        this.pendingOutputSampleRateHz = -1;
+    }
+
+    public final float setSpeed(float f) {
+        float constrainValue = Util.constrainValue(f, 0.1f, 8.0f);
+        if (this.speed != constrainValue) {
+            this.speed = constrainValue;
+            this.sonic = null;
+        }
+        flush();
+        return constrainValue;
+    }
+
+    public final float setPitch(float f) {
+        float constrainValue = Util.constrainValue(f, 0.1f, 8.0f);
+        if (this.pitch != constrainValue) {
+            this.pitch = constrainValue;
+            this.sonic = null;
+        }
+        flush();
+        return constrainValue;
+    }
+
+    public final long scaleDurationForSpeedup(long j) {
+        long j2 = this.outputBytes;
+        if (j2 < PlaybackStateCompat.ACTION_PLAY_FROM_MEDIA_ID) {
+            return (long) (this.speed * j);
+        }
+        int i = this.outputSampleRateHz;
+        int i2 = this.sampleRateHz;
+        if (i == i2) {
+            return Util.scaleLargeTimestamp(j, this.inputBytes, j2);
+        }
+        return Util.scaleLargeTimestamp(j, this.inputBytes * i, j2 * i2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        int i4 = this.pendingOutputSampleRateHz;
+        if (i4 == -1) {
+            i4 = i;
+        }
+        if (this.sampleRateHz == i && this.channelCount == i2 && this.outputSampleRateHz == i4) {
+            return false;
+        }
+        this.sampleRateHz = i;
+        this.channelCount = i2;
+        this.outputSampleRateHz = i4;
+        this.sonic = null;
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.sampleRateHz != -1 && (Math.abs(this.speed - 1.0f) >= CLOSE_THRESHOLD || Math.abs(this.pitch - 1.0f) >= CLOSE_THRESHOLD || this.outputSampleRateHz != this.sampleRateHz);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        Assertions.checkState(this.sonic != null);
+        if (byteBuffer.hasRemaining()) {
+            ShortBuffer asShortBuffer = byteBuffer.asShortBuffer();
+            int remaining = byteBuffer.remaining();
+            this.inputBytes += remaining;
+            this.sonic.queueInput(asShortBuffer);
+            byteBuffer.position(byteBuffer.position() + remaining);
+        }
+        int framesAvailable = this.sonic.getFramesAvailable() * this.channelCount * 2;
+        if (framesAvailable > 0) {
+            if (this.buffer.capacity() < framesAvailable) {
+                ByteBuffer order = ByteBuffer.allocateDirect(framesAvailable).order(ByteOrder.nativeOrder());
+                this.buffer = order;
+                this.shortBuffer = order.asShortBuffer();
+            } else {
+                this.buffer.clear();
+                this.shortBuffer.clear();
+            }
+            this.sonic.getOutput(this.shortBuffer);
+            this.outputBytes += framesAvailable;
+            this.buffer.limit(framesAvailable);
+            this.outputBuffer = this.buffer;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        Assertions.checkState(this.sonic != null);
+        this.sonic.queueEndOfStream();
+        this.inputEnded = true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        Sonic sonic;
+        return this.inputEnded && ((sonic = this.sonic) == null || sonic.getFramesAvailable() == 0);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        if (isActive()) {
+            Sonic sonic = this.sonic;
+            if (sonic == null) {
+                this.sonic = new Sonic(this.sampleRateHz, this.channelCount, this.speed, this.pitch, this.outputSampleRateHz);
+            } else {
+                sonic.flush();
+            }
+        }
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputBytes = 0L;
+        this.outputBytes = 0L;
+        this.inputEnded = false;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        this.speed = 1.0f;
+        this.pitch = 1.0f;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.outputSampleRateHz = -1;
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.shortBuffer = byteBuffer.asShortBuffer();
+        this.outputBuffer = byteBuffer;
+        this.pendingOutputSampleRateHz = -1;
+        this.sonic = null;
+        this.inputBytes = 0L;
+        this.outputBytes = 0L;
+        this.inputEnded = false;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/audio/TrimmingAudioProcessor.java

@@ -0,0 +1,142 @@
+package com.mbridge.msdk.playercommon.exoplayer2.audio;
+
+import com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+final class TrimmingAudioProcessor implements AudioProcessor {
+    private ByteBuffer buffer;
+    private int channelCount;
+    private byte[] endBuffer;
+    private int endBufferSize;
+    private boolean inputEnded;
+    private boolean isActive;
+    private ByteBuffer outputBuffer;
+    private int pendingTrimStartBytes;
+    private int sampleRateHz;
+    private int trimEndFrames;
+    private int trimStartFrames;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void flush() {
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.inputEnded = false;
+        this.pendingTrimStartBytes = 0;
+        this.endBufferSize = 0;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final ByteBuffer getOutput() {
+        ByteBuffer byteBuffer = this.outputBuffer;
+        this.outputBuffer = AudioProcessor.EMPTY_BUFFER;
+        return byteBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputChannelCount() {
+        return this.channelCount;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputEncoding() {
+        return 2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final int getOutputSampleRateHz() {
+        return this.sampleRateHz;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isActive() {
+        return this.isActive;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean isEnded() {
+        return this.inputEnded && this.outputBuffer == AudioProcessor.EMPTY_BUFFER;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueEndOfStream() {
+        this.inputEnded = true;
+    }
+
+    public final void setTrimFrameCount(int i, int i2) {
+        this.trimStartFrames = i;
+        this.trimEndFrames = i2;
+    }
+
+    public TrimmingAudioProcessor() {
+        ByteBuffer byteBuffer = AudioProcessor.EMPTY_BUFFER;
+        this.buffer = byteBuffer;
+        this.outputBuffer = byteBuffer;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.endBuffer = new byte[0];
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final boolean configure(int i, int i2, int i3) throws AudioProcessor.UnhandledFormatException {
+        if (i3 != 2) {
+            throw new AudioProcessor.UnhandledFormatException(i, i2, i3);
+        }
+        this.channelCount = i2;
+        this.sampleRateHz = i;
+        int i4 = this.trimEndFrames;
+        this.endBuffer = new byte[i4 * i2 * 2];
+        this.endBufferSize = 0;
+        int i5 = this.trimStartFrames;
+        this.pendingTrimStartBytes = i2 * i5 * 2;
+        boolean z = this.isActive;
+        boolean z2 = (i5 == 0 && i4 == 0) ? false : true;
+        this.isActive = z2;
+        return z != z2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void queueInput(ByteBuffer byteBuffer) {
+        int position = byteBuffer.position();
+        int limit = byteBuffer.limit();
+        int i = limit - position;
+        int min = Math.min(i, this.pendingTrimStartBytes);
+        this.pendingTrimStartBytes -= min;
+        byteBuffer.position(position + min);
+        if (this.pendingTrimStartBytes > 0) {
+            return;
+        }
+        int i2 = i - min;
+        int length = (this.endBufferSize + i2) - this.endBuffer.length;
+        if (this.buffer.capacity() < length) {
+            this.buffer = ByteBuffer.allocateDirect(length).order(ByteOrder.nativeOrder());
+        } else {
+            this.buffer.clear();
+        }
+        int constrainValue = Util.constrainValue(length, 0, this.endBufferSize);
+        this.buffer.put(this.endBuffer, 0, constrainValue);
+        int constrainValue2 = Util.constrainValue(length - constrainValue, 0, i2);
+        byteBuffer.limit(byteBuffer.position() + constrainValue2);
+        this.buffer.put(byteBuffer);
+        byteBuffer.limit(limit);
+        int i3 = i2 - constrainValue2;
+        int i4 = this.endBufferSize - constrainValue;
+        this.endBufferSize = i4;
+        byte[] bArr = this.endBuffer;
+        System.arraycopy(bArr, constrainValue, bArr, 0, i4);
+        byteBuffer.get(this.endBuffer, this.endBufferSize, i3);
+        this.endBufferSize += i3;
+        this.buffer.flip();
+        this.outputBuffer = this.buffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.audio.AudioProcessor
+    public final void reset() {
+        flush();
+        this.buffer = AudioProcessor.EMPTY_BUFFER;
+        this.channelCount = -1;
+        this.sampleRateHz = -1;
+        this.endBuffer = new byte[0];
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/Buffer.java

@@ -0,0 +1,38 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public abstract class Buffer {
+    private int flags;
+
+    public final void addFlag(int i) {
+        this.flags = i | this.flags;
+    }
+
+    public void clear() {
+        this.flags = 0;
+    }
+
+    public final void clearFlag(int i) {
+        this.flags = (~i) & this.flags;
+    }
+
+    public final boolean getFlag(int i) {
+        return (this.flags & i) == i;
+    }
+
+    public final void setFlags(int i) {
+        this.flags = i;
+    }
+
+    public final boolean isDecodeOnly() {
+        return getFlag(Integer.MIN_VALUE);
+    }
+
+    public final boolean isEndOfStream() {
+        return getFlag(4);
+    }
+
+    public final boolean isKeyFrame() {
+        return getFlag(1);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/CryptoInfo.java

@@ -0,0 +1,83 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import android.annotation.TargetApi;
+import android.media.MediaCodec;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+
+/* loaded from: classes4.dex */
+public final class CryptoInfo {
+    public int clearBlocks;
+    public int encryptedBlocks;
+    private final MediaCodec.CryptoInfo frameworkCryptoInfo;
+    public byte[] iv;
+    public byte[] key;
+    public int mode;
+    public int[] numBytesOfClearData;
+    public int[] numBytesOfEncryptedData;
+    public int numSubSamples;
+    private final PatternHolderV24 patternHolder;
+
+    @TargetApi(16)
+    public final MediaCodec.CryptoInfo getFrameworkCryptoInfoV16() {
+        return this.frameworkCryptoInfo;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    public CryptoInfo() {
+        int i = Util.SDK_INT;
+        Object[] objArr = 0;
+        MediaCodec.CryptoInfo newFrameworkCryptoInfoV16 = i >= 16 ? newFrameworkCryptoInfoV16() : null;
+        this.frameworkCryptoInfo = newFrameworkCryptoInfoV16;
+        this.patternHolder = i >= 24 ? new PatternHolderV24(newFrameworkCryptoInfoV16) : null;
+    }
+
+    public final void set(int i, int[] iArr, int[] iArr2, byte[] bArr, byte[] bArr2, int i2, int i3, int i4) {
+        this.numSubSamples = i;
+        this.numBytesOfClearData = iArr;
+        this.numBytesOfEncryptedData = iArr2;
+        this.key = bArr;
+        this.iv = bArr2;
+        this.mode = i2;
+        this.encryptedBlocks = i3;
+        this.clearBlocks = i4;
+        if (Util.SDK_INT >= 16) {
+            updateFrameworkCryptoInfoV16();
+        }
+    }
+
+    @TargetApi(16)
+    private MediaCodec.CryptoInfo newFrameworkCryptoInfoV16() {
+        return new MediaCodec.CryptoInfo();
+    }
+
+    @TargetApi(16)
+    private void updateFrameworkCryptoInfoV16() {
+        MediaCodec.CryptoInfo cryptoInfo = this.frameworkCryptoInfo;
+        cryptoInfo.numSubSamples = this.numSubSamples;
+        cryptoInfo.numBytesOfClearData = this.numBytesOfClearData;
+        cryptoInfo.numBytesOfEncryptedData = this.numBytesOfEncryptedData;
+        cryptoInfo.key = this.key;
+        cryptoInfo.iv = this.iv;
+        cryptoInfo.mode = this.mode;
+        if (Util.SDK_INT >= 24) {
+            this.patternHolder.set(this.encryptedBlocks, this.clearBlocks);
+        }
+    }
+
+    @TargetApi(24)
+    public static final class PatternHolderV24 {
+        private final MediaCodec.CryptoInfo frameworkCryptoInfo;
+        private final MediaCodec.CryptoInfo.Pattern pattern;
+
+        private PatternHolderV24(MediaCodec.CryptoInfo cryptoInfo) {
+            this.frameworkCryptoInfo = cryptoInfo;
+            this.pattern = new MediaCodec.CryptoInfo.Pattern(0, 0);
+        }
+
+        /* JADX INFO: Access modifiers changed from: private */
+        public void set(int i, int i2) {
+            this.pattern.set(i, i2);
+            this.frameworkCryptoInfo.setPattern(this.pattern);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/Decoder.java

@@ -0,0 +1,18 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.lang.Exception;
+
+/* loaded from: classes4.dex */
+public interface Decoder<I, O, E extends Exception> {
+    I dequeueInputBuffer() throws Exception;
+
+    O dequeueOutputBuffer() throws Exception;
+
+    void flush();
+
+    String getName();
+
+    void queueInputBuffer(I i) throws Exception;
+
+    void release();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/DecoderCounters.java

@@ -0,0 +1,29 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public final class DecoderCounters {
+    public int decoderInitCount;
+    public int decoderReleaseCount;
+    public int droppedBufferCount;
+    public int droppedToKeyframeCount;
+    public int inputBufferCount;
+    public int maxConsecutiveDroppedBufferCount;
+    public int renderedOutputBufferCount;
+    public int skippedInputBufferCount;
+    public int skippedOutputBufferCount;
+
+    public final synchronized void ensureUpdated() {
+    }
+
+    public final void merge(DecoderCounters decoderCounters) {
+        this.decoderInitCount += decoderCounters.decoderInitCount;
+        this.decoderReleaseCount += decoderCounters.decoderReleaseCount;
+        this.inputBufferCount += decoderCounters.inputBufferCount;
+        this.skippedInputBufferCount += decoderCounters.skippedInputBufferCount;
+        this.renderedOutputBufferCount += decoderCounters.renderedOutputBufferCount;
+        this.skippedOutputBufferCount += decoderCounters.skippedOutputBufferCount;
+        this.droppedBufferCount += decoderCounters.droppedBufferCount;
+        this.maxConsecutiveDroppedBufferCount = Math.max(this.maxConsecutiveDroppedBufferCount, decoderCounters.maxConsecutiveDroppedBufferCount);
+        this.droppedToKeyframeCount += decoderCounters.droppedToKeyframeCount;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/DecoderInputBuffer.java

@@ -0,0 +1,82 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.nio.ByteBuffer;
+
+/* loaded from: classes4.dex */
+public class DecoderInputBuffer extends Buffer {
+    public static final int BUFFER_REPLACEMENT_MODE_DIRECT = 2;
+    public static final int BUFFER_REPLACEMENT_MODE_DISABLED = 0;
+    public static final int BUFFER_REPLACEMENT_MODE_NORMAL = 1;
+    private final int bufferReplacementMode;
+    public final CryptoInfo cryptoInfo = new CryptoInfo();
+    public ByteBuffer data;
+    public long timeUs;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface BufferReplacementMode {
+    }
+
+    public final boolean isFlagsOnly() {
+        return this.data == null && this.bufferReplacementMode == 0;
+    }
+
+    public static DecoderInputBuffer newFlagsOnlyInstance() {
+        return new DecoderInputBuffer(0);
+    }
+
+    public DecoderInputBuffer(int i) {
+        this.bufferReplacementMode = i;
+    }
+
+    public void ensureSpaceForWrite(int i) throws IllegalStateException {
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer == null) {
+            this.data = createReplacementByteBuffer(i);
+            return;
+        }
+        int capacity = byteBuffer.capacity();
+        int position = this.data.position();
+        int i2 = i + position;
+        if (capacity >= i2) {
+            return;
+        }
+        ByteBuffer createReplacementByteBuffer = createReplacementByteBuffer(i2);
+        if (position > 0) {
+            this.data.position(0);
+            this.data.limit(position);
+            createReplacementByteBuffer.put(this.data);
+        }
+        this.data = createReplacementByteBuffer;
+    }
+
+    public final boolean isEncrypted() {
+        return getFlag(1073741824);
+    }
+
+    public final void flip() {
+        this.data.flip();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Buffer
+    public void clear() {
+        super.clear();
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer != null) {
+            byteBuffer.clear();
+        }
+    }
+
+    private ByteBuffer createReplacementByteBuffer(int i) {
+        int i2 = this.bufferReplacementMode;
+        if (i2 == 1) {
+            return ByteBuffer.allocate(i);
+        }
+        if (i2 == 2) {
+            return ByteBuffer.allocateDirect(i);
+        }
+        ByteBuffer byteBuffer = this.data;
+        throw new IllegalStateException("Buffer too small (" + (byteBuffer == null ? 0 : byteBuffer.capacity()) + " < " + i + ")");
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/OutputBuffer.java

@@ -0,0 +1,9 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+/* loaded from: classes4.dex */
+public abstract class OutputBuffer extends Buffer {
+    public int skippedOutputBufferCount;
+    public long timeUs;
+
+    public abstract void release();
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/SimpleDecoder.java

@@ -0,0 +1,249 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.DecoderInputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.lang.Exception;
+import java.util.ArrayDeque;
+
+/* loaded from: classes4.dex */
+public abstract class SimpleDecoder<I extends DecoderInputBuffer, O extends OutputBuffer, E extends Exception> implements Decoder<I, O, E> {
+    private int availableInputBufferCount;
+    private final I[] availableInputBuffers;
+    private int availableOutputBufferCount;
+    private final O[] availableOutputBuffers;
+    private final Thread decodeThread;
+    private I dequeuedInputBuffer;
+    private E exception;
+    private boolean flushed;
+    private final Object lock = new Object();
+    private final ArrayDeque<I> queuedInputBuffers = new ArrayDeque<>();
+    private final ArrayDeque<O> queuedOutputBuffers = new ArrayDeque<>();
+    private boolean released;
+    private int skippedOutputBufferCount;
+
+    public abstract I createInputBuffer();
+
+    public abstract O createOutputBuffer();
+
+    public abstract E createUnexpectedDecodeException(Throwable th);
+
+    public abstract E decode(I i, O o, boolean z);
+
+    public SimpleDecoder(I[] iArr, O[] oArr) {
+        this.availableInputBuffers = iArr;
+        this.availableInputBufferCount = iArr.length;
+        for (int i = 0; i < this.availableInputBufferCount; i++) {
+            this.availableInputBuffers[i] = createInputBuffer();
+        }
+        this.availableOutputBuffers = oArr;
+        this.availableOutputBufferCount = oArr.length;
+        for (int i2 = 0; i2 < this.availableOutputBufferCount; i2++) {
+            this.availableOutputBuffers[i2] = createOutputBuffer();
+        }
+        Thread thread = new Thread() { // from class: com.mbridge.msdk.playercommon.exoplayer2.decoder.SimpleDecoder.1
+            @Override // java.lang.Thread, java.lang.Runnable
+            public void run() {
+                SimpleDecoder.this.run();
+            }
+        };
+        this.decodeThread = thread;
+        thread.start();
+    }
+
+    public final void setInitialInputBufferSize(int i) {
+        Assertions.checkState(this.availableInputBufferCount == this.availableInputBuffers.length);
+        for (I i2 : this.availableInputBuffers) {
+            i2.ensureSpaceForWrite(i);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final I dequeueInputBuffer() throws Exception {
+        I i;
+        synchronized (this.lock) {
+            maybeThrowException();
+            Assertions.checkState(this.dequeuedInputBuffer == null);
+            int i2 = this.availableInputBufferCount;
+            if (i2 == 0) {
+                i = null;
+            } else {
+                I[] iArr = this.availableInputBuffers;
+                int i3 = i2 - 1;
+                this.availableInputBufferCount = i3;
+                i = iArr[i3];
+            }
+            this.dequeuedInputBuffer = i;
+        }
+        return i;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void queueInputBuffer(I i) throws Exception {
+        synchronized (this.lock) {
+            maybeThrowException();
+            Assertions.checkArgument(i == this.dequeuedInputBuffer);
+            this.queuedInputBuffers.addLast(i);
+            maybeNotifyDecodeLoop();
+            this.dequeuedInputBuffer = null;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final O dequeueOutputBuffer() throws Exception {
+        synchronized (this.lock) {
+            try {
+                maybeThrowException();
+                if (this.queuedOutputBuffers.isEmpty()) {
+                    return null;
+                }
+                return this.queuedOutputBuffers.removeFirst();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public void releaseOutputBuffer(O o) {
+        synchronized (this.lock) {
+            releaseOutputBufferInternal(o);
+            maybeNotifyDecodeLoop();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public final void flush() {
+        synchronized (this.lock) {
+            try {
+                this.flushed = true;
+                this.skippedOutputBufferCount = 0;
+                I i = this.dequeuedInputBuffer;
+                if (i != null) {
+                    releaseInputBufferInternal(i);
+                    this.dequeuedInputBuffer = null;
+                }
+                while (!this.queuedInputBuffers.isEmpty()) {
+                    releaseInputBufferInternal(this.queuedInputBuffers.removeFirst());
+                }
+                while (!this.queuedOutputBuffers.isEmpty()) {
+                    releaseOutputBufferInternal(this.queuedOutputBuffers.removeFirst());
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Decoder
+    public void release() {
+        synchronized (this.lock) {
+            this.released = true;
+            this.lock.notify();
+        }
+        try {
+            this.decodeThread.join();
+        } catch (InterruptedException unused) {
+            Thread.currentThread().interrupt();
+        }
+    }
+
+    private void maybeThrowException() throws Exception {
+        E e = this.exception;
+        if (e != null) {
+            throw e;
+        }
+    }
+
+    private void maybeNotifyDecodeLoop() {
+        if (canDecodeBuffer()) {
+            this.lock.notify();
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void run() {
+        do {
+            try {
+            } catch (InterruptedException e) {
+                throw new IllegalStateException(e);
+            }
+        } while (decode());
+    }
+
+    private boolean decode() throws InterruptedException {
+        synchronized (this.lock) {
+            while (!this.released && !canDecodeBuffer()) {
+                try {
+                    this.lock.wait();
+                } finally {
+                }
+            }
+            if (this.released) {
+                return false;
+            }
+            I removeFirst = this.queuedInputBuffers.removeFirst();
+            O[] oArr = this.availableOutputBuffers;
+            int i = this.availableOutputBufferCount - 1;
+            this.availableOutputBufferCount = i;
+            O o = oArr[i];
+            boolean z = this.flushed;
+            this.flushed = false;
+            if (removeFirst.isEndOfStream()) {
+                o.addFlag(4);
+            } else {
+                if (removeFirst.isDecodeOnly()) {
+                    o.addFlag(Integer.MIN_VALUE);
+                }
+                try {
+                    this.exception = decode(removeFirst, o, z);
+                } catch (OutOfMemoryError e) {
+                    this.exception = createUnexpectedDecodeException(e);
+                } catch (RuntimeException e2) {
+                    this.exception = createUnexpectedDecodeException(e2);
+                }
+                if (this.exception != null) {
+                    synchronized (this.lock) {
+                    }
+                    return false;
+                }
+            }
+            synchronized (this.lock) {
+                try {
+                    if (this.flushed) {
+                        releaseOutputBufferInternal(o);
+                    } else if (o.isDecodeOnly()) {
+                        this.skippedOutputBufferCount++;
+                        releaseOutputBufferInternal(o);
+                    } else {
+                        o.skippedOutputBufferCount = this.skippedOutputBufferCount;
+                        this.skippedOutputBufferCount = 0;
+                        this.queuedOutputBuffers.addLast(o);
+                    }
+                    releaseInputBufferInternal(removeFirst);
+                } finally {
+                }
+            }
+            return true;
+        }
+    }
+
+    private boolean canDecodeBuffer() {
+        return !this.queuedInputBuffers.isEmpty() && this.availableOutputBufferCount > 0;
+    }
+
+    private void releaseInputBufferInternal(I i) {
+        i.clear();
+        I[] iArr = this.availableInputBuffers;
+        int i2 = this.availableInputBufferCount;
+        this.availableInputBufferCount = i2 + 1;
+        iArr[i2] = i;
+    }
+
+    private void releaseOutputBufferInternal(O o) {
+        o.clear();
+        O[] oArr = this.availableOutputBuffers;
+        int i = this.availableOutputBufferCount;
+        this.availableOutputBufferCount = i + 1;
+        oArr[i] = o;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/decoder/SimpleOutputBuffer.java

@@ -0,0 +1,39 @@
+package com.mbridge.msdk.playercommon.exoplayer2.decoder;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/* loaded from: classes4.dex */
+public class SimpleOutputBuffer extends OutputBuffer {
+    public ByteBuffer data;
+    private final SimpleDecoder<?, SimpleOutputBuffer, ?> owner;
+
+    public SimpleOutputBuffer(SimpleDecoder<?, SimpleOutputBuffer, ?> simpleDecoder) {
+        this.owner = simpleDecoder;
+    }
+
+    public ByteBuffer init(long j, int i) {
+        this.timeUs = j;
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer == null || byteBuffer.capacity() < i) {
+            this.data = ByteBuffer.allocateDirect(i).order(ByteOrder.nativeOrder());
+        }
+        this.data.position(0);
+        this.data.limit(i);
+        return this.data;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.Buffer
+    public void clear() {
+        super.clear();
+        ByteBuffer byteBuffer = this.data;
+        if (byteBuffer != null) {
+            byteBuffer.clear();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.decoder.OutputBuffer
+    public void release() {
+        this.owner.releaseOutputBuffer(this);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ClearKeyUtil.java

@@ -0,0 +1,57 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.util.Log;
+import com.mbridge.msdk.foundation.entity.CampaignEx;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/* loaded from: classes4.dex */
+final class ClearKeyUtil {
+    private static final String TAG = "ClearKeyUtil";
+
+    private ClearKeyUtil() {
+    }
+
+    public static byte[] adjustRequestData(byte[] bArr) {
+        return Util.SDK_INT >= 27 ? bArr : Util.getUtf8Bytes(base64ToBase64Url(Util.fromUtf8Bytes(bArr)));
+    }
+
+    public static byte[] adjustResponseData(byte[] bArr) {
+        if (Util.SDK_INT >= 27) {
+            return bArr;
+        }
+        try {
+            JSONObject jSONObject = new JSONObject(Util.fromUtf8Bytes(bArr));
+            StringBuilder sb = new StringBuilder("{\"keys\":[");
+            JSONArray jSONArray = jSONObject.getJSONArray("keys");
+            for (int i = 0; i < jSONArray.length(); i++) {
+                if (i != 0) {
+                    sb.append(",");
+                }
+                JSONObject jSONObject2 = jSONArray.getJSONObject(i);
+                sb.append("{\"k\":\"");
+                sb.append(base64UrlToBase64(jSONObject2.getString(CampaignEx.JSON_KEY_AD_K)));
+                sb.append("\",\"kid\":\"");
+                sb.append(base64UrlToBase64(jSONObject2.getString("kid")));
+                sb.append("\",\"kty\":\"");
+                sb.append(jSONObject2.getString("kty"));
+                sb.append("\"}");
+            }
+            sb.append("]}");
+            return Util.getUtf8Bytes(sb.toString());
+        } catch (JSONException e) {
+            Log.e(TAG, "Failed to adjust response data: " + Util.fromUtf8Bytes(bArr), e);
+            return bArr;
+        }
+    }
+
+    private static String base64ToBase64Url(String str) {
+        return str.replace('+', '-').replace('/', '_');
+    }
+
+    private static String base64UrlToBase64(String str) {
+        return str.replace('-', '+').replace('_', '/');
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DecryptionException.java

@@ -0,0 +1,11 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public class DecryptionException extends Exception {
+    public final int errorCode;
+
+    public DecryptionException(int i, String str) {
+        super(str);
+        this.errorCode = i;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSession.java

@@ -0,0 +1,444 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.NotProvisionedException;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.util.Log;
+import android.util.Pair;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+class DefaultDrmSession<T extends ExoMediaCrypto> implements DrmSession<T> {
+    private static final int MAX_LICENSE_DURATION_TO_RENEW = 60;
+    private static final int MSG_KEYS = 1;
+    private static final int MSG_PROVISION = 0;
+    private static final String TAG = "DefaultDrmSession";
+    final MediaDrmCallback callback;
+    private Object currentKeyRequest;
+    private Object currentProvisionRequest;
+    private final DefaultDrmSessionEventListener.EventDispatcher eventDispatcher;
+    private final int initialDrmRequestRetryCount;
+    private DrmSession.DrmSessionException lastException;
+    private T mediaCrypto;
+    private final ExoMediaDrm<T> mediaDrm;
+    private final int mode;
+    private byte[] offlineLicenseKeySetId;
+    private int openCount;
+    private final HashMap<String, String> optionalKeyRequestParameters;
+    private DefaultDrmSession<T>.PostRequestHandler postRequestHandler;
+    final DefaultDrmSession<T>.PostResponseHandler postResponseHandler;
+    private final ProvisioningManager<T> provisioningManager;
+    private HandlerThread requestHandlerThread;
+    private final DrmInitData.SchemeData schemeData;
+    private byte[] sessionId;
+    private int state;
+    final UUID uuid;
+
+    public interface ProvisioningManager<T extends ExoMediaCrypto> {
+        void onProvisionCompleted();
+
+        void onProvisionError(Exception exc);
+
+        void provisionRequired(DefaultDrmSession<T> defaultDrmSession);
+    }
+
+    private boolean isOpen() {
+        int i = this.state;
+        return i == 3 || i == 4;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final DrmSession.DrmSessionException getError() {
+        if (this.state == 1) {
+            return this.lastException;
+        }
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final T getMediaCrypto() {
+        return this.mediaCrypto;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public byte[] getOfflineLicenseKeySetId() {
+        return this.offlineLicenseKeySetId;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final int getState() {
+        return this.state;
+    }
+
+    public DefaultDrmSession(UUID uuid, ExoMediaDrm<T> exoMediaDrm, ProvisioningManager<T> provisioningManager, @Nullable DrmInitData.SchemeData schemeData, int i, @Nullable byte[] bArr, HashMap<String, String> hashMap, MediaDrmCallback mediaDrmCallback, Looper looper, DefaultDrmSessionEventListener.EventDispatcher eventDispatcher, int i2) {
+        this.uuid = uuid;
+        this.provisioningManager = provisioningManager;
+        this.mediaDrm = exoMediaDrm;
+        this.mode = i;
+        this.offlineLicenseKeySetId = bArr;
+        this.schemeData = bArr != null ? null : schemeData;
+        this.optionalKeyRequestParameters = hashMap;
+        this.callback = mediaDrmCallback;
+        this.initialDrmRequestRetryCount = i2;
+        this.eventDispatcher = eventDispatcher;
+        this.state = 2;
+        this.postResponseHandler = new PostResponseHandler(looper);
+        HandlerThread handlerThread = new HandlerThread("DrmRequestHandler");
+        this.requestHandlerThread = handlerThread;
+        handlerThread.start();
+        this.postRequestHandler = new PostRequestHandler(this.requestHandlerThread.getLooper());
+    }
+
+    public void acquire() {
+        int i = this.openCount + 1;
+        this.openCount = i;
+        if (i == 1 && this.state != 1 && openInternal(true)) {
+            doLicense(true);
+        }
+    }
+
+    public boolean release() {
+        int i = this.openCount - 1;
+        this.openCount = i;
+        if (i != 0) {
+            return false;
+        }
+        this.state = 0;
+        this.postResponseHandler.removeCallbacksAndMessages(null);
+        this.postRequestHandler.removeCallbacksAndMessages(null);
+        this.postRequestHandler = null;
+        this.requestHandlerThread.quit();
+        this.requestHandlerThread = null;
+        this.mediaCrypto = null;
+        this.lastException = null;
+        this.currentKeyRequest = null;
+        this.currentProvisionRequest = null;
+        byte[] bArr = this.sessionId;
+        if (bArr != null) {
+            this.mediaDrm.closeSession(bArr);
+            this.sessionId = null;
+        }
+        return true;
+    }
+
+    public boolean hasInitData(byte[] bArr) {
+        DrmInitData.SchemeData schemeData = this.schemeData;
+        return Arrays.equals(schemeData != null ? schemeData.data : null, bArr);
+    }
+
+    public boolean hasSessionId(byte[] bArr) {
+        return Arrays.equals(this.sessionId, bArr);
+    }
+
+    public void onMediaDrmEvent(int i) {
+        if (isOpen()) {
+            if (i == 1) {
+                this.state = 3;
+                this.provisioningManager.provisionRequired(this);
+            } else if (i == 2) {
+                doLicense(false);
+            } else {
+                if (i != 3) {
+                    return;
+                }
+                onKeysExpired();
+            }
+        }
+    }
+
+    public void provision() {
+        ExoMediaDrm.ProvisionRequest provisionRequest = this.mediaDrm.getProvisionRequest();
+        this.currentProvisionRequest = provisionRequest;
+        this.postRequestHandler.post(0, provisionRequest, true);
+    }
+
+    public void onProvisionCompleted() {
+        if (openInternal(false)) {
+            doLicense(true);
+        }
+    }
+
+    public void onProvisionError(Exception exc) {
+        onError(exc);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public Map<String, String> queryKeyStatus() {
+        byte[] bArr = this.sessionId;
+        if (bArr == null) {
+            return null;
+        }
+        return this.mediaDrm.queryKeyStatus(bArr);
+    }
+
+    private boolean openInternal(boolean z) {
+        if (isOpen()) {
+            return true;
+        }
+        try {
+            byte[] openSession = this.mediaDrm.openSession();
+            this.sessionId = openSession;
+            this.mediaCrypto = this.mediaDrm.createMediaCrypto(openSession);
+            this.state = 3;
+            return true;
+        } catch (NotProvisionedException e) {
+            if (z) {
+                this.provisioningManager.provisionRequired(this);
+                return false;
+            }
+            onError(e);
+            return false;
+        } catch (Exception e2) {
+            onError(e2);
+            return false;
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onProvisionResponse(Object obj, Object obj2) {
+        if (obj == this.currentProvisionRequest) {
+            if (this.state == 2 || isOpen()) {
+                this.currentProvisionRequest = null;
+                if (obj2 instanceof Exception) {
+                    this.provisioningManager.onProvisionError((Exception) obj2);
+                    return;
+                }
+                try {
+                    this.mediaDrm.provideProvisionResponse((byte[]) obj2);
+                    this.provisioningManager.onProvisionCompleted();
+                } catch (Exception e) {
+                    this.provisioningManager.onProvisionError(e);
+                }
+            }
+        }
+    }
+
+    private void doLicense(boolean z) {
+        int i = this.mode;
+        if (i != 0 && i != 1) {
+            if (i != 2) {
+                if (i == 3 && restoreKeys()) {
+                    postKeyRequest(3, z);
+                    return;
+                }
+                return;
+            }
+            if (this.offlineLicenseKeySetId == null) {
+                postKeyRequest(2, z);
+                return;
+            } else {
+                if (restoreKeys()) {
+                    postKeyRequest(2, z);
+                    return;
+                }
+                return;
+            }
+        }
+        if (this.offlineLicenseKeySetId == null) {
+            postKeyRequest(1, z);
+            return;
+        }
+        if (this.state == 4 || restoreKeys()) {
+            long licenseDurationRemainingSec = getLicenseDurationRemainingSec();
+            if (this.mode == 0 && licenseDurationRemainingSec <= 60) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("Offline license has expired or will expire soon. Remaining seconds: ");
+                sb.append(licenseDurationRemainingSec);
+                postKeyRequest(2, z);
+                return;
+            }
+            if (licenseDurationRemainingSec <= 0) {
+                onError(new KeysExpiredException());
+            } else {
+                this.state = 4;
+                this.eventDispatcher.drmKeysRestored();
+            }
+        }
+    }
+
+    private boolean restoreKeys() {
+        try {
+            this.mediaDrm.restoreKeys(this.sessionId, this.offlineLicenseKeySetId);
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "Error trying to restore Widevine keys.", e);
+            onError(e);
+            return false;
+        }
+    }
+
+    private long getLicenseDurationRemainingSec() {
+        if (!C.WIDEVINE_UUID.equals(this.uuid)) {
+            return Long.MAX_VALUE;
+        }
+        Pair<Long, Long> licenseDurationRemainingSec = WidevineUtil.getLicenseDurationRemainingSec(this);
+        return Math.min(((Long) licenseDurationRemainingSec.first).longValue(), ((Long) licenseDurationRemainingSec.second).longValue());
+    }
+
+    private void postKeyRequest(int i, boolean z) {
+        String str;
+        byte[] bArr;
+        String str2;
+        byte[] bArr2 = i == 3 ? this.offlineLicenseKeySetId : this.sessionId;
+        DrmInitData.SchemeData schemeData = this.schemeData;
+        if (schemeData != null) {
+            byte[] bArr3 = schemeData.data;
+            String str3 = schemeData.mimeType;
+            str = schemeData.licenseServerUrl;
+            str2 = str3;
+            bArr = bArr3;
+        } else {
+            str = null;
+            bArr = null;
+            str2 = null;
+        }
+        try {
+            Pair create = Pair.create(this.mediaDrm.getKeyRequest(bArr2, bArr, str2, i, this.optionalKeyRequestParameters), str);
+            this.currentKeyRequest = create;
+            this.postRequestHandler.post(1, create, z);
+        } catch (Exception e) {
+            onKeysError(e);
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public void onKeyResponse(Object obj, Object obj2) {
+        if (obj == this.currentKeyRequest && isOpen()) {
+            this.currentKeyRequest = null;
+            if (obj2 instanceof Exception) {
+                onKeysError((Exception) obj2);
+                return;
+            }
+            try {
+                byte[] bArr = (byte[]) obj2;
+                if (this.mode == 3) {
+                    this.mediaDrm.provideKeyResponse(this.offlineLicenseKeySetId, bArr);
+                    this.eventDispatcher.drmKeysRemoved();
+                    return;
+                }
+                byte[] provideKeyResponse = this.mediaDrm.provideKeyResponse(this.sessionId, bArr);
+                int i = this.mode;
+                if ((i == 2 || (i == 0 && this.offlineLicenseKeySetId != null)) && provideKeyResponse != null && provideKeyResponse.length != 0) {
+                    this.offlineLicenseKeySetId = provideKeyResponse;
+                }
+                this.state = 4;
+                this.eventDispatcher.drmKeysLoaded();
+            } catch (Exception e) {
+                onKeysError(e);
+            }
+        }
+    }
+
+    private void onKeysExpired() {
+        if (this.state == 4) {
+            this.state = 3;
+            onError(new KeysExpiredException());
+        }
+    }
+
+    private void onKeysError(Exception exc) {
+        if (exc instanceof NotProvisionedException) {
+            this.provisioningManager.provisionRequired(this);
+        } else {
+            onError(exc);
+        }
+    }
+
+    private void onError(Exception exc) {
+        this.lastException = new DrmSession.DrmSessionException(exc);
+        this.eventDispatcher.drmSessionManagerError(exc);
+        if (this.state != 4) {
+            this.state = 1;
+        }
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class PostResponseHandler extends Handler {
+        public PostResponseHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            Pair pair = (Pair) message.obj;
+            Object obj = pair.first;
+            Object obj2 = pair.second;
+            int i = message.what;
+            if (i == 0) {
+                DefaultDrmSession.this.onProvisionResponse(obj, obj2);
+            } else {
+                if (i != 1) {
+                    return;
+                }
+                DefaultDrmSession.this.onKeyResponse(obj, obj2);
+            }
+        }
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class PostRequestHandler extends Handler {
+        public PostRequestHandler(Looper looper) {
+            super(looper);
+        }
+
+        public void post(int i, Object obj, boolean z) {
+            obtainMessage(i, z ? 1 : 0, 0, obj).sendToTarget();
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            Object obj = message.obj;
+            try {
+                int i = message.what;
+                if (i == 0) {
+                    DefaultDrmSession defaultDrmSession = DefaultDrmSession.this;
+                    e = defaultDrmSession.callback.executeProvisionRequest(defaultDrmSession.uuid, (ExoMediaDrm.ProvisionRequest) obj);
+                } else if (i == 1) {
+                    Pair pair = (Pair) obj;
+                    ExoMediaDrm.KeyRequest keyRequest = (ExoMediaDrm.KeyRequest) pair.first;
+                    String str = (String) pair.second;
+                    DefaultDrmSession defaultDrmSession2 = DefaultDrmSession.this;
+                    e = defaultDrmSession2.callback.executeKeyRequest(defaultDrmSession2.uuid, keyRequest, str);
+                } else {
+                    throw new RuntimeException();
+                }
+            } catch (Exception e) {
+                e = e;
+                if (maybeRetryRequest(message)) {
+                    return;
+                }
+            }
+            DefaultDrmSession.this.postResponseHandler.obtainMessage(message.what, Pair.create(obj, e)).sendToTarget();
+        }
+
+        private boolean maybeRetryRequest(Message message) {
+            int i;
+            if (message.arg1 != 1 || (i = message.arg2 + 1) > DefaultDrmSession.this.initialDrmRequestRetryCount) {
+                return false;
+            }
+            Message obtain = Message.obtain(message);
+            obtain.arg2 = i;
+            sendMessageDelayed(obtain, getRetryDelayMillis(i));
+            return true;
+        }
+
+        private long getRetryDelayMillis(int i) {
+            return Math.min((i - 1) * 1000, 5000);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSessionEventListener.java

@@ -0,0 +1,102 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.Handler;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Iterator;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/* loaded from: classes4.dex */
+public interface DefaultDrmSessionEventListener {
+    void onDrmKeysLoaded();
+
+    void onDrmKeysRemoved();
+
+    void onDrmKeysRestored();
+
+    void onDrmSessionManagerError(Exception exc);
+
+    public static final class EventDispatcher {
+        private final CopyOnWriteArrayList<HandlerAndListener> listeners = new CopyOnWriteArrayList<>();
+
+        public final void addListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+            Assertions.checkArgument((handler == null || defaultDrmSessionEventListener == null) ? false : true);
+            this.listeners.add(new HandlerAndListener(handler, defaultDrmSessionEventListener));
+        }
+
+        public final void removeListener(DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                if (next.listener == defaultDrmSessionEventListener) {
+                    this.listeners.remove(next);
+                }
+            }
+        }
+
+        public final void drmKeysLoaded() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.1
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysLoaded();
+                    }
+                });
+            }
+        }
+
+        public final void drmSessionManagerError(final Exception exc) {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.2
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmSessionManagerError(exc);
+                    }
+                });
+            }
+        }
+
+        public final void drmKeysRestored() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.3
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysRestored();
+                    }
+                });
+            }
+        }
+
+        public final void drmKeysRemoved() {
+            Iterator<HandlerAndListener> it = this.listeners.iterator();
+            while (it.hasNext()) {
+                HandlerAndListener next = it.next();
+                final DefaultDrmSessionEventListener defaultDrmSessionEventListener = next.listener;
+                next.handler.post(new Runnable() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener.EventDispatcher.4
+                    @Override // java.lang.Runnable
+                    public void run() {
+                        defaultDrmSessionEventListener.onDrmKeysRemoved();
+                    }
+                });
+            }
+        }
+
+        public static final class HandlerAndListener {
+            public final Handler handler;
+            public final DefaultDrmSessionEventListener listener;
+
+            public HandlerAndListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+                this.handler = handler;
+                this.listener = defaultDrmSessionEventListener;
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DefaultDrmSessionManager.java

@@ -0,0 +1,376 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Message;
+import android.text.TextUtils;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import com.ironsource.mediationsdk.metadata.a;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.PsshAtomUtil;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+public class DefaultDrmSessionManager<T extends ExoMediaCrypto> implements DefaultDrmSession.ProvisioningManager<T>, DrmSessionManager<T> {
+    public static final int INITIAL_DRM_REQUEST_RETRY_COUNT = 3;
+    public static final int MODE_DOWNLOAD = 2;
+    public static final int MODE_PLAYBACK = 0;
+    public static final int MODE_QUERY = 1;
+    public static final int MODE_RELEASE = 3;
+    public static final String PLAYREADY_CUSTOM_DATA_KEY = "PRCustomData";
+    private static final String TAG = "DefaultDrmSessionMgr";
+    private final MediaDrmCallback callback;
+    private final DefaultDrmSessionEventListener.EventDispatcher eventDispatcher;
+    private final int initialDrmRequestRetryCount;
+    private final ExoMediaDrm<T> mediaDrm;
+    volatile DefaultDrmSessionManager<T>.MediaDrmHandler mediaDrmHandler;
+    private int mode;
+    private final boolean multiSession;
+    private byte[] offlineLicenseKeySetId;
+    private final HashMap<String, String> optionalKeyRequestParameters;
+    private Looper playbackLooper;
+    private final List<DefaultDrmSession<T>> provisioningSessions;
+    private final List<DefaultDrmSession<T>> sessions;
+    private final UUID uuid;
+
+    @Deprecated
+    public interface EventListener extends DefaultDrmSessionEventListener {
+    }
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Mode {
+    }
+
+    public static final class MissingSchemeDataException extends Exception {
+        private MissingSchemeDataException(UUID uuid) {
+            super("Media does not support uuid: " + uuid);
+        }
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance(MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance = newWidevineInstance(mediaDrmCallback, hashMap);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newWidevineInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newWidevineInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newWidevineInstance(MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        return newFrameworkInstance(C.WIDEVINE_UUID, mediaDrmCallback, hashMap);
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance(MediaDrmCallback mediaDrmCallback, String str, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance = newPlayReadyInstance(mediaDrmCallback, str);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newPlayReadyInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newPlayReadyInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newPlayReadyInstance(MediaDrmCallback mediaDrmCallback, String str) throws UnsupportedDrmException {
+        HashMap hashMap;
+        if (TextUtils.isEmpty(str)) {
+            hashMap = null;
+        } else {
+            hashMap = new HashMap();
+            hashMap.put(PLAYREADY_CUSTOM_DATA_KEY, str);
+        }
+        return newFrameworkInstance(C.PLAYREADY_UUID, mediaDrmCallback, hashMap);
+    }
+
+    @Deprecated
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance(UUID uuid, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) throws UnsupportedDrmException {
+        DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance = newFrameworkInstance(uuid, mediaDrmCallback, hashMap);
+        if (handler != null && defaultDrmSessionEventListener != null) {
+            newFrameworkInstance.addListener(handler, defaultDrmSessionEventListener);
+        }
+        return newFrameworkInstance;
+    }
+
+    public static DefaultDrmSessionManager<FrameworkMediaCrypto> newFrameworkInstance(UUID uuid, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        return new DefaultDrmSessionManager<>(uuid, (ExoMediaDrm) FrameworkMediaDrm.newInstance(uuid), mediaDrmCallback, hashMap, false, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) {
+        this(uuid, (ExoMediaDrm) exoMediaDrm, mediaDrmCallback, hashMap, false, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener, boolean z) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, boolean z) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z, 3);
+    }
+
+    @Deprecated
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener, boolean z, int i) {
+        this(uuid, exoMediaDrm, mediaDrmCallback, hashMap, z, i);
+        if (handler == null || defaultDrmSessionEventListener == null) {
+            return;
+        }
+        addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public DefaultDrmSessionManager(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap, boolean z, int i) {
+        Assertions.checkNotNull(uuid);
+        Assertions.checkNotNull(exoMediaDrm);
+        Assertions.checkArgument(!C.COMMON_PSSH_UUID.equals(uuid), "Use C.CLEARKEY_UUID instead");
+        this.uuid = uuid;
+        this.mediaDrm = exoMediaDrm;
+        this.callback = mediaDrmCallback;
+        this.optionalKeyRequestParameters = hashMap;
+        this.eventDispatcher = new DefaultDrmSessionEventListener.EventDispatcher();
+        this.multiSession = z;
+        this.initialDrmRequestRetryCount = i;
+        this.mode = 0;
+        this.sessions = new ArrayList();
+        this.provisioningSessions = new ArrayList();
+        if (z) {
+            exoMediaDrm.setPropertyString("sessionSharing", a.j);
+        }
+        exoMediaDrm.setOnEventListener(new MediaDrmEventListener());
+    }
+
+    public final void addListener(Handler handler, DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this.eventDispatcher.addListener(handler, defaultDrmSessionEventListener);
+    }
+
+    public final void removeListener(DefaultDrmSessionEventListener defaultDrmSessionEventListener) {
+        this.eventDispatcher.removeListener(defaultDrmSessionEventListener);
+    }
+
+    public final String getPropertyString(String str) {
+        return this.mediaDrm.getPropertyString(str);
+    }
+
+    public final void setPropertyString(String str, String str2) {
+        this.mediaDrm.setPropertyString(str, str2);
+    }
+
+    public final byte[] getPropertyByteArray(String str) {
+        return this.mediaDrm.getPropertyByteArray(str);
+    }
+
+    public final void setPropertyByteArray(String str, byte[] bArr) {
+        this.mediaDrm.setPropertyByteArray(str, bArr);
+    }
+
+    public void setMode(int i, byte[] bArr) {
+        Assertions.checkState(this.sessions.isEmpty());
+        if (i == 1 || i == 3) {
+            Assertions.checkNotNull(bArr);
+        }
+        this.mode = i;
+        this.offlineLicenseKeySetId = bArr;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public boolean canAcquireSession(@NonNull DrmInitData drmInitData) {
+        if (this.offlineLicenseKeySetId != null) {
+            return true;
+        }
+        if (getSchemeData(drmInitData, this.uuid, true) == null) {
+            if (drmInitData.schemeDataCount != 1 || !drmInitData.get(0).matches(C.COMMON_PSSH_UUID)) {
+                return false;
+            }
+            Log.w(TAG, "DrmInitData only contains common PSSH SchemeData. Assuming support for: " + this.uuid);
+        }
+        String str = drmInitData.schemeType;
+        if (str == null || C.CENC_TYPE_cenc.equals(str)) {
+            return true;
+        }
+        return !(C.CENC_TYPE_cbc1.equals(str) || C.CENC_TYPE_cbcs.equals(str) || C.CENC_TYPE_cens.equals(str)) || Util.SDK_INT >= 25;
+    }
+
+    /* JADX WARN: Multi-variable type inference failed */
+    /* JADX WARN: Type inference failed for: r2v0, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionManager$1] */
+    /* JADX WARN: Type inference failed for: r2v1 */
+    /* JADX WARN: Type inference failed for: r2v12 */
+    /* JADX WARN: Type inference failed for: r2v2 */
+    /* JADX WARN: Type inference failed for: r2v3, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession, com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession<T extends com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto>] */
+    /* JADX WARN: Type inference failed for: r2v5 */
+    /* JADX WARN: Type inference failed for: r2v7, types: [com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession] */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public DrmSession<T> acquireSession(Looper looper, DrmInitData drmInitData) {
+        DrmInitData.SchemeData schemeData;
+        Looper looper2 = this.playbackLooper;
+        Assertions.checkState(looper2 == null || looper2 == looper);
+        if (this.sessions.isEmpty()) {
+            this.playbackLooper = looper;
+            if (this.mediaDrmHandler == null) {
+                this.mediaDrmHandler = new MediaDrmHandler(looper);
+            }
+        }
+        DefaultDrmSession<T> defaultDrmSession = 0;
+        defaultDrmSession = 0;
+        if (this.offlineLicenseKeySetId == null) {
+            DrmInitData.SchemeData schemeData2 = getSchemeData(drmInitData, this.uuid, false);
+            if (schemeData2 == null) {
+                MissingSchemeDataException missingSchemeDataException = new MissingSchemeDataException(this.uuid);
+                this.eventDispatcher.drmSessionManagerError(missingSchemeDataException);
+                return new ErrorStateDrmSession(new DrmSession.DrmSessionException(missingSchemeDataException));
+            }
+            schemeData = schemeData2;
+        } else {
+            schemeData = null;
+        }
+        if (!this.multiSession) {
+            if (!this.sessions.isEmpty()) {
+                defaultDrmSession = this.sessions.get(0);
+            }
+        } else {
+            byte[] bArr = schemeData != null ? schemeData.data : null;
+            Iterator<DefaultDrmSession<T>> it = this.sessions.iterator();
+            while (true) {
+                if (!it.hasNext()) {
+                    break;
+                }
+                DefaultDrmSession<T> next = it.next();
+                if (next.hasInitData(bArr)) {
+                    defaultDrmSession = next;
+                    break;
+                }
+            }
+        }
+        if (defaultDrmSession == 0) {
+            DefaultDrmSession<T> defaultDrmSession2 = new DefaultDrmSession<>(this.uuid, this.mediaDrm, this, schemeData, this.mode, this.offlineLicenseKeySetId, this.optionalKeyRequestParameters, this.callback, looper, this.eventDispatcher, this.initialDrmRequestRetryCount);
+            this.sessions.add(defaultDrmSession2);
+            defaultDrmSession = defaultDrmSession2;
+        }
+        ((DefaultDrmSession) defaultDrmSession).acquire();
+        return (DrmSession<T>) defaultDrmSession;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSessionManager
+    public void releaseSession(DrmSession<T> drmSession) {
+        if (drmSession instanceof ErrorStateDrmSession) {
+            return;
+        }
+        DefaultDrmSession<T> defaultDrmSession = (DefaultDrmSession) drmSession;
+        if (defaultDrmSession.release()) {
+            this.sessions.remove(defaultDrmSession);
+            if (this.provisioningSessions.size() > 1 && this.provisioningSessions.get(0) == defaultDrmSession) {
+                this.provisioningSessions.get(1).provision();
+            }
+            this.provisioningSessions.remove(defaultDrmSession);
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void provisionRequired(DefaultDrmSession<T> defaultDrmSession) {
+        this.provisioningSessions.add(defaultDrmSession);
+        if (this.provisioningSessions.size() == 1) {
+            defaultDrmSession.provision();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void onProvisionCompleted() {
+        Iterator<DefaultDrmSession<T>> it = this.provisioningSessions.iterator();
+        while (it.hasNext()) {
+            it.next().onProvisionCompleted();
+        }
+        this.provisioningSessions.clear();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSession.ProvisioningManager
+    public void onProvisionError(Exception exc) {
+        Iterator<DefaultDrmSession<T>> it = this.provisioningSessions.iterator();
+        while (it.hasNext()) {
+            it.next().onProvisionError(exc);
+        }
+        this.provisioningSessions.clear();
+    }
+
+    private static DrmInitData.SchemeData getSchemeData(DrmInitData drmInitData, UUID uuid, boolean z) {
+        ArrayList arrayList = new ArrayList(drmInitData.schemeDataCount);
+        for (int i = 0; i < drmInitData.schemeDataCount; i++) {
+            DrmInitData.SchemeData schemeData = drmInitData.get(i);
+            if ((schemeData.matches(uuid) || (C.CLEARKEY_UUID.equals(uuid) && schemeData.matches(C.COMMON_PSSH_UUID))) && (schemeData.data != null || z)) {
+                arrayList.add(schemeData);
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        if (C.WIDEVINE_UUID.equals(uuid)) {
+            for (int i2 = 0; i2 < arrayList.size(); i2++) {
+                DrmInitData.SchemeData schemeData2 = (DrmInitData.SchemeData) arrayList.get(i2);
+                int parseVersion = schemeData2.hasData() ? PsshAtomUtil.parseVersion(schemeData2.data) : -1;
+                int i3 = Util.SDK_INT;
+                if (i3 < 23 && parseVersion == 0) {
+                    return schemeData2;
+                }
+                if (i3 >= 23 && parseVersion == 1) {
+                    return schemeData2;
+                }
+            }
+        }
+        return (DrmInitData.SchemeData) arrayList.get(0);
+    }
+
+    @SuppressLint({"HandlerLeak"})
+    public class MediaDrmHandler extends Handler {
+        public MediaDrmHandler(Looper looper) {
+            super(looper);
+        }
+
+        @Override // android.os.Handler
+        public void handleMessage(Message message) {
+            byte[] bArr = (byte[]) message.obj;
+            for (DefaultDrmSession defaultDrmSession : DefaultDrmSessionManager.this.sessions) {
+                if (defaultDrmSession.hasSessionId(bArr)) {
+                    defaultDrmSession.onMediaDrmEvent(message.what);
+                    return;
+                }
+            }
+        }
+    }
+
+    public class MediaDrmEventListener implements ExoMediaDrm.OnEventListener<T> {
+        private MediaDrmEventListener() {
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.OnEventListener
+        public void onEvent(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, int i, int i2, byte[] bArr2) {
+            if (DefaultDrmSessionManager.this.mode == 0) {
+                DefaultDrmSessionManager.this.mediaDrmHandler.obtainMessage(i, bArr).sendToTarget();
+            }
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmInitData.java

@@ -0,0 +1,260 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class DrmInitData implements Parcelable, Comparator<SchemeData> {
+    public static final Parcelable.Creator<DrmInitData> CREATOR = new Parcelable.Creator<DrmInitData>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData.1
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public DrmInitData createFromParcel(Parcel parcel) {
+            return new DrmInitData(parcel);
+        }
+
+        /* JADX WARN: Can't rename method to resolve collision */
+        @Override // android.os.Parcelable.Creator
+        public DrmInitData[] newArray(int i) {
+            return new DrmInitData[i];
+        }
+    };
+    private int hashCode;
+    public final int schemeDataCount;
+    private final SchemeData[] schemeDatas;
+
+    @Nullable
+    public final String schemeType;
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    @Nullable
+    public static DrmInitData createSessionCreationData(@Nullable DrmInitData drmInitData, @Nullable DrmInitData drmInitData2) {
+        String str;
+        ArrayList arrayList = new ArrayList();
+        if (drmInitData != null) {
+            str = drmInitData.schemeType;
+            for (SchemeData schemeData : drmInitData.schemeDatas) {
+                if (schemeData.hasData()) {
+                    arrayList.add(schemeData);
+                }
+            }
+        } else {
+            str = null;
+        }
+        if (drmInitData2 != null) {
+            if (str == null) {
+                str = drmInitData2.schemeType;
+            }
+            int size = arrayList.size();
+            for (SchemeData schemeData2 : drmInitData2.schemeDatas) {
+                if (schemeData2.hasData() && !containsSchemeDataWithUuid(arrayList, size, schemeData2.uuid)) {
+                    arrayList.add(schemeData2);
+                }
+            }
+        }
+        if (arrayList.isEmpty()) {
+            return null;
+        }
+        return new DrmInitData(str, arrayList);
+    }
+
+    public DrmInitData(List<SchemeData> list) {
+        this(null, false, (SchemeData[]) list.toArray(new SchemeData[list.size()]));
+    }
+
+    public DrmInitData(String str, List<SchemeData> list) {
+        this(str, false, (SchemeData[]) list.toArray(new SchemeData[list.size()]));
+    }
+
+    public DrmInitData(SchemeData... schemeDataArr) {
+        this((String) null, schemeDataArr);
+    }
+
+    public DrmInitData(@Nullable String str, SchemeData... schemeDataArr) {
+        this(str, true, schemeDataArr);
+    }
+
+    private DrmInitData(@Nullable String str, boolean z, SchemeData... schemeDataArr) {
+        this.schemeType = str;
+        schemeDataArr = z ? (SchemeData[]) schemeDataArr.clone() : schemeDataArr;
+        Arrays.sort(schemeDataArr, this);
+        this.schemeDatas = schemeDataArr;
+        this.schemeDataCount = schemeDataArr.length;
+    }
+
+    public DrmInitData(Parcel parcel) {
+        this.schemeType = parcel.readString();
+        SchemeData[] schemeDataArr = (SchemeData[]) parcel.createTypedArray(SchemeData.CREATOR);
+        this.schemeDatas = schemeDataArr;
+        this.schemeDataCount = schemeDataArr.length;
+    }
+
+    @Deprecated
+    public final SchemeData get(UUID uuid) {
+        for (SchemeData schemeData : this.schemeDatas) {
+            if (schemeData.matches(uuid)) {
+                return schemeData;
+            }
+        }
+        return null;
+    }
+
+    public final SchemeData get(int i) {
+        return this.schemeDatas[i];
+    }
+
+    public final DrmInitData copyWithSchemeType(@Nullable String str) {
+        return Util.areEqual(this.schemeType, str) ? this : new DrmInitData(str, false, this.schemeDatas);
+    }
+
+    public final int hashCode() {
+        if (this.hashCode == 0) {
+            String str = this.schemeType;
+            this.hashCode = ((str == null ? 0 : str.hashCode()) * 31) + Arrays.hashCode(this.schemeDatas);
+        }
+        return this.hashCode;
+    }
+
+    @Override // java.util.Comparator
+    public final boolean equals(@Nullable Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || DrmInitData.class != obj.getClass()) {
+            return false;
+        }
+        DrmInitData drmInitData = (DrmInitData) obj;
+        return Util.areEqual(this.schemeType, drmInitData.schemeType) && Arrays.equals(this.schemeDatas, drmInitData.schemeDatas);
+    }
+
+    @Override // java.util.Comparator
+    public final int compare(SchemeData schemeData, SchemeData schemeData2) {
+        UUID uuid = C.UUID_NIL;
+        if (uuid.equals(schemeData.uuid)) {
+            return uuid.equals(schemeData2.uuid) ? 0 : 1;
+        }
+        return schemeData.uuid.compareTo(schemeData2.uuid);
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel parcel, int i) {
+        parcel.writeString(this.schemeType);
+        parcel.writeTypedArray(this.schemeDatas, 0);
+    }
+
+    private static boolean containsSchemeDataWithUuid(ArrayList<SchemeData> arrayList, int i, UUID uuid) {
+        for (int i2 = 0; i2 < i; i2++) {
+            if (arrayList.get(i2).uuid.equals(uuid)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static final class SchemeData implements Parcelable {
+        public static final Parcelable.Creator<SchemeData> CREATOR = new Parcelable.Creator<SchemeData>() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.DrmInitData.SchemeData.1
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SchemeData createFromParcel(Parcel parcel) {
+                return new SchemeData(parcel);
+            }
+
+            /* JADX WARN: Can't rename method to resolve collision */
+            @Override // android.os.Parcelable.Creator
+            public SchemeData[] newArray(int i) {
+                return new SchemeData[i];
+            }
+        };
+        public final byte[] data;
+        private int hashCode;
+
+        @Nullable
+        public final String licenseServerUrl;
+        public final String mimeType;
+        public final boolean requiresSecureDecryption;
+        private final UUID uuid;
+
+        @Override // android.os.Parcelable
+        public final int describeContents() {
+            return 0;
+        }
+
+        public final boolean hasData() {
+            return this.data != null;
+        }
+
+        public SchemeData(UUID uuid, String str, byte[] bArr) {
+            this(uuid, str, bArr, false);
+        }
+
+        public SchemeData(UUID uuid, String str, byte[] bArr, boolean z) {
+            this(uuid, null, str, bArr, z);
+        }
+
+        public SchemeData(UUID uuid, @Nullable String str, String str2, byte[] bArr, boolean z) {
+            this.uuid = (UUID) Assertions.checkNotNull(uuid);
+            this.licenseServerUrl = str;
+            this.mimeType = (String) Assertions.checkNotNull(str2);
+            this.data = bArr;
+            this.requiresSecureDecryption = z;
+        }
+
+        public SchemeData(Parcel parcel) {
+            this.uuid = new UUID(parcel.readLong(), parcel.readLong());
+            this.licenseServerUrl = parcel.readString();
+            this.mimeType = parcel.readString();
+            this.data = parcel.createByteArray();
+            this.requiresSecureDecryption = parcel.readByte() != 0;
+        }
+
+        public final boolean matches(UUID uuid) {
+            return C.UUID_NIL.equals(this.uuid) || uuid.equals(this.uuid);
+        }
+
+        public final boolean canReplace(SchemeData schemeData) {
+            return hasData() && !schemeData.hasData() && matches(schemeData.uuid);
+        }
+
+        public final boolean equals(@Nullable Object obj) {
+            if (!(obj instanceof SchemeData)) {
+                return false;
+            }
+            if (obj == this) {
+                return true;
+            }
+            SchemeData schemeData = (SchemeData) obj;
+            return Util.areEqual(this.licenseServerUrl, schemeData.licenseServerUrl) && Util.areEqual(this.mimeType, schemeData.mimeType) && Util.areEqual(this.uuid, schemeData.uuid) && Arrays.equals(this.data, schemeData.data);
+        }
+
+        public final int hashCode() {
+            if (this.hashCode == 0) {
+                int hashCode = this.uuid.hashCode() * 31;
+                String str = this.licenseServerUrl;
+                this.hashCode = ((((hashCode + (str == null ? 0 : str.hashCode())) * 31) + this.mimeType.hashCode()) * 31) + Arrays.hashCode(this.data);
+            }
+            return this.hashCode;
+        }
+
+        @Override // android.os.Parcelable
+        public final void writeToParcel(Parcel parcel, int i) {
+            parcel.writeLong(this.uuid.getMostSignificantBits());
+            parcel.writeLong(this.uuid.getLeastSignificantBits());
+            parcel.writeString(this.licenseServerUrl);
+            parcel.writeString(this.mimeType);
+            parcel.writeByteArray(this.data);
+            parcel.writeByte(this.requiresSecureDecryption ? (byte) 1 : (byte) 0);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmSession.java

@@ -0,0 +1,37 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Map;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public interface DrmSession<T extends ExoMediaCrypto> {
+    public static final int STATE_ERROR = 1;
+    public static final int STATE_OPENED = 3;
+    public static final int STATE_OPENED_WITH_KEYS = 4;
+    public static final int STATE_OPENING = 2;
+    public static final int STATE_RELEASED = 0;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface State {
+    }
+
+    DrmSessionException getError();
+
+    T getMediaCrypto();
+
+    byte[] getOfflineLicenseKeySetId();
+
+    int getState();
+
+    Map<String, String> queryKeyStatus();
+
+    public static class DrmSessionException extends Exception {
+        public DrmSessionException(Throwable th) {
+            super(th);
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/DrmSessionManager.java

@@ -0,0 +1,15 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.os.Looper;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public interface DrmSessionManager<T extends ExoMediaCrypto> {
+    DrmSession<T> acquireSession(Looper looper, DrmInitData drmInitData);
+
+    boolean canAcquireSession(DrmInitData drmInitData);
+
+    void releaseSession(DrmSession<T> drmSession);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ErrorStateDrmSession.java

@@ -0,0 +1,40 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class ErrorStateDrmSession<T extends ExoMediaCrypto> implements DrmSession<T> {
+    private final DrmSession.DrmSessionException error;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final DrmSession.DrmSessionException getError() {
+        return this.error;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final T getMediaCrypto() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final byte[] getOfflineLicenseKeySetId() {
+        return null;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final int getState() {
+        return 1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession
+    public final Map<String, String> queryKeyStatus() {
+        return null;
+    }
+
+    public ErrorStateDrmSession(DrmSession.DrmSessionException drmSessionException) {
+        this.error = (DrmSession.DrmSessionException) Assertions.checkNotNull(drmSessionException);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ExoMediaCrypto.java

@@ -0,0 +1,6 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public interface ExoMediaCrypto {
+    boolean requiresSecureDecoderComponent(String str);
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/ExoMediaDrm.java

@@ -0,0 +1,139 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.media.DeniedByServerException;
+import android.media.MediaCryptoException;
+import android.media.MediaDrmException;
+import android.media.NotProvisionedException;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public interface ExoMediaDrm<T extends ExoMediaCrypto> {
+    public static final int EVENT_KEY_EXPIRED = 3;
+    public static final int EVENT_KEY_REQUIRED = 2;
+    public static final int EVENT_PROVISION_REQUIRED = 1;
+    public static final int KEY_TYPE_OFFLINE = 2;
+    public static final int KEY_TYPE_RELEASE = 3;
+    public static final int KEY_TYPE_STREAMING = 1;
+
+    public interface KeyRequest {
+        byte[] getData();
+
+        String getDefaultUrl();
+    }
+
+    public interface KeyStatus {
+        byte[] getKeyId();
+
+        int getStatusCode();
+    }
+
+    public interface OnEventListener<T extends ExoMediaCrypto> {
+        void onEvent(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, int i, int i2, @Nullable byte[] bArr2);
+    }
+
+    public interface OnKeyStatusChangeListener<T extends ExoMediaCrypto> {
+        void onKeyStatusChange(ExoMediaDrm<? extends T> exoMediaDrm, byte[] bArr, List<KeyStatus> list, boolean z);
+    }
+
+    public interface ProvisionRequest {
+        byte[] getData();
+
+        String getDefaultUrl();
+    }
+
+    void closeSession(byte[] bArr);
+
+    T createMediaCrypto(byte[] bArr) throws MediaCryptoException;
+
+    KeyRequest getKeyRequest(byte[] bArr, byte[] bArr2, String str, int i, HashMap<String, String> hashMap) throws NotProvisionedException;
+
+    byte[] getPropertyByteArray(String str);
+
+    String getPropertyString(String str);
+
+    ProvisionRequest getProvisionRequest();
+
+    byte[] openSession() throws MediaDrmException;
+
+    byte[] provideKeyResponse(byte[] bArr, byte[] bArr2) throws NotProvisionedException, DeniedByServerException;
+
+    void provideProvisionResponse(byte[] bArr) throws DeniedByServerException;
+
+    Map<String, String> queryKeyStatus(byte[] bArr);
+
+    void release();
+
+    void restoreKeys(byte[] bArr, byte[] bArr2);
+
+    void setOnEventListener(OnEventListener<? super T> onEventListener);
+
+    void setOnKeyStatusChangeListener(OnKeyStatusChangeListener<? super T> onKeyStatusChangeListener);
+
+    void setPropertyByteArray(String str, byte[] bArr);
+
+    void setPropertyString(String str, String str2);
+
+    public static final class DefaultKeyStatus implements KeyStatus {
+        private final byte[] keyId;
+        private final int statusCode;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyStatus
+        public final byte[] getKeyId() {
+            return this.keyId;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyStatus
+        public final int getStatusCode() {
+            return this.statusCode;
+        }
+
+        public DefaultKeyStatus(int i, byte[] bArr) {
+            this.statusCode = i;
+            this.keyId = bArr;
+        }
+    }
+
+    public static final class DefaultKeyRequest implements KeyRequest {
+        private final byte[] data;
+        private final String defaultUrl;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest
+        public final byte[] getData() {
+            return this.data;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest
+        public final String getDefaultUrl() {
+            return this.defaultUrl;
+        }
+
+        public DefaultKeyRequest(byte[] bArr, String str) {
+            this.data = bArr;
+            this.defaultUrl = str;
+        }
+    }
+
+    public static final class DefaultProvisionRequest implements ProvisionRequest {
+        private final byte[] data;
+        private final String defaultUrl;
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.ProvisionRequest
+        public final byte[] getData() {
+            return this.data;
+        }
+
+        @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.ProvisionRequest
+        public final String getDefaultUrl() {
+            return this.defaultUrl;
+        }
+
+        public DefaultProvisionRequest(byte[] bArr, String str) {
+            this.data = bArr;
+            this.defaultUrl = str;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/FrameworkMediaCrypto.java

@@ -0,0 +1,30 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.media.MediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+
+@TargetApi(16)
+/* loaded from: classes4.dex */
+public final class FrameworkMediaCrypto implements ExoMediaCrypto {
+    private final boolean forceAllowInsecureDecoderComponents;
+    private final MediaCrypto mediaCrypto;
+
+    public final MediaCrypto getWrappedMediaCrypto() {
+        return this.mediaCrypto;
+    }
+
+    public FrameworkMediaCrypto(MediaCrypto mediaCrypto) {
+        this(mediaCrypto, false);
+    }
+
+    public FrameworkMediaCrypto(MediaCrypto mediaCrypto, boolean z) {
+        this.mediaCrypto = (MediaCrypto) Assertions.checkNotNull(mediaCrypto);
+        this.forceAllowInsecureDecoderComponents = z;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto
+    public final boolean requiresSecureDecoderComponent(String str) {
+        return !this.forceAllowInsecureDecoderComponents && this.mediaCrypto.requiresSecureDecoderComponent(str);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/FrameworkMediaDrm.java

@@ -0,0 +1,243 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
+import android.media.DeniedByServerException;
+import android.media.MediaCrypto;
+import android.media.MediaCryptoException;
+import android.media.MediaDrm;
+import android.media.MediaDrmException;
+import android.media.NotProvisionedException;
+import android.media.UnsupportedSchemeException;
+import android.os.Handler;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(23)
+/* loaded from: classes4.dex */
+public final class FrameworkMediaDrm implements ExoMediaDrm<FrameworkMediaCrypto> {
+    private static final String CENC_SCHEME_MIME_TYPE = "cenc";
+    private final MediaDrm mediaDrm;
+    private final UUID uuid;
+
+    public static FrameworkMediaDrm newInstance(UUID uuid) throws UnsupportedDrmException {
+        try {
+            return new FrameworkMediaDrm(uuid);
+        } catch (UnsupportedSchemeException e) {
+            throw new UnsupportedDrmException(1, e);
+        } catch (Exception e2) {
+            throw new UnsupportedDrmException(2, e2);
+        }
+    }
+
+    @SuppressLint({"WrongConstant"})
+    private FrameworkMediaDrm(UUID uuid) throws UnsupportedSchemeException {
+        Assertions.checkNotNull(uuid);
+        UUID uuid2 = C.COMMON_PSSH_UUID;
+        Assertions.checkArgument(!uuid2.equals(uuid), "Use C.CLEARKEY_UUID instead");
+        if (Util.SDK_INT < 27 && C.CLEARKEY_UUID.equals(uuid)) {
+            uuid = uuid2;
+        }
+        this.uuid = uuid;
+        MediaDrm mediaDrm = new MediaDrm(uuid);
+        this.mediaDrm = mediaDrm;
+        if (C.WIDEVINE_UUID.equals(uuid) && needsForceL3Workaround()) {
+            mediaDrm.setPropertyString("securityLevel", "L3");
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setOnEventListener(final ExoMediaDrm.OnEventListener<? super FrameworkMediaCrypto> onEventListener) {
+        this.mediaDrm.setOnEventListener(onEventListener == null ? null : new MediaDrm.OnEventListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.1
+            @Override // android.media.MediaDrm.OnEventListener
+            public void onEvent(@NonNull MediaDrm mediaDrm, @Nullable byte[] bArr, int i, int i2, byte[] bArr2) {
+                onEventListener.onEvent(FrameworkMediaDrm.this, bArr, i, i2, bArr2);
+            }
+        });
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setOnKeyStatusChangeListener(final ExoMediaDrm.OnKeyStatusChangeListener<? super FrameworkMediaCrypto> onKeyStatusChangeListener) {
+        if (Util.SDK_INT < 23) {
+            throw new UnsupportedOperationException();
+        }
+        this.mediaDrm.setOnKeyStatusChangeListener(onKeyStatusChangeListener == null ? null : new MediaDrm.OnKeyStatusChangeListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.2
+            @Override // android.media.MediaDrm.OnKeyStatusChangeListener
+            public void onKeyStatusChange(@NonNull MediaDrm mediaDrm, @NonNull byte[] bArr, @NonNull List<MediaDrm.KeyStatus> list, boolean z) {
+                ArrayList arrayList = new ArrayList();
+                for (MediaDrm.KeyStatus keyStatus : list) {
+                    arrayList.add(new ExoMediaDrm.DefaultKeyStatus(keyStatus.getStatusCode(), keyStatus.getKeyId()));
+                }
+                onKeyStatusChangeListener.onKeyStatusChange(FrameworkMediaDrm.this, bArr, arrayList, z);
+            }
+        }, (Handler) null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] openSession() throws MediaDrmException {
+        return this.mediaDrm.openSession();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void closeSession(byte[] bArr) {
+        this.mediaDrm.closeSession(bArr);
+    }
+
+    /* JADX WARN: Code restructure failed: missing block: B:33:0x003c, code lost:
+    
+        if ("AFTM".equals(r1) == false) goto L20;
+     */
+    /* JADX WARN: Removed duplicated region for block: B:10:0x004e  */
+    /* JADX WARN: Removed duplicated region for block: B:19:0x0082  */
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    public final com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm.KeyRequest getKeyRequest(byte[] r9, byte[] r10, java.lang.String r11, int r12, java.util.HashMap<java.lang.String, java.lang.String> r13) throws android.media.NotProvisionedException {
+        /*
+            r8 = this;
+            int r0 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.SDK_INT
+            r1 = 21
+            if (r0 >= r1) goto L10
+            java.util.UUID r1 = com.mbridge.msdk.playercommon.exoplayer2.C.WIDEVINE_UUID
+            java.util.UUID r2 = r8.uuid
+            boolean r1 = r1.equals(r2)
+            if (r1 != 0) goto L3e
+        L10:
+            java.util.UUID r1 = com.mbridge.msdk.playercommon.exoplayer2.C.PLAYREADY_UUID
+            java.util.UUID r2 = r8.uuid
+            boolean r1 = r1.equals(r2)
+            if (r1 == 0) goto L49
+            java.lang.String r1 = "Amazon"
+            java.lang.String r2 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.MANUFACTURER
+            boolean r1 = r1.equals(r2)
+            if (r1 == 0) goto L49
+            java.lang.String r1 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.MODEL
+            java.lang.String r2 = "AFTB"
+            boolean r2 = r2.equals(r1)
+            if (r2 != 0) goto L3e
+            java.lang.String r2 = "AFTS"
+            boolean r2 = r2.equals(r1)
+            if (r2 != 0) goto L3e
+            java.lang.String r2 = "AFTM"
+            boolean r1 = r2.equals(r1)
+            if (r1 == 0) goto L49
+        L3e:
+            java.util.UUID r1 = r8.uuid
+            byte[] r1 = com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.PsshAtomUtil.parseSchemeSpecificData(r10, r1)
+            if (r1 != 0) goto L47
+            goto L49
+        L47:
+            r4 = r1
+            goto L4a
+        L49:
+            r4 = r10
+        L4a:
+            r10 = 26
+            if (r0 >= r10) goto L6a
+            java.util.UUID r10 = com.mbridge.msdk.playercommon.exoplayer2.C.CLEARKEY_UUID
+            java.util.UUID r0 = r8.uuid
+            boolean r10 = r10.equals(r0)
+            if (r10 == 0) goto L6a
+            java.lang.String r10 = "video/mp4"
+            boolean r10 = r10.equals(r11)
+            if (r10 != 0) goto L68
+            java.lang.String r10 = "audio/mp4"
+            boolean r10 = r10.equals(r11)
+            if (r10 == 0) goto L6a
+        L68:
+            java.lang.String r11 = "cenc"
+        L6a:
+            r5 = r11
+            android.media.MediaDrm r2 = r8.mediaDrm
+            r3 = r9
+            r6 = r12
+            r7 = r13
+            android.media.MediaDrm$KeyRequest r9 = r2.getKeyRequest(r3, r4, r5, r6, r7)
+            byte[] r10 = r9.getData()
+            java.util.UUID r11 = com.mbridge.msdk.playercommon.exoplayer2.C.CLEARKEY_UUID
+            java.util.UUID r12 = r8.uuid
+            boolean r11 = r11.equals(r12)
+            if (r11 == 0) goto L86
+            byte[] r10 = com.mbridge.msdk.playercommon.exoplayer2.drm.ClearKeyUtil.adjustRequestData(r10)
+        L86:
+            com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$DefaultKeyRequest r11 = new com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$DefaultKeyRequest
+            java.lang.String r9 = r9.getDefaultUrl()
+            r11.<init>(r10, r9)
+            return r11
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.drm.FrameworkMediaDrm.getKeyRequest(byte[], byte[], java.lang.String, int, java.util.HashMap):com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm$KeyRequest");
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] provideKeyResponse(byte[] bArr, byte[] bArr2) throws NotProvisionedException, DeniedByServerException {
+        if (C.CLEARKEY_UUID.equals(this.uuid)) {
+            bArr2 = ClearKeyUtil.adjustResponseData(bArr2);
+        }
+        return this.mediaDrm.provideKeyResponse(bArr, bArr2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final ExoMediaDrm.ProvisionRequest getProvisionRequest() {
+        MediaDrm.ProvisionRequest provisionRequest = this.mediaDrm.getProvisionRequest();
+        return new ExoMediaDrm.DefaultProvisionRequest(provisionRequest.getData(), provisionRequest.getDefaultUrl());
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void provideProvisionResponse(byte[] bArr) throws DeniedByServerException {
+        this.mediaDrm.provideProvisionResponse(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final Map<String, String> queryKeyStatus(byte[] bArr) {
+        return this.mediaDrm.queryKeyStatus(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void release() {
+        this.mediaDrm.release();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void restoreKeys(byte[] bArr, byte[] bArr2) {
+        this.mediaDrm.restoreKeys(bArr, bArr2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final String getPropertyString(String str) {
+        return this.mediaDrm.getPropertyString(str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final byte[] getPropertyByteArray(String str) {
+        return this.mediaDrm.getPropertyByteArray(str);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setPropertyString(String str, String str2) {
+        this.mediaDrm.setPropertyString(str, str2);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final void setPropertyByteArray(String str, byte[] bArr) {
+        this.mediaDrm.setPropertyByteArray(str, bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm
+    public final FrameworkMediaCrypto createMediaCrypto(byte[] bArr) throws MediaCryptoException {
+        return new FrameworkMediaCrypto(new MediaCrypto(this.uuid, bArr), Util.SDK_INT < 21 && C.WIDEVINE_UUID.equals(this.uuid) && "L3".equals(getPropertyString("securityLevel")));
+    }
+
+    private static boolean needsForceL3Workaround() {
+        return "ASUS_Z00AD".equals(Util.MODEL);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/HttpMediaDrmCallback.java

@@ -0,0 +1,189 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.annotation.TargetApi;
+import android.text.TextUtils;
+import androidx.annotation.Nullable;
+import com.ironsource.nb;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+@TargetApi(18)
+/* loaded from: classes4.dex */
+public final class HttpMediaDrmCallback implements MediaDrmCallback {
+    private static final int MAX_MANUAL_REDIRECTS = 5;
+    private final HttpDataSource.Factory dataSourceFactory;
+    private final String defaultLicenseUrl;
+    private final boolean forceDefaultLicenseUrl;
+    private final Map<String, String> keyRequestProperties;
+
+    public HttpMediaDrmCallback(String str, HttpDataSource.Factory factory) {
+        this(str, false, factory);
+    }
+
+    public HttpMediaDrmCallback(String str, boolean z, HttpDataSource.Factory factory) {
+        this.dataSourceFactory = factory;
+        this.defaultLicenseUrl = str;
+        this.forceDefaultLicenseUrl = z;
+        this.keyRequestProperties = new HashMap();
+    }
+
+    public final void setKeyRequestProperty(String str, String str2) {
+        Assertions.checkNotNull(str);
+        Assertions.checkNotNull(str2);
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.put(str, str2);
+        }
+    }
+
+    public final void clearKeyRequestProperty(String str) {
+        Assertions.checkNotNull(str);
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.remove(str);
+        }
+    }
+
+    public final void clearAllKeyRequestProperties() {
+        synchronized (this.keyRequestProperties) {
+            this.keyRequestProperties.clear();
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws IOException {
+        return executePost(this.dataSourceFactory, provisionRequest.getDefaultUrl() + "&signedRequest=" + Util.fromUtf8Bytes(provisionRequest.getData()), new byte[0], null);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception {
+        String str2;
+        String defaultUrl = keyRequest.getDefaultUrl();
+        if (!TextUtils.isEmpty(defaultUrl)) {
+            str = defaultUrl;
+        }
+        if (this.forceDefaultLicenseUrl || TextUtils.isEmpty(str)) {
+            str = this.defaultLicenseUrl;
+        }
+        HashMap hashMap = new HashMap();
+        UUID uuid2 = C.PLAYREADY_UUID;
+        if (uuid2.equals(uuid)) {
+            str2 = "text/xml";
+        } else {
+            str2 = C.CLEARKEY_UUID.equals(uuid) ? nb.L : "application/octet-stream";
+        }
+        hashMap.put("Content-Type", str2);
+        if (uuid2.equals(uuid)) {
+            hashMap.put("SOAPAction", "http://schemas.microsoft.com/DRM/2007/03/protocols/AcquireLicense");
+        }
+        synchronized (this.keyRequestProperties) {
+            hashMap.putAll(this.keyRequestProperties);
+        }
+        return executePost(this.dataSourceFactory, str, keyRequest.getData(), hashMap);
+    }
+
+    /* JADX WARN: Removed duplicated region for block: B:25:0x006b A[Catch: all -> 0x004f, TRY_LEAVE, TryCatch #1 {all -> 0x004f, blocks: (B:11:0x0047, B:19:0x0053, B:21:0x0059, B:25:0x006b, B:29:0x007c, B:32:0x005f), top: B:10:0x0047, inners: #0 }] */
+    /* JADX WARN: Removed duplicated region for block: B:27:0x0073 A[LOOP:1: B:9:0x002e->B:27:0x0073, LOOP_END] */
+    /* JADX WARN: Removed duplicated region for block: B:28:0x007c A[SYNTHETIC] */
+    /* JADX WARN: Removed duplicated region for block: B:31:0x0070  */
+    /*
+        Code decompiled incorrectly, please refer to instructions dump.
+        To view partially-correct add '--show-bad-code' argument
+    */
+    private static byte[] executePost(com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource.Factory r17, java.lang.String r18, byte[] r19, java.util.Map<java.lang.String, java.lang.String> r20) throws java.io.IOException {
+        /*
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource r1 = r17.createDataSource()
+            if (r20 == 0) goto L2a
+            java.util.Set r0 = r20.entrySet()
+            java.util.Iterator r0 = r0.iterator()
+        Le:
+            boolean r2 = r0.hasNext()
+            if (r2 == 0) goto L2a
+            java.lang.Object r2 = r0.next()
+            java.util.Map$Entry r2 = (java.util.Map.Entry) r2
+            java.lang.Object r3 = r2.getKey()
+            java.lang.String r3 = (java.lang.String) r3
+            java.lang.Object r2 = r2.getValue()
+            java.lang.String r2 = (java.lang.String) r2
+            r1.setRequestProperty(r3, r2)
+            goto Le
+        L2a:
+            r2 = 0
+            r0 = r18
+            r3 = r2
+        L2e:
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec r15 = new com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSpec
+            android.net.Uri r5 = android.net.Uri.parse(r0)
+            r7 = 0
+            r9 = 0
+            r11 = -1
+            r13 = 0
+            r14 = 1
+            r4 = r15
+            r6 = r19
+            r4.<init>(r5, r6, r7, r9, r11, r13, r14)
+            com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSourceInputStream r4 = new com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSourceInputStream
+            r4.<init>(r1, r15)
+            byte[] r0 = com.mbridge.msdk.playercommon.exoplayer2.util.Util.toByteArray(r4)     // Catch: java.lang.Throwable -> L4f com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource.InvalidResponseCodeException -> L51
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            return r0
+        L4f:
+            r0 = move-exception
+            goto L7d
+        L51:
+            r0 = move-exception
+            r5 = r0
+            int r0 = r5.responseCode     // Catch: java.lang.Throwable -> L4f
+            r6 = 307(0x133, float:4.3E-43)
+            if (r0 == r6) goto L5f
+            int r0 = r5.responseCode     // Catch: java.lang.Throwable -> L4f
+            r6 = 308(0x134, float:4.32E-43)
+            if (r0 != r6) goto L67
+        L5f:
+            int r0 = r3 + 1
+            r6 = 5
+            if (r3 >= r6) goto L66
+            r3 = 1
+            goto L69
+        L66:
+            r3 = r0
+        L67:
+            r0 = r3
+            r3 = r2
+        L69:
+            if (r3 == 0) goto L70
+            java.lang.String r3 = getRedirectUrl(r5)     // Catch: java.lang.Throwable -> L4f
+            goto L71
+        L70:
+            r3 = 0
+        L71:
+            if (r3 == 0) goto L7c
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            r16 = r3
+            r3 = r0
+            r0 = r16
+            goto L2e
+        L7c:
+            throw r5     // Catch: java.lang.Throwable -> L4f
+        L7d:
+            com.mbridge.msdk.playercommon.exoplayer2.util.Util.closeQuietly(r4)
+            throw r0
+        */
+        throw new UnsupportedOperationException("Method not decompiled: com.mbridge.msdk.playercommon.exoplayer2.drm.HttpMediaDrmCallback.executePost(com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource$Factory, java.lang.String, byte[], java.util.Map):byte[]");
+    }
+
+    private static String getRedirectUrl(HttpDataSource.InvalidResponseCodeException invalidResponseCodeException) {
+        List<String> list;
+        Map<String, List<String>> map = invalidResponseCodeException.headerFields;
+        if (map == null || (list = map.get("Location")) == null || list.isEmpty()) {
+            return null;
+        }
+        return list.get(0);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/KeysExpiredException.java

@@ -0,0 +1,5 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+/* loaded from: classes4.dex */
+public final class KeysExpiredException extends Exception {
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/LocalMediaDrmCallback.java

@@ -0,0 +1,26 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.io.IOException;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class LocalMediaDrmCallback implements MediaDrmCallback {
+    private final byte[] keyResponse;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception {
+        return this.keyResponse;
+    }
+
+    public LocalMediaDrmCallback(byte[] bArr) {
+        this.keyResponse = (byte[]) Assertions.checkNotNull(bArr);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.MediaDrmCallback
+    public final byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/MediaDrmCallback.java

@@ -0,0 +1,12 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import androidx.annotation.Nullable;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaDrm;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public interface MediaDrmCallback {
+    byte[] executeKeyRequest(UUID uuid, ExoMediaDrm.KeyRequest keyRequest, @Nullable String str) throws Exception;
+
+    byte[] executeProvisionRequest(UUID uuid, ExoMediaDrm.ProvisionRequest provisionRequest) throws Exception;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/OfflineLicenseHelper.java

@@ -0,0 +1,133 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.os.ConditionVariable;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.DrmSession;
+import com.mbridge.msdk.playercommon.exoplayer2.drm.ExoMediaCrypto;
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.HttpDataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import java.util.HashMap;
+import java.util.UUID;
+
+/* loaded from: classes4.dex */
+public final class OfflineLicenseHelper<T extends ExoMediaCrypto> {
+    private final ConditionVariable conditionVariable;
+    private final DefaultDrmSessionManager<T> drmSessionManager;
+    private final HandlerThread handlerThread;
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, HttpDataSource.Factory factory) throws UnsupportedDrmException {
+        return newWidevineInstance(str, false, factory, null);
+    }
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, boolean z, HttpDataSource.Factory factory) throws UnsupportedDrmException {
+        return newWidevineInstance(str, z, factory, null);
+    }
+
+    public static OfflineLicenseHelper<FrameworkMediaCrypto> newWidevineInstance(String str, boolean z, HttpDataSource.Factory factory, HashMap<String, String> hashMap) throws UnsupportedDrmException {
+        UUID uuid = C.WIDEVINE_UUID;
+        return new OfflineLicenseHelper<>(uuid, FrameworkMediaDrm.newInstance(uuid), new HttpMediaDrmCallback(str, z, factory), hashMap);
+    }
+
+    public OfflineLicenseHelper(UUID uuid, ExoMediaDrm<T> exoMediaDrm, MediaDrmCallback mediaDrmCallback, HashMap<String, String> hashMap) {
+        HandlerThread handlerThread = new HandlerThread("OfflineLicenseHelper");
+        this.handlerThread = handlerThread;
+        handlerThread.start();
+        this.conditionVariable = new ConditionVariable();
+        DefaultDrmSessionEventListener defaultDrmSessionEventListener = new DefaultDrmSessionEventListener() { // from class: com.mbridge.msdk.playercommon.exoplayer2.drm.OfflineLicenseHelper.1
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysLoaded() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmSessionManagerError(Exception exc) {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysRestored() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+
+            @Override // com.mbridge.msdk.playercommon.exoplayer2.drm.DefaultDrmSessionEventListener
+            public void onDrmKeysRemoved() {
+                OfflineLicenseHelper.this.conditionVariable.open();
+            }
+        };
+        DefaultDrmSessionManager<T> defaultDrmSessionManager = new DefaultDrmSessionManager<>(uuid, exoMediaDrm, mediaDrmCallback, hashMap);
+        this.drmSessionManager = defaultDrmSessionManager;
+        defaultDrmSessionManager.addListener(new Handler(handlerThread.getLooper()), defaultDrmSessionEventListener);
+    }
+
+    public final synchronized byte[] getPropertyByteArray(String str) {
+        return this.drmSessionManager.getPropertyByteArray(str);
+    }
+
+    public final synchronized void setPropertyByteArray(String str, byte[] bArr) {
+        this.drmSessionManager.setPropertyByteArray(str, bArr);
+    }
+
+    public final synchronized String getPropertyString(String str) {
+        return this.drmSessionManager.getPropertyString(str);
+    }
+
+    public final synchronized void setPropertyString(String str, String str2) {
+        this.drmSessionManager.setPropertyString(str, str2);
+    }
+
+    public final synchronized byte[] downloadLicense(DrmInitData drmInitData) throws DrmSession.DrmSessionException {
+        Assertions.checkArgument(drmInitData != null);
+        return blockingKeyRequest(2, null, drmInitData);
+    }
+
+    public final synchronized byte[] renewLicense(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        return blockingKeyRequest(2, bArr, null);
+    }
+
+    public final synchronized void releaseLicense(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        blockingKeyRequest(3, bArr, null);
+    }
+
+    public final synchronized Pair<Long, Long> getLicenseDurationRemainingSec(byte[] bArr) throws DrmSession.DrmSessionException {
+        Assertions.checkNotNull(bArr);
+        DrmSession<T> openBlockingKeyRequest = openBlockingKeyRequest(1, bArr, null);
+        DrmSession.DrmSessionException error = openBlockingKeyRequest.getError();
+        Pair<Long, Long> licenseDurationRemainingSec = WidevineUtil.getLicenseDurationRemainingSec(openBlockingKeyRequest);
+        this.drmSessionManager.releaseSession(openBlockingKeyRequest);
+        if (error == null) {
+            return licenseDurationRemainingSec;
+        }
+        if (error.getCause() instanceof KeysExpiredException) {
+            return Pair.create(0L, 0L);
+        }
+        throw error;
+    }
+
+    public final void release() {
+        this.handlerThread.quit();
+    }
+
+    private byte[] blockingKeyRequest(int i, byte[] bArr, DrmInitData drmInitData) throws DrmSession.DrmSessionException {
+        DrmSession<T> openBlockingKeyRequest = openBlockingKeyRequest(i, bArr, drmInitData);
+        DrmSession.DrmSessionException error = openBlockingKeyRequest.getError();
+        byte[] offlineLicenseKeySetId = openBlockingKeyRequest.getOfflineLicenseKeySetId();
+        this.drmSessionManager.releaseSession(openBlockingKeyRequest);
+        if (error == null) {
+            return offlineLicenseKeySetId;
+        }
+        throw error;
+    }
+
+    private DrmSession<T> openBlockingKeyRequest(int i, byte[] bArr, DrmInitData drmInitData) {
+        this.drmSessionManager.setMode(i, bArr);
+        this.conditionVariable.close();
+        DrmSession<T> acquireSession = this.drmSessionManager.acquireSession(this.handlerThread.getLooper(), drmInitData);
+        this.conditionVariable.block();
+        return acquireSession;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/UnsupportedDrmException.java

@@ -0,0 +1,24 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/* loaded from: classes4.dex */
+public final class UnsupportedDrmException extends Exception {
+    public static final int REASON_INSTANTIATION_ERROR = 2;
+    public static final int REASON_UNSUPPORTED_SCHEME = 1;
+    public final int reason;
+
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface Reason {
+    }
+
+    public UnsupportedDrmException(int i) {
+        this.reason = i;
+    }
+
+    public UnsupportedDrmException(int i, Exception exc) {
+        super(exc);
+        this.reason = i;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/drm/WidevineUtil.java

@@ -0,0 +1,34 @@
+package com.mbridge.msdk.playercommon.exoplayer2.drm;
+
+import android.util.Pair;
+import com.mbridge.msdk.playercommon.exoplayer2.C;
+import java.util.Map;
+
+/* loaded from: classes4.dex */
+public final class WidevineUtil {
+    public static final String PROPERTY_LICENSE_DURATION_REMAINING = "LicenseDurationRemaining";
+    public static final String PROPERTY_PLAYBACK_DURATION_REMAINING = "PlaybackDurationRemaining";
+
+    private WidevineUtil() {
+    }
+
+    public static Pair<Long, Long> getLicenseDurationRemainingSec(DrmSession<?> drmSession) {
+        Map<String, String> queryKeyStatus = drmSession.queryKeyStatus();
+        if (queryKeyStatus == null) {
+            return null;
+        }
+        return new Pair<>(Long.valueOf(getDurationRemainingSec(queryKeyStatus, PROPERTY_LICENSE_DURATION_REMAINING)), Long.valueOf(getDurationRemainingSec(queryKeyStatus, PROPERTY_PLAYBACK_DURATION_REMAINING)));
+    }
+
+    private static long getDurationRemainingSec(Map<String, String> map, String str) {
+        if (map == null) {
+            return C.TIME_UNSET;
+        }
+        try {
+            String str2 = map.get(str);
+            return str2 != null ? Long.parseLong(str2) : C.TIME_UNSET;
+        } catch (NumberFormatException unused) {
+            return C.TIME_UNSET;
+        }
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ChunkIndex.java

@@ -0,0 +1,58 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class ChunkIndex implements SeekMap {
+    private final long durationUs;
+    public final long[] durationsUs;
+    public final int length;
+    public final long[] offsets;
+    public final int[] sizes;
+    public final long[] timesUs;
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final long getDurationUs() {
+        return this.durationUs;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final boolean isSeekable() {
+        return true;
+    }
+
+    public ChunkIndex(int[] iArr, long[] jArr, long[] jArr2, long[] jArr3) {
+        this.sizes = iArr;
+        this.offsets = jArr;
+        this.durationsUs = jArr2;
+        this.timesUs = jArr3;
+        int length = iArr.length;
+        this.length = length;
+        if (length > 0) {
+            this.durationUs = jArr2[length - 1] + jArr3[length - 1];
+        } else {
+            this.durationUs = 0L;
+        }
+    }
+
+    public final int getChunkIndex(long j) {
+        return Util.binarySearchFloor(this.timesUs, j, true, true);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.SeekMap
+    public final SeekMap.SeekPoints getSeekPoints(long j) {
+        int chunkIndex = getChunkIndex(j);
+        SeekPoint seekPoint = new SeekPoint(this.timesUs[chunkIndex], this.offsets[chunkIndex]);
+        if (seekPoint.timeUs >= j || chunkIndex == this.length - 1) {
+            return new SeekMap.SeekPoints(seekPoint);
+        }
+        int i = chunkIndex + 1;
+        return new SeekMap.SeekPoints(seekPoint, new SeekPoint(this.timesUs[i], this.offsets[i]));
+    }
+
+    public final String toString() {
+        return "ChunkIndex(length=" + this.length + ", sizes=" + Arrays.toString(this.sizes) + ", offsets=" + Arrays.toString(this.offsets) + ", timeUs=" + Arrays.toString(this.timesUs) + ", durationsUs=" + Arrays.toString(this.durationsUs) + ")";
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DefaultExtractorInput.java

@@ -0,0 +1,196 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.upstream.DataSource;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Assertions;
+import com.mbridge.msdk.playercommon.exoplayer2.util.Util;
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.Arrays;
+
+/* loaded from: classes4.dex */
+public final class DefaultExtractorInput implements ExtractorInput {
+    private static final int PEEK_MAX_FREE_SPACE = 524288;
+    private static final int PEEK_MIN_FREE_SPACE_AFTER_RESIZE = 65536;
+    private static final int SCRATCH_SPACE_SIZE = 4096;
+    private final DataSource dataSource;
+    private int peekBufferLength;
+    private int peekBufferPosition;
+    private long position;
+    private final long streamLength;
+    private byte[] peekBuffer = new byte[65536];
+    private final byte[] scratchSpace = new byte[4096];
+
+    private void commitBytesRead(int i) {
+        if (i != -1) {
+            this.position += i;
+        }
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getLength() {
+        return this.streamLength;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getPeekPosition() {
+        return this.position + this.peekBufferPosition;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final long getPosition() {
+        return this.position;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void resetPeekPosition() {
+        this.peekBufferPosition = 0;
+    }
+
+    public DefaultExtractorInput(DataSource dataSource, long j, long j2) {
+        this.dataSource = dataSource;
+        this.position = j;
+        this.streamLength = j2;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final int read(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        int readFromPeekBuffer = readFromPeekBuffer(bArr, i, i2);
+        if (readFromPeekBuffer == 0) {
+            readFromPeekBuffer = readFromDataSource(bArr, i, i2, 0, true);
+        }
+        commitBytesRead(readFromPeekBuffer);
+        return readFromPeekBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean readFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException {
+        int readFromPeekBuffer = readFromPeekBuffer(bArr, i, i2);
+        while (readFromPeekBuffer < i2 && readFromPeekBuffer != -1) {
+            readFromPeekBuffer = readFromDataSource(bArr, i, i2, readFromPeekBuffer, z);
+        }
+        commitBytesRead(readFromPeekBuffer);
+        return readFromPeekBuffer != -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void readFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        readFully(bArr, i, i2, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final int skip(int i) throws IOException, InterruptedException {
+        int skipFromPeekBuffer = skipFromPeekBuffer(i);
+        if (skipFromPeekBuffer == 0) {
+            byte[] bArr = this.scratchSpace;
+            skipFromPeekBuffer = readFromDataSource(bArr, 0, Math.min(i, bArr.length), 0, true);
+        }
+        commitBytesRead(skipFromPeekBuffer);
+        return skipFromPeekBuffer;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean skipFully(int i, boolean z) throws IOException, InterruptedException {
+        int skipFromPeekBuffer = skipFromPeekBuffer(i);
+        while (skipFromPeekBuffer < i && skipFromPeekBuffer != -1) {
+            skipFromPeekBuffer = readFromDataSource(this.scratchSpace, -skipFromPeekBuffer, Math.min(i, this.scratchSpace.length + skipFromPeekBuffer), skipFromPeekBuffer, z);
+        }
+        commitBytesRead(skipFromPeekBuffer);
+        return skipFromPeekBuffer != -1;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void skipFully(int i) throws IOException, InterruptedException {
+        skipFully(i, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean peekFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException {
+        if (!advancePeekPosition(i2, z)) {
+            return false;
+        }
+        System.arraycopy(this.peekBuffer, this.peekBufferPosition - i2, bArr, i, i2);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void peekFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException {
+        peekFully(bArr, i, i2, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final boolean advancePeekPosition(int i, boolean z) throws IOException, InterruptedException {
+        ensureSpaceForPeek(i);
+        int min = Math.min(this.peekBufferLength - this.peekBufferPosition, i);
+        while (min < i) {
+            min = readFromDataSource(this.peekBuffer, this.peekBufferPosition, i, min, z);
+            if (min == -1) {
+                return false;
+            }
+        }
+        int i2 = this.peekBufferPosition + i;
+        this.peekBufferPosition = i2;
+        this.peekBufferLength = Math.max(this.peekBufferLength, i2);
+        return true;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final void advancePeekPosition(int i) throws IOException, InterruptedException {
+        advancePeekPosition(i, false);
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorInput
+    public final <E extends Throwable> void setRetryPosition(long j, E e) throws Throwable {
+        Assertions.checkArgument(j >= 0);
+        this.position = j;
+        throw e;
+    }
+
+    private void ensureSpaceForPeek(int i) {
+        int i2 = this.peekBufferPosition + i;
+        byte[] bArr = this.peekBuffer;
+        if (i2 > bArr.length) {
+            this.peekBuffer = Arrays.copyOf(this.peekBuffer, Util.constrainValue(bArr.length * 2, 65536 + i2, i2 + 524288));
+        }
+    }
+
+    private int skipFromPeekBuffer(int i) {
+        int min = Math.min(this.peekBufferLength, i);
+        updatePeekBuffer(min);
+        return min;
+    }
+
+    private int readFromPeekBuffer(byte[] bArr, int i, int i2) {
+        int i3 = this.peekBufferLength;
+        if (i3 == 0) {
+            return 0;
+        }
+        int min = Math.min(i3, i2);
+        System.arraycopy(this.peekBuffer, 0, bArr, i, min);
+        updatePeekBuffer(min);
+        return min;
+    }
+
+    private void updatePeekBuffer(int i) {
+        int i2 = this.peekBufferLength - i;
+        this.peekBufferLength = i2;
+        this.peekBufferPosition = 0;
+        byte[] bArr = this.peekBuffer;
+        byte[] bArr2 = i2 < bArr.length - 524288 ? new byte[65536 + i2] : bArr;
+        System.arraycopy(bArr, i, bArr2, 0, i2);
+        this.peekBuffer = bArr2;
+    }
+
+    private int readFromDataSource(byte[] bArr, int i, int i2, int i3, boolean z) throws InterruptedException, IOException {
+        if (Thread.interrupted()) {
+            throw new InterruptedException();
+        }
+        int read = this.dataSource.read(bArr, i + i3, i2 - i3);
+        if (read != -1) {
+            return i3 + read;
+        }
+        if (i3 == 0 && z) {
+            return -1;
+        }
+        throw new EOFException();
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DefaultExtractorsFactory.java

@@ -0,0 +1,95 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.amr.AmrExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.flv.FlvExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mkv.MatroskaExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp3.Mp3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.FragmentedMp4Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.mp4.Mp4Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ogg.OggExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.Ac3Extractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.AdtsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.PsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.ts.TsExtractor;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.wav.WavExtractor;
+import java.lang.reflect.Constructor;
+
+/* loaded from: classes4.dex */
+public final class DefaultExtractorsFactory implements ExtractorsFactory {
+    private static final Constructor<? extends Extractor> FLAC_EXTRACTOR_CONSTRUCTOR;
+    private int fragmentedMp4Flags;
+    private int matroskaFlags;
+    private int mp3Flags;
+    private int mp4Flags;
+    private int tsFlags;
+    private int tsMode = 1;
+
+    static {
+        Constructor<? extends Extractor> constructor;
+        try {
+            constructor = Class.forName("com.mbridge.msdk.playercommon.exoplayer2.ext.flac.FlacExtractor").asSubclass(Extractor.class).getConstructor(new Class[0]);
+        } catch (ClassNotFoundException unused) {
+            constructor = null;
+        } catch (Exception e) {
+            throw new RuntimeException("Error instantiating FLAC extension", e);
+        }
+        FLAC_EXTRACTOR_CONSTRUCTOR = constructor;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMatroskaExtractorFlags(int i) {
+        this.matroskaFlags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMp4ExtractorFlags(int i) {
+        this.mp4Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setFragmentedMp4ExtractorFlags(int i) {
+        this.fragmentedMp4Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setMp3ExtractorFlags(int i) {
+        this.mp3Flags = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setTsExtractorMode(int i) {
+        this.tsMode = i;
+        return this;
+    }
+
+    public final synchronized DefaultExtractorsFactory setTsExtractorFlags(int i) {
+        this.tsFlags = i;
+        return this;
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.ExtractorsFactory
+    public final synchronized Extractor[] createExtractors() {
+        Extractor[] extractorArr;
+        Constructor<? extends Extractor> constructor = FLAC_EXTRACTOR_CONSTRUCTOR;
+        extractorArr = new Extractor[constructor == null ? 12 : 13];
+        extractorArr[0] = new MatroskaExtractor(this.matroskaFlags);
+        extractorArr[1] = new FragmentedMp4Extractor(this.fragmentedMp4Flags);
+        extractorArr[2] = new Mp4Extractor(this.mp4Flags);
+        extractorArr[3] = new Mp3Extractor(this.mp3Flags);
+        extractorArr[4] = new AdtsExtractor();
+        extractorArr[5] = new Ac3Extractor();
+        extractorArr[6] = new TsExtractor(this.tsMode, this.tsFlags);
+        extractorArr[7] = new FlvExtractor();
+        extractorArr[8] = new OggExtractor();
+        extractorArr[9] = new PsExtractor();
+        extractorArr[10] = new WavExtractor();
+        extractorArr[11] = new AmrExtractor();
+        if (constructor != null) {
+            try {
+                extractorArr[12] = constructor.newInstance(new Object[0]);
+            } catch (Exception e) {
+                throw new IllegalStateException("Unexpected error creating FLAC extractor", e);
+            }
+        }
+        return extractorArr;
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/DummyTrackOutput.java

@@ -0,0 +1,35 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import com.mbridge.msdk.playercommon.exoplayer2.Format;
+import com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput;
+import com.mbridge.msdk.playercommon.exoplayer2.util.ParsableByteArray;
+import java.io.EOFException;
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public final class DummyTrackOutput implements TrackOutput {
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void format(Format format) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void sampleMetadata(long j, int i, int i2, int i3, TrackOutput.CryptoData cryptoData) {
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final int sampleData(ExtractorInput extractorInput, int i, boolean z) throws IOException, InterruptedException {
+        int skip = extractorInput.skip(i);
+        if (skip != -1) {
+            return skip;
+        }
+        if (z) {
+            return -1;
+        }
+        throw new EOFException();
+    }
+
+    @Override // com.mbridge.msdk.playercommon.exoplayer2.extractor.TrackOutput
+    public final void sampleData(ParsableByteArray parsableByteArray, int i) {
+        parsableByteArray.skipBytes(i);
+    }
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/Extractor.java

@@ -0,0 +1,20 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface Extractor {
+    public static final int RESULT_CONTINUE = 0;
+    public static final int RESULT_END_OF_INPUT = -1;
+    public static final int RESULT_SEEK = 1;
+
+    void init(ExtractorOutput extractorOutput);
+
+    int read(ExtractorInput extractorInput, PositionHolder positionHolder) throws IOException, InterruptedException;
+
+    void release();
+
+    void seek(long j, long j2);
+
+    boolean sniff(ExtractorInput extractorInput) throws IOException, InterruptedException;
+}

decompiled/sources/com/mbridge/msdk/playercommon/exoplayer2/extractor/ExtractorInput.java

@@ -0,0 +1,36 @@
+package com.mbridge.msdk.playercommon.exoplayer2.extractor;
+
+import java.io.IOException;
+
+/* loaded from: classes4.dex */
+public interface ExtractorInput {
+    void advancePeekPosition(int i) throws IOException, InterruptedException;
+
+    boolean advancePeekPosition(int i, boolean z) throws IOException, InterruptedException;
+
+    long getLength();
+
+    long getPeekPosition();
+
+    long getPosition();
+
+    void peekFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    boolean peekFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException;
+
+    int read(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    void readFully(byte[] bArr, int i, int i2) throws IOException, InterruptedException;
+
+    boolean readFully(byte[] bArr, int i, int i2, boolean z) throws IOException, InterruptedException;
+
+    void resetPeekPosition();
+
+    <E extends Throwable> void setRetryPosition(long j, E e) throws Throwable;
+
+    int skip(int i) throws IOException, InterruptedException;
+
+    void skipFully(int i) throws IOException, InterruptedException;
+
+    boolean skipFully(int i, boolean z) throws IOException, InterruptedException;
+}