You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
529 lines
20 KiB
529 lines
20 KiB
/****************************************************************************/
|
|
/* */
|
|
/* AVIFFMT.H - Include file for working with AVI files */
|
|
/* */
|
|
/* Note: You must include WINDOWS.H and MMSYSTEM.H before */
|
|
/* including this file. */
|
|
/* */
|
|
/* Copyright (c) 1991-1992, Microsoft Corp. All rights reserved. */
|
|
/* */
|
|
/****************************************************************************/
|
|
|
|
/*
|
|
*
|
|
* An AVI file is the following RIFF form:
|
|
*
|
|
* RIFF('AVI'
|
|
* LIST('hdrl'
|
|
* avih(<MainAVIHeader>)
|
|
* LIST ('strl'
|
|
* strh(<Stream header>)
|
|
* strf(<Stream format>)
|
|
* ... additional header data
|
|
* LIST('movi'
|
|
* { LIST('rec'
|
|
* SubChunk...
|
|
* )
|
|
* | SubChunk } ....
|
|
* )
|
|
* [ <AVIIndex> ]
|
|
* )
|
|
*
|
|
* The first two characters of each chunk are the track number.
|
|
* SubChunk = { xxdh(<AVI DIB header>)
|
|
* | xxdb(<AVI DIB bits>)
|
|
* | xxdc(<AVI compressed DIB bits>)
|
|
* | xxpc(<AVI Palette Change>)
|
|
* | xxwb(<AVI WAVE bytes>)
|
|
* | xxws(<AVI Silence record>)
|
|
* | xxmd(<MIDI data>)
|
|
* | additional custom chunks }
|
|
*
|
|
*/
|
|
/*
|
|
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
* We need a better description of the AVI file header here.
|
|
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
|
*
|
|
* The grouping into LIST 'rec' chunks implies only that the contents of
|
|
* the chunk should be read into memory at the same time. This
|
|
* grouping is only necessary for interleaved files.
|
|
*
|
|
* For loading efficiency, the beginning of each LIST 'rec' chunk may
|
|
* be aligned on a 2K boundary. (Actually, the beginning of the LIST
|
|
* chunk should be 12 bytes before a 2K boundary, so that the data chunks
|
|
* inside the LIST chunk are aligned.)
|
|
*
|
|
* If the AVI file is being played from CD-ROM in, it is recommended that
|
|
* the file be padded.
|
|
*
|
|
* Limitations for the Alpha release:
|
|
* If the AVI file has audio, each record LIST must contain exactly
|
|
* one audio chunk, which must be the first chunk.
|
|
* Each record must contain exactly one video chunk (possibly preceded
|
|
* by one or more palette change chunks).
|
|
* No wave format or DIB header chunks may occur outside of the header.
|
|
*/
|
|
|
|
#ifndef _INC_AVIFFMT
|
|
#define _INC_AVIFFMT
|
|
|
|
#ifndef RC_INVOKED
|
|
#pragma pack(1) /* Assume byte packing throughout */
|
|
#endif /* RC_INVOKED */
|
|
|
|
#ifndef mmioFOURCC
|
|
#define mmioFOURCC( ch0, ch1, ch2, ch3 ) \
|
|
( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \
|
|
( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )
|
|
#endif
|
|
|
|
/* Macro to make a TWOCC out of two characters */
|
|
#ifndef aviTWOCC
|
|
#define aviTWOCC(ch0, ch1) ((WORD)(BYTE)(ch0) | ((WORD)(BYTE)(ch1) << 8))
|
|
#endif
|
|
|
|
typedef WORD TWOCC;
|
|
|
|
/* form types, list types, and chunk types */
|
|
#define formtypeAVI mmioFOURCC('A', 'V', 'I', ' ')
|
|
#define listtypeAVIHEADER mmioFOURCC('h', 'd', 'r', 'l')
|
|
#define ckidAVIMAINHDR mmioFOURCC('a', 'v', 'i', 'h')
|
|
#define listtypeSTREAMHEADER mmioFOURCC('s', 't', 'r', 'l')
|
|
#define ckidSTREAMHEADER mmioFOURCC('s', 't', 'r', 'h')
|
|
#define ckidSTREAMFORMAT mmioFOURCC('s', 't', 'r', 'f')
|
|
#define ckidSTREAMHANDLERDATA mmioFOURCC('s', 't', 'r', 'd')
|
|
|
|
#define listtypeAVIMOVIE mmioFOURCC('m', 'o', 'v', 'i')
|
|
#define listtypeAVIRECORD mmioFOURCC('r', 'e', 'c', ' ')
|
|
|
|
#define ckidAVINEWINDEX mmioFOURCC('i', 'd', 'x', '1')
|
|
|
|
/*
|
|
** Here are some stream types. Currently, only audio and video
|
|
** are supported.
|
|
*/
|
|
#define streamtypeVIDEO mmioFOURCC('v', 'i', 'd', 's')
|
|
#define streamtypeAUDIO mmioFOURCC('a', 'u', 'd', 's')
|
|
#define streamtypeMIDI mmioFOURCC('m', 'i', 'd', 's')
|
|
#define streamtypeTEXT mmioFOURCC('t', 'x', 't', 's')
|
|
|
|
/*
|
|
** Here are some compression types.
|
|
*/
|
|
#define comptypeRLE0 mmioFOURCC('R','L','E','0')
|
|
#define comptypeRLE mmioFOURCC('R','L','E',' ')
|
|
#define comptypeDIB mmioFOURCC('D','I','B',' ')
|
|
|
|
#define cktypeDIBbits aviTWOCC('d', 'b')
|
|
#define cktypeDIBcompressed aviTWOCC('d', 'c')
|
|
#define cktypeDIBhalf aviTWOCC('d', 'x')
|
|
#define cktypePALchange aviTWOCC('p', 'c')
|
|
#define cktypeWAVEbytes aviTWOCC('w', 'b')
|
|
#define cktypeWAVEsilence aviTWOCC('w', 's')
|
|
|
|
#define cktypeMIDIdata aviTWOCC('m', 'd')
|
|
|
|
#define cktypeDIBheader aviTWOCC('d', 'h')
|
|
#define cktypeWAVEformat aviTWOCC('w', 'f')
|
|
|
|
#define ckidAVIPADDING mmioFOURCC('J', 'U', 'N', 'K')
|
|
#define ckidOLDPADDING mmioFOURCC('p', 'a', 'd', 'd')
|
|
|
|
|
|
/*
|
|
** Useful macros
|
|
*/
|
|
#define ToHex(n) ((BYTE) (((n) > 9) ? ((n) - 10 + 'A') : ((n) + '0')))
|
|
#define FromHex(n) (((n) >= 'A') ? ((n) + 10 - 'A') : ((n) - '0'))
|
|
|
|
/* Macro to get stream number out of a FOURCC ckid */
|
|
#define StreamFromFOURCC(fcc) ((WORD) ((FromHex(LOBYTE(LOWORD(fcc))) << 4) + \
|
|
(FromHex(HIBYTE(LOWORD(fcc))))))
|
|
|
|
/* Macro to get TWOCC chunk type out of a FOURCC ckid */
|
|
#define TWOCCFromFOURCC(fcc) HIWORD(fcc)
|
|
|
|
/* Macro to make a ckid for a chunk out of a TWOCC and a stream number
|
|
** from 0-255.
|
|
**
|
|
** Warning: This is a nasty macro, and MS C 6.0 compiles it incorrectly
|
|
** if optimizations are on. Ack.
|
|
*/
|
|
#define MAKEAVICKID(tcc, stream) \
|
|
MAKELONG((ToHex((stream) & 0x0f) << 8) | ToHex(((stream) & 0xf0) >> 4), tcc)
|
|
|
|
|
|
|
|
/*
|
|
** Main AVI File Header
|
|
*/
|
|
|
|
/* flags for use in <dwFlags> in AVIFileHdr */
|
|
#define AVIF_HASINDEX 0x00000010 // Index at end of file?
|
|
#define AVIF_MUSTUSEINDEX 0x00000020
|
|
#define AVIF_ISINTERLEAVED 0x00000100
|
|
#define AVIF_VARIABLESIZEREC 0x00000200
|
|
#define AVIF_NOPADDING 0x00000400
|
|
#define AVIF_WASCAPTUREFILE 0x00010000
|
|
#define AVIF_COPYRIGHTED 0x00020000
|
|
|
|
/* The AVI File Header LIST chunk should be padded to this size */
|
|
#define AVI_HEADERSIZE 2048 // size of AVI header list
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL AVI_FFMT
|
|
*
|
|
* @types MainAVIHeader | The <t MainAVIHeader> structure contains
|
|
* global information for the entire AVI file. It is contained
|
|
* within an 'avih' chunk within the LIST 'hdrl' chunk at the
|
|
* beginning of an AVI RIFF file.
|
|
*
|
|
* @field DWORD | dwMicroSecPerFrame | Specifies the number of
|
|
* microseconds between frames.
|
|
*
|
|
* @field DWORD | dwMaxBytesPerSec | Specifies the approximate
|
|
* maximum data rate of file.
|
|
*
|
|
* @field DWORD | dwReserved1 | Reserved. (This field should be set to 0.)
|
|
*
|
|
* @field DWORD | dwFlags | Specifies any applicable flags.
|
|
* The following flags are defined:
|
|
*
|
|
* @flag AVIF_HASINDEX | Indicates
|
|
* the AVI file has an 'idx1' chunk containing an index
|
|
* at the end of the file. For good performance, all AVI
|
|
* files should contain an index.
|
|
*
|
|
* @flag AVIF_MUSTUSEINDEX | Indicates that the
|
|
* index, rather than the physical ordering of the chunks
|
|
* in the file, should be used to determine the order of
|
|
* presentation of the data. For example, this could be
|
|
* used for creating a list frames for editing.
|
|
*
|
|
* @flag AVIF_ISINTERLEAVED | Indicates
|
|
* the AVI file is interleaved.
|
|
*
|
|
* @flag AVIF_WASCAPTUREFILE | Indicates
|
|
* the AVI file is a specially allocated file used for
|
|
* capturing real-time video. Applications should warn the
|
|
* user before writing over a file with this flag set
|
|
* because the user probably defragmented
|
|
* this file.
|
|
*
|
|
* @flag AVIF_COPYRIGHTED | Indicates the
|
|
* AVI file contains copyrighted data and software.
|
|
* When this flag is used,
|
|
* software should not permit the data to be duplicated.
|
|
*
|
|
* @field DWORD | dwTotalFrames | Specifies the number of
|
|
* frames of data in file.
|
|
*
|
|
* @field DWORD | dwInitialFrames | Specifies the initial frame
|
|
* for interleaved files. Non-interleaved files should specify
|
|
* zero.
|
|
*
|
|
* @field DWORD | dwStreams | Specifies the number of streams in the file.
|
|
* For example, a file with audio and video has 2 streams.
|
|
*
|
|
* @field DWORD | dwSuggestedBufferSize | Specifies the suggested
|
|
* buffer size for reading the file. Generally, this size
|
|
* should be large enough to contain the largest chunk in
|
|
* the file. If set to zero, or if it is too small, the playback
|
|
* software will have to reallocate memory during playback
|
|
* which will reduce performance.
|
|
*
|
|
* For an interleaved file, this buffer size should be large
|
|
* enough to read an entire record and not just a chunk.
|
|
*
|
|
* @field DWORD | dwWidth | Specifies the width of the AVI file in pixels.
|
|
*
|
|
* @field DWORD | dwHeight | Specifies the height of the AVI file in pixels.
|
|
*
|
|
* @field DWORD | dwScale | This field is used with
|
|
* <e MainAVIHeader.dwRate> to specify the time scale that
|
|
* applies to the AVI file. In addition, each stream
|
|
* can have its own time scale.
|
|
*
|
|
* Dividing <e MainAVIHeader.dwRate> by <e AVIStreamHeader.dwScale>
|
|
* gives the number of samples per second.
|
|
*
|
|
* @field DWORD | dwRate | See <e MainAVIHeader.dwScale>.
|
|
*
|
|
* @field DWORD | dwStart | Specifies the starting time of the AVI file.
|
|
* The units are defined by <e MainAVIHeader.dwRate> and
|
|
* <e MainAVIHeader.dwScale>. This field is usually set to zero.
|
|
*
|
|
* @field DWORD | dwLength | Specifies the length of the AVI file.
|
|
* The units are defined by <e AVIStreamHeader.dwRate> and
|
|
* <e AVIStreamHeader.dwScale>. This length is returned by MCIAVI when
|
|
* using the frames time format.
|
|
*
|
|
****************************************************************************/
|
|
|
|
typedef struct
|
|
{
|
|
DWORD dwMicroSecPerFrame; // frame display rate (or 0L)
|
|
DWORD dwMaxBytesPerSec; // max. transfer rate
|
|
DWORD dwPaddingGranularity; // pad to multiples of this
|
|
// size; normally 2K.
|
|
DWORD dwFlags; // the ever-present flags
|
|
DWORD dwTotalFrames; // # frames in file
|
|
DWORD dwInitialFrames;
|
|
DWORD dwStreams;
|
|
DWORD dwSuggestedBufferSize;
|
|
|
|
DWORD dwWidth;
|
|
DWORD dwHeight;
|
|
|
|
/* Do we want the stuff below for the whole movie, or just
|
|
** for the individual streams?
|
|
*/
|
|
DWORD dwScale;
|
|
DWORD dwRate; /* dwRate / dwScale == samples/second */
|
|
DWORD dwStart; /* Is this always zero? */
|
|
DWORD dwLength; /* In units above... */
|
|
} MainAVIHeader;
|
|
|
|
|
|
/*
|
|
** Stream header
|
|
*/
|
|
|
|
/* !!! Do we need to distinguish between discrete and continuous streams? */
|
|
|
|
#define AVISF_DISABLED 0x00000001
|
|
#define AVISF_VIDEO_PALCHANGES 0x00010000
|
|
/* Do we need identity palette support? */
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL AVI_FFMT
|
|
*
|
|
* @types AVIStreamHeader | The <t AVIStreamHeader> structure contains
|
|
* header information for a single stream of an file. It is contained
|
|
* within an 'strh' chunk within a LIST 'strl' chunk that is itself
|
|
* contained within the LIST 'hdrl' chunk at the beginning of
|
|
* an AVI RIFF file.
|
|
*
|
|
* @field FOURCC | fccType | Contains a four-character code which specifies
|
|
* the type of data contained in the stream. The following values are
|
|
* currently defined:
|
|
*
|
|
* @flag 'vids' | Indicates the stream contains video data. The stream
|
|
* format chunk contains a <t BITMAPINFO> structure which can include
|
|
* palette information.
|
|
*
|
|
* @flag 'auds' | Indicates the stream contains video data. The stream
|
|
* format chunk contains a <t WAVEFORMATEX> or <t PCMWAVEFORMAT>
|
|
* structure.
|
|
*
|
|
* New data types should be registered with the <MI>Multimedia Developer
|
|
* Registration Kit<D>.
|
|
*
|
|
* @field FOURCC | fccHandler | Contains a four-character code that
|
|
* identifies a specific data handler.
|
|
*
|
|
* @field DWORD | dwFlags | Specifies any applicable flags.
|
|
* The bits in the high-order word of these flags
|
|
* are specific to the type of data contained in the stream.
|
|
* The following flags are currently defined:
|
|
*
|
|
* @flag AVISF_DISABLED | Indicates
|
|
* this stream should not be enabled by default.
|
|
*
|
|
* @flag AVISF_VIDEO_PALCHANGES | Indicates
|
|
* this video stream contains palette changes. This flag warns
|
|
* the playback software that it will need to animate the
|
|
* palette.
|
|
*
|
|
* @field DWORD | dwReserved1 | Reserved. (Should be set to 0.)
|
|
*
|
|
* @field DWORD | dwInitialFrames | Reserved for interleaved files.
|
|
* (Set this to 0 for non-interleaved files.)
|
|
*
|
|
* @field DWORD | dwScale | This field is used together with
|
|
* <e AVIStreamHeader.dwRate> to specify the time scale that
|
|
* this stream will use.
|
|
*
|
|
* Dividing <e AVIStreamHeader.dwRate> by <e AVIStreamHeader.dwScale>
|
|
* gives the number of samples per second.
|
|
*
|
|
* For video streams, this rate should be the frame rate.
|
|
*
|
|
* For audio streams, this rate should correspond to the time needed for
|
|
* <e WAVEFORMATEX.nBlockAlign> bytes of audio, which for PCM audio simply
|
|
* reduces to the sample rate.
|
|
*
|
|
* @field DWORD | dwRate | See <e AVIStreamHeader.dwScale>.
|
|
*
|
|
* @field DWORD | dwStart | Specifies the starting time of the AVI file.
|
|
* The units are defined by the
|
|
* <e MainAVIHeader.dwRate> and <e MainAVIHeader.dwScale> fields
|
|
* in the main file header. Normally, this is zero, but it can
|
|
* specify a delay time for a stream which does not start concurrently
|
|
* with the file.
|
|
*
|
|
* Note: The 1.0 release of the AVI tools does not support a non-zero
|
|
* starting time.
|
|
*
|
|
* @field DWORD | dwLength | Specifies the length of this stream.
|
|
* The units are defined by the
|
|
* <e AVIStreamHeader.dwRate> and <e AVIStreamHeader.dwScale>
|
|
* fields of the stream's header.
|
|
*
|
|
* @field DWORD | dwSuggestedBufferSize | Suggests how large a buffer
|
|
* should be used to read this stream. Typically, this contains a
|
|
* value corresponding to the largest chunk present in the stream.
|
|
* Using the correct buffer size makes playback more efficient.
|
|
* Use zero if you do not know the correct buffer size.
|
|
*
|
|
* @field DWORD | dwQuality | Specifies an indicator of the quality
|
|
* of the data in the stream. Quality is
|
|
* represented as a number between 0 and 10000. For compressed data,
|
|
* this typically represent the value of the quality parameter
|
|
* passed to the compression software.
|
|
*
|
|
* @field DWORD | dwSampleSize | Specifies the size of a single sample
|
|
* of data. This is set to
|
|
* zero if the samples can vary in size. If this number is non-zero, then
|
|
* multiple samples of data can be grouped into a single chunk within
|
|
* the file. If it is zero, each sample of data (such as a video
|
|
* frame) must be in a separate chunk.
|
|
*
|
|
* For video streams, this number is typically zero, although it
|
|
* can be non-zero if all video frames are the same size.
|
|
*
|
|
* For audio streams, this number should be the same as the
|
|
* <e WAVEFORMATEX.nBlockAlign> field of the <t WAVEFORMATEX> structure
|
|
* describing the audio.
|
|
*
|
|
****************************************************************************/
|
|
typedef struct {
|
|
FOURCC fccType;
|
|
FOURCC fccHandler;
|
|
DWORD dwFlags; /* Contains AVITF_* flags */
|
|
WORD wPriority;
|
|
WORD wLanguage;
|
|
DWORD dwInitialFrames;
|
|
DWORD dwScale;
|
|
DWORD dwRate; /* dwRate / dwScale == samples/second */
|
|
DWORD dwStart;
|
|
DWORD dwLength; /* In units above... */
|
|
|
|
// new....
|
|
DWORD dwSuggestedBufferSize;
|
|
DWORD dwQuality;
|
|
DWORD dwSampleSize;
|
|
RECT rcFrame; /* does each frame need this? */
|
|
|
|
/* additional type-specific data goes in StreamInfo chunk */
|
|
|
|
/* For video: position within rectangle... */
|
|
/* For audio: volume? stereo channel? */
|
|
} AVIStreamHeader;
|
|
|
|
typedef struct {
|
|
RECT rcFrame;
|
|
} AVIVideoStreamInfo;
|
|
|
|
typedef struct {
|
|
WORD wLeftVolume; // !!! Range?
|
|
WORD wRightVolume;
|
|
DWORD dwLanguage; // !!! Is there a standard representation of this?
|
|
} AVIAudioStreamInfo;
|
|
|
|
|
|
#define AVIIF_LIST 0x00000001L // chunk is a 'LIST'
|
|
#define AVIIF_TWOCC 0x00000002L // ckid is a TWOCC?
|
|
#define AVIIF_KEYFRAME 0x00000010L // this frame is a key frame.
|
|
#define AVIIF_FIRSTPART 0x00000020L // this frame is the start of a partial frame.
|
|
#define AVIIF_LASTPART 0x00000040L // this frame is the end of a partial frame.
|
|
#define AVIIF_MIDPART (AVIIF_LASTPART|AVIIF_FIRSTPART)
|
|
#define AVIIF_NOTIME 0x00000100L // this frame doesn't take any time
|
|
|
|
#define AVIIF_COMPUSE 0x0FFF0000L // these bits are for compressor use
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL AVI_FFMT
|
|
*
|
|
* @types AVIINDEXENTRY | The AVI file index consists of an array
|
|
* of <t AVIINDEXENTRY> structures contained within an 'idx1'
|
|
* chunk at the end of an AVI file. This chunk follows the main LIST 'movi'
|
|
* chunk which contains the actual data.
|
|
*
|
|
* @field DWORD | ckid | Specifies a four-character code corresponding
|
|
* to the chunk ID of a data chunk in the file.
|
|
*
|
|
* @field DWORD | dwFlags | Specifies any applicable flags.
|
|
* The flags in the low-order word are reserved for AVI,
|
|
* while those in the high-order word can be used
|
|
* for stream- and compressor/decompressor-specific information.
|
|
*
|
|
* The following values are currently defined:
|
|
*
|
|
* @flag AVIIF_LIST | Indicates the specified
|
|
* chunk is a 'LIST' chunk, and the <e AVIINDEXENTRY.ckid>
|
|
* field contains the list type of the chunk.
|
|
*
|
|
* @flag AVIIF_KEYFRAME | Indicates this chunk
|
|
* is a key frame. Key frames do not require
|
|
* additional preceding chunks to be properly decoded.
|
|
*
|
|
* @flag AVIIF_NOTIME | Indicates this chunk should have no effect
|
|
* on timing or calculating time values based on the number of chunks.
|
|
* For example, palette change chunks in a video stream
|
|
* should have this flag set, so that they are not counted
|
|
* as taking up a frame's worth of time.
|
|
*
|
|
* @field DWORD | dwChunkOffset | Specifies the position in the file of the
|
|
* specified chunk. The position value includes the eight byte RIFF header.
|
|
*
|
|
* @field DWORD | dwChunkLength | Specifies the length of the
|
|
* specified chunk. The length value does not include the eight
|
|
* byte RIFF header.
|
|
*
|
|
****************************************************************************/
|
|
typedef struct
|
|
{
|
|
DWORD ckid;
|
|
DWORD dwFlags;
|
|
DWORD dwChunkOffset; // Position of chunk
|
|
DWORD dwChunkLength; // Length of chunk
|
|
} AVIINDEXENTRY;
|
|
|
|
|
|
/*
|
|
** Palette change chunk
|
|
**
|
|
** Used in video streams.
|
|
*/
|
|
typedef struct
|
|
{
|
|
BYTE bFirstEntry; /* first entry to change */
|
|
BYTE bNumEntries; /* # entries to change (0 if 256) */
|
|
WORD wFlags; /* Mostly to preserve alignment... */
|
|
PALETTEENTRY peNew[]; /* New color specifications */
|
|
} AVIPALCHANGE;
|
|
|
|
/*****************************************************************************
|
|
* @doc EXTERNAL AVI_FFMT
|
|
*
|
|
* @types AVIPALCHANGE | The <t AVIPALCHANGE> structure is used in
|
|
* video streams containing palettized data to indicate the
|
|
* palette should change for subsequent video data.
|
|
*
|
|
* @field BYTE | bFirstEntry | Specifies the first palette entry to change.
|
|
*
|
|
* @field BYTE | bNumEntries | Specifies the number of entries to change.
|
|
*
|
|
* @field WORD | wFlags | Reserved. (This should be set to 0.)
|
|
*
|
|
* @field PALETTEENTRY | peNew | Specifies an array of new palette entries.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef RC_INVOKED
|
|
#pragma pack() /* Revert to default packing */
|
|
#endif /* RC_INVOKED */
|
|
|
|
#endif /* INC_AVIFFMT */
|