视频聊天的问题，相关的资料太少了，问题却很多！！~~ (0分)

欢迎大家来讨论语音视频聊天的问题，相关的资料太少了，问题却很多！！~~

怎么没有人发言，介绍一些相关的书籍也好啊！

因为他们都保密...

如果不是要求特别高的话，还是比较简单的，关键是处理缓存的问题。
要求非常实时的话就很难了，反正我是搞不了。

大富翁就是讨论技术的地方，如果人人都保密，那也就是都只能拘泥于一个私人空间里，得不到深化，我还是希望大家都发表一下自己的看法，遇到的问题，大家共同进步不是更好吗！！！

在控件的选择方面也存在问题，到底那些控件比较好用，那些面临淘汰，希望高手指点
一下，让入门的人也有个方向啊~！！不至于误入歧途。

看看DirectShow 吧

语音方面只用一些WAV开头的API就行了，视频嘛，麻烦些！

音频可以用ACM压缩控件，视频有2种方式，1是传输图片，2是传输视频流，数据大多使用UDP协议传输。

视频的话用什么控件比较好啊！

视频也有一组API，在delphi的SDK里找 Video Capture 就可以看到了。

那么用delphi自带的函数，就可做了，是不是可以不用控件啊！

谢谢，我也希望大家多多支持啊！

大富翁现在怎么也是这么冷清啊！发表一下意见嘛！

最近遇到一个头疼的问题，通过回调函数采集到的视频流，发到客户端时无法回显，我尝试着将流保存为本地BMP，同样无法显示，估计是图象编码格式的问题，但是找遍了整个vfw软件包，也没有发现一个解码回显的函数，郁闷ing~~~谁帮帮我？[]

这个不知道对楼主有用没??
==============================
在许多关于视频的软件(如视频会议、可视电话等)开发中，都应用了视频捕获技术。微软为软件开发人员提供了一个专门用于视频捕获的VFW (Video for Windows) SDK。VFW SDK为在Windows系统中实现视频捕获提供了标准的接口，从而大大降低了程序的开发难度。由于VFW SDK只有VC和VB版，没有Delphi版，因此需要在Delphi中一一声明DLL中的各个函数和变量（可以参考MSDN中的VC的函数声明以及变量定义）。本文分3部分介绍如何利用VFW在Delphi中开发视频捕获程序。
VFW简介
VFW是微软公司1992年推出的关于数字视频的一个软件包，它能使应用程序通过数字化设备从传统的模拟视频源得到数字化的视频剪辑。VFW的一个关键思想是播放时不需要专用硬件，为了解决数字视频数据量大的问题，需要对数据进行压缩。它引进了一种叫AVI的文件标准，该标准未规定如何对视频进行捕获、压缩及播放，仅规定视频和音频该如何存储在硬盘上，以及在AVI文件中交替存储视频帧和与之相匹配的音频数据。VFW使程序员能通过发送消息或设置属性来捕获、播放和编辑视频剪辑。在Windows 9x系统中,当用户在安装VFW时，安装程序会自动地安装配置视频所需要的组件，如设备驱动程序、视频压缩程序等。
VFW主要由以下6个模块组成：
●AVICAP.DLL：包含执行视频捕获的函数，它给AVI文件的I/O处理和视频、音频设备驱动程序提供一个高级接口；
●MSVIDEO.DLL：包含一套特殊的DrawDib函数，用来处理屏幕上的视频操作；
●MCIAVI.DRV：包括对VFW的MCI命令解释器的驱动程序；
●AVIFILE.DLL：包含由标准多媒体I/O（mmio）函数提供的更高的命令，用来访问.AVI文件；
●压缩管理器（ICM）：用于管理的视频压缩/解压缩的编译码器（Codec）；
●音频压缩管理器ACM：提供与ICM相似的服务，适用于波形音频。
开发步骤
AVICap窗口类支持实时的视频流捕获和单帧捕获，并提供对视频源的控制。虽然MCI也提供数字视频服务(比如它为显示.AVI文件的视频提供了AVI VIDEO命令集)，为视频叠加提供了Overlay命令集，但这些命令主要是基于文件的操作，它们不能满足实时地从视频缓存中取数据的要求， 对于使用没有视频叠加能力的捕获卡的PC机来说， 用MCI提供的命令集是无法捕获视频流的。而AVICap窗口类在捕获视频方面具有一定的优势，它能直接访问视频缓冲区，不需要生成中间文件，实时性很强，效率很高。而且，它还可将数字视频捕获到一个文件中。
1.创建“捕获窗”
在进行视频捕获之前必需要先创建一个“捕获窗”，并以它为基础进行所有的捕获及设置操作。“捕获窗”用AVICap窗口类的“CapCreateCaptureWindow”函数来创建，其窗口风格一般为WS_CHILD和WS_VISIBLE。
捕获窗类似于标准控件（如按钮、列表框等），并具有下列功能：
●将视频流和音频流捕获到一个AVI文件中；
●动态地同视频和音频输入器件连接或断开；
●以Overlay或Preview模式对输入的视频流进行实时显示；
●在捕获时，可指定所用的文件名并能将捕获文件的内容拷贝到另一个文件；
●设置捕获速率；
●显示控制视频源、视频格式、视频压缩的对话框；
●创建、保存或载入调色板；
●将图像和相关的调色板拷贝到剪贴板；
●将捕获的单帧图像保存为DIB格式的文件。
2．关联捕获窗和驱动程序
单独定义的一个捕获窗是不能工作的，它必需与一个设备相关联，这样才能取得视频信号。用函数CapDriverConnect可使一个捕获窗与一个设备驱动程序相关联。
3．设置视频设备的属性
通过设置TcaptureParms结构变量的各个成员变量，可以控制设备的采样频率、中断采样按键、状态行为等等。设置好TCaptureParms结构变量后，可以用函数CapCaptureSetSetup使设置生效。之后还可以用CapPreviewScale、CapPreviewRate来设置预览的比例与速度，也可以直接使用设备的默认值。
4．打开预览
利用函数CapOverlay选择是否采用叠加模式预览，这样占用系统资源小，并且视频显示速度快。然后用CapPreview启动预览功能，这时就可以在屏幕上看到来自摄像机的图像了。
通过以上4步就可以建立一个基本的视频捕获程序。但如果想自已处理从设备捕获到的视频数据，则要使用捕获窗回调函数来处理，比如一帧一帧地获得视频数据或以流的方式获得视频数据等等。
实例编程
下面以一个一帧一帧地从视频设备上捕获视频数据的Delphi程序为例，来说明每个函数的作用以及开发过程。
该程序的功能是可以在屏幕上显视捕获到的视频，并可以获得每一帧的图像数据。
新建一个工程，并将AVICAP32.PAS包含到USES中。
在Form1上放置一个TPanel控件，设Name为“gCapVideoArea”，该控件用于显示视频。再放置两个TButton控件，一个Name为“Openvideo”，另一个Name为“Closevideo”。
定义全局变量：
var
//定义捕获窗句柄
ghCapWnd: THandle;

//可以得到视频数据指针的结构变量，用于回调函数中
VideoStr: LPVIDEOHDR;

//用于设置设备属性的结构变量
CapParms: TCaptureParms;

在Name为“Openvideo”的TButton 的Click事件中写入以下代码：
procedure TForm1.OpenvideoClick(Sender: TObject);

begin

//使用Tpanel控件来创建捕获窗口
ghCapWnd := CapCreateCaptureWindow
( PChar(‘KruwoSoft'), //捕获窗口的名字
WS_CHILD or WS_VISIBLE,//窗口样式
0, //X坐标
0, //Y坐标
gCapVideoArea.Width, //窗口宽
gCapVideoArea.Height, //窗口高
gCapVideoArea.Handle, //窗口句柄
0);
//一般为0
{为了能够捕获视频帧，要启动一个捕获帧回调函数VideoStreamCallBack。捕获一个视频流或当前设备状态时分别使用以下函数：
//捕获一个视频流
CapSetCallbackOnVideoStream;

//得到一个设备错误
CapSetCallbackOnError;

//得到一个设备状态
CapSetCallbackOnStatus
}
//定义一个帧捕获回调函数
CapSetCallbackOnFrame (ghCapWnd,LongInt(@VideoStreamCallBack));

//将一个捕获窗口与一个设备驱程相关联，第二个参数是个序号，当系统中装有多个显视驱动程序时，其值分别依次为0到总个数
CapDriverConnect(ghCapWnd, 0);

//设置设备属性的结构变量
CapParms.dwRequestMicroSecPerFrame:=40000;

CapParms.fLimitEnabled := FALSE;

CapParms.fCaptureAudio := FALSE;
// NO Audio
CapParms.fMCIControl := FALSE;

CapParms.fYield := TRUE;

CapParms.vKeyAbort := VK_ESCAPE;

CapParms.fAbortLeftMouse := FALSE;

CapParms.fAbortRightMouse := FALSE;

//使设置生效
CapCaptureSetSetup(ghCapWnd,LongInt(@CapParms),sizeof(TCAPTUREPARMS));

//设置预览时的比例
CapPreviewScale(ghCapWnd, 1);

//设置预览时的帧频率
CapPreviewRate(ghCapWnd,66);

//如果要捕获视频流，则要使用函数指定不生成文件。否则将会自动生成AVI文件
CapCaptureSequenceNoFile(ghCapWnd);

//指定是否使用叠加模式，使用为1，否则为0
CapOverlay(ghCapWnd, 1);

//打开预览
CapPreview(ghCapWnd, 1);

end;


在Name为“Closevideo”的TButton 的Click事件中写入以下代码：
procedure TForm1.ClosevideoClick(Sender: TObject);

begin

//停止捕获
capCaptureAbort(ghCapWnd);

//将捕获窗同驱动器断开
capDriverDisconnect(ghCapWnd);

end;


定义捕获帧回调函数：
function FrameCallBack(hWnd:HWND;
lpVHdr:LongInt) :LongInt;
stdcall;

var
DataPoint:^byte;

DibLen,RectWidth,RectHeight:integer;

begin

//转换从回调函数中得到的指针
VideoStr:=LPVIDEOHDR(lpVHdr);

//得到返回的数据大小
DibLen:=VideoStr^.dwBufferLength;

GetMem(DataPoint,64000);

//将帧数据COPY到一个内存中，注意DATAPOINT要先分配空间
CopyMemory(DataPoint,VideoStr^.lpData,Diblen);

//一些其他处理
……
end;


灵活地使用AVICap窗口类的回调函数可以满足各种不同的需求，但要注意从视频卡中捕获的视频数据的格式和图像的长宽要参考视频卡的参数。而且有些视频卡通过设置可支持多种的格式和图像长宽，所以在还原图像时要注意参考所用的视频卡的参数。

谢谢！我会好好研究的~！！[]

yxgszm:
回显是什么?
你的问题是不是需要关键侦重传!

哪有avicap32.pas ????
哪位大侠有 vfw.pas 文件，如有的话，可不可以mail 一份:dengzj7773_cn@sina.com
在网上下载一个不能装，老报错 line too long .
god !

unit vfw;

interface

uses
Windows, MMSystem, Messages;





const
// ------------------------------------------------------------------
// Window Messages WM_CAP... which can be sent to an AVICAP window
// ------------------------------------------------------------------

// Defines start of the message range
WM_CAP_START = WM_USER;

WM_CAP_GET_CAPSTREAMPTR = (WM_CAP_START+ 1);
WM_CAP_SET_CALLBACK_ERROR = (WM_CAP_START+ 2);
WM_CAP_SET_CALLBACK_STATUS = (WM_CAP_START+ 3);
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_NAME = (WM_CAP_START+ 12);
WM_CAP_DRIVER_GET_VERSION = (WM_CAP_START+ 13);
WM_CAP_DRIVER_GET_CAPS = (WM_CAP_START+ 14);

WM_CAP_FILE_SET_CAPTURE_FILE = (WM_CAP_START+ 20);
WM_CAP_FILE_GET_CAPTURE_FILE = (WM_CAP_START+ 21);
WM_CAP_FILE_ALLOCATE = (WM_CAP_START+ 22);
WM_CAP_FILE_SAVEAS = (WM_CAP_START+ 23);
WM_CAP_FILE_SET_INFOCHUNK = (WM_CAP_START+ 24);
WM_CAP_FILE_SAVEDIB = (WM_CAP_START+ 25);

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_DEVICE = (WM_CAP_START+ 66);
WM_CAP_GET_MCI_DEVICE = (WM_CAP_START+ 67);
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_OPEN = (WM_CAP_START+ 80);
WM_CAP_PAL_SAVE = (WM_CAP_START+ 81);
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_END = WM_CAP_SET_CALLBACK_CAPCONTROL;

// dwFlags field of TVIDEOHDR
VHDR_DONE = $00000001;
//do
ne bit */
VHDR_PREPARED= $00000002;
// Set if this header has been prepared */
VHDR_INQUEUE = $00000004;
// Reserved for driver */
VHDR_KEYFRAME= $00000008;
// Key Frame */

// ------------------------------------------------------------------
// Structures
// ------------------------------------------------------------------


type
PCapDriverCaps = ^TCapDriverCaps;
TCapDriverCaps = record
wDeviceIndex :WORD;
// 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?
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;
//do
es capture file exist?
dwCurrentVideoFrame WORD;
// # of video frames cap'td
dwCurrentVideoFramesDropped WORD;
// # of video frames dropped
dwCurrentWaveSamples WORD;
// # of wave samples cap'td
dwCurrentTimeElapsedMS WORD;
// Elapsed capture duration
hPalCurrent :HPALETTE;
// Current palette in use
fCapturingNow :BOOL;
// Capture in progress?
dwReturn WORD;
// Error value after any operation
wNumVideoAllocated :UINT;
// Actual number of video buffers
wNumAudioAllocated :UINT;
// Actual number of audio buffers
end;



pCaptureParms = ^TCaptureParms;
TCaptureParms = record // Default values in parenthesis
dwRequestMicroSecPerFrame WORD;
// 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 WORD;
// Max index size in frames (32K)
wChunkGranularity :UINT;
// Junk chunk granularity (2K)
fUsingDOSMemory :BOOL;
// Usedo
S 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 WORD;
// Time to start in MS
dwMCIStopTime WORD;
// Time to stop in MS
fStepCaptureAt2x :BOOL;
// Perform spatial averaging 2x
wStepCaptureAverageFrames :UINT;
// Temporal average n Frames
dwAudioBufferSize WORD;
// Size of audio bufs (0 = default)
fDisableWriteCache :BOOL;
// Attempt to disable write cache
AVStreamMaster :UINT;
// Which stream controls length?
end;


PCapInfoChunk = ^TCapInfoChunk;
TCapInfoChunk = record
fccInfoID :FOURCC;
// Chunk ID, "ICOP" for copyright
lpData ointer;
// pointer to data
cbData :LongInt;
// size of lpData
end;


PVIDEOHDR = ^TVIDEOHDR;
TVIDEOHDR = record
lpDataByte;
// pointer to locked data buffer
dwBufferLengthWORD;
// Length of data buffer
dwBytesUsedWORD;
// Bytes actually used
dwTimeCapturedWORD;
// Milliseconds from start of stream
dwUserWORD;
// for client's use
dwFlagsWORD;
// assorted flags (see defines)
dwReserved: array [0..4] of DWORD;
// reserved for driver
end;




// ------------------------------------------------------------------
// Callback Definitions
// ------------------------------------------------------------------
type
TCAPSTATUSCALLBACK = function(hWnd:HWND;
nID:Integer;
lpszChar):LongInt;
stdcall;
TCAPYIELDCALLBACK = function(hWnd:HWND):LongInt;
stdcall;
TCAPERRORCALLBACK = function(hWnd:HWND;
nID:Integer;
lpszchar):LongInt;
stdcall;
TCAPVIDEOSTREAMCALLBACK = function(hWnd:HWND;
lpVHdrVIDEOHDR):LongInt;
stdcall;
TCAPWAVESTREAMCALLBACK = function(hWnd:HWND;
lpWHdrWAVEHDR):LongInt;
stdcall;
TCAPCONTROLCALLBACK = function(hWnd:HWND;
nState:Integer):LongInt;
stdcall;
// ------------------------------------------------------------------
// CapControlCallback states
// ------------------------------------------------------------------
Const
CONTROLCALLBACK_PREROLL = 1; // Waiting to start capture
CONTROLCALLBACK_CAPTURING = 2;
// Now capturing





// ------------------------------------------------------------------
// Message crackers for above
// ------------------------------------------------------------------
function capSetCallbackOnError (hwnd : THandle;
fpProc:TCAPERRORCALLBACK):LongInt;
function capSetCallbackOnStatus(hwnd : THandle;
fpProc:TCAPSTATUSCALLBACK):LongInt;
function capSetCallbackOnYield (hwnd : THandle;
fpProc:TCAPYIELDCALLBACK):LongInt;
function capSetCallbackOnFrame (hwnd : THandle;
fpProc:TCAPVIDEOSTREAMCALLBACK):LongInt;
// Hier ist der Type der Callbackfunktion nicht klar !
function capSetCallbackOnVideoStream(hwnd:THandle;
fpProc:TCAPVIDEOSTREAMCALLBACK):LongInt;
function capSetCallbackOnWaveStream (hwnd:THandle;
fpProc: TCAPWAVESTREAMCALLBACK):LongInt;
function capSetCallbackOnCapControl (hwnd:THandle;
fpProc:TCAPCONTROLCALLBACK):LongInt;


function capSetUserData(hwnd:THandle;
lUser:LongInt):LongInt;
function capGetUserData(hwnd:THandle):LongInt;

function capDriverConnect(hwnd:THandle;
I: Word) : boolean;
function capDriverDisconnect(hwnd:THandle):boolean;

function capDriverGetName(hwnd:THandle;
szNameChar;
wSize:Word):boolean;
function capDriverGetVersion(hwnd:THandle;
szVerChar;
wSize:Word):Boolean;
function capDriverGetCaps(hwnd:THandle;
sCapDriverCaps;
wSize:Word):boolean;

function capFileSetCaptureFile(hwnd:THandle;
szNameChar):boolean;
function capFileGetCaptureFile(hwnd:THandle;
szNameChar;
wSize:Word):boolean;
function capFileAlloc(hwnd:THandle;
dwSizeWORD):boolean;
function capFileSaveAs(hwnd:THandle;
szNamechar):boolean;
function capFileSetInfoChunk(hwnd:THandle;
lpInfoChunkCapInfoChunk):boolean ;
function capFileSaveDIB(hwnd:THandle;
szNamechar):boolean;

function capEditCopy(hwnd : THandle):boolean;

function capSetAudioFormat(hwnd:THandle;
sWaveFormatEx;
wSize:Word):Boolean;
function capGetAudioFormat(hwnd:THandle;
sWaveFormatEx;
wSize:Word)WORD;
function capGetAudioFormatSize(hwnd:THandle)WORD;

function capDlgVideoFormat(hwnd:THandle):boolean;
function capDlgVideoSource(hwnd:THandle):boolean;
function capDlgVideoDisplay(hwnd:THandle):boolean;
function capDlgVideoCompression(hwnd:THandle):boolean;

function capGetVideoFormat(hwnd:THandle;
sBitmapInfo;
wSize:Word)Word;
function capGetVideoFormatSize(hwnd:THandle)WORD;

function capSetVideoFormat(hwnd:THandle;
sBitmapInfo;
wSize:Word):boolean;

function capPreview(hwnd:THandle;
f:boolean):boolean;
function capPreviewRate(hwnd:THandle;
wMS:Word):boolean;
function capOverlay(hwnd:THandle;
f:boolean):boolean;
function capPreviewScale(hwnd:THandle;
f:boolean):boolean;
function capGetStatus(hwnd:THandle;
sCapStatus;
wSize:Word):boolean;
function capSetScrollPos(hwnd:THandle;
lpPPoint):boolean;

function capGrabFrame(hwnd:THandle):boolean;
function capGrabFrameNoStop(hwnd:THandle):boolean;

function capCaptureSequence(hwnd:THandle):Boolean;
function capCaptureSequenceNoFile(hwnd:THandle):Boolean;
function capCaptureStop(hwnd:THandle):boolean;
function capCaptureAbort(hwnd:THandle):boolean;

function capCaptureSingleFrameOpen(hwnd:THandle):boolean;
function capCaptureSingleFrameClose(hwnd:THandle):boolean;
function capCaptureSingleFrame(hwnd:THandle):boolean;

function capCaptureGetSetup(hwnd:THandle;
sCaptureParms;
wSize:Word):boolean;
function capCaptureSetSetup(hwnd:THandle;
sCaptureParms;
wSize:Word):boolean;

function capSetMCIDeviceName(hwnd:THandle;
szNameChar):boolean;
function capGetMCIDeviceName(hwnd:THandle;
szNameChar;
wSize:Word):boolean;

function capPaletteOpen(hwnd:THandle;
szNameChar):boolean;
function capPaletteSave(hwnd:THandle;
szNameChar):boolean;
function capPalettePaste(hwnd:THandle):Boolean;
function capPaletteAuto(hwnd:THandle;
iFrames:Word;
iColors:word):boolean;
function capPaletteManual(hwnd:THandle;
fGrab:Word;
iColors:word):boolean;






// ------------------------------------------------------------------
// The only exported functions from AVICAP.DLL
// ------------------------------------------------------------------
function capCreateCaptureWindow (
lpszWindowName : PChar;
dwStyle : DWord;
x, y : Integer;
nWidth, nHeight : Integer;
hwndParent : THandle;
nID : Integer ) : THandle;
stdcall;

function capGetDriverDescription (
wDriverIndex : DWord;
lpszName : PChar;
cbName : Integer;
lpszVer : PChar;
cbVer : Integer ) : Boolean;
stdcall;

// ------------------------------------------------------------------
// New Information chunk IDs
// ------------------------------------------------------------------
(*
infotypeDIGITIZATION_TIME = mmioStringToFOURCC(PChar('IDIT'), MMIO_TOUPPER);
infotypeSMPTE_TIME = mmioStringToFOURCC(PChar('ISMP'), MMIO_TOUPPER);
*)

// ------------------------------------------------------------------
// String IDs from status and error callbacks
// ------------------------------------------------------------------
Const
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." *)



{== 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;
//do
nt 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): Pointer;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: integer;
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 : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
dxSrc : integer;
dySrc : integer;
wFlags : UINT
): BOOL;
stdcall;

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

function DrawDibDraw(
hdd : HDRAWDIB;
hdc : HDC;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
lpBits : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
wFlags : UINT
): BOOL;
stdcall;

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

//function DrawDibUpdate(hdd: HDRAWDIB;
hdc: HDC;
x, y: integer): BOOL;stdcall;

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

// Helper fucntion for FOURCC

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(TICOPEN)
fccType : DWORD ;
// 'vidc'
fccHandler : DWORD ;
//
dwVersion : DWORD ;
// version of compman opening you
dwFlags : DWORD ;
// LOWORD is type specific
dwError : DWORD ;
// error return.
pV1Reserved : Pointer ;
// Reserved
pV2Reserved : Pointer ;
// Reserved
dnDevNode : DWORD ;
// Devnode for PnP devices
end;


{-----------------------------------------------------------------------------}

PICINFO = ^TICINFO ;
TICINFO = record
dwSize : DWORD;
// sizeof(TICINFO)
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 ;
//do
es not need prev frame on compress
VIDCF_FASTTEMPORALD = $0080 ;
//do
es 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 : Pointer ;
// output data

lpbiInput : PBITMAPINFOHEADER ;
// format of frame to compress
lpInput : Pointer ;
// 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 : Pointer ;
// previous frame
end;


{-----------------------------------------------------------------------------}

const
ICCOMPRESSFRAMES_PADDING = $00000001 ;

type
TICCompressProc = function(lInput: LPARAM;
lFrame: DWORD;
lpBits: Pointer;
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 = %do
ne
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 ;
//do
n't draw just buffer (hurry up!)
ICDECOMPRESS_UPDATE = $40000000 ;
//do
n'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 : Pointer ;
// compressed data
lpbiOutput : PBITMAPINFOHEADER ;
// DIB to decompress to
lpOutput : Pointer ;
ckid : DWORD ;
// ckid from AVI file
end;


PICDECOMPRESSEX = ^TICDECOMPRESSEX;
TICDECOMPRESSEX = record

//
// same as ICM_DECOMPRESS
//

dwFlags : DWORD;
lpbiSrc : PBITMAPINFOHEADER;
// BITMAPINFO of compressed data
lpSrc : Pointer;
// compressed data
lpbiDst : PBITMAPINFOHEADER;
// DIB to decompress to
lpDst : Pointer;
// output data

//
// new for ICM_DECOMPRESSEX
//

xDst : integer ;
// destination rectangle
yDst : integer ;
dxDst : integer ;
dyDst : integer ;

xSrc : integer ;
// source rectangle
ySrc : integer ;
dxSrc : integer ;
dySrc : integer ;
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 : integer ;
// destination rectangle
yDst : integer ;
dxDst : integer ;
dyDst : integer ;

lpbi : PBITMAPINFOHEADER ;
// format of frame to draw

xSrc : integer ;
// source rectangle
ySrc : integer ;
dxSrc : integer ;
dySrc : integer ;

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


{-----------------------------------------------------------------------------}

const
ICDRAW_HURRYUP = $80000000 ;
//do
n't draw just buffer (hurry up!)
ICDRAW_UPDATE = $40000000 ;
//do
n'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 : Pointer ;
// format of frame to decompress
lpData : Pointer ;
// 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 : integer ;
// source extent or 0
dySrc : integer ;
dxDst : integer ;
// dest extent or 0
dyDst : integer ;
hicDecompressor : HIC ;
// decompressor you can talk to
end;


{-----------------------------------------------------------------------------}

PICPALETTE = ^TICPALETTE;
TICPALETTE = record
dwFlags : DWORD ;
// flags (from AVI index...)
iStart : integer ;
// first palette to change
iLen : integer ;
// 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: integer) : 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: Pointer;
cb: DWORD): DWORD;
function ICSetState(hic: HIC;
pv: Pointer;
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 : Pointer;
// output data
lpbiInput : PBITMAPINFOHEADER;
// format of frame to compress
lpBits : Pointer;
// 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 : Pointer // 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 : Pointer;
// data
lpbi : PBITMAPINFOHEADER;
// DIB to decompress to
lpBits : Pointer
): 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 : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): DWORD;
stdcall;

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

function ICDecompressExbegin
(
hic : HIC;
dwFlags : DWORD;
lpbiSrc : PBITMAPINFOHEADER;
lpSrc : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): DWORD;
stdcall;

{-- ICDecompressExQuery() ----------------------------------------------------}

function ICDecompressExQuery(
hic : HIC;
dwFlags : DWORD;
lpbiSrc : PBITMAPINFOHEADER;
lpSrc : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): 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 : integer;
// destination rectangle
yDst : integer;
dxDst : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
// format of frame to draw
xSrc : integer;
// source rectangle
ySrc : integer;
dxSrc : integer;
dySrc : integer;
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 : Pointer;
// format of frame to decompress
lpData : Pointer;
// 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
// todo
the same job

function ICDrawSuggestFormat(
hic : HIC;
lpbiIn : PBITMAPINFOHEADER;
lpbiOut : PBITMAPINFOHEADER;
dxSrc : integer;
dySrc : integer;
dxDst : integer;
dyDst : integer;
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: integer;
dx, dy: integer): 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 : Pointer;
// 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 : Pointer;
// 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 : Pointer;
lpBitsPrev : Pointer;
lFrame : DWORD;
lKey : DWORD;
// key frames how often?
lDataRate : DWORD;
// desired data rate KB/Sec
lQ : DWORD;
// desired quality
lKeyCount : DWORD;
lpState : Pointer;
// 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 : Pointer;
// input format (optional)
lpData : Pointer;
// 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;
//do
n'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 : Pointer;
// input DIB bits
pfKey : PBOOL;
// did it end up being a key frame?
plSize : PDWORD // size to compress to/of returned image
): Pointer;
stdcall;

procedure ICCompressorFree(pc: PCOMPVARS);
stdcall;























implementation

// Dlls

const
AVICAP32 = 'AVICAP32.dll';
VFWDLL = 'MSVFW32.DLL';




(* Externals from AVICAP.DLL *)
function capGetDriverDescription;
external AVICAP32 name 'capGetDriverDescriptionA';
function capCreateCaptureWindow;
external AVICAP32 name 'capCreateCaptureWindowA';


(* Message crackers for above *)
function capSetCallbackOnError(hwnd : THandle;
fpProc:TCAPERRORCALLBACK) : LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_ERROR, 0,LPARAM(@fpProc));
end;


function capSetCallbackOnStatus(hwnd : THandle;
fpProc:TCAPSTATUSCALLBACK):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_STATUS, 0, LPARAM(@fpProc));
end;


function capSetCallbackOnYield (hwnd : THandle;
fpProc:TCAPYIELDCALLBACK):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_YIELD, 0, LPARAM(@fpProc));
end;


function capSetCallbackOnFrame (hwnd : THandle;
fpProc:TCAPVIDEOSTREAMCALLBACK):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_FRAME, 0,LPARAM( @fpProc));
end;


function capSetCallbackOnVideoStream(hwnd:THandle;
fpProc:TCAPVIDEOSTREAMCALLBACK):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, LPARAM(@fpProc));
end;


function capSetCallbackOnWaveStream (hwnd:THandle;
fpProc:TCAPWAVESTREAMCALLBACK):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, LPARAM(@fpProc));
end;


function capSetCallbackOnCapControl (hwnd:THandle;
fpProc:TCAPCONTROLCALLBACK):longint;
begin

Result := SendMessage(hwnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, LPARAM(@fpProc));
end;


function capSetUserData(hwnd:THandle;
lUser:LongInt):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_SET_USER_DATA, 0, lUser);
end;


function capGetUserData(hwnd:THandle):LongInt;
begin

Result := SendMessage(hwnd, WM_CAP_GET_USER_DATA, 0, 0);
end;


function capDriverConnect(hwnd:THandle;
I: Word) : boolean;
begin

Result :=boolean( SendMessage(hwnd, WM_CAP_DRIVER_CONNECT, WPARAM(I), 0));
end;


function capDriverDisconnect(hwnd:THandle):Boolean;
begin

Result := boolean(SendMessage(hwnd, WM_CAP_DRIVER_DISCONNECT, 0, 0));
end;


function capDriverGetName(hwnd:THandle;
szNameChar;
wSize:Word):boolean;
begin

Result :=boolean( SendMessage(hwnd, WM_CAP_DRIVER_GET_NAME, WPARAM(wSize), LPARAM( szName)));
end;


function capDriverGetVersion(hwnd:THandle;
szVerChar;
wSize:Word):boolean;
begin

Result :=boolean( SendMessage(hwnd, WM_CAP_DRIVER_GET_VERSION, WPARAM(wSize),LPARAM( szVer)));
end;


function capDriverGetCaps(hwnd:THandle;
sCapDriverCaps;
wSize:Word):boolean;
begin

Result := boolean(SendMessage(hwnd, WM_CAP_DRIVER_GET_CAPS, WPARAM(wSize),LPARAM(s)));
end;


function capFileSetCaptureFile(hwnd:THandle;
szNameChar):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, LPARAM(szName)));
end;


function capFileGetCaptureFile(hwnd:THandle;
szNameChar;
wSize:Word):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, LPARAM(szName)));
end;


function capFileAlloc(hwnd:THandle;
dwSizeWord):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_FILE_ALLOCATE, 0, LPARAM(dwSize)));
end;


function capFileSaveAs(hwnd:THandle;
szNamechar):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_FILE_SAVEAS, 0,LPARAM(szName)));
end;


function capFileSetInfoChunk(hwnd:THandle;
lpInfoChunkCapInfoChunk):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_FILE_SET_INFOCHUNK, 0, LPARAM(lpInfoChunk)));
end;


function capFileSaveDIB(hwnd:THandle;
szNamechar):Boolean;
begin

Result :=Boolean(SendMessage(hwnd, WM_CAP_FILE_SAVEDIB, 0,LPARAM(szName)));
end;


function capEditCopy(hwnd : THandle):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_EDIT_COPY, 0, 0));
end;


function capSetAudioFormat(hwnd:THandle;
sWaveFormatEx;
wSize:Word):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_AUDIOFORMAT, WPARAM(wSize),LPARAM(s)));
end;


function capGetAudioFormat(hwnd:THandle;
sWaveFormatEx;
wSize:Word)WORD;
begin

Result :=DWORD( SendMessage(hwnd, WM_CAP_GET_AUDIOFORMAT, WPARAM(wSize),LPARAM(s)));
end;


function capGetAudioFormatSize(hwnd:THandle)WORD;
begin

Result := DWORD(SendMessage(hwnd, WM_CAP_GET_AUDIOFORMAT, 0, 0));
end;


function capDlgVideoFormat(hwnd:THandle):boolean;
begin

Result :=boolean(SendMessage(hwnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0));
end;


function capDlgVideoSource(hwnd:THandle):boolean;
begin

Result :=boolean (SendMessage(hwnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0));
end;


function capDlgVideoDisplay(hwnd:THandle):boolean;
begin

Result := boolean(SendMessage(hwnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0));
end;


function capDlgVideoCompression(hwnd:THandle):boolean;
begin

Result := boolean(SendMessage(hwnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0));
end;


function capGetVideoFormat(hwnd:THandle;
sBitmapInfo;
wSize:Word)Word;
begin

Result := DWord(SendMessage(hwnd, WM_CAP_GET_VIDEOFORMAT, Wparam(wSize), LPARAM(s)));
end;


function capGetVideoFormatSize(hwnd:THandle)Word;
begin

Result := DWord(SendMessage(hwnd, WM_CAP_GET_VIDEOFORMAT, 0, 0));
end;


function capSetVideoFormat(hwnd:THandle;
sBitmapInfo;
wSize:Word):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_VIDEOFORMAT, WPARAM(wSize), LPARAM(s)));
end;


function capPreview(hwnd:THandle;
f:boolean):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_PREVIEW, WPARAM(f), 0));
end;


function capPreviewRate(hwnd:THandle;
wMS:Word):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_PREVIEWRATE, WPARAM(wMS), 0));
end;


function capOverlay(hwnd:THandle;
f:boolean):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_OVERLAY, WPARAM(f), 0));
end;


function capPreviewScale(hwnd:THandle;
f:boolean):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_SCALE,WPARAM(f), 0));
end;


function capGetStatus(hwnd:THandle;
sCapStatus;
wSize:Word):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_GET_STATUS, WPARAM(wSize),LPARAM(s)));
end;


function capSetScrollPos(hwnd:THandle;
lpPPoint):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SET_SCROLL, 0, LParam(lpP)));
end;


function capGrabFrame(hwnd:THandle):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_GRAB_FRAME, 0, 0));
end;


function capGrabFrameNoStop(hwnd:THandle):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0));
end;


function capCaptureSequence(hwnd:THandle):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SEQUENCE, 0, 0));
end;


function capCaptureSequenceNoFile(hwnd:THandle):boolean;
begin

Result :=Boolean(SendMessage(hwnd, WM_CAP_SEQUENCE_NOFILE, 0, 0));
end;


function capCaptureStop(hwnd:THandle):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_STOP, 0, 0));
end;


function capCaptureAbort(hwnd:THandle):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_ABORT, 0, 0));
end;


function capCaptureSingleFrameOpen(hwnd:THandle):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0));
end;


function capCaptureSingleFrameClose(hwnd:THandle):boolean ;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0));
end;


function capCaptureSingleFrame(hwnd:THandle):boolean;
begin

Result :=Boolean(SendMessage(hwnd, WM_CAP_SINGLE_FRAME, 0, 0));
end;


function capCaptureGetSetup(hwnd:THandle;
sCaptureParms;
wSize:Word):boolean;
begin

Result :=Boolean( SendMessage(hwnd, WM_CAP_GET_SEQUENCE_SETUP, WPARAM(wSize),LPARAM(s)));
end;


function capCaptureSetSetup(hwnd:THandle;
sCaptureParms;
wSize:Word):boolean;
begin

Result := Boolean (SendMessage(hwnd, WM_CAP_SET_SEQUENCE_SETUP, WParam(wSize),LParam(s)));
end;


function capSetMCIDeviceName(hwnd:THandle;
szNamechar):Boolean;
begin

Result :=Boolean( SendMessage(hwnd, WM_CAP_SET_MCI_DEVICE, 0, LParam(szName)));
end;


function capGetMCIDeviceName(hwnd:THandle;
szNamechar;
wSize:Word):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_GET_MCI_DEVICE, Wparam(wSize), LPARAM(szName)));
end;


function capPaletteOpen(hwnd:THandle;
szNameChar):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_PAL_OPEN, 0, LParam(szName)));
end;


function capPaletteSave(hwnd:THandle;
szNameChar):boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_PAL_SAVE, 0,LParam(szName)));
end;


function capPalettePaste(hwnd:THandle):Boolean;
begin

Result :=Boolean( SendMessage(hwnd, WM_CAP_PAL_PASTE, 0, 0));
end;


function capPaletteAuto(hwnd:THandle;
iFrames:Word;
iColors:word):Boolean;
begin

Result :=Boolean( SendMessage(hwnd, WM_CAP_PAL_AUTOCREATE, WPARAM(iFrames),LPARAM(iColors)));
end;


function capPaletteManual(hwnd:THandle;
fGrab:Word;
iColors:word):Boolean;
begin

Result := Boolean(SendMessage(hwnd, WM_CAP_PAL_MANUALCREATE, WPARAM(fGrab),LPARAM(iColors)));
end;



{== 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): Pointer;
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: integer;
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 : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
dxSrc : integer;
dySrc : integer;
wFlags : UINT
): BOOL;
stdcall;
external VFWDLL;

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

function DrawDibDraw(
hdd : HDRAWDIB;
hdc : HDC;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
lpBits : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
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;




// Installable Compression Manager

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, -1, 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, -1, 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: Pointer;
cb: DWORD): DWORD;
begin

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


function ICSetState(hic: HIC;
pv: Pointer;
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;


{-- 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: integer) : DWORD ;
stdcall ;
external VFWDLL;

{== Compression functions ====================================================}

{-- ICCompress() - compress a single frame -----------------------------------}

function ICCompress(
hic : HIC;
dwFlags : DWORD;
// flags
lpbiOutput : PBITMAPINFOHEADER;
// output format
lpData : Pointer;
// output data
lpbiInput : PBITMAPINFOHEADER;
// format of frame to compress
lpBits : Pointer;
// 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 : Pointer // 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 : Pointer;
// data
lpbi : PBITMAPINFOHEADER;
// DIB to decompress to
lpBits : Pointer
): 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 : integer;
// destination rectangle
yDst : integer;
dxDst : integer;
dyDst : integer;
lpbi : PBITMAPINFOHEADER;
// format of frame to draw
xSrc : integer;
// source rectangle
ySrc : integer;
dxSrc : integer;
dySrc : integer;
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 : Pointer;
// format of frame to decompress
lpData : Pointer;
// 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: integer;
dx, dy: integer): 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 : Pointer;
// 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 : Pointer;
// 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 : Pointer;
// input format (optional)
lpData : Pointer;
// 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 : Pointer;
// input DIB bits
pfKey : PBOOL;
// did it end up being a key frame?
plSize : PDWORD // size to compress to/of returned image
): Pointer;
stdcall;
external VFWDLL;

procedure ICCompressorFree(pc: PCOMPVARS);
stdcall;
external VFWDLL;

{-- ICDecompressEx() - decompress a single frame -----------------------------}

function ICDecompressEx(
hic : HIC;
dwFlags : DWORD;
lpbiSrc : PBITMAPINFOHEADER;
lpSrc : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): 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 : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): 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 : Pointer;
xSrc : integer;
ySrc : integer;
dxSrc : integer;
dySrc : integer;
lpbiDst : PBITMAPINFOHEADER;
lpDst : Pointer;
xDst : integer;
yDst : integer;
dxDst : integer;
dyDst : integer
): 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 : integer;
dySrc : integer;
dxDst : integer;
dyDst : integer;
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;



end.

問題真的不少,我想現在比軟成熟的是msn,icq,qq,netmetting的語音聊天了,但看來都不是用delphi做的,不知有沒有人真的用delphi做過??