1/* ------------------------------------------------------------------
2 * Copyright (C) 1998-2009 PacketVideo
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
13 * express or implied.
14 * See the License for the specific language governing permissions
15 * and limitations under the License.
16 * -------------------------------------------------------------------
17 */
18#ifndef PVMF_MP4FFPARSER_NODE_H_INCLUDED
19#define PVMF_MP4FFPARSER_NODE_H_INCLUDED
20
21
22#ifndef OSCL_BASE_H_INCLUDED
23#include "oscl_base.h"
24#endif
25
26#ifndef PVMF_MEDIA_CLOCK_H_INCLUDED
27#include "pvmf_media_clock.h"
28#endif
29
30#ifndef OSCL_TIMER_H_INCLUDED
31#include "oscl_timer.h"
32#endif
33
34#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
35#include "oscl_scheduler_ao.h"
36#endif
37
38#ifndef OSCL_FILE_IO_H_INCLUDED
39#include "oscl_file_io.h"
40#endif
41
42#ifndef OSCL_STRING_H_INCLUDED
43#include "oscl_string.h"
44#endif
45
46#ifndef PVLOGGER_H_INCLUDED
47#include "pvlogger.h"
48#endif
49
50#ifndef PVLOGGER_FILE_APPENDER_H_INCLUDED
51#include "pvlogger_file_appender.h"
52#endif
53
54#ifndef OSCL_BIN_STREAM_H_INCLUDED
55#include "oscl_bin_stream.h"
56#endif
57
58#ifndef PVMF_FORMAT_TYPE_H_INCLUDED
59#include "pvmf_format_type.h"
60#endif
61
62#ifndef PVMF_NODE_INTERFACE_H_INCLUDED
63#include "pvmf_node_interface.h"
64#endif
65
66#ifndef PVMF_NODE_UTILS_H_INCLUDED
67#include "pvmf_node_utils.h"
68#endif
69
70#ifndef OSCL_PRIQUEUE_H_INCLUDED
71#include "oscl_priqueue.h"
72#endif
73
74#ifndef PVMF_MEDIA_DATA_H_INCLUDED
75#include "pvmf_media_data.h"
76#endif
77
78#ifndef OSCL_MEM_MEMPOOL_H_INCLUDED
79#include "oscl_mem_mempool.h"
80#endif
81
82#ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
83#include "pvmf_simple_media_buffer.h"
84#endif
85
86#ifndef PVMF_MEDIA_FRAG_GROUP_H_INCLUDED
87#include "pvmf_media_frag_group.h"
88#endif
89
90#ifndef PVMF_MP4FFPARSER_DEFS_H_INCLUDED
91#include "pvmf_mp4ffparser_defs.h"
92#endif
93
94#ifndef PVMF_DATA_SOURCE_PLAYBACK_CONTROL_H_INCLUDED
95#include "pvmf_data_source_playback_control.h"
96#endif
97
98#ifndef PVMF_META_DATA_EXTENSION_H_INCLUDED
99#include "pvmf_meta_data_extension.h"
100#endif
101
102#ifndef PVMF_DATA_SOURCE_INIT_EXTENSION_H_INCLUDED
103#include "pvmf_data_source_init_extension.h"
104#endif
105
106#ifndef PVMF_TRACK_SELECTION_EXTENSION_H_INCLUDED
107#include "pvmf_track_selection_extension.h"
108#endif
109
110#ifndef PVMF_MEDIA_PRESENTATION_INFO_H_INCLUDED
111#include "pvmf_media_presentation_info.h"
112#endif
113
114#ifndef PVMF_TRACK_LEVEL_INFO_EXTENSION_H_INCLUDED
115#include "pvmf_track_level_info_extension.h"
116#endif
117
118#ifndef PVMF_MP4_PROGDOWNLOAD_SUPPORT_EXTENSION_H_INCLUDED
119#include "pvmf_mp4_progdownload_support_extension.h"
120#endif
121
122#ifndef CPM_H_INCLUDED
123#include "cpm.h"
124#endif
125
126#ifndef PVMF_CPMPLUGIN_ACCESS_INTERFACE_H_INCLUDED
127#include "pvmf_cpmplugin_access_interface.h"
128#endif
129
130#ifndef PVMF_LOCAL_DATA_SOURCE_H_INCLUDED
131#include "pvmf_local_data_source.h"
132#endif
133
134#ifndef PVMF_MEMPOOL_H_INCLUDED
135#include "pvmf_mempool.h"
136#endif
137
138#ifndef PVMF_TIMEDTEXT_H_INCLUDED
139#include "pvmf_timedtext.h"
140#endif
141
142#ifndef PV_GAU_H_
143#include "pv_gau.h"
144#endif
145
146#ifndef PVMF_FORMAT_PROGDOWNLOAD_SUPPORT_EXTENSION_H_INCLUDED
147#include "pvmf_format_progdownload_support_extension.h"
148#endif
149
150#ifndef PVMF_DOWNLOAD_PROGRESS_EXTENSION_H
151#include "pvmf_download_progress_interface.h"
152#endif
153
154#ifndef PVMI_DATASTREAMUSER_INTERFACE_H_INCLUDED
155#include "pvmi_datastreamuser_interface.h"
156#endif
157
158#ifndef PVMF_MP4FFPARSER_OUTPORT_H_INCLUDED
159#include "pvmf_mp4ffparser_outport.h"
160#endif
161
162#ifndef PVMF_SOURCE_CONTEXT_DATA_H_INCLUDED
163#include "pvmf_source_context_data.h"
164#endif
165
166#ifndef PVMF_CPMPLUGIN_LICENSE_INTERFACE_H_INCLUDED
167#include "pvmf_cpmplugin_license_interface.h"
168#endif
169
170#ifndef PVMI_KVP_UTIL_H_INCLUDED
171#include "pvmi_kvp_util.h"
172#endif
173
174#ifndef PVMF_BASIC_ERRORINFOMESSAGE_H_INCLUDED
175#include "pvmf_basic_errorinfomessage.h"
176#endif
177
178#ifndef PVMF_DATA_SOURCE_DIRECTION_CONTROL_H_INCLUDED
179#include "pvmf_data_source_direction_control.h"
180#endif
181
182/**
183* Node command handling
184*/
185
186class PVMFMP4ParserNodeLoggerDestructDealloc : public OsclDestructDealloc
187{
188    public:
189        void destruct_and_dealloc(OsclAny* ptr)
190        {
191            PVLoggerAppender* p = OSCL_REINTERPRET_CAST(PVLoggerAppender*, ptr);
192            BinaryFileAppender* binPtr = OSCL_REINTERPRET_CAST(BinaryFileAppender*, p);
193            if (!binPtr)
194                return;
195            OSCL_DELETE(binPtr);
196        }
197};
198
199#define PVMF_MP4FFPARSERNODE_UNDERFLOW_STATUS_TIMER_ID 1
200
201#define PVMF_MP4FFPARSERNODE_MAX_CPM_METADATA_KEYS 256
202
203#define NORMAL_PLAYRATE 100000
204
205typedef PVMFGenericNodeCommand<OsclMemAllocator> PVMFMP4FFParserNodeCommandBase;
206
207enum PVMFMP4FFParserNodeCommandType
208{
209    PVMP4FF_NODE_CMD_SETDATASOURCEPOSITION = PVMF_GENERIC_NODE_COMMAND_LAST
210    , PVMP4FF_NODE_CMD_QUERYDATASOURCEPOSITION
211    , PVMP4FF_NODE_CMD_SETDATASOURCERATE
212    , PVMP4FF_NODE_CMD_GETNODEMETADATAKEYS
213    , PVMP4FF_NODE_CMD_GETNODEMETADATAVALUES
214    , PVMP4FF_NODE_CMD_GET_LICENSE_W
215    , PVMP4FF_NODE_CMD_GET_LICENSE
216    , PVMP4FF_NODE_CMD_CANCEL_GET_LICENSE
217    , PVMF_MP4_PARSER_NODE_CAPCONFIG_SETPARAMS
218    , PVMP4FF_NODE_CMD_SETDATASOURCEDIRECTION
219};
220
221class PVMFMP4FFParserNodeCommand : public PVMFMP4FFParserNodeCommandBase
222{
223    public:
224
225        // Constructor and parser for GetNodeMetadataKeys
226        void Construct(PVMFSessionId s, int32 cmd
227                       , PVMFMetadataList& aKeyList
228                       , uint32 aStartingIndex
229                       , int32 aMaxEntries
230                       , char* aQueryKey
231                       , const OsclAny* aContext)
232        {
233            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
234            iParam1 = (OsclAny*) & aKeyList;
235            iParam2 = (OsclAny*)aStartingIndex;
236            iParam3 = (OsclAny*)aMaxEntries;
237            if (aQueryKey)
238            {
239                //allocate a copy of the query key string.
240                Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str;
241                iParam4 = str.ALLOC_AND_CONSTRUCT(aQueryKey);
242            }
243        }
244        void Parse(PVMFMetadataList*& MetaDataListPtr, uint32 &aStartingIndex, int32 &aMaxEntries, char*& aQueryKey)
245        {
246            MetaDataListPtr = (PVMFMetadataList*)iParam1;
247            aStartingIndex = (uint32)iParam2;
248            aMaxEntries = (int32)iParam3;
249            aQueryKey = NULL;
250            if (iParam4)
251            {
252                OSCL_HeapString<OsclMemAllocator>* keystring = (OSCL_HeapString<OsclMemAllocator>*)iParam4;
253                aQueryKey = keystring->get_str();
254            }
255        }
256
257        // Constructor and parser for GetNodeMetadataValue
258        void Construct(PVMFSessionId s, int32 cmd, PVMFMetadataList& aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 aStartIndex, int32 aMaxEntries, const OsclAny* aContext)
259        {
260            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
261            iParam1 = (OsclAny*) & aKeyList;
262            iParam2 = (OsclAny*) & aValueList;
263            iParam3 = (OsclAny*)aStartIndex;
264            iParam4 = (OsclAny*)aMaxEntries;
265
266        }
267        void Parse(PVMFMetadataList* &aKeyList, Oscl_Vector<PvmiKvp, OsclMemAllocator>* &aValueList, uint32 &aStartingIndex, int32 &aMaxEntries)
268        {
269            aKeyList = (PVMFMetadataList*)iParam1;
270            aValueList = (Oscl_Vector<PvmiKvp, OsclMemAllocator>*)iParam2;
271            aStartingIndex = (uint32)iParam3;
272            aMaxEntries = (int32)iParam4;
273        }
274
275        /* Constructor and parser for setParametersAsync */
276        void Construct(PVMFSessionId s, int32 cmd, PvmiMIOSession aSession,
277                       PvmiKvp* aParameters, int num_elements,
278                       PvmiKvp*& aRet_kvp, OsclAny* aContext)
279        {
280            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
281            iParam1 = (OsclAny*)aSession;
282            iParam2 = (OsclAny*)aParameters;
283            iParam3 = (OsclAny*)num_elements;
284            iParam4 = (OsclAny*) & aRet_kvp;
285        }
286        void Parse(PvmiMIOSession& aSession, PvmiKvp*& aParameters,
287                   int &num_elements, PvmiKvp** &ppRet_kvp)
288        {
289            aSession = (PvmiMIOSession)iParam1;
290            aParameters = (PvmiKvp*)iParam2;
291            num_elements = (int)iParam3;
292            ppRet_kvp = (PvmiKvp**)iParam4;
293        }
294
295        // Constructor and parser for SetDataSourcePosition
296        void Construct(PVMFSessionId s, int32 cmd, PVMFTimestamp aTargetNPT, PVMFTimestamp& aActualNPT, PVMFTimestamp& aActualMediaDataTS,
297                       bool aSeekToSyncPoint, uint32 aStreamID, const OsclAny*aContext)
298        {
299            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
300            iParam1 = (OsclAny*)aTargetNPT;
301            iParam2 = (OsclAny*) & aActualNPT;
302            iParam3 = (OsclAny*) & aActualMediaDataTS;
303            iParam4 = (OsclAny*)aSeekToSyncPoint;
304            iParam5 = (OsclAny*)aStreamID;
305        }
306        void Parse(PVMFTimestamp& aTargetNPT, PVMFTimestamp*& aActualNPT, PVMFTimestamp*& aActualMediaDataTS, bool& aSeekToSyncPoint, uint32& aStreamID)
307        {
308            aTargetNPT = (PVMFTimestamp)iParam1;
309            aActualNPT = (PVMFTimestamp*)iParam2;
310            aActualMediaDataTS = (PVMFTimestamp*)iParam3;
311            aSeekToSyncPoint = (iParam4) ? true : false;
312            aStreamID = (uint32)iParam5;
313        }
314
315        // Constructor and parser for QueryDataSourcePosition
316        void Construct(PVMFSessionId s, int32 cmd, PVMFTimestamp aTargetNPT, PVMFTimestamp &aActualNPT,
317                       bool aSeekToSyncPoint, const OsclAny*aContext)
318        {
319            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
320            iParam1 = (OsclAny*)aTargetNPT;
321            iParam2 = (OsclAny*) & aActualNPT;
322            iParam3 = (OsclAny*)aSeekToSyncPoint;
323            iParam4 = NULL;
324            iParam5 = NULL;
325        }
326
327        // Constructor and parser for QueryDataSourcePosition with aSeekPointBeforeTargetNPT and aSeekPointAfterTargetNPT
328        void Construct(PVMFSessionId s, int32 cmd, PVMFTimestamp aTargetNPT,
329                       PVMFTimestamp& aSeekPointBeforeTargetNPT, PVMFTimestamp& aSeekPointAfterTargetNPT,
330                       const OsclAny*aContext, bool aSeekToSyncPoint)
331        {
332            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
333            iParam1 = (OsclAny*)aTargetNPT;
334            iParam3 = (OsclAny*)aSeekToSyncPoint;
335            iParam4 = (OsclAny*) & aSeekPointBeforeTargetNPT;
336            iParam5 = (OsclAny*) & aSeekPointAfterTargetNPT;
337        }
338
339
340        void Parse(PVMFTimestamp& aTargetNPT, PVMFTimestamp*& aActualNPT, bool& aSeekToSyncPoint)
341        {
342            aTargetNPT = (PVMFTimestamp)iParam1;
343            aActualNPT = (PVMFTimestamp*)iParam2;
344            aSeekToSyncPoint = (iParam3) ? true : false;
345        }
346
347        void Parse(PVMFTimestamp& aTargetNPT, PVMFTimestamp*& aSeekPointBeforeTargetNPT,
348                   bool& aSeekToSyncPoint, PVMFTimestamp*& aSeekPointAfterTargetNPT)
349        {
350            aTargetNPT = (PVMFTimestamp)iParam1;
351            aSeekPointBeforeTargetNPT = (PVMFTimestamp*)iParam4;
352            aSeekPointAfterTargetNPT = (PVMFTimestamp*)iParam5;
353            aSeekToSyncPoint = (iParam3) ? true : false;
354        }
355        /* Constructor and parser for SetDataSourceDirection */
356        void Construct(PVMFSessionId s, int32 cmd, int32 aDirection,
357                       PVMFTimestamp& aActualNPT, PVMFTimestamp& aActualMediaDataTS,
358                       PVMFTimebase* aTimebase, OsclAny* aContext)
359        {
360            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
361            iParam1 = (OsclAny*)aDirection;
362            iParam2 = (OsclAny*) & aActualNPT;
363            iParam3 = (OsclAny*) & aActualMediaDataTS;
364            iParam4 = (OsclAny*)aTimebase;
365            iParam5 = NULL;
366        }
367        void Parse(int32& aDirection,
368                   PVMFTimestamp*& aActualNPT,
369                   PVMFTimestamp*& aActualMediaDataTS,
370                   PVMFTimebase*& aTimebase)
371        {
372            aDirection = (int32)iParam1;
373            aActualNPT = (PVMFTimestamp*)iParam2;
374            aActualMediaDataTS = (PVMFTimestamp*)iParam3;
375            aTimebase = (PVMFTimebase*)iParam4;
376        }
377
378        // Constructor and parser for SetDataSourceRate
379        void Construct(PVMFSessionId s, int32 cmd, int32 aRate, PVMFTimebase* aTimebase, const OsclAny*aContext)
380        {
381            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
382            iParam1 = (OsclAny*)aRate;
383            iParam2 = (OsclAny*)aTimebase;
384            iParam3 = NULL;
385            iParam4 = NULL;
386            iParam5 = NULL;
387        }
388        void Parse(int32& aRate, PVMFTimebase*& aTimebase)
389        {
390            aRate = (int32)iParam1;
391            aTimebase = (PVMFTimebase*)iParam2;
392        }
393
394        /* Constructor and parser for GetLicenseW */
395        void Construct(PVMFSessionId s,
396                       int32 cmd,
397                       OSCL_wString& aContentName,
398                       OsclAny* aLicenseData,
399                       uint32 aDataSize,
400                       int32 aTimeoutMsec,
401                       OsclAny* aContext)
402        {
403            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
404            iParam1 = (OsclAny*) & aContentName;
405            iParam2 = (OsclAny*)aLicenseData;
406            iParam3 = (OsclAny*)aDataSize;
407            iParam4 = (OsclAny*)aTimeoutMsec;
408            iParam5 = NULL;
409        }
410        void Parse(OSCL_wString*& aContentName,
411                   OsclAny*& aLicenseData,
412                   uint32& aDataSize,
413                   int32& aTimeoutMsec)
414        {
415            aContentName = (OSCL_wString*)iParam1;
416            aLicenseData = (PVMFTimestamp*)iParam2;
417            aDataSize = (uint32)iParam3;
418            aTimeoutMsec = (int32)iParam4;
419        }
420
421        /* Constructor and parser for GetLicense */
422        void Construct(PVMFSessionId s,
423                       int32 cmd,
424                       OSCL_String& aContentName,
425                       OsclAny* aLicenseData,
426                       uint32 aDataSize,
427                       int32 aTimeoutMsec,
428                       OsclAny* aContext)
429        {
430            PVMFMP4FFParserNodeCommandBase::Construct(s, cmd, aContext);
431            iParam1 = (OsclAny*) & aContentName;
432            iParam2 = (OsclAny*)aLicenseData;
433            iParam3 = (OsclAny*)aDataSize;
434            iParam4 = (OsclAny*)aTimeoutMsec;
435            iParam5 = NULL;
436        }
437        void Parse(OSCL_String*& aContentName,
438                   OsclAny*& aLicenseData,
439                   uint32& aDataSize,
440                   int32& aTimeoutMsec)
441        {
442            aContentName = (OSCL_String*)iParam1;
443            aLicenseData = (PVMFTimestamp*)iParam2;
444            aDataSize = (uint32)iParam3;
445            aTimeoutMsec = (int32)iParam4;
446        }
447
448
449        // Need to overlaod the base Destroy routine to cleanup metadata key.
450        void Destroy()
451        {
452            PVMFGenericNodeCommand<OsclMemAllocator>::Destroy();
453            switch (iCmd)
454            {
455                case PVMP4FF_NODE_CMD_GETNODEMETADATAKEYS:
456                    if (iParam4)
457                    {
458                        //cleanup the allocated string
459                        Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str;
460                        str.destruct_and_dealloc(iParam4);
461                    }
462                    break;
463                default:
464                    break;
465            }
466        }
467
468        // Need to overlaod the base Copy routine to copy metadata key.
469        void Copy(const PVMFGenericNodeCommand<OsclMemAllocator>& aCmd)
470        {
471            PVMFGenericNodeCommand<OsclMemAllocator>::Copy(aCmd);
472            switch (aCmd.iCmd)
473            {
474                case PVMP4FF_NODE_CMD_GETNODEMETADATAKEYS:
475                    if (aCmd.iParam4)
476                    {
477                        //copy the allocated string
478                        OSCL_HeapString<OsclMemAllocator>* aStr = (OSCL_HeapString<OsclMemAllocator>*)aCmd.iParam4;
479                        Oscl_TAlloc<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> str;
480                        iParam4 = str.ALLOC_AND_CONSTRUCT(*aStr);
481                    }
482                    break;
483                default:
484                    break;
485            }
486        }
487
488};
489typedef PVMFNodeCommandQueue<PVMFMP4FFParserNodeCommand, OsclMemAllocator> PVMFMP4FFParserNodeCmdQueue;
490
491//Command queue type
492typedef PVMFNodeCommandQueue<PVMFMP4FFParserNodeCommand, OsclMemAllocator> PVMFMP4FFParserNodeCmdQueue;
493
494
495/**
496* The Node class
497*/
498class IMpeg4File;
499class PVMFMP4FFParserOutPort;
500class PVMFMP4FFPortIter;
501class PVLogger;
502class PVMFMediaClock;
503
504enum BaseKeys_SelectionType
505{
506    INVALID = 0,
507    NET,
508    FILE_IO
509};
510
511#define PVMFFFPARSERNODE_MAX_NUM_TRACKS 6
512
513class PVMFMP4FFParserNode : public OsclTimerObject,
514        public PVMFNodeInterface,
515        public PVMFDataSourceInitializationExtensionInterface,
516        public PVMFTrackSelectionExtensionInterface,
517        public PvmfDataSourcePlaybackControlInterface,
518        public PVMFMetadataExtensionInterface,
519        public PVMFTrackLevelInfoExtensionInterface,
520        public PVMFCPMStatusObserver,
521        public PvmiDataStreamObserver,
522        public PVMIDatastreamuserInterface,
523        public PVMFFormatProgDownloadSupportInterface,
524        public OsclTimerObserver,
525        public PVMFCPMPluginLicenseInterface,
526        public PvmiCapabilityAndConfig,
527        public PVMFMediaClockStateObserver, // For observing the playback clock states
528        public PvmfDataSourceDirectionControlInterface
529{
530    public:
531        PVMFMP4FFParserNode(int32 aPriority = OsclActiveObject::EPriorityNominal);
532        virtual ~PVMFMP4FFParserNode();
533
534        // From PVMFNodeInterface
535        PVMFStatus ThreadLogon();
536        PVMFStatus ThreadLogoff();
537        PVMFStatus GetCapability(PVMFNodeCapability& aNodeCapability);
538        PVMFPortIter* GetPorts(const PVMFPortFilter* aFilter = NULL);
539
540        PVMFCommandId QueryUUID(PVMFSessionId aSessionId,
541                                const PvmfMimeString& aMimeType,
542                                Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
543                                bool aExactUuidsOnly = false,
544                                const OsclAny* aContext = NULL);
545        PVMFCommandId QueryInterface(PVMFSessionId aSessionId,
546                                     const PVUuid& aUuid,
547                                     PVInterface*& aInterfacePtr,
548                                     const OsclAny* aContext = NULL);
549
550        PVMFCommandId RequestPort(PVMFSessionId aSessionId, int32 aPortTag,
551                                  const PvmfMimeString* aPortConfig = NULL,
552                                  const OsclAny* aContext = NULL);
553        PVMFStatus ReleasePort(PVMFSessionId aSessionId, PVMFPortInterface& aPort,
554                               const OsclAny* aContext = NULL);
555
556        PVMFCommandId Init(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
557        PVMFCommandId Prepare(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
558        PVMFCommandId Start(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
559        PVMFCommandId Stop(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
560        PVMFCommandId Flush(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
561        PVMFCommandId Pause(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
562        PVMFCommandId Reset(PVMFSessionId aSessionId, const OsclAny* aContext = NULL);
563
564        PVMFCommandId CancelAllCommands(PVMFSessionId aSessionId, const OsclAny* aContextData = NULL);
565        PVMFCommandId CancelCommand(PVMFSessionId aSessionId, PVMFCommandId aCmdId, const OsclAny* aContextData = NULL);
566        PVMFStatus QueryInterfaceSync(PVMFSessionId aSession,
567                                      const PVUuid& aUuid,
568                                      PVInterface*& aInterfacePtr);
569
570        /* cap config interface */
571        virtual void setObserver(PvmiConfigAndCapabilityCmdObserver* aObserver)
572        {
573            ciObserver = aObserver;
574        }
575
576        virtual PVMFStatus getParametersSync(PvmiMIOSession aSession,
577                                             PvmiKeyType aIdentifier,
578                                             PvmiKvp*& aParameters,
579                                             int& aNumParamElements,
580                                             PvmiCapabilityContext aContext);
581        virtual PVMFStatus releaseParameters(PvmiMIOSession aSession,
582                                             PvmiKvp* aParameters,
583                                             int num_elements);
584        virtual void createContext(PvmiMIOSession aSession, PvmiCapabilityContext& aContext);
585        virtual void setContextParameters(PvmiMIOSession aSession, PvmiCapabilityContext& aContext,
586                                          PvmiKvp* aParameters, int num_parameter_elements);
587        virtual void DeleteContext(PvmiMIOSession aSession,
588                                   PvmiCapabilityContext& aContext);
589        virtual void setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters,
590                                       int num_elements, PvmiKvp * & aRet_kvp);
591        virtual PVMFCommandId setParametersAsync(PvmiMIOSession aSession,
592                PvmiKvp* aParameters,
593                int num_elements,
594                PvmiKvp*& aRet_kvp,
595                OsclAny* context = NULL);
596        virtual uint32 getCapabilityMetric(PvmiMIOSession aSession);
597        virtual PVMFStatus verifyParametersSync(PvmiMIOSession aSession,
598                                                PvmiKvp* aParameters,
599                                                int num_elements);
600
601        PVMFStatus GetConfigParameter(PvmiKvp*& aParameters, int& aNumParamElements,
602                                      int32 aIndex, PvmiKvpAttr reqattr);
603        PVMFStatus VerifyAndSetConfigParameter(int index, PvmiKvp& aParameter, bool set);
604
605
606        // From PVInterface
607        void addRef();
608        void removeRef();
609        bool queryInterface(const PVUuid& uuid, PVInterface*& iface);
610
611        // From PVMFDataSourceInitializationExtensionInterface
612        PVMFStatus SetSourceInitializationData(OSCL_wString& aSourceURL, PVMFFormatType& aSourceFormat, OsclAny* aSourceData);
613        PVMFStatus SetClientPlayBackClock(PVMFMediaClock* aClientClock);
614        PVMFStatus SetEstimatedServerClock(PVMFMediaClock* aClientClock);
615
616        // From PVMFTrackSelectionExtensionInterface
617        PVMFStatus GetMediaPresentationInfo(PVMFMediaPresentationInfo& aInfo);
618        PVMFStatus SelectTracks(PVMFMediaPresentationInfo& aInfo);
619
620        // From PVMFMetadataExtensionInterface
621        uint32 GetNumMetadataKeys(char* aQueryKeyString = NULL);
622        uint32 GetNumMetadataValues(PVMFMetadataList& aKeyList);
623        uint32 GetNumImotionMetadataValues(PVMFMetadataList& aKeyList);
624        PVMFCommandId GetNodeMetadataKeys(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList, uint32 aStartingKeyIndex, int32 aMaxKeyEntries,
625                                          char* aQueryKeyString = NULL, const OsclAny* aContextData = NULL);
626        PVMFCommandId GetNodeMetadataValues(PVMFSessionId aSessionId, PVMFMetadataList& aKeyList,
627                                            Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 aStartingValueIndex, int32 aMaxValueEntries, const OsclAny* aContextData = NULL);
628        PVMFStatus ReleaseNodeMetadataKeys(PVMFMetadataList& aKeyList, uint32 aStartingKeyIndex, uint32 aEndKeyIndex);
629        PVMFStatus ReleaseNodeMetadataValues(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, uint32 aStartingValueIndex, uint32 aEndValueIndex);
630
631        // From PvmfDataSourcePlaybackControlInterface
632        PVMFCommandId SetDataSourcePosition(PVMFSessionId aSessionId, PVMFTimestamp aTargetNPT, PVMFTimestamp& aActualNPT,
633                                            PVMFTimestamp& aActualMediaDataTS, bool aSeekToSyncPoint = true, uint32 aStreamID = 0, OsclAny* aContext = NULL);
634        PVMFCommandId QueryDataSourcePosition(PVMFSessionId aSessionId, PVMFTimestamp aTargetNPT, PVMFTimestamp& aActualNPT,
635                                              bool aSeekToSyncPoint = true, OsclAny* aContext = NULL);
636        PVMFCommandId QueryDataSourcePosition(PVMFSessionId aSessionId, PVMFTimestamp aTargetNPT,
637                                              PVMFTimestamp& aSeekPointBeforeTargetNPT, PVMFTimestamp& aSeekPointAfterTargetNPT,  OsclAny* aContext = NULL, bool aSeekToSyncPoint = true);
638
639        PVMFCommandId SetDataSourceRate(PVMFSessionId aSession, int32 aRate, PVMFTimebase* aTimebase = NULL, OsclAny* aContext = NULL);
640        PVMFCommandId SetDataSourceDirection(PVMFSessionId aSessionId, int32 aDirection, PVMFTimestamp& aActualNPT,
641                                             PVMFTimestamp& aActualMediaDataTS, PVMFTimebase* aTimebase, OsclAny* aContext);
642
643        // From PVMFTrackLevelInfoExtensionInterface
644        PVMFStatus GetAvailableTracks(Oscl_Vector<PVMFTrackInfo, OsclMemAllocator>& aTracks);
645        PVMFStatus GetTimestampForSampleNumber(PVMFTrackInfo& aTrackInfo, uint32 aSampleNum, PVMFTimestamp& aTimestamp);
646        PVMFStatus GetSampleNumberForTimestamp(PVMFTrackInfo& aTrackInfo, PVMFTimestamp aTimestamp, uint32& aSampleNum);
647        PVMFStatus GetNumberOfSyncSamples(PVMFTrackInfo& aTrackInfo, int32& aNumSyncSamples);
648        PVMFStatus GetSyncSampleInfo(PVMFTrackInfo& aTrackInfo, PVMFSampleNumTSList& aList, uint32 aStartIndex = 0, int32 aMaxEntries = -1);
649        PVMFStatus GetSyncSampleInfo(PVMFSampleNumTSList& aList, PVMFTrackInfo& aTrackInfo, int32 aTargetTimeInMS, uint32 aHowManySamples = 1);
650        PVMFStatus GetTimestampForDataPosition(PVMFTrackInfo& aTrackInfo, uint32 aDataPosition, PVMFTimestamp& aTimestamp);
651        PVMFStatus GetDataPositionForTimestamp(PVMFTrackInfo& aTrackInfo, PVMFTimestamp aTimestamp, uint32& aDataPosition);
652
653
654        // From PVMFPortActivityHandler
655        void HandlePortActivity(const PVMFPortActivity& aActivity);
656
657        // From PVMFCPMStatusObserver
658        void CPMCommandCompleted(const PVMFCmdResp& aResponse);
659
660        /* From PVMIDatastreamuserInterface */
661        void PassDatastreamFactory(PVMFDataStreamFactory& aFactory,
662                                   int32 aFactoryTag,
663                                   const PvmfMimeString* aFactoryConfig = NULL);
664        void PassDatastreamReadCapacityObserver(PVMFDataStreamReadCapacityObserver* aObserver);
665
666
667        /* From PVMFFormatProgDownloadSupportInterface */
668        int32 convertSizeToTime(uint32 fileSize, uint32& aNPTInMS);
669        void setFileSize(const uint32 aFileSize);
670        void setDownloadProgressInterface(PVMFDownloadProgressInterface*);
671        void playResumeNotification(bool aDownloadComplete);
672        void notifyDownloadComplete();
673
674        // From OsclTimer
675        void TimeoutOccurred(int32 timerID, int32 timeoutInfo);
676
677        /* From PVMFCPMPluginLicenseInterface */
678        PVMFStatus GetLicenseURL(PVMFSessionId aSessionId,
679                                 OSCL_wString& aContentName,
680                                 OSCL_wString& aLicenseURL)
681        {
682            OSCL_UNUSED_ARG(aSessionId);
683            OSCL_UNUSED_ARG(aContentName);
684            OSCL_UNUSED_ARG(aLicenseURL);
685            //must use Async method.
686            return PVMFErrNotSupported;
687        }
688        PVMFStatus GetLicenseURL(PVMFSessionId aSessionId,
689                                 OSCL_String&  aContentName,
690                                 OSCL_String&  aLicenseURL)
691        {
692            OSCL_UNUSED_ARG(aSessionId);
693            OSCL_UNUSED_ARG(aContentName);
694            OSCL_UNUSED_ARG(aLicenseURL);
695            //must use Async method.
696            return PVMFErrNotSupported;
697        }
698
699        PVMFCommandId GetLicense(PVMFSessionId aSessionId,
700                                 OSCL_wString& aContentName,
701                                 OsclAny* aData,
702                                 uint32 aDataSize,
703                                 int32 aTimeoutMsec,
704                                 OsclAny* aContextData) ;
705
706        PVMFCommandId GetLicense(PVMFSessionId aSessionId,
707                                 OSCL_String&  aContentName,
708                                 OsclAny* aData,
709                                 uint32 aDataSize,
710                                 int32 aTimeoutMsec,
711                                 OsclAny* aContextData);
712
713        PVMFCommandId CancelGetLicense(PVMFSessionId aSessionId
714                                       , PVMFCommandId aCmdId
715                                       , OsclAny* aContextData);
716
717        PVMFStatus GetLicenseStatus(
718            PVMFCPMLicenseStatus& aStatus) ;
719
720        //from PVMFMediaClockStateObserver
721        void ClockStateUpdated();
722        void NotificationsInterfaceDestroyed();
723
724    private:
725        // from OsclTimerObject
726        void Run();
727
728        //Command processing
729        PVMFCommandId QueueCommandL(PVMFMP4FFParserNodeCommand& aCmd);
730        void MoveCmdToCurrentQueue(PVMFMP4FFParserNodeCommand& aCmd);
731        void MoveCmdToCancelQueue(PVMFMP4FFParserNodeCommand& aCmd);
732        void ProcessCommand();
733        void CommandComplete(PVMFMP4FFParserNodeCmdQueue& aCmdQueue, PVMFMP4FFParserNodeCommand& aCmd, PVMFStatus aStatus, OsclAny* aData = NULL, PVUuid* aEventUUID = NULL, int32* aEventCode = NULL);
734        bool FlushPending();
735        PVMFMP4FFParserNodeCmdQueue iInputCommands;
736        PVMFMP4FFParserNodeCmdQueue iCurrentCommand;
737        PVMFMP4FFParserNodeCmdQueue iCancelCommand;
738
739        // Event reporting
740        void ReportMP4FFParserErrorEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, PVUuid* aEventUUID = NULL, int32* aEventCode = NULL);
741        void ReportMP4FFParserInfoEvent(PVMFEventType aEventType, OsclAny* aEventData = NULL, PVUuid* aEventUUID = NULL, int32* aEventCode = NULL);
742        void ChangeNodeState(TPVMFNodeInterfaceState aNewState);
743
744        // Node command handlers
745        PVMFStatus DoQueryUuid(PVMFMP4FFParserNodeCommand& aCmd);
746        PVMFStatus DoQueryInterface(PVMFMP4FFParserNodeCommand& aCmd);
747        PVMFStatus DoRequestPort(PVMFMP4FFParserNodeCommand& aCmd, PVMFPortInterface*&);
748        void GetTrackMaxParameters(PVMFFormatType aFormatType, uint32& aMaxDataSize, uint32& aMaxQueueDepth);
749        PVMFStatus DoReleasePort(PVMFMP4FFParserNodeCommand& aCmd);
750
751        PVMFStatus DoInit(PVMFMP4FFParserNodeCommand& aCmd);
752        bool ParseMP4File(PVMFMP4FFParserNodeCmdQueue& aCmdQ,
753                          PVMFMP4FFParserNodeCommand& aCmd);
754        void PushToAvailableMetadataKeysList(const char* aKeystr, char* aOptionalParam = NULL);
755        PVMFStatus InitMetaData();
756        PVMFStatus InitImotionMetaData();
757        uint32 CountImotionMetaDataKeys();
758        int32 CountMetaDataKeys();
759        void CompleteInit(PVMFMP4FFParserNodeCmdQueue& aCmdQ,
760                          PVMFMP4FFParserNodeCommand& aCmd);
761        void CompleteCancelAfterInit();
762
763
764        PVMFStatus DoPrepare(PVMFMP4FFParserNodeCommand& aCmd);
765        void CompletePrepare(PVMFStatus aStatus);
766        PVMFStatus DoStart(PVMFMP4FFParserNodeCommand& aCmd);
767        PVMFStatus DoStop(PVMFMP4FFParserNodeCommand& aCmd);
768        PVMFStatus DoFlush(PVMFMP4FFParserNodeCommand& aCmd);
769        PVMFStatus DoPause(PVMFMP4FFParserNodeCommand& aCmd);
770
771        PVMFStatus DoReset(PVMFMP4FFParserNodeCommand& aCmd);
772        void CompleteReset(PVMFMP4FFParserNodeCmdQueue& aCmdQ, PVMFMP4FFParserNodeCommand& aCmd);
773
774        PVMFStatus DoCancelAllCommands(PVMFMP4FFParserNodeCommand& aCmd);
775        PVMFStatus DoCancelCommand(PVMFMP4FFParserNodeCommand& aCmd);
776        PVMFStatus DoCancelCurrentCommand(PVMFMP4FFParserNodeCommand& aCmd);
777
778        // For metadata extention interface
779        PVMFStatus DoGetMetadataKeys(PVMFMP4FFParserNodeCommand& aCmd);
780        PVMFStatus CompleteGetMetadataKeys(PVMFMP4FFParserNodeCommand& aCmd);
781        PVMFStatus DoGetImotionMetadataValues(PVMFMP4FFParserNodeCommand& aCmd, int32 &numentriesadded);
782        PVMFStatus DoGetMetadataValues(PVMFMP4FFParserNodeCommand& aCmd);
783        void CompleteGetMetaDataValues();
784        int32 AddToValueList(Oscl_Vector<PvmiKvp, OsclMemAllocator>& aValueList, PvmiKvp& aNewValue);
785        PVMFStatus GetIndexParamValues(const char* aString, uint32& aStartIndex, uint32& aEndIndex);
786        void DeleteAPICStruct(PvmfApicStruct*& aAPICStruct);
787        PVMFStatus GetVideoFrameWidth(uint32 aId, int32& aWidth, int32& aDisplayWidth);
788        PVMFStatus GetVideoFrameHeight(uint32 aId, int32& aHeight, int32& aDisplayHeight);
789        int32 FindVideoWidth(uint32 aId);
790        int32 FindVideoHeight(uint32 aId);
791        int32 FindVideoDisplayWidth(uint32 aId);
792        int32 FindVideoDisplayHeight(uint32 aId);
793        PVMFStatus PopulateVideoDimensions(uint32 aId);
794        uint32 GetNumAudioChannels(uint32 aId);
795        uint32 GetAudioSampleRate(uint32 aId);
796        uint32 GetAudioBitsPerSample(uint32 aId);
797        PVMFStatus FindBestThumbnailKeyFrame(uint32 aId, uint32& aKeyFrameNum);
798
799        // For data source position extension interface
800        PVMFStatus DoSetDataSourcePosition(PVMFMP4FFParserNodeCommand& aCmd, PVMFStatus &aEventCode, PVUuid &aEventUuid);
801        PVMFStatus DoQueryDataSourcePosition(PVMFMP4FFParserNodeCommand& aCmd);
802        PVMFStatus DoSetDataSourceRate(PVMFMP4FFParserNodeCommand& aCmd);
803
804        PVMFStatus DoSetDataSourceDirection(PVMFMP4FFParserNodeCommand& aCmd);
805
806        void HandleTrackState();
807        bool RetrieveTrackConfigInfo(uint32 aTrackId,
808                                     PVMFFormatType aFormatType,
809                                     OsclRefCounterMemFrag &aConfig);
810        bool RetrieveTrackConfigInfoAndFirstSample(uint32 aTrackId,
811                PVMFFormatType aFormatType,
812                OsclRefCounterMemFrag &aConfig);
813        bool RetrieveTrackData(PVMP4FFNodeTrackPortInfo& aTrackPortInfo);
814        bool SendTrackData(PVMP4FFNodeTrackPortInfo& aTrackPortInfo);
815        bool GenerateAVCNALGroup(PVMP4FFNodeTrackPortInfo& aTrackPortInfo, OsclSharedPtr<PVMFMediaDataImpl>& aMediaFragGroup);
816        bool GenerateAACFrameFrags(PVMP4FFNodeTrackPortInfo& aTrackPortInfo, OsclSharedPtr<PVMFMediaDataImpl>& aMediaFragGroup);
817        bool GetAVCNALLength(OsclBinIStreamBigEndian& stream, uint32& lengthSize, int32& len);
818        bool UpdateTextSampleEntry(PVMP4FFNodeTrackPortInfo& aTrackPortInfo, uint32 aEntryIndex, PVMFTimedTextMediaData& aTextMediaData);
819        bool SendEndOfTrackCommand(PVMP4FFNodeTrackPortInfo& aTrackPortInfo);
820        bool SendBeginOfMediaStreamCommand(PVMP4FFNodeTrackPortInfo& aTrackPortInfo);
821
822        // Port processing
823        void ProcessPortActivity();
824        void QueuePortActivity(const PVMFPortActivity& aActivity);
825        PVMFStatus ProcessIncomingMsg(PVMFPortInterface* aPort);
826        PVMFStatus ProcessOutgoingMsg(PVMFPortInterface* aPort);
827        Oscl_Vector<PVMFPortActivity, OsclMemAllocator> iPortActivityQueue;
828
829        friend class PVMFMP4FFParserOutPort;
830
831        PVMFFormatType GetFormatTypeFromMIMEType(PvmfMimeString* aMIMEString);
832
833        void ResetAllTracks();
834        bool ReleaseAllPorts();
835        void RemoveAllCommands();
836        void CleanupFileSource();
837
838        // For comparison with download progress clock
839        bool checkTrackPosition(PVMP4FFNodeTrackPortInfo& aTrackPortInfo, uint32 numsamples);
840
841        bool GetTrackPortInfoForTrackID(PVMP4FFNodeTrackPortInfo*& aInfo,
842                                        uint32 aTrackID);
843
844        bool GetTrackPortInfoForPort(PVMP4FFNodeTrackPortInfo*& aInfo,
845                                     PVMFPortInterface* aPort);
846
847        OSCL_wHeapString<OsclMemAllocator> iFilename;
848        PVMFFormatType iSourceFormat;
849        PVMFMediaClock* iClientPlayBackClock;
850        PVMFMediaClockNotificationsInterface *iClockNotificationsInf;
851        bool iUseCPMPluginRegistry;
852        PVMFLocalDataSource iCPMSourceData;
853        PVMFSourceContextData iSourceContextData;
854        OsclFileHandle* iFileHandle;
855        Oscl_FileServer iFileServer;
856        uint32 iParsingMode;
857        bool iProtectedFile;
858        IMpeg4File* iMP4FileHandle;
859        Oscl_Vector<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> iAvailableMetadataKeys;
860        uint32 iMP4ParserNodeMetadataValueCount;
861        Oscl_Vector<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> iCPMMetadataKeys;
862        Oscl_Vector<PVMP4FFNodeTrackPortInfo, OsclMemAllocator> iNodeTrackPortList;
863        Oscl_Vector<PVMFTrackInfo, OsclMemAllocator> iSelectedTrackInfoList;
864        Oscl_Vector<VideoTrackDimensionInfo, OsclMemAllocator> iVideoDimensionInfoVec;
865
866        PVMFMP4FFPortIter* iPortIter;
867
868        // stream id
869        uint32 iStreamID;
870
871        PVMFNodeCapability iCapability;
872        PVLogger* iLogger;
873        PVLogger* iDataPathLogger;
874        PVLogger* iAVCDataPathLogger;
875        PVLogger* iClockLogger;
876        PVLogger* iDiagnosticsLogger;
877        // Reference counter for extension
878        uint32 iExtensionRefCount;
879
880        // variables to support download autopause
881        OsclSharedPtr<PVMFMediaClock> download_progress_clock;
882        PVMFDownloadProgressInterface* download_progress_interface;
883        uint32 iDownloadFileSize;
884        bool autopaused;
885
886        void DataStreamCommandCompleted(const PVMFCmdResp& aResponse);
887        void DataStreamInformationalEvent(const PVMFAsyncEvent& aEvent);
888        void DataStreamErrorEvent(const PVMFAsyncEvent& aEvent);
889
890        bool MapMP4ErrorCodeToEventCode(int32 aMP4ErrCode, PVUuid& aEventUUID, int32& aEventCode);
891
892        GAU iGau;
893
894        bool iThumbNailMode;
895
896        // Content Policy Manager related
897        bool iSourceContextDataValid;
898        bool iPreviewMode;
899        PVMFCPM* iCPM;
900        PVMFSessionId iCPMSessionID;
901        PVMFCPMContentType iCPMContentType;
902        PVMFCPMPluginAccessInterfaceFactory* iCPMContentAccessFactory;
903        PVMFMetadataExtensionInterface* iCPMMetaDataExtensionInterface;
904        PVMFCPMPluginLicenseInterface* iCPMLicenseInterface;
905        PVInterface* iCPMLicenseInterfacePVI;
906        PVMFCPMPluginAccessUnitDecryptionInterface* iDecryptionInterface;
907        PvmiKvp iRequestedUsage;
908        PvmiKvp iApprovedUsage;
909        PvmiKvp iAuthorizationDataKvp;
910        PVMFCPMUsageID iUsageID;
911        bool oWaitingOnLicense;
912        bool iPoorlyInterleavedContentEventSent;
913
914        PVMFCommandId iCPMInitCmdId;
915        PVMFCommandId iCPMOpenSessionCmdId;
916        PVMFCommandId iCPMRegisterContentCmdId;
917        PVMFCommandId iCPMRequestUsageId;
918        PVMFCommandId iCPMUsageCompleteCmdId;
919        PVMFCommandId iCPMCloseSessionCmdId;
920        PVMFCommandId iCPMResetCmdId;
921        PVMFCommandId iCPMGetMetaDataKeysCmdId;
922        PVMFCommandId iCPMGetMetaDataValuesCmdId;
923        PVMFCommandId iCPMGetLicenseInterfaceCmdId;
924        PVMFCommandId iCPMGetLicenseCmdId;
925        PVMFCommandId iCPMCancelGetLicenseCmdId;
926        void InitCPM();
927        void OpenCPMSession();
928        void CPMRegisterContent();
929        bool GetCPMContentAccessFactory();
930        void GetCPMContentType();
931        bool GetCPMMetaDataExtensionInterface();
932        void GetCPMLicenseInterface();
933        void RequestUsage(PVMP4FFNodeTrackOMA2DRMInfo* aInfo);
934        void SendUsageComplete();
935        void CloseCPMSession();
936        void ResetCPM();
937        void GetCPMMetaDataKeys();
938        PVMFStatus CheckCPMCommandCompleteStatus(PVMFCommandId, PVMFStatus);
939        PVMFStatus iCPMRequestUsageCommandStatus;
940
941        PVMFStatus DoGetLicense(PVMFMP4FFParserNodeCommand& aCmd,
942                                bool aWideCharVersion = false);
943        PVMFStatus DoCancelGetLicense(PVMFMP4FFParserNodeCommand& aCmd);
944        void CompleteGetLicense();
945
946        void PopulateOMA1DRMInfo();
947        /*
948         * OMA2 DRM Related Methods
949         */
950        Oscl_Vector<PVMP4FFNodeTrackOMA2DRMInfo, OsclMemAllocator> iOMA2DRMInfoVec;
951        PVMP4FFNodeTrackOMA2DRMInfo* LookUpOMA2TrackInfoForTrack(uint32 aTrackID);
952        PVMFStatus InitOMA2DRMInfo();
953        void PopulateOMA2DRMInfo(PVMP4FFNodeTrackOMA2DRMInfo* aInfo);
954        PVMFStatus CheckForOMA2AuthorizationComplete(PVMP4FFNodeTrackOMA2DRMInfo*& aInfo);
955        void OMA2TrackAuthorizationComplete();
956        bool CheckForOMA2UsageApproval();
957        void ResetOMA2Flags();
958        uint8* iOMA2DecryptionBuffer;
959
960        PVMFStatus GetFileOffsetForAutoResume(uint32& aOffset, bool aPortsAvailable = true);
961        PVMFStatus GetFileOffsetForAutoResume(uint32& aOffset, PVMP4FFNodeTrackPortInfo* aInfo);
962
963        PVMFStatus CheckForUnderFlow(PVMP4FFNodeTrackPortInfo* aInfo);
964
965        void getLanguageCode(uint16 langcode, int8 *LangCode);
966        void getBrand(uint32 langcode, char *LangCode);
967
968        PVMFStatus CheckForMP4HeaderAvailability();
969        int32 CreateErrorInfoMsg(PVMFBasicErrorInfoMessage** aErrorMsg, PVUuid aEventUUID, int32 aEventCode);
970        void CreateDurationInfoMsg(uint32 adurationms);
971        PVMFStatus PushKVPToMetadataValueList(Oscl_Vector<PvmiKvp, OsclMemAllocator>* aVecPtr, PvmiKvp& aKvpVal);
972        PVMFStatus CreateNewArray(uint32** aTrackidList, uint32 aNumTracks);
973        PVMFStatus PushValueToList(Oscl_Vector<OSCL_HeapString<OsclMemAllocator>, OsclMemAllocator> &aRefMetadataKeys,
974                                   PVMFMetadataList *&aKeyListPtr,
975                                   uint32 aLcv);
976        PVMIDataStreamSyncInterface* iDataStreamInterface;
977        PVMFDataStreamFactory* iDataStreamFactory;
978        PVMFDataStreamReadCapacityObserver* iDataStreamReadCapacityObserver;
979        PvmiDataStreamSession iDataStreamSessionID;
980        PvmiDataStreamCommandId iRequestReadCapacityNotificationID;
981        uint32 iMP4HeaderSize;
982        bool iDownloadComplete;
983        bool iProgressivelyDownlodable;
984        uint32 iLastNPTCalcInConvertSizeToTime;
985        uint32 iFileSizeLastConvertedToTime;
986        bool iFastTrackSession;
987
988        /* External PseudoStreaming related */
989        bool iExternalDownload;
990
991        bool iUnderFlowEventReported;
992        PVMFStatus ReportUnderFlow();
993        OsclTimer<OsclMemAllocator> *iUnderFlowCheckTimer;
994
995        /* bitstream logging */
996        void LogMediaData(PVMFSharedMediaDataPtr data,
997                          PVMFPortInterface* aPort);
998        bool iPortDataLog;
999        char iLogFileIndex;
1000        OSCL_HeapString<OsclMemAllocator> portLogPath;
1001
1002        uint32 minTime;
1003        uint32 avgTime;
1004        uint32 maxTime;
1005        uint32 sumTime;
1006        bool iDiagnosticsLogged;
1007        void LogDiagnostics();
1008        uint32 iTimeTakenInReadMP4File;
1009        bool iBackwardReposFlag; /* To avoid backwardlooping :: A flag to remember backward repositioning */
1010        bool iForwardReposFlag;
1011        uint32 iCurPos;
1012        bool iEOTForTextSentToMIO;
1013
1014        bool iSetTextSampleDurationZero;
1015
1016        /* To take into account if we get negative TS for text track after repositionings*/
1017        bool iTextInvalidTSAfterReposition;
1018
1019        uint32 iDelayAddToNextTextSample;
1020
1021        uint32 iCacheSize;
1022        uint32 iAsyncReadBuffSize;
1023        bool iPVLoggerEnableFlag;
1024        bool iPVLoggerStateEnableFlag;
1025        uint32 iNativeAccessMode;
1026
1027        BaseKeys_SelectionType iBaseKey;
1028        uint32 iJitterBufferDurationInMs;
1029        bool iDataStreamRequestPending;
1030        bool iCPMSequenceInProgress;
1031        bool oIsAACFramesFragmented;
1032
1033        int32 iPlayBackDirection;
1034        int32 iStartForNextTSSearch;
1035        int32 iPrevSampleTS;
1036        bool iParseAudioDuringFF;
1037        bool iParseAudioDuringREW;
1038        bool iParseVideoOnly;
1039        int32 iDataRate;
1040
1041        int32 minFileOffsetTrackID;
1042};
1043
1044
1045class PVMFMP4FFPortIter : public PVMFPortIter
1046{
1047    public:
1048        PVMFMP4FFPortIter(Oscl_Vector<PVMP4FFNodeTrackPortInfo, OsclMemAllocator>& aTrackList)
1049        {
1050            iIndex = 0;
1051            iTrackList = &aTrackList;
1052        };
1053
1054        virtual ~PVMFMP4FFPortIter() {};
1055
1056        uint16 NumPorts()
1057        {
1058            if (iTrackList->size() < 0xFFFF)
1059            {
1060                return (uint16)(iTrackList->size());
1061            }
1062            else
1063            {
1064                return 0xFFFF;
1065            }
1066        };
1067
1068        PVMFPortInterface* GetNext()
1069        {
1070            if (iIndex < iTrackList->size())
1071            {
1072                PVMFPortInterface* portiface = (*iTrackList)[iIndex].iPortInterface;
1073                ++iIndex;
1074                return portiface;
1075            }
1076            else
1077            {
1078                return NULL;
1079            }
1080        };
1081
1082        void Reset()
1083        {
1084            iIndex = 0;
1085        };
1086
1087    private:
1088        Oscl_Vector<PVMP4FFNodeTrackPortInfo, OsclMemAllocator>* iTrackList;
1089        uint32 iIndex;
1090};
1091
1092#endif // PVMF_MP4FFPARSER_NODE_H_INCLUDED
1093
1094