• Home
• com.infotel.seleniumRobot
• grid-extensions
• 4.23.13
• source code
• AbstractAVIStream.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.seleniumtests.util.video.avi.AbstractAVIStream Maven / Gradle / Ivy

/*
 * @(#)AbstractAVIStream.java  
 * 
 * Copyright (c) 2011 Werner Randelshofer, Goldau, Switzerland.
 * All rights reserved.
 * 
 * You may not use, copy or modify this file, except in compliance with the
 * license agreement you entered into with Werner Randelshofer.
 * For details see accompanying license terms.
 */
package com.seleniumtests.util.video.avi;

import org.monte.media.riff.RIFFChunk;
import java.util.Map;
import org.monte.media.Buffer;
import org.monte.media.Codec;
import org.monte.media.Format;
import org.monte.media.io.SubImageOutputStream;
import java.awt.Dimension;
import java.awt.image.IndexColorModel;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import javax.imageio.stream.ImageOutputStream;
import static org.monte.media.VideoFormatKeys.*;

/**
 * This is the base class for low-level AVI stream IO.
 *
 * @author Werner Randelshofer
 * @version $Id: AbstractAVIStream.java 299 2013-01-03 07:40:18Z werner $
 */
public abstract class AbstractAVIStream {

    /**
     * Chunk IDs.
     */
    /*
    protected final static int RIFF_ID = 0x46464952;//0x52494646;// "RIFF"
    protected final static int AVI_ID = 0x20495641; //0x41564920;// "AVI "
    protected final static int LIST_ID = 0x5453494c;//0x4c495354;// "LIST"
    protected final static int MOVI_ID = 0x69766f6d;//0x6d6f7669;// "movi"
    protected final static int HDRL_ID = 0x6c726468;//0x6864726c;// "hdrl"
    protected final static int AVIH_ID = 0x68697661;//0x61766968;// "avih"
    protected final static int STRL_ID = 0x6c727473;//0x7374726c;// "strl"
    protected final static int STRH_ID = 0x68727473;//0x73747268;// "strh"
    protected final static int STRN_ID = 0x6e727473;//0x7374726e;// "strn"
    protected final static int STRF_ID = 0x66727473;//0x73747266;// "strf"
    protected final static int STRD_ID = 0x64727473;//0x73747264;// "strd"
    protected final static int IDX1_ID = 0x31786469;//0x69647831;// "idx1"
    protected final static int REC_ID = 0x20636572;//0x72656320;// "rec "
    protected final static int PC_ID = 0x63700000;//0x00007063;// "??pc"
    protected final static int DB_ID = 0x62640000;//0x00006462;// "??db"
    protected final static int DC_ID = 0x63640000;//0x00006463;// "??dc"
    protected final static int WB_ID = 0x62770000;//0x00007762;// "??wb"
    */
    protected final static int RIFF_ID =0x52494646;// "RIFF"
    protected final static int AVI_ID = 0x41564920;// "AVI "
    protected final static int AVIX_ID = 0x41564958;// "AVIX"
    protected final static int LIST_ID = 0x4c495354;// "LIST"
    protected final static int MOVI_ID = 0x6d6f7669;// "movi"
    protected final static int HDRL_ID = 0x6864726c;// "hdrl"
    protected final static int AVIH_ID = 0x61766968;// "avih"
    protected final static int STRL_ID = 0x7374726c;// "strl"
    protected final static int STRH_ID = 0x73747268;// "strh"
    protected final static int STRN_ID = 0x7374726e;// "strn"
    protected final static int STRF_ID = 0x73747266;// "strf"
    protected final static int STRD_ID = 0x73747264;// "strd"
    protected final static int IDX1_ID = 0x69647831;// "idx1"
    protected final static int REC_ID = 0x72656320;// "rec "
    protected final static int CHUNK_SUBTYPE_MASK = 0xffff;// "??xx"
    protected final static int PC_ID = 0x00007063;// "??pc"
    protected final static int DB_ID = 0x00006462;// "??db"
    protected final static int DC_ID = 0x00006463;// "??dc"
    protected final static int WB_ID = 0x00007762;// "??wb"
    
    /**
     * Indicates the AVI file has an index.
     */
    public final static int AVIH_FLAG_HAS_INDEX = 0x00000010;
    /**
     * Indicates that application should use the index, rather than the physical
     * ordering of the chunks in the file, to determine the order of
     * presentation of the data. For example, this flag could be used to create
     * a list of frames for editing.
     */
    public final static int AVIH_FLAG_MUST_USE_INDEX = 0x00000020;
    /**
     * Indicates the AVI file is interleaved.
     */
    public final static int AVIH_FLAG_IS_INTERLEAVED = 0x00000100;
    /**
     * ??
     */
    public final static int AVIH_FLAG_TRUST_CK_TYPE = 0x00000800;
    /**
     * // 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.
     */
    public final static int AVIH_FLAG_WAS_CAPTURE_FILE = 0x00010000;
    /* Indicates the AVI file contains copyrighted data and 
     * software. When this flag is used, software should not
     * permit the data to be duplicated. */
    public final static int AVIH_FLAG_COPYRIGHTED = 0x00020000;
    /**
     * Indicates this stream should not be enabled by default.
     */
    public final static int STRH_FLAG_DISABLED = 0x00000001;
    /**
     * Indicates this video stream contains palette changes. This flag warns the
     * playback software that it will need to animate the palette.
     */
    public final static int STRH_FLAG_VIDEO_PALETTE_CHANGES = 0x00010000;
    /**
     * Underlying output stream.
     */
    protected ImageOutputStream out;
    /**
     * The offset in the underlying ImageOutputStream. Normally this is 0 unless
     * the underlying stream already contained data when it was passed to the
     * constructor.
     */
    protected long streamOffset;

    /**
     * Supported media types.
     */
    public static enum AVIMediaType {

        AUDIO("auds"),//
        MIDI("mids"),//
        TEXT("txts"),//
        VIDEO("vids")//
        ;
        protected final String fccType;

        @Override
        public String toString() {
            return fccType;
        }

        AVIMediaType(String fourCC) {
            this.fccType = fourCC;
        }
    }
    /**
     * The list of tracks in the file.
     */
    protected ArrayList tracks = new ArrayList();

    /**
     * Gets the position relative to the beginning of the QuickTime stream. 

     * Usually this value is equal to the stream position of the underlying
     * ImageOutputStream, but can be larger if the underlying stream already
     * contained data.
     *
     * @return The relative stream position.
     * @throws IOException
     */
    protected long getRelativeStreamPosition() throws IOException {
        return out.getStreamPosition() - streamOffset;
    }

    /**
     * Seeks relative to the beginning of the AVI stream. 
 Usually this equal
     * to seeking in the underlying ImageOutputStream, but can be different if
     * the underlying stream already contained data.
     *
     */
    protected void seekRelative(long newPosition) throws IOException {
        out.seek(newPosition + streamOffset);
    }

    /**
     * AVI stores media data in sample chunks. A sample chunk may contain one or
     * more media samples. A media sample is a single element in a sequence of
     * time-ordered data.
     */
    protected static class Sample {

        int chunkType;
        /**
         * Offset of the sample chunk relative to the startTime of the AVI file.
         */
        long offset;
        /**
         * Data length of the sample chunk.
         */
        long length;
        /**
         * The number of media samples in the sample chunk.
         */
        int duration;
        /**
         * Whether the sample is a sync-sample.
         */
        boolean isKeyframe;
        long timeStamp;
        /**
         * Palette change sample.
         */
        Sample header;

        /**
         * Creates a new sample.
         *
         * @param duration The number of media samples contained in the sample
         * chunk.
         * @param offset The offset in the AVI stream.
         * @param length The length in the AVI stream.
         */
        public Sample(int chunkId, int duration, long offset, long length, boolean isSync) {
            this.chunkType = chunkId;
            this.duration = duration;
            this.offset = offset;
            this.length = length;
            this.isKeyframe = isSync;
        }
    }

    /**
     * Represents a track (or "stream") in an AVI file. 
 A track is defined
     * by an "strh" chunk, which contains an {@code AVISTREAMHEADER} struct.
     * Additional chunks can be provided depending on the media type of the
     * track. 
 See 
     * http://msdn.microsoft.com/en-us/library/ms779638(VS.85).aspx 
     * 
     * -----------------
     * AVI Stream Header
     * -----------------
     *
     * enum {
     *    audioStream = "auds",
     *   midiStream = "mids",
     *   textStream = "txts",
     *   videoStream = "vids"
     * } aviStrhType;
     *
     * set {
     *    disabled = 0x00000001, // Indicates this stream should not be enabled by default.
     *    videoPaletteChanges = 0x00010000
     *        // Indicates this video stream contains palette changes. This flag
     *        // warns the playback software that it will need to animate the palette.
     *} aviStrhFlags;
     *
     *typedef struct {
     *    Int16 left;
     *    Int16 top;
     *    Int16 right;
     *    Int16 bottom;
     *} aviRectangle;
     *
     *typedef struct {
     *     FOURCC enum aviStrhType type;
     *        // Contains a FOURCC that specifies the type of the data contained in
     *        // the stream. The following standard AVI values for video and audio are
     *        // defined.
     *     FOURCC handler;
     *        // Optionally, contains a FOURCC that identifies a specific data
     *        // handler.
     *        // The data handler is the preferred handler for the stream. For audio
     *        // and video streams, this specifies the codec for decoding the stream.
     *     DWORD  set aviStrhFlags flags;
     *        // Contains any flags for the data stream. The bits in the high-order
     *        // word of these flags are specific to the type of data contained in the
     *        // stream.
     *     WORD   priority;
     *        // Specifies priority of a stream type. For example, in a file with
     *        // multiple audio streams, the one with the highest priority might be
     *        // the default stream.
     *     WORD   language;
     *     DWORD  initialFrames;
     *        // Specifies how far audio data is skewed ahead of the video frames in
     *        // interleaved files. Typically, this is about 0.75 seconds. 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 member. For
     *        // more information about the contents of this member, see "Special
     *        // Information for Interleaved Files" in the Video for Windows
     *        // Programmer's Guide.
     *     DWORD  scale;
     *        // Used with "rate" to specify the time scale that this stream will use.
     *        // Dividing "rate" by "scale" gives the number of samples per second.
     *        // For video streams, this is the frame rate. For audio streams, this
     *        // rate corresponds to the time needed to play blockAlign bytes of
     *        // audio, which for PCM audio is the just the sample rate.
     *     DWORD  rate;
     *        // See "scale".
     *     DWORD  startTime;
     *        // Specifies the starting time for this stream. The units are defined by
     *        // the "rate" and "scale" members in the main file header. Usually, this
     *        // is zero, but it can specify a delay time for a stream that does not
     *        // startTime concurrently with the file.
     *     DWORD  length;
     *        // Specifies the length of this stream. The units are defined by the
     *        // "rate" and "scale" members of the stream's header.
     *     DWORD  suggestedBufferSize;
     *        // Specifies 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.
     *     DWORD  quality;
     *        // Specifies an indicator of the quality of the data in the stream.
     *        // Quality is represented as a number between 0 and 10,000. For
     *        // compressed data, this typically represents the value of the quality
     *        // parameter passed to the compression software. If set to �1, drivers
     *        // use the default quality value.
     *     DWORD  sampleSize;
     *        // 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 nonzero, 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 nonzero if all video frames are
     *        // the same size. For audio streams, this number should be the same as
     *        // the blockAlign member of the WAVEFORMATEX structure describing the audio.
     *    aviRectangle frame;
     *        // Specifies the destination rectangle for a text or video stream within
     *        // the movie rectangle specified by the "frameWidth" and "frameHeight"
     *        // members of the AVI main header structure. The "frame" member is
     *        // typically used in support of multiple video streams. Set this
     *        // rectangle to the coordinates corresponding to the movie rectangle to
     *        // update the whole movie rectangle. Units for this member are pixels.
     *        // The upper-left corner of the destination rectangle is relative to the
     *        // upper-left corner of the movie rectangle.
     * } AVISTREAMHEADER; * 
     */
    protected abstract class Track {

        /**
         * The media format.
         *
         * FIXME - AbstractAVIStream should have no dependencies to Format.
         */
        protected Format format;
        // Common metadata
        /**
         * The scale of the media in the track. 
 Used with rate to specify
         * the time scale that this stream will use. Dividing rate by scale
         * gives the number of samples per second. For video streams, this is
         * the frame rate. For audio streams, this rate corresponds to the time
         * needed to play blockAlign bytes of audio, which for PCM audio is just
         * the sample rate.
         */
        /**
         * The rate of the media in scale units. 

         *
         * @see scale
         */
        /**
         * List of samples.
         */
        protected ArrayList samples;
        /**
         * Interval between sync samples (keyframes). 0 = automatic. 1 = write
         * all samples as sync samples. n = sync every n-th sample.
         */
        protected int syncInterval = 30;
        /**
         * The twoCC code is used for the ids of the chunks which hold the data
         * samples.
         */
        protected int twoCC;
        //
        // AVISTREAMHEADER structure
        // -------------------------
        /**
         * {@code mediaType.fccType} contains a FOURCC that specifies the type
         * of the data contained in the stream. The following standard AVI
         * values for video and audio are defined.
         *
         * FOURCC	Description 'auds'	Audio stream 'mids'	MIDI stream 'txts'	Text
         * stream 'vids'	Video stream
         *
         */
        protected final AVIMediaType mediaType;
        //protected String fccType;
        /**
         * Optionally, contains a FOURCC that identifies a specific data
         * handler. The data handler is the preferred handler for the stream.
         * For audio and video streams, this specifies the codec for decoding
         * the stream.
         */
        protected int fccHandler;
        /**
         * Contains any flags for the data stream. The bits in the high-order
         * word of these flags are specific to the type of data contained in the
         * stream. The following standard flags are defined.
         *
         * Value	Description
         *
         * AVISF_DISABLED	0x00000001 Indicates this stream should not be enabled
         * by default.
         *
         * AVISF_VIDEO_PALCHANGES 0x00010000 Indicates this video stream
         * contains palette changes. This flag warns the playback software that
         * it will need to animate the palette.
         */
        protected int flags;
        /**
         * Specifies priority of a stream type. For example, in a file with
         * multiple audio streams, the one with the highest priority might be
         * the default stream.
         */
        protected int priority = 0;
        /**
         * Language tag.
         */
        protected int language = 0;
        /**
         * Specifies how far audio data is skewed ahead of the video frames in
         * interleaved files. Typically, this is about 0.75 seconds. 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 member. For
         * more information, see the remarks for the initialFrames member of the
         * AVIMAINHEADER structure.
         */
        protected long initialFrames = 0;
        /**
         * Used with rate to specify the time scale that this stream will use.
         * Dividing rate by scale gives the number of samples per second. For
         * video streams, this is the frame rate. For audio streams, this rate
         * corresponds to the time needed to play blockAlign bytes of audio,
         * which for PCM audio is the just the sample rate.
         */
        protected long scale = 1;
        /**
         * The rate of the media in scale units.
         */
        protected long rate = 30;
        /**
         * Specifies the starting time for this stream. The units are defined by
         * the rate and scale members in the main file header. Usually, this is
         * zero, but it can specify a delay time for a stream that does not
         * startTime concurrently with the file.
         */
        protected long startTime = 0;
        /**
         * Specifies the length of this stream. The units are defined by the
         * rate and scale members of the stream's header.
         */
        protected long length;
        /**
         * Specifies 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.
         */
        //protected long dwSuggestedBufferSize; => this field is computed from tr.samples
        /**
         * Specifies an indicator of the quality of the data in the stream.
         * Quality is represented as a number between 0 and 10,000. For
         * compressed data, this typically represents the value of the quality
         * parameter passed to the compression software. If set to –1, drivers
         * use the default quality value.
         */
        protected int quality = -1;
        /**
         * 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 nonzero, 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 nonzero if all video frames are
         * the same size. For audio streams, this number should be the same as
         * the blockAlign member of the WAVEFORMATEX structure describing the
         * audio.
         */
        //protected long dwSampleSize; => computed from tr.samples
        /**
         * Specifies the destination rectangle for a text or video stream within
         * the movie rectangle specified by the dwWidth and dwHeight members of
         * the AVI main header structure. The rcFrame member is typically used
         * in support of multiple video streams. Set this rectangle to the
         * coordinates corresponding to the movie rectangle to update the whole
         * movie rectangle. Units for this member are pixels. The upper-left
         * corner of the destination rectangle is relative to the upper-left
         * corner of the movie rectangle.
         */
        int frameLeft;
        int frameTop;
        int frameRight;
        int frameBottom;
        // --------------------------------
        // End of AVISTREAMHEADER structure
        /**
         * This chunk holds the AVI Stream Header.
         */
        protected FixedSizeDataChunk strhChunk;
        /**
         * This chunk holds the AVI Stream Format Header.
         */
        protected FixedSizeDataChunk strfChunk;
        /**
         * The optional name of the track.
         */
        protected String name;
        /**
         * The codec.
         */
        protected Codec codec;
        /**
         * The output buffer is used to store the output of the codec.
         */
        protected Buffer outputBuffer;
        /**
         * The input buffer is used when one of the convenience methods without
         * a Buffer parameter is used.
         */
        protected Buffer inputBuffer;
        /**
         * The current chunk index of the reader.
         */
        protected long readIndex = 0;
        /**
         * List of additional header chunks.
         */
        protected ArrayList extraHeaders;

        public Track(int trackIndex, AVIMediaType mediaType, int fourCC) {
            this.mediaType = mediaType;
            twoCC = (('0'+trackIndex/10)<<24) | (('0'+trackIndex%10)<<16);
            
            this.fccHandler = fourCC;
            this.samples = new ArrayList();
            this.extraHeaders = new ArrayList();
        }

        public abstract long getSTRFChunkSize();

        public abstract int getSampleChunkFourCC(boolean isSync);

        public void addSample(Sample s) {
            if (!samples.isEmpty()) {
                s.timeStamp = samples.get(samples.size() - 1).timeStamp + samples.get(samples.size() - 1).duration;
            }
            samples.add(s);
            length++;
        }
    }

    /**
     * Represents a video track in an AVI file. 
 The format of a video track
     * is defined in a "strf" chunk, which contains a {@code BITMAPINFOHEADER}
     * struct.
     *
     * 

     * ----------------------
     * AVI Wave Format Header
     * ----------------------
     * // values for this enum taken from mmreg.h
     * enum {
     *         WAVE_FORMAT_PCM = 0x0001,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_ADPCM = 0x0002,
     *         //  Microsoft Corporation
     *          *   IEEE754: range (+1, -1]
     *          *  32-bit/64-bit format as defined by
     *          *  MSVC++ float/double type
     *
     *         WAVE_FORMAT_IEEE_FLOAT = 0x0003,
     *         //  IBM Corporation
     *         WAVE_FORMAT_IBM_CVSD = 0x0005,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_ALAW = 0x0006,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_MULAW = 0x0007,
     *         //  OKI
     *         WAVE_FORMAT_OKI_ADPCM = 0x0010,
     *         //  Intel Corporation
     *         WAVE_FORMAT_DVI_ADPCM = 0x0011,
     *         //  Intel Corporation
     *         WAVE_FORMAT_IMA_ADPCM = 0x0011,
     *         //  Videologic
     *         WAVE_FORMAT_MEDIASPACE_ADPCM = 0x0012,
     *         //  Sierra Semiconductor Corp
     *         WAVE_FORMAT_SIERRA_ADPCM = 0x0013,
     *         //  Antex Electronics Corporation
     *         WAVE_FORMAT_G723_ADPCM = 0x0014,
     *         //  DSP Solutions, Inc.
     *         WAVE_FORMAT_DIGISTD = 0x0015,
     *         //  DSP Solutions, Inc.
     *         WAVE_FORMAT_DIGIFIX = 0x0016,
     *         //  Dialogic Corporation
     *         WAVE_FORMAT_DIALOGIC_OKI_ADPCM = 0x0017,
     *         //  Media Vision, Inc.
     *         WAVE_FORMAT_MEDIAVISION_ADPCM = 0x0018,
     *         //  Yamaha Corporation of America
     *         WAVE_FORMAT_YAMAHA_ADPCM = 0x0020,
     *         //  Speech Compression
     *         WAVE_FORMAT_SONARC = 0x0021,
     *         //  DSP Group, Inc
     *         WAVE_FORMAT_DSPGROUP_TRUESPEECH = 0x0022,
     *         //  Echo Speech Corporation
     *         WAVE_FORMAT_ECHOSC1 = 0x0023,
     *         //
     *         WAVE_FORMAT_AUDIOFILE_AF36 = 0x0024,
     *         //  Audio Processing Technology
     *         WAVE_FORMAT_APTX = 0x0025,
     *         //
     *         WAVE_FORMAT_AUDIOFILE_AF10 = 0x0026,
     *         //  Dolby Laboratories
     *         WAVE_FORMAT_DOLBY_AC2 = 0x0030,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_GSM610 = 0x0031,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_MSNAUDIO = 0x0032,
     *         //  Antex Electronics Corporation
     *         WAVE_FORMAT_ANTEX_ADPCME = 0x0033,
     *         //  Control Resources Limited
     *         WAVE_FORMAT_CONTROL_RES_VQLPC = 0x0034,
     *         //  DSP Solutions, Inc.
     *         WAVE_FORMAT_DIGIREAL = 0x0035,
     *         //  DSP Solutions, Inc.
     *         WAVE_FORMAT_DIGIADPCM = 0x0036,
     *         //  Control Resources Limited
     *         WAVE_FORMAT_CONTROL_RES_CR10 = 0x0037,
     *         //  Natural MicroSystems
     *         WAVE_FORMAT_NMS_VBXADPCM = 0x0038,
     *         // Crystal Semiconductor IMA ADPCM
     *         WAVE_FORMAT_CS_IMAADPCM = 0x0039,
     *         // Echo Speech Corporation
     *         WAVE_FORMAT_ECHOSC3 = 0x003A,
     *         // Rockwell International
     *         WAVE_FORMAT_ROCKWELL_ADPCM = 0x003B,
     *         // Rockwell International
     *         WAVE_FORMAT_ROCKWELL_DIGITALK = 0x003C,
     *         // Xebec Multimedia Solutions Limited
     *         WAVE_FORMAT_XEBEC = 0x003D,
     *         //  Antex Electronics Corporation
     *         WAVE_FORMAT_G721_ADPCM = 0x0040,
     *         //  Antex Electronics Corporation
     *         WAVE_FORMAT_G728_CELP = 0x0041,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_MPEG = 0x0050,
     *         //  ISO/MPEG Layer3 Format Tag
     *         WAVE_FORMAT_MPEGLAYER3 = 0x0055,
     *         //  Cirrus Logic
     *         WAVE_FORMAT_CIRRUS = 0x0060,
     *         //  ESS Technology
     *         WAVE_FORMAT_ESPCM = 0x0061,
     *         //  Voxware Inc
     *         WAVE_FORMAT_VOXWARE = 0x0062,
     *         //  Canopus, co., Ltd.
     *         WAVE_FORMAT_CANOPUS_ATRAC = 0x0063,
     *         //  APICOM
     *         WAVE_FORMAT_G726_ADPCM = 0x0064,
     *         //  APICOM
     *         WAVE_FORMAT_G722_ADPCM = 0x0065,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_DSAT = 0x0066,
     *         //  Microsoft Corporation
     *         WAVE_FORMAT_DSAT_DISPLAY = 0x0067,
     *         //  Softsound, Ltd.
     *         WAVE_FORMAT_SOFTSOUND = 0x0080,
     *         //  Rhetorex Inc
     *         WAVE_FORMAT_RHETOREX_ADPCM = 0x0100,
     *         //  Creative Labs, Inc
     *         WAVE_FORMAT_CREATIVE_ADPCM = 0x0200,
     *         //  Creative Labs, Inc
     *         WAVE_FORMAT_CREATIVE_FASTSPEECH8 = 0x0202,
     *         //  Creative Labs, Inc
     *         WAVE_FORMAT_CREATIVE_FASTSPEECH10 = 0x0203,
     *         //  Quarterdeck Corporation
     *         WAVE_FORMAT_QUARTERDECK = 0x0220,
     *         //  Fujitsu Corp.
     *         WAVE_FORMAT_FM_TOWNS_SND = 0x0300,
     *         //  Brooktree Corporation
     *         WAVE_FORMAT_BTV_DIGITAL = 0x0400,
     *         //  Ing C. Olivetti & C., S.p.A.
     *         WAVE_FORMAT_OLIGSM = 0x1000,
     *         //  Ing C. Olivetti & C., S.p.A.
     *         WAVE_FORMAT_OLIADPCM = 0x1001,
     *         //  Ing C. Olivetti & C., S.p.A.
     *         WAVE_FORMAT_OLICELP = 0x1002,
     *         //  Ing C. Olivetti & C., S.p.A.
     *         WAVE_FORMAT_OLISBC = 0x1003,
     *         //  Ing C. Olivetti & C., S.p.A.
     *         WAVE_FORMAT_OLIOPR = 0x1004,
     *         //  Lernout & Hauspie
     *         WAVE_FORMAT_LH_CODEC = 0x1100,
     *         //  Norris Communications, Inc.
     *         WAVE_FORMAT_NORRIS = 0x1400,
     *         //
     *          *  the WAVE_FORMAT_DEVELOPMENT format tag can be used during the
     *          *  development phase of a new wave format.  Before shipping, you MUST
     *          *  acquire an official format tag from Microsoft.
     *
     *         WAVE_FORMAT_DEVELOPMENT = 0xFFFF,
     * } wFormatTagEnum;
     *
     * typedef struct {
     *   WORD enum wFormatTagEnum formatTag;
     *     // Waveform-audio format type. Format tags are registered with Microsoft
     *     // Corporation for many compression algorithms. A complete list of format
     *     // tags can be found in the Mmreg.h header file. For one- or two-channel
     *     // Pulse Code Modulation (PCM) data, this value should be WAVE_FORMAT_PCM.
     *   WORD  numberOfChannels;
     *     // Number of channels in the waveform-audio data. Monaural data uses one
     *     // channel and stereo data uses two channels.
     *   DWORD samplesPerSec;
     *     // Sample rate, in samples per second (hertz). If "formatTag" is
     *     // "WAVE_FORMAT_PCM", then common values for "samplesPerSec" are 8.0 kHz,
     *     // 11.025 kHz, 22.05 kHz, and 44.1 kHz. For non-PCM formats, this member
     *     // must be computed according to the manufacturer's specification of the
     *     // format tag.
     *   DWORD avgBytesPerSec;
     *     // Required average data-transfer rate, in bytes per second, for the format
     *     // tag. If "formatTag" is "WAVE_FORMAT_PCM", "avgBytesPerSec" should be
     *     // equal to the product of "samplesPerSec" and "blockAlignment". For non-PCM
     *     // formats, this member must be computed according to the manufacturer's
     *     // specification of the format tag.
     *   WORD  blockAlignment;
     *     // Block alignment, in bytes. The block alignment is the minimum atomic unit
     *     // of data for the "formatTag" format type. If "formatTag" is
     *     // "WAVE_FORMAT_PCM" or "WAVE_FORMAT_EXTENSIBLE, "blockAlignment" must be equal
     *     // to the product of "numberOfChannels" and "bitsPerSample" divided by 8 (bits per
     *     // byte). For non-PCM formats, this member must be computed according to the
     *     // manufacturer's specification of the format tag.
     *     // Software must process a multiple of "blockAlignment" bytes of data at a
     *     // time. Data written to and read from a device must always start at the
     *     // beginning of a block. For example, it is illegal to start playback of PCM
     *     // data in the middle of a sample (that is, on a non-block-aligned boundary).
     *   WORD  bitsPerSample;
     *     // Bits per sample for the waveFormatTag format type. If "formatTag" is
     *     // "WAVE_FORMAT_PCM", then "bitsPerSample" should be equal to 8 or 16. For
     *     // non-PCM formats, this member must be set according to the manufacturer's
     *     // specification of the format tag. If "formatTag" is
     *     // "WAVE_FORMAT_EXTENSIBLE", this value can be any integer multiple of 8.
     *     // Some compression schemes cannot define a value for "bitsPerSample", so
     *     // this member can be zero.
     *   WORD  cbSize;
     *     // Size, in bytes, of extra format information appended to the end of the
     *     // WAVEFORMATEX structure. This information can be used by non-PCM formats
     *     // to store extra attributes for the "wFormatTag". If no extra information
     *     // is required by the "wFormatTag", this member must be set to zero. For
     *     // WAVE_FORMAT_PCM formats (and only WAVE_FORMAT_PCM formats), this member
     *     // is ignored.
     *   byte[cbSize] extra;
     * } WAVEFORMATEX;
     * 

     * ---------------
     * AVI Main Header
     * ---------------
     *
     * Set values taken from
     * http://graphics.cs.uni-sb.de/NMM/dist-0.4.0/Docs/Doxygen/html/avifmt_8h.html
     *
     * typedef struct {
     *     DWORD  microSecPerFrame;
     *             // Specifies the number of microseconds between frames.
     *             // This value indicates the overall timing for the file.
     *     DWORD  maxBytesPerSec;
     *             // 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.
     *     DWORD  paddingGranularity;
     *             // Specifies the alignment for data, in bytes. Pad the data to
     *             // multiples of this value.
     *     DWORD set avihFlags  flags;
     *             // Contains a bitwise combination of zero or more of the following flags:
     *     DWORD  totalFrames;
     *             // Specifies the total number of frames of data in the file.
     *     DWORD  initialFrames;
     *             // Specifies the initial frame for interleaved files. Noninterleaved
     *             // files should specify zero. 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 member. For more information
     *             // about the contents of this member, see "Special Information for
     *             // Interleaved Files" in the Video for Windows Programmer's Guide.
     *     DWORD  streams;
     *             // Specifies the number of streams in the file. For example, a file
     *             // with audio and video has two streams.
     *     DWORD  suggestedBufferSize;
     *             // 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.
     *     DWORD  width;
     *             // Specifies the width of the AVI file in pixels.
     *     DWORD  height;
     *             // Specifies the height of the AVI file in pixels.
     *     DWORD[]  reserved;
     *             // Reserved. Set this array to zero.
     * } AVIMAINHEADER;
     *