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 #ifndef SRP_H 20 #define SRP_H 21 22 #ifndef OSCL_BASE_H_INCLUDED 23 #include "oscl_base.h" 24 #endif 25 26 #ifndef OSCL_TIMER_H_INCLUDED 27 #include "oscl_timer.h" 28 #endif 29 30 #ifndef OSCL_VECTOR_H_INCLUDED 31 #include "oscl_vector.h" 32 #endif 33 34 #ifndef OSCL_MEM_H_INCLUDED 35 #include "oscl_mem.h" 36 #endif 37 38 #ifndef OSCL_MEM_MEMPOOL_H_INCLUDED 39 #include "oscl_mem_mempool.h" 40 #endif 41 42 #ifndef PVMF_PORT_INTERFACE_H_INCLUDED 43 #include "pvmf_port_interface.h" 44 #endif 45 46 #ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED 47 #include "pvmf_media_frag_group.h" 48 #endif 49 50 #ifndef PVMF_POOL_BUFFER_ALLOCATOR_H_INCLUDED 51 #include "pvmf_pool_buffer_allocator.h" 52 #endif 53 54 #ifndef PVLOGGER_H_INCLUDED 55 #include "pvlogger.h" 56 #endif 57 58 #include "crccheck_cpp.h" 59 60 61 /* SRP frame information */ 62 #define SRP_HEADER_SIZE 1 63 #define SRP_SEQUENCE_SIZE 1 64 #define SRP_FCS_SIZE 2 65 #define CCSRL_HEADER_SIZE 1 66 #define SRP_COMMAND_HEADER 0xF9 67 #define SRP_RESPONSE_HEADER 0xFB 68 #define NSRP_RESPONSE_HEADER 0xF7 69 #define MINIMUM_FRAME_SIZE SRP_HEADER_SIZE+SRP_FCS_SIZE 70 #define DEFAULT_CCSRL_SIZE 256 71 #define INTERMEDIATE_CCSRL_CHUNK 0x00 72 #define LAST_CCSRL_CHUNK 0xFF 73 #define DEFAULT_SEND_QUEUE_SIZE 24 74 #define MAX_SEND_FRAGS_PER_MSG 4 //Header + CCSRL + data + FCS frags 75 #define MAX_RESP_MSGS 24 76 77 /* CRC definition */ 78 #define GX_CRC_12 0x1021 /* CRC Generate matrix ( G(X) = X^16 + X^12 + X^5 + 1�j */ 79 80 81 /* Fragment pool definition */ 82 #define MAX_SIZE_OF_SRP_HEADER (SRP_HEADER_SIZE+SRP_SEQUENCE_SIZE+SRP_FCS_SIZE) 83 #define MAX_SIZE_OF_SRP_PDU 1024 /* Thie is the AL1 SDU size */ 84 85 /* WNSRP definitions */ 86 #define WNSRP_COMMAND_HEADER 0xF1 87 #define WNSRP_RESPONSE_HEADER 0xF3 88 #define DEFAULT_WNSRP_WINDOW 5 89 #define N402_DEFAULT_MAX_COUNTER 3 /* Number of SRP/NSRP frames to accept before dropping out of WNSRP mode */ 90 91 /* Timer definition */ 92 #define N400_DEFAULT_MAX_COUNTER 100 93 #define T401_PRIMARY WNSRP_WINDOW /* Primary SRP timer id, set it to the WNSRP window, id for the WNSRP timers will be the array index */ 94 #define T401_RESOLUTION 10 // Set SRP timeout to 100ms 95 #define T401_VALUE_DEFAULT 2 // Sets the default T401 timeout to 200ms 96 97 /* Multiplex table entry definitions */ 98 #define SRP_NSRP_MT_ENTRY_NUMBER 0 99 #define WNSRP_MT_ENTRY_NUMBER 15 100 #define NUM_MT_ENTRY_NUMBERS 2 //Number of possible MT entry numbers SRP can send on (SRP/NSRP = 0, WNSRP = 15) 101 #define MT_ENTRY_NUMBER_SIZE sizeof(uint8) 102 103 /* TBD */ 104 #define SRP_INPUT_PORT_TAG 0 105 #define SRP_OUTPUT_PORT_TAG 1 106 107 class SRPStats 108 { 109 public: SRPStats()110 SRPStats() : totalFramesRecv(0), 111 totalInvalidSizeFramesRecv(0), 112 totalCRCErrorsRecv(0), 113 totalCommandFramesRecv(0), 114 totalWNSRPCommandFramesRecv(0), 115 totalInvalidCCSRLChunkRecv(0), 116 totalSRPRespRecv(0), 117 totalNSRPRespRecv(0), 118 totalWNSRPRespRecv(0), 119 totalH245MessagesRecv(0), 120 totalCCSRLChunksRecv(0), 121 totalCommandFramesSent(0), 122 totalH245MessagesToSend(0), 123 totalH245MessagesFragmented(0), 124 totalCCSRLChunksSent(0), 125 totalNumTimeouts(0), 126 totalBytesRecv(0), 127 totalBytesSent(0), 128 totalInvalidFrames(0), 129 minRespTime(0xFFFFFFFF), 130 maxRespTime(0), 131 aveRespTime(0) {}; 132 ~SRPStats()133 ~SRPStats() {}; 134 Reset()135 void Reset() 136 { 137 totalFramesRecv = 0; 138 totalInvalidSizeFramesRecv = 0; 139 totalCRCErrorsRecv = 0; 140 totalCommandFramesRecv = 0; 141 totalWNSRPCommandFramesRecv = 0; 142 totalInvalidCCSRLChunkRecv = 0; 143 totalSRPRespRecv = 0; 144 totalNSRPRespRecv = 0; 145 totalWNSRPRespRecv = 0; 146 totalH245MessagesRecv = 0; 147 totalCCSRLChunksRecv = 0; 148 totalCommandFramesSent = 0; 149 totalH245MessagesToSend = 0; 150 totalH245MessagesFragmented = 0; 151 totalCCSRLChunksSent = 0; 152 totalNumTimeouts = 0; 153 totalBytesRecv = 0; 154 totalBytesSent = 0; 155 totalInvalidFrames = 0; 156 minRespTime = 0xFFFFFFFF; 157 maxRespTime = 0; 158 aveRespTime = 0; 159 } 160 161 SRPStats &operator=(SRPStats &a) 162 { 163 totalFramesRecv = a.totalFramesRecv; 164 totalInvalidSizeFramesRecv = a.totalInvalidSizeFramesRecv; 165 totalCRCErrorsRecv = a.totalCRCErrorsRecv; 166 totalCommandFramesRecv = a.totalCommandFramesRecv; 167 totalWNSRPCommandFramesRecv = a.totalWNSRPCommandFramesRecv; 168 totalInvalidCCSRLChunkRecv = a.totalInvalidCCSRLChunkRecv; 169 totalSRPRespRecv = a.totalSRPRespRecv; 170 totalNSRPRespRecv = a.totalNSRPRespRecv; 171 totalWNSRPRespRecv = a.totalWNSRPRespRecv; 172 totalH245MessagesRecv = a.totalH245MessagesRecv; 173 totalCCSRLChunksRecv = a.totalCCSRLChunksRecv; 174 totalCommandFramesSent = a.totalCommandFramesSent; 175 totalH245MessagesToSend = a.totalH245MessagesToSend; 176 totalH245MessagesFragmented = a.totalH245MessagesFragmented; 177 totalCCSRLChunksSent = a.totalCCSRLChunksSent; 178 totalNumTimeouts = a.totalNumTimeouts; 179 totalBytesRecv = a.totalBytesRecv; 180 totalBytesSent = a.totalBytesSent; 181 totalInvalidFrames = a.totalInvalidFrames; 182 minRespTime = a.minRespTime; 183 maxRespTime = a.maxRespTime; 184 aveRespTime = a.aveRespTime; 185 return *this; 186 } 187 188 uint32 totalFramesRecv; 189 uint32 totalInvalidSizeFramesRecv; 190 uint32 totalCRCErrorsRecv; 191 uint32 totalCommandFramesRecv; 192 uint32 totalWNSRPCommandFramesRecv; 193 uint32 totalInvalidCCSRLChunkRecv; 194 uint32 totalSRPRespRecv; 195 uint32 totalNSRPRespRecv; 196 uint32 totalWNSRPRespRecv; 197 uint32 totalH245MessagesRecv; 198 uint32 totalCCSRLChunksRecv; 199 uint32 totalCommandFramesSent; 200 uint32 totalH245MessagesToSend; 201 uint32 totalH245MessagesFragmented; 202 uint32 totalCCSRLChunksSent; 203 uint32 totalNumTimeouts; 204 uint32 totalBytesRecv; 205 uint32 totalBytesSent; 206 uint32 totalInvalidFrames; 207 uint32 minRespTime; 208 uint32 maxRespTime; 209 uint32 aveRespTime; 210 }; 211 212 213 class SRPObserver 214 { 215 public: ~SRPObserver()216 virtual ~SRPObserver() {} 217 virtual void TransmissionFailure() = 0; 218 virtual void UseWNSRP(bool aUse) = 0; 219 }; 220 221 typedef OsclSharedPtr<PVMFMediaDataImpl> PVMFSharedMediaDataImplPtr; 222 223 class SRP : public OsclTimerObserver 224 { 225 public: 226 /* structures used by SRP class */ 227 228 enum SrpStatus {STS_IDLE = 0, STS_WAIT_RESPONSE, MAX_STATUS}; 229 enum SrpEvent {EV_NOP = 0, /* Unknown Event */ 230 EV_PDU, /* PDU message */ 231 EV_COMMAND, /* PRIMITIVE(DATA-COMMAND) */ 232 EV_RESPONSE, /* PRIMITIVE(DATA-RESPONSE) */ 233 EV_NSRP_RESPONSE, /* PRIMITIVE NSRP(DATA-RESPONSE) */ 234 EV_TIMEOUT, /* Response wait timeout */ 235 EV_WNSRP_COMMAND, /* WNSRP(DATA-COMMAND) */ 236 EV_WNSRP_RESPONSE, /* WNSRP(DATA-RESPONSE) */ 237 MAX_EVENT 238 }; 239 enum SrpAction {ACTION_NOP = 0, ACTION_0_1, ACTION_0_2, ACTION_1_1, ACTION_1_3, ACTION_1_4}; 240 241 enum WnsrpStatus {NO_WNSRP_SUPPORT, WNSRP_TX_SUPPORT, WNSRP_FULL_SUPPORT}; 242 243 244 245 /* methods */ 246 OSCL_IMPORT_REF SRP() ; 247 OSCL_IMPORT_REF virtual ~SRP() ; 248 SetObserver(SRPObserver * pObserver)249 OSCL_IMPORT_REF void SetObserver(SRPObserver *pObserver) 250 { 251 iObserver = pObserver; 252 } 253 254 /* srp_main.cpp */ 255 OSCL_IMPORT_REF void SrpInitL(void); /* Initialization method */ 256 OSCL_IMPORT_REF void SrpReset(void); /* Shutdown method */ 257 258 OSCL_IMPORT_REF void SrpStart(void); /* Restart SRP operations after stop. */ 259 OSCL_IMPORT_REF void SrpStop(void); /* Halt SRP operations, stop timers, flush queue, do not shutdown. */ 260 261 /* srp_tim.cpp */ 262 void TimeoutOccurred(int32 timerID, int32 timeoutInfo); 263 264 void LowerLayerRx(PVMFSharedMediaDataPtr aData); 265 void UpperLayerRx(PVMFSharedMediaDataPtr aData); 266 SetWNSRPTxWindow(uint32 window)267 void SetWNSRPTxWindow(uint32 window) 268 { 269 iWNSRPTxWindow = window; 270 } SetWNSRPRxWindow(uint32 window)271 void SetWNSRPRxWindow(uint32 window) 272 { 273 iWNSRPRxWindow = window; 274 } SetCCSRLSduSize(int size)275 void SetCCSRLSduSize(int size) 276 { 277 iCcsrlSduSize = size; 278 } 279 280 void UseNSRP(bool aUseNsrp = true); 281 void DisableWNSRPSupport(); 282 SetNumTxMsgs(uint32 numMsgs)283 void SetNumTxMsgs(uint32 numMsgs) 284 { 285 iNumTxMsgs = numMsgs; 286 } 287 288 void SrpResetStats(); 289 void SrpGetStats(SRPStats &aStats); 290 291 //Number or times to retry sending SRP command before notifying upper layer of failure. SetNumSRPRetries(int maxRetries)292 void SetNumSRPRetries(int maxRetries) 293 { 294 iN400MaxCounter = maxRetries; 295 } 296 //Actual timeout is (resolution * value). SetSRPTimeoutValue(int value)297 void SetSRPTimeoutValue(int value) 298 { 299 iT401TimerValue = value; 300 } 301 302 303 RequestLLPort(const int32 aPortTag)304 PVMFPortInterface * RequestLLPort(const int32 aPortTag) 305 { 306 if (aPortTag == SRP_INPUT_PORT_TAG) 307 { 308 return iLLPortIn; 309 } 310 if (aPortTag == SRP_OUTPUT_PORT_TAG) 311 { 312 return iLLPortOut; 313 } 314 315 return NULL; 316 } 317 RequestULPort(const int32 aPortTag)318 PVMFPortInterface * RequestULPort(const int32 aPortTag) 319 { 320 if (aPortTag == SRP_INPUT_PORT_TAG) 321 { 322 return iULPortIn; 323 } 324 if (aPortTag == SRP_OUTPUT_PORT_TAG) 325 { 326 return iULPortOut; 327 } 328 329 return NULL; 330 } 331 WnsrpStatusGet(void)332 WnsrpStatus WnsrpStatusGet(void) 333 { 334 return(iCurWnsrpStatus); 335 } 336 private: 337 338 class SRPRxData 339 { 340 public: SRPRxData()341 SRPRxData() : seqNum(0), 342 next(NULL) 343 {}; 344 345 uint8 seqNum; 346 PVMFSharedMediaDataPtr data; 347 SRPRxData *next; 348 }; 349 350 bool AllocateRxPacket(OsclSharedPtr<PVMFMediaDataImpl>& data, SRPRxData* rxData); 351 bool CreateMediaData(SRPRxData* rxData, OsclSharedPtr<PVMFMediaDataImpl> data); 352 bool Allocate(OsclSharedPtr<PVMFMediaDataImpl>& data, OsclRefCounterMemFrag& CCSRLFrag); 353 bool CreateMediaData(PVMFSharedMediaDataPtr& srpPkt, 354 OsclSharedPtr<PVMFMediaDataImpl> data); 355 356 class SRPRespTimer 357 { 358 public: SRPRespTimer()359 SRPRespTimer() : T401Timer("SRPTimer"), 360 timerID(0), 361 N400Counter(0), 362 isTimerActive(false) 363 {}; 364 ~SRPRespTimer()365 ~SRPRespTimer() {}; 366 367 OsclTimer<OsclMemAllocator> T401Timer; 368 int32 timerID; 369 int N400Counter; 370 bool isTimerActive; 371 PVMFSharedMediaDataPtr pPkt; 372 }; 373 374 /* srp_cnt.cpp */ 375 int SrpN400Check(SRPRespTimer &timer); 376 377 /* WNSRP counter */ 378 void SrpN402Initialize(void); SrpN402Clear(void)379 void SrpN402Clear(void) 380 { 381 iN402Counter = 0; 382 } SrpN402Count(void)383 void SrpN402Count(void) 384 { 385 ++iN402Counter; 386 } 387 int SrpN402Check(); 388 389 /* srp_crc.cpp */ CrcClear(void)390 void CrcClear(void) 391 { 392 iCrcData = 0; 393 } 394 void CrcCalc(uint8 *pData, int Size); 395 uint16 CrcResultGet(void); 396 void CrcSetToFrame(uint16 crc, uint8 *pFcs); 397 398 /* srp_edit.cpp */ 399 PVMFSharedMediaDataPtr SrpCommandCreate(PVMFSharedMediaDataPtr pPkt, uint8 header); 400 void SrpCommandClear(uint32 seqNum); 401 PVMFSharedMediaDataPtr SrpResponseCreate(uint8 seqNum, uint8 header); 402 403 /* srp_main.cpp */ 404 SrpEvent SrpGetEventNoFromAL1(PVMFSharedMediaDataPtr pPkt); 405 406 bool SrpMsgCopy(PVMFSharedMediaDataPtr inPkt); 407 408 /* srp_prot.cpp */ SrpNop()409 int SrpNop() 410 { 411 return 1; 412 } 413 int Srp_0_1(); 414 int Srp_0_2(PVMFSharedMediaDataPtr pPkt, int event); 415 int Srp_1_1(); 416 int Srp_1_3(PVMFSharedMediaDataPtr pPkt, int event); 417 int Srp_1_4(int32 id); 418 419 /* srp_que.cpp */ SrpSendWaitSet(PVMFSharedMediaDataPtr pPkt)420 void SrpSendWaitSet(PVMFSharedMediaDataPtr pPkt) 421 { 422 iSrpWaitQueue.push_back(pPkt); 423 } 424 PVMFSharedMediaDataPtr SrpSendWaitGet(uint32 index); 425 int SrpSendWaitRemove(uint32 index); 426 427 /* srp_seq.cpp */ SrpSendSeqClear(void)428 void SrpSendSeqClear(void) 429 { 430 iSendSeqNumber = 0; 431 } 432 void SrpSendSeqCount(void); SrpSendSeqGet(void)433 uint32 SrpSendSeqGet(void) 434 { 435 return(iSendSeqNumber); 436 } SrpRecvSeqClear(void)437 void SrpRecvSeqClear(void) 438 { 439 iRecvSeqNumber = 0; 440 iOldestWNSRPRetransSeqNum = (iRecvSeqNumber - ((256 - iWNSRPRxWindow) / 2)) % 256; 441 } 442 void SrpRecvSeqCount(void); SrpRecvSeqGet(void)443 uint32 SrpRecvSeqGet(void) 444 { 445 return(iRecvSeqNumber); 446 } SrpRecvSeqSet(uint8 seqNo)447 void SrpRecvSeqSet(uint8 seqNo) 448 { 449 iRecvSeqNumber = seqNo; 450 } 451 452 /* srp_sts.cpp */ 453 void SrpStatusSet(SrpStatus newStatus) ; SrpStatusGet(void)454 SrpStatus SrpStatusGet(void) 455 { 456 return(iStatus); 457 } 458 459 /* WNSRP status */ 460 void WnsrpStatusSet(WnsrpStatus newStatus) ; 461 462 /* srp_tim.cpp */ 463 void SrpT401Start(SRPRespTimer &timer, PVMFSharedMediaDataPtr pPkt); 464 void SrpT401Stop(SRPRespTimer &timer); 465 466 467 /* Layer sendto interfaces.*/ LowerLayerTx(PVMFSharedMediaDataPtr pPkt)468 void LowerLayerTx(PVMFSharedMediaDataPtr pPkt) 469 { 470 if (iLLPortOut) 471 { 472 iStats.totalBytesSent += pPkt->getFilledSize(); 473 474 PVMFSharedMediaMsgPtr mediaMsg; 475 convertToPVMFMediaMsg(mediaMsg, pPkt); 476 iLLPortOut->QueueOutgoingMsg(mediaMsg); 477 iLLPortOut->Send(); 478 } 479 } UpperLayerTx(PVMFSharedMediaDataPtr pPkt)480 void UpperLayerTx(PVMFSharedMediaDataPtr pPkt) 481 { 482 if (iULPortOut) 483 { 484 iStats.totalBytesSent += pPkt->getFilledSize(); 485 486 PVMFSharedMediaMsgPtr mediaMsg; 487 convertToPVMFMediaMsg(mediaMsg, pPkt); 488 iULPortOut->QueueOutgoingMsg(mediaMsg); 489 iULPortOut->Send(); 490 } 491 } 492 493 int SrpStateChange(int status, int event, void *data); 494 495 void UpdateRespStats(); 496 497 SRPRespTimer *GetFreeWnsrpTimer(); FreeWnsrpTimer(SRPRespTimer * timer)498 void FreeWnsrpTimer(SRPRespTimer *timer) 499 { 500 iFreeWnsrpCommandSave.push_back(timer); 501 } AddActiveWnsrpTimer(SRPRespTimer * timer)502 void AddActiveWnsrpTimer(SRPRespTimer *timer) 503 { 504 iActiveWnsrpCommandSave.push_back(timer); 505 } 506 SRPRespTimer *FindActiveWnsrpTimer(int32 timerID); 507 void RemoveActiveWnsrpTimer(SRPRespTimer *timer); 508 509 void FreeRxFrag(SRPRxData *frag); 510 SRPRxData *GetRxFrag(); 511 512 void AddPendingRxFrag(SRPRxData *frag); 513 bool CheckRxSeqNum(uint32 seqNum, uint8 header); 514 bool CheckPendingRxList(uint32 seqNum); 515 bool CheckWNSRPRetrans(uint32 seqNum); 516 517 static const SRP::SrpAction iSrpStateTable[MAX_STATUS][MAX_EVENT]; 518 519 /* Counter data */ 520 int iN400MaxCounter; 521 522 /* WNSRP counter data */ 523 int iN402MaxCounter; 524 int iN402Counter; 525 526 /* CRC data */ 527 CRC iCrc; 528 uint32 iCrcData; 529 530 /* Queue data */ 531 Oscl_Vector<PVMFSharedMediaDataPtr, OsclMemAllocator> iSrpWaitQueue; 532 533 /* Seq data */ 534 uint32 iSendSeqNumber; 535 uint32 iRecvSeqNumber; 536 537 /* Status data */ 538 SrpStatus iStatus; 539 WnsrpStatus iCurWnsrpStatus; 540 541 /* Timer data */ 542 int iT401TimerValue; 543 544 /* Commands that have not been acknowledged yet */ 545 SRPRespTimer iSrpCommandSave; 546 SRPRespTimer *iWnsrpCommandSave; 547 Oscl_Vector<SRPRespTimer *, OsclMemAllocator> iFreeWnsrpCommandSave; 548 Oscl_Vector<SRPRespTimer *, OsclMemAllocator> iActiveWnsrpCommandSave; 549 550 /* CCSRL data */ 551 unsigned int iCcsrlSduSize; 552 553 /* Received packet data */ 554 SRPRxData *iRxFrags; 555 SRPRxData *iFreeRxFragList; 556 SRPRxData *iPendingRxFragList; 557 558 559 /* WWU_CCSRL: add end */ 560 bool iFirstCmd; /* WWU_RB8 */ 561 562 PVMFPortInterface *iLLPortOut; 563 PVMFPortInterface *iLLPortIn; 564 PVMFPortInterface *iULPortOut; 565 PVMFPortInterface *iULPortIn; 566 567 OsclMemAllocator iMemAllocator; 568 569 OsclMemPoolFixedChunkAllocator* iTxMediaMsgPoolAlloc; 570 OsclMemPoolFixedChunkAllocator* iTxMediaDataImplMemAlloc; 571 PVMFMediaFragGroupCombinedAlloc<OsclMemAllocator>* iTxPacketAlloc; 572 573 OsclMemPoolFixedChunkAllocator* iOutstandingTxMediaMsgPoolAlloc; 574 OsclMemPoolFixedChunkAllocator* iOutstandingTxMediaDataImplMemAlloc; 575 576 OsclMemPoolFixedChunkAllocator* iRxMediaMsgPoolAlloc; 577 OsclMemPoolFixedChunkAllocator* iRxMediaDataImplMemAlloc; 578 PVMFSimpleMediaBufferCombinedAlloc *iRxPacketAlloc; 579 580 OsclMemPoolFixedChunkAllocator* iRespMediaMsgPoolAlloc; 581 OsclMemPoolFixedChunkAllocator* iRespMemAlloc; 582 PVMFSimpleMediaBufferCombinedAlloc *iRespPacketAlloc; 583 OsclMemPoolFixedChunkAllocator* iNsrpRespMemAlloc; 584 PVMFSimpleMediaBufferCombinedAlloc *iNsrpRespPacketAlloc; 585 586 PVMFBufferPoolAllocator iHdrAllocator; 587 PVMFBufferPoolAllocator iCcsrlAllocator; 588 PVMFBufferPoolAllocator iFCSAllocator; 589 PVMFBufferPoolAllocator iMTEntryNumAllocator; 590 591 OsclRefCounterMemFrag iSrpNsrpEntryNumFrag; 592 OsclRefCounterMemFrag iWnsrpEntryNumFrag; 593 594 uint32 iNumTxMsgs; 595 596 bool iUseNSRP; 597 //If first NSRP response message was received. 598 bool iFirstNSRPResp; 599 600 //For testing purposes. Always should support receiving WNSRP messages. 601 bool iHandleWNSRP; 602 uint32 iWNSRPTxWindow; 603 uint32 iWNSRPRxWindow; 604 uint32 iOldestWNSRPRetransSeqNum; 605 606 int iT401Resolution; 607 SRPObserver* iObserver; 608 609 SRPStats iStats; 610 uint32 iTotalRespTime; 611 TimeValue iInitialTimeChunkSent; 612 613 PVLogger *iLogger; 614 }; 615 616 #endif 617 618