C H A P T E R 4

AVI Files

The Microsoft Audio/Video Interleaved (AVI) file format is a RIFF file specification used
with applications that capture, edit, and playback audio/video sequences. In general, AVI
files contain multiple streams of different types of data. Most AVI sequences will use both
audio and video streams. A simple variation for an AVI sequence uses video data and
does not require an audio stream. Specialized AVI sequences might include a control track
or MIDI track as an additional data stream. The control track could control external
devices such as an MCI videodisc player. The MIDI track could play background music
for the sequence. While a specialized sequence requires a specialized control program to
take advantage of all its capabilities, applications that can read and play AVI sequences
can still read and play an AVI sequence in a specialized file. (These applications ignore
the non-AVI data in the specialized file.) This chapter primarily describes AVI files
containing only audio and video data.
This chapter covers the following topics:
 The required chunks of an AVI file
 The optional chunks of an AVI file
 Developing routines to write AVI files
For additional information about RIFF files, see the Microsoft Windows Multimedia
Programmer’s Guide and Microsoft Windows Multimedia Programmer’s Reference.
For additional information about installable compressors and decompressors, see chapter
10, “Video Compression and Decompression Drivers.”

AVI RIFF Form

AVI files use the AVI RIFF form. The AVI RIFF form is identified by the four-character
code “AVI ”. All AVI files include two mandatory LIST chunks. These chunks define the
format of the streams and stream data. AVI files might also include an index chunk. This
錯誤! 僅限主文件。-2 Video for Windows Programmer's Guide
optional chunk specifies the location of data chunks within the file. An AVI file with these
components has the following form:
RIFF ('AVI '
LIST ('hdrl'
.
.
.
)
LIST ('movi'
.
.
.
)
['idx1'<AVI Index>]
)

The LIST chunks and the index chunk are subchunks of the RIFF “AVI ” chunk. The
“AVI ” chunk identifies the file as an AVI RIFF file. The LIST “hdrl” chunk defines the
format of the data and is the first required list chunk. The LIST “movi” chunk contains the
data for the AVI sequence and is the second required list chunk. The “idx1” chunk is the
optional index chunk. AVI files must keep these three components in the proper sequence.
The LIST “hdrl” and LIST “movi” chunks use subchunks for their data. The following
example shows the AVI RIFF form expanded with the chunks needed to complete the
LIST “hdrl” and LIST “movi” chunks:
RIFF ('AVI '
LIST ('hdrl'
'avih'(<Main AVI Header>)
LIST ('strl'
'strh'(<Stream header>)
'strf'(<Stream format>)
'strd'(additional header data)
.
.
.
)

.
.
.
)

02/10/93
 AVI Files 錯誤! 僅限主文件。-3
LIST ('movi'
{SubChunk | LIST('rec '
SubChunk1
SubChunk2
.
.
.
)

.
.
.
}

.
.
.
)

['idx1'<AVIIndex>]
)

The following sections describe the chunks contained in the LIST “hdrl” and LIST “movi”
chunks as well as the “idx1” chunk.

Data Structures for AVI Files

Data structures used in the RIFF chunks are defined in the AVIFMT.H header file. The
reference section at the end of this chapter describes the data structures that can be used
for the main AVI header, stream header, AVIIndex, and palette change chunks.

The Main AVI Header LIST

The file begins with the main header. In the AVI file, this header is identified with “avih”
four-character code. The header contains general information about the file, such as the
number of streams within the file and the width and height of the AVI sequence. The main
header has the following data structure defined for it:

02/10/93
錯誤! 僅限主文件。-4 Video for Windows Programmer's Guide
typedef struct {
DWORD dwMicroSecPerFrame;
DWORD dwMaxBytesPerSec;
DWORD dwReserved1;
DWORD dwFlags;
DWORD dwTotalFrames;
DWORD dwInitialFrames;
DWORD dwStreams;
DWORD dwSuggestedBufferSize;
DWORD dwWidth;
DWORD dwHeight;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
} MainAVIHeader;

The dwMicroSecPerFrame field specifies the period between video frames. This value
indicates the overall timing for the file.
The dwMaxBytesPerSec field specifies the approximate maximum data rate of the file.
This value indicates the number of bytes per second the system must handle to present an
AVI sequence as specified by the other parameters contained in the main header and
stream header chunks.
The dwFlags field contains any flags for the file. The following flags are defined:

AVIF_HASINDEX
Indicates the AVI file has an “idx1” chunk.
AVIF_MUSTUSEINDEX
Indicates the index should be used to determine the order of presentation of the data.
AVIF_ISINTERLEAVED
Indicates the AVI file is interleaved.
AVIF_WASCAPTUREFILE
Indicates the AVI file is a specially allocated file used for capturing real-time video.
AVIF_COPYRIGHTED
Indicates the AVI file contains copyrighted data.

The AVIF_HASINDEX and AVIF_MUSTUSEINDEX flags applies to files with an

index chunk. The AVI_HASINDEX flag indicates an index is present. The
AVIF_MUSTUSEINDEX flag indicates the index should be used to determine the order
of the presentation of the data. When this flag is set, it implies the physical ordering of the
chunks in the file does not correspond to the presentation order.
The AVIF_ISINTERLEAVED flag indicates the AVI file has been interleaved. The
system can stream interleaved data from a CD-ROM more efficiently than non-interleaved

02/10/93
 AVI Files 錯誤! 僅限主文件。-5
data. For more information on interleaved files, see “Special Information for Interleaved
Files.”
The AVIF_WASCAPTUREFILE flag indicates the AVI file is a specially allocated file
used for capturing real-time video. Typically, capture files have been defragmented by
user so video capture data can be efficiently streamed into the file. If this flag is set, an
application should warn the user before writing over the file with this flag.
The AVIF_COPYRIGHTED flag indicates the AVI file contains copyrighted data. When
this flag is set, applications should not let users duplicate the file or the data in the file.
The dwTotalFrames field of the main header specifies the total number of frames of data
in file.
The dwInitialFrames is used for interleaved files. If you are creating interleaved files,
specify the number of frames in the file prior to the initial frame of the AVI sequence in
this field.
The dwStreams field specifies the number of streams in the file. For example, a file with
audio and video has 2 streams.
The dwSuggestedBufferSize field 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, the buffer size should be
large enough to read an entire record and not just a chunk.
The dwWidth and dwHeight fields specify the width and height of the AVI file in pixels.
The dwScale and dwRate fields are used to specify the general time scale that the file will
use. In addition to this time scale, each stream can have its own time scale. The time scale
in samples per second is determined by dividing dwRate by dwScale.
The dwStart and dwLength fields specify the starting time of the AVI file and the length
of the file. The units are defined by dwRate and dwScale. The dwStart field is usually
set to zero.

The Stream Header (“strl”) Chunks

The main header is followed by one or more “strl” chunks. (A “strl” chunk is required for
each data stream.) These chunks contain information about the streams in the file. Each
“strl” chunk must contain a stream header and stream format chunk. Stream header chunks
are identified by the four-character code “strh” and stream format chunks are identified
with the four-character code “strf”. In addition to the stream header and stream format
chunks, the “strl” chunk might also contain a stream data chunk. Stream data chunks are
identified with the four-character code “strd”.

02/10/93
錯誤! 僅限主文件。-6 Video for Windows Programmer's Guide
The stream header has the following data structure defined for it:
typedef struct {
FOURCC fccType;
FOURCC fccHandler;
DWORD dwFlags;
DWORD dwReserved1;
DWORD dwInitialFrames;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
} AVIStreamHeader;

The stream header specifies the type of data the stream contains, such as audio or video,
by means of a four-character code. The fccType field is set to “vids” if the stream it
specifies contains video data. It is set to “auds” if it contains audio data.
The fccHandler field contains a four-character code describing the installable compressor
or decompressor used with the data.
The dwFlags field contains any flags for the data stream. The AVISF_DISABLED flag
indicates that the stream data should be rendered only when explicitly enabled by the user.
The AVISF_VIDEO_PALCHANGES flag indicates palette changes are embedded in the
file.
The dwInitialFrames is used for interleaved files. If you are creating interleaved files,
specify the number of frames in the file prior to the initial frame of the AVI sequence in
this field.
The remaining fields describe the playback characteristics of the stream. These factors
include the playback rate (dwScale and dwRate), the starting time of the sequence
(dwStart), the length of the sequence (dwLength), the size of the playback buffer
(dwSuggestedBuffer), an indicator of the data quality (dwQuality), and sample size
(dwSampleSize). See the reference section for more information on these fields.
Some of the fields in the stream header structure are also present in the main header
structure. The data in the main header structure applies to the whole file while the data in
the stream header structure applies only to a stream.
A stream format (“strf”) chunk must follow a stream header (“strh”) chunk. The stream
format chunk describes the format of the data in the stream. For video streams, the
information in this chunk is a BITMAPINFO structure (including palette information if
appropriate). For audio streams, the information in this chunk is a WAVEFORMATEX or
PCMWAVEFORMAT structure. (The WAVEFORMATEX structure is an extended
version of the WAVEFORMAT structure.) For more information on this structure, see the
New Multimedia Data Types and Data Techniques Standards Update.
The “strl” chunk might also contain a stream data (“strd”) chunk. If used, this chunk
follows the stream format chunk. The format and content of this chunk is defined by
installable compression or decompression drivers. Typically, drivers use this information

02/10/93
 AVI Files 錯誤! 僅限主文件。-7
for configuration. Applications that read and write RIFF files do not need to decode this
information. They transfer this data to and from a driver as a memory block.
An AVI player associates the stream headers in the LIST “hdrl” chunk with the stream
data in the LIST “movi” chunk by using the order of the “strl” chunks. The first “strl”
chunk applies to stream 0, the second applies to stream 1, and so forth. For example, if the
first “strl” chunk describes the wave audio data, the wave audio data is contained in
stream 0. Similarly, if the second “strl” chunk describes video data, then the video data is
contained in stream 1.

The LIST “movi” Chunk

Following the header information is a LIST “movi” chunk that contains chunks of the
actual data in the streams; that is, the pictures and sounds themselves. The data chunks can
reside directly in the LIST “movi” chunk or they might be grouped into “rec ” chunks. The
“rec ” grouping implies that the grouped chunks should be read from disk all at once. This
is used only for files specifically interleaved to play from CD-ROM.
Like any RIFF chunk, the data chunks contain a four-character code to identify the chunk
type. The four-character code that identifies each chunk consists of the stream number and
a two-character code that defines the type of information encapsulated in the chunk. For
example, a waveform chunk is identified by a two-character code of “wb”. If a waveform
chunk corresponded to the second LIST “hdrl” stream description, it would have a four-
character code of “01wb”.
Since all the format information is in the header, the audio data contained in these data
chunks does not contain any information about its format. An audio data chunk has the
following format (the ## in the format represents the stream identifier):
WAVE Bytes '##wb'
BYTE abBytes[];

Video data can be compressed or uncompressed DIBs. An uncompressed DIB has

BI_RGB specified for the biCompression field in its associated BITMAPINFO structure.
A compressed DIB has a value other than BI_RGB specified in the biCompression field.
For more information about compression formats, see the description of the
BITMAPINFOHEADER data structure in the Microsoft Windows Programmers
Reference and Chapter 5, “DIB Format Extensions for Microsoft Windows.”
A data chunk for an uncompressed DIB contains RGB video data. These chunks are
identified with a two-character code of “db” (db is an abbreviation for DIB bits). Data
chunks for a compressed DIB are identified with a two-character code of “dc” (dc is an
abbreviation for DIB compressed). Neither data chunk will contain any header
information about the DIBs. The data chunk for an uncompressed DIB has the following
form:
DIB Bits '##db'
BYTE abBits[];

02/10/93
錯誤! 僅限主文件。-8 Video for Windows Programmer's Guide
The data chunk for a compressed DIB has the following form:
Compressed DIB '##dc'
BYTE abBits[];

Video data chunks can also define new palette entries used to update the palette during an
AVI sequence. These chunks are identified with a two-character code of “pc” (pc is an
abbreviation for palette change). The following data structure is defined palette
information:
typedef struct {
BYTE bFirstEntry;
BYTE bNumEntries;
WORD wFlags;
PALETTEENTRY peNew;
} AVIPALCHANGE;

The bFirstEntry field defines the first entry to change and the bNumEntries field
specifies the number of entries to change. The peNew field contains the new color entries.
If you include palette changes in a video stream, set the AVITF_VIDEO_PALCHANGES
flag in the dwFlags field of the stream header. This flag indicates that this video stream
contains palette changes and warns the playback software that it will need to animate the
palette.

The “idx1” Chunk

AVI files can have an index chunk after the LIST “movi” chunk. The index chunk
essentially contains a list of the data chunks and their location in the file. This provides
efficient random access to the data within the file, because an application can locate a
particular sound sequence or video image in a large AVI file without having to scan it.
Index chunks use the four-character code “idx1”. The following data structure is defined
for index entries:
typedef struct {
DWORD ckid;
DWORD dwFlags;
DWORD dwChunkOffset;
DWORD dwChunkLength;
} AVIINDEXENTRY;

The ckid, dwFlags, dwChunkOffset, and dwChunkLength entries are repeated in the
AVI file for each data chunk indexed. If the file is interleaved, the index will also have
these entries for each “rec” chunk. The “rec” entries should have the AVIIF_LIST flag set
and the list type in the ckid field.
The ckid field identifies the data chunk. This field uses four-character codes for
identifying the chunk.
The dwFlags field specifies any flags for the data. The AVIIF_KEYFRAME flag
indicates key frames in the video sequence. Key frames do not need previous video
information to be decompressed. The AVIIF_NOTIME flag indicates a chunk does not

02/10/93
 AVI Files 錯誤! 僅限主文件。-9
affect the timing of a video stream. For example, changing palette entries indicated by a
palette chunk should occur between displaying video frames. Thus, if an application needs
to determine the length of a video sequence, it should not use chunks with the
AVIIF_NOTIME flag. In this case, it would ignore a palette chunk. The AVIIF_LIST flag
indicates the current chunk is a LIST chunk. Use the ckid field to identify the type of
LIST chunk.
The dwChunkOffset and dwChunkLength fields specify the position of the chunk and
the length of the chunk. The dwChunkOffset field specifies the position of the chunk in
the file relative to the 'movi' list. The dwChunkLength field specifies the length of the
chunk excluding the eight bytes for the RIFF header.
If you include an index in the RIFF file, set the AVIF_HASINDEX in the dwFlags field
of the AVI header. (This header is identified by “avih” chunk ID.) This flag indicates that
the file has an index.

Other Data Chunks

If you need to align data in your AVI file you can add a “JUNK” chunk. (This chunk is a
standard RIFF type.) Applications reading these chunks ignore their contents. Files played
from CD-ROM use these chunks to align data so they can be read more efficiently. You
might want to use this chunk to align your data for the 2 kilobyte CD-ROM boundaries.
The “JUNK” chunk has the following form:
AVI Padding 'JUNK'
Byte data[]

As with any other RIFF files, all applications that read AVI files should ignore the non-
AVI chunks that it does not recognize. Applications that read and write AVI files should
preserve the non-AVI chunks when they save files they have loaded.

Special Information for Interleaved Files

Files that are interleaved for playback from CD-ROM require some special handling.
While they can be read similarly to any other AVI files, they require special care when
produced.
The audio has to be separated into single-frame pieces, and audio and video for each
frame needs to be grouped together into “rec ” chunks. The record chunks should be
padded so that their size is a multiple of 2 kilobytes and so that the beginning of the actual
data in the LIST chunk lies on a 2 kilobyte boundary in the file. (This implies that the
LIST chunk itself begins 12 bytes before a 2 kilobyte boundary.)
To give the audio driver enough audio to work with, the audio data has to be skewed from
the video data. Typically, the audio data should be moved forward enough frames to allow
approximately 0.75 seconds of audio data to be preloaded. The dwInitialRecords field of
the main header and the dwInitialFrames field of the audio stream header should be set
to the number of frames the audio is skewed.
Additionally, you must ensure that CD-ROM drive is capable of reading the data fast
enough to support your AVI sequence. Non-MPC CD-ROM drives can have a data rate of
less than 150 kilobytes per second.

02/10/93
錯誤! 僅限主文件。-10 Video for Windows Programmer's Guide

Using VidEdit With AVI Files

VidEdit lets you create and edit audio-visual sequences consisting of a series of frames
that contain digital audio and video data. You can use VidEdit to create and edit AVI files
that contain one audio and one video stream. Each stream in the file must start at the
beginning of the file (that is, the dwStart field in each stream header must be zero).

Example Code for Writing AVI Files

The WRITEAVI.C and AVIEASY.C files contain example code for writing AVI files.
For simplicity, the examples assume that all video frames are uncompressed DIBs of the
same size. While the DIBS can have any bit depth; 8, 16, and 24 bits are preferred.
These examples also assume all wave data is in memory. A more generalized procedure
should work with wave data that is in memory as well as in a disk file. These examples do
not restrict wave data to PCM. It should work with any format.

An Outline for Writing AVI Files

Like other RIFF files, AVI files are created with the mmioOpen, mmioCreateChunk,
mmioWrite, mmioAscend, and mmioClose functions. These functions have the
following definitions:

mmioOpen
Opens a file for reading or writing, and returns a handle to the open file.
mmioCreateChunk
Creates a new chunk in a RIFF file.
mmioWrite
Writes a specified number of bytes to an open file.
mmioAscend
Ascends out of a RIFF file chunk to the next chunk in the file.
mmioClose
Closes an open file.

In addition to these functions, you can use mmioFOURCC to convert four individual
characters into a four-character code. For more information on these functions and macros,
see the Microsoft Windows Multimedia Programmer’s Guide and Microsoft Windows
Multimedia Programmer’s Reference.

02/10/93
 AVI Files 錯誤! 僅限主文件。-11
Note:

The AVIFMT.H file contains macro definitions for creating the two- and four-character
codes described in this chapter. It also defines the aviTWOCC and
TWOCCFromFOURCC macros. These macros create two-character codes from
individual characters or from four-character codes.

Unlike many other RIFF files, AVI files use many nested chunks and subchunks. This
makes them more complicated than most RIFF files. Use the following tables as a
checklist to help you decide when to create a chunk, when to write data to a chunk, and
when to ascend from a chunk. The tables do not include information about writing non-
AVI data chunks to the file. The information in the chunk column of the table mirrors the
example in the “AVI RIFF Form” section presented previously.

Creating the File and “AVI ” Chunk

The “AVI ” chunk is the first chunk in the file. You will not ascend from this chunk until
all other chunks have been created.

Chunk How to Handle

RIFF ('AVI ' Use mmioOpen to open the file. Seek to the
beginning of the file with mmioSeek. Create the
AVI chunk with mmioCreateChunk. (Use the
“AVI ” four-character code and the
MMIO_CREATERIFF flag.) Do not ascend from
this chunk in preparation for writing the remaining
chunks.

Creating the LIST “hdrl ” and “avih” Chunks

The LIST “hdrl ” chunk contains the stream format header chunks. Because it contains
other chunks, you will not ascend from it until the other header chunks are created.
The “avih” chunk contains the main header list. This is written as a complete chunk.

Chunk How to Handle

LIST ('hdrl' Create the LIST “hdrl” chunk with
mmioCreateChunk. (Use the “hdrl” four-
character code and the MMIO_CREATELIST
flag.)
'avih'(<Main AVI Header>) Create the Main AVI Header chunk with
mmioCreateChunk. (Use the “avih” four-
character code.) Write the header information with
mmioWrite. Ascend from the “avih” chunk with
mmioAscend. Do not ascend from the LIST
“hdrl” chunk.

02/10/93
錯誤! 僅限主文件。-12 Video for Windows Programmer's Guide

Creating the “strl”, “strh”, “strf”, and “strd” Chunks

The “strl”, “strh”, “strf”, and “strd” chunks are written as complete chunks. You write a
set of the “strh”, “strf”, and “strd” chunks for each stream in the file. After all the stream
descriptions are written, you ascend from LIST “hdrl” chunk.

Chunk How to Handle

LIST ('strl' Create the LIST “strl” chunk with
mmioCreateChunk. (Use the “strl” four-character
code and the MMIO_CREATELIST flag.)
'strh'(<Stream header>) Create the stream header chunk with
mmioCreateChunk. (Use the “strh” four-character
code.) Write the stream header information with
mmioWrite. Ascend from the “strh” chunk with
mmioAscend.
'strf'(<Stream format>) Create the stream format chunk with
mmioCreateChunk. (Use the “strf” four-character
code.) Write the stream format information with
mmioWrite. Ascend from the “strf” chunk with
mmioAscend.
'strd'(additional header data) If needed, create chunks for any additional header
data with mmioCreateChunk. (Use the “strd”
four-character code.) Write the additional header
data with mmioWrite. Ascend from the “strd”
chunk.
. If needed, add stream header, stream format, and
. additional header data chunks for other streams in
. the file.
) Ascend from the LIST “strl” chunk with
mmioAscend.
. Ascend from the LIST “hdrl” chunk with
. mmioAscend. If needed, create and write padding
. chunks or other data chunks.
)

Creating the LIST “movi” and “rec ” Chunks

The LIST “movi” chunk contains other chunks. After you create this chunk, you will not
ascend from it until the other chunks are written.

02/10/93
 AVI Files 錯誤! 僅限主文件。-13
You can write the data as an individual chunk or as part of a “rec ” chunk. Like the LIST
“movi” chunk, you will not ascend from a “rec ” chunk until you write all of its subchunks.

Chunk How to Handle

LIST ('movi' Create the LIST “movi” chunk with
mmioCreateChunk. (Use the LIST “movi” four-
character code and the MMIO_CREATELIST
flag.)
{ SubChunk | You can add your movie data directly at this point
LIST('rec ' in a subchunk or include it in a “rec ” chunk. The
SubChunk1 following steps summarize creating these chunks:
SubChunk2 Create a data chunk with mmioCreateChunk.
. (Use the four-character code appropriate for the
. data chunk and stream.) If you are adding an index
. chunk to the end of the file, save the location of the
) subchunks for it.
.
.
.
}
.
.
.
) Ascend from the LIST “movi ” chunk.

Creating the “idx1” Chunk and Ascending From the “AVI ” Chunk
The optional index chunk is written as a complete chunk. After you have completed this
chunk, you can ascend from the “AVI ” chunk and close the file.

Chunk How to Handle

['idx1'<AVIIndex>] If used, create the AVI index chunk with
mmioCreateChunk. (Use the “idx1” four-
character code.) Write the index information with
mmioWrite. Ascend from the “idx1” chunk with
mmioAscend. Although the “idx1” is the last
chunk used in an AVI sequence, you can add non-
AVI chunks after it. These subchunks will still be
part of the “AVI ” chunk.
) Ascend from the “AVI ” chunk with mmioAscend.
Close the file with mmioClose.

02/10/93
錯誤! 僅限主文件。-14 Video for Windows Programmer's Guide

AVI RIFF File Reference

This section lists data structures used to support AVI RIFF files. (These structures are
defined in AVIFMT.H.) The data structures are presented in alphabetical order. The
structure definition is given, followed by a description of each field.

AVIINDEXENTRY
The AVI file index consists of an array of 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.
typedef struct {
DWORD ckid;
DWORD dwFlags;
DWORD dwChunkOffset;
DWORD dwChunkLength;
} AVIINDEXENTRY;

Fields
The AVIINDEXENTRY structure has the following fields:
ckid
Specifies a four-character code corresponding to the chunk ID of a data chunk in the
file.
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:
AVIIF_LIST
Indicates the specified chunk is a 'LIST' chunk, and the ckid field contains the list
type of the chunk.
AVIIF_KEYFRAME
Indicates this chunk is a key frame. Key frames do not require additional preceding
chunks to be properly decoded.

02/10/93
 AVI Files 錯誤! 僅限主文件。-15
AVIIF_FIRSTPART
Indicates this chunk needs the frames following it to be used; it cannot stand alone.
AVIIF_LASTPART
Indicates this chunk needs the frames preceding it to be used; it cannot stand alone.
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.
dwChunkOffset
Specifies the position in the file of the specified chunk. The position value includes the
eight byte RIFF header.
dwChunkLength
Specifies the length of the specified chunk. The length value does not include the eight
byte RIFF header.

AVIPALCHANGE
The AVIPALCHANGE structure is used in video streams containing palettized data to
indicate the palette should change for subsequent video data.
typedef struct {
BYTE bFirstEntry;
BYTE bNumEntries;
WORD wFlags;
PALETTEENTRY peNew;
} AVIPALCHANGE;

Fields
The AVIPALCHANGE structure has the following fields:
bFirstEntry
Specifies the first palette entry to change.
bNumEntries
Specifies the number of entries to change.
wFlags
Reserved. (This should be set to 0.)
peNew
Specifies an array of new palette entries.

02/10/93
錯誤! 僅限主文件。-16 Video for Windows Programmer's Guide

AVIStreamHeader
The 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.
typedef struct {
FOURCC fccType;
FOURCC fccHandler;
DWORD dwFlags;
DWORD dwReserved1;
DWORD dwInitialFrames;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
DWORD dwSuggestedBufferSize;
DWORD dwQuality;
DWORD dwSampleSize;
} AVIStreamHeader;

Fields
The AVIStreamHeader structure has the following fields:
fccType
Contains a four-character code which specifies the type of data contained in the stream.
The following values are currently defined for AVI data:
'vids'
Indicates the stream contains video data. The stream format chunk contains a
BITMAPINFO structure which can include palette information.
'auds'
Indicates the stream contains video data. The stream format chunk contains a
WAVEFORMAT or PCMWAVEFORMAT structure.
Other four-character codes can identify non-AVI data.
fccHandler
Optionally, contains a four-character code that identifies a specific data handler. The
data handler is the preferred handler for the stream.
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:
AVISF_DISABLED
Indicates this stream should not be enabled by default.
AVISF_VIDEO_PALCHANGES
Indicates this video stream contains palette changes. This flag warns the playback
software that it will need to animate the palette.
dwReserved1
Reserved. (Should be set to 0.)

02/10/93
 AVI Files 錯誤! 僅限主文件。-17
dwInitialFrames
Specifies how far audio data is skewed ahead of the video frames in interleaved files.
Typically, this is about 0.75 seconds.
dwScale
This field is used together with dwRate to specify the time scale that this stream will
use.
Dividing dwRate by 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 nBlockAlign
bytes of audio, which for PCM audio simply reduces to the sample rate.
dwRate
See dwScale.
dwStart
Specifies the starting time of the AVI file. The units are defined by the dwRate and
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.
dwLength
Specifies the length of this stream. The units are defined by the dwRate and dwScale
fields of the stream’s header.
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.
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. If set to -1, drivers use the
default quality value.
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 nBlockAlign field of the
WAVEFORMAT structure describing the audio.

02/10/93
錯誤! 僅限主文件。-18 Video for Windows Programmer's Guide

MainAVIHeader
The 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.
typedef struct {
DWORD dwMicroSecPerFrame;
DWORD dwMaxBytesPerSec;
DWORD dwReserved1;
DWORD dwFlags;
DWORD dwTotalFrames;
DWORD dwInitialFrames;
DWORD dwStreams;
DWORD dwSuggestedBufferSize;
DWORD dwWidth;
DWORD dwHeight;
DWORD dwScale;
DWORD dwRate;
DWORD dwStart;
DWORD dwLength;
} MainAVIHeader;

Fields
The MainAVIHeader structure has the following fields:
dwMicroSecPerFrame
Specifies the number of microseconds between frames.
dwMaxBytesPerSec
Specifies the approximate maximum data rate of file.
dwReserved1
Reserved. (This field should be set to 0.)
dwFlags
Specifies any applicable flags. The following flags are defined:
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.
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.
AVIF_ISINTERLEAVED
Indicates the AVI file is interleaved.
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.

02/10/93
 AVI Files 錯誤! 僅限主文件。-19
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.
dwTotalFrames
Specifies the number of frames of data in file.
dwInitialFrames
Specifies the initial frame for interleaved files. Non-interleaved files should specify
zero.
dwStreams
Specifies the number of streams in the file. For example, a file with audio and video
has 2 streams.
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.
dwWidth
Specifies the width of the AVI file in pixels.
dwHeight
Specifies the height of the AVI file in pixels.
dwScale
This field is used with dwRate to specify the time scale that the file as a whole will use.
In addition, each stream can have its own time scale.
Dividing dwRate by dwScale gives the number of samples per second.
dwRate
See dwScale.
dwStart
Specifies the starting time of the AVI file. The units are defined by dwRate and
dwScale. This field is usually set to zero.
dwLength
Specifies the length of the AVI file. The units are defined by dwRate and dwScale.
This length is returned by MCIAVI when using the frames time format.

02/10/93