home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  13.6 KB  |  463 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MoviesFormat.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT MoviesFormat;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __MOVIESFORMAT__}
  27. {$SETC __MOVIESFORMAT__ := 1}
  28.  
  29. {$I+}
  30. {$SETC MoviesFormatIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __WINDOWS__}
  40. {$I Windows.p}
  41. {$ENDC}
  42. {    Memory.p                                                    }
  43. {        MixedMode.p                                                }
  44. {    Quickdraw.p                                                    }
  45. {        QuickdrawText.p                                            }
  46. {    Events.p                                                    }
  47. {        OSUtils.p                                                }
  48. {    Controls.p                                                    }
  49. {        Menus.p                                                    }
  50.  
  51. {$IFC UNDEFINED __IMAGECOMPRESSION__}
  52. {$I ImageCompression.p}
  53. {$ENDC}
  54. {    QDOffscreen.p                                                }
  55. {        Errors.p                                                }
  56. {    Components.p                                                }
  57. {    StandardFile.p                                                }
  58. {        Dialogs.p                                                }
  59. {            TextEdit.p                                            }
  60. {        Files.p                                                    }
  61.  
  62. {$IFC UNDEFINED __MOVIES__}
  63. {$I Movies.p}
  64. {$ENDC}
  65. {    Aliases.p                                                    }
  66. {        AppleTalk.p                                                }
  67.  
  68. {$PUSH}
  69. {$ALIGN MAC68K}
  70. {$LibExport+}
  71.  
  72. CONST
  73.     kMovieVersion                = 0;                            { version number of the format here described }
  74.  
  75.  
  76. TYPE
  77.     MoviesUserData = RECORD
  78.         size:                    LONGINT;                                { size of this user data }
  79.         udType:                    LONGINT;                                { type of user data }
  80.         data:                    PACKED ARRAY [0..0] OF CHAR;            { the user data }
  81.     END;
  82.     UserDataAtom = RECORD
  83.         size:                    LONGINT;
  84.         atomType:                LONGINT;
  85.         userData:                ARRAY [0..0] OF MoviesUserData;
  86.     END;
  87. { MoviesDataDescription tells us where the data for the movie or track lives.
  88.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  89.    be in the resource fork of the same file as the directory resource, be in another file in the
  90.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  91. {***************************************
  92. *
  93. *   MediaDirectory information -
  94. *        The MediaDirectory is tightly coupled to the data.
  95. *
  96. ***************************************}
  97.     SampleDescriptionAtom = RECORD
  98.         size:                    LONGINT;
  99.         atomType:                LONGINT;                                { = 'stsd' }
  100.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  101.         numEntries:                LONGINT;
  102.         sampleDescTable:        ARRAY [0..0] OF SampleDescription;
  103.     END;
  104. { TimeToSampleNum maps physical sample time to physical sample number. }
  105.     TimeToSampleNum = RECORD
  106.         sampleCount:            LONGINT;
  107.         sampleDuration:            TimeValue;
  108.     END;
  109.     TimeToSampleNumAtom = RECORD
  110.         size:                    LONGINT;
  111.         atomType:                LONGINT;                                { = 'stts' }
  112.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  113.         numEntries:                LONGINT;
  114.         timeToSampleNumTable:    ARRAY [0..0] OF TimeToSampleNum;
  115.     END;
  116. { SyncSamples is a list of the physical samples which are self contained. }
  117.     SyncSampleAtom = RECORD
  118.         size:                    LONGINT;
  119.         atomType:                LONGINT;                                { = 'stss' }
  120.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  121.         numEntries:                LONGINT;
  122.         syncSampleTable:        ARRAY [0..0] OF LONGINT;
  123.     END;
  124. { SampleToChunk maps physical sample number to chunk number. }
  125. { same as SampleToChunk, but redundant first sample is removed }
  126.     SampleToChunk = RECORD
  127.         firstChunk:                LONGINT;
  128.         samplesPerChunk:        LONGINT;
  129.         sampleDescriptionID:    LONGINT;
  130.     END;
  131.     SampleToChunkAtom = RECORD
  132.         size:                    LONGINT;
  133.         atomType:                LONGINT;                                { = 'stsc' }
  134.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  135.         numEntries:                LONGINT;
  136.         sampleToChunkTable:        ARRAY [0..0] OF SampleToChunk;
  137.     END;
  138.     ChunkOffsetAtom = RECORD
  139.         size:                    LONGINT;
  140.         atomType:                LONGINT;                                { = 'stco' }
  141.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  142.         numEntries:                LONGINT;
  143.         chunkOffsetTable:        ARRAY [0..0] OF LONGINT;
  144.     END;
  145.     SampleSizeAtom = RECORD
  146.         size:                    LONGINT;
  147.         atomType:                LONGINT;                                { = 'stsz' }
  148.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  149.         sampleSize:                LONGINT;
  150.         numEntries:                LONGINT;
  151.         sampleSizeTable:        ARRAY [0..0] OF LONGINT;
  152.     END;
  153.     ShadowSync = RECORD
  154.         fdSampleNum:            LONGINT;
  155.         syncSampleNum:            LONGINT;
  156.     END;
  157.     ShadowSyncAtom = RECORD
  158.         size:                    LONGINT;
  159.         atomType:                LONGINT;                                { = 'stsz' }
  160.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  161.         numEntries:                LONGINT;
  162.         shadowSyncTable:        ARRAY [0..0] OF ShadowSync;
  163.     END;
  164.     SampleTableAtom = RECORD
  165.         size:                    LONGINT;
  166.         atomType:                LONGINT;                                { = 'stbl' }
  167.         sampleDescription:        SampleDescriptionAtom;
  168.         timeToSampleNum:        TimeToSampleNumAtom;
  169.         sampleToChunk:            SampleToChunkAtom;
  170.         syncSample:                SyncSampleAtom;
  171.         sampleSize:                SampleSizeAtom;
  172.         chunkOffset:            ChunkOffsetAtom;
  173.         shadowSync:                ShadowSyncAtom;
  174.     END;
  175.     PublicHandlerInfo = RECORD
  176.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  177.         componentType:            LONGINT;
  178.         componentSubType:        LONGINT;
  179.         componentManufacturer:    LONGINT;
  180.         componentFlags:            LONGINT;
  181.         componentFlagsMask:        LONGINT;
  182.         componentName:            PACKED ARRAY [0..0] OF CHAR;
  183.     END;
  184.     HandlerAtom = RECORD
  185.         size:                    LONGINT;
  186.         atomType:                LONGINT;                                { = 'hdlr' }
  187.         hInfo:                    PublicHandlerInfo;
  188.     END;
  189. { a data reference is a private structure }
  190.     DataRefAtom = LONGINT;
  191.  
  192.     DataInfoAtom = RECORD
  193.         size:                    LONGINT;
  194.         atomType:                LONGINT;                                { = 'dinf' }
  195.         dataRef:                DataRefAtom;
  196.     END;
  197.     RgnAtom = RECORD
  198.         size:                    LONGINT;
  199.         atomType:                LONGINT;
  200.         rgnSize:                INTEGER;
  201.         rgnBBox:                Rect;
  202.         data:                    PACKED ARRAY [0..0] OF CHAR;
  203.     END;
  204.     MatteCompressedAtom = RECORD
  205.         size:                    LONGINT;
  206.         atomType:                LONGINT;
  207.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  208.         matteImageDescription:    ImageDescription;
  209.         matteData:                PACKED ARRAY [0..0] OF CHAR;
  210.     END;
  211.     MatteAtom = RECORD
  212.         size:                    LONGINT;
  213.         atomType:                LONGINT;
  214.         aCompressedMatte:        MatteCompressedAtom;
  215.     END;
  216.     ClippingAtom = RECORD
  217.         size:                    LONGINT;
  218.         atomType:                LONGINT;
  219.         aRgnClip:                RgnAtom;
  220.     END;
  221. {**********************
  222. * Media Info Example Structures
  223. **********************}
  224.     VideoMediaInfoHeader = RECORD
  225.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  226.         graphicsMode:            INTEGER;                                { for QD - transfer mode }
  227.         opColorRed:                INTEGER;                                { opcolor for transfer mode }
  228.         opColorGreen:            INTEGER;
  229.         opColorBlue:            INTEGER;
  230.     END;
  231.     VideoMediaInfoHeaderAtom = RECORD
  232.         size:                    LONGINT;                                { size of Media info }
  233.         atomType:                LONGINT;                                { = 'vmhd' }
  234.         vmiHeader:                VideoMediaInfoHeader;
  235.     END;
  236.     VideoMediaInfo = RECORD
  237.         size:                    LONGINT;                                { size of Media info }
  238.         atomType:                LONGINT;                                { = 'minf' }
  239.         header:                    VideoMediaInfoHeaderAtom;
  240.         dataHandler:            HandlerAtom;
  241.         dataInfo:                DataInfoAtom;
  242.         sampleTable:            SampleTableAtom;
  243.     END;
  244.     SoundMediaInfoHeader = RECORD
  245.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  246.         balance:                INTEGER;
  247.         rsrvd:                    INTEGER;
  248.     END;
  249.     SoundMediaInfoHeaderAtom = RECORD
  250.         size:                    LONGINT;                                { size of Media info }
  251.         atomType:                LONGINT;                                { = 'vmhd' }
  252.         smiHeader:                SoundMediaInfoHeader;
  253.     END;
  254.     SoundMediaInfo = RECORD
  255.         size:                    LONGINT;                                { size of Media info }
  256.         atomType:                LONGINT;                                { = 'minf' }
  257.         header:                    SoundMediaInfoHeaderAtom;
  258.         dataHandler:            HandlerAtom;
  259.         dataReference:            DataRefAtom;
  260.         sampleTable:            SampleTableAtom;
  261.     END;
  262. { whatever data the media handler needs goes after the atomType }
  263.     MediaInfo = RECORD
  264.         size:                    LONGINT;
  265.         atomType:                LONGINT;
  266.     END;
  267. {**********************
  268. * Media Directory Structures
  269. **********************}
  270.     MediaHeader = RECORD
  271.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  272.         creationTime:            LONGINT;                                { seconds since Jan 1904 when directory was created }
  273.         modificationTime:        LONGINT;                                { seconds since Jan 1904 when directory was appended }
  274.         timeScale:                TimeValue;                                { start time for Media (Media time) }
  275.         duration:                TimeValue;                                { length of Media (Media time) }
  276.         language:                INTEGER;
  277.         quality:                INTEGER;
  278.     END;
  279.     MediaHeaderAtom = RECORD
  280.         size:                    LONGINT;
  281.         atomType:                LONGINT;
  282.         header:                    MediaHeader;
  283.     END;
  284.     MediaDirectory = RECORD
  285.         size:                    LONGINT;
  286.         atomType:                LONGINT;                                { = 'mdia' }
  287.         mediaHeader:            MediaHeaderAtom;                        { standard Media information }
  288.         mediaHandler:            HandlerAtom;
  289.         mediaInfo:                MediaInfo;
  290.     END;
  291. {**********************
  292. * Track Structures
  293. **********************}
  294.  
  295. CONST
  296.     TrackEnable                    = 1 * (2**(0));
  297.     TrackInMovie                = 1 * (2**(1));
  298.     TrackInPreview                = 1 * (2**(2));
  299.     TrackInPoster                = 1 * (2**(3));
  300.  
  301.  
  302. TYPE
  303.     TrackHeader = RECORD
  304.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  305.         creationTime:            LONGINT;                                { seconds since Jan 1904 when directory was created }
  306.         modificationTime:        LONGINT;                                { seconds since Jan 1904 when directory was appended }
  307.         trackID:                LONGINT;
  308.         reserved1:                LONGINT;
  309.         duration:                TimeValue;                                { length of track (track time) }
  310.         reserved2:                LONGINT;
  311.         reserved3:                LONGINT;
  312.         layer:                    INTEGER;
  313.         alternateGroup:            INTEGER;
  314.         volume:                    INTEGER;
  315.         reserved4:                INTEGER;
  316.         matrix:                    MatrixRecord;
  317.         trackWidth:                Fixed;
  318.         trackHeight:            Fixed;
  319.     END;
  320.     TrackHeaderAtom = RECORD
  321.         size:                    LONGINT;                                { size of track header }
  322.         atomType:                LONGINT;                                { = 'tkhd' }
  323.         header:                    TrackHeader;
  324.     END;
  325.     EditListType = RECORD
  326.         trackDuration:            TimeValue;
  327.         mediaTime:                TimeValue;
  328.         mediaRate:                Fixed;
  329.     END;
  330.     EditListAtom = RECORD
  331.         size:                    LONGINT;
  332.         atomType:                LONGINT;                                { = elst }
  333.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  334.         numEntries:                LONGINT;
  335.         editListTable:            ARRAY [0..0] OF EditListType;
  336.     END;
  337.     EditsAtom = RECORD
  338.         size:                    LONGINT;
  339.         atomType:                LONGINT;                                { = edts }
  340.         editList:                EditListAtom;
  341.     END;
  342.     TrackLoadSettings = RECORD
  343.         preloadStartTime:        TimeValue;
  344.         preloadDuration:        TimeValue;
  345.         preloadFlags:            LONGINT;
  346.         defaultHints:            LONGINT;
  347.     END;
  348.     TrackLoadSettingsAtom = RECORD
  349.         size:                    LONGINT;
  350.         atomType:                LONGINT;                                { = load }
  351.         settings:                TrackLoadSettings;
  352.     END;
  353.     TrackDirectory = RECORD
  354.         size:                    LONGINT;
  355.         atomType:                LONGINT;                                { = 'trak' }
  356.         trackHeader:            TrackHeaderAtom;                        { standard track information }
  357.         trackClip:                ClippingAtom;
  358.         edits:                    EditsAtom;
  359.         media:                    MediaDirectory;
  360.         userData:                UserDataAtom;                            { space for extending with new data types }
  361.     END;
  362. {***************************************
  363. *
  364. *   MovieDirectory -
  365. *        The MovieDirectory is the top level structure which
  366. *        holds the TrackInstance describing where the
  367. *        TrackDirectories are.
  368. *
  369. ***************************************}
  370.     MovieHeader = RECORD
  371.         flags:                    LONGINT;                                { 1 byte of version / 3 bytes of flags }
  372.         creationTime:            LONGINT;                                { seconds since Jan 1904 when directory was created }
  373.         modificationTime:        LONGINT;                                { seconds since Jan 1904 when directory was appended }
  374.         timeScale:                TimeValue;                                { Time specifications }
  375.         duration:                TimeValue;
  376.         preferredRate:            Fixed;                                    { rate at which to play this movie }
  377.         preferredVolume:        INTEGER;                                { volume to play movie at }
  378.         reserved1:                INTEGER;
  379.         preferredLong1:            LONGINT;
  380.         preferredLong2:            LONGINT;
  381.         matrix:                    MatrixRecord;
  382.         previewTime:            TimeValue;                                { time in track the proxy begins (track time) }
  383.         previewDuration:        TimeValue;                                { how long the proxy lasts (track time) }
  384.         posterTime:                TimeValue;                                { time in track the proxy begins (track time) }
  385.         selectionTime:            TimeValue;                                { time in track the proxy begins (track time) }
  386.         selectionDuration:        TimeValue;                                { time in track the proxy begins (track time) }
  387.         currentTime:            TimeValue;                                { time in track the proxy begins (track time) }
  388.         nextTrackID:            LONGINT;                                { next value to use for a TrackID }
  389.     END;
  390.     MovieHeaderAtom = RECORD
  391.         size:                    LONGINT;
  392.         atomType:                LONGINT;                                { = 'mvhd' }
  393.         header:                    MovieHeader;
  394.     END;
  395.     MovieDirectory = RECORD
  396.         size:                    LONGINT;
  397.         atomType:                LONGINT;                                { = 'moov' }
  398.         header:                    MovieHeaderAtom;
  399.         movieClip:                ClippingAtom;
  400.         { Track Directories }
  401.         track:            RECORD
  402.                 trackDirectory:                    TrackDirectory;                    { Track directory information }
  403.             END;
  404.  
  405.         { User data for Movie }
  406.         userData:                UserDataAtom;                            { space for user extensions }
  407.     END;
  408.  
  409. CONST
  410. { some system defined format IDs }
  411.     MOVIE_TYPE                    = 'moov';
  412.     TRACK_TYPE                    = 'trak';
  413.     MEDIA_TYPE                    = 'mdia';
  414.     VIDEO_TYPE                    = 'vide';
  415.     SOUND_TYPE                    = 'soun';
  416.  
  417. { atom id's }
  418.     MovieAID                    = 'moov';
  419.     MovieHeaderAID                = 'mvhd';
  420.     ClipAID                        = 'clip';
  421.     RgnClipAID                    = 'crgn';
  422.     MatteAID                    = 'matt';
  423.     MatteCompAID                = 'kmat';
  424.     TrackAID                    = 'trak';
  425.     UserDataAID                    = 'udta';
  426.     TrackHeaderAID                = 'tkhd';
  427.     EditsAID                    = 'edts';
  428.     EditListAID                    = 'elst';
  429.     MediaAID                    = 'mdia';
  430.     MediaHeaderAID                = 'mdhd';
  431.     MediaInfoAID                = 'minf';
  432.     VideoMediaInfoHeaderAID        = 'vmhd';
  433.     SoundMediaInfoHeaderAID        = 'smhd';
  434.     GenericMediaInfoHeaderAID    = 'gmhd';
  435.     GenericMediaInfoAID            = 'gmin';
  436.     DataInfoAID                    = 'dinf';
  437.     DataRefAID                    = 'dref';
  438.     SampleTableAID                = 'stbl';
  439.     STSampleDescAID                = 'stsd';
  440.     STTimeToSampAID                = 'stts';
  441.     STSyncSampleAID                = 'stss';
  442.     STSampleToChunkAID            = 'stsc';
  443.     STShadowSyncAID                = 'stsh';
  444.     HandlerAID                    = 'hdlr';
  445.     STSampleSizeAID                = 'stsz';
  446.     STChunkOffsetAID            = 'stco';
  447.     DataRefContainerAID            = 'drfc';
  448.     TrackReferenceAID            = 'tref';
  449.     ColorTableAID                = 'ctab';
  450.     LoadSettingsAID                = 'load';
  451.  
  452.  
  453. {$ALIGN RESET}
  454. {$POP}
  455.  
  456. {$SETC UsingIncludes := MoviesFormatIncludes}
  457.  
  458. {$ENDC} {__MOVIESFORMAT__}
  459.  
  460. {$IFC NOT UsingIncludes}
  461.  END.
  462. {$ENDC}
  463.