XnStatus DepthPanasonic::StartGenerating()
{
XnStatus nRetVal = XN_STATUS_OK;
m_bGenerating = TRUE;
// start scheduler thread
nRetVal = xnOSCreateThread(SchedulerThread, this, &m_hScheduler);
if (nRetVal != XN_STATUS_OK)
{
m_bGenerating = FALSE;
return (nRetVal);
}
m_generatingEvent.Raise();
// Inicializa a câmera
if (InitImageDriver() != 0) {
return XN_STATUS_DEVICE_NOT_CONNECTED;
}
// Define a frequência da luz (evitar interferênia com outras)
if (Freqmode () != 1){
ChangeFreq (1);
}
// Acorda a câmera
if (Sleepmode () == 0){
ChangeSleep (1);
}
return (XN_STATUS_OK);
}
XN_C_API XnStatus xnSchedulerStart(XnScheduler** ppScheduler)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_OUTPUT_PTR(ppScheduler);
*ppScheduler = NULL;
// allocate handle
XnScheduler* pScheduler = NULL;
XN_VALIDATE_CALLOC(pScheduler, XnScheduler, 1);
// create event
nRetVal = xnOSCreateEvent(&pScheduler->hWakeThreadEvent, FALSE);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
// create critical section
nRetVal = xnOSCreateCriticalSection(&pScheduler->hCriticalSection);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
// start thread
nRetVal = xnOSCreateThread(xnSchedulerThreadFunc, (XN_THREAD_PARAM)pScheduler, &pScheduler->hThread);
XN_CHECK_RC_AND_FREE(nRetVal, pScheduler);
*ppScheduler = pScheduler;
return (XN_STATUS_OK);
}
XnStatus xnUSBPlatformSpecificInit()
{
xnLogVerbose(XN_MASK_USB, "Initializing USB...");
// initialize the library
int rc = libusb_init(&g_InitData.pContext);
if (rc != 0)
{
return (XN_STATUS_USB_INIT_FAILED);
}
XnStatus nRetVal = xnOSCreateCriticalSection(&g_InitData.hLock);
XN_IS_STATUS_OK(nRetVal);
#ifdef XN_USE_UDEV
// initialize the UDEV Events thread
g_bShouldRunUDEVThread = true;
nRetVal = xnOSCreateThread(xnUSBUDEVEventsThread, NULL, &g_hUDEVThread);
if (nRetVal != XN_STATUS_OK)
{
g_hUDEVThread = NULL;
g_bShouldRunUDEVThread = false;
// clean-up
xnUSBPlatformSpecificShutdown();
return nRetVal;
}
#endif
//libusb_set_debug(g_InitData.pContext, 3);
xnLogInfo(XN_MASK_USB, "USB is initialized.");
return (XN_STATUS_OK);
}
XnStatus xnUSBAsynchThreadAddRef()
{
XnStatus nRetVal = XN_STATUS_OK;
xnl::AutoCSLocker locker(g_InitData.hLock);
++g_InitData.nOpenDevices;
if (g_InitData.hThread == NULL)
{
xnLogVerbose(XN_MASK_USB, "Starting libusb asynch thread...");
// mark thread should run
g_InitData.bShouldThreadRun = TRUE;
// and start thread
nRetVal = xnOSCreateThread(xnUSBHandleEventsThread, NULL, &g_InitData.hThread);
if (nRetVal != XN_STATUS_OK)
{
// clean-up
xnUSBPlatformSpecificShutdown();
return nRetVal;
}
// set thread priority to critical
nRetVal = xnOSSetThreadPriority(g_InitData.hThread, XN_PRIORITY_CRITICAL);
if (nRetVal != 0)
{
xnLogWarning(XN_MASK_USB, "USB events thread: Failed to set thread priority to critical. This might cause loss of data...");
printf("Warning: USB events thread - failed to set priority. This might cause loss of data...\n");
}
}
return (XN_STATUS_OK);
}
OniStatus Recorder::initialize(const char* fileName)
{
m_fileName = fileName;
// Probe if we can actually open the file.
XN_FILE_HANDLE fileHandle = XN_INVALID_FILE_HANDLE;
XnStatus status = xnOSOpenFile(
/* file name = */ fileName,
/* open flags = */ XN_OS_FILE_WRITE | XN_OS_FILE_TRUNCATE,
/* out handle = */ &fileHandle);
if (XN_STATUS_OK != status)
{
return ONI_STATUS_ERROR;
}
xnOSCloseFile(&fileHandle);
m_assembler.initialize();
status = xnOSCreateThread(threadMain, this, &m_thread);
if (XN_STATUS_OK != status)
{
return ONI_STATUS_ERROR;
}
send(Message::MESSAGE_INITIALIZE);
return ONI_STATUS_OK;
}
XN_C_API XnStatus xnProfilingInit(XnUInt32 nProfilingInterval)
{
XnStatus nRetVal = XN_STATUS_OK;
if (nProfilingInterval == 0)
{
xnProfilingShutdown();
}
else if (!g_ProfilingData.bInitialized)
{
g_ProfilingData.nMaxSectionName = 0;
g_ProfilingData.nSectionCount = 0;
g_ProfilingData.nProfilingInterval = nProfilingInterval;
g_ProfilingData.bKillThread = FALSE;
XN_VALIDATE_CALLOC(g_ProfilingData.aSections, XnProfiledSection, MAX_PROFILED_SECTIONS);
g_ProfilingData.nSectionCount = 0;
nRetVal = xnOSCreateThread(xnProfilingThread, (XN_THREAD_PARAM)NULL, &g_ProfilingData.hThread);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&g_ProfilingData.hCriticalSection);
XN_IS_STATUS_OK(nRetVal);
g_ProfilingData.bInitialized = TRUE;
}
return XN_STATUS_OK;
}
XnStatus XnServerSession::Init()
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_privateIncomingPacker.Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_privateOutgoingPacker.Init();
XN_IS_STATUS_OK(nRetVal);
nRetVal = XnStreamDataSetCreate(&m_pStreamDataSet);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hCommLock);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hStreamsLock);
XN_IS_STATUS_OK(nRetVal);
// start thread
nRetVal = xnOSCreateThread(ServeThreadCallback, this, &m_hThread);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
VideoStream::VideoStream(void* streamHandle, const OniSensorInfo* pSensorInfo, Device& device, const DriverHandler& libraryHandler, xnl::ErrorLogger& errorLogger) :
m_errorLogger(errorLogger),
m_pSensorInfo(NULL),
m_running(true),
m_device(device),
m_driverHandler(libraryHandler),
m_streamHandle(streamHandle),
m_pContextNewFrameEvent(NULL),
m_started(FALSE)
{
xnOSCreateEvent(&m_newFrameInternalEvent, false);
xnOSCreateEvent(&m_newFrameInternalEventForFrameHolder, false);
xnOSCreateThread(newFrameThread, this, &m_newFrameThread);
m_pSensorInfo = XN_NEW(OniSensorInfo);
m_pSensorInfo->sensorType = pSensorInfo->sensorType;
m_pSensorInfo->numSupportedVideoModes = pSensorInfo->numSupportedVideoModes;
m_pSensorInfo->pSupportedVideoModes = XN_NEW_ARR(OniVideoMode, m_pSensorInfo->numSupportedVideoModes);
xnOSMemCopy(m_pSensorInfo->pSupportedVideoModes, pSensorInfo->pSupportedVideoModes, sizeof(OniVideoMode)*m_pSensorInfo->numSupportedVideoModes);
m_driverHandler.streamSetNewFrameCallback(m_streamHandle, stream_NewFrame, this);
m_driverHandler.streamSetPropertyChangedCallback(m_streamHandle, stream_PropertyChanged, this);
refreshWorldConversionCache();
}
OniStatus start()
{
m_osEvent.Create(TRUE);
xnOSCreateThread(threadFunc, this, &m_threadHandle);
return ONI_STATUS_OK;
}
XnStatus XnVMessageListener::RunAsThread()
{
XnStatus rc = xnOSCreateThread(MessageListenerThread, this, &m_hActivityThread);
if (rc == XN_STATUS_OK)
{
m_bInternalThreadAlive = true;
}
return rc;
} // XnVMessageListener::RunAsThread
XnStatus XnServerSensorInvoker::Init(const XnChar* strDevicePath, const XnChar* strGlobalConfigFile, XnUInt32 nAdditionalProps, XnProperty** aAdditionalProps)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = m_sensor.SetGlobalConfigFile(strGlobalConfigFile);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hSensorLock);
XN_IS_STATUS_OK(nRetVal);
XnDeviceConfig config;
config.DeviceMode = XN_DEVICE_MODE_READ;
config.cpConnectionString = strDevicePath;
config.pInitialValues = NULL;
config.SharingMode = XN_DEVICE_SHARED;
nRetVal = m_sensor.Init(&config);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_sensor.DeviceModule()->AddProperties(aAdditionalProps, nAdditionalProps);
XN_IS_STATUS_OK(nRetVal);
XnProperty* aInvokerAdditionalProps[] = { &m_numberOfBuffers, &m_allowOtherUsers };
nRetVal = m_sensor.DeviceModule()->AddProperties(aInvokerAdditionalProps, sizeof(aInvokerAdditionalProps) / sizeof(aInvokerAdditionalProps[0]));
XN_IS_STATUS_OK(nRetVal);
// configure from global file
nRetVal = m_sensor.ConfigureModuleFromGlobalFile(XN_MODULE_NAME_DEVICE, XN_SENSOR_SERVER_CONFIG_FILE_SECTION);
XN_IS_STATUS_OK(nRetVal);
// register to events
XnCallbackHandle hDummy = NULL;
nRetVal = m_sensor.OnStreamCollectionChangedEvent().Register(StreamCollectionChangedCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
nRetVal = m_sensor.OnNewStreamDataEvent().Register(NewStreamDataCallback, this, hDummy);
XN_IS_STATUS_OK(nRetVal);
// register to all properties
XN_PROPERTY_SET_CREATE_ON_STACK(props);
nRetVal = m_sensor.DeviceModule()->GetAllProperties(&props);
XN_IS_STATUS_OK(nRetVal);
nRetVal = RegisterToProps(&props);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateEvent(&m_hNewDataEvent, FALSE);
XN_IS_STATUS_OK(nRetVal);
// start reader thread
nRetVal = xnOSCreateThread(ReaderThread, this, &m_hReaderThread);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Code
//---------------------------------------------------------------------------
XnStatus xnUSBPlatformSpecificInit()
{
XnStatus nRetVal = XN_STATUS_OK;
// give a unique class name (there might be multiple instances of this code in multiple DLLs)
char className[MAX_PATH];
sprintf_s(className, "xnUsbDeviceDetector%x", &g_xnUsbhModule);
WNDCLASS wc;
wc.style = 0;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = (HINSTANCE)g_xnUsbhModule;
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
wc.lpfnWndProc = DevDetectWndProc;
wc.hIcon = NULL;
wc.hCursor = NULL;
g_xnClass = RegisterClass(&wc);
if (g_xnClass)
{
HANDLE hWaitEv = CreateEvent(NULL,FALSE,FALSE,NULL);
g_bUsbDevDetectShoudRun = TRUE;
nRetVal = xnOSCreateThread(DevDetectThread, hWaitEv, &g_xnUsbhPnThread);
XN_IS_STATUS_OK(nRetVal);
WaitForSingleObject(hWaitEv,INFINITE);
CloseHandle(hWaitEv);
}
else
{
return (XN_STATUS_USB_FAILED_TO_REGISTER_CALLBACK);
}
DEV_BROADCAST_DEVICEINTERFACE NotificationFilter;
ZeroMemory( &NotificationFilter, sizeof(NotificationFilter) );
NotificationFilter.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
NotificationFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
NotificationFilter.dbcc_classguid = GUID_CLASS_PSDRV_USB;
RegisterDeviceNotification(g_xnUsbhDevDetectWnd, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
return (XN_STATUS_OK);
}
void kinectWeb::setup() {
ofSetLogLevel(OF_LOG_VERBOSE);
ofLog(OF_LOG_VERBOSE, "Start setup()");
// 画面の初期化
ofSetFrameRate(30);
ofBackground(255, 255, 255);
ofSetWindowShape(640, 480);
ofEnableSmoothing();
// ofxOpenNIの初期化
context.setup();
depthGenerator.setup(&context);
imageGenerator.setup(&context);
userGenerator.setup(&context);
userGenerator.setUseMaskPixels(true);
context.toggleRegisterViewport();
context.toggleMirror();
#ifdef TARGET_OSX
hardware.setup();
hardware.setLedOption(LED_BLINK_GREEN);
#endif
// メモリ確保
grayPixels = new unsigned char[640 * 480];
xnOSMemSet(grayPixels, 0, 640 * 480 * sizeof(unsigned char));
saveImage.allocate(640, 480, OF_IMAGE_COLOR);
// ソケットの初期化
try {
clients.bind("tcp://*:5555");
ofLog(OF_LOG_NOTICE, "Open ZMQ Sokcet at 5555");
} catch (zmq::error_t e) {
ofLog(OF_LOG_ERROR, (string)e.what());
}
// 通信用ワーカースレッドの作成
XnStatus rc = xnOSCreateThread(workerThread,
(XN_THREAD_PARAM)NULL,
&threadHandle);
if (rc != XN_STATUS_OK) {
ofLog(OF_LOG_ERROR, xnGetStatusString(rc));
}
}
XnStatus SampleDepth::StartGenerating()
{
XnStatus nRetVal = XN_STATUS_OK;
m_bGenerating = TRUE;
// start scheduler thread
nRetVal = xnOSCreateThread(SchedulerThread, this, &m_hScheduler);
if (nRetVal != XN_STATUS_OK)
{
m_bGenerating = FALSE;
return (nRetVal);
}
m_generatingEvent.Raise();
return (XN_STATUS_OK);
}
// Initialize the driver
// ドライバを初期化する
virtual OniStatus initialize(
oni::driver::DeviceConnectedCallback connectedCallback,
oni::driver::DeviceDisconnectedCallback disconnectedCallback,
oni::driver::DeviceStateChangedCallback deviceStateChangedCallback,
void* pCookie)
{
oni::driver::DriverBase::initialize(connectedCallback, disconnectedCallback, deviceStateChangedCallback, pCookie);
// Connect to the DepthSense device
// DepthSense デバイスに接続する
m_context = DepthSense::Context::create("localhost");
// Enumerate the connected devices
// 接続されているデバイスの情報を作成する
m_depthSenseDevices = m_context.getDevices();
int deviceIndex = 0;
for ( auto it = m_depthSenseDevices.begin(); it != m_depthSenseDevices.end(); ++it ) {
// Populate the device information
// デバイス情報をコピーする
OniDeviceInfo* pInfo = XN_NEW(OniDeviceInfo);
xnOSStrCopy(pInfo->vendor, "DepthSense", ONI_MAX_STR);
xnOSStrCopy(pInfo->name, DepthSense::Device::Model_toString( it->getModel() ).c_str(), ONI_MAX_STR);
XnUInt32 uriLen;
xnOSStrFormat(pInfo->uri, ONI_MAX_STR, &uriLen, "%s/%d", pInfo->name, deviceIndex++);
// Register the device information with the map
// デバイス情報を登録する
m_devices[pInfo] = NULL;
// Raise events
// デバイスの接続を通知する
deviceConnected(pInfo);
deviceStateChanged(pInfo, 0);
}
// Create the thread for main loop
// デバイスのメインループ用スレッドを生成する
xnOSCreateThread(threadFunc, this, &m_threadHandle);
return ONI_STATUS_OK;
}
XnStatus SocketInConnection::Connect()
{
XnStatus nRetVal = XN_STATUS_OK;
Disconnect(); // In case we're already connected
nRetVal = xnOSCreateThread(&ReadThreadProc, this, &m_hReadThread);
XN_IS_STATUS_OK_LOG_ERROR("Create input socket read thread", nRetVal);
xnLogVerbose(XN_MASK_LINK, "Waiting for connection on socket %u...", m_nPort);
nRetVal = xnOSWaitEvent(m_hConnectEvent, CONNECT_TIMEOUT);
XN_IS_STATUS_OK_LOG_ERROR("Wait for input socket to connect", nRetVal);
if (m_nConnectionStatus != XN_STATUS_OK)
{
xnLogError(XN_MASK_LINK, "Failed to connect to socket %u: %s", m_nPort, xnGetStatusString(m_nConnectionStatus));
XN_ASSERT(FALSE);
return m_nConnectionStatus;
}
xnLogVerbose(XN_MASK_LINK, "Socket %u connected.", m_nPort);
nRetVal = xnOSSetThreadPriority(m_hReadThread, XN_PRIORITY_CRITICAL);
XN_IS_STATUS_OK_LOG_ERROR("Set read thread priority", nRetVal);
return XN_STATUS_OK;
}
XnStatus XnSensorClient::InitImpl(const XnDeviceConfig* pDeviceConfig)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_MUTEX_HANDLE hServerRunningMutex = NULL;
XnOSEvent serverRunningEvent;
nRetVal = serverRunningEvent.Open(XN_SENSOR_SERVER_RUNNING_EVENT_NAME);
if (nRetVal != XN_STATUS_OK)
{
nRetVal = serverRunningEvent.Create(XN_SENSOR_SERVER_RUNNING_EVENT_NAME, TRUE);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to create server running event: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
}
nRetVal = xnOSCreateNamedMutex(&hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_NAME);
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSLockMutex(hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_TIMEOUT);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseMutex(&hServerRunningMutex);
return nRetVal;
}
XnBool bServerRunning = (serverRunningEvent.Wait(1) == XN_STATUS_OK);
nRetVal = xnOSUnLockMutex(hServerRunningMutex);
xnOSCloseMutex(&hServerRunningMutex);
XN_IS_STATUS_OK(nRetVal);
if (!bServerRunning)
{
nRetVal = StartServerProcess();
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to start server process: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
}
nRetVal = serverRunningEvent.Wait(XN_SENSOR_CLIENT_WAIT_FOR_SERVER);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Failed to wait for server to start: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
// init network
nRetVal = xnOSInitNetwork();
XN_IS_STATUS_OK(nRetVal);
nRetVal = xnOSCreateCriticalSection(&m_hLock);
XN_IS_STATUS_OK(nRetVal);
// now init
nRetVal = XnStreamReaderDevice::InitImpl(pDeviceConfig);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
m_bConnected = TRUE;
nRetVal = xnOSCreateEvent(&m_hReplyEvent, FALSE);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
nRetVal = xnOSCreateThread(ListenThread, this, &m_hListenThread);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseEvent(&m_hReplyEvent);
xnOSCloseCriticalSection(&m_hLock);
return nRetVal;
}
return (XN_STATUS_OK);
}
OniStatus start()
{
xnOSCreateThread(threadFunc, this, &m_threadHandle);
return ONI_STATUS_OK;
}
OniStatus PlayerDevice::Initialize()
{
static XnNodeNotifications notifications =
{
OnNodeAdded,
OnNodeRemoved,
OnNodeIntPropChanged,
OnNodeRealPropChanged,
OnNodeStringPropChanged,
OnNodeGeneralPropChanged,
OnNodeStateReady,
OnNodeNewData,
};
static XnPlayerInputStreamInterface inputInterface =
{
FileOpen,
FileRead,
FileSeek,
FileTell,
FileClose,
FileSeek64,
FileTell64,
};
static PlayerNode::CodecFactory codecFactory =
{
CodecCreate,
CodecDestroy
};
// Initialize the player.
XnStatus rc = m_player.Init();
if (rc != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
// Set the notifications.
rc = m_player.SetNodeNotifications(this, ¬ifications);
if (rc != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
// Set the codec factory.
rc = m_player.SetNodeCodecFactory(this, &codecFactory);
if (rc != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
// Register to end of file reached event.
XnCallbackHandle handle;
rc = m_player.RegisterToEndOfFileReached(OnEndOfFileReached, this, handle);
if (rc != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
// Set the input interface.
rc = m_player.SetInputStream(this, &inputInterface);
if (rc != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
// Create thread for running the player.
XnStatus status = xnOSCreateThread(ThreadProc, this, &m_threadHandle);
if (status != XN_STATUS_OK)
{
return ONI_STATUS_ERROR;
}
return ONI_STATUS_OK;
}
