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
81class AVCSampleEntry;
82/*
83Class Movie Atom
84*/
85class 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
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
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
151        uint64 getCreationTime()
152        {
153            if (_pmovieHeaderAtom != NULL)
154            {
155                return _pmovieHeaderAtom->getCreationTime();
156            }
157            else
158            {
159                return 0;
160            }
161        }
162
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
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);
191        int32 getScalability() const
192        {
193            return _scalability;
194        }
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);
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();
270        int32 getNumAssetInfoTitleAtoms()
271        {
272            if (_pUserDataAtom != NULL)
273            {
274                return (_pUserDataAtom->getNumAssetInfoTitleAtoms());
275            }
276            else
277            {
278                return 0;
279            }
280        }
281        int32 getNumAssetInfoDescAtoms()
282        {
283            if (_pUserDataAtom != NULL)
284            {
285                return (_pUserDataAtom->getNumAssetInfoDescAtoms());
286            }
287            else
288            {
289                return 0;
290            }
291        }
292        int32 getNumCopyRightAtoms()
293        {
294            if (_pUserDataAtom != NULL)
295            {
296                return (_pUserDataAtom->getNumCopyRightAtoms());
297            }
298            else
299            {
300                return 0;
301            }
302        }
303
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
313        int32 getNumAssetInfoPerformerAtoms()
314        {
315            if (_pUserDataAtom != NULL)
316            {
317                return (_pUserDataAtom->getNumAssetInfoPerformerAtoms());
318            }
319            else
320            {
321                return 0;
322            }
323        }
324        int32 getNumAssetInfoAuthorAtoms()
325        {
326            if (_pUserDataAtom != NULL)
327            {
328                return (_pUserDataAtom->getNumAssetInfoAuthorAtoms());
329            }
330            else
331            {
332                return 0;
333            }
334        }
335        int32 getNumAssetInfoGenreAtoms()
336        {
337            if (_pUserDataAtom != NULL)
338            {
339                return (_pUserDataAtom->getNumAssetInfoGenreAtoms());
340            }
341            else
342            {
343                return 0;
344            }
345        }
346        int32 getNumAssetInfoRatingAtoms()
347        {
348            if (_pUserDataAtom != NULL)
349            {
350                return (_pUserDataAtom->getNumAssetInfoRatingAtoms());
351            }
352            else
353            {
354                return 0;
355            }
356        }
357        int32 getNumAssetInfoClassificationAtoms()
358        {
359            if (_pUserDataAtom != NULL)
360            {
361                return (_pUserDataAtom->getNumAssetInfoClassificationAtoms());
362            }
363            else
364            {
365                return 0;
366            }
367        }
368        int32 getNumAssetInfoKeyWordAtoms()
369        {
370            if (_pUserDataAtom != NULL)
371            {
372                return (_pUserDataAtom->getNumAssetInfoKeyWordAtoms());
373            }
374            else
375            {
376                return 0;
377            }
378        }
379        int32 getNumAssetInfoLocationAtoms()
380        {
381            if (_pUserDataAtom != NULL)
382            {
383                return (_pUserDataAtom->getNumAssetInfoLocationAtoms());
384            }
385            else
386            {
387                return 0;
388            }
389        }
390
391        int32 getNumAssetInfoAlbumAtoms()
392        {
393            if (_pUserDataAtom != NULL)
394            {
395                return (_pUserDataAtom->getNumAssetInfoAlbumAtoms());
396            }
397            else
398            {
399                return 0;
400            }
401        }
402
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
480        OSCL_EXPORT_REF bool IsMovieFragmentPresent()
481        {
482            return _isMovieFragmentPresent;
483        }
484
485        Oscl_Vector<TrackExtendsAtom*, OsclMemAllocator> *getTrackExtendsAtomVec()
486        {
487            if (_pMovieExtendsAtom != NULL)
488                return _pMovieExtendsAtom->getTrackExtendsAtomVec();
489
490            return NULL;
491        }
492
493
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
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
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
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
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 **
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
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--
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
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
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
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
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
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
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
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
657        uint16 getITunesThisTrackNo() const
658        {
659            if (_pUserDataAtom)
660                return _pUserDataAtom->getITunesThisTrackNo();
661            else
662                return 0;
663        }
664
665        uint16 getITunesTotalTracks() const
666        {
667            if (_pUserDataAtom)
668                return _pUserDataAtom->getITunesTotalTracks();
669            else
670                return 0;
671        }
672
673        bool IsITunesCompilationPart() const
674        {
675            if (_pUserDataAtom)
676                return _pUserDataAtom->IsITunesCompilationPart();
677            else
678                return false;
679        }
680
681        bool IsITunesContentRating() const
682        {
683            if (_pUserDataAtom)
684                return _pUserDataAtom->IsITunesContentRating();
685            else
686                return false;
687        }
688
689        uint16 getITunesBeatsPerMinute() const
690        {
691            if (_pUserDataAtom)
692                return _pUserDataAtom->getITunesBeatsPerMinute();
693            else
694                return 0;
695        }
696
697
698        PvmfApicStruct* getITunesImageData() const
699        {
700            if (_pUserDataAtom)
701                return _pUserDataAtom->getITunesImageData();
702            else
703                return NULL;
704        }
705
706        uint16 getITunesThisDiskNo() const
707        {
708            if (_pUserDataAtom)
709                return _pUserDataAtom->getITunesThisDiskNo();
710            else
711                return 0;
712        }
713
714        uint16 getITunesTotalDisks() const
715        {
716            if (_pUserDataAtom)
717                return _pUserDataAtom->getITunesTotalDisks();
718            else
719                return 0;
720        }
721
722
723
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
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
743        uint8 getITunesTotalCDIdentifierData() const
744        {
745
746            if (_pUserDataAtom)
747                return _pUserDataAtom->getITunesTotalCDIdentifierData();
748            else
749                return 0;
750        }
751
752
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
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
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