#include <codec/vidc.hpp>
#include <codec/fourcc.hpp>

VideoCodec::ReturnCode VideoCodec::openDriver(const DriverName &driverName)
{
	return openDriver(driverName.driverLoadName());
}

VideoCodec::ReturnCode VideoCodec::openDriver(DWORD fccHandler)
{
	DriverName driverName;

	if(!locateDriver(fccHandler,driverName))return FailResult;
	return openDriver(driverName);
}

WORD VideoCodec::enumerateDrivers(Block<DriverName> &driverStrings)
{
	Profile systemProfile("SYSTEM.INI","UNSET");
	String sectionName("DRIVERS32");
	String videoCodecID("VIDC");
	String driverType;
	String driverName;
	String driverLoadName;
	Block<String> driversBlock;

  driverStrings.remove();
	systemProfile.readProfileBlock(sectionName,driversBlock);
	if(!driversBlock.size())return FALSE;
	for(short itemIndex=0;itemIndex<driversBlock.size();itemIndex++)
	{
		driverType=driversBlock[itemIndex].betweenString(0,'.');
		if(driverType.isNull())continue;
		driverType.upper();
		if(!(driverType==videoCodecID))continue;
		driverName=driversBlock[itemIndex].betweenString('.','=');
    if(driverName.isNull())continue;
		driverLoadName=driversBlock[itemIndex].betweenString('=',0);
    if(driverLoadName.isNull())continue;
    driverStrings.insert(&DriverName(driverName,driverLoadName));
  }
	return FALSE;
}

WORD VideoCodec::locateDriver(DWORD fccType,DriverName &driverName)
{
	Block<DriverName> driverNames;
	String fccString;
	WORD driverCount;

  ::OutputDebugString(String("\nsearching for a driver to handle type '")+FOURCC(fccType).toString()+String("'\n"));
	enumerateDrivers(driverNames);
	if(0==(driverCount=driverNames.size()))return FALSE;
	for(short itemIndex=0;itemIndex<driverCount;itemIndex++)
	{
		fccString=driverNames[itemIndex].driverName();
		::OutputDebugString(driverNames[itemIndex].driverName()+String(":")+driverNames[itemIndex].driverLoadName()+String("\n"));
		if(fccType==FOURCC(fccString)){driverName=driverNames[itemIndex];return TRUE;}
		fccString.lower();
		if(fccType==FOURCC(fccString)){driverName=driverNames[itemIndex];return TRUE;}
	}
  return FALSE;
}

VideoCodec::ReturnCode VideoCodec::openDriver(const String &driverLoadName)
{
	closeDriver();
	if((mhVideoCodec=::LoadLibrary(driverLoadName))<(HINSTANCE)HINSTANCE_ERROR)mhVideoCodec=(HINSTANCE)0;
	if(!mhVideoCodec)return FailResult;
	mlpfnDriverProc=(LPFNDRIVERPROC)::GetProcAddress(mhVideoCodec,"DriverProc");
	if(!mlpfnDriverProc){closeDriver();return FailResult;}
	return OkResult;
}

void VideoCodec::closeDriver(void)
{
	if(!mhVideoCodec)return;
	::FreeLibrary(mhVideoCodec);
	mhVideoCodec=(HINSTANCE)0;
	mlpfnDriverProc=0;
}

VideoCodec::ReturnCode VideoCodec::driverProc(ICMOpen &someICMOpen)
{
	ReturnCode returnCode(FailResult);
	if(!mlpfnDriverProc)return returnCode;
  mDriverID=(DWORD)((mlpfnDriverProc)(DriverID,(HDRVR)DriverHandle,DRV_OPEN,0L,(LONG)&someICMOpen));
	return (ReturnCode)mDriverID;
}

VideoCodec::ReturnCode VideoCodec::driverProc(ICMInfo &someICMInfo)
{
	ReturnCode returnCode(FailResult);
	if(!mlpfnDriverProc)return returnCode;
  return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_GETINFO,(LONG)&someICMInfo,(LONG)someICMInfo.size()));
}

VideoCodec::ReturnCode VideoCodec::getCompressFormat(BitmapInfo &srcBitmapInfo)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_GET_FORMAT,(LONG)&srcBitmapInfo.getBITMAPINFO(),0L));
}

VideoCodec::ReturnCode VideoCodec::getCompressFormat(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_GET_FORMAT,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));
}

VideoCodec::ReturnCode VideoCodec::getFormat(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_FORMAT,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));
}

VideoCodec::ReturnCode VideoCodec::getFormat(BitmapInfo &srcBitmapInfo)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_FORMAT,(LONG)&srcBitmapInfo.getBITMAPINFO(),0));
}

VideoCodec::ReturnCode VideoCodec::getPalette(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_GET_PALETTE,(LONG)&srcBitmapInfo.getBITMAPINFOHEADER(),(LONG)&dstBitmapInfo.getBITMAPINFOHEADER()));
}

VideoCodec::ReturnCode VideoCodec::driverLoad(void)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,DRV_LOAD,0L,0L));
}

VideoCodec::ReturnCode VideoCodec::driverEnable(void)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,DRV_ENABLE,0L,0L));
}

VideoCodec::ReturnCode VideoCodec::canCompress(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_QUERY,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));
	return returnCode;
}

VideoCodec::ReturnCode VideoCodec::canCompress(BitmapInfo &srcBitmapInfo)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_QUERY,(LONG)&srcBitmapInfo.getBITMAPINFO(),0));
	return returnCode;
}

VideoCodec::ReturnCode VideoCodec::icmCompressBegin(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	if(!mlpfnDriverProc)return BadFormatResult;
	try{return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_BEGIN,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));}
	catch(...){::OutputDebugString("[VideoCodec::icmCompressBegin]Exception!");return FailResult;}
}

VideoCodec::ReturnCode VideoCodec::icmCompressEnd(void)
{
	if(!mlpfnDriverProc)return BadFormatResult;
	try{return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS_END,0L,0L));}
	catch(...){::OutputDebugString("[VideoCodec::icmCompressEnd]Exception");return FailResult;}
}

VideoCodec::ReturnCode VideoCodec::icmCompress(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo,MovieData &srcMovieData,MovieData &dstMovieData)
{
  ICMCompress icmCompress;
	DWORD chunkID;

	icmCompress.srcBitmapInfoHeaderPtr(srcBitmapInfo);
	icmCompress.dstBitmapInfoHeaderPtr(dstBitmapInfo);
	icmCompress.srcInputPtr(srcMovieData);
	icmCompress.dstOutputPtr(dstMovieData);
	icmCompress.chunkID(&chunkID);
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_COMPRESS,(LONG)&icmCompress,ICMCompress::size()));
}

VideoCodec::ReturnCode VideoCodec::compressFrame(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo,MovieData &srcMovieData,MovieData &dstMovieData)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	if(BadFormatResult==canCompress(srcBitmapInfo))return FailResult;
	if(BadFormatResult==getCompressFormat(srcBitmapInfo,dstBitmapInfo))return FailResult;
	dstMovieData.size(dstBitmapInfo.sizeImage());
	if(!dstMovieData.size())return FailResult;
	if(OkResult!=(returnCode=icmCompress(srcBitmapInfo,dstBitmapInfo,srcMovieData,dstMovieData)))return FailResult;
	return OkResult;
}

VideoCodec::ReturnCode VideoCodec::canDecompress(BitmapInfo &someBitmapInfo)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_QUERY,(LONG)&someBitmapInfo.getBITMAPINFO(),0L));
	return returnCode;
}

VideoCodec::ReturnCode VideoCodec::canDecompress(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	returnCode=(ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_QUERY,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));
  return returnCode;
}

VideoCodec::ReturnCode VideoCodec::icmDecompressBegin(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo)
{
	if(!mlpfnDriverProc)return BadFormatResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_BEGIN,(LONG)&srcBitmapInfo.getBITMAPINFO(),(LONG)&dstBitmapInfo.getBITMAPINFO()));
}

VideoCodec::ReturnCode VideoCodec::icmDecompressEnd(void)
{
	if(!mlpfnDriverProc)return FailResult;
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS_END,0L,0L));
}

VideoCodec::ReturnCode VideoCodec::icmDecompress(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo,MovieData &srcMovieData,MovieData &dstMovieData)
{
	ICMDecompress icmDecompress;

	if(!mlpfnDriverProc)return BadFormatResult;
	icmDecompress.flags(ICMDecompress::HurryUp);
	icmDecompress.srcBitmapInfoHeaderPtr(srcBitmapInfo);
	icmDecompress.dstBitmapInfoHeaderPtr(dstBitmapInfo);
	icmDecompress.srcInputPtr(srcMovieData);
	icmDecompress.dstInputPtr(dstMovieData);
	icmDecompress.chunkID(0x01);
	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_DECOMPRESS,(LONG)&icmDecompress,ICMDecompress::size()));
}

VideoCodec::ReturnCode VideoCodec::icmConfigure(HWND hDisplayWindow)
{
	if(!mlpfnDriverProc)return FailResult;

	return (ReturnCode)((mlpfnDriverProc)(mDriverID,(HDRVR)DriverHandle,ICM_CONFIGURE,(LONG)hDisplayWindow,0L));
}

VideoCodec::ReturnCode VideoCodec::decompressFrame(BitmapInfo &srcBitmapInfo,BitmapInfo &dstBitmapInfo,MovieData &srcMovieData,MovieData &dstMovieData)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	if(BadFormatResult==canDecompress(srcBitmapInfo))return FailResult;
	if(BadFormatResult==getFormat(srcBitmapInfo))return FailResult;
	if(BadFormatResult==getFormat(srcBitmapInfo,dstBitmapInfo))return FailResult;
	dstMovieData.size(dstBitmapInfo.sizeImage());
	if(BitmapInfo::TrueColor==dstBitmapInfo.bitCount())
	{
		dstBitmapInfo.bitCount(BitmapInfo::Bit8);
		if(BadFormatResult==canDecompress(srcBitmapInfo,dstBitmapInfo))return FailResult;
    if(ICERR_OK !=getPalette(srcBitmapInfo,dstBitmapInfo))return FailResult;
    dstMovieData.size(dstBitmapInfo.sizeImage());
  }
	if(BadFormatResult==icmDecompressBegin(srcBitmapInfo,dstBitmapInfo))return FailResult;
	if(BadFormatResult==icmDecompress(srcBitmapInfo,dstBitmapInfo,srcMovieData,dstMovieData))return FailResult;
	if(OkResult!=icmDecompressEnd())return FailResult;
	return OkResult;
}

VideoCodec::ReturnCode VideoCodec::decompressFrame(BitmapInfo &srcBitmapInfo,MovieData &srcMovieData,MovieData &dstMovieData)
{
	ReturnCode returnCode(FailResult);

	if(!mlpfnDriverProc)return returnCode;
	if(BadFormatResult==canDecompress(srcBitmapInfo))return FailResult;
	if(BadFormatResult==getFormat(srcBitmapInfo))return FailResult;
	if(BadFormatResult==getFormat(srcBitmapInfo,srcBitmapInfo))return FailResult;
	dstMovieData.size(srcBitmapInfo.sizeImage());
	if(BitmapInfo::TrueColor==srcBitmapInfo.bitCount())
	{
		srcBitmapInfo.bitCount(BitmapInfo::Bit8);
		if(BadFormatResult==canDecompress(srcBitmapInfo,srcBitmapInfo))return FailResult;
    if(OkResult!=getPalette(srcBitmapInfo,srcBitmapInfo))return FailResult;
    dstMovieData.size(srcBitmapInfo.sizeImage());
  }
	if(BadFormatResult==icmDecompressBegin(srcBitmapInfo,srcBitmapInfo))return FailResult;
	if(BadFormatResult==icmDecompress(srcBitmapInfo,srcBitmapInfo,srcMovieData,dstMovieData))return FailResult;
	if(OkResult!=icmDecompressEnd())return FailResult;
	return OkResult;
}