1 /* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
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
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18 #ifndef PVMF_JITTER_BUFFER_H_INCLUDED
19 #include "pvmf_jitter_buffer.h"
20 #endif
21
22 #ifndef PVMF_MEDIA_CMD_H_INCLUDED
23 #include "pvmf_media_cmd.h"
24 #endif
25
26 // Define entry point for this DLL
OSCL_DLL_ENTRY_POINT_DEFAULT()27 OSCL_DLL_ENTRY_POINT_DEFAULT()
28
29 #define PVMF_JITTER_BUFFER_ROLL_OVER_THRESHOLD_16BIT 2000
30 void PVMFJitterBufferImpl::ResetParams(bool aReleaseMemory)
31 {
32 if (aReleaseMemory)
33 {
34 DestroyAllocators();
35 OSCL_DELETE(iJitterBuffer);
36 if (iBufferAlloc)
37 iBufferAlloc->removeRef();
38 }
39
40 iStreamingState = STREAMINGSTATE_UNKNOWN;
41 iSeqNum = 0;
42 iReportCanRetrievePacket = false;
43
44 iInPlaceProcessing = true;
45 iOnePacketPerFragment = true;
46 iOnePacketPerMediaMsg = true;
47
48 iLastPacketOutTs = 0;
49
50 iMediaDataGroupAlloc = NULL;
51 iMediaDataImplMemPool = NULL;
52 iMediaMsgMemPool = NULL;
53
54 iStartTimeInMS = 0;
55 iStopTimeInMS = 0;
56 iPlayStopTimeAvailable = 0;
57 iBroadCastSession = false;
58
59 iMaxAdjustedRTPTS = 0;
60
61 iSessionDurationExpired = false;
62 iDurationInMilliSeconds = 0;
63 iRebufferingThresholdInMilliSeconds = 0;
64
65 iMonotonicTimeStamp = 0;
66 iFirstSeqNum = 0;
67 iJitterBuffer = NULL;
68 iEOSSignalled = false;
69 iEOSSent = false;
70 iStreamID = 0;
71 iMaxAdjustedTS = 0;
72 iPrevAdjustedTS = 0;
73 iHeaderPreParsed = false;
74
75 iRTPTimeScale = 0;
76 iPrevTSOut = 0;
77
78 seqNumLock = false;
79
80 iInterArrivalJitter = 0;
81 oFirstPacket = false;
82
83
84 SSRCLock = 0;
85 oSSRCFromSetUpResponseAvailable = false;
86 SSRCFromSetUpResponse = 0;
87
88 iPrevSeqNumBaseOut = 0;
89 seqLockTimeStamp = 0;
90
91 iPrevAdjustedRTPTS = 0;
92 iPrevTSIn = 0;
93 iPrevSeqNumBaseIn = 0;
94
95 iBufferAlloc = NULL;
96 prevMinPercentOccupancy = 100;
97 consecutiveLowBufferCount = 0;
98 iNumUnderFlow = 0;
99
100 iWaitForOOOPacketCallBkId = 0;
101 iMonitorReBufferingCallBkId = 0;
102 iJitterBufferDurationCallBkId = 0;
103
104 iMonitorReBufferingCallBkPending = false;
105 iWaitForOOOPacketCallBkPending = false;
106 iJitterBufferDurationCallBkPending = false;
107
108 ipMediaClockConverter = NULL;
109 iTimeScale = 0;
110 }
111
DestroyAllocators()112 void PVMFJitterBufferImpl::DestroyAllocators()
113 {
114 /* Destroy allocators if present */
115 if (iMediaDataGroupAlloc != NULL)
116 {
117 iMediaDataGroupAlloc->CancelFreeChunkAvailableCallback();
118 iMediaDataGroupAlloc->removeRef();
119 iMediaDataGroupAlloc = NULL;
120 }
121 if (iMediaDataImplMemPool != NULL)
122 {
123 iMediaDataImplMemPool->removeRef();
124 iMediaDataImplMemPool = NULL;
125 }
126 if (iMediaMsgMemPool != NULL)
127 {
128 iMediaMsgMemPool->removeRef();
129 iMediaMsgMemPool = NULL;
130 }
131 }
132
StreamingSessionStarted()133 OSCL_EXPORT_REF void PVMFJitterBufferImpl::StreamingSessionStarted()
134 {
135 iStreamingState = STREAMINGSTATE_STARTED;
136 iNumUnderFlow = 0;
137 }
138
StreamingSessionPaused()139 OSCL_EXPORT_REF void PVMFJitterBufferImpl::StreamingSessionPaused()
140 {
141 iStreamingState = STREAMINGSTATE_PAUSED;
142 CancelEventCallBack(JB_NOTIFY_WAIT_FOR_OOO_PACKET_COMPLETE);
143 CancelEventCallBack(JB_MONITOR_REBUFFERING);
144 CancelEventCallBack(JB_BUFFERING_DURATION_COMPLETE);
145 }
146
StreamingSessionStopped()147 OSCL_EXPORT_REF void PVMFJitterBufferImpl::StreamingSessionStopped()
148 {
149 iStreamingState = STREAMINGSTATE_STOPPED;
150 CancelEventCallBack(JB_NOTIFY_WAIT_FOR_OOO_PACKET_COMPLETE);
151 CancelEventCallBack(JB_MONITOR_REBUFFERING);
152 CancelEventCallBack(JB_BUFFERING_DURATION_COMPLETE);
153 FlushJitterBuffer();
154 }
155
SetRebufferingThresholdInMilliSeconds(uint32 aRebufferingThresholdInMilliSeconds)156 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetRebufferingThresholdInMilliSeconds(uint32 aRebufferingThresholdInMilliSeconds)
157 {
158 iRebufferingThresholdInMilliSeconds = aRebufferingThresholdInMilliSeconds;
159 }
160
SetDurationInMilliSeconds(uint32 aDuration)161 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetDurationInMilliSeconds(uint32 aDuration)
162 {
163 iDurationInMilliSeconds = aDuration;
164 }
165
PrepareForRepositioning()166 OSCL_EXPORT_REF void PVMFJitterBufferImpl::PrepareForRepositioning()
167 {
168 irDataState = PVMF_JITTER_BUFFER_IN_TRANSITION;
169 iEOSSignalled = false;
170 iEOSSent = false;
171 irDelayEstablished = false;
172 }
173
GetState() const174 OSCL_EXPORT_REF PVMFJitterBufferDataState PVMFJitterBufferImpl::GetState() const
175 {
176 return irDataState;
177 }
178
SetJitterBufferState(PVMFJitterBufferDataState aState)179 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetJitterBufferState(PVMFJitterBufferDataState aState)
180 {
181 irDataState = aState;
182 }
183
SetJitterBufferChunkAllocator(OsclMemPoolResizableAllocator * aDataBufferAllocator)184 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetJitterBufferChunkAllocator(OsclMemPoolResizableAllocator* aDataBufferAllocator)
185 {
186 iBufferAlloc = aDataBufferAllocator;
187 iBufferAlloc->addRef();
188 }
189
GetMimeType() const190 OSCL_EXPORT_REF const char* PVMFJitterBufferImpl::GetMimeType() const
191 {
192 return irMimeType.get_cstr();
193 }
194
195
196
197 ///////////////////////////////////////////////////////////////////////////////
198 // Creation and cleanup functions
199 ///////////////////////////////////////////////////////////////////////////////
200
PVMFJitterBufferImpl(const PVMFJitterBufferConstructParams & aJBConstructParams)201 OSCL_EXPORT_REF PVMFJitterBufferImpl::PVMFJitterBufferImpl(const PVMFJitterBufferConstructParams& aJBConstructParams)
202 : irEstimatedServerClock(aJBConstructParams.GetEstimatedServerClock())
203 , irClientPlayBackClock(aJBConstructParams.GetClientPlaybackClock())
204 , irJBEventNotifier(aJBConstructParams.GetEventNotifier())
205 , irMimeType(aJBConstructParams.GetMimeType())
206 , irDelayEstablished(aJBConstructParams.GetDelayEstablishStatus())
207 , irJitterDelayPercent(aJBConstructParams.GetJBDelayPercent())
208 , irDataState(aJBConstructParams.GetJitterBufferState())
209 , iObserver(aJBConstructParams.GetJBObserver())
210 , iObserverContext(aJBConstructParams.GetContextData())
211 {
212 iMediaMsgMemPool = NULL;
213 iMediaDataImplMemPool = NULL;
214 iMediaDataGroupAlloc = NULL;
215
216 ipLogger = NULL;
217 ipClockLoggerSessionDuration = NULL;
218 ipDataPathLogger = NULL;
219 ipDataPathLoggerIn = NULL;
220 ipDataPathLoggerOut = NULL;
221 ipClockLogger = NULL;
222 ipRTCPDataPathLoggerIn = NULL;
223 ipRTCPDataPathLoggerOut = NULL;
224 ipClockLoggerRebuff = NULL;
225 ipDataPathLoggerFlowCtrl = NULL;
226 ipJBEventsClockLogger = NULL;
227
228 ResetParams(false);
229 }
230
231
232
~PVMFJitterBufferImpl()233 OSCL_EXPORT_REF PVMFJitterBufferImpl::~PVMFJitterBufferImpl()
234 {
235 ResetJitterBuffer();
236 ResetParams();
237 DestroyAllocators();
238 }
239
Construct()240 OSCL_EXPORT_REF void PVMFJitterBufferImpl::Construct()
241 {
242 ipLogger = PVLogger::GetLoggerObject("JitterBuffer");
243 ipClockLoggerSessionDuration = PVLogger::GetLoggerObject("clock.streaming_manager.sessionduration");
244 ipDataPathLogger = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer");
245 ipDataPathLoggerIn = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.in");
246 ipDataPathLoggerOut = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.out");
247 ipClockLogger = PVLogger::GetLoggerObject("clock.jitterbuffer");
248 ipRTCPDataPathLoggerIn = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.rtcp.in");
249 ipRTCPDataPathLoggerOut = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.rtcp.out");
250 ipMaxRTPTsLogger = PVLogger::GetLoggerObject("MaxRTPTs");
251 ipClockLoggerRebuff = PVLogger::GetLoggerObject("clock.jitterbuffernode.rebuffer");
252 ipDataPathLoggerFlowCtrl = PVLogger::GetLoggerObject("datapath.sourcenode.jitterbuffer.flowctrl");
253 ipJBEventsClockLogger = PVLogger::GetLoggerObject("eventnotifier.PVMFJitterBufferImpl");
254
255 if (!iInPlaceProcessing)
256 {
257 CreateAllocators();
258 }
259
260 uint32 numNodes = 0;
261
262 #if (PMVF_JITTER_BUFFER_NODE_USE_NO_RESIZE_ALLOC)
263 numNodes = PVMF_JB_NO_RESIZE_ALLOC_NUM_CHUNKS_RTP;
264 #else
265 numNodes = DEFAULT_NUM_MEDIA_MSGS_IN_JITTER_BUFFER;
266 #endif
267 iJitterBuffer = OSCL_NEW(PVMFDynamicCircularArrayType,
268 (numNodes));
269
270
271 }
272
273 ///////////////////////////////////////////////////////////////////////////////
274 // Interface functions
275 ///////////////////////////////////////////////////////////////////////////////
RegisterMediaMsg(PVMFSharedMediaMsgPtr & aMsg)276 OSCL_EXPORT_REF PVMFJitterBufferRegisterMediaMsgStatus PVMFJitterBufferImpl::RegisterMediaMsg(PVMFSharedMediaMsgPtr& aMsg)
277 {
278 PVMFJitterBufferRegisterMediaMsgStatus retval = PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS;
279 PVMFSharedMediaDataPtr dataPacket;
280
281 if (aMsg->getFormatID() > PVMF_MEDIA_CMD_FORMAT_IDS_START) //IsCmdMsg
282 {
283 RegisterCmdPacket(aMsg);
284 }
285 else
286 {
287 LOGCLIENTANDESTIMATEDSERVCLK_DATAPATH;
288 //1. Parse the header, and validate the packet
289 //2. Create the packet (if iInPlaceProcessing is false)
290 //3. Update statistics
291 //4. Register the packet
292 //5. Check for flow control [JB specific]
293 PVMFSharedMediaDataPtr inputDataPacket;
294 convertToPVMFMediaData(inputDataPacket, aMsg);
295 OsclSharedPtr<PVMFMediaDataImpl> mediaDataIn;
296 if (!inputDataPacket->getMediaDataImpl(mediaDataIn))
297 {
298 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::ProcessIncomingMsgRTP: corrupt input media msg"));
299 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::ProcessIncomingMsgRTP: corrupt input media msg"));
300 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_CORRUPT_PACKET;
301 }
302 else
303 {
304 if (iOnePacketPerMediaMsg)
305 {
306 PVMFSharedMediaDataPtr dataPacket;
307 PVMFJBPacketParsingAndStatUpdationStatus status = ParsePacketHeaderAndUpdateJBStats(inputDataPacket, dataPacket);
308 if (PVMF_JB_PACKET_PARSING_SUCCESS == status)
309 {
310 if (CanRegisterMediaMsg())
311 {
312 if (CheckSpaceAvailability())
313 {
314 retval = RegisterDataPacket(inputDataPacket);
315
316 }
317 else
318 {
319 retval = PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_JB_FULL;
320 }
321 }
322 else
323 {
324 if (dataPacket.GetRep())
325 {
326 #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG)
327 PVMF_JB_LOGDATATRAFFIC_FLOWCTRL_E((0, "PVMFJitterBufferNode::ProcessIncomingMsgRTP: - Ignoring - Wrong State"
328 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), inputDataPacket->getStreamID()));
329 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferNode::ProcessIncomingMsg: - Ignoring - Wrong State"
330 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), inputDataPacket->getStreamID()));
331 PVMF_JB_LOGERROR((0, "PVMFJitterBufferNode::ProcessIncomingMsg: - Ignoring - Wrong State"
332 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), inputDataPacket->getStreamID()));
333 #endif
334 }
335 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::RegisterMediaMsg: Invalid State to accept any packet"));
336 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::RegisterMediaMsg: Invalid State to accept any packet"));
337 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_CORRUPT_PACKET;
338 }
339 }
340 else
341 {
342 if (PVMF_JB_ERR_INSUFFICIENT_MEM_TO_PACKETIZE == status)
343 {
344 retval = PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_INSUFFICIENT_MEMORY_FOR_PACKETIZATION;
345 }
346 if (PVMF_JB_ERR_INVALID_CONFIGURATION == status)
347 {
348 retval = PVMF_JB_BUFFER_REGISTER_MEDIA_MSG_ERR_CONFIG_NOT_SUPPORTED;
349 }
350 if ((PVMF_JB_ERR_CORRUPT_HDR == status) || (PVMF_JB_ERR_TRUNCATED_HDR == status))
351 {
352 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_INVALID_HEADER;
353 }
354 if (PVMF_JB_ERR_UNEXPECTED_PKT == status)
355 {
356 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_UNEXPECTED_DATA;
357 }
358 if (PVMF_JB_ERR_LATE_PACKET == status)
359 {
360 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_LATE_MSG;
361 }
362 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::RegisterMediaMsg: ParsePacketHeader failed retval %d", retval));
363 }
364 }
365 else
366 {
367 if (iOnePacketPerFragment)
368 {
369 const uint32 numOfFragments = inputDataPacket->getNumFragments();
370 for (uint ii = 0; ii < numOfFragments ; ii++)
371 {
372 PVMFSharedMediaDataPtr dataPacket;
373 PVMFJBPacketParsingAndStatUpdationStatus status = ParsePacketHeaderAndUpdateJBStats(inputDataPacket, dataPacket, ii);
374 if (PVMF_JB_PACKET_PARSING_SUCCESS == status)
375 {
376 if (CanRegisterMediaMsg())
377 {
378 if (CheckSpaceAvailability())
379 {
380 retval = RegisterDataPacket(dataPacket);
381 }
382 else
383 {
384 retval = PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_JB_FULL;
385 }
386 }
387 else
388 {
389 if (dataPacket.GetRep())
390 {
391 #if (PVLOGGER_INST_LEVEL > PVLOGMSG_INST_LLDBG)
392 PVMF_JB_LOGDATATRAFFIC_FLOWCTRL_E((0, "PVMFJitterBufferNode::ProcessIncomingMsgRTP: - Ignoring - Wrong State"
393 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), dataPacket->getStreamID()));
394 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferNode::ProcessIncomingMsg: - Ignoring - Wrong State"
395 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), dataPacket->getStreamID()));
396 PVMF_JB_LOGERROR((0, "PVMFJitterBufferNode::ProcessIncomingMsg: - Ignoring - Wrong State"
397 "Size=%d, SSRC=%d", inputDataPacket->getFilledSize(), dataPacket->getStreamID()));
398 #endif
399 }
400 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::RegisterMediaMsg: Invalid State to accept any packet"));
401 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::RegisterMediaMsg: Invalid State to accept any packet"));
402 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_CORRUPT_PACKET;
403 }
404 }
405 else
406 {
407 if (PVMF_JB_ERR_INSUFFICIENT_MEM_TO_PACKETIZE == status)
408 {
409 retval = PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_INSUFFICIENT_MEMORY_FOR_PACKETIZATION;
410 }
411 if (PVMF_JB_ERR_INVALID_CONFIGURATION == status)
412 {
413 retval = PVMF_JB_BUFFER_REGISTER_MEDIA_MSG_ERR_CONFIG_NOT_SUPPORTED;
414 }
415 if ((PVMF_JB_ERR_CORRUPT_HDR == status) || (PVMF_JB_ERR_TRUNCATED_HDR == status))
416 {
417 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_INVALID_HEADER;
418 }
419 if (PVMF_JB_ERR_UNEXPECTED_PKT == status)
420 {
421 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_UNEXPECTED_DATA;
422 }
423 if (PVMF_JB_ERR_LATE_PACKET == status)
424 {
425 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_LATE_MSG;
426 }
427 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::RegisterMediaMsg: ParsePacketHeader failed retval %d", retval));
428 }
429 if (retval == PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_INSUFFICIENT_MEMORY_FOR_PACKETIZATION || retval == PVMF_JB_REGISTER_MEDIA_MSG_FAILURE_JB_FULL)
430 {
431 //Serious err.. drop the packets... May be leave and let the obs trap...?
432 break;
433 }
434 }
435 }
436 else
437 {
438 //invalid use case, not expected, cause exception(leave) here
439 OSCL_LEAVE(JBPacketRegistrationConfigurationCorrupted);
440 }
441 }
442 }
443 }
444 return retval;
445 }
446
RetrievePacket(PVMFSharedMediaMsgPtr & aMediaMsgPtr,bool & aCmdPacket)447 OSCL_EXPORT_REF PVMFStatus PVMFJitterBufferImpl::RetrievePacket(PVMFSharedMediaMsgPtr& aMediaMsgPtr, bool& aCmdPacket)
448 {
449 aCmdPacket = false;
450 PVMFSharedMediaMsgPtr mediaMsg;
451 if (CanRetrievePacket(aMediaMsgPtr, aCmdPacket))
452 {
453 return PVMFSuccess;
454 }
455 else
456 {
457 return PVMFErrNotReady;
458 }
459 }
460
SetInputPacketHeaderPreparsed(bool aPreParsed)461 OSCL_EXPORT_REF PVMFStatus PVMFJitterBufferImpl::SetInputPacketHeaderPreparsed(bool aPreParsed)
462 {
463 iHeaderPreParsed = aPreParsed;
464 return PVMFSuccess;
465 }
466
getJitterBufferStats()467 OSCL_EXPORT_REF PVMFJitterBufferStats& PVMFJitterBufferImpl::getJitterBufferStats()
468 {
469 OSCL_ASSERT(iJitterBuffer);
470 return (iJitterBuffer->getStats());
471 }
472
FlushJitterBuffer()473 OSCL_EXPORT_REF void PVMFJitterBufferImpl::FlushJitterBuffer()
474 {
475 iFirstDataPackets.clear();
476 iJitterBuffer->Clear();
477 iJitterBuffer->ResetJitterBufferStats();
478 iRTPInfoParamsVec.clear();
479 }
480
ResetJitterBuffer()481 OSCL_EXPORT_REF void PVMFJitterBufferImpl::ResetJitterBuffer()
482 {
483 FlushJitterBuffer();
484 iJitterBuffer->ResetJitterBufferStats();
485
486 iRTPInfoParamsVec.clear();
487 iMonotonicTimeStamp = 0;
488 iPrevTSOut = 0;
489 iMaxAdjustedRTPTS = 0;
490 }
491
peekNextElementTimeStamp()492 OSCL_EXPORT_REF PVMFTimestamp PVMFJitterBufferImpl::peekNextElementTimeStamp()
493 {
494 if (iJitterBuffer->getNumElements() > 0)
495 {
496 PVMFTimestamp currTS;
497 PVMFTimestamp prevTS;
498 uint32 aSeqNum;
499 iJitterBuffer->peekNextElementTimeStamp(currTS, aSeqNum);
500 DeterminePrevTimeStampPeek(aSeqNum, prevTS);
501 uint64 ts64 = iMonotonicTimeStamp;
502 ts64 += (currTS - prevTS);
503 PVMFTimestamp adjTS =
504 (PVMFTimestamp)(Oscl_Int64_Utils::get_uint64_lower32(ts64));
505 return (adjTS);
506 }
507 else
508 {
509 PVMFTimestamp adjTS =
510 (PVMFTimestamp)(Oscl_Int64_Utils::get_uint64_lower32(iMonotonicTimeStamp));
511 return (adjTS);
512 }
513 }
514
peekMaxElementTimeStamp()515 OSCL_EXPORT_REF PVMFTimestamp PVMFJitterBufferImpl::peekMaxElementTimeStamp()
516 {
517 if (iJitterBuffer->getNumElements() > 0)
518 {
519 PVMFTimestamp currTS;
520 PVMFTimestamp maxTS;
521 PVMFTimestamp prevTS;
522 uint32 aSeqNum;
523 iJitterBuffer->peekNextElementTimeStamp(currTS, aSeqNum);
524 DeterminePrevTimeStampPeek(aSeqNum, prevTS);
525 iJitterBuffer->peekMaxElementTimeStamp(maxTS, aSeqNum);
526 uint64 ts64 = iMonotonicTimeStamp;
527 ts64 += (maxTS - prevTS);
528 PVMFTimestamp adjTS =
529 (PVMFTimestamp)(Oscl_Int64_Utils::get_uint64_lower32(ts64));
530 return (adjTS);
531 }
532 else
533 {
534 PVMFTimestamp adjTS =
535 (PVMFTimestamp)(Oscl_Int64_Utils::get_uint64_lower32(iMonotonicTimeStamp));
536 return (adjTS);
537 }
538 }
539
540 ///////////////////////////////////////////////////////////////////////////////
541 ///////////////////////////////////////////////////////////////////////////////
542
RegisterCmdPacket(PVMFSharedMediaMsgPtr & aMediaCmd)543 OSCL_EXPORT_REF PVMFJitterBufferRegisterMediaMsgStatus PVMFJitterBufferImpl::RegisterCmdPacket(PVMFSharedMediaMsgPtr& aMediaCmd)
544 {
545 if (aMediaCmd->getFormatID() == PVMF_MEDIA_CMD_EOS_FORMAT_ID)
546 {
547 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::RegisterCmdPacket - EOS Received"));
548 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::RegisterCmdPacket - EOS Received"));
549 EOSCmdReceived();
550 }
551 else /* unknown command */
552 {
553 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::ProcessIncomingMsgRTP - Unknown Cmd Recvd"));
554 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::ProcessIncomingMsgRTP - Unknown Cmd Recvd"));
555 PVMFJitterBufferStats stats = getJitterBufferStats();
556 MediaCommandMsgHolder cmdHolder;
557 cmdHolder.iPreceedingMediaMsgSeqNumber = stats.lastRegisteredSeqNum;
558 cmdHolder.iCmdMsg = aMediaCmd;
559 iMediaCmdVec.push_back(cmdHolder);
560 }
561 return PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS;
562 }
563
RegisterDataPacket(PVMFSharedMediaDataPtr & aDataPacket)564 PVMFJitterBufferRegisterMediaMsgStatus PVMFJitterBufferImpl::RegisterDataPacket(PVMFSharedMediaDataPtr& aDataPacket)
565 {
566 PVMFJitterBufferRegisterMediaMsgStatus retval = AddPacket(aDataPacket);
567 if (retval == PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS)
568 {
569 PerformFlowControl(true);
570 }
571 uint32 aClockDiff = 0;
572 bool delayEstablished = IsDelayEstablished(aClockDiff);//To update delay percent
573 if (iReportCanRetrievePacket && delayEstablished)
574 {
575 //Check if delay is established
576 //There's no hole for for min threshold time
577 if (CanRetrievePacket())
578 {
579 iObserver->PacketReadyToBeRetrieved(iObserverContext);
580 iReportCanRetrievePacket = false;
581 }
582 }
583 return retval;
584 }
585
AddPacket(PVMFSharedMediaDataPtr & aDataPacket)586 PVMFJitterBufferRegisterMediaMsgStatus PVMFJitterBufferImpl::AddPacket(PVMFSharedMediaDataPtr& aDataPacket)
587 {
588 PVMFJitterBufferRegisterMediaMsgStatus retval = PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS;
589 if (iEOSSent)
590 {
591 /* EOS received - do not register packet */
592 PVMF_JB_LOGWARNING((0, "0x%x PVMFJitterBufferImpl::addPacket: After EOS Reached!!!", this));
593 return PVMF_JB_REGISTER_MEDIA_MSG_ERR_EOS_SIGNALLED;
594 }
595
596 if (seqNumLock)
597 {
598 if (oSSRCFromSetUpResponseAvailable == false)
599 {
600 oSSRCFromSetUpResponseAvailable = true;
601 SSRCLock = aDataPacket->getStreamID();
602 iObserver->MediaTrackSSRCEstablished(this, SSRCLock);
603 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::addPacket: Ser No SSRC, set to 1st pkt SSRC %d", SSRCLock));
604 }
605 /* Filter based on SSRC */
606 if (aDataPacket->getStreamID() == SSRCLock)
607 {
608 PVMFJitterBufferAddElemStatus status;
609
610 status = iJitterBuffer->addElement(aDataPacket, iFirstSeqNum);
611 if (status == PVMF_JITTER_BUFFER_ADD_ELEM_SUCCESS)
612 {
613 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::addPacket: MimeType=%s TS=%u, SEQNUM= %d",
614 irMimeType.get_cstr(), aDataPacket->getTimestamp(), aDataPacket->getSeqNum()));
615
616 if (iRTPInfoParamsVec.size() > 0)
617 {
618 /*
619 * Calculate adjusted RTP TS - Will be used to update
620 * the estimated server clock, if any only if some rtp-info
621 * params have been set
622 */
623 ComputeMaxAdjustedRTPTS();
624 }
625 }
626 else if (status == PVMF_JITTER_BUFFER_ADD_ELEM_PACKET_OVERWRITE)
627 {
628 PVMF_JB_LOGDATATRAFFIC_IN_E((0, "PVMFJitterBufferImpl::addPacket - OverWrite: MimeType=%s TS=%d, SEQNUM= %d",
629 irMimeType.get_cstr(), aDataPacket->getTimestamp(), aDataPacket->getSeqNum()));
630 retval = PVMF_JB_REGISTER_MEDIA_MSG_ERR_UNKNOWN;
631 }
632 }
633 }
634 else
635 {
636 if (oSSRCFromSetUpResponseAvailable && (aDataPacket->getStreamID() != SSRCFromSetUpResponse))
637 {//discard packet
638 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::addPacket: ERROR wrong ssrc %d", aDataPacket->getStreamID()));
639 return PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS;
640 }
641 // Add packet to temporary array
642 iFirstDataPackets.push_back(aDataPacket);
643
644 const uint cPktNeededForVote = 5;
645 if (iFirstDataPackets.size() < cPktNeededForVote)
646 return PVMF_JB_REGISTER_MEDIA_MSG_SUCCESS;
647
648 //Majortiy vote for SSRC first
649 //0 count; 1 ssrc; 2 seqbase; 3 timestamp; uint32 PVMFTimestamp;
650 uint32 my_ssrc[cPktNeededForVote][4];
651 for (uint32 i = 0; i < cPktNeededForVote; i++)
652 my_ssrc[i][0] = my_ssrc[i][1] = my_ssrc[i][2] = my_ssrc[i][3] = 0;
653
654 {
655 // 1. vote
656 for (uint32 i = 0; i < cPktNeededForVote; i++)
657 {
658 uint32 ssrc = iFirstDataPackets[i]->getStreamID();
659 for (uint32 j = 0; j < cPktNeededForVote; j++)
660 {
661 if (my_ssrc[j][0] > 0)
662 {
663 if (ssrc == my_ssrc[j][1])
664 {
665 my_ssrc[j][0]++;
666 if (iFirstDataPackets[i]->getSeqNum() < my_ssrc[j][2])
667 {
668 my_ssrc[j][2] = iFirstDataPackets[i]->getSeqNum();
669 my_ssrc[j][3] = iFirstDataPackets[i]->getTimestamp();
670 }
671 break;
672 }
673 }
674 else
675 {
676 my_ssrc[j][0]++; //my_ssrc[j][0]=1
677 my_ssrc[j][1] = ssrc;
678 my_ssrc[j][2] = iFirstDataPackets[i]->getSeqNum();
679 my_ssrc[j][3] = iFirstDataPackets[i]->getTimestamp();
680 break;
681 }
682 }
683 }
684 }
685
686 {// 2. poll ssrc
687 uint32 first_ssrc_index = 0, second_ssrc_index = 1;
688 if (my_ssrc[0][0] < my_ssrc[1][0])
689 {
690 first_ssrc_index = 1;
691 second_ssrc_index = 0;
692 }
693 for (uint32 i = 2; i < cPktNeededForVote; i++)
694 {
695 if (my_ssrc[i][0] > first_ssrc_index)
696 {
697 second_ssrc_index = first_ssrc_index;
698 first_ssrc_index = i;
699 }
700 else if (my_ssrc[i][0] > second_ssrc_index)
701 {
702 second_ssrc_index = i;
703 }
704 }
705 if (my_ssrc[first_ssrc_index][0] <= my_ssrc[second_ssrc_index][0])
706 {
707 //got a tie. should rarely happen
708 //for now, just pick the first one
709 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::addPacket: ERROR first %d second %d", first_ssrc_index, second_ssrc_index));
710 }
711 SSRCLock = my_ssrc[first_ssrc_index][1];
712 seqNumLock = true;
713
714 //if we got RTPInfo by now, we should still use it
715 if (iRTPInfoParamsVec.size() > 0)
716 {
717 Oscl_Vector<PVMFRTPInfoParams, OsclMemAllocator>::iterator it;
718 it = iRTPInfoParamsVec.begin();
719 iFirstSeqNum = (it->seqNumBaseSet) ? it->seqNum : my_ssrc[first_ssrc_index][2];
720 seqLockTimeStamp = (it->rtpTimeBaseSet) ? it->rtpTime : my_ssrc[first_ssrc_index][3];
721 }
722 else
723 {
724 iFirstSeqNum = my_ssrc[first_ssrc_index][2];
725 seqLockTimeStamp = my_ssrc[first_ssrc_index][3];
726 }
727 // iFirstSeqNum must be initialized when we come here
728 iJitterBuffer->setFirstSeqNumAdded(iFirstSeqNum);
729 CheckForRTPTimeAndRTPSeqNumberBase();
730 }
731 // 3.throw away the pkt not belong to current session and register packets
732
733 bool bNoErr = true;
734 Oscl_Vector<PVMFSharedMediaDataPtr, OsclMemAllocator>::iterator it;
735 for (it = iFirstDataPackets.begin(); it != iFirstDataPackets.end(); it++)
736 {
737 if ((*it)->getStreamID() == SSRCLock)
738 {
739 //Validate the packet before trying to push
740
741 PVMFSharedMediaDataPtr& elem = *it;
742 uint32 seqNum = elem->getSeqNum();
743 PVMFTimestamp packetTs = elem->getTimestamp();
744
745 if (iFirstSeqNum != seqNum)
746 {
747 PVMFJitterBufferStats& jbStats = getJitterBufferStats();
748
749 if (iBroadCastSession == true)
750 {
751 /*
752 * This can happen when using prerecorded transport streams that loop
753 * If this happens, just signal an unexpected data event
754 */
755 if (packetTs < jbStats.maxTimeStampRegistered)
756 {
757 return PVMF_JB_REGISTER_MEDIA_MSG_ERR_UNEXPECTED_DATA;
758 }
759 }
760
761 if (!IsSeqTsValidForPkt(seqNum, packetTs, jbStats))
762 {
763 return PVMF_JB_REGISTER_MEDIA_MSG_ERR_LATE_MSG;
764 }
765 }
766
767 if (! iJitterBuffer->addElement(*it, iFirstSeqNum))
768 {
769 PVMF_JB_LOGERROR((0, "PVMFJitterBufferImpl::addPacket: addElement failed"));
770 bNoErr = false;
771 }
772 else
773 {
774 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::addPacket: MimeType=%s TS=%d, SEQNUM= %d",
775 irMimeType.get_cstr(), (*it)->getTimestamp(), (*it)->getSeqNum()));
776 }
777 }
778 }
779
780 iFirstDataPackets.clear();
781 if (iRTPInfoParamsVec.size() > 0)
782 {
783 /*
784 * Calculate adjusted RTP TS - Will be used to update
785 * the estimated server clock, if any only if some rtp-info
786 * params have been set
787 */
788 ComputeMaxAdjustedRTPTS();
789 }
790
791 if (!bNoErr)
792 return PVMF_JB_REGISTER_MEDIA_MSG_ERR_UNKNOWN;
793
794 }
795
796 PVMFJitterBufferStats stats = getJitterBufferStats();
797 if (stats.totalPacketsLost > 0)
798 {
799 PVMF_JB_LOGWARNING((0, "Packet Loss: MimeType=%s, NumPacketsLost=%d", irMimeType.get_cstr(), stats.totalPacketsLost));
800 }
801 PVMF_JB_LOGINFO((0, "PVMFJitterBufferImpl::addPacket - JB Occup Stats - MimeType=%s, MaxSize=%d, CurrOccupany=%d", irMimeType.get_cstr(), iJitterBuffer->getArraySize(), iJitterBuffer->getNumElements()));
802 return retval;
803 }
804
805 ///////////////////////////////////////////////////////////////////////////////
806 //Prtected functions to implement the interface functions
807 ///////////////////////////////////////////////////////////////////////////////
CanRegisterMediaMsg()808 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CanRegisterMediaMsg()
809 {
810 if ((STREAMINGSTATE_STARTED == iStreamingState) || (STREAMINGSTATE_PAUSED == iStreamingState))
811 {
812 return true;
813 }
814 return false;
815 }
816
CreateAllocators()817 void PVMFJitterBufferImpl::CreateAllocators()
818 {
819 //Create allocators
820 iMediaMsgMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator,
821 (DEFAULT_NUM_MEDIA_MSGS_IN_JITTER_BUFFER));
822 iMediaDataImplMemPool = OSCL_NEW(OsclMemPoolFixedChunkAllocator,
823 (DEFAULT_NUM_MEDIA_MSGS_IN_JITTER_BUFFER));
824 iMediaDataGroupAlloc = OSCL_NEW(PVMFMediaFragGroupCombinedAlloc<OsclMemPoolFixedChunkAllocator>,
825 (DEFAULT_NUM_MEDIA_MSGS_IN_JITTER_BUFFER,
826 DEFAULT_NUM_FRAGMENTS_IN_MEDIA_MSG,
827 iMediaDataImplMemPool));
828 iMediaDataGroupAlloc->create();
829 }
830
CreateMediaData(PVMFSharedMediaDataPtr & dataPacket,OsclSharedPtr<PVMFMediaDataImpl> & mediaDataOut)831 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CreateMediaData(PVMFSharedMediaDataPtr& dataPacket, OsclSharedPtr<PVMFMediaDataImpl>& mediaDataOut)
832 {
833 int32 err;
834
835 OSCL_TRY(err,
836 dataPacket = PVMFMediaData::createMediaData(mediaDataOut,
837 iMediaMsgMemPool););
838
839 if (err != OsclErrNone)
840 {
841 return false;
842 }
843
844 return true;
845 }
Allocate(OsclSharedPtr<PVMFMediaDataImpl> & mediaDataOut)846 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::Allocate(OsclSharedPtr<PVMFMediaDataImpl>& mediaDataOut)
847 {
848 int32 err;
849 OSCL_TRY(err,
850 mediaDataOut = iMediaDataGroupAlloc->allocate());
851
852 if (err != OsclErrNone)
853 {
854 return false;
855 }
856
857 // If there is no memory left return false
858 if (mediaDataOut.GetRep() == NULL)
859 {
860 return false;
861 }
862
863 return true;
864 }
865
RequestEventCallBack(JB_NOTIFY_CALLBACK aEventType,uint32 aDelay,OsclAny * aContext)866 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::RequestEventCallBack(JB_NOTIFY_CALLBACK aEventType, uint32 aDelay, OsclAny* aContext)
867 {
868 OSCL_UNUSED_ARG(aContext);
869 bool retval = false;
870 switch (aEventType)
871 {
872 case JB_NOTIFY_WAIT_FOR_OOO_PACKET_COMPLETE :
873 {
874 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_ESTIMATEDSERVER, this, NULL);
875 retval = irJBEventNotifier.RequestCallBack(eventRequestInfo, aDelay, iWaitForOOOPacketCallBkId);
876 if (retval)
877 {
878 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::RequestEventCallBack In OOO CallBackId [%d] Mime %s", iWaitForOOOPacketCallBkId, irMimeType.get_cstr()));
879 iWaitForOOOPacketCallBkPending = true;
880 }
881 }
882 break;
883 case JB_MONITOR_REBUFFERING:
884 {
885 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_CLIENTPLAYBACK, this, NULL);
886 retval = irJBEventNotifier.RequestCallBack(eventRequestInfo, aDelay, iMonitorReBufferingCallBkId);
887 if (retval)
888 {
889 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::RequestEventCallBack In Rebuffering CallBackId [%d] Mime %s", iMonitorReBufferingCallBkId, irMimeType.get_cstr()));
890 iMonitorReBufferingCallBkPending = true;
891 }
892 }
893 break;
894 case JB_BUFFERING_DURATION_COMPLETE:
895 {
896 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_NONDECREASING, this, NULL);
897 retval = irJBEventNotifier.RequestCallBack(eventRequestInfo, iDurationInMilliSeconds, iJitterBufferDurationCallBkId);
898 if (retval)
899 {
900 iJitterBufferDurationCallBkPending = true;
901 }
902 }
903 break;
904 default:
905 {
906 //Log it
907 }
908 }
909
910 return retval;
911 }
912
CancelEventCallBack(JB_NOTIFY_CALLBACK aEventType,OsclAny * aContext)913 OSCL_EXPORT_REF void PVMFJitterBufferImpl::CancelEventCallBack(JB_NOTIFY_CALLBACK aEventType, OsclAny* aContext)
914 {
915 OSCL_UNUSED_ARG(aContext);
916 switch (aEventType)
917 {
918 case JB_NOTIFY_WAIT_FOR_OOO_PACKET_COMPLETE:
919 {
920 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_ESTIMATEDSERVER, this, NULL);
921 irJBEventNotifier.CancelCallBack(eventRequestInfo, iWaitForOOOPacketCallBkId);
922 iWaitForOOOPacketCallBkPending = false;
923 }
924 break;
925 case JB_MONITOR_REBUFFERING:
926 {
927 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_CLIENTPLAYBACK, this, NULL);
928 irJBEventNotifier.CancelCallBack(eventRequestInfo, iMonitorReBufferingCallBkId);
929 iMonitorReBufferingCallBkPending = false;
930 }
931 break;
932 case JB_BUFFERING_DURATION_COMPLETE:
933 {
934 PVMFJBEventNotificationRequestInfo eventRequestInfo(CLOCK_NOTIFICATION_INTF_TYPE_NONDECREASING, this, NULL);
935 irJBEventNotifier.CancelCallBack(eventRequestInfo, iJitterBufferDurationCallBkId);
936 iJitterBufferDurationCallBkPending = false;
937 }
938 break;
939
940 default:
941 {
942 //Log it
943 }
944 }
945 return;
946 }
947
ProcessCallback(CLOCK_NOTIFICATION_INTF_TYPE aClockNotificationInterfaceType,uint32 aCallBkId,const OsclAny * aContext,PVMFStatus aStatus)948 OSCL_EXPORT_REF void PVMFJitterBufferImpl::ProcessCallback(CLOCK_NOTIFICATION_INTF_TYPE aClockNotificationInterfaceType, uint32 aCallBkId, const OsclAny* aContext, PVMFStatus aStatus)
949 {
950 OSCL_UNUSED_ARG(aClockNotificationInterfaceType);
951 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::ProcessCallBack In CallBackId [%d] Mime %s", aCallBkId, irMimeType.get_cstr()));
952
953 if (PVMFSuccess == aStatus)
954 {
955 if (aCallBkId == iWaitForOOOPacketCallBkId)
956 {
957 iWaitForOOOPacketCallBkPending = false;
958 HandleEvent_NotifyWaitForOOOPacketComplete(aContext);
959 }
960
961 if (aCallBkId == iMonitorReBufferingCallBkId)
962 {
963 iMonitorReBufferingCallBkPending = false;
964 HandleEvent_MonitorReBuffering(aContext);
965 }
966 else if (aCallBkId == iJitterBufferDurationCallBkId)
967 {
968 iJitterBufferDurationCallBkPending = false;
969 HandleEvent_JitterBufferBufferingDurationComplete();
970 }
971 }
972 else
973 {
974 //Log it
975 }
976 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::ProcessCallBack Out"));
977 }
978
HandleEvent_MonitorReBuffering(const OsclAny * aContext)979 void PVMFJitterBufferImpl::HandleEvent_MonitorReBuffering(const OsclAny* aContext)
980 {
981 OSCL_UNUSED_ARG(aContext);
982 uint32 timebase32 = 0;
983 uint32 estServerClock = 0;
984 uint32 clientClock = 0;
985 bool overflowFlag = false;
986 irEstimatedServerClock.GetCurrentTime32(estServerClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
987 irClientPlayBackClock.GetCurrentTime32(clientClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
988
989
990 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::IsJitterBufferReady - Time Delay Check - EstServClock=%d", estServerClock));
991 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::IsJitterBufferReady - Time Delay Check - ClientClock=%d", clientClock));
992
993 uint32 clockDiff;
994 IsDelayEstablished(clockDiff); //just to evaluate the rebuiffering condition.
995 }
996
HandleEvent_NotifyWaitForOOOPacketComplete(const OsclAny * aContext)997 void PVMFJitterBufferImpl::HandleEvent_NotifyWaitForOOOPacketComplete(const OsclAny* aContext)
998 {
999 OSCL_UNUSED_ARG(aContext);
1000 if (iReportCanRetrievePacket)
1001 {
1002 iObserver->PacketReadyToBeRetrieved(iObserverContext);
1003 }
1004 }
1005
IsCallbackPending(JB_NOTIFY_CALLBACK aEventType,OsclAny * aContext)1006 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::IsCallbackPending(JB_NOTIFY_CALLBACK aEventType, OsclAny* aContext)
1007 {
1008 bool* callBackPending = NULL;
1009 switch (aEventType)
1010 {
1011 case JB_MONITOR_REBUFFERING:
1012 {
1013 callBackPending = &iMonitorReBufferingCallBkPending;
1014 }
1015 break;
1016 case JB_NOTIFY_WAIT_FOR_OOO_PACKET_COMPLETE:
1017 {
1018 callBackPending = &iWaitForOOOPacketCallBkPending;
1019 }
1020 break;
1021 case JB_BUFFERING_DURATION_COMPLETE:
1022 {
1023 callBackPending = &iJitterBufferDurationCallBkPending;
1024 }
1025 break;
1026 default:
1027 OSCL_ASSERT(false);
1028 }
1029 // PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::IsCallbackPending - Event Type[%d] CallBackPending [%d] aContext[0x%x]", aEventType, *callBackPending, aContext));
1030 return *callBackPending;
1031 }
1032
QueueBOSCommand(uint32 aStreamId)1033 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::QueueBOSCommand(uint32 aStreamId)
1034 {
1035 iStreamID = aStreamId;
1036 PVMFSharedMediaCmdPtr sharedMediaCmdPtr = PVMFMediaCmd::createMediaCmd();
1037 // Set the formatID, timestamp, sequenceNumber and streamID for the media message
1038 sharedMediaCmdPtr->setFormatID(PVMF_MEDIA_CMD_BOS_FORMAT_ID);
1039 uint32 seqNum = 0;
1040 sharedMediaCmdPtr->setSeqNum(seqNum);
1041 sharedMediaCmdPtr->setStreamID(iStreamID);
1042
1043 PVMFSharedMediaMsgPtr mediaMsgOut;
1044 convertToPVMFMediaCmdMsg(mediaMsgOut, sharedMediaCmdPtr);
1045
1046
1047 addMediaCommand(mediaMsgOut);
1048
1049 PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, ipLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFJitterBufferNode::QueueBOSCommand() MIME=%s StreamID=%d", irMimeType.get_cstr(), iStreamID));
1050 return true;
1051 }
1052
SetInPlaceProcessingMode(bool aInPlaceProcessingMode)1053 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetInPlaceProcessingMode(bool aInPlaceProcessingMode)
1054 {
1055 iInPlaceProcessing = aInPlaceProcessingMode;
1056 if (iInPlaceProcessing)
1057 {
1058 iOnePacketPerMediaMsg = true;
1059 }
1060 else
1061 {
1062 iOnePacketPerMediaMsg = false;
1063 }
1064
1065 iOnePacketPerFragment = true;
1066
1067 if (iInPlaceProcessing == false)
1068 {
1069 CreateAllocators();
1070 }
1071 else
1072 {
1073 DestroyAllocators();
1074 }
1075 }
1076
1077 OSCL_EXPORT_REF PVMFStatus
GenerateAndSendEOSCommand(PVMFSharedMediaMsgPtr & aMediaOutMsg,bool & aCmdPacket)1078 PVMFJitterBufferImpl::GenerateAndSendEOSCommand(PVMFSharedMediaMsgPtr& aMediaOutMsg, bool& aCmdPacket)
1079 {
1080 PVMF_JB_LOGINFO((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand"));
1081 PVMF_JB_LOG_RTCPDATATRAFFIC_OUT((0, "PVMFJitterBufferImpl::GenerateAndSendEOSCommand In Mime[%s]-", irMimeType.get_cstr()));
1082
1083 if (iEOSSent == false)
1084 {
1085 aCmdPacket = true;
1086 PVMFSharedMediaCmdPtr sharedMediaCmdPtr =
1087 PVMFMediaCmd::createMediaCmd();
1088
1089 sharedMediaCmdPtr->setFormatID(PVMF_MEDIA_CMD_EOS_FORMAT_ID);
1090
1091 sharedMediaCmdPtr->setStreamID(iStreamID);
1092
1093 convertToPVMFMediaCmdMsg(aMediaOutMsg, sharedMediaCmdPtr);
1094
1095 aMediaOutMsg->setTimestamp(iLastPacketOutTs);
1096
1097 uint32 timebase32 = 0;
1098 uint32 clientClock32 = 0;
1099 bool overflowFlag = false;
1100
1101 irClientPlayBackClock.GetCurrentTime32(clientClock32, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1102 timebase32 = 0;
1103 uint32 estServClock32 = 0;
1104 irEstimatedServerClock.GetCurrentTime32(estServClock32, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1105 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: MimeType=%s, StreamID=%d",
1106 irMimeType.get_cstr(),
1107 aMediaOutMsg->getStreamID()));
1108 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: ClientClock=%d",
1109 clientClock32));
1110 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: EstServClock=%d",
1111 estServClock32));
1112 PVMF_JB_LOGCLOCK_SESSION_DURATION((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: MimeType=%s, StreamID=%d",
1113 irMimeType.get_cstr(),
1114 aMediaOutMsg->getStreamID()));
1115 PVMF_JB_LOGCLOCK_SESSION_DURATION((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: ClientClock=%d",
1116 clientClock32));
1117 PVMF_JB_LOGCLOCK_SESSION_DURATION((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand: EstServClock=%d",
1118 estServClock32));
1119 iEOSSent = true;
1120 return PVMFSuccess;
1121 }
1122 else
1123 {
1124 PVMF_JB_LOGINFO((0, "PVMFJitterBufferNode::GenerateAndSendEOSCommand - EOS already sent..."));
1125 }
1126
1127 return PVMFSuccess;
1128 }
1129
NotifyCanRetrievePacket()1130 OSCL_EXPORT_REF void PVMFJitterBufferImpl::NotifyCanRetrievePacket()
1131 {
1132 PVMF_JB_LOGDATATRAFFIC_OUT_E((0, "PVMFJitterBufferImpl::NotifyCanRetrievePacket Mime %s", irMimeType.get_cstr()));
1133 iReportCanRetrievePacket = true;
1134 }
1135
CancelNotifyCanRetrievePacket()1136 OSCL_EXPORT_REF void PVMFJitterBufferImpl::CancelNotifyCanRetrievePacket()
1137 {
1138 iReportCanRetrievePacket = false;
1139 }
1140
IsDelayEstablished(uint32 & aClockDiff)1141 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::IsDelayEstablished(uint32& aClockDiff)
1142 {
1143 aClockDiff = iDurationInMilliSeconds;
1144 if (GetState() == PVMF_JITTER_BUFFER_IN_TRANSITION)
1145 {
1146 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Jitter Buffer In Transition - Preparing for Seek"));
1147 irDelayEstablished = false;
1148 irJitterDelayPercent = 0;
1149 return irDelayEstablished;
1150 }
1151
1152 uint32 timebase32 = 0;
1153 uint32 estServerClock = 0;
1154 uint32 clientClock = 0;
1155 bool overflowFlag = false;
1156
1157 irEstimatedServerClock.GetCurrentTime32(estServerClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1158 irClientPlayBackClock.GetCurrentTime32(clientClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1159
1160 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - EstServClock=%d", estServerClock));
1161 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - ClientClock=%d", clientClock));
1162
1163 if (iEOSSignalled)
1164 {
1165 /*
1166 * No check needed - We are past the clip time, just play out the last
1167 * bit in the jitter buffer
1168 */
1169 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Session Duration Expired"));
1170 if (irDelayEstablished == false)
1171 {
1172 /*
1173 * Coming out of rebuffering in case we had gone into
1174 * rebuffering just before
1175 */
1176 irJitterDelayPercent = 100;
1177 PVMFAsyncEvent jbEvent(PVMFInfoEvent, PVMFInfoDataReady, NULL, NULL);
1178 ReportJBInfoEvent(jbEvent);
1179 }
1180 irDelayEstablished = true;
1181 }
1182 else
1183 {
1184 uint32 diff32ms = 0;
1185 bool isEarly = PVTimeComparisonUtils::IsEarlier(estServerClock, clientClock, diff32ms);
1186 if (isEarly && diff32ms > 0)
1187 {
1188 /* Could happen during repositioning */
1189 if (irDelayEstablished == true)
1190 {
1191 aClockDiff = 0;
1192 irDelayEstablished = false;
1193 irJitterDelayPercent = 0;
1194 /* Start timer */
1195 PVMFAsyncEvent jbEvent(PVMFInfoEvent, PVMFInfoUnderflow, NULL, NULL);
1196 ReportJBInfoEvent(jbEvent);
1197 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - EstServClock=%d",
1198 Oscl_Int64_Utils::get_uint64_lower32(estServerClock)));
1199 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - ClientClock=%d",
1200 Oscl_Int64_Utils::get_uint64_lower32(clientClock)));
1201 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Estimated Serv Clock Less Than ClientClock!!!!"));
1202 PVMF_JB_LOGCLOCK_REBUFF((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - EstServClock=%d",
1203 Oscl_Int64_Utils::get_uint64_lower32(estServerClock)));
1204 PVMF_JB_LOGCLOCK_REBUFF((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Check - ClientClock=%d",
1205 Oscl_Int64_Utils::get_uint64_lower32(clientClock)));
1206 PVMF_JB_LOGCLOCK_REBUFF((0, "PVMFJitterBufferNode::IsDelayEstablished - Estimated Serv Clock Less Than ClientClock!!!!"));
1207 }
1208 return irDelayEstablished;
1209 }
1210 aClockDiff = diff32ms;
1211 if (diff32ms >= iDurationInMilliSeconds)
1212 {
1213 uint32 jbSize = iBufferAlloc->getBufferSize();
1214 uint32 largestContiguousFreeBlockSize = iBufferAlloc->getLargestContiguousFreeBlockSize();
1215 uint32 minPercentOccupancy = 100;
1216 if ((largestContiguousFreeBlockSize*100 / jbSize) < minPercentOccupancy)
1217 {
1218 minPercentOccupancy = (uint32)(largestContiguousFreeBlockSize * 100 / jbSize);
1219 }
1220
1221 if ((prevMinPercentOccupancy < MIN_PERCENT_OCCUPANCY_THRESHOLD) && (minPercentOccupancy < MIN_PERCENT_OCCUPANCY_THRESHOLD))
1222 {
1223 consecutiveLowBufferCount++;
1224 }
1225 else
1226 {
1227 consecutiveLowBufferCount = 0;
1228 }
1229
1230 prevMinPercentOccupancy = minPercentOccupancy;
1231 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - minPercentOccupancy=%d, consecutiveLowBufferCount=%d",
1232 minPercentOccupancy,
1233 consecutiveLowBufferCount));
1234
1235
1236 if ((diff32ms > JITTER_BUFFER_DURATION_MULTIPLIER_THRESHOLD*iDurationInMilliSeconds) && !iOverflowFlag && (consecutiveLowBufferCount > CONSECUTIVE_LOW_BUFFER_COUNT_THRESHOLD))
1237 {
1238 iOverflowFlag = true;
1239 PVMFAsyncEvent jbEvent(PVMFInfoEvent, PVMFInfoOverflow, NULL, NULL);
1240 ReportJBInfoEvent(jbEvent);
1241 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished reporting PVMFInfoSourceOverflow"));
1242 }
1243
1244 if (irDelayEstablished == false)
1245 {
1246 if (CheckNumElements())
1247 {
1248 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Cancelling Jitter Buffer Duration Timer"));
1249 irDelayEstablished = true;
1250 irJitterDelayPercent = 100;
1251 PVMFAsyncEvent jbEvent(PVMFInfoEvent, PVMFInfoDataReady, NULL, NULL);
1252 ReportJBInfoEvent(jbEvent);
1253 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Established - EstServClock=%d", estServerClock));
1254 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Established - ClientClock=%d", clientClock));
1255 PVMF_JB_LOGCLOCK_REBUFF((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Established - EstServClock=%d",
1256 estServerClock));
1257 PVMF_JB_LOGCLOCK_REBUFF((0, "PVMFJitterBufferNode::IsDelayEstablished - Time Delay Established - ClientClock=%d",
1258 clientClock));
1259 }
1260 else
1261 {
1262 irJitterDelayPercent = 0;
1263 }
1264 }
1265 else
1266 {
1267 irJitterDelayPercent = 100;
1268 }
1269 }
1270 else
1271 {
1272 /*
1273 * Update the buffering percent - to be used while sending buffering
1274 * status events, in case we go into rebuffering or if we are in buffering
1275 * state.
1276 */
1277 irJitterDelayPercent = ((diff32ms * 100) / iDurationInMilliSeconds);
1278 if (irDelayEstablished == true)
1279 {
1280 if (diff32ms <= iRebufferingThresholdInMilliSeconds)
1281 {
1282 /* Implies that we are going into rebuffering */
1283 if (!iEOSSignalled)
1284 {
1285 irDelayEstablished = false;
1286 PVMFAsyncEvent jbEvent(PVMFInfoEvent, PVMFInfoUnderflow, NULL, NULL);
1287 ReportJBInfoEvent(jbEvent);
1288 LOGCLIENTANDESTIMATEDSERVCLK_REBUFF;
1289 }
1290 /* we are past the end of the clip, no more rebuffering */
1291 irClientPlayBackClock.Pause();
1292 }
1293 }
1294 if (irDelayEstablished == false && CheckNumElements() == false)
1295 {
1296 irJitterDelayPercent = 0;
1297 }
1298 PVMF_JB_LOGCLOCK((0, "PVMFJitterBufferNode::IsDelayEstablished: Delay Percent = %d", irJitterDelayPercent));
1299 }
1300 /* if we are not rebuffering check for flow control */
1301 PerformFlowControl(false);
1302 }
1303 return (irDelayEstablished);
1304 }
1305
RetrievePacketPayload()1306 OSCL_EXPORT_REF PVMFSharedMediaDataPtr PVMFJitterBufferImpl::RetrievePacketPayload()
1307 {
1308 PVMF_JB_LOGINFO((0, "PVMFJitterBufferImpl::retrievePacket - JB Occup Stats - MimeType=%s, MaxSize=%d, CurrOccupany=%d", irMimeType.get_cstr(), iJitterBuffer->getArraySize(), iJitterBuffer->getNumElements()));
1309
1310 PVMFSharedMediaDataPtr elem = iJitterBuffer->retrieveElement();
1311 if (elem.GetRep() != NULL)
1312 {
1313 /*
1314 * Adjust TimeStamp - Goal is to provide a monotonically increasing
1315 * timestamp.
1316 */
1317 PVMFTimestamp currTS = elem->getTimestamp();
1318 DeterminePrevTimeStamp(elem->getSeqNum());
1319 iMonotonicTimeStamp += (currTS - iPrevTSOut);
1320 PVMFTimestamp adjustedTS =
1321 (PVMFTimestamp)(Oscl_Int64_Utils::get_uint64_lower32(iMonotonicTimeStamp));
1322 elem->setTimestamp(adjustedTS);
1323
1324 PVMFJitterBufferStats* jbStatsPtr = iJitterBuffer->getStatsPtr();
1325 jbStatsPtr->maxTimeStampRetrievedWithoutRTPOffset = adjustedTS;
1326
1327 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferImpl::retrievePacket: MimeType=%s, TS=%d, SEQNUM= %d",
1328 irMimeType.get_cstr(),
1329 elem->getTimestamp(),
1330 elem->getSeqNum()));
1331 iPrevTSOut = currTS;
1332 }
1333 return elem;
1334 }
1335
IsEmpty()1336 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::IsEmpty()
1337 {
1338 uint32 elems = iJitterBuffer->getNumElements();
1339 if (elems == 0)
1340 {
1341 return true;
1342 }
1343 return false;
1344 }
1345
SetEOS(bool aVal)1346 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetEOS(bool aVal)
1347 {
1348 PVMF_JB_LOG_RTCPDATATRAFFIC_OUT((0, "PVMFJitterBufferImpl::SetEOS Mime[%s]", irMimeType.get_cstr()));
1349 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferImpl::SetEOS Mime[%s]", irMimeType.get_cstr()));
1350
1351 if (aVal && !iEOSSignalled)
1352 {
1353 LOGCLIENTANDESTIMATEDSERVCLK_DATAPATH_OUT;
1354 iEOSSignalled = aVal;
1355 iObserver->EndOfStreamSignalled(iObserverContext);
1356 }
1357
1358 if (iReportCanRetrievePacket)
1359 {
1360 if (CanRetrievePacket())
1361 {
1362 iObserver->PacketReadyToBeRetrieved(iObserverContext);
1363 }
1364 }
1365 }
1366
GetEOS()1367 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::GetEOS()
1368 {
1369 return iEOSSignalled;
1370 }
1371
SetPlayRange(int32 aStartTimeInMS,bool aPlayAfterSeek,bool aStopTimeAvailable,int32 aStopTimeInMS)1372 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetPlayRange(int32 aStartTimeInMS, bool aPlayAfterSeek, bool aStopTimeAvailable, int32 aStopTimeInMS)
1373 {
1374 iStartTimeInMS = aStartTimeInMS;
1375 if (aStopTimeAvailable)
1376 {
1377 iPlayStopTimeAvailable = aStopTimeAvailable;
1378 iStopTimeInMS = aStopTimeInMS;
1379 }
1380
1381 if (aPlayAfterSeek)
1382 {
1383 iEOSSignalled = false;
1384 iEOSSent = false;
1385 }
1386 }
1387
CheckForHighWaterMark()1388 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CheckForHighWaterMark()
1389 {
1390 PVMFJitterBufferStats stats = iJitterBuffer->getStats();
1391 uint32 currOccupancy = stats.currentOccupancy;
1392 uint32 maxOccupancy = stats.maxOccupancy;
1393
1394 PVMF_JB_LOGINFO((0, "PVMFJitterBufferImpl::CheckForHighWaterMark: CurrOccupancy = %d", currOccupancy));
1395 if (currOccupancy >=
1396 maxOccupancy*DEFAULT_JITTER_BUFFER_HIGH_WATER_MARK)
1397 {
1398 return true;
1399 }
1400 return false;
1401 }
1402
CheckForLowWaterMark()1403 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CheckForLowWaterMark()
1404 {
1405 PVMFJitterBufferStats stats = iJitterBuffer->getStats();
1406 uint32 currOccupancy = stats.currentOccupancy;
1407 uint32 maxOccupancy = stats.maxOccupancy;
1408
1409 PVMF_JB_LOGINFO((0, "PVMFJitterBufferImpl::CheckForLowWaterMark: CurrOccupancy = %d", currOccupancy));
1410 if (currOccupancy <=
1411 maxOccupancy*DEFAULT_JITTER_BUFFER_LOW_WATER_MARK)
1412 {
1413 return true;
1414 }
1415 return false;
1416 }
1417
CheckNumElements()1418 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CheckNumElements()
1419 {
1420 if (iJitterBuffer->getNumElements() > 0)
1421 {
1422 return true;
1423 }
1424 else
1425 {
1426 return false;
1427 }
1428 }
1429
addMediaCommand(PVMFSharedMediaMsgPtr & aMediaCmd)1430 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::addMediaCommand(PVMFSharedMediaMsgPtr& aMediaCmd)
1431 {
1432 MediaCommandMsgHolder cmdHolder;
1433 cmdHolder.iPreceedingMediaMsgSeqNumber = getJitterBufferStats().lastRegisteredSeqNum;
1434 cmdHolder.iCmdMsg = aMediaCmd;
1435 iMediaCmdVec.push_back(cmdHolder);
1436 return true;
1437 }
1438
GetPendingCommand(PVMFSharedMediaMsgPtr & aCmdMsg)1439 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::GetPendingCommand(PVMFSharedMediaMsgPtr& aCmdMsg)
1440 {
1441 /*
1442 * Parse the command queue to see if it is time to send out
1443 * any pending ones. if last retrieved seq num is same as
1444 * the seq num of media msg that preceeds this cmd, then
1445 * it is time to send this cmd out
1446 */
1447 PVMFJitterBufferStats stats = getJitterBufferStats();
1448 Oscl_Vector<MediaCommandMsgHolder, OsclMemAllocator>::iterator it;
1449 for (it = iMediaCmdVec.begin(); it != iMediaCmdVec.end(); it++)
1450 {
1451 if (it->iCmdMsg->getFormatID() == PVMF_MEDIA_CMD_BOS_FORMAT_ID)
1452 {
1453 aCmdMsg = it->iCmdMsg;
1454 iMediaCmdVec.erase(it);
1455 return true;
1456 }
1457 if (it->iPreceedingMediaMsgSeqNumber == stats.lastRetrievedSeqNum)
1458 {
1459 aCmdMsg = it->iCmdMsg;
1460 iMediaCmdVec.erase(it);
1461 return true;
1462 }
1463 }
1464 return false;
1465 }
1466
HasPendingCommand()1467 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::HasPendingCommand()
1468 {
1469 /*
1470 * Parse the command queue to see if it is time to send out
1471 * any pending ones. if last retrieved seq num is same as
1472 * the seq num of media msg that preceeds this cmd, then
1473 * it is time to send this cmd out
1474 */
1475 PVMFJitterBufferStats stats = getJitterBufferStats();
1476 Oscl_Vector<MediaCommandMsgHolder, OsclMemAllocator>::iterator it;
1477 for (it = iMediaCmdVec.begin(); it != iMediaCmdVec.end(); it++)
1478 {
1479 if (it->iCmdMsg->getFormatID() == PVMF_MEDIA_CMD_BOS_FORMAT_ID)
1480 {
1481 return true;
1482 }
1483 if (it->iPreceedingMediaMsgSeqNumber == stats.lastRetrievedSeqNum)
1484 {
1485 return true;
1486 }
1487 }
1488 return false;
1489 }
1490
1491
SetAdjustedTSInMS(PVMFTimestamp aAdjustedTSInMS)1492 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetAdjustedTSInMS(PVMFTimestamp aAdjustedTSInMS)
1493 {
1494 // convert adjustedTS to RTP Timescale
1495 uint32 in_wrap_count = 0;
1496 MediaClockConverter clockConvertor;
1497 clockConvertor.set_timescale(1000);
1498 clockConvertor.set_clock(aAdjustedTSInMS, in_wrap_count);
1499 uint32 adjustedTSInRTPTS = clockConvertor.get_converted_ts(iRTPTimeScale);
1500 iMonotonicTimeStamp = adjustedTSInRTPTS;
1501 PVMF_JB_LOGDATATRAFFIC_OUT((0, "PVMFJitterBufferImpl::SetAdjustedTS(): adjustedTSInRTPTS=%d, iMonotonicTS=%d", adjustedTSInRTPTS, Oscl_Int64_Utils::get_uint64_lower32(iMonotonicTimeStamp)));
1502 }
1503
SetBroadCastSession()1504 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetBroadCastSession()
1505 {
1506 iBroadCastSession = true;
1507 }
1508
GetRTPInfoParams()1509 OSCL_EXPORT_REF PVMFRTPInfoParams& PVMFJitterBufferImpl::GetRTPInfoParams()
1510 {
1511 return *iRTPInfoParamsVec.end();
1512 }
1513
GetRTPTimeStampOffset(uint32 & aTimeStampOffset)1514 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::GetRTPTimeStampOffset(uint32& aTimeStampOffset)
1515 {
1516 if (seqNumLock)
1517 aTimeStampOffset = seqLockTimeStamp;
1518
1519 return seqNumLock;
1520 }
1521
NotifyFreeSpaceAvailable()1522 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::NotifyFreeSpaceAvailable()
1523 {
1524 if (iMediaDataGroupAlloc)
1525 {
1526 iMediaDataGroupAlloc->notifyfreechunkavailable(*this);
1527 return true;
1528 }
1529 return false;
1530 }
1531
freechunkavailable(OsclAny *)1532 OSCL_EXPORT_REF void PVMFJitterBufferImpl::freechunkavailable(OsclAny*)
1533 {
1534 if (iObserver)
1535 {
1536 iObserver->JitterBufferFreeSpaceAvailable(iObserverContext);
1537 }
1538 }
1539
1540
1541
CheckSpaceAvailability(PVMFSharedMediaMsgPtr & aMsg)1542 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CheckSpaceAvailability(PVMFSharedMediaMsgPtr& aMsg)
1543 {
1544 if (iJitterBuffer)
1545 {
1546 return (iJitterBuffer->CheckSpaceAvailability(GetNumOfPackets(aMsg)));
1547 }
1548 return false;
1549 }
1550
CheckSpaceAvailability()1551 OSCL_EXPORT_REF bool PVMFJitterBufferImpl::CheckSpaceAvailability()
1552 {
1553 return (iJitterBuffer->CheckSpaceAvailability());
1554 }
1555
setSSRC(uint32 aSSRC)1556 OSCL_EXPORT_REF void PVMFJitterBufferImpl::setSSRC(uint32 aSSRC)
1557 {
1558 PVMF_JB_LOGDATATRAFFIC_IN((0, "PVMFJitterBufferImpl::setSSRC: Setting SSRCFromSetUpResponse - MimeType=%s, SSRC=%d", irMimeType.get_cstr(), aSSRC));
1559 oSSRCFromSetUpResponseAvailable = true;
1560 SSRCFromSetUpResponse = aSSRC;
1561 SSRCLock = aSSRC;
1562 }
1563
GetSSRC() const1564 OSCL_EXPORT_REF uint32 PVMFJitterBufferImpl::GetSSRC() const
1565 {
1566 return SSRCLock;
1567 }
1568
1569 /**
1570 */
1571 //virtual bool CancelServerClockNotificationUpdates();
1572
1573
SetJitterBufferMemPoolInfo(uint32 aSize,uint32 aResizeSize,uint32 aMaxNumResizes,uint32 aExpectedNumberOfBlocksPerBuffer)1574 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetJitterBufferMemPoolInfo(uint32 aSize,
1575 uint32 aResizeSize,
1576 uint32 aMaxNumResizes,
1577 uint32 aExpectedNumberOfBlocksPerBuffer)
1578 {
1579 iJitterBufferMemPoolInfo.Init(aSize, aResizeSize, aMaxNumResizes, aExpectedNumberOfBlocksPerBuffer);
1580 }
1581
GetJitterBufferMemPoolInfo(uint32 & aSize,uint32 & aResizeSize,uint32 & aMaxNumResizes,uint32 & aExpectedNumberOfBlocksPerBuffer) const1582 OSCL_EXPORT_REF void PVMFJitterBufferImpl::GetJitterBufferMemPoolInfo(uint32& aSize, uint32& aResizeSize, uint32& aMaxNumResizes, uint32& aExpectedNumberOfBlocksPerBuffer) const
1583 {
1584 aSize = iJitterBufferMemPoolInfo.iSize;
1585 aResizeSize = iJitterBufferMemPoolInfo.iResizeSize;
1586 aMaxNumResizes = iJitterBufferMemPoolInfo.iMaxNumResizes;
1587 aExpectedNumberOfBlocksPerBuffer = iJitterBufferMemPoolInfo.iExpectedNumberOfBlocksPerBuffer;
1588 }
1589
SetTrackConfig(OsclRefCounterMemFrag & aConfig)1590 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetTrackConfig(OsclRefCounterMemFrag& aConfig)
1591 {
1592 iTrackConfig = aConfig;
1593 }
1594
SetTimeScale(uint32 aTimeScale)1595 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetTimeScale(uint32 aTimeScale)
1596 {
1597 iTimeScale = aTimeScale;
1598 }
1599
GetTimeScale() const1600 OSCL_EXPORT_REF uint32 PVMFJitterBufferImpl::GetTimeScale() const
1601 {
1602 return iTimeScale;
1603 }
1604
SetMediaClockConverter(MediaClockConverter * aConverter)1605 OSCL_EXPORT_REF void PVMFJitterBufferImpl::SetMediaClockConverter(MediaClockConverter* aConverter)
1606 {
1607 ipMediaClockConverter = aConverter;
1608 }
1609
PerformFlowControl(bool aIncomingMedia)1610 OSCL_EXPORT_REF PVMFStatus PVMFJitterBufferImpl::PerformFlowControl(bool aIncomingMedia)
1611 {
1612 OSCL_UNUSED_ARG(aIncomingMedia);
1613 return PVMFSuccess;
1614 }
1615
1616
LogClientAndEstimatedServerClock(PVLogger * & aLogger)1617 OSCL_EXPORT_REF void PVMFJitterBufferImpl::LogClientAndEstimatedServerClock(PVLogger*& aLogger)
1618 {
1619 uint32 timebase32 = 0;
1620 uint32 estServerClock = 0;
1621 uint32 clientClock = 0;
1622 bool overflowFlag = false;
1623 irEstimatedServerClock.GetCurrentTime32(estServerClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1624 irClientPlayBackClock.GetCurrentTime32(clientClock, overflowFlag, PVMF_MEDIA_CLOCK_MSEC, timebase32);
1625 PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, aLogger, PVLOGMSG_INFO, (0, "The value of estimated server clock is [%d] and client clock is [%d]", estServerClock, clientClock));
1626 }
1627
GetNumOfPackets(PVMFSharedMediaMsgPtr & aMsg) const1628 OSCL_EXPORT_REF uint32 PVMFJitterBufferImpl::GetNumOfPackets(PVMFSharedMediaMsgPtr& aMsg) const
1629 {
1630 if (iOnePacketPerFragment)
1631 {
1632 PVMFSharedMediaDataPtr inputDataPacket;
1633 convertToPVMFMediaData(inputDataPacket, aMsg);
1634 return inputDataPacket->getNumFragments();
1635 }
1636 else
1637 return 1;
1638 }
1639
ReportJBInfoEvent(PVMFAsyncEvent & aEvent)1640 OSCL_EXPORT_REF void PVMFJitterBufferImpl::ReportJBInfoEvent(PVMFAsyncEvent& aEvent)
1641 {
1642 iObserver->ProcessJBInfoEvent(aEvent);
1643 }
1644
HandleEvent_JitterBufferBufferingDurationComplete()1645 void PVMFJitterBufferImpl::HandleEvent_JitterBufferBufferingDurationComplete()
1646 {
1647 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::HandleEvent_JitterBufferBufferingDurationComplete In"));
1648
1649 if (!irDelayEstablished)
1650 {
1651 uint32 aClockDiff = 0;
1652 bool delayEstablished = IsDelayEstablished(aClockDiff);//To update delay percent
1653 if (iReportCanRetrievePacket && delayEstablished)
1654 {
1655 //Check if delay is established
1656 //There's no hole for for min threshold time
1657 if (CanRetrievePacket())
1658 {
1659 iObserver->PacketReadyToBeRetrieved(iObserverContext);
1660 iReportCanRetrievePacket = false;
1661 }
1662 }
1663 else
1664 {
1665 RequestEventCallBack(JB_BUFFERING_DURATION_COMPLETE);
1666 }
1667 }
1668
1669 PVMF_JB_LOG_EVENTS_CLOCK((0, "PVMFJitterBufferNode::HandleEvent_JitterBufferBufferingDurationComplete Out"));
1670 }
1671