• 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 MovieAtom Class                             */
21 /*     -------------------------------------------------------------------       */
22 /*********************************************************************************/
23 /*
24     This MovieAtom Class is the main atom class in the MPEG-4 File that stores
25     all the meta data about the MPEG-4 presentation.
26 */
27 
28 
29 #ifndef MOVIEATOM_H_INCLUDED
30 #define MOVIEATOM_H_INCLUDED
31 
32 #define PV_ERROR -1
33 
34 #ifndef OSCL_FILE_IO_H_INCLUDED
35 #include "oscl_file_io.h"
36 #endif
37 
38 #ifndef ATOM_H_INCLUDED
39 #include "atom.h"
40 #endif
41 
42 #ifndef MOVIEHEADERATOM_H_INCLUDED
43 #include "movieheaderatom.h"
44 #endif
45 
46 #ifndef OBJECTDESCRIPTORATOM_H_INCLUDED
47 #include "objectdescriptoratom.h"
48 #endif
49 
50 #ifndef TRACKATOM_H_INCLUDED
51 #include "trackatom.h"
52 #endif
53 
54 #ifndef DECODERSPECIFICINFO_H_INCLUDED
55 #include "decoderspecificinfo.h"
56 #endif
57 
58 
59 #ifndef SAMPLEENTRY_H_INCLUDED
60 #include "sampleentry.h"
61 #endif
62 
63 #ifndef OSCL_MEDIA_DATA_H_INCLUDED
64 #include "oscl_media_data.h"
65 #endif
66 
67 #ifndef PV_GAU_H_INCLUDED
68 #include "pv_gau.h"
69 #endif
70 
71 #ifndef OMA2BOXES_H_INCLUDED
72 #include "oma2boxes.h"
73 #endif
74 
75 
76 #ifndef MOVIEEXTENDSATOM_HINCLUDED
77 #include "movieextendsatom.h"
78 #endif
79 
80 
81 class AVCSampleEntry;
82 /*
83 Class Movie Atom
84 */
85 class MovieAtom : public Atom
86 {
87 
88     public:
89 
90         OSCL_IMPORT_REF MovieAtom(MP4_FF_FILE *fp,
91                                   OSCL_wString& filename,
92                                   uint32 size,
93                                   uint32 type,
94                                   bool oPVContent = false,
95                                   bool oPVContentDownloadable = false,
96                                   uint32 parsingMode = 0);
97 
98         OSCL_IMPORT_REF virtual ~MovieAtom();
99 
100 
101         int32 updateFileSize(uint32 filesize);
102 
103         int32 getNextMediaSample(uint32 id, uint8 *buf, uint32 &size, uint32 &index, uint32 &SampleOffset);
104         int32 getMediaSample(uint32 sampleNumber, uint32 id, uint8 *buf, int32 &size, uint32 &index, uint32 &SampleOffset);
105 
106         MP4_ERROR_CODE getKeyMediaSampleNumAt(uint32 aTrackId,
107                                               uint32 aKeySampleNum,
108                                               GAU    *pgau);
109 
110         int32 getPrevKeyMediaSample(uint32 inputtimestamp,
111                                     uint32 &aKeySampleNum,
112                                     uint32 id,
113                                     uint32 *n,
114                                     GAU    *pgau);
115         int32 getNextKeyMediaSample(uint32 inputtimestamp,
116                                     uint32 &aKeySampleNum,
117                                     uint32 id,
118                                     uint32 *n,
119                                     GAU    *pgau);
120 
121 
122         uint32 getTimestampForCurrentSample(uint32 id);
123         int32 getOffsetByTime(uint32 id, uint32 ts, int32* sampleFileOffset);
124 
getNumKeyFrames(uint32 trackid)125         uint32 getNumKeyFrames(uint32 trackid)
126         {
127             TrackAtom *track = getTrackForID(trackid);
128 
129             if (track != NULL)
130             {
131                 return track->getNumKeyFrames();
132             }
133             else
134             {
135                 return 0;
136             }
137         }
138 
getDuration()139         uint64 getDuration()
140         {
141             if (_pmovieHeaderAtom != NULL)
142             {
143                 return _pmovieHeaderAtom->getDuration();
144             }
145             else
146                 return 0;
147         }// Get the duration of the movie
148 
149         OSCL_IMPORT_REF uint64 getMovieFragmentDuration();
150 
getCreationTime()151         uint64 getCreationTime()
152         {
153             if (_pmovieHeaderAtom != NULL)
154             {
155                 return _pmovieHeaderAtom->getCreationTime();
156             }
157             else
158             {
159                 return 0;
160             }
161         }
162 
getCreationDate()163         OSCL_wHeapString<OsclMemAllocator> getCreationDate()
164         {
165             if (_pmovieHeaderAtom != NULL)
166             {
167                 return _pmovieHeaderAtom->getCreationDate();
168             }
169             else
170             {
171                 return _emptyString;
172             }
173         }
174 
175 
getModificationTime()176         uint64 getModificationTime()
177         {
178             if (_pmovieHeaderAtom != NULL)
179             {
180                 return _pmovieHeaderAtom->getModificationTime();
181             }
182             else
183             {
184                 return 0;
185             }
186         }
187 
188         uint32 getTimeScale() const;    // Gets the timescale of the mp4 movie
189 
190         OSCL_IMPORT_REF TrackAtom *getTrackForID(uint32 id);
getScalability()191         int32 getScalability() const
192         {
193             return _scalability;
194         }
getFileType()195         OSCL_IMPORT_REF int32 getFileType() const
196         {
197             return _fileType;
198         }
199 
200         int32 getTimestampForRandomAccessPoints(uint32 id, uint32 *num, uint32 *tsBuf, uint32* numBuf, uint32* offsetBuf);
201 
202         int32 getTimestampForRandomAccessPointsBeforeAfter(uint32 id, uint32 ts, uint32 *tsBuf, uint32* numBuf,
203                 uint32& numsamplestoget,
204                 uint32 howManyKeySamples);
getNumTracks()205         int32 getNumTracks()
206         {
207             return _ptrackArray->size();
208         }
209 
210         OSCL_IMPORT_REF uint32 getTrackIDList(uint32 *ids, int size) ;
211         uint32 getTrackWholeIDList(uint32 *ids);
212 
213         // From TrackHeader
214         uint64 getTrackDuration(uint32 id);
215 
216         // From TrackReference
217         int32 trackDependsOn(uint32 id);
218 
219         // From MediaHeader
220         uint64 getTrackMediaDuration(uint32 id);
221 
222         int32 getTrackMediaTimescale(uint32 id);
223 
224         // From Handler
225         int32 getTrackStreamType(uint32 id);
226 
227         // From SampleDescription
228         OSCL_IMPORT_REF int32 getTrackNumSampleEntries(uint32 id);
229 
230         // From DecoderConfigDescriptor
231         DecoderSpecificInfo *getTrackDecoderSpecificInfo(uint32 id);
232 
233         DecoderSpecificInfo *getTrackDecoderSpecificInfoAtSDI(uint32 trackID, uint32 index);
234 
235         void getTrackMIMEType(uint32 id, OSCL_String& aMimeType);
236 
237         int32 getTrackMaxBufferSizeDB(uint32 id);
238 
239         int32  getTrackAverageBitrate(uint32 id);
240 
241         OSCL_IMPORT_REF int32 getTrackHeight(uint32 id);
242         OSCL_IMPORT_REF int32 getTrackWidth(uint32 id);
243 
244         TrackAtom *getTrackforID(uint32 id);
245 
246         void resetPlayback();
247         void resetTrackToEOT();
248 
249         uint32 resetPlayback(uint32 time, uint16 numTracks, uint32 *trackList, bool bResetToIFrame);
250 
251         int32 queryRepositionTime(uint32 time,
252                                   uint16 numTracks,
253                                   uint32 *trackList,
254                                   bool bResetToIFrame,
255                                   bool bBeforeRequestedTime);
256 
257         int32 querySyncFrameBeforeTime(uint32 time, uint16 numTracks, uint32 *trackList);
258 
259         int32 getNextBundledAccessUnits(const uint32 trackID,
260                                         uint32 *n,
261                                         GAU    *pgau);
262 
263         int32 peekNextBundledAccessUnits(const uint32 trackID,
264                                          uint32 *n,
265                                          MediaMetaInfo *mInfo);
266 
267         OSCL_IMPORT_REF uint32 getSampleCountInTrack(uint32 id);
268 
269         bool checkMMP4();
getNumAssetInfoTitleAtoms()270         int32 getNumAssetInfoTitleAtoms()
271         {
272             if (_pUserDataAtom != NULL)
273             {
274                 return (_pUserDataAtom->getNumAssetInfoTitleAtoms());
275             }
276             else
277             {
278                 return 0;
279             }
280         }
getNumAssetInfoDescAtoms()281         int32 getNumAssetInfoDescAtoms()
282         {
283             if (_pUserDataAtom != NULL)
284             {
285                 return (_pUserDataAtom->getNumAssetInfoDescAtoms());
286             }
287             else
288             {
289                 return 0;
290             }
291         }
getNumCopyRightAtoms()292         int32 getNumCopyRightAtoms()
293         {
294             if (_pUserDataAtom != NULL)
295             {
296                 return (_pUserDataAtom->getNumCopyRightAtoms());
297             }
298             else
299             {
300                 return 0;
301             }
302         }
303 
getITunesDescription()304         OSCL_wHeapString<OsclMemAllocator> getITunesDescription() const
305         {
306             OSCL_wHeapString<OsclMemAllocator> temp;
307             if (_pUserDataAtom)
308                 return _pUserDataAtom->getITunesDescription();
309             else
310                 return temp;
311         }
312 
getNumAssetInfoPerformerAtoms()313         int32 getNumAssetInfoPerformerAtoms()
314         {
315             if (_pUserDataAtom != NULL)
316             {
317                 return (_pUserDataAtom->getNumAssetInfoPerformerAtoms());
318             }
319             else
320             {
321                 return 0;
322             }
323         }
getNumAssetInfoAuthorAtoms()324         int32 getNumAssetInfoAuthorAtoms()
325         {
326             if (_pUserDataAtom != NULL)
327             {
328                 return (_pUserDataAtom->getNumAssetInfoAuthorAtoms());
329             }
330             else
331             {
332                 return 0;
333             }
334         }
getNumAssetInfoGenreAtoms()335         int32 getNumAssetInfoGenreAtoms()
336         {
337             if (_pUserDataAtom != NULL)
338             {
339                 return (_pUserDataAtom->getNumAssetInfoGenreAtoms());
340             }
341             else
342             {
343                 return 0;
344             }
345         }
getNumAssetInfoRatingAtoms()346         int32 getNumAssetInfoRatingAtoms()
347         {
348             if (_pUserDataAtom != NULL)
349             {
350                 return (_pUserDataAtom->getNumAssetInfoRatingAtoms());
351             }
352             else
353             {
354                 return 0;
355             }
356         }
getNumAssetInfoClassificationAtoms()357         int32 getNumAssetInfoClassificationAtoms()
358         {
359             if (_pUserDataAtom != NULL)
360             {
361                 return (_pUserDataAtom->getNumAssetInfoClassificationAtoms());
362             }
363             else
364             {
365                 return 0;
366             }
367         }
getNumAssetInfoKeyWordAtoms()368         int32 getNumAssetInfoKeyWordAtoms()
369         {
370             if (_pUserDataAtom != NULL)
371             {
372                 return (_pUserDataAtom->getNumAssetInfoKeyWordAtoms());
373             }
374             else
375             {
376                 return 0;
377             }
378         }
getNumAssetInfoLocationAtoms()379         int32 getNumAssetInfoLocationAtoms()
380         {
381             if (_pUserDataAtom != NULL)
382             {
383                 return (_pUserDataAtom->getNumAssetInfoLocationAtoms());
384             }
385             else
386             {
387                 return 0;
388             }
389         }
390 
getNumAssetInfoAlbumAtoms()391         int32 getNumAssetInfoAlbumAtoms()
392         {
393             if (_pUserDataAtom != NULL)
394             {
395                 return (_pUserDataAtom->getNumAssetInfoAlbumAtoms());
396             }
397             else
398             {
399                 return 0;
400             }
401         }
402 
getNumAssetInfoRecordingYearAtoms()403         int32 getNumAssetInfoRecordingYearAtoms()
404         {
405             if (_pUserDataAtom != NULL)
406             {
407                 return (_pUserDataAtom->getNumAssetInfoRecordingYearAtoms());
408             }
409             else
410             {
411                 return 0;
412             }
413         }
414 
415         uint16 getAssetInfoTitleLangCode(int32 index) ;
416         OSCL_wString& getAssetInfoTitleNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
417         uint16 getAssetInfoDescLangCode(int32 index) ;
418         OSCL_wString& getAssetInfoDescNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
419         OSCL_wString& getCopyRightString(MP4FFParserOriginalCharEnc &charType, int32 index);
420         uint16 getCopyRightLanguageCode(int32 index);
421         uint16 getAssetInfoPerformerLangCode(int32 index) ;
422         OSCL_wString& getAssetInfoPerformerNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
423         uint16 getAssetInfoAuthorLangCode(int32 index) ;
424         OSCL_wString& getAssetInfoAuthorNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
425         uint16 getAssetInfoGenreLangCode(int32 index) ;
426         OSCL_wString& getAssetInfoGenreNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
427         uint32 getAssetInfoRatingCriteria(int32 index) ;
428         uint32 getAssetInfoRatingEntity(int32 index) ;
429         uint16 getAssetInfoRatingLangCode(int32 index) ;
430         OSCL_wString& getAssetInfoRatingNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
431         uint32 getAssetInfoClassificationEntity(int32 index) ;
432         uint16 getAssetInfoClassificationTable(int32 index) ;
433         uint16 getAssetInfoClassificationLangCode(int32 index) ;
434         OSCL_wString& getAssetInfoClassificationNotice(MP4FFParserOriginalCharEnc &charType, int32 index) ;
435         uint16 getAssetInfoNumKeyWords(int32 index) ;
436         uint16 getAssetInfoKeyWordLangCode(int32 index) ;
437         OSCL_wString& getAssetInfoKeyWord(int32 atomIndex, int32 keyWordIndex) ;
438 
439         PvmfAssetInfo3GPPLocationStruct *getAssetInfoLocationStruct(int32 index) const;
440 
441         uint16 getAssetInfoAlbumLangCode(int32 index);
442         OSCL_wString& getAssetInfoAlbumNotice(MP4FFParserOriginalCharEnc &charType, int32 index);
443         uint8 getAssetInfoAlbumTrackNumber(int32 index);
444 
445         uint16 getAssetInfoRecordingYear(int32 index);
446 
447         int16 getLayer(uint32 id);
448         uint16 getAlternateGroup(uint32 id);
449         int32 getTextTrackWidth(uint32 id);
450         int32 getTextTrackHeight(uint32 id);
451         int32 getTextTrackXOffset(uint32 id);
452         int32 getTextTrackYOffset(uint32 id);
453 
454         SampleEntry *getTextSampleEntryAt(uint32 id, uint32 index);
455 
456         int32 getNumAMRFramesPerSample(uint32 trackID);
457 
458 
459         MP4_ERROR_CODE getMaxTrackTimeStamp(uint32 trackID,
460                                             uint32 fileSize,
461                                             uint32& timeStamp);
462 
463         MP4_ERROR_CODE getSampleNumberClosestToTimeStamp(uint32 trackID,
464                 uint32 &sampleNumber,
465                 uint32 timeStamp,
466                 uint32 sampleOffset = 0);
467 
468 
469         AVCSampleEntry* getAVCSampleEntry(uint32 trackID, uint32 index);
470 
471         uint32 getAVCNALLengthSize(uint32 trackID, uint32 index);
472 
473         uint32 getNumAVCSampleEntries(uint32 trackID);
474 
475         int32 getTrackTSStartOffset(uint32& aTSOffset, uint32 aTrackID);
476 
477 
478         OSCL_EXPORT_REF bool isMultipleSampleDescriptionAvailable(uint32 trackID);
479 
IsMovieFragmentPresent()480         OSCL_EXPORT_REF bool IsMovieFragmentPresent()
481         {
482             return _isMovieFragmentPresent;
483         }
484 
getTrackExtendsAtomVec()485         Oscl_Vector<TrackExtendsAtom*, OsclMemAllocator> *getTrackExtendsAtomVec()
486         {
487             if (_pMovieExtendsAtom != NULL)
488                 return _pMovieExtendsAtom->getTrackExtendsAtomVec();
489 
490             return NULL;
491         }
492 
493 
getITunesTitle()494         OSCL_wHeapString<OsclMemAllocator> getITunesTitle() const
495         {
496             OSCL_wHeapString<OsclMemAllocator> temp;
497             if (_pUserDataAtom)
498                 return _pUserDataAtom->getITunesTitle();
499             else
500                 return temp;
501         }
502 
getITunesTrackSubTitle()503         OSCL_wHeapString<OsclMemAllocator> getITunesTrackSubTitle() const
504         {
505             OSCL_wHeapString<OsclMemAllocator> temp;
506             if (_pUserDataAtom)
507                 return _pUserDataAtom->getITunesTrackSubTitle();
508             else
509                 return temp;
510         }
511 
getITunesArtist()512         OSCL_wHeapString<OsclMemAllocator> getITunesArtist() const
513         {
514             OSCL_wHeapString<OsclMemAllocator> temp;
515             if (_pUserDataAtom)
516                 return _pUserDataAtom->getITunesArtist();
517             else
518                 return temp;
519         }
520 
getITunesAlbumArtist()521         OSCL_wHeapString<OsclMemAllocator> getITunesAlbumArtist() const
522         {
523             OSCL_wHeapString<OsclMemAllocator> temp;
524             if (_pUserDataAtom)
525                 return _pUserDataAtom->getITunesAlbumArtist();
526             else
527                 return temp;
528         }
529 
530 
getITunesAlbum()531         OSCL_wHeapString<OsclMemAllocator> getITunesAlbum() const
532         {
533             OSCL_wHeapString<OsclMemAllocator> temp;
534             if (_pUserDataAtom)
535                 return _pUserDataAtom->getITunesAlbum();
536             else
537                 return temp;
538         }
539 
540         // Gnre ** Starts **
getITunesGnreID()541         uint16 getITunesGnreID() const
542         {
543             if (_pUserDataAtom)
544             {
545                 if (_pUserDataAtom->getITunesGnreVersion() == INTEGER_GENRE)
546                 {
547                     return _pUserDataAtom->getITunesGnreID();
548                 }
549                 else
550                     return 0;
551             }
552             else
553                 return 0;
554         }
555 
556 
getITunesGnreString()557         OSCL_wHeapString<OsclMemAllocator> getITunesGnreString() const
558         {
559             OSCL_wHeapString<OsclMemAllocator> temp;
560             if (_pUserDataAtom)
561             {
562                 if (_pUserDataAtom->getITunesGnreVersion() == STRING_GENRE)
563                 {
564                     return _pUserDataAtom->getITunesGnreString();
565                 }
566                 else
567                     return temp;
568             }
569             else
570                 return temp;
571         }
572 
573         //This function will tell the type of Genre--
getITunesGnreVersion()574         GnreVersion getITunesGnreVersion() const
575         {
576             if (_pUserDataAtom)
577             {
578                 return _pUserDataAtom->getITunesGnreVersion();
579             }
580             else
581                 // By-default return INTEGER_GENRE
582                 return INTEGER_GENRE;
583         }
584         // Gnre ** Ends **
585 
586 
587         // Returns the 4-byte YEAR when the song was recorded
getITunesYear()588         OSCL_wHeapString<OsclMemAllocator> getITunesYear() const
589         {
590             OSCL_wHeapString<OsclMemAllocator> temp;
591             if (_pUserDataAtom)
592                 return _pUserDataAtom->getITunesYear();
593             else
594                 return temp;
595         }
596 
597 
getITunesTool()598         OSCL_wHeapString<OsclMemAllocator> getITunesTool() const
599         {
600             OSCL_wHeapString<OsclMemAllocator> temp;
601             if (_pUserDataAtom)
602             {
603                 return _pUserDataAtom->getITunesTool();
604             }
605             else
606                 return temp;
607         }
608 
getITunesEncodedBy()609         OSCL_wHeapString<OsclMemAllocator> getITunesEncodedBy() const
610         {
611             OSCL_wHeapString<OsclMemAllocator> temp;
612             if (_pUserDataAtom)
613             {
614                 return _pUserDataAtom->getITunesEncodedBy();
615             }
616             else
617                 return temp;
618         }
619 
getITunesWriter()620         OSCL_wHeapString<OsclMemAllocator> getITunesWriter() const
621         {
622             OSCL_wHeapString<OsclMemAllocator> temp;
623             if (_pUserDataAtom)
624                 return _pUserDataAtom->getITunesWriter();
625             else
626                 return temp;
627         }
628 
getITunesGroup()629         OSCL_wHeapString<OsclMemAllocator> getITunesGroup() const
630         {
631             OSCL_wHeapString<OsclMemAllocator> temp;
632             if (_pUserDataAtom)
633                 return _pUserDataAtom->getITunesGroup();
634             else
635                 return temp;
636         }
637 
getITunesComment()638         OSCL_wHeapString<OsclMemAllocator> getITunesComment() const
639         {
640             OSCL_wHeapString<OsclMemAllocator> temp;
641             if (_pUserDataAtom)
642                 return _pUserDataAtom->getITunesComment();
643             else
644                 return temp;
645         }
646 
getITunesCopyright()647         OSCL_wHeapString<OsclMemAllocator> getITunesCopyright() const
648         {
649             OSCL_wHeapString<OsclMemAllocator> temp;
650             if (_pUserDataAtom)
651                 return _pUserDataAtom->getITunesCopyright();
652             else
653                 return temp;
654         }
655 
656 
getITunesThisTrackNo()657         uint16 getITunesThisTrackNo() const
658         {
659             if (_pUserDataAtom)
660                 return _pUserDataAtom->getITunesThisTrackNo();
661             else
662                 return 0;
663         }
664 
getITunesTotalTracks()665         uint16 getITunesTotalTracks() const
666         {
667             if (_pUserDataAtom)
668                 return _pUserDataAtom->getITunesTotalTracks();
669             else
670                 return 0;
671         }
672 
IsITunesCompilationPart()673         bool IsITunesCompilationPart() const
674         {
675             if (_pUserDataAtom)
676                 return _pUserDataAtom->IsITunesCompilationPart();
677             else
678                 return false;
679         }
680 
IsITunesContentRating()681         bool IsITunesContentRating() const
682         {
683             if (_pUserDataAtom)
684                 return _pUserDataAtom->IsITunesContentRating();
685             else
686                 return false;
687         }
688 
getITunesBeatsPerMinute()689         uint16 getITunesBeatsPerMinute() const
690         {
691             if (_pUserDataAtom)
692                 return _pUserDataAtom->getITunesBeatsPerMinute();
693             else
694                 return 0;
695         }
696 
697 
getITunesImageData()698         PvmfApicStruct* getITunesImageData() const
699         {
700             if (_pUserDataAtom)
701                 return _pUserDataAtom->getITunesImageData();
702             else
703                 return NULL;
704         }
705 
getITunesThisDiskNo()706         uint16 getITunesThisDiskNo() const
707         {
708             if (_pUserDataAtom)
709                 return _pUserDataAtom->getITunesThisDiskNo();
710             else
711                 return 0;
712         }
713 
getITunesTotalDisks()714         uint16 getITunesTotalDisks() const
715         {
716             if (_pUserDataAtom)
717                 return _pUserDataAtom->getITunesTotalDisks();
718             else
719                 return 0;
720         }
721 
722 
723 
getITunesNormalizationData()724         OSCL_wHeapString<OsclMemAllocator> getITunesNormalizationData() const
725         {
726             OSCL_wHeapString<OsclMemAllocator> temp;
727             if (_pUserDataAtom)
728                 return _pUserDataAtom->getITunesNormalizationData();
729             else
730                 return temp;
731         }
732 
getITunesCDIdentifierData(uint8 index)733         OSCL_wHeapString<OsclMemAllocator> getITunesCDIdentifierData(uint8 index) const
734         {
735             OSCL_wHeapString<OsclMemAllocator> temp;
736             if (_pUserDataAtom)
737                 return _pUserDataAtom->getITunesCDIdentifierData(index);
738             else
739                 return temp;
740         }
741 
742 
getITunesTotalCDIdentifierData()743         uint8 getITunesTotalCDIdentifierData() const
744         {
745 
746             if (_pUserDataAtom)
747                 return _pUserDataAtom->getITunesTotalCDIdentifierData();
748             else
749                 return 0;
750         }
751 
752 
getITunesCDTrackNumberData()753         OSCL_wHeapString<OsclMemAllocator> getITunesCDTrackNumberData() const
754         {
755             OSCL_wHeapString<OsclMemAllocator> temp;
756             if (_pUserDataAtom)
757                 return _pUserDataAtom->getITunesCDTrackNumberData();
758             else
759                 return temp;
760         }
761 
getITunesCDDB1Data()762         OSCL_wHeapString<OsclMemAllocator> getITunesCDDB1Data() const
763         {
764             OSCL_wHeapString<OsclMemAllocator> temp;
765             if (_pUserDataAtom)
766                 return _pUserDataAtom->getITunesCDDB1Data();
767             else
768                 return temp;
769         }
770 
getITunesLyrics()771         OSCL_wHeapString<OsclMemAllocator> getITunesLyrics() const
772         {
773             OSCL_wHeapString<OsclMemAllocator> temp;
774             if (_pUserDataAtom)
775                 return _pUserDataAtom->getITunesLyrics();
776             else
777                 return temp;
778         }
779 
780     private:
781         void addTrackAtom(TrackAtom *a);
782 
783         MovieHeaderAtom       *_pmovieHeaderAtom;
784         ObjectDescriptorAtom  *_pobjectDescriptorAtom;
785         UserDataAtom          *_pUserDataAtom;
786 
787 
788         MovieExtendsAtom      *_pMovieExtendsAtom;
789 
790         int32 _scalability;
791         int32 _fileType;
792 
793         Oscl_Vector<TrackAtom*, OsclMemAllocator> *_ptrackArray;
794 
795         bool _isMovieFragmentPresent;
796         bool _oVideoTrackPresent;
797 
798         OSCL_wHeapString<OsclMemAllocator> _emptyString;
799 
800 
801 };
802 
803 #endif // MOVIEATOM_H_INCLUDED
804 
805 
806