dllentry.c

OK视频采集卡VC源代码

{	return lpfnFillInputLUT(hBoard,  bLUT, start, num);	}



long	WINAPI okGetImageDevice(OKDEVTYPE **lpOkDevice, LPARAM lParam)
{
	(FARPROC )lpfnGetImageDevice=GetProcPointer("okGetImageDevice");
	return lpfnGetImageDevice(lpOkDevice, lParam);	}

short	WINAPI okGetSlotBoard(BOARDTYPE **lpOkInfo)
{
	(FARPROC )lpfnGetSlotBoard=GetProcPointer("okGetSlotBoard");
	return lpfnGetSlotBoard(lpOkInfo);	}

short	WINAPI okGetBoardIndex(char *szBoardName, short iNo)
{
	(FARPROC )lpfnGetBoardIndex=GetProcPointer("okGetBoardIndex");
	return lpfnGetBoardIndex(szBoardName, iNo);	}


long	WINAPI okGetBoardName(long lIndex, LPSTR szBoardName)
{
	(FARPROC )lpfnGetBoardName=GetProcPointer("okGetBoardName");
	return lpfnGetBoardName(lIndex, szBoardName);	}


long	WINAPI okGetAvailBuffer(void **lpLinear, DWORD *dwSize)
{
	(FARPROC )lpfnGetAvailBuffer=GetProcPointer("okGetAvailBuffer");
	return lpfnGetAvailBuffer(lpLinear, dwSize);	}

long	WINAPI okLockBuffer(HANDLE hBoard, DWORD dwSizeByte, void **lpBasLinear)
{	return lpfnLockBuffer(hBoard, dwSizeByte, lpBasLinear);	}

BOOL	WINAPI okUnlockAllBuffer(void)
{	return lpfnUnlockAllBuffer();	}


long	WINAPI okApplyMemBlock(DWORD dwBlockSize, DWORD dwBlockNo)
{	(FARPROC )lpfnApplyMemBlock=GetProcPointer("okApplyMemBlock");
	return lpfnApplyMemBlock(dwBlockSize, dwBlockNo);	}

BOOL	WINAPI okFreeMemBlock(void)
{	return lpfnFreeMemBlock();	}

long	WINAPI okGetMemBlock(HANDLE hBoard, DWORD *dwEachSize,  DWORD *dwBlockNo)
{	return lpfnGetMemBlock(hBoard, dwEachSize,  dwBlockNo);	}

long	WINAPI okLockMemBlock(HANDLE hBoard, long lBlockNo)
{	return lpfnLockMemBlock(hBoard, lBlockNo);	}

BOOL	WINAPI okUnlockMemBlock(void)
{	return lpfnUnlockMemBlock();	}



BOOL	WINAPI okMulCaptureTo(HANDLE *lphBoard, TARGET Dest, long start, LPARAM lParam)
{	return lpfnMulCaptureTo(lphBoard, Dest, start, lParam);	}

BOOL	WINAPI okMulCaptureByBuffer(HANDLE *lphBoard, TARGET Dest, long start, LPARAM lParam)
{	return lpfnCaptureByBuffer(lphBoard, Dest, start, lParam);	}


long	WINAPI okSetAllocBuffer(long lSize)
{
	(FARPROC )lpfnSetAllocBuffer=GetProcPointer("okSetAllocBuffer");
	return lpfnSetAllocBuffer(lSize);	
}

BOOL	WINAPI okSetStaticVxD(long lMode)
{
	(FARPROC )lpfnSetStaticVxD=GetProcPointer("okSetStaticVxD");
	return lpfnSetStaticVxD(lMode);	
}

BOOL	WINAPI okSetNTDriver(BOOL lMode)
{
	(FARPROC )lpfnSetNTDriver=GetProcPointer("okSetNTDriver");
	return lpfnSetNTDriver(lMode);	
}

long	WINAPI okSetLangResource(long lMode)
{
	(FARPROC )lpfnSetLangResource=GetProcPointer("okSetLangResource");
	return lpfnSetLangResource(lMode);	
}


BOOL	WINAPI okUnRegister(DWORD dwCmd)
{	
	(FARPROC )lpfnUnRegister=GetProcPointer("okUnRegister");
	return lpfnUnRegister(dwCmd);	
}

long	WINAPI okGetProgramInfo(int iItem, LPSTR lpString, int iSize)
{	
	(FARPROC )lpfnGetProgramInfo=GetProcPointer("okGetProgramInfo");
	return lpfnGetProgramInfo(iItem, lpString, iSize);
}


BOOL	WINAPI okSaveInitParam(HANDLE hBoard, short iChanNo)
{	return lpfnSaveInitParam(hBoard, iChanNo);	}

BOOL	WINAPI okLoadInitParam(HANDLE hBoard, short iChanNo)
{	return lpfnLoadInitParam(hBoard, iChanNo);	}

long	WINAPI okReadProtCode(HANDLE hApi, short iIndex)
{	return lpfnReadProtCode(hApi, iIndex);	}

long	WINAPI okWriteProtCode(HANDLE hApi, short iIndex, long lCode)
{	return lpfnWriteProtCode(hApi, iIndex, lCode);	}



long WINAPI okSaveImageFile(HANDLE hBoard, LPSTR szFileName, long first, TARGET target, long start, long num)
{	return lpfnSaveImageFile(hBoard, szFileName, first, target, start, num);	}

long WINAPI okLoadImageFile(HANDLE hBoard, LPSTR szFileName, long first, TARGET target, long start, long num)
{	return lpfnLoadImageFile(hBoard, szFileName, first, target, start, num);	}

BOOL WINAPI okLoadConfigFile(HANDLE hBoard, LPSTR szFileName)
{	return lpfnLoadConfigFile(hBoard, szFileName);	}

BOOL WINAPI okSaveConfigFile(HANDLE hBoard, LPSTR szFileName)
{	return lpfnSaveConfigFile(hBoard, szFileName);	}

 
BOOL WINAPI okOpenSetParamDlg( HANDLE hBoard, HWND hParentWnd)
{	return lpfnOpenSetParamDlg(hBoard, hParentWnd);	}

BOOL WINAPI okOpenSeqCaptureDlg( HANDLE hBoard, HWND hParentWnd)
{	return lpfnOpenSeqCaptureDlg(hBoard, hParentWnd);	}

LPDIBINFO WINAPI okOpenReplayDlg( HANDLE hBoard, HWND hWnd, TARGET src, long total)
{	return lpfnOpenReplayDlg(hBoard, hWnd, src, total);	}

HWND WINAPI okOpenReplayDlgEx( HANDLE hBoard, HWND hWnd, TARGET src, long total, LPBITMAPINFOHEADER lpbi, LPBYTE lpdib)
{	return lpfnOpenReplayDlgEx(hBoard, hWnd, src, total, lpbi, lpdib);	}


HANDLE WINAPI okBeginEncode(HANDLE hBoard, DWORD wCodeWay, LPARAM lParam)
{	return lpfnBeginEncode(hBoard, wCodeWay, lParam);	}

long WINAPI okEncodeImage(HANDLE hCoder, TARGET target, long start, LPBYTE lpData, long maxlen)
{	return lpfnEncodeImage(hCoder, target, start, lpData, maxlen);	}

long WINAPI okEndEncode(HANDLE hCoder)
{	return lpfnEndEncode(hCoder);	}


HANDLE WINAPI okBeginDecode(HANDLE hBoard, DWORD wCodeWay, LPBYTE lpData, LPARAM lpImageInfo)
{	return lpfnBeginDecode(hBoard, wCodeWay, lpData, lpImageInfo);	}

long WINAPI okDecodeImage(HANDLE hCoder, LPBYTE lpData, long *length, TARGET target, long start)
{	return lpfnDecodeImage(hCoder, lpData, length, target, start);	}

long WINAPI okEndDecode(HANDLE hCoder)
{	return lpfnEndDecode(hCoder);	}



BOOL	WINAPI okOutputByte(WORD port, BYTE data)
{	LoadOkApiDll(0);
	return lpfnOutputByte(port, data);	}

BYTE	WINAPI okInputByte(WORD port)
{	LoadOkApiDll(0);
	return lpfnInputByte(port);	}

BOOL	WINAPI okOutputShort(WORD port, short data)
{	LoadOkApiDll(0);
	return lpfnOutputShort(port, data);	}

short	WINAPI okInputShort(WORD port)
{	LoadOkApiDll(0);
	return lpfnInputShort(port);	}

BOOL	WINAPI okOutputLong(WORD port, long data)
{	LoadOkApiDll(0);
	return lpfnOutputLong(port, data);	}

long	WINAPI okInputLong(WORD port)
{	LoadOkApiDll(0);	
	return lpfnInputLong(port);	}


BOOL	WINAPI okSetPortBase(WORD wPortBase, short iPortCount)
{	LoadOkApiDll(0);
	return lpfnSetPortBase(wPortBase, iPortCount);	}

short	WINAPI okGetGPIOPort(short index, WORD *wPortBase)
{	LoadOkApiDll(0);
	return lpfnGetGPIOPort(index, wPortBase);	}
		


DWORD	WINAPI okGetAddrForVB(void *lpArry)
{	LoadOkApiDll(0);
	return lpfnGetAddrForVB(lpArry);	}

DWORD	WINAPI okGetTickCount(void)
{	LoadOkApiDll(0);
	return lpfnGetTickCount();	}

void	WINAPI okSleep(DWORD dwMillSeconds)
{	LoadOkApiDll(0);
	lpfnSleep(dwMillSeconds);	}

DWORD	WINAPI okGetTickCountMicro(LPDWORD lpHigh)
{	LoadOkApiDll(0);
	return lpfnGetTickCountMicro(lpHigh);	}


//--------audio-----------

HANDLE	WINAPI okOpenAudio(HANDLE hBoard, LPARAM lParam)
{	
	LoadOkApiDll(1);
	return lpfnOpenAudio(hBoard, lParam);	
}

BOOL	WINAPI okCloseAudio(HANDLE hAudio)
{	
	BOOL	ret;
	
	ret=lpfnCloseAudio(hAudio);	
	if(ret)
		FreeOkApiDll();

	return ret;
}


long	WINAPI okCaptureAudio(HANDLE hAudio, TARGET target, FARPROC WriteAudioProc, LPARAM lParam)
{	return lpfnCaptureAudio(hAudio, target, WriteAudioProc, lParam);	}

BOOL	WINAPI okStopCaptureAudio(HANDLE hAudio)
{	return lpfnStopCaptureAudio(hAudio);	}

long	WINAPI okSetAudioParam(HANDLE hAudio, WORD wParam, LPARAM lParam)
{	return lpfnSetAudioParam(hAudio, wParam, lParam);	}

long	WINAPI okReadAudioData(HANDLE hAudio, LPBYTE lpAudioBuf, long lSize)
{	return lpfnReadAudioData(hAudio, lpAudioBuf, lSize);	}




//--------stream-----------

HANDLE	WINAPI okOpenStream(HANDLE hBoard, LPARAM lParam)
{	
	LoadOkApiDll(1);
	return lpfnOpenStream(hBoard, lParam);	
}

BOOL	WINAPI okCloseStream(HANDLE hStream)
{	
	BOOL	ret;
	
	ret=lpfnCloseStream(hStream);	
	if(ret)
		FreeOkApiDll();

	return ret;
}


long	WINAPI okCaptureStream(HANDLE hStream, TARGET target, FARPROC WriteStreamProc, LPARAM lParam)
{	return lpfnCaptureStream(hStream, target, WriteStreamProc, lParam);	}

BOOL	WINAPI okStopCaptureStream(HANDLE hStream, DWORD dwPause)
{	return lpfnStopCaptureStream(hStream, dwPause);	}

long	WINAPI okSetStreamParam(HANDLE hStream, WORD wParam, LPARAM lParam)
{	return lpfnSetStreamParam(hStream, wParam, lParam);	}

long	WINAPI okReadStreamData(HANDLE hStream, LPBYTE lpStreamBuf, long lSize)
{	return lpfnReadStreamData(hStream, lpStreamBuf, lSize);	}



long	WINAPI okSetSerial(HANDLE hBoard, WPARAM wParam, LPARAM lParam)
{	return lpfnSetSerial( hBoard, wParam, lParam);	}

long	WINAPI okReadSerial(HANDLE hBoard, LPVOID lpBuffer, long lSize, long lTimeOut)
{	return lpfnReadSerial( hBoard, lpBuffer, lSize, lTimeOut);	}

BOOL	WINAPI okWriteSerial(HANDLE hBoard, LPVOID lpBuffer, long lSize, long lTimeOut)
{	return lpfnWriteSerial( hBoard, lpBuffer, lSize, lTimeOut);	}



//-----------end-----------------------------------------------------------------------