#include  "stdafx.h"

#include  "resource.h"
#include  "NiTool.h"
#include  "NITools/NiDevice.h"
#include  "MFCio.h"



/*
使用するパラメータ
	appParam.nowSDKLib
	appParam.isUseImage			CSetViewMode
	appParam.isMirroring		CSetViewMode
	appParam.isForcePose		CSetViewMode
	appParam.saveDataMode		CSetDataSave
	appParam.savePosMode		CSetDataSave
	appParam.saveRotMode		CSetDataSave
	appParam.saveQutMode		CSetDataSave
	appParam.useDevMotor		CSetDevice
	appParam.useDevLED			CSetDevice
*/




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CNiDevice クラス : ライブラリのラッパークラス
//

CNiDevice::CNiDevice(void)
{
	nowSDKLib	   = NiSDK_None;
	#ifdef ENABLE_KINECT_SDK
	nowSDKLib	   = NiSDK_Kinect;
	#endif
	#ifdef ENABLE_OPENNI
	nowSDKLib	   = NiSDK_OpenNI;
	#endif

	openni_win	   = NULL;
	kinect_sdk	   = NULL;

	pSensorFrame   = NULL;
	pLogFrame	   = NULL;
	pSkeletonFrame = NULL;

	hWnd		   = NULL;
	enableUSBDev   = FALSE;

	has_device	   = FALSE;
	loaded_data	   = FALSE;

	inputDevice	   = NiDevice_NI;
	prvNiInputDevice = NiDevice_NI;
	err_message    = make_Buffer(LMESG);

	appParam.init();

	//
	image_xsize	   = 0;
	image_ysize	   = 0;
	image_fps      = 0;
}



CNiDevice::~CNiDevice()
{
	DEBUG_ERR("DESTRUCTOR: CNiDevice");

	deleteRecordeTempFile();

	if (pSensorFrame!=NULL) {
		CExFrame* pfrm = pSensorFrame;
		setSensorFramePtr(NULL);
		::Sleep(NIDEVICE_WAIT_TIME);
		delete(pfrm);
	}
	if (pLogFrame!=NULL) {
		delete(pLogFrame);
		pLogFrame = NULL;
	}
	if (this->pSkeletonFrame!=NULL) {
		delete(pSkeletonFrame);
		pSkeletonFrame = NULL;
	}

	if (openni_win!=NULL) {
		delete(openni_win);
		openni_win = NULL;
	}
	if (kinect_sdk!=NULL) {
		delete(kinect_sdk);
		kinect_sdk = NULL;
	}
}




BOOL  CNiDevice::init(void)
{
	CString mesg;
	has_device = FALSE;

	BOOL ret = check_lib();
	if (!ret) {
		#ifdef WIN64
		mesg.LoadString(IDS_STR_NOT_LIB64);			// "64bitライブラリがインストールされていません"
		#else
		mesg.LoadString(IDS_STR_NOT_LIB32);			// "32bitライブラリがインストールされていません"
		#endif
		copy_s2Buffer((char*)(LPCSTR)mesg, &err_message);
		return FALSE;
	}

	//
	else {
		ret = init_device();
		if (!ret) {
			mesg.LoadString(IDS_STR_NOT_DEVICE);	// "NIデバイスが接続されていません"
			copy_s2Buffer((char*)(LPCSTR)mesg, &err_message);
			return FALSE;
		}
	}

	//
	has_device = TRUE;	
	return TRUE;
}




BOOL  CNiDevice::check_lib(void)
{
	if (nowSDKLib==NiSDK_Kinect) {
		if (load_lib(KINECT_SDK_DLLNAME)) {
			nowSDKLib = NiSDK_Kinect;
		}
		else if (load_lib(OPENNI_NITE_DLLNAME)) {
			nowSDKLib = NiSDK_OpenNI;
		}
		else {
			nowSDKLib = NiSDK_None;
		}
	}

	//
	else {
		if (load_lib(OPENNI_NITE_DLLNAME)) {
			nowSDKLib = NiSDK_OpenNI;
		}
		else if (load_lib(KINECT_SDK_DLLNAME)) {
			nowSDKLib = NiSDK_Kinect;
		}
		else {
			nowSDKLib = NiSDK_None;
		}
	}

	//
	if (nowSDKLib==NiSDK_None) return FALSE;
	return TRUE;
}




//
// need isUseImage, isUseMotor, isUseLED
//
BOOL  CNiDevice::init_device()
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win = new CExOpenNiWin();
		if (openni_win!=NULL) {
			setUseImage(appParam.isUseImage);
			ret = openni_win->init();
			if (ret) {
				image_xsize = openni_win->device->outputMode.nXRes;
				image_ysize = openni_win->device->outputMode.nYRes;
				image_fps   = openni_win->device->outputMode.nFPS;
			}
			else {
				openni_win->deleteDevice();
			}
			NiSetOpenNIJointNums();
		}
		#endif
	}

	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk = new CExKinectWin();
		if (kinect_sdk!=NULL) {
			setUseImage(appParam.isUseImage);
			ret = kinect_sdk->init();
			if (ret) {
				image_xsize = kinect_sdk->device->m_xsize;
				image_ysize = kinect_sdk->device->m_ysize;
				image_fps   = kinect_sdk->device->m_fps;
			}
			else {
				kinect_sdk->deleteDevice();
			}
			NiSetKinectJointNums();
		}
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::init_device ERROR: Unknown Library Type.", &err_message);
	}

	if (ret) {
		openUSBDevice();
		setUseLED(appParam.useDevLED);
		setUseMotor(appParam.useDevMotor);
		//setTiltMotor(0);
		setLEDColor(NI_LED_GREEN);
	}

	return ret;
}



/*
//
// need isUseImage, isForcePose, isUseMotor, isUseLED
//
BOOL  CNiDevice::reset_device()
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win!=NULL && openni_win->device!=NULL) {
			openni_win->device->delete_Depth();
			openni_win->device->delete_Image();
			ret = openni_win->device->init(appParam.isUseImage);
			if (!ret) {
				has_device = FALSE;
				openni_win = NULL;
			}
		}
		#endif
	}

	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk!=NULL) {
			delete(kinect_sdk);
			ret = init_device();
		}
		#endif
	}

	return ret;
}
*/



BOOL  CNiDevice::load_lib(char* lib_name)
{
	if (LoadLibrary(lib_name)==NULL) return FALSE;
	if (FAILED(__HrLoadAllImportsForDll(lib_name))) return FALSE;

	return TRUE;
}





//////////////////////////////////////////////////////////////////////////////////////////////////////////
//

NiFileType  CNiDevice::checkFileType(char* fname)
{
	char buf[10];
	memset(buf, 0, 10);

	FILE* fp = fopen(fname, "rb");
	if (fp==NULL) return FileDataUnknown;
	fread(buf, 9, 1, fp);
	fclose(fp);

	if (!strncasecmp(buf, "HIERARCHY", 9)) {
		return FileDataBVH;
	}
	else if (!strncasecmp(buf, "RINIONS", 8)) {
		return FileDataORG;
	}
	return FileDataONI;
}





//////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Interface 
//

void  CNiDevice::setParameter(CParameterSet param)
{	
	appParam = param;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win!=NULL) {
			openni_win->setParameter(param);
			openni_win->setMotion(param);
			setUseImage(param.isUseImage);
			setMirroring(param.isMirroring);
			setUseMotor(param.useDevMotor);
			setUseLED(param.useDevLED);
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk!=NULL) {
			kinect_sdk->setParameter(param);
			kinect_sdk->setMotion(param);
			setUseImage(param.isUseImage);
			setMirroring(param.isMirroring);
			setUseMotor(param.useDevMotor);
			setUseLED(param.useDevLED);
		}
		#endif
	}

	return;
}



BOOL  CNiDevice::initRingBuffer(void)
{	
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->initRingBuffer();
		if (!ret) copy_Buffer(&openni_win->m_err_mesg, &err_message);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		ret = kinect_sdk->initRingBuffer();
		if (!ret) copy_Buffer(&kinect_sdk->m_err_mesg, &err_message);
		#endif
	}
	//else {
	//	copy_s2Buffer("CNiDevice::initRingBuffer ERROR: Unknown Library Type.", &err_message);
	//}

	return ret;
}



/*
void  CNiDevice::execMirroring(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win==NULL) return;
		if (openni_win->device==NULL) return;
		if (openni_win->device->context==NULL) return;
		openni_win->device->context->SetGlobalMirror(appParam.isMirroring);
		::Sleep(NIDEVICE_WAIT_TIME);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk==NULL) return;
		kinect_sdk->m_is_mirroring = appParam.isMirroring;
		#endif
	}

	return;
}
*/



char*  CNiDevice::getErrorMessage(BOOL dev)
{
	if (dev) {
		//
		if (nowSDKLib==NiSDK_OpenNI) {
			#ifdef ENABLE_OPENNI
			if (openni_win!=NULL) copy_Buffer(&openni_win->m_err_mesg, &err_message);
			#endif
		}
		//
		else if (nowSDKLib==NiSDK_Kinect) {
			#ifdef ENABLE_KINECT_SDK
			if (kinect_sdk!=NULL) copy_Buffer(&kinect_sdk->m_err_mesg, &err_message);
			#endif
		}
	}
	
	return (char*)err_message.buf;
}




int   CNiDevice::getDevState(void)
{
	int st = NI_STATE_DETECT_STOPPED;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		st = openni_win->getDevState();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		st = kinect_sdk->getDevState();
		#endif
	}

	return st;
}


/*
void  CNiDevice::setDevState(int state)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setDevState(state);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setDevState(state);
		#endif
	}

	return;
}
*/


void  CNiDevice::setViewScale(int scale)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->m_scale = scale;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->m_scale = scale;
		#endif
	}

	return;
}




//////////////////////////////////////////////////////////////////////////////////////////

void  CNiDevice::clearBoneData(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->clearBoneData();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->clearBoneData();
		#endif
	}

	return;
}



void  CNiDevice::clearAvatarDetected(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->clearAvatarDetected();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->clearAvatarDetected();
		#endif
	}

	return;
}




//////////////////////////////////////////////////////////////////////////////////////////

void  CNiDevice::clearLogDocPtr(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->pLogDoc = NULL;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->pLogDoc = NULL;
		#endif
	}

	return;
}



void  CNiDevice::setLogFramePtr(CExFrame* ptr)
{
	pLogFrame = ptr;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setLogFramePtr(ptr);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setLogFramePtr(ptr);
		#endif
	}

	return;
}


void  CNiDevice::setSensorFramePtr(CExFrame* ptr)
{
	pSensorFrame = ptr;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setSensorFramePtr(ptr);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setSensorFramePtr(ptr);
		#endif
	}

	return;
}



void  CNiDevice::setSkeletonFramePtr(CExFrame* ptr)
{
	pSkeletonFrame = ptr;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setSkeletonFramePtr(ptr);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setSkeletonFramePtr(ptr);
		#endif
	}

	return;
}




//////////////////////////////////////////////////////////////////////////////////////////

void  CNiDevice::setViewPoint(void)
{ 
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) {
			if (openni_win->device->image!=NULL && openni_win->device->depth!=NULL) {
				openni_win->device->depth->GetAlternativeViewPointCap().SetViewPoint(*(openni_win->device->image));
			}
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->nop();
		#endif
	}

	return;
}



void  CNiDevice::setJointConst(CNiJoints* joints)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->niJoints = joints;
		joints->posVect = openni_win->posVect;
		joints->rotQuat = openni_win->rotQuat;
		joints->posRing = openni_win->posRing;
		joints->rotRing = openni_win->rotRing;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->niJoints = joints;
		joints->posVect = kinect_sdk->posVect;
		joints->rotQuat = kinect_sdk->rotQuat;
		joints->posRing = kinect_sdk->posRing;
		joints->rotRing = kinect_sdk->rotRing;
		#endif
	}

	return;

}



void  CNiDevice::setNetwork(CNiNetwork* net)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->niNetwork = net;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->niNetwork = net;
		#endif
	}

	return;

}



void  CNiDevice::setSharedMem(CNiSMemory* mem)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->sharedMem = mem;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->sharedMem = mem;
		#endif
	}

	return;
}




//////////////////////////////////////////////////////////////////////////////////////////

BOOL  CNiDevice::createImage(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) ret = openni_win->device->create_Image();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk->device!=NULL) ret = kinect_sdk->device->create_Image();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::createImage ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



BOOL  CNiDevice::createDepth(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) ret = openni_win->device->create_Depth();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk->device!=NULL) ret = kinect_sdk->device->create_Depth();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::createDepth ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



void  CNiDevice::deleteDevice(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->deleteDevice();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->deleteDevice();
		#endif
	}

	return;
}



void  CNiDevice::deleteImage(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) openni_win->device->delete_Image();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if ( kinect_sdk->device!=NULL) kinect_sdk->device->delete_Image();
		#endif
	}

	return;
}



void  CNiDevice::deleteDepth(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) openni_win->device->delete_Depth();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if ( kinect_sdk->device!=NULL) kinect_sdk->device->delete_Depth();
		#endif
	}

	return;
}



BOOL  CNiDevice::hasImage(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) {
			if (openni_win->device->image!=NULL) ret = TRUE;
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk->device!=NULL) {
			if (kinect_sdk->device->image!=NULL) ret = TRUE;
		}
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::hasImage ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



BOOL  CNiDevice::hasDepth(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win->device!=NULL) {
			if (openni_win->device->depth!=NULL) ret = TRUE;
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (kinect_sdk->device!=NULL) {
			if (kinect_sdk->device->depth!=NULL) ret = TRUE;
		}
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::hasDepth ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}




void  CNiDevice::setUseImage(BOOL use)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->m_use_image = use;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->m_use_image = use;
		#endif
	}

	return;
}




void  CNiDevice::setMirroring(BOOL use)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setMirroring(use);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setMirroring(use);
		#endif
	}

	return;
}




//////////////////////////////////////////////////////////////////////////////////////////

BOOL  CNiDevice::startDetection()
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->startDetection(appParam.isForcePose);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		ret = kinect_sdk->startDetection();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::startDetection ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



BOOL  CNiDevice::stopDetection()
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->stopDetection();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		ret = kinect_sdk->stopDetection();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::stopDetection ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



void  CNiDevice::setTrackingSearch(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setTrackingSearch();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setTrackingSearch();
		#endif
	}

	return;
}







//////////////////////////////////////////////////////////////////////////////////////////
//
// File
//

BOOL  CNiDevice::startRecorde(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (appParam.saveDataMode==FileDataONI) {
			ret = openni_win->start_Recorde((char*)openni_win->saveTempFilePath.buf, appParam.isUseImage);
		}
		else if (appParam.saveDataMode==FileDataBVH) {
			copy_s2Buffer("This BVH mode is not implemented yet", &err_message);
		}
		else if (appParam.saveDataMode==FileDataORG) {
			copy_s2Buffer("This ORG mode is not implemented yet", &err_message);
		}
		else {
			copy_s2Buffer("Unknown Recorde Format!!", &err_message);
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (appParam.saveDataMode==FileDataONI) {
			copy_s2Buffer("Can not treat ONI file with Kinect SDK Lib", &err_message);
		}
		else if (appParam.saveDataMode==FileDataBVH) {
			copy_s2Buffer("This BVH mode is not implemented yet", &err_message);
		}
		else if (appParam.saveDataMode==FileDataORG) {
			copy_s2Buffer("This ORG mode is not implemented yet", &err_message);
		}
		else {
			copy_s2Buffer("Unknown Recorde Format!!", &err_message);
		}
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::startRecorde ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}



void  CNiDevice::stopRecorde(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (appParam.saveDataMode==FileDataONI) {
			openni_win->stop_Recorde();
		}
		else if (appParam.saveDataMode==FileDataBVH) {
		}
		else if (appParam.saveDataMode==FileDataORG) {
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->nop();
		#endif
	}

	return;
}



int   CNiDevice::backupRecordeTempFile(char* backup_file)
{
	int ret = 0;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = copyFileWithCounter((char*)openni_win->saveTempFilePath.buf, backup_file);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		#endif
	}

	return ret;
}



void   CNiDevice::deleteRecordeTempFile()
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->deleteRecordeTempFile();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		//unkink(KINECT_RECORDE_TEMP_FILE);
		#endif
	}

	return;
}




BOOL  CNiDevice::openLoadFile(char* fname)
{
	BOOL ret = FALSE;
	loaded_data = FALSE;

	NiFileType fd = checkFileType(fname);

	if (fd==FileDataBVH) {
		copy_s2Buffer("BVH file is not implemented yet", &err_message);
	}
	
	//
	else if (fd==FileDataORG) {
		copy_s2Buffer("ORG file is not implemented yet", &err_message);
	}

	//
	else if (fd==FileDataONI) {
		//
		if (nowSDKLib==NiSDK_OpenNI) {
			#ifdef ENABLE_OPENNI
			ret = makeFileDevice(fname);
			if (ret) {
				openni_win->device->player->SetRepeat(TRUE);
				openni_win->device->player->SeekToTimeStamp(0, XN_PLAYER_SEEK_SET);
				prvNiInputDevice = inputDevice;
				inputDevice = NiDevice_File;
				loaded_data = TRUE;
			}
			else {
				CString mesg = LoadString_byID(IDS_STR_ERR_UNKNOWN_FILE);
				copy_s2Buffer((char*)(LPCSTR)mesg, &err_message);
			}
			#endif
		}
		else {
			CString mesg = LoadString_byID(IDS_STR_ERR_LIB_LOAD_FILE);
			copy_s2Buffer((char*)(LPCSTR)mesg, &err_message);
		}
	}

	//
	else {
		CString mesg = LoadString_byID(IDS_STR_ERR_UNKNOWN_FILE);
		copy_s2Buffer((char*)(LPCSTR)mesg, &err_message);
	}

	return ret;
}






//////////////////////////////////////////////////////////////////////////////////////////
//
// USB
//

BOOL  CNiDevice::openUSBDevice(void)
{
	enableUSBDev = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		enableUSBDev = openni_win->openUSBDevice();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		enableUSBDev = kinect_sdk->openUSBDevice();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::openUSBDevice ERROR: Unknown Library Type.", &err_message);
	}

	return enableUSBDev;
}



//
void  CNiDevice::closeUSBDevice(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->closeUSBDevice();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->closeUSBDevice();
		#endif
	}
	
	enableUSBDev = FALSE;
	return;
}



void  CNiDevice::setTiltMotor(int ang)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setTiltMotor(ang);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->setTiltMotor(ang);
		#endif
	}

	return;
}


	
void  CNiDevice::setLEDColor(int col)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->setLEDColor(col);
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->nop();
		#endif
	}

	return;
}



void  CNiDevice::setUseMotor(BOOL use)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->m_use_motor = use;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->m_use_motor = use;
		#endif
	}

	return;
}



void  CNiDevice::setUseLED(BOOL use)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->m_use_led = use;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->m_use_led = use;
		#endif
	}

	return;
}





//////////////////////////////////////////////////////////////////////////////////////////
//
// File Device
//

BOOL  CNiDevice::makeFileDevice(char* fname)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->makeFileDevice(fname);
		if (ret) {
			image_xsize = openni_win->device->outputMode.nXRes;
			image_ysize = openni_win->device->outputMode.nYRes;
			image_fps   = openni_win->device->outputMode.nFPS;
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->nop();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::makeFileDevice ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}




BOOL  CNiDevice::restoreDevice(void)
{
	BOOL ret = FALSE;

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->restoreDevice();
		if (ret) {
			image_xsize = openni_win->device->outputMode.nXRes;
			image_ysize = openni_win->device->outputMode.nYRes;
			image_fps   = openni_win->device->outputMode.nFPS;
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->nop();
		#endif
	}
	else {
		copy_s2Buffer("CNiDevice::restoreDevice ERROR: Unknown Library Type.", &err_message);
	}

	return ret;
}







//////////////////////////////////////////////////////////////////////////////////////////
//
//
//

UINT  niDeviceEventLoop(LPVOID pParam)
{
	UINT  ret = 1;
	if (pParam==NULL) return ret;

	CNiDevice* niDevice = (CNiDevice*)pParam;

	if (niDevice->nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openniEventLoop((LPVOID)niDevice->openni_win);
        #endif
	}
	//
	else if (niDevice->nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		ret = kinectEventLoop((LPVOID)niDevice->kinect_sdk);
        #endif
	}

	if (ret>0) {
		MessageBox(niDevice->hWnd, niDevice->getErrorMessage(), "Error", MB_OK);
	}

	return ret;
}