vfw.pas

Previous  Top  Next

    
 

 

Code:

{*******************************************************************************

Original author unknown.

Modified for Delphi 3/4 COM syntax by Tom Nuydens

                                       (delphi3d@gamedeveloper.org)

                                       (www.gamedeveloper.org/delphi3d)

*******************************************************************************}

 

unit VFW;

 

interface

 

uses

   Windows, MMSystem, Messages, CommDlg, ActiveX;

 

{== General ==================================================================}

 

type

   PDWORD  = ^DWORD;

   PLONG   = PDWORD;

   UDWORD  = DWORD;

   PVOID   = Pointer;

   int     = Integer;

 

{-- Returns version of VFW ---------------------------------------------------}

 

function    VideoForWindowsVersion: DWord; pascal;

 

{-- Call these to start stop using VfW from your app -------------------------}

 

{ TODO: Where are these functions? }

 

// function    InitVFW: DWORD; stdcall;

// function    TermVFW: DWORD; stdcall;

 

{-- Macros -------------------------------------------------------------------}

 

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; // mmioFOURCC('v', 'i', 'd', 'c')

   ICTYPE_AUDIO                = $63647561; // mmioFOURCC('a', 'u', 'd', 'c')

 

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; // mmioFOURCC('F','r','m','R')

   ICM_KEYFRAMERATE            = $5279654B; // mmioFOURCC('K','e','y','R')

 

{-- 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                     = 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                     = 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 WideChar  ; // short name

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

       szDriver                : array[0..127] of WideChar ; // 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                 = 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               : DWORD ;                // 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(lInput: LPARAM; lFrame: DWORD; lpBits: PVOID; len: DWORD): DWORD; stdcall;

 

   PICCOMPRESSFRAMES           = ^TICCOMPRESSFRAMES;

   TICCOMPRESSFRAMES           = record

       dwFlags                 : DWORD ;               // flags

 

       lpbiOutput              : PBITMAPINFOHEADER ;   // output format

       lOutput                 : LPARAM ;              // output identifier

 

       lpbiInput               : PBITMAPINFOHEADER ;   // format of frame to compress

       lInput                  : LPARAM ;              // input identifier

 

       lStartFrame             : DWORD ;                // start frame

       lFrameCount             : DWORD ;                // # of frames

 

       lQuality                : DWORD ;                // quality

       lDataRate               : DWORD ;                // data rate

       lKeyRate                : DWORD ;                // 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: DWORD): DWORD; stdcall;

 

   PICSETSTATUSPROC            = ^TICSETSTATUSPROC;

   TICSETSTATUSPROC            = 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               = 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             = 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                = 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                     = record

       dwFlags                 : DWORD ;   // flags

       lpFormat                : PVOID ;   // format of frame to decompress

       lpData                  : PVOID ;   // frame data to decompress

       cbData                  : DWORD ;

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

   end;

 

   PICDRAWSUGGEST              = ^TICDRAWSUGGEST;

   TICDRAWSUGGEST              = 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                  = 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 fmt to a dest fmt ----}

 

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

 

{-- ICCompressQuery() - determines if compression from src to dst is supp ----}

 

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

 

{-- ICCompressGetFormat() - get the output format (fmt of compressed) --------}

 

// if lpbiOutput is nil 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 src fmt to a dest fmt -------}

 

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

 

{-- ICDecompressQuery() - determines if compression is supported -------------}

 

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

 

{-- ICDecompressGetFormat - get the output fmt (fmt of uncompressed 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 src fmt to a dest fmt ---}

 

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 fmt directly to 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 fmt ----}

 

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    : DWORD;                 // 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       = 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      : DWORD;

       lKey        : DWORD;             // key frames how often?

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

       lQ          : DWORD;             // desired quality

       lKeyCount   : DWORD;

       lpState     : PVOID;            // state of compressor

       cbState     : DWORD;             // 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

 

{-- ICCompressorChoose() - 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        = record

       timeCount       : DWORD;

       timeDraw        : DWORD;

       timeDecompress  : DWORD;

       timeDither      : DWORD;

       timeStretch     : DWORD;

       timeBlt         : DWORD;

       timeSetDIBits   : DWORD;

   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 ============================================================}

 

{-- 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              = 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            = 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              = 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               = record

       bFirstEntry             : BYTE;         // first entry to change

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

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

       // peNew                : array[0..-1] of PALETTEENTRY ;

                                               // 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             = 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             = 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;

 

   TAVISTREAMINFO              = TAVISTREAMINFOA;

   PAVISTREAMINFO              = PAVISTREAMINFOA;

 

const

   AVISTREAMINFO_DISABLED      = $00000001;

   AVISTREAMINFO_FORMATCHANGES = $00010000;

 

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

 

type

   PAVIFILEINFOW               = ^TAVIFILEINFOW;

   TAVIFILEINFOW               = 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               = 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;

 

   TAVIFILEINFO                    = TAVIFILEINFOA;

   PAVIFILEINFO                    = PAVIFILEINFOA;

 

{-- 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             = 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 interfaces ===========================================================}

 

{-- AVIStream ----------------------------------------------------------------}

 

type

   PAVIStream      = ^IAVIStream;

   IAVIStream      = interface(IUnknown)

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

       function    Info(psi: PAVISTREAMINFOW; lSize: DWORD): HResult; stdcall;

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

       function    ReadFormat(lPos: DWORD; lpFormat: PVOID; lpcbFormat: PDWORD): HResult; stdcall;

       function    SetFormat(lPos: DWORD; lpFormat: PVOID; cbFormat: DWORD): HResult; stdcall;

       function    Read(lStart: DWORD; lSamples: DWORD; lpBuffer: PVOID; cbBuffer: DWORD; plBytes, plSamples: PDWORD): HResult; stdcall;

       function    Write(lStart: DWORD; lSamples: DWORD; lpBuffer: PVOID; cbBuffer: DWORD; dwFlags: DWORD; plSampWritten, plBytesWritten: PDWORD): HResult; stdcall;

       function    Delete(lStart: DWORD; lSamples: DWORD): HResult; stdcall;

       function    ReadData(fcc: DWORD; lp: PVOID; lpcb: PDWORD): HResult; stdcall;

       function    WriteData(fcc: DWORD; lp: PVOID; cb: DWORD): HResult; stdcall;

       function    SetInfo(lpInfo: PAVISTREAMINFOW; cbInfo: DWORD): HResult; stdcall;

   end;

 

   PAVIStreaming   = ^IAVIStreaming;

   IAVIStreaming   = interface(IUnknown)

       function    _Begin(

                           lStart,         // start of what we expect to play

                           lEnd  : DWORD;   // expected end, or -1

                           lRate : DWORD    // Should this be a float?

                         ): HResult; stdcall;

       function    _End: HResult; stdcall;

   end;

 

   PAVIEditStream  = ^IAVIEditStream;

   IAVIEditStream  = interface(IUnknown)

       function    Cut(plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall;

       function    Copy(plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall;

       function    Paste(plPos: PDWORD; plLength: PDWORD; pstream: PAVISTREAM; lStart, lEnd: DWORD): HResult; stdcall;

       function    Clone(var ppResult: PAVISTREAM): HResult; stdcall;

       function    SetInfo(lpInfo: PAVISTREAMINFOW; cbInfo: DWORD): HResult; stdcall;

   end;

 

{-- AVIFile ------------------------------------------------------------------}

 

   PAVIFile        = ^IAVIFile;

   IAVIFile        = interface(IUnknown)

       function    Info(pfi: PAVIFILEINFOW; lSize: DWORD): HResult; stdcall;

       function    GetStream(var ppStream: PAVISTREAM; fccType: DWORD; lParam: DWORD): HResult; stdcall;

       function    CreateStream(var ppStream: PAVISTREAM; psi: PAVISTREAMINFOW): HResult; stdcall;

       function    WriteData(ckid: DWORD; lpData: PVOID; cbData: DWORD): HResult; stdcall;

       function    ReadData(ckid: DWORD; lpData: PVOID; lpcbData: PDWORD): HResult; stdcall;

       function    EndRecord: HResult; stdcall;

       function    DeleteStream(fccType: DWORD; lParam: DWORD): HResult; stdcall;

   end;

 

{-- GetFrame -----------------------------------------------------------------}

 

   PGetFrame       = ^IGetFrame;

   IGetFrame       = interface(IUnknown)

       function    GetFrame(lPos: DWORD): PVOID; stdcall;

 

       function    _Begin(lStart, lEnd: DWORD; lRate: DWORD): HResult; stdcall;

       function    _End: HResult; stdcall;

 

       function    SetFormat(lpbi: PBITMAPINFOHEADER; lpBits: PVOID; x, y, dx, dy: int): HResult; stdcall;

 

       // STDMETHOD(DrawFrameStart) (THIS) PURE;

       // STDMETHOD(DrawFrame) (THIS_ DWORD lPos, HDC hdc, int x, int y, int dx, int dy) PURE;

       // STDMETHOD(DrawFrameEnd) (THIS) PURE;

   end;

 

{-- GUIDs --------------------------------------------------------------------}

 

const

   IID_IAVIFile                : TGUID =

       (D1: $00020020; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

   IID_IAVIStream              : TGUID =

       (D1: $00020021; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

   IID_IAVIStreaming           : TGUID =

       (D1: $00020022; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

   IID_IGetFrame               : TGUID =

       (D1: $00020023; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

   IID_IAVIEditStream          : TGUID =

       (D1: $00020024; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

 

   CLSID_AVISimpleUnMarshal    : TGUID =

       (D1: $00020009; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

 

   CLSID_AVIFile               : TGUID =

       (D1: $00020000; D2: $0; D3: $0; D4:($C0,$0,$0,$0,$0,$0,$0,$46));

 

   AVIFILEHANDLER_CANREAD          = $0001;

   AVIFILEHANDLER_CANWRITE         = $0002;

   AVIFILEHANDLER_CANACCEPTNONRGB  = $0004;

 

{-- Functions ----------------------------------------------------------------}

 

procedure   AVIFileInit; stdcall;   // Call this first!

procedure   AVIFileExit; stdcall;

 

function    AVIFileAddRef(pfile: PAVIFILE): UDWORD; stdcall;

function    AVIFileRelease(pfile: PAVIFILE): UDWORD; stdcall;

 

function    AVIFileOpenA(var ppfile: PAVIFILE; szFile: LPCSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcall;

function    AVIFileOpenW(var ppfile: PAVIFILE; szFile: LPCWSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcall;

 

function    AVIFileOpen(var ppfile: PAVIFILE; szFile: LPCSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcall; // AVIFileOpenA

 

function    AVIFileInfoW(pfile: PAVIFILE; pfi: PAVIFILEINFOW; lSize: DWORD): HResult; stdcall;

function    AVIFileInfoA(pfile: PAVIFILE; pfi: PAVIFILEINFOA; lSize: DWORD): HResult; stdcall;

 

function    AVIFileInfo(pfile: PAVIFILE; pfi: PAVIFILEINFOA; lSize: DWORD): HResult; stdcall; // AVIFileInfoA

 

function    AVIFileGetStream(pfile: PAVIFILE; var ppavi: PAVISTREAM; fccType: DWORD; lParam: DWORD): HResult; stdcall;

 

function    AVIFileCreateStreamW(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOW): HResult; stdcall;

function    AVIFileCreateStreamA(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOA): HResult; stdcall;

 

function    AVIFileCreateStream(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOA): HResult; stdcall;    // AVIFileCreateStreamA

 

function    AVIFileWriteData(pfile: PAVIFILE; ckid: DWORD; lpData: PVOID; cbData: DWORD): HResult; stdcall;

function    AVIFileReadData(pfile: PAVIFILE; ckid: DWORD; lpData: PVOID; lpcbData: PDWORD): HResult; stdcall;

function    AVIFileEndRecord(pfile: PAVIFILE): HResult; stdcall;

 

function    AVIStreamAddRef(pavi: PAVISTREAM): UDWORD; stdcall;

function    AVIStreamRelease(pavi: PAVISTREAM): UDWORD; stdcall;

 

function    AVIStreamInfoW (pavi: PAVISTREAM; psi: PAVISTREAMINFOW; lSize: DWORD): HResult; stdcall;

function    AVIStreamInfoA (pavi: PAVISTREAM; psi: PAVISTREAMINFOA; lSize: DWORD): HResult; stdcall;

 

function    AVIStreamInfo(pavi: PAVISTREAM; psi: PAVISTREAMINFOA; lSize: DWORD): HResult; stdcall; // AVIStreamInfoA

 

function    AVIStreamFindSample(pavi: PAVISTREAM; lPos: DWORD; lFlags: DWORD): DWORD; stdcall;

function    AVIStreamReadFormat(pavi: PAVISTREAM; lPos: DWORD; lpFormat: PVOID; lpcbFormat: PDWORD): HResult; stdcall;

function    AVIStreamSetFormat(pavi: PAVISTREAM; lPos: DWORD; lpFormat: PVOID; cbFormat: DWORD): HResult; stdcall;

function    AVIStreamReadData(pavi: PAVISTREAM; fcc: DWORD; lp: PVOID; lpcb: PDWORD): HResult; stdcall;

function    AVIStreamWriteData(pavi: PAVISTREAM; fcc: DWORD; lp: PVOID; cb: DWORD): HResult; stdcall;

 

function    AVIStreamRead(

   pavi            : PAVISTREAM;

   lStart          : DWORD;

   lSamples        : DWORD;

   lpBuffer        : PVOID;

   cbBuffer        : DWORD;

   plBytes         : PDWORD;

   plSamples       : PDWORD

   ): HResult; stdcall;

 

const

   AVISTREAMREAD_CONVENIENT    = -1;

 

function    AVIStreamWrite(

   pavi            : PAVISTREAM;

   lStart,

   lSamples        : DWORD;

   lpBuffer        : PVOID;

   cbBuffer        : DWORD;

   dwFlags         : DWORD;

   plSampWritten   : PDWORD;

   plBytesWritten  : PDWORD

   ): HResult; stdcall;

 

// Right now, these just use AVIStreamInfo() to get information, then

// return some of it.  Can they be more efficient?

 

function    AVIStreamStart(pavi: PAVISTREAM): DWORD; stdcall;

function    AVIStreamLength(pavi: PAVISTREAM): DWORD; stdcall;

function    AVIStreamTimeToSample(pavi: PAVISTREAM; lTime: DWORD): DWORD; stdcall;

function    AVIStreamSampleToTime(pavi: PAVISTREAM; lSample: DWORD): DWORD; stdcall;

 

function    AVIStreamBeginStreaming(pavi: PAVISTREAM; lStart, lEnd: DWORD; lRate: DWORD): HResult; stdcall;

function    AVIStreamEndStreaming(pavi: PAVISTREAM): HResult; stdcall;

 

{-- Helper functions for using IGetFrame -------------------------------------}

 

function    AVIStreamGetFrameOpen(pavi: PAVISTREAM; lpbiWanted: PBITMAPINFOHEADER): PGETFRAME; stdcall;

function    AVIStreamGetFrame(pg: PGETFRAME; lPos: DWORD): PVOID; stdcall;

function    AVIStreamGetFrameClose(pg: PGETFRAME): HResult; stdcall;

 

// !!! We need some way to place an advise on a stream....

// STDAPI AVIStreamHasChanged   (PAVISTREAM pavi);

 

{-- Shortcut function --------------------------------------------------------}

 

function    AVIStreamOpenFromFileA(var ppavi: PAVISTREAM; szFile: LPCSTR; fccType: DWORD;

                                  lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall;

function    AVIStreamOpenFromFileW(var ppavi: PAVISTREAM; szFile: LPCWSTR; fccType: DWORD;

                                  lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall;

 

function    AVIStreamOpenFromFile(var ppavi: PAVISTREAM; szFile: LPCSTR; fccType: DWORD;

                                 lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall; // AVIStreamOpenFromFileA

 

{-- Use to create disembodied streams ----------------------------------------}

 

function    AVIStreamCreate(var ppavi: PAVISTREAM; lParam1, lParam2: DWORD;

                           pclsidHandler: PCLSID): HResult; stdcall;

 

// PHANDLER    AVIAPI AVIGetHandler         (PAVISTREAM pavi, PAVISTREAMHANDLER psh);

// PAVISTREAM  AVIAPI AVIGetStream          (PHANDLER p);

 

{-- Flags for AVIStreamFindSample --------------------------------------------}

 

const

   FIND_DIR                        = $0000000F;    // direction

   FIND_NEXT                       = $00000001;    // go forward

   FIND_PREV                       = $00000004;    // go backward

   FIND_FROM_START                 = $00000008;    // start at the logical beginning

 

   FIND_TYPE                       = $000000F0;    // type mask

   FIND_KEY                        = $00000010;    // find key frame.

   FIND_ANY                        = $00000020;    // find any (non-empty) sample

   FIND_FORMAT                     = $00000040;    // find format change

 

   FIND_RET                        = $0000F000;    // return mask

   FIND_POS                        = $00000000;    // return logical position

   FIND_LENGTH                     = $00001000;    // return logical size

   FIND_OFFSET                     = $00002000;    // return physical position

   FIND_SIZE                       = $00003000;    // return physical size

   FIND_INDEX                      = $00004000;    // return physical index position

 

{-- Stuff to support backward compat. ----------------------------------------}

 

function    AVIStreamFindKeyFrame(pavi: PAVISTREAM; lPos: DWORD; lFlags: DWORD): DWORD; stdcall; // AVIStreamFindSample

 

// Non-portable: this is alias for method name

// FindKeyFrame FindSample

 

function    AVIStreamClose(pavi: PAVISTREAM): UDWORD; stdcall; // AVIStreamRelease

function    AVIFileClose(pfile: PAVIFILE): UDWORD; stdcall; // AVIFileRelease

procedure   AVIStreamInit; stdcall; // AVIFileInit

procedure   AVIStreamExit; stdcall; // AVIFileExit

 

const

   SEARCH_NEAREST                  = FIND_PREV;

   SEARCH_BACKWARD                 = FIND_PREV;

   SEARCH_FORWARD                  = FIND_NEXT;

   SEARCH_KEY                      = FIND_KEY;

   SEARCH_ANY                      = FIND_ANY;

 

{-- Helper macros ------------------------------------------------------------}

 

function    AVIStreamSampleToSample(pavi1, pavi2: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamNextSample(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamPrevSample(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamNearestSample(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamNextKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamPrevKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamNearestKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

function    AVIStreamIsKeyFrame(pavi: PAVISTREAM; l: DWORD): BOOL;

function    AVIStreamPrevSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamNextSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamNearestSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamNextKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamPrevKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamNearestKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

function    AVIStreamStartTime(pavi: PAVISTREAM): DWORD;

function    AVIStreamLengthTime(pavi: PAVISTREAM): DWORD;

function    AVIStreamEnd(pavi: PAVISTREAM): DWORD;

function    AVIStreamEndTime(pavi: PAVISTREAM): DWORD;

function    AVIStreamSampleSize(pavi: PAVISTREAM; lPos: DWORD; plSize: PDWORD): DWORD;

function    AVIStreamFormatSize(pavi: PAVISTREAM; lPos: DWORD; plSize: PDWORD): HResult;

function    AVIStreamDataSize(pavi: PAVISTREAM; fcc: DWORD; plSize: PDWORD): HResult;

 

{== AVISave routines and structures ==========================================}

 

const

   comptypeDIB                     = $20424944; // mmioFOURCC('D', 'I', 'B', ' ')

 

function    AVIMakeCompressedStream(

   var ppsCompressed   : PAVISTREAM;

   ppsSource           : PAVISTREAM;

   lpOptions           : PAVICOMPRESSOPTIONS;

   pclsidHandler       : PCLSID

   ): HResult; stdcall;

 

// Non-portable: uses variable number of params

// EXTERN_C HRESULT CDECL AVISaveA (LPCSTR               szFile,

//      CLSID FAR *pclsidHandler,

//      AVISAVECALLBACK     lpfnCallback,

//      int                 nStreams,

//      PAVISTREAM      pfile,

//      LPAVICOMPRESSOPTIONS lpOptions,

//      ...);

 

function    AVISaveVA(

   szFile          : LPCSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall;

 

// Non-portable: uses variable number of params

// EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR               szFile,

//      CLSID FAR *pclsidHandler,

//      AVISAVECALLBACK     lpfnCallback,

//      int                 nStreams,

//      PAVISTREAM      pfile,

//      LPAVICOMPRESSOPTIONS lpOptions,

//      ...);

 

function    AVISaveVW(

   szFile          : LPCWSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall;

 

// #define AVISave      AVISaveA

 

function    AVISaveV(

   szFile          : LPCSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall; // AVISaveVA

 

function    AVISaveOptions(

   hwnd            : HWND;

   uiFlags         : UINT;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): BOOL; stdcall;

 

function    AVISaveOptionsFree(nStreams: int; var plpOptions: PAVICOMPRESSOPTIONS): HResult; stdcall;

 

{-- FLAGS FOR uiFlags --------------------------------------------------------}

 

// Same as the flags for ICCompressorChoose (see compman.h)

// These determine what the compression options dialog for video streams

// will look like.

 

function    AVIBuildFilterW(lpszFilter: LPWSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall;

function    AVIBuildFilterA(lpszFilter: LPSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall;

 

function    AVIBuildFilter(lpszFilter: LPSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall; // AVIBuildFilterA

 

function    AVIMakeFileFromStreams(var ppfile: PAVIFILE; nStreams: int; var papStreams: PAVISTREAM): HResult; stdcall;

 

function    AVIMakeStreamFromClipboard(cfFormat: UINT; hGlobal: THANDLE; var ppstream: PAVISTREAM): HResult; stdcall;

 

{-- Clipboard routines -------------------------------------------------------}

 

function    AVIPutFileOnClipboard(pf: PAVIFILE): HResult; stdcall;

function    AVIGetFromClipboard(var lppf: PAVIFILE): HResult; stdcall;

function    AVIClearClipboard: HResult; stdcall;

 

{-- Editing routines ---------------------------------------------------------}

 

function    CreateEditableStream(var ppsEditable: PAVISTREAM; psSource: PAVISTREAM): HResult; stdcall;

 

function    EditStreamCut(pavi: PAVISTREAM; plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall;

 

function    EditStreamCopy(pavi: PAVISTREAM; plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall;

 

function    EditStreamPaste(pavi: PAVISTREAM; plPos, plLength: PDWORD; pstream: PAVISTREAM; lStart, lEnd: DWORD): HResult; stdcall;

 

function    EditStreamClone(pavi: PAVISTREAM; var ppResult: PAVISTREAM): HResult; stdcall;

 

function    EditStreamSetNameA(pavi: PAVISTREAM; lpszName: LPCSTR): HResult; stdcall;

function    EditStreamSetNameW(pavi: PAVISTREAM; lpszName: LPCWSTR): HResult; stdcall;

function    EditStreamSetInfoW(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOW; cbInfo: DWORD): HResult; stdcall;

function    EditStreamSetInfoA(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOA; cbInfo: DWORD): HResult; stdcall;

 

function    EditStreamSetInfo(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOA; cbInfo: DWORD): HResult; stdcall; // EditStreamSetInfoA

function    EditStreamSetName(pavi: PAVISTREAM; lpszName: LPCSTR): HResult; stdcall; // EditStreamSetNameA

 

{-- Error handling -----------------------------------------------------------}

 

const

   AVIERR_OK                       = 0;

 

// !!! Questions to be answered:

// How can you get a string form of these errors?

// Which of these errors should be replaced by errors in SCODE.H?

 

const

   AVIERR_UNSUPPORTED              = $80044065; // MAKE_AVIERR(101)

   AVIERR_BADFORMAT                = $80044066; // MAKE_AVIERR(102)

   AVIERR_MEMORY                   = $80044067; // MAKE_AVIERR(103)

   AVIERR_INTERNAL                 = $80044068; // MAKE_AVIERR(104)

   AVIERR_BADFLAGS                 = $80044069; // MAKE_AVIERR(105)

   AVIERR_BADPARAM                 = $8004406A; // MAKE_AVIERR(106)

   AVIERR_BADSIZE                  = $8004406B; // MAKE_AVIERR(107)

   AVIERR_BADHANDLE                = $8004406C; // MAKE_AVIERR(108)

   AVIERR_FILEREAD                 = $8004406D; // MAKE_AVIERR(109)

   AVIERR_FILEWRITE                = $8004406E; // MAKE_AVIERR(110)

   AVIERR_FILEOPEN                 = $8004406F; // MAKE_AVIERR(111)

   AVIERR_COMPRESSOR               = $80044070; // MAKE_AVIERR(112)

   AVIERR_NOCOMPRESSOR             = $80044071; // MAKE_AVIERR(113)

   AVIERR_READONLY                 = $80044072; // MAKE_AVIERR(114)

   AVIERR_NODATA                   = $80044073; // MAKE_AVIERR(115)

   AVIERR_BUFFERTOOSMALL           = $80044074; // MAKE_AVIERR(116)

   AVIERR_CANTCOMPRESS             = $80044075; // MAKE_AVIERR(117)

   AVIERR_USERABORT                = $800440C6; // MAKE_AVIERR(198)

   AVIERR_ERROR                    = $800440C7; // MAKE_AVIERR(199)

 

{== MCIWnd - Window class for MCI objects ====================================}

 

//

//  MCIWnd

//

//    MCIWnd window class header file.

//

//    the MCIWnd window class is a window class for controling MCI devices

//    MCI devices include, wave files, midi files, AVI Video, cd audio,

//    vcr, video disc, and others..

//

//    to learn more about MCI and mci command sets see the

//    "Microsoft Multimedia Programmers's guide" in the Win31 SDK

//

//    the easiest use of the MCIWnd class is like so:

//

//          hwnd = MCIWndCreate(hwndParent, hInstance, 0, "chimes.wav");

//          ...

//          MCIWndPlay(hwnd);

//          MCIWndStop(hwnd);

//          MCIWndPause(hwnd);

//          ....

//          MCIWndDestroy(hwnd);

//

//    this will create a window with a play/pause, stop and a playbar

//    and start the wave file playing.

//

//    mciwnd.h defines macros for all the most common MCI commands, but

//    any string command can be used if needed.

//

//    Note: unlike the mciSendString() API, no alias or file name needs

//    to be specifed, since the device to use is implied by the window handle.

//

//          MCIWndSendString(hwnd, "setaudio stream to 2");

//

//    (C) Copyright Microsoft Corp. 1991-1995.  All rights reserved.

//

// WIN32:

//

//    MCIWnd supports both ansi and unicode interfaces. For any message that

//    takes or returns a text string, two versions of the message are defined,

//    appended with A or W for Ansi or Wide Char. The message or api itself

//    is defined to be one or other of these depending on whether you have

//    UNICODE defined in your application.

//    Thus for the api MCIWndCreate, there are in fact two apis,

//    MCIWndCreateA and MCIWndCreateW. If you call MCIWndCreate, this will be

//    re-routed to MCIWndCreateA unless UNICODE is defined when building your

//    application. In any one application, you can mix calls to the

//    Ansi and Unicode entrypoints.

//

//    If you use SendMessage instead of the macros below such as MCIWndOpen(),

//    you will see that the messages have changed for WIN32, to support Ansi

//    and Unicode entrypoints. In particular, MCI_OPEN has been replaced by

//    MCWNDM_OPENA, or MCIWNDM_OPENW (MCIWNDM_OPEN is defined to be one or

//    other of these).

//

//    Also, note that the WIN32 implementation of MCIWnd uses UNICODE

//    so all apis and messages supporting ANSI strings do so by mapping them

//    UNICODE strings and then calling the corresponding UNICODE entrypoint.

//

 

function    MCIWndSM(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): DWORD;

 

const                              

   MCIWND_WINDOW_CLASS             = 'MCIWndClass' ;

 

function    MCIWndCreateA(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCSTR): HWND; cdecl;

function    MCIWndCreateW(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCWSTR): HWND; cdecl;

 

function    MCIWndCreate(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCSTR): HWND; cdecl; // MCIWndCreateA

 

function    MCIWndRegisterClass: BOOL; cdecl;

 

{-- Flags for the MCIWndOpen command -----------------------------------------}

 

const

   MCIWNDOPENF_NEW                 = $0001;    // open a new file

 

{-- Window styles ------------------------------------------------------------}

 

   MCIWNDF_NOAUTOSIZEWINDOW        = $0001;    // when movie size changes

   MCIWNDF_NOPLAYBAR               = $0002;    // no toolbar

   MCIWNDF_NOAUTOSIZEMOVIE         = $0004;    // when window size changes

   MCIWNDF_NOMENU                  = $0008;    // no popup menu from RBUTTONDOWN

   MCIWNDF_SHOWNAME                = $0010;    // show name in caption

   MCIWNDF_SHOWPOS                 = $0020;    // show position in caption

   MCIWNDF_SHOWMODE                = $0040;    // show mode in caption

   MCIWNDF_SHOWALL                 = $0070;    // show all

 

   MCIWNDF_NOTIFYMODE              = $0100;    // tell parent of mode change

   MCIWNDF_NOTIFYPOS               = $0200;    // tell parent of pos change

   MCIWNDF_NOTIFYSIZE              = $0400;    // tell parent of size change

   MCIWNDF_NOTIFYERROR             = $1000;    // tell parent of an error

   MCIWNDF_NOTIFYALL               = $1F00;    // tell all

 

   MCIWNDF_NOTIFYANSI              = $0080;

 

// The MEDIA notification includes a text string.

// To receive notifications in ANSI instead of unicode set the

// MCIWNDF_NOTIFYANSI style bit. The macro below includes this bit

// by default unless you define UNICODE in your application.

 

   MCIWNDF_NOTIFYMEDIAA            = $0880;    // tell parent of media change

   MCIWNDF_NOTIFYMEDIAW            = $0800;    // tell parent of media change

 

   MCIWNDF_NOTIFYMEDIA             = MCIWNDF_NOTIFYMEDIAA;

 

   MCIWNDF_RECORD                  = $2000;    // Give a record button

   MCIWNDF_NOERRORDLG              = $4000;    // Show Error Dlgs for MCI cmds?

   MCIWNDF_NOOPEN                  = $8000;    // Don't allow user to open things

 

{-- Can macros ---------------------------------------------------------------}

 

function    MCIWndCanPlay(hwnd: HWND): BOOL;

function    MCIWndCanRecord(hwnd: HWND): BOOL;

function    MCIWndCanSave(hwnd: HWND): BOOL;

function    MCIWndCanWindow(hwnd: HWND): BOOL;

function    MCIWndCanEject(hwnd: HWND): BOOL;

function    MCIWndCanConfig(hwnd: HWND): BOOL;

function    MCIWndPaletteKick(hwnd: HWND): BOOL;

 

function    MCIWndSave(hwnd: HWND; szFile: LPCSTR): DWORD;

function    MCIWndSaveDialog(hwnd: HWND): DWORD;

 

// If you dont give a device it will use the current device....

 

function    MCIWndNew(hwnd: HWND; lp: PVOID): DWORD;

function    MCIWndRecord(hwnd: HWND): DWORD;

function    MCIWndOpen(hwnd: HWND; sz: LPCSTR; f: BOOL): DWORD;

function    MCIWndOpenDialog(hwnd: HWND): DWORD;

function    MCIWndClose(hwnd: HWND): DWORD;

function    MCIWndPlay(hwnd: HWND): DWORD;

function    MCIWndStop(hwnd: HWND): DWORD;

function    MCIWndPause(hwnd: HWND): DWORD;

function    MCIWndResume(hwnd: HWND): DWORD;

function    MCIWndSeek(hwnd: HWND; lPos: DWORD): DWORD;

function    MCIWndEject(hwnd: HWND): DWORD;

 

function    MCIWndHome(hwnd: HWND): DWORD;

function    MCIWndEnd(hwnd: HWND): DWORD;

 

function    MCIWndGetSource(hwnd: HWND; prc: PRECT): DWORD;

function    MCIWndPutSource(hwnd: HWND; prc: PRECT): DWORD;

 

function    MCIWndGetDest(hwnd: HWND; prc: PRECT): DWORD;

function    MCIWndPutDest(hwnd: HWND; prc: PRECT): DWORD;

 

function    MCIWndPlayReverse(hwnd: HWND): DWORD;

function    MCIWndPlayFrom(hwnd: HWND; lPos: DWORD): DWORD;

function    MCIWndPlayTo(hwnd: HWND; lPos: DWORD): DWORD;

function    MCIWndPlayFromTo(hwnd: HWND; lStart, lEnd: DWORD): DWORD;

 

function    MCIWndGetDeviceID(hwnd: HWND): UINT;

function    MCIWndGetAlias(hwnd: HWND): UINT;

function    MCIWndGetMode(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

function    MCIWndGetPosition(hwnd: HWND): DWORD;

function    MCIWndGetPositionString(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

function    MCIWndGetStart(hwnd: HWND): DWORD;

function    MCIWndGetLength(hwnd: HWND): DWORD;

function    MCIWndGetEnd(hwnd: HWND): DWORD;

 

function    MCIWndStep(hwnd: HWND; n: DWORD): DWORD;

 

procedure   MCIWndDestroy(hwnd: HWND);

procedure   MCIWndSetZoom(hwnd: HWND; iZoom: UINT);

function    MCIWndGetZoom(hwnd: HWND): UINT;

function    MCIWndSetVolume(hwnd: HWND; iVol: UINT): DWORD;

function    MCIWndGetVolume(hwnd: HWND): DWORD;

function    MCIWndSetSpeed(hwnd: HWND; iSpeed: UINT): DWORD;

function    MCIWndGetSpeed(hwnd: HWND): DWORD;

function    MCIWndSetTimeFormat(hwnd: HWND; lp: LPCSTR): DWORD;

function    MCIWndGetTimeFormat(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

procedure   MCIWndValidateMedia(hwnd: HWND);

 

procedure   MCIWndSetRepeat(hwnd: HWND; f: BOOL);

function    MCIWndGetRepeat(hwnd: HWND): BOOL;

 

function    MCIWndUseFrames(hwnd: HWND): DWORD;

function    MCIWndUseTime(hwnd: HWND): DWORD;

 

procedure   MCIWndSetActiveTimer(hwnd: HWND; active: UINT);

procedure   MCIWndSetInactiveTimer(hwnd: HWND; inactive: UINT);

procedure   MCIWndSetTimers(hwnd: HWND; active, inactive: UINT);

function    MCIWndGetActiveTimer(hwnd: HWND): UINT;

function    MCIWndGetInactiveTimer(hwnd: HWND): UINT;

 

function    MCIWndRealize(hwnd: HWND; fBkgnd: BOOL): DWORD;

 

function    MCIWndSendString(hwnd: HWND; sz: LPCSTR): DWORD;

function    MCIWndReturnString(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

function    MCIWndGetError(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

 

// #define MCIWndActivate(hwnd, f)     (void)MCIWndSM(hwnd, WM_ACTIVATE, (WPARAM)(BOOL)(f), 0)

 

function    MCIWndGetPalette(hwnd: HWND): HPALETTE;

function    MCIWndSetPalette(hwnd: HWND; hpal: HPALETTE): DWORD;

 

function    MCIWndGetFileName(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

function    MCIWndGetDevice(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

 

function    MCIWndGetStyles(hwnd: HWND): UINT;

function    MCIWndChangeStyles(hwnd: HWND; mask: UINT; value: DWORD): DWORD;

 

type

   PUnknown    = ^IUnknown;

 

function    MCIWndOpenInterface(hwnd: HWND; pUnk: PUnknown): DWORD;

 

function    MCIWndSetOwner(hwnd: HWND; hwndP: HWND): DWORD;

 

{-- Messages an app will send to MCIWND --------------------------------------}

 

// all the text-related messages are defined out of order above (they need

// to be defined before the MCIWndOpen() macros

 

const

   MCIWNDM_GETDEVICEID             = WM_USER + 100;

   MCIWNDM_GETSTART                = WM_USER + 103;

   MCIWNDM_GETLENGTH               = WM_USER + 104;

   MCIWNDM_GETEND                  = WM_USER + 105;

   MCIWNDM_EJECT                   = WM_USER + 107;

   MCIWNDM_SETZOOM                 = WM_USER + 108;

   MCIWNDM_GETZOOM                 = WM_USER + 109;

   MCIWNDM_SETVOLUME               = WM_USER + 110;

   MCIWNDM_GETVOLUME               = WM_USER + 111;

   MCIWNDM_SETSPEED                = WM_USER + 112;

   MCIWNDM_GETSPEED                = WM_USER + 113;

   MCIWNDM_SETREPEAT               = WM_USER + 114;

   MCIWNDM_GETREPEAT               = WM_USER + 115;

   MCIWNDM_REALIZE                 = WM_USER + 118;

   MCIWNDM_VALIDATEMEDIA           = WM_USER + 121;

   MCIWNDM_PLAYFROM                = WM_USER + 122;

   MCIWNDM_PLAYTO                  = WM_USER + 123;

   MCIWNDM_GETPALETTE              = WM_USER + 126;

   MCIWNDM_SETPALETTE              = WM_USER + 127;

   MCIWNDM_SETTIMERS               = WM_USER + 129;

   MCIWNDM_SETACTIVETIMER          = WM_USER + 130;

   MCIWNDM_SETINACTIVETIMER        = WM_USER + 131;

   MCIWNDM_GETACTIVETIMER          = WM_USER + 132;

   MCIWNDM_GETINACTIVETIMER        = WM_USER + 133;

   MCIWNDM_CHANGESTYLES            = WM_USER + 135;

   MCIWNDM_GETSTYLES               = WM_USER + 136;

   MCIWNDM_GETALIAS                = WM_USER + 137;

   MCIWNDM_PLAYREVERSE             = WM_USER + 139;

   MCIWNDM_GET_SOURCE              = WM_USER + 140;

   MCIWNDM_PUT_SOURCE              = WM_USER + 141;

   MCIWNDM_GET_DEST                = WM_USER + 142;

   MCIWNDM_PUT_DEST                = WM_USER + 143;

   MCIWNDM_CAN_PLAY                = WM_USER + 144;

   MCIWNDM_CAN_WINDOW              = WM_USER + 145;

   MCIWNDM_CAN_RECORD              = WM_USER + 146;

   MCIWNDM_CAN_SAVE                = WM_USER + 147;

   MCIWNDM_CAN_EJECT               = WM_USER + 148;

   MCIWNDM_CAN_CONFIG              = WM_USER + 149;

   MCIWNDM_PALETTEKICK             = WM_USER + 150;

   MCIWNDM_OPENINTERFACE           = WM_USER + 151;

   MCIWNDM_SETOWNER                = WM_USER + 152;

 

{-- Define both A and W messages ---------------------------------------------}

 

   MCIWNDM_SENDSTRINGA             = WM_USER + 101;

   MCIWNDM_GETPOSITIONA            = WM_USER + 102;

   MCIWNDM_GETMODEA                = WM_USER + 106;

   MCIWNDM_SETTIMEFORMATA          = WM_USER + 119;

   MCIWNDM_GETTIMEFORMATA          = WM_USER + 120;

   MCIWNDM_GETFILENAMEA            = WM_USER + 124;

   MCIWNDM_GETDEVICEA              = WM_USER + 125;

   MCIWNDM_GETERRORA               = WM_USER + 128;

   MCIWNDM_NEWA                    = WM_USER + 134;

   MCIWNDM_RETURNSTRINGA           = WM_USER + 138;

   MCIWNDM_OPENA                   = WM_USER + 153;

 

   MCIWNDM_SENDSTRINGW             = WM_USER + 201;

   MCIWNDM_GETPOSITIONW            = WM_USER + 202;

   MCIWNDM_GETMODEW                = WM_USER + 206;

   MCIWNDM_SETTIMEFORMATW          = WM_USER + 219;

   MCIWNDM_GETTIMEFORMATW          = WM_USER + 220;

   MCIWNDM_GETFILENAMEW            = WM_USER + 224;

   MCIWNDM_GETDEVICEW              = WM_USER + 225;

   MCIWNDM_GETERRORW               = WM_USER + 228;

   MCIWNDM_NEWW                    = WM_USER + 234;

   MCIWNDM_RETURNSTRINGW           = WM_USER + 238;

   MCIWNDM_OPENW                   = WM_USER + 252;

 

{-- Map defaults to A --------------------------------------------------------}

 

   MCIWNDM_SENDSTRING              = MCIWNDM_SENDSTRINGA;

   MCIWNDM_GETPOSITION             = MCIWNDM_GETPOSITIONA;

   MCIWNDM_GETMODE                 = MCIWNDM_GETMODEA;

   MCIWNDM_SETTIMEFORMAT           = MCIWNDM_SETTIMEFORMATA;

   MCIWNDM_GETTIMEFORMAT           = MCIWNDM_GETTIMEFORMATA;

   MCIWNDM_GETFILENAME             = MCIWNDM_GETFILENAMEA;

   MCIWNDM_GETDEVICE               = MCIWNDM_GETDEVICEA;

   MCIWNDM_GETERROR                = MCIWNDM_GETERRORA;

   MCIWNDM_NEW                     = MCIWNDM_NEWA;

   MCIWNDM_RETURNSTRING            = MCIWNDM_RETURNSTRINGA;

   MCIWNDM_OPEN                    = MCIWNDM_OPENA;

 

// note that the source text for MCIWND will thus contain

// support for eg MCIWNDM_SENDSTRING (both the 16-bit entrypoint and

// in win32 mapped to MCIWNDM_SENDSTRINGW), and MCIWNDM_SENDSTRINGA (the

// win32 ansi thunk).

 

{-- Messages MCIWND will send to an app --------------------------------------}

 

const

   MCIWNDM_NOTIFYMODE              = WM_USER + 200;    // wp = hwnd, lp = mode

   MCIWNDM_NOTIFYPOS               = WM_USER + 201;    // wp = hwnd, lp = pos

   MCIWNDM_NOTIFYSIZE              = WM_USER + 202;    // wp = hwnd

   MCIWNDM_NOTIFYMEDIA             = WM_USER + 203;    // wp = hwnd, lp = fn

   MCIWNDM_NOTIFYERROR             = WM_USER + 205;    // wp = hwnd, lp = error

 

{-- Special seek values for START and END ------------------------------------}

 

   MCIWND_START                    = Cardinal(-1) ;

   MCIWND_END                      = Cardinal(-2) ;

 

{== VIDEO - Video capture driver interface ===================================}

 

type

   HVIDEO                          = THandle;

   PHVIDEO                         = ^HVIDEO;

 

{-- Error return values ------------------------------------------------------}

 

const

   DV_ERR_OK                       = 0;                    // No error

   DV_ERR_BASE                     = 1;                    // Error Base

   DV_ERR_NONSPECIFIC              = DV_ERR_BASE;

   DV_ERR_BADFORMAT                = DV_ERR_BASE + 1;      // unsupported video format

   DV_ERR_STILLPLAYING             = DV_ERR_BASE + 2;      // still something playing

   DV_ERR_UNPREPARED               = DV_ERR_BASE + 3;      // header not prepared

   DV_ERR_SYNC                     = DV_ERR_BASE + 4;      // device is synchronous

   DV_ERR_TOOMANYCHANNELS          = DV_ERR_BASE + 5;      // number of channels exceeded

   DV_ERR_NOTDETECTED              = DV_ERR_BASE + 6;      // HW not detected

   DV_ERR_BADINSTALL               = DV_ERR_BASE + 7;      // Can not get Profile

   DV_ERR_CREATEPALETTE            = DV_ERR_BASE + 8;

   DV_ERR_SIZEFIELD                = DV_ERR_BASE + 9;

   DV_ERR_PARAM1                   = DV_ERR_BASE + 10;

   DV_ERR_PARAM2                   = DV_ERR_BASE + 11;

   DV_ERR_CONFIG1                  = DV_ERR_BASE + 12;

   DV_ERR_CONFIG2                  = DV_ERR_BASE + 13;

   DV_ERR_FLAGS                    = DV_ERR_BASE + 14;

   DV_ERR_13                       = DV_ERR_BASE + 15;

 

   DV_ERR_NOTSUPPORTED             = DV_ERR_BASE + 16;     // function not suported

   DV_ERR_NOMEM                    = DV_ERR_BASE + 17;     // out of memory

   DV_ERR_ALLOCATED                = DV_ERR_BASE + 18;     // device is allocated

   DV_ERR_BADDEVICEID              = DV_ERR_BASE + 19;

   DV_ERR_INVALHANDLE              = DV_ERR_BASE + 20;

   DV_ERR_BADERRNUM                = DV_ERR_BASE + 21;

   DV_ERR_NO_BUFFERS               = DV_ERR_BASE + 22;     // out of buffers

 

   DV_ERR_MEM_CONFLICT             = DV_ERR_BASE + 23;     // Mem conflict detected

   DV_ERR_IO_CONFLICT              = DV_ERR_BASE + 24;     // I/O conflict detected

   DV_ERR_DMA_CONFLICT             = DV_ERR_BASE + 25;     // DMA conflict detected

   DV_ERR_INT_CONFLICT             = DV_ERR_BASE + 26;     // Interrupt conflict detected

   DV_ERR_PROTECT_ONLY             = DV_ERR_BASE + 27;     // Can not run in standard mode

   DV_ERR_LASTERROR                = DV_ERR_BASE + 27;

 

   DV_ERR_USER_MSG                 = DV_ERR_BASE + 1000;   // Hardware specific errors

 

{-- Callback messages --------------------------------------------------------}

 

// Note that the values for all installable driver callback messages are

// identical, (ie. MM_DRVM_DATA has the same value for capture drivers,

// installable video codecs, and the audio compression manager).

 

const

   DV_VM_OPEN                      = MM_DRVM_OPEN;     // Obsolete messages

   DV_VM_CLOSE                     = MM_DRVM_CLOSE;

   DV_VM_DATA                      = MM_DRVM_DATA;

   DV_VM_ERROR                     = MM_DRVM_ERROR;

 

{== Structures ===============================================================}

 

{-- Video data block header --------------------------------------------------}

 

type

   PVIDEOHDR               = ^TVIDEOHDR;

   TVIDEOHDR               = record

       lpData              : PBYTE;                // pointer to locked data buffer

       dwBufferLength      : DWORD;                // Length of data buffer

       dwBytesUsed         : DWORD;                // Bytes actually used

       dwTimeCaptured      : DWORD;                // Milliseconds from start of stream

       dwUser              : DWORD;                // for client's use

       dwFlags             : DWORD;                // assorted flags (see defines)

       dwReserved          : array[0..3] of DWORD; // reserved for driver

   end;

 

{-- dwFlags field of VIDEOHDR ------------------------------------------------}

 

const

   VHDR_DONE                       = $00000001;    // Done bit

   VHDR_PREPARED                   = $00000002;    // Set if this header has been prepared

   VHDR_INQUEUE                    = $00000004;    // Reserved for driver

   VHDR_KEYFRAME                   = $00000008;    // Key Frame

 

{-- Channel capabilities structure -------------------------------------------}

 

type

   PCHANNEL_CAPS           = ^TCHANNEL_CAPS;

   TCHANNEL_CAPS           = record

       dwFlags             : DWORD;    // Capability flags

       dwSrcRectXMod       : DWORD;    // Granularity of src rect in x

       dwSrcRectYMod       : DWORD;    // Granularity of src rect in y

       dwSrcRectWidthMod   : DWORD;    // Granularity of src rect width

       dwSrcRectHeightMod  : DWORD;    // Granularity of src rect height

       dwDstRectXMod       : DWORD;    // Granularity of dst rect in x

       dwDstRectYMod       : DWORD;    // Granularity of dst rect in y

       dwDstRectWidthMod   : DWORD;    // Granularity of dst rect width

       dwDstRectHeightMod  : DWORD;    // Granularity of dst rect height

   end;

 

{-- dwFlags of CHANNEL_CAPS --------------------------------------------------}

 

const

   VCAPS_OVERLAY                   = $00000001;    // overlay channel

   VCAPS_SRC_CAN_CLIP              = $00000002;    // src rect can clip

   VCAPS_DST_CAN_CLIP              = $00000004;    // dst rect can clip

   VCAPS_CAN_SCALE                 = $00000008;    // allows src != dst

 

{== API flags ================================================================}

 

{-- Types of channels to open with the videoOpen function --------------------}

 

const

   VIDEO_EXTERNALIN                = $0001;

   VIDEO_EXTERNALOUT               = $0002;

   VIDEO_IN                        = $0004;

   VIDEO_OUT                       = $0008;

 

{-- Is a driver dialog available for this channel ----------------------------}

 

   VIDEO_DLG_QUERY                 = $0010;

 

{-- videoConfigure (both GET and SET) ----------------------------------------}

 

   VIDEO_CONFIGURE_QUERY           = $8000;

 

{-- videoConfigure (SET only) ------------------------------------------------}

 

   VIDEO_CONFIGURE_SET             = $1000;

 

{-- videoConfigure (GET only) ------------------------------------------------}

 

   VIDEO_CONFIGURE_GET             = $2000;

   VIDEO_CONFIGURE_QUERYSIZE       = $0001;

 

   VIDEO_CONFIGURE_CURRENT         = $0010;

   VIDEO_CONFIGURE_NOMINAL         = $0020;

   VIDEO_CONFIGURE_MIN             = $0040;

   VIDEO_CONFIGURE_MAX             = $0080;

 

{== Configure messages =======================================================}

 

   DVM_USER                        = $4000;

 

   DVM_CONFIGURE_START             = $1000;

   DVM_CONFIGURE_END               = $1FFF;

 

   DVM_PALETTE                     = DVM_CONFIGURE_START + 1;

   DVM_FORMAT                      = DVM_CONFIGURE_START + 2;

   DVM_PALETTERGB555               = DVM_CONFIGURE_START + 3;

   DVM_SRC_RECT                    = DVM_CONFIGURE_START + 4;

   DVM_DST_RECT                    = DVM_CONFIGURE_START + 5;

 

{== AVICAP - Window class for AVI capture ====================================}

 

function    AVICapSM(hwnd: HWND; m: UINT; w: WPARAM; l: LPARAM): DWORD;

 

{-- Window messages WM_CAP... which can be sent to an AVICAP window ----------}

 

// UNICODE

//

// The Win32 version of AVICAP on NT supports UNICODE applications:

// for each API or message that takes a char or string parameter, there are

// two versions, ApiNameA and ApiNameW. The default name ApiName is #defined

// to one or other depending on whether UNICODE is defined. Apps can call

// the A and W apis directly, and mix them.

//

// The 32-bit AVICAP on NT uses unicode exclusively internally.

// ApiNameA() will be implemented as a call to ApiNameW() together with

// translation of strings.

 

// Defines start of the message range

const

   WM_CAP_START                    = WM_USER;

   WM_CAP_UNICODE_START            = WM_USER + 100;

 

   WM_CAP_GET_CAPSTREAMPTR         = WM_CAP_START + 1;

 

   WM_CAP_SET_CALLBACK_ERRORW      = WM_CAP_UNICODE_START + 2;

   WM_CAP_SET_CALLBACK_STATUSW     = WM_CAP_UNICODE_START + 3;

   WM_CAP_SET_CALLBACK_ERRORA      = WM_CAP_START + 2;

   WM_CAP_SET_CALLBACK_STATUSA     = WM_CAP_START + 3;

   WM_CAP_SET_CALLBACK_ERROR       = WM_CAP_SET_CALLBACK_ERRORA;

   WM_CAP_SET_CALLBACK_STATUS      = WM_CAP_SET_CALLBACK_STATUSA;

 

   WM_CAP_SET_CALLBACK_YIELD       = WM_CAP_START + 4;

   WM_CAP_SET_CALLBACK_FRAME       = WM_CAP_START + 5;

   WM_CAP_SET_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6;

   WM_CAP_SET_CALLBACK_WAVESTREAM  = WM_CAP_START + 7;

   WM_CAP_GET_USER_DATA            = WM_CAP_START + 8;

   WM_CAP_SET_USER_DATA            = WM_CAP_START + 9;

 

   WM_CAP_DRIVER_CONNECT           = WM_CAP_START + 10;

   WM_CAP_DRIVER_DISCONNECT        = WM_CAP_START + 11;

 

   WM_CAP_DRIVER_GET_NAMEA         = WM_CAP_START + 12;

   WM_CAP_DRIVER_GET_VERSIONA      = WM_CAP_START + 13;

   WM_CAP_DRIVER_GET_NAMEW         = WM_CAP_UNICODE_START + 12;

   WM_CAP_DRIVER_GET_VERSIONW      = WM_CAP_UNICODE_START + 13;

   WM_CAP_DRIVER_GET_NAME          = WM_CAP_DRIVER_GET_NAMEA;

   WM_CAP_DRIVER_GET_VERSION       = WM_CAP_DRIVER_GET_VERSIONA;

 

   WM_CAP_DRIVER_GET_CAPS          = WM_CAP_START + 14;

 

   WM_CAP_FILE_SET_CAPTURE_FILEA   = WM_CAP_START + 20;

   WM_CAP_FILE_GET_CAPTURE_FILEA   = WM_CAP_START + 21;

   WM_CAP_FILE_SAVEASA             = WM_CAP_START + 23;

   WM_CAP_FILE_SAVEDIBA            = WM_CAP_START + 25;

   WM_CAP_FILE_SET_CAPTURE_FILEW   = WM_CAP_UNICODE_START + 20;

   WM_CAP_FILE_GET_CAPTURE_FILEW   = WM_CAP_UNICODE_START + 21;

   WM_CAP_FILE_SAVEASW             = WM_CAP_UNICODE_START + 23;

   WM_CAP_FILE_SAVEDIBW            = WM_CAP_UNICODE_START + 25;

   WM_CAP_FILE_SET_CAPTURE_FILE    = WM_CAP_FILE_SET_CAPTURE_FILEA;

   WM_CAP_FILE_GET_CAPTURE_FILE    = WM_CAP_FILE_GET_CAPTURE_FILEA;

   WM_CAP_FILE_SAVEAS              = WM_CAP_FILE_SAVEASA;

   WM_CAP_FILE_SAVEDIB             = WM_CAP_FILE_SAVEDIBA;

 

   // out of order to save on ifdefs

 

   WM_CAP_FILE_ALLOCATE            = WM_CAP_START + 22;

   WM_CAP_FILE_SET_INFOCHUNK       = WM_CAP_START + 24;

 

   WM_CAP_EDIT_COPY                = WM_CAP_START + 30;

 

   WM_CAP_SET_AUDIOFORMAT          = WM_CAP_START + 35;

   WM_CAP_GET_AUDIOFORMAT          = WM_CAP_START + 36;

 

   WM_CAP_DLG_VIDEOFORMAT          = WM_CAP_START + 41;

   WM_CAP_DLG_VIDEOSOURCE          = WM_CAP_START + 42;

   WM_CAP_DLG_VIDEODISPLAY         = WM_CAP_START + 43;

   WM_CAP_GET_VIDEOFORMAT          = WM_CAP_START + 44;

   WM_CAP_SET_VIDEOFORMAT          = WM_CAP_START + 45;

   WM_CAP_DLG_VIDEOCOMPRESSION     = WM_CAP_START + 46;

 

   WM_CAP_SET_PREVIEW              = WM_CAP_START + 50;

   WM_CAP_SET_OVERLAY              = WM_CAP_START + 51;

   WM_CAP_SET_PREVIEWRATE          = WM_CAP_START + 52;

   WM_CAP_SET_SCALE                = WM_CAP_START + 53;

   WM_CAP_GET_STATUS               = WM_CAP_START + 54;

   WM_CAP_SET_SCROLL               = WM_CAP_START + 55;

 

   WM_CAP_GRAB_FRAME               = WM_CAP_START + 60;

   WM_CAP_GRAB_FRAME_NOSTOP        = WM_CAP_START + 61;

 

   WM_CAP_SEQUENCE                 = WM_CAP_START + 62;

   WM_CAP_SEQUENCE_NOFILE          = WM_CAP_START + 63;

   WM_CAP_SET_SEQUENCE_SETUP       = WM_CAP_START + 64;

   WM_CAP_GET_SEQUENCE_SETUP       = WM_CAP_START + 65;

 

   WM_CAP_SET_MCI_DEVICEA          = WM_CAP_START + 66;

   WM_CAP_GET_MCI_DEVICEA          = WM_CAP_START + 67;

   WM_CAP_SET_MCI_DEVICEW          = WM_CAP_UNICODE_START + 66;

   WM_CAP_GET_MCI_DEVICEW          = WM_CAP_UNICODE_START + 67;

   WM_CAP_SET_MCI_DEVICE           = WM_CAP_SET_MCI_DEVICEA;

   WM_CAP_GET_MCI_DEVICE           = WM_CAP_GET_MCI_DEVICEA;

 

   WM_CAP_STOP                     = WM_CAP_START + 68;

   WM_CAP_ABORT                    = WM_CAP_START + 69;

 

   WM_CAP_SINGLE_FRAME_OPEN        = WM_CAP_START + 70;

   WM_CAP_SINGLE_FRAME_CLOSE       = WM_CAP_START + 71;

   WM_CAP_SINGLE_FRAME             = WM_CAP_START + 72;

 

   WM_CAP_PAL_OPENA                = WM_CAP_START + 80;

   WM_CAP_PAL_SAVEA                = WM_CAP_START + 81;

   WM_CAP_PAL_OPENW                = WM_CAP_UNICODE_START + 80;

   WM_CAP_PAL_SAVEW                = WM_CAP_UNICODE_START + 81;

   WM_CAP_PAL_OPEN                 = WM_CAP_PAL_OPENA;

   WM_CAP_PAL_SAVE                 = WM_CAP_PAL_SAVEA;

 

   WM_CAP_PAL_PASTE                = WM_CAP_START + 82;

   WM_CAP_PAL_AUTOCREATE           = WM_CAP_START + 83;

   WM_CAP_PAL_MANUALCREATE         = WM_CAP_START + 84;

 

   // Following added post VFW 1.1

 

   WM_CAP_SET_CALLBACK_CAPCONTROL  = WM_CAP_START + 85;

 

   // Defines end of the message range

 

   WM_CAP_UNICODE_END              = WM_CAP_PAL_SAVEW;

   WM_CAP_END                      = WM_CAP_UNICODE_END;

 

{-- Callback definitions -----------------------------------------------------}

 

type

   TCAPYIELDCALLBACK               = function(hWnd: HWND): DWORD; stdcall;

 

   TCAPSTATUSCALLBACKW             = function(hWnd: HWND; nID: int; lpsz: LPCWSTR): DWORD; stdcall;

   TCAPERRORCALLBACKW              = function(hWnd: HWND; nID: int; lpsz: LPCWSTR): DWORD; stdcall;

   TCAPSTATUSCALLBACKA             = function(hWnd: HWND; nID: int; lpsz: LPCSTR): DWORD; stdcall;

   TCAPERRORCALLBACKA              = function(hWnd: HWND; nID: int; lpsz: LPCSTR): DWORD; stdcall;

 

   TCAPSTATUSCALLBACK              = TCAPSTATUSCALLBACKA;

   TCAPERRORCALLBACK               = TCAPERRORCALLBACKA;

 

   TCAPVIDEOCALLBACK               = function(hWnd: HWND; lpVHdr: PVIDEOHDR): DWORD; stdcall;

   TCAPWAVECALLBACK                = function(hWnd: HWND; lpWHdr: PWAVEHDR): DWORD; stdcall;

   TCAPCONTROLCALLBACK             = function(hWnd: HWND; nState: int): DWORD; stdcall;

 

{-- Structures ---------------------------------------------------------------}

 

type

   PCAPDRIVERCAPS                  = ^TCAPDRIVERCAPS;

   TCAPDRIVERCAPS                  = record

       wDeviceIndex                : UINT;     // Driver index in system.ini

       fHasOverlay                 : BOOL;     // Can device overlay?

       fHasDlgVideoSource          : BOOL;     // Has Video source dlg?

       fHasDlgVideoFormat          : BOOL;     // Has Format dlg?

       fHasDlgVideoDisplay         : BOOL;     // Has External out dlg?

       fCaptureInitialized         : BOOL;     // Driver ready to capture?

       fDriverSuppliesPalettes     : BOOL;     // Can driver make palettes?

 

       // following always NULL on Win32.

       hVideoIn                    : THANDLE;   // Driver In channel

       hVideoOut                   : THANDLE;   // Driver Out channel

       hVideoExtIn                 : THANDLE;   // Driver Ext In channel

       hVideoExtOut                : THANDLE;   // Driver Ext Out channel

   end;

 

   PCAPSTATUS                      = ^TCAPSTATUS;

   TCAPSTATUS                      = record

       uiImageWidth                : UINT    ; // Width of the image

       uiImageHeight               : UINT    ; // Height of the image

       fLiveWindow                 : BOOL    ; // Now Previewing video?

       fOverlayWindow              : BOOL    ; // Now Overlaying video?

       fScale                      : BOOL    ; // Scale image to client?

       ptScroll                    : TPOINT  ; // Scroll position

       fUsingDefaultPalette        : BOOL    ; // Using default driver palette?

       fAudioHardware              : BOOL    ; // Audio hardware present?

       fCapFileExists              : BOOL    ; // Does capture file exist?

       dwCurrentVideoFrame         : DWORD   ; // # of video frames cap'td

       dwCurrentVideoFramesDropped : DWORD   ; // # of video frames dropped

       dwCurrentWaveSamples        : DWORD   ; // # of wave samples cap'td

       dwCurrentTimeElapsedMS      : DWORD   ; // Elapsed capture duration

       hPalCurrent                 : HPALETTE; // Current palette in use

       fCapturingNow               : BOOL    ; // Capture in progress?

       dwReturn                    : DWORD   ; // Error value after any operation

       wNumVideoAllocated          : UINT    ; // Actual number of video buffers

       wNumAudioAllocated          : UINT    ; // Actual number of audio buffers

   end;

 

   // Default values in parenthesis

 

   PCAPTUREPARMS                   = ^TCAPTUREPARMS;

   TCAPTUREPARMS                   = record

       dwRequestMicroSecPerFrame   : DWORD ;   // Requested capture rate

       fMakeUserHitOKToCapture     : BOOL  ;   // Show "Hit OK to cap" dlg?

       wPercentDropForError        : UINT  ;   // Give error msg if > (10%)

       fYield                      : BOOL  ;   // Capture via background task?

       dwIndexSize                 : DWORD ;   // Max index size in frames (32K)

       wChunkGranularity           : UINT  ;   // Junk chunk granularity (2K)

       fUsingDOSMemory             : BOOL  ;   // Use DOS buffers?

       wNumVideoRequested          : UINT  ;   // # video buffers, If 0, autocalc

       fCaptureAudio               : BOOL  ;   // Capture audio?

       wNumAudioRequested          : UINT  ;   // # audio buffers, If 0, autocalc

       vKeyAbort                   : UINT  ;   // Virtual key causing abort

       fAbortLeftMouse             : BOOL  ;   // Abort on left mouse?

       fAbortRightMouse            : BOOL  ;   // Abort on right mouse?

       fLimitEnabled               : BOOL  ;   // Use wTimeLimit?

       wTimeLimit                  : UINT  ;   // Seconds to capture

       fMCIControl                 : BOOL  ;   // Use MCI video source?

       fStepMCIDevice              : BOOL  ;   // Step MCI device?

       dwMCIStartTime              : DWORD ;   // Time to start in MS

       dwMCIStopTime               : DWORD ;   // Time to stop in MS

       fStepCaptureAt2x            : BOOL  ;   // Perform spatial averaging 2x

       wStepCaptureAverageFrames   : UINT  ;   // Temporal average n Frames

       dwAudioBufferSize           : DWORD ;   // Size of audio bufs (0 = default)

       fDisableWriteCache          : BOOL  ;   // Attempt to disable write cache

       AVStreamMaster              : UINT  ;   // Which stream controls length?

   end;

 

{-- AVStreamMaster -----------------------------------------------------------}

 

//  Since Audio and Video streams generally use non-synchronized capture

//  clocks, this flag determines whether the audio stream is to be considered

//  the master or controlling clock when writing the AVI file:

//

//  AVSTREAMMASTER_AUDIO  - Audio is master, video frame duration is forced

//                          to match audio duration (VFW 1.0, 1.1 default)

//  AVSTREAMMASTER_NONE   - No master, audio and video streams may be of

//                          different lengths

 

const

   AVSTREAMMASTER_AUDIO            = 0;        // Audio master (VFW 1.0, 1.1)

   AVSTREAMMASTER_NONE             = 1;        // No master

 

type

   PCAPINFOCHUNK                   = ^TCAPINFOCHUNK;

   TCAPINFOCHUNK                   = record

       fccInfoID                   : FOURCC;   // Chunk ID, "ICOP" for copyright

       lpData                      : PVOID;    // pointer to data

       cbData                      : DWORD;     // size of lpData

   end;

 

{-- CapControlCallback states ------------------------------------------------}

 

const

   CONTROLCALLBACK_PREROLL         = 1;        // Waiting to start capture

   CONTROLCALLBACK_CAPTURING       = 2;        // Now capturing

 

{-- Message crackers for above -----------------------------------------------}

 

// message wrapper macros are defined for the default messages only. Apps

// that wish to mix Ansi and UNICODE message sending will have to

// reference the _A and _W messages directly

 

function    capSetCallbackOnError(hwnd: HWND; fpProc: TCAPERRORCALLBACK): BOOL;

function    capSetCallbackOnStatus(hwnd: HWND; fpProc: TCAPSTATUSCALLBACK): BOOL;

function    capSetCallbackOnYield(hwnd: HWND; fpProc: TCAPYIELDCALLBACK): BOOL;

function    capSetCallbackOnFrame(hwnd: HWND; fpProc: TCAPVIDEOCALLBACK): BOOL;

function    capSetCallbackOnVideoStream(hwnd: HWND; fpProc: TCAPVIDEOCALLBACK): BOOL;

function    capSetCallbackOnWaveStream(hwnd: HWND; fpProc: TCAPWAVECALLBACK): BOOL;

function    capSetCallbackOnCapControl(hwnd: HWND; fpProc: TCAPCONTROLCALLBACK): BOOL;

 

function    capSetUserData(hwnd: HWND; lUser: DWORD): BOOL;

function    capGetUserData(hwnd: HWND): DWORD;

 

function    capDriverConnect(hwnd: HWND; i: INT): BOOL;

function    capDriverDisconnect(hwnd: HWND): BOOL;

function    capDriverGetName(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

function    capDriverGetVersion(hwnd: HWND; szVer: LPSTR; wSize: WORD): BOOL;

function    capDriverGetCaps(hwnd: HWND; s: PCAPDRIVERCAPS; wSize: WORD): BOOL;

 

function    capFileSetCaptureFile(hwnd: HWND; szName: LPCSTR): BOOL;

function    capFileGetCaptureFile(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

function    capFileAlloc(hwnd: HWND; dwSize: DWORD): BOOL;

function    capFileSaveAs(hwnd: HWND; szName: LPCSTR): BOOL;

function    capFileSetInfoChunk(hwnd: HWND; lpInfoChunk: PCAPINFOCHUNK): BOOL;

function    capFileSaveDIB(hwnd: HWND; szName: LPCSTR): BOOL;

 

function    capEditCopy(hwnd: HWND): BOOL;

 

function    capSetAudioFormat(hwnd: HWND; s: PWAVEFORMATEX; wSize: WORD): BOOL;

function    capGetAudioFormat(hwnd: HWND; s: PWAVEFORMATEX; wSize: WORD): DWORD;

function    capGetAudioFormatSize(hwnd: HWND): DWORD;

 

function    capDlgVideoFormat(hwnd: HWND): BOOL;

function    capDlgVideoSource(hwnd: HWND): BOOL;

function    capDlgVideoDisplay(hwnd: HWND): BOOL;

function    capDlgVideoCompression(hwnd: HWND): BOOL;

 

function    capGetVideoFormat(hwnd: HWND; s: PVOID; wSize: WORD): DWORD;

function    capGetVideoFormatSize(hwnd: HWND): DWORD;

function    capSetVideoFormat(hwnd: HWND; s: PVOID; wSize: WORD): BOOL;

 

function    capPreview(hwnd: HWND; f: BOOL): BOOL;

function    capPreviewRate(hwnd: HWND; wMS: WORD): BOOL;

function    capOverlay(hwnd: HWND; f: BOOL): BOOL;

function    capPreviewScale(hwnd: HWND; f: BOOL): BOOL;

function    capGetStatus(hwnd: HWND; s: PCAPSTATUS; wSize: WORD): BOOL;

function    capSetScrollPos(hwnd: HWND; lpP: PPOINT): BOOL;

 

function    capGrabFrame(hwnd: HWND): BOOL;

function    capGrabFrameNoStop(hwnd: HWND): BOOL;

 

function    capCaptureSequence(hwnd: HWND): BOOL;

function    capCaptureSequenceNoFile(hwnd: HWND): BOOL;

function    capCaptureStop(hwnd: HWND): BOOL;

function    capCaptureAbort(hwnd: HWND): BOOL;

 

function    capCaptureSingleFrameOpen(hwnd: HWND): BOOL;

function    capCaptureSingleFrameClose(hwnd: HWND): BOOL;

function    capCaptureSingleFrame(hwnd: HWND): BOOL;

 

function    capCaptureGetSetup(hwnd: HWND; s: PCAPTUREPARMS; wSize: WORD): BOOL;

function    capCaptureSetSetup(hwnd: HWND; s: PCAPTUREPARMS; wSize: WORD): BOOL;

 

function    capSetMCIDeviceName(hwnd: HWND; szName: LPCSTR): BOOL;

function    capGetMCIDeviceName(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

 

function    capPaletteOpen(hwnd: HWND; szName: LPCSTR): BOOL;

function    capPaletteSave(hwnd: HWND; szName: LPCSTR): BOOL;

function    capPalettePaste(hwnd: HWND): BOOL;

function    capPaletteAuto(hwnd: HWND; iFrames, iColors: INT): BOOL;

function    capPaletteManual(hwnd: HWND; fGrab: BOOL; iColors: INT): BOOL;

 

{-- The only exported functions from AVICAP.DLL ------------------------------}

 

function    capCreateCaptureWindowA(

   lpszWindowName      : LPCSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall;

 

function    capGetDriverDescriptionA(

   wDriverIndex        : UINT;

   lpszName            : LPSTR;

   cbName              : int;

   lpszVer             : LPSTR;

   cbVer               : int

   ): BOOL; stdcall;

 

function    capCreateCaptureWindowW(

   lpszWindowName      : LPCWSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall;

 

function    capGetDriverDescriptionW(

   wDriverIndex        : UINT;

   lpszName            : LPWSTR;

   cbName              : int;

   lpszVer             : LPWSTR;

   cbVer               : int

   ): BOOL; stdcall;

 

function    capCreateCaptureWindow(

   lpszWindowName      : LPCSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall; // capCreateCaptureWindowA

 

function    capGetDriverDescription(

   wDriverIndex        : UINT;

   lpszName            : LPSTR;

   cbName              : int;

   lpszVer             : LPSTR;

   cbVer               : int

   ): BOOL; stdcall; // capGetDriverDescriptionA

 

{-- New information chunk IDs ------------------------------------------------}

 

const

   infotypeDIGITIZATION_TIME       = $54494449; // mmioFOURCC ('I','D','I','T')

   infotypeSMPTE_TIME              = $504D5349; // mmioFOURCC ('I','S','M','P')

 

{-- String IDs from status and error callbacks -------------------------------}

 

   IDS_CAP_BEGIN                   = 300// "Capture Start"

   IDS_CAP_END                     = 301// "Capture End"

 

   IDS_CAP_INFO                    = 401// "%s"

   IDS_CAP_OUTOFMEM                = 402// "Out of memory"

   IDS_CAP_FILEEXISTS              = 403// "File '%s' exists -- overwrite it?"

   IDS_CAP_ERRORPALOPEN            = 404// "Error opening palette '%s'"

   IDS_CAP_ERRORPALSAVE            = 405// "Error saving palette '%s'"

   IDS_CAP_ERRORDIBSAVE            = 406// "Error saving frame '%s'"

   IDS_CAP_DEFAVIEXT               = 407// "avi"

   IDS_CAP_DEFPALEXT               = 408// "pal"

   IDS_CAP_CANTOPEN                = 409// "Cannot open '%s'"

   IDS_CAP_SEQ_MSGSTART            = 410// "Select OK to start capture\nof video sequence\nto %s."

   IDS_CAP_SEQ_MSGSTOP             = 411// "Hit ESCAPE or click to end capture"

 

   IDS_CAP_VIDEDITERR              = 412// "An error occurred while trying to run VidEdit."

   IDS_CAP_READONLYFILE            = 413// "The file '%s' is a read-only file."

   IDS_CAP_WRITEERROR              = 414// "Unable to write to file '%s'.\nDisk may be full."

   IDS_CAP_NODISKSPACE             = 415// "There is no space to create a capture file on the specified device."

   IDS_CAP_SETFILESIZE             = 416// "Set File Size"

   IDS_CAP_SAVEASPERCENT           = 417// "SaveAs: %2ld%%  Hit Escape to abort."

 

   IDS_CAP_DRIVER_ERROR            = 418// Driver specific error message

 

   IDS_CAP_WAVE_OPEN_ERROR         = 419// "Error: Cannot open the wave input device.\nCheck sample size, frequency, and channels."

   IDS_CAP_WAVE_ALLOC_ERROR        = 420// "Error: Out of memory for wave buffers."

   IDS_CAP_WAVE_PREPARE_ERROR      = 421// "Error: Cannot prepare wave buffers."

   IDS_CAP_WAVE_ADD_ERROR          = 422// "Error: Cannot add wave buffers."

   IDS_CAP_WAVE_SIZE_ERROR         = 423// "Error: Bad wave size."

 

   IDS_CAP_VIDEO_OPEN_ERROR        = 424// "Error: Cannot open the video input device."

   IDS_CAP_VIDEO_ALLOC_ERROR       = 425// "Error: Out of memory for video buffers."

   IDS_CAP_VIDEO_PREPARE_ERROR     = 426// "Error: Cannot prepare video buffers."

   IDS_CAP_VIDEO_ADD_ERROR         = 427// "Error: Cannot add video buffers."

   IDS_CAP_VIDEO_SIZE_ERROR        = 428// "Error: Bad video size."

 

   IDS_CAP_FILE_OPEN_ERROR         = 429// "Error: Cannot open capture file."

   IDS_CAP_FILE_WRITE_ERROR        = 430// "Error: Cannot write to capture file.  Disk may be full."

   IDS_CAP_RECORDING_ERROR         = 431// "Error: Cannot write to capture file.  Data rate too high or disk full."

   IDS_CAP_RECORDING_ERROR2        = 432// "Error while recording"

   IDS_CAP_AVI_INIT_ERROR          = 433// "Error: Unable to initialize for capture."

   IDS_CAP_NO_FRAME_CAP_ERROR      = 434// "Warning: No frames captured.\nConfirm that vertical sync interrupts\nare configured and enabled."

   IDS_CAP_NO_PALETTE_WARN         = 435// "Warning: Using default palette."

   IDS_CAP_MCI_CONTROL_ERROR       = 436// "Error: Unable to access MCI device."

   IDS_CAP_MCI_CANT_STEP_ERROR     = 437// "Error: Unable to step MCI device."

   IDS_CAP_NO_AUDIO_CAP_ERROR      = 438// "Error: No audio data captured.\nCheck audio card settings."

   IDS_CAP_AVI_DRAWDIB_ERROR       = 439// "Error: Unable to draw this data format."

   IDS_CAP_COMPRESSOR_ERROR        = 440// "Error: Unable to initialize compressor."

   IDS_CAP_AUDIO_DROP_ERROR        = 441// "Error: Audio data was lost during capture, reduce capture rate."

 

{-- Status string IDs --------------------------------------------------------}

 

   IDS_CAP_STAT_LIVE_MODE          = 500// "Live window"

   IDS_CAP_STAT_OVERLAY_MODE       = 501// "Overlay window"

   IDS_CAP_STAT_CAP_INIT           = 502// "Setting up for capture - Please wait"

   IDS_CAP_STAT_CAP_FINI           = 503// "Finished capture, now writing frame %ld"

   IDS_CAP_STAT_PALETTE_BUILD      = 504// "Building palette map"

   IDS_CAP_STAT_OPTPAL_BUILD       = 505// "Computing optimal palette"

   IDS_CAP_STAT_I_FRAMES           = 506// "%d frames"

   IDS_CAP_STAT_L_FRAMES           = 507// "%ld frames"

   IDS_CAP_STAT_CAP_L_FRAMES       = 508// "Captured %ld frames"

   IDS_CAP_STAT_CAP_AUDIO          = 509// "Capturing audio"

   IDS_CAP_STAT_VIDEOCURRENT       = 510// "Captured %ld frames (%ld dropped) %d.%03d sec."

   IDS_CAP_STAT_VIDEOAUDIO         = 511// "Captured %d.%03d sec.  %ld frames (%ld dropped) (%d.%03d fps).  %ld audio bytes (%d,%03d sps)"

   IDS_CAP_STAT_VIDEOONLY          = 512// "Captured %d.%03d sec.  %ld frames (%ld dropped) (%d.%03d fps)"

   IDS_CAP_STAT_FRAMESDROPPED      = 513// "Dropped %ld of %ld frames (%d.%02d%%) during capture."

 

{== FilePreview dialog =======================================================}

 

function    GetOpenFileNamePreviewA(lpofn: POPENFILENAMEA): BOOL; stdcall;

function    GetSaveFileNamePreviewA(lpofn: POPENFILENAMEA): BOOL; stdcall;

 

function    GetOpenFileNamePreviewW(lpofn: POPENFILENAMEW): BOOL; stdcall;

function    GetSaveFileNamePreviewW(lpofn: POPENFILENAMEW): BOOL; stdcall;

 

function    GetOpenFileNamePreview(lpofn: POPENFILENAMEA): BOOL; stdcall; // GetOpenFileNamePreviewA

function    GetSaveFileNamePreview(lpofn: POPENFILENAMEA): BOOL; stdcall; // GetSaveFileNamePreviewA

 

implementation

 

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

begin

   Result := (DWord(Ord(ch0))) or

             (DWord(Ord(ch1)) shl 8) or

             (DWord(Ord(ch2)) shl 16) or

             (DWord(Ord(ch3)) shl 24);

end;

 

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

begin

   Result := MKFOURCC(ch0,ch1,ch2,ch3);

end;

 

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

begin

   Result := (Word(Ord(ch0))) or

             (Word(Ord(ch1)) shl 8);

end;

 

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

 

function    ICQueryAbout(hic: HIC): BOOL;

begin

   Result := ICSendMessage(hic, ICM_ABOUT, $FFFFFFFF, ICMF_ABOUT_QUERY) = ICERR_OK;

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_ABOUT, hwnd, 0);

end;

 

function    ICQueryConfigure(hic: HIC): BOOL;

begin

   Result := ICSendMessage(hic, ICM_CONFIGURE, $FFFFFFFF, ICMF_CONFIGURE_QUERY) = ICERR_OK;

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_CONFIGURE, hwnd, 0);

end;

 

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

 

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

begin

   Result := ICSendMessage(hic, ICM_GETSTATE, DWORD(pv), cb);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_SETSTATE, DWORD(pv), cb);

end;

 

function    ICGetStateSize(hic: HIC): DWORD;

begin

   Result := ICGetState(hic, nil, 0);

end;

 

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

 

function    ICGetDefaultQuality(hic: HIC): DWORD;

begin

   ICSendMessage(hic, ICM_GETDEFAULTQUALITY, DWORD(@Result), sizeof(Result));

end;

 

function    ICGetDefaultKeyFrameRate(hic: HIC): DWORD;

begin

   ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, DWORD(@Result), sizeof(Result));

end;

 

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

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_WINDOW, DWORD(prc), sizeof(prc^));

end;

 

{-- ICCompressBegin() - start compression from a source fmt to a dest fmt ----}

 

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

begin

   Result := ICSendMessage(hic, ICM_COMPRESS_BEGIN, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

{-- ICCompressQuery() - determines if compression from src to dst is supp ----}

 

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

begin

   Result := ICSendMessage(hic, ICM_COMPRESS_QUERY, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

{-- ICCompressGetFormat() - get the output format (fmt of compressed) --------}

 

// if lpbiOutput is nil return the size in bytes needed for format.

 

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

begin

   Result := ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

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

begin

   Result := ICCompressGetFormat(hic, lpbi, nil);

end;

 

{-- ICCompressSize() - return the maximal size of a compressed frame ---------}

 

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

begin

   Result := ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

function    ICCompressEnd(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_COMPRESS_END, 0, 0);

end;

 

{-- ICDecompressBegin() - start compression from src fmt to a dest fmt -------}

 

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

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

{-- ICDecompressQuery() - determines if compression is supported -------------}

 

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

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_QUERY, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

{-- ICDecompressGetFormat - get the output fmt (fmt of uncompressed data) ----}

 

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

 

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

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

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

begin

   Result := ICDecompressGetFormat(hic, lpbi, nil);

end;

 

{-- ICDecompressGetPalette() - get the output palette ------------------------}

 

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

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, DWORD(lpbiInput), DWORD(lpbiOutput));

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, DWORD(lpbiPalette), 0);

end;

 

function    ICDecompressEnd(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0);

end;

 

{-- 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;

var

   ic : TICDECOMPRESSEX;

begin

   ic.dwFlags  := dwFlags;

   ic.lpbiSrc  := lpbiSrc;

   ic.lpSrc    := lpSrc;

   ic.xSrc     := xSrc;

   ic.ySrc     := ySrc;

   ic.dxSrc    := dxSrc;

   ic.dySrc    := dySrc;

   ic.lpbiDst  := lpbiDst;

   ic.lpDst    := lpDst;

   ic.xDst     := xDst;

   ic.yDst     := yDst;

   ic.dxDst    := dxDst;

   ic.dyDst    := dyDst;

 

   // note that ICM swaps round the length and pointer

   // length in lparam2, pointer in lparam1

   Result := ICSendMessage(hic, ICM_DECOMPRESSEX, DWORD(@ic), sizeof(ic));

end;

 

{-- ICDecompressExBegin() - start compression from a src fmt to a dest fmt ---}

 

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;

var

   ic : TICDECOMPRESSEX ;

begin

   ic.dwFlags  := dwFlags;

   ic.lpbiSrc  := lpbiSrc;

   ic.lpSrc    := lpSrc;

   ic.xSrc     := xSrc;

   ic.ySrc     := ySrc;

   ic.dxSrc    := dxSrc;

   ic.dySrc    := dySrc;

   ic.lpbiDst  := lpbiDst;

   ic.lpDst    := lpDst;

   ic.xDst     := xDst;

   ic.yDst     := yDst;

   ic.dxDst    := dxDst;

   ic.dyDst    := dyDst;

 

   // note that ICM swaps round the length and pointer

   // length in lparam2, pointer in lparam1

   Result      := ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, DWORD(@ic), sizeof(ic));

end;

 

{-- 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;

var

   ic : TICDECOMPRESSEX;

begin

   ic.dwFlags  := dwFlags;

   ic.lpbiSrc  := lpbiSrc;

   ic.lpSrc    := lpSrc;

   ic.xSrc     := xSrc;

   ic.ySrc     := ySrc;

   ic.dxSrc    := dxSrc;

   ic.dySrc    := dySrc;

   ic.lpbiDst  := lpbiDst;

   ic.lpDst    := lpDst;

   ic.xDst     := xDst;

   ic.yDst     := yDst;

   ic.dxDst    := dxDst;

   ic.dyDst    := dyDst;

 

   // note that ICM swaps round the length and pointer

   // length in lparam2, pointer in lparam1

   Result      := ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, DWORD(@ic), sizeof(ic));

end;

 

function    ICDecompressExEnd(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0)

end;

 

function    ICDrawSuggestFormat(

   hic         : HIC;

   lpbiIn      : PBITMAPINFOHEADER;

   lpbiOut     : PBITMAPINFOHEADER;

   dxSrc       : int;

   dySrc       : int;

   dxDst       : int;

   dyDst       : int;

   hicDecomp   : HIC

   ): DWORD; stdcall;

var

   ic : TICDRAWSUGGEST;

begin

   ic.lpbiIn           := lpbiIn;

   ic.lpbiSuggest      := lpbiOut;

   ic.dxSrc            := dxSrc;

   ic.dySrc            := dySrc;

   ic.dxDst            := dxDst;

   ic.dyDst            := dyDst;

   ic.hicDecompressor  := hicDecomp;

 

   // note that ICM swaps round the length and pointer

   // length in lparam2, pointer in lparam1

   Result := ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, DWORD(@ic), sizeof(ic));

end;

 

{-- ICDrawQuery() - determines if the compressor is willing to render fmt ----}

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_QUERY, DWORD(lpbiInput), 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, DWORD(lpbiInput), 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_GETBUFFERSWANTED, DWORD(lpdwBuffers), 0);

end;

 

function    ICDrawEnd(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_END, 0, 0);

end;

 

function    ICDrawStart(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_START, 0, 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_START_PLAY, lFrom, lTo);

end;

 

function    ICDrawStop(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_STOP, 0, 0);

end;

 

function    ICDrawStopPlay(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_GETTIME, DWORD(lplTime), 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_SETTIME, lTime, 0);

end;

 

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

begin

   Result := ICSendMessage(hic, ICM_DRAW_REALIZE, DWORD(hdc), DWORD(fBackground));

end;

 

function    ICDrawFlush(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0);

end;

 

function    ICDrawRenderBuffer(hic: HIC): DWORD;

begin

   Result := ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0);

end;

 

{-- ICSetStatusProc() - Set the status callback function ---------------------}

 

// ICMessage is not supported on NT

 

function    ICSetStatusProc(

   hic         : HIC;

   dwFlags     : DWORD;

   lParam      : DWORD;

   fpfnStatus  : TICStatusProc

   ): DWORD; stdcall;

var

   ic : TICSETSTATUSPROC;

begin

   ic.dwFlags  := dwFlags;

   ic.lParam   := lParam;

   ic.Status   := fpfnStatus;

 

   // note that ICM swaps round the length and pointer

   // length in lparam2, pointer in lparam1

   Result      := ICSendMessage(hic, ICM_SET_STATUS_PROC, DWORD(@ic), sizeof(ic));

end;

 

{== Helper routines for DrawDib and MCIAVI... ================================}

 

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

begin

   Result := ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS);

end;

 

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

begin

   Result := ICLocate(fccType, fccHandler, lpbiIn, nil, ICMODE_DRAW);

end;

 

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

 

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

begin

   Result  := DrawDibDraw(hdd, hdc, x, y, 0, 0, nil, nil, 0, 0, 0, 0, DDF_UPDATE);

end;

 

{== Useful macros ============================================================}

 

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

 

function    FromHex(n: BYTE): BYTE;

begin

   if n >= Ord('A') then

       Result := Ord(n) + 10 - Ord('A')

   else

       Result := Ord(n) - Ord('0');

end;

 

function    StreamFromFOURCC(fcc: DWORD): BYTE;

begin

   Result :=  (FromHex(Lo(LoWord(fcc))) shl 4) + FromHex(Hi(LoWord(fcc)));

end;

 

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

 

function    TWOCCFromFOURCC(fcc: DWORD): WORD;

begin

   Result := HiWord(fcc);

end;

 

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

 

function    ToHex(n: BYTE): BYTE;

begin

   if n > 9 then

       Result := n - 10 + Ord('A')

   else

       Result := n + Ord('0');

end;

 

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

begin

   Result := MakeLONG((ToHex(stream and $0F) shl 8) or ToHex((stream and $F0) shr 4),tcc);

end;

 

{-- Helper macros ------------------------------------------------------------}

 

function    AVIStreamSampleToSample(pavi1, pavi2: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamTimeToSample(pavi1,AVIStreamSampleToTime(pavi2, l));

end;

 

function    AVIStreamNextSample(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l+1,FIND_NEXT or FIND_ANY);

end;

 

function    AVIStreamPrevSample(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l-1,FIND_PREV or FIND_ANY);

end;

 

function    AVIStreamNearestSample(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l,FIND_PREV or FIND_ANY);

end;

 

function    AVIStreamNextKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l+1,FIND_NEXT or FIND_KEY);

end;

 

function    AVIStreamPrevKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l-1,FIND_PREV or FIND_KEY);

end;

 

function    AVIStreamNearestKeyFrame(pavi: PAVISTREAM; l: DWORD): DWORD;

begin

   Result  := AVIStreamFindSample(pavi,l,FIND_PREV or FIND_KEY)

end;

 

function    AVIStreamIsKeyFrame(pavi: PAVISTREAM; l: DWORD): BOOL;

begin

   Result  := AVIStreamNearestKeyFrame(pavi,l) = l;

end;

 

function    AVIStreamPrevSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamPrevSample(pavi,AVIStreamTimeToSample(pavi,t)));

end;

 

function    AVIStreamNextSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamNextSample(pavi,AVIStreamTimeToSample(pavi,t)));

end;

 

function    AVIStreamNearestSampleTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamNearestSample(pavi,AVIStreamTimeToSample(pavi,t)));

end;

 

function    AVIStreamNextKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamNextKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)));

end;

 

function    AVIStreamPrevKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamPrevKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)));

end;

 

function    AVIStreamNearestKeyFrameTime(pavi: PAVISTREAM; t: DWORD): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamNearestKeyFrame(pavi,AVIStreamTimeToSample(pavi, t)));

end;

 

function    AVIStreamStartTime(pavi: PAVISTREAM): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamStart(pavi));

end;

 

function    AVIStreamLengthTime(pavi: PAVISTREAM): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamLength(pavi));

end;

 

function    AVIStreamEnd(pavi: PAVISTREAM): DWORD;

begin

   Result  := AVIStreamStart(pavi) + AVIStreamLength(pavi);

end;

 

function    AVIStreamEndTime(pavi: PAVISTREAM): DWORD;

begin

   Result  := AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi));

end;

 

function    AVIStreamSampleSize(pavi: PAVISTREAM; lPos: DWORD; plSize: PDWORD): DWORD;

begin

   Result  := AVIStreamRead(pavi,lPos,1,nil,0,plSize,nil);

end;

 

function    AVIStreamFormatSize(pavi: PAVISTREAM; lPos: DWORD; plSize: PDWORD): HResult;

begin

   Result  := AVIStreamReadFormat(pavi,lPos,nil,plSize);

end;

 

function    AVIStreamDataSize(pavi: PAVISTREAM; fcc: DWORD; plSize: PDWORD): HResult;

begin

   Result  := AVIStreamReadData(pavi,fcc,nil,plSize)

end;

 

{== MCIWnd ===================================================================}

 

function    MCIWndSM(hWnd: HWND; Msg: UINT; wParam: WPARAM; lParam: LPARAM): DWORD;

begin

   Result := SendMessage(hWnd, Msg, wParam, lParam);

end;

 

{-- Can macros ---------------------------------------------------------------}

 

function    MCIWndCanPlay(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_PLAY,0,0) <> 0;

end;

 

function    MCIWndCanRecord(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_RECORD,0,0) <> 0;

end;

 

function    MCIWndCanSave(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_SAVE,0,0) <> 0;

end;

 

function    MCIWndCanWindow(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_WINDOW,0,0) <> 0;

end;

 

function    MCIWndCanEject(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_EJECT,0,0) <> 0;

end;

 

function    MCIWndCanConfig(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_CAN_CONFIG,0,0) <> 0;

end;

 

function    MCIWndPaletteKick(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd,MCIWNDM_PALETTEKICK,0,0) <> 0;

end;

 

function    MCIWndSave(hwnd: HWND; szFile: LPCSTR): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_SAVE, 0, LPARAM(szFile));

end;

 

function    MCIWndSaveDialog(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSave(hwnd, LPCSTR(-1));

end;

 

// If you dont give a device it will use the current device....

 

function    MCIWndNew(hwnd: HWND; lp: PVOID): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_NEW, 0, LPARAM(lp));

end;

 

function    MCIWndRecord(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_RECORD, 0, 0);

end;

 

function    MCIWndOpen(hwnd: HWND; sz: LPCSTR; f: BOOL): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_OPEN, WPARAM(f), LPARAM(sz));

end;

 

function    MCIWndOpenDialog(hwnd: HWND): DWORD;

begin

   Result  := MCIWndOpen(hwnd, LPCSTR(-1), False);

end;

 

function    MCIWndClose(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_CLOSE, 0, 0);

end;

 

function    MCIWndPlay(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_PLAY, 0, 0);

end;

 

function    MCIWndStop(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_STOP, 0, 0);

end;

 

function    MCIWndPause(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_PAUSE, 0, 0);

end;

 

function    MCIWndResume(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_RESUME, 0, 0);

end;

 

function    MCIWndSeek(hwnd: HWND; lPos: DWORD): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_SEEK, 0, lPos);

end;

 

function    MCIWndEject(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_EJECT, 0, 0);

end;

 

function    MCIWndHome(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSeek(hwnd, MCIWND_START);

end;

 

function    MCIWndEnd(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSeek(hwnd, MCIWND_END);

end;

 

function    MCIWndGetSource(hwnd: HWND; prc: PRECT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GET_SOURCE, 0, LPARAM(prc));

end;

 

function    MCIWndPutSource(hwnd: HWND; prc: PRECT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_PUT_SOURCE, 0, LPARAM(prc));

end;

 

function    MCIWndGetDest(hwnd: HWND; prc: PRECT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GET_DEST, 0, LPARAM(prc));

end;

 

function    MCIWndPutDest(hwnd: HWND; prc: PRECT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_PUT_DEST, 0, LPARAM(prc));

end;

 

function    MCIWndPlayReverse(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_PLAYREVERSE, 0, 0);

end;

 

function    MCIWndPlayFrom(hwnd: HWND; lPos: DWORD): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_PLAYFROM, 0, lPos);

end;

 

function    MCIWndPlayTo(hwnd: HWND; lPos: DWORD): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_PLAYTO, 0, lPos);

end;

 

function    MCIWndPlayFromTo(hwnd: HWND; lStart, lEnd: DWORD): DWORD;

begin

   MCIWndSeek(hwnd, lStart);

   Result  := MCIWndPlayTo(hwnd, lEnd);

end;

 

function    MCIWndGetDeviceID(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETDEVICEID, 0, 0);

end;

 

function    MCIWndGetAlias(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETALIAS, 0, 0);

end;

 

function    MCIWndGetMode(hwnd: HWND; lp: LPCSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETMODE, len, LPARAM(lp));

end;

 

function    MCIWndGetPosition(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETPOSITION, 0, 0);

end;

 

function    MCIWndGetPositionString(hwnd: HWND; lp: LPCSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETPOSITION, len, LPARAM(lp));

end;

 

function    MCIWndGetStart(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETSTART, 0, 0);

end;

 

function    MCIWndGetLength(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETLENGTH, 0, 0);

end;

 

function    MCIWndGetEnd(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETEND, 0, 0);

end;

 

function    MCIWndStep(hwnd: HWND; n: DWORD): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCI_STEP, 0, n);

end;

 

procedure   MCIWndDestroy(hwnd: HWND);

begin

   MCIWndSM(hwnd, WM_CLOSE, 0, 0);

end;

 

procedure   MCIWndSetZoom(hwnd: HWND; iZoom: UINT);

begin

   MCIWndSM(hwnd, MCIWNDM_SETZOOM, 0, iZoom);

end;

 

function    MCIWndGetZoom(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETZOOM, 0, 0);

end;

 

function    MCIWndSetVolume(hwnd: HWND; iVol: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SETVOLUME, 0, iVol);

end;

 

function    MCIWndGetVolume(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETVOLUME, 0, 0);

end;

 

function    MCIWndSetSpeed(hwnd: HWND; iSpeed: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SETSPEED, 0, iSpeed);

end;

 

function    MCIWndGetSpeed(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETSPEED, 0, 0);

end;

 

function    MCIWndSetTimeFormat(hwnd: HWND; lp: LPCSTR): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SETTIMEFORMAT, 0, LPARAM(lp));

end;

 

function    MCIWndGetTimeFormat(hwnd: HWND; lp: LPCSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETTIMEFORMAT, len, LPARAM(lp));

end;

 

procedure   MCIWndValidateMedia(hwnd: HWND);

begin

   MCIWndSM(hwnd, MCIWNDM_VALIDATEMEDIA, 0, 0);

end;

 

procedure   MCIWndSetRepeat(hwnd: HWND; f: BOOL);

begin

   MCIWndSM(hwnd, MCIWNDM_SETREPEAT, 0, LPARAM(f));

end;

 

function    MCIWndGetRepeat(hwnd: HWND): BOOL;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETREPEAT, 0, 0) <> 0;

end;

 

function    MCIWndUseFrames(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSetTimeFormat(hwnd, 'frames');

end;

 

function    MCIWndUseTime(hwnd: HWND): DWORD;

begin

   Result  := MCIWndSetTimeFormat(hwnd, 'ms');

end;

 

procedure   MCIWndSetActiveTimer(hwnd: HWND; active: UINT);

begin

   MCIWndSM(hwnd, MCIWNDM_SETACTIVETIMER, active, 0);

end;

 

procedure   MCIWndSetInactiveTimer(hwnd: HWND; inactive: UINT);

begin

   MCIWndSM(hwnd, MCIWNDM_SETINACTIVETIMER, inactive, 0);

end;

 

procedure   MCIWndSetTimers(hwnd: HWND; active, inactive: UINT);

begin

   MCIWndSM(hwnd, MCIWNDM_SETTIMERS, active, inactive);

end;

 

function    MCIWndGetActiveTimer(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETACTIVETIMER, 0, 0);

end;

 

function    MCIWndGetInactiveTimer(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETINACTIVETIMER, 0, 0);

end;

 

function    MCIWndRealize(hwnd: HWND; fBkgnd: BOOL): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_REALIZE, WPARAM(fBkgnd), 0);

end;

 

function    MCIWndSendString(hwnd: HWND; sz: LPCSTR): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SENDSTRING, 0, LPARAM(sz));

end;

 

function    MCIWndReturnString(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_RETURNSTRING, len, LPARAM(lp));

end;

 

function    MCIWndGetError(hwnd: HWND; lp: LPSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETERROR, len, LPARAM(lp));

end;

 

function    MCIWndGetPalette(hwnd: HWND): HPALETTE;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETPALETTE, 0, 0);

end;

 

function    MCIWndSetPalette(hwnd: HWND; hpal: HPALETTE): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SETPALETTE, hpal, 0);

end;

 

function    MCIWndGetFileName(hwnd: HWND; lp: LPCSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETFILENAME, len, LPARAM(lp));

end;

 

function    MCIWndGetDevice(hwnd: HWND; lp: LPCSTR; len: UINT): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETDEVICE, len, LPARAM(lp));

end;

 

function    MCIWndGetStyles(hwnd: HWND): UINT;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_GETSTYLES, 0, 0);

end;

 

function    MCIWndChangeStyles(hwnd: HWND; mask: UINT; value: DWORD): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_CHANGESTYLES, mask, value);

end;

 

function    MCIWndOpenInterface(hwnd: HWND; pUnk: PUNKNOWN): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_OPENINTERFACE, 0, LPARAM(pUnk));

end;

 

function    MCIWndSetOwner(hwnd: HWND; hwndP: HWND): DWORD;

begin

   Result  := MCIWndSM(hwnd, MCIWNDM_SETOWNER, hwndP, 0);

end;

 

{== AVICAP - Window class for AVI capture ====================================}

 

function    AVICapSM(hwnd: HWND; m: UINT; w: WPARAM; l: LPARAM): DWORD;

begin

   if IsWindow(hwnd) then

       Result := SendMessage(hwnd,m,w,l)

   else

       Result := 0;

end;

 

{-- Message crackers for above -----------------------------------------------}

 

function    capSetCallbackOnError(hwnd: HWND; fpProc: TCAPERRORCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_ERROR, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnStatus(hwnd: HWND; fpProc: TCAPSTATUSCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_STATUS, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnYield(hwnd: HWND; fpProc: TCAPYIELDCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_YIELD, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnFrame(hwnd: HWND; fpProc: TCAPVIDEOCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_FRAME, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnVideoStream(hwnd: HWND; fpProc: TCAPVIDEOCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnWaveStream(hwnd: HWND; fpProc: TCAPWAVECALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetCallbackOnCapControl(hwnd: HWND; fpProc: TCAPCONTROLCALLBACK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, LPARAM(@fpProc)) <> 0;

end;

 

function    capSetUserData(hwnd: HWND; lUser: DWORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_USER_DATA, 0, lUser) <> 0;

end;

 

function    capGetUserData(hwnd: HWND): DWORD;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_USER_DATA, 0, 0);

end;

 

function    capDriverConnect(hwnd: HWND; i: INT): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DRIVER_CONNECT, i, 0) <> 0;

end;

 

function    capDriverDisconnect(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DRIVER_DISCONNECT, 0, 0) <> 0;

end;

 

function    capDriverGetName(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DRIVER_GET_NAME, wSize, LPARAM(szName)) <> 0;

end;

 

function    capDriverGetVersion(hwnd: HWND; szVer: LPSTR; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DRIVER_GET_VERSION, wSize, LPARAM(szVer)) <> 0;

end;

 

function    capDriverGetCaps(hwnd: HWND; s: PCAPDRIVERCAPS; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DRIVER_GET_CAPS, wSize, LPARAM(s)) <> 0;

end;

 

function    capFileSetCaptureFile(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, LPARAM(szName)) <> 0;

end;

 

function    capFileGetCaptureFile(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, LPARAM(szName)) <> 0;

end;

 

function    capFileAlloc(hwnd: HWND; dwSize: DWORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_ALLOCATE, 0, dwSize) <> 0;

end;

 

function    capFileSaveAs(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_SAVEAS, 0, LPARAM(szName)) <> 0;

end;

 

function    capFileSetInfoChunk(hwnd: HWND; lpInfoChunk: PCAPINFOCHUNK): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_SET_INFOCHUNK, 0, LPARAM(lpInfoChunk)) <> 0;

end;

 

function    capFileSaveDIB(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_FILE_SAVEDIB, 0, LPARAM(szName)) <> 0;

end;

 

function    capEditCopy(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_EDIT_COPY, 0, 0) <> 0;

end;

 

function    capSetAudioFormat(hwnd: HWND; s: PWAVEFORMATEX; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_AUDIOFORMAT, wSize, LPARAM(s)) <> 0;

end;

 

function    capGetAudioFormat(hwnd: HWND; s: PWAVEFORMATEX; wSize: WORD): DWORD;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_AUDIOFORMAT, wSize, LPARAM(s));

end;

 

function    capGetAudioFormatSize(hwnd: HWND): DWORD;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_AUDIOFORMAT, 0, 0);

end;

 

function    capDlgVideoFormat(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0) <> 0;

end;

 

function    capDlgVideoSource(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0) <> 0;

end;

 

function    capDlgVideoDisplay(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0) <> 0;

end;

 

function    capDlgVideoCompression(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0) <> 0;

end;

 

function    capGetVideoFormat(hwnd: HWND; s: PVOID; wSize: WORD): DWORD;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_VIDEOFORMAT, wSize, LPARAM(s));

end;

 

function    capGetVideoFormatSize(hwnd: HWND): DWORD;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_VIDEOFORMAT, 0, 0);

end;

 

function    capSetVideoFormat(hwnd: HWND; s: PVOID; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_VIDEOFORMAT, wSize, LPARAM(s)) <> 0;

end;

 

function    capPreview(hwnd: HWND; f: BOOL): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_PREVIEW, WPARAM(f), 0) <> 0;

end;

 

function    capPreviewRate(hwnd: HWND; wMS: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_PREVIEWRATE, wMS, 0) <> 0;

end;

 

function    capOverlay(hwnd: HWND; f: BOOL): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_OVERLAY, WPARAM(f), 0) <> 0;

end;

 

function    capPreviewScale(hwnd: HWND; f: BOOL): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_SCALE, WPARAM(f), 0) <> 0;

end;

 

function    capGetStatus(hwnd: HWND; s: PCAPSTATUS; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_STATUS, wSize, LPARAM(s)) <> 0;

end;

 

function    capSetScrollPos(hwnd: HWND; lpP: PPOINT): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_SCROLL, 0, LPARAM(lpP)) <> 0;

end;

 

function    capGrabFrame(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GRAB_FRAME, 0, 0) <> 0;

end;

 

function    capGrabFrameNoStop(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0) <> 0;

end;

 

function    capCaptureSequence(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SEQUENCE, 0, 0) <> 0;

end;

 

function    capCaptureSequenceNoFile(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SEQUENCE_NOFILE, 0, 0) <> 0;

end;

 

function    capCaptureStop(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_STOP, 0, 0) <> 0;

end;

 

function    capCaptureAbort(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_ABORT, 0, 0) <> 0;

end;

 

function    capCaptureSingleFrameOpen(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0) <> 0;

end;

 

function    capCaptureSingleFrameClose(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0) <> 0;

end;

 

function    capCaptureSingleFrame(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SINGLE_FRAME, 0, 0) <> 0;

end;

 

function    capCaptureGetSetup(hwnd: HWND; s: PCAPTUREPARMS; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_SEQUENCE_SETUP, wSize, LPARAM(s)) <> 0;

end;

 

function    capCaptureSetSetup(hwnd: HWND; s: PCAPTUREPARMS; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_SEQUENCE_SETUP, wSize, LPARAM(s)) <> 0;

end;

 

function    capSetMCIDeviceName(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_SET_MCI_DEVICE, 0, LPARAM(szName)) <> 0;

end;

 

function    capGetMCIDeviceName(hwnd: HWND; szName: LPSTR; wSize: WORD): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_GET_MCI_DEVICE, wSize, LPARAM(szName)) <> 0;

end;

 

function    capPaletteOpen(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_PAL_OPEN, 0, LPARAM(szName)) <> 0;

end;

 

function    capPaletteSave(hwnd: HWND; szName: LPCSTR): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_PAL_SAVE, 0, LPARAM(szName)) <> 0;

end;

 

function    capPalettePaste(hwnd: HWND): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_PAL_PASTE, 0, 0) <> 0;

end;

 

function    capPaletteAuto(hwnd: HWND; iFrames, iColors: INT): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_PAL_AUTOCREATE, iFrames, iColors) <> 0;

end;

 

function    capPaletteManual(hwnd: HWND; fGrab: BOOL; iColors: INT): BOOL;

begin

   Result  := AVICapSM(hwnd, WM_CAP_PAL_MANUALCREATE, WPARAM(fGrab), iColors) <> 0;

end;

 

{== Externals ================================================================}

 

const

   VFWDLL      = 'MSVFW32.DLL';

   AVIFILDLL   = 'AVIFIL32.DLL';

   AVICAPDLL   = 'AVICAP32.DLL';

 

{-- Returns version of VFW ---------------------------------------------------}

 

function    VideoForWindowsVersion: DWord; pascal; external VFWDLL;

 

{-- Call these to start stop using VfW from your app -------------------------}

 

{ TODO: Where are these functions? }

 

// function    InitVFW: DWORD; stdcall;

// function    TermVFW: DWORD; stdcall;

 

{-- ICM function declarations ------------------------------------------------}

 

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

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

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

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

 

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

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

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

 

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

 

{== 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; external VFWDLL;

 

{== 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; external VFWDLL;

 

{== Drawing functions ========================================================}

 

{-- ICDrawBegin() - start decompressing data with fmt directly to 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; external VFWDLL;

 

{-- 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; external VFWDLL;

 

{== Helper routines for DrawDib and MCIAVI... ================================}

 

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

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

 

{== 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    : DWORD;                 // quality to use

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

   ): THANDLE; stdcall; external VFWDLL;

 

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; external VFWDLL;

 

{-- ICCompressorChoose() - 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; external VFWDLL;

 

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

procedure   ICSeqCompressFrameEnd(pc: PCOMPVARS); stdcall; external VFWDLL;

 

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; external VFWDLL;

 

procedure   ICCompressorFree(pc: PCOMPVARS); stdcall; external VFWDLL;

 

{== DrawDib functions ========================================================}

 

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

 

function    DrawDibOpen: HDRAWDIB; stdcall; external VFWDLL;

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

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

 

function    DrawDibBegin(

   hdd         : HDRAWDIB;

   hdc         : HDC;

   dxDst       : int;

   dyDst       : int;

   lpbi        : PBITMAPINFOHEADER;

   dxSrc       : int;

   dySrc       : int;

   wFlags      : UINT

   ): BOOL; stdcall; external VFWDLL;

 

{-- 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; external VFWDLL;

 

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

 

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

 

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

 

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

 

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

 

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

 

{-- Functions ----------------------------------------------------------------}

 

procedure   AVIFileInit; stdcall; external AVIFILDLL; // Call this first!

procedure   AVIFileExit; stdcall; external AVIFILDLL;

 

function    AVIFileAddRef(pfile: PAVIFILE): UDWORD; stdcall; external AVIFILDLL;

function    AVIFileRelease(pfile: PAVIFILE): UDWORD; stdcall; external AVIFILDLL;

 

function    AVIFileOpenA(var ppfile: PAVIFILE; szFile: LPCSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcall; external AVIFILDLL;

function    AVIFileOpenW(var ppfile: PAVIFILE; szFile: LPCWSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcall; external AVIFILDLL;

 

function    AVIFileOpen(var ppfile: PAVIFILE; szFile: LPCSTR; uMode: UINT; lpHandler: PCLSID): HResult; stdcallexternal AVIFILDLL name 'AVIFileOpenA';

 

function    AVIFileInfoW(pfile: PAVIFILE; pfi: PAVIFILEINFOW; lSize: DWORD): HResult; stdcall; external AVIFILDLL;

function    AVIFileInfoA(pfile: PAVIFILE; pfi: PAVIFILEINFOA; lSize: DWORD): HResult; stdcall; external AVIFILDLL;

 

function    AVIFileInfo(pfile: PAVIFILE; pfi: PAVIFILEINFOA; lSize: DWORD): HResult; stdcallexternal AVIFILDLL name 'AVIFileInfoA';

 

function    AVIFileGetStream(pfile: PAVIFILE; var ppavi: PAVISTREAM; fccType: DWORD; lParam: DWORD): HResult; stdcall; external AVIFILDLL;

 

function    AVIFileCreateStreamW(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOW): HResult; stdcall; external AVIFILDLL;

function    AVIFileCreateStreamA(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOA): HResult; stdcall; external AVIFILDLL;

 

function    AVIFileCreateStream(pfile: PAVIFILE; var ppavi: PAVISTREAM; psi: PAVISTREAMINFOA): HResult; stdcall; external AVIFILDLL name 'AVIFileCreateStreamA';

 

function    AVIFileWriteData(pfile: PAVIFILE; ckid: DWORD; lpData: PVOID; cbData: DWORD): HResult; stdcall; external AVIFILDLL;

function    AVIFileReadData(pfile: PAVIFILE; ckid: DWORD; lpData: PVOID; lpcbData: PDWORD): HResult; stdcall; external AVIFILDLL;

function    AVIFileEndRecord(pfile: PAVIFILE): HResult; stdcall; external AVIFILDLL;

 

function    AVIStreamAddRef(pavi: PAVISTREAM): UDWORD; stdcall; external AVIFILDLL;

function    AVIStreamRelease(pavi: PAVISTREAM): UDWORD; stdcall; external AVIFILDLL;

 

function    AVIStreamInfoW (pavi: PAVISTREAM; psi: PAVISTREAMINFOW; lSize: DWORD): HResult; stdcall; external AVIFILDLL;

function    AVIStreamInfoA (pavi: PAVISTREAM; psi: PAVISTREAMINFOA; lSize: DWORD): HResult; stdcall; external AVIFILDLL;

 

function    AVIStreamInfo(pavi: PAVISTREAM; psi: PAVISTREAMINFOA; lSize: DWORD): HResult; stdcall; external AVIFILDLL name 'AVIStreamInfoA';

 

function    AVIStreamFindSample(pavi: PAVISTREAM; lPos: DWORD; lFlags: DWORD): DWORD; stdcall; external AVIFILDLL;

function    AVIStreamReadFormat(pavi: PAVISTREAM; lPos: DWORD; lpFormat: PVOID; lpcbFormat: PDWORD): HResult; stdcall; external AVIFILDLL;

function    AVIStreamSetFormat(pavi: PAVISTREAM; lPos: DWORD; lpFormat: PVOID; cbFormat: DWORD): HResult; stdcall; external AVIFILDLL;

function    AVIStreamReadData(pavi: PAVISTREAM; fcc: DWORD; lp: PVOID; lpcb: PDWORD): HResult; stdcall; external AVIFILDLL;

function    AVIStreamWriteData(pavi: PAVISTREAM; fcc: DWORD; lp: PVOID; cb: DWORD): HResult; stdcall; external AVIFILDLL;

 

function    AVIStreamRead(

   pavi            : PAVISTREAM;

   lStart          : DWORD;

   lSamples        : DWORD;

   lpBuffer        : PVOID;

   cbBuffer        : DWORD;

   plBytes         : PDWORD;

   plSamples       : PDWORD

   ): HResult; stdcall; external AVIFILDLL;

 

function    AVIStreamWrite(

   pavi            : PAVISTREAM;

   lStart,

   lSamples        : DWORD;

   lpBuffer        : PVOID;

   cbBuffer        : DWORD;

   dwFlags         : DWORD;

   plSampWritten   : PDWORD;

   plBytesWritten  : PDWORD

   ): HResult; stdcall; external AVIFILDLL;

 

// Right now, these just use AVIStreamInfo() to get information, then

// return some of it.  Can they be more efficient?

 

function    AVIStreamStart(pavi: PAVISTREAM): DWORD; stdcall; external AVIFILDLL;

function    AVIStreamLength(pavi: PAVISTREAM): DWORD; stdcall; external AVIFILDLL;

function    AVIStreamTimeToSample(pavi: PAVISTREAM; lTime: DWORD): DWORD; stdcall; external AVIFILDLL;

function    AVIStreamSampleToTime(pavi: PAVISTREAM; lSample: DWORD): DWORD; stdcall; external AVIFILDLL;

 

function    AVIStreamBeginStreaming(pavi: PAVISTREAM; lStart, lEnd: DWORD; lRate: DWORD): HResult; stdcall; external AVIFILDLL;

function    AVIStreamEndStreaming(pavi: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

 

{-- Helper functions for using IGetFrame -------------------------------------}

 

function    AVIStreamGetFrameOpen(pavi: PAVISTREAM; lpbiWanted: PBITMAPINFOHEADER): PGETFRAME; stdcall; external AVIFILDLL;

function    AVIStreamGetFrame(pg: PGETFRAME; lPos: DWORD): PVOID; stdcall; external AVIFILDLL;

function    AVIStreamGetFrameClose(pg: PGETFRAME): HResult; stdcall; external AVIFILDLL;

 

// !!! We need some way to place an advise on a stream....

// STDAPI AVIStreamHasChanged   (PAVISTREAM pavi);

 

{-- Shortcut function --------------------------------------------------------}

 

function    AVIStreamOpenFromFileA(var ppavi: PAVISTREAM; szFile: LPCSTR; fccType: DWORD;

                                  lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall; external AVIFILDLL;

function    AVIStreamOpenFromFileW(var ppavi: PAVISTREAM; szFile: LPCWSTR; fccType: DWORD;

                                  lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall; external AVIFILDLL;

 

function    AVIStreamOpenFromFile(var ppavi: PAVISTREAM; szFile: LPCSTR; fccType: DWORD;

                                 lParam: DWORD; mode: UINT; pclsidHandler: PCLSID): HResult; stdcall; external AVIFILDLL name 'AVIStreamOpenFromFileA';

 

{-- Use to create disembodied streams ----------------------------------------}

 

function    AVIStreamCreate(var ppavi: PAVISTREAM; lParam1, lParam2: DWORD;

                           pclsidHandler: PCLSID): HResult; stdcall; external AVIFILDLL;

 

// PHANDLER    AVIAPI AVIGetHandler         (PAVISTREAM pavi, PAVISTREAMHANDLER psh);

// PAVISTREAM  AVIAPI AVIGetStream          (PHANDLER p);

 

{-- Stuff to support backward compat. ----------------------------------------}

 

function    AVIStreamFindKeyFrame(pavi: PAVISTREAM; lPos: DWORD; lFlags: DWORD): DWORD; stdcall; external AVIFILDLL name 'AVIStreamFindSample';

 

// Non-portable: this is alias for method name

// FindKeyFrame FindSample

 

function    AVIStreamClose(pavi: PAVISTREAM): UDWORD; stdcall; external AVIFILDLL name 'AVIStreamRelease';

function    AVIFileClose(pfile: PAVIFILE): UDWORD; stdcall; external AVIFILDLL name 'AVIFileRelease';

procedure   AVIStreamInit; stdcall; external AVIFILDLL name 'AVIFileInit';

procedure   AVIStreamExit; stdcall; external AVIFILDLL name 'AVIFileExit';

 

{== AVISave routines and structures ==========================================}

 

function    AVIMakeCompressedStream(

   var ppsCompressed   : PAVISTREAM;

   ppsSource           : PAVISTREAM;

   lpOptions           : PAVICOMPRESSOPTIONS;

   pclsidHandler       : PCLSID

   ): HResult; stdcall; external AVIFILDLL;

 

// Non-portable: uses variable number of params

// EXTERN_C HRESULT CDECL AVISaveA (LPCSTR               szFile,

//      CLSID FAR *pclsidHandler,

//      AVISAVECALLBACK     lpfnCallback,

//      int                 nStreams,

//      PAVISTREAM      pfile,

//      LPAVICOMPRESSOPTIONS lpOptions,

//      ...);

 

function    AVISaveVA(

   szFile          : LPCSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall; external AVIFILDLL;

 

// Non-portable: uses variable number of params

// EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR               szFile,

//      CLSID FAR *pclsidHandler,

//      AVISAVECALLBACK     lpfnCallback,

//      int                 nStreams,

//      PAVISTREAM      pfile,

//      LPAVICOMPRESSOPTIONS lpOptions,

//      ...);

 

function    AVISaveVW(

   szFile          : LPCWSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall; external AVIFILDLL;

 

// #define AVISave      AVISaveA

 

function    AVISaveV(

   szFile          : LPCSTR;

   pclsidHandler   : PCLSID;

   lpfnCallback    : TAVISAVECALLBACK;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): HResult; stdcall; external AVIFILDLL name 'AVISaveVA';

 

function    AVISaveOptions(

   hwnd            : HWND;

   uiFlags         : UINT;

   nStreams        : int;

   var ppavi       : PAVISTREAM;

   var plpOptions  : PAVICOMPRESSOPTIONS

   ): BOOL; stdcall; external AVIFILDLL;

 

function    AVISaveOptionsFree(nStreams: int; var plpOptions: PAVICOMPRESSOPTIONS): HResult; stdcall; external AVIFILDLL;

 

{-----------------------------------------------------------------------------}

 

function    AVIBuildFilterW(lpszFilter: LPWSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall; external AVIFILDLL;

function    AVIBuildFilterA(lpszFilter: LPSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall; external AVIFILDLL;

 

function    AVIBuildFilter(lpszFilter: LPSTR; cbFilter: DWORD; fSaving: BOOL): HResult; stdcall; external AVIFILDLL name 'AVIBuildFilterA';

 

function    AVIMakeFileFromStreams(var ppfile: PAVIFILE; nStreams: int; var papStreams: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

 

function    AVIMakeStreamFromClipboard(cfFormat: UINT; hGlobal: THANDLE; var ppstream: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

 

{-- Clipboard routines -------------------------------------------------------}

 

function    AVIPutFileOnClipboard(pf: PAVIFILE): HResult; stdcall; external AVIFILDLL;

function    AVIGetFromClipboard(var lppf: PAVIFILE): HResult; stdcall; external AVIFILDLL;

function    AVIClearClipboard: HResult; stdcall; external AVIFILDLL;

 

{-- Editing routines ---------------------------------------------------------}

 

function    CreateEditableStream(var ppsEditable: PAVISTREAM; psSource: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

 

function    EditStreamCut(pavi: PAVISTREAM; plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

function    EditStreamCopy(pavi: PAVISTREAM; plStart, plLength: PDWORD; var ppResult: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

function    EditStreamPaste(pavi: PAVISTREAM; plPos, plLength: PDWORD; pstream: PAVISTREAM; lStart, lEnd: DWORD): HResult; stdcall; external AVIFILDLL;

function    EditStreamClone(pavi: PAVISTREAM; var ppResult: PAVISTREAM): HResult; stdcall; external AVIFILDLL;

 

function    EditStreamSetNameA(pavi: PAVISTREAM; lpszName: LPCSTR): HResult; stdcall; external AVIFILDLL;

function    EditStreamSetNameW(pavi: PAVISTREAM; lpszName: LPCWSTR): HResult; stdcall; external AVIFILDLL;

function    EditStreamSetInfoW(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOW; cbInfo: DWORD): HResult; stdcall; external AVIFILDLL;

function    EditStreamSetInfoA(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOA; cbInfo: DWORD): HResult; stdcall; external AVIFILDLL;

 

function    EditStreamSetInfo(pavi: PAVISTREAM; lpInfo: PAVISTREAMINFOA; cbInfo: DWORD): HResult; stdcall; external AVIFILDLL name 'EditStreamSetInfoA';

function    EditStreamSetName(pavi: PAVISTREAM; lpszName: LPCSTR): HResult; stdcall; external AVIFILDLL name 'EditStreamSetNameA';

 

{-- MCIWnd -------------------------------------------------------------------}

 

function    MCIWndCreateA(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCSTR): HWND; cdecl; external VFWDLL;

function    MCIWndCreateW(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCWSTR): HWND; cdecl; external VFWDLL;

 

function    MCIWndCreate(hwndParent: HWND; hInstance: HINST; dwStyle: DWORd; szFile: LPCSTR): HWND; cdeclexternal VFWDLL name 'MCIWndCreateA';

 

function    MCIWndRegisterClass: BOOL; cdecl; external VFWDLL;

 

{== AVICAP - Window class for AVI capture ====================================}

 

{-- The only exported functions from AVICAP.DLL ------------------------------}

 

function    capCreateCaptureWindowA(

   lpszWindowName      : LPCSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall; external AVICAPDLL;

 

function    capGetDriverDescriptionA(

   wDriverIndex        : UINT;

   lpszName            : LPSTR;

   cbName              : int;

   lpszVer             : LPSTR;

   cbVer               : int

   ): BOOL; stdcall; external AVICAPDLL;

 

function    capCreateCaptureWindowW(

   lpszWindowName      : LPCWSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall; external AVICAPDLL;

 

function    capGetDriverDescriptionW(

   wDriverIndex        : UINT;

   lpszName            : LPWSTR;

   cbName              : int;

   lpszVer             : LPWSTR;

   cbVer               : int

   ): BOOL; stdcall; external AVICAPDLL;

 

function    capCreateCaptureWindow(

   lpszWindowName      : LPCSTR;

   dwStyle             : DWORD;

   x, y                : int;

   nWidth, nHeight     : int;

   hwndParent          : HWND;

   nID                 : int

   ): HWND; stdcall; external AVICAPDLL name 'capCreateCaptureWindowA';

 

function    capGetDriverDescription(

   wDriverIndex        : UINT;

   lpszName            : LPSTR;

   cbName              : int;

   lpszVer             : LPSTR;

   cbVer               : int

   ): BOOL; stdcall; external AVICAPDLL name 'capGetDriverDescriptionA';

 

{== FilePreview dialog =======================================================}

 

function GetOpenFileNamePreviewA(lpofn: POPENFILENAMEA): BOOL; stdcall; external VFWDLL;

function GetSaveFileNamePreviewA(lpofn: POPENFILENAMEA): BOOL; stdcall; external VFWDLL;

 

function GetOpenFileNamePreviewW(lpofn: POPENFILENAMEW): BOOL; stdcall; external VFWDLL;

function GetSaveFileNamePreviewW(lpofn: POPENFILENAMEW): BOOL; stdcall; external VFWDLL;

 

function GetOpenFileNamePreview(lpofn: POPENFILENAMEA): BOOL; stdcall; external VFWDLL name 'GetOpenFileNamePreviewA';

function GetSaveFileNamePreview(lpofn: POPENFILENAMEA): BOOL; stdcall; external VFWDLL name 'GetSaveFileNamePreviewA';

 

end.