• 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 PVMF_PROTOCOLENGINE_NODE_COMMON_H_INCLUDED
20 #define PVMF_PROTOCOLENGINE_NODE_COMMON_H_INCLUDED
21 
22 #ifndef OSCL_MEM_MEMPOOL_H_INCLUDED
23 #include "oscl_mem_mempool.h"
24 #endif
25 #ifndef PVMF_MEDIA_DATA_H_INCLUDED
26 #include "pvmf_media_data.h"
27 #endif
28 #ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
29 #include "pvmf_simple_media_buffer.h"
30 #endif
31 #ifndef PVMF_META_DATA_TYPES_H_INCLUDED
32 #include "pvmf_meta_data_types.h"
33 #endif
34 #ifndef PVMF_MEDIA_MSG_FORMAT_IDS_H_INCLUDED
35 #include "pvmf_media_msg_format_ids.h"
36 #endif
37 #ifndef PVMI_DATASTREAMUSER_INTERFACE_H_INCLUDED
38 #include "pvmi_datastreamuser_interface.h"
39 #endif
40 #ifndef PVLOGGER_H_INCLUDED
41 #include "pvlogger.h"
42 #endif
43 #ifndef PVLOGGER_FILE_APPENDER_H_INCLUDED
44 #include "pvlogger_file_appender.h"
45 #endif
46 #ifndef PVMF_DOWNLOAD_DATA_SOURCE_H_INCLUDED
47 #include "pvmf_download_data_source.h"
48 #endif
49 #ifndef PVMF_SOURCE_CONTEXT_DATA_H_INCLUDED
50 #include "pvmf_source_context_data.h"
51 #endif
52 #ifndef OSCL_TIMER_H_INCLUDED
53 #include "oscl_timer.h"
54 #endif
55 #ifndef PVMF_PROTOCOL_ENGINE_COMMON_H_INCLUDED
56 #include "pvmf_protocol_engine_common.h"
57 #endif
58 #ifndef PVMF_NODE_UTILS_H_INCLUDED
59 #include "pvmf_node_utils.h"
60 #endif
61 #ifndef PVMF_PROTOCOL_ENGINE_NODE_EVENTS_H_INCLUDED
62 #include "pvmf_protocol_engine_node_events.h"
63 #endif
64 #ifndef PVMI_DATA_STREAM_INTERFACE_H_INCLUDED
65 #include "pvmi_data_stream_interface.h"
66 #endif
67 #ifndef PVMF_EVENT_HANDLING_H_INCLUDED
68 #include "pvmf_event_handling.h"
69 #endif
70 #ifndef PVMF_MEDIA_PRESENTATION_INFO_H_INCLUDED
71 #include "pvmf_media_presentation_info.h"
72 #endif
73 #ifndef PVMF_MEMPOOL_H_INCLUDED
74 #include "pvmf_mempool.h"
75 #endif
76 #ifndef PVMF_MEDIA_CLOCK_H_INCLUDED
77 #include "pvmf_media_clock.h"
78 #endif
79 #ifndef PVMI_KVP_H_INCLUDED
80 #include "pvmi_kvp.h"
81 #endif
82 
83 
84 //#define PVMF_PROTOCOL_ENGINE_LOG_MS_STREAMING_OUTPUT
85 
86 
87 
88 //memory allocator type for this node.
89 typedef OsclMemAllocator PVMFProtocolEngineNodeAllocator;
90 
91 // Structure to hold the key string info for
92 // AAC decnode's capability-and-config
93 struct PVProtocolEngineNodeKeyStringData
94 {
95     char iString[64];
96     PvmiKvpType iType;
97     PvmiKvpValueType iValueType;
98 };
99 
100 // The number of characters to allocate for the key string
101 #define PVPROTOCOLENGINENODECONFIG_KEYSTRING_SIZE 128
102 
103 ///////////////////////////////////////////////////////
104 // For Command implementation
105 ///////////////////////////////////////////////////////
106 
107 //Default vector reserve size
108 #define PVMF_PROTOCOLENGINE_NODE_COMMAND_VECTOR_RESERVE 16
109 
110 //Starting value for command IDs
111 #define PVMF_PROTOCOLENGINE_NODE_COMMAND_ID_START 6000
112 
113 enum PVMFProtocolEngineNodeCmdType
114 {
115     PVPROTOCOLENGINE_NODE_CMD_SEEK = PVMF_GENERIC_NODE_COMMAND_LAST,
116     PVPROTOCOLENGINE_NODE_CMD_BITSTREAM_SWITCH,
117     PVPROTOCOLENGINE_NODE_CMD_DATASTREAM_REQUEST_REPOSITION
118 };
119 
120 enum PVMFProtocolEngineNodeState
121 {
122     // this is special node internal state for processing start command
123     // we set node state as this state before doing the actual work for start
124     // this is to differentiate the node state between pause and start without completing start command
125     // this differentiation aims to ignore logging/keep-alive response when start command gets called,
126     // but hasn't got completed.
127     // This internal state should be gone when start command gets completed, then node state will change
128     // to EPVMFNodeStarted
129     PVMFProtocolEngineNodeState_BeingStarted = EPVMFNodeLastState,
130 };
131 
132 
133 //Node command type.
134 #define PVMFProtocolEngineNodeCommandBase PVMFGenericNodeCommand<PVMFProtocolEngineNodeAllocator> // to remove warning on symbian build
135 class PVMFProtocolEngineNodeCommand: public PVMFProtocolEngineNodeCommandBase
136 {
137     public:
138         //constructor for Custom2 command
Construct(PVMFSessionId s,int32 cmd,int32 arg1,int32 arg2,int32 & arg3,const OsclAny * aContext)139         void Construct(PVMFSessionId s, int32 cmd, int32 arg1, int32 arg2, int32& arg3, const OsclAny*aContext)
140         {
141             PVMFProtocolEngineNodeCommandBase::Construct(s, cmd, aContext);
142             iParam1 = (OsclAny*)arg1;
143             iParam2 = (OsclAny*)arg2;
144             iParam3 = (OsclAny*) & arg3;
145         }
Parse(int32 & arg1,int32 & arg2,int32 * & arg3)146         void Parse(int32&arg1, int32&arg2, int32*&arg3)
147         {
148             arg1 = (int32)iParam1;
149             arg2 = (int32)iParam2;
150             arg3 = (int32*)iParam3;
151         }
152 
153         // Constructor and parser for seek and bitstreamSwitch
Construct(PVMFSessionId s,int32 cmd,uint64 aNPTInMS,uint32 & aFirstSeqNumAfterChange,OsclAny * aContext)154         void Construct(PVMFSessionId s, int32 cmd,
155                        uint64 aNPTInMS,
156                        uint32& aFirstSeqNumAfterChange,
157                        OsclAny* aContext)
158         {
159             PVMFProtocolEngineNodeCommandBase::Construct(s, cmd, aContext);
160             iNPTInMS = aNPTInMS;
161             iParam2 = (OsclAny*) & aFirstSeqNumAfterChange;
162         }
163 
Parse(uint64 & aNPTInMS,uint32 * & aFirstSeqNumAfterChange)164         void Parse(uint64& aNPTInMS, uint32*& aFirstSeqNumAfterChange)
165         {
166             aNPTInMS = iNPTInMS;
167             aFirstSeqNumAfterChange = (uint32*)iParam2;
168         }
169 
170         // constructor and parser for data stream request, especially reposition request
Construct(PVMFSessionId s,int32 cmd,PvmiDataStreamSession aSessionID,PvmiDataStreamRequest aRequestID,OsclAny * aRequestData,PvmiDataStreamCommandId aDataStreamCmdId,OsclAny * aContext)171         void Construct(PVMFSessionId s, int32 cmd,
172                        PvmiDataStreamSession aSessionID,
173                        PvmiDataStreamRequest aRequestID,
174                        OsclAny* aRequestData,
175                        PvmiDataStreamCommandId aDataStreamCmdId,
176                        OsclAny* aContext)
177         {
178             PVMFProtocolEngineNodeCommandBase::Construct(s, cmd, aContext);
179             iParam1 = (OsclAny*)aSessionID;
180             iParam2 = (OsclAny*)((uint32)aRequestID);
181             iParam3 = aRequestData;
182             iParam4 = (OsclAny*)aDataStreamCmdId;
183         }
184 
Parse(PvmiDataStreamSession & aSessionID,PvmiDataStreamRequest & aRequestID,OsclAny * & aRequestData,PvmiDataStreamCommandId & aDataStreamCmdId)185         void Parse(PvmiDataStreamSession& aSessionID, PvmiDataStreamRequest& aRequestID,
186                    OsclAny*& aRequestData, PvmiDataStreamCommandId &aDataStreamCmdId)
187         {
188             aSessionID   = (PvmiDataStreamSession)iParam1;
189             aRequestData = iParam3;
190             aDataStreamCmdId = (PvmiDataStreamCommandId)iParam4;
191             uint32 requestIDNum = (uint32)iParam2;
192             aRequestID   = (PvmiDataStreamRequest)requestIDNum;
193         }
194 
Parse(OsclAny * & aRequestData)195         void Parse(OsclAny*& aRequestData)
196         {
197             aRequestData = iParam3;
198         }
199 
Parse(OsclAny * & aRequestData,PvmiDataStreamCommandId & aDataStreamCmdId)200         void Parse(OsclAny*& aRequestData, PvmiDataStreamCommandId &aDataStreamCmdId)
201         {
202             aRequestData = iParam3;
203             aDataStreamCmdId = (PvmiDataStreamCommandId)iParam4;
204         }
205 
206     private:
207         uint64 iNPTInMS;
208 };
209 
210 
211 //Command queue type
212 typedef PVMFNodeCommandQueue<PVMFProtocolEngineNodeCommand, PVMFProtocolEngineNodeAllocator> PVMFProtocolEngineNodeCmdQ;
213 
214 typedef Oscl_Vector<PVMFSharedMediaMsgPtr, PVMFProtocolEngineNodeAllocator> INPUT_DATA_QUEUE;
215 typedef Oscl_Vector<OsclRefCounterMemFrag, PVMFProtocolEngineNodeAllocator> OUTPUT_DATA_QUEUE;
216 typedef Oscl_Vector<OsclRefCounterMemFrag*, PVMFProtocolEngineNodeAllocator> PENDING_OUTPUT_DATA_QUEUE;
217 
218 // two macros used in the array member and function parameter below
219 #define PVHTTPDOWNLOADOUTPUT_CONTENTDATA_CHUNKSIZE 8000
220 #define EVENT_HANDLER_TOTAL 10
221 
222 enum NetworkTimerType
223 {
224     SERVER_RESPONSE_TIMER_ID = 0,
225     SERVER_INACTIVITY_TIMER_ID,
226     SERVER_KEEPALIVE_TIMER_ID,
227     SERVER_RESPONSE_TIMER_ID_FOR_STOPEOS_LOGGING,
228     // handle data processing in case of no data input (PE node will become idle) for download/progressive streaming,
229     // so there should be a way to activate PE node to continue data processing if needed
230     WALL_CLOCK_TIMER_ID,
231     // a timer to report buffer status periodically, say at every up to 2sec, at least buffer status has to be reported
232     // which tells our system is running
233     BUFFER_STATUS_TIMER_ID
234 };
235 
236 enum PVHttpProtocol
237 {
238     PVHTTPPROTOCOL_PROGRESSIVE_DOWNLOAD = 0,
239     PVHTTPPROTOCOL_PROGRESSIVE_STREAMING,
240     PVHTTPPROTOCOL_SHOUTCAST,
241     PVHTTPPROTOCOL_FASTTRACK_DOWNLOAD,
242     PVHTTPPROTOCOL_MS_HTTP_STREAMING,
243     PVHTTPPROTOCOL_UNKNOWN
244 };
245 
246 // Forward declarations
247 class PVMFProtocolEngineNode;
248 class PVMFProtocolEnginePort;
249 class PVMIDataStreamSyncInterface;
250 class PVLogger;
251 class PVMFLightMediaFragGroupAlloc;
252 class PVMFMediaPresentationInfo;
253 class HttpBasedProtocol;
254 class PVMFProtocolEngineNodeOutput;
255 class DownloadControlInterface;
256 class DownloadProgressInterface;
257 class EventReporter;
258 class PVDlCfgFile;
259 class PVDlCfgFileContainer;
260 class PVMFDownloadDataSourceContainer;
261 class PVMFProtocolEngineNodeTimer;
262 class InterfacingObjectContainer;
263 class UserAgentField;
264 struct PVProtocolEngineNodeInternalEvent;
265 class PVProtocolEngineNodeInternalEventHandler;
266 class PVMFProtocolEnginePort;
267 class OsclSharedLibrary;
268 
269 
270 enum NodeObjectType
271 {
272     NodeObjectType_InputPortForData = 0,
273     NodeObjectType_InputPortForLogging,
274     NodeObjectType_OutPort,
275     NodeObjectType_InternalEventQueue,
276 
277     NodeObjectType_Protocol,
278     NodeObjectType_Output,
279     NodeObjectType_DownloadControl,
280     NodeObjectType_DownloadProgress,
281     NodeObjectType_EventReport,
282     NodeObjectType_DlCfgFileContainer,
283     NodeObjectType_DataSourceContainer,
284     NodeObjectType_Timer,
285     NodeObjectType_InterfacingObjectContainer,
286     NodeObjectType_UseAgentField
287 };
288 
289 class ProtocolContainerObserver
290 {
291     public:
292         virtual uint32 GetObserverState() = 0;
293         virtual void SetObserverState(const uint32 aState) = 0;
294         virtual bool DispatchEvent(PVProtocolEngineNodeInternalEvent *aEvent) = 0;
295         virtual bool SendMediaCommand(PVMFProtocolEnginePort *aPort, PVUid32 aCmdId, const bool isForLogging = false) = 0;
296         virtual void ClearRest(const bool aNeedDelete = false) = 0;
297         virtual void RecheduleDataFlow() = 0;
298         virtual void SendManualResumeNotificationEvent() = 0;
299         virtual bool IsRepositionCmdPending() = 0;
300         virtual PVMFProtocolEngineNodeCommand* FindPendingCmd(int32 aCmdId) = 0;
301         virtual void CompletePendingCmd(int32 status) = 0;
302         virtual void CompleteInputCmd(PVMFProtocolEngineNodeCommand& aCmd, int32 status) = 0;
303         virtual void ErasePendingCmd(PVMFProtocolEngineNodeCommand *aCmd) = 0;
304         virtual void ReportEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, const int32 aEventCode = 0, OsclAny* aEventLocalBuffer = NULL, const uint32 aEventLocalBufferSize = 0) = 0;
305 };
306 
307 
308 
309 // This class handles protocol initialization for multiple http based protocols,
310 // and it serves as a friend class of PVMFProtocolEngineNode, and thus helps do
311 // protocol initialization.
312 class ProtocolContainer
313 {
314     public:
315         // constructor
316         OSCL_IMPORT_REF ProtocolContainer(PVMFProtocolEngineNode *aNode = NULL);
~ProtocolContainer()317         virtual ~ProtocolContainer()
318         {
319             iDataPathLogger = NULL;
320             clear();
321         }
322 
setObserver(ProtocolContainerObserver * aObserver)323         void setObserver(ProtocolContainerObserver *aObserver)
324         {
325             iObserver = aObserver;
326         }
327         OSCL_IMPORT_REF virtual bool createProtocolObjects();
328         OSCL_IMPORT_REF virtual void deleteProtocolObjects();
329         OSCL_IMPORT_REF virtual bool isObjectsReady(); // centralize the info-checking
330         OSCL_IMPORT_REF virtual void setSupportObject(OsclAny* aSupportObject, const uint32 aType);
doInit()331         virtual PVMFStatus doInit()
332         {
333             return PVMFSuccess;    // used in PVMFProtocolEngineNode::doInit
334         }
335         OSCL_IMPORT_REF virtual PVMFStatus doPrepare();                         // used in PVMFProtocolEngineNode::doPrepare, the default implementation is for both 3gpp and fasttrack download
doProPrepare()336         virtual bool doProPrepare()
337         {
338             return true;    // used only for fasttrack, invoke the call to generate SDP info.
339         }
doPreStart()340         virtual int32 doPreStart()
341         {
342             return PROCESS_SUCCESS;
343         }
doPause()344         virtual bool doPause()
345         {
346             return true;
347         }
348         OSCL_IMPORT_REF virtual PVMFStatus doStop();
349         OSCL_IMPORT_REF virtual bool doEOS(const bool isTrueEOS = true);
doInfoUpdate(const uint32 downloadStatus)350         virtual bool doInfoUpdate(const uint32 downloadStatus)
351         {
352             OSCL_UNUSED_ARG(downloadStatus);    // for now, used for download only, report event and update download control
353             return true;
354         }
doSeek(PVMFProtocolEngineNodeCommand & aCmd)355         virtual PVMFStatus doSeek(PVMFProtocolEngineNodeCommand& aCmd)
356         {
357             OSCL_UNUSED_ARG(aCmd);
358             return PVMFSuccess;
359         }
doBitstreamSwitch(PVMFProtocolEngineNodeCommand & aCmd)360         virtual PVMFStatus doBitstreamSwitch(PVMFProtocolEngineNodeCommand& aCmd)
361         {
362             OSCL_UNUSED_ARG(aCmd);
363             return PVMFSuccess;
364         }
365         OSCL_IMPORT_REF virtual bool reconnectSocket(const bool aForceSocketReconnect = true);  // used for progressive download and http streaming
needSocketReconnect()366         virtual bool needSocketReconnect()
367         {
368             return true;
369         }
370         OSCL_IMPORT_REF virtual void startDataFlowByCommand(const bool needDoSocketReconnect = true);
371 
372         OSCL_IMPORT_REF virtual void doClear(const bool aNeedDelete = false);
373         OSCL_IMPORT_REF virtual void doStopClear();
374         OSCL_IMPORT_REF virtual void doCancelClear();
addSourceData(OsclAny * aSourceData)375         virtual bool addSourceData(OsclAny* aSourceData)
376         {
377             OSCL_UNUSED_ARG(aSourceData);
378             return true;
379         }
createCfgFile(OSCL_String & aUri)380         virtual bool createCfgFile(OSCL_String& aUri)
381         {
382             OSCL_UNUSED_ARG(aUri);
383             return true;
384         }
385         virtual bool getProxy(OSCL_String& aProxyName, uint32 &aProxyPort) = 0;
setHttpVersion(const uint32 aHttpVersion)386         virtual void setHttpVersion(const uint32 aHttpVersion)
387         {
388             OSCL_UNUSED_ARG(aHttpVersion);
389         }
handleContentRangeUnmatch()390         virtual bool handleContentRangeUnmatch()
391         {
392             return true;
393         }
downloadUpdateForHttpHeaderAvailable()394         virtual bool downloadUpdateForHttpHeaderAvailable()
395         {
396             return true;
397         }
398         virtual void setHttpExtensionHeaderField(OSCL_String &aFieldKey, OSCL_String &aFieldValue, const HttpMethod aMethod = HTTP_GET, const bool aPurgeOnRedirect = false)
399         {
400             OSCL_UNUSED_ARG(aFieldKey);
401             OSCL_UNUSED_ARG(aFieldValue);
402             OSCL_UNUSED_ARG(aMethod);
403             OSCL_UNUSED_ARG(aPurgeOnRedirect);
404         }
405 
406         OSCL_IMPORT_REF virtual void handleTimeout(const int32 timerID);
407         OSCL_IMPORT_REF virtual bool handleProtocolStateComplete(PVProtocolEngineNodeInternalEvent &aEvent, PVProtocolEngineNodeInternalEventHandler *aEventHandler);
408 
409         // for fasttrack only
getMediaPresentationInfo(PVMFMediaPresentationInfo & aInfo)410         virtual PVMFStatus getMediaPresentationInfo(PVMFMediaPresentationInfo& aInfo)
411         {
412             OSCL_UNUSED_ARG(aInfo);
413             return PVMFSuccess;
414         }
selectTracks(PVMFMediaPresentationInfo & aInfo)415         virtual PVMFStatus selectTracks(PVMFMediaPresentationInfo& aInfo)
416         {
417             OSCL_UNUSED_ARG(aInfo);
418             return PVMFSuccess;
419         }
420 
421         //Http status code 409 means low disk space
isHTTP409ForLowDiskSpace(const int32 errorCode)422         virtual bool isHTTP409ForLowDiskSpace(const int32 errorCode)
423         {
424             OSCL_UNUSED_ARG(errorCode);
425             return false;
426         }
427 
428         // for ms http streaming only
429         virtual void setLoggingStartInPause(const bool aLoggingStartInPause = true)
430         {
431             OSCL_UNUSED_ARG(aLoggingStartInPause);
432         }
isLoggingStartInPause()433         virtual bool isLoggingStartInPause()
434         {
435             return false;
436         }
needSendEOSDuetoError(const int32 aErrorCode)437         virtual bool needSendEOSDuetoError(const int32 aErrorCode)
438         {
439             OSCL_UNUSED_ARG(aErrorCode);
440             return false;
441         }
442 
443         // for progressive download only
needCheckExtraDataComeIn()444         virtual bool needCheckExtraDataComeIn()
445         {
446             return false;
447         }
needCheckEOSAfterDisconnectSocket()448         virtual bool needCheckEOSAfterDisconnectSocket()
449         {
450             return false;
451         }
452 
453         // for progressive playback (special case of progressive download) only
isStreamingPlayback()454         virtual bool isStreamingPlayback()
455         {
456             return false;
457         }
completeRepositionRequest()458         virtual bool completeRepositionRequest()
459         {
460             return false;
461         }
checkSendResumeNotification()462         virtual void checkSendResumeNotification()
463         {
464             ;
465         }
466         virtual void enableInfoUpdate(const bool aEnabled = true)
467         {
468             OSCL_UNUSED_ARG(aEnabled);
469         }
470 
471         OSCL_IMPORT_REF virtual OsclAny* getObject(const NodeObjectType aObjectType);
472 
SetSharedLibraryPtr(OsclSharedLibrary * aPtr)473         virtual void SetSharedLibraryPtr(OsclSharedLibrary* aPtr)
474         {
475             iOsclSharedLibrary = aPtr;
476         }
477 
478         /**
479          * Retrieves shared library pointer
480          * @returns Pointer to the shared library.
481          **/
GetSharedLibraryPtr()482         virtual OsclSharedLibrary* GetSharedLibraryPtr()
483         {
484             return iOsclSharedLibrary;
485         }
486 
487     protected:
488         OSCL_IMPORT_REF virtual PVMFStatus initImpl();
489         virtual int32 initNodeOutput() = 0;
490         OSCL_IMPORT_REF bool initProtocol();
491         virtual bool initProtocol_SetConfigInfo() = 0;
initDownloadControl()492         virtual void initDownloadControl()
493         {
494             ;
495         }
496         OSCL_IMPORT_REF uint32 getBitMaskForHTTPMethod(const HttpMethod aMethod = HTTP_GET);
497         // called by handleTimeout()
handleTimeoutInPause(const int32 timerID)498         virtual bool handleTimeoutInPause(const int32 timerID)
499         {
500             OSCL_UNUSED_ARG(timerID);
501             return false;
502         }
handleTimeoutInDownloadStreamingDone(const int32 timerID)503         virtual bool handleTimeoutInDownloadStreamingDone(const int32 timerID)
504         {
505             OSCL_UNUSED_ARG(timerID);
506             return false;
507         }
508         // called by doStop()
509         OSCL_IMPORT_REF virtual void sendSocketDisconnectCmd();
510         // called by handleTimeout()
511         OSCL_IMPORT_REF virtual bool ignoreThisTimeout(const int32 timerID);
512         OSCL_IMPORT_REF virtual void clear();
513 
514     private:
515         //called by createProtocolObjects()
516         bool createNetworkTimer();
517 
518         // called by handleTimeout()
519         bool handleTimeoutErr(const int32 timerID);
520 
521         // called by startDataFlowByCommand()
522         void checkEOSMsgFromInputPort();
523         // called by doClear or doCancelClear()
524         void clearInternalEventQueue();
525 
526     protected:
527         PVMFProtocolEngineNode *iNode;
528         ProtocolContainerObserver *iObserver;
529         PVLogger *iDataPathLogger;
530 
531         // hold references for the following node objects
532         HttpBasedProtocol *iProtocol;
533         PVMFProtocolEngineNodeOutput *iNodeOutput;
534         DownloadControlInterface *iDownloadControl;
535         DownloadProgressInterface *iDownloadProgess;
536         EventReporter *iEventReport;
537         PVDlCfgFileContainer *iCfgFileContainer;
538         PVMFDownloadDataSourceContainer *iDownloadSource;
539         PVMFProtocolEngineNodeTimer *iNodeTimer;
540         InterfacingObjectContainer *iInterfacingObjectContainer;
541         UserAgentField *iUserAgentField;
542 
543         // pass-in node objects
544         PVMFProtocolEnginePort *iPortInForData, *iPortInForLogging, *iPortOut;
545         Oscl_Vector<PVProtocolEngineNodeInternalEvent, PVMFProtocolEngineNodeAllocator> *iInternalEventQueue;
546 
547         OsclSharedLibrary* iOsclSharedLibrary;
548 };
549 
550 ////////////////////////////////////////////////////////////////////////////////////
551 
552 // Using state to handle multiple use cases
553 enum PVProtocolEngineNodePrcoessingState
554 {
555     ProcessingState_Idle = 0,
556     ProcessingState_NormalDataflow,             // normal data flow
557     // other states are changed to using event
558 };
559 
560 static const TPVMFNodeInterfaceState SetStateByCommand[11] =
561 {
562     EPVMFNodeInitialized,   // PVMF_GENERIC_NODE_INIT=4
563     EPVMFNodePrepared,      // PVMF_GENERIC_NODE_PREPARE=5
564     EPVMFNodeStarted,       // PVMF_GENERIC_NODE_START=6
565     EPVMFNodePrepared,      // PVMF_GENERIC_NODE_STOP=7
566     EPVMFNodeStarted,       // PVMF_GENERIC_NODE_FLUSH=8
567     EPVMFNodePaused,        // PVMF_GENERIC_NODE_PAUSE=9
568     EPVMFNodeCreated,       // PVMF_GENERIC_NODE_RESET=10
569     EPVMFNodeLastState,     // PVMF_GENERIC_NODE_CANCELALLCOMMANDS=11
570     EPVMFNodeLastState,     // PVMF_GENERIC_NODE_CANCELCOMMAND=12
571     EPVMFNodeStarted,       // PVPROTOCOLENGINE_NODE_CMD_SEEK=13,
572     EPVMFNodeStarted        // PVPROTOCOLENGINE_NODE_CMD_BITSTREAM_SWITCH=14
573 };
574 
575 
576 ////////////////////////////////////////////////////////////////////////////////////
577 //////  PVProtocolEngineNodeInternalEvent definition
578 ////////////////////////////////////////////////////////////////////////////////////
579 
580 // This structure defines the internal event(constrast to node event) struture, which serves as the basis of
581 // event-driven handling inside the node
582 enum PVProtocolEngineNodeInternalEventType
583 {
584     // This group of events comes from the callback/feedback from protocol engine
585     PVProtocolEngineNodeInternalEventType_HttpHeaderAvailable = 0,
586     PVProtocolEngineNodeInternalEventType_FirstPacketAvailable,
587     PVProtocolEngineNodeInternalEventType_NormalDataAvailable,
588     PVProtocolEngineNodeInternalEventType_ProtocolStateComplete,
589 
590     // This group of events comes from node itself
591     PVProtocolEngineNodeInternalEventType_EndOfProcessing,
592     PVProtocolEngineNodeInternalEventType_ServerResponseError_Bypassing,
593     PVProtocolEngineNodeInternalEventType_ProtocolStateError,
594     PVProtocolEngineNodeInternalEventType_CheckResumeNotificationMaually,
595     PVProtocolEngineNodeInternalEventType_OutgoingMsgQueuedAndSentSuccessfully,
596 
597     // data flow event
598     PVProtocolEngineNodeInternalEventType_IncomingMessageReady = 9,
599     PVProtocolEngineNodeInternalEventType_HasExtraInputData,
600     PVProtocolEngineNodeInternalEventType_OutputDataReady,
601     PVProtocolEngineNodeInternalEventType_StartDataflowByCommand,
602     PVProtocolEngineNodeInternalEventType_StartDataflowByBufferAvailability,
603     PVProtocolEngineNodeInternalEventType_StartDataflowBySendRequestAction,
604     PVProtocolEngineNodeInternalEventType_StartDataflowByPortOutgoingQueueReady
605 };
606 
607 struct PVProtocolEngineNodeInternalEvent
608 {
609     PVProtocolEngineNodeInternalEventType iEventId;
610     OsclAny *iEventInfo; // any other side info except the actual data, such as error code, sequence number(http streaming), seek offset(fasttrack)
611     OsclAny *iEventData; // actual data for the event
612 
613     // default constructor
PVProtocolEngineNodeInternalEventPVProtocolEngineNodeInternalEvent614     PVProtocolEngineNodeInternalEvent() : iEventId(PVProtocolEngineNodeInternalEventType_HttpHeaderAvailable), iEventInfo(NULL), iEventData(NULL)
615     {
616         ;
617     }
618 
619     // constructor with parameters
620     PVProtocolEngineNodeInternalEvent(PVProtocolEngineNodeInternalEventType aEventId, OsclAny *aEventInfo, OsclAny *aEventData = NULL)
621     {
622         iEventId   = aEventId;
623         iEventInfo = aEventInfo;
624         iEventData = aEventData;
625     }
626 
627     PVProtocolEngineNodeInternalEvent(const ProtocolEngineOutputDataSideInfo &aSideInfo, const OsclAny *aData = NULL)
628     {
629         ProtocolEngineOutputDataSideInfo sideInfo = (ProtocolEngineOutputDataSideInfo&) aSideInfo;
630         iEventId   = (PVProtocolEngineNodeInternalEventType)((uint32)sideInfo.iDataType);
631         iEventInfo = (OsclAny *)sideInfo.iData;
632         iEventData = (OsclAny *)aData;
633     }
634     PVProtocolEngineNodeInternalEvent(PVProtocolEngineNodeInternalEventType aEventId, int32 aInfoCode = 0)
635     {
636         iEventId   = aEventId;
637         iEventInfo = (OsclAny *)aInfoCode;
638         iEventData = NULL;
639     }
640 
641     // copy constructor
PVProtocolEngineNodeInternalEventPVProtocolEngineNodeInternalEvent642     PVProtocolEngineNodeInternalEvent(const PVProtocolEngineNodeInternalEvent &x)
643     {
644         iEventId   = x.iEventId;
645         iEventInfo = x.iEventInfo;
646         iEventData = x.iEventData;
647     }
648 
649     // operator "="
650     PVProtocolEngineNodeInternalEvent &operator=(const PVProtocolEngineNodeInternalEvent& x)
651     {
652         iEventId   = x.iEventId;
653         iEventInfo = x.iEventInfo;
654         iEventData = x.iEventData;
655         return *this;
656     }
657 };
658 
659 // this structure defines information needed for EndOfDataProcessingHandler, will be as iEventInfo
660 struct EndOfDataProcessingInfo
661 {
662     bool iSendResumeNotification;
663     bool iExtraDataComeIn;
664     bool iSendServerDisconnectEvent;
665     bool iStreamingDone;
666     bool iForceStop;
667 
668     // constructor
EndOfDataProcessingInfoEndOfDataProcessingInfo669     EndOfDataProcessingInfo() : iSendResumeNotification(false),
670             iExtraDataComeIn(false),
671             iSendServerDisconnectEvent(false),
672             iStreamingDone(false),
673             iForceStop(false) {}
674 
isValidEndOfDataProcessingInfo675     bool isValid() const
676     {
677         return (iSendResumeNotification     ||
678                 iExtraDataComeIn            ||
679                 iSendServerDisconnectEvent  ||
680                 iStreamingDone              ||
681                 iForceStop);
682     }
683 
clearEndOfDataProcessingInfo684     void clear()
685     {
686         iSendResumeNotification = false;
687         iExtraDataComeIn = false;
688         iSendServerDisconnectEvent = false;
689         iStreamingDone = false;
690         iForceStop = false;
691     }
692 };
693 
694 // this structure defines information needed for ProtocolStateErrorHandler, will be as iEventInfo
695 struct ProtocolStateErrorInfo
696 {
697     int32 iErrorCode;
698     // true means using the current iErrorCode, false means using the previous iErrorCode
699     bool iUseInputErrorCode;
700 
701     // constructor
ProtocolStateErrorInfoProtocolStateErrorInfo702     ProtocolStateErrorInfo() : iErrorCode(0), iUseInputErrorCode(true)
703     {
704         ;
705     }
706     ProtocolStateErrorInfo(const int32 aErrorCode, const bool aUseInputErrorCode = true) :
iErrorCodeProtocolStateErrorInfo707             iErrorCode(aErrorCode),
708             iUseInputErrorCode(aUseInputErrorCode)
709     {
710         ;
711     }
712 };
713 
714 // this structure defines infomation needed for OutgoingMsgSentSuccessHandler, will be as iEventInfo
715 struct OutgoingMsgSentSuccessInfo
716 {
717     PVMFProtocolEnginePort *iPort;
718     PVMFSharedMediaMsgPtr iMsg;
719 
720     // constructor
OutgoingMsgSentSuccessInfoOutgoingMsgSentSuccessInfo721     OutgoingMsgSentSuccessInfo(): iPort(NULL)
722     {
723         ;
724     }
OutgoingMsgSentSuccessInfoOutgoingMsgSentSuccessInfo725     OutgoingMsgSentSuccessInfo(PVMFProtocolEnginePort *aPort, PVMFSharedMediaMsgPtr &aMsg) :
726             iPort(aPort), iMsg(aMsg)
727     {
728         ;
729     }
730 
731     OutgoingMsgSentSuccessInfo &operator=(const OutgoingMsgSentSuccessInfo& x)
732     {
733         iPort = x.iPort;
734         iMsg  = x.iMsg;
735         return *this;
736     }
737 };
738 
739 // use polymophism to handle variant events
740 class PVProtocolEngineNodeInternalEventHandler
741 {
742     public:
~PVProtocolEngineNodeInternalEventHandler()743         virtual ~PVProtocolEngineNodeInternalEventHandler() {}
744 
745         virtual bool handle(PVProtocolEngineNodeInternalEvent &aEvent) = 0;
746         virtual bool completePendingCommand(PVProtocolEngineNodeInternalEvent &aEvent);
747 
748         // contructor
749         PVProtocolEngineNodeInternalEventHandler(PVMFProtocolEngineNode *aNode);
750 
751     protected:
752         bool isBeingStopped(const int32 aStatus = PROCESS_SUCCESS_END_OF_MESSAGE); // common routine
753 
754     private:
755         inline bool isCurrEventMatchCurrPendingCommand(uint32 aCurrEventId);
756         bool completePendingCommandWithError(PVProtocolEngineNodeInternalEvent &aEvent);
757         int32 getBasePVMFErrorReturnCode(const int32 errorCode, const bool isForCommandComplete = true);
758         void handleErrResponse(int32 &aBaseCode, int32 &aErrCode, char* &aEventData, uint32 &aEventDataLen);
759         void handleAuthenErrResponse(int32 &aErrCode, char* &aEventData, uint32 &aEventDataLen);
760         void handleRedirectErrResponse(char* &aEventData, uint32 &aEventDataLen);
761         inline bool isStopCmdPending(); // called by isBeingStopped
762         inline bool isProtocolStateComplete(const int32 aStatus);
763 
764     protected:
765         PVMFProtocolEngineNode *iNode;
766         PVLogger* iDataPathLogger;
767 
768     private:
769         OSCL_HeapString<OsclMemAllocator> iAuthenInfoRealm;
770 };
771 
772 // ProtocolStateErrorHandling becomes a little bit more complicated due to the new requirement:
773 // PE node needs to send EOS to downstream node once error happens during streaming
774 // Previously, PE node just error out without doing that much stuff. Now for this new requirement,
775 // PE node needs two rounds error handling in this case, at the first round, probably does nothing but
776 // storing error code and preparing sending EOS, and then at the second round, does the real error handling
777 // But for other cases (PDL or streaming doesn't really start), just do error handling
778 class ProtocolStateErrorHandler : public PVProtocolEngineNodeInternalEventHandler
779 {
780     public:
781         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
782 
783         // constructor
ProtocolStateErrorHandler(PVMFProtocolEngineNode * aNode)784         ProtocolStateErrorHandler(PVMFProtocolEngineNode *aNode) :
785                 PVProtocolEngineNodeInternalEventHandler(aNode), iErrorCode(0)
786         {
787             ;
788         }
789     private:
790         int32 parseServerResponseCode(const int32 aErrorCode, bool &isInfoEvent);
791         // return value: 0 means caller needs to return immediately, not 0 means error
792         int32 checkRedirectHandling(const int32 aErrorCode);
793         bool handleRedirect();
794         bool NeedHandleContentRangeUnmatch(const int32 aErrorCode);
795         bool handleContentRangeUnmatch();
796         bool needCompletePendingCommandAtThisRound(PVProtocolEngineNodeInternalEvent &aEvent);
797 
798     private:
799         int32 iErrorCode;
800 };
801 
802 class HttpHeaderAvailableHandler : public PVProtocolEngineNodeInternalEventHandler
803 {
804     public:
805         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
806 
807         // constructor
HttpHeaderAvailableHandler(PVMFProtocolEngineNode * aNode)808         HttpHeaderAvailableHandler(PVMFProtocolEngineNode *aNode) :
809                 PVProtocolEngineNodeInternalEventHandler(aNode)
810         {
811             ;
812         }
813 };
814 
815 class FirstPacketAvailableHandler : public PVProtocolEngineNodeInternalEventHandler
816 {
817     public:
818         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
819 
820         // constructor
FirstPacketAvailableHandler(PVMFProtocolEngineNode * aNode)821         FirstPacketAvailableHandler(PVMFProtocolEngineNode *aNode) :
822                 PVProtocolEngineNodeInternalEventHandler(aNode)
823         {
824             ;
825         }
826 };
827 
828 
829 class NormalDataAvailableHandler : public PVProtocolEngineNodeInternalEventHandler
830 {
831     public:
832         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
833 
834         // constructor
NormalDataAvailableHandler(PVMFProtocolEngineNode * aNode)835         NormalDataAvailableHandler(PVMFProtocolEngineNode *aNode) :
836                 PVProtocolEngineNodeInternalEventHandler(aNode)
837         {
838             ;
839         }
840 };
841 
842 class ProtocolStateCompleteHandler : public PVProtocolEngineNodeInternalEventHandler
843 {
844     public:
845         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
846 
847         // constructor
ProtocolStateCompleteHandler(PVMFProtocolEngineNode * aNode)848         ProtocolStateCompleteHandler(PVMFProtocolEngineNode *aNode) :
849                 PVProtocolEngineNodeInternalEventHandler(aNode)
850         {
851             ;
852         }
853 };
854 
855 class NormalDataFlowHandler : public PVProtocolEngineNodeInternalEventHandler
856 {
857     public:
858         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
859 
860         // constructor
NormalDataFlowHandler(PVMFProtocolEngineNode * aNode)861         NormalDataFlowHandler(PVMFProtocolEngineNode *aNode) : PVProtocolEngineNodeInternalEventHandler(aNode), iSendSocketReconnect(false)
862         {
863             ;
864         }
865 
866     private:
867         bool flushDataPostProcessing(const int32 aStatusFlushData);
868         bool handleEOSLogging();
869         bool handleEOS(const int32 aStatus);
870         bool handleEndOfProcessing(const int32 aStatus);
871         bool dataFlowContinue(const int32 aStatus);
872         inline bool isReadyGotoNextState(const int32 aStatus); // called by dataFlowContinueOrStop
873 
874     private:
875         bool iSendSocketReconnect;
876 };
877 
878 class EndOfDataProcessingHandler : public PVProtocolEngineNodeInternalEventHandler
879 {
880     public:
881         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
882 
883         // constructor
EndOfDataProcessingHandler(PVMFProtocolEngineNode * aNode)884         EndOfDataProcessingHandler(PVMFProtocolEngineNode *aNode) :
885                 PVProtocolEngineNodeInternalEventHandler(aNode)
886         {
887             ;
888         }
889 
890     private:
891         void cleanupForStop(PVProtocolEngineNodeInternalEvent &aEvent);
892 };
893 
894 
895 class ServerResponseErrorBypassingHandler : public PVProtocolEngineNodeInternalEventHandler
896 {
897     public:
898         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
899 
900         // constructor
ServerResponseErrorBypassingHandler(PVMFProtocolEngineNode * aNode)901         ServerResponseErrorBypassingHandler(PVMFProtocolEngineNode *aNode) :
902                 PVProtocolEngineNodeInternalEventHandler(aNode)
903         {
904             ;
905         }
906 };
907 
908 
909 // This handler is for PVProtocolEngineNodeInternalEventType_CheckResumeNotificationMaually only. This happens in progressive streaming,
910 // when MBDS is quickly filled up,and parser node hasn't parsed any data. In this special case, PE node will go idle, but parser node
911 // may send an internal RequestResumeNotification before parsing any data, then deadlock happens.
912 class CheckResumeNotificationHandler : public PVProtocolEngineNodeInternalEventHandler
913 {
914     public:
915         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
916 
917         // constructor
CheckResumeNotificationHandler(PVMFProtocolEngineNode * aNode)918         CheckResumeNotificationHandler(PVMFProtocolEngineNode *aNode) :
919                 PVProtocolEngineNodeInternalEventHandler(aNode)
920         {
921             ;
922         }
923 };
924 
925 class OutgoingMsgSentSuccessHandler : public PVProtocolEngineNodeInternalEventHandler
926 {
927     public:
928         bool handle(PVProtocolEngineNodeInternalEvent &aEvent);
929 
930         // constructor
OutgoingMsgSentSuccessHandler(PVMFProtocolEngineNode * aNode)931         OutgoingMsgSentSuccessHandler(PVMFProtocolEngineNode *aNode) :
932                 PVProtocolEngineNodeInternalEventHandler(aNode)
933         {
934             ;
935         }
936 };
937 
938 
939 
940 
941 ////////////////////////////////////////////////////////////////////////////////////
942 //////  PVMFProtocolEngineNodeOutput
943 ////////////////////////////////////////////////////////////////////////////////////
944 
945 // Observer class for pvHttpStreamingOutput to notify the node when the output buffer is available since
946 // the memory pool is created inside pvHttpStreamingOutput
947 class PVMFProtocolEngineNodeOutputObserver
948 {
949     public:
~PVMFProtocolEngineNodeOutputObserver()950         virtual ~PVMFProtocolEngineNodeOutputObserver() {}
951 
952         // notify the node that the output buffer pool is fool, so hold off any data processing
953         virtual void OutputBufferPoolFull() = 0;
954         // notify the node that the new output buffer inside the pool is back to available.
955         virtual void OutputBufferAvailable() = 0;
956         // notify the node that the new data is already written the file and then download control and status
957         // should be updated responsively
958         virtual void ReadyToUpdateDownloadControl() = 0;
959         // notify the node that a media message has been queued in outgoing message queue successfully
960         virtual bool QueueOutgoingMsgSentComplete(PVMFProtocolEnginePort *aPort, PVMFSharedMediaMsgPtr &aMsg, const PVMFStatus aStatus) = 0;
961 };
962 
963 enum NodeOutputType
964 {
965     NodeOutputType_InputPortForData = 0,
966     NodeOutputType_InputPortForLogging,
967     NodeOutputType_OutPort,
968     NodeOutputType_DataStreamFactory
969 };
970 
971 // This base class encapsulates port objects (port and data stream)
972 class PVMFProtocolEngineNodeOutput
973 {
974     public:
975         // set output object such as, input port, output port and data stream factory
976         OSCL_IMPORT_REF virtual void setOutputObject(OsclAny* aOutputObject, const uint32 aObjectType = NodeOutputType_InputPortForData);
setConfigInfo(OsclAny * aConfig)977         virtual void setConfigInfo(OsclAny* aConfig)
978         {
979             OSCL_UNUSED_ARG(aConfig);
980         }
981         OSCL_IMPORT_REF virtual bool passDownNewOutputData(OUTPUT_DATA_QUEUE &aOutputQueue, OsclAny* aSideInfo = NULL);
982         OSCL_IMPORT_REF virtual int32 flushData(const uint32 aOutputType = NodeOutputType_InputPortForData) = 0;
983         virtual int32 initialize(OsclAny* aInitInfo = NULL) = 0;
reCreateMemPool(uint32 aNumPool)984         virtual int32 reCreateMemPool(uint32 aNumPool)
985         {
986             OSCL_UNUSED_ARG(aNumPool);
987             return PROCESS_SUCCESS;
988         }
getNumBuffersInMediaDataPool()989         virtual uint32 getNumBuffersInMediaDataPool()
990         {
991             return 0;
992         }
993         OSCL_IMPORT_REF bool getBuffer(PVMFSharedMediaDataPtr &aMediaData, uint32 aRequestSize = PVHTTPDOWNLOADOUTPUT_CONTENTDATA_CHUNKSIZE);
994         OSCL_IMPORT_REF virtual void discardData(const bool aNeedReopen = false);
995         OSCL_IMPORT_REF virtual bool isPortBusy();
996 
997         // PPB (progressive streaming/playback)
releaseMemFrag(OsclRefCounterMemFrag * aFrag)998         virtual bool releaseMemFrag(OsclRefCounterMemFrag* aFrag)
999         {
1000             OSCL_UNUSED_ARG(aFrag);
1001             return false;
1002         };
setContentLength(uint32 aLength)1003         virtual void setContentLength(uint32 aLength)
1004         {
1005             OSCL_UNUSED_ARG(aLength);
1006         };
dataStreamCommandCompleted(const PVMFCmdResp & aResponse)1007         virtual void dataStreamCommandCompleted(const PVMFCmdResp& aResponse)
1008         {
1009             OSCL_UNUSED_ARG(aResponse);
1010         };
setDataStreamSourceRequestObserver(PvmiDataStreamRequestObserver * aObserver)1011         virtual void setDataStreamSourceRequestObserver(PvmiDataStreamRequestObserver* aObserver)
1012         {
1013             OSCL_UNUSED_ARG(aObserver);
1014         };
flushDataStream()1015         virtual void flushDataStream()
1016         {
1017             ;
1018         }
seekDataStream(const uint32 aSeekOffset)1019         virtual bool seekDataStream(const uint32 aSeekOffset)
1020         {
1021             OSCL_UNUSED_ARG(aSeekOffset);
1022             return true;
1023         };
1024 
1025         // get info from output object to serve as the basis for status update
getCurrentOutputSize()1026         uint32 getCurrentOutputSize()
1027         {
1028             return iCurrTotalOutputSize;
1029         }
setCurrentOutputSize(const uint32 aCurrentSize)1030         void setCurrentOutputSize(const uint32 aCurrentSize)
1031         {
1032             iCurrTotalOutputSize = aCurrentSize;    // used in resume download
1033         }
getCurrentPlaybackTime()1034         virtual uint32 getCurrentPlaybackTime()
1035         {
1036             return 0;
1037         }
1038         // in case of progressive streaming, the following two sizes mean available cache size and maximum cache size
getAvailableOutputSize()1039         virtual uint32 getAvailableOutputSize()
1040         {
1041             return 0xFFFFFFFF;
1042         }
getMaxAvailableOutputSize()1043         virtual uint32 getMaxAvailableOutputSize()
1044         {
1045             return 0;
1046         }
1047 
1048         // constructor and destructor
1049         OSCL_IMPORT_REF PVMFProtocolEngineNodeOutput(PVMFProtocolEngineNodeOutputObserver *aObserver = NULL);
1050         OSCL_IMPORT_REF virtual ~PVMFProtocolEngineNodeOutput();
1051 
1052     protected:
1053         // for media data
1054         OSCL_IMPORT_REF PVMFStatus createMemPool();
1055         OSCL_IMPORT_REF void deleteMemPool();
1056         // create media data for composing http request
1057         OSCL_IMPORT_REF bool createMediaData(PVMFSharedMediaDataPtr &aMediaData, uint32 aRequestSize);
1058         OSCL_IMPORT_REF bool sendToDestPort(PVMFSharedMediaDataPtr &aMediaData, PVMFProtocolEnginePort *aPort);
1059 
1060         // send the input media data to the port
1061         OSCL_IMPORT_REF virtual bool sendToPort(PVMFSharedMediaDataPtr &aMediaData, const uint32 aPortType = NodeOutputType_InputPortForData);
1062 
1063         // reset
1064         OSCL_IMPORT_REF virtual void reset();
1065 
1066     protected:
1067         PVMFProtocolEnginePort *iPortIn;  // input port connecting to socket node, both for download and http streaming
1068 
1069         // Output buffer memory pool
1070         OsclMemPoolFixedChunkAllocator *iContentDataMemPool;
1071 
1072         // Allocator for simple media data buffer
1073         PVMFSimpleMediaBufferCombinedAlloc *iMediaDataAlloc;
1074 
1075         // Memory pool for simple media data
1076         PVMFMemPoolFixedChunkAllocator iMediaDataMemPool;
1077 
1078         PVMFSharedMediaDataPtr iMediaData;
1079         Oscl_Vector<OUTPUT_DATA_QUEUE, PVMFProtocolEngineNodeAllocator> iOutputFramesQueue;
1080         // Mem frags in this queue are being used by the data stream
1081         PENDING_OUTPUT_DATA_QUEUE iPendingOutputDataQueue;
1082 
1083         // observer to notify the node when output buffer is available
1084         PVMFProtocolEngineNodeOutputObserver *iObserver;
1085 
1086         // current total output size, serves as the basis for status update
1087         uint32 iCurrTotalOutputSize;
1088 
1089         PVLogger* iLogger;
1090         PVLogger* iDataPathLogger;
1091         PVLogger* iClockLogger;
1092 };
1093 
1094 
1095 ////////////////////////////////////////////////////////////////////////////////////
1096 //////  DownloadControlInterface
1097 ////////////////////////////////////////////////////////////////////////////////////
1098 enum DownloadControlSupportObjectType
1099 {
1100     DownloadControlSupportObjectType_SupportInterface = 0,
1101     DownloadControlSupportObjectType_ProgressInterface,
1102     DownloadControlSupportObjectType_EnginePlaybackClock,
1103     DownloadControlSupportObjectType_ProtocolEngine,
1104     DownloadControlSupportObjectType_ConfigFileContainer,
1105     DownloadControlSupportObjectType_SDPInfoContainer,
1106     DownloadControlSupportObjectType_DownloadProgress,
1107     DownloadControlSupportObjectType_OutputObject
1108 };
1109 
1110 // The intent of introducing this download ocntrol interface is to make streaming counterpart as a NULL object,
1111 // which remove any error-prone check
1112 class DownloadControlInterface
1113 {
1114     public:
1115         // set download control supporting objects:
1116         virtual void setSupportObject(OsclAny *aDLSupportObject, DownloadControlSupportObjectType aType) = 0;
1117         // From PVMFDownloadProgressInterface API pass down
1118         virtual void requestResumeNotification(const uint32 currentNPTReadPosition, bool& aDownloadComplete, bool& aNeedSendUnderflowEvent) = 0;
1119         // check whether to make resume notification; if needed, then make resume notification
1120         virtual void cancelResumeNotification() = 0;
1121         // cancel request of resume notification.
1122         virtual int32 checkResumeNotification(const bool aDownloadComplete = true) = 0;
1123         // return true for the new download progress
1124         // From PVMFDownloadProgressInterface API
1125         virtual void getDownloadClock(OsclSharedPtr<PVMFMediaClock> &aClock) = 0;
1126         // From PVMFDownloadProgressInterface API
1127         virtual void setClipDuration(const uint32 aClipDurationMsec) = 0;
1128         // for auto-resume control for resume download
1129         virtual void setPrevDownloadSize(uint32 aPrevDownloadSize = 0) = 0;
1130         virtual void clear() = 0;
1131 
1132         // for progressive playback repositioning
1133         virtual void clearPerRequest() = 0;
1134         virtual bool isDownloadCompletedPerRequest() = 0;
1135 
1136         // destructor
~DownloadControlInterface()1137         virtual ~DownloadControlInterface()
1138         {
1139             ;
1140         }
1141 };
1142 
1143 ////////////////////////////////////////////////////////////////////////////////////
1144 //////  DownloadProgressInterface
1145 ////////////////////////////////////////////////////////////////////////////////////
1146 
1147 // This class encapsulates the download progress update based on different download progress modes
1148 class DownloadProgressInterface
1149 {
1150     public:
1151         virtual void setSupportObject(OsclAny *aDLSupportObject, DownloadControlSupportObjectType aType) = 0;
1152 
1153         // updata download clock and download progress
1154         virtual bool update(const bool aDownloadComplete = false) = 0;
1155 
1156         // return true for the new download progress
1157         virtual bool getNewProgressPercent(uint32 &aProgressPercent) = 0;
1158 
1159         // return duration for auto-resume decision
1160         virtual void setClipDuration(const uint32 aClipDurationMsec) = 0;
1161 
1162         virtual void setDownloadProgressMode(DownloadProgressMode aMode = DownloadProgressMode_TimeBased) = 0;
1163 
~DownloadProgressInterface()1164         virtual ~DownloadProgressInterface()
1165         {
1166             ;
1167         }
1168 };
1169 
1170 ////////////////////////////////////////////////////////////////////////////////////
1171 //////  EventReporter
1172 ////////////////////////////////////////////////////////////////////////////////////
1173 // This class wraps up sending node info&error event.
1174 enum EventReporterSupportObjectType
1175 {
1176     EventReporterSupportObjectType_DownloadProgress = 0,
1177     EventReporterSupportObjectType_ProtocolEngine,
1178     EventReporterSupportObjectType_ConfigFileContainer,
1179     EventReporterSupportObjectType_NodeInterfacingObject,
1180     EventReporterSupportObjectType_TimerObject,
1181     EventReporterSupportObjectType_OutputObject
1182 };
1183 
1184 class EventReporterObserver
1185 {
1186     public:
1187         // TODO: Change the buffer to be const void*.
1188         // TODO: Why do we have event data AND event buffer?
1189         virtual void ReportEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, const int32 aEventCode = 0, OsclAny* aEventLocalBuffer = NULL, const size_t aEventLocalBufferSize = 0) = 0;
1190         virtual void NotifyContentTooLarge() = 0;
1191         virtual uint32 GetObserverState() = 0;
1192 };
1193 
1194 class EventReporter
1195 {
1196     public:
~EventReporter()1197         virtual ~EventReporter() {}
1198 
1199         // constructor
1200         OSCL_IMPORT_REF EventReporter(EventReporterObserver *aObserver);
1201 
setSupportObject(OsclAny * aSupportObject,EventReporterSupportObjectType aType)1202         virtual void setSupportObject(OsclAny *aSupportObject, EventReporterSupportObjectType aType)
1203         {
1204             OSCL_UNUSED_ARG(aSupportObject);
1205             OSCL_UNUSED_ARG(aType);
1206         }
1207 
1208         // major function to walk throught all the node info & error event whether to be sent out
checkReportEvent(const uint32 downloadStatus)1209         virtual bool checkReportEvent(const uint32 downloadStatus)
1210         {
1211             OSCL_UNUSED_ARG(downloadStatus);
1212             return true;
1213         }
1214         // the content-length event and content too large event, can't fit into the above checkReportEvent() completely
checkContentInfoEvent(const uint32 downloadStatus)1215         virtual bool checkContentInfoEvent(const uint32 downloadStatus)
1216         {
1217             OSCL_UNUSED_ARG(downloadStatus);
1218             return true;
1219         }
1220 
1221         // enable some specific events
sendDataReadyEvent()1222         virtual void sendDataReadyEvent()
1223         {
1224             ;
1225         }
enableBufferingCompleteEvent()1226         virtual void enableBufferingCompleteEvent()
1227         {
1228             ;
1229         }
sendBufferStatusEvent()1230         virtual void sendBufferStatusEvent()
1231         {
1232             ;
1233         }
1234 
1235         OSCL_IMPORT_REF virtual void clear();
1236 
1237         // node is running in start state to kick off the normal downloading and streaming
1238         OSCL_IMPORT_REF void startRealDataflow();
1239 
1240     protected:
1241         bool iStarted;
1242         EventReporterObserver *iObserver;
1243         PVLogger *iDataPathLogger;
1244 };
1245 
1246 
1247 // This class wraps up user agent setting, differentiated in progessive download, fastrack and ms http streaming.
1248 // Any this kind of variation should be wrapped up into an object
1249 class UserAgentField
1250 {
1251     public:
1252         // constructor
UserAgentField()1253         UserAgentField() : iOverwritable(false)
1254         {
1255             ;
1256         }
1257         OSCL_IMPORT_REF UserAgentField(OSCL_wString &aUserAgent, const bool isOverwritable = false);
1258         OSCL_IMPORT_REF UserAgentField(OSCL_String &aUserAgent, const bool isOverwritable = false);
~UserAgentField()1259         virtual ~UserAgentField()
1260         {
1261             ;
1262         }
1263 
1264         // set user agent
1265         OSCL_IMPORT_REF bool setUserAgent(OSCL_wString &aUserAgent, const bool isOverwritable = false);
1266         OSCL_IMPORT_REF bool setUserAgent(OSCL_String &aUserAgent, const bool isOverwritable = false);
1267 
1268         // get the actual user agent (not wide string version) based on overwrite mode or replace mode (attach the input user agent to the default one)
1269         OSCL_IMPORT_REF bool getUserAgent(OSCL_String &aUserAgent);
1270 
1271     protected:
1272         virtual void getDefaultUserAgent(OSCL_String &aUserAgent) = 0;
1273 
1274     protected:
1275         OSCL_HeapString<OsclMemAllocator> iInputUserAgent;
1276         OSCL_HeapString<OsclMemAllocator> iActualUserAgent;
1277         bool iOverwritable;
1278 };
1279 
1280 typedef Oscl_Vector<OutgoingMsgSentSuccessInfo, PVMFProtocolEngineNodeAllocator> OutgoingMsgSentSuccessInfoVec;
1281 
1282 // This class interfaces between the node and node user, which is in fact a data holder and holds the data set by the node public APIs
1283 // and some output data return to node user
1284 class InterfacingObjectContainer
1285 {
1286     public:
1287         // set and get download format
setDownloadFormat(PVMFFormatType & aDownloadFormat)1288         void setDownloadFormat(PVMFFormatType &aDownloadFormat)
1289         {
1290             iDownloadFormat = (PVMFFormatType)aDownloadFormat;
1291         }
getDownloadFormat()1292         PVMFFormatType getDownloadFormat() const
1293         {
1294             return iDownloadFormat;
1295         }
1296 
1297         // set and get url
1298         void setURI(OSCL_String &aUri, const bool aRedirectUri = false)
1299         {
1300             iDownloadURI.setURI(aUri, aRedirectUri);
1301         }
1302         void setURI(OSCL_wString &aUri, const bool aRedirectUri = false)
1303         {
1304             iDownloadURI.setURI(aUri, aRedirectUri);
1305         }
getURIObject()1306         INetURI &getURIObject()
1307         {
1308             return iDownloadURI;
1309         }
1310 
setLoggingURI(OSCL_String & aUri)1311         void setLoggingURI(OSCL_String &aUri)
1312         {
1313             iLoggingURI.setURI(aUri);
1314         }
setLoggingURI(OSCL_wString & aUri)1315         void setLoggingURI(OSCL_wString &aUri)
1316         {
1317             iLoggingURI.setURI(aUri);
1318         }
getLoggingURIObject()1319         INetURI &getLoggingURIObject()
1320         {
1321             return iLoggingURI;
1322         }
1323 
1324         // set and get data stream factory
setDataStreamFactory(const PVMFDataStreamFactory * aDataStreamFactory)1325         void setDataStreamFactory(const PVMFDataStreamFactory *aDataStreamFactory)
1326         {
1327             iDataStreamFactory = (PVMFDataStreamFactory *)aDataStreamFactory;
1328         }
getDataStreamFactory()1329         PVMFDataStreamFactory *getDataStreamFactory()
1330         {
1331             return iDataStreamFactory;
1332         }
1333 
1334         // set and get stream parameters in http streaming
setStreamParams(PVMFProtocolEngineNodeMSHTTPStreamingParams & aStreamParams)1335         void setStreamParams(PVMFProtocolEngineNodeMSHTTPStreamingParams &aStreamParams)
1336         {
1337             iStreamParams = aStreamParams;
1338         }
getStreamParams()1339         PVProtocolEngineMSHttpStreamingParams *getStreamParams()
1340         {
1341             return &iStreamParams;
1342         }
1343 
1344         //set fast cache setting
SetAccelBitrate(uint32 aAccelBitrate)1345         void SetAccelBitrate(uint32 aAccelBitrate)
1346         {
1347             iStreamParams.iAccelBitrate = aAccelBitrate;
1348         }
SetAccelDuration(uint32 aAccelDuration)1349         void SetAccelDuration(uint32 aAccelDuration)
1350         {
1351             iStreamParams.iAccelDuration = aAccelDuration;
1352         }
1353 
1354         //set max streaming size
SetMaxHttpStreamingSize(uint32 aMaxHttpStreamingSize)1355         void SetMaxHttpStreamingSize(uint32 aMaxHttpStreamingSize)
1356         {
1357             iStreamParams.iMaxHttpStreamingSize = aMaxHttpStreamingSize;
1358         }
1359 
1360         // set and get number of buffers in media message allocator in http streaming
setMediaMsgAllocatorNumBuffers(const uint32 aNumBuffersInAllocator)1361         void setMediaMsgAllocatorNumBuffers(const uint32 aNumBuffersInAllocator)
1362         {
1363             iNumBuffersInAllocator = aNumBuffersInAllocator;
1364         }
getMediaMsgAllocatorNumBuffers()1365         uint32 getMediaMsgAllocatorNumBuffers() const
1366         {
1367             return iNumBuffersInAllocator;
1368         }
1369 
1370         // set and get number of redirect trials
setNumRedirectTrials(const uint32 aNumRedirectTrials)1371         void setNumRedirectTrials(const uint32 aNumRedirectTrials)
1372         {
1373             iNumRedirectTrials = aNumRedirectTrials;
1374         }
setCurrNumRedirectTrials(const uint32 aCurrNumRedirectTrials)1375         void setCurrNumRedirectTrials(const uint32 aCurrNumRedirectTrials)
1376         {
1377             iCurrRedirectTrials = aCurrNumRedirectTrials;
1378         }
getNumRedirectTrials()1379         uint32 getNumRedirectTrials() const
1380         {
1381             return iNumRedirectTrials;
1382         }
getCurrNumRedirectTrials()1383         uint32 getCurrNumRedirectTrials() const
1384         {
1385             return iCurrRedirectTrials;
1386         }
1387 
1388         // set and get http header
1389         // return the actual http header length, 0 means no header
1390         OSCL_IMPORT_REF uint32 setHttpHeader(OUTPUT_DATA_QUEUE &aHttpHeader);
getHTTPHeader(uint8 * & aHeader,uint32 & aHeaderLen)1391         void getHTTPHeader(uint8*& aHeader, uint32& aHeaderLen)
1392         {
1393             aHeader = (uint8*)iHttpHeaderBuffer;
1394             aHeaderLen = iHttpHeaderLength;
1395         }
1396 
1397         // set and get file size
setFileSize(const uint32 aFileSize)1398         void setFileSize(const uint32 aFileSize)
1399         {
1400             iFileSize = aFileSize;
1401         }
getFileSize()1402         uint32 getFileSize() const
1403         {
1404             return iFileSize;
1405         }
1406 
1407         // socket connect flags
updateSocketConnectFlags(const bool isEOS)1408         void updateSocketConnectFlags(const bool isEOS)
1409         {
1410             if (!iCurrSocketConnection && !isEOS) iSocketReconnectCmdSent = false; // when connnection becomes from down (EOS) to up, clear the flag of sending socket reconnect command
1411             iPrevSocketConnection = iCurrSocketConnection;
1412             iCurrSocketConnection = !isEOS;
1413         }
isSocketConnectionUp()1414         bool isSocketConnectionUp() const
1415         {
1416             return iCurrSocketConnection;
1417         }
isPrevSocketConnectionUp()1418         bool isPrevSocketConnectionUp() const
1419         {
1420             return iPrevSocketConnection;
1421         }
isSocketReconnectCmdSent()1422         bool isSocketReconnectCmdSent() const
1423         {
1424             return iSocketReconnectCmdSent;
1425         }
1426         void setSocketReconnectCmdSent(const bool aSocketReconnectCmdSent = true)
1427         {
1428             iSocketReconnectCmdSent = aSocketReconnectCmdSent;
1429             iCurrSocketConnection = true;
1430             iPrevSocketConnection = true;
1431         }
ignoreCurrentInputData()1432         bool ignoreCurrentInputData() const
1433         {
1434             return isCurrentInputDataUnwanted;
1435         }
1436         void setInputDataUnwanted(const bool aInputDataUnwanted = true)
1437         {
1438             isCurrentInputDataUnwanted = aInputDataUnwanted;
1439         }
1440 
1441         // KeepAlive timeout
setKeepAliveTimeout(const uint32 aTimeout)1442         void setKeepAliveTimeout(const uint32 aTimeout)
1443         {
1444             iKeepAliveTimeout = aTimeout;
1445         }
getKeepAliveTimeout()1446         uint32 getKeepAliveTimeout() const
1447         {
1448             return iKeepAliveTimeout;
1449         }
1450 
1451         // Streaming proxy
1452         OSCL_IMPORT_REF bool setStreamingProxy(OSCL_wString& aProxyName, const uint32 aProxyPort = DEFAULT_HTTP_PORT_NUMBER);
getStreamingProxy(OSCL_String & aProxyName,uint32 & aProxyPort)1453         void getStreamingProxy(OSCL_String& aProxyName, uint32 &aProxyPort)
1454         {
1455             aProxyName = iProxyName;
1456             aProxyPort = iProxyPort;
1457         }
1458 
1459         // flag of disabling HTTP HEAD request
1460         void setHttpHeadRequestDisabled(const bool aDisableHeadRequest = true)
1461         {
1462             iDisableHeadRequest = aDisableHeadRequest;
1463         }
getHttpHeadRequestDisabled()1464         bool getHttpHeadRequestDisabled() const
1465         {
1466             return iDisableHeadRequest;
1467         }
1468 
1469         // maximum ASF header size
setMaxASFHeaderSize(const uint32 aMaxASFHeaderSize)1470         void setMaxASFHeaderSize(const uint32 aMaxASFHeaderSize)
1471         {
1472             iMaxASFHeaderSize = aMaxASFHeaderSize;
1473         }
getMaxASFHeaderSize()1474         uint32 getMaxASFHeaderSize() const
1475         {
1476             return iMaxASFHeaderSize;
1477         }
1478 
1479         // latest packet number just sent to downstream node successfully
setLatestPacketNumSent(const uint32 aPacketNum)1480         void setLatestPacketNumSent(const uint32 aPacketNum)
1481         {
1482             iLatestDataPacketNumSent = aPacketNum;
1483         }
getLatestPacketNumSent()1484         uint32 getLatestPacketNumSent() const
1485         {
1486             return iLatestDataPacketNumSent;
1487         }
1488 
1489         // user-id and password for HTTP authentication
setUserAuthInfo(OSCL_String & aUserID,OSCL_String & aPasswd)1490         void setUserAuthInfo(OSCL_String &aUserID, OSCL_String &aPasswd)
1491         {
1492             if (aUserID.get_size() > 0)
1493             {
1494                 iStreamParams.iUserID = OSCL_HeapString<OsclMemAllocator> (aUserID.get_cstr(), aUserID.get_size());
1495             }
1496             if (aPasswd.get_size() > 0)
1497             {
1498                 iStreamParams.iUserPasswd = OSCL_HeapString<OsclMemAllocator> (aPasswd.get_cstr(), aPasswd.get_size());
1499             }
1500         }
1501 
1502         OSCL_IMPORT_REF void setNumBuffersInMediaDataPoolSMCalc(uint32 aVal);
getNumBuffersInMediaDataPoolSMCalc()1503         uint32 getNumBuffersInMediaDataPoolSMCalc() const
1504         {
1505             return iNumBuffersInMediaDataPoolSMCalc;
1506         }
1507         // iOutputPortConnected
1508         void setOutputPortConnect(const bool aConnected = true)
1509         {
1510             iOutputPortConnected = aConnected;
1511         }
getOutputPortConnect()1512         bool getOutputPortConnect() const
1513         {
1514             return iOutputPortConnected;
1515         }
1516 
1517         // iCancelCmdHappened
1518         void setCancelCmdHappened(const bool aCancelCmdHappened = true)
1519         {
1520             iCancelCmdHappened = aCancelCmdHappened;
1521         }
getCancelCmdHappened()1522         bool getCancelCmdHappened() const
1523         {
1524             return iCancelCmdHappened;
1525         }
1526 
1527         // iEOPInfo
getEOPInfo()1528         EndOfDataProcessingInfo *getEOPInfo()
1529         {
1530             return &iEOPInfo;
1531         }
1532 
1533         // protocol state complete info
1534         void setProtocolStateCompleteInfo(const ProtocolStateCompleteInfo &aInfo, const bool aForceSet = false)
1535         {
1536             if (!aForceSet)
1537             {
1538                 if (aInfo.isDownloadStreamingDone) iProtocolStateCompleteInfo.isDownloadStreamingDone = true;
1539                 if (aInfo.isWholeSessionDone)     iProtocolStateCompleteInfo.isWholeSessionDone = true;
1540                 if (aInfo.isEOSAchieved)              iProtocolStateCompleteInfo.isEOSAchieved = true;
1541             }
1542             else
1543             {
1544                 iProtocolStateCompleteInfo.isDownloadStreamingDone = aInfo.isDownloadStreamingDone;
1545                 iProtocolStateCompleteInfo.isWholeSessionDone      = aInfo.isWholeSessionDone;
1546                 iProtocolStateCompleteInfo.isEOSAchieved           = aInfo.isEOSAchieved;
1547             }
1548         }
getProtocolStateCompleteInfo()1549         ProtocolStateCompleteInfo *getProtocolStateCompleteInfo()
1550         {
1551             return &iProtocolStateCompleteInfo;
1552         }
1553 
getOutgoingMsgSentSuccessInfoVec()1554         OutgoingMsgSentSuccessInfoVec *getOutgoingMsgSentSuccessInfoVec()
1555         {
1556             return &iOutgoingMsgSentSuccessInfoVec;
1557         }
1558 
isDownloadStreamingDone()1559         bool isDownloadStreamingDone()
1560         {
1561             return iProtocolStateCompleteInfo.isDownloadStreamingDone;
1562         }
isWholeSessionDone()1563         bool isWholeSessionDone()
1564         {
1565             return iProtocolStateCompleteInfo.isWholeSessionDone;
1566         }
isEOSAchieved()1567         bool isEOSAchieved()
1568         {
1569             return iProtocolStateCompleteInfo.isEOSAchieved;
1570         }
1571 
1572         void setTruncatedForLimitSize(const bool aTruncatedForLimitSize = false)
1573         {
1574             iTruncatedForLimitSize = aTruncatedForLimitSize;
1575         }
getTruncatedForLimitSize()1576         bool getTruncatedForLimitSize() const
1577         {
1578             return iTruncatedForLimitSize;
1579         }
1580 
1581         // constructor
1582         InterfacingObjectContainer();
~InterfacingObjectContainer()1583         ~InterfacingObjectContainer()
1584         {
1585             clear();
1586             iOutgoingMsgSentSuccessInfoVec.clear();
1587         }
1588 
1589         // clear
clear()1590         void clear()
1591         {
1592             iHttpHeaderLength           = 0;
1593             iFileSize                   = 0;
1594             iSocketReconnectCmdSent     = false;
1595             iCurrRedirectTrials         = 0;
1596             isCurrentInputDataUnwanted  = true; // when clear(), treat all the input data unwanted (that needs to be ignored), let command and event to enable it
1597             iProcessingDone             = false;
1598             iKeepAliveTimeout           = 0;
1599             iDisableHeadRequest         = true; // changed on the request of Japan
1600             iMaxASFHeaderSize           = 0;
1601             iCancelCmdHappened          = false;
1602             iTruncatedForLimitSize      = false;
1603             iProtocolStateCompleteInfo.clear();
1604         }
1605 
1606     private:
1607         PVMFFormatType  iDownloadFormat;
1608         // set by SetSourceInitializationData()
1609         INetURI iDownloadURI;
1610         // set by SetLoggingURL
1611         INetURI iLoggingURI;
1612         // set by PassDatastreamFactory()
1613         PVMFDataStreamFactory *iDataStreamFactory;
1614         // set by SetStreamParams()
1615         PVProtocolEngineMSHttpStreamingParams iStreamParams;
1616         // set by SetMediaMsgAllocatorNumBuffers()
1617         uint32 iNumBuffersInAllocator;
1618         // set by SetNumRedirectTrials
1619         uint32 iNumRedirectTrials;
1620         uint32 iCurrRedirectTrials;
1621 
1622         uint32 iNumBuffersInMediaDataPoolSMCalc;
1623         // get from GetHTTPHeader()
1624         char iHttpHeaderBuffer[PVHTTPDOWNLOADOUTPUT_CONTENTDATA_CHUNKSIZE+1]; // to hold http header
1625         uint32 iHttpHeaderLength;
1626         // get from GetFileSize()
1627         uint32 iFileSize;
1628 
1629         // socket connect flags
1630         bool iCurrSocketConnection; // true means the connection is up and on ; false means the connection is downn
1631         bool iPrevSocketConnection; // the status of previous socket connection
1632         bool iSocketReconnectCmdSent; // flag to record whether the socket reconnect command is sent
1633 
1634         // this flag is introduced to ignore unwanted incoming messages in certain scenarios,
1635         // such as stop/reset/cancel, protocol state complete/error, while init/prepare/start command would disable
1636         // this flag
1637         bool isCurrentInputDataUnwanted;
1638 
1639         bool iProcessingDone; // work as a global variable
1640 
1641         uint32 iKeepAliveTimeout;
1642 
1643         // streaming proxy and port
1644         OSCL_HeapString<OsclMemAllocator> iProxyName;
1645         uint32 iProxyPort;
1646 
1647         bool iDisableHeadRequest;
1648         uint32 iMaxASFHeaderSize;
1649         uint32 iLatestDataPacketNumSent;
1650 
1651         // the connection status between PE node output port and downstream(JB) node input port
1652         // this flag will help sending EOS or not
1653         bool iOutputPortConnected;
1654 
1655         bool iCancelCmdHappened;
1656 
1657         // work as a global variable
1658         EndOfDataProcessingInfo iEOPInfo;
1659         ProtocolStateCompleteInfo iProtocolStateCompleteInfo;
1660         OutgoingMsgSentSuccessInfoVec iOutgoingMsgSentSuccessInfoVec;
1661 
1662         // This flag mean data-size reach limitation or not
1663         // true : data reached limitation
1664         // false: data don't reach limitation
1665         bool iTruncatedForLimitSize;
1666 };
1667 
1668 
1669 ////////////////////////////////////////////////////////////////////////////////////
1670 //////  PVMFProtocolEngineNodeTimer
1671 ////////////////////////////////////////////////////////////////////////////////////
1672 
1673 // This class wraps OsclTimer<allocator> to hide some details and make call more expressive
1674 struct TimerUnit
1675 {
1676     uint32 iTimerID;
1677     uint32 iTimeout;
1678 
1679     // constructor
TimerUnitTimerUnit1680     TimerUnit() : iTimerID(0), iTimeout(0)
1681     {
1682         ;
1683     }
TimerUnitTimerUnit1684     TimerUnit(const uint32 aTimerID, const uint32 aTimeout) : iTimerID(aTimerID), iTimeout(aTimeout)
1685     {
1686         ;
1687     }
1688 };
1689 
1690 class PVMFProtocolEngineNodeTimer
1691 {
1692     public:
1693         // factory and destructor
1694         OSCL_IMPORT_REF static PVMFProtocolEngineNodeTimer* create(OsclTimerObserver *aObserver);
1695         OSCL_IMPORT_REF ~PVMFProtocolEngineNodeTimer();
1696 
1697         // register and set timer id and timeout value
1698         // note that if aTimeout=0, that means using the internal default one
1699         OSCL_IMPORT_REF void set(const uint32 aTimerID, const int32 aTimeout = 0);
1700 
1701         // get the timeout value for specific timer id. If not set, return default value
1702         // if input timer id is not registered, will return 0xffffffff
1703         OSCL_IMPORT_REF uint32 getTimeout(const uint32 aTimerID);
1704 
1705         // start the timer with optional new timeout value, aTimeout=0 means using the existing one
1706         // if the timer id doesn't exist, it will return failure, which means set() has to be called before start()
1707         OSCL_IMPORT_REF bool start(const uint32 aTimerID, const int32 aTimeout = 0);
1708 
1709         OSCL_IMPORT_REF void cancel(const uint32 aTimerID);
1710         OSCL_IMPORT_REF void clear();
1711 
1712         // clear all the timers except the timer with the given timer ID
1713         OSCL_IMPORT_REF void clearExcept(const uint32 aTimerID);
1714 
1715     private:
1716         // constructor
PVMFProtocolEngineNodeTimer()1717         PVMFProtocolEngineNodeTimer() : iWatchdogTimer(NULL)
1718         {
1719             ;
1720         }
1721         bool construct(OsclTimerObserver *aObserver);
1722 
1723         uint32 getDefaultTimeout(const uint32 aTimerID);
1724         uint32 getTimerVectorIndex(const uint32 aTimerID);
1725 
1726     private:
1727         OsclTimer<PVMFProtocolEngineNodeAllocator>  *iWatchdogTimer;
1728         Oscl_Vector<TimerUnit, PVMFProtocolEngineNodeAllocator> iTimerVec;
1729 };
1730 
1731 #endif
1732