/* ------------------------------------------------------------------ * 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. * ------------------------------------------------------------------- */ /* The PVA_FF_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__ #define __Mpeg4File_H__ #include "pv_mp4ffcomposer_config.h" #include "filetypeatom.h" #include "a_impeg4file.h" #include "userdataatom.h" #include "movieatom.h" #include "mediadataatom.h" #include "a_atomdefs.h" #include "a_isucceedfail.h" #include "interleavebuffer.h" // movie fragment #include "moviefragmentatom.h" #include "moviefragmentrandomaccessatom.h" #include "assetinfoatoms.h" //HEADER FILES REQD FOR MULTIPLE SAMPLE API #include "oscl_media_data.h" #include "pv_gau.h" #ifndef OSCL_MEM_H_INCLUDED #include "oscl_mem.h" #endif #include "textsampledescinfo.h" class PVA_FF_Mpeg4File : public PVA_FF_IMpeg4File, public PVA_FF_Parentable { public: PVA_FF_Mpeg4File(int32 mediaType = FILE_TYPE_VIDEO); // Constructor virtual ~PVA_FF_Mpeg4File(); // 03/21/01 Multiple instances support, commented out moved FROM private bool init(int32 mediaType, void* osclFileServerSession = NULL, uint32 fileAuthoringFlags = PVMP4FF_3GPP_DOWNLOAD_MODE); // Member get methods PVA_FF_MovieAtom &getMutableMovieAtom() { return *_pmovieAtom; } const PVA_FF_MovieAtom &getMovieAtom() { return *_pmovieAtom; } void addMediaDataAtom(PVA_FF_MediaDataAtom* atom); Oscl_Vector& getMediaDataAtomVec() const { return *_pmediaDataAtomVec; } uint32 getSize() const { return _size; } virtual void setVersion(PVA_FF_UNICODE_STRING_PARAM version, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setTitle(PVA_FF_UNICODE_STRING_PARAM title, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setAuthor(PVA_FF_UNICODE_STRING_PARAM author, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setCopyright(PVA_FF_UNICODE_STRING_PARAM copyright, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setDescription(PVA_FF_UNICODE_STRING_PARAM description, uint16 langCode = LANGUAGE_CODE_UNKNOWN); //AssetInfo specific virtual void setPerformer(PVA_FF_UNICODE_STRING_PARAM performer, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setGenre(PVA_FF_UNICODE_STRING_PARAM genre, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setRating(PVA_FF_UNICODE_STRING_PARAM ratingInfo, uint16 langCode = LANGUAGE_CODE_UNKNOWN, uint32 ratingEntity = RATING_ENTITY_UNKNOWN, uint32 ratingCriteria = RATING_CRITERIA_UNKNOWN); virtual void setClassification(PVA_FF_UNICODE_STRING_PARAM classificationInfo, uint32 classificationEntity, uint16 classificationTable, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setKeyWord(uint8 keyWordSize, PVA_FF_UNICODE_HEAP_STRING keyWordInfo, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setLocationInfo(PvmfAssetInfo3GPPLocationStruct*); virtual void setAlbumInfo(PVA_FF_UNICODE_STRING_PARAM albumInfo, uint16 langCode = LANGUAGE_CODE_UNKNOWN); virtual void setAlbumTrackNumber(uint8 trackNumber); virtual void setRecordingYear(uint16 recordingYear); virtual void setCreationDate(PVA_FF_UNICODE_STRING_PARAM creationDate); // Methods to set the sample rate (i.e. timescales) for the streams and // the overall Mpeg-4 presentation virtual void setPresentationTimescale(uint32 timescale); virtual int32 getFileType() const { return _fileType; } // MPEG4 header retrieval methods virtual void setDecoderSpecificInfo(uint8 * header, int32 size, int32 trackID); // MPEG4 header retrieval methods for timed text virtual void setTextDecoderSpecificInfo(PVA_FF_TextSampleDescInfo *header, int32 trackID); // Render to file with filename virtual bool renderToFile(PVA_FF_UNICODE_STRING_PARAM filename); // Rendering the PVA_FF_Mpeg4File in proper format (bitlengths, etc.) to an ostream virtual bool renderToFileStream(MP4_AUTHOR_FF_FILE_IO_WRAP *fp); // An access function to set the postfix string for PVA_FF_MediaDataAtom objects virtual void SetTempFilePostFix(PVA_FF_UNICODE_STRING_PARAM postFix); virtual void setMajorBrand(uint32 brand) { if (_pFileTypeAtom != NULL) { _pFileTypeAtom->setMajorBrand(brand); } } // 16.16 NOTATATION AND THE VERSION OF WMF SPEC is 1.1, hence the default // value 0x00010001 virtual void setMajorBrandVersion(uint32 version = 0x10001) { if (_pFileTypeAtom != NULL) { _pFileTypeAtom->setMajorBrandVersion(version); } } virtual void addCompatibleBrand(uint32 brand) { if (_pFileTypeAtom != NULL) { _pFileTypeAtom->addCompatibleBrand(brand); } } virtual void setVideoParams(uint32 trackID, float frate, uint16 interval, uint32 frame_width, uint32 frame_height); virtual void setAudioEncodeParams(uint32 trackId, PVMP4FFComposerAudioEncodeParams &audioParams); virtual void setH263ProfileLevel(uint32 trackID, uint8 profile, uint8 level); uint32 addTrack(int32 mediaType, int32 codecType, bool oDirectRender = false, uint8 profile = 1, uint8 profileComp = 0xFF, uint8 level = 0xFF); bool addSampleToTrack(uint32 trackID, Oscl_Vector & fragmentList, uint32 ts, uint8 flags); //special API for Timed text bool addTextSampleToTrack(uint32 trackID, Oscl_Vector & fragmentList, uint32 ts, uint8 flags, int32 index, uint8* Textsamplemodifier); void addTrackReference(uint32 currtrackID, int32 reftrackID); void setTargetBitrate(uint32 trackID, uint32 avgBitRate, uint32 maxBitRate = 0, uint32 bufferSizeDB = 0); void setTimeScale(uint32 trackID, uint32 rate); // An access function to set the output path string for PVA_FF_MediaDataAtom objects virtual void SetTempOutputPath(PVA_FF_UNICODE_STRING_PARAM outputPath); PVA_FF_MediaDataAtom* getMediaDataAtomForTrack(uint32 trackID); void setMaxBufferSizeDB(uint32 trackID, uint32 max) { _pmovieAtom->setMaxBufferSizeDB(trackID, max); } bool addMultipleAccessUnitsToTrack(uint32 trackID, GAU *pgau); bool renderTruncatedFile(PVA_FF_UNICODE_STRING_PARAM filename); uint32 convertCreationTime(PVA_FF_UNICODE_STRING_PARAM creationDate); bool checkInterLeaveDuration(uint32 trackID, uint32 ts); bool flushInterLeaveBuffer(uint32 trackID); bool getTargetFileSize(uint32 &metaDataSize, uint32 &mediaDataSize); bool prepareToEncode(); void populateUserDataAtom(); virtual bool setInterLeaveInterval(int32 interval) { if (interval > 0) { _interLeaveDuration = (uint32)interval; return true; } return false; } bool addMediaSampleInterleave(uint32 trackID, Oscl_Vector & fragmentList, uint32 size, uint32 ts, uint8 flags); bool addTextMediaSampleInterleave(uint32 trackID, Oscl_Vector & fragmentList, uint32 size, uint32 ts, uint8 flags, int32 index); //interleave buffer vector functions void addInterLeaveBuffer(PVA_FF_InterLeaveBuffer *pInterLeaveBuffer); PVA_FF_InterLeaveBuffer* getInterLeaveBuffer(uint32 trackID); bool setOutputFileName(PVA_FF_UNICODE_STRING_PARAM outputFileName); bool setOutputFileHandle(MP4_AUTHOR_FF_FILE_HANDLE outputFileHandle); bool reAuthorFirstSampleInTrack(uint32 trackID, uint8 *psample, uint32 size); void setLanguage(uint32 language) { if (_pmovieAtom != NULL) _pmovieAtom->setLanguage(language); } void SetCacheSize(uint32 aCacheSize); // movie fragment : set duration of MOOF void setMovieFragmentDuration(uint32 duration); uint32 getMovieFragmentDuration(); bool renderMoovAtom(); bool renderMovieFragments(); private: PVA_FF_UNICODE_HEAP_STRING _title; bool _oSetTitleDone; PVA_FF_UNICODE_HEAP_STRING _author; bool _oSetAuthorDone; PVA_FF_UNICODE_HEAP_STRING _copyright; bool _oSetCopyrightDone; PVA_FF_UNICODE_HEAP_STRING _description; bool _oSetDescriptionDone; PVA_FF_UNICODE_HEAP_STRING _performer; bool _oSetPerformerDone; PVA_FF_UNICODE_HEAP_STRING _genre; bool _oSetGenreDone; PVA_FF_UNICODE_HEAP_STRING _ratingInfo; uint32 _ratingEntity; uint32 _ratingCriteria; bool _oSetRatingDone; PVA_FF_UNICODE_HEAP_STRING _classificationInfo; uint32 _classificationEntity; uint32 _classificationTable; bool _oSetClassificationDone; PVA_FF_UNICODE_HEAP_STRING _keyWordInfo; uint8 _keyWordSize; PVA_FF_UNICODE_HEAP_STRING _locationName; PVA_FF_UNICODE_HEAP_STRING _locationInfoAstrBody; PVA_FF_UNICODE_HEAP_STRING _locationInfoAddNotes; uint8 _locationInfoRole; uint32 _locationInfoLongitude; uint32 _locationInfoLatitude; uint32 _locationInfoAltitude; bool _oSetLocationInfoDone; PVA_FF_UNICODE_HEAP_STRING _albumInfo; bool _oSetAlbumDone; uint16 _recordingYear; bool _oSetRecordingYearDone; PVA_FF_UNICODE_HEAP_STRING _creationDate; bool _oSetCreationDateDone; virtual void recomputeSize(); PVA_FF_UserDataAtom *_puserDataAtom; PVA_FF_FileTypeAtom *_pFileTypeAtom; PVA_FF_MovieAtom *_pmovieAtom; Oscl_Vector *_pmediaDataAtomVec; // In movie fragment mode these parameters hold // the current MOOF and MDAT to add samples. They are destroyed once // they are written to file PVA_FF_MovieFragmentAtom *_pCurrentMoofAtom; PVA_FF_MediaDataAtom *_pCurrentMediaDataAtom; // This media data atom holds MDAT for movie fragments only // Movie Fragment random access atom in case of movie fragments PVA_FF_MovieFragmentRandomAccessAtom *_pMfraAtom; // Movie Fragment mode parameters bool _oMovieFragmentEnabled; bool _oComposeMoofAtom; // flag when true, samples are added in MOOF uint32 _currentMoofOffset; // contains the offset of current MOOF before MDAT, // actual offset is current offset + size of MDAT for this MOOF uint32 _movieFragmentDuration; // always in milliseconds : decides total sample length in MOOF and MOOV bool _oTrunStart; // true when new TRUN is to be added in MOOF from interleave buffer // made true for 1st sample of interleave buffer uint32 _sequenceNumber; // keep track of number of movie fragments added // interleave buffers and vectors Oscl_Vector *_pInterLeaveBufferVec; uint32 _size; bool _modifiable; int32 _scalability; int32 _fileType; bool _firstFrameInLayer0; bool _firstFrameInLayer1; // Postfix string to handle multiple instances of the output filter, // the temporary file names will be different for every instances PVA_FF_UNICODE_HEAP_STRING _tempFilePostfix; bool _downLoadOnly; int32 _codecType; // an output path for generated temporary files (.mdat) PVA_FF_UNICODE_HEAP_STRING _tempOutputPath; bool _fileWriteFailed; bool _oFileRenderCalled; bool _oUserDataPopulated; bool _oFtypPopulated; bool _o3GPPTrack; bool _oWMFTrack; bool _oMPEGTrack; bool _oPVMMTrack; uint32 _fileAuthoringFlags; bool _oInterLeaveEnabled; bool _oMovieAtomUpfront; uint32 _interLeaveDuration; // Always in milliseconds bool _oAuthorASSETINFOAtoms; uint32 _baseOffset; bool _oChunkStart; uint16 _nextAvailableODID; int32 _tempFileIndex; void *_aFs; PVA_FF_UNICODE_HEAP_STRING _targetFileName; MP4_AUTHOR_FF_FILE_HANDLE _targetFileHandle; bool _oPartialTempFileRemoval; bool _oDirectRenderEnabled; uint32 _initialUserDataSize; uint32 _directRenderFileOffset; PVA_FF_UNICODE_HEAP_STRING _outputFileName; MP4_AUTHOR_FF_FILE_HANDLE _outputFileHandle; bool _outputFileNameSet; bool _totalTempFileRemoval; bool _oUserDataUpFront; bool _oFileOpenedOutsideAFFLib; bool _oFirstSampleEditMode; uint32 iCacheSize; bool _oIsFileOpen; }; #endif