//---------------------------------------------------------------------------
// XnSensorImageStream class
//---------------------------------------------------------------------------
XnSensorImageStream::XnSensorImageStream(const XnChar* strDeviceName, const XnChar* StreamName, XnSensorObjects* pObjects, XnUInt32 nBufferCount, XnBool bAllowOtherUsers) :
XnImageStream(StreamName, FALSE),
m_Helper(pObjects),
m_BufferPool(nBufferCount, strDeviceName, StreamName, GetMaxBufferSize(m_Helper.GetFirmwareVersion()), bAllowOtherUsers),
m_SharedBufferName(XN_STREAM_PROPERTY_SHARED_BUFFER_NAME, m_BufferPool.GetSharedMemoryName()),
m_InputFormat(XN_STREAM_PROPERTY_INPUT_FORMAT, XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT),
m_AntiFlicker(XN_STREAM_PROPERTY_FLICKER, XN_IMAGE_STREAM_DEFAULT_FLICKER),
m_ImageQuality(XN_STREAM_PROPERTY_QUALITY, XN_IMAGE_STREAM_DEFAULT_QUALITY),
m_Brightness(XN_STREAM_PROPERTY_BRIGHTNESS, XN_IMAGE_STREAM_DEFAULT_BRIGHTNESS),
m_Contrast(XN_STREAM_PROPERTY_CONTRAST, XN_IMAGE_STREAM_DEFAULT_CONTRAST),
m_Saturation(XN_STREAM_PROPERTY_SATURATION, XN_IMAGE_STREAM_DEFAULT_SATURATION),
m_Sharpness(XN_STREAM_PROPERTY_SHARPNESS, XN_IMAGE_STREAM_DEFAULT_SHARPNESS),
m_ColorTemperature(XN_STREAM_PROPERTY_COLOR_TEMPERATURE, XN_IMAGE_STREAM_DEFAULT_COLOR_TEMP),
m_BackLightCompensation(XN_STREAM_PROPERTY_BACKLIGHT_COMPENSATION, XN_IMAGE_STREAM_DEFAULT_BACKLIGHT_COMP),
m_Gain(XN_STREAM_PROPERTY_GAIN, XN_IMAGE_STREAM_DEFAULT_GAIN),
m_Zoom(XN_STREAM_PROPERTY_ZOOM, XN_IMAGE_STREAM_DEFAULT_ZOOM),
m_Exposure(XN_STREAM_PROPERTY_EXPOSURE, XN_IMAGE_STREAM_DEFAULT_EXPOSURE_BAR),
m_Pan(XN_STREAM_PROPERTY_PAN, XN_IMAGE_STREAM_DEFAULT_PAN),
m_Tilt(XN_STREAM_PROPERTY_TILT, XN_IMAGE_STREAM_DEFAULT_TILT),
m_LowLightCompensation(XN_STREAM_PROPERTY_LOW_LIGHT_COMPENSATION, XN_IMAGE_STREAM_DEFAULT_LOW_LIGHT_COMP),
m_FirmwareMirror("FirmwareMirror", FALSE, StreamName),
m_FirmwareCropSizeX("FirmwareCropSizeX", 0, StreamName),
m_FirmwareCropSizeY("FirmwareCropSizeY", 0, StreamName),
m_FirmwareCropOffsetX("FirmwareCropOffsetX", 0, StreamName),
m_FirmwareCropOffsetY("FirmwareCropOffsetY", 0, StreamName),
m_FirmwareCropEnabled("FirmwareCropEnabled", FALSE, StreamName),
m_FirmwareColorTemperature("FirmwareWhiteBalance", 0, StreamName),
m_FirmwareAutoWhiteBalance("FirmwareAutoWhiteBalance", 0, StreamName),
m_FirmwareExposure("FirmwareExposure", 0, StreamName),
m_FirmwareAutoExposure("FirmwareAutoExposure", FALSE, StreamName),
m_ActualRead(XN_STREAM_PROPERTY_ACTUAL_READ_DATA, FALSE)
{
m_ActualRead.UpdateSetCallback(SetActualReadCallback, this);
}
/*
Sets Innodb buffer pool size (1/8 of RAM by default), if not already specified
via command line.
Calculates innodb log file size as min(50, innodb buffer pool size/8)
*/
extern "C" UINT __stdcall PresetDatabaseProperties(MSIHANDLE hInstall)
{
unsigned long long InnodbBufferPoolSize= 256;
unsigned long long InnodbLogFileSize= 50;
wchar_t buff[MAX_PATH];
UINT er = ERROR_SUCCESS;
HRESULT hr= S_OK;
MEMORYSTATUSEX memstatus;
hr = WcaInitialize(hInstall, __FUNCTION__);
ExitOnFailure(hr, "Failed to initialize");
WcaLog(LOGMSG_STANDARD, "Initialized.");
/* Check if bufferpoolsize parameter was given on the command line*/
DWORD BufferPoolsizeParamLen = MAX_PATH;
MsiGetPropertyW(hInstall, L"BUFFERPOOLSIZE", buff, &BufferPoolsizeParamLen);
if (BufferPoolsizeParamLen && buff[0])
{
WcaLog(LOGMSG_STANDARD, "BUFFERPOOLSIZE=%s, len=%u",buff, BufferPoolsizeParamLen);
InnodbBufferPoolSize= _wtoi64(buff);
}
else
{
memstatus.dwLength = sizeof(memstatus);
if (!GlobalMemoryStatusEx(&memstatus))
{
WcaLog(LOGMSG_STANDARD, "Error %u from GlobalMemoryStatusEx",
GetLastError());
er= ERROR_INSTALL_FAILURE;
goto LExit;
}
unsigned long long totalPhys= memstatus.ullTotalPhys;
/* Give innodb 12.5% of available physical memory. */
InnodbBufferPoolSize= totalPhys/ONE_MB/8;
#ifdef _M_IX86
/*
For 32 bit processes, take virtual address space limitation into account.
Do not try to use more than 3/4 of virtual address space, even if there
is plenty of physical memory.
*/
InnodbBufferPoolSize= min(GetMaxBufferSize(totalPhys)/ONE_MB*3/4,
InnodbBufferPoolSize);
#endif
swprintf_s(buff, L"%llu",InnodbBufferPoolSize);
MsiSetPropertyW(hInstall, L"BUFFERPOOLSIZE", buff);
}
InnodbLogFileSize = min(50, InnodbBufferPoolSize);
swprintf_s(buff, L"%llu",InnodbLogFileSize);
MsiSetPropertyW(hInstall, L"LOGFILESIZE", buff);
LExit:
return WcaFinalize(er);
}
//---------------------------------------------------------------------------
// XnSensorImageStream class
//---------------------------------------------------------------------------
XnSensorImageStream::XnSensorImageStream(const XnChar* strDeviceName, const XnChar* StreamName, XnSensorObjects* pObjects, XnUInt32 nBufferCount) :
XnImageStream(StreamName, FALSE),
m_Helper(pObjects),
m_BufferPool(nBufferCount, strDeviceName, StreamName, GetMaxBufferSize(m_Helper.GetFirmwareVersion())),
m_SharedBufferName(XN_STREAM_PROPERTY_SHARED_BUFFER_NAME, m_BufferPool.GetSharedMemoryName()),
m_InputFormat(XN_STREAM_PROPERTY_INPUT_FORMAT, XN_IMAGE_STREAM_DEFAULT_INPUT_FORMAT),
m_AntiFlicker(XN_STREAM_PROPERTY_FLICKER, XN_IMAGE_STREAM_DEFAULT_FLICKER),
m_ImageQuality(XN_STREAM_PROPERTY_QUALITY, XN_IMAGE_STREAM_DEFAULT_QUALITY),
m_FirmwareMirror("FirmwareMirror", FALSE, StreamName),
m_FirmwareCropSizeX("FirmwareCropSizeX", 0, StreamName),
m_FirmwareCropSizeY("FirmwareCropSizeY", 0, StreamName),
m_FirmwareCropOffsetX("FirmwareCropOffsetX", 0, StreamName),
m_FirmwareCropOffsetY("FirmwareCropOffsetY", 0, StreamName),
m_FirmwareCropEnabled("FirmwareCropEnabled", FALSE, StreamName),
m_ActualRead(XN_STREAM_PROPERTY_ACTUAL_READ_DATA, FALSE)
{
m_ActualRead.UpdateSetCallback(SetActualReadCallback, this);
}
unsigned int NoximBuffer::getCurrentFreeSlots() const {
return (GetMaxBufferSize() - Size());
}
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
HttpRequest* HttpRequestSystem::MakeRequest(HttpRequest::Type in_type, const std::string& in_url, const std::string& in_body, const ChilliSource::ParamDictionary& in_headers, const HttpRequest::Delegate& in_delegate, u32 in_timeoutSecs)
{
CS_ASSERT(ChilliSource::Application::Get()->GetTaskScheduler()->IsMainThread() == true, "Http requests can currently only be made on the main thread");
CS_ASSERT(in_delegate != nullptr, "Cannot make an http request with a null delegate");
CS_ASSERT(in_url.empty() == false, "Cannot make an http request to a blank url");
HttpRequest* request = new HttpRequest(in_type, in_url, in_body, in_headers, in_timeoutSecs, GetMaxBufferSize(), in_delegate);
m_requests.push_back(request);
return request;
}
//--------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------
HttpRequest* HttpRequestSystem::MakeRequest(HttpRequest::Type in_type, const std::string& in_url, const std::string& in_body, const CSCore::ParamDictionary& in_headers, const HttpRequest::Delegate& in_delegate, u32 in_timeoutSecs)
{
CS_ASSERT(CSCore::Application::Get()->GetTaskScheduler()->IsMainThread() == true, "Http requests can currently only be made on the main thread");
CS_ASSERT(in_delegate != nullptr, "Cannot make an http request with a null delegate");
CS_ASSERT(in_url.empty() == false, "Cannot make an http request to a blank url");
URL_COMPONENTS urlComps;
//Initialize the URL_COMPONENTS structure.
ZeroMemory(&urlComps, sizeof(URL_COMPONENTS));
urlComps.dwStructSize = sizeof(URL_COMPONENTS);
//Set required component lengths to non-zero so that they are cracked.
urlComps.dwSchemeLength = (DWORD)-1;
urlComps.dwHostNameLength = (DWORD)-1;
urlComps.dwUrlPathLength = (DWORD)-1;
urlComps.dwExtraInfoLength = (DWORD)-1;
//Change the URL to wide string
std::wstring url(WindowsStringUtils::UTF8ToUTF16(in_url));
//Crack the URL.
if (!WinHttpCrackUrl(url.c_str(), (DWORD)url.length(), 0, &urlComps))
{
CS_LOG_FATAL("Cannot crack URL: " + in_url);
return nullptr;
}
//Weirdly the cracked URL struct only gives you the ability to crack your own URL
std::wstring hostName = urlComps.lpszHostName;
hostName = hostName.substr(0, urlComps.dwHostNameLength);
HINTERNET connectionHandle = ::WinHttpConnect(m_sessionHandle, hostName.c_str(), INTERNET_DEFAULT_PORT, 0);
if (!connectionHandle)
{
CS_LOG_ERROR("Failed to connect to server: " + in_url);
return nullptr;
}
//Set up the request based on whether it is POST or GET and whether it is SSL
LPCWSTR type = (in_type == CSNetworking::HttpRequest::Type::k_get ? L"GET" : L"POST");
HINTERNET requestHandle = 0;
std::wstring urlPath = urlComps.lpszUrlPath;
urlPath = urlPath.substr(0, urlComps.dwUrlPathLength);
if (urlComps.nScheme == INTERNET_SCHEME_HTTPS)
{
requestHandle = ::WinHttpOpenRequest(connectionHandle, type, urlPath.c_str(), L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);
if (requestHandle == nullptr || ApplySSLSettings(requestHandle) == false)
{
CS_LOG_ERROR("Failed to open request: " + in_url);
WinHttpCloseHandle(connectionHandle);
return nullptr;
}
}
else
{
requestHandle = ::WinHttpOpenRequest(connectionHandle, type, urlPath.c_str(), L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0);
if (requestHandle == nullptr)
{
CS_LOG_ERROR("Failed to open request: " + in_url);
WinHttpCloseHandle(connectionHandle);
return nullptr;
}
}
if (in_headers.empty() == false)
{
std::wstring headerBlob = ConvertHeaders(in_headers);
if (WinHttpAddRequestHeaders(requestHandle, headerBlob.c_str(), DWORD(headerBlob.length()), WINHTTP_ADDREQ_FLAG_ADD) == false)
{
CS_LOG_ERROR("Failed to add http headers: " + in_url);
WinHttpCloseHandle(requestHandle);
WinHttpCloseHandle(connectionHandle);
return nullptr;
}
}
HttpRequest* httpRequest = new HttpRequest(in_type, in_url, in_body, in_headers, in_timeoutSecs, requestHandle, connectionHandle, GetMaxBufferSize(), in_delegate);
m_requests.push_back(httpRequest);
return httpRequest;
}
/*
Checks SERVICENAME, PORT and BUFFERSIZE parameters
*/
extern "C" UINT __stdcall CheckDatabaseProperties (MSIHANDLE hInstall)
{
wchar_t ServiceName[MAX_PATH]={0};
wchar_t SkipNetworking[MAX_PATH]={0};
wchar_t QuickConfig[MAX_PATH]={0};
wchar_t Password[MAX_PATH]={0};
wchar_t EscapedPassword[2*MAX_PATH+2];
wchar_t Port[6];
wchar_t BufferPoolSize[16];
DWORD PortLen=6;
bool haveInvalidPort=false;
const wchar_t *ErrorMsg=0;
HRESULT hr= S_OK;
UINT er= ERROR_SUCCESS;
hr = WcaInitialize(hInstall, __FUNCTION__);
ExitOnFailure(hr, "Failed to initialize");
WcaLog(LOGMSG_STANDARD, "Initialized.");
DWORD ServiceNameLen = MAX_PATH;
MsiGetPropertyW (hInstall, L"SERVICENAME", ServiceName, &ServiceNameLen);
if(ServiceName[0])
{
if(ServiceNameLen > 256)
{
ErrorMsg= L"Invalid service name. The maximum length is 256 characters.";
goto LExit;
}
for(DWORD i=0; i< ServiceNameLen;i++)
{
if(ServiceName[i] == L'\\' || ServiceName[i] == L'/'
|| ServiceName[i]=='\'' || ServiceName[i] ==L'"')
{
ErrorMsg =
L"Invalid service name. Forward slash and back slash are forbidden."
L"Single and double quotes are also not permitted.";
goto LExit;
}
}
if(CheckServiceExists(ServiceName))
{
ErrorMsg=
L"A service with the same name already exists. "
L"Please use a different name.";
goto LExit;
}
}
DWORD PasswordLen= MAX_PATH;
MsiGetPropertyW (hInstall, L"PASSWORD", Password, &PasswordLen);
EscapeCommandLine(Password, EscapedPassword,
sizeof(EscapedPassword)/sizeof(EscapedPassword[0]));
MsiSetPropertyW(hInstall,L"ESCAPEDPASSWORD",EscapedPassword);
DWORD SkipNetworkingLen= MAX_PATH;
MsiGetPropertyW(hInstall, L"SKIPNETWORKING", SkipNetworking,
&SkipNetworkingLen);
MsiGetPropertyW(hInstall, L"PORT", Port, &PortLen);
if(SkipNetworking[0]==0 && Port[0] != 0)
{
/* Strip spaces */
for(DWORD i=PortLen-1; i > 0; i--)
{
if(Port[i]== ' ')
Port[i] = 0;
}
if(PortLen > 5 || PortLen <= 3)
haveInvalidPort = true;
else
{
for (DWORD i=0; i< PortLen && Port[i] != 0;i++)
{
if(Port[i] < '0' || Port[i] >'9')
{
haveInvalidPort=true;
break;
}
}
}
if (haveInvalidPort)
{
ErrorMsg =
L"Invalid port number. Please use a number between 1025 and 65535.";
goto LExit;
}
short port = (short)_wtoi(Port);
if (!IsPortFree(port))
{
ErrorMsg =
L"The TCP Port you selected is already in use. "
L"Please choose a different port.";
goto LExit;
}
}
DWORD QuickConfigLen = MAX_PATH;
MsiGetPropertyW (hInstall, L"STDCONFIG", QuickConfig, &QuickConfigLen);
if(QuickConfig[0] !=0)
{
MEMORYSTATUSEX memstatus;
memstatus.dwLength =sizeof(memstatus);
wchar_t invalidValueMsg[256];
if (!GlobalMemoryStatusEx(&memstatus))
{
WcaLog(LOGMSG_STANDARD, "Error %u from GlobalMemoryStatusEx",
GetLastError());
er= ERROR_INSTALL_FAILURE;
goto LExit;
}
DWORD BufferPoolSizeLen= 16;
MsiGetPropertyW(hInstall, L"BUFFERPOOLSIZE", BufferPoolSize, &BufferPoolSizeLen);
/* Strip spaces */
for(DWORD i=BufferPoolSizeLen-1; i > 0; i--)
{
if(BufferPoolSize[i]== ' ')
BufferPoolSize[i] = 0;
}
unsigned long long availableMemory=
GetMaxBufferSize(memstatus.ullTotalPhys)/ONE_MB;
swprintf_s(invalidValueMsg,
L"Invalid buffer pool size. Please use a number between 1 and %llu",
availableMemory);
if(BufferPoolSizeLen == 0 || BufferPoolSizeLen > 15)
{
ErrorMsg= invalidValueMsg;
goto LExit;
}
for (DWORD i=0; i < BufferPoolSizeLen && BufferPoolSize[BufferPoolSizeLen];
i++)
{
if(BufferPoolSize[i]< '0' || BufferPoolSize[i] > '9')
{
ErrorMsg= invalidValueMsg;
goto LExit;
}
}
BufferPoolSize[BufferPoolSizeLen]=0;
MsiSetPropertyW(hInstall, L"BUFFERPOOLSIZE", BufferPoolSize);
long long sz = _wtoi64(BufferPoolSize);
if(sz <= 0 || sz > (long long)availableMemory)
{
if(sz > 0)
{
swprintf_s(invalidValueMsg,
L"Value for buffer pool size is too large."
L"Only approximately %llu MB is available for allocation."
L"Please use a number between 1 and %llu.",
availableMemory, availableMemory);
}
ErrorMsg= invalidValueMsg;
goto LExit;
}
}
LExit:
MsiSetPropertyW (hInstall, L"WarningText", ErrorMsg);
return WcaFinalize(er);
}
