///////////////////////////////////////////////////////////////////////////////
//
//  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.
//
//  Contributors:
//      Dave Mackie, dmackie@cisco.com
//      Alix Marchandise-Franquet, alix@cisco.com
//      Ximpo Group Ltd., mp4v2@ximpo.com
//      Kona Blend, kona8lend@@gmail.com
//
///////////////////////////////////////////////////////////////////////////////

#ifndef MP4V2_IMPL_MP4FILE_H
#define MP4V2_IMPL_MP4FILE_H

namespace mp4v2 { namespace impl {

///////////////////////////////////////////////////////////////////////////////

class MP4Atom;
class MP4Property;
class MP4Float32Property;
class MP4StringProperty;
class MP4BytesProperty;
class MP4Descriptor;
class MP4DescriptorProperty;

class MP4File
{
public:
    static void CopySample(
        MP4File*    srcFile,
        MP4TrackId  srcTrackId,
        MP4SampleId srcSampleId,
        MP4File*    dstFile,
        MP4TrackId  dstTrackId,
        MP4Duration dstSampleDuration );

    static void EncAndCopySample(
        MP4File*      srcFile,
        MP4TrackId    srcTrackId,
        MP4SampleId   srcSampleId,
        encryptFunc_t encfcnp,
        uint32_t      encfcnparam1,
        MP4File*      dstFile,
        MP4TrackId    dstTrackId,
        MP4Duration   dstSampleDuration );

public:
    MP4File();
    ~MP4File();

    ///////////////////////////////////////////////////////////////////////////
    // file ops
    ///////////////////////////////////////////////////////////////////////////

    const std::string &GetFilename() const;

    void Read( const char*            fileName,
               const MP4FileProvider* provider,
               const MP4IOCallbacks*  callbacks,
               void*                  handle );

    void Create( const char*           fileName,
                 const MP4IOCallbacks* callbacks,
                 void*                 handle,
                 uint32_t              flags,
                 int                   add_ftyp = 1,
                 int                   add_iods = 1,
                 char*                 majorBrand = NULL,
                 uint32_t              minorVersion = 0,
                 char**                supportedBrands = NULL,
                 uint32_t              supportedBrandsCount = 0 );

    bool Modify( const char*           fileName,
                 const MP4IOCallbacks* callbacks,
                 void*                 handle );

    void Optimize( const char* srcFileName, const char* dstFileName = NULL );
    bool CopyClose( const string& copyFileName );
    void Dump( bool dumpImplicits = false );
    void Close(uint32_t flags = 0);

    bool Use64Bits(const char *atomName);
    void Check64BitStatus(const char *atomName);
    /* file properties */

    uint64_t GetIntegerProperty(const char* name);
    float GetFloatProperty(const char* name);
    const char* GetStringProperty(const char* name);
    void GetBytesProperty(const char* name,
                          uint8_t** ppValue, uint32_t* pValueSize);

    void SetIntegerProperty(const char* name, uint64_t value);
    void SetFloatProperty(const char* name, float value);
    void SetStringProperty(const char* name, const char* value);
    void SetBytesProperty(const char* name,
                          const uint8_t* pValue, uint32_t valueSize);

    // file level convenience functions

    MP4Duration GetDuration();
    void SetDuration(MP4Duration value);

    uint32_t GetTimeScale();
    void SetTimeScale(uint32_t value);

    uint8_t GetODProfileLevel();
    void SetODProfileLevel(uint8_t value);

    uint8_t GetSceneProfileLevel();
    void SetSceneProfileLevel(uint8_t value);

    uint8_t GetVideoProfileLevel();
    void SetVideoProfileLevel(uint8_t value);

    uint8_t GetAudioProfileLevel();
    void SetAudioProfileLevel(uint8_t value);

    uint8_t GetGraphicsProfileLevel();
    void SetGraphicsProfileLevel(uint8_t value);

    const char* GetSessionSdp();
    void SetSessionSdp(const char* sdpString);
    void AppendSessionSdp(const char* sdpString);

    /* track operations */

    MP4TrackId AddTrack(const char* type, uint32_t timeScale = 1000);
    void DeleteTrack(MP4TrackId trackId);

    uint32_t GetNumberOfTracks(const char* type = NULL, uint8_t subType = 0);

    MP4TrackId AllocTrackId();
    MP4TrackId FindTrackId(uint16_t trackIndex,
                           const char* type = NULL, uint8_t subType = 0);
    uint16_t FindTrackIndex(MP4TrackId trackId);
    uint16_t FindTrakAtomIndex(MP4TrackId trackId);

    /* track properties */
    MP4Atom *FindTrackAtom(MP4TrackId trackId, const char *name);
    uint64_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,
        uint8_t** ppValue, uint32_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 uint8_t* pValue, uint32_t valueSize);

    bool GetTrackLanguage( MP4TrackId, char* );
    bool SetTrackLanguage( MP4TrackId, const char* );
    bool GetTrackName( MP4TrackId trackId, char** name );
    bool SetTrackName( MP4TrackId trackId, const char* name);

    /* sample operations */

    uint32_t GetSampleSize(MP4TrackId trackId, MP4SampleId sampleId);

    uint32_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
        uint8_t**     ppBytes,
        uint32_t*     pNumBytes,
        MP4Timestamp* pStartTime = NULL,
        MP4Duration*  pDuration = NULL,
        MP4Duration*  pRenderingOffset = NULL,
        bool*         pIsSyncSample = NULL,
        bool*         hasDependencyFlags = NULL,
        uint32_t*     dependencyFlags = NULL );

    void WriteSample(
        MP4TrackId     trackId,
        const uint8_t* pBytes,
        uint32_t       numBytes,
        MP4Duration    duration = 0,
        MP4Duration    renderingOffset = 0,
        bool           isSyncSample = true );

    void WriteSampleDependency(
        MP4TrackId     trackId,
        const uint8_t* pBytes,
        uint32_t       numBytes,
        MP4Duration    duration,
        MP4Duration    renderingOffset,
        bool           isSyncSample,
        uint32_t       dependencyFlags );

    void SetSampleRenderingOffset(
        MP4TrackId  trackId,
        MP4SampleId sampleId,
        MP4Duration renderingOffset );

    MP4Duration GetTrackDurationPerChunk( MP4TrackId );
    void        SetTrackDurationPerChunk( MP4TrackId, MP4Duration );

    /* track level convenience functions */

    MP4TrackId AddSystemsTrack(const char* type, uint32_t timeScale = 1000 );

    MP4TrackId AddODTrack();

    MP4TrackId AddSceneTrack();

    MP4TrackId AddAudioTrack(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint8_t audioType);

    MP4TrackId AddULawAudioTrack(
        uint32_t timeScale);

    MP4TrackId AddALawAudioTrack(
        uint32_t timeScale);

    MP4TrackId AddAC3AudioTrack(
        uint32_t samplingRate,
        uint8_t fscod,
        uint8_t bsid,
        uint8_t bsmod,
        uint8_t acmod,
        uint8_t lfeon,
        uint8_t bit_rate_code);

    MP4TrackId AddEncAudioTrack( // ismacryp
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint8_t  audioType,
        uint32_t scheme_type,
        uint16_t scheme_version,
        uint8_t  key_ind_len,
        uint8_t  iv_len,
        bool      selective_enc,
        const char  *kms_uri,
        bool      use_ismacryp);

    void SetAmrVendor(
        MP4TrackId trackId,
        uint32_t vendor);

    void SetAmrDecoderVersion(
        MP4TrackId trackId,
        uint8_t decoderVersion);

    void SetAmrModeSet(
        MP4TrackId trackId,
        uint16_t modeSet);
    uint16_t GetAmrModeSet(MP4TrackId trackId);

    MP4TrackId AddAmrAudioTrack(
        uint32_t timeScale,
        uint16_t modeSet,
        uint8_t modeChangePeriod,
        uint8_t framesPerSample,
        bool isAmrWB);

    MP4TrackId AddHrefTrack(uint32_t timeScale,
                            MP4Duration sampleDuration,
                            const char *base_url);

    MP4TrackId AddMP4VideoTrack(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        uint8_t videoType);

    MP4TrackId AddEncVideoTrack( // ismacryp
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        uint8_t  videoType,
        mp4v2_ismacrypParams *icPp,
        const char *oFormat);

    void SetH263Vendor(
        MP4TrackId trackId,
        uint32_t vendor);

    void SetH263DecoderVersion(
        MP4TrackId trackId,
        uint8_t decoderVersion);

    void SetH263Bitrates(
        MP4TrackId,
        uint32_t avgBitrate,
        uint32_t maxBitrate);

    MP4TrackId AddH263VideoTrack(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        uint8_t h263Level,
        uint8_t h263Profile,
        uint32_t avgBitrate,
        uint32_t maxBitrate);

    MP4TrackId AddH264VideoTrack(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        uint8_t AVCProfileIndication,
        uint8_t profile_compat,
        uint8_t AVCLevelIndication,
        uint8_t sampleLenFieldSizeMinusOne);

    MP4TrackId AddEncH264VideoTrack(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        MP4Atom *srcAtom,
        mp4v2_ismacrypParams *icPp);

    void AddH264SequenceParameterSet(MP4TrackId trackId,
                                     const uint8_t *pSequence,
                                     uint16_t sequenceLen);
    void AddH264PictureParameterSet(MP4TrackId trackId,
                                    const uint8_t *pPicture,
                                    uint16_t pictureLen);
    MP4TrackId AddHintTrack(MP4TrackId refTrackId);

    MP4TrackId AddTextTrack(MP4TrackId refTrackId);

    /** Add a QuickTime chapter track.
     *
     *  This function adds a chapter (text) track.
     *  The optional parameter <b>timescale</b> may be supplied to give the new
     *  chapter a specific timescale. Otherwise the chapter track will have
     *  the same timescale as the reference track defined in parameter refTrackId.
     *
     *  @param refTrackId ID of the track that will reference the chapter track.
     *  @param timescale the timescale of the chapter track or 0 to use the
     *      timescale of track specified by <b>refTrackId</b>.
     *
     *  @return ID of the created chapter track.
     */
    MP4TrackId AddChapterTextTrack(
        MP4TrackId refTrackId,
        uint32_t   timescale = 0 );

    MP4TrackId AddSubtitleTrack(uint32_t timescale,
                                uint16_t width,
                                uint16_t height);

    MP4TrackId AddSubpicTrack(uint32_t timescale,
                                uint16_t width,
                                uint16_t height);

    MP4TrackId AddPixelAspectRatio(MP4TrackId trackId, uint32_t hSpacing, uint32_t vSpacing);
    MP4TrackId AddColr(MP4TrackId trackId, uint16_t pri, uint16_t tran, uint16_t mat);

    /** Add a QuickTime chapter.
     *
     *  @param chapterTrackId ID of chapter track or #MP4_INVALID_TRACK_ID
     *      if unknown.
     *  @param chapterDuration duration (in the timescale of the chapter track).
     *  @param chapterTitle title text for the chapter or NULL to use default
     *      title format ("Chapter %03d", n) where n is the chapter number.
     */
    void AddChapter(
        MP4TrackId  chapterTrackId,
        MP4Duration chapterDuration,
        const char* chapterTitle = 0 );

    /** Add a Nero chapter.
     *
     *  @param chapterStart the start time of the chapter in 100 nanosecond units
     *  @param chapterTitle title text for the chapter or NULL to use default
     *      title format ("Chapter %03d", n) where n is the chapter number.
     */
    void AddNeroChapter(
        MP4Timestamp chapterStart,
        const char*  chapterTitle = 0 );

    /*! Returns the ID of the track referencing the chapter track chapterTrackId.
     *  This function searches for a track of type MP4_AUDIO_TRACK_TYPE that references
     *  the track chapterTrackId through the atom "tref.chap".
     *
     * @param chapterTrackId the ID of the chapter track
     * @param trackName receives the name of the referencing track if not null
     * @param trackNameSize the size of the memory pointed to by trackName
     * @return the ID if the track referencing the chapter track or MP4_INVALID_TRACK_ID
     */
    MP4TrackId FindChapterReferenceTrack(MP4TrackId chapterTrackId,
                                         char *trackName = 0,
                                         int trackNameSize = 0);

    /*! Find the QuickTime chapter track in the current file.
     * This function searches for a track of type text.
     *
     * @param trackName receives the name of the chapter track if not null
     * @param trackNameSize the size of the memory pointed to by trackName
     * @return the ID of the chapter track or MP4_INVALID_TRACK_ID
     */
    MP4TrackId FindChapterTrack(char *trackName = 0, int trackNameSize = 0);

    /** Delete chapters.
     *
     *  @param chapterType the type of chapters to delete:
     *      @li #MP4ChapterTypeAny (delete all known chapter types)
     *      @li #MP4ChapterTypeQt
     *      @li #MP4ChapterTypeNero
     *  @param chapterTrackId ID of the chapter track if known,
     *      or #MP4_INVALID_TRACK_ID.
     *      Only applies when <b>chapterType</b>=#MP4ChapterTypeQt.
     *
     * @return the type of deleted chapters
     */
    MP4ChapterType DeleteChapters(
        MP4ChapterType chapterType = MP4ChapterTypeQt,
        MP4TrackId chapterTrackId = 0 );

    /** Get list of chapters.
     *
     *  @param chapterList address receiving array of chapter items.
     *      If a non-NULL is received the caller is responsible for freeing the
     *      memory with MP4Free().
     *  @param chapterCount address receiving count of items in array.
     *  @param chapterType the type of chapters to read:
     *      @li #MP4ChapterTypeAny (any chapters, searched in order of Qt, Nero)
     *      @li #MP4ChapterTypeQt
     *      @li #MP4ChapterTypeNero
     *
     *  @result the first type of chapters found.
     */

    MP4ChapterType GetChapters(
        MP4Chapter_t** chapterList,
        uint32_t*      chapterCount,
        MP4ChapterType fromChapterType = MP4ChapterTypeQt );

    /** Set list of chapters.
     *
     *  This functions sets the complete chapter list.
     *  If any chapters of the same type already exist they will first
     *  be deleted.
     *
     *  @param chapterList array of chapters items.
     *  @param chapterCount count of items in array.
     *  @param chapterType type of chapters to write:
     *      @li #MP4ChapterTypeAny (chapters of all types are written)
     *      @li #MP4ChapterTypeQt
     *      @li #MP4ChapterTypeNero
     *
     *  @return the type of chapters written.
     */
    MP4ChapterType SetChapters(
        MP4Chapter_t*  chapterList,
        uint32_t       chapterCount,
        MP4ChapterType toChapterType = MP4ChapterTypeQt );

    /** Convert chapters to another type.
     *
     *  This function converts existing chapters
     *  from one type to another type.
     *  Conversion from Nero to QuickTime or QuickTime to Nero is supported.
     *
     *  @param toChapterType the chapter type to convert to:
     *      @li #MP4ChapterTypeQt (convert from Nero to Qt)
     *      @li #MP4ChapterTypeNero (convert from Qt to Nero)
     *
     *  @return the chapter type before conversion or #MP4ChapterTypeNone
     *      if the source chapters do not exist
     *      or invalid <b>toChapterType</b> was specified.
     */
    MP4ChapterType ConvertChapters(MP4ChapterType toChapterType = MP4ChapterTypeQt);

    /** Change the general timescale.
     *
     *  This function changes the general timescale to the new timescale
     *  <b>value</b> by recalculating all values that depend on the timescale
     *  in "moov.mvhd".
     *
     *  If the timescale is already equal to value nothing is done.
     *
     *  @param value the new timescale.
     */
    void ChangeMovieTimeScale(uint32_t timescale);

    MP4SampleId GetTrackNumberOfSamples(MP4TrackId trackId);

    const char* GetTrackType(MP4TrackId trackId);

    const char *GetTrackMediaDataName(MP4TrackId trackId);
    bool GetTrackMediaDataOriginalFormat(MP4TrackId trackId,
                                         char *originalFormat, uint32_t buflen);
    MP4Duration GetTrackDuration(MP4TrackId trackId);

    uint32_t GetTrackTimeScale(MP4TrackId trackId);
    void SetTrackTimeScale(MP4TrackId trackId, uint32_t value);

    // replacement to GetTrackAudioType and GetTrackVideoType
    uint8_t GetTrackEsdsObjectTypeId(MP4TrackId trackId);

    uint8_t GetTrackAudioMpeg4Type(MP4TrackId trackId);

    MP4Duration GetTrackFixedSampleDuration(MP4TrackId trackId);

    double GetTrackVideoFrameRate(MP4TrackId trackId);

    int GetTrackAudioChannels(MP4TrackId trackId);
    void GetTrackESConfiguration(MP4TrackId trackId,
                                 uint8_t** ppConfig, uint32_t* pConfigSize);
    void SetTrackESConfiguration(MP4TrackId trackId,
                                 const uint8_t* pConfig, uint32_t configSize);

    void GetTrackVideoMetadata(MP4TrackId trackId,
                               uint8_t** ppConfig, uint32_t* pConfigSize);
    void GetTrackH264SeqPictHeaders(MP4TrackId trackId,
                                    uint8_t ***pSeqHeader,
                                    uint32_t **pSeqHeaderSize,
                                    uint8_t ***pPictHeader,
                                    uint32_t **pPictHeaderSize);
    const char* GetHintTrackSdp(MP4TrackId hintTrackId);
    void SetHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString);
    void AppendHintTrackSdp(MP4TrackId hintTrackId, const char* sdpString);

    void MakeFtypAtom(
        char*    majorBrand,
        uint32_t minorVersion,
        char**   compatibleBrands,
        uint32_t compatibleBrandsCount );

    // 3GPP specific functions
    void Make3GPCompliant(const char* fileName,
                          char* majorBrand,
                          uint32_t minorVersion,
                          char** supportedBrands,
                          uint32_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(
        uint8_t videoProfile,
        uint32_t videoBitrate,
        uint8_t* videoConfig,
        uint32_t videoConfigLength,
        uint8_t audioProfile,
        uint32_t audioBitrate,
        uint8_t* audioConfig,
        uint32_t audioConfigLength,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

    // time convenience functions

    uint64_t ConvertFromMovieDuration(
        MP4Duration duration,
        uint32_t timeScale);

    uint64_t ConvertFromTrackTimestamp(
        MP4TrackId trackId,
        MP4Timestamp timeStamp,
        uint32_t timeScale);

    MP4Timestamp ConvertToTrackTimestamp(
        MP4TrackId trackId,
        uint64_t timeStamp,
        uint32_t timeScale);

    uint64_t ConvertFromTrackDuration(
        MP4TrackId trackId,
        MP4Duration duration,
        uint32_t timeScale);

    MP4Duration ConvertToTrackDuration(
        MP4TrackId trackId,
        uint64_t duration,
        uint32_t timeScale);

    // specialized operations

    void GetHintTrackRtpPayload(
        MP4TrackId hintTrackId,
        char** ppPayloadName = NULL,
        uint8_t* pPayloadNumber = NULL,
        uint16_t* pMaxPayloadSize = NULL,
        char **ppEncodingParams = NULL);

    void SetHintTrackRtpPayload(
        MP4TrackId hintTrackId,
        const char* payloadName,
        uint8_t* pPayloadNumber,
        uint16_t maxPayloadSize,
        const char *encoding_params,
        bool include_rtp_map,
        bool include_mpeg4_esid);

    MP4TrackId GetHintTrackReferenceTrackId(
        MP4TrackId hintTrackId);

    void ReadRtpHint(
        MP4TrackId hintTrackId,
        MP4SampleId hintSampleId,
        uint16_t* pNumPackets = NULL);

    uint16_t GetRtpHintNumberOfPackets(
        MP4TrackId hintTrackId);

    int8_t GetRtpPacketBFrame(
        MP4TrackId hintTrackId,
        uint16_t packetIndex);

    int32_t GetRtpPacketTransmitOffset(
        MP4TrackId hintTrackId,
        uint16_t packetIndex);

    void ReadRtpPacket(
        MP4TrackId hintTrackId,
        uint16_t packetIndex,
        uint8_t** ppBytes,
        uint32_t* pNumBytes,
        uint32_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,
        uint32_t timestampOffset);

    void AddRtpPacket(
        MP4TrackId hintTrackId,
        bool setMbit,
        int32_t transmitOffset);

    void AddRtpImmediateData(
        MP4TrackId hintTrackId,
        const uint8_t* pBytes,
        uint32_t numBytes);

    void AddRtpSampleData(
        MP4TrackId hintTrackId,
        MP4SampleId sampleId,
        uint32_t dataOffset,
        uint32_t dataLength);

    void AddRtpESConfigurationPacket(
        MP4TrackId hintTrackId);

    void WriteRtpHint(
        MP4TrackId hintTrackId,
        MP4Duration duration,
        bool isSyncSample);

    uint8_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);

    uint32_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);

    /* "protected" interface to be used only by friends in library */

    uint64_t GetPosition( File* file = NULL );
    void SetPosition( uint64_t pos, File* file = NULL );
    uint64_t GetSize( File* file = NULL );

    void ReadBytes( uint8_t* buf, uint32_t bufsiz, File* file = NULL );
    void PeekBytes( uint8_t* buf, uint32_t bufsiz, File* file = NULL );

    uint8_t ReadUInt8();
    uint16_t ReadUInt16();
    uint32_t ReadUInt24();
    uint32_t ReadUInt32();
    uint64_t ReadUInt64();

    template<class type, int size> type ReadUInt();

    float ReadFixed16();
    float ReadFixed32();
    float ReadFloat();
    char* ReadString();
    char* ReadCountedString(uint8_t charSize = 1,
                            bool allowExpandedCount = false,
                            uint8_t fixedLength = 0);
    uint64_t ReadBits(uint8_t numBits);
    void FlushReadBits();
    uint32_t ReadMpegLength();

    void WriteBytes( uint8_t* buf, uint32_t bufsiz, File* file = NULL );

    void WriteUInt8(uint8_t value);
    void WriteUInt16(uint16_t value);
    void WriteUInt24(uint32_t value);
    void WriteUInt32(uint32_t value);
    void WriteUInt64(uint64_t value);

    template<class type, int size> void WriteUInt(type value);

    void WriteFixed16(float value);
    void WriteFixed32(float value);
    void WriteFloat(float value);
    void WriteString(char* string);
    void WriteCountedString(char* string,
                            uint8_t charSize = 1,
                            bool allowExpandedCount = false,
                            uint32_t fixedLength = 0);
    void WriteBits(uint64_t bits, uint8_t numBits);
    void PadWriteBits(uint8_t pad = 0);
    void FlushWriteBits();
    void WriteMpegLength(uint32_t value, bool compact = false);

    void EnableMemoryBuffer(
        uint8_t* pBytes = NULL, uint64_t numBytes = 0);
    void DisableMemoryBuffer(
        uint8_t** ppBytes = NULL, uint64_t* pNumBytes = NULL);

    bool IsWriteMode();

    MP4Track* GetTrack(MP4TrackId trackId);

    void 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,
        uint32_t index);

    MP4Atom* InsertChildAtom(
        MP4Atom* pParentAtom,
        const char* childName,
        uint32_t index);

    MP4Atom* AddDescendantAtoms(
        const char* ancestorName,
        const char* childName);

    MP4Atom* AddDescendantAtoms(
        MP4Atom* pAncestorAtom,
        const char* childName);

protected:
    void Init();

    void Open( const char*            fileName,
               File::Mode             mode,
               const MP4FileProvider* provider = NULL,
               const MP4IOCallbacks*  callbacks = NULL,
               void*                  handle = NULL );

    void ReadFromFile();
    void GenerateTracks();
    void BeginWrite();
    void FinishWrite(uint32_t options);
    void CacheProperties();
    void RewriteMdat( File& src, File& dst );
    bool ShallHaveIods();

    void Rename(const char* existingFileName, const char* newFileName);

    void FindIntegerProperty(const char* name,
                             MP4Property** ppProperty, uint32_t* pIndex = NULL);
    void FindFloatProperty(const char* name,
                           MP4Property** ppProperty, uint32_t* pIndex = NULL);
    void FindStringProperty(const char* name,
                            MP4Property** ppProperty, uint32_t* pIndex = NULL);
    void FindBytesProperty(const char* name,
                           MP4Property** ppProperty, uint32_t* pIndex = NULL);

    bool FindProperty(const char* name,
                      MP4Property** ppProperty, uint32_t* pIndex = NULL);

    MP4TrackId AddVideoTrackDefault(
        uint32_t timeScale,
        MP4Duration sampleDuration,
        uint16_t width,
        uint16_t height,
        const char *videoType);
    MP4TrackId AddCntlTrackDefault(
        uint32_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);

    uint32_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);

    uint8_t ConvertTrackTypeToStreamType(const char* trackType);

    void CreateIsmaIodFromFile(
        MP4TrackId odTrackId,
        MP4TrackId sceneTrackId,
        MP4TrackId audioTrackId,
        MP4TrackId videoTrackId,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

    void CreateESD(
        MP4DescriptorProperty* pEsProperty,
        uint32_t esid,
        uint8_t objectType,
        uint8_t streamType,
        uint32_t bufferSize,
        uint32_t bitrate,
        const uint8_t* pConfig,
        uint32_t configLength,
        char* url);

    void CreateIsmaODUpdateCommandFromFileForFile(
        MP4TrackId odTrackId,
        MP4TrackId audioTrackId,
        MP4TrackId videoTrackId,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

    void CreateIsmaODUpdateCommandFromFileForStream(
        MP4TrackId audioTrackId,
        MP4TrackId videoTrackId,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

    void CreateIsmaODUpdateCommandForStream(
        MP4DescriptorProperty* pAudioEsdProperty,
        MP4DescriptorProperty* pVideoEsdProperty,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

    void CreateIsmaSceneCommand(
        bool hasAudio,
        bool hasVideo,
        uint8_t** ppBytes,
        uint64_t* pNumBytes);

protected:
    File*    m_file;
    uint64_t m_fileOriginalSize;
    uint32_t m_createFlags;

    MP4Atom*          m_pRootAtom;
    MP4Integer32Array m_trakIds;
    MP4TrackArray     m_pTracks;
    MP4TrackId        m_odTrackId;
    bool              m_useIsma;

    // cached properties
    MP4IntegerProperty*     m_pModificationProperty;
    MP4Integer32Property*   m_pTimeScaleProperty;
    MP4IntegerProperty*     m_pDurationProperty;

    // read/write in memory
    uint8_t*    m_memoryBuffer;
    uint64_t    m_memoryBufferPosition;
    uint64_t    m_memoryBufferSize;

    // bit read/write buffering
    uint8_t m_numReadBits;
    uint8_t m_bufReadBits;
    uint8_t m_numWriteBits;
    uint8_t m_bufWriteBits;

    char m_trakName[1024];
    char *m_editName;

 private:
    MP4File ( const MP4File &src );
    MP4File &operator= ( const MP4File &src );

    void MoveMoovAtomToFront();
};

template<> inline uint8_t MP4File::ReadUInt<uint8_t, 8> () { return ReadUInt8(); }
template<> inline uint16_t MP4File::ReadUInt<uint16_t, 16> () { return ReadUInt16(); }
template<> inline uint32_t MP4File::ReadUInt<uint32_t, 24> () { return ReadUInt24(); }
template<> inline uint32_t MP4File::ReadUInt<uint32_t, 32> () { return ReadUInt32(); }
template<> inline uint64_t MP4File::ReadUInt<uint64_t, 64> () { return ReadUInt64(); }

template<> inline void MP4File::WriteUInt<uint8_t, 8> (uint8_t value) { WriteUInt8(value); }
template<> inline void MP4File::WriteUInt<uint16_t, 16> (uint16_t value) { WriteUInt16(value); }
template<> inline void MP4File::WriteUInt<uint32_t, 24> (uint32_t value) { WriteUInt24(value); }
template<> inline void MP4File::WriteUInt<uint32_t, 32> (uint32_t value) { WriteUInt32(value); }
template<> inline void MP4File::WriteUInt<uint64_t, 64> (uint64_t value) { WriteUInt64(value); }

///////////////////////////////////////////////////////////////////////////////

}} // namespace mp4v2::impl

#endif // MP4V2_IMPL_MP4FILE_H
