• 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 /*     -------------------------------------------------------------------       */
20 /*                            MPEG-4 Mpeg4File Class                             */
21 /*     -------------------------------------------------------------------       */
22 /*********************************************************************************/
23 /*
24     The Mpeg4File Class is the class that will construct and maintain all the
25     mecessary data structures to be able to render a valid MP4 file to disk.
26     Format.
27 */
28 
29 
30 #ifndef MPEG4FILE_H_INCLUDED
31 #define MPEG4FILE_H_INCLUDED
32 
33 #ifndef OSCL_FILE_IO_H_INCLUDED
34 #include "oscl_file_io.h"
35 #endif
36 #ifndef IMPEG4FILE_H_INCLUDED
37 #include "impeg4file.h"
38 #endif
39 #ifndef PARENTABLE_H_INCLUDED
40 #include "parentable.h"
41 #endif
42 #ifndef USERDATAATOM_H_INCLUDED
43 #include "userdataatom.h"
44 #endif
45 #ifndef MOVIEATOM_H_INCLUDED
46 #include "movieatom.h"
47 #endif
48 #ifndef MEDIADATAATOM_H_INCLUDED
49 #include "mediadataatom.h"
50 #endif
51 #ifndef ATOMDEFS_H_INCLUDED
52 #include "atomdefs.h"
53 #endif
54 #ifndef FILETYPEATOM_H_INCLUDED
55 #include "filetypeatom.h"
56 #endif
57 #ifndef COPYRIGHTATOM_H_INCLUDED
58 #include "copyrightatom.h"
59 #endif
60 
61 #ifndef OSCL_MEDIA_DATA_H_INCLUDED
62 #include "oscl_media_data.h"
63 #endif
64 #ifndef PV_GAU_H_INCLUDED
65 #include "pv_gau.h"
66 #endif
67 
68 #ifndef OMA2BOXES_H_INCLUDED
69 #include "oma2boxes.h"
70 #endif
71 #ifndef ATOMDEFS_H_INCLUDED
72 #include "atomdefs.h"
73 #endif
74 
75 #ifndef OSCL_UTF8CONV_H_INCLUDED
76 #include "oscl_utf8conv.h"
77 #endif
78 
79 #ifndef MOVIEFRAGMENTATOM_H_INCLUDED
80 #include "moviefragmentatom.h"
81 #endif
82 
83 #ifndef MOVIEFRAGMENTRANDOMACCESSATOM_H_INCLUDED
84 #include "moviefragmentrandomaccess.h"
85 #endif
86 
87 #ifndef MEDIA_CLOCK_CONVERTOR_H_INCLUDED
88 #include "media_clock_converter.h"
89 #endif
90 
91 #ifndef PV_ID3_PARCOM_H_INCLUDED
92 #include "pv_id3_parcom.h"
93 #endif
94 
95 #define ID3V1_STR_MAX_SIZE 64
96 
97 class AVCSampleEntry;
98 
99 class Mpeg4File : public IMpeg4File, public Parentable
100 {
101 
102     public:
103         Mpeg4File(MP4_FF_FILE *fp,
104                   OSCL_wString& filename,
105                   uint32 parsingMode = 0); // Stream-in Constructor
106         virtual ~Mpeg4File();
107 
updateFileSize(uint32 filesize)108         int32 updateFileSize(uint32 filesize)
109         {
110             if (_pmovieAtom != NULL)
111             {
112                 return _pmovieAtom->updateFileSize(filesize);
113             }
114             return DEFAULT_ERROR;
115         }
116 
getNextMediaSample(uint32 id,uint8 * buf,uint32 & size,uint32 & index,uint32 & SampleOffset)117         int32 getNextMediaSample(uint32 id, uint8 *buf, uint32 &size, uint32 &index, uint32 &SampleOffset)
118         {
119             if (_pmovieAtom == NULL)
120             {
121                 return READ_MOVIE_ATOM_FAILED;
122             }
123             return _pmovieAtom->getNextMediaSample(id,  buf, size, index, SampleOffset);
124         }
125 
126         MP4_ERROR_CODE getKeyMediaSampleNumAt(uint32 aTrackId,
127                                               uint32 aKeySampleNum,
128                                               GAU    *pgau);
129 
getNumKeyFrames(uint32 trackid)130         uint32 getNumKeyFrames(uint32 trackid)
131         {
132             if (_pmovieAtom != NULL)
133             {
134                 return _pmovieAtom->getNumKeyFrames(trackid);
135             }
136             else
137             {
138                 return 0;
139             }
140         }
141 
getPrevKeyMediaSample(uint32 inputtimestamp,uint32 & aKeySampleNum,uint32 id,uint32 * n,GAU * pgau)142         int32 getPrevKeyMediaSample(uint32 inputtimestamp,
143                                     uint32 &aKeySampleNum,
144                                     uint32 id,
145                                     uint32 *n,
146                                     GAU    *pgau)
147         {
148             if (_pmovieAtom == NULL)
149             {
150                 return READ_MOVIE_ATOM_FAILED;
151             }
152             return _pmovieAtom->getPrevKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau);
153         }
154 
getNextKeyMediaSample(uint32 inputtimestamp,uint32 & aKeySampleNum,uint32 id,uint32 * n,GAU * pgau)155         int32 getNextKeyMediaSample(uint32 inputtimestamp,
156                                     uint32 &aKeySampleNum,
157                                     uint32 id,
158                                     uint32 *n,
159                                     GAU    *pgau)
160         {
161             if (_pmovieAtom == NULL)
162             {
163                 return READ_MOVIE_ATOM_FAILED;
164             }
165             return _pmovieAtom->getNextKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau);
166         }
167 
getMediaSample(uint32 id,uint32 sampleNumber,uint8 * buf,int32 & size,uint32 & index,uint32 & SampleOffset)168         int32 getMediaSample(uint32 id, uint32 sampleNumber, uint8 *buf, int32 &size, uint32 &index, uint32 &SampleOffset)
169         {
170             if (_pmovieAtom == NULL)
171             {
172                 return READ_MOVIE_ATOM_FAILED;
173             }
174             return _pmovieAtom->getMediaSample(id, sampleNumber, buf, size, index, SampleOffset);
175         }
176 
177         int32 getOffsetByTime(uint32 id, uint32 ts, int32* sampleFileOffset , uint32 jitterbuffertimeinmillisec);
178 
179 
getMediaTimestampForCurrentSample(uint32 id)180         uint32 getMediaTimestampForCurrentSample(uint32 id)
181         {
182             if (_pmovieAtom != NULL)
183             {
184                 return _pmovieAtom->getTimestampForCurrentSample(id);
185             }
186             else
187             {
188                 return 0;
189             }
190         }
191 
192         int32 getTimestampForRandomAccessPoints(uint32 id, uint32 *num, uint32 *tsBuf, uint32* numBuf, uint32 *offsetBuf);
193 
194 
195         int32 getTimestampForRandomAccessPointsBeforeAfter(uint32 id, uint32 ts, uint32 *tsBuf, uint32* numBuf,
196                 uint32& numsamplestoget,
197                 uint32 howManyKeySamples);
198 
199 
200         //Return MPEG VOL header information
201         virtual uint8* getTrackDecoderSpecificInfoContent(uint32 id);
202         virtual uint32 getTrackDecoderSpecificInfoSize(uint32 id);
203         uint32 getTimestampForSampleNumber(uint32 id, uint32 sampleNumber) ;
204         int32 getSampleSizeAt(uint32 id, int32 sampleNum) ;
205 
206         virtual DecoderSpecificInfo* getTrackDecoderSpecificInfoAtSDI(uint32 trackID, uint32 index);
207 
208         virtual void resetPlayback();
209 
210         uint32 repositionFromMoof(uint32 time, uint32 trackID);
211 
212         void resetAllMovieFragments();
213 
214 
215         virtual uint32 resetPlayback(uint32 time, uint16 numTracks, uint32 *trackList, bool bResetToIFrame);
216 
217         virtual int32 queryRepositionTime(uint32 time,
218                                           uint16 numTracks,
219                                           uint32 *trackList,
220                                           bool bResetToIFrame,
221                                           bool bBeforeRequestedTime);
222 
querySyncFrameBeforeTime(uint32 time,uint16 numTracks,uint32 * trackList)223         virtual int32   querySyncFrameBeforeTime(uint32 time, uint16 numTracks, uint32 *trackList)
224         {
225             if (_pmovieAtom == NULL)
226             {
227                 return READ_MOVIE_ATOM_FAILED;
228             }
229             return _pmovieAtom->querySyncFrameBeforeTime(time, numTracks, trackList);
230         }
231 
232         // pvmm
233         virtual OSCL_wString& getPVTitle(MP4FFParserOriginalCharEnc &charType) ;
234         virtual OSCL_wString& getPVAuthor(MP4FFParserOriginalCharEnc &charType) ;
235         virtual OSCL_wString& getPVDescription(MP4FFParserOriginalCharEnc &charType) ;
236         virtual OSCL_wString& getPVRating(MP4FFParserOriginalCharEnc &charType) ;
237         virtual OSCL_wString& getPVCopyright(MP4FFParserOriginalCharEnc &charType) ;
238         virtual OSCL_wString& getPVVersion(MP4FFParserOriginalCharEnc &charType) ;
239         virtual OSCL_wHeapString<OsclMemAllocator> getCreationDate(MP4FFParserOriginalCharEnc &charType) ;
240 
241         // from 'ftyp' atom
getCompatibiltyMajorBrand()242         uint32 getCompatibiltyMajorBrand()
243         {
244             if (_pFileTypeAtom != NULL)
245             {
246                 return  _pFileTypeAtom->getMajorBrand();
247             }
248             else
249             {
250                 return 0;
251             }
252         }
253 
getCompatibiltyMajorBrandVersion()254         uint32 getCompatibiltyMajorBrandVersion()
255         {
256             if (_pFileTypeAtom != NULL)
257             {
258                 return _pFileTypeAtom->getMajorBrandVersion();
259             }
260             else
261             {
262                 return 0;
263             }
264         }
265 
getCompatibiltyList()266         Oscl_Vector<uint32, OsclMemAllocator> *getCompatibiltyList()
267         {
268             if (_pFileTypeAtom != NULL)
269             {
270                 return _pFileTypeAtom->getCompatibleBrand();
271             }
272             else
273             {
274                 return NULL;
275             }
276         }
277 
278         // From Movie
getNumTracks()279         int32 getNumTracks()
280         {
281             if (_pmovieAtom != NULL)
282             {
283                 return _pmovieAtom->getNumTracks();
284             }
285             else
286             {
287                 return 0;
288             }
289         }
290 
getTrackIDList(uint32 * ids,int size)291         int32 getTrackIDList(uint32 *ids, int size)
292         {
293             if (_pmovieAtom != NULL)
294             {
295                 return _pmovieAtom->getTrackIDList(ids, size);
296             }
297             else
298             {
299                 return 0;
300             }
301         }
302 
getTrackWholeIDList(uint32 * ids)303         uint32 getTrackWholeIDList(uint32 *ids)
304         {
305             if (_pmovieAtom != NULL)
306             {
307                 return _pmovieAtom->getTrackWholeIDList(ids);
308             }
309             else
310             {
311                 return 0;
312             }
313         }
314 
315 
316         // RETRIEVAL METHODS
317         // Methods to get the sample rate (i.e. timescales) for the streams and
318         // the overall Mpeg-4 presentation
319         virtual uint64 getMovieDuration() const;
320         virtual uint64 getMovieFragmentDuration() const;
321         virtual uint32 getMovieTimescale() const;
322 
323         // From TrackHeader
324         uint64 getTrackDuration(uint32 id);
325 
326         // From TrackReference
327         uint32  trackDependsOn(uint32 id);
328 
329         // From MediaHeader
330         uint64 getTrackMediaDurationForMovie(uint32 id);
331 
332         // From MediaHeader
333         uint64 getTrackMediaDuration(uint32 id);
334         uint32 getTrackMediaTimescale(uint32 id);
335         uint16 getTrackLangCode(uint32 id);
336 
337         // From Handler
338         uint32 getTrackMediaType(uint32 id);
339 
340         // From SampleDescription
341         int32 getTrackNumSampleEntries(uint32 id);
342 
343         void getTrackMIMEType(uint32 id, OSCL_String& aMimeType); // Based on OTI value
344 
345         int32 getTrackMaxBufferSizeDB(uint32 id);
346         int32 getTrackAverageBitrate(uint32 id);
347 
348         //From PASP atom
349         uint32 getHspacing(uint32 id);
350         uint32 getVspacing(uint32 id);
351 
352 
353 
354         // MPEG4 header retrieval methods
getFileType()355         int32 getFileType() const
356         {
357             return _fileType;
358         }
getScalability()359         int32 getScalability() const
360         {
361             return _scalability;
362         }
363         int32 parseMFRA();
364 
365         virtual int32 peekNextBundledAccessUnits(const uint32 trackID,
366                 uint32 *n,
367                 MediaMetaInfo *mInfo);
368 
369         virtual int32 getNextBundledAccessUnits(const uint32 trackID, uint32 *n, GAU    *pgau);
370         MovieFragmentAtom *getMovieFragmentForTrackId(uint32 id);
371 
372         uint32 getSampleCountInTrack(uint32 id);
373 
374 
getLayer(uint32 trackid)375         int16 getLayer(uint32 trackid)
376         {
377             return _pmovieAtom->getLayer(trackid);
378         }
getAlternateGroup(uint32 trackid)379         uint16 getAlternateGroup(uint32 trackid)
380         {
381             return _pmovieAtom->getAlternateGroup(trackid);
382         }
getVideoFrameHeight(uint32 trackid)383         int32 getVideoFrameHeight(uint32 trackid)
384         {
385             return _pmovieAtom->getTrackHeight(trackid);
386         }
387 
getVideoFrameWidth(uint32 trackid)388         int32 getVideoFrameWidth(uint32 trackid)
389         {
390             return _pmovieAtom->getTrackWidth(trackid);
391         }
392 
getTextTrackWidth(uint32 trackid)393         int32 getTextTrackWidth(uint32 trackid)
394         {
395             return _pmovieAtom->getTextTrackWidth(trackid);
396         }
getTextTrackHeight(uint32 trackid)397         int32 getTextTrackHeight(uint32 trackid)
398         {
399             return _pmovieAtom->getTextTrackHeight(trackid);
400         }
getTextTrackXOffset(uint32 trackid)401         int32 getTextTrackXOffset(uint32 trackid)
402         {
403             return _pmovieAtom->getTextTrackXOffset(trackid);
404         }
getTextTrackYOffset(uint32 trackid)405         int32 getTextTrackYOffset(uint32 trackid)
406         {
407             return _pmovieAtom->getTextTrackYOffset(trackid);
408         }
409 
getTextSampleEntryAt(uint32 trackid,uint32 index)410         SampleEntry *getTextSampleEntryAt(uint32 trackid, uint32 index)
411         {
412             if (_pmovieAtom != NULL)
413             {
414                 return (_pmovieAtom->getTextSampleEntryAt(trackid, index));
415             }
416             else
417             {
418                 return NULL;
419             }
420         }
421 
422         virtual bool IsMobileMP4();
423 
424         OSCL_wString& convertModificationTime(uint32 time);
425 
426 //Metadata Retrieval Functions
427 
428         virtual PVMFStatus populateMetadataVectors();
429 
430         //Title Retrieval Functions
431         virtual uint32 getNumTitle();
432         virtual PVMFStatus getTitle(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
433         virtual PVMFStatus populateTitleVector();
434 
435         //Author Retrieval Functions
436         virtual uint32 getNumAuthor();
437         virtual PVMFStatus getAuthor(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
438         virtual PVMFStatus populateAuthorVector();
439 
440         //Album Retrieval Functions
441         virtual uint32 getNumAlbum();
442         virtual PVMFStatus getAlbum(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
443         virtual PVMFStatus populateAlbumVector();
444 
445         //Artist Retrieval Functions
446         virtual uint32 getNumArtist();
447         virtual PVMFStatus getArtist(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
448         virtual PVMFStatus populateArtistVector();
449 
450         //Genre Retrieval Functions
451         virtual uint32 getNumGenre();
452         virtual PVMFStatus getGenre(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
453         virtual PVMFStatus populateGenreVector();
454 
455         //Year Retrieval Functions
456         virtual uint32 getNumYear();
457         virtual PVMFStatus getYear(uint32 index, uint32& aVal);
458         virtual PVMFStatus populateYearVector();
459 
460         //Copyright Retrieval Functions
461         virtual uint32 getNumCopyright();
462         virtual PVMFStatus getCopyright(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
463         virtual PVMFStatus populateCopyrightVector();
464 
465         //Comment Retrieval Functions
466         virtual uint32 getNumComment();
467         virtual PVMFStatus getComment(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
468         virtual PVMFStatus populateCommentVector();
469 
470         //Description Retrieval Functions
471         virtual uint32 getNumDescription();
472         virtual PVMFStatus getDescription(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
473         virtual PVMFStatus populateDescriptionVector();
474 
475         //Rating Retrieval Functions
476         virtual uint32 getNumRating();
477         virtual PVMFStatus getRating(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType);
478         virtual PVMFStatus populateRatingVector();
479 
480 
getAssetInfoTitleLangCode(int32 index)481         uint16 getAssetInfoTitleLangCode(int32 index) const
482         {
483             return (_pmovieAtom->getAssetInfoTitleLangCode(index));
484         }
getAssetInfoTitleNotice(MP4FFParserOriginalCharEnc & charType,int32 index)485         OSCL_wString& getAssetInfoTitleNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
486         {
487             return (_pmovieAtom->getAssetInfoTitleNotice(charType, index));
488         }
getAssetInfoDescLangCode(int32 index)489         uint16 getAssetInfoDescLangCode(int32 index) const
490         {
491             return (_pmovieAtom->getAssetInfoDescLangCode(index));
492         }
getAssetInfoDescNotice(MP4FFParserOriginalCharEnc & charType,int32 index)493         OSCL_wString& getAssetInfoDescNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
494         {
495             return (_pmovieAtom->getAssetInfoDescNotice(charType, index));
496         }
getCopyRightString(MP4FFParserOriginalCharEnc & charType,int32 index)497         OSCL_wString& getCopyRightString(MP4FFParserOriginalCharEnc &charType, int32 index)
498         {
499             return (_pmovieAtom->getCopyRightString(charType, index));
500         }
getCopyRightLanguageCode(int32 index)501         uint16 getCopyRightLanguageCode(int32 index)
502         {
503             return (_pmovieAtom->getCopyRightLanguageCode(index));
504         }
getAssetInfoPerformerLangCode(int32 index)505         uint16 getAssetInfoPerformerLangCode(int32 index) const
506         {
507             return (_pmovieAtom->getAssetInfoPerformerLangCode(index));
508         }
getAssetInfoPerformerNotice(MP4FFParserOriginalCharEnc & charType,int32 index)509         OSCL_wString& getAssetInfoPerformerNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
510         {
511             return (_pmovieAtom->getAssetInfoPerformerNotice(charType, index));
512         }
getAssetInfoAuthorLangCode(int32 index)513         uint16 getAssetInfoAuthorLangCode(int32 index) const
514         {
515             return (_pmovieAtom->getAssetInfoAuthorLangCode(index));
516         }
getAssetInfoAuthorNotice(MP4FFParserOriginalCharEnc & charType,int32 index)517         OSCL_wString& getAssetInfoAuthorNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
518         {
519             return (_pmovieAtom->getAssetInfoAuthorNotice(charType, index));
520         }
getAssetInfoGenreLangCode(int32 index)521         uint16 getAssetInfoGenreLangCode(int32 index) const
522         {
523             return (_pmovieAtom->getAssetInfoGenreLangCode(index));
524         }
getAssetInfoGenreNotice(MP4FFParserOriginalCharEnc & charType,int32 index)525         OSCL_wString& getAssetInfoGenreNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
526         {
527             return (_pmovieAtom->getAssetInfoGenreNotice(charType, index));
528         }
getAssetInfoRatingCriteria(int32 index)529         uint32 getAssetInfoRatingCriteria(int32 index) const
530         {
531             return (_pmovieAtom->getAssetInfoRatingCriteria(index));
532         }
getAssetInfoRatingEntity(int32 index)533         uint32 getAssetInfoRatingEntity(int32 index) const
534         {
535             return (_pmovieAtom->getAssetInfoRatingEntity(index));
536         }
getAssetInfoRatingLangCode(int32 index)537         uint16 getAssetInfoRatingLangCode(int32 index) const
538         {
539             return (_pmovieAtom->getAssetInfoRatingLangCode(index));
540         }
getAssetInfoRatingNotice(MP4FFParserOriginalCharEnc & charType,int32 index)541         OSCL_wString& getAssetInfoRatingNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
542         {
543             return (_pmovieAtom->getAssetInfoRatingNotice(charType, index));
544         }
getAssetInfoClassificationEntity(int32 index)545         uint32 getAssetInfoClassificationEntity(int32 index) const
546         {
547             return (_pmovieAtom->getAssetInfoClassificationEntity(index));
548         }
getAssetInfoClassificationTable(int32 index)549         uint16 getAssetInfoClassificationTable(int32 index) const
550         {
551             return (_pmovieAtom->getAssetInfoClassificationTable(index));
552         }
getAssetInfoClassificationLangCode(int32 index)553         uint16 getAssetInfoClassificationLangCode(int32 index) const
554         {
555             return (_pmovieAtom->getAssetInfoClassificationLangCode(index));
556         }
getAssetInfoClassificationNotice(MP4FFParserOriginalCharEnc & charType,int32 index)557         OSCL_wString& getAssetInfoClassificationNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const
558         {
559             return (_pmovieAtom->getAssetInfoClassificationNotice(charType, index));
560         }
getAssetInfoNumKeyWords(int32 index)561         uint16 getAssetInfoNumKeyWords(int32 index) const
562         {
563             return (_pmovieAtom->getAssetInfoNumKeyWords(index));
564         }
getAssetInfoKeyWordLangCode(int32 index)565         uint16 getAssetInfoKeyWordLangCode(int32 index) const
566         {
567             return (_pmovieAtom->getAssetInfoKeyWordLangCode(index));
568         }
getAssetInfoKeyWord(int32 atomIndex,int32 keyWordIndex)569         OSCL_wString& getAssetInfoKeyWord(int32 atomIndex, int32 keyWordIndex) const
570         {
571             return (_pmovieAtom->getAssetInfoKeyWord(atomIndex, keyWordIndex));
572         }
573 
getNumAssetInfoTitleAtoms()574         int32 getNumAssetInfoTitleAtoms()
575         {
576             if (_pmovieAtom != NULL)
577             {
578                 return (_pmovieAtom->getNumAssetInfoTitleAtoms());
579             }
580             else
581             {
582                 return 0;
583             }
584         }
getNumAssetInfoDescAtoms()585         int32 getNumAssetInfoDescAtoms()
586         {
587             if (_pmovieAtom != NULL)
588             {
589                 return (_pmovieAtom->getNumAssetInfoDescAtoms());
590             }
591             else
592             {
593                 return 0;
594             }
595         }
getNumCopyRightAtoms()596         int32 getNumCopyRightAtoms()
597         {
598             if (_pmovieAtom != NULL)
599             {
600                 return (_pmovieAtom->getNumCopyRightAtoms());
601             }
602             else
603             {
604                 return 0;
605             }
606         }
getNumAssetInfoPerformerAtoms()607         int32 getNumAssetInfoPerformerAtoms()
608         {
609             if (_pmovieAtom != NULL)
610             {
611                 return (_pmovieAtom->getNumAssetInfoPerformerAtoms());
612             }
613             else
614             {
615                 return 0;
616             }
617         }
getNumAssetInfoAuthorAtoms()618         int32 getNumAssetInfoAuthorAtoms()
619         {
620             if (_pmovieAtom != NULL)
621             {
622                 return (_pmovieAtom->getNumAssetInfoAuthorAtoms());
623             }
624             else
625             {
626                 return 0;
627             }
628         }
getNumAssetInfoGenreAtoms()629         int32 getNumAssetInfoGenreAtoms()
630         {
631             if (_pmovieAtom != NULL)
632             {
633                 return (_pmovieAtom->getNumAssetInfoGenreAtoms());
634             }
635             else
636             {
637                 return 0;
638             }
639         }
getNumAssetInfoRatingAtoms()640         int32 getNumAssetInfoRatingAtoms()
641         {
642             if (_pmovieAtom != NULL)
643             {
644                 return (_pmovieAtom->getNumAssetInfoRatingAtoms());
645             }
646             else
647             {
648                 return 0;
649             }
650         }
getNumAssetInfoClassificationAtoms()651         int32 getNumAssetInfoClassificationAtoms()
652         {
653             if (_pmovieAtom != NULL)
654             {
655                 return (_pmovieAtom->getNumAssetInfoClassificationAtoms());
656             }
657             else
658             {
659                 return 0;
660             }
661         }
getNumAssetInfoKeyWordAtoms()662         int32 getNumAssetInfoKeyWordAtoms()
663         {
664             if (_pmovieAtom != NULL)
665             {
666                 return (_pmovieAtom->getNumAssetInfoKeyWordAtoms());
667             }
668             else
669             {
670                 return 0;
671             }
672         }
getNumAssetInfoLocationAtoms()673         int32 getNumAssetInfoLocationAtoms()
674         {
675             if (_pmovieAtom != NULL)
676             {
677                 return (_pmovieAtom->getNumAssetInfoLocationAtoms());
678             }
679             else
680             {
681                 return 0;
682             }
683         }
684 
getNumAssetInfoAlbumAtoms()685         int32 getNumAssetInfoAlbumAtoms()
686         {
687             if (_pmovieAtom != NULL)
688             {
689                 return (_pmovieAtom->getNumAssetInfoAlbumAtoms());
690             }
691             else
692             {
693                 return 0;
694             }
695         }
696 
getNumAssetInfoRecordingYearAtoms()697         int32 getNumAssetInfoRecordingYearAtoms()
698         {
699             if (_pmovieAtom != NULL)
700             {
701                 return (_pmovieAtom->getNumAssetInfoRecordingYearAtoms());
702             }
703             else
704             {
705                 return 0;
706             }
707         }
708         PvmfAssetInfo3GPPLocationStruct *getAssetInfoLocationStruct(int32 index = 0) const
709         {
710             if (_pmovieAtom != NULL)
711             {
712                 return (_pmovieAtom->getAssetInfoLocationStruct(index));
713             }
714             else
715             {
716                 return NULL;
717             }
718         }
getAssetInfoAlbumLangCode(int32 index)719         uint16 getAssetInfoAlbumLangCode(int32 index)
720         {
721             if (_pmovieAtom != NULL)
722             {
723                 return (_pmovieAtom->getAssetInfoAlbumLangCode(index));
724             }
725             else
726             {
727                 return 0;
728             }
729         }
getAssetInfoAlbumNotice(MP4FFParserOriginalCharEnc & charType,int32 index)730         OSCL_wString& getAssetInfoAlbumNotice(MP4FFParserOriginalCharEnc &charType, int32 index)
731         {
732             if (_pmovieAtom != NULL)
733             {
734                 return (_pmovieAtom->getAssetInfoAlbumNotice(charType, index));
735             }
736             else
737             {
738                 return _emptyString;
739             }
740         }
getAssetInfoAlbumTrackNumber(int32 index)741         uint8 getAssetInfoAlbumTrackNumber(int32 index)
742         {
743             if (_pmovieAtom != NULL)
744             {
745                 return (_pmovieAtom->getAssetInfoAlbumTrackNumber(index));
746             }
747             else
748             {
749                 return 0;
750             }
751         }
getAssetInfoRecordingYear(int32 index)752         uint16 getAssetInfoRecordingYear(int32 index)
753         {
754             if (_pmovieAtom != NULL)
755             {
756                 return (_pmovieAtom->getAssetInfoRecordingYear(index));
757             }
758             else
759             {
760                 return 0;
761             }
762         }
763 
getNumAMRFramesPerSample(uint32 trackID)764         int32 getNumAMRFramesPerSample(uint32 trackID)
765         {
766             if (_pmovieAtom != NULL)
767             {
768                 return (_pmovieAtom->getNumAMRFramesPerSample(trackID));
769             }
770             else
771             {
772                 return 0;
773             }
774         }
775 
776         uint8 parseBufferAndGetNumAMRFrames(uint8* buffer, uint32 size);
777 
778 
getMaxTrackTimeStamp(uint32 trackID,uint32 fileSize,uint32 & timeStamp)779         MP4_ERROR_CODE getMaxTrackTimeStamp(uint32 trackID,
780                                             uint32 fileSize,
781                                             uint32& timeStamp)
782         {
783             if (_pmovieAtom != NULL)
784             {
785                 return (_pmovieAtom->getMaxTrackTimeStamp(trackID,
786                         fileSize,
787                         timeStamp));
788             }
789             else
790             {
791                 return DEFAULT_ERROR;
792             }
793         }
794 
795         MP4_ERROR_CODE getSampleNumberClosestToTimeStamp(uint32 trackID,
796                 uint32 &sampleNumber,
797                 uint32 timeStamp,
798                 uint32 sampleOffset = 0)
799         {
800             if (_pmovieAtom != NULL)
801             {
802                 return
803                     (_pmovieAtom->getSampleNumberClosestToTimeStamp(trackID,
804                             sampleNumber,
805                             timeStamp,
806                             sampleOffset));
807             }
808             else
809             {
810                 return (READ_FAILED);
811             }
812         }
813 
getAVCSampleEntry(uint32 trackID,uint32 index)814         AVCSampleEntry* getAVCSampleEntry(uint32 trackID, uint32 index)
815         {
816             if (_pmovieAtom != NULL)
817             {
818                 return (_pmovieAtom->getAVCSampleEntry(trackID, index));
819             }
820             return (NULL);
821         }
822 
getAVCNALLengthSize(uint32 trackID,uint32 index)823         uint32 getAVCNALLengthSize(uint32 trackID, uint32 index)
824         {
825             if (_pmovieAtom != NULL)
826             {
827                 return (_pmovieAtom->getAVCNALLengthSize(trackID, index));
828             }
829             return 0;
830         }
831 
getNumAVCSampleEntries(uint32 trackID)832         uint32 getNumAVCSampleEntries(uint32 trackID)
833         {
834             if (_pmovieAtom != NULL)
835             {
836                 return (_pmovieAtom->getNumAVCSampleEntries(trackID));
837             }
838             return 0;
839         }
840 
ResetVideoTrackPresentFlag(void)841         void ResetVideoTrackPresentFlag(void)
842         {
843             _oVideoTrackPresent = false;
844         }
845 
846         uint32 getTrackLevelOMA2DRMInfoSize(uint32 trackID);
847         uint8* getTrackLevelOMA2DRMInfo(uint32 trackID);
848 
849         MP4_ERROR_CODE RequestReadCapacityNotification(PvmiDataStreamObserver& aObserver,
850                 uint32 aFileOffset,
851                 OsclAny* aContextData = NULL);
852 
853         MP4_ERROR_CODE CancelNotificationSync();
854 
855         MP4_ERROR_CODE GetCurrentFileSize(uint32& aFileSize);
856 
getTrackTSStartOffset(uint32 & aTSOffset,uint32 aTrackID)857         int32 getTrackTSStartOffset(uint32& aTSOffset, uint32 aTrackID)
858         {
859             if (_pmovieAtom != NULL)
860             {
861                 return (_pmovieAtom->getTrackTSStartOffset(aTSOffset, aTrackID));
862             }
863             else
864             {
865                 return READ_FAILED;
866             }
867         }
868 
869 
getITunesArtist()870         OSCL_wHeapString<OsclMemAllocator> getITunesArtist() const
871         {
872             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
873             if (_pmovieAtom != NULL)
874             {
875                 return _pmovieAtom->getITunesArtist();
876 
877             }
878             else
879                 return temp;
880         }
881 
getITunesAlbumArtist()882         OSCL_wHeapString<OsclMemAllocator> getITunesAlbumArtist() const
883         {
884             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
885             if (_pmovieAtom != NULL)
886             {
887                 return _pmovieAtom->getITunesAlbumArtist();
888 
889             }
890             else
891                 return temp;
892         }
893 
getITunesTitle()894         OSCL_wHeapString<OsclMemAllocator> getITunesTitle() const
895         {
896             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
897             if (_pmovieAtom != NULL)
898             {
899                 return _pmovieAtom->getITunesTitle();
900 
901             }
902             else
903                 return temp;
904 
905         }
906 
getITunesTrackSubTitle()907         OSCL_wHeapString<OsclMemAllocator> getITunesTrackSubTitle() const
908         {
909             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
910             if (_pmovieAtom != NULL)
911             {
912                 return _pmovieAtom->getITunesTrackSubTitle();
913 
914             }
915             else
916                 return temp;
917 
918         }
919 
920 
getITunesAlbum()921         OSCL_wHeapString<OsclMemAllocator> getITunesAlbum() const
922         {
923             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
924 
925             if (_pmovieAtom != NULL)
926             {
927                 return _pmovieAtom->getITunesAlbum();
928             }
929             else
930                 return temp;
931         }
932 
933         // Gnre ** Starts **
getITunesGnreID()934         uint16 getITunesGnreID() const
935         {
936             if (_pmovieAtom != NULL)
937             {
938 
939                 if (_pmovieAtom->getITunesGnreVersion() == INTEGER_GENRE)
940                 {
941                     return _pmovieAtom->getITunesGnreID();
942                 }
943                 else
944                     return 0;
945             }
946             else
947                 return 0;
948         }
949 
950 
getITunesGnreString()951         OSCL_wHeapString<OsclMemAllocator> getITunesGnreString() const
952         {
953             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
954 
955             if (_pmovieAtom != NULL)
956             {
957 
958                 if (_pmovieAtom->getITunesGnreVersion() == STRING_GENRE)
959                 {
960                     return _pmovieAtom->getITunesGnreString();
961                 }
962                 else
963                     return temp;
964             }
965             else
966                 return temp;
967         }
968 
969         //This function will tell the type of Genre--
getITunesGnreVersion()970         GnreVersion getITunesGnreVersion() const
971         {
972             if (_pmovieAtom != NULL)
973             {
974                 return _pmovieAtom->getITunesGnreVersion();
975             }
976             else
977                 return INTEGER_GENRE;
978 
979         }
980         // Gnre ** Ends **
981 
982 
983         // Returns the 4-byte YEAR when the song was recorded
getITunesYear()984         OSCL_wHeapString<OsclMemAllocator> getITunesYear() const
985         {
986             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
987 
988             if (_pmovieAtom != NULL)
989             {
990 
991                 return _pmovieAtom->getITunesYear();
992             }
993             else
994                 return temp;
995         }
996 
997 
getITunesTool()998         OSCL_wHeapString<OsclMemAllocator> getITunesTool() const
999         {
1000             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1001 
1002             if (_pmovieAtom != NULL)
1003             {
1004 
1005                 return _pmovieAtom->getITunesTool();
1006             }
1007             else
1008                 return temp;
1009         }
1010 
getITunesEncodedBy()1011         OSCL_wHeapString<OsclMemAllocator> getITunesEncodedBy() const
1012         {
1013             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1014 
1015             if (_pmovieAtom != NULL)
1016             {
1017 
1018                 return _pmovieAtom->getITunesEncodedBy();
1019             }
1020             else
1021                 return temp;
1022         }
1023 
getITunesWriter()1024         OSCL_wHeapString<OsclMemAllocator> getITunesWriter() const
1025         {
1026             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1027 
1028             if (_pmovieAtom != NULL)
1029             {
1030 
1031                 return _pmovieAtom->getITunesWriter();
1032             }
1033             else
1034                 return temp;
1035         }
1036 
getITunesGroupData()1037         OSCL_wHeapString<OsclMemAllocator> getITunesGroupData() const
1038         {
1039             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1040 
1041             if (_pmovieAtom != NULL)
1042             {
1043 
1044                 return _pmovieAtom->getITunesGroup();
1045             }
1046             else
1047                 return temp;
1048         }
1049 
getITunesComment()1050         OSCL_wHeapString<OsclMemAllocator> getITunesComment() const
1051         {
1052             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1053 
1054             if (_pmovieAtom != NULL)
1055             {
1056 
1057                 return _pmovieAtom->getITunesComment();
1058             }
1059             else
1060                 return temp;
1061         }
1062 
getITunesCopyright()1063         OSCL_wHeapString<OsclMemAllocator> getITunesCopyright() const
1064         {
1065             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1066 
1067             if (_pmovieAtom != NULL)
1068             {
1069 
1070                 return _pmovieAtom->getITunesCopyright();
1071             }
1072             else
1073                 return temp;
1074         }
1075 
getITunesDescription()1076         OSCL_wHeapString<OsclMemAllocator> getITunesDescription() const
1077         {
1078             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1079 
1080             if (_pmovieAtom != NULL)
1081             {
1082 
1083                 return _pmovieAtom->getITunesDescription();
1084             }
1085             else
1086                 return temp;
1087         }
1088 
getITunesThisTrackNo()1089         uint16 getITunesThisTrackNo() const
1090         {
1091             if (_pmovieAtom != NULL)
1092             {
1093 
1094                 return _pmovieAtom->getITunesThisTrackNo();
1095             }
1096             else
1097                 return 0;
1098         }
1099 
getITunesTotalTracks()1100         uint16 getITunesTotalTracks() const
1101         {
1102             if (_pmovieAtom != NULL)
1103             {
1104 
1105                 return _pmovieAtom->getITunesTotalTracks();
1106             }
1107             else
1108                 return 0;
1109         }
1110 
IsITunesCompilationPart()1111         bool IsITunesCompilationPart() const
1112         {
1113             if (_pmovieAtom != NULL)
1114             {
1115 
1116                 return _pmovieAtom->IsITunesCompilationPart();
1117             }
1118             else
1119                 return false;
1120         }
1121 
IsITunesContentRating()1122         bool IsITunesContentRating() const
1123         {
1124             if (_pmovieAtom != NULL)
1125             {
1126 
1127                 return _pmovieAtom->IsITunesContentRating();
1128             }
1129             else
1130                 return false;
1131         }
1132 
getITunesBeatsPerMinute()1133         uint16 getITunesBeatsPerMinute() const
1134         {
1135             if (_pmovieAtom != NULL)
1136             {
1137                 return _pmovieAtom->getITunesBeatsPerMinute();
1138 
1139             }
1140             else
1141                 return 0;
1142         }
1143 
1144 
getITunesImageData()1145         PvmfApicStruct* getITunesImageData() const
1146         {
1147             if (_pmovieAtom)
1148                 return _pmovieAtom ->getITunesImageData();
1149             else
1150                 return NULL;
1151         }
1152 
getITunesThisDiskNo()1153         uint16 getITunesThisDiskNo() const
1154         {
1155             if (_pmovieAtom != NULL)
1156             {
1157 
1158                 return _pmovieAtom->getITunesThisDiskNo();
1159 
1160             }
1161             else
1162                 return 0;
1163         }
1164 
getITunesTotalDisks()1165         uint16 getITunesTotalDisks() const
1166         {
1167             if (_pmovieAtom != NULL)
1168             {
1169 
1170                 return _pmovieAtom->getITunesTotalDisks();
1171             }
1172             else
1173                 return 0;
1174         }
1175 
1176 
getITunesNormalizationData()1177         OSCL_wHeapString<OsclMemAllocator> getITunesNormalizationData() const
1178         {
1179             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1180 
1181             if (_pmovieAtom != NULL)
1182             {
1183                 return _pmovieAtom->getITunesNormalizationData();
1184 
1185             }
1186             else
1187                 return temp;
1188 
1189         }
1190 
getITunesCDIdentifierData(uint8 index)1191         OSCL_wHeapString<OsclMemAllocator> getITunesCDIdentifierData(uint8 index)
1192         {
1193             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1194 
1195             if (_pmovieAtom != NULL)
1196             {
1197                 return _pmovieAtom->getITunesCDIdentifierData(index);
1198 
1199             }
1200             else
1201                 return temp;
1202         }
1203 
1204 
getITunesTotalCDIdentifierData()1205         uint8 getITunesTotalCDIdentifierData() const
1206         {
1207 
1208             if (_pmovieAtom != NULL)
1209                 return _pmovieAtom->getITunesTotalCDIdentifierData();
1210             else
1211                 return 0;
1212         }
1213 
1214 
getITunesCDTrackNumberData()1215         OSCL_wHeapString<OsclMemAllocator> getITunesCDTrackNumberData() const
1216         {
1217             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1218 
1219             if (_pmovieAtom != NULL)
1220             {
1221                 return _pmovieAtom->getITunesCDTrackNumberData();
1222 
1223             }
1224             else
1225                 return temp;
1226 
1227         }
1228 
getITunesCDDB1Data()1229         OSCL_wHeapString<OsclMemAllocator> getITunesCDDB1Data() const
1230         {
1231             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1232 
1233             if (_pmovieAtom != NULL)
1234             {
1235                 return _pmovieAtom->getITunesCDDB1Data();
1236 
1237             }
1238             else
1239                 return temp;
1240 
1241         }
1242 
getITunesLyrics()1243         OSCL_wHeapString<OsclMemAllocator> getITunesLyrics() const
1244         {
1245             OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT(""));
1246 
1247             if (_pmovieAtom != NULL)
1248             {
1249 
1250                 return _pmovieAtom->getITunesLyrics();
1251             }
1252             else
1253                 return temp;
1254         }
1255 
1256         // For DRM Atom.
1257         bool IsTFRAPresentForTrack(uint32 TrackId, bool oVideoAudioTextTrack);
1258 
1259         /*
1260         This function has been modified to check the entry count in TFRA for all tracks are equal.
1261         The code change is under macro DISABLE_REPOS_ON_CLIPS_HAVING_UNEQUAL_TFRA_ENTRY_COUNT
1262         */
1263         bool IsTFRAPresentForAllTrack(uint32 numTracks, uint32 *trackList);
1264 
1265 
IsMovieFragmentsPresent()1266         bool IsMovieFragmentsPresent() const
1267         {
1268             return  _isMovieFragmentsPresent;
1269         }
1270         uint32 GetByteOffsetToStartOfAudioFrames();
1271         void GetID3MetaData(PvmiKvpSharedPtrVector &id3Frames);
1272         bool IsID3Frame(const OSCL_String& frameType);
1273         void GetID3Frame(const OSCL_String& aFrameType, PvmiKvpSharedPtrVector& aFrame);
1274         PVID3Version GetID3Version() const;
1275         void parseID3Header(MP4_FF_FILE * aFile);
1276 
1277         uint32 getContentType();
1278         bool CreateDataStreamSessionForExternalDownload(OSCL_wString& aFilename,
1279                 PVMFCPMPluginAccessInterfaceFactory* aCPMAccessFactory,
1280                 OsclFileHandle* aHandle,
1281                 Oscl_FileServer* aFileServSession);
1282         void DestroyDataStreamForExternalDownload();
1283 
1284 
1285     private:
1286         void ReserveMemoryForLangCodeVector(Oscl_Vector<uint16, OsclMemAllocator> &iLangCode, int32 capacity, int32 &leavecode);
1287         void ReserveMemoryForValuesVector(Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> &iValues, int32 capacity, int32 &leavecode);
1288         OSCL_wHeapString<OsclMemAllocator> _emptyString;
1289         UserDataAtom *_puserDataAtom;
1290         FileTypeAtom *_pFileTypeAtom;
1291         MovieAtom    *_pmovieAtom;
1292         MovieFragmentAtom *_pMovieFragmentAtom;
1293         PVID3ParCom* _pID3Parser;
1294 
1295         Oscl_Vector<TrackAtom*, OsclMemAllocator> *_pTrackAtomVec;
1296 
1297         int32 _scalability;
1298         int32 _fileType;
1299 
1300         // From DecoderConfigDescriptor
1301         DecoderSpecificInfo *getTrackDecoderSpecificInfo(uint32 id);
1302 
1303         bool _oPVContent;
1304         bool _oPVContentDownloadable;
1305 
1306         MP4_FF_FILE *_commonFilePtr;
1307 
1308         bool _isMovieFragmentsPresent;
1309         uint32 _pointerMovieAtomEnd;
1310         MP4_FF_FILE *_movieFragmentFilePtr;
1311         Oscl_Vector<MovieFragmentAtom*, OsclMemAllocator> *_pMovieFragmentAtomVec;
1312         Oscl_Vector<MovieFragmentRandomAccessAtom*, OsclMemAllocator> *_pMovieFragmentRandomAccessAtomVec;
1313         MfraOffsetAtom *_pMfraOffsetAtom;
1314         uint32 _ptrMoofEnds;
1315         uint32 _parsing_mode;
1316         uint32 _movieFragmentIdx[256];
1317         uint32 _peekMovieFragmentIdx[256];
1318         TrackDurationContainer *_pTrackDurationContainer;
1319         Oscl_Vector<TrackExtendsAtom*, OsclMemAllocator> *_pTrackExtendsAtomVec;
1320         Oscl_Vector<uint32, OsclMemAllocator> *_pMoofOffsetVec;
1321         void populateTrackDurationVec();
1322         MP4_FF_FILE tempfptr;
1323 
1324         PVLogger *iLogger, *iStateVarLogger, *iParsedDataLogger;
1325         bool oMfraFound;
1326         bool parseMoofCompletely;
1327         bool moofParsingCompleted;
1328         uint32 moofType;
1329         uint32 moofSize;
1330         uint32 moofCount;
1331         uint32 moofPtrPos;
1332         uint32 currMoofNum;
1333         bool _oVideoTrackPresent;
1334         uint32 _movieFragmentSeqIdx[256];
1335         uint32 _peekMovieFragmentSeqIdx[256];
1336         bool isResetPlayBackCalled;
1337         uint32 countOfTrunsParsed;
1338 
1339         //Master Title List
1340         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> titleValues;
1341         Oscl_Vector<uint16, OsclMemAllocator> iTitleLangCode;
1342         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iTitleCharType;
1343 
1344         //Master Author List
1345         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> authorValues;
1346         Oscl_Vector<uint16, OsclMemAllocator> iAuthorLangCode;
1347         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAuthorCharType;
1348 
1349         //Master Album List
1350         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> albumValues;
1351         Oscl_Vector<uint16, OsclMemAllocator> iAlbumLangCode;
1352         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAlbumCharType;
1353 
1354         //Master Artist List
1355         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> artistValues;
1356         Oscl_Vector<uint16, OsclMemAllocator> iArtistLangCode;
1357         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iArtistCharType;
1358 
1359         //Master Genre List
1360         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> genreValues;
1361         Oscl_Vector<uint16, OsclMemAllocator> iGenreLangCode;
1362         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iGenreCharType;
1363 
1364         //Master Year List
1365         Oscl_Vector<uint32, OsclMemAllocator> yearValues;
1366 
1367         //Master Copyright List
1368         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> copyrightValues;
1369         Oscl_Vector<uint16, OsclMemAllocator> iCopyrightLangCode;
1370         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCopyrightCharType;
1371 
1372         //Master Comment List
1373         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> commentValues;
1374         Oscl_Vector<uint16, OsclMemAllocator> iCommentLangCode;
1375         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCommentCharType;
1376 
1377         //Master Description List
1378         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> descriptionValues;
1379         Oscl_Vector<uint16, OsclMemAllocator> iDescriptionLangCode;
1380         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iDescriptionCharType;
1381 
1382         //Master Rating List
1383         Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> ratingValues;
1384         Oscl_Vector<uint16, OsclMemAllocator> iRatingLangCode;
1385         Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iRatingCharType;
1386 
1387         oscl_wchar _id3v1Title[ID3V1_STR_MAX_SIZE];
1388         oscl_wchar _id3v1Album[ID3V1_STR_MAX_SIZE];
1389         oscl_wchar _id3v1Artist[ID3V1_STR_MAX_SIZE];
1390         oscl_wchar _id3v1Comment[ID3V1_STR_MAX_SIZE];
1391         uint32 _id3v1Year;
1392         uint32 _fileSize;
1393 
1394 };
1395 
1396 #endif // MPEG4FILE_H_INCLUDED
1397 
1398 
1399 
1400