1 /**
2 * Copyright (C) 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <IRtpSession.h>
18 #include <RtpService.h>
19 #include <ImsMediaTrace.h>
20 #include <ImsMediaVideoUtil.h>
21
22 std::list<IRtpSession*> IRtpSession::mListRtpSession;
23
GetInstance(ImsMediaType type,const RtpAddress & localAddress,const RtpAddress & peerAddress)24 IRtpSession* IRtpSession::GetInstance(
25 ImsMediaType type, const RtpAddress& localAddress, const RtpAddress& peerAddress)
26 {
27 IMLOGD1("[GetInstance] media[%d]", type);
28
29 for (auto& i : mListRtpSession)
30 {
31 if (i != nullptr && i->isSameInstance(type, localAddress, peerAddress))
32 {
33 i->increaseRefCounter();
34 return i;
35 }
36 }
37
38 if (mListRtpSession.size() == 0)
39 {
40 IMLOGI0("[GetInstance] Initialize Rtp Stack");
41 IMS_RtpSvc_Initialize();
42 }
43
44 IRtpSession* pSession = new IRtpSession(type, localAddress, peerAddress);
45 mListRtpSession.push_back(pSession);
46 pSession->increaseRefCounter();
47 return pSession;
48 }
49
ReleaseInstance(IRtpSession * session)50 void IRtpSession::ReleaseInstance(IRtpSession* session)
51 {
52 if (session == nullptr)
53 {
54 return;
55 }
56
57 IMLOGD2("[ReleaseInstance] media[%d], RefCount[%d]", session->getMediaType(),
58 session->getRefCounter());
59 session->decreaseRefCounter();
60
61 if (session->getRefCounter() == 0)
62 {
63 mListRtpSession.remove(session);
64 delete session;
65 }
66
67 if (mListRtpSession.size() == 0)
68 {
69 IMLOGI0("[ReleaseInstance] Deinitialize Rtp Stack");
70 IMS_RtpSvc_Deinitialize();
71 }
72 }
73
IRtpSession(ImsMediaType mediatype,const RtpAddress & localAddress,const RtpAddress & peerAddress)74 IRtpSession::IRtpSession(
75 ImsMediaType mediatype, const RtpAddress& localAddress, const RtpAddress& peerAddress)
76 {
77 mMediaType = mediatype;
78 mRtpSessionId = 0;
79 mRefCount = 0;
80 mLocalAddress = localAddress;
81 mPeerAddress = peerAddress;
82 mRtpEncoderListener = nullptr;
83 mRtpDecoderListener = nullptr;
84 mRtcpEncoderListener = nullptr;
85 mRtcpDecoderListener = nullptr;
86 std::memset(mPayloadParam, 0, sizeof(tRtpSvc_SetPayloadParam) * MAX_NUM_PAYLOAD_PARAM);
87 mNumPayloadParam = 0;
88 mLocalRtpSsrc = 0;
89 mPeerRtpSsrc = 0;
90 mEnableRtcpTx = false;
91 mEnableDTMF = false;
92 mRtpDtmfPayloadType = 0;
93 mPrevTimestamp = -1;
94 mRtpStarted = 0;
95 mRtcpStarted = 0;
96 mNumRtpProcPacket = 0;
97 mNumRtcpProcPacket = 0;
98 mNumRtpPacket = 0;
99 mNumSRPacket = 0;
100 mNumRRPacket = 0;
101 mNumRtpDataToSend = 0;
102 mNumRtpPacketSent = 0;
103 mNumRtcpPacketSent = 0;
104 mRttd = -1;
105
106 // create rtp stack session
107 IMS_RtpSvc_CreateSession(
108 mLocalAddress.ipAddress, mLocalAddress.port, this, &mLocalRtpSsrc, &mRtpSessionId);
109 IMLOGD6("[IRtpSession] media[%d], localIp[%s], localPort[%d], peerIp[%s], peerPort[%d], "
110 "sessionId[%d]",
111 mMediaType, mLocalAddress.ipAddress, mLocalAddress.port, mPeerAddress.ipAddress,
112 mPeerAddress.port, mRtpSessionId);
113 }
114
~IRtpSession()115 IRtpSession::~IRtpSession()
116 {
117 IMS_RtpSvc_DeleteSession(mRtpSessionId);
118 mRtpEncoderListener = nullptr;
119 mRtpDecoderListener = nullptr;
120 mRtcpEncoderListener = nullptr;
121 mRtcpDecoderListener = nullptr;
122 }
123
operator ==(const IRtpSession & obj2)124 bool IRtpSession::operator==(const IRtpSession& obj2)
125 {
126 if (mMediaType == obj2.mMediaType && mLocalAddress == obj2.mLocalAddress &&
127 mPeerAddress == obj2.mPeerAddress)
128 {
129 return true;
130 }
131
132 return false;
133 }
134
isSameInstance(ImsMediaType mediatype,const RtpAddress & localAddress,const RtpAddress & peerAddress)135 bool IRtpSession::isSameInstance(
136 ImsMediaType mediatype, const RtpAddress& localAddress, const RtpAddress& peerAddress)
137 {
138 if (mMediaType == mediatype && mLocalAddress == localAddress && mPeerAddress == peerAddress)
139 {
140 return true;
141 }
142
143 return false;
144 }
145
SetRtpEncoderListener(IRtpEncoderListener * pRtpEncoderListener)146 void IRtpSession::SetRtpEncoderListener(IRtpEncoderListener* pRtpEncoderListener)
147 {
148 std::lock_guard<std::mutex> guard(mutexEncoder);
149 mRtpEncoderListener = pRtpEncoderListener;
150 }
151
SetRtpDecoderListener(IRtpDecoderListener * pRtpDecoderListener)152 void IRtpSession::SetRtpDecoderListener(IRtpDecoderListener* pRtpDecoderListener)
153 {
154 std::lock_guard<std::mutex> guard(mutexDecoder);
155 mRtpDecoderListener = pRtpDecoderListener;
156 }
157
SetRtcpEncoderListener(IRtcpEncoderListener * pRtcpEncoderListener)158 void IRtpSession::SetRtcpEncoderListener(IRtcpEncoderListener* pRtcpEncoderListener)
159 {
160 std::lock_guard<std::mutex> guard(mutexEncoder);
161 mRtcpEncoderListener = pRtcpEncoderListener;
162 }
163
SetRtcpDecoderListener(IRtcpDecoderListener * pRtcpDecoderListener)164 void IRtpSession::SetRtcpDecoderListener(IRtcpDecoderListener* pRtcpDecoderListener)
165 {
166 std::lock_guard<std::mutex> guard(mutexDecoder);
167 mRtcpDecoderListener = pRtcpDecoderListener;
168 }
169
SetRtpPayloadParam(int32_t payloadNumTx,int32_t payloadNumRx,int32_t samplingRate,int32_t subTxPayloadTypeNum,int32_t subRxPayloadTypeNum,int32_t subSamplingRate)170 void IRtpSession::SetRtpPayloadParam(int32_t payloadNumTx, int32_t payloadNumRx,
171 int32_t samplingRate, int32_t subTxPayloadTypeNum, int32_t subRxPayloadTypeNum,
172 int32_t subSamplingRate)
173 {
174 mNumPayloadParam = 0;
175 std::memset(mPayloadParam, 0, sizeof(tRtpSvc_SetPayloadParam) * MAX_NUM_PAYLOAD_PARAM);
176 IMLOGD3("[SetRtpPayloadParam] localPayload[%d], peerPayload[%d], sampling[%d]", payloadNumTx,
177 payloadNumRx, samplingRate);
178
179 mPayloadParam[mNumPayloadParam].frameInterval = 100; // not used in stack
180 mPayloadParam[mNumPayloadParam].payloadType = payloadNumTx;
181 mPayloadParam[mNumPayloadParam].samplingRate = samplingRate;
182 mNumPayloadParam++;
183
184 if (payloadNumTx != payloadNumRx)
185 {
186 mPayloadParam[mNumPayloadParam].frameInterval = 100; // not used in stack
187 mPayloadParam[mNumPayloadParam].payloadType = payloadNumRx;
188 mPayloadParam[mNumPayloadParam].samplingRate = samplingRate;
189 mNumPayloadParam++;
190 }
191
192 if (mMediaType == IMS_MEDIA_AUDIO || mMediaType == IMS_MEDIA_TEXT)
193 {
194 mEnableDTMF = false;
195
196 if (subTxPayloadTypeNum != 0 && subRxPayloadTypeNum != 0)
197 {
198 IMLOGD3("[SetRtpPayloadParam] sub Txpayload[%d],sub Rxpayload[%d],sub samplingRate[%d]",
199 subTxPayloadTypeNum, subRxPayloadTypeNum, subSamplingRate);
200
201 if (mNumPayloadParam >= MAX_NUM_PAYLOAD_PARAM)
202 {
203 IMLOGE1("[SetRtpPayloadParam] overflow[%d]", mNumPayloadParam);
204 }
205 else
206 {
207 if (mMediaType == IMS_MEDIA_AUDIO)
208 {
209 mEnableDTMF = true;
210 }
211
212 mPayloadParam[mNumPayloadParam].frameInterval = 100; // not used in stack
213 mPayloadParam[mNumPayloadParam].payloadType = subTxPayloadTypeNum;
214 mPayloadParam[mNumPayloadParam].samplingRate = subSamplingRate;
215 mNumPayloadParam++;
216
217 if (subTxPayloadTypeNum != subRxPayloadTypeNum)
218 {
219 mPayloadParam[mNumPayloadParam].frameInterval = 100; // not used in stack
220 mPayloadParam[mNumPayloadParam].payloadType = subRxPayloadTypeNum;
221 mPayloadParam[mNumPayloadParam].samplingRate = subSamplingRate;
222 mNumPayloadParam++;
223 }
224 }
225 }
226 }
227
228 IMS_RtpSvc_SetPayload(mRtpSessionId, mPayloadParam,
229 mMediaType == IMS_MEDIA_VIDEO ? eRTP_TRUE : eRTP_FALSE, mNumPayloadParam);
230 }
231
SetRtcpInterval(int32_t nInterval)232 void IRtpSession::SetRtcpInterval(int32_t nInterval)
233 {
234 IMLOGD1("[SetRtcpInterval] nInterval[%d]", nInterval);
235 IMS_RtpSvc_SetRTCPInterval(mRtpSessionId, nInterval);
236 }
237
StartRtp(bool bResetSsrc)238 void IRtpSession::StartRtp(bool bResetSsrc)
239 {
240 IMLOGD1("[StartRtp] RtpStarted[%d]", mRtpStarted);
241
242 if (mRtpStarted == 0)
243 {
244 IMLOGD0("[StartRtp] IMS_RtpSvc_SessionEnableRTP");
245 IMS_RtpSvc_SessionEnableRTP(mRtpSessionId, bResetSsrc ? eRTP_TRUE : eRTP_FALSE);
246 }
247
248 mRtpStarted++;
249 }
250
StopRtp()251 void IRtpSession::StopRtp()
252 {
253 IMLOGD1("[StopRtp] RtpStarted[%d]", mRtpStarted);
254
255 if (mRtpStarted == 0)
256 {
257 return;
258 }
259
260 mRtpStarted--;
261
262 if (mRtpStarted == 0)
263 {
264 IMS_RtpSvc_SessionDisableRTP(mRtpSessionId);
265 IMLOGI0("[StopRtp] IMS_RtpSvc_SessionDisableRTP");
266 }
267 }
268
StartRtcp(bool bSendRtcpBye)269 void IRtpSession::StartRtcp(bool bSendRtcpBye)
270 {
271 IMLOGD1("[StartRtcp] RtcpStarted[%d]", mRtcpStarted);
272
273 if (mRtcpStarted == 0)
274 {
275 IMS_RtpSvc_SessionEnableRTCP(mRtpSessionId, static_cast<eRtp_Bool>(bSendRtcpBye));
276 }
277
278 mEnableRtcpTx = true;
279 mRtcpStarted++;
280 }
281
StopRtcp()282 void IRtpSession::StopRtcp()
283 {
284 IMLOGD1("[StopRtcp] RtcpStarted[%d]", mRtcpStarted);
285
286 if (mRtcpStarted == 0)
287 {
288 return;
289 }
290
291 mRtcpStarted--;
292
293 if (mRtcpStarted == 0)
294 {
295 IMLOGI0("[StopRtcp] IMS_RtpSvc_SessionDisableRtcp");
296 IMS_RtpSvc_SessionDisableRTCP(mRtpSessionId);
297 mEnableRtcpTx = false;
298 }
299 }
300
SendRtpPacket(uint32_t payloadType,uint8_t * data,uint32_t dataSize,uint32_t timestamp,bool mark,uint32_t timeDiff,RtpHeaderExtensionInfo * extensionInfo)301 bool IRtpSession::SendRtpPacket(uint32_t payloadType, uint8_t* data, uint32_t dataSize,
302 uint32_t timestamp, bool mark, uint32_t timeDiff, RtpHeaderExtensionInfo* extensionInfo)
303 {
304 tRtpSvc_SendRtpPacketParam stRtpPacketParam;
305 memset(&stRtpPacketParam, 0, sizeof(tRtpSvc_SendRtpPacketParam));
306 IMLOGD_PACKET5(IM_PACKET_LOG_RTP,
307 "SendRtpPacket, payloadType[%u], size[%u], TS[%u], mark[%d], extension[%d]",
308 payloadType, dataSize, timestamp, mark, extensionInfo != nullptr);
309 stRtpPacketParam.bMbit = mark ? eRTP_TRUE : eRTP_FALSE;
310 stRtpPacketParam.byPayLoadType = payloadType;
311 stRtpPacketParam.diffFromLastRtpTimestamp = timeDiff;
312 stRtpPacketParam.bXbit = extensionInfo != nullptr ? eRTP_TRUE : eRTP_FALSE;
313
314 if (extensionInfo != nullptr)
315 {
316 stRtpPacketParam.wDefinedByProfile = extensionInfo->definedByProfile;
317 stRtpPacketParam.wExtLen = extensionInfo->length;
318 stRtpPacketParam.pExtData = extensionInfo->extensionData;
319 stRtpPacketParam.nExtDataSize = extensionInfo->extensionDataSize;
320 }
321
322 if (mPrevTimestamp == timestamp)
323 {
324 stRtpPacketParam.bUseLastTimestamp = eRTP_TRUE;
325 }
326 else
327 {
328 stRtpPacketParam.bUseLastTimestamp = eRTP_FALSE;
329 mPrevTimestamp = timestamp;
330 }
331
332 mNumRtpDataToSend++;
333 IMS_RtpSvc_SendRtpPacket(
334 this, mRtpSessionId, reinterpret_cast<char*>(data), dataSize, &stRtpPacketParam);
335 return true;
336 }
337
ProcRtpPacket(uint8_t * pData,uint32_t nDataSize)338 bool IRtpSession::ProcRtpPacket(uint8_t* pData, uint32_t nDataSize)
339 {
340 IMLOGD_PACKET1(IM_PACKET_LOG_RTP, "[ProcRtpPacket] size[%d]", nDataSize);
341 mNumRtpProcPacket++;
342
343 /** if it is loopback, change the ssrc */
344 if (mLocalAddress == mPeerAddress)
345 {
346 unsigned int ssrc;
347 ssrc = *reinterpret_cast<uint32_t*>(pData + 8);
348 ssrc++;
349 *reinterpret_cast<uint32_t*>(pData + 8) = ssrc;
350
351 IMLOGD1("[ProcRtcpPacket] loopback mode, ssrc changed[%d]", ssrc);
352 }
353
354 IMS_RtpSvc_ProcRtpPacket(this, mRtpSessionId, pData, nDataSize, mPeerAddress.ipAddress,
355 mPeerAddress.port, mPeerRtpSsrc);
356 return true;
357 }
358
ProcRtcpPacket(uint8_t * pData,uint32_t nDataSize)359 bool IRtpSession::ProcRtcpPacket(uint8_t* pData, uint32_t nDataSize)
360 {
361 IMLOGD_PACKET1(IM_PACKET_LOG_RTCP, "[ProcRtcpPacket] size[%d]", nDataSize);
362 mNumRtcpProcPacket++;
363 IMS_RtpSvc_ProcRtcpPacket(this, mRtpSessionId, pData, nDataSize, mPeerAddress.ipAddress,
364 (mPeerAddress.port + 1), &mLocalRtpSsrc);
365 return true;
366 }
367
OnRtpPacket(unsigned char * pData,RtpSvc_Length wLen)368 int IRtpSession::OnRtpPacket(unsigned char* pData, RtpSvc_Length wLen)
369 {
370 IMLOGD_PACKET1(IM_PACKET_LOG_RTP, "[OnRtpPacket] size[%d]", wLen);
371 std::lock_guard<std::mutex> guard(mutexEncoder);
372
373 if (mRtpEncoderListener)
374 {
375 mNumRtpPacketSent++;
376 mRtpEncoderListener->OnRtpPacket(pData, wLen);
377 return wLen;
378 }
379 return 0;
380 }
381
OnRtcpPacket(unsigned char * pData,RtpSvc_Length wLen)382 int IRtpSession::OnRtcpPacket(unsigned char* pData, RtpSvc_Length wLen)
383 {
384 IMLOGD_PACKET0(IM_PACKET_LOG_RTCP, "[OnRtcpPacket] Enter");
385 if (mEnableRtcpTx == false)
386 {
387 IMLOGD_PACKET0(IM_PACKET_LOG_RTCP, "[OnRtcpPacket] disabled");
388 return wLen;
389 }
390
391 std::lock_guard<std::mutex> guard(mutexEncoder);
392 if (mRtcpEncoderListener)
393 {
394 if (pData != nullptr)
395 {
396 mNumRtcpPacketSent++;
397 mRtcpEncoderListener->OnRtcpPacket(pData, wLen);
398 IMLOGD_PACKET0(IM_PACKET_LOG_RTCP, "[OnRtcpPacket] Send, Exit");
399 return wLen;
400 }
401 else
402 {
403 IMLOGD_PACKET1(IM_PACKET_LOG_RTCP, "[OnRtcpPacket] pData[%x]", pData);
404 return 0;
405 }
406 }
407 return 0;
408 }
409
OnPeerInd(tRtpSvc_IndicationFromStack type,void * pMsg)410 void IRtpSession::OnPeerInd(tRtpSvc_IndicationFromStack type, void* pMsg)
411 {
412 IMLOGD_PACKET2(IM_PACKET_LOG_RTP, "[OnPeerInd] media[%d], type[%d]", mMediaType, type);
413 std::lock_guard<std::mutex> guard(mutexDecoder);
414
415 switch (type)
416 {
417 case RTPSVC_RECEIVE_RTP_IND:
418 mNumRtpPacket++;
419
420 if (mRtpDecoderListener)
421 {
422 tRtpSvcIndSt_ReceiveRtpInd* pstRtp =
423 reinterpret_cast<tRtpSvcIndSt_ReceiveRtpInd*>(pMsg);
424
425 if ((mEnableDTMF == false || mRtpDtmfPayloadType != pstRtp->dwPayloadType) &&
426 pstRtp->dwPayloadType != 20)
427 {
428 RtpHeaderExtensionInfo extensionInfo(pstRtp->wDefinedByProfile, pstRtp->wExtLen,
429 reinterpret_cast<int8_t*>(pstRtp->pExtData), pstRtp->wExtDataSize);
430
431 mRtpDecoderListener->OnMediaDataInd(pstRtp->pMsgBody, pstRtp->wMsgBodyLen,
432 pstRtp->dwTimestamp, pstRtp->bMbit, pstRtp->dwSeqNum,
433 pstRtp->dwPayloadType, pstRtp->dwSsrc, extensionInfo);
434 }
435 }
436 break;
437
438 case RTPSVC_RECEIVE_RTCP_SR_IND:
439 mNumSRPacket++;
440
441 if (mRtcpDecoderListener)
442 {
443 mRtcpDecoderListener->OnRtcpInd(type, pMsg);
444 }
445 break;
446 case RTPSVC_RECEIVE_RTCP_RR_IND:
447 mNumRRPacket++;
448
449 if (mRtcpDecoderListener)
450 {
451 mRtcpDecoderListener->OnRtcpInd(type, pMsg);
452 }
453 break;
454 case RTPSVC_RECEIVE_RTCP_FB_IND:
455 case RTPSVC_RECEIVE_RTCP_PAYLOAD_FB_IND:
456 if (mRtcpDecoderListener)
457 {
458 mRtcpDecoderListener->OnRtcpInd(type, pMsg);
459 }
460 break;
461 default:
462 IMLOGD1("[OnPeerInd] unhandled[%d]", type);
463 break;
464 }
465 }
466
OnPeerRtcpComponents(void * nMsg)467 void IRtpSession::OnPeerRtcpComponents(void* nMsg)
468 {
469 IMLOGD0("[OnPeerRtcpComponents]");
470
471 if (nMsg != nullptr && mRtcpDecoderListener != nullptr)
472 {
473 int32_t roundTripTimeDelay = *reinterpret_cast<int32_t*>(nMsg);
474 mRtcpDecoderListener->OnEvent(kRequestRoundTripTimeDelayUpdate, roundTripTimeDelay);
475 }
476 }
477
OnTimer()478 void IRtpSession::OnTimer()
479 {
480 IMLOGI8("[OnTimer] media[%d], RXRtp[%03d/%03d], RXRtcp[%02d/%02d], TXRtp[%03d/%03d],"
481 " TXRtcp[%02d]",
482 mMediaType, mNumRtpProcPacket, mNumRtpPacket, mNumRtcpProcPacket,
483 mNumSRPacket + mNumRRPacket, mNumRtpDataToSend, mNumRtpPacketSent, mNumRtcpPacketSent);
484
485 std::lock_guard<std::mutex> guard(mutexDecoder);
486
487 if (mRtpDecoderListener)
488 {
489 mRtpDecoderListener->OnNumReceivedPacket(mNumRtpProcPacket);
490 }
491
492 if (mRtcpDecoderListener)
493 {
494 mRtcpDecoderListener->OnNumReceivedPacket(mNumRtcpProcPacket, mNumRRPacket);
495 }
496
497 mNumRtpProcPacket = 0;
498 mNumRtcpProcPacket = 0;
499 mNumRtpPacket = 0;
500 mNumSRPacket = 0;
501 mNumRRPacket = 0;
502 mNumRtpDataToSend = 0;
503 mNumRtpPacketSent = 0;
504 mNumRtcpPacketSent = 0;
505 }
506
SendRtcpXr(uint8_t * pPayload,uint32_t nSize)507 void IRtpSession::SendRtcpXr(uint8_t* pPayload, uint32_t nSize)
508 {
509 IMLOGD1("[SendRtcpXr] nSize[%d]", nSize);
510
511 if (mRtpSessionId)
512 {
513 IMS_RtpSvc_SendRtcpXrPacket(mRtpSessionId, pPayload, nSize);
514 }
515 }
516
SendRtcpFeedback(int32_t type,uint8_t * pFic,uint32_t nFicSize)517 bool IRtpSession::SendRtcpFeedback(int32_t type, uint8_t* pFic, uint32_t nFicSize)
518 {
519 IMLOGD1("[SendRtcpFeedback] type[%d]", type);
520
521 if (!mRtcpStarted)
522 {
523 return false;
524 }
525
526 eRtp_Bool bRet = eRTP_FALSE;
527
528 if (kRtpFbNack <= type && type <= kRtpFbTmmbn)
529 {
530 // RTP-FB
531 IMLOGD1("[SendRtcpFeedback] Send rtp feedback, type[%d]", type);
532 bRet = IMS_RtpSvc_SendRtcpRtpFbPacket(
533 mRtpSessionId, type, reinterpret_cast<char*>(pFic), nFicSize, mPeerRtpSsrc);
534 }
535 else if (kPsfbPli <= type && type <= kPsfbFir)
536 {
537 type -= kPsfbBoundary;
538 // PSFB
539 IMLOGD1("[SendRtcpFeedback] Send payload specific feedback, type[%d]", type);
540 bRet = IMS_RtpSvc_SendRtcpPayloadFbPacket(
541 mRtpSessionId, type, reinterpret_cast<char*>(pFic), nFicSize, mPeerRtpSsrc);
542 }
543
544 if (bRet != eRTP_TRUE)
545 {
546 IMLOGE0("[SendRtcpFeedback] error");
547 return false;
548 }
549
550 return true;
551 }
552
getMediaType()553 ImsMediaType IRtpSession::getMediaType()
554 {
555 return mMediaType;
556 }
557
increaseRefCounter()558 void IRtpSession::increaseRefCounter()
559 {
560 ++mRefCount;
561 IMLOGD1("[increaseRefCounter] count[%d]", mRefCount.load());
562 }
563
decreaseRefCounter()564 void IRtpSession::decreaseRefCounter()
565 {
566 --mRefCount;
567 IMLOGD1("[decreaseRefCounter] count[%d]", mRefCount.load());
568 }
569
getRefCounter()570 uint32_t IRtpSession::getRefCounter()
571 {
572 return mRefCount.load();
573 }
574
SetRtpContext(uint32_t ssrc,uint32_t timestamp,uint16_t sequenceNumber)575 void IRtpSession::SetRtpContext(uint32_t ssrc, uint32_t timestamp, uint16_t sequenceNumber)
576 {
577 IMS_RtpSvc_SetRtpContext(mRtpSessionId, ssrc, timestamp, sequenceNumber);
578 }
579
GetRtpContext(uint32_t & ssrc,uint32_t & timestamp,uint16_t & sequenceNumber)580 void IRtpSession::GetRtpContext(uint32_t& ssrc, uint32_t& timestamp, uint16_t& sequenceNumber)
581 {
582 IMS_RtpSvc_GetRtpContext(mRtpSessionId, ssrc, timestamp, sequenceNumber);
583 }
584