bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Sensor_stm32comm_Params * params=(VisualizationMono_Sensor_stm32comm_Params *)paramsPtr;
VisualizationMono_Sensor_stm32comm_Vars * vars=(VisualizationMono_Sensor_stm32comm_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
//vars->comm_label->setText("open");
GetParamValue(xmlloader,params,mapsize);
GetParamValue(xmlloader,params,pixelsize);
GetParamValue(xmlloader,vars,showheight);
vars->mapzero.x = 0;
vars->mapzero.y = 0;
vars->map.create(cv::Size(params->mapsize,params->mapsize),CV_8UC3);
vars->map.setTo(0);
vars->qmap->setText("Opened");
return 1;
}
wxObject *wxHyperlinkCtrlXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(control, wxHyperlinkCtrl)
SetupWindow(control);
control->Create(m_parentAsWindow, GetID(),
GetParamValue(wxT("label")), GetParamValue(wxT("url")),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxHL_DEFAULT_STYLE));
return control;
}
bool GetScanChanelStatus()
{
char szReq[1024] = {0};
char szResp[1024];
sprintf(szReq,"<msg type=\"Scan_Channel_req\"></msg>");
bool bOK = ExchangeMessage( szReq,szResp );
if(!bOK)
return false;
int ret = GetResponseRetValue(szResp);
if(ret == -1)
{
printf("all channel is no signal!\n");
return false;
}
char Freq[10];
bOK = GetParamValue(szResp,"freq","\"","\"",Freq);
if( !bOK )
return false;
int freq = atoi(Freq);
printf("Signal Channel Freq:%d\n",freq);
bOK = LockFrequencyPoint("DVB-T2",freq * 1000,8000,0,0);
if(bOK)
printf("Lock FrequencyPoint success!\n");
else
printf("Lock FrequencyPoint fail!\n");
return true;
}
int
VideoEncoder::GetGPUCount(NVEncoderParams *pParams, int *gpuPerf, int *bestGPU)
{
assert(gpuPerf != NULL && bestGPU != NULL && pParams != NULL);
// Now we can query the GPUs available for encoding
HRESULT hr = GetParamValue(NVVE_GET_GPU_COUNT, &(pParams->GPU_count));
if (hr!=S_OK)
{
printf(" >> NVVE_GET_GPU_COUNT error ! <<\n\n");
}
printf("\n[ Detected %d GPU(s) capable of CUDA Accelerated Video Encoding ]\n\n", pParams->GPU_count);
int temp = 0;
for (int deviceCount=0; deviceCount < pParams->GPU_count; deviceCount++)
{
temp = DisplayGPUCaps(deviceCount, pParams, !(pParams->force_device));
if (temp > (*gpuPerf))
{
*gpuPerf = temp;
*bestGPU = deviceCount;
}
}
return (*bestGPU);
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
Simulator_Sensor_Velodyne_Params * params=(Simulator_Sensor_Velodyne_Params *)paramsPtr;
SensorInternalEvent_ROS_Sensor_Velodyne_Vars * vars=(SensorInternalEvent_ROS_Sensor_Velodyne_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,params,velodynecalibfile);
QFile file;
file.setFileName(params->velodynecalibfile);
if(!file.exists()||!file.open(QIODevice::ReadOnly|QIODevice::Text))
{
return 0;
}
while(!file.atEnd())
{
QString tmpstr=file.readLine();
int tmpindex=tmpstr.indexOf(":");
if(tmpindex<0)
{
continue;
}
QString prefix=tmpstr.left(tmpindex).trimmed();
QString suffix=tmpstr.mid(tmpindex+1).trimmed();
QStringList values=suffix.split(QChar(' '),QString::SkipEmptyParts);
if(prefix.startsWith(QString("R")))
{
int i,n=values.size();
for(i=0;i<n;i++)
{
int row=i/3;
int col=i%3;
params->calib2camera(row,col)=values[i].toFloat();
}
}
else if(prefix.startsWith(QString("T")))
{
int i,n=values.size();
for(i=0;i<n;i++)
{
params->calib2camera(i,3)=values[i].toFloat();
}
}
}
file.close();
vars->velodynesub->startReceiveSlot();
return 1;
}
wxObject *wxFilePickerCtrlXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(picker, wxFilePickerCtrl)
picker->Create(m_parentAsWindow,
GetID(),
GetParamValue(wxT("value")),
GetText(wxT("message")),
GetParamValue(wxT("wildcard")),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxFLP_DEFAULT_STYLE),
wxDefaultValidator,
GetName());
SetupWindow(picker);
return picker;
}
wxObject *wxSplitterWindowXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(splitter, wxSplitterWindow);
splitter->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxSP_3D),
GetName());
SetupWindow(splitter);
long sashpos = GetLong(wxT("sashpos"), 0);
long minpanesize = GetLong(wxT("minsize"), -1);
if (minpanesize != -1)
splitter->SetMinimumPaneSize(minpanesize);
wxWindow *win1 = NULL, *win2 = NULL;
wxXmlNode *n = m_node->GetChildren();
while (n)
{
if ((n->GetType() == wxXML_ELEMENT_NODE) &&
(n->GetName() == wxT("object") ||
n->GetName() == wxT("object_ref")))
{
wxObject *created = CreateResFromNode(n, splitter, NULL);
wxWindow *win = wxDynamicCast(created, wxWindow);
if (win1 == NULL)
{
win1 = win;
}
else
{
win2 = win;
break;
}
}
n = n->GetNext();
}
if (win1 == NULL)
wxLogError(wxT("wxSplitterWindow node must contain at least one window."));
bool horizontal = (GetParamValue(wxT("orientation")) != wxT("vertical"));
if (win1 && win2)
{
if (horizontal)
splitter->SplitHorizontally(win1, win2, sashpos);
else
splitter->SplitVertically(win1, win2, sashpos);
}
else
{
splitter->Initialize(win1);
}
return splitter;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
SensorInternalEvent_Sensor_Laser_Params * params=(SensorInternalEvent_Sensor_Laser_Params *)paramsPtr;
Simulator_Sensor_Laser_Vars * vars=(Simulator_Sensor_Laser_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,vars,path);
GetParamValue(xmlloader,vars,filename);
GetParamValue(xmlloader,params,first_step);
GetParamValue(xmlloader,params,last_step);
GetParamValue(xmlloader,params,skip_step);
GetParamValue(xmlloader,params,nearfilter);
GetParamValue(xmlloader,params,farfilter);
vars->file.setFileName(QString("%1%2").arg(vars->path).arg(vars->filename));
if(!vars->file.open(QIODevice::ReadOnly))
{
return 0;
}
vars->file.read(sizeof(float)*3);//文件头
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Sensor_Laser_Params * params=(VisualizationMono_Sensor_Laser_Params *)paramsPtr;
VisualizationMono_Sensor_Laser_Vars * vars=(VisualizationMono_Sensor_Laser_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,params,range);
GetParamValue(xmlloader,params,interval);
GetParamValue(xmlloader,params,imageradius);
GetParamValue(xmlloader,params,frontonly);
GetParamValue(xmlloader,params,laserbeam);
GetParamValue(xmlloader,params,calib_width);
GetParamValue(xmlloader,params,calib_height);
vars->beams->setText("Opened");
return 1;
}
void CGmObjShape::Init()
{
GetParamValue( "collision_damage", &m_fCollisionDamage );
if( m_poEffect )
{
m_poEffect->Init();
}
}
int GetResponseRetValue( const char*xml)
{
char szValue[256]={0};
bool bOK = GetParamValue( xml, "ret", "\"", "\"", szValue ) ;
if( !bOK )
return -1 ;
return atoi(szValue) ;
}
wxObject *wxCollapsiblePaneXmlHandler::DoCreateResource()
{
if (m_class == wxT("panewindow")) // read the XRC for the pane window
{
wxXmlNode *n = GetParamNode(wxT("object"));
if ( !n )
n = GetParamNode(wxT("object_ref"));
if (n)
{
bool old_ins = m_isInside;
m_isInside = false;
wxObject *item = CreateResFromNode(n, m_collpane->GetPane(), NULL);
m_isInside = old_ins;
return item;
}
else
{
ReportError("no control within panewindow");
return NULL;
}
}
else
{
XRC_MAKE_INSTANCE(ctrl, wxCollapsiblePane)
wxString label = GetParamValue(wxT("label"));
if (label.empty())
{
ReportParamError("label", "label cannot be empty");
return NULL;
}
ctrl->Create(m_parentAsWindow,
GetID(),
label,
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxCP_DEFAULT_STYLE),
wxDefaultValidator,
GetName());
ctrl->Collapse(GetBool(wxT("collapsed")));
SetupWindow(ctrl);
wxCollapsiblePane *old_par = m_collpane;
m_collpane = ctrl;
bool old_ins = m_isInside;
m_isInside = true;
CreateChildren(m_collpane, true/*only this handler*/);
m_isInside = old_ins;
m_collpane = old_par;
return ctrl;
}
}
/** 函数名： get_config_value int 的项值
* 功能描述： 获取配置文件中某一项的值
* 参数列表： item:为配置文件中的项名
* 返回值： 出错返回-1 成功返回项的值
*/
int get_config_value(char *item)
{
char value[50];
if(GetParamValue(CONFIGFILENAME,item,value) == NULL)
{
return -1;
}
return atoi(value);
}
void wxSizerXmlHandler::SetFlexibleMode(wxFlexGridSizer* fsizer)
{
if (HasParam(wxT("flexibledirection")))
{
wxString dir = GetParamValue(wxT("flexibledirection"));
if (dir == wxT("wxVERTICAL"))
fsizer->SetFlexibleDirection(wxVERTICAL);
else if (dir == wxT("wxHORIZONTAL"))
fsizer->SetFlexibleDirection(wxHORIZONTAL);
else if (dir == wxT("wxBOTH"))
fsizer->SetFlexibleDirection(wxBOTH);
else
{
ReportParamError
(
wxT("flexibledirection"),
wxString::Format("unknown direction \"%s\"", dir)
);
}
}
if (HasParam(wxT("nonflexiblegrowmode")))
{
wxString mode = GetParamValue(wxT("nonflexiblegrowmode"));
if (mode == wxT("wxFLEX_GROWMODE_NONE"))
fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_NONE);
else if (mode == wxT("wxFLEX_GROWMODE_SPECIFIED"))
fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
else if (mode == wxT("wxFLEX_GROWMODE_ALL"))
fsizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_ALL);
else
{
ReportParamError
(
wxT("nonflexiblegrowmode"),
wxString::Format("unknown grow mode \"%s\"", mode)
);
}
}
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Params * params=(VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Params *)paramsPtr;
VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Vars * vars=(VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,vars,radius);
GetParamValue(xmlloader,vars,thickness);
GetParamValue(xmlloader,vars,range);
vars->image->setText("Open");
vars->init=1;
return 1;
}
/* Checks if commandline argument contains property specified
* and analyze it as boolean property (true/false).
* Returns -1 if the argument does not contain the parameter;
* Returns 1 if the argument contains the parameter and its value is "true";
* Returns 0 if the argument contains the parameter and its value is "false".
*/
int GetBoolParamValue(const char *paramName, const char *arg) {
const char * paramValue = GetParamValue(paramName, arg);
if (paramValue != NULL) {
if (JLI_StrCaseCmp(paramValue, "true") == 0) {
return 1;
}
if (JLI_StrCaseCmp(paramValue, "false") == 0) {
return 0;
}
}
return -1;
}
//-----------------------------------------------------------------------------
void USER_IMPL::Connect(bool fakeConnect)
{
/*
* Connect user to Internet. This function is differ from Authorize() !!!
*/
STG_LOCKER lock(&mutex);
if (!fakeConnect)
{
std::string scriptOnConnect = settings->GetScriptsDir() + "/OnConnect";
if (access(scriptOnConnect.c_str(), X_OK) == 0)
{
std::string dirs = dirsToString(enabledDirs);
std::string scriptOnConnectParams;
strprintf(&scriptOnConnectParams,
"%s \"%s\" \"%s\" \"%f\" \"%d\" \"%s\"",
scriptOnConnect.c_str(),
login.c_str(),
inet_ntostring(currIP).c_str(),
cash.ConstData(),
id,
dirs.c_str());
std::vector<std::string>::const_iterator it(settings->GetScriptParams().begin());
while (it != settings->GetScriptParams().end())
{
scriptOnConnectParams += " \"" + GetParamValue(it->c_str()) + "\"";
++it;
}
ScriptExec(scriptOnConnectParams.c_str());
}
else
{
WriteServLog("Script %s cannot be executed. File not found.", scriptOnConnect.c_str());
}
connected = true;
}
if (!settings->GetDisableSessionLog() && store->WriteUserConnect(login, currIP))
{
WriteServLog("Cannot write connect for user %s.", login.c_str());
WriteServLog("%s", store->GetStrError().c_str());
}
if (!fakeConnect)
lastIPForDisconnect = currIP;
}
bool CGmObjShape::GetParamValue( const char * pcParamName, int *piValue )
{
if( piValue )
{
float fValue;
if( GetParamValue( pcParamName, &fValue ) )
{
*piValue = int( rintf( fValue ) );
return true;
}
}
return false;
}
wxObject *wxButtonXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(button, wxButton)
button->Create(m_parentAsWindow,
GetID(),
GetText(wxT("label")),
GetPosition(), GetSize(),
GetStyle(),
wxDefaultValidator,
GetName());
if (GetBool(wxT("default"), 0))
button->SetDefault();
if ( GetParamNode("bitmap") )
{
wxDirection dir;
const wxString dirstr = GetParamValue("direction");
if ( dirstr.empty() || dirstr == "wxLEFT" )
dir = wxLEFT;
else if ( dirstr == "wxRIGHT" )
dir = wxRIGHT;
else if ( dirstr == "wxTOP" )
dir = wxTOP;
else if ( dirstr == "wxBOTTOM" )
dir = wxBOTTOM;
else
{
ReportError
(
GetParamNode("bitmapposition"),
wxString::Format
(
"Invalid bitmap position \"%s\": must be one of "
"wxLEFT|wxRIGHT|wxTOP|wxBOTTOM.",
dirstr
)
);
dir = wxLEFT;
}
button->SetBitmap(GetBitmap("bitmap", wxART_BUTTON), dir);
}
SetupWindow(button);
return button;
}
wxObject *wxBitmapButtonXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(button, wxBitmapButton)
button->Create(m_parentAsWindow,
GetID(),
GetBitmap(wxT("bitmap"), wxART_BUTTON),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxBU_AUTODRAW),
wxDefaultValidator,
GetName());
if (GetBool(wxT("default"), 0))
button->SetDefault();
SetupWindow(button);
if (!GetParamValue(wxT("selected")).IsEmpty())
button->SetBitmapSelected(GetBitmap(wxT("selected")));
if (!GetParamValue(wxT("focus")).IsEmpty())
button->SetBitmapFocus(GetBitmap(wxT("focus")));
if (!GetParamValue(wxT("disabled")).IsEmpty())
button->SetBitmapDisabled(GetBitmap(wxT("disabled")));
return button;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Processor_PathGenerator_Params * params=(VisualizationMono_Processor_PathGenerator_Params *)paramsPtr;
VisualizationMono_Processor_PathGenerator_Vars * vars=(VisualizationMono_Processor_PathGenerator_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, vars, offlineTrajecPath);
GetParamValue(xmlloader, vars, offlineTrajecFilename);
FILE *fp = fopen((vars->offlineTrajecPath+vars->offlineTrajecFilename).toStdString().c_str(), "r");
double ox, oy, oth;
while (fscanf(fp, "%lf %lf %lf", &ox, &oy, &oth) == 3)
{
trajec_state tmp = {ox, oy, oth, 0};
vars->offlinetrajec.push_back(tmp);
}
fclose(fp);
vars->glviewer->makeCurrent();
vars->glviewer->setBackground(QColor(241,241,241));
vars->glviewer->clearDisplayList();
vars->displaylistbase = glGenLists(vars->shownum);
int i;
for(i=0; i<vars->shownum; i++)
vars->glviewer->addDisplayList(vars->displaylistbase + i);
vars->lastPos.x = vars->lastPos.y = 0;
return 1;
}
void wxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer,
const wxChar* param,
bool rows)
{
int nrows, ncols;
sizer->CalcRowsCols(nrows, ncols);
const int nslots = rows ? nrows : ncols;
wxStringTokenizer tkn;
tkn.SetString(GetParamValue(param), wxT(","));
while (tkn.HasMoreTokens())
{
unsigned long l;
if (!tkn.GetNextToken().ToULong(&l))
{
ReportParamError
(
param,
"value must be comma-separated list of row numbers"
);
break;
}
if ( (int)l >= nslots )
{
ReportParamError
(
param,
wxString::Format
(
"invalid %s index %d: must be less than %d",
rows ? "row" : "column",
l,
nslots
)
);
// ignore incorrect value, still try to process the rest
continue;
}
if (rows)
sizer->AddGrowableRow(l);
else
sizer->AddGrowableCol(l);
}
}
/*-------------------------------------------*/
void ReadFile()
{
/*The files may contain comments etc, but I look for strings in the
form "#define NUMINDS 424" which define parameter values*/
int notEOF = 1; /*switch this to 0 when we hit EOF*/
char next;
do /*scan the file for # until EOF is reached*/
{
next = fgetc(PARAMS);
if (next==EOF) notEOF=0;
else if (next=='#') /*signals parameter value coming*/
GetParamValue();
} while (notEOF);
}
void MaxSizerXmlHandler::SetGrowables(wxFlexGridSizer* sizer, const wxChar* param, bool rows) {
wxStringTokenizer tkn;
unsigned long l;
tkn.SetString(GetParamValue(param), wxT(","));
while (tkn.HasMoreTokens())
{
if (!tkn.GetNextToken().ToULong(&l))
wxLogError(wxT("growable[rows|cols] must be comma-separated list of row numbers"));
else {
if (rows)
sizer->AddGrowableRow(l);
else
sizer->AddGrowableCol(l);
}
}
}
wxObject *wxFileCtrlXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(filectrl, wxFileCtrl)
filectrl->Create(m_parentAsWindow,
GetID(),
GetText(wxT("defaultdirectory")),
GetText(wxT("defaultfilename")),
GetParamValue(wxT("wildcard")),
GetStyle(wxT("style"), wxFC_DEFAULT_STYLE),
GetPosition(),
GetSize(),
GetName());
SetupWindow(filectrl);
return filectrl;
}
bool GetSignalStatus()
{
char szReq[1024]={0};
char szResp[1024];
sprintf(szReq, "<msg type=\"signal_status_req\"></msg>") ;
bool bOK = ExchangeMessage( szReq, szResp ) ;
if( !bOK )
return false ;
char Signal_Status[500];
bOK = GetParamValue(szResp,"signal_status"," ","/>",Signal_Status);
if(!bOK )
return false ;
printf("Signal_Status:%s\n",Signal_Status);
return true ;
}
void
VideoEncoder::SetGPUOffloadLevel(NVEncoderParams *pParams)
{
assert(pParams != NULL);
NVVE_GPUOffloadLevel eMaxOffloadLevel = NVVE_GPU_OFFLOAD_DEFAULT;
HRESULT hr = GetParamValue(NVVE_GPU_OFFLOAD_LEVEL_MAX, &eMaxOffloadLevel);
if (hr!=S_OK)
{
printf(" >> NVVE_GPUOFFLOAD_LEVEL_MAX Error <<\n\n");
}
if (pParams->GPUOffloadLevel > eMaxOffloadLevel)
{
pParams->GPUOffloadLevel = eMaxOffloadLevel;
printf(" >> Overriding, setting GPU to: ");
switch (pParams->GPUOffloadLevel)
{
case NVVE_GPU_OFFLOAD_DEFAULT:
printf("Offload Default (CPU: PEL Processing\n)");
break;
case NVVE_GPU_OFFLOAD_ESTIMATORS:
printf("Offload Motion Estimators\n");
break;
case NVVE_GPU_OFFLOAD_ALL:
printf("Offload Full Encode\n)");
break;
}
}
hr = SetParamValue(NVVE_GPU_OFFLOAD_LEVEL, &(pParams->GPUOffloadLevel));
if (hr!=S_OK)
{
printf(" >> NVVE_GPU_OFFLOAD_LEVEL Error <<\n\n");
}
}
bool Login()
{
char szReq[1024] = {0};
char szResp[1024] = {0};
sprintf( szReq, "<msg type=\"login_req\"><params protocol=\"UDP\" port=\"%d\"/></msg>", m_nMyRecvPort ) ;
bool bOK = ExchangeMessage( szReq, szResp ) ;
if( !bOK )
return false ;
int ret = GetResponseRetValue( szResp ) ;
if( ret != 0 )
{
return false ;
}
char szDevInfo[256];
bOK = GetParamValue( szResp, "deviceinfo", " ", "/>", szDevInfo ) ;
printf("devices info:%s\n",szDevInfo);
return true ;
}
wxObject *wxHtmlWindowXmlHandler::DoCreateResource()
{
XRC_MAKE_INSTANCE(control, wxHtmlWindow)
control->Create(m_parentAsWindow,
GetID(),
GetPosition(), GetSize(),
GetStyle(wxT("style"), wxHW_SCROLLBAR_AUTO),
GetName());
if (HasParam(wxT("borders")))
{
control->SetBorders(GetDimension(wxT("borders")));
}
if (HasParam(wxT("url")))
{
wxString url = GetParamValue(wxT("url"));
wxFileSystem& fsys = GetCurFileSystem();
wxFSFile *f = fsys.OpenFile(url);
if (f)
{
control->LoadPage(f->GetLocation());
delete f;
}
else
control->LoadPage(url);
}
else if (HasParam(wxT("htmlcode")))
{
control->SetPage(GetText(wxT("htmlcode")));
}
SetupWindow(control);
return control;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMulti_VisualMisc_ControlJoy_Params * params=(VisualizationMulti_VisualMisc_ControlJoy_Params *)paramsPtr;
VisualizationMulti_VisualMisc_ControlJoy_Vars * vars=(VisualizationMulti_VisualMisc_ControlJoy_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, vars, leftArrowPath);
GetParamValue(xmlloader, vars, rightArrowPath);
GetParamValue(xmlloader, vars, forwardArrowPath);
GetParamValue(xmlloader, vars, backArrowPath);
GetParamValue(xmlloader, vars, width);
GetParamValue(xmlloader, vars, height);
GetParamValue(xmlloader, vars, fontSize);
std::cout<<"open Joystick\n";
vars->label->setText("Open");
bool flag = vars->leftArrowImg.load(vars->leftArrowPath);
flag &= vars->rightArrowImg.load(vars->rightArrowPath);
flag &= vars->forwardArrowImg.load(vars->forwardArrowPath);
flag &= vars->backArrowImg.load(vars->backArrowPath);
if(!flag)
{
std::cout<<"load image error: VisualizationMulti_ControlJoy !"<<std::endl;
return 0;
}
return 1;
}