package androidx.media3.exoplayer.rtsp;

import android.net.Uri;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Pair;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;
import androidx.media3.common.ColorInfo;
import androidx.media3.common.Format;
import androidx.media3.common.MimeTypes;
import androidx.media3.common.ParserException;
import androidx.media3.common.util.Assertions;
import androidx.media3.common.util.CodecSpecificDataUtil;
import androidx.media3.common.util.ParsableBitArray;
import androidx.media3.common.util.Util;
import androidx.media3.exoplayer.rtsp.MediaDescription;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import q1.k;
import q1.p;
import q1.u;
import q1.v;

/* JADX INFO: loaded from: classes.dex */
final class RtspMediaTrack {
    private static final String AAC_CODECS_PREFIX = "mp4a.40.";
    private static final int DEFAULT_H263_HEIGHT = 288;
    private static final int DEFAULT_H263_WIDTH = 352;
    private static final int DEFAULT_MP4V_HEIGHT = 288;
    private static final int DEFAULT_MP4V_WIDTH = 352;
    private static final int DEFAULT_VP8_HEIGHT = 240;
    private static final int DEFAULT_VP8_WIDTH = 320;
    private static final int DEFAULT_VP9_HEIGHT = 240;
    private static final int DEFAULT_VP9_WIDTH = 320;
    private static final String GENERIC_CONTROL_ATTR = "*";
    private static final String H264_CODECS_PREFIX = "avc1.";
    private static final String MPEG4_CODECS_PREFIX = "mp4v.";
    private static final int OPUS_CLOCK_RATE = 48000;
    private static final String PARAMETER_AMR_INTERLEAVING = "interleaving";
    private static final String PARAMETER_AMR_OCTET_ALIGN = "octet-align";
    private static final String PARAMETER_H265_SPROP_MAX_DON_DIFF = "sprop-max-don-diff";
    private static final String PARAMETER_H265_SPROP_PPS = "sprop-pps";
    private static final String PARAMETER_H265_SPROP_SPS = "sprop-sps";
    private static final String PARAMETER_H265_SPROP_VPS = "sprop-vps";
    private static final String PARAMETER_MP4A_CONFIG = "config";
    private static final String PARAMETER_MP4A_C_PRESENT = "cpresent";
    private static final String PARAMETER_PROFILE_LEVEL_ID = "profile-level-id";
    private static final String PARAMETER_SPROP_PARAMS = "sprop-parameter-sets";
    public final RtpPayloadFormat payloadFormat;
    public final Uri uri;

    public RtspMediaTrack(RtspHeaders rtspHeaders, MediaDescription mediaDescription, Uri uri) {
        Assertions.checkArgument(mediaDescription.attributes.containsKey(SessionDescription.ATTR_CONTROL), "missing attribute control");
        this.payloadFormat = generatePayloadFormat(mediaDescription);
        this.uri = extractTrackUri(rtspHeaders, uri, (String) Util.castNonNull((String) mediaDescription.attributes.get(SessionDescription.ATTR_CONTROL)));
    }

    private static Uri extractTrackUri(RtspHeaders rtspHeaders, Uri uri, String str) {
        Uri uri2 = Uri.parse(str);
        if (uri2.isAbsolute()) {
            return uri2;
        }
        if (!TextUtils.isEmpty(rtspHeaders.get(RtspHeaders.CONTENT_BASE))) {
            uri = Uri.parse(rtspHeaders.get(RtspHeaders.CONTENT_BASE));
        } else if (!TextUtils.isEmpty(rtspHeaders.get(RtspHeaders.CONTENT_LOCATION))) {
            uri = Uri.parse(rtspHeaders.get(RtspHeaders.CONTENT_LOCATION));
        }
        return str.equals(GENERIC_CONTROL_ATTR) ? uri : uri.buildUpon().appendEncodedPath(str).build();
    }

    @VisibleForTesting
    public static RtpPayloadFormat generatePayloadFormat(MediaDescription mediaDescription) {
        Format.Builder builder;
        String str;
        int i10;
        int iInferChannelCount;
        ImmutableMap<String, String> fmtpParametersAsMap;
        builder = new Format.Builder();
        int i11 = mediaDescription.bitrate;
        if (i11 > 0) {
            builder.setAverageBitrate(i11);
        }
        MediaDescription.RtpMapAttribute rtpMapAttribute = mediaDescription.rtpMapAttribute;
        int i12 = rtpMapAttribute.payloadType;
        str = rtpMapAttribute.mediaEncoding;
        String mimeTypeFromRtpMediaType = RtpPayloadFormat.getMimeTypeFromRtpMediaType(str);
        builder.setSampleMimeType(mimeTypeFromRtpMediaType);
        i10 = mediaDescription.rtpMapAttribute.clockRate;
        if ("audio".equals(mediaDescription.mediaType)) {
            iInferChannelCount = inferChannelCount(mediaDescription.rtpMapAttribute.encodingParameters, mimeTypeFromRtpMediaType);
            builder.setSampleRate(i10).setChannelCount(iInferChannelCount);
        } else {
            iInferChannelCount = -1;
        }
        fmtpParametersAsMap = mediaDescription.getFmtpParametersAsMap();
        switch (mimeTypeFromRtpMediaType) {
            case "audio/mp4a-latm":
                Assertions.checkArgument(iInferChannelCount != -1);
                Assertions.checkArgument(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                if (str.equals(RtpPayloadFormat.RTP_MEDIA_MPEG4_LATM_AUDIO)) {
                    Assertions.checkArgument(fmtpParametersAsMap.containsKey(PARAMETER_MP4A_C_PRESENT) && ((String) fmtpParametersAsMap.get(PARAMETER_MP4A_C_PRESENT)).equals(SessionDescription.SUPPORTED_SDP_VERSION), "Only supports cpresent=0 in AAC audio.");
                    String str2 = (String) fmtpParametersAsMap.get(PARAMETER_MP4A_CONFIG);
                    Assertions.checkNotNull(str2, "AAC audio stream must include config fmtp parameter");
                    Assertions.checkArgument(str2.length() % 2 == 0, "Malformat MPEG4 config: ".concat(str2));
                    androidx.media3.extractor.a aacStreamMuxConfig = parseAacStreamMuxConfig(str2);
                    builder.setSampleRate(aacStreamMuxConfig.f3305a).setChannelCount(aacStreamMuxConfig.f3306b).setCodecs(aacStreamMuxConfig.f3307c);
                }
                processAacFmtpAttribute(builder, fmtpParametersAsMap, str, iInferChannelCount, i10);
                break;
            case "audio/3gpp":
            case "audio/amr-wb":
                Assertions.checkArgument(iInferChannelCount == 1, "Multi channel AMR is not currently supported.");
                Assertions.checkArgument(!fmtpParametersAsMap.isEmpty(), "fmtp parameters must include octet-align.");
                Assertions.checkArgument(fmtpParametersAsMap.containsKey(PARAMETER_AMR_OCTET_ALIGN), "Only octet aligned mode is currently supported.");
                Assertions.checkArgument(!fmtpParametersAsMap.containsKey(PARAMETER_AMR_INTERLEAVING), "Interleaving mode is not currently supported.");
                break;
            case "audio/opus":
                Assertions.checkArgument(iInferChannelCount != -1);
                Assertions.checkArgument(i10 == OPUS_CLOCK_RATE, "Invalid OPUS clock rate.");
                break;
            case "video/mp4v-es":
                Assertions.checkArgument(!fmtpParametersAsMap.isEmpty());
                processMPEG4FmtpAttribute(builder, fmtpParametersAsMap);
                break;
            case "video/3gpp":
                builder.setWidth(352).setHeight(288);
                break;
            case "video/avc":
                Assertions.checkArgument(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                processH264FmtpAttribute(builder, fmtpParametersAsMap);
                break;
            case "video/hevc":
                Assertions.checkArgument(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                processH265FmtpAttribute(builder, fmtpParametersAsMap);
                break;
            case "video/x-vnd.on2.vp8":
                builder.setWidth(320).setHeight(240);
                break;
            case "video/x-vnd.on2.vp9":
                builder.setWidth(320).setHeight(240);
                break;
            case "audio/raw":
                builder.setPcmEncoding(RtpPayloadFormat.getRawPcmEncodingType(str));
                break;
        }
        Assertions.checkArgument(i10 > 0);
        return new RtpPayloadFormat(builder.build(), i12, i10, fmtpParametersAsMap, str);
    }

    private static byte[] getInitializationDataFromParameterSet(String str) {
        byte[] bArrDecode = Base64.decode(str, 0);
        byte[] bArr = new byte[bArrDecode.length + 4];
        System.arraycopy(v.f32164a, 0, bArr, 0, 4);
        System.arraycopy(bArrDecode, 0, bArr, 4, bArrDecode.length);
        return bArr;
    }

    private static int inferChannelCount(int i10, String str) {
        return i10 != -1 ? i10 : str.equals(MimeTypes.AUDIO_AC3) ? 6 : 1;
    }

    private static androidx.media3.extractor.a parseAacStreamMuxConfig(String str) {
        ParsableBitArray parsableBitArray = new ParsableBitArray(Util.getBytesFromHexString(str));
        Assertions.checkArgument(parsableBitArray.readBits(1) == 0, "Only supports audio mux version 0.");
        Assertions.checkArgument(parsableBitArray.readBits(1) == 1, "Only supports allStreamsSameTimeFraming.");
        parsableBitArray.skipBits(6);
        Assertions.checkArgument(parsableBitArray.readBits(4) == 0, "Only supports one program.");
        Assertions.checkArgument(parsableBitArray.readBits(3) == 0, "Only supports one numLayer.");
        try {
            return androidx.media3.extractor.b.d(parsableBitArray, false);
        } catch (ParserException e10) {
            throw new IllegalArgumentException(e10);
        }
    }

    private static void processAacFmtpAttribute(Format.Builder builder, ImmutableMap<String, String> immutableMap, String str, int i10, int i11) {
        String str2 = (String) immutableMap.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str2 == null && str.equals(RtpPayloadFormat.RTP_MEDIA_MPEG4_LATM_AUDIO)) {
            str2 = "30";
        }
        Assertions.checkArgument((str2 == null || str2.isEmpty()) ? false : true, "missing profile-level-id param");
        builder.setCodecs(AAC_CODECS_PREFIX + str2);
        int i12 = -1;
        for (int i13 = 0; i13 < 13; i13++) {
            if (i11 == androidx.media3.extractor.b.f3316a[i13]) {
                i12 = i13;
            }
        }
        int i14 = -1;
        for (int i15 = 0; i15 < 16; i15++) {
            if (i10 == androidx.media3.extractor.b.f3317b[i15]) {
                i14 = i15;
            }
        }
        if (i11 == -1 || i14 == -1) {
            throw new IllegalArgumentException(defpackage.e.f("Invalid sample rate or number of channels: ", i11, ", ", i10));
        }
        builder.setInitializationData(ImmutableList.w(androidx.media3.extractor.b.a(2, i12, i14)));
    }

    private static void processH264FmtpAttribute(Format.Builder builder, ImmutableMap<String, String> immutableMap) {
        Assertions.checkArgument(immutableMap.containsKey(PARAMETER_SPROP_PARAMS), "missing sprop parameter");
        String[] strArrSplit = Util.split((String) Assertions.checkNotNull((String) immutableMap.get(PARAMETER_SPROP_PARAMS)), ",");
        Assertions.checkArgument(strArrSplit.length == 2, "empty sprop value");
        ImmutableList immutableListX = ImmutableList.x(getInitializationDataFromParameterSet(strArrSplit[0]), getInitializationDataFromParameterSet(strArrSplit[1]));
        builder.setInitializationData(immutableListX);
        byte[] bArr = immutableListX.get(0);
        byte[] bArr2 = v.f32164a;
        u uVarG = v.g(4, bArr.length, bArr);
        builder.setPixelWidthHeightRatio(uVarG.f32151g);
        builder.setHeight(uVarG.f32150f);
        builder.setWidth(uVarG.f32149e);
        builder.setColorInfo(new ColorInfo.Builder().setColorSpace(uVarG.f32160p).setColorRange(uVarG.f32161q).setColorTransfer(uVarG.f32162r).setLumaBitdepth(uVarG.f32152h + 8).setChromaBitdepth(uVarG.f32153i + 8).build());
        String str = (String) immutableMap.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str != null) {
            builder.setCodecs(H264_CODECS_PREFIX.concat(str));
        } else {
            builder.setCodecs(CodecSpecificDataUtil.buildAvcCodecString(uVarG.f32145a, uVarG.f32146b, uVarG.f32147c));
        }
    }

    /* JADX WARN: Type inference failed for: r0v6, types: [byte[], java.io.Serializable] */
    private static void processH265FmtpAttribute(Format.Builder builder, ImmutableMap<String, String> immutableMap) {
        if (immutableMap.containsKey(PARAMETER_H265_SPROP_MAX_DON_DIFF)) {
            int i10 = Integer.parseInt((String) Assertions.checkNotNull((String) immutableMap.get(PARAMETER_H265_SPROP_MAX_DON_DIFF)));
            Assertions.checkArgument(i10 == 0, "non-zero sprop-max-don-diff " + i10 + " is not supported");
        }
        Assertions.checkArgument(immutableMap.containsKey(PARAMETER_H265_SPROP_VPS), "missing sprop-vps parameter");
        String str = (String) Assertions.checkNotNull((String) immutableMap.get(PARAMETER_H265_SPROP_VPS));
        Assertions.checkArgument(immutableMap.containsKey(PARAMETER_H265_SPROP_SPS), "missing sprop-sps parameter");
        String str2 = (String) Assertions.checkNotNull((String) immutableMap.get(PARAMETER_H265_SPROP_SPS));
        Assertions.checkArgument(immutableMap.containsKey(PARAMETER_H265_SPROP_PPS), "missing sprop-pps parameter");
        ImmutableList immutableListU = ImmutableList.u(getInitializationDataFromParameterSet(str), getInitializationDataFromParameterSet(str2), getInitializationDataFromParameterSet((String) Assertions.checkNotNull((String) immutableMap.get(PARAMETER_H265_SPROP_PPS))));
        builder.setInitializationData(immutableListU);
        byte[] bArr = immutableListU.get(1);
        byte[] bArr2 = v.f32164a;
        p h265SpsNalUnit = v.parseH265SpsNalUnit(bArr, 4, bArr.length, null);
        builder.setPixelWidthHeightRatio(h265SpsNalUnit.f32131h);
        builder.setHeight(h265SpsNalUnit.f32128e).setWidth(h265SpsNalUnit.f32127d);
        builder.setColorInfo(new ColorInfo.Builder().setColorSpace(h265SpsNalUnit.f32133j).setColorRange(h265SpsNalUnit.f32134k).setColorTransfer(h265SpsNalUnit.f32135l).setLumaBitdepth(h265SpsNalUnit.f32125b + 8).setChromaBitdepth(h265SpsNalUnit.f32126c + 8).build());
        k kVar = h265SpsNalUnit.profileTierLevel;
        if (kVar != null) {
            builder.setCodecs(CodecSpecificDataUtil.buildHevcCodecString(kVar.f32108a, kVar.f32109b, kVar.f32110c, kVar.f32111d, kVar.f32112e, kVar.f32113f));
        }
    }

    private static void processMPEG4FmtpAttribute(Format.Builder builder, ImmutableMap<String, String> immutableMap) {
        String str = (String) immutableMap.get(PARAMETER_MP4A_CONFIG);
        if (str != null) {
            byte[] bytesFromHexString = Util.getBytesFromHexString(str);
            builder.setInitializationData(ImmutableList.w(bytesFromHexString));
            Pair<Integer, Integer> videoResolutionFromMpeg4VideoConfig = CodecSpecificDataUtil.getVideoResolutionFromMpeg4VideoConfig(bytesFromHexString);
            builder.setWidth(((Integer) videoResolutionFromMpeg4VideoConfig.first).intValue()).setHeight(((Integer) videoResolutionFromMpeg4VideoConfig.second).intValue());
        } else {
            builder.setWidth(352).setHeight(288);
        }
        String str2 = (String) immutableMap.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str2 == null) {
            str2 = "1";
        }
        builder.setCodecs(MPEG4_CODECS_PREFIX.concat(str2));
    }

    public boolean equals(@Nullable Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || RtspMediaTrack.class != obj.getClass()) {
            return false;
        }
        RtspMediaTrack rtspMediaTrack = (RtspMediaTrack) obj;
        return this.payloadFormat.equals(rtspMediaTrack.payloadFormat) && this.uri.equals(rtspMediaTrack.uri);
    }

    public int hashCode() {
        return this.uri.hashCode() + ((this.payloadFormat.hashCode() + 217) * 31);
    }
}