• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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