isobmff/_i_s_o_movies_8h_source.html

#ifndef INCLUDED_ISOMOVIE_H

#define INCLUDED_ISOMOVIE_H


#ifndef INCLUDED_MP4MOVIE_H

#include "MP4Movies.h"

#endif


#ifdef __cplusplus

extern "C"

{

#endif


/* These data types are common to both MPEG-4 and JPEG-2; ideally the "ISO" names should be used. */

#define ISOHandle MP4Handle

#define ISOErr MP4Err

#define ISOMovie MP4Movie

#define ISOTrack MP4Track

#define ISOMedia MP4Media

#define ISOTrackReader MP4TrackReader

#define ISOUserData MP4UserData

#define ISOAtomPtr MP4AtomPtr

#define ISOLinkedList MP4LinkedList


#define ISO_EXTERN MP4_EXTERN


/* These constants are common to both MPEG-4 and JPEG-2; ideally the "ISO" names should be used. */

#define ISOEOF MP4EOF

#define ISONoErr MP4NoErr

#define ISOFileNotFoundErr MP4FileNotFoundErr

#define ISOBadParamErr MP4BadParamErr

#define ISONoMemoryErr MP4NoMemoryErr

#define ISOIOErr MP4IOErr

#define ISONoLargeAtomSupportErr MP4NoLargeAtomSupportErr

#define ISOBadDataErr MP4BadDataErr

#define ISOVersionNotSupportedErr MP4VersionNotSupportedErr

#define ISOInvalidMediaErr MP4InvalidMediaErr

#define ISODataEntryTypeNotSupportedErr MP4DataEntryTypeNotSupportedErr

#define ISONoQTAtomErr MP4NoQTAtomErr

#define ISONotImplementedErr MP4NotImplementedErr


#define ISONewTrackIsVisual MP4NewTrackIsVisual

#define ISONewTrackIsAudio MP4NewTrackIsAudio

#define ISONewTrackIsPrivate MP4NewTrackIsPrivate

#define ISONewTrackIsMetadata MP4NewTrackIsMetadata


#define ISOVisualHandlerType MP4VisualHandlerType

#define ISOAudioHandlerType MP4AudioHandlerType

#define ISOHintHandlerType MP4HintHandlerType

#define ISOVolumetricHandlerType MP4VolumetricHandlerType

#define ISOHapticHandlerType MP4HapticHandlerType


#define ISOOpenMovieNormal MP4OpenMovieNormal

#define ISOOpenMovieDebug MP4OpenMovieDebug

#define ISOOpenMovieInPlace MP4OpenMovieInPlace


  struct MP4BoxedMetadataSampleEntry;


  enum

  {

    ISOGraphicsModeSrcCopy     = 0x00000000,

    ISOGraphicsModeTransparent = 0x00000024,

    ISOGraphicsModeAlpha       = 0x00000100,

    ISOGraphicsModeWhiteAlpha  = 0x00000101,

    ISOGraphicsModeBlackAlpha  = 0x00000102

  };


  struct ISOMatrixRecord

  {

    u32 data[9];

  };


  typedef struct ISOMatrixRecord ISOMatrixRecord;

  typedef ISOMatrixRecord *ISOMatrix;


  struct ISORGBColor

  {

    u16 red;

    u16 green;

    u16 blue;

  };


  typedef struct ISORGBColor ISORGBColor;

  typedef ISORGBColor *ISORGBColorPtr;


  enum

  {

    ISOUnknownFileType        = (u32)0,

    ISOMPEG4FileType          = (u32)1,

    ISOStillJPEG2000FileType  = (u32)2,

    ISOMotionJPEG2000FileType = (u32)3,

    ISOQuickTimeFileType      = (u32)4,

    ISO3GPPFileType           = (u32)5,

    ISOMPEG21FileType         = (u32)6

  };


  enum

  {

    ISOMediaHandlerType = MP4_FOUR_CHAR_CODE('m', 'h', 'l', 'r'),

    ISODataHandlerType  = MP4_FOUR_CHAR_CODE('d', 'h', 'l', 'r')

  };


  enum

  {

    JP2JPEG2000Brand = MP4_FOUR_CHAR_CODE('j', 'p', '2', ' '),

    MJ2JPEG2000Brand = MP4_FOUR_CHAR_CODE('m', 'j', 'p', '2'),

    ISOQuickTimeBrand = MP4_FOUR_CHAR_CODE('q', 't', ' ', ' '),

    ISOMpeg4V1Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '1'),

    ISOMpeg4V2Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '2'),

    ISOISOBrand = MP4_FOUR_CHAR_CODE('i', 's', 'o', 'm'),

    ISOISO2Brand = MP4_FOUR_CHAR_CODE('i', 's', 'o', '2'),

    ISO3GP4Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '4'),

    ISO3GP5Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '5'),

    ISO3GP6Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '6'),

    ISOMPEG21Brand = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'),

    ISOUnknownBrand = MP4_FOUR_CHAR_CODE(' ', ' ', ' ', ' '),

    ISO_DASH_Brand = MP4_FOUR_CHAR_CODE('d', 'a', 's', 'h'),

    ISO_DASH_DSMS_Brand = MP4_FOUR_CHAR_CODE('d', 's', 'm', 's'),

    ISO_DASH_MSDH_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'),

    ISO_DASH_MSIX_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'),

    ISO_DASH_RISX_Brand = MP4_FOUR_CHAR_CODE('r', 'i', 's', 'x'),

    ISO_DASH_LMSG_Brand = MP4_FOUR_CHAR_CODE('l', 'm', 's', 'g'),

    ISO_DASH_SISX_Brand = MP4_FOUR_CHAR_CODE('s', 'i', 's', 'x'),

    ISO_DASH_SSSS_Brand = MP4_FOUR_CHAR_CODE('s', 's', 's', 's')

  };


  enum

  {

    AVCsps    = 1,

    AVCpps    = 2,

    AVCspsext = 3,

    SVCsps    = 0x11,

    SVCpps    = 0x12,

    SVCspsext = 0x13,

    HEVCvps   = 0x20,

    HEVCsps   = 0x21,

    HEVCpps   = 0x22

  };


  enum

  {

    VVCsps         = 15,

    VVCpps         = 16,

    VVCvps         = 14,

    VVCopi         = 12,

    VVCdci         = 13,

    VVC_prefix_aps = 17,

    VVC_prefix_sei = 23

  };


  struct ISOMetaRecord

  {

    void *data;

  };


  typedef struct ISOMetaRecord ISOMetaRecord;

  typedef ISOMetaRecord *ISOMeta;


  struct ISOMetaItemRecord

  {

    void *data;

  };


  typedef struct ISOMetaItemRecord ISOMetaItemRecord;

  typedef ISOMetaItemRecord *ISOMetaItem;


  typedef struct EntityGroupEntry

  {

    u32 grouping_type;

    u32 group_id;

    u32 num_entities_in_group;

    u32 *entity_ids;

  } EntityGroupEntry, *EntityGroupEntryPtr;


/* These functions are general movie-handling functions and are common to both MPEG-4 and JPEG-2;

   ideally the "ISO" names should be used. */

#define ISODisposeMovie MP4DisposeMovie

#define ISOGetMovieTimeScale MP4GetMovieTimeScale

#define ISOGetMovieTrack MP4GetMovieTrack

#define ISOOpenMovieFile MP4OpenMovieFile

#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle

#define ISOSetMovieTimeScale MP4SetMovieTimeScale

#define ISOAddTrackReference MP4AddTrackReference

#define ISOAddSubSampleInformationToTrack MP4AddSubSampleInformationToTrack

#define ISOSetSubSampleInformationFlags MP4SetSubSampleInformationFlags

#define ISOGetSubSampleInformationEntryFromTrack MP4GetSubSampleInformationEntryFromTrack

#define ISOAddSubSampleInformationEntry MP4AddSubSampleInformationEntry

#define ISOAddTrackGroup MP4AddTrackGroup

#define ISOAddTrackReferenceWithID MP4AddTrackReferenceWithID

#define ISOGetMovieIndTrack MP4GetMovieIndTrack

#define ISOGetMovieTrackCount MP4GetMovieTrackCount

#define ISOGetTrackEnabled MP4GetTrackEnabled

#define ISOGetTrackID MP4GetTrackID

#define ISOGetTrackMedia MP4GetTrackMedia

#define ISOGetTrackMovie MP4GetTrackMovie

#define ISOGetTrackOffset MP4GetTrackOffset

#define ISOGetTrackReference MP4GetTrackReference

#define ISOGetTrackReferenceCount MP4GetTrackReferenceCount

#define ISOGetTrackGroup MP4GetTrackGroup

#define ISOInsertMediaIntoTrack MP4InsertMediaIntoTrack

#define ISONewMovieTrack MP4NewMovieTrack

#define ISONewMovieTrackWithID MP4NewMovieTrackWithID

#define ISONewTrackMedia MP4NewTrackMedia

#define ISOSetTrackEnabled MP4SetTrackEnabled

#define ISOSetTrackOffset MP4SetTrackOffset

#define ISOTrackTimeToMediaTime MP4TrackTimeToMediaTime

#define ISOAddMediaDataReference MP4AddMediaDataReference

#define ISOAddMediaSampleReference MP4AddMediaSampleReference

#define ISOAddMediaSamples MP4AddMediaSamples

#define ISOAddMediaSamplesPad MP4AddMediaSamplesPad

#define ISOBeginMediaEdits MP4BeginMediaEdits

#define ISOCheckMediaDataReferences MP4CheckMediaDataReferences

#define ISOEndMediaEdits MP4EndMediaEdits

#define ISOGetIndMediaSample MP4GetIndMediaSample

#define ISOGetIndMediaSampleWithPad MP4GetIndMediaSampleWithPad

#define ISOGetMediaDataReference MP4GetMediaDataReference

#define ISOGetMovieDuration MP4GetMovieDuration

#define ISOGetTrackDuration MP4GetTrackDuration

#define ISOGetMediaDuration MP4GetMediaDuration

#define ISOGetMediaHandlerDescription MP4GetMediaHandlerDescription

#define ISOGetMediaLanguage MP4GetMediaLanguage

#define ISOGetMediaSample MP4GetMediaSample

#define ISOGetMediaSampleWithPad MP4GetMediaSampleWithPad

#define ISOGetMediaSampleCount MP4GetMediaSampleCount

#define ISOGetMediaTimeScale MP4GetMediaTimeScale

#define ISOGetMediaTrack MP4GetMediaTrack

#define ISOMediaTimeToSampleNum MP4MediaTimeToSampleNum

#define ISOSampleNumToMediaTime MP4SampleNumToMediaTime

#define ISOSetMediaLanguage MP4SetMediaLanguage

#define ISOSetMediaExtendedLanguageTag MP4SetMediaExtendedLanguageTag

#define ISOAddUserData MP4AddUserData

#define ISOGetIndUserDataType MP4GetIndUserDataType

#define ISOGetMovieUserData MP4GetMovieUserData

#define ISOGetTrackUserData MP4GetTrackUserData

#define ISOGetUserDataEntryCount MP4GetUserDataEntryCount

#define ISOGetUserDataItem MP4GetUserDataItem

#define ISOGetAtomFromUserData MP4GetAtomFromUserData

#define ISODeleteUserDataItem MP4DeleteUserDataItem

#define ISOGetUserDataTypeCount MP4GetUserDataTypeCount

#define ISONewUserData MP4NewUserData

#define ISOCreateTrackReader MP4CreateTrackReader

#define ISOSetMebxTrackReader MP4SetMebxTrackReader

#define ISODisposeTrackReader MP4DisposeTrackReader

#define ISONewHandle MP4NewHandle

#define ISOSetHandleSize MP4SetHandleSize

#define ISODisposeHandle MP4DisposeHandle

#define ISOGetHandleSize MP4GetHandleSize

#define ISOSetHandleOffset MP4SetHandleOffset

#define ISOUseSignedCompositionTimeOffsets MP4UseSignedCompositionTimeOffsets


#define QTPutMovieIntoHandle MP4PutMovieIntoHandle

#define MJ2PutMovieIntoHandle MP4PutMovieIntoHandle

#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle


#define QTWriteMovieToFile MP4WriteMovieToFile

#define MJ2WriteMovieToFile MP4WriteMovieToFile

#define ISOWriteMovieToFile MP4WriteMovieToFile


#define ISOAddAtomToMovie MP4AddAtomToMovie

#define ISONewForeignAtom MP4NewForeignAtom

#define ISOGetForeignAtom MP4GetForeignAtom

#define ISONewUUIDAtom MP4NewUUIDAtom

#define ISOAddAtomToTrack MP4AddAtomToTrack


#define ISOGetTrackEditlistEntryCount MP4GetTrackEditlistEntryCount

#define ISOGetTrackEditlist MP4GetTrackEditlist


#define ISOGenericAtom MP4GenericAtom


#define MJ2TrackReaderGetNextSample MP4TrackReaderGetNextAccessUnit


  /*************************************************************************************************

   * These functions are specific to Motion JPEG-2; they have only the "MJ2" names.

   ************************************************************************************************/


  ISO_EXTERN(ISOErr) MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9]);

  ISO_EXTERN(ISOErr) MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9]);

  ISO_EXTERN(ISOErr) MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate);

  ISO_EXTERN(ISOErr) MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate);

  ISO_EXTERN(ISOErr) MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume);

  ISO_EXTERN(ISOErr) MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume);

  ISO_EXTERN(ISOErr) MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9]);

  ISO_EXTERN(ISOErr) MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9]);

  ISO_EXTERN(ISOErr) MJ2SetTrackLayer(ISOTrack theTrack, s16 layer);

  ISO_EXTERN(ISOErr) MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer);

  ISO_EXTERN(ISOErr) MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height);

  ISO_EXTERN(ISOErr) MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight);

  ISO_EXTERN(ISOErr) MJ2SetTrackVolume(ISOTrack theTrack, s16 volume);

  ISO_EXTERN(ISOErr) MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume);

  ISO_EXTERN(ISOErr)

  MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor);

  ISO_EXTERN(ISOErr)

  MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor);

  ISO_EXTERN(ISOErr) MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance);

  ISO_EXTERN(ISOErr) MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance);

  ISO_EXTERN(ISOErr) MJ2NewMovie(ISOMovie *outMovie);


  /*************************************************************************************************

   * These functions are specific to 3GPP; they have only the "3GPP" names.

   ************************************************************************************************/


  ISO_EXTERN(ISOErr) New3GPPMovie(ISOMovie *outMovie, u16 release);


  /*************************************************************************************************

   * These functions are specific to QuickTime; they have only the "QT" names.

   ************************************************************************************************/


  ISO_EXTERN(ISOErr) QTNewMovie(ISOMovie *outMovie);


  /*************************************************************************************************

   * These functions are general.

   ************************************************************************************************/


  ISO_EXTERN(ISOErr) ISOWriteMovieToFile(ISOMovie theMovie, const char *filename);

  ISO_EXTERN(ISOErr) ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion);

  ISO_EXTERN(ISOErr) ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand);

  ISO_EXTERN(ISOErr) ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion);

  ISO_EXTERN(ISOErr) ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand);


  /*************************************************************************************************

   * AVC Sample descriptions

   ************************************************************************************************/


  ISO_EXTERN(ISOErr)

  ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                             u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps,

                             MP4Handle first_pps, MP4Handle first_spsext);

  ISO_EXTERN(ISOErr) ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where);

  ISO_EXTERN(ISOErr)

  ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size,

                             u32 *sps_count, u32 *pss_count, u32 *spsext_count);

  ISO_EXTERN(ISOErr)

  ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index);

  ISO_EXTERN(ISOErr)

  ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index);

  ISO_EXTERN(ISOErr)

  ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index);

  ISO_EXTERN(ISOErr) ISOGetNALUnitLength(MP4Handle sampleEntryH, u32 *out);

  ISO_EXTERN(ISOErr) ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt);

  ISO_EXTERN(ISOErr)

  ISOGetRESVSchemeType(MP4Handle sampleEntryH, u32 *schemeType, u32 *schemeVersion,

                       char **schemeURI);

  ISO_EXTERN(ISOErr)

  ISOGetRESVSchemeInfoAtom(MP4Handle sampleEntryH, u32 atomType, MP4Handle outAtom);

  ISO_EXTERN(ISOErr)

  ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                              u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps,

                              MP4Handle first_pps, MP4Handle first_vps);


  ISO_EXTERN(ISOErr)

  ISONewMebxSampleDescription(struct MP4BoxedMetadataSampleEntry **outSE, u32 dataReferenceIndex);


  ISO_EXTERN(ISOErr)

  ISOAddMebxMetadataToSampleEntry(struct MP4BoxedMetadataSampleEntry *mebxSE,

                                  u32 desired_local_key_id, u32 *out_local_key_id,

                                  u32 key_namespace, MP4Handle key_value, char *locale_string,

                                  MP4Handle setupInfo);


  ISO_EXTERN(ISOErr)

  ISOGetMebxHandle(struct MP4BoxedMetadataSampleEntry *mebxSE, MP4Handle sampleDescriptionH);


  ISO_EXTERN(ISOErr)

  ISOGetMebxMetadataCount(MP4Handle sampleEntryH, u32 *key_cnt);


  ISO_EXTERN(ISOErr)

  ISOGetMebxMetadataConfig(MP4Handle sampleEntryH, u32 cnt, u32 *local_key_id, u32 *key_namespace,

                           MP4Handle key_value, char **locale_string, MP4Handle setupInfo);


  /*************************************************************************************************

   * VVC Sample descriptions

   ************************************************************************************************/

  ISO_EXTERN(ISOErr)

  ISONewVVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                             u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps,

                             MP4Handle first_pps);

  MP4_EXTERN(ISOErr)

  ISOGetVVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size,

                             u32 naluType, u32 *count);

  ISO_EXTERN(ISOErr)

  ISOGetVVCNaluNums(MP4Handle sampleEntryH, u32 where, u32 *num_nalus);

  ISO_EXTERN(ISOErr)

  ISOGetVVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index);

  MP4_EXTERN(ISOErr)

  ISOAddVVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where);

  MP4_EXTERN(ISOErr)

  ISONewVVCSubpicSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                                   u32 dataReferenceIndex, u32 width, u32 height, u32 length_size);

  MP4_EXTERN(ISOErr)

  ISOGetVVCSubpicSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex,

                                   u32 *length_size);


  /*************************************************************************************************

   * 3GPP media

   ************************************************************************************************/

  MP4_EXTERN(MP4Err)

  ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB,

                                   u32 maxBitrate, u32 avgBitrate);

  MP4_EXTERN(MP4Err)

  ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                              u32 dataReferenceIndex, u32 vendor, u8 decoder_version, u8 H263_level,

                              u8 H263_profile);

  MP4_EXTERN(MP4Err)

  ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                             u32 dataReferenceIndex, u8 is_WB, u32 vendor, u8 decoder_version,

                             u16 mode_set, u8 mode_change_period, u8 frames_per_sample);

  MP4_EXTERN(MP4Err)

  ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH,

                               u32 dataReferenceIndex, u32 vendor, u8 decoder_version);


  /*************************************************************************************************

   * Meta Data

   ************************************************************************************************/

  ISO_EXTERN(ISOErr) ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta);

  ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta);

  ISO_EXTERN(ISOErr) ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *meta);

  ISO_EXTERN(ISOErr)

  ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type);

  ISO_EXTERN(ISOErr)

  ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type);

  ISO_EXTERN(ISOErr)

  ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHandle urnHandle);

  ISO_EXTERN(ISOErr)

  ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index);

  ISO_EXTERN(ISOErr)

  ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index,

                       u16 item_ID);

  ISO_EXTERN(ISOErr) ISOAddItemExtent(ISOMetaItem item, MP4Handle data);

  ISO_EXTERN(ISOErr) ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length);

  ISO_EXTERN(ISOErr) ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data);

  ISO_EXTERN(ISOErr)

  ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length);

  ISO_EXTERN(ISOErr)

  ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex);

  ISO_EXTERN(ISOErr)

  ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count,

                       MP4Handle to_item_IDs);

  MP4_EXTERN(MP4Err)

  ISOAddItemRelation(ISOMetaItem fromItem, ISOMetaItem toItem, u32 relationType);

  ISO_EXTERN(ISOErr)

  ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count,

                       MP4Handle to_item_IDs);

  ISO_EXTERN(ISOErr)

  ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index,

                      ISOMetaItem *outItem);

  ISO_EXTERN(ISOErr) ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom);

  ISO_EXTERN(ISOErr) ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom);

  ISO_EXTERN(ISOErr)

  ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom);

  ISO_EXTERN(ISOErr) ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item);

  ISO_EXTERN(ISOErr) ISOGetPrimaryItemID(ISOMeta meta, u16 *ID);

  ISO_EXTERN(ISOErr) ISOGetItemID(ISOMetaItem item, u16 *ID);

  ISO_EXTERN(ISOErr)

  ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content_type,

                 char *content_encoding);

  ISO_EXTERN(ISOErr)

  ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 extension_type);

  ISO_EXTERN(ISOErr)

  ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 *extension_type);

  ISO_EXTERN(ISOErr) ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type);

  ISO_EXTERN(ISOErr) ISOHideItem(ISOMetaItem item);

  ISO_EXTERN(ISOErr) ISOIsItemHidden(ISOMetaItem item);

  ISO_EXTERN(ISOErr) ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type);

  ISO_EXTERN(ISOErr)

  ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType);

  ISO_EXTERN(ISOErr)

  ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType);

  ISO_EXTERN(ISOErr)

  ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, u32 *outMetaType);

  ISO_EXTERN(ISOErr)

  ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound);

  ISO_EXTERN(ISOErr) ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case);

  ISO_EXTERN(ISOErr) ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID);

  ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset);

  ISO_EXTERN(ISOErr)

  ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *content_type,

                 char *content_encoding);

  ISO_EXTERN(MP4Err) ISOCheckMetaDataReferences(ISOMeta meta);

  ISO_EXTERN(MP4Err)

  ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url,

                       u16 *protection_index);

  ISO_EXTERN(MP4Err)

  ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom);

  ISO_EXTERN(MP4Err)

  ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, u32 *sch_version,

                       char *sch_url);

  ISO_EXTERN(MP4Err)

  ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type,

                           MP4GenericAtom *schi_atom);

  ISO_EXTERN(MP4Err)

  ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essential);

  ISO_EXTERN(MP4Err)

  ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *propertiesFound);

  ISO_EXTERN(ISOErr) ISONewEntityGroup(ISOMeta meta, u32 grouping_type, u32 group_id);

  ISO_EXTERN(ISOErr) ISOAddEntityIDToGroup(ISOMeta meta, u32 group_id, u32 entity_id);

  ISO_EXTERN(ISOErr) ISOGetEntityIDCnt(ISOMeta meta, u32 group_id, u32 *num_entities_in_group);

  ISO_EXTERN(ISOErr)

  ISOGetEntityGroupEntries(ISOMeta meta, EntityGroupEntryPtr *pEntries, u32 *cnt);


#ifdef PRAGMA_EXPORT

#pragma export on

#endif


#ifdef __cplusplus

}

#endif

#ifdef PRAGMA_EXPORT

#pragma export off

#endif


#endif

ISOGetMebxMetadataCount
ISOErr ISOGetMebxMetadataCount(MP4Handle sampleEntryH, u32 *key_cnt)
Get the number of entries in the mebx sample entry.

QTNewMovie
ISOErr QTNewMovie(ISOMovie *outMovie)
Creaets a new empty QT Movie in memory.

MJ2SetMediaSoundBalance
ISOErr MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance)
Sets the left-right balance of an audio track (normally a mono track).

ISOAddMebxMetadataToSampleEntry
ISOErr ISOAddMebxMetadataToSampleEntry(struct MP4BoxedMetadataSampleEntry *mebxSE, u32 desired_local_key_id, u32 *out_local_key_id, u32 key_namespace, MP4Handle key_value, char *locale_string, MP4Handle setupInfo)
Add a new metadata type to mebx sample entry.

MJ2SetMediaGraphicsMode
ISOErr MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor)
Sets the graphics mode for this track.

MJ2GetMediaGraphicsMode
ISOErr MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor)
Returns the currently set graphics mode.

MJ2GetMediaSoundBalance
ISOErr MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance)
Returns the currently set balance value.

MP4Movies.h
API.

ISOSetPrimaryItem
ISOErr ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item)
Sets the item of the indicated ID as the primary item (using a primary item box).

ISOGetProperitesOfMetaItem
MP4Err ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *propertiesFound)
Retruns an array of MP4GenericAtom pointers, which represent the item properties found for the item g...

ISONewMetaProtection
MP4Err ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, u16 *protection_index)
Creates a new item protection information inside the given meta-data box.

ISONewMovieMeta
ISOErr ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta)
Creates a new meta box (atom), with the indicated ‘handler’ type, in the movie box (atom).

ISOSetItemInfo
ISOErr ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content_type, char *content_encoding)
Sets the information for the indicated item.

ISOAddMetaItemWithID
ISOErr ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index, u16 item_ID)
Creates a new meta-data item with specific ID, and returns an opaque pointer to it.

ISOSetItemInfoExtension
ISOErr ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 extension_type)
Adds an item info extension to an existing item info entry.

ISOGetEntityIDCnt
ISOErr ISOGetEntityIDCnt(ISOMeta meta, u32 group_id, u32 *num_entities_in_group)
Get number of entries in the EntityToGroupBox.

ISOAddItemRelation
MP4Err ISOAddItemRelation(ISOMetaItem fromItem, ISOMetaItem toItem, u32 relationType)

ISOAddMetaDataReference
ISOErr ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHandle urnHandle)
Adds a data reference to the given meta-data.

ISOAddItemExtent
ISOErr ISOAddItemExtent(ISOMetaItem item, MP4Handle data)
Adds some data to the given item, as its first (perhaps only) extent.

ISOGetItemID
ISOErr ISOGetItemID(ISOMetaItem item, u16 *ID)
Gets the ID of the indicated item.

ISOGetEntityGroupEntries
ISOErr ISOGetEntityGroupEntries(ISOMeta meta, EntityGroupEntryPtr *pEntries, u32 *cnt)
Get common data for all EntityToGroup entries.

ISOAddItemReference
ISOErr ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex)
This function adds an item reference to the item reference box.

ISOAddMetaProtectionInfo
MP4Err ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom)
Adds an arbitrary atom to the scheme information of the associated protection information.

ISOFindItemByID
ISOErr ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID)
Gets a reference to an item by its ID.

ISOGetItemData
ISOErr ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset)
Reads and returns the data associated with all the extents of the given item, concatenating them.

ISOGetItemInfoExtension
ISOErr ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 *extension_type)
Gets an item info extension and its extension type from an item.

ISOAddItemExtentItem
ISOErr ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length)
Indicates that the data for this extent is located at another item’s extends.

ISOGetMetaBoxRelation
ISOErr ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type)
Get the reletation type.

ISONewTrackMeta
ISOErr ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *meta)
Creates a new meta box (atom), with the indicated ‘handler’ type, in the indicated track box (atom).

ISOGetItemReference
ISOErr ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, ISOMetaItem *outItem)
Get an item by reference type and index.

ISOGetAllItemsWithType
ISOErr ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound)
Collects all items of a given type and presents the result in form of an array.

ISOGetItemInfoItemType
ISOErr ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type)
Gets an item info item type from an existing item info entry.

ISOSetItemInfoItemType
ISOErr ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type)
Adds an item info item type to an existing item info entry.

ISOGetPrimaryData
ISOErr ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom)
Finds the box of the given type inside the meta box, and returns its contents.

ISOGetItemInfo
ISOErr ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *content_type, char *content_encoding)
Returns the information for a given item.

ISOGetItemReferences
ISOErr ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, MP4Handle to_item_IDs)
This function collects all item references of the item / reference_type combination.

ISOAddItemExtentUsingItemData
ISOErr ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data)
Adds some data to the given item, as its first (perhaps only) extent.

ISOAddItemReferences
ISOErr ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, MP4Handle to_item_IDs)
This function adds multiple item references to the item reference box.

ISOAddMetaBoxRelation
ISOErr ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type)
Adds a meta box relation box to the additional meta data box, related to first and second meta box.

ISOGetMetaProtection
MP4Err ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, u32 *sch_version, char *sch_url)
Gets the scheme type, version, and URL associated with the protection information of the given index.

ISOAddMetaItemProperty
MP4Err ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essential)
Adds an item property, which can be any MP4GenericAtom, to an ISOMetaItem.

ISOGetFileMeta
ISOErr ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType)
Gets a reference to the file-level meta data.

ISOGetMetaProtectionInfo
MP4Err ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type, MP4GenericAtom *schi_atom)
Finds and returns the atom of the given type inside the scheme information of the protection scheme a...

ISOGetMovieMeta
ISOErr ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType)
Gets a reference to the movie-level meta data.

ISOCheckMetaDataReferences
MP4Err ISOCheckMetaDataReferences(ISOMeta meta)
Checks that all the data references used by the meta-data are accessible.

ISOGetTrackMeta
ISOErr ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, u32 *outMetaType)
Gets a reference to the track-level meta data.

ISOAddMetaItem
ISOErr ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index)
Creates a new meta-data item, and returns an opaque pointer to it.

ISONewFileMeta
ISOErr ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta)
Creates a new meta box (atom), with the indicated ‘handler’ type, at the file level.

ISOGetPrimaryItemID
ISOErr ISOGetPrimaryItemID(ISOMeta meta, u16 *ID)
Finds the ID of the primary item.

ISOHideItem
ISOErr ISOHideItem(ISOMetaItem item)
Hide item by setting the (flags & 1) = 1.

ISONewEntityGroup
ISOErr ISONewEntityGroup(ISOMeta meta, u32 grouping_type, u32 group_id)
Add new EntityToGroupBox (creates grpl if needed)

ISOGetPrimaryItemData
ISOErr ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom)
Finds the box of the given type inside the meta box, and returns its contents.

ISOFindItemByName
ISOErr ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case)
Finds an item that has the associated name in its item information.

ISOAddEntityIDToGroup
ISOErr ISOAddEntityIDToGroup(ISOMeta meta, u32 group_id, u32 entity_id)
Add entity_id to EntityToGroupBox.

ISOAddItemExtentReference
ISOErr ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length)
Adds a reference to the data.

ISOIsItemHidden
ISOErr ISOIsItemHidden(ISOMetaItem item)
Check if item is hiden.

ISOAddPrimaryData
ISOErr ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom)
Places the indicated data inside a box in the meta-box, with the indicated box type (e....

MJ2GetMovieMatrix
ISOErr MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9])
This returns the overall transformation matrix for the movie.

MJ2SetMovieMatrix
ISOErr MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9])
This sets the matrix of the overall movie.

New3GPPMovie
ISOErr New3GPPMovie(ISOMovie *outMovie, u16 release)
Creates a new empty 3GPP Movie in memory, and sets the brand to the indicated release (4,...

MJ2SetMoviePreferredRate
ISOErr MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate)
This sets the rate of the movie (the normal and default rate is 1.0).

MJ2GetMoviePreferredRate
ISOErr MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate)
This returns the currently set movie preferred rate.

ISOSetMovieCompatibleBrand
ISOErr ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand)
Adds a minor brand into the compatible brands list of the Movie.

ISOSetMovieBrand
ISOErr ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion)
Sets the Movie’s major brand.

MJ2GetMoviePreferredVolume
ISOErr MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume)
This returns the movie volume setting.

MJ2SetMoviePreferredVolume
ISOErr MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume)
This sets the normal volume of the movie.

ISOIsMovieCompatibleBrand
ISOErr ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand)
If the brand is a compatible brand of the movie, this returns MP4NoErr, otherwise it returns MP4NotFo...

ISOGetMovieBrand
ISOErr ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion)
Returns the Movie’s major brand and minor version.

MJ2NewMovie
ISOErr MJ2NewMovie(ISOMovie *outMovie)
Creates a new empty Motion JPEG 2000 Movie in memory.

ISOGetVCSampleDescriptionPS
ISOErr ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index)
Gets an AVC parameter set, placing it in the given handle.

ISONewAVCSampleDescription
ISOErr ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, MP4Handle first_pps, MP4Handle first_spsext)
Create a new AVC sample entry.

ISOGetRESVSampleDescriptionPS
ISOErr ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index)
Gets a restricted video parameter set (AVC or HEVC), placing it in the given handle.

ISOGetRESVOriginalFormat
ISOErr ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt)
Get the four character code of the original un-transformed sample entry.

ISONewHEVCSampleDescription
ISOErr ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, MP4Handle first_pps, MP4Handle first_vps)
Create a new HEVC sample entry.

ISOGetVVCSampleDescription
ISOErr ISOGetVVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size, u32 naluType, u32 *count)
Gets the basic parameters of the VVC sample entry.

ISOGetVVCNaluNums
ISOErr ISOGetVVCNaluNums(MP4Handle sampleEntryH, u32 where, u32 *num_nalus)
Gets a VVC parameter set, placing it in the given handle.

ISOGetRESVSchemeType
ISOErr ISOGetRESVSchemeType(MP4Handle sampleEntryH, u32 *schemeType, u32 *schemeVersion, char **schemeURI)
Get scheme_type and scheme_version from the SchemeTypeBox in resv.

ISONewH263SampleDescription
MP4Err ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 vendor, u8 decoder_version, u8 H263_level, u8 H263_profile)
Creates a new H.263 video sample description according to the 3GPP specifications.

ISOGetVVCSampleDescriptionPS
ISOErr ISOGetVVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index)
Gets a VVC parameter set, placing it in the given handle.

ISONewAMRWPSampleDescription
MP4Err ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 vendor, u8 decoder_version)
Creates a new AMR wideband plus audio sample description according to the 3GPP spec.

ISOGetAVCSampleDescription
ISOErr ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size, u32 *sps_count, u32 *pss_count, u32 *spsext_count)
Gets the basic parameters of the AVC sample entry.

ISOGetNALUnitLength
ISOErr ISOGetNALUnitLength(MP4Handle sampleEntryH, u32 *out)
Get the NALUnitLength size in bytes.

ISONewVVCSubpicSampleDescription
ISOErr ISONewVVCSubpicSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 width, u32 height, u32 length_size)
Create a new VVC subpicture (vvs1) sample entry.

ISOGetRESVSchemeInfoAtom
ISOErr ISOGetRESVSchemeInfoAtom(MP4Handle sampleEntryH, u32 atomType, MP4Handle outAtom)
Get the box from the SchemeInformationBox in resv.

ISOAddBitrateToSampleDescription
MP4Err ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, u32 maxBitrate, u32 avgBitrate)
Add a bitrate atom to a sample entry (description).

ISONewAMRSampleDescription
MP4Err ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u8 is_WB, u32 vendor, u8 decoder_version, u16 mode_set, u8 mode_change_period, u8 frames_per_sample)
Creates a new AMR audio sample description according to the 3GPP specifications.

ISOGetHEVCSampleDescriptionPS
ISOErr ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index)
Gets a HEVC parameter set, placing it in the given handle.

ISONewVVCSampleDescription
ISOErr ISONewVVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, MP4Handle first_pps)
Create a new VVC sample entry.

ISOAddVCSampleDescriptionPS
ISOErr ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where)
This adds another parameter set (which is not, in fact, inspected), to the configuration.

ISONewMebxSampleDescription
ISOErr ISONewMebxSampleDescription(struct MP4BoxedMetadataSampleEntry **outSE, u32 dataReferenceIndex)
Construct a new mebx sample entry.

ISOAddVVCSampleDescriptionPS
ISOErr ISOAddVVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where)
This adds another parameter set (which is not, in fact, inspected), to the configuration.

ISOGetVVCSubpicSampleDescription
ISOErr ISOGetVVCSubpicSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size)
Gets the length size of the VVC subpicture sample entry.

MJ2GetTrackMatrix
ISOErr MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9])
This returns the current matrix.

MJ2SetTrackMatrix
ISOErr MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9])
This sets the overall transformation matrix for the movie as a whole.

MJ2SetTrackLayer
ISOErr MJ2SetTrackLayer(ISOTrack theTrack, s16 layer)
This sets the ordering of the visual tracks.

MJ2SetTrackVolume
ISOErr MJ2SetTrackVolume(ISOTrack theTrack, s16 volume)
This sets the normal volume of the track.

MJ2GetTrackDimensions
ISOErr MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight)
This returns the currently set dimensions.

MJ2GetTrackVolume
ISOErr MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume)
Returns the currently set track volume.

MJ2GetTrackLayer
ISOErr MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer)
This returns the currently set track layer.

MJ2SetTrackDimensions
ISOErr MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height)
This sets the width and height of a track.

MP4Err
int MP4Err
This is a typedef for function error codes.
Definition MP4Movies.h:34

MP4Handle
char ** MP4Handle
MP4Handle is used to pass sections of dynamically allocated memory to the API.
Definition MP4Movies.h:274

ISOMetaItem
ISOMetaItemRecord * ISOMetaItem
This is an opaque handle that contains a reference to a rich meta-data item.
Definition ISOMovies.h:233

MP4_FOUR_CHAR_CODE
#define MP4_FOUR_CHAR_CODE(a, b, c, d)
Makes a four-character code when needed.
Definition MP4OSMacros.h:51

ISOMeta
ISOMetaRecord * ISOMeta
This is an opaque handle that contains a reference to rich meta-data.
Definition ISOMovies.h:219

ISOUnknownBrand
@ ISOUnknownBrand
default 'brand'
Definition ISOMovies.h:153

ISO_DASH_MSIX_Brand
@ ISO_DASH_MSIX_Brand
DASH indexed media segment.
Definition ISOMovies.h:161

ISO_DASH_DSMS_Brand
@ ISO_DASH_DSMS_Brand
DASH self-initializing media seg.
Definition ISOMovies.h:157

ISO3GP5Brand
@ ISO3GP5Brand
3GPP Release 5
Definition ISOMovies.h:147

MJ2JPEG2000Brand
@ MJ2JPEG2000Brand
brand for Motion JPEG-2000
Definition ISOMovies.h:133

ISO_DASH_MSDH_Brand
@ ISO_DASH_MSDH_Brand
DASH general format media segment.
Definition ISOMovies.h:159

ISO_DASH_Brand
@ ISO_DASH_Brand
DASH (ISO/IEC 23009-1)
Definition ISOMovies.h:155

ISOMpeg4V1Brand
@ ISOMpeg4V1Brand
brand for MPEG-4 version 1
Definition ISOMovies.h:137

ISOMPEG21Brand
@ ISOMPEG21Brand
MPEG-21.
Definition ISOMovies.h:151

ISOQuickTimeBrand
@ ISOQuickTimeBrand
brand for QuickTime
Definition ISOMovies.h:135

ISOMpeg4V2Brand
@ ISOMpeg4V2Brand
brand for MPEG-4 version 2
Definition ISOMovies.h:139

ISO_DASH_RISX_Brand
@ ISO_DASH_RISX_Brand
DASH representation index segment.
Definition ISOMovies.h:163

JP2JPEG2000Brand
@ JP2JPEG2000Brand
brand for JPEG-2000
Definition ISOMovies.h:131

ISO3GP6Brand
@ ISO3GP6Brand
3GPP Release 6
Definition ISOMovies.h:149

ISO_DASH_SISX_Brand
@ ISO_DASH_SISX_Brand
DASH single index segment.
Definition ISOMovies.h:167

ISOISOBrand
@ ISOISOBrand
conforming brand for all files
Definition ISOMovies.h:141

ISO_DASH_SSSS_Brand
@ ISO_DASH_SSSS_Brand
DASH subsegment index segment.
Definition ISOMovies.h:169

ISO3GP4Brand
@ ISO3GP4Brand
3GPP Release 4
Definition ISOMovies.h:145

ISOISO2Brand
@ ISOISO2Brand
conforming brand for all files
Definition ISOMovies.h:143

ISO_DASH_LMSG_Brand
@ ISO_DASH_LMSG_Brand
DASH last media segment indicator.
Definition ISOMovies.h:165

AVCpps
@ AVCpps
AVC Picture parameter set.
Definition ISOMovies.h:181

SVCpps
@ SVCpps
SVC Picture parameter set.
Definition ISOMovies.h:184

AVCspsext
@ AVCspsext
AVC Sequence parameter set extension.
Definition ISOMovies.h:182

AVCsps
@ AVCsps
AVC Sequence parameter set.
Definition ISOMovies.h:180

SVCspsext
@ SVCspsext
SVC SPS extension.
Definition ISOMovies.h:185

HEVCsps
@ HEVCsps
HEVC Sequence Parameter Set.
Definition ISOMovies.h:187

SVCsps
@ SVCsps
SVC Sequence parameter set.
Definition ISOMovies.h:183

HEVCvps
@ HEVCvps
HEVC Video Parameter Set.
Definition ISOMovies.h:186

HEVCpps
@ HEVCpps
HEVC Picture Parameter Set.
Definition ISOMovies.h:188

EntityGroupEntry
Structure which contanis all the common parameters of an EntityGroup.
Definition ISOMovies.h:240

ISOMatrixRecord
These data types are specific to JPEG-2; however, they have "ISO" names.
Definition ISOMovies.h:83

ISOMetaItemRecord
Meta-item records.
Definition ISOMovies.h:225

ISOMetaRecord
Meta-data records.
Definition ISOMovies.h:211

ISORGBColor
RGB color type.
Definition ISOMovies.h:93

MP4GenericAtomRecord
Definition MP4Movies.h:256

MP4TrackRecord
Definition MP4Movies.h:209