dllentry.c

OK视频采集卡VC源代码

/*==============================================================================
*
*       filename        dllentry.c
*       purpose         API for dynamic loading okapi32.dll (Ok series image cards)
*       language        Microsoft Visual C 5.0
*       author          S. Yang
*       date            mon-date-99
*-----------------------
*       modify by       S. Yang
*       purpose         
*       language        Microsoft Visual C 5.0 
*       date            99
*
*-----------------------
*
*		Copyright (C).  All Rights Reserved.
*
*
*==============================================================================
*       language include files
*/


#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#include <dos.h>
#include <memory.h>
#include <time.h>
#include<windows.h>


#include "okapi32.h"


/*-----------------------------------------------------------------------------
*       Functions Pointors
*/


//1. section

HANDLE	(WINAPI *lpfnOpenBoard)(long *);
BOOL	(WINAPI *lpfnCloseBoard)(HANDLE);
long	(WINAPI *lpfnGetLastError)(void);
long	(WINAPI *lpfnGetBufferSize)(HANDLE hBoard, void **lpLinear, DWORD *dwSize);
LPVOID 	(WINAPI *lpfnGetBufferAddr)(HANDLE hBoard, long iNoFrame);
LPVOID  (WINAPI *lpfnGetTargetInfo)(HANDLE hBoard, TARGET tgt, long lNoFrame, short * wid, short * ht, long *stride);
long	(WINAPI *lpfnGetTypeCode)(HANDLE hBoard,LPSTR lpBoardName);

long	(WINAPI *lpfnSetTargetRect)(HANDLE hBoard, TARGET target, LPRECT lpTgtRect);
BOOL	(WINAPI *lpfnSetToWndRect)(HANDLE hBoard, HWND hWnd);
long	(WINAPI *lpfnSetVideoParam)(HANDLE hBoard, WORD wParam, long lParam);
long	(WINAPI *lpfnSetCaptureParam)(HANDLE hBoard, WORD wParam, long lParam);
BOOL	(WINAPI *lpfnSetSeqCallback)(HANDLE hBoard, 
								BOOL CALLBACK BeginProc(HANDLE hBoard), 
								BOOL CALLBACK SeqProc(HANDLE hBoard, long No), 
								BOOL CALLBACK EndProc(HANDLE hBoard));
BOOL	(WINAPI *lpfnCaptureTo)(HANDLE hBoard, TARGET Dest, long start, LPARAM lParam);
BOOL	(WINAPI *lpfnCaptureSingle)(HANDLE hBoard, TARGET Dest, LONG lStart);
BOOL	(WINAPI *lpfnCaptureActive)(HANDLE hBoard, TARGET Dest, LONG lStart);
BOOL	(WINAPI *lpfnCaptureThread)(HANDLE hBoard, TARGET Dest, LONG lStart, LONG lNoFrame);
BOOL	(WINAPI *lpfnCaptureSequence)(HANDLE hBoard, LONG lStart, LONG lNoFrame);

BOOL	(WINAPI *lpfnCaptureToScreen)(HANDLE hBoard);
BOOL	(WINAPI *lpfnPlaybackFrom)(HANDLE hBoard, TARGET src, long start, LPARAM lParam);
BOOL	(WINAPI *lpfnPlaybackSequence)(HANDLE hBoard, LONG lStart, LONG lNoFrame);

long	(WINAPI *lpfnGetCaptureStatus)(HANDLE hBoard, BOOL bWait);
BOOL	(WINAPI *lpfnStopCapture)(HANDLE hBoard);

long	(WINAPI *lpfnGetSeqCapture)(HANDLE hApi, long start, long count);

BOOL	(WINAPI *lpfnCaptureByBuffer)(HANDLE hBoard, TARGET dest, long start, long num);
BOOL	(WINAPI *lpfnCaptureByBufferEx)(HANDLE hBoard, long fileset, TARGET dest, long start, long num);
BOOL	(WINAPI *lpfnPlaybackByBuffer)(HANDLE hBoard, TARGET src, long start, long num);


long	(WINAPI *lpfnReadPixel)(HANDLE hBoard, TARGET src, long start, short x, short y);
long	(WINAPI *lpfnWritePixel)(HANDLE hBoard, TARGET tgt, long start, short x, short y, long lValue);

long	(WINAPI *lpfnSetConvertParam)(HANDLE hBoard, WORD wParam, long lParam);
long	(WINAPI *lpfnReadRect)(HANDLE hBoard, TARGET src, long start, LPBYTE lpBuf);
long	(WINAPI *lpfnWriteRect)(HANDLE hBoard, TARGET dst, long start, LPBYTE lpBuf);
long	(WINAPI *lpfnTransferRect)(HANDLE hBoard, TARGET dest, long iFirst, TARGET src, long iStart, long lNum);
long	(WINAPI *lpfnConvertRect)(HANDLE hBoard, TARGET dst, long first, TARGET src, long start, LPARAM no);
long	(WINAPI *lpfnConvertRectEx)(HANDLE hDstBoard, TARGET dst, long first, HANDLE hSrcBoard,TARGET src, long start, LPARAM no);
long	(WINAPI *lpfnReadRectEx)(HANDLE hBoard, TARGET src, long start, LPBYTE lpBuf, LPARAM lParam);
long	(WINAPI *lpfnWriteRectEx)(HANDLE hBoard, TARGET dst, long start, LPBYTE lpBuf, LPARAM lParam);

BOOL	(WINAPI *lpfnSetTextTo)(HANDLE hBoard, TARGET target, LPRECT lpRect, LOGFONT *lfLogFont, SETTEXTMODE *textMode, LPSTR lpString, long lLength); 
long	(WINAPI *lpfnDrawEllipsTo)(HANDLE hBoard, TARGET target, long lStart, LPRECT lpRect, long iForeColor);
HDC		(WINAPI *lpfnCreateDCBitmap)(HANDLE hBoard, TARGET target, HANDLE *hDCBitmap);
BOOL	(WINAPI *lpfnMapDCBitmapTo)(HANDLE hDCBitmap, long lStart);
BOOL	(WINAPI *lpfnFreeDCBitmap)(HANDLE hDCBitmap);




long	(WINAPI *lpfnGetSignalParam)(HANDLE hBoard, WPARAM wParam);
long	(WINAPI *lpfnWaitSignalEvent)(HANDLE hBoard, WPARAM wParam, LPARAM lMilliSecond);
long	(WINAPI *lpfnPutSignalParam)(HANDLE hBoard, WPARAM wParam, LPARAM lParam);

BOOL	(WINAPI *lpfnSetSeqProcWnd)(HANDLE hBoard, HWND hwndMain);

long	(WINAPI *lpfnEnableMask)(HANDLE hBoard, BOOL bMask);
long	(WINAPI *lpfnSetMaskRect)(HANDLE hBoard, LPRECT lpRect, LPSTR lpMask);

long	(WINAPI *lpfnFillOutLUT)(HANDLE hBoard,  LPBYTE bLUT, short offset, short num);
long	(WINAPI *lpfnFillInputLUT)(HANDLE hBoard,  LPBYTE bLUT, short offset, short num);

long	(WINAPI *lpfnGetImageDevice)(OKDEVTYPE **lpOkInfo, LPARAM lParam);
short	(WINAPI *lpfnGetSlotBoard)(BOARDTYPE **lpOkInfo);
short	(WINAPI *lpfnGetBoardIndex)(char *szBoardName, short iNo);
long	(WINAPI *lpfnGetBoardName)(long lIndex, LPSTR szBoardName);

long	(WINAPI *lpfnGetAvailBuffer)(void **lpLinear, DWORD *dwSize);
long	(WINAPI *lpfnLockBuffer)(HANDLE hBoard, DWORD dwSizeByte, void **lpBasLinear);
BOOL	(WINAPI *lpfnUnlockAllBuffer)(void);

long	(WINAPI *lpfnApplyMemBlock)(DWORD dwBlockSize, DWORD dwBlockNo);
long	(WINAPI *lpfnFreeMemBlock)(void);
long	(WINAPI *lpfnGetMemBlock)(HANDLE hBoard, DWORD *dwEachSize,  DWORD *dwBlockNo);
long	(WINAPI *lpfnLockMemBlock)(HANDLE hBoard, long dwBlockNo);
long	(WINAPI *lpfnUnlockMemBlock)(void);



BOOL	(WINAPI *lpfnMulCaptureTo)(HANDLE *lphBoard, TARGET Dest, long start, LPARAM lParam);
BOOL	(WINAPI *lpfnMulCaptureByBuffer)(HANDLE *lphBoard, TARGET dest, long start, long num);

BOOL	(WINAPI *lpfnSaveInitParam)(HANDLE hBoard, short iChannNo);
BOOL	(WINAPI *lpfnLoadInitParam)(HANDLE hBoard, short iChannNo);

long	(WINAPI *lpfnSetAllocBuffer)(long lSize);
BOOL	(WINAPI *lpfnSetStaticVxD)(long lMode);
BOOL	(WINAPI *lpfnSetNTDriver)(BOOL bCmd);
BOOL	(WINAPI *lpfnSetLangResource)(BOOL bCmd);


BOOL	(WINAPI *lpfnUnRegister)(DWORD dwCmd);
long	(WINAPI *lpfnGetProgramInfo)(int iItem, LPSTR lpString, int iSize);

long	(WINAPI *lpfnReadProtCode)(HANDLE hBoard, short iIndex);
long	(WINAPI *lpfnWriteProtCode)(HANDLE hBoard, short iIndex, long lCode);

long	(WINAPI *lpfnSaveImageFile)(HANDLE hBoard, LPSTR szFileName, long first, TARGET target, long start, long num);
long	(WINAPI *lpfnLoadImageFile)(HANDLE hBoard, LPSTR szFileName, long first, TARGET target, long start, long num);

long	(WINAPI *lpfnLoadConfigFile)(HANDLE hBoard, LPSTR szFileName);
long	(WINAPI *lpfnSaveConfigFile)(HANDLE hBoard, LPSTR szFileName);

 
BOOL	(WINAPI *lpfnOpenSetParamDlg)( HANDLE hBoard, HWND hParentWnd);
BOOL	(WINAPI *lpfnOpenSeqCaptureDlg)( HANDLE hBoard, HWND hParentWnd);
LPDIBINFO (WINAPI *lpfnOpenReplayDlg)( HANDLE hBoard, HWND hWnd, TARGET src, long total);
HWND     (WINAPI *lpfnOpenReplayDlgEx)( HANDLE hBoard, HWND hWnd, TARGET src, long total,
									LPBITMAPINFOHEADER lpbi, LPBYTE lpdib);


HANDLE	(WINAPI *lpfnBeginEncode)(HANDLE hBoard, DWORD wCodeWay, LPARAM lParam);
long	(WINAPI *lpfnEncodeImage)(HANDLE hCoder, TARGET target, long start, LPBYTE lpData, long maxlen);
long	(WINAPI *lpfnEndEncode)(HANDLE hCoder);


HANDLE	(WINAPI *lpfnBeginDecode)(HANDLE hBoard, DWORD wCodeWay, LPBYTE lpData, LPARAM lpImageInfo);
long	(WINAPI *lpfnDecodeImage)(HANDLE hCoder, LPBYTE lpData, long *length, TARGET target, long start);
long	(WINAPI *lpfnEndDecode)(HANDLE hCoder);


BOOL	(WINAPI *lpfnOutputByte)(WORD port, BYTE data);
BYTE	(WINAPI *lpfnInputByte)(WORD port);
BOOL	(WINAPI *lpfnOutputShort)(WORD port, short data);
short	(WINAPI *lpfnInputShort)(WORD port);
BOOL	(WINAPI *lpfnOutputLong)(WORD port, long data);
long	(WINAPI *lpfnInputLong)(WORD port);

BOOL	(WINAPI *lpfnSetPortBase)(WORD wPortBase, short iPortCount);
short	(WINAPI *lpfnGetGPIOPort)(short index, WORD *wPortBase);


DWORD	(WINAPI *lpfnGetAddrForVB)(void *);
DWORD	(WINAPI *lpfnGetTickCount)(void );
void	(WINAPI *lpfnSleep)(DWORD);
DWORD	(WINAPI *lpfnGetTickCountMicro)(LPDWORD lpHigh);


//------audio section
HANDLE	(WINAPI *lpfnOpenAudio)(HANDLE hBoard, LPARAM lParam);
BOOL	(WINAPI *lpfnCloseAudio)(HANDLE hAudio);
long	(WINAPI *lpfnCaptureAudio)(HANDLE hAudio, TARGET target, FARPROC WriteAudioProc, LPARAM lParam);
BOOL	(WINAPI *lpfnStopCaptureAudio)(HANDLE hAudio);

long	(WINAPI *lpfnSetAudioParam)(HANDLE hAudio, WORD wParam, LPARAM lParam);
long	(WINAPI *lpfnReadAudioData)(HANDLE hAudio, LPBYTE lpAudioBuf, long lSize);


//------stream section
HANDLE	(WINAPI *lpfnOpenStream)(HANDLE hBoard, LPARAM lParam);
BOOL	(WINAPI *lpfnCloseStream)(HANDLE hStream);
long	(WINAPI *lpfnCaptureStream)(HANDLE hStream, TARGET target, FARPROC WriteStreamProc, LPARAM lParam);
BOOL	(WINAPI *lpfnStopCaptureStream)(HANDLE hStream, DWORD dwPause);

long	(WINAPI *lpfnSetStreamParam)(HANDLE hStream, WORD wParam, LPARAM lParam);
long	(WINAPI *lpfnReadStreamData)(HANDLE hStream, LPBYTE lpStreamBuf, long lSize);

//-------serial section
long	(WINAPI *lpfnSetSerial)(HANDLE hBoard, WPARAM wParam, LPARAM lParam);
long	(WINAPI *lpfnReadSerial)(HANDLE hBoard, LPVOID lpBuffer, long lSize, long lTimeOut);
long	(WINAPI *lpfnWriteSerial)(HANDLE hBoard, LPVOID lpBuffer, long lSize, long lTimeOut);


/*-----------------------------------------------------------------------------
*       Functions Process
*/


//2. section

static int		iLoadNum=0;
static HANDLE	hDLLDrv;

BOOL LoadOkApiDll(BOOL bCount)
{
	if(!hDLLDrv)
		hDLLDrv=LoadLibrary(TEXT("OKAPI32.DLL"));

	if(!hDLLDrv) //not found
		return FALSE;

	if(iLoadNum==0) {
		(FARPROC )lpfnOpenBoard=GetProcAddress(hDLLDrv,"okOpenBoard");
		(FARPROC )lpfnCloseBoard=GetProcAddress(hDLLDrv,"okCloseBoard");
		(FARPROC )lpfnGetLastError=GetProcAddress(hDLLDrv,"okGetLastError");
		(FARPROC )lpfnGetBufferSize=GetProcAddress(hDLLDrv,"okGetBufferSize");
		(FARPROC )lpfnGetBufferAddr=GetProcAddress(hDLLDrv,"okGetBufferAddr");
		(FARPROC )lpfnGetTargetInfo=GetProcAddress(hDLLDrv,"okGetTargetInfo");

		(FARPROC )lpfnGetTypeCode=GetProcAddress(hDLLDrv,"okGetTypeCode");

		(FARPROC )lpfnSetTargetRect=GetProcAddress(hDLLDrv,"okSetTargetRect");
		(FARPROC )lpfnSetToWndRect=GetProcAddress(hDLLDrv,"okSetToWndRect");
		(FARPROC )lpfnSetVideoParam=GetProcAddress(hDLLDrv,"okSetVideoParam");
		(FARPROC )lpfnSetCaptureParam=GetProcAddress(hDLLDrv,"okSetCaptureParam");

		(FARPROC )lpfnCaptureTo=GetProcAddress(hDLLDrv,"okCaptureTo");
		(FARPROC )lpfnCaptureSingle=GetProcAddress(hDLLDrv,"okCaptureSingle");
		(FARPROC )lpfnCaptureActive=GetProcAddress(hDLLDrv,"okCaptureActive");
		(FARPROC )lpfnCaptureThread=GetProcAddress(hDLLDrv,"okCaptureThread");
		(FARPROC )lpfnCaptureSequence=GetProcAddress(hDLLDrv,"okCaptureSequence");
		(FARPROC )lpfnCaptureToScreen=GetProcAddress(hDLLDrv,"okCaptureToScreen");
		(FARPROC )lpfnPlaybackFrom=GetProcAddress(hDLLDrv,"okPlaybackFrom");
		(FARPROC )lpfnPlaybackSequence=GetProcAddress(hDLLDrv,"okPlaybackSequence");

		(FARPROC )lpfnGetCaptureStatus=GetProcAddress(hDLLDrv,"okGetCaptureStatus");
		(FARPROC )lpfnStopCapture=GetProcAddress(hDLLDrv,"okStopCapture");

		(FARPROC )lpfnGetSeqCapture=GetProcAddress(hDLLDrv,"okGetSeqCapture");

		(FARPROC )lpfnCaptureByBuffer=GetProcAddress(hDLLDrv,"okCaptureByBuffer");
		(FARPROC )lpfnCaptureByBufferEx=GetProcAddress(hDLLDrv,"okCaptureByBufferEx");
		(FARPROC )lpfnPlaybackByBuffer=GetProcAddress(hDLLDrv,"okPlaybackByBuffer");

		(FARPROC )lpfnReadPixel=GetProcAddress(hDLLDrv,"okReadPixel");
		(FARPROC )lpfnWritePixel=GetProcAddress(hDLLDrv,"okWritePixel");
		(FARPROC )lpfnSetConvertParam=GetProcAddress(hDLLDrv,"okSetConvertParam");
		(FARPROC )lpfnReadRect=GetProcAddress(hDLLDrv,"okReadRect");
		(FARPROC )lpfnWriteRect=GetProcAddress(hDLLDrv,"okWriteRect");
		(FARPROC )lpfnTransferRect=GetProcAddress(hDLLDrv,"okTransferRect");
		(FARPROC )lpfnConvertRect=GetProcAddress(hDLLDrv,"okConvertRect");
		(FARPROC )lpfnConvertRectEx=GetProcAddress(hDLLDrv,"okConvertRectEx");
		(FARPROC )lpfnReadRectEx=GetProcAddress(hDLLDrv,"okReadRectEx");
		(FARPROC )lpfnWriteRectEx=GetProcAddress(hDLLDrv,"okWriteRectEx");

		(FARPROC )lpfnSetTextTo=GetProcAddress(hDLLDrv,"okSetTextTo");
		(FARPROC )lpfnDrawEllipsTo=GetProcAddress(hDLLDrv,"okDrawEllipsTo");

		(FARPROC )lpfnCreateDCBitmap=GetProcAddress(hDLLDrv,"okCreateDCBitmap");
		(FARPROC )lpfnMapDCBitmapTo=GetProcAddress(hDLLDrv,"okMapDCBitmapTo");
		(FARPROC )lpfnFreeDCBitmap=GetProcAddress(hDLLDrv,"okFreeDCBitmap");


		(FARPROC )lpfnGetSignalParam=GetProcAddress(hDLLDrv,"okGetSignalParam");
		(FARPROC )lpfnWaitSignalEvent=GetProcAddress(hDLLDrv,"okWaitSignalEvent");
		(FARPROC )lpfnPutSignalParam=GetProcAddress(hDLLDrv,"okPutSignalParam");

		(FARPROC )lpfnSetSeqProcWnd=GetProcAddress(hDLLDrv,"okSetSeqProcWnd");
		(FARPROC )lpfnSetSeqCallback=GetProcAddress(hDLLDrv,"okSetSeqCallback");

		(FARPROC )lpfnEnableMask=GetProcAddress(hDLLDrv,"okEnableMask");
		(FARPROC )lpfnSetMaskRect=GetProcAddress(hDLLDrv,"okSetMaskRect");
		(FARPROC )lpfnFillOutLUT=GetProcAddress(hDLLDrv,"okFillOutLUT");
		(FARPROC )lpfnFillInputLUT=GetProcAddress(hDLLDrv,"okFillInputLUT");

		(FARPROC )lpfnGetImageDevice=GetProcAddress(hDLLDrv,"okGetImageDevice");
		(FARPROC )lpfnGetSlotBoard=GetProcAddress(hDLLDrv,"okGetSlotBoard");
		(FARPROC )lpfnGetBoardIndex=GetProcAddress(hDLLDrv,"okGetBoardIndex");