unit VFW;



{$IFDEF FPC}

  {$MODE DELPHI}

{$ENDIF}



interface



{$UNDEF UNICODE}



(****************************************************************************

 *

 *      VfW.H - Video for windows include file for WIN32

 *

 *      Copyright (c) 1991-1999, Microsoft Corp.  All rights reserved.

 *

 *      This include files defines interfaces to the following

 *      video components

 *

 *          COMPMAN         - Installable Compression Manager.

 *          DRAWDIB         - Routines for drawing to the display.

 *          VIDEO           - Video Capture Driver Interface

 *

 *          AVIFMT          - AVI File Format structure definitions.

 *          MMREG           - FOURCC and other things

 *

 *          AVIFile         - Interface for reading AVI Files and AVI Streams

 *          MCIWND          - MCI/AVI window class

 *          AVICAP          - AVI Capture Window class

 *

 *          MSACM           - Audio compression manager.

 *

 *      The following symbols control inclusion of various parts of this file:

 *

 *          NOCOMPMAN       - dont include COMPMAN

 *          NODRAWDIB       - dont include DRAWDIB

 *          NOVIDEO         - dont include video capture interface

 *

 *          NOAVIFMT        - dont include AVI file format structs

 *          NOMMREG         - dont include MMREG

 *

 *          NOAVIFILE       - dont include AVIFile interface

 *          NOMCIWND        - dont include AVIWnd class.

 *          NOAVICAP        - dont include AVICap class.

 *

 *          NOMSACM         - dont include ACM stuff.

 *

 ****************************************************************************)



(******************************************************************************)

(*                                                                            *)

(*  VFW.PAS Conversion by Ronald Dittrich                                     *)

(*                                                                            *)

(*  E-Mail: info@swiftsoft.de                                                 *)

(*  http://www.swiftsoft.de                                                   *)

(*                                                                            *)

(******************************************************************************)



(******************************************************************************)

(*                                                                            *)

(*  Modyfied: 25.April.2000                                                   *)

(*                                                                            *)

(*  E-Mail:                                                                   *)

(*  Ivo Steinmann: isteinmann@bluewin.ch                                      *)

(*                                                                            *)

(*  Please send all messages regarding specific errors and lacks of this unit *)

(*  to Ivo Steinmann                                                          *)

(*                                                                            *)

(******************************************************************************)



(******************************************************************************)

(*                                                                            *)

(*  Modyfied: 2000-12-07                                                      *)

(*                                                                            *)

(*  E-Mail:                                                                   *)

(*  Peter Haas: PeterJHaas@t-online.de                                        *)

(*                                                                            *)

(*  Only modified line 1380  ( TAVIPALCHANGE.peNew )                          *)

(*                                                                            *)

(******************************************************************************)







uses

{$IFNDEF FPC}

    CommDlg,

    ActiveX, {Ole2}

    Dialogs,

{$ENDIF}

    Windows,

    MMSystem,

    Messages;



(****************************************************************************

 *

 *  types

 *

 ***************************************************************************)



type

  PVOID = pointer;

  LONG  = longint;

  PLONG = ^LONG;

  int   = integer;



{$IFDEF FPC}

  POpenFilenameA = ^TOpenFilenameA;

  POpenFilenameW = ^TOpenFilenameW;

  POpenFilename = POpenFilenameA;



  tagOFNA = packed record

    lStructSize: DWORD;

    hWndOwner: HWND;

    hInstance: HINST;

    lpstrFilter: PAnsiChar;

    lpstrCustomFilter: PAnsiChar;

    nMaxCustFilter: DWORD;

    nFilterIndex: DWORD;

    lpstrFile: PAnsiChar;

    nMaxFile: DWORD;

    lpstrFileTitle: PAnsiChar;

    nMaxFileTitle: DWORD;

    lpstrInitialDir: PAnsiChar;

    lpstrTitle: PAnsiChar;

    Flags: DWORD;

    nFileOffset: Word;

    nFileExtension: Word;

    lpstrDefExt: PAnsiChar;

    lCustData: LPARAM;

    lpfnHook: function(Wnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): UINT stdcall;

    lpTemplateName: PAnsiChar;

    pvReserved: Pointer;

    dwReserved: DWORD;

    FlagsEx: DWORD;

  end;



  tagOFNW = packed record

    lStructSize: DWORD;

    hWndOwner: HWND;

    hInstance: HINST;

    lpstrFilter: PWideChar;

    lpstrCustomFilter: PWideChar;

    nMaxCustFilter: DWORD;

    nFilterIndex: DWORD;

    lpstrFile: PWideChar;

    nMaxFile: DWORD;

    lpstrFileTitle: PWideChar;

    nMaxFileTitle: DWORD;

    lpstrInitialDir: PWideChar;

    lpstrTitle: PWideChar;

    Flags: DWORD;

    nFileOffset: Word;

    nFileExtension: Word;

    lpstrDefExt: PWideChar;

    lCustData: LPARAM;

    lpfnHook: function(Wnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): UINT stdcall;

    lpTemplateName: PWideChar;

    pvReserved: Pointer;

    dwReserved: DWORD;

    FlagsEx: DWORD;

  end;



  tagOFN = tagOFNA;

  TOpenFilenameA = tagOFNA;

  TOpenFilenameW = tagOFNW;

  TOpenFilename = TOpenFilenameA;



  OPENFILENAMEA = tagOFNA;

  OPENFILENAMEW = tagOFNW;

  OPENFILENAME = OPENFILENAMEA;

{$ENDIF}



(****************************************************************************

 *

 *  VideoForWindowsVersion() - returns version of VfW

 *

 ***************************************************************************)



function VideoForWindowsVersion: DWORD; pascal;



(****************************************************************************

 *

 *  call these to start stop using VfW from your app.

 *

 ***************************************************************************)

                                {

function InitVFW: LONG; stdcall;

function TermVFW: LONG; stdcall;  }



(****************************************************************************/

/*                                                                          */

/*        Macros                                                            */

/*                                                                          */

/*  should we define this??                                                 */

/*                                                                          */

/****************************************************************************)



function MKFOURCC(ch0, ch1, ch2, ch3: Char): FOURCC;



(****************************************************************************

 *

 *  COMPMAN - Installable Compression Manager.

 *

 ****************************************************************************)



const

  ICVERSION                   = $0104 ;



type

  HIC                         = THandle;  // Handle to an Installable Compressor



//

// this code in biCompression means the DIB must be accesed via

// 48 bit pointers! using *ONLY* the selector given.

//

const

  BI_1632                     = $32333631;    // '1632'



function mmioFOURCC(ch0, ch1, ch2, ch3: Char): FOURCC;



type

  TWOCC                       = word;



function aviTWOCC(ch0, ch1: Char): TWOCC;



const

  ICTYPE_VIDEO                = $63646976;  {vidc}

  ICTYPE_AUDIO                = $63647561;  {audc}



const

  ICERR_OK                    = 0 ;

  ICERR_DONTDRAW              = 1 ;

  ICERR_NEWPALETTE            = 2 ;

  ICERR_GOTOKEYFRAME          = 3 ;

  ICERR_STOPDRAWING           = 4 ;



  ICERR_UNSUPPORTED           = -1 ;

  ICERR_BADFORMAT             = -2 ;

  ICERR_MEMORY                = -3 ;

  ICERR_INTERNAL              = -4 ;

  ICERR_BADFLAGS              = -5 ;

  ICERR_BADPARAM              = -6 ;

  ICERR_BADSIZE               = -7 ;

  ICERR_BADHANDLE             = -8 ;

  ICERR_CANTUPDATE            = -9 ;

  ICERR_ABORT                 = -10 ;

  ICERR_ERROR                 = -100 ;

  ICERR_BADBITDEPTH           = -200 ;

  ICERR_BADIMAGESIZE          = -201 ;



  ICERR_CUSTOM                = -400 ;    // errors less than ICERR_CUSTOM...



{-- Values for dwFlags of ICOpen() -------------------------------------------}



  ICMODE_COMPRESS             = 1 ;

  ICMODE_DECOMPRESS           = 2 ;

  ICMODE_FASTDECOMPRESS       = 3 ;

  ICMODE_QUERY                = 4 ;

  ICMODE_FASTCOMPRESS         = 5 ;

  ICMODE_DRAW                 = 8 ;



{-- Flags for AVI file index -------------------------------------------------}



  AVIIF_LIST                  = $00000001 ;

  AVIIF_TWOCC                 = $00000002 ;

  AVIIF_KEYFRAME              = $00000010 ;



{-- quality flags ------------------------------------------------------------}



  ICQUALITY_LOW               = 0 ;

  ICQUALITY_HIGH              = 10000 ;

  ICQUALITY_DEFAULT           = -1 ;



(************************************************************************

************************************************************************)



  ICM_USER                    = (DRV_USER+$0000) ;



  ICM_RESERVED_LOW            = (DRV_USER+$1000) ;

  ICM_RESERVED_HIGH           = (DRV_USER+$2000) ;

  ICM_RESERVED                = ICM_RESERVED_LOW ;



(************************************************************************



    messages.



************************************************************************)



  ICM_GETSTATE                = (ICM_RESERVED+0) ;    // Get compressor state

  ICM_SETSTATE                = (ICM_RESERVED+1) ;    // Set compressor state

  ICM_GETINFO                 = (ICM_RESERVED+2) ;    // Query info about the compressor



  ICM_CONFIGURE               = (ICM_RESERVED+10);    // show the configure dialog

  ICM_ABOUT                   = (ICM_RESERVED+11);    // show the about box



  ICM_GETDEFAULTQUALITY       = (ICM_RESERVED+30);    // get the default value for quality

  ICM_GETQUALITY              = (ICM_RESERVED+31);    // get the current value for quality

  ICM_SETQUALITY              = (ICM_RESERVED+32);    // set the default value for quality



  ICM_SET                     = (ICM_RESERVED+40);    // Tell the driver something

  ICM_GET                     = (ICM_RESERVED+41);    // Ask the driver something



{-- Constants for ICM_SET: ---------------------------------------------------}



  ICM_FRAMERATE               = $526D7246;  {FrmR}

  ICM_KEYFRAMERATE            = $5279654B;  {KeyR}



(************************************************************************



    ICM specific messages.



************************************************************************)



  ICM_COMPRESS_GET_FORMAT     = (ICM_USER+4)  ;   // get compress format or size

  ICM_COMPRESS_GET_SIZE       = (ICM_USER+5)  ;   // get output size

  ICM_COMPRESS_QUERY          = (ICM_USER+6)  ;   // query support for compress

  ICM_COMPRESS_BEGIN          = (ICM_USER+7)  ;   // begin a series of compress calls.

  ICM_COMPRESS                = (ICM_USER+8)  ;   // compress a frame

  ICM_COMPRESS_END            = (ICM_USER+9)  ;   // end of a series of compress calls.



  ICM_DECOMPRESS_GET_FORMAT   = (ICM_USER+10) ;   // get decompress format or size

  ICM_DECOMPRESS_QUERY        = (ICM_USER+11) ;   // query support for dempress

  ICM_DECOMPRESS_BEGIN        = (ICM_USER+12) ;   // start a series of decompress calls

  ICM_DECOMPRESS              = (ICM_USER+13) ;   // decompress a frame

  ICM_DECOMPRESS_END          = (ICM_USER+14) ;   // end a series of decompress calls

  ICM_DECOMPRESS_SET_PALETTE  = (ICM_USER+29) ;   // fill in the DIB color table

  ICM_DECOMPRESS_GET_PALETTE  = (ICM_USER+30) ;   // fill in the DIB color table



  ICM_DRAW_QUERY              = (ICM_USER+31) ;   // query support for dempress

  ICM_DRAW_BEGIN              = (ICM_USER+15) ;   // start a series of draw calls

  ICM_DRAW_GET_PALETTE        = (ICM_USER+16) ;   // get the palette needed for drawing

  ICM_DRAW_START              = (ICM_USER+18) ;   // start decompress clock

  ICM_DRAW_STOP               = (ICM_USER+19) ;   // stop decompress clock

  ICM_DRAW_END                = (ICM_USER+21) ;   // end a series of draw calls

  ICM_DRAW_GETTIME            = (ICM_USER+32) ;   // get value of decompress clock

  ICM_DRAW                    = (ICM_USER+33) ;   // generalized "render" message

  ICM_DRAW_WINDOW             = (ICM_USER+34) ;   // drawing window has moved or hidden

  ICM_DRAW_SETTIME            = (ICM_USER+35) ;   // set correct value for decompress clock

  ICM_DRAW_REALIZE            = (ICM_USER+36) ;   // realize palette for drawing

  ICM_DRAW_FLUSH              = (ICM_USER+37) ;   // clear out buffered frames

  ICM_DRAW_RENDERBUFFER       = (ICM_USER+38) ;   // draw undrawn things in queue



  ICM_DRAW_START_PLAY         = (ICM_USER+39) ;   // start of a play

  ICM_DRAW_STOP_PLAY          = (ICM_USER+40) ;   // end of a play



  ICM_DRAW_SUGGESTFORMAT      = (ICM_USER+50) ;   // Like ICGetDisplayFormat

  ICM_DRAW_CHANGEPALETTE      = (ICM_USER+51) ;   // for animating palette



  ICM_GETBUFFERSWANTED        = (ICM_USER+41) ;   // ask about prebuffering



  ICM_GETDEFAULTKEYFRAMERATE  = (ICM_USER+42) ;   // get the default value for key frames



  ICM_DECOMPRESSEX_BEGIN      = (ICM_USER+60) ;   // start a series of decompress calls

  ICM_DECOMPRESSEX_QUERY      = (ICM_USER+61) ;   // start a series of decompress calls

  ICM_DECOMPRESSEX            = (ICM_USER+62) ;   // decompress a frame

  ICM_DECOMPRESSEX_END        = (ICM_USER+63) ;   // end a series of decompress calls



  ICM_COMPRESS_FRAMES_INFO    = (ICM_USER+70) ;   // tell about compress to come

  ICM_SET_STATUS_PROC         = (ICM_USER+72) ;   // set status callback



(************************************************************************

************************************************************************)



type

  PICOPEN = ^TICOPEN;

  TICOPEN = packed record

    dwSize                  : DWORD   ; // sizeof(ICOPEN)

    fccType                 : DWORD   ; // 'vidc'

    fccHandler              : DWORD   ; //

    dwVersion               : DWORD   ; // version of compman opening you

    dwFlags                 : DWORD   ; // LOWORD is type specific

    dwError                 : DWORD   ; // error return.

    pV1Reserved             : PVOID   ; // Reserved

    pV2Reserved             : PVOID   ; // Reserved

    dnDevNode               : DWORD   ; // Devnode for PnP devices

  end;



(************************************************************************

************************************************************************)



  PICINFO = ^TICINFO;

  TICINFO = packed record

    dwSize                  : DWORD;    // sizeof(ICINFO)

    fccType                 : DWORD;    // compressor type     'vidc' 'audc'

    fccHandler              : DWORD;    // compressor sub-type 'rle ' 'jpeg' 'pcm '

    dwFlags                 : DWORD;    // flags LOWORD is type specific

    dwVersion               : DWORD;    // version of the driver

    dwVersionICM            : DWORD;    // version of the ICM used

    //

    // under Win32, the driver always returns UNICODE strings.

    //

    szName                  : array[0..15] of WChar  ; // short name

    szDescription           : array[0..127] of WChar ; // DWORD name

    szDriver                : array[0..127] of WChar ; // driver that contains compressor

  end;



{-- Flags for the <dwFlags> field of the <ICINFO> structure. ------------}



const

  VIDCF_QUALITY               = $0001 ;  // supports quality

  VIDCF_CRUNCH                = $0002 ;  // supports crunching to a frame size

  VIDCF_TEMPORAL              = $0004 ;  // supports inter-frame compress

  VIDCF_COMPRESSFRAMES        = $0008 ;  // wants the compress all frames message

  VIDCF_DRAW                  = $0010 ;  // supports drawing

  VIDCF_FASTTEMPORALC         = $0020 ;  // does not need prev frame on compress

  VIDCF_FASTTEMPORALD         = $0080 ;  // does not need prev frame on decompress

  //VIDCF_QUALITYTIME         = $0040 ;  // supports temporal quality



  //VIDCF_FASTTEMPORAL        = (VIDCF_FASTTEMPORALC or VIDCF_FASTTEMPORALD)



(************************************************************************

************************************************************************)



  ICCOMPRESS_KEYFRAME         = $00000001;



type

  PICCOMPRESS = ^TICCOMPRESS;

  TICCOMPRESS = packed record

    dwFlags                 : DWORD;                // flags



    lpbiOutput              : PBITMAPINFOHEADER ;   // output format

    lpOutput                : PVOID ;               // output data



    lpbiInput               : PBITMAPINFOHEADER ;   // format of frame to compress

    lpInput                 : PVOID ;               // frame data to compress



    lpckid                  : PDWORD ;              // ckid for data in AVI file

    lpdwFlags               : PDWORD;               // flags in the AVI index.

    lFrameNum               : LONG ;               // frame number of seq.

    dwFrameSize             : DWORD ;               // reqested size in bytes. (if non zero)



    dwQuality               : DWORD ;               // quality



    // these are new fields



    lpbiPrev                : PBITMAPINFOHEADER ;   // format of previous frame

    lpPrev                  : PVOID ;               // previous frame

  end;



(************************************************************************

************************************************************************)



const

  ICCOMPRESSFRAMES_PADDING    = $00000001 ;



type

  TICCompressProc    = function(lInputOutput: LPARAM; lFrame: DWORD; lpBits: PVOID; len: LONG): LONG; stdcall;



  PICCOMPRESSFRAMES  = ^TICCOMPRESSFRAMES;

  TICCOMPRESSFRAMES  = packed record

    dwFlags                 : DWORD ;               // flags



    lpbiOutput              : PBITMAPINFOHEADER ;   // output format

    lOutput                 : LPARAM ;              // output identifier



    lpbiInput               : PBITMAPINFOHEADER ;   // format of frame to compress

    lInput                  : LPARAM ;              // input identifier



    lStartFrame             : LONG ;                // start frame

    lFrameCount             : LONG ;                // # of frames



    lQuality                : LONG ;                // quality

    lDataRate               : LONG ;                // data rate

    lKeyRate                : LONG ;                // key frame rate



    dwRate                  : DWORD ;               // frame rate, as always

    dwScale                 : DWORD ;



    dwOverheadPerFrame      : DWORD ;

    dwReserved2             : DWORD ;



    GetData                 : TICCompressProc;

    PutData                 : TICCompressProc;

  end;



{-- Messages for Status callback ---------------------------------------------}



const

    ICSTATUS_START              = 0 ;

    ICSTATUS_STATUS             = 1 ;   // l = % done

    ICSTATUS_END                = 2 ;

    ICSTATUS_ERROR              = 3 ;   // l = error string (LPSTR)

    ICSTATUS_YIELD              = 4 ;



type

  // return nonzero means abort operation in progress

  TICStatusProc    = function(lParam: LPARAM; message: UINT; l: LONG): LONG; stdcall;



  PICSETSTATUSPROC = ^TICSETSTATUSPROC;

  TICSETSTATUSPROC = packed record

    dwFlags                 : DWORD ;

    lParam                  : LPARAM ;

    Status                  : TICStatusProc;

  end;



(************************************************************************

************************************************************************)



const

    ICDECOMPRESS_HURRYUP        = $80000000 ;   // don't draw just buffer (hurry up!)

    ICDECOMPRESS_UPDATE         = $40000000 ;   // don't draw just update screen

    ICDECOMPRESS_PREROLL        = $20000000 ;   // this frame is before real start

    ICDECOMPRESS_NULLFRAME      = $10000000 ;   // repeat last frame

    ICDECOMPRESS_NOTKEYFRAME    = $08000000 ;   // this frame is not a key frame



type

  PICDECOMPRESS = ^TICDECOMPRESS;

  TICDECOMPRESS = packed record

    dwFlags                 : DWORD ;               // flags (from AVI index...)

    lpbiInput               : PBITMAPINFOHEADER ;   // BITMAPINFO of compressed data

                                                        // biSizeImage has the chunk size

    lpInput                 : PVOID ;               // compressed data

    lpbiOutput              : PBITMAPINFOHEADER ;   // DIB to decompress to

    lpOutput                : PVOID ;

    ckid                    : DWORD ;               // ckid from AVI file

  end;



  PICDECOMPRESSEX = ^TICDECOMPRESSEX;

  TICDECOMPRESSEX = packed record



    //

    // same as ICM_DECOMPRESS

    //



    dwFlags                 : DWORD;

    lpbiSrc                 : PBITMAPINFOHEADER;    // BITMAPINFO of compressed data

    lpSrc                   : PVOID;                // compressed data

    lpbiDst                 : PBITMAPINFOHEADER;    // DIB to decompress to

    lpDst                   : PVOID;                // output data



    //

    // new for ICM_DECOMPRESSEX

    //



    xDst                    : int; // destination rectangle

    yDst                    : int;

    dxDst                   : int;

    dyDst                   : int;



    xSrc                    : int; // source rectangle

    ySrc                    : int;

    dxSrc                   : int;

    dySrc                   : int;

  end;



(************************************************************************

************************************************************************)



const

    ICDRAW_QUERY                = $00000001 ; // test for support

    ICDRAW_FULLSCREEN           = $00000002 ; // draw to full screen

    ICDRAW_HDC                  = $00000004 ; // draw to a HDC/HWND

    ICDRAW_ANIMATE              = $00000008 ;   // expect palette animation

    ICDRAW_CONTINUE             = $00000010 ;   // draw is a continuation of previous draw

    ICDRAW_MEMORYDC             = $00000020 ;   // DC is offscreen, by the way

    ICDRAW_UPDATING             = $00000040 ;   // We're updating, as opposed to playing

    ICDRAW_RENDER               = $00000080 ; // used to render data not draw it

    ICDRAW_BUFFER               = $00000100 ; // please buffer this data offscreen, we will need to update it



type

  PICDRAWBEGIN = ^TICDRAWBEGIN;

  TICDRAWBEGIN = packed record

    dwFlags                 : DWORD ;       // flags



    hpal                    : HPALETTE ;    // palette to draw with

    hwnd                    : HWND ;        // window to draw to

    hdc                     : HDC ;         // HDC to draw to



    xDst                    : int ;         // destination rectangle

    yDst                    : int ;

    dxDst                   : int ;

    dyDst                   : int ;



    lpbi                    : PBITMAPINFOHEADER ;

                                                // format of frame to draw



    xSrc                    : int ;         // source rectangle

    ySrc                    : int ;

    dxSrc                   : int ;

    dySrc                   : int ;



    dwRate                  : DWORD ;       // frames/second = (dwRate/dwScale)

    dwScale                 : DWORD ;

  end;



(************************************************************************

************************************************************************)



const

    ICDRAW_HURRYUP              = $80000000 ;   // don't draw just buffer (hurry up!)

    ICDRAW_UPDATE               = $40000000 ;   // don't draw just update screen

    ICDRAW_PREROLL              = $20000000 ;   // this frame is before real start

    ICDRAW_NULLFRAME            = $10000000 ;   // repeat last frame

    ICDRAW_NOTKEYFRAME          = $08000000 ;   // this frame is not a key frame



type

    PICDRAW                     = ^TICDRAW;

    TICDRAW                     = packed record

        dwFlags                 : DWORD ;   // flags

        lpFormat                : PVOID ;   // format of frame to decompress

        lpData                  : PVOID ;   // frame data to decompress

        cbData                  : DWORD ;

        lTime                   : LONG  ;   // time in drawbegin units (see dwRate and dwScale)

    end;



    PICDRAWSUGGEST              = ^TICDRAWSUGGEST;

    TICDRAWSUGGEST              = packed record

        lpbiIn                  : PBITMAPINFOHEADER ;   // format to be drawn

        lpbiSuggest             : PBITMAPINFOHEADER ;   // location for suggested format (or NULL to get size)

        dxSrc                   : int ;                 // source extent or 0

        dySrc                   : int ;

        dxDst                   : int ;                 // dest extent or 0

        dyDst                   : int ;

        hicDecompressor         : HIC ;                 // decompressor you can talk to

    end;



(************************************************************************

************************************************************************)



    PICPALETTE                  = ^TICPALETTE;

    TICPALETTE                  = packed record

        dwFlags                 : DWORD ;           // flags (from AVI index...)

        iStart                  : int ;             // first palette to change

        iLen                    : int ;             // count of entries to change.

        lppe                    : PPALETTEENTRY ;   // palette

    end;



(************************************************************************



    ICM function declarations



************************************************************************)



function    ICInfo(fccType, fccHandler: DWORD; lpicinfo: PICINFO) : BOOL ; stdcall ;

function    ICInstall(fccType, fccHandler: DWORD; lParam: LPARAM; szDesc: LPSTR; wFlags: UINT) : BOOL ; stdcall ;

function    ICRemove(fccType, fccHandler: DWORD; wFlags: UINT) : BOOL ; stdcall ;

function    ICGetInfo(hic: HIC; picinfo: PICINFO; cb: DWORD) : DWORD ; stdcall ;



function    ICOpen(fccType, fccHandler: DWORD; wMode: UINT) : HIC ; stdcall ;

function    ICOpenFunction(fccType, fccHandler: DWORD; wMode: UINT; lpfnHandler: TFarProc) : HIC ; stdcall ;

function    ICClose(hic: HIC) : DWORD; stdcall ;



function    ICSendMessage(hic: HIC; msg: UINT; dw1, dw2: DWORD) : DWORD ; stdcall ;



{-- Values for wFlags of ICInstall -------------------------------------------}



const

    ICINSTALL_UNICODE           = $8000 ;



    ICINSTALL_FUNCTION          = $0001 ; // lParam is a DriverProc (function ptr)

    ICINSTALL_DRIVER            = $0002 ; // lParam is a driver name (string)

    ICINSTALL_HDRV              = $0004 ; // lParam is a HDRVR (driver handle)



    ICINSTALL_DRIVERW           = $8002 ; // lParam is a unicode driver name



{-- Query macros -------------------------------------------------------------}



    ICMF_CONFIGURE_QUERY        = $00000001 ;

    ICMF_ABOUT_QUERY            = $00000001 ;



function    ICQueryAbout(hic: HIC): BOOL;

function    ICAbout(hic: HIC; hwnd: HWND): DWORD;

function    ICQueryConfigure(hic: HIC): BOOL;

function    ICConfigure(hic: HIC; hwnd: HWND): DWORD;



{-- Get/Set state macros -----------------------------------------------------}



function    ICGetState(hic: HIC; pv: PVOID; cb: DWORD): DWORD;

function    ICSetState(hic: HIC; pv: PVOID; cb: DWORD): DWORD;

function    ICGetStateSize(hic: HIC): DWORD;



{-- Get value macros ---------------------------------------------------------}



function    ICGetDefaultQuality(hic: HIC): DWORD;

function    ICGetDefaultKeyFrameRate(hic: HIC): DWORD;



{-- Draw window macro --------------------------------------------------------}



function    ICDrawWindow(hic: HIC; prc: PRECT): DWORD;



(************************************************************************



    compression functions



************************************************************************/

/*

 *  ICCompress()

 *

 *  compress a single frame

 *

 *)

function ICCompress(

    hic             : HIC;

    dwFlags         : DWORD;                // flags

    lpbiOutput      : PBITMAPINFOHEADER;    // output format

    lpData          : PVOID;                // output data

    lpbiInput       : PBITMAPINFOHEADER;    // format of frame to compress

    lpBits          : PVOID;                // frame data to compress

    lpckid          : PDWORD;               // ckid for data in AVI file

    lpdwFlags       : PDWORD;               // flags in the AVI index.

    lFrameNum       : DWORD;                 // frame number of seq.

    dwFrameSize     : DWORD;                // reqested size in bytes. (if non zero)

    dwQuality       : DWORD;                // quality within one frame

    lpbiPrev        : PBITMAPINFOHEADER;    // format of previous frame

    lpPrev          : PVOID                 // previous frame

    ): DWORD; cdecl;



(*

 *  ICCompressBegin()

 *

 *  start compression from a source format (lpbiInput) to a dest

 *  format (lpbiOuput) is supported.

 *

 *)



function    ICCompressBegin(hic: HIC; lpbiInput: PBITMAPINFOHEADER; lpbiOutput: PBITMAPINFOHEADER): DWORD;



(*

 *  ICCompressQuery()

 *

 *  determines if compression from a source format (lpbiInput) to a dest

 *  format (lpbiOuput) is supported.

 *

 *)



function    ICCompressQuery(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;



(*

 *  ICCompressGetFormat()

 *

 *  get the output format, (format of compressed data)

 *  if lpbiOutput is NULL return the size in bytes needed for format.

 *

 *)



function    ICCompressGetFormat(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;

function    ICCompressGetFormatSize(hic: HIC; lpbi: PBITMAPINFOHEADER): DWORD;



(*

 *  ICCompressSize()

 *

 *  return the maximal size of a compressed frame

 *

 *)



function    ICCompressGetSize(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;

function    ICCompressEnd(hic: HIC): DWORD;



(************************************************************************



    decompression functions



************************************************************************)



(*

 *  ICDecompress()

 *

 *  decompress a single frame

 *

 *)



function    ICDecompress(

    hic             : HIC;

    dwFlags         : DWORD;                // flags (from AVI index...)

    lpbiFormat      : PBITMAPINFOHEADER;    // BITMAPINFO of compressed data

                                            // biSizeImage has the chunk size

    lpData          : PVOID;                // data

    lpbi            : PBITMAPINFOHEADER;    // DIB to decompress to

    lpBits          : PVOID

    ): DWORD; cdecl;



(*

 *  ICDecompressBegin()

 *

 *  start compression from a source format (lpbiInput) to a dest

 *  format (lpbiOutput) is supported.

 *

 *)



function    ICDecompressBegin(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;



(*

 *  ICDecompressQuery()

 *

 *  determines if compression from a source format (lpbiInput) to a dest

 *  format (lpbiOutput) is supported.

 *

 *)



function    ICDecompressQuery(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;



(*

 *  ICDecompressGetFormat()

 *

 *  get the output format, (format of un-compressed data)

 *  if lpbiOutput is NULL return the size in bytes needed for format.

 *

 *)



function    ICDecompressGetFormat(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;

function    ICDecompressGetFormatSize(hic: HIC; lpbi: PBITMAPINFOHEADER): DWORD;



(*

 *  ICDecompressGetPalette()

 *

 *  get the output palette

 *

 *)



function    ICDecompressGetPalette(hic: HIC; lpbiInput, lpbiOutput: PBITMAPINFOHEADER): DWORD;

function    ICDecompressSetPalette(hic: HIC; lpbiPalette: PBITMAPINFOHEADER): DWORD;



function    ICDecompressEnd(hic: HIC): DWORD;



(************************************************************************



    decompression (ex) functions



************************************************************************)



//

// on Win16 these functions are macros that call ICMessage. ICMessage will

// not work on NT. rather than add new entrypoints we have given

// them as static inline functions

//



(*

 *  ICDecompressEx()

 *

 *  decompress a single frame

 *

 *)



function    ICDecompressEx(

    hic         : HIC;

    dwFlags     : DWORD;

    lpbiSrc     : PBITMAPINFOHEADER;

    lpSrc       : PVOID;

    xSrc        : int;

    ySrc        : int;

    dxSrc       : int;

    dySrc       : int;

    lpbiDst     : PBITMAPINFOHEADER;

    lpDst       : PVOID;

    xDst        : int;

    yDst        : int;

    dxDst       : int;

    dyDst       : int

    ): DWORD; stdcall;



(*

 *  ICDecompressExBegin()

 *

 *  start compression from a source format (lpbiInput) to a dest

 *  format (lpbiOutput) is supported.

 *

 *)



function    ICDecompressExBegin(

    hic         : HIC;

    dwFlags     : DWORD;

    lpbiSrc     : PBITMAPINFOHEADER;

    lpSrc       : PVOID;

    xSrc        : int;

    ySrc        : int;

    dxSrc       : int;

    dySrc       : int;

    lpbiDst     : PBITMAPINFOHEADER;

    lpDst       : PVOID;

    xDst        : int;

    yDst        : int;

    dxDst       : int;

    dyDst       : int

    ): DWORD; stdcall;



(*

 *  ICDecompressExQuery()

 *

 *)



function    ICDecompressExQuery(

    hic         : HIC;

    dwFlags     : DWORD;

    lpbiSrc     : PBITMAPINFOHEADER;

    lpSrc       : PVOID;

    xSrc        : int;

    ySrc        : int;

    dxSrc       : int;

    dySrc       : int;

    lpbiDst     : PBITMAPINFOHEADER;

    lpDst       : PVOID;

    xDst        : int;

    yDst        : int;

    dxDst       : int;

    dyDst       : int

    ): DWORD; stdcall;



function ICDecompressExEnd(hic: HIC): DWORD;



(************************************************************************



    drawing functions



************************************************************************)



(*

 *  ICDrawBegin()

 *

 *  start decompressing data with format (lpbiInput) directly to the screen

 *

 *  return zero if the decompressor supports drawing.

 *

 *)



function    ICDrawBegin(

    hic         : HIC;

    dwFlags     : DWORD;                // flags

    hpal        : HPALETTE;             // palette to draw with

    hwnd        : HWND;                 // window to draw to

    hdc         : HDC;                  // HDC to draw to

    xDst        : int;                  // destination rectangle

    yDst        : int;

    dxDst       : int;

    dyDst       : int;

    lpbi        : PBITMAPINFOHEADER;    // format of frame to draw

    xSrc        : int;                  // source rectangle

    ySrc        : int;

    dxSrc       : int;

    dySrc       : int;

    dwRate      : DWORD;                // frames/second = (dwRate/dwScale)

    dwScale     : DWORD

    ): DWORD; cdecl;



(*

 *  ICDraw()

 *

 *  decompress data directly to the screen

 *

 *)



function    ICDraw(

    hic         : HIC;

    dwFlags     : DWORD;                // flags

    lpFormat    : PVOID;                // format of frame to decompress

    lpData      : PVOID;                // frame data to decompress

    cbData      : DWORD;                // size of data

    lTime       : DWORD                  // time to draw this frame

    ): DWORD; cdecl;



// ICMessage is not supported on Win32, so provide a static inline function

// to do the same job

function    ICDrawSuggestFormat(

    hic         : HIC;

    lpbiIn      : PBITMAPINFOHEADER;

    lpbiOut     : PBITMAPINFOHEADER;

    dxSrc       : int;

    dySrc       : int;

    dxDst       : int;

    dyDst       : int;

    hicDecomp   : HIC

    ): DWORD; stdcall;



(*

 *  ICDrawQuery()

 *

 *  determines if the compressor is willing to render the specified format.

 *

 *)



function    ICDrawQuery(hic: HIC; lpbiInput: PBITMAPINFOHEADER): DWORD;

function    ICDrawChangePalette(hic: HIC; lpbiInput: PBITMAPINFOHEADER): DWORD;

function    ICGetBuffersWanted(hic: HIC; lpdwBuffers: PDWORD): DWORD;

function    ICDrawEnd(hic: HIC): DWORD;

function    ICDrawStart(hic: HIC): DWORD;

function    ICDrawStartPlay(hic: HIC; lFrom, lTo: DWORD): DWORD;

function    ICDrawStop(hic: HIC): DWORD;

function    ICDrawStopPlay(hic: HIC): DWORD;

function    ICDrawGetTime(hic: HIC; lplTime: PDWORD): DWORD;

function    ICDrawSetTime(hic: HIC; lTime: DWORD): DWORD;

function    ICDrawRealize(hic: HIC; hdc: HDC; fBackground: BOOL): DWORD;

function    ICDrawFlush(hic: HIC): DWORD;

function    ICDrawRenderBuffer(hic: HIC): DWORD;



(************************************************************************



    Status callback functions



************************************************************************/



/*

 *  ICSetStatusProc()

 *

 *  Set the status callback function

 *

 *)





// ICMessage is not supported on NT

function    ICSetStatusProc(

    hic         : HIC;

    dwFlags     : DWORD;

    lParam      : DWORD;

    fpfnStatus  : TICStatusProc

    ): DWORD; stdcall;



(************************************************************************



helper routines for DrawDib and MCIAVI...



************************************************************************)



function    ICLocate(fccType, fccHandler: DWORD; lpbiIn, lpbiOut: PBITMAPINFOHEADER; wFlags: WORD): HIC; stdcall;

function    ICGetDisplayFormat(hic: HIC; lpbiIn, lpbiOut: PBITMAPINFOHEADER; BitDepth: int; dx, dy: int): HIC; stdcall;



function    ICDecompressOpen(fccType, fccHandler: DWORD; lpbiIn, lpbiOut: PBITMAPINFOHEADER): HIC;

function    ICDrawOpen(fccType, fccHandler: DWORD; lpbiIn: PBITMAPINFOHEADER): HIC;



(************************************************************************

Higher level functions

************************************************************************)



function    ICImageCompress(

    hic         : HIC;                  // compressor to use

    uiFlags     : UINT;                 // flags (none yet)

    lpbiIn      : PBITMAPINFO;          // format to compress from

    lpBits      : PVOID;                // data to compress

    lpbiOut     : PBITMAPINFO;          // compress to this (NULL ==> default)

    lQuality    : LONG;                 // quality to use

    plSize      : PDWORD                 // compress to this size (0=whatever)

    ): THANDLE; stdcall;



function    ICImageDecompress(

    hic         : HIC;                  // compressor to use

    uiFlags     : UINT;                 // flags (none yet)

    lpbiIn      : PBITMAPINFO;          // format to decompress from

    lpBits      : PVOID;                // data to decompress

    lpbiOut     : PBITMAPINFO           // decompress to this (NULL ==> default)

    ): THANDLE; stdcall;



{-- TCompVars ----------------------------------------------------------------}



//

// Structure used by ICSeqCompressFrame and ICCompressorChoose routines

// Make sure this matches the autodoc in icm.c!

//



type

  PCOMPVARS       = ^TCOMPVARS;

  TCOMPVARS       = packed record

        cbSize      : DWORD;            // set to sizeof(COMPVARS) before

                                        // calling ICCompressorChoose

        dwFlags     : DWORD;            // see below...

        hic         : HIC;              // HIC of chosen compressor

        fccType     : DWORD;            // basically ICTYPE_VIDEO

        fccHandler  : DWORD;            // handler of chosen compressor or

                                        // "" or "DIB "

        lpbiIn      : PBITMAPINFO;      // input format

        lpbiOut     : PBITMAPINFO;      // output format - will compress to this

        lpBitsOut   : PVOID;

        lpBitsPrev  : PVOID;

        lFrame      : LONG;

        lKey        : LONG;             // key frames how often?

        lDataRate   : LONG;             // desired data rate KB/Sec

        lQ          : LONG;             // desired quality

        lKeyCount   : LONG;

        lpState     : PVOID;            // state of compressor

        cbState     : LONG;             // size of the state

    end;



// FLAGS for dwFlags element of COMPVARS structure:

// set this flag if you initialize COMPVARS before calling ICCompressorChoose



const

    ICMF_COMPVARS_VALID         = $00000001;    // COMPVARS contains valid data



//

//  allows user to choose compressor, quality etc...

//

function    ICCompressorChoose(

    hwnd        : HWND;                     // parent window for dialog

    uiFlags     : UINT;                     // flags

    pvIn        : PVOID;                    // input format (optional)

    lpData      : PVOID;                    // input data (optional)

    pc          : PCOMPVARS;                // data about the compressor/dlg

    lpszTitle   : LPSTR                     // dialog title (optional)

    ): BOOL; stdcall;



// defines for uiFlags



const

    ICMF_CHOOSE_KEYFRAME        = $0001;    // show KeyFrame Every box

    ICMF_CHOOSE_DATARATE        = $0002;    // show DataRate box

    ICMF_CHOOSE_PREVIEW         = $0004;    // allow expanded preview dialog

    ICMF_CHOOSE_ALLCOMPRESSORS  = $0008;    // don't only show those that

                                            // can handle the input format

                                            // or input data



function    ICSeqCompressFrameStart(pc: PCOMPVARS; lpbiIn: PBITMAPINFO): BOOL; stdcall;

procedure   ICSeqCompressFrameEnd(pc: PCOMPVARS); stdcall;



function    ICSeqCompressFrame(

    pc          : PCOMPVARS;                // set by ICCompressorChoose

    uiFlags     : UINT;                     // flags

    lpBits      : PVOID;                    // input DIB bits

    pfKey       : PBOOL;                    // did it end up being a key frame?

    plSize      : PDWORD                     // size to compress to/of returned image

    ): PVOID; stdcall;



procedure   ICCompressorFree(pc: PCOMPVARS); stdcall;





(**************************************************************************

 *

 *  DRAWDIB - Routines for drawing to the display.

 *

 *************************************************************************)



type

    HDRAWDIB                    = THandle;  // hdd



(*********************************************************************



  DrawDib Flags



**********************************************************************)



const

    DDF_UPDATE                  = $0002;    // re-draw the last DIB

    DDF_SAME_HDC                = $0004;    // HDC same as last call (all setup)

    DDF_SAME_DRAW               = $0008;    // draw params are the same

    DDF_DONTDRAW                = $0010;    // dont draw frame, just decompress

    DDF_ANIMATE                 = $0020;    // allow palette animation

    DDF_BUFFER                  = $0040;    // always buffer image

    DDF_JUSTDRAWIT              = $0080;    // just draw it with GDI

    DDF_FULLSCREEN              = $0100;    // use DisplayDib

    DDF_BACKGROUNDPAL           = $0200;    // Realize palette in background

    DDF_NOTKEYFRAME             = $0400;    // this is a partial frame update, hint

    DDF_HURRYUP                 = $0800;    // hurry up please!

    DDF_HALFTONE                = $1000;    // always halftone



    DDF_PREROLL                 = DDF_DONTDRAW; // Builing up a non-keyframe

    DDF_SAME_DIB                = DDF_SAME_DRAW;

    DDF_SAME_SIZE               = DDF_SAME_DRAW;



(*********************************************************************



    DrawDib functions



*********************************************************************)



{-- DrawDibOpen() ------------------------------------------------------------}



function    DrawDibOpen: HDRAWDIB; stdcall;



{-- DrawDibClose() -----------------------------------------------------------}



function    DrawDibClose(hdd: HDRAWDIB): BOOL; stdcall;



{-- DrawDibGetBuffer() -------------------------------------------------------}



function    DrawDibGetBuffer(hdd: HDRAWDIB; lpbi: PBITMAPINFOHEADER; dwSize: DWORD; dwFlags: DWORD): PVOID; stdcall;



{-- DrawDibGetPalette() - get the palette used for drawing DIBs --------------}



function    DrawDibGetPalette(hdd: HDRAWDIB): HPALETTE; stdcall;



{-- DrawDibSetPalette() - set the palette used for drawing DIBs --------------}



function    DrawDibSetPalette(hdd: HDRAWDIB; hpal: HPALETTE): BOOL; stdcall;



{-- DrawDibChangePalette() ---------------------------------------------------}



function    DrawDibChangePalette(hdd: HDRAWDIB; iStart, iLen: int; lppe: PPALETTEENTRY): BOOL; stdcall;



{-- DrawDibRealize() - realize the palette in a HDD --------------------------}



function    DrawDibRealize(hdd: HDRAWDIB; hdc: HDC; fBackground: BOOL): UINT; stdcall;



{-- DrawDibStart() - start of streaming playback -----------------------------}



function    DrawDibStart(hdd: HDRAWDIB; rate: DWORD): BOOL; stdcall;



{-- DrawDibStop() - start of streaming playback ------------------------------}



function    DrawDibStop(hdd: HDRAWDIB): BOOL; stdcall;



{-- DrawDibBegin() - prepare to draw -----------------------------------------}



function    DrawDibBegin(

    hdd         : HDRAWDIB;

    hdc         : HDC;

    dxDst       : int;

    dyDst       : int;

    lpbi        : PBITMAPINFOHEADER;

    dxSrc       : int;

    dySrc       : int;

    wFlags      : UINT

    ): BOOL; stdcall;



{-- DrawDibDraw() - actually draw a DIB to the screen ------------------------}



function    DrawDibDraw(

    hdd         : HDRAWDIB;

    hdc         : HDC;

    xDst        : int;

    yDst        : int;

    dxDst       : int;

    dyDst       : int;

    lpbi        : PBITMAPINFOHEADER;

    lpBits      : PVOID;

    xSrc        : int;

    ySrc        : int;

    dxSrc       : int;

    dySrc       : int;

    wFlags      : UINT

    ): BOOL; stdcall;



{-- DrawDibUpdate() - redraw last image (may only be valid with DDF_BUFFER) --}



function    DrawDibUpdate(hdd: HDRAWDIB; hdc: HDC; x, y: int): BOOL;



{-- DrawDibEnd() -------------------------------------------------------------}



function    DrawDibEnd(hdd: HDRAWDIB): BOOL; stdcall;



{-- DrawDibTime() - for debugging purposes only ------------------------------}



type

    PDRAWDIBTIME        = ^TDRAWDIBTIME;

    TDRAWDIBTIME        = packed record

        timeCount       : LONG;

        timeDraw        : LONG;

        timeDecompress  : LONG;

        timeDither      : LONG;

        timeStretch     : LONG;

        timeBlt         : LONG;

        timeSetDIBits   : LONG;

    end;



function    DrawDibTime(hdd: HDRAWDIB; lpddtime: PDRAWDIBTIME): BOOL; stdcall;



{-- Display profiling --------------------------------------------------------}



const

    PD_CAN_DRAW_DIB             = $0001;    // if you can draw at all

    PD_CAN_STRETCHDIB           = $0002;    // basicly RC_STRETCHDIB

    PD_STRETCHDIB_1_1_OK        = $0004;    // is it fast?

    PD_STRETCHDIB_1_2_OK        = $0008;    // ...

    PD_STRETCHDIB_1_N_OK        = $0010;    // ...



function    DrawDibProfileDisplay(lpbi: PBITMAPINFOHEADER): DWORD; stdcall;



(****************************************************************************

 *

 *  AVIFMT - AVI file format definitions

 *

 ****************************************************************************)



//

// The following is a short description of the AVI file format.  Please

// see the accompanying documentation for a full explanation.

//

// 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 main file header specifies how many streams are present.  For

//  each one, there must be a stream header chunk and a stream format

//  chunk, enlosed in a 'strl' LIST chunk.  The 'strf' chunk contains

//  type-specific format information; for a video stream, this should

//  be a BITMAPINFO structure, including palette.  For an audio stream,

//  this should be a WAVEFORMAT (or PCMWAVEFORMAT) structure.

//

//  The actual data is contained in subchunks within the 'movi' LIST

//  chunk.  The first two characters of each data chunk are the

//  stream number with which that data is associated.

//

//  Some defined chunk types:

//           Video Streams:

//                  ##db:   RGB DIB bits

//                  ##dc:   RLE8 compressed DIB bits

//                  ##pc:   Palette Change

//

//           Audio Streams:

//                  ##wb:   waveform audio bytes

//

// 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 used for files specifically intended to be played from

//   CD-ROM.

//

// The index chunk at the end of the file should contain one entry for

//   each data chunk in the file.

//

// Limitations for the current software:

//  Only one video stream and one audio stream are allowed.

//  The streams must start at the beginning of the file.

//

//

// To register codec types please obtain a copy of the Multimedia

// Developer Registration Kit from:

//

//  Microsoft Corporation

//  Multimedia Systems Group

//  Product Marketing

//  One Microsoft Way

//  Redmond, WA 98052-6399

//



{-- form types, list types and chunk types -----------------------------------}



const

    formtypeAVI                 = $20495641; // mmioFOURCC('A', 'V', 'I', ' ')

    listtypeAVIHEADER           = $6C726468; // mmioFOURCC('h', 'd', 'r', 'l')

    ckidAVIMAINHDR              = $68697661; // mmioFOURCC('a', 'v', 'i', 'h')

    listtypeSTREAMHEADER        = $6C727473; // mmioFOURCC('s', 't', 'r', 'l')

    ckidSTREAMHEADER            = $68727473; // mmioFOURCC('s', 't', 'r', 'h')

    ckidSTREAMFORMAT            = $66727473; // mmioFOURCC('s', 't', 'r', 'f')

    ckidSTREAMHANDLERDATA       = $64727473; // mmioFOURCC('s', 't', 'r', 'd')

    ckidSTREAMNAME              = $6E727473; // mmioFOURCC('s', 't', 'r', 'n')



    listtypeAVIMOVIE            = $69766F6D; // mmioFOURCC('m', 'o', 'v', 'i')

    listtypeAVIRECORD           = $20636572; // mmioFOURCC('r', 'e', 'c', ' ')



    ckidAVINEWINDEX             = $31786469; // mmioFOURCC('i', 'd', 'x', '1')



{-- Stream types for the <fccType> field of the stream header ----------------}



    streamtypeVIDEO             = $73646976; // mmioFOURCC('v', 'i', 'd', 's')

    streamtypeAUDIO             = $73647561; // mmioFOURCC('a', 'u', 'd', 's')

    streamtypeMIDI              = $7364696D; // mmioFOURCC('m', 'i', 'd', 's')

    streamtypeTEXT              = $73747874; // mmioFOURCC('t', 'x', 't', 's')



{-- Basic chunk types --------------------------------------------------------}



    cktypeDIBbits               = $6264; // aviTWOCC('d', 'b')

    cktypeDIBcompressed         = $6364; // aviTWOCC('d', 'c')

    cktypePALchange             = $6370; // aviTWOCC('p', 'c')

    cktypeWAVEbytes             = $6277; // aviTWOCC('w', 'b')



{-- Chunk id to use for extra chunks for padding -----------------------------}



    ckidAVIPADDING              = $4B4E554A; // mmioFOURCC('J', 'U', 'N', 'K')



(*

** Useful macros

**

** Warning: These are nasty macro, and MS C 6.0 compiles some of them

** incorrectly if optimizations are on.  Ack.

*)



{-- Macro to get stream number out of a FOURCC ckid --------------------------}



function    FromHex(n: BYTE): BYTE;

function    StreamFromFOURCC(fcc: DWORD): BYTE;



{-- Macro to get TWOCC chunk type out of a FOURCC ckid -----------------------}



function    TWOCCFromFOURCC(fcc: DWORD): WORD;



{-- Macro to make a ckid for a chunk out of a TWOCC and a stream num (0-255) -}



function    ToHex(n: BYTE): BYTE;

function    MAKEAVICKID(tcc: WORD; stream: BYTE): DWORD;



{-- Main AVI file header -----------------------------------------------------}



{-- flags for use in <dwFlags> in AVIFileHdr ---------------------------------}



const

    AVIF_HASINDEX               = $00000010;    // Index at end of file?

    AVIF_MUSTUSEINDEX           = $00000020;

    AVIF_ISINTERLEAVED          = $00000100;

    AVIF_TRUSTCKTYPE            = $00000800;    // Use CKType to find key frames?

    AVIF_WASCAPTUREFILE         = $00010000;

    AVIF_COPYRIGHTED            = $00020000;



{-- The AVI File Header LIST chunk should be padded to this size -------------}



const

    AVI_HEADERSIZE              = 2048;         // size of AVI header list



type

    PMainAVIHeader              = ^TMainAVIHeader;

    TMainAVIHeader              = packed record

        dwMicroSecPerFrame      : DWORD;        // frame display rate (or 0L)

        dwMaxBytesPerSec        : DWORD;        // max. transfer rate

        dwPaddingGranularity    : DWORD;        // pad to multiples of this

                                                // size; normally 2K.

        dwFlags                 : DWORD;        // the ever-present flags

        dwTotalFrames           : DWORD;        // # frames in file

        dwInitialFrames         : DWORD;

        dwStreams               : DWORD;

        dwSuggestedBufferSize   : DWORD;



        dwWidth                 : DWORD;

        dwHeight                : DWORD;



        dwReserved              : array[0..3] of DWORD;

    end;



{-- Stream header ------------------------------------------------------------}



const

    AVISF_DISABLED              = $00000001;



    AVISF_VIDEO_PALCHANGES      = $00010000;



type

    PAVIStreamHeader            = ^TAVIStreamHeader;

    TAVIStreamHeader            = packed record

        fccType                 : FOURCC;

        fccHandler              : FOURCC;

        dwFlags                 : DWORD;        // Contains AVITF_* flags

        wPriority               : WORD;

        wLanguage               : WORD;

        dwInitialFrames         : DWORD;

        dwScale                 : DWORD;

        dwRate                  : DWORD;        // dwRate / dwScale == samples/second

        dwStart                 : DWORD;

        dwLength                : DWORD;        // In units above...

        dwSuggestedBufferSize   : DWORD;

        dwQuality               : DWORD;

        dwSampleSize            : DWORD;

        rcFrame                 : TRECT;

    end;



{-- Flags for index ----------------------------------------------------------}



const

    AVIIF_NOTIME                = $00000100;    // this frame doesn't take any time

    AVIIF_COMPUSE               = $0FFF0000;    // these bits are for compressor use



type

    PAVIINDEXENTRY              = ^TAVIINDEXENTRY;

    TAVIINDEXENTRY              = packed record

        ckid                    : DWORD;

        dwFlags                 : DWORD;

        dwChunkOffset           : DWORD;        // Position of chunk

        dwChunkLength           : DWORD;        // Length of chunk

    end;



{-- Palette change chunk (used in video streams) -----------------------------}



    PAVIPALCHANGE               = ^TAVIPALCHANGE;

    TAVIPALCHANGE               = packed record

        bFirstEntry             : BYTE;         // first entry to change

        bNumEntries             : BYTE;         // # entries to change (0 if 256)

        wFlags                  : WORD;         // Mostly to preserve alignment...

        peNew                   : array[0..0] of TPALETTEENTRY; // New color specifications

    end;



(****************************************************************************

 *

 *  AVIFile - routines for reading/writing standard AVI files

 *

 ***************************************************************************)



//

// Ansi - Unicode thunking.

//

// Unicode or Ansi-only apps can call the avifile APIs.

// any Win32 app who wants to use

// any of the AVI COM interfaces must be UNICODE - the AVISTREAMINFO and

// AVIFILEINFO structures used in the Info methods of these interfaces are

// the unicode variants, and no thunking to or from ansi takes place

// except in the AVIFILE api entrypoints.

//

// For Ansi/Unicode thunking: for each entrypoint or structure that

// uses chars or strings, two versions are declared in the Win32 version,

// ApiNameW and ApiNameA. The default name ApiName is #defined to one or

// other of these depending on whether UNICODE is defined (during

// compilation of the app that is including this header). The source will

// contain ApiName and ApiNameA (with ApiName being the Win16 implementation,

// and also #defined to ApiNameW, and ApiNameA being the thunk entrypoint).

//



// For GetFrame::SetFormat - use the best format for the display



const

    AVIGETFRAMEF_BESTDISPLAYFMT = 1;



//

// Structures used by AVIStreamInfo & AVIFileInfo.

//

// These are related to, but not identical to, the header chunks

// in an AVI file.

//



{-- AVISTREAMINFO ------------------------------------------------------------}



// for Unicode/Ansi thunking we need to declare three versions of this!



type

    PAVIStreamInfoW             = ^TAVIStreamInfoW;

    TAVIStreamInfoW             = packed record

        fccType                 : DWORD;

        fccHandler              : DWORD;

        dwFlags                 : DWORD;        // Contains AVITF_* flags

        dwCaps                  : DWORD;

        wPriority               : WORD;

        wLanguage               : WORD;

        dwScale                 : DWORD;

        dwRate                  : DWORD;        // dwRate / dwScale == samples/second

        dwStart                 : DWORD;

        dwLength                : DWORD;        // In units above...

        dwInitialFrames         : DWORD;

        dwSuggestedBufferSize   : DWORD;

        dwQuality               : DWORD;

        dwSampleSize            : DWORD;

        rcFrame                 : TRECT;

        dwEditCount             : DWORD;

        dwFormatChangeCount     : DWORD;

        szName                  : array[0..63] of WideChar;

    end;



    PAVIStreamInfoA             = ^TAVIStreamInfoA;

    TAVIStreamInfoA             = packed record

        fccType                 : DWORD;

        fccHandler              : DWORD;

        dwFlags                 : DWORD;        // Contains AVITF_* flags

        dwCaps                  : DWORD;

        wPriority               : WORD;

        wLanguage               : WORD;

        dwScale                 : DWORD;

        dwRate                  : DWORD;        // dwRate / dwScale == samples/second

        dwStart                 : DWORD;

        dwLength                : DWORD;        // In units above...

        dwInitialFrames         : DWORD;

        dwSuggestedBufferSize   : DWORD;

        dwQuality               : DWORD;

        dwSampleSize            : DWORD;

        rcFrame                 : TRECT;

        dwEditCount             : DWORD;

        dwFormatChangeCount     : DWORD;

        szName                  : array[0..63] of AnsiChar;

    end;



  PAVIStreamInfo = ^TAVIStreamInfo;

{$IFDEF UNICODE}

  TAVIStreamInfo = TAVIStreamInfoW;

{$ELSE}

  TAVIStreamInfo = TAVIStreamInfoA;

{$ENDIF}



const

    AVISTREAMINFO_DISABLED      = $00000001;

    AVISTREAMINFO_FORMATCHANGES = $00010000;



{-- AVIFILEINFO --------------------------------------------------------------}



type

    PAVIFileInfoW               = ^TAVIFileInfoW;

    TAVIFileInfoW               = packed record

        dwMaxBytesPerSec        : DWORD;        // max. transfer rate

        dwFlags                 : DWORD;        // the ever-present flags

        dwCaps                  : DWORD;

        dwStreams               : DWORD;

        dwSuggestedBufferSize   : DWORD;



        dwWidth                 : DWORD;

        dwHeight                : DWORD;



        dwScale                 : DWORD;

        dwRate                  : DWORD;        // dwRate / dwScale == samples/second

        dwLength                : DWORD;



        dwEditCount             : DWORD;



        szFileType              : array[0..63] of WideChar;

                                                // descriptive string for file type?

    end;



    PAVIFileInfoA               = ^TAVIFileInfoA;

    TAVIFileInfoA               = packed record

        dwMaxBytesPerSec        : DWORD;        // max. transfer rate

        dwFlags                 : DWORD;        // the ever-present flags

        dwCaps                  : DWORD;

        dwStreams               : DWORD;

        dwSuggestedBufferSize   : DWORD;



        dwWidth                 : DWORD;

        dwHeight                : DWORD;



        dwScale                 : DWORD;

        dwRate                  : DWORD;        // dwRate / dwScale == samples/second

        dwLength                : DWORD;



        dwEditCount             : DWORD;



        szFileType              : array[0..63] of AnsiChar;

                                                // descriptive string for file type?

    end;



  PAVIFileInfo = ^TAVIFileInfo;

{$IFDEF UNICODE}

  TAVIFileInfo = TAVIFileInfoW;

{$ELSE}

  TAVIFileInfo = TAVIFileInfoA;

{$ENDIF}



{-- Flags for dwFlags --------------------------------------------------------}



const

    AVIFILEINFO_HASINDEX            = $00000010;

    AVIFILEINFO_MUSTUSEINDEX        = $00000020;

    AVIFILEINFO_ISINTERLEAVED       = $00000100;

    AVIFILEINFO_WASCAPTUREFILE      = $00010000;

    AVIFILEINFO_COPYRIGHTED         = $00020000;



{-- Flags for dwCaps ---------------------------------------------------------}



    AVIFILECAPS_CANREAD             = $00000001;

    AVIFILECAPS_CANWRITE            = $00000002;

    AVIFILECAPS_ALLKEYFRAMES        = $00000010;

    AVIFILECAPS_NOCOMPRESSION       = $00000020;



type

    TAVISAVECALLBACK                = function(i: int): BOOL; pascal;



{-- AVICOMPRESSOPTIONS -------------------------------------------------------}



// Make sure it matches the AutoDoc in avisave.c !!!



type

    PAVICOMPRESSOPTIONS             = ^TAVICOMPRESSOPTIONS;

    TAVICOMPRESSOPTIONS             = packed record

        fccType                     : DWORD;    // stream type, for consistency

        fccHandler                  : DWORD;    // compressor

        dwKeyFrameEvery             : DWORD;    // keyframe rate

        dwQuality                   : DWORD;    // compress quality 0-10,000

        dwBytesPerSecond            : DWORD;    // bytes per second

        dwFlags                     : DWORD;    // flags... see below

        lpFormat                    : PVOID;    // save format

        cbFormat                    : DWORD;

        lpParms                     : PVOID;    // compressor options

        cbParms                     : DWORD;

        dwInterleaveEvery           : DWORD;    // for non-video streams only

    end;



//

// Defines for the dwFlags field of the AVICOMPRESSOPTIONS struct

// Each of these flags determines if the appropriate field in the structure

// (dwInterleaveEvery, dwBytesPerSecond, and dwKeyFrameEvery) is payed

// attention to.  See the autodoc in avisave.c for details.

//



const

    AVICOMPRESSF_INTERLEAVE         = $00000001;    // interleave

    AVICOMPRESSF_DATARATE           = $00000002;    // use a data rate

    AVICOMPRESSF_KEYFRAMES          = $00000004;    // use keyframes

    AVICOMPRESSF_VALID              = $00000008;    // has valid data?



(*	-	-	-	-	-	-	-	-	*/





/****** AVI Stream Interface *******************************************)



type

    IAVIStream = interface(IUnknown)

        function Create(lParam1, lParam2: LPARAM): HResult; stdcall;

        function Info(var psi: TAVIStreamInfoW; lSize: LONG): HResult; stdcall;

        function FindSample(lPos: LONG; lFlags: LONG): LONG; stdcall;

        function ReadFormat(lPos: LONG; lpFormat: PVOID; var lpcbForm