summaryrefslogtreecommitdiff
path: root/common/quicktime_win32/MoviesFormat.h
diff options
context:
space:
mode:
Diffstat (limited to 'common/quicktime_win32/MoviesFormat.h')
-rw-r--r--common/quicktime_win32/MoviesFormat.h875
1 files changed, 875 insertions, 0 deletions
diff --git a/common/quicktime_win32/MoviesFormat.h b/common/quicktime_win32/MoviesFormat.h
new file mode 100644
index 0000000..85c7c6a
--- /dev/null
+++ b/common/quicktime_win32/MoviesFormat.h
@@ -0,0 +1,875 @@
+/*
+ File: MoviesFormat.h
+
+ Contains: QuickTime Interfaces.
+
+ Version: QuickTime 7.3
+
+ Copyright: (c) 2007 (c) 1990-2007 by Apple Inc., all rights reserved
+
+ Bugs?: For bug reports, consult the following page on
+ the World Wide Web:
+
+ http://developer.apple.com/bugreporter/
+
+*/
+#ifndef __MOVIESFORMAT__
+#define __MOVIESFORMAT__
+
+#ifndef __MACTYPES__
+#include <MacTypes.h>
+#endif
+
+#ifndef __MOVIES__
+#include <Movies.h>
+#endif
+
+
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if PRAGMA_IMPORT
+#pragma import on
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+ #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+ #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+ #pragma pack(2)
+#endif
+
+/* QuickTime is not available to 64-bit clients */
+
+#if !__LP64__
+
+enum {
+ kMovieVersion = 0 /* version number of the format here described */
+};
+
+/****************************************
+*
+* General Types -
+* These types are used in more than one of the
+* directory types.
+*
+****************************************/
+/* MoviesUserData is the type used for user data in movie and track directories */
+struct MoviesUserData {
+ long size; /* size of this user data */
+ long udType; /* type of user data */
+ char data[1]; /* the user data */
+};
+typedef struct MoviesUserData MoviesUserData;
+struct UserDataAtom {
+ long size;
+ long atomType;
+ MoviesUserData userData[1];
+};
+typedef struct UserDataAtom UserDataAtom;
+/* MoviesDataDescription tells us where the data for the movie or track lives.
+ The data can follow the directory, be in the datafork of the same file as the directory resource,
+ be in the resource fork of the same file as the directory resource, be in another file in the
+ data fork or resource fork, or require a specific bottleneck to fetch the data. */
+/****************************************
+*
+* MediaDirectory information -
+* The MediaDirectory is tightly coupled to the data.
+*
+****************************************/
+/* SampleDescription is in Movies.h */
+struct SampleDescriptionAtom {
+ long size;
+ long atomType; /* = 'stsd' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ SampleDescription sampleDescTable[1];
+};
+typedef struct SampleDescriptionAtom SampleDescriptionAtom;
+/* TimeToSampleNum maps physical sample time to physical sample number. */
+struct TimeToSampleNum {
+ long sampleCount;
+ TimeValue sampleDuration;
+};
+typedef struct TimeToSampleNum TimeToSampleNum;
+struct TimeToSampleNumAtom {
+ long size;
+ long atomType; /* = 'stts' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ TimeToSampleNum timeToSampleNumTable[1];
+};
+typedef struct TimeToSampleNumAtom TimeToSampleNumAtom;
+/* SyncSamples is a list of the physical samples which are self contained. */
+struct SyncSampleAtom {
+ long size;
+ long atomType; /* = 'stss' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ long syncSampleTable[1];
+};
+typedef struct SyncSampleAtom SyncSampleAtom;
+/* SampleToChunk maps physical sample number to chunk number. */
+/* same as SampleToChunk, but redundant first sample is removed */
+struct SampleToChunk {
+ long firstChunk;
+ long samplesPerChunk;
+ long sampleDescriptionID;
+};
+typedef struct SampleToChunk SampleToChunk;
+struct SampleToChunkAtom {
+ long size;
+ long atomType; /* = 'stsc' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ SampleToChunk sampleToChunkTable[1];
+};
+typedef struct SampleToChunkAtom SampleToChunkAtom;
+struct ChunkOffsetAtom {
+ long size;
+ long atomType; /* = 'stco' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ long chunkOffsetTable[1];
+};
+typedef struct ChunkOffsetAtom ChunkOffsetAtom;
+struct SampleSizeAtom {
+ long size;
+ long atomType; /* = 'stsz' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long sampleSize;
+ long numEntries;
+ long sampleSizeTable[1];
+};
+typedef struct SampleSizeAtom SampleSizeAtom;
+struct ShadowSync {
+ long fdSampleNum;
+ long syncSampleNum;
+};
+typedef struct ShadowSync ShadowSync;
+struct ShadowSyncAtom {
+ long size;
+ long atomType; /* = 'stsz' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ ShadowSync shadowSyncTable[1];
+};
+typedef struct ShadowSyncAtom ShadowSyncAtom;
+/* CompositionOffsetEntry maps sample numbers to composition offsets. */
+struct CompositionOffsetEntry {
+ long sampleCount;
+ TimeValue displayOffset;
+};
+typedef struct CompositionOffsetEntry CompositionOffsetEntry;
+struct CompositionOffsetAtom {
+ long size;
+ long atomType; /* = 'ctts' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ CompositionOffsetEntry compositionOffsetTable[1];
+};
+typedef struct CompositionOffsetAtom CompositionOffsetAtom;
+struct SampleDependencyAtom {
+ long size;
+ long atomType; /* = 'sdtp' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ UInt8 sampleDependencyTable[1];
+};
+typedef struct SampleDependencyAtom SampleDependencyAtom;
+/*
+NOTE: The values for these flags that shipped with QuickTime 7.0 were incorrect.
+They matched neither the specification nor the implementation -- the "Yes" and "No" bits
+were reversed. The flags have been corrected but renamed to ensure that code using
+the incorrect flags is reviewed by developers.
+enum {
+ kQTSampleDependency_DependsOnOthers = 1<<5, // INCORRECT VALUE
+ kQTSampleDependency_DoesNotDependOnOthers = 1<<4, // INCORRECT VALUE
+ kQTSampleDependency_IsDependedOnByOthers = 1<<3, // INCORRECT VALUE
+ kQTSampleDependency_IsNotDependedOnByOthers = 1<<2, // INCORRECT VALUE
+ kQTSampleDependency_HasRedundantCoding = 1<<1, // INCORRECT VALUE
+ kQTSampleDependency_HasNoRedundantCoding = 1<<0 // INCORRECT VALUE
+};
+*/
+/* Values for entries in SampleDependencyAtom.sampleDependencyTable[]*/
+enum {
+ /* bit 0x80 is reserved; bit combinations 0x30, 0xC0 and 0x03 are reserved*/
+ kQTSampleDependency_EarlierDisplayTimesAllowed = 1 << 6, /* corresponds to flag mediaSampleEarlierDisplayTimesAllowed except at different bit offset*/
+ kQTSampleDependency_DoesNotDependOnOthers_Corrected = 1 << 5, /* ie: an I picture*/
+ kQTSampleDependency_DependsOnOthers_Corrected = 1 << 4, /* ie: not an I picture*/
+ kQTSampleDependency_IsNotDependedOnByOthers_Corrected = 1 << 3, /* mediaSampleDroppable*/
+ kQTSampleDependency_IsDependedOnByOthers_Corrected = 1 << 2,
+ kQTSampleDependency_HasNoRedundantCoding_Corrected = 1 << 1,
+ kQTSampleDependency_HasRedundantCoding_Corrected = 1 << 0
+};
+
+struct CompositionShiftLeastGreatestAtom {
+ long size;
+ long atomType; /* = 'cslg' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ SInt32 compositionOffsetToDTDDeltaShift;
+ SInt32 leastDecodeToDisplayDelta;
+ SInt32 greatestDecodeToDisplayDelta;
+ SInt32 displayStartTime;
+ SInt32 displayEndTime;
+};
+typedef struct CompositionShiftLeastGreatestAtom CompositionShiftLeastGreatestAtom;
+struct PartialSyncSampleAtom {
+ long size;
+ long atomType; /* = 'stps' */
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ long numEntries;
+ UInt32 partialSyncSampleTable[1];
+};
+typedef struct PartialSyncSampleAtom PartialSyncSampleAtom;
+struct SampleTableAtom {
+ long size;
+ long atomType; /* = 'stbl' */
+
+ SampleDescriptionAtom sampleDescription;
+ TimeToSampleNumAtom timeToSampleNum;
+ SampleToChunkAtom sampleToChunk;
+ SyncSampleAtom syncSample;
+ SampleSizeAtom sampleSize;
+ ChunkOffsetAtom chunkOffset;
+ ShadowSyncAtom shadowSync;
+};
+typedef struct SampleTableAtom SampleTableAtom;
+struct PublicHandlerInfo {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long componentType;
+ long componentSubType;
+ long componentManufacturer;
+ long componentFlags;
+ long componentFlagsMask;
+ char componentName[1];
+};
+typedef struct PublicHandlerInfo PublicHandlerInfo;
+struct HandlerAtom {
+ long size;
+ long atomType; /* = 'hdlr' */
+
+ PublicHandlerInfo hInfo;
+};
+typedef struct HandlerAtom HandlerAtom;
+/* a data reference is a private structure */
+
+typedef long DataRefAtom;
+struct DataInfoAtom {
+ long size;
+ long atomType; /* = 'dinf' */
+
+ DataRefAtom dataRef;
+};
+typedef struct DataInfoAtom DataInfoAtom;
+struct RgnAtom {
+ long size;
+ long atomType;
+
+ short rgnSize;
+ Rect rgnBBox;
+ char data[1];
+};
+typedef struct RgnAtom RgnAtom;
+struct MatteCompressedAtom {
+ long size;
+ long atomType;
+
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ ImageDescription matteImageDescription;
+
+ char matteData[1];
+};
+typedef struct MatteCompressedAtom MatteCompressedAtom;
+struct MatteAtom {
+ long size;
+ long atomType;
+
+ MatteCompressedAtom aCompressedMatte;
+};
+typedef struct MatteAtom MatteAtom;
+struct ClippingAtom {
+ long size;
+ long atomType;
+
+ RgnAtom aRgnClip;
+};
+typedef struct ClippingAtom ClippingAtom;
+/***********************
+* Media Info Example Structures
+***********************/
+
+struct VideoMediaInfoHeader {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ short graphicsMode; /* for QD - transfer mode */
+ short opColorRed; /* opcolor for transfer mode */
+ short opColorGreen;
+ short opColorBlue;
+};
+typedef struct VideoMediaInfoHeader VideoMediaInfoHeader;
+struct VideoMediaInfoHeaderAtom {
+ long size; /* size of Media info */
+ long atomType; /* = 'vmhd' */
+ VideoMediaInfoHeader vmiHeader;
+};
+typedef struct VideoMediaInfoHeaderAtom VideoMediaInfoHeaderAtom;
+struct VideoMediaInfo {
+ long size; /* size of Media info */
+ long atomType; /* = 'minf' */
+
+ VideoMediaInfoHeaderAtom header;
+
+ HandlerAtom dataHandler;
+
+ DataInfoAtom dataInfo;
+
+ SampleTableAtom sampleTable;
+};
+typedef struct VideoMediaInfo VideoMediaInfo;
+struct SoundMediaInfoHeader {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ short balance;
+ short rsrvd;
+};
+typedef struct SoundMediaInfoHeader SoundMediaInfoHeader;
+struct SoundMediaInfoHeaderAtom {
+ long size; /* size of Media info */
+ long atomType; /* = 'vmhd' */
+
+ SoundMediaInfoHeader smiHeader;
+};
+typedef struct SoundMediaInfoHeaderAtom SoundMediaInfoHeaderAtom;
+struct SoundMediaInfo {
+ long size; /* size of Media info */
+ long atomType; /* = 'minf' */
+
+ SoundMediaInfoHeaderAtom header;
+
+ HandlerAtom dataHandler;
+
+ DataRefAtom dataReference;
+
+ SampleTableAtom sampleTable;
+};
+typedef struct SoundMediaInfo SoundMediaInfo;
+/* whatever data the media handler needs goes after the atomType */
+struct MediaInfo {
+ long size;
+ long atomType;
+};
+typedef struct MediaInfo MediaInfo;
+/***********************
+* Media Directory Structures
+***********************/
+struct MediaHeader {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long creationTime; /* seconds since Jan 1904 when directory was created */
+ long modificationTime; /* seconds since Jan 1904 when directory was appended */
+
+ TimeValue timeScale; /* start time for Media (Media time) */
+ TimeValue duration; /* length of Media (Media time) */
+
+ short language;
+ short quality;
+};
+typedef struct MediaHeader MediaHeader;
+struct MediaHeaderAtom {
+ long size;
+ long atomType;
+
+ MediaHeader header;
+};
+typedef struct MediaHeaderAtom MediaHeaderAtom;
+struct MediaDirectory {
+ long size;
+ long atomType; /* = 'mdia' */
+
+ MediaHeaderAtom mediaHeader; /* standard Media information */
+
+ HandlerAtom mediaHandler;
+
+ MediaInfo mediaInfo;
+};
+typedef struct MediaDirectory MediaDirectory;
+/***********************
+* Track Structures
+***********************/
+enum {
+ TrackEnable = 1 << 0,
+ TrackInMovie = 1 << 1,
+ TrackInPreview = 1 << 2,
+ TrackInPoster = 1 << 3
+};
+
+struct TrackHeader {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long creationTime; /* seconds since Jan 1904 when directory was created */
+ long modificationTime; /* seconds since Jan 1904 when directory was appended */
+
+ long trackID;
+
+ long reserved1;
+
+ TimeValue duration; /* length of track (track time) */
+
+ long reserved2;
+ long reserved3;
+
+ short layer;
+ short alternateGroup;
+
+ short volume;
+ short reserved4;
+
+ MatrixRecord matrix;
+ Fixed trackWidth;
+ Fixed trackHeight;
+};
+typedef struct TrackHeader TrackHeader;
+struct TrackHeaderAtom {
+ long size; /* size of track header */
+ long atomType; /* = 'tkhd' */
+
+ TrackHeader header;
+};
+typedef struct TrackHeaderAtom TrackHeaderAtom;
+struct EditListType {
+ TimeValue trackDuration;
+ TimeValue mediaTime;
+ Fixed mediaRate;
+};
+typedef struct EditListType EditListType;
+struct EditListAtom {
+ long size;
+ long atomType; /* = elst */
+
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long numEntries;
+ EditListType editListTable[1];
+};
+typedef struct EditListAtom EditListAtom;
+struct EditsAtom {
+ long size;
+ long atomType; /* = edts */
+
+ EditListAtom editList;
+};
+typedef struct EditsAtom EditsAtom;
+struct TrackLoadSettings {
+ TimeValue preloadStartTime;
+ TimeValue preloadDuration;
+ long preloadFlags;
+ long defaultHints;
+};
+typedef struct TrackLoadSettings TrackLoadSettings;
+struct TrackLoadSettingsAtom {
+ long size;
+ long atomType; /* = load */
+
+ TrackLoadSettings settings;
+};
+typedef struct TrackLoadSettingsAtom TrackLoadSettingsAtom;
+struct TrackCleanApertureDimensions {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ FixedPoint cleanApertureDimensions;
+};
+typedef struct TrackCleanApertureDimensions TrackCleanApertureDimensions;
+struct TrackCleanApertureDimensionsAtom {
+ long size;
+ long atomType; /* = 'tapt' */
+
+ TrackCleanApertureDimensions cleanApertureDimensions;
+};
+typedef struct TrackCleanApertureDimensionsAtom TrackCleanApertureDimensionsAtom;
+struct TrackProductionApertureDimensions {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ FixedPoint productionApertureDimensions;
+};
+typedef struct TrackProductionApertureDimensions TrackProductionApertureDimensions;
+struct TrackProductionApertureDimensionsAtom {
+ long size;
+ long atomType; /* = 'prof' */
+
+ TrackProductionApertureDimensions productionApertureDimensions;
+};
+typedef struct TrackProductionApertureDimensionsAtom TrackProductionApertureDimensionsAtom;
+struct TrackEncodedPixelsDimensions {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+ FixedPoint encodedPixelsDimensions;
+};
+typedef struct TrackEncodedPixelsDimensions TrackEncodedPixelsDimensions;
+struct TrackEncodedPixelsDimensionsAtom {
+ long size;
+ long atomType; /* = 'enof' */
+
+ TrackEncodedPixelsDimensions encodedPixelsDimensions;
+};
+typedef struct TrackEncodedPixelsDimensionsAtom TrackEncodedPixelsDimensionsAtom;
+struct TrackDirectory {
+ long size;
+ long atomType; /* = 'trak' */
+
+ TrackHeaderAtom trackHeader; /* standard track information */
+
+ ClippingAtom trackClip;
+
+ EditsAtom edits;
+
+ MediaDirectory media;
+
+ UserDataAtom userData; /* space for extending with new data types */
+};
+typedef struct TrackDirectory TrackDirectory;
+/****************************************
+*
+* MovieDirectory -
+* The MovieDirectory is the top level structure which
+* holds the TrackInstance describing where the
+* TrackDirectories are.
+*
+****************************************/
+struct MovieHeader {
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long creationTime; /* seconds since Jan 1904 when directory was created */
+ long modificationTime; /* seconds since Jan 1904 when directory was appended */
+
+ TimeValue timeScale; /* Time specifications */
+ TimeValue duration;
+ Fixed preferredRate; /* rate at which to play this movie */
+
+ short preferredVolume; /* volume to play movie at */
+ short reserved1;
+
+ long preferredLong1;
+ long preferredLong2;
+
+ MatrixRecord matrix;
+
+ TimeValue previewTime; /* time in track the proxy begins (track time) */
+ TimeValue previewDuration; /* how long the proxy lasts (track time) */
+
+ TimeValue posterTime; /* time in track the proxy begins (track time) */
+
+ TimeValue selectionTime; /* time in track the proxy begins (track time) */
+ TimeValue selectionDuration; /* time in track the proxy begins (track time) */
+ TimeValue currentTime; /* time in track the proxy begins (track time) */
+
+ long nextTrackID; /* next value to use for a TrackID */
+};
+typedef struct MovieHeader MovieHeader;
+struct MovieHeaderAtom {
+ long size;
+ long atomType; /* = 'mvhd' */
+
+ MovieHeader header;
+};
+typedef struct MovieHeaderAtom MovieHeaderAtom;
+struct TrackDirectoryEntry {
+ TrackDirectory trackDirectory; /* Track directory information */
+};
+typedef struct TrackDirectoryEntry TrackDirectoryEntry;
+struct MovieDirectory {
+ long size;
+ long atomType; /* = 'moov' */
+
+ MovieHeaderAtom header;
+
+ ClippingAtom movieClip;
+
+ /* Track Directories */
+ TrackDirectoryEntry track[1]; /* Track directory information */
+
+ /* User data for Movie */
+ UserDataAtom userData; /* space for user extensions */
+};
+typedef struct MovieDirectory MovieDirectory;
+/****************************************
+****************************************/
+
+/* Movie formats and tags */
+enum {
+ /* some system defined format IDs */
+ QT_MOVIE_TYPE = FOUR_CHAR_CODE('moov'),
+ QT_TRACK_TYPE = FOUR_CHAR_CODE('trak'),
+ QT_MEDIA_TYPE = FOUR_CHAR_CODE('mdia'),
+ QT_VIDEO_TYPE = FOUR_CHAR_CODE('vide'),
+ QT_SOUND_TYPE = FOUR_CHAR_CODE('soun')
+};
+
+enum {
+ MOVIE_TYPE = FOUR_CHAR_CODE('moov'),
+ TRACK_TYPE = FOUR_CHAR_CODE('trak'),
+ VIDEO_TYPE = FOUR_CHAR_CODE('vide'),
+ SOUND_TYPE = FOUR_CHAR_CODE('soun')
+};
+
+#if !TARGET_OS_WIN32
+/* The name "MEDIA_TYPE" has a name space collision on Win32.*/
+enum {
+ MEDIA_TYPE = FOUR_CHAR_CODE('mdia')
+};
+
+#endif /* !TARGET_OS_WIN32 */
+
+/* atom id's */
+enum {
+ MovieAID = FOUR_CHAR_CODE('moov'),
+ MovieHeaderAID = FOUR_CHAR_CODE('mvhd'),
+ ClipAID = FOUR_CHAR_CODE('clip'),
+ RgnClipAID = FOUR_CHAR_CODE('crgn'),
+ MatteAID = FOUR_CHAR_CODE('matt'),
+ MatteCompAID = FOUR_CHAR_CODE('kmat'),
+ TrackAID = FOUR_CHAR_CODE('trak'),
+ UserDataAID = FOUR_CHAR_CODE('udta'),
+ TrackHeaderAID = FOUR_CHAR_CODE('tkhd'),
+ EditsAID = FOUR_CHAR_CODE('edts'),
+ EditListAID = FOUR_CHAR_CODE('elst'),
+ MediaAID = FOUR_CHAR_CODE('mdia'),
+ MediaHeaderAID = FOUR_CHAR_CODE('mdhd'),
+ MediaInfoAID = FOUR_CHAR_CODE('minf'),
+ VideoMediaInfoHeaderAID = FOUR_CHAR_CODE('vmhd'),
+ SoundMediaInfoHeaderAID = FOUR_CHAR_CODE('smhd'),
+ GenericMediaInfoHeaderAID = FOUR_CHAR_CODE('gmhd'),
+ GenericMediaInfoAID = FOUR_CHAR_CODE('gmin'),
+ DataInfoAID = FOUR_CHAR_CODE('dinf'),
+ DataRefAID = FOUR_CHAR_CODE('dref'),
+ SampleTableAID = FOUR_CHAR_CODE('stbl'),
+ STSampleDescAID = FOUR_CHAR_CODE('stsd'),
+ STTimeToSampAID = FOUR_CHAR_CODE('stts'),
+ STSyncSampleAID = FOUR_CHAR_CODE('stss'),
+ STSampleToChunkAID = FOUR_CHAR_CODE('stsc'),
+ STShadowSyncAID = FOUR_CHAR_CODE('stsh'),
+ HandlerAID = FOUR_CHAR_CODE('hdlr'),
+ STSampleSizeAID = FOUR_CHAR_CODE('stsz'),
+ STChunkOffsetAID = FOUR_CHAR_CODE('stco'),
+ STChunkOffset64AID = FOUR_CHAR_CODE('co64'),
+ STSampleIDAID = FOUR_CHAR_CODE('stid'),
+ STCompositionOffsetAID = FOUR_CHAR_CODE('ctts'),
+ STSampleDependencyAID = FOUR_CHAR_CODE('sdtp'),
+ STCompositionShiftLeastGreatestAID = FOUR_CHAR_CODE('cslg'),
+ STPartialSyncSampleAID = FOUR_CHAR_CODE('stps'),
+ DataRefContainerAID = FOUR_CHAR_CODE('drfc'),
+ TrackReferenceAID = FOUR_CHAR_CODE('tref'),
+ ColorTableAID = FOUR_CHAR_CODE('ctab'),
+ LoadSettingsAID = FOUR_CHAR_CODE('load'),
+ PropertyAtomAID = FOUR_CHAR_CODE('code'),
+ InputMapAID = FOUR_CHAR_CODE('imap'),
+ MovieBufferHintsAID = FOUR_CHAR_CODE('mbfh'),
+ MovieDataRefAliasAID = FOUR_CHAR_CODE('mdra'),
+ SoundLocalizationAID = FOUR_CHAR_CODE('sloc'),
+ CompressedMovieAID = FOUR_CHAR_CODE('cmov'),
+ CompressedMovieDataAID = FOUR_CHAR_CODE('cmvd'),
+ DataCompressionAtomAID = FOUR_CHAR_CODE('dcom'),
+ ReferenceMovieRecordAID = FOUR_CHAR_CODE('rmra'),
+ ReferenceMovieDescriptorAID = FOUR_CHAR_CODE('rmda'),
+ ReferenceMovieDataRefAID = FOUR_CHAR_CODE('rdrf'),
+ ReferenceMovieVersionCheckAID = FOUR_CHAR_CODE('rmvc'),
+ ReferenceMovieDataRateAID = FOUR_CHAR_CODE('rmdr'),
+ ReferenceMovieComponentCheckAID = FOUR_CHAR_CODE('rmcd'),
+ ReferenceMovieQualityAID = FOUR_CHAR_CODE('rmqu'),
+ ReferenceMovieLanguageAID = FOUR_CHAR_CODE('rmla'),
+ ReferenceMovieCPURatingAID = FOUR_CHAR_CODE('rmcs'),
+ ReferenceMovieAlternateGroupAID = FOUR_CHAR_CODE('rmag'),
+ ReferenceMovieNetworkStatusAID = FOUR_CHAR_CODE('rnet'),
+ CloneMediaAID = FOUR_CHAR_CODE('clon'),
+ FileTypeAID = FOUR_CHAR_CODE('ftyp'),
+ SecureContentInfoAID = FOUR_CHAR_CODE('sinf'),
+ SecureContentSchemeTypeAID = FOUR_CHAR_CODE('schm'),
+ SecureContentSchemeInfoAID = FOUR_CHAR_CODE('schi'),
+ TrackApertureModeDimensionsAID = FOUR_CHAR_CODE('tapt'), /* container atom including TrackCleanApertureDimensionsAID, TrackProductionApertureDimensionsAID and TrackEncodedPixelsDimensionsAID */
+ TrackCleanApertureDimensionsAID = FOUR_CHAR_CODE('clef'),
+ TrackProductionApertureDimensionsAID = FOUR_CHAR_CODE('prof'),
+ TrackEncodedPixelsDimensionsAID = FOUR_CHAR_CODE('enof')
+};
+
+/* Text ATOM definitions*/
+
+struct TextBoxAtom {
+ long size;
+ long atomType; /* = 'tbox' */
+ Rect textBox; /* New text box (overrides defaultTextBox)*/
+};
+typedef struct TextBoxAtom TextBoxAtom;
+struct HiliteAtom {
+ long size;
+ long atomType; /* = 'hlit' */
+ long selStart; /* hilite selection start character*/
+ long selEnd; /* hilite selection end character*/
+};
+typedef struct HiliteAtom HiliteAtom;
+struct KaraokeRec {
+ TimeValue timeVal;
+ short beginHilite;
+ short endHilite;
+};
+typedef struct KaraokeRec KaraokeRec;
+struct KaraokeAtom {
+ long numEntries;
+ KaraokeRec karaokeEntries[1];
+};
+typedef struct KaraokeAtom KaraokeAtom;
+/* for ReferenceMovieDataRefRecord.flags*/
+enum {
+ kDataRefIsSelfContained = (1 << 0)
+};
+
+struct ReferenceMovieDataRefRecord {
+ long flags;
+ OSType dataRefType;
+ long dataRefSize;
+ char dataRef[1];
+};
+typedef struct ReferenceMovieDataRefRecord ReferenceMovieDataRefRecord;
+/* for VersionCheckRecord.checkType*/
+enum {
+ kVersionCheckMin = 0, /* val1 is the min. version required*/
+ kVersionCheckMask = 1 /* (gestalt return value & val2) must == val1*/
+};
+
+struct QTAltVersionCheckRecord {
+ long flags; /* currently always 0*/
+ OSType gestaltTag;
+ UInt32 val1;
+ UInt32 val2;
+ short checkType;
+};
+typedef struct QTAltVersionCheckRecord QTAltVersionCheckRecord;
+/* some helpful constants for DataRateRecord.dataRate */
+enum {
+ kDataRate144ModemRate = 1400L,
+ kDataRate288ModemRate = 2800L,
+ kDataRateISDNRate = 5600L,
+ kDataRateDualISDNRate = 11200L,
+ kDataRate256kbpsRate = 25600L,
+ kDataRate384kbpsRate = 38400L,
+ kDataRate512kbpsRate = 51200L,
+ kDataRate768kbpsRate = 76800L,
+ kDataRate1MbpsRate = 100000L,
+ kDataRateT1Rate = 150000L,
+ kDataRateInfiniteRate = 0x7FFFFFFF,
+ kDataRateDefaultIfNotSet = kDataRate384kbpsRate
+};
+
+struct QTAltDataRateRecord {
+ long flags; /* currently always 0*/
+ long dataRate;
+};
+typedef struct QTAltDataRateRecord QTAltDataRateRecord;
+struct QTAltComponentCheckRecord {
+ long flags; /* currently always 0 */
+ ComponentDescription cd;
+ unsigned long minVersion;
+};
+typedef struct QTAltComponentCheckRecord QTAltComponentCheckRecord;
+struct QTAltLanguageRecord {
+ long flags; /* currently always 0*/
+ short language;
+};
+typedef struct QTAltLanguageRecord QTAltLanguageRecord;
+
+enum {
+ kQTCPUSpeed1Rating = 100, /* slowest*/
+ kQTCPUSpeed2Rating = 200,
+ kQTCPUSpeed3Rating = 300,
+ kQTCPUSpeed4Rating = 400,
+ kQTCPUSpeed5Rating = 500 /* fastest*/
+};
+
+struct QTAltCPURatingRecord {
+ UInt32 flags; /* currently always 0*/
+ UInt16 speed;
+};
+typedef struct QTAltCPURatingRecord QTAltCPURatingRecord;
+struct ReferenceMovieNetworkStatusRecord {
+ UInt32 flags; /* currently always 0*/
+ UInt32 valueCount; /* how many status values are in array*/
+ long netStatusValues[1]; /* a value from kQTNetworkStatus... constants*/
+};
+typedef struct ReferenceMovieNetworkStatusRecord ReferenceMovieNetworkStatusRecord;
+struct CloneRecord {
+ long flags;
+ long masterTrackID; /* track ID of the track we're cloning */
+};
+typedef struct CloneRecord CloneRecord;
+struct CloneAtom {
+ long size;
+ long atomType; /* = clon */
+
+ CloneRecord cloneInfo;
+};
+typedef struct CloneAtom CloneAtom;
+struct FileTypeAtom {
+ long size;
+ long atomType; /* = 'ftyp' */
+ long majorBrand; /* best use brand */
+ long minorVersion;
+ long compatibleBrands[4]; /* 1 or greater */
+};
+typedef struct FileTypeAtom FileTypeAtom;
+enum {
+ kQTFileTypeBrandQuickTimeMovie = FOUR_CHAR_CODE('qt '), /* QuickTime movie files*/
+ kQTFileTypeBrandISOFile = FOUR_CHAR_CODE('isom'), /* ISO Base Media files*/
+ kQTFileTypeBrandMPEG4v1 = FOUR_CHAR_CODE('mp41'), /* MPEG-4 (ISO/IEC 14496-1) version 1 files*/
+ kQTFileTypeBrandMPEG4v2 = FOUR_CHAR_CODE('mp42') /* MPEG-4 (ISO/IEC 14496-1) version 2 files*/
+};
+
+struct SecureContentInfoAtom {
+ long size;
+ long atomType; /* = 'sinf' */
+};
+typedef struct SecureContentInfoAtom SecureContentInfoAtom;
+struct SecureContentSchemeTypeAtom {
+ long size;
+ long atomType; /* = 'schm' */
+
+ long flags; /* 1 byte of version / 3 bytes of flags */
+
+ long schemeType;
+ UInt32 schemeVersion;
+ /* if flags & 1, C string holding URL for security component server*/
+};
+typedef struct SecureContentSchemeTypeAtom SecureContentSchemeTypeAtom;
+struct SecureContentSchemeInfoAtom {
+ long size;
+ long atomType; /* = 'schi' */
+};
+typedef struct SecureContentSchemeInfoAtom SecureContentSchemeInfoAtom;
+
+#endif // !__LP64__
+
+
+#if PRAGMA_STRUCT_ALIGN
+ #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+ #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+ #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MOVIESFORMAT__ */
+
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-07 02:22:52 +0000