#include <vidcap/vidcap.hpp>

VidCap::VidCap()
: mIsConnected(false), mhCaptureWnd(0), mhParentWnd(0)
{
}

VidCap::~VidCap()
{
	destroy();
}

void VidCap::disconnect(void)
{
	if(!isOkay()||!isConnected())return;
	::SendMessage(mhCaptureWnd,WM_CAP_STOP,0,0L);
	::SendMessage(mhCaptureWnd,WM_CAP_DRIVER_DISCONNECT,0,0L);
	isConnected(false);
}


bool VidCap::create(HWND hParentWnd,DWORD width,DWORD height)
{
  mhParentWnd=hParentWnd;
  destroy();
	mhCaptureWnd=capCreateCaptureWindow("VIDCAP",WS_CHILD|WS_VISIBLE,0,0,width,height,hParentWnd,ControlID);
	if(0==mhCaptureWnd)return false;
	mInstanceData.setInstanceData(mhCaptureWnd,(void*)this);
	installHandlers();
	return true;
}

void VidCap::destroy(void)
{
  if(!isOkay())return;
	disconnect();
	removeHandlers();
	mInstanceData.removeInstanceData(mhCaptureWnd);
	::DestroyWindow(mhCaptureWnd);
	mhCaptureWnd=0;
}

bool VidCap::connect(const String &driverName)
{
	Block<DriverInfo> capDrivers;

	disconnect();
	getDrivers(capDrivers);
	for(short itemIndex=0;itemIndex<capDrivers.size();itemIndex++)
	  if(driverName==capDrivers[itemIndex].driverName())return connect(itemIndex);
	return false;
}

bool VidCap::connect(void)
{
	return connect(0);
}

bool VidCap::connect(WORD driverIndex)
{
  Block<DriverInfo> capDrivers;
	DriverInfo driverInfo;

	if(!isOkay())return false;
	getDrivers(capDrivers);
	if(!capDrivers.size()||driverIndex>=capDrivers.size())return false;
  disconnect();
	driverInfo=capDrivers[driverIndex];
	if(::SendMessage(mhCaptureWnd,WM_CAP_DRIVER_CONNECT,driverIndex,0L))
	{
	  ::OutputDebugString(String(String("VidCap::connect OK[")+driverInfo.driverName()+String(" ")+driverInfo.driverVersion()+String("\n")).str());
		isConnected(true);
		getCaptureParams(mCaptureParams);
    getCaptureStatus(mCaptureStatus);
	}
	else ::OutputDebugString(String(String("VidCap::connect ERR[")+driverInfo.driverName()+String(" ")+driverInfo.driverVersion()+String("\n")).str());
  return isConnected();
}

void VidCap::getDrivers(Block<DriverInfo> &capDrivers)
{
	short itemIndex(0);
	String driverName;
	String driverVersion;

	capDrivers.remove();
	while(TRUE)
	{
		if(!capGetDriverDescription(itemIndex,(LPSTR)driverName,String::MaxString,(LPSTR)driverVersion,String::MaxString))break;
		capDrivers.insert(&DriverInfo(driverName,driverVersion));
		itemIndex++;
	}
}

void VidCap::installHandlers(void)
{
	if(!isOkay())return;
	capSetCallbackOnError(mhCaptureWnd,(FARPROC)errorCallback);
	capSetCallbackOnStatus(mhCaptureWnd,(FARPROC)statusCallback);
	capSetCallbackOnFrame(mhCaptureWnd,(FARPROC)frameCallback);
  capSetCallbackOnVideoStream(mhCaptureWnd,(FARPROC)videoCallback);
}

void VidCap::removeHandlers(void)
{
	if(!isOkay())return;
	capSetCallbackOnError(mhCaptureWnd,0);
	capSetCallbackOnStatus(mhCaptureWnd,0);
	capSetCallbackOnFrame(mhCaptureWnd,0);
	capSetCallbackOnVideoStream(mhCaptureWnd,0);
}

bool VidCap::getVideoFormat(BitmapInfo &bitmapInfo)
{
	DWORD sizeData;
	GlobalData<BYTE> globalData;
	LPBITMAPINFOHEADER lpCaptureFormat;

	if(!isConnected())return false;
	globalData.size(::SendMessage(mhCaptureWnd,WM_CAP_GET_VIDEOFORMAT,0,0L));
	lpCaptureFormat=(LPBITMAPINFOHEADER)(BYTE*)&globalData[0];
	::SendMessage(mhCaptureWnd,WM_CAP_GET_VIDEOFORMAT,(WPARAM)globalData.size(),(LPARAM)(LPVOID)lpCaptureFormat);
	bitmapInfo.planes(lpCaptureFormat->biPlanes);
	bitmapInfo.width(lpCaptureFormat->biWidth);
	bitmapInfo.height(lpCaptureFormat->biHeight);
	bitmapInfo.bitCount(BitmapInfo::BitsPerPixel(lpCaptureFormat->biBitCount));
	bitmapInfo.compression(lpCaptureFormat->biCompression);
	bitmapInfo.xPelsPerMeter(lpCaptureFormat->biXPelsPerMeter);
	bitmapInfo.yPelsPerMeter(lpCaptureFormat->biYPelsPerMeter);
	bitmapInfo.colorUsed(lpCaptureFormat->biClrUsed);
  bitmapInfo.colorImportant(lpCaptureFormat->biClrImportant);
	bitmapInfo.rgbColors(lpCaptureFormat->biClrImportant);
	return true;
}

bool VidCap::dialogVideoSource(void)
{
	DriverCaps driverCaps;

	if(!getDriverCaps(driverCaps))return false;
	if(!driverCaps.hasDlgVideoSource())return false;
	return ::SendMessage(mhCaptureWnd,WM_CAP_DLG_VIDEOSOURCE,0,0L);
}

bool VidCap::dialogVideoFormat(void)
{
	DriverCaps driverCaps;

	if(!getDriverCaps(driverCaps))return false;
	if(!driverCaps.hasDlgVideoFormat())return false;
	return ::SendMessage(mhCaptureWnd,WM_CAP_DLG_VIDEOFORMAT,0,0L);
}

bool VidCap::dialogVideoDisplay(void)
{
	DriverCaps driverCaps;

	if(!getDriverCaps(driverCaps))return false;
	if(!driverCaps.hasDlgVideoDisplay())return false;
  return ::SendMessage(mhCaptureWnd,WM_CAP_DLG_VIDEODISPLAY,0,0L);
}

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

void WINAPI VidCap::errorCallback(HWND hCaptureWnd,int nErrorID,LPSTR lpszErrorText)
{
	InstanceData instanceData;
	VidCap *lpVideoCapture=((VidCap*)instanceData.getInstanceData(hCaptureWnd));
	lpVideoCapture->errorHandler(nErrorID,String(lpszErrorText));
}

void WINAPI VidCap::statusCallback(HWND hCaptureWnd,int nID,LPSTR lpszStatusText)
{
	InstanceData instanceData;
	VidCap *lpVideoCapture=((VidCap*)instanceData.getInstanceData(hCaptureWnd));
	lpVideoCapture->statusHandler(nID,String(lpszStatusText));
}

void WINAPI VidCap::videoCallback(HWND hCaptureWnd,LPVIDEOHDR lpVideoHeader)
{
	InstanceData instanceData;
	VidCap *lpVideoCapture=((VidCap*)instanceData.getInstanceData(hCaptureWnd));
	lpVideoCapture->videoHandler(*lpVideoHeader);
}

void WINAPI VidCap::frameCallback(HWND hCaptureWnd,LPVIDEOHDR lpVideoHeader)
{
	InstanceData instanceData;
	VidCap *lpVideoCapture=((VidCap*)instanceData.getInstanceData(hCaptureWnd));
	lpVideoCapture->frameHandler(*lpVideoHeader);
}

// virtuals

void VidCap::errorHandler(int errorID,const String &errorString)
{
  ::OutputDebugString(String(String("VidCap::errorHandler[")+errorString+String("]\n")).str());
}

void VidCap::statusHandler(int nID,const String &statusString)
{
  ::OutputDebugString(String(String("VidCap::statusHandler[")+statusString+String("]\n")).str());
}

void VidCap::videoHandler(VIDEOHDR &videoHeader)
{
  ::OutputDebugString("VidCap::videoHandler\n");
}

void VidCap::frameHandler(VIDEOHDR &videoHeader)
{
  ::OutputDebugString("VidCap::frameHandler\n");
}