| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| /*********************************************************************************/ |
| /* ------------------------------------------------------------------- */ |
| /* MPEG-4 Mpeg4File Class */ |
| /* ------------------------------------------------------------------- */ |
| /*********************************************************************************/ |
| /* |
| The Mpeg4File Class is the class that will construct and maintain all the |
| mecessary data structures to be able to render a valid MP4 file to disk. |
| Format. |
| */ |
| |
| |
| #ifndef MPEG4FILE_H_INCLUDED |
| #define MPEG4FILE_H_INCLUDED |
| |
| #ifndef OSCL_FILE_IO_H_INCLUDED |
| #include "oscl_file_io.h" |
| #endif |
| #ifndef IMPEG4FILE_H_INCLUDED |
| #include "impeg4file.h" |
| #endif |
| #ifndef PARENTABLE_H_INCLUDED |
| #include "parentable.h" |
| #endif |
| #ifndef USERDATAATOM_H_INCLUDED |
| #include "userdataatom.h" |
| #endif |
| #ifndef MOVIEATOM_H_INCLUDED |
| #include "movieatom.h" |
| #endif |
| #ifndef MEDIADATAATOM_H_INCLUDED |
| #include "mediadataatom.h" |
| #endif |
| #ifndef ATOMDEFS_H_INCLUDED |
| #include "atomdefs.h" |
| #endif |
| #ifndef FILETYPEATOM_H_INCLUDED |
| #include "filetypeatom.h" |
| #endif |
| #ifndef COPYRIGHTATOM_H_INCLUDED |
| #include "copyrightatom.h" |
| #endif |
| |
| #ifndef OSCL_MEDIA_DATA_H_INCLUDED |
| #include "oscl_media_data.h" |
| #endif |
| #ifndef PV_GAU_H_INCLUDED |
| #include "pv_gau.h" |
| #endif |
| |
| #ifndef OMA2BOXES_H_INCLUDED |
| #include "oma2boxes.h" |
| #endif |
| #ifndef ATOMDEFS_H_INCLUDED |
| #include "atomdefs.h" |
| #endif |
| |
| #ifndef OSCL_UTF8CONV_H_INCLUDED |
| #include "oscl_utf8conv.h" |
| #endif |
| |
| #ifndef MOVIEFRAGMENTATOM_H_INCLUDED |
| #include "moviefragmentatom.h" |
| #endif |
| |
| #ifndef MOVIEFRAGMENTRANDOMACCESSATOM_H_INCLUDED |
| #include "moviefragmentrandomaccess.h" |
| #endif |
| |
| #ifndef MEDIA_CLOCK_CONVERTOR_H_INCLUDED |
| #include "media_clock_converter.h" |
| #endif |
| |
| #ifndef PV_ID3_PARCOM_H_INCLUDED |
| #include "pv_id3_parcom.h" |
| #endif |
| |
| #define ID3V1_STR_MAX_SIZE 64 |
| |
| class AVCSampleEntry; |
| |
| class Mpeg4File : public IMpeg4File, public Parentable |
| { |
| |
| public: |
| Mpeg4File(MP4_FF_FILE *fp, |
| OSCL_wString& filename, |
| uint32 parsingMode = 0); // Stream-in Constructor |
| virtual ~Mpeg4File(); |
| |
| int32 updateFileSize(uint32 filesize) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->updateFileSize(filesize); |
| } |
| return DEFAULT_ERROR; |
| } |
| |
| int32 getNextMediaSample(uint32 id, uint8 *buf, uint32 &size, uint32 &index, uint32 &SampleOffset) |
| { |
| if (_pmovieAtom == NULL) |
| { |
| return READ_MOVIE_ATOM_FAILED; |
| } |
| return _pmovieAtom->getNextMediaSample(id, buf, size, index, SampleOffset); |
| } |
| |
| MP4_ERROR_CODE getKeyMediaSampleNumAt(uint32 aTrackId, |
| uint32 aKeySampleNum, |
| GAU *pgau); |
| |
| uint32 getNumKeyFrames(uint32 trackid) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getNumKeyFrames(trackid); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getPrevKeyMediaSample(uint32 inputtimestamp, |
| uint32 &aKeySampleNum, |
| uint32 id, |
| uint32 *n, |
| GAU *pgau) |
| { |
| if (_pmovieAtom == NULL) |
| { |
| return READ_MOVIE_ATOM_FAILED; |
| } |
| return _pmovieAtom->getPrevKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau); |
| } |
| |
| int32 getNextKeyMediaSample(uint32 inputtimestamp, |
| uint32 &aKeySampleNum, |
| uint32 id, |
| uint32 *n, |
| GAU *pgau) |
| { |
| if (_pmovieAtom == NULL) |
| { |
| return READ_MOVIE_ATOM_FAILED; |
| } |
| return _pmovieAtom->getNextKeyMediaSample(inputtimestamp, aKeySampleNum, id, n, pgau); |
| } |
| |
| int32 getMediaSample(uint32 id, uint32 sampleNumber, uint8 *buf, int32 &size, uint32 &index, uint32 &SampleOffset) |
| { |
| if (_pmovieAtom == NULL) |
| { |
| return READ_MOVIE_ATOM_FAILED; |
| } |
| return _pmovieAtom->getMediaSample(id, sampleNumber, buf, size, index, SampleOffset); |
| } |
| |
| int32 getOffsetByTime(uint32 id, uint32 ts, int32* sampleFileOffset , uint32 jitterbuffertimeinmillisec); |
| |
| |
| uint32 getMediaTimestampForCurrentSample(uint32 id) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getTimestampForCurrentSample(id); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getTimestampForRandomAccessPoints(uint32 id, uint32 *num, uint32 *tsBuf, uint32* numBuf, uint32 *offsetBuf); |
| |
| |
| int32 getTimestampForRandomAccessPointsBeforeAfter(uint32 id, uint32 ts, uint32 *tsBuf, uint32* numBuf, |
| uint32& numsamplestoget, |
| uint32 howManyKeySamples); |
| |
| |
| //Return MPEG VOL header information |
| virtual uint8* getTrackDecoderSpecificInfoContent(uint32 id); |
| virtual uint32 getTrackDecoderSpecificInfoSize(uint32 id); |
| uint32 getTimestampForSampleNumber(uint32 id, uint32 sampleNumber) ; |
| int32 getSampleSizeAt(uint32 id, int32 sampleNum) ; |
| |
| virtual DecoderSpecificInfo* getTrackDecoderSpecificInfoAtSDI(uint32 trackID, uint32 index); |
| |
| virtual void resetPlayback(); |
| |
| uint32 repositionFromMoof(uint32 time, uint32 trackID); |
| |
| void resetAllMovieFragments(); |
| |
| |
| virtual uint32 resetPlayback(uint32 time, uint16 numTracks, uint32 *trackList, bool bResetToIFrame); |
| |
| virtual int32 queryRepositionTime(uint32 time, |
| uint16 numTracks, |
| uint32 *trackList, |
| bool bResetToIFrame, |
| bool bBeforeRequestedTime); |
| |
| virtual int32 querySyncFrameBeforeTime(uint32 time, uint16 numTracks, uint32 *trackList) |
| { |
| if (_pmovieAtom == NULL) |
| { |
| return READ_MOVIE_ATOM_FAILED; |
| } |
| return _pmovieAtom->querySyncFrameBeforeTime(time, numTracks, trackList); |
| } |
| |
| // pvmm |
| virtual OSCL_wString& getPVTitle(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wString& getPVAuthor(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wString& getPVDescription(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wString& getPVRating(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wString& getPVCopyright(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wString& getPVVersion(MP4FFParserOriginalCharEnc &charType) ; |
| virtual OSCL_wHeapString<OsclMemAllocator> getCreationDate(MP4FFParserOriginalCharEnc &charType) ; |
| |
| // from 'ftyp' atom |
| uint32 getCompatibiltyMajorBrand() |
| { |
| if (_pFileTypeAtom != NULL) |
| { |
| return _pFileTypeAtom->getMajorBrand(); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| uint32 getCompatibiltyMajorBrandVersion() |
| { |
| if (_pFileTypeAtom != NULL) |
| { |
| return _pFileTypeAtom->getMajorBrandVersion(); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| Oscl_Vector<uint32, OsclMemAllocator> *getCompatibiltyList() |
| { |
| if (_pFileTypeAtom != NULL) |
| { |
| return _pFileTypeAtom->getCompatibleBrand(); |
| } |
| else |
| { |
| return NULL; |
| } |
| } |
| |
| // From Movie |
| int32 getNumTracks() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getNumTracks(); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getTrackIDList(uint32 *ids, int size) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getTrackIDList(ids, size); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| uint32 getTrackWholeIDList(uint32 *ids) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getTrackWholeIDList(ids); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| |
| // RETRIEVAL METHODS |
| // Methods to get the sample rate (i.e. timescales) for the streams and |
| // the overall Mpeg-4 presentation |
| virtual uint64 getMovieDuration() const; |
| virtual uint64 getMovieFragmentDuration() const; |
| virtual uint32 getMovieTimescale() const; |
| |
| // From TrackHeader |
| uint64 getTrackDuration(uint32 id); |
| |
| // From TrackReference |
| uint32 trackDependsOn(uint32 id); |
| |
| // From MediaHeader |
| uint64 getTrackMediaDurationForMovie(uint32 id); |
| |
| // From MediaHeader |
| uint64 getTrackMediaDuration(uint32 id); |
| uint32 getTrackMediaTimescale(uint32 id); |
| uint16 getTrackLangCode(uint32 id); |
| |
| // From Handler |
| uint32 getTrackMediaType(uint32 id); |
| |
| // From SampleDescription |
| int32 getTrackNumSampleEntries(uint32 id); |
| |
| void getTrackMIMEType(uint32 id, OSCL_String& aMimeType); // Based on OTI value |
| |
| int32 getTrackMaxBufferSizeDB(uint32 id); |
| int32 getTrackAverageBitrate(uint32 id); |
| |
| //From PASP atom |
| uint32 getHspacing(uint32 id); |
| uint32 getVspacing(uint32 id); |
| |
| |
| |
| // MPEG4 header retrieval methods |
| int32 getFileType() const |
| { |
| return _fileType; |
| } |
| int32 getScalability() const |
| { |
| return _scalability; |
| } |
| int32 parseMFRA(); |
| |
| virtual int32 peekNextBundledAccessUnits(const uint32 trackID, |
| uint32 *n, |
| MediaMetaInfo *mInfo); |
| |
| virtual int32 getNextBundledAccessUnits(const uint32 trackID, uint32 *n, GAU *pgau); |
| MovieFragmentAtom *getMovieFragmentForTrackId(uint32 id); |
| |
| uint32 getSampleCountInTrack(uint32 id); |
| |
| |
| int16 getLayer(uint32 trackid) |
| { |
| return _pmovieAtom->getLayer(trackid); |
| } |
| uint16 getAlternateGroup(uint32 trackid) |
| { |
| return _pmovieAtom->getAlternateGroup(trackid); |
| } |
| int32 getVideoFrameHeight(uint32 trackid) |
| { |
| return _pmovieAtom->getTrackHeight(trackid); |
| } |
| |
| int32 getVideoFrameWidth(uint32 trackid) |
| { |
| return _pmovieAtom->getTrackWidth(trackid); |
| } |
| |
| int32 getTextTrackWidth(uint32 trackid) |
| { |
| return _pmovieAtom->getTextTrackWidth(trackid); |
| } |
| int32 getTextTrackHeight(uint32 trackid) |
| { |
| return _pmovieAtom->getTextTrackHeight(trackid); |
| } |
| int32 getTextTrackXOffset(uint32 trackid) |
| { |
| return _pmovieAtom->getTextTrackXOffset(trackid); |
| } |
| int32 getTextTrackYOffset(uint32 trackid) |
| { |
| return _pmovieAtom->getTextTrackYOffset(trackid); |
| } |
| |
| SampleEntry *getTextSampleEntryAt(uint32 trackid, uint32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getTextSampleEntryAt(trackid, index)); |
| } |
| else |
| { |
| return NULL; |
| } |
| } |
| |
| virtual bool IsMobileMP4(); |
| |
| OSCL_wString& convertModificationTime(uint32 time); |
| |
| //Metadata Retrieval Functions |
| |
| virtual PVMFStatus populateMetadataVectors(); |
| |
| //Title Retrieval Functions |
| virtual uint32 getNumTitle(); |
| virtual PVMFStatus getTitle(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateTitleVector(); |
| |
| //Author Retrieval Functions |
| virtual uint32 getNumAuthor(); |
| virtual PVMFStatus getAuthor(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateAuthorVector(); |
| |
| //Album Retrieval Functions |
| virtual uint32 getNumAlbum(); |
| virtual PVMFStatus getAlbum(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateAlbumVector(); |
| |
| //Artist Retrieval Functions |
| virtual uint32 getNumArtist(); |
| virtual PVMFStatus getArtist(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateArtistVector(); |
| |
| //Genre Retrieval Functions |
| virtual uint32 getNumGenre(); |
| virtual PVMFStatus getGenre(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateGenreVector(); |
| |
| //Year Retrieval Functions |
| virtual uint32 getNumYear(); |
| virtual PVMFStatus getYear(uint32 index, uint32& aVal); |
| virtual PVMFStatus populateYearVector(); |
| |
| //Copyright Retrieval Functions |
| virtual uint32 getNumCopyright(); |
| virtual PVMFStatus getCopyright(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateCopyrightVector(); |
| |
| //Comment Retrieval Functions |
| virtual uint32 getNumComment(); |
| virtual PVMFStatus getComment(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateCommentVector(); |
| |
| //Description Retrieval Functions |
| virtual uint32 getNumDescription(); |
| virtual PVMFStatus getDescription(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateDescriptionVector(); |
| |
| //Rating Retrieval Functions |
| virtual uint32 getNumRating(); |
| virtual PVMFStatus getRating(uint32 index, OSCL_wString& aVal, uint16& aLangCode, MP4FFParserOriginalCharEnc& aCharEncType); |
| virtual PVMFStatus populateRatingVector(); |
| |
| |
| uint16 getAssetInfoTitleLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoTitleLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoTitleNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoTitleNotice(charType, index)); |
| } |
| uint16 getAssetInfoDescLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoDescLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoDescNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoDescNotice(charType, index)); |
| } |
| OSCL_wString& getCopyRightString(MP4FFParserOriginalCharEnc &charType, int32 index) |
| { |
| return (_pmovieAtom->getCopyRightString(charType, index)); |
| } |
| uint16 getCopyRightLanguageCode(int32 index) |
| { |
| return (_pmovieAtom->getCopyRightLanguageCode(index)); |
| } |
| uint16 getAssetInfoPerformerLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoPerformerLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoPerformerNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoPerformerNotice(charType, index)); |
| } |
| uint16 getAssetInfoAuthorLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoAuthorLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoAuthorNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoAuthorNotice(charType, index)); |
| } |
| uint16 getAssetInfoGenreLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoGenreLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoGenreNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoGenreNotice(charType, index)); |
| } |
| uint32 getAssetInfoRatingCriteria(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoRatingCriteria(index)); |
| } |
| uint32 getAssetInfoRatingEntity(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoRatingEntity(index)); |
| } |
| uint16 getAssetInfoRatingLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoRatingLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoRatingNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoRatingNotice(charType, index)); |
| } |
| uint32 getAssetInfoClassificationEntity(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoClassificationEntity(index)); |
| } |
| uint16 getAssetInfoClassificationTable(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoClassificationTable(index)); |
| } |
| uint16 getAssetInfoClassificationLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoClassificationLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoClassificationNotice(MP4FFParserOriginalCharEnc &charType, int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoClassificationNotice(charType, index)); |
| } |
| uint16 getAssetInfoNumKeyWords(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoNumKeyWords(index)); |
| } |
| uint16 getAssetInfoKeyWordLangCode(int32 index) const |
| { |
| return (_pmovieAtom->getAssetInfoKeyWordLangCode(index)); |
| } |
| OSCL_wString& getAssetInfoKeyWord(int32 atomIndex, int32 keyWordIndex) const |
| { |
| return (_pmovieAtom->getAssetInfoKeyWord(atomIndex, keyWordIndex)); |
| } |
| |
| int32 getNumAssetInfoTitleAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoTitleAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoDescAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoDescAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumCopyRightAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumCopyRightAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoPerformerAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoPerformerAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoAuthorAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoAuthorAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoGenreAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoGenreAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoRatingAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoRatingAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoClassificationAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoClassificationAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoKeyWordAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoKeyWordAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| int32 getNumAssetInfoLocationAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoLocationAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getNumAssetInfoAlbumAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoAlbumAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getNumAssetInfoRecordingYearAtoms() |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAssetInfoRecordingYearAtoms()); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| PvmfAssetInfo3GPPLocationStruct *getAssetInfoLocationStruct(int32 index = 0) const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAssetInfoLocationStruct(index)); |
| } |
| else |
| { |
| return NULL; |
| } |
| } |
| uint16 getAssetInfoAlbumLangCode(int32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAssetInfoAlbumLangCode(index)); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| OSCL_wString& getAssetInfoAlbumNotice(MP4FFParserOriginalCharEnc &charType, int32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAssetInfoAlbumNotice(charType, index)); |
| } |
| else |
| { |
| return _emptyString; |
| } |
| } |
| uint8 getAssetInfoAlbumTrackNumber(int32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAssetInfoAlbumTrackNumber(index)); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| uint16 getAssetInfoRecordingYear(int32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAssetInfoRecordingYear(index)); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| int32 getNumAMRFramesPerSample(uint32 trackID) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAMRFramesPerSample(trackID)); |
| } |
| else |
| { |
| return 0; |
| } |
| } |
| |
| uint8 parseBufferAndGetNumAMRFrames(uint8* buffer, uint32 size); |
| |
| |
| MP4_ERROR_CODE getMaxTrackTimeStamp(uint32 trackID, |
| uint32 fileSize, |
| uint32& timeStamp) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getMaxTrackTimeStamp(trackID, |
| fileSize, |
| timeStamp)); |
| } |
| else |
| { |
| return DEFAULT_ERROR; |
| } |
| } |
| |
| MP4_ERROR_CODE getSampleNumberClosestToTimeStamp(uint32 trackID, |
| uint32 &sampleNumber, |
| uint32 timeStamp, |
| uint32 sampleOffset = 0) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return |
| (_pmovieAtom->getSampleNumberClosestToTimeStamp(trackID, |
| sampleNumber, |
| timeStamp, |
| sampleOffset)); |
| } |
| else |
| { |
| return (READ_FAILED); |
| } |
| } |
| |
| AVCSampleEntry* getAVCSampleEntry(uint32 trackID, uint32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAVCSampleEntry(trackID, index)); |
| } |
| return (NULL); |
| } |
| |
| uint32 getAVCNALLengthSize(uint32 trackID, uint32 index) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getAVCNALLengthSize(trackID, index)); |
| } |
| return 0; |
| } |
| |
| uint32 getNumAVCSampleEntries(uint32 trackID) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getNumAVCSampleEntries(trackID)); |
| } |
| return 0; |
| } |
| |
| void ResetVideoTrackPresentFlag(void) |
| { |
| _oVideoTrackPresent = false; |
| } |
| |
| uint32 getTrackLevelOMA2DRMInfoSize(uint32 trackID); |
| uint8* getTrackLevelOMA2DRMInfo(uint32 trackID); |
| |
| MP4_ERROR_CODE RequestReadCapacityNotification(PvmiDataStreamObserver& aObserver, |
| uint32 aFileOffset, |
| OsclAny* aContextData = NULL); |
| |
| MP4_ERROR_CODE CancelNotificationSync(); |
| |
| MP4_ERROR_CODE GetCurrentFileSize(uint32& aFileSize); |
| |
| int32 getTrackTSStartOffset(uint32& aTSOffset, uint32 aTrackID) |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return (_pmovieAtom->getTrackTSStartOffset(aTSOffset, aTrackID)); |
| } |
| else |
| { |
| return READ_FAILED; |
| } |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesArtist() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesArtist(); |
| |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesAlbumArtist() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesAlbumArtist(); |
| |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesTitle() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesTitle(); |
| |
| } |
| else |
| return temp; |
| |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesTrackSubTitle() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesTrackSubTitle(); |
| |
| } |
| else |
| return temp; |
| |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesAlbum() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesAlbum(); |
| } |
| else |
| return temp; |
| } |
| |
| // Gnre ** Starts ** |
| uint16 getITunesGnreID() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| if (_pmovieAtom->getITunesGnreVersion() == INTEGER_GENRE) |
| { |
| return _pmovieAtom->getITunesGnreID(); |
| } |
| else |
| return 0; |
| } |
| else |
| return 0; |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesGnreString() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| if (_pmovieAtom->getITunesGnreVersion() == STRING_GENRE) |
| { |
| return _pmovieAtom->getITunesGnreString(); |
| } |
| else |
| return temp; |
| } |
| else |
| return temp; |
| } |
| |
| //This function will tell the type of Genre-- |
| GnreVersion getITunesGnreVersion() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesGnreVersion(); |
| } |
| else |
| return INTEGER_GENRE; |
| |
| } |
| // Gnre ** Ends ** |
| |
| |
| // Returns the 4-byte YEAR when the song was recorded |
| OSCL_wHeapString<OsclMemAllocator> getITunesYear() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesYear(); |
| } |
| else |
| return temp; |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesTool() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesTool(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesEncodedBy() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesEncodedBy(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesWriter() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesWriter(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesGroupData() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesGroup(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesComment() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesComment(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesCopyright() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesCopyright(); |
| } |
| else |
| return temp; |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesDescription() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesDescription(); |
| } |
| else |
| return temp; |
| } |
| |
| uint16 getITunesThisTrackNo() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesThisTrackNo(); |
| } |
| else |
| return 0; |
| } |
| |
| uint16 getITunesTotalTracks() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesTotalTracks(); |
| } |
| else |
| return 0; |
| } |
| |
| bool IsITunesCompilationPart() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->IsITunesCompilationPart(); |
| } |
| else |
| return false; |
| } |
| |
| bool IsITunesContentRating() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->IsITunesContentRating(); |
| } |
| else |
| return false; |
| } |
| |
| uint16 getITunesBeatsPerMinute() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesBeatsPerMinute(); |
| |
| } |
| else |
| return 0; |
| } |
| |
| |
| PvmfApicStruct* getITunesImageData() const |
| { |
| if (_pmovieAtom) |
| return _pmovieAtom ->getITunesImageData(); |
| else |
| return NULL; |
| } |
| |
| uint16 getITunesThisDiskNo() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesThisDiskNo(); |
| |
| } |
| else |
| return 0; |
| } |
| |
| uint16 getITunesTotalDisks() const |
| { |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesTotalDisks(); |
| } |
| else |
| return 0; |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesNormalizationData() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesNormalizationData(); |
| |
| } |
| else |
| return temp; |
| |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesCDIdentifierData(uint8 index) |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesCDIdentifierData(index); |
| |
| } |
| else |
| return temp; |
| } |
| |
| |
| uint8 getITunesTotalCDIdentifierData() const |
| { |
| |
| if (_pmovieAtom != NULL) |
| return _pmovieAtom->getITunesTotalCDIdentifierData(); |
| else |
| return 0; |
| } |
| |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesCDTrackNumberData() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesCDTrackNumberData(); |
| |
| } |
| else |
| return temp; |
| |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesCDDB1Data() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| return _pmovieAtom->getITunesCDDB1Data(); |
| |
| } |
| else |
| return temp; |
| |
| } |
| |
| OSCL_wHeapString<OsclMemAllocator> getITunesLyrics() const |
| { |
| OSCL_wHeapString<OsclMemAllocator> temp(_STRLIT("")); |
| |
| if (_pmovieAtom != NULL) |
| { |
| |
| return _pmovieAtom->getITunesLyrics(); |
| } |
| else |
| return temp; |
| } |
| |
| // For DRM Atom. |
| bool IsTFRAPresentForTrack(uint32 TrackId, bool oVideoAudioTextTrack); |
| |
| /* |
| This function has been modified to check the entry count in TFRA for all tracks are equal. |
| The code change is under macro DISABLE_REPOS_ON_CLIPS_HAVING_UNEQUAL_TFRA_ENTRY_COUNT |
| */ |
| bool IsTFRAPresentForAllTrack(uint32 numTracks, uint32 *trackList); |
| |
| |
| bool IsMovieFragmentsPresent() const |
| { |
| return _isMovieFragmentsPresent; |
| } |
| uint32 GetByteOffsetToStartOfAudioFrames(); |
| void GetID3MetaData(PvmiKvpSharedPtrVector &id3Frames); |
| bool IsID3Frame(const OSCL_String& frameType); |
| void GetID3Frame(const OSCL_String& aFrameType, PvmiKvpSharedPtrVector& aFrame); |
| PVID3Version GetID3Version() const; |
| void parseID3Header(MP4_FF_FILE * aFile); |
| |
| uint32 getContentType(); |
| bool CreateDataStreamSessionForExternalDownload(OSCL_wString& aFilename, |
| PVMFCPMPluginAccessInterfaceFactory* aCPMAccessFactory, |
| OsclFileHandle* aHandle, |
| Oscl_FileServer* aFileServSession); |
| void DestroyDataStreamForExternalDownload(); |
| |
| |
| private: |
| void ReserveMemoryForLangCodeVector(Oscl_Vector<uint16, OsclMemAllocator> &iLangCode, int32 capacity, int32 &leavecode); |
| void ReserveMemoryForValuesVector(Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> &iValues, int32 capacity, int32 &leavecode); |
| OSCL_wHeapString<OsclMemAllocator> _emptyString; |
| UserDataAtom *_puserDataAtom; |
| FileTypeAtom *_pFileTypeAtom; |
| MovieAtom *_pmovieAtom; |
| MovieFragmentAtom *_pMovieFragmentAtom; |
| PVID3ParCom* _pID3Parser; |
| |
| Oscl_Vector<TrackAtom*, OsclMemAllocator> *_pTrackAtomVec; |
| |
| int32 _scalability; |
| int32 _fileType; |
| |
| // From DecoderConfigDescriptor |
| DecoderSpecificInfo *getTrackDecoderSpecificInfo(uint32 id); |
| |
| bool _oPVContent; |
| bool _oPVContentDownloadable; |
| |
| MP4_FF_FILE *_commonFilePtr; |
| |
| bool _isMovieFragmentsPresent; |
| uint32 _pointerMovieAtomEnd; |
| MP4_FF_FILE *_movieFragmentFilePtr; |
| Oscl_Vector<MovieFragmentAtom*, OsclMemAllocator> *_pMovieFragmentAtomVec; |
| Oscl_Vector<MovieFragmentRandomAccessAtom*, OsclMemAllocator> *_pMovieFragmentRandomAccessAtomVec; |
| MfraOffsetAtom *_pMfraOffsetAtom; |
| uint32 _ptrMoofEnds; |
| uint32 _parsing_mode; |
| uint32 _movieFragmentIdx[256]; |
| uint32 _peekMovieFragmentIdx[256]; |
| TrackDurationContainer *_pTrackDurationContainer; |
| Oscl_Vector<TrackExtendsAtom*, OsclMemAllocator> *_pTrackExtendsAtomVec; |
| Oscl_Vector<uint32, OsclMemAllocator> *_pMoofOffsetVec; |
| void populateTrackDurationVec(); |
| MP4_FF_FILE tempfptr; |
| |
| PVLogger *iLogger, *iStateVarLogger, *iParsedDataLogger; |
| bool oMfraFound; |
| bool parseMoofCompletely; |
| bool moofParsingCompleted; |
| uint32 moofType; |
| uint32 moofSize; |
| uint32 moofCount; |
| uint32 moofPtrPos; |
| uint32 currMoofNum; |
| bool _oVideoTrackPresent; |
| uint32 _movieFragmentSeqIdx[256]; |
| uint32 _peekMovieFragmentSeqIdx[256]; |
| bool isResetPlayBackCalled; |
| uint32 countOfTrunsParsed; |
| |
| //Master Title List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> titleValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iTitleLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iTitleCharType; |
| |
| //Master Author List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> authorValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iAuthorLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAuthorCharType; |
| |
| //Master Album List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> albumValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iAlbumLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iAlbumCharType; |
| |
| //Master Artist List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> artistValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iArtistLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iArtistCharType; |
| |
| //Master Genre List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> genreValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iGenreLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iGenreCharType; |
| |
| //Master Year List |
| Oscl_Vector<uint32, OsclMemAllocator> yearValues; |
| |
| //Master Copyright List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> copyrightValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iCopyrightLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCopyrightCharType; |
| |
| //Master Comment List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> commentValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iCommentLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iCommentCharType; |
| |
| //Master Description List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> descriptionValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iDescriptionLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iDescriptionCharType; |
| |
| //Master Rating List |
| Oscl_Vector<OSCL_wHeapString<OsclMemAllocator>, OsclMemAllocator> ratingValues; |
| Oscl_Vector<uint16, OsclMemAllocator> iRatingLangCode; |
| Oscl_Vector<MP4FFParserOriginalCharEnc, OsclMemAllocator> iRatingCharType; |
| |
| oscl_wchar _id3v1Title[ID3V1_STR_MAX_SIZE]; |
| oscl_wchar _id3v1Album[ID3V1_STR_MAX_SIZE]; |
| oscl_wchar _id3v1Artist[ID3V1_STR_MAX_SIZE]; |
| oscl_wchar _id3v1Comment[ID3V1_STR_MAX_SIZE]; |
| uint32 _id3v1Year; |
| uint32 _fileSize; |
| |
| }; |
| |
| #endif // MPEG4FILE_H_INCLUDED |
| |
| |
| |
