home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / aviriff.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  14KB  |  406 lines
  1. #pragma option push -b -a8 -pc -A- /*P_O_Push*/
  2. //==========================================================================;
  3. //
  4. //  Copyright (c) 1996 - 1997  Microsoft Corporation.  All Rights Reserved.
  5. //
  6. //--------------------------------------------------------------------------;
  7. #pragma warning(disable: 4097 4511 4512 4514 4705)
  8.  
  9. /*+
  10.  *
  11.  * Structures and defines for the RIFF AVI file format extended to
  12.  * handle very large/long files
  13.  *
  14.  *-=====================================================================*/
  15.  
  16. #if !defined AVIRIFF_H
  17. #define AVIRIFF_H
  18.  
  19. #if !defined NUMELMS
  20.   #define NUMELMS(aa) (sizeof(aa)/sizeof((aa)[0]))
  21. #endif
  22.  
  23. // all structures in this file are packed on word boundaries
  24. //
  25. #include <pshpack2.h>
  26.  
  27. /*
  28.  * heres the general layout of an AVI riff file (new format)
  29.  *
  30.  * RIFF (3F??????) AVI       <- not more than 1 GB in size
  31.  *     LIST (size) hdrl
  32.  *         avih (0038)
  33.  *         LIST (size) strl
  34.  *             strh (0038)
  35.  *             strf (????)
  36.  *             indx (3ff8)   <- size may vary, should be sector sized
  37.  *         LIST (size) strl
  38.  *             strh (0038)
  39.  *             strf (????)
  40.  *             indx (3ff8)   <- size may vary, should be sector sized
  41.  *         LIST (size) odml
  42.  *             dmlh (????)
  43.  *         JUNK (size)       <- fill to align to sector - 12
  44.  *     LIST (7f??????) movi  <- aligned on sector - 12
  45.  *         00dc (size)       <- sector aligned
  46.  *         01wb (size)       <- sector aligned
  47.  *         ix00 (size)       <- sector aligned
  48.  *     idx1 (00??????)       <- sector aligned
  49.  * RIFF (7F??????) AVIX
  50.  *     JUNK (size)           <- fill to align to sector -12
  51.  *     LIST (size) movi
  52.  *         00dc (size)       <- sector aligned
  53.  * RIFF (7F??????) AVIX      <- not more than 2GB in size
  54.  *     JUNK (size)           <- fill to align to sector - 12
  55.  *     LIST (size) movi
  56.  *         00dc (size)       <- sector aligned
  57.  *
  58.  *-===================================================================*/
  59.  
  60. //
  61. // structures for manipulating RIFF headers
  62. //
  63. #define FCC(ch4) ((((DWORD)(ch4) & 0xFF) << 24) |     \
  64.                   (((DWORD)(ch4) & 0xFF00) << 8) |    \
  65.                   (((DWORD)(ch4) & 0xFF0000) >> 8) |  \
  66.                   (((DWORD)(ch4) & 0xFF000000) >> 24))
  67.  
  68. typedef struct _riffchunk {
  69.    FOURCC fcc;
  70.    DWORD  cb;
  71.    } RIFFCHUNK, * LPRIFFCHUNK;
  72. typedef struct _rifflist {
  73.    FOURCC fcc;
  74.    DWORD  cb;
  75.    FOURCC fccListType;
  76.    } RIFFLIST, * LPRIFFLIST;
  77.  
  78. #define RIFFROUND(cb) ((cb) + ((cb)&1))
  79. #define RIFFNEXT(pChunk) (LPRIFFCHUNK)((LPBYTE)(pChunk) \
  80.                           + sizeof(RIFFCHUNK) \
  81.                           + RIFFROUND(((LPRIFFCHUNK)pChunk)->cb))
  82.  
  83.  
  84. //
  85. // ==================== avi header structures ===========================
  86. //
  87.  
  88. // main header for the avi file (compatibility header)
  89. //
  90. #define ckidMAINAVIHEADER FCC('avih')
  91. typedef struct _avimainheader {
  92.     FOURCC fcc;                    // 'avih'
  93.     DWORD  cb;                     // size of this structure -8
  94.     DWORD  dwMicroSecPerFrame;     // frame display rate (or 0L)
  95.     DWORD  dwMaxBytesPerSec;       // max. transfer rate
  96.     DWORD  dwPaddingGranularity;   // pad to multiples of this size; normally 2K.
  97.     DWORD  dwFlags;                // the ever-present flags
  98.     #define AVIF_HASINDEX        0x00000010 // Index at end of file?
  99.     #define AVIF_MUSTUSEINDEX    0x00000020
  100.     #define AVIF_ISINTERLEAVED   0x00000100
  101.     #define AVIF_TRUSTCKTYPE     0x00000800 // Use CKType to find key frames
  102.     #define AVIF_WASCAPTUREFILE  0x00010000
  103.     #define AVIF_COPYRIGHTED     0x00020000
  104.     DWORD  dwTotalFrames;          // # frames in first movi list
  105.     DWORD  dwInitialFrames;
  106.     DWORD  dwStreams;
  107.     DWORD  dwSuggestedBufferSize;
  108.     DWORD  dwWidth;
  109.     DWORD  dwHeight;
  110.     DWORD  dwReserved[4];
  111.     } AVIMAINHEADER;
  112.  
  113. #define ckidODML          FCC('odml')
  114. #define ckidAVIEXTHEADER  FCC('dmlh')
  115. typedef struct _aviextheader {
  116.    FOURCC  fcc;                    // 'dmlh'
  117.    DWORD   cb;                     // size of this structure -8
  118.    DWORD   dwGrandFrames;          // total number of frames in the file
  119.    DWORD   dwFuture[61];           // to be defined later
  120.    } AVIEXTHEADER;
  121.  
  122. //
  123. // structure of an AVI stream header riff chunk
  124. //
  125. #define ckidSTREAMLIST   FCC('strl')
  126.  
  127. #ifndef ckidSTREAMHEADER
  128. #define ckidSTREAMHEADER FCC('strh')
  129. #endif
  130. typedef struct _avistreamheader {
  131.    FOURCC fcc;          // 'strh'
  132.    DWORD  cb;           // size of this structure - 8
  133.  
  134.    FOURCC fccType;      // stream type codes
  135.  
  136.    #ifndef streamtypeVIDEO
  137.    #define streamtypeVIDEO FCC('vids')
  138.    #define streamtypeAUDIO FCC('auds')
  139.    #define streamtypeMIDI  FCC('mids')
  140.    #define streamtypeTEXT  FCC('txts')
  141.    #endif
  142.  
  143.    FOURCC fccHandler;
  144.    DWORD  dwFlags;
  145.    #define AVISF_DISABLED          0x00000001
  146.    #define AVISF_VIDEO_PALCHANGES  0x00010000
  147.  
  148.    WORD   wPriority;
  149.    WORD   wLanguage;
  150.    DWORD  dwInitialFrames;
  151.    DWORD  dwScale;
  152.    DWORD  dwRate;       // dwRate/dwScale is stream tick rate in ticks/sec
  153.    DWORD  dwStart;
  154.    DWORD  dwLength;
  155.    DWORD  dwSuggestedBufferSize;
  156.    DWORD  dwQuality;
  157.    DWORD  dwSampleSize;
  158.    struct {
  159.       short int left;
  160.       short int top;
  161.       short int right;
  162.       short int bottom;
  163.       }   rcFrame;
  164.    } AVISTREAMHEADER;
  165.  
  166.  
  167. //
  168. // structure of an AVI stream format chunk
  169. //
  170. #ifndef ckidSTREAMFORMAT
  171. #define ckidSTREAMFORMAT FCC('strf')
  172. #endif
  173. //
  174. // avi stream formats are different for each stream type
  175. //
  176. // BITMAPINFOHEADER for video streams
  177. // WAVEFORMATEX or PCMWAVEFORMAT for audio streams
  178. // nothing for text streams
  179. // nothing for midi streams
  180.  
  181.  
  182. #pragma warning(disable:4200)
  183. //
  184. // structure of old style AVI index
  185. //
  186. #define ckidAVIOLDINDEX FCC('idx1')
  187. typedef struct _avioldindex {
  188.    FOURCC  fcc;        // 'idx1'
  189.    DWORD   cb;         // size of this structure -8
  190.    struct _avioldindex_entry {
  191.       DWORD   dwChunkId;
  192.       DWORD   dwFlags;
  193.  
  194.       #ifndef AVIIF_LIST
  195.       #define AVIIF_LIST       0x00000001
  196.       #define AVIIF_KEYFRAME   0x00000010
  197.       #endif
  198.      
  199.       #define AVIIF_NO_TIME    0x00000100
  200.       #define AVIIF_COMPRESSOR 0x0FFF0000  // unused?
  201.       DWORD   dwOffset;    // offset of riff chunk header for the data
  202.       DWORD   dwSize;      // size of the data (excluding riff header size)
  203.       } aIndex[];          // size of this array
  204.    } AVIOLDINDEX;
  205.  
  206.  
  207. //
  208. // ============ structures for timecode in an AVI file =================
  209. //
  210.  
  211. #ifndef TIMECODE_DEFINED
  212. #define TIMECODE_DEFINED
  213.  
  214. // defined
  215. // timecode time structure
  216. //
  217. typedef union _timecode {
  218.    struct {
  219.       WORD   wFrameRate;
  220.       WORD   wFrameFract;
  221.       LONG   cFrames;
  222.       };
  223.    DWORDLONG  qw;
  224.    } TIMECODE;
  225.  
  226. #endif // TIMECODE_DEFINED
  227.  
  228. #define TIMECODE_RATE_30DROP 0   // this MUST be zero
  229.  
  230. // struct for all the SMPTE timecode info
  231. //
  232. typedef struct _timecodedata {
  233.    TIMECODE time;
  234.    DWORD    dwSMPTEflags;
  235.    DWORD    dwUser;
  236.    } TIMECODEDATA;
  237.  
  238. // dwSMPTEflags masks/values
  239. //
  240. #define TIMECODE_SMPTE_BINARY_GROUP 0x07
  241. #define TIMECODE_SMPTE_COLOR_FRAME  0x08
  242.  
  243. //
  244. // ============ structures for new style AVI indexes =================
  245. //
  246.  
  247. // index type codes
  248. //
  249. #define AVI_INDEX_OF_INDEXES       0x00
  250. #define AVI_INDEX_OF_CHUNKS        0x01
  251. #define AVI_INDEX_OF_TIMED_CHUNKS  0x02
  252. #define AVI_INDEX_OF_SUB_2FIELD    0x03
  253. #define AVI_INDEX_IS_DATA          0x80
  254.  
  255. // index subtype codes
  256. //
  257. #define AVI_INDEX_SUB_DEFAULT     0x00
  258.  
  259. // INDEX_OF_CHUNKS subtype codes
  260. //
  261. #define AVI_INDEX_SUB_2FIELD      0x01
  262.  
  263. // meta structure of all avi indexes
  264. //
  265. typedef struct _avimetaindex {
  266.    FOURCC fcc;
  267.    UINT   cb;
  268.    WORD   wLongsPerEntry;
  269.    BYTE   bIndexSubType;
  270.    BYTE   bIndexType;
  271.    DWORD  nEntriesInUse;
  272.    DWORD  dwChunkId;
  273.    DWORD  dwReserved[3];
  274.    DWORD  adwIndex[];
  275.    } AVIMETAINDEX;
  276.  
  277. #define STDINDEXSIZE 0x4000
  278. #define NUMINDEX(wLongsPerEntry) ((STDINDEXSIZE-32)/4/(wLongsPerEntry))
  279. #define NUMINDEXFILL(wLongsPerEntry) ((STDINDEXSIZE/4) - NUMINDEX(wLongsPerEntry))
  280.  
  281. // structure of a super index (INDEX_OF_INDEXES)
  282. //
  283. #define ckidAVISUPERINDEX FCC('indx')
  284. typedef struct _avisuperindex {
  285.    FOURCC   fcc;               // 'indx'
  286.    UINT     cb;                // size of this structure
  287.    WORD     wLongsPerEntry;    // ==4
  288.    BYTE     bIndexSubType;     // ==0 (frame index) or AVI_INDEX_SUB_2FIELD 
  289.    BYTE     bIndexType;        // ==AVI_INDEX_OF_INDEXES
  290.    DWORD    nEntriesInUse;     // offset of next unused entry in aIndex
  291.    DWORD    dwChunkId;         // chunk ID of chunks being indexed, (i.e. RGB8)
  292.    DWORD    dwReserved[3];     // must be 0
  293.    struct _avisuperindex_entry {
  294.       DWORDLONG qwOffset;    // 64 bit offset to sub index chunk
  295.       DWORD    dwSize;       // 32 bit size of sub index chunk
  296.       DWORD    dwDuration;   // time span of subindex chunk (in stream ticks)
  297.       } aIndex[NUMINDEX(4)];
  298.    } AVISUPERINDEX;
  299. #define Valid_SUPERINDEX(pi) (*(DWORD *)(&((pi)->wLongsPerEntry)) == (4 | (AVI_INDEX_OF_INDEXES << 24)))
  300.  
  301. // struct of a standard index (AVI_INDEX_OF_CHUNKS)
  302. //
  303. typedef struct _avistdindex_entry {
  304.    DWORD dwOffset;       // 32 bit offset to data (points to data, not riff header)
  305.    DWORD dwSize;         // 31 bit size of data (does not include size of riff header), bit 31 is deltaframe bit
  306.    } AVISTDINDEX_ENTRY;
  307. #define AVISTDINDEX_DELTAFRAME ( 0x80000000) // Delta frames have the high bit set
  308. #define AVISTDINDEX_SIZEMASK   (~0x80000000)
  309.  
  310. typedef struct _avistdindex {
  311.    FOURCC   fcc;               // 'indx' or '##ix'
  312.    UINT     cb;                // size of this structure
  313.    WORD     wLongsPerEntry;    // ==2
  314.    BYTE     bIndexSubType;     // ==0
  315.    BYTE     bIndexType;        // ==AVI_INDEX_OF_CHUNKS
  316.    DWORD    nEntriesInUse;     // offset of next unused entry in aIndex
  317.    DWORD    dwChunkId;         // chunk ID of chunks being indexed, (i.e. RGB8)
  318.    DWORDLONG qwBaseOffset;     // base offset that all index intries are relative to
  319.    DWORD    dwReserved_3;      // must be 0
  320.    AVISTDINDEX_ENTRY aIndex[NUMINDEX(2)];
  321.    } AVISTDINDEX;
  322.  
  323. // struct of a time variant standard index (AVI_INDEX_OF_TIMED_CHUNKS)
  324. //
  325. typedef struct _avitimedindex_entry {
  326.    DWORD dwOffset;       // 32 bit offset to data (points to data, not riff header)
  327.    DWORD dwSize;         // 31 bit size of data (does not include size of riff header) (high bit is deltaframe bit)
  328.    DWORD dwDuration;     // how much time the chunk should be played (in stream ticks)
  329.    } AVITIMEDINDEX_ENTRY;
  330.  
  331. typedef struct _avitimedindex {
  332.    FOURCC   fcc;               // 'indx' or '##ix'
  333.    UINT     cb;                // size of this structure
  334.    WORD     wLongsPerEntry;    // ==3
  335.    BYTE     bIndexSubType;     // ==0
  336.    BYTE     bIndexType;        // ==AVI_INDEX_OF_TIMED_CHUNKS
  337.    DWORD    nEntriesInUse;     // offset of next unused entry in aIndex
  338.    DWORD    dwChunkId;         // chunk ID of chunks being indexed, (i.e. RGB8)
  339.    DWORDLONG qwBaseOffset;     // base offset that all index intries are relative to
  340.    DWORD    dwReserved_3;      // must be 0
  341.    AVITIMEDINDEX_ENTRY aIndex[NUMINDEX(3)];
  342.    DWORD adwTrailingFill[NUMINDEXFILL(3)]; // to align struct to correct size
  343.    } AVITIMEDINDEX;
  344.  
  345. // structure of a timecode stream
  346. //
  347. typedef struct _avitimecodeindex {
  348.    FOURCC   fcc;               // 'indx' or '##ix'
  349.    UINT     cb;                // size of this structure
  350.    WORD     wLongsPerEntry;    // ==4
  351.    BYTE     bIndexSubType;     // ==0
  352.    BYTE     bIndexType;        // ==AVI_INDEX_IS_DATA
  353.    DWORD    nEntriesInUse;     // offset of next unused entry in aIndex
  354.    DWORD    dwChunkId;         // 'time'
  355.    DWORD    dwReserved[3];     // must be 0
  356.    TIMECODEDATA aIndex[NUMINDEX(sizeof(TIMECODEDATA)/sizeof(LONG))];
  357.    } AVITIMECODEINDEX;
  358.  
  359. // structure of a timecode discontinuity list (when wLongsPerEntry == 7)
  360. //
  361. typedef struct _avitcdlindex_entry {
  362.     DWORD    dwTick;           // stream tick time that maps to this timecode value
  363.     TIMECODE time;
  364.     DWORD    dwSMPTEflags;
  365.     DWORD    dwUser;
  366.     TCHAR    szReelId[12];
  367.     } AVITCDLINDEX_ENTRY;
  368.  
  369. typedef struct _avitcdlindex {
  370.    FOURCC   fcc;               // 'indx' or '##ix'
  371.    UINT     cb;                // size of this structure
  372.    WORD     wLongsPerEntry;    // ==7 (must be 4 or more all 'tcdl' indexes
  373.    BYTE     bIndexSubType;     // ==0
  374.    BYTE     bIndexType;        // ==AVI_INDEX_IS_DATA
  375.    DWORD    nEntriesInUse;     // offset of next unused entry in aIndex
  376.    DWORD    dwChunkId;         // 'tcdl'
  377.    DWORD    dwReserved[3];     // must be 0
  378.    AVITCDLINDEX_ENTRY aIndex[NUMINDEX(7)];
  379.    DWORD adwTrailingFill[NUMINDEXFILL(7)]; // to align struct to correct size
  380.    } AVITCDLINDEX;
  381.  
  382. typedef struct _avifieldindex_chunk {
  383.    FOURCC   fcc;               // 'ix##'
  384.    DWORD    cb;                // size of this structure
  385.    WORD     wLongsPerEntry;    // must be 3 (size of each entry in
  386.                                // aIndex array)
  387.    BYTE     bIndexSubType;     // AVI_INDEX_2FIELD
  388.    BYTE     bIndexType;        // AVI_INDEX_OF_CHUNKS
  389.    DWORD    nEntriesInUse;     //
  390.    DWORD    dwChunkId;         // '##dc' or '##db'
  391.    DWORDLONG qwBaseOffset;     // offsets in aIndex array are relative to this
  392.    DWORD    dwReserved3;       // must be 0
  393.    struct _avifieldindex_entry {
  394.       DWORD    dwOffset;
  395.       DWORD    dwSize;         // size of all fields
  396.                                // (bit 31 set for NON-keyframes)
  397.       DWORD    dwOffsetField2; // offset to second field
  398.    } aIndex[  ];
  399. } AVIFIELDINDEX, * PAVIFIELDINDEX;
  400.  
  401.  
  402. #include <poppack.h>
  403.  
  404. #endif
  405. #pragma option pop /*P_O_Pop*/
  406.