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/google/android/exoplayer2/trackselection/DefaultTrackSelector.java

@@ -0,0 +1,315 @@
+package com.google.android.exoplayer2.trackselection;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.util.SparseArray;
+import android.util.SparseBooleanArray;
+import com.google.android.exoplayer2.source.TrackGroupArray;
+import com.google.android.exoplayer2.trackselection.TrackSelectionParameters;
+import com.google.android.exoplayer2.util.Assertions;
+import com.google.android.exoplayer2.util.Util;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/* loaded from: classes2.dex */
+public abstract class DefaultTrackSelector extends MappingTrackSelector {
+
+    public static final class ParametersBuilder extends TrackSelectionParameters.Builder {
+        public boolean allowAudioMixedChannelCountAdaptiveness;
+        public boolean allowAudioMixedMimeTypeAdaptiveness;
+        public boolean allowAudioMixedSampleRateAdaptiveness;
+        public boolean allowMultipleAdaptiveSelections;
+        public boolean allowVideoMixedMimeTypeAdaptiveness;
+        public boolean allowVideoNonSeamlessAdaptiveness;
+        public int disabledTextTrackSelectionFlags;
+        public boolean exceedAudioConstraintsIfNecessary;
+        public boolean exceedRendererCapabilitiesIfNecessary;
+        public boolean exceedVideoConstraintsIfNecessary;
+        public boolean tunnelingEnabled;
+        public final SparseArray selectionOverrides = new SparseArray();
+        public final SparseBooleanArray rendererDisabledFlags = new SparseBooleanArray();
+
+        public final void init() {
+            this.exceedVideoConstraintsIfNecessary = true;
+            this.allowVideoMixedMimeTypeAdaptiveness = false;
+            this.allowVideoNonSeamlessAdaptiveness = true;
+            this.exceedAudioConstraintsIfNecessary = true;
+            this.allowAudioMixedMimeTypeAdaptiveness = false;
+            this.allowAudioMixedSampleRateAdaptiveness = false;
+            this.allowAudioMixedChannelCountAdaptiveness = false;
+            this.disabledTextTrackSelectionFlags = 0;
+            this.exceedRendererCapabilitiesIfNecessary = true;
+            this.tunnelingEnabled = false;
+            this.allowMultipleAdaptiveSelections = true;
+        }
+
+        public ParametersBuilder() {
+            init();
+        }
+
+        @Override // com.google.android.exoplayer2.trackselection.TrackSelectionParameters.Builder
+        public Parameters build() {
+            return new Parameters(this);
+        }
+    }
+
+    public static final class Parameters extends TrackSelectionParameters implements Parcelable {
+        public static final Parcelable.Creator<Parameters> CREATOR;
+        public static final Parameters DEFAULT;
+        public static final Parameters DEFAULT_WITHOUT_CONTEXT;
+        public final boolean allowAudioMixedChannelCountAdaptiveness;
+        public final boolean allowAudioMixedMimeTypeAdaptiveness;
+        public final boolean allowAudioMixedSampleRateAdaptiveness;
+        public final boolean allowMultipleAdaptiveSelections;
+        public final boolean allowVideoMixedMimeTypeAdaptiveness;
+        public final boolean allowVideoNonSeamlessAdaptiveness;
+        public final int disabledTextTrackSelectionFlags;
+        public final boolean exceedAudioConstraintsIfNecessary;
+        public final boolean exceedRendererCapabilitiesIfNecessary;
+        public final boolean exceedVideoConstraintsIfNecessary;
+        public final SparseBooleanArray rendererDisabledFlags;
+        public final SparseArray selectionOverrides;
+        public final boolean tunnelingEnabled;
+
+        @Override // com.google.android.exoplayer2.trackselection.TrackSelectionParameters, android.os.Parcelable
+        public int describeContents() {
+            return 0;
+        }
+
+        static {
+            Parameters build = new ParametersBuilder().build();
+            DEFAULT_WITHOUT_CONTEXT = build;
+            DEFAULT = build;
+            CREATOR = new Parcelable.Creator() { // from class: com.google.android.exoplayer2.trackselection.DefaultTrackSelector.Parameters.1
+                @Override // android.os.Parcelable.Creator
+                public Parameters createFromParcel(Parcel parcel) {
+                    return new Parameters(parcel);
+                }
+
+                @Override // android.os.Parcelable.Creator
+                public Parameters[] newArray(int i) {
+                    return new Parameters[i];
+                }
+            };
+        }
+
+        public Parameters(ParametersBuilder parametersBuilder) {
+            super(parametersBuilder);
+            this.exceedVideoConstraintsIfNecessary = parametersBuilder.exceedVideoConstraintsIfNecessary;
+            this.allowVideoMixedMimeTypeAdaptiveness = parametersBuilder.allowVideoMixedMimeTypeAdaptiveness;
+            this.allowVideoNonSeamlessAdaptiveness = parametersBuilder.allowVideoNonSeamlessAdaptiveness;
+            this.exceedAudioConstraintsIfNecessary = parametersBuilder.exceedAudioConstraintsIfNecessary;
+            this.allowAudioMixedMimeTypeAdaptiveness = parametersBuilder.allowAudioMixedMimeTypeAdaptiveness;
+            this.allowAudioMixedSampleRateAdaptiveness = parametersBuilder.allowAudioMixedSampleRateAdaptiveness;
+            this.allowAudioMixedChannelCountAdaptiveness = parametersBuilder.allowAudioMixedChannelCountAdaptiveness;
+            this.disabledTextTrackSelectionFlags = parametersBuilder.disabledTextTrackSelectionFlags;
+            this.exceedRendererCapabilitiesIfNecessary = parametersBuilder.exceedRendererCapabilitiesIfNecessary;
+            this.tunnelingEnabled = parametersBuilder.tunnelingEnabled;
+            this.allowMultipleAdaptiveSelections = parametersBuilder.allowMultipleAdaptiveSelections;
+            this.selectionOverrides = parametersBuilder.selectionOverrides;
+            this.rendererDisabledFlags = parametersBuilder.rendererDisabledFlags;
+        }
+
+        public Parameters(Parcel parcel) {
+            super(parcel);
+            this.exceedVideoConstraintsIfNecessary = Util.readBoolean(parcel);
+            this.allowVideoMixedMimeTypeAdaptiveness = Util.readBoolean(parcel);
+            this.allowVideoNonSeamlessAdaptiveness = Util.readBoolean(parcel);
+            this.exceedAudioConstraintsIfNecessary = Util.readBoolean(parcel);
+            this.allowAudioMixedMimeTypeAdaptiveness = Util.readBoolean(parcel);
+            this.allowAudioMixedSampleRateAdaptiveness = Util.readBoolean(parcel);
+            this.allowAudioMixedChannelCountAdaptiveness = Util.readBoolean(parcel);
+            this.disabledTextTrackSelectionFlags = parcel.readInt();
+            this.exceedRendererCapabilitiesIfNecessary = Util.readBoolean(parcel);
+            this.tunnelingEnabled = Util.readBoolean(parcel);
+            this.allowMultipleAdaptiveSelections = Util.readBoolean(parcel);
+            this.selectionOverrides = readSelectionOverrides(parcel);
+            this.rendererDisabledFlags = (SparseBooleanArray) Util.castNonNull(parcel.readSparseBooleanArray());
+        }
+
+        @Override // com.google.android.exoplayer2.trackselection.TrackSelectionParameters
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || Parameters.class != obj.getClass()) {
+                return false;
+            }
+            Parameters parameters = (Parameters) obj;
+            return super.equals(parameters) && this.exceedVideoConstraintsIfNecessary == parameters.exceedVideoConstraintsIfNecessary && this.allowVideoMixedMimeTypeAdaptiveness == parameters.allowVideoMixedMimeTypeAdaptiveness && this.allowVideoNonSeamlessAdaptiveness == parameters.allowVideoNonSeamlessAdaptiveness && this.exceedAudioConstraintsIfNecessary == parameters.exceedAudioConstraintsIfNecessary && this.allowAudioMixedMimeTypeAdaptiveness == parameters.allowAudioMixedMimeTypeAdaptiveness && this.allowAudioMixedSampleRateAdaptiveness == parameters.allowAudioMixedSampleRateAdaptiveness && this.allowAudioMixedChannelCountAdaptiveness == parameters.allowAudioMixedChannelCountAdaptiveness && this.disabledTextTrackSelectionFlags == parameters.disabledTextTrackSelectionFlags && this.exceedRendererCapabilitiesIfNecessary == parameters.exceedRendererCapabilitiesIfNecessary && this.tunnelingEnabled == parameters.tunnelingEnabled && this.allowMultipleAdaptiveSelections == parameters.allowMultipleAdaptiveSelections && areRendererDisabledFlagsEqual(this.rendererDisabledFlags, parameters.rendererDisabledFlags) && areSelectionOverridesEqual(this.selectionOverrides, parameters.selectionOverrides);
+        }
+
+        @Override // com.google.android.exoplayer2.trackselection.TrackSelectionParameters
+        public int hashCode() {
+            return ((((((((((((((((((((((super.hashCode() + 31) * 31) + (this.exceedVideoConstraintsIfNecessary ? 1 : 0)) * 31) + (this.allowVideoMixedMimeTypeAdaptiveness ? 1 : 0)) * 31) + (this.allowVideoNonSeamlessAdaptiveness ? 1 : 0)) * 31) + (this.exceedAudioConstraintsIfNecessary ? 1 : 0)) * 31) + (this.allowAudioMixedMimeTypeAdaptiveness ? 1 : 0)) * 31) + (this.allowAudioMixedSampleRateAdaptiveness ? 1 : 0)) * 31) + (this.allowAudioMixedChannelCountAdaptiveness ? 1 : 0)) * 31) + this.disabledTextTrackSelectionFlags) * 31) + (this.exceedRendererCapabilitiesIfNecessary ? 1 : 0)) * 31) + (this.tunnelingEnabled ? 1 : 0)) * 31) + (this.allowMultipleAdaptiveSelections ? 1 : 0);
+        }
+
+        @Override // com.google.android.exoplayer2.trackselection.TrackSelectionParameters, android.os.Parcelable
+        public void writeToParcel(Parcel parcel, int i) {
+            super.writeToParcel(parcel, i);
+            Util.writeBoolean(parcel, this.exceedVideoConstraintsIfNecessary);
+            Util.writeBoolean(parcel, this.allowVideoMixedMimeTypeAdaptiveness);
+            Util.writeBoolean(parcel, this.allowVideoNonSeamlessAdaptiveness);
+            Util.writeBoolean(parcel, this.exceedAudioConstraintsIfNecessary);
+            Util.writeBoolean(parcel, this.allowAudioMixedMimeTypeAdaptiveness);
+            Util.writeBoolean(parcel, this.allowAudioMixedSampleRateAdaptiveness);
+            Util.writeBoolean(parcel, this.allowAudioMixedChannelCountAdaptiveness);
+            parcel.writeInt(this.disabledTextTrackSelectionFlags);
+            Util.writeBoolean(parcel, this.exceedRendererCapabilitiesIfNecessary);
+            Util.writeBoolean(parcel, this.tunnelingEnabled);
+            Util.writeBoolean(parcel, this.allowMultipleAdaptiveSelections);
+            writeSelectionOverridesToParcel(parcel, this.selectionOverrides);
+            parcel.writeSparseBooleanArray(this.rendererDisabledFlags);
+        }
+
+        public static SparseArray readSelectionOverrides(Parcel parcel) {
+            int readInt = parcel.readInt();
+            SparseArray sparseArray = new SparseArray(readInt);
+            for (int i = 0; i < readInt; i++) {
+                int readInt2 = parcel.readInt();
+                int readInt3 = parcel.readInt();
+                HashMap hashMap = new HashMap(readInt3);
+                for (int i2 = 0; i2 < readInt3; i2++) {
+                    hashMap.put((TrackGroupArray) Assertions.checkNotNull((TrackGroupArray) parcel.readParcelable(TrackGroupArray.class.getClassLoader())), (SelectionOverride) parcel.readParcelable(SelectionOverride.class.getClassLoader()));
+                }
+                sparseArray.put(readInt2, hashMap);
+            }
+            return sparseArray;
+        }
+
+        public static void writeSelectionOverridesToParcel(Parcel parcel, SparseArray sparseArray) {
+            int size = sparseArray.size();
+            parcel.writeInt(size);
+            for (int i = 0; i < size; i++) {
+                int keyAt = sparseArray.keyAt(i);
+                Map map = (Map) sparseArray.valueAt(i);
+                int size2 = map.size();
+                parcel.writeInt(keyAt);
+                parcel.writeInt(size2);
+                for (Map.Entry entry : map.entrySet()) {
+                    parcel.writeParcelable((Parcelable) entry.getKey(), 0);
+                    parcel.writeParcelable((Parcelable) entry.getValue(), 0);
+                }
+            }
+        }
+
+        public static boolean areRendererDisabledFlagsEqual(SparseBooleanArray sparseBooleanArray, SparseBooleanArray sparseBooleanArray2) {
+            int size = sparseBooleanArray.size();
+            if (sparseBooleanArray2.size() != size) {
+                return false;
+            }
+            for (int i = 0; i < size; i++) {
+                if (sparseBooleanArray2.indexOfKey(sparseBooleanArray.keyAt(i)) < 0) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public static boolean areSelectionOverridesEqual(SparseArray sparseArray, SparseArray sparseArray2) {
+            int size = sparseArray.size();
+            if (sparseArray2.size() != size) {
+                return false;
+            }
+            for (int i = 0; i < size; i++) {
+                int indexOfKey = sparseArray2.indexOfKey(sparseArray.keyAt(i));
+                if (indexOfKey < 0 || !areSelectionOverridesEqual((Map) sparseArray.valueAt(i), (Map) sparseArray2.valueAt(indexOfKey))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public static boolean areSelectionOverridesEqual(Map map, Map map2) {
+            if (map2.size() != map.size()) {
+                return false;
+            }
+            for (Map.Entry entry : map.entrySet()) {
+                TrackGroupArray trackGroupArray = (TrackGroupArray) entry.getKey();
+                if (!map2.containsKey(trackGroupArray) || !Util.areEqual(entry.getValue(), map2.get(trackGroupArray))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    public static final class SelectionOverride implements Parcelable {
+        public static final Parcelable.Creator<SelectionOverride> CREATOR = new Parcelable.Creator() { // from class: com.google.android.exoplayer2.trackselection.DefaultTrackSelector.SelectionOverride.1
+            @Override // android.os.Parcelable.Creator
+            public SelectionOverride createFromParcel(Parcel parcel) {
+                return new SelectionOverride(parcel);
+            }
+
+            @Override // android.os.Parcelable.Creator
+            public SelectionOverride[] newArray(int i) {
+                return new SelectionOverride[i];
+            }
+        };
+        public final int groupIndex;
+        public final int length;
+        public final int[] tracks;
+        public final int type;
+
+        @Override // android.os.Parcelable
+        public int describeContents() {
+            return 0;
+        }
+
+        public SelectionOverride(int i, int... iArr) {
+            this(i, iArr, 0);
+        }
+
+        public SelectionOverride(int i, int[] iArr, int i2) {
+            this.groupIndex = i;
+            int[] copyOf = Arrays.copyOf(iArr, iArr.length);
+            this.tracks = copyOf;
+            this.length = iArr.length;
+            this.type = i2;
+            Arrays.sort(copyOf);
+        }
+
+        public SelectionOverride(Parcel parcel) {
+            this.groupIndex = parcel.readInt();
+            int readByte = parcel.readByte();
+            this.length = readByte;
+            int[] iArr = new int[readByte];
+            this.tracks = iArr;
+            parcel.readIntArray(iArr);
+            this.type = parcel.readInt();
+        }
+
+        public boolean containsTrack(int i) {
+            for (int i2 : this.tracks) {
+                if (i2 == i) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public int hashCode() {
+            return (((this.groupIndex * 31) + Arrays.hashCode(this.tracks)) * 31) + this.type;
+        }
+
+        public boolean equals(Object obj) {
+            if (this == obj) {
+                return true;
+            }
+            if (obj == null || SelectionOverride.class != obj.getClass()) {
+                return false;
+            }
+            SelectionOverride selectionOverride = (SelectionOverride) obj;
+            return this.groupIndex == selectionOverride.groupIndex && Arrays.equals(this.tracks, selectionOverride.tracks) && this.type == selectionOverride.type;
+        }
+
+        @Override // android.os.Parcelable
+        public void writeToParcel(Parcel parcel, int i) {
+            parcel.writeInt(this.groupIndex);
+            parcel.writeInt(this.tracks.length);
+            parcel.writeIntArray(this.tracks);
+            parcel.writeInt(this.type);
+        }
+    }
+}

decompiled/sources/com/google/android/exoplayer2/trackselection/MappingTrackSelector.java

@@ -0,0 +1,5 @@
+package com.google.android.exoplayer2.trackselection;
+
+/* loaded from: classes2.dex */
+public abstract class MappingTrackSelector extends TrackSelector {
+}

decompiled/sources/com/google/android/exoplayer2/trackselection/TrackSelectionParameters.java

@@ -0,0 +1,187 @@
+package com.google.android.exoplayer2.trackselection;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import com.google.android.exoplayer2.util.Util;
+import com.google.common.collect.ImmutableList;
+import java.util.ArrayList;
+import java.util.Collection;
+
+/* loaded from: classes2.dex */
+public class TrackSelectionParameters implements Parcelable {
+    public static final Parcelable.Creator<TrackSelectionParameters> CREATOR;
+    public static final TrackSelectionParameters DEFAULT;
+    public static final TrackSelectionParameters DEFAULT_WITHOUT_CONTEXT;
+    public final boolean forceHighestSupportedBitrate;
+    public final boolean forceLowestBitrate;
+    public final int maxAudioBitrate;
+    public final int maxAudioChannelCount;
+    public final int maxVideoBitrate;
+    public final int maxVideoFrameRate;
+    public final int maxVideoHeight;
+    public final int maxVideoWidth;
+    public final int minVideoBitrate;
+    public final int minVideoFrameRate;
+    public final int minVideoHeight;
+    public final int minVideoWidth;
+    public final ImmutableList preferredAudioLanguages;
+    public final ImmutableList preferredAudioMimeTypes;
+    public final int preferredAudioRoleFlags;
+    public final ImmutableList preferredTextLanguages;
+    public final int preferredTextRoleFlags;
+    public final ImmutableList preferredVideoMimeTypes;
+    public final boolean selectUndeterminedTextLanguage;
+    public final int viewportHeight;
+    public final boolean viewportOrientationMayChange;
+    public final int viewportWidth;
+
+    @Override // android.os.Parcelable
+    public int describeContents() {
+        return 0;
+    }
+
+    public static class Builder {
+        public int minVideoBitrate;
+        public int minVideoFrameRate;
+        public int minVideoHeight;
+        public int minVideoWidth;
+        public int maxVideoWidth = Integer.MAX_VALUE;
+        public int maxVideoHeight = Integer.MAX_VALUE;
+        public int maxVideoFrameRate = Integer.MAX_VALUE;
+        public int maxVideoBitrate = Integer.MAX_VALUE;
+        public int viewportWidth = Integer.MAX_VALUE;
+        public int viewportHeight = Integer.MAX_VALUE;
+        public boolean viewportOrientationMayChange = true;
+        public ImmutableList preferredVideoMimeTypes = ImmutableList.of();
+        public ImmutableList preferredAudioLanguages = ImmutableList.of();
+        public int preferredAudioRoleFlags = 0;
+        public int maxAudioChannelCount = Integer.MAX_VALUE;
+        public int maxAudioBitrate = Integer.MAX_VALUE;
+        public ImmutableList preferredAudioMimeTypes = ImmutableList.of();
+        public ImmutableList preferredTextLanguages = ImmutableList.of();
+        public int preferredTextRoleFlags = 0;
+        public boolean selectUndeterminedTextLanguage = false;
+        public boolean forceLowestBitrate = false;
+        public boolean forceHighestSupportedBitrate = false;
+
+        public TrackSelectionParameters build() {
+            return new TrackSelectionParameters(this);
+        }
+    }
+
+    static {
+        TrackSelectionParameters build = new Builder().build();
+        DEFAULT_WITHOUT_CONTEXT = build;
+        DEFAULT = build;
+        CREATOR = new Parcelable.Creator() { // from class: com.google.android.exoplayer2.trackselection.TrackSelectionParameters.1
+            @Override // android.os.Parcelable.Creator
+            public TrackSelectionParameters createFromParcel(Parcel parcel) {
+                return new TrackSelectionParameters(parcel);
+            }
+
+            @Override // android.os.Parcelable.Creator
+            public TrackSelectionParameters[] newArray(int i) {
+                return new TrackSelectionParameters[i];
+            }
+        };
+    }
+
+    public TrackSelectionParameters(Builder builder) {
+        this.maxVideoWidth = builder.maxVideoWidth;
+        this.maxVideoHeight = builder.maxVideoHeight;
+        this.maxVideoFrameRate = builder.maxVideoFrameRate;
+        this.maxVideoBitrate = builder.maxVideoBitrate;
+        this.minVideoWidth = builder.minVideoWidth;
+        this.minVideoHeight = builder.minVideoHeight;
+        this.minVideoFrameRate = builder.minVideoFrameRate;
+        this.minVideoBitrate = builder.minVideoBitrate;
+        this.viewportWidth = builder.viewportWidth;
+        this.viewportHeight = builder.viewportHeight;
+        this.viewportOrientationMayChange = builder.viewportOrientationMayChange;
+        this.preferredVideoMimeTypes = builder.preferredVideoMimeTypes;
+        this.preferredAudioLanguages = builder.preferredAudioLanguages;
+        this.preferredAudioRoleFlags = builder.preferredAudioRoleFlags;
+        this.maxAudioChannelCount = builder.maxAudioChannelCount;
+        this.maxAudioBitrate = builder.maxAudioBitrate;
+        this.preferredAudioMimeTypes = builder.preferredAudioMimeTypes;
+        this.preferredTextLanguages = builder.preferredTextLanguages;
+        this.preferredTextRoleFlags = builder.preferredTextRoleFlags;
+        this.selectUndeterminedTextLanguage = builder.selectUndeterminedTextLanguage;
+        this.forceLowestBitrate = builder.forceLowestBitrate;
+        this.forceHighestSupportedBitrate = builder.forceHighestSupportedBitrate;
+    }
+
+    public TrackSelectionParameters(Parcel parcel) {
+        ArrayList arrayList = new ArrayList();
+        parcel.readList(arrayList, null);
+        this.preferredAudioLanguages = ImmutableList.copyOf((Collection) arrayList);
+        this.preferredAudioRoleFlags = parcel.readInt();
+        ArrayList arrayList2 = new ArrayList();
+        parcel.readList(arrayList2, null);
+        this.preferredTextLanguages = ImmutableList.copyOf((Collection) arrayList2);
+        this.preferredTextRoleFlags = parcel.readInt();
+        this.selectUndeterminedTextLanguage = Util.readBoolean(parcel);
+        this.maxVideoWidth = parcel.readInt();
+        this.maxVideoHeight = parcel.readInt();
+        this.maxVideoFrameRate = parcel.readInt();
+        this.maxVideoBitrate = parcel.readInt();
+        this.minVideoWidth = parcel.readInt();
+        this.minVideoHeight = parcel.readInt();
+        this.minVideoFrameRate = parcel.readInt();
+        this.minVideoBitrate = parcel.readInt();
+        this.viewportWidth = parcel.readInt();
+        this.viewportHeight = parcel.readInt();
+        this.viewportOrientationMayChange = Util.readBoolean(parcel);
+        ArrayList arrayList3 = new ArrayList();
+        parcel.readList(arrayList3, null);
+        this.preferredVideoMimeTypes = ImmutableList.copyOf((Collection) arrayList3);
+        this.maxAudioChannelCount = parcel.readInt();
+        this.maxAudioBitrate = parcel.readInt();
+        ArrayList arrayList4 = new ArrayList();
+        parcel.readList(arrayList4, null);
+        this.preferredAudioMimeTypes = ImmutableList.copyOf((Collection) arrayList4);
+        this.forceLowestBitrate = Util.readBoolean(parcel);
+        this.forceHighestSupportedBitrate = Util.readBoolean(parcel);
+    }
+
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null || getClass() != obj.getClass()) {
+            return false;
+        }
+        TrackSelectionParameters trackSelectionParameters = (TrackSelectionParameters) obj;
+        return this.maxVideoWidth == trackSelectionParameters.maxVideoWidth && this.maxVideoHeight == trackSelectionParameters.maxVideoHeight && this.maxVideoFrameRate == trackSelectionParameters.maxVideoFrameRate && this.maxVideoBitrate == trackSelectionParameters.maxVideoBitrate && this.minVideoWidth == trackSelectionParameters.minVideoWidth && this.minVideoHeight == trackSelectionParameters.minVideoHeight && this.minVideoFrameRate == trackSelectionParameters.minVideoFrameRate && this.minVideoBitrate == trackSelectionParameters.minVideoBitrate && this.viewportOrientationMayChange == trackSelectionParameters.viewportOrientationMayChange && this.viewportWidth == trackSelectionParameters.viewportWidth && this.viewportHeight == trackSelectionParameters.viewportHeight && this.preferredVideoMimeTypes.equals(trackSelectionParameters.preferredVideoMimeTypes) && this.preferredAudioLanguages.equals(trackSelectionParameters.preferredAudioLanguages) && this.preferredAudioRoleFlags == trackSelectionParameters.preferredAudioRoleFlags && this.maxAudioChannelCount == trackSelectionParameters.maxAudioChannelCount && this.maxAudioBitrate == trackSelectionParameters.maxAudioBitrate && this.preferredAudioMimeTypes.equals(trackSelectionParameters.preferredAudioMimeTypes) && this.preferredTextLanguages.equals(trackSelectionParameters.preferredTextLanguages) && this.preferredTextRoleFlags == trackSelectionParameters.preferredTextRoleFlags && this.selectUndeterminedTextLanguage == trackSelectionParameters.selectUndeterminedTextLanguage && this.forceLowestBitrate == trackSelectionParameters.forceLowestBitrate && this.forceHighestSupportedBitrate == trackSelectionParameters.forceHighestSupportedBitrate;
+    }
+
+    public int hashCode() {
+        return ((((((((((((((((((((((((((((((((((((((((((this.maxVideoWidth + 31) * 31) + this.maxVideoHeight) * 31) + this.maxVideoFrameRate) * 31) + this.maxVideoBitrate) * 31) + this.minVideoWidth) * 31) + this.minVideoHeight) * 31) + this.minVideoFrameRate) * 31) + this.minVideoBitrate) * 31) + (this.viewportOrientationMayChange ? 1 : 0)) * 31) + this.viewportWidth) * 31) + this.viewportHeight) * 31) + this.preferredVideoMimeTypes.hashCode()) * 31) + this.preferredAudioLanguages.hashCode()) * 31) + this.preferredAudioRoleFlags) * 31) + this.maxAudioChannelCount) * 31) + this.maxAudioBitrate) * 31) + this.preferredAudioMimeTypes.hashCode()) * 31) + this.preferredTextLanguages.hashCode()) * 31) + this.preferredTextRoleFlags) * 31) + (this.selectUndeterminedTextLanguage ? 1 : 0)) * 31) + (this.forceLowestBitrate ? 1 : 0)) * 31) + (this.forceHighestSupportedBitrate ? 1 : 0);
+    }
+
+    @Override // android.os.Parcelable
+    public void writeToParcel(Parcel parcel, int i) {
+        parcel.writeList(this.preferredAudioLanguages);
+        parcel.writeInt(this.preferredAudioRoleFlags);
+        parcel.writeList(this.preferredTextLanguages);
+        parcel.writeInt(this.preferredTextRoleFlags);
+        Util.writeBoolean(parcel, this.selectUndeterminedTextLanguage);
+        parcel.writeInt(this.maxVideoWidth);
+        parcel.writeInt(this.maxVideoHeight);
+        parcel.writeInt(this.maxVideoFrameRate);
+        parcel.writeInt(this.maxVideoBitrate);
+        parcel.writeInt(this.minVideoWidth);
+        parcel.writeInt(this.minVideoHeight);
+        parcel.writeInt(this.minVideoFrameRate);
+        parcel.writeInt(this.minVideoBitrate);
+        parcel.writeInt(this.viewportWidth);
+        parcel.writeInt(this.viewportHeight);
+        Util.writeBoolean(parcel, this.viewportOrientationMayChange);
+        parcel.writeList(this.preferredVideoMimeTypes);
+        parcel.writeInt(this.maxAudioChannelCount);
+        parcel.writeInt(this.maxAudioBitrate);
+        parcel.writeList(this.preferredAudioMimeTypes);
+        Util.writeBoolean(parcel, this.forceLowestBitrate);
+        Util.writeBoolean(parcel, this.forceHighestSupportedBitrate);
+    }
+}

decompiled/sources/com/google/android/exoplayer2/trackselection/TrackSelector.java

@@ -0,0 +1,5 @@
+package com.google.android.exoplayer2.trackselection;
+
+/* loaded from: classes2.dex */
+public abstract class TrackSelector {
+}