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 // ---------------------------------------------------------------------- 19 // 20 // This Software is an original work of authorship of PacketVideo Corporation. 21 // Portions of the Software were developed in collaboration with NTT DoCoMo, 22 // Inc. or were derived from the public domain or materials licensed from 23 // third parties. Title and ownership, including all intellectual property 24 // rights in and to the Software shall remain with PacketVideo Corporation 25 // and NTT DoCoMo, Inc. 26 // 27 // ----------------------------------------------------------------------- 28 29 #include "srp.h" 30 #include "srp_ports.h" 31 #include "pvlogger.h" 32 33 /************************************************************************/ 34 /* Constants */ 35 /************************************************************************/ 36 const SRP::SrpAction SRP::iSrpStateTable[MAX_STATUS][MAX_EVENT] = 37 { 38 /* Event No. 0 1 2 3 4 5 6 7 */ 39 /* Status 0 */ { SRP::ACTION_NOP, SRP::ACTION_0_1, SRP::ACTION_0_2, SRP::ACTION_NOP, SRP::ACTION_NOP, SRP::ACTION_NOP, SRP::ACTION_0_2, SRP::ACTION_NOP} , 40 /* Status 1 */ { SRP::ACTION_NOP, SRP::ACTION_1_1, SRP::ACTION_0_2, SRP::ACTION_1_3, SRP::ACTION_1_3, SRP::ACTION_1_4, SRP::ACTION_0_2, SRP::ACTION_1_3} 41 }; 42 43 44 OSCL_EXPORT_REF SRP::SRP() : iN400MaxCounter(N400_DEFAULT_MAX_COUNTER), //changed max # of allowable retries from 10 to 200 45 //This was done in conjunction with lowering the SRP 46 //timeout value from 400ms to 50ms 47 iN402MaxCounter(N402_DEFAULT_MAX_COUNTER), //WNSRP counter 48 iCrcData(0), 49 iSendSeqNumber(0), 50 iRecvSeqNumber(0), 51 iStatus(STS_IDLE), 52 iCurWnsrpStatus(WNSRP_TX_SUPPORT), 53 iT401TimerValue(T401_VALUE_DEFAULT), 54 iWnsrpCommandSave(NULL), 55 iCcsrlSduSize(DEFAULT_CCSRL_SIZE), 56 iRxFrags(NULL), 57 iFreeRxFragList(NULL), 58 iPendingRxFragList(NULL), 59 iFirstCmd(true), 60 iLLPortOut(NULL), 61 iLLPortIn(NULL), 62 iULPortOut(NULL), 63 iULPortIn(NULL), 64 iTxMediaMsgPoolAlloc(NULL), 65 iTxMediaDataImplMemAlloc(NULL), 66 iTxPacketAlloc(NULL), 67 iOutstandingTxMediaMsgPoolAlloc(NULL), 68 iOutstandingTxMediaDataImplMemAlloc(NULL), 69 iRxMediaMsgPoolAlloc(NULL), 70 iRxMediaDataImplMemAlloc(NULL), 71 iRxPacketAlloc(NULL), 72 iRespMediaMsgPoolAlloc(NULL), 73 iRespMemAlloc(NULL), 74 iRespPacketAlloc(NULL), 75 iNsrpRespMemAlloc(NULL), 76 iNsrpRespPacketAlloc(NULL), 77 iNumTxMsgs(DEFAULT_SEND_QUEUE_SIZE), 78 iUseNSRP(true), 79 iFirstNSRPResp(false), 80 iHandleWNSRP(true), 81 iWNSRPTxWindow(DEFAULT_WNSRP_WINDOW), 82 iWNSRPRxWindow(DEFAULT_WNSRP_WINDOW), 83 iOldestWNSRPRetransSeqNum(0), 84 iT401Resolution(T401_RESOLUTION), 85 iObserver(NULL) 86 { 87 iLogger = PVLogger::GetLoggerObject("3g324m.h324.srp"); 88 } 89 90 OSCL_EXPORT_REF SRP::~SRP() 91 { 92 } 93 94 OSCL_EXPORT_REF void SRP::SrpInitL(void) 95 { 96 iLLPortOut = OSCL_NEW(SRPLowerLayerPortOut, ()); 97 OsclError::LeaveIfNull(iLLPortOut); 98 iLLPortIn = OSCL_NEW(SRPLowerLayerPortIn, (this)); 99 OsclError::LeaveIfNull(iLLPortIn); 100 iULPortOut = OSCL_NEW(SRPUpperLayerPortOut, ()); 101 OsclError::LeaveIfNull(iULPortOut); 102 iULPortIn = OSCL_NEW(SRPUpperLayerPortIn, (this)); 103 OsclError::LeaveIfNull(iULPortIn); 104 105 uint32 i; 106 iSrpCommandSave.timerID = iWNSRPTxWindow; 107 108 iWnsrpCommandSave = OSCL_ARRAY_NEW(SRPRespTimer, iWNSRPTxWindow); 109 OsclError::LeaveIfNull(iWnsrpCommandSave); 110 for (i = 0; i < iWNSRPTxWindow; i++) 111 { 112 iWnsrpCommandSave[i].timerID = i; 113 } 114 115 iRxFrags = OSCL_ARRAY_NEW(SRPRxData, iWNSRPRxWindow); 116 OsclError::LeaveIfNull(iRxFrags); 117 for (i = 0; i < iWNSRPRxWindow; i++) 118 { 119 FreeRxFrag(&iRxFrags[i]); 120 } 121 122 iTxMediaMsgPoolAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iNumTxMsgs, 0, &iMemAllocator)); 123 OsclError::LeaveIfNull(iTxMediaMsgPoolAlloc); 124 iTxMediaDataImplMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iNumTxMsgs + ((iWNSRPTxWindow + 1) * 2), 0, &iMemAllocator)); 125 OsclError::LeaveIfNull(iTxMediaDataImplMemAlloc); 126 iTxPacketAlloc = OSCL_NEW(PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>, (iNumTxMsgs + ((iWNSRPTxWindow + 1) * 2), MAX_SEND_FRAGS_PER_MSG, iTxMediaDataImplMemAlloc)); 127 OsclError::LeaveIfNull(iTxPacketAlloc); 128 iTxPacketAlloc->create(); 129 130 iOutstandingTxMediaMsgPoolAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, ((iWNSRPTxWindow + 1) * 2, 0, &iMemAllocator)); 131 OsclError::LeaveIfNull(iOutstandingTxMediaMsgPoolAlloc); 132 iOutstandingTxMediaDataImplMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, ((iWNSRPTxWindow + 1) * 2, 0, &iMemAllocator)); 133 OsclError::LeaveIfNull(iOutstandingTxMediaDataImplMemAlloc); 134 135 iRxMediaMsgPoolAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iWNSRPRxWindow * 2, 0, &iMemAllocator)); 136 OsclError::LeaveIfNull(iRxMediaMsgPoolAlloc); 137 iRxMediaDataImplMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (iWNSRPRxWindow * 2, 0, &iMemAllocator)); 138 OsclError::LeaveIfNull(iRxMediaDataImplMemAlloc); 139 iRxPacketAlloc = OSCL_NEW(PVMFSimpleMediaBufferCombinedAlloc, (iRxMediaDataImplMemAlloc)); 140 OsclError::LeaveIfNull(iRxPacketAlloc); 141 142 iRespMediaMsgPoolAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (MAX_RESP_MSGS, 0, &iMemAllocator)); 143 OsclError::LeaveIfNull(iRespMediaMsgPoolAlloc); 144 iRespMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (MAX_RESP_MSGS, 0, &iMemAllocator)); 145 OsclError::LeaveIfNull(iRespMemAlloc); 146 iRespPacketAlloc = OSCL_NEW(PVMFSimpleMediaBufferCombinedAlloc, (iRespMemAlloc)); 147 OsclError::LeaveIfNull(iRespPacketAlloc); 148 iNsrpRespMemAlloc = OSCL_NEW(OsclMemPoolFixedChunkAllocator, (MAX_RESP_MSGS, 0, &iMemAllocator)); 149 OsclError::LeaveIfNull(iNsrpRespMemAlloc); 150 iNsrpRespPacketAlloc = OSCL_NEW(PVMFSimpleMediaBufferCombinedAlloc, (iNsrpRespMemAlloc)); 151 OsclError::LeaveIfNull(iNsrpRespPacketAlloc); 152 153 iHdrAllocator.size((uint16) iNumTxMsgs*2, (SRP_HEADER_SIZE)); 154 iHdrAllocator.SetLeaveOnAllocFailure(false); 155 iCcsrlAllocator.size((uint16) iNumTxMsgs*2, CCSRL_HEADER_SIZE + SRP_SEQUENCE_SIZE); 156 iCcsrlAllocator.SetLeaveOnAllocFailure(false); 157 iFCSAllocator.size((uint16) iNumTxMsgs*2, SRP_FCS_SIZE); 158 iFCSAllocator.SetLeaveOnAllocFailure(false); 159 160 //Just need 1 fragment for SRP/NSRP messages and 1 for WNSRP messages 161 iMTEntryNumAllocator.size(NUM_MT_ENTRY_NUMBERS, MT_ENTRY_NUMBER_SIZE); 162 iMTEntryNumAllocator.SetLeaveOnAllocFailure(false); 163 iSrpNsrpEntryNumFrag = iMTEntryNumAllocator.get(); 164 *(uint8 *)iSrpNsrpEntryNumFrag.getMemFragPtr() = SRP_NSRP_MT_ENTRY_NUMBER; 165 iWnsrpEntryNumFrag = iMTEntryNumAllocator.get(); 166 *(uint8 *)iWnsrpEntryNumFrag.getMemFragPtr() = WNSRP_MT_ENTRY_NUMBER; 167 168 iSrpWaitQueue.reserve(iNumTxMsgs); 169 170 iFreeWnsrpCommandSave.reserve(iWNSRPTxWindow); 171 iActiveWnsrpCommandSave.reserve(iWNSRPTxWindow); 172 173 iSrpCommandSave.T401Timer.SetFrequency(T401_RESOLUTION); 174 for (i = 0; i < iWNSRPTxWindow; i++) 175 { 176 iWnsrpCommandSave[i].T401Timer.SetFrequency(T401_RESOLUTION); 177 iFreeWnsrpCommandSave.push_back(&iWnsrpCommandSave[i]); 178 } 179 180 //Temporary for now, should be called when tsc does a connect. 181 SrpStart(); 182 } 183 184 OSCL_EXPORT_REF void SRP::SrpReset(void) 185 { 186 //Temporary for now, should be called when tsc does a disconnect. 187 SrpStop(); 188 189 OsclRefCounterMemFrag temp; 190 iSrpNsrpEntryNumFrag = temp; 191 iWnsrpEntryNumFrag = temp; 192 193 iActiveWnsrpCommandSave.clear(); 194 iFreeWnsrpCommandSave.clear(); 195 196 iMTEntryNumAllocator.clear(); 197 iHdrAllocator.clear(); 198 iCcsrlAllocator.clear(); 199 iFCSAllocator.clear(); 200 201 if (iTxPacketAlloc) 202 { 203 iTxPacketAlloc->removeRef(); 204 iTxPacketAlloc = NULL; 205 } 206 207 if (iTxMediaDataImplMemAlloc) 208 { 209 OSCL_DELETE(iTxMediaDataImplMemAlloc); 210 iTxMediaDataImplMemAlloc = NULL; 211 } 212 213 if (iTxMediaMsgPoolAlloc) 214 { 215 OSCL_DELETE(iTxMediaMsgPoolAlloc); 216 iTxMediaMsgPoolAlloc = NULL; 217 } 218 219 if (iOutstandingTxMediaDataImplMemAlloc) 220 { 221 OSCL_DELETE(iOutstandingTxMediaDataImplMemAlloc); 222 iOutstandingTxMediaDataImplMemAlloc = NULL; 223 } 224 225 if (iOutstandingTxMediaMsgPoolAlloc) 226 { 227 OSCL_DELETE(iOutstandingTxMediaMsgPoolAlloc); 228 iOutstandingTxMediaMsgPoolAlloc = NULL; 229 } 230 231 if (iRxPacketAlloc) 232 { 233 OSCL_DELETE(iRxPacketAlloc); 234 iRxPacketAlloc = NULL; 235 } 236 237 if (iRxMediaDataImplMemAlloc) 238 { 239 OSCL_DELETE(iRxMediaDataImplMemAlloc); 240 iRxMediaDataImplMemAlloc = NULL; 241 } 242 243 if (iRxMediaMsgPoolAlloc) 244 { 245 OSCL_DELETE(iRxMediaMsgPoolAlloc); 246 iRxMediaMsgPoolAlloc = NULL; 247 } 248 249 if (iNsrpRespMemAlloc) 250 { 251 OSCL_DELETE(iNsrpRespMemAlloc); 252 iNsrpRespMemAlloc = NULL; 253 } 254 255 if (iNsrpRespPacketAlloc) 256 { 257 OSCL_DELETE(iNsrpRespPacketAlloc); 258 iNsrpRespPacketAlloc = NULL; 259 } 260 261 if (iRespMemAlloc) 262 { 263 OSCL_DELETE(iRespMemAlloc); 264 iRespMemAlloc = NULL; 265 } 266 267 if (iRespPacketAlloc) 268 { 269 OSCL_DELETE(iRespPacketAlloc); 270 iRespPacketAlloc = NULL; 271 } 272 273 if (iRespMediaMsgPoolAlloc) 274 { 275 OSCL_DELETE(iRespMediaMsgPoolAlloc); 276 iRespMediaMsgPoolAlloc = NULL; 277 } 278 279 if (iWnsrpCommandSave) 280 { 281 OSCL_ARRAY_DELETE(iWnsrpCommandSave); 282 iWnsrpCommandSave = NULL; 283 } 284 285 if (iRxFrags) 286 { 287 OSCL_ARRAY_DELETE(iRxFrags); 288 iRxFrags = NULL; 289 } 290 291 if (iLLPortOut) 292 { 293 OSCL_DELETE(iLLPortOut); 294 iLLPortOut = NULL; 295 } 296 297 if (iLLPortIn) 298 { 299 OSCL_DELETE(iLLPortIn); 300 iLLPortIn = NULL; 301 } 302 303 if (iULPortOut) 304 { 305 OSCL_DELETE(iULPortOut); 306 iULPortOut = NULL; 307 } 308 309 if (iULPortIn) 310 { 311 OSCL_DELETE(iULPortIn); 312 iULPortIn = NULL; 313 } 314 315 WnsrpStatusSet(WNSRP_TX_SUPPORT); 316 iHandleWNSRP = true; 317 } 318 319 320 OSCL_EXPORT_REF void SRP::SrpStart(void) 321 { 322 SrpResetStats(); 323 324 iFirstCmd = true; 325 326 /* Clear receive sequence number */ 327 SrpRecvSeqClear(); 328 /* Clear send sequence number */ 329 SrpSendSeqClear(); 330 331 /* Clear WNSRP retry counter */ 332 SrpN402Initialize(); 333 /* Set status */ 334 SrpStatusSet(STS_IDLE); 335 } 336 337 OSCL_EXPORT_REF void SRP::SrpStop(void) 338 { 339 SRPRxData *pendingRxFrag; 340 341 // Cancel any outstanding timer events 342 if (iSrpCommandSave.isTimerActive) 343 { 344 SrpT401Stop(iSrpCommandSave); 345 iSrpCommandSave.pPkt.Unbind(); 346 } 347 348 //Clear all WNSRP resp timers 349 while (!iActiveWnsrpCommandSave.empty()) 350 { 351 // Stop response wait timer 352 SrpT401Stop(*iActiveWnsrpCommandSave[0]); 353 354 // Release packet 355 iActiveWnsrpCommandSave[0]->pPkt.Unbind(); 356 357 // Remove timer from active list 358 RemoveActiveWnsrpTimer(iActiveWnsrpCommandSave[0]); 359 } 360 361 WnsrpStatusSet(WNSRP_TX_SUPPORT); 362 363 // Flush the queue 364 iSrpWaitQueue.clear(); 365 366 // Clear pending received packet. 367 while (iPendingRxFragList) 368 { 369 pendingRxFrag = iPendingRxFragList; 370 iPendingRxFragList = iPendingRxFragList->next; 371 FreeRxFrag(pendingRxFrag); 372 } 373 374 375 /* AR: Switch back to SRP mode */ 376 iUseNSRP = false; 377 378 /* Print iStats */ 379 SRPStats tempStats; 380 SrpGetStats(tempStats); 381 382 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "SRP Stats:")); 383 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Total frames recv %d", tempStats.totalFramesRecv)); 384 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Invalid size frames recv %d", tempStats.totalInvalidSizeFramesRecv)); 385 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "CRC errors recv %d", tempStats.totalCRCErrorsRecv)); 386 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Cmd frames recv %d", tempStats.totalCommandFramesRecv)); 387 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Cmd WNSRP frames recv %d", tempStats.totalWNSRPCommandFramesRecv)); 388 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Invalid CCSRL chunk recv %d", tempStats.totalInvalidCCSRLChunkRecv)); 389 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "SRP resp recv %d", tempStats.totalSRPRespRecv)); 390 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "NSRP resp recv %d", tempStats.totalNSRPRespRecv)); 391 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "WNSRP resp recv %d", tempStats.totalWNSRPRespRecv)); 392 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "H245 messages recv %d", tempStats.totalH245MessagesRecv)); 393 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "CCSRL chunks recv %d", tempStats.totalCCSRLChunksRecv)); 394 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Cmd frames sent %d", tempStats.totalCommandFramesSent)); 395 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "H245 messages to send %d", tempStats.totalH245MessagesToSend)); 396 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "H245 messages fragmented %d", tempStats.totalH245MessagesFragmented)); 397 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "CCSRL chunks sent %d", tempStats.totalCCSRLChunksSent)); 398 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Num of timeouts %d", tempStats.totalNumTimeouts)); 399 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Bytes recv %d", tempStats.totalBytesRecv)); 400 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Bytes sent %d", tempStats.totalBytesSent)); 401 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Invalid frames %d", tempStats.totalInvalidFrames)); 402 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Min response time %d", tempStats.minRespTime)); 403 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Max response time %d", tempStats.maxRespTime)); 404 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STATISTIC, (0x40000020, "Ave response time %d", tempStats.aveRespTime)); 405 } 406 407 /************************************************************************/ 408 /* function name : SrpGetEventNoFromAL1 */ 409 /* function outline : decide event number from received PDU */ 410 /* (H.223 AL1) */ 411 /* function discription: INT SrpGetEventNoFromAL1( */ 412 /* PVMFSharedMediaDataPtr pPkt ) */ 413 /* input data : pPkt - pointer of received packet */ 414 /* output data : event number */ 415 /* draw time : '96.10.29 */ 416 /*----------------------------------------------------------------------*/ 417 /* amendent career : */ 418 /* Copyright (C) 1996 NTT DoCoMo */ 419 /************************************************************************/ 420 SRP::SrpEvent SRP::SrpGetEventNoFromAL1(PVMFSharedMediaDataPtr pPkt) 421 { 422 SrpEvent EventNo = EV_NOP; 423 uint8 *pFrame; 424 uint8 CrcWork[2]; 425 OsclRefCounterMemFrag frag; 426 OsclSharedPtr<PVMFMediaDataImpl> data; 427 uint16 Crc16Check(PVMFSharedMediaDataPtr aData); 428 429 if (pPkt->getNumFragments() != 1) 430 { 431 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - fragments not equal to 1, num frags %d", pPkt->getNumFragments())); 432 return EventNo; 433 } 434 435 if (pPkt->getFilledSize() >= MINIMUM_FRAME_SIZE) 436 { 437 pPkt->getMediaDataImpl(data); 438 439 CrcClear(); 440 CrcSetToFrame(iCrc.Crc16Check(data, true), &CrcWork[0]); 441 442 pPkt->getMediaFragment(0, frag); 443 pFrame = (uint8 *) frag.getMemFragPtr(); 444 445 if ((CrcWork[0] == pFrame[pPkt->getFilledSize()-SRP_FCS_SIZE]) && 446 (CrcWork[1] == pFrame[pPkt->getFilledSize()-SRP_FCS_SIZE+1])) 447 { 448 switch (pFrame[0]) 449 { 450 case SRP_COMMAND_HEADER: 451 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - SRP_COMMAND_HEADER, seq num %d", pFrame[1])); 452 453 //Disable WNSRP if 1st command frame does not start with seq num 0 454 if ((WnsrpStatusGet() == WNSRP_TX_SUPPORT) && 455 iFirstCmd && 456 (pFrame[1] != 0)) 457 { 458 WnsrpStatusSet(NO_WNSRP_SUPPORT); 459 } 460 461 iStats.totalCommandFramesRecv++; 462 463 pPkt->setSeqNum((uint32) pFrame[1]); 464 465 //If using CCSRL method. 466 if (iCcsrlSduSize > 0) 467 { 468 //Check if is a valid CCSRL chunk. 469 if ((pFrame[2] == INTERMEDIATE_CCSRL_CHUNK) || (pFrame[2] == LAST_CCSRL_CHUNK)) 470 { 471 EventNo = EV_COMMAND; 472 } 473 else 474 { 475 // Record invalid CCSRL chunk 476 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP: Invalid CCSRL Chunk")); 477 iStats.totalInvalidCCSRLChunkRecv++; 478 } 479 } 480 //Else not using CCSRL method 481 else 482 { 483 EventNo = EV_COMMAND; 484 } 485 486 break; 487 488 case SRP_RESPONSE_HEADER: // No sequence number in SRP responses 489 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - SRP_RESPONSE_HEADER")); 490 491 if (WnsrpStatusGet() == WNSRP_TX_SUPPORT) 492 { 493 SrpN402Count(); 494 if (SrpN402Check() == false) 495 { 496 WnsrpStatusSet(NO_WNSRP_SUPPORT); 497 } 498 } 499 500 iStats.totalSRPRespRecv++; 501 502 // If using NSRP 503 if (iUseNSRP) 504 { 505 // If we haven't received an NSRP response yet, keep accepting SRP responses. 506 if (!iFirstNSRPResp) 507 { 508 EventNo = EV_RESPONSE; 509 } 510 } 511 // Else not using NSRP 512 else 513 { 514 EventNo = EV_RESPONSE; 515 } 516 break; 517 518 case NSRP_RESPONSE_HEADER: 519 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - NSRP_RESPONSE_HEADER, seq num %d", pFrame[1])); 520 521 if (WnsrpStatusGet() == WNSRP_TX_SUPPORT) 522 { 523 SrpN402Count(); 524 if (SrpN402Check() == false) 525 { 526 WnsrpStatusSet(NO_WNSRP_SUPPORT); 527 } 528 } 529 530 iStats.totalNSRPRespRecv++; 531 532 // If using NSRP, check sequence number. 533 if (iUseNSRP) 534 { 535 pPkt->setSeqNum((uint32) pFrame[1]); 536 537 if (!iFirstNSRPResp) 538 { 539 iFirstNSRPResp = true; 540 } 541 542 EventNo = EV_NSRP_RESPONSE; 543 } 544 //Else using SRP, just accept as a valid SRP response frame 545 else 546 { 547 EventNo = EV_RESPONSE; 548 } 549 break; 550 551 case WNSRP_COMMAND_HEADER: 552 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - WNSRP_COMMAND_HEADER, status %d, seq num %d", WnsrpStatusGet(), pFrame[1])); 553 554 if (!iHandleWNSRP) 555 { 556 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP:SrpGetEventNoFromAL1 - WNSRP_COMMAND_HEADER, not handling WNSRP frames")); 557 break; 558 } 559 560 iStats.totalWNSRPCommandFramesRecv++; 561 562 pPkt->setSeqNum((uint32) pFrame[1]); 563 564 switch (WnsrpStatusGet()) 565 { 566 case WNSRP_TX_SUPPORT: 567 WnsrpStatusSet(WNSRP_FULL_SUPPORT); 568 //Fall into next case. 569 570 case WNSRP_FULL_SUPPORT: 571 //If using CCSRL method. 572 if (iCcsrlSduSize > 0) 573 { 574 //Check if is a valid CCSRL chunk. 575 if ((pFrame[2] == INTERMEDIATE_CCSRL_CHUNK) || (pFrame[2] == LAST_CCSRL_CHUNK)) 576 { 577 EventNo = EV_WNSRP_COMMAND; 578 } 579 else 580 { 581 // Record invalid CCSRL chunk 582 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP: Invalid CCSRL Chunk")); 583 iStats.totalInvalidCCSRLChunkRecv++; 584 } 585 } 586 //Else not using CCSRL method 587 else 588 { 589 EventNo = EV_WNSRP_COMMAND; 590 } 591 592 break; 593 594 case NO_WNSRP_SUPPORT: 595 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP:SrpGetEventNoFromAL1 - no WNSRP support")); 596 break; 597 } 598 599 break; 600 601 case WNSRP_RESPONSE_HEADER: 602 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP:SrpGetEventNoFromAL1 - WNSRP_RESPONSE_HEADER, status %d, seq num %d", WnsrpStatusGet(), pFrame[1])); 603 604 if (!iHandleWNSRP) 605 { 606 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP:SrpGetEventNoFromAL1 - WNSRP_COMMAND_HEADER, not handling WNSRP frames")); 607 break; 608 } 609 610 iStats.totalWNSRPRespRecv++; 611 612 switch (WnsrpStatusGet()) 613 { 614 case WNSRP_TX_SUPPORT: 615 WnsrpStatusSet(WNSRP_FULL_SUPPORT); 616 //Fall into next case. 617 618 case WNSRP_FULL_SUPPORT: 619 //Set sequence number of the response. 620 pPkt->setSeqNum((uint32) pFrame[1]); 621 622 EventNo = EV_WNSRP_RESPONSE; 623 break; 624 625 case NO_WNSRP_SUPPORT: 626 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP:SrpGetEventNoFromAL1 - no WNSRP support")); 627 break; 628 } 629 break; 630 631 default: 632 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP: Unknown SRP command %d", pFrame[0])); 633 iStats.totalInvalidFrames++; 634 break; 635 } 636 } 637 // CRC errors. 638 else 639 { 640 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP: CRC check failed")); 641 iStats.totalCRCErrorsRecv++; 642 } 643 } 644 else 645 { 646 // Record number of frames received that have an invalid size. 647 iStats.totalInvalidSizeFramesRecv++; 648 } 649 650 return(EventNo) ; 651 } 652 653 /************************************************************************/ 654 /* function name : SrpStateChange */ 655 /* function outline : decide function to call given the status and */ 656 /* event */ 657 /* function discription: INT SrpGetEventNoFromAL1( void *data ) */ 658 /* input data : status - Status of Srp */ 659 /* event - Incoming event */ 660 /* data - optional state change data */ 661 /* output data : None */ 662 /* draw time : '96.10.29 */ 663 /*----------------------------------------------------------------------*/ 664 /* amendent career : */ 665 /* Copyright (C) 1996 NTT DoCoMo */ 666 /************************************************************************/ 667 int SRP::SrpStateChange(int status, int event, void *data) 668 { 669 switch (iSrpStateTable[status][event]) 670 { 671 case ACTION_NOP: 672 return (SrpNop()); 673 case ACTION_0_1: 674 return (Srp_0_1()); 675 case ACTION_0_2: 676 return (Srp_0_2(*(PVMFSharedMediaDataPtr *) data, event)); 677 678 679 case ACTION_1_1: 680 return (Srp_1_1()); 681 case ACTION_1_3: 682 return (Srp_1_3(*(PVMFSharedMediaDataPtr *) data, event)); 683 case ACTION_1_4: 684 return (Srp_1_4(*(int32 *) data)); 685 default: 686 return 0; 687 } 688 } 689 690 /************************************************************************/ 691 /* function name : SrpN400Check */ 692 /* function outline : N400 counter check */ 693 /* function discription: INT SrpN400Check(SRPRespTimer &timer) */ 694 /* input data : timer - timer to check */ 695 /* output data : Check result */ 696 /* OK : Not count over */ 697 /* NG : Count over */ 698 /* draw time : '96.10.29 */ 699 /*----------------------------------------------------------------------*/ 700 /* amendent career : */ 701 /* Copyright (C) 1996 NTT DoCoMo */ 702 /************************************************************************/ 703 int SRP::SrpN400Check(SRPRespTimer &timer) 704 { 705 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpN400Check - N400Counter=%d N400MaxCounter=%d", timer.N400Counter, iN400MaxCounter)); 706 707 if (timer.N400Counter < iN400MaxCounter) 708 { 709 return true; 710 } 711 else 712 { 713 return false; 714 } 715 } 716 717 /************************************************************************/ 718 /* function name : SrpN402Initialize */ 719 /* function outline : N402 counter initialize */ 720 /* function discription: void SrpN402Initialize( void ) */ 721 /* input data : None */ 722 /* output data : None */ 723 /* draw time : '05.08.23 */ 724 /*----------------------------------------------------------------------*/ 725 /* amendent career : */ 726 /* Copyright (C) 2005 PacketVideo Corp. */ 727 /************************************************************************/ 728 void SRP::SrpN402Initialize() 729 { 730 /* Clear counter */ 731 iN402Counter = 0 ; 732 } 733 734 735 /************************************************************************/ 736 /* function name : SrpN402Check */ 737 /* function outline : N402 counter check */ 738 /* function discription: INT SrpN402Check( void ) */ 739 /* input data : None */ 740 /* output data : Check result */ 741 /* OK : Not count over */ 742 /* NG : Count over */ 743 /* draw time : '05.08.23 */ 744 /*----------------------------------------------------------------------*/ 745 /* amendent career : */ 746 /* Copyright (C) 2005 PacketVideo Corp. */ 747 /************************************************************************/ 748 int SRP::SrpN402Check() 749 { 750 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpN402Check - N402Counter=%d N402MaxCounter=%d", iN402Counter, iN402MaxCounter)); 751 752 if (iN402Counter < iN402MaxCounter) 753 { 754 return true; 755 } 756 else 757 { 758 return false; 759 } 760 } 761 762 /************************************************************************/ 763 /* function name : CrcCalc */ 764 /* function outline : CRC calculation */ 765 /* function discription: void CrcCalc( PUCHAR pData, int Size ) */ 766 /* input data : pData - object data pointer */ 767 /* Size - object data size (octet length) */ 768 /* output data : None */ 769 /* draw time : '96.10.29 */ 770 /*----------------------------------------------------------------------*/ 771 /* amendent career : */ 772 /* Copyright (C) 1996 NTT DoCoMo */ 773 /************************************************************************/ 774 void SRP::CrcCalc(uint8 *pData, int Size) 775 { 776 int BitCount; 777 778 while (Size--) /* process for all data */ 779 { 780 for (BitCount = 0 ; BitCount < 8 ; BitCount++) /* process for 8 bit data */ 781 { 782 if ((iCrcData & 0x8000) != 0) /* MSB=1? */ 783 { 784 iCrcData <<= 1; 785 iCrcData |= ((*pData >> BitCount) & 0x01); 786 iCrcData ^= GX_CRC_12; 787 } 788 else 789 { 790 iCrcData <<= 1; 791 iCrcData |= ((*pData >> BitCount) & 0x01); 792 } 793 } 794 795 /* update pointer of data */ 796 pData++; 797 } 798 return ; 799 } 800 801 /************************************************************************/ 802 /* function name : CrcResultGet */ 803 /* function outline : Get result of CRC calculation */ 804 /* function discription: USHORT CrcResultGet( void ) */ 805 /* input data : None */ 806 /* output data : Result of CRC Calculation */ 807 /* draw time : '96.10.29 */ 808 /*----------------------------------------------------------------------*/ 809 /* amendent career : */ 810 /* Copyright (C) 1996 NTT DoCoMo */ 811 /************************************************************************/ 812 uint16 SRP::CrcResultGet(void) 813 { 814 int BitCount; 815 816 for (BitCount = 0 ; BitCount < 16 ; BitCount++) /* process for 16bit */ 817 { 818 if ((iCrcData & 0x8000) != 0) /* MSB=1? */ 819 { 820 iCrcData <<= 1; 821 iCrcData ^= GX_CRC_12; 822 } 823 else 824 { 825 iCrcData <<= 1; 826 } 827 } 828 return((uint16)iCrcData) ; 829 } 830 831 /************************************************************************/ 832 /* function name : CrcSetToFrame */ 833 /* function outline : Set CRC data to FCS area of frame */ 834 /* function discription: void CrcSetToFrame( USHORT Crc, PUCHAR pFcs ) */ 835 /* input data : None */ 836 /* output data : Crc - CRC data */ 837 /* pFcs - FCS data pointer */ 838 /* draw time : '96.10.29 */ 839 /*----------------------------------------------------------------------*/ 840 /* amendent career : */ 841 /* Copyright (C) 1996 NTT DoCoMo */ 842 /************************************************************************/ 843 void SRP::CrcSetToFrame(uint16 crc, uint8 *pFcs) 844 { 845 846 /* Clear first fcs octet */ 847 *pFcs = 0; 848 849 *pFcs = (uint8)(crc & 0x00ff); 850 pFcs++; 851 *pFcs = (uint8)((crc & 0xff00) >> 8); 852 853 return ; 854 } 855 856 /************************************************************************/ 857 /* function name : SrpCommandCreate */ 858 /* function outline : Create command frame */ 859 /* function discription: void SrpCommandCreate( */ 860 /* PVMFSharedMediaDataPtr pPkt ) */ 861 /* input data : pPkt - data packet to create SRP command frame*/ 862 /* output data : None */ 863 /* draw time : '05.08.24 */ 864 /*----------------------------------------------------------------------*/ 865 /* amendent career : */ 866 /* Copyright (C) 2005 PacketVideo Corp. */ 867 /************************************************************************/ 868 PVMFSharedMediaDataPtr SRP::SrpCommandCreate(PVMFSharedMediaDataPtr pPkt, uint8 header) 869 { 870 uint16 crc; 871 uint16 Crc16Check(PVMFSharedMediaDataPtr aData); 872 int32 error = OsclErrNone; 873 OsclSharedPtr<PVMFMediaDataImpl> srpPkt; 874 PVMFSharedMediaDataPtr txData; 875 OsclRefCounterMemFrag headerFrag; 876 OsclRefCounterMemFrag FCSFrag; 877 878 OSCL_UNUSED_ARG(error); 879 switch (header) 880 { 881 case SRP_COMMAND_HEADER: 882 case WNSRP_COMMAND_HEADER: 883 srpPkt = iTxPacketAlloc->allocate(); 884 if (!srpPkt) 885 { 886 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, 887 (0x40000020, "SRP::SrpCommandCreate - Unable allocate tx media impl %d", error)); 888 return txData; 889 } 890 break; 891 892 default: 893 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpCommandCreate - Unable command type %x", header)); 894 return txData; 895 896 } 897 898 // Allocate header fragment. 899 headerFrag = iHdrAllocator.get(); 900 if (headerFrag.getMemFragPtr() == NULL) 901 { 902 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpCommandCreate Unable to allocate header frag %d", error)); 903 return txData; 904 } 905 906 907 // Allocate fcs fragment. 908 FCSFrag = iFCSAllocator.get(); 909 if (FCSFrag.getMemFragPtr() == NULL) 910 { 911 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpCommandCreate Unable to allocate FCS frag %d", error)); 912 return txData; 913 } 914 915 916 //Set header value 917 *(uint8 *) headerFrag.getMemFragPtr() = header; 918 headerFrag.getMemFrag().len = SRP_HEADER_SIZE; 919 920 // Add header to the front of the packet. 921 srpPkt->appendMediaFragment(headerFrag); 922 923 // Add data fragments 924 for (uint32 i = 0; i < pPkt->getNumFragments(); i++) 925 { 926 pPkt->getMediaFragment(i, headerFrag); 927 srpPkt->appendMediaFragment(headerFrag); 928 } 929 930 // Initialize crc calcuration 931 CrcClear(); 932 // Calculate crc 933 crc = iCrc.Crc16Check(srpPkt); // 16bit CRC Infomation Create 934 935 // Set crc to fcs 936 CrcSetToFrame(crc, (uint8 *) FCSFrag.getMemFragPtr()); 937 FCSFrag.getMemFrag().len = SRP_FCS_SIZE; 938 939 // Add CRC to the end of the packet. 940 srpPkt->appendMediaFragment(FCSFrag); 941 942 txData = PVMFMediaData::createMediaData(srpPkt, iOutstandingTxMediaMsgPoolAlloc); 943 if (!txData) 944 { 945 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpCommandCreate - Unable allocate tx message %d", error)) 946 return txData; 947 } 948 //If SRP 949 if (header == SRP_COMMAND_HEADER) 950 { 951 txData->setFormatSpecificInfo(iSrpNsrpEntryNumFrag); 952 } 953 //Else WNSRP 954 else 955 { 956 txData->setFormatSpecificInfo(iWnsrpEntryNumFrag); 957 } 958 959 // Set sequence number 960 txData->setSeqNum(pPkt->getSeqNum()); 961 962 iStats.totalCCSRLChunksSent++; 963 iStats.totalCommandFramesSent++; 964 965 /* Record initial time when chunk is sent. */ 966 iInitialTimeChunkSent.set_to_current_time(); 967 968 return txData; 969 } 970 971 /************************************************************************/ 972 /* function name : SrpCommandClear */ 973 /* function outline : Clear comand frame for re-transmittion */ 974 /* function discription: void SrpCommandClear(SRPRespTimer &timer) */ 975 /* input data : timer - response timer that hold frame to be */ 976 /* retransmitted. */ 977 /* output data : None */ 978 /* draw time : '05.08.24 */ 979 /*----------------------------------------------------------------------*/ 980 /* amendent career : */ 981 /* Copyright (C) 2005 PacketVideo Corp. */ 982 /************************************************************************/ 983 void SRP::SrpCommandClear(uint32 seqNum) 984 { 985 uint32 i; 986 987 //Find packet with same sequence number in wait queue and remove 988 for (i = 0; i < iSrpWaitQueue.size(); i++) 989 { 990 if (iSrpWaitQueue[i]->getSeqNum() == seqNum) 991 { 992 iSrpWaitQueue.erase(&iSrpWaitQueue[i]); 993 return; 994 } 995 } 996 997 return; 998 } 999 1000 /************************************************************************/ 1001 /* function name : SrpResponseCreate */ 1002 /* function outline : Create response frame */ 1003 /* function discription: void SrpResponseCreate( uint8 seqNum ) */ 1004 /* input data : seqNum - Sequence number of response frame */ 1005 /* header - SRP response frame type */ 1006 /* output data : pointer to created response packet */ 1007 /* draw time : '96.10.29 */ 1008 /*----------------------------------------------------------------------*/ 1009 /* amendent career : */ 1010 /* Copyright (C) 1996 NTT DoCoMo */ 1011 /************************************************************************/ 1012 PVMFSharedMediaDataPtr SRP::SrpResponseCreate(uint8 seqNum, uint8 header) 1013 { 1014 OsclSharedPtr<PVMFMediaDataImpl> resp; 1015 PVMFSharedMediaDataPtr mediaData; 1016 int32 error = OsclErrNone; 1017 uint8* pEditPtr; 1018 uint16 crc; 1019 uint16 Crc16Check(uint8 *, uint16); 1020 OsclRefCounterMemFrag frag; 1021 1022 OSCL_UNUSED_ARG(error); 1023 1024 switch (header) 1025 { 1026 case NSRP_RESPONSE_HEADER: 1027 case WNSRP_RESPONSE_HEADER: 1028 resp = iNsrpRespPacketAlloc->allocate(SRP_HEADER_SIZE + SRP_FCS_SIZE + SRP_SEQUENCE_SIZE); /* WWU_NSRP */ 1029 break; 1030 1031 case SRP_RESPONSE_HEADER: 1032 resp = iRespPacketAlloc->allocate(SRP_HEADER_SIZE + SRP_FCS_SIZE); /* SRP */ 1033 break; 1034 1035 default: 1036 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpResponseCreate - Unknown response type %d", header)); 1037 return mediaData; 1038 } 1039 1040 //Unable to allocate fragment. 1041 if (!resp) 1042 { 1043 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpResponseCreate - Unable to allocate fragment %d", error)); 1044 return mediaData; 1045 } 1046 1047 resp->getMediaFragment(0, frag); 1048 1049 pEditPtr = (uint8 *) frag.getMemFragPtr(); 1050 1051 /* Initialize crc calcuration */ 1052 CrcClear() ; 1053 1054 /* Set header octet */ 1055 switch (header) 1056 { 1057 case NSRP_RESPONSE_HEADER: 1058 case WNSRP_RESPONSE_HEADER: 1059 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpResponseCreate - Sending NSRP or WNSRP Response, SeqNum = %d", seqNum)); 1060 *pEditPtr++ = header; 1061 *pEditPtr++ = seqNum; 1062 resp->setMediaFragFilledLen(0, SRP_HEADER_SIZE + SRP_FCS_SIZE + SRP_SEQUENCE_SIZE); 1063 crc = iCrc.Crc16Check((uint8 *) frag.getMemFragPtr(), SRP_HEADER_SIZE + SRP_SEQUENCE_SIZE); /* 16bit CRC Infomation Create */ 1064 break; 1065 1066 case SRP_RESPONSE_HEADER: 1067 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpResponseCreate - Sending SRP Response")); 1068 *pEditPtr++ = header; 1069 resp->setMediaFragFilledLen(0, SRP_HEADER_SIZE + SRP_FCS_SIZE); 1070 crc = iCrc.Crc16Check((uint8 *) frag.getMemFragPtr(), SRP_HEADER_SIZE); /* 16bit CRC Infomation Create */ 1071 break; 1072 1073 default: 1074 return mediaData; 1075 } 1076 1077 /* Set crc to fcs */ 1078 CrcSetToFrame(crc, pEditPtr) ; 1079 1080 mediaData = PVMFMediaData::createMediaData(resp, iRespMediaMsgPoolAlloc); 1081 if (!mediaData) 1082 { 1083 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpResponseCreate - Unable to allocate msg %d", error)); 1084 return mediaData; 1085 } 1086 mediaData->setSeqNum((uint32) seqNum); 1087 //If SRP 1088 switch (header) 1089 { 1090 case NSRP_RESPONSE_HEADER: 1091 case SRP_RESPONSE_HEADER: 1092 mediaData->setFormatSpecificInfo(iSrpNsrpEntryNumFrag); 1093 break; 1094 1095 case WNSRP_RESPONSE_HEADER: 1096 mediaData->setFormatSpecificInfo(iWnsrpEntryNumFrag); 1097 break; 1098 } 1099 1100 return mediaData; 1101 } 1102 1103 /************************************************************************/ 1104 /* function name : SrpMsgCopy */ 1105 /* function outline : Get SRP data from in packet and put it in the */ 1106 /* out packet. */ 1107 /* function discription: bool SrpMsgCopy( */ 1108 /* PVMFSharedMediaDataPtr inPkt) */ 1109 /* input data : inPkt - Pointer to incoming packet. */ 1110 /* outPkt - Pointer to outgoing packet. */ 1111 /* output data : None */ 1112 /* draw time : '96.10.29 */ 1113 /*----------------------------------------------------------------------*/ 1114 /* amendent career : */ 1115 /* Copyright (C) 1996 NTT DoCoMo */ 1116 /************************************************************************/ 1117 bool SRP::SrpMsgCopy(PVMFSharedMediaDataPtr inPkt) 1118 { 1119 OsclRefCounterMemFrag frag; 1120 OsclSharedPtr<PVMFMediaDataImpl> data; 1121 SRPRxData *rxData; 1122 int32 error = OsclErrNone; 1123 OSCL_UNUSED_ARG(error); 1124 uint8 *pData; 1125 uint8* pFragPos = NULL; 1126 int fragLen = 0; 1127 1128 inPkt->getMediaFragment(0, frag); 1129 1130 pData = ((uint8 *) frag.getMemFragPtr()) + SRP_HEADER_SIZE + SRP_SEQUENCE_SIZE; 1131 1132 //If using CCSRL method. 1133 if (iCcsrlSduSize > 0) 1134 { 1135 iStats.totalCCSRLChunksRecv++; 1136 pFragPos = pData + CCSRL_HEADER_SIZE; 1137 fragLen = frag.getMemFragSize() - SRP_HEADER_SIZE - SRP_SEQUENCE_SIZE - CCSRL_HEADER_SIZE - SRP_FCS_SIZE; 1138 } 1139 else 1140 { 1141 pFragPos = pData; 1142 fragLen = frag.getMemFragSize() - SRP_HEADER_SIZE - SRP_SEQUENCE_SIZE - SRP_FCS_SIZE; 1143 } 1144 1145 //Data to large. Pass up whatever is buffered in receive packet 1146 if (fragLen > MAX_SIZE_OF_SRP_PDU) 1147 { 1148 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpMsgCopy - incoming data to large to copy %d, max %d", fragLen, MAX_SIZE_OF_SRP_PDU)); 1149 return false; 1150 } 1151 1152 rxData = GetRxFrag(); 1153 1154 if (rxData == NULL) 1155 { 1156 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpMsgCopy - unable to allocate rx data frag %d", error)); 1157 return false; 1158 } 1159 1160 if (!AllocateRxPacket(data, rxData)) 1161 return 0; 1162 if (!CreateMediaData(rxData, data)) 1163 return 0; 1164 rxData->data->getMediaFragment(0, frag); 1165 oscl_memcpy(frag.getMemFragPtr(), pFragPos, fragLen); 1166 rxData->data->setMediaFragFilledLen(0, fragLen); 1167 1168 rxData->seqNum = (uint8) inPkt->getSeqNum(); 1169 1170 if (iCcsrlSduSize > 0) 1171 { 1172 // Return true if last CCSRL fragment in original H245 packet. 1173 data->setMarkerInfo(((*pData == LAST_CCSRL_CHUNK) ? true : false)); 1174 } 1175 else 1176 { 1177 data->setMarkerInfo(true); 1178 } 1179 1180 //Add to rx pending list 1181 AddPendingRxFrag(rxData); 1182 1183 return true; 1184 } 1185 1186 bool SRP::AllocateRxPacket(OsclSharedPtr<PVMFMediaDataImpl>& data, SRPRxData* rxData) 1187 { 1188 data = iRxPacketAlloc->allocate(MAX_SIZE_OF_SRP_PDU); 1189 if (!data) 1190 { 1191 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpMsgCopy - Unable allocate rx message impl")); 1192 FreeRxFrag(rxData); 1193 return false; 1194 } 1195 return true; 1196 1197 } 1198 bool SRP::CreateMediaData(SRPRxData* rxData, OsclSharedPtr<PVMFMediaDataImpl> data) 1199 { 1200 rxData->data = PVMFMediaData::createMediaData(data, iRxMediaMsgPoolAlloc); 1201 if (!(rxData->data)) 1202 { 1203 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::SrpMsgCopy - Unable allocate rx message")); 1204 FreeRxFrag(rxData); 1205 return false; 1206 } 1207 return true; 1208 1209 } 1210 1211 1212 bool SRP::CreateMediaData(PVMFSharedMediaDataPtr& srpPkt, 1213 OsclSharedPtr<PVMFMediaDataImpl> data) 1214 { 1215 srpPkt = PVMFMediaData::createMediaData(data, iTxMediaMsgPoolAlloc); 1216 if (!srpPkt) 1217 { 1218 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, 1219 (0x40000020, "SRP::UpperLayerRx - Unable allocate tx message")); 1220 return false; 1221 } 1222 return true; 1223 } 1224 1225 /************************************************************************/ 1226 /* function name : Srp_0_1 */ 1227 /* function outline : PDU received in IDLE */ 1228 /* function discription: PVMFSharedMediaDataPtr Srp_0_1() */ 1229 /* input data : pPkt - pointer of received packet from corder */ 1230 /* output data : None */ 1231 /* draw time : '96.10.29 */ 1232 /*----------------------------------------------------------------------*/ 1233 /* amendent career : */ 1234 /* Copyright (C) 1996 NTT DoCoMo */ 1235 /************************************************************************/ 1236 int SRP::Srp_0_1() 1237 { 1238 PVMFSharedMediaDataPtr pSrpCommandPkt; 1239 PVMFSharedMediaDataPtr pTxPkt; 1240 PVMFSharedMediaDataPtr pFirstPkt; 1241 SRPRespTimer *pTimer; 1242 1243 switch (WnsrpStatusGet()) 1244 { 1245 case NO_WNSRP_SUPPORT: 1246 case WNSRP_TX_SUPPORT: 1247 pFirstPkt = SrpSendWaitGet(0); 1248 1249 /* Create SRP command */ 1250 pTxPkt = SrpCommandCreate(pFirstPkt, SRP_COMMAND_HEADER); 1251 1252 /* If packet could not be created. */ 1253 if (pTxPkt.GetRep() == NULL) 1254 { 1255 return(0); 1256 } 1257 1258 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_0_1 - lowerlayertx srp cmd seq num %d", pTxPkt->getSeqNum())); 1259 1260 /* Send SRP command */ 1261 LowerLayerTx(pTxPkt); 1262 /* Start response wait timer */ 1263 SrpT401Start(iSrpCommandSave, pTxPkt); 1264 1265 if (WnsrpStatusGet() == NO_WNSRP_SUPPORT) break; 1266 //If tx support only, must send srp frame also. 1267 1268 case WNSRP_FULL_SUPPORT: 1269 while (!iFreeWnsrpCommandSave.empty() && 1270 (iActiveWnsrpCommandSave.size() < iSrpWaitQueue.size())) 1271 { 1272 pSrpCommandPkt = SrpSendWaitGet(iActiveWnsrpCommandSave.size()); 1273 1274 //No more outstanding frags to send 1275 if (pSrpCommandPkt.GetRep() == NULL) 1276 { 1277 break; 1278 } 1279 1280 /* Create WNSRP command */ 1281 pTxPkt = SrpCommandCreate(pSrpCommandPkt, WNSRP_COMMAND_HEADER); 1282 1283 /* If packet could not be created. */ 1284 if (pTxPkt.GetRep() == NULL) 1285 { 1286 return(0); 1287 } 1288 1289 pTimer = GetFreeWnsrpTimer(); 1290 1291 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_0_1 - lowerlayertx wnsrp cmd seq num %d", pTxPkt->getSeqNum())); 1292 1293 /* Send SRP command */ 1294 LowerLayerTx(pTxPkt); 1295 /* Start response wait timer */ 1296 SrpT401Start(*pTimer, pTxPkt); 1297 1298 AddActiveWnsrpTimer(pTimer); 1299 } 1300 1301 break; 1302 1303 default: 1304 break; 1305 } 1306 1307 /* Set status */ 1308 SrpStatusSet(STS_WAIT_RESPONSE); 1309 return (1); 1310 } 1311 1312 /************************************************************************/ 1313 /* function name : Srp_0_2 */ 1314 /* function outline : SRP command received */ 1315 /* in IDLE or WAITING-RESPONSE */ 1316 /* function discription: PVMFSharedMediaDataPtr Srp_0_2( */ 1317 /* PVMFSharedMediaDataPtr pPkt ) */ 1318 /* input data : pPkt - pointer of received packet from AL1C */ 1319 /* output data : None */ 1320 /* draw time : '96.10.29 */ 1321 /*----------------------------------------------------------------------*/ 1322 /* amendent career : */ 1323 /* Copyright (C) 1996 NTT DoCoMo */ 1324 /************************************************************************/ 1325 int SRP::Srp_0_2(PVMFSharedMediaDataPtr pPkt, int event) 1326 { 1327 PVMFSharedMediaDataPtr resp; 1328 OsclRefCounterMemFrag frag; 1329 SRPRxData *rxData; 1330 uint8 header; 1331 1332 //If WNSRP command 1333 if (event == EV_WNSRP_COMMAND) 1334 { 1335 header = WNSRP_RESPONSE_HEADER; 1336 } 1337 //Else SRP command 1338 else 1339 { 1340 if (iUseNSRP) 1341 { 1342 header = NSRP_RESPONSE_HEADER; 1343 } 1344 else 1345 { 1346 header = SRP_RESPONSE_HEADER; 1347 } 1348 } 1349 1350 if (iFirstCmd) 1351 { 1352 //WNSRP must always start with 0 1353 if (event == EV_WNSRP_COMMAND) 1354 { 1355 SrpRecvSeqSet(0); 1356 } 1357 else 1358 { 1359 SrpRecvSeqSet((uint8) pPkt->getSeqNum()); 1360 } 1361 1362 iFirstCmd = false; 1363 } 1364 1365 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::Srp_0_2 - Incoming SequenceNumber = %d", pPkt->getSeqNum())); 1366 1367 if (CheckRxSeqNum(pPkt->getSeqNum(), header)) 1368 { 1369 if (!SrpMsgCopy(pPkt)) 1370 { 1371 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::Srp_0_2 - Unable to copy data")); 1372 return 0; 1373 } 1374 1375 // Create SRP response 1376 resp = SrpResponseCreate((uint8) pPkt->getSeqNum(), header); 1377 if (resp.GetRep() == NULL) 1378 { 1379 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::Srp_0_2 - Unable create reponse packet")); 1380 /* If unable to create response message. */ 1381 return 0; 1382 } 1383 1384 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_0_2 - lowerlayertx srp resp seq num %d", resp->getSeqNum())); 1385 1386 // SRP response send 1387 LowerLayerTx(resp); 1388 1389 // Check for full H245 messages 1390 while (iPendingRxFragList && 1391 (iPendingRxFragList->seqNum == SrpRecvSeqGet())) 1392 { 1393 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_0_2 - upperlayertx last frag %d", iPendingRxFragList->data->getMarkerInfo())); 1394 1395 UpperLayerTx(iPendingRxFragList->data); 1396 1397 rxData = iPendingRxFragList; 1398 iPendingRxFragList = iPendingRxFragList->next; 1399 1400 FreeRxFrag(rxData); 1401 1402 SrpRecvSeqCount(); 1403 } 1404 } 1405 1406 return 1; 1407 } 1408 1409 /************************************************************************/ 1410 /* function name : Srp_1_1 */ 1411 /* function outline : PDU received from corder in WAITING-RESPONSE */ 1412 /* function discription: PVMFSharedMediaDataPtr Srp_1_1() */ 1413 /* input data : pPkt - pointer of received packet from corder */ 1414 /* output data : None */ 1415 /* draw time : '96.10.29 */ 1416 /*----------------------------------------------------------------------*/ 1417 /* amendent career : */ 1418 /* Copyright (C) 1996 NTT DoCoMo */ 1419 /************************************************************************/ 1420 int SRP::Srp_1_1() 1421 { 1422 PVMFSharedMediaDataPtr pTxPkt; 1423 SRPRespTimer *pTimer; 1424 1425 switch (WnsrpStatusGet()) 1426 { 1427 case NO_WNSRP_SUPPORT: 1428 //SRP mode, cannot send until response for last packet is received. 1429 break; 1430 1431 case WNSRP_TX_SUPPORT: 1432 case WNSRP_FULL_SUPPORT: 1433 while (!iFreeWnsrpCommandSave.empty() && 1434 (iActiveWnsrpCommandSave.size() < iSrpWaitQueue.size())) 1435 { 1436 /* Create WNSRP command */ 1437 pTxPkt = SrpCommandCreate(SrpSendWaitGet(iActiveWnsrpCommandSave.size()), WNSRP_COMMAND_HEADER); 1438 1439 /* If packet could not be created. */ 1440 if (pTxPkt.GetRep() == NULL) 1441 { 1442 return(0); 1443 } 1444 1445 pTimer = GetFreeWnsrpTimer(); 1446 1447 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_1_1 - lowerlayertx wnsrp cmd seq num %d", pTxPkt->getSeqNum())); 1448 1449 /* Send SRP command */ 1450 LowerLayerTx(pTxPkt); 1451 /* Start response wait timer */ 1452 SrpT401Start(*pTimer, pTxPkt); 1453 1454 AddActiveWnsrpTimer(pTimer); 1455 } 1456 break; 1457 1458 default: 1459 break; 1460 } 1461 1462 return (1); 1463 } 1464 1465 /************************************************************************/ 1466 /* function name : Srp_1_3 */ 1467 /* function outline : SRP response received in WAITING-RESPONSE */ 1468 /* function discription: PVMFSharedMediaDataPtr Srp_1_3( */ 1469 /* PVMFSharedMediaDataPtr pPkt ) */ 1470 /* input data : pPkt - pointer of received packet from AL1C */ 1471 /* output data : None */ 1472 /* draw time : '96.10.29 */ 1473 /*----------------------------------------------------------------------*/ 1474 /* amendent career : */ 1475 /* Copyright (C) 1996 NTT DoCoMo */ 1476 /************************************************************************/ 1477 int SRP::Srp_1_3(PVMFSharedMediaDataPtr pPkt, int event) 1478 { 1479 PVMFSharedMediaDataPtr pSrpCommandPkt; 1480 SRPRespTimer *pTimer; 1481 uint32 i; 1482 uint32 seqNum = pPkt->getSeqNum(); 1483 bool isWaiting; 1484 1485 switch (event) 1486 { 1487 case EV_WNSRP_RESPONSE: 1488 // Remove packet from waiting list 1489 SrpCommandClear(seqNum); 1490 1491 for (isWaiting = false, i = 0; i < iActiveWnsrpCommandSave.size(); i++) 1492 { 1493 if (seqNum == iActiveWnsrpCommandSave[i]->pPkt->getSeqNum()) 1494 { 1495 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_1_3 - wnsrp timer found %d", i)); 1496 1497 // Resend previous WNSRP packets per section A.4.3 1498 for (uint32 k = 0; k < i; k++) 1499 { 1500 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_1_3 - lowerlayertx EV_WNSRP_RESPONSE wnsrp cmd seq num %d, index k %d", iActiveWnsrpCommandSave[k]->pPkt->getSeqNum(), k)); 1501 1502 // Send SRP command 1503 LowerLayerTx(iActiveWnsrpCommandSave[k]->pPkt); 1504 // Stop timer 1505 SrpT401Stop(*iActiveWnsrpCommandSave[k]); 1506 // Restart timer 1507 SrpT401Start(*iActiveWnsrpCommandSave[k], iActiveWnsrpCommandSave[k]->pPkt); 1508 // Count-up retry counter 1509 ++iActiveWnsrpCommandSave[k]->N400Counter; 1510 } 1511 1512 // Stop response wait timer 1513 SrpT401Stop(*iActiveWnsrpCommandSave[i]); 1514 1515 // Release packet 1516 iActiveWnsrpCommandSave[i]->pPkt.Unbind(); 1517 1518 // Remove timer from active list 1519 RemoveActiveWnsrpTimer(iActiveWnsrpCommandSave[i]); 1520 1521 isWaiting = true; 1522 break; 1523 } 1524 } 1525 1526 if (!isWaiting) 1527 { 1528 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_3 - WNSRP command with seq %d not waiting for response", seqNum)); 1529 return 0; 1530 } 1531 break; 1532 1533 case EV_NSRP_RESPONSE: 1534 // Remove packet from waiting list 1535 SrpCommandClear(seqNum); 1536 1537 //Stop any wnsrp timers with same seq number 1538 for (i = 0; i < iActiveWnsrpCommandSave.size(); i++) 1539 { 1540 if (seqNum == iActiveWnsrpCommandSave[i]->pPkt->getSeqNum()) 1541 { 1542 // Stop response wait timer 1543 SrpT401Stop(*iActiveWnsrpCommandSave[i]); 1544 1545 // Release packet 1546 iActiveWnsrpCommandSave[i]->pPkt.Unbind(); 1547 1548 // Remove timer from active list 1549 RemoveActiveWnsrpTimer(iActiveWnsrpCommandSave[i]); 1550 break; 1551 } 1552 } 1553 1554 if (iSrpCommandSave.isTimerActive) 1555 { 1556 if (seqNum == iSrpCommandSave.pPkt->getSeqNum()) 1557 { 1558 // Stop response wait timer 1559 SrpT401Stop(iSrpCommandSave); 1560 1561 // Release packet 1562 iSrpCommandSave.pPkt.Unbind(); 1563 } 1564 else 1565 { 1566 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_3 - NSRP command seq %d does not match NSRP resp seq %d", iSrpCommandSave.pPkt->getSeqNum(), seqNum)); 1567 return 0; 1568 } 1569 } 1570 else 1571 { 1572 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_3 - No command waiting for NSRP response")); 1573 return 0; 1574 } 1575 break; 1576 1577 case EV_RESPONSE: 1578 if (iSrpCommandSave.isTimerActive) 1579 { 1580 //Stop oldest wnsrp timer 1581 if (!iActiveWnsrpCommandSave.empty()) 1582 { 1583 // Stop response wait timer 1584 SrpT401Stop(*iActiveWnsrpCommandSave[0]); 1585 1586 // Release packet 1587 iActiveWnsrpCommandSave[0]->pPkt.Unbind(); 1588 1589 // Remove timer from active list 1590 RemoveActiveWnsrpTimer(iActiveWnsrpCommandSave[0]); 1591 } 1592 1593 // Remove packet from waiting list 1594 SrpCommandClear(iSrpCommandSave.pPkt->getSeqNum()); 1595 1596 // Stop response wait timer 1597 SrpT401Stop(iSrpCommandSave); 1598 1599 // Release packet 1600 iSrpCommandSave.pPkt.Unbind(); 1601 } 1602 else 1603 { 1604 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_3 - No command waiting for SRP response")); 1605 return 0; 1606 } 1607 break; 1608 1609 default: 1610 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::Srp_1_3 - Invalid response type %d", event)); 1611 return 0; 1612 } 1613 1614 switch (WnsrpStatusGet()) 1615 { 1616 case NO_WNSRP_SUPPORT: 1617 case WNSRP_TX_SUPPORT: 1618 // Waiting PDU exists? 1619 if (!iSrpWaitQueue.empty()) 1620 { 1621 // Create SRP command 1622 pSrpCommandPkt = SrpCommandCreate(SrpSendWaitGet(0), SRP_COMMAND_HEADER); 1623 1624 if (pSrpCommandPkt.GetRep() == NULL) 1625 { 1626 // Set status 1627 SrpStatusSet(STS_IDLE); 1628 return 0; 1629 } 1630 1631 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_1_3 - lowerlayertx srp cmd seq num %d", pSrpCommandPkt->getSeqNum())); 1632 1633 // Send SRP command 1634 LowerLayerTx(pSrpCommandPkt); 1635 // Start response wait timer 1636 SrpT401Start(iSrpCommandSave, pSrpCommandPkt); 1637 } 1638 1639 if (WnsrpStatusGet() == NO_WNSRP_SUPPORT) 1640 { 1641 break; 1642 } 1643 1644 //Fall through to next case 1645 1646 case WNSRP_FULL_SUPPORT: 1647 //Check if wnsrp timer is available 1648 if (iActiveWnsrpCommandSave.size() < iSrpWaitQueue.size()) 1649 { 1650 /* Create WNSRP command */ 1651 pSrpCommandPkt = SrpCommandCreate(SrpSendWaitGet(iActiveWnsrpCommandSave.size()), WNSRP_COMMAND_HEADER); 1652 1653 /* If packet could not be created. */ 1654 if (pSrpCommandPkt.GetRep() == NULL) 1655 { 1656 return(0); 1657 } 1658 1659 pTimer = GetFreeWnsrpTimer(); 1660 1661 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::Srp_1_3 - lowerlayertx WNSRP_FULL_SUPPORT wnsrp cmd seq num %d", pSrpCommandPkt->getSeqNum())); 1662 1663 /* Send SRP command */ 1664 LowerLayerTx(pSrpCommandPkt); 1665 /* Start response wait timer */ 1666 SrpT401Start(*pTimer, pSrpCommandPkt); 1667 1668 AddActiveWnsrpTimer(pTimer); 1669 } 1670 1671 1672 break; 1673 } 1674 1675 if (!iSrpCommandSave.isTimerActive && iActiveWnsrpCommandSave.empty()) 1676 { 1677 // Set status 1678 SrpStatusSet(STS_IDLE); 1679 } 1680 1681 /* Get total response time for frame. */ 1682 UpdateRespStats(); 1683 1684 return(1) ; 1685 } 1686 1687 /************************************************************************/ 1688 /* function name : Srp_1_4 */ 1689 /* function outline : Response wait timer timeout */ 1690 /* in WAITING-RESPONSE */ 1691 /* function discription: PVMFSharedMediaDataPtr Srp_1_4( */ 1692 /* PVMFSharedMediaDataPtr pPkt, */ 1693 /* int32 id ) */ 1694 /* input data : pPkt - pointer of timeout information */ 1695 /* id - id of timer that timed out */ 1696 /* output data : None */ 1697 /* draw time : '96.10.29 */ 1698 /*----------------------------------------------------------------------*/ 1699 /* amendent career : */ 1700 /* Copyright (C) 1996 NTT DoCoMo */ 1701 /************************************************************************/ 1702 int SRP::Srp_1_4(int32 id) 1703 { 1704 PVMFSharedMediaDataPtr pSrpCommandPkt; 1705 SRPRespTimer *timer; 1706 1707 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_4 - Response wait timer timeout")); 1708 1709 if (iSrpCommandSave.timerID == id) 1710 { 1711 timer = &iSrpCommandSave; 1712 } 1713 else if ((uint32) id < iWNSRPTxWindow) 1714 { 1715 timer = FindActiveWnsrpTimer(id); 1716 } 1717 else 1718 { 1719 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::Srp_1_4 - unknown SRP timer %d", id)); 1720 return 0; 1721 } 1722 1723 // Retry over ? 1724 if (SrpN400Check(*timer) == false) 1725 { 1726 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_4 - Max retry over")); 1727 1728 // Remove command from wait queue. 1729 SrpCommandClear(timer->pPkt->getSeqNum()); 1730 1731 // Stop timer 1732 SrpT401Stop(*timer); 1733 1734 //Release packet 1735 timer->pPkt.Unbind(); 1736 1737 // Take timer off WNSRP timer wait list (if it is a WNSRP timer) 1738 RemoveActiveWnsrpTimer(timer); 1739 1740 // If observer exists. 1741 1742 1743 if (iObserver) 1744 { 1745 /* Report transmission failure to TSC. 1746 TSC will stop SRP if necessary. */ 1747 iObserver->TransmissionFailure(); 1748 } 1749 1750 else 1751 { 1752 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::Srp_1_4 - No observer!")); 1753 1754 switch (WnsrpStatusGet()) 1755 { 1756 case NO_WNSRP_SUPPORT: 1757 // Set status 1758 SrpStatusSet(STS_IDLE); 1759 break; 1760 1761 case WNSRP_TX_SUPPORT: 1762 case WNSRP_FULL_SUPPORT: 1763 //If no more packets waiting to be sent. 1764 if (!iSrpWaitQueue.empty()) 1765 { 1766 // Set status 1767 SrpStatusSet(STS_IDLE); 1768 } 1769 break; 1770 } 1771 } 1772 } 1773 else 1774 { 1775 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_WARNING, (0x40000020, "SRP::Srp_1_4 - Create and send SRP command again, seq num %d", timer->pPkt->getSeqNum())); 1776 // Send SRP command 1777 LowerLayerTx(timer->pPkt); 1778 // Count-up retry counter 1779 ++timer->N400Counter; 1780 } 1781 1782 return 1; 1783 } 1784 1785 /************************************************************************/ 1786 /* function name : SrpSendWaitGet */ 1787 /* function outline : Get from queue for waiting transmittion */ 1788 /* function discription: PVMFSharedMediaDataPtr SrpSendWaitGet( */ 1789 /* uint32 index) */ 1790 /* input data : index - index of srp frags */ 1791 /* output data : data pointer of waiting transmittion */ 1792 /* draw time : '05.08.25 */ 1793 /*----------------------------------------------------------------------*/ 1794 /* amendent career : */ 1795 /* Copyright (C) 2005 PacketVideo Corp. */ 1796 /************************************************************************/ 1797 PVMFSharedMediaDataPtr SRP::SrpSendWaitGet(uint32 index) 1798 { 1799 if (index < iSrpWaitQueue.size()) 1800 { 1801 return iSrpWaitQueue[index]; 1802 } 1803 else 1804 { 1805 PVMFSharedMediaDataPtr temp; 1806 return temp; 1807 } 1808 } 1809 1810 /************************************************************************/ 1811 /* function name : SrpSendWaitRemove */ 1812 /* function outline : Remove from queue for waiting transmission */ 1813 /* function discription: PVMFSharedMediaDataPtr SrpSendWaitRemove( */ 1814 /* uint32 index) */ 1815 /* input data : index - index of srp frags */ 1816 /* output data : data pointer of waiting transmittion */ 1817 /* draw time : '05.08.25 */ 1818 /*----------------------------------------------------------------------*/ 1819 /* amendent career : */ 1820 /* Copyright (C) 2005 PacketVideo Corp. */ 1821 /************************************************************************/ 1822 int SRP::SrpSendWaitRemove(uint32 index) 1823 { 1824 if (index < iSrpWaitQueue.size()) 1825 { 1826 iSrpWaitQueue.erase(&iSrpWaitQueue[index]); 1827 return 1; 1828 } 1829 else 1830 { 1831 return 0; 1832 } 1833 } 1834 1835 /************************************************************************/ 1836 /* function name : SrpSendSeqCount */ 1837 /* function outline : Count up sequence number for sending */ 1838 /* function discription: void SrpSendSeqCount( void ) */ 1839 /* input data : None */ 1840 /* output data : None */ 1841 /* draw time : '96.10.29 */ 1842 /*----------------------------------------------------------------------*/ 1843 /* amendent career : */ 1844 /* Copyright (C) 1996 NTT DoCoMo */ 1845 /************************************************************************/ 1846 void SRP::SrpSendSeqCount() 1847 { 1848 if (iSendSeqNumber < 255) 1849 { 1850 ++ iSendSeqNumber; 1851 } 1852 else 1853 { 1854 iSendSeqNumber = 0; 1855 } 1856 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpSendSeqCount = %d", iSendSeqNumber)); 1857 return; 1858 } 1859 1860 1861 /************************************************************************/ 1862 /* function name : SrpRecvSeqCount */ 1863 /* function outline : Count up sequence number for receiving */ 1864 /* function discription: void SrpRecvSeqCount( void ) */ 1865 /* input data : None */ 1866 /* output data : None */ 1867 /* draw time : '96.10.29 */ 1868 /*----------------------------------------------------------------------*/ 1869 /* amendent career : */ 1870 /* Copyright (C) 1996 NTT DoCoMo */ 1871 /************************************************************************/ 1872 void SRP::SrpRecvSeqCount() 1873 { 1874 if (iRecvSeqNumber < 255) 1875 { 1876 ++iRecvSeqNumber; 1877 } 1878 else 1879 { 1880 iRecvSeqNumber = 0; 1881 } 1882 1883 if (iOldestWNSRPRetransSeqNum < 255) 1884 { 1885 ++iOldestWNSRPRetransSeqNum; 1886 } 1887 else 1888 { 1889 iOldestWNSRPRetransSeqNum = 0; 1890 } 1891 1892 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpRecvSeqCount = %d, oldest retrans = %d", iRecvSeqNumber, iOldestWNSRPRetransSeqNum)); 1893 return; 1894 } 1895 1896 1897 /************************************************************************/ 1898 /* function name : SrpStatusSet */ 1899 /* function outline : Status number set */ 1900 /* function discription: void SrpStatusSet( SrpStatus newStatus ) */ 1901 /* input data : newStatus - status number */ 1902 /* output data : None */ 1903 /* draw time : '96.10.29 */ 1904 /*----------------------------------------------------------------------*/ 1905 /* amendent career : */ 1906 /* Copyright (C) 1996 NTT DoCoMo */ 1907 /************************************************************************/ 1908 void SRP::SrpStatusSet(SrpStatus newStatus) 1909 { 1910 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::SrpStatusSet - SrpStatus from %d => %d", iStatus, newStatus)); 1911 iStatus = newStatus; 1912 return; 1913 } 1914 1915 /************************************************************************/ 1916 /* function name : WnsrpStatusSet */ 1917 /* function outline : WNSRP Status number set */ 1918 /* function discription: void WnsrpStatusSet( WnsrpStatus newStatus ) */ 1919 /* input data : newStatus - status number */ 1920 /* output data : None */ 1921 /* draw time : '05.08.23 */ 1922 /*----------------------------------------------------------------------*/ 1923 /* amendent career : */ 1924 /* Copyright (C) 2005 PacketVideo Corp. */ 1925 /************************************************************************/ 1926 void SRP::WnsrpStatusSet(WnsrpStatus newStatus) 1927 { 1928 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_VERBOSE, (0x40000020, "SRP::WnsrpStatusSet - WnsrpStatus from %d => %d", iCurWnsrpStatus, newStatus)); 1929 iCurWnsrpStatus = newStatus; 1930 1931 switch (iCurWnsrpStatus) 1932 { 1933 case NO_WNSRP_SUPPORT: 1934 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0x40000020, "SRP::WnsrpStatusSet - Remote does not support WNSRP!")); 1935 //Clear all WNSRP resp timers 1936 while (!iActiveWnsrpCommandSave.empty()) 1937 { 1938 // Stop response wait timer 1939 SrpT401Stop(*iActiveWnsrpCommandSave[0]); 1940 1941 // Release packet 1942 iActiveWnsrpCommandSave[0]->pPkt.Unbind(); 1943 1944 // Remove timer from active list 1945 RemoveActiveWnsrpTimer(iActiveWnsrpCommandSave[0]); 1946 } 1947 1948 if (iObserver) iObserver->UseWNSRP(false); 1949 break; 1950 1951 case WNSRP_FULL_SUPPORT: 1952 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0x40000020, "SRP::WnsrpStatusSet - Remote supports WNSRP!")); 1953 //Disable SRP tx 1954 if (iSrpCommandSave.isTimerActive) 1955 { 1956 // Stop response wait timer 1957 SrpT401Stop(iSrpCommandSave); 1958 1959 // Release packet 1960 iSrpCommandSave.pPkt.Unbind(); 1961 } 1962 1963 //Send all WNSRP frames using the default multiplex table entry number 0 1964 *(uint8 *)iWnsrpEntryNumFrag.getMemFragPtr() = SRP_NSRP_MT_ENTRY_NUMBER; 1965 1966 if (iObserver) iObserver->UseWNSRP(true); 1967 break; 1968 default: 1969 break; 1970 } 1971 return; 1972 } 1973 1974 /************************************************************************/ 1975 /* function name : SrpT401Start */ 1976 /* function outline : T401 timer start */ 1977 /* function discription: void SrpT401Start( SRPRespTimer &timer ) */ 1978 /* input data : timer - timer to start */ 1979 /* output data : None */ 1980 /* draw time : '05.08.24 */ 1981 /*----------------------------------------------------------------------*/ 1982 /* amendent career : */ 1983 /* Copyright (C) 2005 PacketVideo Corp. */ 1984 /************************************************************************/ 1985 void SRP::SrpT401Start(SRPRespTimer &timer, PVMFSharedMediaDataPtr pPkt) 1986 { 1987 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "SRP::SrpT401Start - id %d, IsPrimaryTimerActive = %d", timer.timerID, timer.isTimerActive)); 1988 1989 /* Start timer that is not active. */ 1990 if (!timer.isTimerActive) 1991 { 1992 timer.T401Timer.Request(timer.timerID, (int32)this, iT401TimerValue, this, true); 1993 timer.isTimerActive = true; 1994 } 1995 1996 timer.pPkt = pPkt; 1997 timer.N400Counter = 0; 1998 1999 return; 2000 } 2001 2002 /************************************************************************/ 2003 /* function name : SrpT401Stop */ 2004 /* function outline : T401 timer stop */ 2005 /* function discription: void SrpT401Stop( SRPRespTimer &timer ) */ 2006 /* input data : timer - timer to stop */ 2007 /* output data : None */ 2008 /* draw time : '05.08.24 */ 2009 /*----------------------------------------------------------------------*/ 2010 /* amendent career : */ 2011 /* Copyright (C) 2005 PacketVideo Corp. */ 2012 /************************************************************************/ 2013 void SRP::SrpT401Stop(SRPRespTimer &timer) 2014 { 2015 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::SrpT401Stop - id %d, IsPrimaryTimerActive = %d", timer.timerID, timer.isTimerActive)); 2016 2017 /* Reset active timer */ 2018 if (timer.isTimerActive) 2019 { 2020 timer.T401Timer.Cancel(timer.timerID); 2021 timer.isTimerActive = false; 2022 } 2023 2024 return; 2025 } 2026 2027 /************************************************************************/ 2028 /* function name : SrpT401Timeout */ 2029 /* function outline : T401 timeout */ 2030 /* function discription: int SrpT401Timeout(int TimerId, void *Param) */ 2031 /* input data : TimerId - timer id */ 2032 /* Param - timer parameter */ 2033 /* output data : 0 - Reset timer to fire again */ 2034 /* 1 - Do not reset timer */ 2035 /* draw time : '96.10.29 */ 2036 /*----------------------------------------------------------------------*/ 2037 /* amendent career : */ 2038 /* Copyright (C) 1996 NTT DoCoMo */ 2039 /************************************************************************/ 2040 // OsclTimerObserver virtual function 2041 void SRP::TimeoutOccurred(int32 timerID, int32 param) 2042 { 2043 OSCL_UNUSED_ARG(param); 2044 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::TimeoutOccurred, id %d, wnsrp status %d", timerID, iCurWnsrpStatus)); 2045 2046 iStats.totalNumTimeouts++; 2047 2048 /* Process call */ 2049 SrpStateChange(SrpStatusGet(), EV_TIMEOUT, (void *) &timerID); 2050 } 2051 2052 2053 /************************************************************************/ 2054 /* function name : LowerLayerRx */ 2055 /* function outline : Lower Layer Receive */ 2056 /* function description: void LowerLayerRx(MediaPacket* pPkt) */ 2057 /* input data : pPkt - pointer to incoming packet */ 2058 /* output data : None */ 2059 /* draw time : '96.10.29 */ 2060 /*----------------------------------------------------------------------*/ 2061 /* amendent career : */ 2062 /* Copyright (C) 1996 NTT DoCoMo */ 2063 /************************************************************************/ 2064 void SRP::LowerLayerRx(PVMFSharedMediaDataPtr pPkt) 2065 { 2066 int32 error; 2067 OsclSharedPtr<PVMFMediaDataImpl> data; 2068 OSCL_TRY(error, data = iRxPacketAlloc->allocate(MAX_SIZE_OF_SRP_PDU)); 2069 OSCL_FIRST_CATCH_ANY(error, PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::LowerLayerRx - Unable allocate rx message impl %d", error)); 2070 return); 2071 2072 OsclRefCounterMemFrag frag; 2073 data->getMediaFragment(0, frag); 2074 uint8* pos = (uint8*)frag.getMemFragPtr(); 2075 for (unsigned i = 0; i < pPkt->getNumFragments(); i++) 2076 { 2077 OsclRefCounterMemFrag src_frag; 2078 pPkt->getMediaFragment(i, src_frag); 2079 oscl_memcpy(pos, src_frag.getMemFragPtr(), src_frag.getMemFragSize()); 2080 pos += src_frag.getMemFragSize(); 2081 } 2082 data->setMediaFragFilledLen(0, pPkt->getFilledSize()); 2083 /* Record number of frames received from lower layer. */ 2084 iStats.totalFramesRecv++; 2085 2086 /* Record number of bytes received. */ 2087 iStats.totalBytesRecv += pPkt->getFilledSize(); 2088 2089 /* Process call */ 2090 PVMFSharedMediaDataPtr mediaData; 2091 OSCL_TRY(error, mediaData = PVMFMediaData::createMediaData(data, iRxMediaMsgPoolAlloc)); 2092 OSCL_FIRST_CATCH_ANY(error, PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::LowerLayerRx - Unable allocate rx message %d", error)); 2093 return); 2094 SrpStateChange(SrpStatusGet(), SrpGetEventNoFromAL1(mediaData), &mediaData); 2095 return; 2096 2097 } 2098 2099 /************************************************************************/ 2100 /* function name : UpperLayerRx */ 2101 /* function outline : Upper Layer Receive */ 2102 /* function description: void UpperLayerRx(MediaPacket* pPkt) */ 2103 /* input data : pPkt - pointer to incoming packet */ 2104 /* output data : None */ 2105 /* draw time : '96.10.29 */ 2106 /*----------------------------------------------------------------------*/ 2107 /* amendent career : */ 2108 /* Copyright (C) 1996 NTT DoCoMo */ 2109 /************************************************************************/ 2110 void SRP::UpperLayerRx(PVMFSharedMediaDataPtr pPkt) 2111 { 2112 uint32 offset; 2113 uint8 *buf; 2114 PVMFSharedMediaDataPtr srpPkt; 2115 OsclRefCounterMemFrag newFrag; 2116 OsclRefCounterMemFrag CCSRLFrag; 2117 OsclRefCounterMemFrag frag; 2118 OsclSharedPtr<PVMFMediaDataImpl> data; 2119 uint8 seqNum; 2120 uint32 size; 2121 2122 iStats.totalH245MessagesToSend++; 2123 2124 2125 // IMPORTANT: Assume upper layer is sending 1 fragment in a packet! 2126 if (pPkt->getNumFragments() != 1) 2127 { 2128 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::UpperLayerRx - Num frags of incoming message not equal to 1, %d", pPkt->getNumFragments())); 2129 return; 2130 } 2131 2132 pPkt->getMediaFragment(0, frag); 2133 2134 /* CCSRL */ 2135 if (iCcsrlSduSize > 0) 2136 { 2137 //--------------------------------------------------------- 2138 // Send the encoded message (pCodeData, GetSize) to SRP 2139 // using the multi-chunk feature of H.324. 2140 //--------------------------------------------------------- 2141 size = frag.getMemFragSize(); 2142 2143 // If queue cannot hold the number of fragments that will be needed. 2144 // If not enough messages available to send the entire message 2145 if (((size / iCcsrlSduSize) + 1) > iTxPacketAlloc->NumMsgAvail()) 2146 { 2147 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::UpperLayerRx - Unable allocate enough messages, current num %d", iTxPacketAlloc->NumMsgAvail())); 2148 return; 2149 } 2150 2151 if (size > iCcsrlSduSize) 2152 { 2153 iStats.totalH245MessagesFragmented++; 2154 } 2155 2156 buf = (uint8 *) frag.getMemFragPtr(); 2157 offset = 0; 2158 2159 while (offset < size) 2160 { 2161 if (!Allocate(data, CCSRLFrag)) 2162 return; 2163 newFrag = frag; 2164 newFrag.getMemFrag().ptr = (buf + offset); 2165 2166 /* Set sequence number */ 2167 seqNum = (uint8)SrpSendSeqGet(); 2168 SrpSendSeqCount(); 2169 *(uint8 *)CCSRLFrag.getMemFrag().ptr = seqNum; 2170 CCSRLFrag.getMemFrag().len = SRP_SEQUENCE_SIZE + CCSRL_HEADER_SIZE; 2171 2172 if ((offset + iCcsrlSduSize) >= size) 2173 { 2174 /* Last CCSRL chunk */ 2175 *((uint8 *)CCSRLFrag.getMemFrag().ptr + 1) = LAST_CCSRL_CHUNK; 2176 data->appendMediaFragment(CCSRLFrag); 2177 2178 newFrag.getMemFrag().len = size - offset; 2179 2180 offset += (size - offset); 2181 } 2182 else 2183 { 2184 /* Intermediate CCSRL chunk */ 2185 *((uint8 *)CCSRLFrag.getMemFrag().ptr + 1) = INTERMEDIATE_CCSRL_CHUNK; 2186 data->appendMediaFragment(CCSRLFrag); 2187 2188 newFrag.getMemFrag().len = iCcsrlSduSize; 2189 2190 offset += iCcsrlSduSize; 2191 } 2192 2193 data->appendMediaFragment(newFrag); 2194 if (!CreateMediaData(srpPkt, data)) 2195 return; 2196 srpPkt->setSeqNum(seqNum); 2197 2198 /* Queue received PDU */ 2199 SrpSendWaitSet(srpPkt); 2200 } 2201 } 2202 else 2203 { 2204 // If no message available to send the entire message 2205 if (iTxPacketAlloc->NumMsgAvail() == 0) 2206 { 2207 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::UpperLayerRx - no message available")); 2208 return; 2209 } 2210 if (!Allocate(data, CCSRLFrag)) 2211 return; 2212 2213 /* Set sequence number */ 2214 seqNum = (uint8) SrpSendSeqGet(); 2215 SrpSendSeqCount(); 2216 *(uint8 *)CCSRLFrag.getMemFrag().ptr = seqNum; 2217 CCSRLFrag.getMemFrag().len = SRP_SEQUENCE_SIZE; 2218 2219 data->appendMediaFragment(CCSRLFrag); 2220 2221 data->appendMediaFragment(frag); 2222 2223 if (!CreateMediaData(srpPkt, data)) 2224 return; 2225 2226 //--------------------------------------------------------- 2227 // Send the encoded message (pCodeData, GetSize) to SRP 2228 // without using the H.324 multi-chunk method. 2229 //--------------------------------------------------------- 2230 2231 srpPkt->setSeqNum(seqNum); 2232 2233 /* Queue received PDU */ 2234 SrpSendWaitSet(srpPkt); 2235 } 2236 2237 /* Process call */ 2238 SrpStateChange(SrpStatusGet(), EV_PDU, NULL); 2239 2240 return; 2241 } 2242 2243 bool SRP::Allocate(OsclSharedPtr<PVMFMediaDataImpl>& data, OsclRefCounterMemFrag& CCSRLFrag) 2244 { 2245 data = iTxPacketAlloc->allocate(); 2246 2247 if (!data) 2248 { 2249 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, 2250 (0x40000020, "SRP::UpperLayerRx - Unable allocate tx media impl")); 2251 return false; 2252 } 2253 2254 CCSRLFrag = iCcsrlAllocator.get(); 2255 2256 return (CCSRLFrag.getMemFragPtr() ? true : false); 2257 } 2258 2259 /************************************************************************/ 2260 /* function name : UseNSRP */ 2261 /* function outline : Set use of NSRP response frames or not. */ 2262 /* function description: void UseNSRP( bool aUseNsrp ) */ 2263 /* input data : None */ 2264 /* output data : None */ 2265 /* draw time : '05.08.23 */ 2266 /*----------------------------------------------------------------------*/ 2267 /* amendent career : */ 2268 /* Copyright (C) 2005 PacketVideo Corp. */ 2269 /************************************************************************/ 2270 void SRP::UseNSRP(bool aUseNsrp) 2271 { 2272 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0x40000020, "SRP::UseNSRP - cur %d, new %d", iUseNSRP, aUseNsrp)); 2273 if (aUseNsrp == iUseNSRP) 2274 { 2275 return; 2276 } 2277 iUseNSRP = aUseNsrp; 2278 iFirstNSRPResp = false; 2279 return; 2280 } 2281 2282 /************************************************************************/ 2283 /* function name : DisableWNSRPSupport */ 2284 /* function outline : Disables all support for WNSRP. Must be */ 2285 /* called before initailization. */ 2286 /* function description: void DisableWNSRPSupport() */ 2287 /* input data : None */ 2288 /* output data : None */ 2289 /* draw time : '05.08.23 */ 2290 /*----------------------------------------------------------------------*/ 2291 /* amendent career : */ 2292 /* Copyright (C) 2005 PacketVideo Corp. */ 2293 /************************************************************************/ 2294 void SRP::DisableWNSRPSupport() 2295 { 2296 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::DisableWNSRPSupport")); 2297 2298 if (WnsrpStatusGet() == WNSRP_TX_SUPPORT) 2299 { 2300 WnsrpStatusSet(NO_WNSRP_SUPPORT); 2301 } 2302 2303 iHandleWNSRP = false; 2304 return; 2305 } 2306 2307 /************************************************************************/ 2308 /* function name : SrpResetStats */ 2309 /* function outline : Reset statistics */ 2310 /* function description: void SrpResetStats( void ) */ 2311 /* input data : None */ 2312 /* output data : None */ 2313 /* draw time : '96.10.29 */ 2314 /*----------------------------------------------------------------------*/ 2315 /* amendent career : */ 2316 /* Copyright (C) 1996 NTT DoCoMo */ 2317 /************************************************************************/ 2318 void SRP::SrpResetStats() 2319 { 2320 iStats.Reset(); 2321 iTotalRespTime = 0; 2322 } 2323 2324 /************************************************************************/ 2325 /* function name : SrpGetStats */ 2326 /* function outline : Retrieve statistics */ 2327 /* function description: void SrpGetStats(SRPStats &aStats) */ 2328 /* input data : aStats - iStats object to fill */ 2329 /* output data : None */ 2330 /* draw time : '96.10.29 */ 2331 /*----------------------------------------------------------------------*/ 2332 /* amendent career : */ 2333 /* Copyright (C) 1996 NTT DoCoMo */ 2334 /************************************************************************/ 2335 void SRP::SrpGetStats(SRPStats &aStats) 2336 { 2337 if (iStats.totalCCSRLChunksSent > 0) 2338 { 2339 iStats.aveRespTime = iTotalRespTime / iStats.totalCCSRLChunksSent; 2340 } 2341 else 2342 { 2343 iStats.aveRespTime = 0; 2344 } 2345 2346 aStats = iStats; 2347 } 2348 2349 /************************************************************************/ 2350 /* function name : UpdateRespStats */ 2351 /* function outline : Update response statistics */ 2352 /* function description: void UpdateRespStats() */ 2353 /* input data : None */ 2354 /* output data : None */ 2355 /* draw time : '96.10.29 */ 2356 /*----------------------------------------------------------------------*/ 2357 /* amendent career : */ 2358 /* Copyright (C) 1996 NTT DoCoMo */ 2359 /************************************************************************/ 2360 void SRP::UpdateRespStats() 2361 { 2362 TimeValue timeNow; 2363 uint32 timeDifference; 2364 2365 timeNow.set_to_current_time(); 2366 2367 timeDifference = timeNow.to_msec() - iInitialTimeChunkSent.to_msec(); 2368 2369 if (timeDifference > iStats.maxRespTime) 2370 { 2371 iStats.maxRespTime = timeDifference; 2372 } 2373 else if (timeDifference < iStats.minRespTime) 2374 { 2375 iStats.minRespTime = timeDifference; 2376 } 2377 2378 iTotalRespTime += timeDifference; 2379 } 2380 2381 /************************************************************************/ 2382 /* function name : GetFreeWnsrpTimer */ 2383 /* function outline : Get free WNSRP response timer */ 2384 /* function description: SRPRespTimer *GetFreeWnsrpTimer() */ 2385 /* input data : None */ 2386 /* output data : None */ 2387 /* draw time : '05.08.26 */ 2388 /*----------------------------------------------------------------------*/ 2389 /* amendent career : */ 2390 /* Copyright (C) 2005 PacketVideo Corp. */ 2391 /************************************************************************/ 2392 SRP::SRPRespTimer *SRP::GetFreeWnsrpTimer() 2393 { 2394 SRPRespTimer *timer = NULL; 2395 if (!iFreeWnsrpCommandSave.empty()) 2396 { 2397 timer = iFreeWnsrpCommandSave[0]; 2398 iFreeWnsrpCommandSave.erase(iFreeWnsrpCommandSave.begin()); 2399 } 2400 2401 return timer; 2402 } 2403 2404 /************************************************************************/ 2405 /* function name : FindActiveWnsrpTimer */ 2406 /* function outline : Get free WNSRP response timer */ 2407 /* function description: SRPRespTimer *FindActiveWnsrpTimer( */ 2408 /* int32 timerID) */ 2409 /* input data : timerID - id of timer */ 2410 /* output data : None */ 2411 /* draw time : '05.08.26 */ 2412 /*----------------------------------------------------------------------*/ 2413 /* amendent career : */ 2414 /* Copyright (C) 2005 PacketVideo Corp. */ 2415 /************************************************************************/ 2416 SRP::SRPRespTimer *SRP::FindActiveWnsrpTimer(int32 timerID) 2417 { 2418 for (uint32 i = 0; i < iActiveWnsrpCommandSave.size(); i++) 2419 { 2420 if (iActiveWnsrpCommandSave[i]->timerID == timerID) 2421 { 2422 return iActiveWnsrpCommandSave[i]; 2423 } 2424 } 2425 2426 return NULL; 2427 } 2428 2429 /************************************************************************/ 2430 /* function name : RemoveActiveWnsrpTimer */ 2431 /* function outline : Remove an timer from the active WNSRP timer */ 2432 /* list */ 2433 /* function description: void RemoveActiveWnsrpTimer( */ 2434 /* SRPRespTimer *timer) */ 2435 /* input data : timer - timer to remove */ 2436 /* output data : None */ 2437 /* draw time : '05.08.26 */ 2438 /*----------------------------------------------------------------------*/ 2439 /* amendent career : */ 2440 /* Copyright (C) 2005 PacketVideo Corp. */ 2441 /************************************************************************/ 2442 void SRP::RemoveActiveWnsrpTimer(SRPRespTimer *timer) 2443 { 2444 //Timer should be stopped before this method is called. 2445 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::RemoveActiveWnsrpTimer id %d", timer->timerID)); 2446 2447 for (uint32 i = 0; i < iActiveWnsrpCommandSave.size(); i++) 2448 { 2449 if (iActiveWnsrpCommandSave[i] == timer) 2450 { 2451 FreeWnsrpTimer(iActiveWnsrpCommandSave[i]); 2452 iActiveWnsrpCommandSave.erase(&iActiveWnsrpCommandSave[i]); 2453 2454 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::RemoveActiveWnsrpTimer timer removed index %d", i)); 2455 return; 2456 } 2457 } 2458 2459 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::RemoveActiveWnsrpTimer timer not found")); 2460 return; 2461 } 2462 2463 2464 /************************************************************************/ 2465 /* function name : FreeRxFrag */ 2466 /* function outline : Free a frag to the free list */ 2467 /* function description: void FreeRxFrag(SRPRxData *frag) */ 2468 /* input data : timer - timer to remove */ 2469 /* output data : None */ 2470 /* draw time : '05.08.26 */ 2471 /*----------------------------------------------------------------------*/ 2472 /* amendent career : */ 2473 /* Copyright (C) 2005 PacketVideo Corp. */ 2474 /************************************************************************/ 2475 void SRP::FreeRxFrag(SRPRxData *frag) 2476 { 2477 frag->seqNum = 0; 2478 frag->data.Unbind(); 2479 2480 frag->next = iFreeRxFragList; 2481 iFreeRxFragList = frag; 2482 2483 return; 2484 } 2485 2486 /************************************************************************/ 2487 /* function name : GetRxFrag */ 2488 /* function outline : Remove an frag from the free list */ 2489 /* function description: SRPRxData *GetRxFrag() */ 2490 /* input data : timer - timer to remove */ 2491 /* output data : None */ 2492 /* draw time : '05.08.26 */ 2493 /*----------------------------------------------------------------------*/ 2494 /* amendent career : */ 2495 /* Copyright (C) 2005 PacketVideo Corp. */ 2496 /************************************************************************/ 2497 SRP::SRPRxData *SRP::GetRxFrag(void) 2498 { 2499 SRPRxData *free; 2500 if (iFreeRxFragList) 2501 { 2502 free = iFreeRxFragList; 2503 iFreeRxFragList = iFreeRxFragList->next; 2504 return free; 2505 } 2506 else 2507 { 2508 return NULL; 2509 } 2510 } 2511 2512 /************************************************************************/ 2513 /* function name : AddPendingRxFrag */ 2514 /* function outline : Add a rx frag to the pending list in order of */ 2515 /* rx sequence number mod 256. */ 2516 /* function description: void AddPendingRxFrag(SRPRxData *frag) */ 2517 /* input data : timer - timer to remove */ 2518 /* output data : None */ 2519 /* draw time : '05.08.26 */ 2520 /*----------------------------------------------------------------------*/ 2521 /* amendent career : */ 2522 /* Copyright (C) 2005 PacketVideo Corp. */ 2523 /************************************************************************/ 2524 void SRP::AddPendingRxFrag(SRPRxData *frag) 2525 { 2526 SRPRxData *cur = iPendingRxFragList; 2527 SRPRxData *prev = NULL; 2528 2529 while (cur) 2530 { 2531 if (cur->seqNum > frag->seqNum) 2532 { 2533 if (prev) 2534 { 2535 prev->next = frag; 2536 frag->next = cur; 2537 } 2538 else 2539 { 2540 frag->next = iPendingRxFragList; 2541 iPendingRxFragList = frag; 2542 } 2543 return; 2544 } 2545 2546 prev = cur; 2547 cur = cur->next; 2548 } 2549 2550 frag->next = NULL; 2551 if (prev) 2552 { 2553 prev->next = frag; 2554 } 2555 else 2556 { 2557 iPendingRxFragList = frag; 2558 } 2559 return; 2560 } 2561 2562 /************************************************************************/ 2563 /* function name : CheckRxSeqNum */ 2564 /* function outline : Check Rx sequence number for against the */ 2565 /* pending rx frags. */ 2566 /* function description: bool CheckRxSeqNum(uint32 seqNum, */ 2567 /* uint8 header) */ 2568 /* input data : timer - timer to remove */ 2569 /* output data : None */ 2570 /* draw time : '05.08.26 */ 2571 /*----------------------------------------------------------------------*/ 2572 /* amendent career : */ 2573 /* Copyright (C) 2005 PacketVideo Corp. */ 2574 /************************************************************************/ 2575 bool SRP::CheckRxSeqNum(uint32 seqNum, uint8 header) 2576 { 2577 PVMFSharedMediaDataPtr resp; 2578 uint32 endSeqNum; 2579 2580 //If WNSRP command 2581 switch (header) 2582 { 2583 case WNSRP_RESPONSE_HEADER: 2584 //Check if data is already pending to be sent up 2585 if (CheckPendingRxList(seqNum)) 2586 { 2587 /* Create WNSRP response */ 2588 resp = SrpResponseCreate((uint8) seqNum, header); 2589 if (resp.GetRep() == NULL) 2590 { 2591 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::CheckRxSeqNum - Unable create WNSRP reponse packet")); 2592 /* If unable to create response message. */ 2593 return false; 2594 } 2595 2596 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::CheckRxSeqNum - lowerlayertx wnsrp resp seq num %d", resp->getSeqNum())); 2597 2598 /* SRP response send */ 2599 LowerLayerTx(resp); 2600 return false; 2601 } 2602 2603 endSeqNum = (SrpRecvSeqGet() + iWNSRPRxWindow) % 256; 2604 //If rx window does not wrap 2605 if (endSeqNum > SrpRecvSeqGet()) 2606 { 2607 //If can't accept sequence number because of rx window 2608 if ((seqNum < SrpRecvSeqGet()) || 2609 (seqNum > endSeqNum)) 2610 { 2611 if (CheckWNSRPRetrans(seqNum)) 2612 { 2613 /* Create WNSRP response */ 2614 resp = SrpResponseCreate((uint8) seqNum, header); 2615 if (resp.GetRep() == NULL) 2616 { 2617 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::CheckRxSeqNum - Unable create WNSRP reponse packet")); 2618 /* If unable to create response message. */ 2619 return false; 2620 } 2621 2622 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::CheckRxSeqNum - lowerlayertx wnsrp resp seq num %d", resp->getSeqNum())); 2623 2624 /* SRP response send */ 2625 LowerLayerTx(resp); 2626 } 2627 return false; 2628 } 2629 2630 //Else can accept sequence number 2631 } 2632 //Else window wraps around 2633 else 2634 { 2635 //If can accept sequence number 2636 if ((seqNum >= SrpRecvSeqGet()) || 2637 (seqNum <= endSeqNum)) 2638 { 2639 return true; 2640 } 2641 //Else can't accept sequence number 2642 else 2643 { 2644 if (CheckWNSRPRetrans(seqNum)) 2645 { 2646 /* Create WNSRP response */ 2647 resp = SrpResponseCreate((uint8) seqNum, header); 2648 if (resp.GetRep() == NULL) 2649 { 2650 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::CheckRxSeqNum - Unable create WNSRP reponse packet")); 2651 /* If unable to create response message. */ 2652 return false; 2653 } 2654 2655 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::CheckRxSeqNum - lowerlayertx wnsrp resp seq num %d", resp->getSeqNum())); 2656 2657 /* SRP response send */ 2658 LowerLayerTx(resp); 2659 } 2660 return false; 2661 } 2662 } 2663 return true; 2664 2665 case NSRP_RESPONSE_HEADER: 2666 case SRP_RESPONSE_HEADER: 2667 if (seqNum != SrpRecvSeqGet()) 2668 { 2669 if (((seqNum + 1) % 256) == SrpRecvSeqGet()) 2670 { 2671 /* Create SRP response */ 2672 resp = SrpResponseCreate((uint8) seqNum, header); 2673 if (resp.GetRep() == NULL) 2674 { 2675 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0x40000020, "SRP::CheckRxSeqNum - Unable create SRP reponse packet")); 2676 /* If unable to create response message. */ 2677 return false; 2678 } 2679 2680 PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0x40000020, "SRP::CheckRxSeqNum - lowerlayertx srp resp seq num %d", resp->getSeqNum())); 2681 2682 /* SRP response send */ 2683 LowerLayerTx(resp); 2684 } 2685 return false; 2686 } 2687 return true; 2688 2689 default: 2690 return false; 2691 } 2692 } 2693 2694 /************************************************************************/ 2695 /* function name : CheckPendingRxList */ 2696 /* function outline : Check pending rx list against sequence number */ 2697 /* function description: bool CheckRxSeqNum(uint32 seqNum) */ 2698 /* input data : seqNum - sequence number to check */ 2699 /* output data : None */ 2700 /* draw time : '05.08.26 */ 2701 /*----------------------------------------------------------------------*/ 2702 /* amendent career : */ 2703 /* Copyright (C) 2005 PacketVideo Corp. */ 2704 /************************************************************************/ 2705 bool SRP::CheckPendingRxList(uint32 seqNum) 2706 { 2707 SRPRxData *data = iPendingRxFragList; 2708 while (data) 2709 { 2710 if (data->seqNum == seqNum) 2711 { 2712 return true; 2713 } 2714 data = data->next; 2715 } 2716 return false; 2717 } 2718 2719 /************************************************************************/ 2720 /* function name : CheckWNSRPRetrans */ 2721 /* function outline : Check Rx sequence number for WNSRP retrans */ 2722 /* window. */ 2723 /* function description: bool CheckWNSRPRetrans(uint32 seqNum) */ 2724 /* input data : timer - timer to remove */ 2725 /* output data : None */ 2726 /* draw time : '05.08.26 */ 2727 /*----------------------------------------------------------------------*/ 2728 /* amendent career : */ 2729 /* Copyright (C) 2005 PacketVideo Corp. */ 2730 /************************************************************************/ 2731 bool SRP::CheckWNSRPRetrans(uint32 seqNum) 2732 { 2733 //Retrans window does not wrap 2734 if (iOldestWNSRPRetransSeqNum < SrpRecvSeqGet()) 2735 { 2736 if ((seqNum < SrpRecvSeqGet()) && 2737 (seqNum > iOldestWNSRPRetransSeqNum)) 2738 { 2739 return true; 2740 } 2741 } 2742 //Retrans window wraps 2743 else if ((seqNum < SrpRecvSeqGet()) || 2744 (seqNum > iOldestWNSRPRetransSeqNum)) 2745 { 2746 return true; 2747 } 2748 2749 return false; 2750 } 2751 2752 2753 2754
