package androidx.media3.exoplayer.rtsp;

import android.net.Uri;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Pair;
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.CodecSpecificDataUtil;
import androidx.media3.common.util.ParsableBitArray;
import androidx.media3.common.util.Util;
import androidx.media3.container.NalUnitUtil;
import androidx.media3.exoplayer.rtsp.MediaDescription;
import androidx.media3.extractor.AacUtil;
import androidx.media3.extractor.metadata.icy.IcyHeaders;
import androidx.media3.extractor.ts.PsExtractor;
import defpackage.bj4;
import defpackage.bs6;
import defpackage.fj4;
import defpackage.if7;
import defpackage.rq6;
import defpackage.sma;
import defpackage.t7a;

/* 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) {
        if7.f(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();
    }

    /* JADX WARN: Removed duplicated region for block: B:65:0x015f  */
    @sma
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    public static RtpPayloadFormat generatePayloadFormat(MediaDescription mediaDescription) {
        int iInferChannelCount;
        String str;
        Format.Builder builder = new Format.Builder();
        int i = mediaDescription.bitrate;
        if (i > 0) {
            builder.setAverageBitrate(i);
        }
        MediaDescription.RtpMapAttribute rtpMapAttribute = mediaDescription.rtpMapAttribute;
        int i2 = rtpMapAttribute.payloadType;
        String str2 = rtpMapAttribute.mediaEncoding;
        String mimeTypeFromRtpMediaType = RtpPayloadFormat.getMimeTypeFromRtpMediaType(str2);
        builder.setSampleMimeType(mimeTypeFromRtpMediaType);
        int i3 = mediaDescription.rtpMapAttribute.clockRate;
        if ("audio".equals(mediaDescription.mediaType)) {
            iInferChannelCount = inferChannelCount(mediaDescription.rtpMapAttribute.encodingParameters, mimeTypeFromRtpMediaType);
            builder.setSampleRate(i3).setChannelCount(iInferChannelCount);
        } else {
            iInferChannelCount = -1;
        }
        fj4<String, String> fmtpParametersAsMap = mediaDescription.getFmtpParametersAsMap();
        switch (mimeTypeFromRtpMediaType.hashCode()) {
            case -1664118616:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_H263)) {
                    builder.setWidth(352).setHeight(288);
                }
                break;
            case -1662541442:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_H265)) {
                    if7.f(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                    processH265FmtpAttribute(builder, fmtpParametersAsMap);
                }
                break;
            case -1606874997:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.AUDIO_AMR_WB)) {
                    if7.f(iInferChannelCount == 1, "Multi channel AMR is not currently supported.");
                    if7.f(!fmtpParametersAsMap.isEmpty(), "fmtp parameters must include octet-align.");
                    if7.f(fmtpParametersAsMap.containsKey(PARAMETER_AMR_OCTET_ALIGN), "Only octet aligned mode is currently supported.");
                    if7.f(!fmtpParametersAsMap.containsKey(PARAMETER_AMR_INTERLEAVING), "Interleaving mode is not currently supported.");
                }
                break;
            case -53558318:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.AUDIO_AAC)) {
                    if7.e(iInferChannelCount != -1);
                    if7.f(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                    if (str2.equals(RtpPayloadFormat.RTP_MEDIA_MPEG4_LATM_AUDIO)) {
                        if7.f(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 str3 = (String) fmtpParametersAsMap.get(PARAMETER_MP4A_CONFIG);
                        if7.l(str3, "AAC audio stream must include config fmtp parameter");
                        if7.h(str3.length() % 2 == 0, "Malformat MPEG4 config: %s", str3);
                        AacUtil.Config aacStreamMuxConfig = parseAacStreamMuxConfig(str3);
                        builder.setSampleRate(aacStreamMuxConfig.sampleRateHz).setChannelCount(aacStreamMuxConfig.channelCount).setCodecs(aacStreamMuxConfig.codecs);
                    }
                    processAacFmtpAttribute(builder, fmtpParametersAsMap, str2, iInferChannelCount, i3);
                }
                break;
            case 187078296:
                str = MimeTypes.AUDIO_AC3;
                mimeTypeFromRtpMediaType.equals(str);
                break;
            case 187094639:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.AUDIO_RAW)) {
                    builder.setPcmEncoding(RtpPayloadFormat.getRawPcmEncodingType(str2));
                }
                break;
            case 1187890754:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_MP4V)) {
                    if7.e(!fmtpParametersAsMap.isEmpty());
                    processMPEG4FmtpAttribute(builder, fmtpParametersAsMap);
                }
                break;
            case 1331836730:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_H264)) {
                    if7.f(!fmtpParametersAsMap.isEmpty(), "missing attribute fmtp");
                    processH264FmtpAttribute(builder, fmtpParametersAsMap);
                }
                break;
            case 1503095341:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.AUDIO_AMR_NB)) {
                }
                break;
            case 1504891608:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.AUDIO_OPUS)) {
                    if7.e(iInferChannelCount != -1);
                    if7.f(i3 == 48000, "Invalid OPUS clock rate.");
                }
                break;
            case 1599127256:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_VP8)) {
                    builder.setWidth(320).setHeight(PsExtractor.VIDEO_STREAM_MASK);
                }
                break;
            case 1599127257:
                if (mimeTypeFromRtpMediaType.equals(MimeTypes.VIDEO_VP9)) {
                    builder.setWidth(320).setHeight(PsExtractor.VIDEO_STREAM_MASK);
                }
                break;
            case 1903231877:
                str = MimeTypes.AUDIO_ALAW;
                mimeTypeFromRtpMediaType.equals(str);
                break;
            case 1903589369:
                str = MimeTypes.AUDIO_MLAW;
                mimeTypeFromRtpMediaType.equals(str);
                break;
        }
        if7.e(i3 > 0);
        return new RtpPayloadFormat(builder.build(), i2, i3, fmtpParametersAsMap, str2);
    }

    private static byte[] getInitializationDataFromParameterSet(String str) {
        byte[] bArrDecode = Base64.decode(str, 0);
        int length = bArrDecode.length;
        byte[] bArr = NalUnitUtil.NAL_START_CODE;
        byte[] bArr2 = new byte[length + bArr.length];
        System.arraycopy(bArr, 0, bArr2, 0, bArr.length);
        System.arraycopy(bArrDecode, 0, bArr2, bArr.length, bArrDecode.length);
        return bArr2;
    }

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

    private static AacUtil.Config parseAacStreamMuxConfig(String str) {
        ParsableBitArray parsableBitArray = new ParsableBitArray(Util.getBytesFromHexString(str));
        if7.f(parsableBitArray.readBits(1) == 0, "Only supports audio mux version 0.");
        if7.f(parsableBitArray.readBits(1) == 1, "Only supports allStreamsSameTimeFraming.");
        parsableBitArray.skipBits(6);
        if7.f(parsableBitArray.readBits(4) == 0, "Only supports one program.");
        if7.f(parsableBitArray.readBits(3) == 0, "Only supports one numLayer.");
        try {
            return AacUtil.parseAudioSpecificConfig(parsableBitArray, false);
        } catch (ParserException e) {
            throw new IllegalArgumentException(e);
        }
    }

    private static void processAacFmtpAttribute(Format.Builder builder, fj4<String, String> fj4Var, String str, int i, int i2) {
        String str2 = (String) fj4Var.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str2 == null && str.equals(RtpPayloadFormat.RTP_MEDIA_MPEG4_LATM_AUDIO)) {
            str2 = "30";
        }
        if7.f((str2 == null || str2.isEmpty()) ? false : true, "missing profile-level-id param");
        builder.setCodecs(AAC_CODECS_PREFIX + str2);
        builder.setInitializationData(bj4.r(AacUtil.buildAacLcAudioSpecificConfig(i2, i)));
    }

    private static void processH264FmtpAttribute(Format.Builder builder, fj4<String, String> fj4Var) {
        if7.f(fj4Var.containsKey(PARAMETER_SPROP_PARAMS), "missing sprop parameter");
        String str = (String) fj4Var.get(PARAMETER_SPROP_PARAMS);
        str.getClass();
        String[] strArrSplit = Util.split(str, ",");
        if7.f(strArrSplit.length == 2, "empty sprop value");
        bj4 bj4VarS = bj4.s(getInitializationDataFromParameterSet(strArrSplit[0]), getInitializationDataFromParameterSet(strArrSplit[1]));
        builder.setInitializationData(bj4VarS);
        byte[] bArr = bj4VarS.get(0);
        NalUnitUtil.SpsData spsNalUnit = NalUnitUtil.parseSpsNalUnit(bArr, NalUnitUtil.NAL_START_CODE.length, bArr.length);
        builder.setPixelWidthHeightRatio(spsNalUnit.pixelWidthHeightRatio);
        builder.setHeight(spsNalUnit.height);
        builder.setWidth(spsNalUnit.width);
        builder.setColorInfo(new ColorInfo.Builder().setColorSpace(spsNalUnit.colorSpace).setColorRange(spsNalUnit.colorRange).setColorTransfer(spsNalUnit.colorTransfer).setLumaBitdepth(spsNalUnit.bitDepthLumaMinus8 + 8).setChromaBitdepth(spsNalUnit.bitDepthChromaMinus8 + 8).build());
        String str2 = (String) fj4Var.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str2 != null) {
            builder.setCodecs(H264_CODECS_PREFIX.concat(str2));
        } else {
            builder.setCodecs(CodecSpecificDataUtil.buildAvcCodecString(spsNalUnit.profileIdc, spsNalUnit.constraintsFlagsAndReservedZero2Bits, spsNalUnit.levelIdc));
        }
    }

    private static void processH265FmtpAttribute(Format.Builder builder, fj4<String, String> fj4Var) {
        if (fj4Var.containsKey(PARAMETER_H265_SPROP_MAX_DON_DIFF)) {
            String str = (String) fj4Var.get(PARAMETER_H265_SPROP_MAX_DON_DIFF);
            str.getClass();
            int i = Integer.parseInt(str);
            if7.c("non-zero sprop-max-don-diff %s is not supported", i, i == 0);
        }
        if7.f(fj4Var.containsKey(PARAMETER_H265_SPROP_VPS), "missing sprop-vps parameter");
        String str2 = (String) fj4Var.get(PARAMETER_H265_SPROP_VPS);
        str2.getClass();
        if7.f(fj4Var.containsKey(PARAMETER_H265_SPROP_SPS), "missing sprop-sps parameter");
        String str3 = (String) fj4Var.get(PARAMETER_H265_SPROP_SPS);
        str3.getClass();
        if7.f(fj4Var.containsKey(PARAMETER_H265_SPROP_PPS), "missing sprop-pps parameter");
        String str4 = (String) fj4Var.get(PARAMETER_H265_SPROP_PPS);
        str4.getClass();
        byte[] initializationDataFromParameterSet = getInitializationDataFromParameterSet(str2);
        byte[] initializationDataFromParameterSet2 = getInitializationDataFromParameterSet(str3);
        byte[] initializationDataFromParameterSet3 = getInitializationDataFromParameterSet(str4);
        t7a t7aVar = bj4.b;
        Object[] objArr = {initializationDataFromParameterSet, initializationDataFromParameterSet2, initializationDataFromParameterSet3};
        bs6.a(3, objArr);
        bj4 bj4VarH = bj4.h(3, objArr);
        builder.setInitializationData(bj4VarH);
        byte[] bArr = bj4VarH.get(1);
        NalUnitUtil.H265SpsData h265SpsNalUnit = NalUnitUtil.parseH265SpsNalUnit(bArr, NalUnitUtil.NAL_START_CODE.length, bArr.length, null);
        builder.setPixelWidthHeightRatio(h265SpsNalUnit.pixelWidthHeightRatio);
        builder.setHeight(h265SpsNalUnit.height).setWidth(h265SpsNalUnit.width);
        builder.setColorInfo(new ColorInfo.Builder().setColorSpace(h265SpsNalUnit.colorSpace).setColorRange(h265SpsNalUnit.colorRange).setColorTransfer(h265SpsNalUnit.colorTransfer).setLumaBitdepth(h265SpsNalUnit.bitDepthLumaMinus8 + 8).setChromaBitdepth(h265SpsNalUnit.bitDepthChromaMinus8 + 8).build());
        NalUnitUtil.H265ProfileTierLevel h265ProfileTierLevel = h265SpsNalUnit.profileTierLevel;
        if (h265ProfileTierLevel != null) {
            builder.setCodecs(CodecSpecificDataUtil.buildHevcCodecString(h265ProfileTierLevel.generalProfileSpace, h265ProfileTierLevel.generalTierFlag, h265ProfileTierLevel.generalProfileIdc, h265ProfileTierLevel.generalProfileCompatibilityFlags, h265ProfileTierLevel.constraintBytes, h265ProfileTierLevel.generalLevelIdc));
        }
    }

    private static void processMPEG4FmtpAttribute(Format.Builder builder, fj4<String, String> fj4Var) {
        String str = (String) fj4Var.get(PARAMETER_MP4A_CONFIG);
        if (str != null) {
            byte[] bytesFromHexString = Util.getBytesFromHexString(str);
            builder.setInitializationData(bj4.r(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) fj4Var.get(PARAMETER_PROFILE_LEVEL_ID);
        if (str2 == null) {
            str2 = IcyHeaders.REQUEST_HEADER_ENABLE_METADATA_VALUE;
        }
        builder.setCodecs(MPEG4_CODECS_PREFIX.concat(str2));
    }

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

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