bool TaskRecorderManagerClient::getInfo(const task_recorder2_msgs::Description& description,
std::string& abs_file_name)
{
if(!servicesAreReady())
{
waitForServices();
}
task_recorder2::GetInfo::Request get_info_request;
get_info_request.description = description;
task_recorder2::GetInfo::Response get_info_response;
if(!get_info_service_client_.call(get_info_request, get_info_response))
{
ROS_ERROR("Problems when calling >%s<.", get_info_service_client_.getService().c_str());
return false;
}
if(get_info_response.return_code != task_recorder2::GetInfo::Response::SERVICE_CALL_SUCCESSFUL)
{
ROS_ERROR("Service >%s< was not successful: %s (%i)", get_info_service_client_.getService().c_str(),
get_info_response.info.c_str(), get_info_response.return_code);
return false;
}
abs_file_name.assign(get_info_response.file_name);
return true;
}
std::string CSysInfo::GetManufacturerName(void)
{
static std::string manufName;
static bool inited = false;
if (!inited)
{
#if defined(TARGET_ANDROID)
char deviceCStr[PROP_VALUE_MAX];
int propLen = __system_property_get("ro.product.manufacturer", deviceCStr);
manufName.assign(deviceCStr, (propLen > 0 && propLen <= PROP_VALUE_MAX) ? propLen : 0);
#elif defined(TARGET_DARWIN)
manufName = CDarwinUtils::GetManufacturer();
#elif defined(TARGET_WINDOWS_STORE)
auto eas = EasClientDeviceInformation();
auto manufacturer = eas.SystemManufacturer();
g_charsetConverter.wToUTF8(std::wstring(manufacturer.c_str()), manufName);
#elif defined(TARGET_WINDOWS)
// We just don't care, might be useful on embedded
#endif
inited = true;
}
return manufName;
}
std::string CSysInfo::GetKernelName(bool emptyIfUnknown /*= false*/)
{
static std::string kernelName;
if (kernelName.empty())
{
#if defined(TARGET_WINDOWS)
OSVERSIONINFOEXW osvi;
if (sysGetVersionExWByRef(osvi) && osvi.dwPlatformId == VER_PLATFORM_WIN32_NT)
kernelName = "Windows NT";
#elif defined(TARGET_POSIX)
struct utsname un;
if (uname(&un) == 0)
kernelName.assign(un.sysname);
#endif // defined(TARGET_POSIX)
if (kernelName.empty())
kernelName = "Unknown kernel"; // can't detect
}
if (emptyIfUnknown && kernelName == "Unknown kernel")
return "";
return kernelName;
}
static void xml_decode(const char *str, std::string& decoded)
{
static const char raw_entrs[] = {
'<', '>', '&', '\'', '\"', 0
};
static const char* xml_entrs[] = {
"lt;", "gt;", "amp;", "apos;", "quot;", 0
};
static const int xml_ent_len[] = {
3, 3, 4, 5, 5
};
int ient;
const char *amp = strchr(str, '&');
if (amp == NULL) {
decoded = str;
return;
}
decoded.assign(str, amp - str);
while (*amp)
if (*amp == '&') {
for (ient = 0; xml_entrs[ient] != 0; ++ient)
if (strncmp(amp + 1, xml_entrs[ient],
xml_ent_len[ient]) == 0) {
decoded += raw_entrs[ient];
amp += xml_ent_len[ient]+1;
break;
}
if (xml_entrs[ient] == 0) // unrecognized sequence
decoded += *amp++;
} else {
decoded += *amp++;
}
}
void
Compressor::compress(std::string & in, std::string & out)
{
switch (m_compression_codec) {
case CompressionCodec::UNCOMPRESSED:
{
// Just swap the input and output collections ...
out.swap(in);
}
break;
case CompressionCodec::SNAPPY:
{
size_t compressed_size;
m_tmp.resize(snappy::MaxCompressedLength(in.size()));
snappy::RawCompress((char const *) in.data(),
in.size(),
(char *) m_tmp.data(),
&compressed_size);
m_tmp.resize(compressed_size);
out.assign(m_tmp.begin(), m_tmp.end());
}
break;
case CompressionCodec::GZIP:
{
int window_bits = 15 + 16; // maximum window + GZIP
z_stream stream;
memset(&stream, '\0', sizeof(stream));
int rv = deflateInit2(&stream,
Z_DEFAULT_COMPRESSION,
Z_DEFLATED,
window_bits,
9,
Z_DEFAULT_STRATEGY);
if (rv != Z_OK) {
cerr << "deflateInit2 failed: " << rv;
exit(1);
}
m_tmp.resize(deflateBound(&stream, in.size()));
stream.next_in =
const_cast<Bytef*>(reinterpret_cast<const Bytef*>(in.data()));
stream.avail_in = in.size();
stream.next_out = (Bytef*) m_tmp.data();
stream.avail_out = m_tmp.size();
rv = deflate(&stream, Z_FINISH);
if (rv != Z_STREAM_END) {
cerr << "gzip deflate failed: " << rv;
exit(1);
}
out.assign(m_tmp.begin(), m_tmp.begin() + stream.total_out);
deflateEnd(&stream);
}
break;
default:
cerr << "unsupported compression codec: " << int(m_compression_codec);
exit(1);
break;
}
}
option& set_default_value( const Value& _value ) {
check_option_necessity();
value = boost::lexical_cast< std::string >( _value );
default_value.assign( value.begin(), value.end() );
return *this;
}
BOOL LLNetMap::handleToolTip( S32 x, S32 y, std::string& msg, LLRect* sticky_rect_screen )
{
BOOL handled = FALSE;
if (gDisconnected)
{
return FALSE;
}
LLViewerRegion* region = LLWorld::getInstance()->getRegionFromPosGlobal(viewPosToGlobal(x, y, gSavedSettings.getBOOL( "MiniMapRotate" )));
if( region )
{
msg.assign("");
std::string fullname;
if(mClosestAgentToCursor.notNull() && gCacheName->getFullName(mClosestAgentToCursor, fullname))
{
//msg.append(fullname);
// [RLVa:KB] - Version: 1.23.4 | Checked: 2009-07-08 (RLVa-1.0.0e) | Modified: RLVa-0.2.0b
// [Ansariel: Display name support]
// msg.append( (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES)) ? fullname : RlvStrings::getAnonym(fullname) );
if (gRlvHandler.hasBehaviour(RLV_BHVR_SHOWNAMES))
{
msg.append(RlvStrings::getAnonym(fullname));
}
else
{
if (LLAvatarNameCache::useDisplayNames())
{
LLAvatarName avatar_name;
if (LLAvatarNameCache::get(mClosestAgentToCursor, &avatar_name))
{
static const LLCachedControl<S32> phoenix_name_system("PhoenixNameSystem", 0);
if (phoenix_name_system == 2 || (phoenix_name_system == 1 && avatar_name.mIsDisplayNameDefault))
{
fullname = avatar_name.mDisplayName;
}
else
{
fullname = avatar_name.getCompleteName(true);
}
}
}
msg.append(fullname);
}
// [/Ansariel: Display name support]
// [/RLVa:KB]
msg.append("\n");
LLVector3d mypos = gAgent.getPositionGlobal();
LLVector3d position = mClosestAgentPosition;
if ( LLFloaterAvatarList::instanceExists() )
{
LLAvatarListEntry *ent = LLFloaterAvatarList::getInstance()->getAvatarEntry(mClosestAgentToCursor);
if ( NULL != ent )
{
//position = LLFloaterAvatarList::AvatarPosition(mClosestAgentToCursor);
position = ent->getPosition();
}
}
LLVector3d delta = position - mypos;
F32 distance = (F32)delta.magVec();
//llinfos << distance << " - " << position << llendl;
msg.append( llformat("\n(Distance: %.02fm)\n\n",distance) );
}
// [RLVa:KB] - Version: 1.23.4 | Checked: 2009-07-04 (RLVa-1.0.0a) | Modified: RLVa-0.2.0b
msg.append( (!gRlvHandler.hasBehaviour(RLV_BHVR_SHOWLOC)) ? region->getName() : RlvStrings::getString(RLV_STRING_HIDDEN) );
// [/RLVa:KB]
//msg.append( region->getName() );
//#ifndef LL_RELEASE_FOR_DOWNLOAD
std::string buffer;
msg.append("\n");
buffer = region->getHost().getHostName();
msg.append(buffer);
msg.append("\n");
buffer = region->getHost().getString();
msg.append(buffer);
//#endif
msg.append("\n");
msg.append(getToolTip());
S32 SLOP = 4;
localPointToScreen(
x - SLOP, y - SLOP,
&(sticky_rect_screen->mLeft), &(sticky_rect_screen->mBottom) );
sticky_rect_screen->mRight = sticky_rect_screen->mLeft + 2 * SLOP;
sticky_rect_screen->mTop = sticky_rect_screen->mBottom + 2 * SLOP;
handled = TRUE;
}
if(!handled)
{
return LLPanel::handleToolTip(x, y, msg, sticky_rect_screen);
}
return handled;
}
void ProviderTestBasic::EchoBinary(IDvInvocationStd& /*aInvocation*/, const std::string& aValue, std::string& aResult)
{
aResult.assign(aValue);
}
int main(int argc,char *argv[])
{
{
#ifdef MULTITHREAD_STDLOCALE_WORKAROUND
// Note: there's a known threading bug regarding std::locale with MSVC according to
// http://connect.microsoft.com/VisualStudio/feedback/details/492128/std-locale-constructor-modifies-global-locale-via-setlocale
int iPreviousFlag = ::_configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
#endif
using std::locale;
locale::global(locale(locale::classic(), "", locale::collate | locale::ctype));
#ifdef MULTITHREAD_STDLOCALE_WORKAROUND
if (iPreviousFlag > 0 )
::_configthreadlocale(iPreviousFlag);
#endif
}
TASPlayer::Init();
SetThreadAffinityMask(GetCurrentThread(),1);
//printf("%08x",opsize); //AGAIN?!
char *t;
initArchiveSystem();
if(timeBeginPeriod(1) != TIMERR_NOERROR)
{
AddLogText("Error setting timer granularity to 1ms.", DO_ADD_NEWLINE);
}
InitCommonControls();
debugSystem = new DebugSystem();
if(!FCEUI_Initialize())
{
do_exit();
return 1;
}
ApplyDefaultCommandMapping();
fceu_hInstance = GetModuleHandle(0);
fceu_hAccel = LoadAccelerators(fceu_hInstance,MAKEINTRESOURCE(IDR_ACCELERATOR1));
// Get the base directory
GetBaseDirectory();
// load fceux.cfg
sprintf(TempArray,"%s\\%s",BaseDirectory.c_str(),cfgFile.c_str());
LoadConfig(TempArray);
//initDirectories();
// Parse the commandline arguments
t = ParseArgies(argc, argv);
int saved_pal_setting = !!pal_emulation;
if (ConfigToLoad)
{
// alternative config file specified
cfgFile.assign(ConfigToLoad);
// Load the config information
sprintf(TempArray,"%s\\%s",BaseDirectory.c_str(),cfgFile.c_str());
LoadConfig(TempArray);
}
//Bleh, need to find a better place for this.
{
FCEUI_SetGameGenie(genie!=0);
fullscreen = !!fullscreen;
soundo = !!soundo;
frame_display = !!frame_display;
allowUDLR = !!allowUDLR;
pauseAfterPlayback = !!pauseAfterPlayback;
closeFinishedMovie = !!closeFinishedMovie;
EnableBackgroundInput = !!EnableBackgroundInput;
KeyboardSetBackgroundAccess(EnableBackgroundInput!=0);
JoystickSetBackgroundAccess(EnableBackgroundInput!=0);
FCEUI_SetSoundVolume(soundvolume);
FCEUI_SetSoundQuality(soundquality);
FCEUI_SetTriangleVolume(soundTrianglevol);
FCEUI_SetSquare1Volume(soundSquare1vol);
FCEUI_SetSquare2Volume(soundSquare2vol);
FCEUI_SetNoiseVolume(soundNoisevol);
FCEUI_SetPCMVolume(soundPCMvol);
}
//Since a game doesn't have to be loaded before the GUI can be used, make
//sure the temporary input type variables are set.
ParseGIInput(NULL);
// Initialize default directories
CreateDirs();
SetDirs();
DoVideoConfigFix();
DoTimingConfigFix();
if(eoptions & EO_CPALETTE)
{
FCEUI_SetPaletteArray(cpalette);
}
if(!t)
{
fullscreen=0;
}
CreateMainWindow();
// Do single instance coding, since we now know if the user wants it,
// and we have a source window to send from
// http://wiki.github.com/ffi/ffi/windows-examples
if (SingleInstanceOnly) {
// Checks window names / hWnds, decides if there's going to be a conflict.
EnumDesktopWindows(NULL, EnumCallbackFCEUXInstantiated, (LPARAM)0);
if (DoInstantiatedExit) {
if(t)
{
COPYDATASTRUCT cData;
DATA tData;
sprintf(tData.strFilePath,"%s",t);
cData.dwData = 1;
cData.cbData = sizeof ( tData );
cData.lpData = &tData;
SendMessage(DoInstantiatedExitWindow,WM_COPYDATA,(WPARAM)(HWND)hAppWnd, (LPARAM)(LPVOID) &cData);
do_exit();
return 0;
}
}
}
if(!InitDInput())
{
do_exit();
return 1;
}
if(!DriverInitialize())
{
do_exit();
return 1;
}
InitSpeedThrottle();
if (t)
{
ALoad(t);
} else
{
if (AutoResumePlay && romNameWhenClosingEmulator && romNameWhenClosingEmulator[0])
ALoad(romNameWhenClosingEmulator, 0, true);
if (eoptions & EO_FOAFTERSTART)
LoadNewGamey(hAppWnd, 0);
}
if (pal_setting_specified)
{
// Force the PAL setting specified in the command line
pal_emulation = saved_pal_setting;
FCEUI_SetVidSystem(pal_emulation);
}
if(PaletteToLoad)
{
SetPalette(PaletteToLoad);
free(PaletteToLoad);
PaletteToLoad = NULL;
}
if(GameInfo && MovieToLoad)
{
//switch to readonly mode if the file is an archive
if(FCEU_isFileInArchive(MovieToLoad))
replayReadOnlySetting = true;
FCEUI_LoadMovie(MovieToLoad, replayReadOnlySetting, replayStopFrameSetting != 0);
FCEUX_LoadMovieExtras(MovieToLoad);
free(MovieToLoad);
MovieToLoad = NULL;
}
if(GameInfo && StateToLoad)
{
FCEUI_LoadState(StateToLoad);
free(StateToLoad);
StateToLoad = NULL;
}
if(GameInfo && LuaToLoad)
{
FCEU_LoadLuaCode(LuaToLoad);
free(LuaToLoad);
LuaToLoad = NULL;
}
//Initiates AVI capture mode, will set up proper settings, and close FCUEX once capturing is finished
if(AVICapture && AviToLoad) //Must be used in conjunction with AviToLoad
{
//We want to disable flags that will pause the emulator
PauseAfterLoad = 0;
pauseAfterPlayback = 0;
KillFCEUXonFrame = AVICapture;
}
if(AviToLoad)
{
FCEUI_AviBegin(AviToLoad);
free(AviToLoad);
AviToLoad = NULL;
}
TASPlayer::Init_Loaded();
if (MemWatchLoadOnStart) CreateMemWatch();
if (PauseAfterLoad) FCEUI_ToggleEmulationPause();
SetAutoFirePattern(AFon, AFoff);
UpdateCheckedMenuItems();
doloopy:
UpdateFCEUWindow();
if(GameInfo)
{
while(GameInfo)
{
uint8 *gfx=0; ///contains framebuffer
int32 *sound=0; ///contains sound data buffer
int32 ssize=0; ///contains sound samples count
if (turbo)
{
if (!frameSkipCounter)
{
frameSkipCounter = frameSkipAmt;
skippy = 0;
}
else
{
frameSkipCounter--;
if (muteTurbo) skippy = 2; //If mute turbo is on, we want to bypass sound too, so set it to 2
else skippy = 1; //Else set it to 1 to just frameskip
}
}
else skippy = 0;
TASPlayer::Run(&gfx, &sound, &ssize, skippy);
//FCEUI_Emulate(&gfx, &sound, &ssize, skippy); //emulate a single frame -- THIS IS NOW HANDLED BY TASPLAYER
//FCEUD_Update(gfx, sound, ssize); //update displays and debug tools -- THIS IS NOW HANDLED BY TASPLAYER
//mbg 6/30/06 - close game if we were commanded to by calls nested in FCEUI_Emulate()
if (closeGame)
{
FCEUI_CloseGame();
GameInfo = NULL;
}
}
//xbsave = NULL;
RedrawWindow(hAppWnd,0,0,RDW_ERASE|RDW_INVALIDATE);
}
else
UpdateRawInputAndHotkeys();
if(!TASPlayer::SimulMode) {
Sleep(50);
}
if(!exiting)
goto doloopy;
DriverKill();
timeEndPeriod(1);
FCEUI_Kill();
delete debugSystem;
return(0);
}
void
prepare_string(
const char* input,
size_t size) {
_prepare.assign(input, size);
}
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPTSTR lpstrCmdLine, int nCmdShow) {
g_hInstance = hInstance;
json_value* appSettings = GetApplicationSettings();
if (GetApplicationSettingsError().length()) {
std::string error = GetApplicationSettingsError();
error.append("\nApplication will terminate immediately. ");
FatalError(NULL, error);
}
// Debugging options.
bool show_console = (*appSettings)["debugging"]["show_console"];
bool subprocess_show_console = (*appSettings)["debugging"]["subprocess_show_console"];
std::string log_level = (*appSettings)["debugging"]["log_level"];
std::string log_file = (*appSettings)["debugging"]["log_file"];
log_file = GetAbsolutePath(log_file);
// Initialize logging.
if (std::wstring(lpstrCmdLine).find(L"--type=") != std::string::npos) {
// This is a subprocess.
InitializeLogging(subprocess_show_console, log_level, log_file);
} else {
// Main browser process.
InitializeLogging(show_console, log_level, log_file);
}
// Command line arguments
LPWSTR *argv;
int argc;
argv = CommandLineToArgvW(GetCommandLineW(), &argc);
if (argv) {
for (int i = 0; i < argc; i++) {
std::string argument = WideToUtf8(std::wstring(argv[i]));
size_t pos = argument.find("=");
if (pos != std::string::npos) {
std::string name = argument.substr(0, pos);
std::string value = argument.substr(pos+1, std::string::npos);
if (name == "--cgi-environment" && value.length()) {
g_cgiEnvironmentFromArgv.assign(value);
}
}
}
} else {
LOG_WARNING << "CommandLineToArgvW() failed";
}
// CEF subprocesses.
CefMainArgs main_args(hInstance);
CefRefPtr<App> app(new App);
int exit_code = CefExecuteProcess(main_args, app.get(), NULL);
if (exit_code >= 0) {
ShutdownLogging();
return exit_code;
}
LOG_INFO << "--------------------------------------------------------";
LOG_INFO << "Started application";
if (log_file.length())
LOG_INFO << "Logging to: " << log_file;
else
LOG_INFO << "No logging file set";
LOG_INFO << "Log level = "
<< FILELog::ToString(FILELog::ReportingLevel());
// Main window title option.
std::string main_window_title = (*appSettings)["main_window"]["title"];
if (main_window_title.empty())
main_window_title = GetExecutableName();
// Single instance guid option.
const char* single_instance_guid =
(*appSettings)["application"]["single_instance_guid"];
if (single_instance_guid && single_instance_guid[0] != 0) {
int guidSize = strlen(single_instance_guid) + 1;
g_singleInstanceApplicationGuid = new wchar_t[guidSize];
Utf8ToWide(single_instance_guid, g_singleInstanceApplicationGuid,
guidSize);
}
if (g_singleInstanceApplicationGuid
&& g_singleInstanceApplicationGuid[0] != 0) {
g_singleInstanceApplication.Initialize(
g_singleInstanceApplicationGuid);
if (g_singleInstanceApplication.IsRunning()) {
HWND hwnd = FindWindow(g_singleInstanceApplicationGuid, NULL);
if (hwnd) {
if (IsIconic(hwnd))
ShowWindow(hwnd, SW_RESTORE);
SetForegroundWindow(hwnd);
return 0;
}
}
}
// Window class name.
if (g_singleInstanceApplicationGuid) {
swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s",
g_singleInstanceApplicationGuid);
} else {
swprintf_s(g_windowClassName, _countof(g_windowClassName), L"%s",
Utf8ToWide(GetExecutableName()).c_str());
}
if (!StartWebServer()) {
FatalError(NULL, "Error while starting an internal local server.\n"
"Application will terminate immediately.");
}
CefSettings cef_settings;
// log_file
std::string chrome_log_file = (*appSettings)["chrome"]["log_file"];
chrome_log_file = GetAbsolutePath(chrome_log_file);
CefString(&cef_settings.log_file) = chrome_log_file;
// log_severity
std::string chrome_log_severity = (*appSettings)["chrome"]["log_severity"];
cef_log_severity_t log_severity = LOGSEVERITY_DEFAULT;
if (chrome_log_severity == "verbose") {
log_severity = LOGSEVERITY_VERBOSE;
} else if (chrome_log_severity == "info") {
log_severity = LOGSEVERITY_INFO;
} else if (chrome_log_severity == "warning") {
log_severity = LOGSEVERITY_WARNING;
} else if (chrome_log_severity == "error") {
log_severity = LOGSEVERITY_ERROR;
} else if (chrome_log_severity == "error-report") {
log_severity = LOGSEVERITY_ERROR_REPORT;
} else if (chrome_log_severity == "disable") {
log_severity = LOGSEVERITY_DISABLE;
}
cef_settings.log_severity = log_severity;
// cache_path
std::string cache_path = (*appSettings)["chrome"]["cache_path"];
cache_path = GetAbsolutePath(cache_path);
CefString(&cef_settings.cache_path) = cache_path;
// remote_debugging_port
// A value of -1 will disable remote debugging.
int remote_debugging_port = static_cast<long>(
(*appSettings)["chrome"]["remote_debugging_port"]);
if (remote_debugging_port == 0) {
remote_debugging_port = random(49152, 65535+1);
int i = 100;
while (((i--) > 0) && remote_debugging_port == GetWebServerPort()) {
remote_debugging_port = random(49152, 65535+1);
}
}
if (remote_debugging_port > 0) {
LOG_INFO << "remote_debugging_port = " << remote_debugging_port;
cef_settings.remote_debugging_port = remote_debugging_port;
}
// Sandbox support
cef_settings.no_sandbox = true;
CefInitialize(main_args, cef_settings, app.get(), NULL);
CreateMainWindow(hInstance, nCmdShow, main_window_title);
CefRunMessageLoop();
CefShutdown();
LOG_INFO << "Ended application";
LOG_INFO << "--------------------------------------------------------";
ShutdownLogging();
return 0;
}
//--------------------------------------------------------------------------
/// Write a trace's metadata file and return the contenst through the out-param.
/// \param inFullResponseString The full response string for a collected linked trace request.
/// \param outMetadataXML The XML metadata string to return to the client.
/// \returns True if writing the metadata file was successful.
//--------------------------------------------------------------------------
bool MultithreadedTraceAnalyzerLayer::WriteTraceAndMetadataFiles(const std::stringstream& inFullResponseString, std::string& outMetadataXML)
{
bool bWrittenSuccessfully = false;
// Empty out the incoming path to the metadata file. We'll know the exact path later.
outMetadataXML.assign("");
osModuleArchitecture moduleArchitecture;
osRuntimePlatform currentPlatform;
gtString executablePath;
gtString commandLine;
gtString workingDirectory;
// Retrieve the name of the instrumented application. Construct a metadata filename which references it.
if (osGetProcessLaunchInfo(osGetCurrentProcessId(), moduleArchitecture, currentPlatform, executablePath, commandLine, workingDirectory) == true)
{
osFilePath executableFilepath;
executableFilepath.setFullPathFromString(executablePath);
gtString appName;
if (executableFilepath.getFileName(appName) == true)
{
osTime currentTime;
currentTime.setFromCurrentTime();
tm timeStruct;
currentTime.timeAsTmStruct(timeStruct, osTime::LOCAL);
// Need to add 1900, since tm contains "years since 1900".
int year = timeStruct.tm_year + 1900;
// Need to add 1, since tm contains "months since January".
int month = timeStruct.tm_mon + 1;
int day = timeStruct.tm_mday;
int hour = timeStruct.tm_hour;
int minute = timeStruct.tm_min;
int second = timeStruct.tm_sec;
gtASCIIString metadataFilename;
// ExecutableFilename-YEAR-MM-DD-HOUR-MINUTE-SECOND
metadataFilename.appendFormattedString("description-%s-%d-%d-%d-%d-%d-%d.xml",
appName.asASCIICharArray(),
year, month, day,
hour, minute, second);
// Build a path to the GPS folder within the Temp directory.
osFilePath systemTempDirectory;
systemTempDirectory.setPath(osFilePath::OS_TEMP_DIRECTORY);
gtString toolDirectory;
#ifdef CODEXL_GRAPHICS
toolDirectory.fromASCIIString("CodeXL");
#else
toolDirectory.fromASCIIString(GetPerfStudioDirName());
#endif
// @TODO: Construct a path from the temp + tool directory.
systemTempDirectory.appendSubDirectory(toolDirectory);
gtList<osFilePath> toolDirectoryPaths;
osDirectory d;
d.setDirectoryPath(systemTempDirectory);
// @TODO: Find a better way to create the "Session" directory. We shouldn't need to search through existing session directories.
int maxSessionIndex = 0;
bool bGotSubDirectories = d.getSubDirectoriesPaths(osDirectory::SORT_BY_NAME_DESCENDING, toolDirectoryPaths);
if (bGotSubDirectories)
{
// Step through each directory, and look for "Session" folders.
gtList<osFilePath>::iterator subdirectoryIter;
for (subdirectoryIter = toolDirectoryPaths.begin(); subdirectoryIter != toolDirectoryPaths.end(); ++subdirectoryIter)
{
gtString subdirString;
osFilePath subdir = *subdirectoryIter;
subdir.getFileName(subdirString);
if (subdir.isDirectory() && subdirString.startsWith(L"Session"))
{
// Remove the "Session" part of the string. We're only interested in the number at the end.
subdirString.replace(L"Session", L"", true);
const char* sessionIndexAsString = subdirString.asASCIICharArray();
int thisSessionId = atoi(sessionIndexAsString);
if (thisSessionId > maxSessionIndex)
{
maxSessionIndex = thisSessionId;
}
}
}
}
gtASCIIString pathToDataDirectory = systemTempDirectory.asString().asASCIICharArray();
// Metadata files will be saved to the temp directory with the following filename scheme:
// "%TEMP%/ToolDirectory/Session[Index]/ApplicationBinaryName/Frame[Index]/description.xml"
int frameIndex = GetInterceptor()->GetParentLayerManager()->GetFrameCount();
// Generate a "Session" folder with a number at the end. Compute the correct number by looking at the
// Session folders that already exist
gtASCIIString sessionString;
sessionString.appendFormattedString("Session%d", maxSessionIndex + 1);
pathToDataDirectory.appendFormattedString("\\%s\\%s\\Frame%d\\", sessionString.asCharArray(), appName.asASCIICharArray(), frameIndex);
// Create the data directory if it doesn't already exist.
gtString fullPathToDataDirectoryAsGTString;
fullPathToDataDirectoryAsGTString.fromASCIIString(pathToDataDirectory.asCharArray());
osDirectory dir;
dir.setDirectoryFullPathFromString(fullPathToDataDirectoryAsGTString);
if (!dir.exists())
{
bool bDirectoryCreated = dir.create();
if (!bDirectoryCreated)
{
Log(logERROR, "Failed to create data directory for traced frame: '%s'.\n", fullPathToDataDirectoryAsGTString.asASCIICharArray());
}
}
gtASCIIString pathToMetadataFile = pathToDataDirectory;
pathToMetadataFile.appendFormattedString("%s", metadataFilename.asCharArray());
gtString fullMetadataFilepathAsGTString;
fullMetadataFilepathAsGTString.fromASCIIString(pathToMetadataFile.asCharArray());
osFile metadataFile(fullMetadataFilepathAsGTString);
bool bMetadataFileOpened = metadataFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE);
// If we've successfully opened the metadata file, we'll also attempt to write the trace file.
if (bMetadataFileOpened)
{
osFilePath traceFileDirectory;
traceFileDirectory.setPath(osFilePath::OS_TEMP_DIRECTORY);
traceFileDirectory.appendSubDirectory(toolDirectory);
// Construct a filename for the cached trace response.
gtASCIIString fullTraceFilename;
fullTraceFilename.appendFormattedString("LinkedTrace-%s-%d-%d-%d-%d-%d-%d.ltr", appName.asASCIICharArray(), year, month, day, hour, minute, second);
gtASCIIString fullTraceFilePath = pathToDataDirectory;
fullTraceFilePath.appendFormattedString("%s", fullTraceFilename.asCharArray());
gtString fullTraceResponseFilepathGTString;
fullTraceResponseFilepathGTString.fromASCIIString(fullTraceFilePath.asCharArray());
// Write the contents of the trace response file.
osFile traceResponseFile(fullTraceResponseFilepathGTString);
bool bTraceResponseFileOpened = traceResponseFile.open(osChannel::OS_ASCII_TEXT_CHANNEL, osFile::OS_OPEN_TO_WRITE);
if (bTraceResponseFileOpened)
{
// Dump the response into an ASCII string.
std::string responseAsString = inFullResponseString.str();
// Now put the ASCII string into a gtString so we can write it to the open file.
gtString gtStringResponse;
std::wstring wideString;
wideString.assign(responseAsString.begin(), responseAsString.end());
gtStringResponse.appendFormattedString(L"%s", wideString.c_str());
traceResponseFile.writeString(gtStringResponse);
traceResponseFile.close();
}
else
{
Log(logERROR, "Failed to write trace response to file: '%s'\n", fullTraceResponseFilepathGTString.asASCIICharArray());
}
// Write the filename for the associated trace response that was just collected.
std::string traceFilepathAsString;
traceFilepathAsString.assign(fullTraceResponseFilepathGTString.asASCIICharArray());
TraceMetadata metadata;
// Insert the location of the metadata file being written out.
metadata.mMetadataFilepath = pathToMetadataFile.asCharArray();
// Insert the path to the cached trace file.
metadata.mPathToTraceFile = fullTraceFilePath.asCharArray();
// @TODO: When we have a framebuffer image system working, assign the path-to-image here.
metadata.mPathToFrameBufferImage = "UNKNOWNPATH";
ModernAPILayerManager* layerManager = GetInterceptor()->GetParentLayerManager();
FrameInfo frameInfo;
layerManager->GetFrameInfo(frameInfo);
// Populate the metadata structure with the values stored in the LayerManager.
metadata.mFrameInfo = frameInfo;
metadata.mFrameIndex = frameIndex;
metadata.mArchitecture = moduleArchitecture;
// Write the metadata xml into the output file.
gtASCIIString metadataXMLString;
metadata.WriteToXML(metadataXMLString);
gtString metadataXMLAsGTString;
metadataXMLAsGTString.fromASCIIString(metadataXMLString.asCharArray());
// Write the metadata XML into the file, and close.
metadataFile.writeString(metadataXMLAsGTString);
metadataFile.close();
// The client will receive the full metadata XML string to parse.
outMetadataXML.assign(metadataXMLString.asCharArray());
bWrittenSuccessfully = true;
}
else
{
Log(logERROR, "Failed to open trace metadata file for writing: '%s'\n", metadataFilename);
}
}
else
{
Log(logERROR, "Failed to retrieve the instrumented process's application filename.\n");
}
}
else
{
Log(logERROR, "Failed to retrieve process launch info for target application.\n");
}
return bWrittenSuccessfully;
}
/*++
* @method: oAuth::getSignature
*
* @description: this method calculates HMAC-SHA1 signature of OAuth header
*
* @input: eType - HTTP request type
* rawUrl - raw url of the HTTP request
* rawKeyValuePairs - key-value pairs containing OAuth headers and HTTP data
*
* @output: oAuthSignature - base64 and url encoded signature
*
* @remarks: internal method
*
*--*/
bool oAuth::getSignature( const eOAuthHttpRequestType eType,
const std::string& rawUrl,
const oAuthKeyValuePairs& rawKeyValuePairs,
std::string& oAuthSignature )
{
std::string rawParams;
std::string paramsSeperator;
std::string sigBase;
/* Initially empty signature */
oAuthSignature.assign( "" );
/* Build a string using key-value pairs */
paramsSeperator = "&";
getStringFromOAuthKeyValuePairs( rawKeyValuePairs, rawParams, paramsSeperator );
/* Start constructing base signature string. Refer http://dev.twitter.com/auth#intro */
switch( eType )
{
case eOAuthHttpGet:
{
sigBase.assign( "GET&" );
}
break;
case eOAuthHttpPost:
{
sigBase.assign( "POST&" );
}
break;
case eOAuthHttpDelete:
{
sigBase.assign( "DELETE&" );
}
break;
default:
{
return false;
}
break;
}
sigBase.append( urlencode( rawUrl ) );
sigBase.append( "&" );
sigBase.append( urlencode( rawParams ) );
/* Now, hash the signature base string using HMAC_SHA1 class */
CHMAC_SHA1 objHMACSHA1;
std::string secretSigningKey;
unsigned char strDigest[oAuthLibDefaults::OAUTHLIB_BUFFSIZE_LARGE];
memset( strDigest, 0, oAuthLibDefaults::OAUTHLIB_BUFFSIZE_LARGE );
/* Signing key is composed of consumer_secret&token_secret */
secretSigningKey.assign( m_consumerSecret );
secretSigningKey.append( "&" );
if( m_oAuthTokenSecret.length() )
{
secretSigningKey.append( m_oAuthTokenSecret );
}
objHMACSHA1.HMAC_SHA1( (unsigned char*)sigBase.c_str(),
sigBase.length(),
(unsigned char*)secretSigningKey.c_str(),
secretSigningKey.length(),
strDigest );
/* Do a base64 encode of signature */
std::string base64Str = base64_encode( strDigest, 20 /* SHA 1 digest is 160 bits */ );
/* Do an url encode */
oAuthSignature = urlencode( base64Str );
return ( oAuthSignature.length() ) ? true : false;
}
bool CScraperUrl::Get(const SUrlEntry& scrURL, std::string& strHTML, XFILE::CCurlFile& http, const CStdString& cacheContext)
{
CURL url(scrURL.m_url);
http.SetReferer(scrURL.m_spoof);
CStdString strCachePath;
if (scrURL.m_isgz)
http.SetContentEncoding("gzip");
if (!scrURL.m_cache.empty())
{
strCachePath = URIUtils::AddFileToFolder(g_advancedSettings.m_cachePath,
"scrapers/" + cacheContext + "/" + scrURL.m_cache);
if (XFILE::CFile::Exists(strCachePath))
{
XFILE::CFile file;
XFILE::auto_buffer buffer;
if (file.LoadFile(strCachePath, buffer))
{
strHTML.assign(buffer.get(), buffer.length());
return true;
}
}
}
CStdString strHTML1(strHTML);
if (scrURL.m_post)
{
CStdString strOptions = url.GetOptions();
strOptions = strOptions.substr(1);
url.SetOptions("");
if (!http.Post(url.Get(), strOptions, strHTML1))
return false;
}
else
if (!http.Get(url.Get(), strHTML1))
return false;
strHTML = strHTML1;
std::string mimeType(http.GetMimeType());
CMime::EFileType ftype = CMime::GetFileTypeFromMime(mimeType);
if (ftype == CMime::FileTypeUnknown)
ftype = CMime::GetFileTypeFromContent(strHTML);
if (ftype == CMime::FileTypeZip || ftype == CMime::FileTypeGZip)
{
XFILE::CZipFile file;
std::string strBuffer;
int iSize = file.UnpackFromMemory(strBuffer,strHTML,scrURL.m_isgz); // FIXME: use FileTypeGZip instead of scrURL.m_isgz?
if (iSize > 0)
{
strHTML = strBuffer;
CLog::Log(LOGDEBUG, "%s: Archive \"%s\" was unpacked in memory", __FUNCTION__, scrURL.m_url.c_str());
}
else
CLog::Log(LOGWARNING, "%s: \"%s\" looks like archive, but cannot be unpacked", __FUNCTION__, scrURL.m_url.c_str());
}
std::string reportedCharset(http.GetServerReportedCharset());
if (ftype == CMime::FileTypeHtml)
{
std::string realHtmlCharset, converted;
if (!CCharsetDetection::ConvertHtmlToUtf8(strHTML, converted, reportedCharset, realHtmlCharset))
CLog::Log(LOGWARNING, "%s: Can't find precise charset for HTML \"%s\", using \"%s\" as fallback", __FUNCTION__, scrURL.m_url.c_str(), realHtmlCharset.c_str());
else
CLog::Log(LOGDEBUG, "%s: Using \"%s\" charset for HTML \"%s\"", __FUNCTION__, realHtmlCharset.c_str(), scrURL.m_url.c_str());
strHTML = converted;
}
else if (ftype == CMime::FileTypeXml)
{
CXBMCTinyXML xmlDoc;
xmlDoc.Parse(strHTML, reportedCharset);
std::string realXmlCharset(xmlDoc.GetUsedCharset());
if (!realXmlCharset.empty())
{
CLog::Log(LOGDEBUG, "%s: Using \"%s\" charset for XML \"%s\"", __FUNCTION__, realXmlCharset.c_str(), scrURL.m_url.c_str());
std::string converted;
g_charsetConverter.ToUtf8(realXmlCharset, strHTML, converted);
strHTML = converted;
}
}
else if (ftype == CMime::FileTypePlainText || StringUtils::CompareNoCase(mimeType.substr(0, 5), "text/") == 0)
{
std::string realTextCharset, converted;
CCharsetDetection::ConvertPlainTextToUtf8(strHTML, converted, reportedCharset, realTextCharset);
strHTML = converted;
if (reportedCharset != realTextCharset)
CLog::Log(LOGWARNING, "%s: Using \"%s\" charset for plain text \"%s\" instead of server reported \"%s\" charset", __FUNCTION__, realTextCharset.c_str(), scrURL.m_url.c_str(), reportedCharset.c_str());
else
CLog::Log(LOGDEBUG, "%s: Using \"%s\" charset for plain text \"%s\"", __FUNCTION__, realTextCharset.c_str(), scrURL.m_url.c_str());
}
else if (!reportedCharset.empty())
{
CLog::Log(LOGDEBUG, "%s: Using \"%s\" charset for \"%s\"", __FUNCTION__, reportedCharset.c_str(), scrURL.m_url.c_str());
if (reportedCharset != "UTF-8")
{
std::string converted;
g_charsetConverter.ToUtf8(reportedCharset, strHTML, converted);
strHTML = converted;
}
}
else
CLog::Log(LOGDEBUG, "%s: Using content of \"%s\" as binary or text with \"UTF-8\" charset", __FUNCTION__, scrURL.m_url.c_str());
if (!scrURL.m_cache.empty())
{
CStdString strCachePath = URIUtils::AddFileToFolder(g_advancedSettings.m_cachePath,
"scrapers/" + cacheContext + "/" + scrURL.m_cache);
XFILE::CFile file;
if (file.OpenForWrite(strCachePath,true))
file.Write(strHTML.data(),strHTML.size());
file.Close();
}
return true;
}
// virtual
BOOL LLViewerTextEditor::handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
EAcceptance *accept,
std::string& tooltip_msg)
{
BOOL handled = FALSE;
LLToolDragAndDrop::ESource source = LLToolDragAndDrop::getInstance()->getSource();
if (LLToolDragAndDrop::SOURCE_NOTECARD == source)
{
// We currently do not handle dragging items from one notecard to another
// since items in a notecard must be in Inventory to be verified. See DEV-2891.
return FALSE;
}
if (getEnabled() && acceptsTextInput())
{
switch( cargo_type )
{
case DAD_CALLINGCARD:
case DAD_TEXTURE:
case DAD_SOUND:
case DAD_LANDMARK:
case DAD_SCRIPT:
case DAD_CLOTHING:
case DAD_OBJECT:
case DAD_NOTECARD:
case DAD_BODYPART:
case DAD_ANIMATION:
case DAD_GESTURE:
case DAD_MESH:
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
if( item && allowsEmbeddedItems() )
{
U32 mask_next = item->getPermissions().getMaskNextOwner();
if((mask_next & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
{
if( drop )
{
deselect();
S32 old_cursor = mCursorPos;
setCursorAtLocalPos( x, y, TRUE );
S32 insert_pos = mCursorPos;
setCursorPos(old_cursor);
BOOL inserted = insertEmbeddedItem( insert_pos, item );
if( inserted && (old_cursor > mCursorPos) )
{
setCursorPos(mCursorPos + 1);
}
needsReflow();
}
*accept = ACCEPT_YES_COPY_MULTI;
}
else
{
*accept = ACCEPT_NO;
if (tooltip_msg.empty())
{
// *TODO: Translate
tooltip_msg.assign("Only items with unrestricted\n"
"'next owner' permissions \n"
"can be attached to notecards.");
}
}
}
else
{
*accept = ACCEPT_NO;
}
break;
}
default:
*accept = ACCEPT_NO;
break;
}
}
else
{
// Not enabled
*accept = ACCEPT_NO;
}
handled = TRUE;
LL_DEBUGS("UserInput") << "dragAndDrop handled by LLViewerTextEditor " << getName() << LL_ENDL;
return handled;
}
void ValueImpl::getString(std::string& ret) const
{
if (null)
throw NullValue();
ret.assign(data);
}
static bool find_include_file(std::string &srcincpath, int srcrootlen, int dstrootlen, std::string &srcfile, std::string &dstfile, std::string &filename)
{
// iterate over include paths and find the file
for (include_path *curpath = incpaths; curpath != nullptr; curpath = curpath->next)
{
// a '.' include path is specially treated
if (curpath->path.compare(".") == 0)
srcincpath.assign(srcfile.substr(0, srcfile.find_last_of(PATH_SEPARATOR[0])));
else
srcincpath.assign(srcfile.substr(0, srcrootlen + 1)).append(curpath->path);
// append the filename piecemeal to account for directories
int lastsepindex = 0;
int sepindex;
while ((sepindex = filename.find_first_of('/', lastsepindex)) != -1)
{
// handle .. by removing a chunk from the incpath
std::string pathpart(filename, lastsepindex, sepindex - lastsepindex);
if (pathpart.compare("..")==0)
{
sepindex = srcincpath.find_last_of(PATH_SEPARATOR[0]);
if (sepindex != -1)
srcincpath.substr(0, sepindex);
}
// otherwise, append a path separator and the pathpart
else
srcincpath.append(PATH_SEPARATOR).append(pathpart);
// advance past the previous index
lastsepindex = sepindex + 1;
}
// now append the filename
srcincpath.append(PATH_SEPARATOR).append(filename.substr(lastsepindex, -1));
// see if we can open it
util::core_file::ptr testfile;
if (util::core_file::open(srcincpath, OPEN_FLAG_READ, testfile) == osd_file::error::NONE)
{
// close the file
testfile.reset();
// find the longest matching directory substring between the include and source file
lastsepindex = 0;
while ((sepindex = srcincpath.find_first_of(PATH_SEPARATOR[0], lastsepindex)) != -1)
{
// get substrings up to the current directory
std::string tempfile(srcfile, 0, sepindex);
std::string tempinc(srcincpath, 0, sepindex);
// if we don't match, stop
if (tempfile.compare(tempinc)!=0)
break;
lastsepindex = sepindex + 1;
}
// chop off the common parts of the paths
std::string tempfile(srcfile, lastsepindex, -1);
srcincpath = srcincpath.substr(lastsepindex, -1);
strreplacechr(srcincpath, PATH_SEPARATOR[0], '/');
// for each directory left in the filename, we need to prepend a "../"
while ((sepindex = tempfile.find_first_of(PATH_SEPARATOR[0])) != -1)
{
tempfile.substr(sepindex + 1, -1);
srcincpath.insert(0, "../");
}
srcincpath.append(".html");
// free the strings and return the include path
return true;
}
}
return false;
}
void DvProviderAvOpenhomeOrgExakt2Cpp::GetPropertyVersion(std::string& aValue)
{
ASSERT(iPropertyVersion != NULL);
const Brx& val = iPropertyVersion->Value();
aValue.assign((const char*)val.Ptr(), val.Bytes());
}
int main(int argc, char **argv)
{
bool try_flip = false;
std::string scale_param = "--scale=";
size_t scale_param_length = scale_param.length();
std::string cascade_param = "--cascade=";
size_t cascade_param_length = cascade_param.length();
std::string nested_cascade_param = "--nested-cascade=";
size_t nested_cascade_param_length = nested_cascade_param.length();
std::string try_flip_param = "--try-flip=";
size_t try_flip_param_length = try_flip_param.length();
std::string name_input;
double scale = 1.0;
cv::Mat frame;
cv::Mat frame_copy;
cv::Mat image;
cv::CascadeClassifier cascade;
cv::CascadeClassifier nested_cascade;
CvCapture *capture = 0;
g_face_recognition.getUseHelp();
// Load trained model.
g_model = cv::createLBPHFaceRecognizer();
g_model->load(g_save_model_path);
std::cout << "*************************" << std::endl
<< " Load model finished " << std::endl
<< "*************************" << std::endl
<< std::endl;
// Load command line parameters.
for (int i = 1; i < argc; i++) {
std::cout << "Processing " << i << " " << argv[i] << std::endl;
if (cascade_param.compare(0,
cascade_param_length,
argv[i],
cascade_param_length) == 0) {
g_name_cascade.assign(argv[i] + cascade_param_length);
std::cout << "Cascade name: " << g_name_cascade
<< std::endl;
}
else if (nested_cascade_param.compare(0,
nested_cascade_param_length,
argv[i],
nested_cascade_param_length) == 0) {
if (argv[i][nested_cascade_param.length()] == '=') {
g_name_nested_cascade.assign(argv[i] +
nested_cascade_param.length() + 1);
}
if (!nested_cascade.load(g_name_nested_cascade)) {
std::cerr << "Load nested cascade classifier failed!"
<< std::endl;
}
}
else if (scale_param.compare(0,
scale_param_length,
argv[i],
scale_param_length) == 0) {
if(!sscanf(argv[i] + scale_param.length(), "%lf", &scale) ||
scale < 1) {
scale = 1;
}
std::cout << "Scale: " << scale << std::endl;
}
else if (try_flip_param.compare(0,
try_flip_param_length,
argv[i],
try_flip_param_length) == 0) {
try_flip = true;
std::cout << " Try to flip image horizontally."
<< std::endl;
}
else if (argv[i][0] == '-') {
std::cerr << "Unknown option %s" << argv[i] << std::endl;
}
else {
name_input.assign(argv[i]);
}
}
if (!cascade.load(g_name_cascade)) {
std::cerr << "Load cascade classifier failed!" << std::endl;
g_face_recognition.getUseHelp();
return -1;
}
if (name_input.empty() || (isdigit(name_input.c_str()[0]) &&
name_input.c_str()[1]) == '\0') {
capture = cvCaptureFromCAM(name_input.empty() ? 0 :
name_input.c_str()[0] - '0');
int camera = name_input.empty() ? 0 : name_input.c_str()[0] - '0';
if (!capture) {
std::cerr << "Capture from CAM " << camera << "doesn't work!"
<< std::endl;
}
}
else if (name_input.size()) {
image = cv::imread(name_input, 1);
if (image.empty()) {
capture = cvCaptureFromAVI(name_input.c_str());
if (!capture) {
std::cerr << "Capture from AVI doesn't work!" << std::endl;
}
}
}
else {
image = cv::imread("lena.jpg", 1);
if (image.empty()) {
std::cerr << "Read lena.jpg failed!" << std::endl;
}
}
cvNamedWindow("Face Recognition", 1);
if (capture) {
std::cout << "In capture..." << std::endl;
for (;;) {
IplImage *ipl_image = cvQueryFrame(capture);
frame = ipl_image;
while (frame.dims == 0) {
ipl_image = cvQueryFrame(capture);
frame = ipl_image;
}
if (frame.empty()) {
break;
}
if (ipl_image->origin == IPL_ORIGIN_TL) {
frame.copyTo(frame_copy);
}
else {
cv::flip(frame, frame_copy, 0);
}
g_face_recognition.detectAndDraw(frame_copy,
cascade,
nested_cascade,
scale,
try_flip);
// Press any keys to close the camera and exit.
if (cv::waitKey(10) > 0) {
goto cleanup;
}
}
cv::waitKey(0);
cleanup:
cvReleaseCapture(&capture);
}
else {
std::cout << "In image read..." << std::endl;
if (!image.empty()) {
g_face_recognition.detectAndDraw(image,
cascade,
nested_cascade,
scale,
try_flip);
cv::waitKey(0);
}
else if (!name_input.empty()) {
FILE *file = fopen(name_input.c_str(), "rt");
if (file) {
char buffer[1000 + 1];
while (fgets(buffer, 1000, file)) {
int length = (int)strlen(buffer);
int key = 0;
while (length > 0 && isspace(buffer[length - 1])) {
length--;
}
buffer[length] = '\0';
std::cout << "File " << buffer << std::endl;
image = cv::imread(buffer, 1);
if (!image.empty()) {
g_face_recognition.detectAndDraw(image,
cascade,
nested_cascade,
scale,
try_flip);
key = cv::waitKey(0);
if (key == 27 || key == 'q' || key == 'Q') {
break;
}
}
else {
std::cerr << "Read image failed!" << std::endl;
}
}
fclose(file);
}
}
}
cvDestroyWindow("Face Detection");
return 0;
}
void unpack_string(std::string& str) {
str.assign(reinterpret_cast<char *>(data()), size());
}
// - read (and dequeue) all available data
// returns false when nothing is present
bool serialPoll_t :: read( std::string &s )
{
s.assign( inData_, inLength_ );
inLength_ = 0 ;
return ( 0 != s.size() );
}
/*++
* \fn OAuth::getSignature
*
* \brief this method calculates HMAC-SHA1 signature of OAuth header
*
* \param eType - HTTP request type
* rawUrl - raw url of the HTTP request
* rawKeyValuePairs - key-value pairs containing OAuth headers and HTTP data
*
* \return oAuthSignature - base64 and url encoded signature
*
* @remarks: internal method
*
*--*/
bool OAuth::getSignature( const e_HTTP_request_type method,
const std::string& rawUrl,
const std::map<std::string, std::string>& rawKeyValuePairs,
std::string& oAuthSignature ) {
std::string rawParams;
std::string paramsSeperator;
std::string sigBase;
/* Initially empty signature */
oAuthSignature.assign( "" );
/* Build a string using key-value pairs */
paramsSeperator = "&";
getStringFromOAuthKeyValuePairs( rawKeyValuePairs, rawParams, paramsSeperator );
/* Start constructing base signature string. Refer http://dev.twitter.com/auth#intro */
switch( method ) {
case GET:
sigBase.assign( "GET&" );
break;
case POST:
sigBase.assign( "POST&" );
break;
case DELETE:
sigBase.assign( "DELETE&" );
break;
default:
return false;
break;
}
sigBase.append( urlencode( rawUrl ) );
sigBase.append( "&" );
sigBase.append( urlencode( rawParams ) );
/* Now, hash the signature base string using HMAC_SHA1 class */
CHMAC_SHA1 objHMACSHA1;
std::string secretSigningKey;
unsigned char strDigest[OAuthConsts::BUFFSIZE_LARGE];
memset( strDigest, 0, OAuthConsts::BUFFSIZE_LARGE );
/* Signing key is composed of consumer_secret&token_secret */
secretSigningKey.assign( _consumer_secret );
secretSigningKey.append( "&" );
if( _token_secret.length() ) {
secretSigningKey.append( _token_secret );
}
objHMACSHA1.HMAC_SHA1( (unsigned char*)sigBase.c_str(),
sigBase.length(),
(unsigned char*)secretSigningKey.c_str(),
secretSigningKey.length(),
strDigest );
/* Do a base64 encode of signature */
std::string base64Str = base64_encode( strDigest, 20 /* SHA 1 digest is 160 bits */ );
/* Do an url encode */
oAuthSignature = urlencode( base64Str );
return ( oAuthSignature.length() ) ? true : false;
}
uint32_t Reader::ReadRecord(string &record, std::string &scratch, uint32_t &blockid) {
if (!SkipToInitialBlock()) {
return 0;
}
initial_offset_ = 0;
scratch.clear();
record.clear();
bool in_fragmented_record = false;
// Record offset of the logical record that we're reading
// 0 is a dummy value to make compilers happy
uint64_t prospective_record_offset = 0;
string fragment;
fragment.clear();
while (true) {
uint64_t physical_record_offset = end_of_buffer_offset_ - buffer_.size();
uint32_t id;
const unsigned int record_type = ReadPhysicalRecord(fragment, id, blockid);
//cout << "record_type: " << record_type << endl;
switch (record_type) {
case kFullType:
if (in_fragmented_record) {
// Handle bug in earlier versions of log::Writer where
// it could emit an empty kFirstType record at the tail end
// of a block followed by a kFullType or kFirstType record
// at the beginning of the next block.
if (scratch.empty()) {
in_fragmented_record = false;
} else {
ReportCorruption(scratch.size(), "partial record without end(1)");
}
}
prospective_record_offset = physical_record_offset;
scratch.clear();
record = fragment;
last_record_offset_ = prospective_record_offset;
last_record_end_offset_ = kBlockSize - buffer_.size();
if(read_block_num_ != -1) {
real_read_block_num_ = read_block_num_;
}
//Version::Instance()->SetBlockInterId();
//cout << "kFullType: " << last_record_end_offset_ << endl;
return id;
case kFirstType:
if (in_fragmented_record) {
// Handle bug in earlier versions of log::Writer where
// it could emit an empty kFirstType record at the tail end
// of a block followed by a kFullType or kFirstType record
// at the beginning of the next block.
if (scratch.empty()) {
in_fragmented_record = false;
} else {
ReportCorruption(scratch.size(), "partial record without end(2)");
}
}
prospective_record_offset = physical_record_offset;
scratch.assign(fragment.data(), fragment.size());
in_fragmented_record = true;
break;
case kMiddleType:
if (!in_fragmented_record) {
ReportCorruption(fragment.size(),
"missing start of fragmented record(1)");
} else {
scratch.append(fragment.data(), fragment.size());
}
break;
case kLastType:
if (!in_fragmented_record) {
ReportCorruption(fragment.size(),
"missing start of fragmented record(2)");
} else {
scratch.append(fragment.data(), fragment.size());
record = scratch;
last_record_offset_ = prospective_record_offset;
last_record_end_offset_ = kBlockSize - buffer_.size();
if(read_block_num_ != -1) {
real_read_block_num_ = read_block_num_;
}
//Version::Instance()->SetBlockInterId();
return id;
}
break;
case kEof:
if (in_fragmented_record) {
ReportCorruption(scratch.size(), "partial record without end(3)");
scratch.clear();
}
return 0;
case kBadRecord:
if (in_fragmented_record) {
ReportCorruption(scratch.size(), "error in middle of record");
in_fragmented_record = false;
scratch.clear();
}
break;
default: {
char buf[40];
snprintf(buf, sizeof(buf), "unknown record type %u", record_type);
ReportCorruption(
(fragment.size() + (in_fragmented_record ? scratch.size() : 0)),
buf);
in_fragmented_record = false;
scratch.clear();
break;
}
}
}
return 0;
}
bool parseCommandLine(int argc, char **argv)
{
for (int i = 1; i < argc; ++i) {
if (!std::strcmp(argv[i],"-ip") && i + 1 < argc)
d_hosts.push_back(argv[++i]);
else if (!std::strcmp(argv[i],"-p") && i + 1 < argc)
d_port = std::atoi(argv[++i]);
else if (!std::strcmp(argv[i],"-s") && i + 1 < argc)
d_securities.push_back(argv[++i]);
else if (!std::strcmp(argv[i],"-f") && i + 1 < argc)
d_fields.push_back(argv[++i]);
else if (!std::strcmp(argv[i],"-r") && i + 1 < argc) {
++ i;
if (!std::strcmp(argv[i], "server")) {
d_role = SERVER;
}
else if (!std::strcmp(argv[i], "client")) {
d_role = CLIENT;
}
else if (!std::strcmp(argv[i], "both")) {
d_role = BOTH;
}
else {
printUsage();
return false;
}
}
else if (!std::strcmp(argv[i], "-auth") && i + 1 < argc) {
++ i;
if (!std::strcmp(argv[i], AUTH_OPTION_NONE)) {
d_authOptions.clear();
}
else if (strncmp(argv[i], AUTH_OPTION_APP, strlen(AUTH_OPTION_APP)) == 0) {
d_authOptions.clear();
d_authOptions.append(AUTH_APP_PREFIX);
d_authOptions.append(argv[i] + strlen(AUTH_OPTION_APP));
}
else if (strncmp(argv[i], AUTH_OPTION_USER_APP, strlen(AUTH_OPTION_USER_APP)) == 0) {
d_authOptions.clear();
d_authOptions.append(AUTH_USER_APP_PREFIX);
d_authOptions.append(argv[i] + strlen(AUTH_OPTION_USER_APP));
}
else if (strncmp(argv[i], AUTH_OPTION_DIR, strlen(AUTH_OPTION_DIR)) == 0) {
d_authOptions.clear();
d_authOptions.append(AUTH_DIR_PREFIX);
d_authOptions.append(argv[i] + strlen(AUTH_OPTION_DIR));
}
else if (!std::strcmp(argv[i], AUTH_OPTION_USER)) {
d_authOptions.assign(AUTH_USER);
}
else {
printUsage();
return false;
}
}
else {
printUsage();
return false;
}
}
if (d_hosts.size() == 0) {
d_hosts.push_back("localhost");
}
if (d_securities.size() == 0) {
d_securities.push_back("IBM US Equity");
}
if (d_fields.size() == 0) {
d_fields.push_back("PX_LAST");
}
return true;
}
option& set_location( const std::string& _location ) {
location.assign( _location.begin(), _location.end() );
detail::string_it end_it = boost::find_last( location, "::" ).begin();
section.assign( location.begin(), end_it );
return *this;
}
// Allow calling cards to be dropped onto text fields. Append the name and
// a carriage return.
// virtual
BOOL LLViewerTextEditor::handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
EAcceptance *accept,
std::string& tooltip_msg)
{
BOOL handled = FALSE;
LLToolDragAndDrop::ESource source = LLToolDragAndDrop::getInstance()->getSource();
if (LLToolDragAndDrop::SOURCE_NOTECARD == source)
{
// We currently do not handle dragging items from one notecard to another
// since items in a notecard must be in Inventory to be verified. See DEV-2891.
return FALSE;
}
if (mTakesNonScrollClicks)
{
if (getEnabled() && acceptsTextInput())
{
switch( cargo_type )
{
// <edit>
// This does not even appear to be used maybe
// Throwing it out so I can embed calling cards
/*
case DAD_CALLINGCARD:
if(acceptsCallingCardNames())
{
if (drop)
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
std::string name = item->getName();
appendText(name, true, true);
}
*accept = ACCEPT_YES_COPY_SINGLE;
}
else
{
*accept = ACCEPT_NO;
}
break;
*/
case DAD_CALLINGCARD:
// </edit>
case DAD_TEXTURE:
case DAD_SOUND:
case DAD_LANDMARK:
case DAD_SCRIPT:
case DAD_CLOTHING:
case DAD_OBJECT:
case DAD_NOTECARD:
case DAD_BODYPART:
case DAD_ANIMATION:
case DAD_GESTURE:
{
LLInventoryItem *item = (LLInventoryItem *)cargo_data;
// <edit>
if((item->getPermissions().getMaskOwner() & PERM_ITEM_UNRESTRICTED) != PERM_ITEM_UNRESTRICTED)
{
if(gSavedSettings.getBOOL("ForceNotecardDragCargoPermissive"))
{
item = new LLInventoryItem((LLInventoryItem *)cargo_data);
LLPermissions old = item->getPermissions();
LLPermissions perm;
perm.init(old.getCreator(), old.getOwner(), old.getLastOwner(), old.getGroup());
perm.setMaskBase(PERM_ITEM_UNRESTRICTED);
perm.setMaskEveryone(PERM_ITEM_UNRESTRICTED);
perm.setMaskGroup(PERM_ITEM_UNRESTRICTED);
perm.setMaskNext(PERM_ITEM_UNRESTRICTED);
perm.setMaskOwner(PERM_ITEM_UNRESTRICTED);
item->setPermissions(perm);
}
}
// </edit>
if( item && allowsEmbeddedItems() )
{
U32 mask_next = item->getPermissions().getMaskNextOwner();
// <edit>
//if((mask_next & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED)
if(((mask_next & PERM_ITEM_UNRESTRICTED) == PERM_ITEM_UNRESTRICTED) || gSavedSettings.getBOOL("ForceNotecardDragCargoAcceptance"))
{
if( drop )
{
deselect();
S32 old_cursor = mCursorPos;
setCursorAtLocalPos( x, y, TRUE );
S32 insert_pos = mCursorPos;
setCursorPos(old_cursor);
BOOL inserted = insertEmbeddedItem( insert_pos, item );
if( inserted && (old_cursor > mCursorPos) )
{
setCursorPos(mCursorPos + 1);
}
updateLineStartList();
}
*accept = ACCEPT_YES_COPY_MULTI;
}
else
{
*accept = ACCEPT_NO;
if (tooltip_msg.empty())
{
tooltip_msg.assign("Only items with unrestricted\n"
"'next owner' permissions \n"
"can be attached to notecards.");
}
}
}
else
{
*accept = ACCEPT_NO;
}
break;
}
default:
*accept = ACCEPT_NO;
break;
}
}
else
{
// Not enabled
*accept = ACCEPT_NO;
}
handled = TRUE;
LL_DEBUGS("UserInput") << "dragAndDrop handled by LLViewerTextEditor " << getName() << LL_ENDL;
}
return handled;
}
option& set_default_value( const char* _value ) {
check_option_necessity();
value.assign( _value );
default_value.assign( value.begin(), value.end() );
return *this;
}
/** Handle /KILL
*/
CmdResult CommandKill::Handle (const std::vector<std::string>& parameters, User *user)
{
/* Allow comma seperated lists of users for /KILL (thanks w00t) */
if (CommandParser::LoopCall(user, this, parameters, 0))
{
// If we got a colon delimited list of nicks then the handler ran for each nick,
// and KILL commands were broadcast for remote targets.
return CMD_FAILURE;
}
User *u = ServerInstance->FindNick(parameters[0]);
if ((u) && (!IS_SERVER(u)))
{
/*
* Here, we need to decide how to munge kill messages. Whether to hide killer, what to show opers, etc.
* We only do this when the command is being issued LOCALLY, for remote KILL, we just copy the message we got.
*
* This conditional is so that we only append the "Killed (" prefix ONCE. If killer is remote, then the kill
* just gets processed and passed on, otherwise, if they are local, it gets prefixed. Makes sense :-) -- w00t
*/
if (IS_LOCAL(user))
{
/*
* Moved this event inside the IS_LOCAL check also, we don't want half the network killing a user
* and the other half not. This would be a bad thing. ;p -- w00t
*/
ModResult MOD_RESULT;
FIRST_MOD_RESULT(OnKill, MOD_RESULT, (user, u, parameters[1]));
if (MOD_RESULT == MOD_RES_DENY)
return CMD_FAILURE;
killreason = "Killed (";
if (!ServerInstance->Config->HideKillsServer.empty())
{
// hidekills is on, use it
killreason += ServerInstance->Config->HideKillsServer;
}
else
{
// hidekills is off, do nothing
killreason += user->nick;
}
killreason += " (" + parameters[1] + "))";
}
else
{
/* Leave it alone, remote server has already formatted it */
killreason.assign(parameters[1], 0, ServerInstance->Config->Limits.MaxQuit);
}
/*
* Now we need to decide whether or not to send a local or remote snotice. Currently this checking is a little flawed.
* No time to fix it right now, so left a note. -- w00t
*/
if (!IS_LOCAL(u))
{
// remote kill
if (!user->server->IsULine())
ServerInstance->SNO->WriteToSnoMask('K', "Remote kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
this->lastuuid = u->uuid;
}
else
{
// local kill
/*
* XXX - this isn't entirely correct, servers A - B - C, oper on A, client on C. Oper kills client, A and B will get remote kill
* snotices, C will get a local kill snotice. this isn't accurate, and needs fixing at some stage. -- w00t
*/
if (!user->server->IsULine())
{
if (IS_LOCAL(user))
ServerInstance->SNO->WriteGlobalSno('k',"Local Kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
else
ServerInstance->SNO->WriteToSnoMask('k',"Local Kill by %s: %s (%s)", user->nick.c_str(), u->GetFullRealHost().c_str(), parameters[1].c_str());
}
ServerInstance->Logs->Log("KILL", LOG_DEFAULT, "LOCAL KILL: %s :%s!%s!%s (%s)", u->nick.c_str(), ServerInstance->Config->ServerName.c_str(), user->dhost.c_str(), user->nick.c_str(), parameters[1].c_str());
u->Write(":%s KILL %s :%s!%s!%s (%s)", ServerInstance->Config->HideKillsServer.empty() ? user->GetFullHost().c_str() : ServerInstance->Config->HideKillsServer.c_str(),
u->nick.c_str(),
ServerInstance->Config->ServerName.c_str(),
user->dhost.c_str(),
ServerInstance->Config->HideKillsServer.empty() ? user->nick.c_str() : ServerInstance->Config->HideKillsServer.c_str(),
parameters[1].c_str());
this->lastuuid.clear();
}
// send the quit out
ServerInstance->Users->QuitUser(u, killreason);
}
else
{
user->WriteNumeric(ERR_NOSUCHNICK, "%s :No such nick/channel", parameters[0].c_str());
return CMD_FAILURE;
}
return CMD_SUCCESS;
}
void message::get(std::string& string, size_t const& part) const
{
string.assign( get(part) );
}
void msx_slot_cartridge_device::get_default_card_software(std::string &result)
{
if (open_image_file(mconfig().options()))
{
const char *slot_string = "nomapper";
UINT32 length = core_fsize(m_file);
dynamic_buffer rom(length);
int type = NOMAPPER;
// Check if there's some mapper related information in the hashfiles
std::string extrainfo;
if (hashfile_extrainfo(*this, extrainfo))
{
int extrainfo_type = -1;
if (1 == sscanf(extrainfo.c_str(), "%d", &extrainfo_type))
{
static const struct { int extrainfo; int mapper; } extrainfo_map[] = {
//{ 0, NOMAPPER },
{ 1, MSXDOS2 },
{ 2, KONAMI_SCC },
{ 3, KONAMI },
{ 4, ASCII8 },
{ 5, ASCII16 },
{ 6, GAMEMASTER2 },
{ 7, ASCII8_SRAM },
{ 8, ASCII16_SRAM },
{ 9, RTYPE },
{ 10, MAJUTSUSHI },
{ 11, FMPAC },
{ 12, SUPERLODERUNNER },
{ 13, SYNTHESIZER },
{ 14, CROSSBLAIM },
{ 15, DISK_ROM },
{ 16, KOREAN_80IN1 },
{ 17, KOREAN_126IN1 }
};
for (int i = 0; i < ARRAY_LENGTH(extrainfo_map); i++)
{
if (extrainfo_map[i].extrainfo == extrainfo_type)
{
type = extrainfo_map[i].mapper;
}
}
}
}
if (type == NOMAPPER)
{
// Not identified through hashfile, try automatic detection
type = get_cart_type(&rom[0], length);
}
if (type > NOMAPPER)
{
slot_string = msx_cart_get_slot_option(type);
}
result.assign(slot_string);
return;
}
software_get_default_slot(result, "nomapper");
}