| /** |
| * Copyright (C) 2022 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef IMS_MEDIA_DEFINE_H |
| #define IMS_MEDIA_DEFINE_H |
| |
| #include <RtpConfig.h> |
| #include <AudioConfig.h> |
| #include <string.h> |
| |
| #define DEFAULT_MTU 1500 |
| #define SEQ_ROUND_QUARD 655 // 1% of FFFF |
| #define USHORT_SEQ_ROUND_COMPARE(a, b) \ |
| ((((a) >= (b)) && (((b) >= SEQ_ROUND_QUARD) || (((a) <= 0xffff - SEQ_ROUND_QUARD)))) || \ |
| (((a) <= SEQ_ROUND_QUARD) && ((b) >= 0xffff - SEQ_ROUND_QUARD))) |
| #define TS_ROUND_QUARD 3000 |
| #define USHORT_TS_ROUND_COMPARE(a, b) \ |
| (((a) >= (b) && (b) >= TS_ROUND_QUARD) || ((a) <= 0xffff - TS_ROUND_QUARD) || \ |
| ((a) <= TS_ROUND_QUARD && (b) >= 0xffff - TS_ROUND_QUARD)) |
| |
| using namespace android::telephony::imsmedia; |
| |
| enum ImsMediaResult |
| { |
| RESULT_SUCCESS = 0, |
| RESULT_INVALID_PARAM, |
| RESULT_NOT_READY, |
| RESULT_NO_MEMORY, |
| RESULT_NO_RESOURCES, |
| RESULT_PORT_UNAVAILABLE, |
| RESULT_NOT_SUPPORTED, |
| }; |
| |
| enum kImsMediaEventType |
| { |
| kImsMediaEventNotifyError = 0, |
| kImsMediaEventStateChanged, |
| kImsMediaEventFirstPacketReceived, |
| kImsMediaEventHeaderExtensionReceived, |
| kImsMediaEventMediaQualityStatus, |
| kImsMediaEventMediaInactivity, |
| kImsMediaEventResolutionChanged, |
| kImsMediaEventNotifyVideoDataUsage, |
| kImsMediaEventNotifyRttReceived, |
| }; |
| |
| // Internal Request Event |
| enum kImsMediaInternalRequestType |
| { |
| kRequestAudioCmr = 300, |
| kRequestAudioRttdUpdate, |
| kRequestAudioCmrEvs, |
| kRequestVideoCvoUpdate, |
| kRequestVideoBitrateChange, |
| kRequestVideoIdrFrame, |
| kRequestVideoSendNack, |
| kRequestVideoSendPictureLost, |
| kRequestVideoSendTmmbr, |
| kRequestVideoSendTmmbn, |
| kRequestRoundTripTimeDelayUpdate = 310, |
| kCollectPacketInfo, |
| kCollectOptionalInfo, |
| kCollectRxRtpStatus, |
| kCollectJitterBufferSize, |
| kGetRtcpXrReportBlock, |
| kRequestSendRtcpXrReport, |
| }; |
| |
| enum kImsMediaErrorNotify |
| { |
| kNotifyErrorSocket = 400, |
| kNotifyErrorSurfaceNotReady, |
| kNotifyErrorCamera, |
| kNotifyErrorEncoder, |
| kNotifyErrorDecoder, |
| }; |
| |
| enum ImsMediaStreamType |
| { |
| kStreamRtpTx, |
| kStreamRtpRx, |
| kStreamRtcp, |
| }; |
| |
| enum kImsMediaStreamType |
| { |
| kStreamModeRtpTx, |
| kStreamModeRtpRx, |
| kStreamModeRtcp, |
| }; |
| |
| enum ImsMediaType |
| { |
| IMS_MEDIA_AUDIO = 0, |
| IMS_MEDIA_VIDEO, |
| IMS_MEDIA_TEXT, |
| }; |
| |
| enum kProtocolType |
| { |
| kProtocolRtp = 0, |
| kProtocolRtcp, |
| }; |
| |
| enum kEvsBandwidth |
| { |
| kEvsBandwidthNone = 0, |
| kEvsBandwidthNB = 1, |
| kEvsBandwidthWB = 2, |
| kEvsBandwidthSWB = 4, |
| kEvsBandwidthFB = 8, |
| }; |
| |
| enum kEvsBitrate |
| { |
| /* 6.6 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate00660 = 0, |
| /* 8.85 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate00885 = 1, |
| /* 12.65 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate01265 = 2, |
| /* 14.25 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate01425 = 3, |
| /* 15.85 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate01585 = 4, |
| /* 18.25 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate01825 = 5, |
| /* 19.85 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate01985 = 6, |
| /* 23.05 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate02305 = 7, |
| /* 23.85 kbps, AMR-IO */ |
| kEvsAmrIoModeBitrate02385 = 8, |
| /* 5.9 kbps, EVS Primary - SC-VBR 2.8kbps, 7.2kbps, 8kbps*/ |
| kEvsPrimaryModeBitrate00590 = 9, |
| /* 7.2 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate00720 = 10, |
| /* 8 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate00800 = 11, |
| /* 9.6 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate00960 = 12, |
| /* 13.20 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate01320 = 13, |
| /* 16.4 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate01640 = 14, |
| /* 24.4 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate02440 = 15, |
| /* 32 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate03200 = 16, |
| /* 48 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate04800 = 17, |
| /* 64 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate06400 = 18, |
| /* 96 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate09600 = 19, |
| /* 128 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrate12800 = 20, |
| /* 2.4 kbps, EVS Primary */ |
| kEvsPrimaryModeBitrateSID = 21, |
| /* SPEECH LOST */ |
| kEvsPrimaryModeBitrateSpeechLost = 22, |
| /* NO DATA */ |
| kEvsPrimaryModeBitrateNoData = 23, |
| }; |
| |
| enum kEvsCodecMode |
| { |
| kEvsCodecModePrimary = 0, // EVS PRIMARY mode 0 |
| kEvsCodecModeAmrIo = 1, // EVS AMR-WB IO mode 1 |
| kEvsCodecModeMax = 0x7FFFFFFF |
| }; |
| |
| /* CMR Code in TS 26.445 */ |
| enum kEvsCmrCodeType |
| { |
| kEvsCmrCodeTypeNb = 0, // 000: Narrow band |
| kEvsCmrCodeTypeAmrIO = 1, // 001: AMR IO mode |
| kEvsCmrCodeTypeWb = 2, // 010: Wide band |
| kEvsCmrCodeTypeSwb = 3, // 011: Super wide band |
| kEvsCmrCodeTypeFb = 4, // 100: Full band |
| kEvsCmrCodeTypeWbCha = 5, // 101: Wide band(13.2 Channel aware mode) |
| kEvsCmrCodeTypeSwbCha = 6, // 110: Super wide band (13.2 Channel aware mode) |
| kEvsCmrCodeTypeNoReq = 7, // 111: Reserved |
| }; |
| |
| /* CMR Definition in TS 26.445 */ |
| enum kEvsCmrCodeDefine |
| { |
| kEvsCmrCodeDefine59 = 0, // 0000 |
| kEvsCmrCodeDefine72 = 1, // 0001 |
| kEvsCmrCodeDefine80 = 2, // 0010 |
| kEvsCmrCodeDefine96 = 3, // 0011 |
| kEvsCmrCodeDefine132 = 4, // 0100 |
| kEvsCmrCodeDefine164 = 5, // 0101 |
| kEvsCmrCodeDefine244 = 6, // 0110 |
| kEvsCmrCodeDefine320 = 7, // 0111 |
| kEvsCmrCodeDefine480 = 8, // 1000 |
| kEvsCmrCodeDefine640 = 9, // 1001 |
| kEvsCmrCodeDefine960 = 10, // 1010 |
| kEvsCmrCodeDefine1280 = 11, // 1011 |
| kEvsCmrCodeDefineNoReq = 15, // 1111 |
| |
| // Channel aware mode |
| kEvsCmrCodeDefineChaOffset2 = 0, // 0000 |
| kEvsCmrCodeDefineChaOffset3 = 1, // 0001 |
| kEvsCmrCodeDefineChaOffset5 = 2, // 0010 |
| kEvsCmrCodeDefineChaOffset7 = 3, // 0011 |
| kEvsCmrCodeDefineChaOffsetH2 = 4, // 0100 |
| kEvsCmrCodeDefineChaOffsetH3 = 5, // 0101 |
| kEvsCmrCodeDefineChaOffsetH5 = 6, // 0110 |
| kEvsCmrCodeDefineChaOffsetH7 = 7, // 0111 |
| |
| // AMR WB-IO |
| kEvsCmrCodeDefineAmrIo660 = 0, // 0000 |
| kEvsCmrCodeDefineAmrIo885 = 1, // 0001 |
| kEvsCmrCodeDefineAmrIo1265 = 2, // 0010 |
| kEvsCmrCodeDefineAmrIo1425 = 3, // 0011 |
| kEvsCmrCodeDefineAmrIo1585 = 4, // 0100 |
| kEvsCmrCodeDefineAmrIo1825 = 5, // 0101 |
| kEvsCmrCodeDefineAmrIo1985 = 6, // 0110 |
| kEvsCmrCodeDefineAmrIo2305 = 7, // 0111 |
| kEvsCmrCodeDefineAmrIo2385 = 8, // 1000 |
| |
| kEvsCmrCodeDefineENUM_MAX = 0x7FFFFFFF |
| }; |
| |
| enum ImsMediaSubType |
| { |
| MEDIASUBTYPE_UNDEFINED = 0, |
| // rtp payload header + encoded bitstream |
| MEDIASUBTYPE_RTPPAYLOAD, |
| // rtp packet |
| MEDIASUBTYPE_RTPPACKET, |
| // rtcp packet |
| MEDIASUBTYPE_RTCPPACKET, |
| // rtcp packet |
| MEDIASUBTYPE_RTCPPACKET_BYE, |
| // raw yuv or pcm data |
| MEDIASUBTYPE_RAWDATA, |
| MEDIASUBTYPE_RAWDATA_ROT90, |
| MEDIASUBTYPE_RAWDATA_ROT90_FLIP, |
| MEDIASUBTYPE_RAWDATA_ROT270, |
| MEDIASUBTYPE_RAWDATA_CROP_ROT90, |
| MEDIASUBTYPE_RAWDATA_CROP_ROT90_FLIP, |
| MEDIASUBTYPE_RAWDATA_CROP_ROT270, |
| MEDIASUBTYPE_RAWDATA_CROP, |
| // dtmf packet with start bit set |
| MEDIASUBTYPE_DTMFSTART, |
| // dtmf payload |
| MEDIASUBTYPE_DTMF_PAYLOAD, |
| // dtmf packet with end bit set |
| MEDIASUBTYPE_DTMFEND, |
| MEDIASUBTYPE_VIDEO_CONFIGSTRING, |
| MEDIASUBTYPE_VIDEO_IDR_FRAME, |
| MEDIASUBTYPE_VIDEO_NON_IDR_FRAME, |
| MEDIASUBTYPE_VIDEO_SEI_FRAME, |
| MEDIASUBTYPE_ROT0 = 20, |
| MEDIASUBTYPE_ROT90, |
| MEDIASUBTYPE_ROT180, |
| MEDIASUBTYPE_ROT270, |
| MEDIASUBTYPE_REFRESHED, |
| // rtt bitstream of t.140 format |
| MEDIASUBTYPE_BITSTREAM_T140, |
| // rtt bitstream of t.140 redundant format |
| MEDIASUBTYPE_BITSTREAM_T140_RED, |
| MEDIASUBTYPE_PCM_DATA, |
| MEDIASUBTYPE_PCM_NO_DATA, |
| // Jitter Buffer GetData not ready |
| MEDIASUBTYPE_NOT_READY, |
| MEDIASUBTYPE_BITSTREAM_CODECCONFIG, |
| MEDIASUBTYPE_MAX |
| }; |
| |
| enum ImsMediaAudioMsgRequest |
| { |
| kAudioOpenSession = 101, |
| kAudioCloseSession, |
| kAudioModifySession, |
| kAudioAddConfig, |
| kAudioDeleteConfig, |
| kAudioConfirmConfig, |
| kAudioSendDtmf, |
| kAudioSendHeaderExtension, |
| kAudioSetMediaQualityThreshold, |
| }; |
| |
| enum ImsMediaAudioMsgResponse |
| { |
| kAudioOpenSessionSuccess = 201, |
| kAudioOpenSessionFailure, |
| kAudioModifySessionResponse, |
| kAudioAddConfigResponse, |
| kAudioConfirmConfigResponse, |
| kAudioFirstMediaPacketInd, |
| kAudioRtpHeaderExtensionInd, |
| kAudioMediaQualityStatusInd, |
| kAudioTriggerAnbrQueryInd, |
| kAudioDtmfReceivedInd, |
| kAudioCallQualityChangedInd, |
| kAudioSessionClosed, |
| }; |
| |
| enum ImsMediaVideoMsgRequest |
| { |
| kVideoOpenSession = 101, |
| kVideoCloseSession, |
| kVideoModifySession, |
| kVideoSetPreviewSurface, |
| kVideoSetDisplaySurface, |
| kVideoSendHeaderExtension, |
| kVideoSetMediaQualityThreshold, |
| kVideoRequestDataUsage, |
| }; |
| |
| enum ImsMediaVideoMsgResponse |
| { |
| kVideoOpenSessionSuccess = 201, |
| kVideoOpenSessionFailure, |
| kVideoModifySessionResponse, |
| kVideoFirstMediaPacketInd, |
| kVideoPeerDimensionChanged, |
| kVideoRtpHeaderExtensionInd, |
| kVideoMediaInactivityInd, |
| kVideoPacketLossInd, |
| kVideoDataUsageInd, |
| kVideoSessionClosed, |
| }; |
| |
| enum ImsMediaTextMsgRequest |
| { |
| kTextOpenSession = 101, |
| kTextCloseSession, |
| kTextModifySession, |
| kTextSetMediaQualityThreshold, |
| kTextSendRtt, |
| }; |
| |
| enum ImsMediaTextMsgResponse |
| { |
| kTextOpenSessionSuccess = 201, |
| kTextOpenSessionFailure, |
| kTextModifySessionResponse, |
| kTextMediaInactivityInd, |
| kTextRttReceived, |
| kTextSessionClosed, |
| }; |
| |
| #define UNDEFINED_SOCKET_FD (-1) |
| #define T140_BUFFERING_TIME (300) |
| #define RTT_MAX_CHAR_PER_SEC (30) // ATIS_GTT : 30 characters per second |
| #define RTT_MAX_UNICODE_UTF8 (4) |
| #define MAX_RTT_LEN (RTT_MAX_CHAR_PER_SEC * RTT_MAX_UNICODE_UTF8) |
| #define T140_MAX_CHUNK (1) |
| #define PAYLOADENCODER_TEXT_MAX_REDUNDANT_INTERVAL (16383) |
| |
| struct EventParamOpenSession |
| { |
| public: |
| void* mConfig; |
| int rtpFd; |
| int rtcpFd; |
| EventParamOpenSession( |
| int rtp = UNDEFINED_SOCKET_FD, int rtcp = UNDEFINED_SOCKET_FD, void* config = nullptr) : |
| mConfig(config), |
| rtpFd(rtp), |
| rtcpFd(rtcp) |
| { |
| } |
| }; |
| |
| struct EventParamDtmf |
| { |
| public: |
| char digit; |
| int duration; |
| |
| EventParamDtmf(char dig, int d) |
| { |
| digit = dig; |
| duration = d; |
| } |
| }; |
| |
| enum kAudioCodecType |
| { |
| kAudioCodecNone = 0, |
| kAudioCodecAmr, |
| kAudioCodecAmrWb, |
| kAudioCodecPcmu, |
| kAudioCodecPcma, |
| kAudioCodecEvs, |
| }; |
| |
| enum kVideoCodecType |
| { |
| kVideoCodecNone = 0, |
| kVideoCodecAvc, |
| kVideoCodecHevc, |
| }; |
| |
| enum kRtpPyaloadHeaderMode |
| { |
| // Amr mode |
| kRtpPyaloadHeaderModeAmrOctetAligned = 0, // octet aligned mode |
| kRtpPyaloadHeaderModeAmrEfficient = 1, // efficient mode |
| // Video packetization mode |
| kRtpPyaloadHeaderModeSingleNalUnit = 0, // packet mode 0 |
| kRtpPyaloadHeaderModeNonInterleaved = 1, // packet mode 1 |
| // Evs mode |
| kRtpPyaloadHeaderModeEvsCompact = 0, // EVS compact format 0 |
| kRtpPyaloadHeaderModeEvsHeaderFull = 1, // EVS header-full format 1 |
| kRtpPyaloadHeaderModeMax |
| }; |
| |
| enum kIpVersion |
| { |
| IPV4, |
| IPV6, |
| }; |
| |
| enum StreamState |
| { |
| /** The state of the stream created but any nodes are not created */ |
| kStreamStateIdle, |
| /** The state of the stream and nodes are created */ |
| kStreamStateCreated, |
| /** The state of the stream nodes are started and running */ |
| kStreamStateRunning, |
| /** Video state wait surface in stating */ |
| kStreamStateWaitSurface, |
| }; |
| |
| enum SessionState |
| { |
| /** The state that the session is created but graph is not created */ |
| kSessionStateOpened, |
| /** The state that the session is created and the Rtp StreamGraphs are running */ |
| kSessionStateActive, |
| /** The state that the session is created and the Rtp StreamGraphs is not running */ |
| kSessionStateSuspended, |
| /** The state that the session is closed */ |
| kSessionStateClosed, |
| }; |
| |
| enum kSocketOption |
| { |
| kSocketOptionNone = 0, |
| kSocketOptionIpTos = 1, |
| kSocketOptionIpTtl = 2, |
| }; |
| |
| enum kRtpPacketStatus |
| { |
| kRtpStatusNotDefined = 0, |
| kRtpStatusNormal, |
| kRtpStatusLate, |
| kRtpStatusDiscarded, |
| kRtpStatusDuplicated, |
| kRtpStatusLost, |
| }; |
| |
| enum kRtpDataType |
| { |
| kRtpDataTypeNoData = 0, |
| kRtpDataTypeSid, |
| kRtpDataTypeNormal, |
| }; |
| |
| enum kRtpOptionalType |
| { |
| kTimeToLive, |
| kRoundTripDelay, |
| kReportPacketLossGap, |
| }; |
| |
| /** TODO: change the name to avoid confusion by similarity */ |
| struct RtpPacket |
| { |
| public: |
| RtpPacket() : |
| ssrc(0), |
| seqNum(0), |
| TTL(0), |
| jitter(0), |
| arrival(0), |
| rtpDataType(kRtpDataTypeNoData), |
| status(kRtpStatusNotDefined) |
| { |
| } |
| RtpPacket(const RtpPacket& p) |
| { |
| ssrc = p.ssrc; |
| seqNum = p.seqNum; |
| TTL = p.TTL; |
| jitter = p.jitter; |
| arrival = p.arrival; |
| rtpDataType = p.rtpDataType; |
| status = p.status; |
| } |
| |
| uint32_t ssrc; |
| uint32_t seqNum; |
| uint32_t TTL; |
| /** transit time difference */ |
| int32_t jitter; |
| /** arrival time */ |
| int32_t arrival; |
| kRtpDataType rtpDataType; |
| kRtpPacketStatus status; |
| }; |
| |
| /** |
| * @brief It is lost packet data structure to store the start number of packet sequence and the |
| * number of lost packets |
| */ |
| struct LostPacket |
| { |
| public: |
| LostPacket(uint16_t s = 0, uint32_t num = 0, uint32_t time = 0, uint32_t opt = 0) : |
| seqNum(s), |
| numLoss(num), |
| markedTime(time), |
| option(opt) |
| { |
| } |
| /** The rtp sequence number of beginning of lost packet */ |
| uint16_t seqNum; |
| /** The number of lost packets */ |
| uint32_t numLoss; |
| /** The time in milliseconds when determined to lost */ |
| uint32_t markedTime; |
| /** optional parameter for nack */ |
| uint32_t option; |
| }; |
| |
| struct tRtpHeaderExtensionInfo |
| { |
| uint16_t nDefinedByProfile; |
| uint16_t nLength; |
| uint16_t nExtensionData; |
| tRtpHeaderExtensionInfo(uint16_t profile = 0, uint16_t length = 0, uint16_t data = 0) |
| { |
| nDefinedByProfile = profile; |
| nLength = length; |
| nExtensionData = data; |
| } |
| tRtpHeaderExtensionInfo& operator=(const tRtpHeaderExtensionInfo& extension) |
| { |
| if (this != &extension) |
| { |
| nDefinedByProfile = extension.nDefinedByProfile; |
| nLength = extension.nLength; |
| nExtensionData = extension.nExtensionData; |
| } |
| |
| return *this; |
| } |
| }; |
| |
| #define MAX_IP_LEN 128 |
| #define MAX_REMOTE_POINT 40 |
| |
| class RtpAddress |
| { |
| public: |
| RtpAddress(const char* ip = nullptr, uint32_t p = 0) |
| { |
| memset(this->ipAddress, 0, MAX_IP_LEN); |
| if (ip != nullptr) |
| { |
| std::strncpy(ipAddress, ip, MAX_IP_LEN); |
| } |
| port = p; |
| } |
| ~RtpAddress() {} |
| RtpAddress(const RtpAddress& address) : |
| port(address.port) |
| { |
| memset(this->ipAddress, 0, MAX_IP_LEN); |
| std::strncpy(this->ipAddress, address.ipAddress, MAX_IP_LEN); |
| } |
| RtpAddress& operator=(const RtpAddress& address) |
| { |
| if (this != &address) |
| { |
| memset(this->ipAddress, 0, MAX_IP_LEN); |
| std::strncpy(this->ipAddress, address.ipAddress, MAX_IP_LEN); |
| this->port = address.port; |
| } |
| |
| return *this; |
| } |
| bool operator==(const RtpAddress& address) |
| { |
| return (std::strcmp(this->ipAddress, address.ipAddress) == 0 && this->port == address.port); |
| } |
| bool operator!=(const RtpAddress& address) |
| { |
| return (std::strcmp(this->ipAddress, address.ipAddress) != 0 || this->port != address.port); |
| } |
| char ipAddress[MAX_IP_LEN]; |
| uint32_t port; |
| }; |
| |
| #endif |