mp4file.h

6410BSP1

    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 try_udta = false);
    bool GetMetadataString(const char *atom, char **value, bool try_udta = false);
    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);
    u_int32_t GetMetadataCoverArtCount(void);
    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);
    #ifdef _WIN32
    void Open(const wchar_t* fmode);
    #endif
    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;
    #ifdef _WIN32
    wchar_t*        m_fileName_w;
    #endif
    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__ */