MoviesFormat.h

Go to the documentation of this file.

 
#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
 
enum {
  kMovieVersion = 0 
};
 
/*****************************************
 *
 *   General Types -
 *       These types are used in more than one of the
 *       directory types.
 *
 ****************************************/
struct MoviesUserData {
  long size;    
  long udType;  
  char data[1]; 
};
typedef struct MoviesUserData MoviesUserData;
struct UserDataAtom {
  long size;
  long atomType;
  MoviesUserData userData[1];
};
typedef struct UserDataAtom UserDataAtom;
/*****************************************
 *
 *   MediaDirectory information -
 *       The MediaDirectory is tightly coupled to the data.
 *
 ****************************************/
 
struct SampleDescriptionAtom {
  long size;
  long atomType; 
  long flags;    
  long numEntries;
  SampleDescription sampleDescTable[1];
};
typedef struct SampleDescriptionAtom SampleDescriptionAtom;
struct TimeToSampleNum {
  long sampleCount;
  TimeValue sampleDuration;
};
typedef struct TimeToSampleNum TimeToSampleNum;
struct TimeToSampleNumAtom {
  long size;
  long atomType; 
  long flags;    
  long numEntries;
  TimeToSampleNum timeToSampleNumTable[1];
};
typedef struct TimeToSampleNumAtom TimeToSampleNumAtom;
struct SyncSampleAtom {
  long size;
  long atomType; 
  long flags;    
  long numEntries;
  long syncSampleTable[1];
};
typedef struct SyncSampleAtom SyncSampleAtom;
struct SampleToChunk {
  long firstChunk;
  long samplesPerChunk;
  long sampleDescriptionID;
};
typedef struct SampleToChunk SampleToChunk;
struct SampleToChunkAtom {
  long size;
  long atomType; 
  long flags;    
  long numEntries;
  SampleToChunk sampleToChunkTable[1];
};
typedef struct SampleToChunkAtom SampleToChunkAtom;
struct ChunkOffsetAtom {
  long size;
  long atomType; 
  long flags;    
  long numEntries;
  long chunkOffsetTable[1];
};
typedef struct ChunkOffsetAtom ChunkOffsetAtom;
struct SampleSizeAtom {
  long size;
  long atomType; 
  long 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; 
  long flags;    
  long numEntries;
  ShadowSync shadowSyncTable[1];
};
typedef struct ShadowSyncAtom ShadowSyncAtom;
struct SampleTableAtom {
  long size;
  long atomType; 
  SampleDescriptionAtom sampleDescription;
  TimeToSampleNumAtom timeToSampleNum;
  SampleToChunkAtom sampleToChunk;
  SyncSampleAtom syncSample;
  SampleSizeAtom sampleSize;
  ChunkOffsetAtom chunkOffset;
  ShadowSyncAtom shadowSync;
};
typedef struct SampleTableAtom SampleTableAtom;
struct PublicHandlerInfo {
  long flags; 
  long componentType;
  long componentSubType;
  long componentManufacturer;
  long componentFlags;
  long componentFlagsMask;
  char componentName[1];
};
typedef struct PublicHandlerInfo PublicHandlerInfo;
struct HandlerAtom {
  long size;
  long atomType; 
  PublicHandlerInfo hInfo;
};
typedef struct HandlerAtom HandlerAtom;
typedef long DataRefAtom;
struct DataInfoAtom {
  long size;
  long atomType; 
  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; 
  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; 
  short graphicsMode; 
  short opColorRed;   
  short opColorGreen;
  short opColorBlue;
};
typedef struct VideoMediaInfoHeader VideoMediaInfoHeader;
struct VideoMediaInfoHeaderAtom {
  long size;     
  long atomType; 
  VideoMediaInfoHeader vmiHeader;
};
typedef struct VideoMediaInfoHeaderAtom VideoMediaInfoHeaderAtom;
struct VideoMediaInfo {
  long size;     
  long atomType; 
  VideoMediaInfoHeaderAtom header;
 
  HandlerAtom dataHandler;
 
  DataInfoAtom dataInfo;
 
  SampleTableAtom sampleTable;
};
typedef struct VideoMediaInfo VideoMediaInfo;
struct SoundMediaInfoHeader {
  long flags; 
  short balance;
  short rsrvd;
};
typedef struct SoundMediaInfoHeader SoundMediaInfoHeader;
struct SoundMediaInfoHeaderAtom {
  long size;     
  long atomType; 
  SoundMediaInfoHeader smiHeader;
};
typedef struct SoundMediaInfoHeaderAtom SoundMediaInfoHeaderAtom;
struct SoundMediaInfo {
  long size;     
  long atomType; 
  SoundMediaInfoHeaderAtom header;
 
  HandlerAtom dataHandler;
 
  DataRefAtom dataReference;
 
  SampleTableAtom sampleTable;
};
typedef struct SoundMediaInfo SoundMediaInfo;
struct MediaInfo {
  long size;
  long atomType;
};
typedef struct MediaInfo MediaInfo;
/************************
 * Media Directory Structures
 ***********************/
struct MediaHeader {
  long flags; 
  long creationTime; 
  long modificationTime; 
  TimeValue timeScale; 
  TimeValue duration;  
  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; 
  MediaHeaderAtom mediaHeader; 
  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; 
  long creationTime; 
  long modificationTime; 
  long trackID;
 
  long reserved1;
 
  TimeValue duration; 
  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;     
  long atomType; 
  TrackHeader header;
};
typedef struct TrackHeaderAtom TrackHeaderAtom;
struct EditListType {
  TimeValue trackDuration;
  TimeValue mediaTime;
  Fixed mediaRate;
};
typedef struct EditListType EditListType;
struct EditListAtom {
  long size;
  long atomType; 
  long flags; 
  long numEntries;
  EditListType editListTable[1];
};
typedef struct EditListAtom EditListAtom;
struct EditsAtom {
  long size;
  long atomType; 
  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; 
  TrackLoadSettings settings;
};
typedef struct TrackLoadSettingsAtom TrackLoadSettingsAtom;
struct TrackDirectory {
  long size;
  long atomType; 
  TrackHeaderAtom trackHeader; 
  ClippingAtom trackClip;
 
  EditsAtom edits;
 
  MediaDirectory media;
 
  UserDataAtom userData; 
};
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; 
  long creationTime; 
  long modificationTime; 
  TimeValue timeScale; 
  TimeValue duration;
  Fixed preferredRate; 
  short preferredVolume; 
  short reserved1;
 
  long preferredLong1;
  long preferredLong2;
 
  MatrixRecord matrix;
 
  TimeValue previewTime;     
  TimeValue previewDuration; 
  TimeValue posterTime; 
  TimeValue selectionTime; 
  TimeValue
      selectionDuration; 
  TimeValue currentTime; 
  long nextTrackID; 
};
typedef struct MovieHeader MovieHeader;
struct MovieHeaderAtom {
  long size;
  long atomType; 
  MovieHeader header;
};
typedef struct MovieHeaderAtom MovieHeaderAtom;
struct TrackDirectoryEntry {
  TrackDirectory trackDirectory; 
};
typedef struct TrackDirectoryEntry TrackDirectoryEntry;
struct MovieDirectory {
  long size;
  long atomType; 
  MovieHeaderAtom header;
 
  ClippingAtom movieClip;
 
  TrackDirectoryEntry track[1]; 
  UserDataAtom userData; 
};
typedef struct MovieDirectory MovieDirectory;
/*****************************************
****************************************/
 
enum {
  MOVIE_TYPE = FOUR_CHAR_CODE('moov'),
  TRACK_TYPE = FOUR_CHAR_CODE('trak'),
  MEDIA_TYPE = FOUR_CHAR_CODE('mdia'),
  VIDEO_TYPE = FOUR_CHAR_CODE('vide'),
  SOUND_TYPE = FOUR_CHAR_CODE('soun')
};
 
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'),
  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')
};
 
struct TextBoxAtom {
  long size;
  long atomType; 
  Rect textBox;  
};
typedef struct TextBoxAtom TextBoxAtom;
struct HiliteAtom {
  long size;
  long atomType; 
  long selStart; 
  long selEnd;   
};
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;
enum { kDataRefIsSelfContained = (1 << 0) };
 
struct ReferenceMovieDataRefRecord {
  long flags;
  OSType dataRefType;
  long dataRefSize;
  char dataRef[1];
};
typedef struct ReferenceMovieDataRefRecord ReferenceMovieDataRefRecord;
enum {
  kVersionCheckMin = 0, 
  kVersionCheckMask = 1 
};
 
struct QTAltVersionCheckRecord {
  long flags; 
  OSType gestaltTag;
  UInt32 val1;
  UInt32 val2;
  short checkType;
};
typedef struct QTAltVersionCheckRecord QTAltVersionCheckRecord;
enum {
  kDataRate144ModemRate = 1400L,
  kDataRate288ModemRate = 2800L,
  kDataRateISDNRate = 5600L,
  kDataRateDualISDNRate = 11200L,
  kDataRate256kbpsRate = 25600L,
  kDataRate384kbpsRate = 38400L,
  kDataRate512kbpsRate = 51200L,
  kDataRate768kbpsRate = 76800L,
  kDataRate1MbpsRate = 100000L,
  kDataRateT1Rate = 150000L,
  kDataRateInfiniteRate = 0x7FFFFFFF,
  kDataRateDefaultIfNotSet = kDataRateISDNRate
};
 
struct QTAltDataRateRecord {
  long flags; 
  long dataRate;
};
typedef struct QTAltDataRateRecord QTAltDataRateRecord;
struct QTAltComponentCheckRecord {
  long flags; 
  ComponentDescription cd;
  unsigned long minVersion;
};
typedef struct QTAltComponentCheckRecord QTAltComponentCheckRecord;
struct QTAltLanguageRecord {
  long flags; 
  short language;
};
typedef struct QTAltLanguageRecord QTAltLanguageRecord;
 
enum {
  kQTCPUSpeed1Rating = 100, 
  kQTCPUSpeed2Rating = 200,
  kQTCPUSpeed3Rating = 300,
  kQTCPUSpeed4Rating = 400,
  kQTCPUSpeed5Rating = 500 
};
 
struct QTAltCPURatingRecord {
  UInt32 flags; 
  UInt16 speed;
};
typedef struct QTAltCPURatingRecord QTAltCPURatingRecord;
struct ReferenceMovieNetworkStatusRecord {
  UInt32 flags;            
  UInt32 valueCount;       
  long netStatusValues[1]; 
};
typedef struct ReferenceMovieNetworkStatusRecord
    ReferenceMovieNetworkStatusRecord;
struct CloneRecord {
  long flags;
  long masterTrackID; 
};
typedef struct CloneRecord CloneRecord;
struct CloneAtom {
  long size;
  long atomType; 
  CloneRecord cloneInfo;
};
typedef struct CloneAtom CloneAtom;
 
#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