#include  "stdafx.h"

#include  "resource.h"
#include  "NiObjects/NiDevice.h"
#include  "MFCio.h"
#include  "ExClass.h"

#include  "NiTool.h"
#include  "WinTools.h"
#include  "MessageBoxDLG.h"
#include  "Dialog/FilePlayerDLG.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;
	nifile_dev	   = NULL;
	niexport_data  = NULL;

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

	locked_sensor  = FALSE;

	niNetwork	   = NULL;
	sharedMem	   = NULL;

	hWnd		   = NULL;
	enableUSBDev   = FALSE;

	has_device	   = FALSE;
	loaded_oni	   = FALSE;

	inputDevice	   = NiDevice_NI;
	prvInputDevice = NiDevice_NI;
	err_message    = _T("");

	appParam.init();

	flpParam.repeat		 = TRUE;
	flpParam.mirroring   = TRUE;
	flpParam.calc_quat   = FALSE;
	flpParam.cm_unit     = FALSE;
	flpParam.init_pos    = FALSE;
	flpParam.time_scale  = 1.0f;
	//
	flpParam.start_frame = 0;
	flpParam.controler   = NULL;
	flpParam.counter     = NULL;

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



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


	deleteRecordeTempFile();

	if (pSensorFrame!=NULL) {
		CExFrame* pfrm = pSensorFrame;
		setSensorFramePtr(NULL);
		while (locked_sensor) {
			::Sleep(NIDEVICE_WAIT_TIME);
			DisPatcher();	
		}
		delete(pfrm);
	}

	//
	if (pLogFrame!=NULL) {
		if (niNetwork!=NULL) niNetwork->pLogDoc = NULL;
		if (pLogFrame->pDoc!=NULL) delete(pLogFrame->pDoc);
		delete(pLogFrame);
		pLogFrame = NULL;
	}
	//
	if (pSkeletonFrame!=NULL) {
		delete(pSkeletonFrame);
		pSkeletonFrame = NULL;
	}

	//
	if (nifile_dev!=NULL) {
		delete(nifile_dev);
		nifile_dev = NULL;
	}
	if (niexport_data!=NULL) {
		delete(niexport_data);
		niexport_data = 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 = _T("");
	has_device = TRUE;

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

		err_message = mesg;
		has_device = FALSE;
	}

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

	//
	nifile_dev	  = new CExNiFileDev(nowSDKLib);
	niexport_data = new CExportNiData();
	
	#ifdef ENABLE_OPENNI
	if (openni_win!=NULL) openni_win->niExportData = niexport_data;
	#endif
	
	#ifdef ENABLE_KINECT_SDK	
	if (kinect_sdk!=NULL) kinect_sdk->niExportData = niexport_data;
	#endif
	
	if (nifile_dev!=NULL) nifile_dev->niExportData = niexport_data;

	return has_device;
}




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

	//
	else {
		if (load_lib(_T(OPENNI_NITE_DLLNAME))) {
			nowSDKLib = NiSDK_OpenNI;
		}
		else if (load_lib(_T(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 {
		err_message = _T("CNiDevice::init_device ERROR: Unknown Library Type.");
	}

	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(LPCTSTR lib_name)
{
	if (LoadLibrary(lib_name)==NULL) return FALSE;

	char* mbstr = ts2mbs(lib_name);
	HRESULT ret = __HrLoadAllImportsForDll(mbstr);
	::free(mbstr);

	if (FAILED(ret)) return FALSE;
	return TRUE;
}





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

NiFileType  CNiDevice::checkFileType(LPCTSTR fname)
{
	char buf[LSNAME];		// 32
	memset(buf, 0, LSNAME);

	FILE* fp = tfopen(fname, _T("rb"));
	if (fp==NULL) return FileDataUnknown;
	fread(buf, LSNAME, 1, fp);
	fclose(fp);

	if      (!strncasecmp(buf, BVH_FILE_HIRCHY_ID, strlen(BVH_FILE_HIRCHY_ID))) {
		return FileDataBVH;
	}
	else if (!strncasecmp(buf, NI_JTXT_FILE_ID, strlen(NI_JTXT_FILE_ID))) {
		return FileDataJTXT;
	}
	else if (!strncasecmp(buf, VMD_FILE_HD_ID2, strlen(VMD_FILE_HD_ID2))) {
		return FileDataVMD2;
	}
	return FileDataONI;
}



void  CNiDevice::execFilePlayer(BOOL login)
{
	CFilePlayerDLG* player = new CFilePlayerDLG(this, login, flpParam);
	if (player!=NULL) {
		player->DoModal();
		flpParam = player->getParameter();
		delete(player);

	}
	sharedMem->clearLocalAnimationData();
	nifile_dev->clearFrameData();
}



int  CNiDevice::execLoadedData(BOOL login, FileDevParam param)
{
	if (login) niNetwork->openSendSocket();

	// 戻り値：　正: 最後のフレームの次のフレームの番号, 負: エラー
	int ret = nifile_dev->convertJointsData(niNetwork, param);
	if (ret<0) {
		*(param.controler) = NI_FILE_PLAYER_STOP;
		err_message = LoadString_byID(IDS_STR_ERR_NEXT_FRAME);
	}

	niNetwork->closeSendSocket();
	return ret;
}




float  CNiDevice::getLocalFPS(void)
{
	if (niexport_data!=NULL) return niexport_data->frameRate;
	else return 0.0f;
}



void  CNiDevice::clearLocalFPS(void)
{
	if (niexport_data!=NULL) niexport_data->clear();
	SendWinMessage(WM_USER_LCLFPS_UPDATE);
}









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

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

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (openni_win!=NULL) {
			openni_win->setParameter(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);
			setUseImage(param.isUseImage);
			setMirroring(param.isMirroring);
			setUseMotor(param.useDevMotor);
			setUseLED(param.useDevLED);
		}
		#endif
	}

	if (niexport_data!=NULL) {
		if (param.outDataFPS>1) {
			int period = Max(1000/(param.outDataFPS-1), 25);	// 最小 25ms, 最大 40FPS
			if (period!=niexport_data->outPeriod) {
				niexport_data->modTime = 0;
				niexport_data->outPeriod = period;
			}
		}
		niexport_data->ctrlFPS = param.outCtrlFPS;
	}
	
	return;
}



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

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		ret = openni_win->initRingBuffer();
		if (!ret) err_message = openni_win->get_err_message();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		ret = kinect_sdk->initRingBuffer();
		if (!ret) err_message = kinect_sdk->get_err_message();
		#endif
	}

	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_mirroring = appParam.isMirroring;
		#endif
	}

	return;
}
*/



CString  CNiDevice::getErrorMessage(BOOL dev)
{
	if (dev) {
		//
		if (nowSDKLib==NiSDK_OpenNI) {
			#ifdef ENABLE_OPENNI
			if (openni_win!=NULL) err_message = openni_win->get_err_message();
			#endif
		}
		//
		else if (nowSDKLib==NiSDK_Kinect) {
			#ifdef ENABLE_KINECT_SDK
			if (kinect_sdk!=NULL) err_message = kinect_sdk->get_err_message();
			#endif
		}
	}
	
	return err_message;
}




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::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::clearJointsData(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->clearJointsData();
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->clearJointsData();
		#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(CExTextFrame* 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)
{
	niNetwork = 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)
{
	sharedMem = 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;
}



void  CNiDevice::setNiFileDev(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		openni_win->niFileDev = nifile_dev;
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		kinect_sdk->niFileDev = nifile_dev;
		#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 {
		err_message = _T("CNiDevice::createImage ERROR: Unknown Library Type.");
	}

	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 {
		err_message = _T("CNiDevice::createDepth ERROR: Unknown Library Type.");
	}

	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 {
		err_message = _T("CNiDevice::hasImage ERROR: Unknown Library Type.");
	}

	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 {
		err_message = _T("CNiDevice::hasDepth ERROR: Unknown Library Type.");
	}

	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;
	clearLocalFPS();

	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 {
		err_message = _T("CNiDevice::startDetection ERROR: Unknown Library Type.");
	}

	return ret;
}



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

	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 {
		err_message = _T("CNiDevice::stopDetection ERROR: Unknown Library Type.");
	}

	return ret;
}



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

	return;
}







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

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

	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (appParam.saveDataMode==FileDataONI) {
			char* mbstr = ts2mbs(openni_win->tempFilePath);
			ret = openni_win->start_Recorde(mbstr, appParam.isUseImage);
			::free(mbstr);
			openni_win->dataSaving = ret;
		}
		else if (appParam.saveDataMode==FileDataBVH || appParam.saveDataMode==FileDataJTXT) {
			if (nifile_dev!=NULL) {
				ret = nifile_dev->openTempJointsFile();
				openni_win->dataSaving = ret;
			}
			else {
				err_message = _T("NiFile Class is NULL.");
			}
		}
		else {
			err_message = _T("Unknown Recorde Format!!");
		}
		#endif
	}

	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (appParam.saveDataMode==FileDataONI) {
			err_message = _T("Can not treat ONI file with Kinect SDK Lib");
		}
		else if (appParam.saveDataMode==FileDataBVH || appParam.saveDataMode==FileDataJTXT) {
			if (nifile_dev!=NULL) {
				ret = nifile_dev->openTempJointsFile();
				kinect_sdk->dataSaving = ret;
			}
			else {
				err_message = _T("NiFile Class is NULL.");
			}
		}
		else {
			err_message = _T("Unknown Recorde Format!!");
		}
		#endif
	}

	//
	else {
		err_message = _T("CNiDevice::startRecorde ERROR: Unknown Library Type.");
	}

	return ret;
}



void  CNiDevice::stopRecorde(void)
{
	if (nowSDKLib==NiSDK_OpenNI) {
		#ifdef ENABLE_OPENNI
		if (appParam.saveDataMode==FileDataONI) {
			openni_win->dataSaving = FALSE;
			openni_win->stop_Recorde();
		}
		else if (appParam.saveDataMode==FileDataBVH || appParam.saveDataMode==FileDataJTXT) {
			if (nifile_dev!=NULL) {
				openni_win->dataSaving = FALSE;
				::Sleep(NIDEVICE_WAIT_TIME);
				nifile_dev->closeTempJointsFile();
			}
		}
		#endif
	}
	//
	else if (nowSDKLib==NiSDK_Kinect) {
		#ifdef ENABLE_KINECT_SDK
		if (appParam.saveDataMode==FileDataBVH || appParam.saveDataMode==FileDataJTXT) {
			if (nifile_dev!=NULL) {
				kinect_sdk->dataSaving = FALSE;
				::Sleep(NIDEVICE_WAIT_TIME);
				nifile_dev->closeTempJointsFile();
			}
		}
		#endif
	}

	return;
}



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

	// Original Format
	if (appParam.saveDataMode==FileDataJTXT) {
		if (nifile_dev!=NULL) {
			ret = nifile_dev->backupAsOrig(backup_file);
		}
	}
	
	// BVH
	else if (appParam.saveDataMode==FileDataBVH) {		
		if (nifile_dev!=NULL) {
			ret = nifile_dev->backupAsBVH(backup_file);
		}
	}

	// ONI
	else if (appParam.saveDataMode==FileDataONI) {
		if (nowSDKLib==NiSDK_OpenNI) {
			#ifdef ENABLE_OPENNI
			ret = copyFileWithCounter((LPCTSTR)openni_win->tempFilePath, backup_file);
			#endif
		}
		//else if (nowSDKLib==NiSDK_Kinect) {
		//	#ifdef ENABLE_KINECT_SDK
		//	#endif
		//}
	}

	return ret;
}



void   CNiDevice::deleteRecordeTempFile()
{
	// Original or BVH
	if (appParam.saveDataMode==FileDataBVH || appParam.saveDataMode==FileDataJTXT) {
		if (nifile_dev!=NULL) {
			nifile_dev->deleteRecordeTempFile();
		}
	}
	
	// ONI
	else if (appParam.saveDataMode==FileDataONI) {
		if (nowSDKLib==NiSDK_OpenNI) {
			#ifdef ENABLE_OPENNI
			openni_win->deleteRecordeTempFile();
			#endif
		}
		//else if (nowSDKLib==NiSDK_Kinect) {
		//	#ifdef ENABLE_KINECT_SDK
		//	#endif
		//}
	}

	return;
}




BOOL  CNiDevice::openLoadFile(LPCTSTR fname)
{
	BOOL ret   = FALSE;
	loaded_oni = FALSE;

	NiFileType fd = checkFileType(fname);

	// BVH
	if (fd==FileDataBVH) {
		int num = 0;
		if (nifile_dev!=NULL) {
			num = nifile_dev->readBVHFile(fname);
		}

		if (num>0) ret = TRUE;
		else err_message = _T("Rrad BVH File Error!!");
	}

	// MMD VMD2
	else if (fd==FileDataVMD2) {
		int num = 0;
		if (nifile_dev!=NULL) {
			num = nifile_dev->readVMDFile(fname);
		}

		if (num>0) ret = TRUE;
		else err_message = _T("Rrad MMD VMD2 File Error!!");
	}

	// Joints Text
	else if (fd==FileDataJTXT) {
		int num = 0;
		if (nifile_dev!=NULL) {
			num = nifile_dev->readJointsTextFile(fname);
		}

		if (num>0) ret = TRUE;
		else err_message = _T("Rrad Text Joints File Error!!");
	}

	// ONI
	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);
				prvInputDevice = inputDevice;
				inputDevice = NiDevice_File;
				loaded_oni = TRUE;
			}
			else {
				err_message = LoadString_byID(IDS_STR_ERR_UNKNOWN_FILE);
				}
			#endif
		}
		else {
			err_message = LoadString_byID(IDS_STR_ERR_LIB_LOAD_FILE);
		}
	}

	//
	else {
		err_message = LoadString_byID(IDS_STR_ERR_UNKNOWN_FILE);
	}

	return ret;
}




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

BOOL  CNiDevice::openUSBDevice(void)
{
	enableUSBDev = FALSE;
//	return 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 {
		err_message = _T("CNiDevice::openUSBDevice ERROR: Unknown Library Type.");
	}

	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(LPCTSTR 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 {
		err_message = _T("CNiDevice::makeFileDevice ERROR: Unknown Library Type.");
	}

	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 {
		err_message = _T("CNiDevice::restoreDevice ERROR: Unknown Library Type.");
	}

	return ret;
}







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

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

	ret = ExecDocFrmView(niDevice->pSensorFrame);
	if (ret>0) {
		ExecDocFrmViewError(niDevice->hWnd, ret);
		return ret;
	}

	niDevice->locked_sensor = TRUE;
	//
	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
	}
	niDevice->locked_sensor = FALSE;

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

	return ret;
}