Mercurial > audlegacy
diff Plugins/Input/aac/libmp4v2/mp4file.h @ 61:fa848bd484d8 trunk
[svn] Move plugins to Plugins/
author | nenolod |
---|---|
date | Fri, 28 Oct 2005 22:58:11 -0700 |
parents | |
children | 0a2ad94e8607 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Plugins/Input/aac/libmp4v2/mp4file.h Fri Oct 28 22:58:11 2005 -0700 @@ -0,0 +1,841 @@ +/* + * The contents of this file are subject to the Mozilla Public + * License Version 1.1 (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.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is MPEG4IP. + * + * The Initial Developer of the Original Code is Cisco Systems Inc. + * Portions created by Cisco Systems Inc. are + * Copyright (C) Cisco Systems Inc. 2001 - 2005. All Rights Reserved. + * + * 3GPP features implementation is based on 3GPP's TS26.234-v5.60, + * and was contributed by Ximpo Group Ltd. + * + * Portions created by Ximpo Group Ltd. are + * Copyright (C) Ximpo Group Ltd. 2003, 2004. All Rights Reserved. + * + * Contributor(s): + * Dave Mackie dmackie@cisco.com + * Alix Marchandise-Franquet alix@cisco.com + * Ximpo Group Ltd. mp4v2@ximpo.com + */ + +#ifndef __MP4_FILE_INCLUDED__ +#define __MP4_FILE_INCLUDED__ + +// forward declarations +class MP4Atom; +class MP4Property; +class MP4Float32Property; +class MP4StringProperty; +class MP4BytesProperty; +class MP4Descriptor; +class MP4DescriptorProperty; + +class MP4File { +public: /* equivalent to MP4 library API */ + MP4File(u_int32_t verbosity = 0); + ~MP4File(); + + /* file operations */ + void Read(const char* fileName); + void Create(const char* fileName, u_int32_t flags, + int add_ftyp = 1, int add_iods = 1, + char* majorBrand = NULL, + u_int32_t minorVersion = 0, char** supportedBrands = NULL, + u_int32_t supportedBrandsCount = 0); + void Modify(const char* fileName); + void Optimize(const char* orgFileName, + const char* newFileName = NULL); + void Dump(FILE* pDumpFile = NULL, bool dumpImplicits = false); + void Close(); + + /* library property per file */ + + u_int32_t GetVerbosity() { + return m_verbosity; + } + void SetVerbosity(u_int32_t verbosity) { + m_verbosity = verbosity; + } + + bool Use64Bits(const char *atomName); + + /* file properties */ + + u_int64_t GetIntegerProperty(const char* name); + float GetFloatProperty(const char* name); + const char* GetStringProperty(const char* name); + void GetBytesProperty(const char* name, + u_int8_t** ppValue, u_int32_t* pValueSize); + + void SetIntegerProperty(const char* name, u_int64_t value); + void SetFloatProperty(const char* name, float value); + void SetStringProperty(const char* name, const char* value); + void SetBytesProperty(const char* name, + const u_int8_t* pValue, u_int32_t valueSize); + + // file level convenience functions + + MP4Duration GetDuration(); + void SetDuration(MP4Duration value); + + u_int32_t GetTimeScale(); + void SetTimeScale(u_int32_t value); + + u_int8_t GetODProfileLevel(); + void SetODProfileLevel(u_int8_t value); + + u_int8_t GetSceneProfileLevel(); + void SetSceneProfileLevel(u_int8_t value); + + u_int8_t GetVideoProfileLevel(); + void SetVideoProfileLevel(u_int8_t value); + + u_int8_t GetAudioProfileLevel(); + void SetAudioProfileLevel(u_int8_t value); + + u_int8_t GetGraphicsProfileLevel(); + void SetGraphicsProfileLevel(u_int8_t value); + + const char* GetSessionSdp(); + void SetSessionSdp(const char* sdpString); + void AppendSessionSdp(const char* sdpString); + + /* track operations */ + + MP4TrackId AddTrack(const char* type, u_int32_t timeScale = 1000); + void DeleteTrack(MP4TrackId trackId); + + u_int32_t GetNumberOfTracks(const char* type = NULL, u_int8_t subType = 0); + + MP4TrackId AllocTrackId(); + MP4TrackId FindTrackId(u_int16_t trackIndex, + const char* type = NULL, u_int8_t subType = 0); + u_int16_t FindTrackIndex(MP4TrackId trackId); + u_int16_t FindTrakAtomIndex(MP4TrackId trackId); + + /* track properties */ + + u_int64_t GetTrackIntegerProperty( + MP4TrackId trackId, const char* name); + float GetTrackFloatProperty( + MP4TrackId trackId, const char* name); + const char* GetTrackStringProperty( + MP4TrackId trackId, const char* name); + void GetTrackBytesProperty( + MP4TrackId trackId, const char* name, + u_int8_t** ppValue, u_int32_t* pValueSize); + + void SetTrackIntegerProperty( + MP4TrackId trackId, const char* name, int64_t value); + void SetTrackFloatProperty( + MP4TrackId trackId, const char* name, float value); + void SetTrackStringProperty( + MP4TrackId trackId, const char* name, const char* value); + void SetTrackBytesProperty( + MP4TrackId trackId, const char* name, + const u_int8_t* pValue, u_int32_t valueSize); + + /* sample operations */ + + u_int32_t GetSampleSize(MP4TrackId trackId, MP4SampleId sampleId); + + u_int32_t GetTrackMaxSampleSize(MP4TrackId trackId); + + MP4SampleId GetSampleIdFromTime(MP4TrackId trackId, + MP4Timestamp when, bool wantSyncSample = false); + + MP4Timestamp GetSampleTime( + MP4TrackId trackId, MP4SampleId sampleId); + + MP4Duration GetSampleDuration( + MP4TrackId trackId, MP4SampleId sampleId); + + MP4Duration GetSampleRenderingOffset( + MP4TrackId trackId, MP4SampleId sampleId); + + bool GetSampleSync( + MP4TrackId trackId, MP4SampleId sampleId); + + void ReadSample( + // input parameters + MP4TrackId trackId, + MP4SampleId sampleId, + // output parameters + u_int8_t** ppBytes, + u_int32_t* pNumBytes, + MP4Timestamp* pStartTime = NULL, + MP4Duration* pDuration = NULL, + MP4Duration* pRenderingOffset = NULL, + bool* pIsSyncSample = NULL); + + void WriteSample( + MP4TrackId trackId, + const u_int8_t* pBytes, + u_int32_t numBytes, + MP4Duration duration = 0, + MP4Duration renderingOffset = 0, + bool isSyncSample = true); + + void SetSampleRenderingOffset( + MP4TrackId trackId, + MP4SampleId sampleId, + MP4Duration renderingOffset); + + /* track level convenience functions */ + + MP4TrackId AddSystemsTrack(const char* type); + + MP4TrackId AddODTrack(); + + MP4TrackId AddSceneTrack(); + + MP4TrackId AddAudioTrack( + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int8_t audioType); + + MP4TrackId AddEncAudioTrack( // ismacryp + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int8_t audioType, + u_int32_t scheme_type, + u_int16_t scheme_version, + u_int8_t key_ind_len, + u_int8_t iv_len, + bool selective_enc, + char *kms_uri); + + void SetAmrVendor( + MP4TrackId trackId, + u_int32_t vendor); + + void SetAmrDecoderVersion( + MP4TrackId trackId, + u_int8_t decoderVersion); + + void SetAmrModeSet( + MP4TrackId trackId, + u_int16_t modeSet); + uint16_t GetAmrModeSet(MP4TrackId trackId); + + MP4TrackId AddAmrAudioTrack( + u_int32_t timeScale, + u_int16_t modeSet, + u_int8_t modeChangePeriod, + u_int8_t framesPerSample, + bool isAmrWB); + + MP4TrackId AddHrefTrack(uint32_t timeScale, + MP4Duration sampleDuration); + + MP4TrackId AddMP4VideoTrack( + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int16_t width, + u_int16_t height, + u_int8_t videoType); + + MP4TrackId AddEncVideoTrack( // ismacryp + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int16_t width, + u_int16_t height, + u_int8_t videoType, + u_int32_t scheme_type, + u_int16_t scheme_version, + u_int8_t key_ind_len, + u_int8_t iv_len, + bool selective_enc, + char *kms_uri); + + + void SetH263Vendor( + MP4TrackId trackId, + u_int32_t vendor); + + void SetH263DecoderVersion( + MP4TrackId trackId, + u_int8_t decoderVersion); + + void SetH263Bitrates( + MP4TrackId, + u_int32_t avgBitrate, + u_int32_t maxBitrate); + + MP4TrackId AddH263VideoTrack( + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int16_t width, + u_int16_t height, + u_int8_t h263Level, + u_int8_t h263Profile, + u_int32_t avgBitrate, + u_int32_t maxBitrate); + MP4TrackId AddH264VideoTrack( + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int16_t width, + u_int16_t height, + uint8_t AVCProfileIndication, + uint8_t profile_compat, + uint8_t AVCLevelIndication, + uint8_t sampleLenFieldSizeMinusOne); + bool AddH264SequenceParameterSet(MP4TrackId trackId, + const uint8_t *pSequence, + uint16_t sequenceLen); + bool AddH264PictureParameterSet(MP4TrackId trackId, + const uint8_t *pPicture, + uint16_t pictureLen); + MP4TrackId AddHintTrack(MP4TrackId refTrackId); + + MP4SampleId GetTrackNumberOfSamples(MP4TrackId trackId); + + const char* GetTrackType(MP4TrackId trackId); + + const char *GetTrackMediaDataName(MP4TrackId trackId); + MP4Duration GetTrackDuration(MP4TrackId trackId); + + u_int32_t GetTrackTimeScale(MP4TrackId trackId); + void SetTrackTimeScale(MP4TrackId trackId, u_int32_t value); + + // replacement to GetTrackAudioType and GetTrackVideoType + u_int8_t GetTrackEsdsObjectTypeId(MP4TrackId trackId); + + u_int8_t GetTrackAudioMpeg4Type(MP4TrackId trackId); + + MP4Duration GetTrackFixedSampleDuration(MP4TrackId trackId); + + double GetTrackVideoFrameRate(MP4TrackId trackId); + + int GetTrackAudioChannels(MP4TrackId trackId); + void GetTrackESConfiguration(MP4TrackId trackId, + u_int8_t** ppConfig, u_int32_t* pConfigSize); + void SetTrackESConfiguration(MP4TrackId trackId, + const u_int8_t* pConfig, u_int32_t configSize); + + void GetTrackVideoMetadata(MP4TrackId trackId, + u_int8_t** ppConfig, u_int32_t* pConfigSize); + void GetTrackH264ProfileLevel(MP4TrackId trackId, + uint8_t *pProfile, + uint8_t *pLevel); + bool GetTrackH264SeqPictHeaders(MP4TrackId trackId, + uint8_t ***pSeqHeader, + uint32_t **pSeqHeaderSize, + uint8_t ***pPictHeader, + uint32_t **pPictHeaderSize); + void GetTrackH264LengthSize(MP4TrackId, + uint32_t *pLength); + const char* GetHintTrackSdp(MP4TrackId hintTrackId); + void SetHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString); + void AppendHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString); + + // 3GPP specific functions + void MakeFtypAtom(char* majorBrand, + u_int32_t minorVersion, + char** supportedBrands, + u_int32_t supportedBrandsCount); + void Make3GPCompliant(const char* fileName, + char* majorBrand, + u_int32_t minorVersion, + char** supportedBrands, + u_int32_t supportedBrandsCount, + bool deleteIodsAtom); + + // ISMA specific functions + + // true if media track encrypted according to ismacryp + bool IsIsmaCrypMediaTrack(MP4TrackId trackId); + + void MakeIsmaCompliant(bool addIsmaComplianceSdp = true); + + void CreateIsmaIodFromParams( + u_int8_t videoProfile, + u_int32_t videoBitrate, + u_int8_t* videoConfig, + u_int32_t videoConfigLength, + u_int8_t audioProfile, + u_int32_t audioBitrate, + u_int8_t* audioConfig, + u_int32_t audioConfigLength, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + + // time convenience functions + + u_int64_t ConvertFromMovieDuration( + MP4Duration duration, + u_int32_t timeScale); + + u_int64_t ConvertFromTrackTimestamp( + MP4TrackId trackId, + MP4Timestamp timeStamp, + u_int32_t timeScale); + + MP4Timestamp ConvertToTrackTimestamp( + MP4TrackId trackId, + u_int64_t timeStamp, + u_int32_t timeScale); + + u_int64_t ConvertFromTrackDuration( + MP4TrackId trackId, + MP4Duration duration, + u_int32_t timeScale); + + MP4Duration ConvertToTrackDuration( + MP4TrackId trackId, + u_int64_t duration, + u_int32_t timeScale); + + // specialized operations + + void GetHintTrackRtpPayload( + MP4TrackId hintTrackId, + char** ppPayloadName = NULL, + u_int8_t* pPayloadNumber = NULL, + u_int16_t* pMaxPayloadSize = NULL, + char **ppEncodingParams = NULL); + + void SetHintTrackRtpPayload( + MP4TrackId hintTrackId, + const char* payloadName, + u_int8_t* pPayloadNumber, + u_int16_t maxPayloadSize, + const char *encoding_params, + bool include_rtp_map, + bool include_mpeg4_esid); + + MP4TrackId GetHintTrackReferenceTrackId( + MP4TrackId hintTrackId); + + void ReadRtpHint( + MP4TrackId hintTrackId, + MP4SampleId hintSampleId, + u_int16_t* pNumPackets = NULL); + + u_int16_t GetRtpHintNumberOfPackets( + MP4TrackId hintTrackId); + + int8_t GetRtpPacketBFrame( + MP4TrackId hintTrackId, + u_int16_t packetIndex); + + int32_t GetRtpPacketTransmitOffset( + MP4TrackId hintTrackId, + u_int16_t packetIndex); + + void ReadRtpPacket( + MP4TrackId hintTrackId, + u_int16_t packetIndex, + u_int8_t** ppBytes, + u_int32_t* pNumBytes, + u_int32_t ssrc = 0, + bool includeHeader = true, + bool includePayload = true); + + MP4Timestamp GetRtpTimestampStart( + MP4TrackId hintTrackId); + + void SetRtpTimestampStart( + MP4TrackId hintTrackId, + MP4Timestamp rtpStart); + + void AddRtpHint( + MP4TrackId hintTrackId, + bool isBframe, + u_int32_t timestampOffset); + + void AddRtpPacket( + MP4TrackId hintTrackId, + bool setMbit, + int32_t transmitOffset); + + void AddRtpImmediateData( + MP4TrackId hintTrackId, + const u_int8_t* pBytes, + u_int32_t numBytes); + + void AddRtpSampleData( + MP4TrackId hintTrackId, + MP4SampleId sampleId, + u_int32_t dataOffset, + u_int32_t dataLength); + + void AddRtpESConfigurationPacket( + MP4TrackId hintTrackId); + + void WriteRtpHint( + MP4TrackId hintTrackId, + MP4Duration duration, + bool isSyncSample); + + u_int8_t AllocRtpPayloadNumber(); + + // edit list related + + char* MakeTrackEditName( + MP4TrackId trackId, + MP4EditId editId, + const char* name); + + MP4EditId AddTrackEdit( + MP4TrackId trackId, + MP4EditId editId = MP4_INVALID_EDIT_ID); + + void DeleteTrackEdit( + MP4TrackId trackId, + MP4EditId editId); + + u_int32_t GetTrackNumberOfEdits( + MP4TrackId trackId); + + MP4Timestamp GetTrackEditStart( + MP4TrackId trackId, + MP4EditId editId); + + MP4Duration GetTrackEditTotalDuration( + MP4TrackId trackId, + MP4EditId editId); + + MP4Timestamp GetTrackEditMediaStart( + MP4TrackId trackId, + MP4EditId editId); + + void SetTrackEditMediaStart( + MP4TrackId trackId, + MP4EditId editId, + MP4Timestamp startTime); + + MP4Duration GetTrackEditDuration( + MP4TrackId trackId, + MP4EditId editId); + + void SetTrackEditDuration( + MP4TrackId trackId, + MP4EditId editId, + MP4Duration duration); + + bool GetTrackEditDwell( + MP4TrackId trackId, + MP4EditId editId); + + void SetTrackEditDwell( + MP4TrackId trackId, + MP4EditId editId, + bool dwell); + + MP4SampleId GetSampleIdFromEditTime( + MP4TrackId trackId, + MP4Timestamp when, + MP4Timestamp* pStartTime = NULL, + MP4Duration* pDuration = NULL); + + /* iTunes metadata handling */ + protected: + bool CreateMetadataAtom(const char* name); + bool DeleteMetadataAtom(const char* name); + bool GetMetadataString(const char *atom, char **value); + bool SetMetadataString(const char *atom, const char *value); + public: + bool MetadataDelete(void); + + /* set metadata */ + bool SetMetadataName(const char* value); + bool SetMetadataWriter(const char* value); + bool SetMetadataAlbum(const char* value); + bool SetMetadataArtist(const char* value); + bool SetMetadataTool(const char* value); + bool SetMetadataComment(const char* value); + bool SetMetadataYear(const char* value); + bool SetMetadataTrack(u_int16_t track, u_int16_t totalTracks); + bool SetMetadataDisk(u_int16_t disk, u_int16_t totalDisks); + bool SetMetadataGenre(const char *value); + bool SetMetadataGrouping(const char *value); + bool SetMetadataTempo(u_int16_t tempo); + bool SetMetadataCompilation(u_int8_t compilation); + bool SetMetadataCoverArt(u_int8_t *coverArt, u_int32_t size); + bool SetMetadataFreeForm(char *name, + u_int8_t* pValue, + u_int32_t valueSize); + + /* get metadata */ + bool GetMetadataByIndex(u_int32_t index, + const char** ppName, + u_int8_t** ppValue, + u_int32_t* pValueSize); + bool GetMetadataName(char** value); + bool GetMetadataWriter(char** value); + bool GetMetadataAlbum(char** value); + bool GetMetadataArtist(char** value); + bool GetMetadataTool(char** value); + bool GetMetadataComment(char** value); + bool GetMetadataYear(char** value); + bool GetMetadataTrack(u_int16_t* track, u_int16_t* totalTracks); + bool GetMetadataDisk(u_int16_t* disk, u_int16_t* totalDisks); + bool GetMetadataGenre(char **value); + bool GetMetadataGrouping(char **value); + bool GetMetadataTempo(u_int16_t* tempo); + bool GetMetadataCompilation(u_int8_t* compilation); + bool GetMetadataCoverArt(u_int8_t **coverArt, u_int32_t* size); + bool GetMetadataFreeForm(char *name, + u_int8_t** pValue, + u_int32_t* valueSize); + + /* delete metadata */ + bool DeleteMetadataName(); + bool DeleteMetadataWriter(); + bool DeleteMetadataAlbum(); + bool DeleteMetadataArtist(); + bool DeleteMetadataTool(); + bool DeleteMetadataComment(); + bool DeleteMetadataYear(); + bool DeleteMetadataTrack(); + bool DeleteMetadataDisk(); + bool DeleteMetadataGenre(); + bool DeleteMetadataGrouping(); + bool DeleteMetadataTempo(); + bool DeleteMetadataCompilation(); + bool DeleteMetadataCoverArt(); + bool DeleteMetadataFreeForm(char *name); + + /* end of MP4 API */ + + /* "protected" interface to be used only by friends in library */ + + u_int64_t GetPosition(FILE* pFile = NULL); + void SetPosition(u_int64_t pos, FILE* pFile = NULL); + + u_int64_t GetSize(); + + u_int32_t ReadBytes( + u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL); + u_int64_t ReadUInt(u_int8_t size); + u_int8_t ReadUInt8(); + u_int16_t ReadUInt16(); + u_int32_t ReadUInt24(); + u_int32_t ReadUInt32(); + u_int64_t ReadUInt64(); + float ReadFixed16(); + float ReadFixed32(); + float ReadFloat(); + char* ReadString(); + char* ReadCountedString( + u_int8_t charSize = 1, bool allowExpandedCount = false); + u_int64_t ReadBits(u_int8_t numBits); + void FlushReadBits(); + u_int32_t ReadMpegLength(); + + u_int32_t PeekBytes( + u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL); + + void WriteBytes(u_int8_t* pBytes, u_int32_t numBytes, FILE* pFile = NULL); + void WriteUInt(u_int64_t value, u_int8_t size); + void WriteUInt8(u_int8_t value); + void WriteUInt16(u_int16_t value); + void WriteUInt24(u_int32_t value); + void WriteUInt32(u_int32_t value); + void WriteUInt64(u_int64_t value); + void WriteFixed16(float value); + void WriteFixed32(float value); + void WriteFloat(float value); + void WriteString(char* string); + void WriteCountedString(char* string, + u_int8_t charSize = 1, bool allowExpandedCount = false); + void WriteBits(u_int64_t bits, u_int8_t numBits); + void PadWriteBits(u_int8_t pad = 0); + void FlushWriteBits(); + void WriteMpegLength(u_int32_t value, bool compact = false); + + void EnableMemoryBuffer( + u_int8_t* pBytes = NULL, u_int64_t numBytes = 0); + void DisableMemoryBuffer( + u_int8_t** ppBytes = NULL, u_int64_t* pNumBytes = NULL); + + char GetMode() { + return m_mode; + } + + MP4Track* GetTrack(MP4TrackId trackId); + + MP4Duration UpdateDuration(MP4Duration duration); + + MP4Atom* FindAtom(const char* name); + + MP4Atom* AddChildAtom( + const char* parentName, + const char* childName); + + MP4Atom* AddChildAtom( + MP4Atom* pParentAtom, + const char* childName); + + MP4Atom* InsertChildAtom( + const char* parentName, + const char* childName, + u_int32_t index); + + MP4Atom* InsertChildAtom( + MP4Atom* pParentAtom, + const char* childName, + u_int32_t index); + + MP4Atom* AddDescendantAtoms( + const char* ancestorName, + const char* childName); + + MP4Atom* AddDescendantAtoms( + MP4Atom* pAncestorAtom, + const char* childName); + +protected: + void Open(const char* fmode); + void ReadFromFile(); + void GenerateTracks(); + void BeginWrite(); + void FinishWrite(); + void CacheProperties(); + void RewriteMdat(FILE* pReadFile, FILE* pWriteFile); + bool ShallHaveIods(); + + const char* TempFileName(); + void Rename(const char* existingFileName, const char* newFileName); + + void ProtectWriteOperation(char* where); + + void FindIntegerProperty(const char* name, + MP4Property** ppProperty, u_int32_t* pIndex = NULL); + void FindFloatProperty(const char* name, + MP4Property** ppProperty, u_int32_t* pIndex = NULL); + void FindStringProperty(const char* name, + MP4Property** ppProperty, u_int32_t* pIndex = NULL); + void FindBytesProperty(const char* name, + MP4Property** ppProperty, u_int32_t* pIndex = NULL); + + bool FindProperty(const char* name, + MP4Property** ppProperty, u_int32_t* pIndex = NULL); + + MP4TrackId AddVideoTrackDefault( + u_int32_t timeScale, + MP4Duration sampleDuration, + u_int16_t width, + u_int16_t height, + const char *videoType); + MP4TrackId AddCntlTrackDefault( + u_int32_t timeScale, + MP4Duration sampleDuration, + const char *videoType); + void AddTrackToIod(MP4TrackId trackId); + + void RemoveTrackFromIod(MP4TrackId trackId, bool shallHaveIods = true); + + void AddTrackToOd(MP4TrackId trackId); + + void RemoveTrackFromOd(MP4TrackId trackId); + + void GetTrackReferenceProperties(const char* trefName, + MP4Property** ppCountProperty, MP4Property** ppTrackIdProperty); + + void AddTrackReference(const char* trefName, MP4TrackId refTrackId); + + u_int32_t FindTrackReference(const char* trefName, MP4TrackId refTrackId); + + void RemoveTrackReference(const char* trefName, MP4TrackId refTrackId); + + void AddDataReference(MP4TrackId trackId, const char* url); + + char* MakeTrackName(MP4TrackId trackId, const char* name); + + u_int8_t ConvertTrackTypeToStreamType(const char* trackType); + + void CreateIsmaIodFromFile( + MP4TrackId odTrackId, + MP4TrackId sceneTrackId, + MP4TrackId audioTrackId, + MP4TrackId videoTrackId, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + + MP4Descriptor* CreateESD( + MP4DescriptorProperty* pEsProperty, + u_int32_t esid, + u_int8_t objectType, + u_int8_t streamType, + u_int32_t bufferSize, + u_int32_t bitrate, + const u_int8_t* pConfig, + u_int32_t configLength, + char* url); + + void CreateIsmaODUpdateCommandFromFileForFile( + MP4TrackId odTrackId, + MP4TrackId audioTrackId, + MP4TrackId videoTrackId, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + + void CreateIsmaODUpdateCommandFromFileForStream( + MP4TrackId audioTrackId, + MP4TrackId videoTrackId, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + + void CreateIsmaODUpdateCommandForStream( + MP4DescriptorProperty* pAudioEsdProperty, + MP4DescriptorProperty* pVideoEsdProperty, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + + void CreateIsmaSceneCommand( + bool hasAudio, + bool hasVideo, + u_int8_t** ppBytes, + u_int64_t* pNumBytes); + +protected: + char* m_fileName; + FILE* m_pFile; + u_int64_t m_orgFileSize; + u_int64_t m_fileSize; + MP4Atom* m_pRootAtom; + MP4Integer32Array m_trakIds; + MP4TrackArray m_pTracks; + MP4TrackId m_odTrackId; + u_int32_t m_verbosity; + char m_mode; + u_int32_t m_createFlags; + bool m_useIsma; + + // cached properties + MP4IntegerProperty* m_pModificationProperty; + MP4Integer32Property* m_pTimeScaleProperty; + MP4IntegerProperty* m_pDurationProperty; + + // read/write in memory + u_int8_t* m_memoryBuffer; + u_int64_t m_memoryBufferPosition; + u_int64_t m_memoryBufferSize; + + // bit read/write buffering + u_int8_t m_numReadBits; + u_int8_t m_bufReadBits; + u_int8_t m_numWriteBits; + u_int8_t m_bufWriteBits; + +#ifndef _WIN32 + char m_tempFileName[64]; +#else + char m_tempFileName[MAX_PATH + 3]; +#endif + char m_trakName[1024]; + char *m_editName; +}; + +#endif /* __MP4_FILE_INCLUDED__ */