//! [Window constructor start]
Window::Window()
{
thread = new RenderThread();
//! [Window constructor start] //! [set up widgets and connections]
label = new QLabel();
label->setAlignment(Qt::AlignCenter);
loadButton = new QPushButton(tr("&Load image..."));
resetButton = new QPushButton(tr("&Stop"));
resetButton->setEnabled(false);
connect(loadButton, SIGNAL(clicked()), this, SLOT(loadImage()));
connect(resetButton, SIGNAL(clicked()), thread, SLOT(stopProcess()));
connect(thread, SIGNAL(finished()), this, SLOT(resetUi()));
//! [set up widgets and connections] //! [connecting signal with custom type]
connect(thread, SIGNAL(sendBlock(Block)), this, SLOT(addBlock(Block)));
//! [connecting signal with custom type]
QHBoxLayout *buttonLayout = new QHBoxLayout();
buttonLayout->addStretch();
buttonLayout->addWidget(loadButton);
buttonLayout->addWidget(resetButton);
buttonLayout->addStretch();
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addWidget(label);
layout->addLayout(buttonLayout);
//! [Window constructor finish]
setWindowTitle(tr("Queued Custom Type"));
}
void WinDbgThread::startProcess(const QString& filename)
{
stopProcess();
m_bOwnsProcess = true;
m_processFileName = filename;
m_pi.dwProcessId = 0;
QThread::start();
}
//!
void ArgManager::analyse(int argc, char *argv[])
{
// Lecture des paramétres
int nbParam = (argc-1)/2;
int acParam = 0;
while(acParam <= nbParam && nbParam>0)
{
acParam++;
string argTag = string(argv[acParam]);
absArgument* arg = getArg(argTag);
if(arg==NULL){
cerr << "Erreur argument " << argTag << " : tag non valide" << endl;
stopProcess();
}
Argument<string>* strArg = dynamic_cast<Argument<string>* >(arg);
Argument<int>* intArg = dynamic_cast<Argument<int>* >(arg);
if(strArg)
{
cerr << "if(strArg) ok" << " Value = " << string(argv[acParam+1]);
strArg->validArg();
strArg->setValue(string(argv[++acParam]));
}
else if(intArg)
{
// cerr << "acParam = " << acParam << "argc = "<< argc << endl;
// cerr << "if(intArg) ok" << " Value = " << string(argv[acParam+1]) << endl;
intArg->validArg();
string strInt = string(argv[++acParam]);
intArg->setValue(atoi(strInt.c_str()));
}
else
{
cerr << "Erreur argument " << argTag << " : type non valide" << endl;
stopProcess();
}
}
}
bool PCProcess::setMemoryAccessRights(Address start, size_t size,
PCMemPerm rights) {
// if (PAGE_EXECUTE_READWRITE == rights || PAGE_READWRITE == rights) {
if (rights.isRWX() || rights.isRW() ) {
mapped_object *obj = findObject(start);
int page_size = getMemoryPageSize();
for (Address cur = start; cur < (start + size); cur += page_size) {
obj->removeProtectedPage(start -(start % page_size));
}
}
stopProcess();
changeMemoryProtections(start, size, rights, true);
return true;
}
bool ProcessServer::stopProcess( dword processId )
{
AutoLock lock( &m_Lock );
if ( m_ProcessInfo.find( processId ).valid() )
{
ProcessInfo & info = m_ProcessInfo[ processId ];
Event stopProcess( CharString().format("StopProcess%u", ::Process::getProcessId( info.m_pHandle )) );
stopProcess.signal();
return true;
}
return false;
}
/**
* Receives a packet and tries to write the packet into the ringbuffer
*/
void PCAPExporterMem::receive(Packet* packet)
{
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive() called");
if (onRestart) {
DPRINTF("Dropping incoming packet, as attached process is not ready");
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive() ended");
packet->removeReference();
return;
}
if (fifoReaderPid == 0) {
msg(MSG_VDEBUG, "fifoReaderPid = 0...this might happen during reconfiguration");
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive() ended");
packet->removeReference();
return;
}
if (restartInterval) {
if (nextRestart.tv_sec==0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive(): updating nextRestart");
nextRestart = packet->timestamp;
nextRestart.tv_sec += restartInterval;
} else if (compareTime(nextRestart, packet->timestamp)<0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive(): restarting process");
// we need to unregister our signal handlers, as we get race conditions with the signal handler for restarting the process
unregisterSignalHandlers();
stopProcess();
startProcess();
registerSignalHandlers();
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive(): updating nextRestart");
nextRestart.tv_sec += ((packet->timestamp.tv_sec-nextRestart.tv_sec)/restartInterval+1)*restartInterval;
}
}
if (writeIntoMemory(packet)) {
statPktsForwarded++;
statBytesForwarded += packet->data_length;
DPRINTFL(MSG_VDEBUG, "Wrote packet at pos %u", *nextWrite);
} else {
batchUpdate();
statPktsDropped++;
statBytesDropped += packet->data_length;
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive(): dropped packet");
}
packet->removeReference();
DPRINTFL(MSG_VDEBUG, "PCAPExporterMem::receive() ended");
}
void MOPACInputDialog::computeClicked()
{
if (m_process != 0) {
QMessageBox::warning(this, tr("MOPAC Running."),
tr("MOPAC is already running. Wait until the previous calculation is finished."));
return;
}
QString fileName = saveInputFile(ui.previewText->toPlainText(), tr("MOPAC Input Deck"), QString("mop"));
if (fileName.isEmpty())
return;
QFileInfo info(mopacPath);
if (!info.exists() || !info.isExecutable()) {
QMessageBox::warning(this, tr("MOPAC Not Installed."),
tr("The MOPAC executable, cannot be found."));
return;
}
m_process = new QProcess(this);
QFileInfo input(fileName);
m_process->setWorkingDirectory(input.absolutePath());
QStringList arguments;
arguments << fileName;
m_inputFile = fileName; // save for reading in output
m_process->start(mopacPath, arguments);
if (!m_process->waitForStarted()) {
QMessageBox::warning(this, tr("MOPAC failed to start."),
tr("MOPAC did not start. Perhaps it is not installed correctly."));
}
connect(m_process, SIGNAL(finished(int)), this, SLOT(finished(int)));
m_progress = new QProgressDialog(this);
m_progress->setRange(0,0); // indeterminate progress
m_progress->setLabelText(tr("Running MOPAC calculation..."));
m_progress->show();
connect(m_progress, SIGNAL(canceled()), this, SLOT(stopProcess()));
}
//=====================================
// Stop processes and release all data
//=====================================
void cJulius::release( void )
{
if ( ! m_recog ) return;
stopProcess();
if (m_threadHandle) {
CloseHandle(m_threadHandle);
m_threadHandle = NULL;
} else {
if ( m_recog ) {
j_recog_free( m_recog ); // jconf will be released inside this
m_recog = NULL;
m_jconf = NULL;
}
if ( m_jconf ) {
j_jconf_free( m_jconf );
m_jconf = NULL;
}
}
}
/**
* @brief VLC module destruct callback
* @param obj
*/
static void y4m_close(vlc_object_t* obj)
{
filter_t* intf = (filter_t*)obj;
filter_sys_t* sys = intf->p_sys;
msg_Info(intf, "close");
// process stop causes thread exit if blocked on write
stopProcess(intf);
// cancel causes thread exit if blocked in mutex or cond wait
if (sys->inputThread.handle)
{
vlc_cancel(sys->inputThread);
vlc_join(sys->inputThread, NULL);
}
// output should be dead if input is
if (sys->outputThread.handle)
vlc_join(sys->outputThread, NULL);
picture_fifo_Flush(sys->inputFifo, LAST_MDATE, true);
picture_fifo_Flush(sys->outputFifo, LAST_MDATE, true);
picture_fifo_Delete(sys->inputFifo);
picture_fifo_Delete(sys->outputFifo);
vlc_cond_destroy(&sys->inputCond);
vlc_cond_destroy(&sys->outputCond);
vlc_mutex_destroy(&sys->inputMutex);
vlc_mutex_destroy(&sys->outputMutex);
free(sys->cmd);
free(sys);
}
WinDbgThread::~WinDbgThread()
{
stopProcess();
}
void ProcessServer::onReceive( dword client, byte message, const InStream & input )
{
//LOG_STATUS( "ProcessServer","onReceive, client = %u (%s), message = 0x%x", client, clientAddress(client), message );
switch( message )
{
case ProcessClient::SERVER_LOGIN:
{
dword job;
input >> job;
CharString uid;
input >> uid;
CharString md5;
input >> md5;
bool result = false;
MetaClient::Profile profile;
if ( m_MetaClient.loginByProxy( uid, md5, profile ) > 0 )
{
LOG_STATUS( "ProcessServer", CharString().format("Login %s, client %u (%s)", profile.name.cstr(), client, clientAddress(client)) );
result = (profile.flags & (MetaClient::ADMINISTRATOR|MetaClient::SERVER)) != 0;
}
else
LOG_STATUS( "ProcessServer", CharString().format("Login failed, client %u (%s)", client, clientAddress(client)) );
AutoLock lock( &m_Lock );
m_ClientValid[ client ] = result;
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << result;
}
break;
case ProcessClient::SERVER_SESSION_LOGIN:
{
dword job;
input >> job;
dword sessionId;
input >> sessionId;
bool result = false;
MetaClient::Profile profile;
if ( m_MetaClient.loginByProxy( sessionId, profile ) > 0 )
{
LOG_STATUS( "ProcessServer", CharString().format("Login %s, client %u (%s)", profile.name.cstr(), client, clientAddress(client)) );
result = (profile.flags & MetaClient::ADMINISTRATOR) != 0;
}
else
LOG_STATUS( "ProcessServer", CharString().format("Login failed, client %u (%s)", client, clientAddress(client)) );
AutoLock lock( &m_Lock );
m_ClientValid[ client ] = result;
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << result;
}
break;
case ProcessClient::SERVER_SEND_PROCESS_LIST:
if ( validateClient( client ) )
{
dword job;
input >> job;
// send process list to the server
AutoLock lock( &m_Lock );
send( client, ProcessClient::CLIENT_RECV_PROCESS_LIST ) << job << m_ProcessList;
}
break;
case ProcessClient::SERVER_SEND_CONFIG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString config;
CharString configFile;
if ( processId != 0 )
{
Process proc;
if ( findProcess( processId, proc ) )
configFile = proc.config;
}
else
configFile = m_Context.config;
LOG_STATUS( "ProcessServer", CharString().format("Send Config, client %u (%s), configFile = %s",
client, clientAddress(client), configFile.cstr()) );
// attempt to load the configuration file
char * pConfig = FileDisk::loadTextFile( configFile );
if ( pConfig != NULL )
{
config = pConfig;
delete [] pConfig;
}
send( client, ProcessClient::CLIENT_RECV_CONFIG ) << job << config;
}
break;
case ProcessClient::SERVER_RECV_CONFIG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString config;
input >> config;
bool jobDone = false;
CharString configFile;
if ( processId != 0 )
{
Process proc;
if ( findProcess( processId, proc ) )
configFile = proc.config;
}
else
configFile = m_Context.config;
LOG_STATUS( "ProcessServer", "Recv Config, client %u (%s), configFile = %s",
client, clientAddress(client), configFile.cstr() );
// save the new file
jobDone = FileDisk::saveTextFile( configFile, CharString( config ) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_SEND_LOG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString log;
CharString logFile;
if ( processId != 0 )
{
// send log of one of our processes
Process proc;
if ( findProcess( processId, proc ) )
logFile = proc.log;
}
else
logFile = m_Context.logFile;
FileDisk file;
if ( file.open( logFile ) )
{
dword size = file.size();
if ( size > MAX_LOG_SIZE )
{
file.setPosition( size - MAX_LOG_SIZE );
size = MAX_LOG_SIZE;
}
char * pLog = new char[ size + 1];
pLog[ size ] = 0;
file.read( pLog, size );
file.close();
// save to string
log = pLog;
// release allocated memory
delete [] pLog;
}
else
log = "Failed to open log file!";
send( client, ProcessClient::CLIENT_RECV_LOG ) << job << log;
}
break;
case ProcessClient::SERVER_ADD_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
Process proc;
input >> proc;
AutoLock lock( &m_Lock );
proc.processId = m_NextProcessId++;
m_ProcessList.push( proc );
LOG_STATUS( "ProcessServer", "Add Process, client = %u (%s), processId = %u, name = %s, exec = %s",
client, clientAddress(client), proc.processId, proc.name.cstr(), proc.executable.cstr() );
saveProcessList();
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << true;
}
break;
case ProcessClient::SERVER_SET_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
Process proc;
input >> proc;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( proc.processId );
if ( pi >= 0 )
{
m_ProcessList[pi] = proc;
jobDone = true;
LOG_STATUS( "ProcessServer", "Set Process, client = %u (%s), processId = %u, name = %s, exec = %s",
client, clientAddress(client), proc.processId, proc.name.cstr(), proc.executable.cstr() );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_DEL_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
LOG_STATUS( "ProcessServer", "Delete Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
// stop the actual process if any
if ( m_ProcessInfo.find( processId ).valid() )
{
::Process::stop( m_ProcessInfo[ processId ].m_pHandle );
m_ProcessInfo.remove( processId );
}
// remove from the list
m_ProcessList.remove( pi );
jobDone = true;
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_STOP_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
m_ProcessList[ pi ].flags |= ProcessClient::PF_DISABLED;
jobDone = true;
LOG_STATUS( "ProcessServer", "Stop Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_START_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
int pi = findProcess( processId );
if ( pi >= 0 )
{
m_ProcessList[ pi ].flags &= ~ProcessClient::PF_DISABLED;
jobDone = true;
LOG_STATUS( "ProcessServer", "Start Process, name = %s, client = %u (%s), processId = %u",
m_ProcessList[pi].name.cstr(), client, clientAddress(client), processId );
saveProcessList();
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_RESTART_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
Process proc;
if ( findProcess( processId, proc ) )
{
if ( m_ProcessInfo.find( processId ).valid() )
{
jobDone = stopProcess( processId );
LOG_STATUS( "ProcessServer", "Restart Process, name = %s, client = %u (%s), processId = %u,",
proc.name.cstr(), client, clientAddress(client), processId );
}
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_SEND_STATUS:
if ( validateClient( client ) )
{
dword job;
input >> job;
AutoLock lock( &m_Lock );
ProcessClient::Status status;
status.processGroup = m_Context.processGroup;
status.networkGroup = m_Context.networkGroup;
status.cpuUsage = cpuUsage();
status.memoryUsage = memoryUsage();
status.processCount = 0;
for(int i=0;i<m_ProcessList.size();i++)
if ( (m_ProcessList[i].flags & ProcessClient::PF_RUNNING) != 0 )
status.processCount++;
send( client, ProcessClient::CLIENT_RECV_STATUS ) << job << status;
}
break;
case ProcessClient::SERVER_STOP_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
m_ProcessList[i].flags |= ProcessClient::PF_DISABLED;
saveProcessList();
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Stop All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_START_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
m_ProcessList[i].flags &= ~ProcessClient::PF_DISABLED;
saveProcessList();
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Start All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_RESTART_ALL:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = false;
AutoLock lock( &m_Lock );
for(int i=0;i<m_ProcessList.size();i++)
stopProcess( m_ProcessList[i].processId );
jobDone = true;
LOG_STATUS( "ProcessServer", CharString().format("Restart All, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_REBOOT:
if ( validateClient( client ) )
{
dword job;
input >> job;
bool jobDone = reboot();
if ( jobDone )
LOG_STATUS( "ProcessServer", CharString().format("Server Rebooting, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_EXIT:
if ( validateClient( client ) )
{
dword job;
input >> job;
// signal all running processes to stop
bool jobDone = shutdown();
if ( jobDone )
LOG_STATUS( "ProcessServer", CharString().format("Server Exiting, client = %u (%s)", client, clientAddress(client)) );
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_TERMINATE_PROCESS:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
bool jobDone = false;
AutoLock lock( &m_Lock );
Process proc;
if ( findProcess( processId, proc ) )
{
// just terminate the process
if ( m_ProcessInfo.find( processId ).valid() )
{
::Process::stop( m_ProcessInfo[ processId ].m_pHandle );
jobDone = true;
LOG_STATUS( "ProcessServer", "Terminated Process, name = %s, client = %u (%s), processId = %u,",
proc.name.cstr(), client, clientAddress(client), processId );
}
}
send( client, ProcessClient::CLIENT_JOB_DONE ) << job << jobDone;
}
break;
case ProcessClient::SERVER_OPEN_LOG:
if ( validateClient( client ) )
{
dword job;
input >> job;
dword processId;
input >> processId;
CharString logFile;
if ( processId != 0 )
{
// send log of one of our processes
Process proc;
if ( findProcess( processId, proc ) )
logFile = proc.log;
}
else
logFile = m_Context.logFile;
dword logId = m_NextLogId++;
AutoLock lock( &m_Lock );
FileDisk & file = m_LogFile[ logId ];
if ( file.open( logFile ) )
{
LOG_STATUS( "ProcessServer", "Open Log, logFile = %s, logId = %u, clientId = %u", logFile.cstr(), logId, client );
m_ActiveLog.push( logId );
m_LogClient[ logId ] = client;
m_ClientLog[ client ].push( logId );
}
else
{
LOG_STATUS( "ProcessServer", "Open Log Failed, logFile = %s, clientId = %u", logFile.cstr(), client );
// failed to open file
m_LogFile.remove( logId );
// set id to 0 for error
logId = 0;
}
send( client, ProcessClient::CLIENT_RECV_LOG_ID ) << job << logId;
}
break;
case ProcessClient::SERVER_CLOSE_LOG:
if ( validateClient( client ) )
{
dword logId;
input >> logId;
AutoLock lock( &m_Lock );
LOG_STATUS( "ProcessServer", CharString().format("Close Log, logId = %u, client = %u", logId, client) );
m_ActiveLog.removeSearch( logId );
m_LogFile.remove( logId );
m_LogClient.remove( logId );
m_ClientLog[ client ].removeSearch( logId );
}
break;
case ProcessClient::SERVER_SEARCH_LOGS:
if ( validateClient( client ) )
{
dword job;
input >> job;
ProcessClient::SearchLogRequest req;
input >> req;
LOG_STATUS( "ProcessServer", CharString().format("Search Log, clientId = %u", client) );
CharString result;
if( req.filemask.find('/') >= 0 || req.filemask.find('\\') >= 0 )
{ // this should never happen, unless the user has a hacked client
LOG_STATUS( "ProcessServer", CharString().format("Search Log, invalid filemask received from clientId = %u", client) );
result = "Failed";
}
else
{
result = searchLogFiles( req.filemask, req.searchString, req.isRegExp, req.searchLevel, req.resolveClientId );
}
send( client, ProcessClient::CLIENT_RECV_SEARCHRESULT ) << job << result;
}
break;
case ProcessClient::PING:
send( client, ProcessClient::PONG );
break;
case ProcessClient::PONG:
break;
default:
{
LOG_ERROR( "ProcessServer", CharString().format("Bad Message, client = %u (%s), message = %d", client, clientAddress(client), message) );
removeClient( client );
}
break;
}
}
/**
* Writes a packet into the pipe
*/
void PCAPExporterPipe::receive(Packet* packet)
{
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() called");
if (onRestart){
DPRINTF("Dropping incoming packet, as attached process is not ready");
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
packet->removeReference();
return;
}
if (fifoReaderPid == 0){
msg(MSG_VDEBUG, "fifoReaderPid = 0...this might happen during reconfiguration");
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
packet->removeReference();
return;
}
if (restartInterval) {
if (nextRestart.tv_sec==0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): updating nextRestart");
nextRestart = packet->timestamp;
struct timeval tv = { restartInterval/1000, (restartInterval % 1000)*1000 };
timeval_add(&nextRestart, &tv);
} else if (compareTime(nextRestart, packet->timestamp)<0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): restarting process");
// we need to unregister our signal handlers, as we get race conditions with the signal handler for restarting the process
unregisterSignalHandlers();
stopProcess();
startProcess();
registerSignalHandlers();
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): updating nextRestart");
timeval tvdiff;
timeval_subtract(&tvdiff, &packet->timestamp, &nextRestart);
uint32_t msdiff = tvdiff.tv_sec*1000+tvdiff.tv_usec/1000;
uint32_t mswait = (msdiff/restartInterval+1)*restartInterval;
tvdiff.tv_sec = mswait/1000;
tvdiff.tv_usec = (mswait%1000)*1000;
timeval_add(&nextRestart, &tvdiff);
}
}
// write packet
static struct pcap_pkthdr packetHeader;
packetHeader.ts = packet->timestamp;
packetHeader.caplen = packet->data_length;
packetHeader.len = packet->pcapPacketLength;
struct iovec wvec[2];
wvec[0].iov_base = &packetHeader;
wvec[0].iov_len = sizeof(packetHeader);
wvec[1].iov_base = packet->data;
wvec[1].iov_len = packetHeader.caplen;
if (writev(pcapFile, wvec, 2)!=(ssize_t)(sizeof(packetHeader)+packetHeader.caplen)) {
if (errno==EAGAIN) {
// pipe is full, drop packet
statBytesDropped += packet->data_length;
statPktsDropped++;
} else
THROWEXCEPTION("PCAPExporterPipe: failed to write, error %u (%s)", errno, strerror(errno));
} else {
statBytesForwarded += packet->data_length;
statPktsForwarded++;
}
packet->removeReference();
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
}
/**
* @brief VLC filter callback
* @return picture(s) containing the filtered frames
*/
static picture_t* y4m_filter(filter_t* intf, picture_t* srcPic)
{
filter_sys_t* sys = intf->p_sys;
//msg_Info(intf, ">>>> filter");
if (!srcPic)
{
//msg_Info(intf, ">>> filter: NULL INPUT");
return NULL;
}
// will be stored to sys->lastDate on return
mtime_t currDate = srcPic->date;
// if there was a problem with the subprocess then send back
// the picture unmodified, at least we won't freeze up vlc
if (sys->startFailed || sys->threadExit)
goto ECHO_RETURN;
// start subprocess and write the y4m header
// fixme: this can go in open() if fmt_in matches the srcPic
if (!sys->startFailed && !sys->childPid)
{
sys->startFailed = !startProcess(intf);
if (sys->startFailed)
goto ECHO_RETURN;
if (0 >= writeY4mHeader(intf, srcPic, sys->stdin))
{
msg_Err(intf, "writeY4mHeader failed: errno=%d %s",
errno, strerror(errno));
stopProcess(intf);
sys->startFailed = true;
goto ECHO_RETURN;
}
}
//
// control the buffering level by monitoring the input/output fifos
//
// the input/output fifos are emptied/filled by input/output threads
// in response to the subprocess reading/writing frames
//
// if the input fifo is empty, then probably the subprocess wants
// more input, so we should buffer more input
//
// if the output fifo is empty, and the input fifo is not empty, then
// probably the subprocess is about to write out a frame and we
// can wait for it to arrive. in practice, most of the time there
// is no waiting needed, unless the filter is too slow to keep up.
//
bool inputEmpty = true;
bool outputEmpty = true;
picture_t* tmp = picture_fifo_Peek(sys->inputFifo);
if (tmp)
{
picture_Release(tmp);
inputEmpty = false;
}
tmp = picture_fifo_Peek(sys->outputFifo);
if (tmp)
{
picture_Release(tmp);
outputEmpty = false;
}
// copy picture to input fifo, we can't use picture_Hold or else
// the decoder or vout would run out of pictures in its pool
picture_t* inPic = picture_NewFromFormat(&srcPic->format);
picture_Copy(inPic, srcPic);
picture_fifo_Push(sys->inputFifo, inPic);
// signal input thread to wake up and write some more data out
vlc_mutex_lock(&sys->inputMutex);
sys->bufferedIn++;
vlc_cond_signal(&sys->inputCond);
vlc_mutex_unlock(&sys->inputMutex);
// if echo is enabled, we're done
// todo: there should be a limiter on the input buffering in case
// the subprocess can't keep up
if (sys->echo)
goto ECHO_RETURN;
// keeps track of the number of buffered output pictures, assumes
// an integer ratio
// fixme: needs modification to support non-integer ratios
// and ratios < 1
sys->bufferedOut += sys->bufferRatio;
// handle buffering
if (outputEmpty && inputEmpty)
{
// we haven't supplied enough input, raise the minimum
// level of buffer to keep and return
sys->minBuffered += sys->bufferRatio;
msg_Info(intf, "buffer more input: buffers:%d:%d:%d",
sys->bufferedIn, sys->bufferedOut, sys->minBuffered);
goto NULL_RETURN;
}
if (outputEmpty)
waitForOutput(intf);
// if we don't know what the frame interval is, make it 0 which
// probably causes the next frames out to drop
// note: this happens at least every time y4m_flush() is called
// for example when seeking
if (currDate <= sys->lastDate || sys->lastDate == 0)
{
//msg_Err(intf, "currDate <= lastDate");
//goto ECHO_RETURN;
sys->lastDate = currDate;
}
// reference to first and last picture we are returning
picture_t* first = NULL;
picture_t* last = NULL;
picture_t* pic;
while( (pic = picture_fifo_Pop(sys->outputFifo)) )
{
// do output setup when we see the first frame out from the filter,
// it could have a different frame rate, chroma, size, etc than
// the frame going in
if (!sys->gotFirstOutput)
{
sys->gotFirstOutput = true;
// get the in/out frame ratio by comparing frame rates
float speed =
((float)srcPic->format.i_frame_rate_base * (float)pic->format.i_frame_rate) /
((float)srcPic->format.i_frame_rate * (float)pic->format.i_frame_rate_base);
if (speed < 1.0)
{
msg_Err(intf, "frame rate reduction isn't supported yet");
}
else
if (speed > 1.0)
{
if (ceil(speed) != speed)
msg_Err(intf, "frame rate change must be integer ratio");
sys->bufferRatio = speed;
// initial ratio was 1.0, need to correct the number of buffered frames
// now that we know what it is
sys->bufferedOut *= sys->bufferRatio;
sys->minBuffered *= sys->bufferRatio;
}
intf->fmt_out.video.i_frame_rate = pic->format.i_frame_rate;
intf->fmt_out.video.i_frame_rate_base = pic->format.i_frame_rate_base;
if (intf->fmt_out.video.i_chroma != pic->format.i_chroma)
msg_Err(intf, "filter changed the chroma, expect corruption");
// this can't be changed after open, crashes the GLX vout
//intf->fmt_out.i_codec = pic->format.i_chroma;
//intf->fmt_out.video.i_chroma = pic->format.i_chroma;
msg_Info(intf, "first output: buffers=%d:%d", sys->bufferedOut, sys->minBuffered);
}
sys->numFrames++;
sys->bufferedOut--;
// it seems filter_NewPicture is required now. however,
// sometimes it returns null in which case it seems like
// the best thing to do is dump frames
picture_t* copy = first == NULL ? srcPic : filter_NewPicture(intf);
if (!copy)
{
picture_Release(pic);
// throw away frames
// vlc already prints warning for this
//msg_Err(intf, "filter_NewPicture returns null");
if (sys->bufferedOut < sys->minBuffered)
break;
else
continue;
}
else
{
picture_CopyPixels(copy, pic);
picture_Release(pic);
pic = copy;
}
// the time per output frame interval is a fraction of the input frame time
int frameTime = (currDate - sys->lastDate) / sys->bufferRatio;
// the pts is whatever the current pts is minus any buffering
// introduced by the filter
pic->date = currDate - sys->bufferedOut*frameTime;
// msg_Info(intf, "frame=%d buffered=%d:%d frameTime=%d ratio:%d:1 fin=%d:%d fout=%d:%d pts=%u",
// sys->numFrames, sys->bufferedOut, sys->minBuffered,
// frameTime, sys->bufferRatio,
// srcPic->format.i_frame_rate, srcPic->format.i_frame_rate_base,
// pic->format.i_frame_rate, pic->format.i_frame_rate_base,
// (unsigned int)pic->date);
if (last)
last->p_next = pic;
else
first = pic;
last = pic;
// if we read too many frames on this iteration, on the next
// one we might not have any frames available which would be
// bad as vlc would think our intent was to drop frames
//
// if we stop reading before the output is completely empty,
// there will always be some frames for the next iteration,
// assuming the filter is fast enough to keep up
if (sys->bufferedOut < sys->minBuffered)
break;
// if there is still some input buffer left, but the fifo is
// empty, wait for next frame to arrive. otherwise we can
// build too much input buffering
if (sys->bufferedIn > 1)
waitForOutput(intf);
}
if (!first)
{
// the buffer checks should prevent from getting here, but
// just in case prevent leaking the input picture
picture_Release(srcPic);
sys->minBuffered++;
}
sys->lastDate = currDate;
return first;
ECHO_RETURN:
sys->lastDate = currDate;
//msg_Info(intf, "<<<< filter: ECHO");
return srcPic;
NULL_RETURN:
sys->lastDate = currDate;
picture_Release(srcPic);
//msg_Info(intf, "<<<< filter: NULL");
return NULL;
}
TouchEventRegister<T>::~TouchEventRegister()
{
stopProcess();
}
deBool deProcess_kill (deProcess* process)
{
return stopProcess(process, DE_TRUE);
}
deBool deProcess_terminate (deProcess* process)
{
return stopProcess(process, DE_FALSE);
}
/**
* @brief Start subprocess that will do the actual filtering
* @bool true if the start was successful
*/
static bool startProcess(filter_t* intf)
{
filter_sys_t* sys = intf->p_sys;
bool ok = false;
sys->childPid = 0;
sys->stdin = -1;
sys->stdout = -1;
gchar** argv;
GError* error = NULL;
if (!g_shell_parse_argv(sys->cmd, NULL, &argv, &error))
{
msg_Err(intf, "startProcess: failed to parse command line");
return false;
}
const gchar* workingDir = NULL;
gchar** envp = NULL;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH;
GSpawnChildSetupFunc childSetup = NULL;
gpointer userData = NULL;
if (!g_spawn_async_with_pipes(workingDir,
argv,
envp,
flags,
childSetup,
userData,
&sys->childPid,
&sys->stdin,
&sys->stdout,
NULL,
&error))
{
// todo: check gerror, print more specific error message if possible
msg_Err(intf, "startProcess: failed to start");
}
else
{
ok = true;
msg_Info(intf, "startProcess: started pid=%d stdin=%d stdout=%d",
sys->childPid, sys->stdin, sys->stdout);
// start input/writer and output/reader threads
// we want them to respond as soon as possible so use a high priority
int err = vlc_clone(&sys->inputThread, inputThread, intf, VLC_THREAD_PRIORITY_OUTPUT);
if (err == VLC_SUCCESS && !sys->echo)
err = vlc_clone(&sys->outputThread, outputThread, intf, VLC_THREAD_PRIORITY_OUTPUT);
if (err != VLC_SUCCESS)
{
msg_Err(intf, "vlc_clone failed");
stopProcess(intf);
ok = false;
}
}
g_strfreev(argv);
return ok;
}
void PCAPExporterMem::performShutdown()
{
unregisterSignalHandlers();
stopProcess();
msg(MSG_INFO, "PCAPExporterMem: sent %llu packets, dropped %llu packets", statPktsForwarded, statPktsDropped);
}
PeopleEventRegister<T>::~PeopleEventRegister()
{
stopProcess();
}
Process::~Process()
{
stopProcess();
}
void PCAPExporterPipe::performShutdown()
{
unregisterSignalHandlers();
stopProcess();
}
void Process::stop()
{
stopProcess();
}
//-------------------------------------------------------------------------------------------------------
long AudioEffectX::dispatcher (long opCode, long index, long value, void *ptr, float opt)
{
long v = 0;
switch(opCode)
{
// VstEvents
case effProcessEvents:
v = processEvents ((VstEvents*)ptr);
break;
// parameters and programs
case effCanBeAutomated:
v = canParameterBeAutomated (index) ? 1 : 0;
break;
case effString2Parameter:
v = string2parameter (index, (char*)ptr) ? 1 : 0;
break;
case effGetNumProgramCategories:
v = getNumCategories ();
break;
case effGetProgramNameIndexed:
v = getProgramNameIndexed (value, index, (char*)ptr) ? 1 : 0;
break;
case effCopyProgram:
v = copyProgram (index) ? 1 : 0;
break;
// connections, configuration
case effConnectInput:
inputConnected (index, value ? true : false);
v = 1;
break;
case effConnectOutput:
outputConnected (index, value ? true : false);
v = 1;
break;
case effGetInputProperties:
v = getInputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;
break;
case effGetOutputProperties:
v = getOutputProperties (index, (VstPinProperties*)ptr) ? 1 : 0;
break;
case effGetPlugCategory:
v = (long)getPlugCategory ();
break;
// realtime
case effGetCurrentPosition:
v = reportCurrentPosition ();
break;
case effGetDestinationBuffer:
v = (long)reportDestinationBuffer ();
break;
// offline
case effOfflineNotify:
v = offlineNotify ((VstAudioFile*)ptr, value, index != 0);
break;
case effOfflinePrepare:
v = offlinePrepare ((VstOfflineTask*)ptr, value);
break;
case effOfflineRun:
v = offlineRun ((VstOfflineTask*)ptr, value);
break;
// other
case effSetSpeakerArrangement:
v = setSpeakerArrangement ((VstSpeakerArrangement*)value, (VstSpeakerArrangement*)ptr) ? 1 : 0;
break;
case effProcessVarIo:
v = processVariableIo ((VstVariableIo*)ptr) ? 1 : 0;
break;
case effSetBlockSizeAndSampleRate:
setBlockSizeAndSampleRate (value, opt);
v = 1;
break;
case effSetBypass:
v = setBypass (value ? true : false) ? 1 : 0;
break;
case effGetEffectName:
v = getEffectName ((char *)ptr) ? 1 : 0;
break;
case effGetErrorText:
v = getErrorText ((char *)ptr) ? 1 : 0;
break;
case effGetVendorString:
v = getVendorString ((char *)ptr) ? 1 : 0;
break;
case effGetProductString:
v = getProductString ((char *)ptr) ? 1 : 0;
break;
case effGetVendorVersion:
v = getVendorVersion ();
break;
case effVendorSpecific:
v = vendorSpecific (index, value, ptr, opt);
break;
case effCanDo:
v = canDo ((char*)ptr);
break;
case effGetIcon:
v = (long)getIcon ();
break;
case effSetViewPosition:
v = setViewPosition (index, value) ? 1 : 0;
break;
case effGetTailSize:
v = getGetTailSize ();
break;
case effIdle:
v = fxIdle ();
break;
case effGetParameterProperties:
v = getParameterProperties (index, (VstParameterProperties*)ptr) ? 1 : 0;
break;
case effKeysRequired:
v = (keysRequired () ? 0 : 1); // reversed to keep v1 compatibility
break;
case effGetVstVersion:
v = getVstVersion ();
break;
#if VST_2_1_EXTENSIONS
case effEditKeyDown:
if (editor)
{
VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt};
v = editor->onKeyDown (keyCode);
}
break;
case effEditKeyUp:
if (editor)
{
VstKeyCode keyCode = {index, (unsigned char)value, (unsigned char)opt};
v = editor->onKeyUp (keyCode);
}
break;
case effSetEditKnobMode:
if (editor)
v = editor->setKnobMode (value);
break;
case effGetMidiProgramName:
v = getMidiProgramName (index, (MidiProgramName*)ptr);
break;
case effGetCurrentMidiProgram:
v = getCurrentMidiProgram (index, (MidiProgramName*)ptr);
break;
case effGetMidiProgramCategory:
v = getMidiProgramCategory (index, (MidiProgramCategory*)ptr);
break;
case effHasMidiProgramsChanged:
v = hasMidiProgramsChanged (index) ? 1 : 0;
break;
case effGetMidiKeyName:
v = getMidiKeyName (index, (MidiKeyName*)ptr) ? 1 : 0;
break;
case effBeginSetProgram:
v = beginSetProgram () ? 1 : 0;
break;
case effEndSetProgram:
v = endSetProgram () ? 1 : 0;
break;
#endif // VST_2_1_EXTENSIONS
#if VST_2_3_EXTENSIONS
case effGetSpeakerArrangement:
v = getSpeakerArrangement ((VstSpeakerArrangement**)value, (VstSpeakerArrangement**)ptr) ? 1 : 0;
break;
case effSetTotalSampleToProcess:
v = setTotalSampleToProcess (value);
break;
case effShellGetNextPlugin:
v = getNextShellPlugin ((char*)ptr);
break;
case effStartProcess:
v = startProcess ();
break;
case effStopProcess:
v = stopProcess ();
break;
case effSetPanLaw:
v = setPanLaw (value, opt) ? 1 : 0;
break;
case effBeginLoadBank:
v = beginLoadBank ((VstPatchChunkInfo*)ptr);
break;
case effBeginLoadProgram:
v = beginLoadProgram ((VstPatchChunkInfo*)ptr);
break;
#endif // VST_2_3_EXTENSIONS
// version 1.0 or unknown
default:
v = AudioEffect::dispatcher (opCode, index, value, ptr, opt);
}
return v;
}
void DialogConversionStatus::abort()
{
resetButtons();
emit stopProcess();
}
void ProcessServer::updateDemon()
{
dword lastRegister = 0;
dword lastTimeSync = 0;
dword pingTime = 0;
while ( running() && !m_bShutdownCompleted )
{
Thread::sleep( 1000 );
if (! m_MetaClient.loggedIn() )
{
LOG_STATUS( "ProcessServer", "Establishing connection to the metaserver" );
// attempt to connect
if ( m_MetaClient.open( m_Context.metaAddress, m_Context.metaPort ) > 0 )
{
if ( m_MetaClient.login( m_Context.uid, m_Context.pw ) < 0 )
{
LOG_STATUS( "ProcessServer", "Failed to login to the metaserver" );
m_MetaClient.close(); // failed to login
}
else
{
LOG_STATUS( "ProcessServer", "Connected to the metaserver" );
// select the correct game
m_MetaClient.selectGame( m_Context.gameId );
}
}
}
m_MetaClient.update();
if ( m_MetaClient.loggedIn() )
{
if ( lastRegister < (Time::seconds() - REGISTER_TIME) )
{
AutoLock lock( &m_Lock );
MetaClient::Server server;
server.gameId = m_Context.gameId;
server.type = MetaClient::PROCESS_SERVER;
server.flags = 0;
server.name = m_Context.name;
server.shortDescription.format( "CPU: %d%%, MEM: %d%%", cpuUsage(), memoryUsage() );
server.description = server.shortDescription + "\n\n";
for(int i=0;i<m_ProcessList.size();i++)
{
Process & proc = m_ProcessList[ i ];
if ( (proc.flags & ProcessClient::PF_RUNNING) == 0 )
continue;
server.description += CharString().format( "%s\n", proc.name.cstr() );
}
server.address = m_Context.address;
server.port = m_Context.port;
server.maxClients = m_Context.maxClients;
server.clients = clientCount();
server.data = CharString().format("processGroup=%u;networkGroup=%u;processCount=%u;cpuUsage=%d;memoryUsage=%d",
m_Context.processGroup, m_Context.networkGroup, m_ProcessList.size(), cpuUsage(), memoryUsage() );
lock.release();
if ( m_MetaClient.registerServer( server ) < 0 )
lastRegister = (Time::seconds() - REGISTER_TIME) + 30; // failed, try again in 30 seconds
else
lastRegister = Time::seconds();
}
if ( m_Context.syncClock && lastTimeSync < (Time::seconds() - SYNC_CLOCKS_TIME) )
{
// get the current time from the metaserver
dword currentTime = m_MetaClient.getTime();
if ( currentTime > 0 )
{
LOG_STATUS( "ProcessServer", "Syncronizing system time to %s", Time::format( currentTime, "%c" ).cstr() );
if (! Time::setTime( currentTime ) )
LOG_STATUS( "ProcessServer", "Failed to set the system time!" );
lastTimeSync = Time::seconds();
}
else
{
LOG_STATUS( "ProcessServer", "Failed to syncronize system time from MetaServer!" );
lastTimeSync = (Time::seconds() - SYNC_CLOCKS_TIME) + 300; // try again in another 5 min
}
}
}
AutoLock lock( &m_Lock );
bool shutdownComplete = true; // have all child processes stopped
// check for log updates
for(int i=0;i<m_ActiveLog.size();i++)
{
dword logId = m_ActiveLog[ i ];
FileDisk & file = m_LogFile[ logId ];
try {
if ( file.position() > file.size() )
file.setPosition( 0 ); // file has been rotated... reset read position
dword read = file.size() - file.position();
if ( read > 0 )
{
if ( read > MAX_LOG_SIZE )
{
file.setPosition( file.size() - MAX_LOG_SIZE );
read = MAX_LOG_SIZE;
}
char * pLines = new char[ read + 1 ];
pLines[ read ] = 0;
file.read( pLines, read );
send( m_LogClient[ logId ], ProcessClient::CLIENT_RECV_LOG_UPDATE ) << logId << CharString(pLines);
delete [] pLines;
}
}
catch( FileDisk::FileError )
{
LOG_STATUS( "ProcessServer", CharString().format("Log Read Error, logFile = %s, logId = %u", file.fileName(), logId) );
// close the previously open file
file.close();
// attempt to reopen the file
file.open( file.fileName() );
}
}
// check process list
for(int i=0;i<m_ProcessList.size();i++)
{
Process & proc = m_ProcessList[ i ];
if ( m_ProcessInfo.find( proc.processId ).valid() )
{
ProcessInfo & info = m_ProcessInfo[ proc.processId ];
proc.flags |= ProcessClient::PF_RUNNING;
if ( (proc.flags & ProcessClient::PF_DISABLED) == 0 )
{
// make sure the process is still running
if (! ::Process::active( info.m_pHandle ) )
{
proc.flags &= ~ProcessClient::PF_RUNNING;
if ( ! m_Shutdown )
{
if ( info.m_nRestartTime != 0 && Time::seconds() < info.m_nRestartTime )
continue; // not time to restart yet, continue onto the next process..
// process has exited, increment the number of restarts, then calculate the next restart
// time increasing the wait time each time the process exits
info.m_nRestarts += 1;
info.m_nRestartTime = Time::seconds() + (60 * (info.m_nRestarts * info.m_nRestarts) );
int exitCode = ::Process::exitCode( info.m_pHandle );
::Process::close( info.m_pHandle );
CharString message;
message.format( "Process %u exit, name = %s, exec = %s, arg = %s, exitCode = %d, restarts = %u",
proc.processId, proc.name.cstr(), proc.executable.cstr(), proc.arguments.cstr(), exitCode, info.m_nRestarts );
LOG_STATUS( "ProcessServer", message );
// send report if exit code is negative
if ( exitCode < 0 )
m_MetaClient.sendChat( 0, CharString().format("/report %s", message.cstr()) );
// restart the process..
Path exePath( proc.executable );
void * pStart = ::Process::start( CharString().format("%s %s", exePath.file().cstr(), proc.arguments.cstr()),
exePath.directory() );
if ( pStart == NULL )
{
LOG_STATUS( "ProcessServer", "Process %u failed to restart", proc.processId );
m_ProcessInfo.remove( proc.processId );
proc.flags |= ProcessClient::PF_DISABLED;
}
else
{
LOG_STATUS( "ProcessServer", "Process %u restarted", proc.processId );
info.m_pHandle = pStart;
}
}
else
{
int exitCode = ::Process::exitCode( info.m_pHandle );
LOG_STATUS( "ProcessServer", "Process Stopped, name = %s, exitCode = %d", proc.name.cstr(), exitCode );
::Process::close( info.m_pHandle );
m_ProcessInfo.remove( proc.processId );
}
}
else if ( m_Shutdown )
{
shutdownComplete = false;
stopProcess( proc.processId );
}
else if ( info.m_nRestartTime != 0 && Time::seconds() > info.m_nRestartTime )
{
// process has been running long enough to clear the restart time.
info.m_nRestartTime = 0;
info.m_nRestarts = 0;
}
}
else
{
if (! ::Process::active( info.m_pHandle ) )
{
LOG_STATUS( "ProcessServer", "Process Stopped, name = %s", proc.name.cstr() );
::Process::close( info.m_pHandle );
m_ProcessInfo.remove( proc.processId );
}
else
stopProcess( proc.processId );
}
}
else
{
proc.flags &= ~ProcessClient::PF_RUNNING;
if ( (proc.flags & ProcessClient::PF_DISABLED) == 0 && !m_Shutdown )
{
LOG_STATUS( "ProcessServer", "Starting Process %u, name = %s, exec = %s, arg = %s",
proc.processId, proc.name.cstr(), proc.executable.cstr(), proc.arguments.cstr() );
Path exePath( proc.executable );
void * pStart = ::Process::start( CharString().format("%s %s", exePath.file().cstr(), proc.arguments.cstr()),
exePath.directory() );
if ( pStart == NULL )
{
proc.flags |= ProcessClient::PF_DISABLED;
LOG_STATUS( "ProcessServer", "Process %u Failed to Start, name = %s, exec = %s",
proc.processId, proc.name.cstr(), proc.executable.cstr() );
}
else
m_ProcessInfo[ proc.processId ].m_pHandle = pStart;
}
}
}
pingTime++;
if ( pingTime > 15 )
{
// ping all clients
for(int i=0;i<clientCount();i++)
send( client(i), ProcessClient::PING );
pingTime = 0;
}
// check for shutdown
if ( m_Shutdown && shutdownComplete )
{
m_bShutdownCompleted = true;
if ( m_RebootOnShutdown )
rebootMachine();
}
lock.release();
}
}
AudioEventRegister::~AudioEventRegister()
{
stopProcess();
}
void MgrStereoHand::initUI(){
// rozmiar przetwarzania
processGroup = new QButtonGroup(this);
processGroup->addButton(ui.processButtonRadio0, VIDEO);
//processGroup->addButton(ui.processButtonRadio1, RECORD);
processGroup->addButton(ui.processButtonRadio2, CAMERA);
Settings::instance()->processType = processGroup->checkedId();
connect(processGroup, SIGNAL(buttonClicked (int)),
this, SLOT(processTypeChanged(int)));
// film
connect(ui.buttonLoadFilm0, SIGNAL(clicked()),
this, SLOT(loadFilmClicked0()));
connect(ui.buttonLoadFilm1, SIGNAL(clicked()),
this, SLOT(loadFilmClicked1()));
// kalibracja
connect(ui.buttonLoadCalibration, SIGNAL(clicked()),
this, SLOT(loadCalibrationFile()));
connect(ui.calibrateButton, SIGNAL(clicked()),
this, SLOT(calibrateButtonClicked()));
// start-stop
connect(ui.buttonStart, SIGNAL(clicked()),
this, SLOT(startProcess()));
connect(ui.buttonStop, SIGNAL(clicked()),
this, SLOT(stopProcess()));
// pokazywane elementy przetwarzania
connect(ui.sliderShowImage, SIGNAL(valueChanged(int)),
this, SLOT(changeShowImage(int)));
Settings::instance()->initImageType(ui.sliderShowImage->value());
ui.labelShowImage->setText(Settings::instance()->getImageTypeString());
// wyjscie
connect(ui.buttonExit, SIGNAL(clicked()),
this, SLOT(exit()));
algorithmsDialog = new AlgorithmsDialog(this);
statisticsDialog = new StatisticsDialog(this);
calibDialog = new CalibrationDialog(this);
connect(calibDialog, SIGNAL(calibrationStartFromDialog()),
this, SLOT(startCalibrationClickedFromDialog()));
connect(calibDialog, SIGNAL(calibrationSaved()),
this, SLOT(savedCalibrationFromDialog()));
setGeometry(10, 30, geometry().width(), geometry().height());
algorithmsDialog->setGeometry( 10, geometry().height()+60,
algorithmsDialog->geometry().width(),
algorithmsDialog->geometry().height());
statisticsDialog->setGeometry( geometry().width()+20, 30,
statisticsDialog->geometry().width(),
statisticsDialog->geometry().height());
calibDialog->setGeometry( 50, geometry().height(),
algorithmsDialog->geometry().width(),
algorithmsDialog->geometry().height());
algorithmsDialog->show();
statisticsDialog->show();
}
/*!
* \brief MainWindow::MainWindow
* \param parent
*/
MainWindow::MainWindow(QWidget *parent)
: QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
ui->stopButton->hide();
ui->qwtPlot->setTitle("Error");
ui->qwtPlot->setAxisTitle(ui->qwtPlot->xBottom, "Epoch");
ui->qwtPlot->setAxisTitle(ui->qwtPlot->yLeft,"Error");
ui->qwtPlot->setAxisAutoScale( ui->qwtPlot->xBottom, true );
ui->qwtPlot->setAxisAutoScale( ui->qwtPlot->yLeft, true );
ui->stopButton->setVisible( false );
ui->saveButton->setVisible( false );
zoom = new QwtPlotZoomer(ui->qwtPlot->canvas());
zoom->setRubberBandPen(QPen(Qt::white));
QPen pen = QPen( Qt::red );
curve.setRenderHint( QwtPlotItem::RenderAntialiased );
curve.setPen( pen );
curve.attach( ui->qwtPlot );
sendAlpha();
// INFO connect ui to mainwindow
{
QObject::connect( ui->saveImageButton, SIGNAL( clicked() ),
this, SLOT( saveImage() ) );
QObject::connect( ui->inputOpenButton, SIGNAL( clicked() ),
this, SLOT( openInputFile() ) );
QObject::connect( ui->saveButton, SIGNAL( clicked() ),
this, SLOT( openOutputFile() ) );
QObject::connect( ui->startButton, SIGNAL( clicked() ),
this, SLOT( start() ) );
QObject::connect( ui->startButton, SIGNAL( clicked( bool ) ),
ui->stopButton, SLOT( setVisible(bool) ) );
QObject::connect( ui->alphaMantiss, SIGNAL( valueChanged( double ) ),
this, SLOT( sendAlpha() ) );
QObject::connect( ui->alphaDegree, SIGNAL( valueChanged( int ) ),
this, SLOT( sendAlpha() ) );
}
// INFO connectio ui to ui
{
QObject::connect(ui->startButton,SIGNAL(clicked()),ui->stopButton,SLOT(show()));
}
// /* INFO connection ui to facade
{
QObject::connect( ui->stopButton, SIGNAL( clicked() ),
&Facade::getInstance(), SLOT( stopProcess() ) );
QObject::connect( ui->maxEpoch, SIGNAL( valueChanged(int) ),
&Facade::getInstance(), SLOT( setMaxNumberOfEpoh(int) ) );
QObject::connect( ui->numberOfNeurons, SIGNAL( valueChanged(int) ),
&Facade::getInstance(), SLOT( setNumberOfNeurons(int) ) );
}
// */
// /* INFO connection facade to ui
{
QObject::connect( &Facade::getInstance(), SIGNAL( processEnd() ),
ui->startButton, SLOT( show() ) );
QObject::connect( &Facade::getInstance(), SIGNAL( processEnd() ),
ui->saveButton, SLOT( show() ) );
QObject::connect( &Facade::getInstance(), SIGNAL( processEnd() ),
ui->stopButton, SLOT( hide() ) );
}
// */
// /* INFO connection facade to main window
{
// QObject::connect( &Facade::getInstance(), SIGNAL( sendInitialLayerInfo(LayerDescription)),
// this, SLOT( setInitialLayerInfo( LayerDescription ) ) );
QObject::connect( &Facade::getInstance(), SIGNAL( processEnd() ),
this, SLOT( displayResults() ) );
}
// */
// /* INFO connection main window to facade
{
QObject::connect( this, SIGNAL( setInputFileName(QString) ),
&Facade::getInstance(), SLOT( setInputFileName(QString) ) );
QObject::connect( this, SIGNAL( setOutputFileName(QString) ),
&Facade::getInstance(), SLOT( setOutputFileName(QString) ) );
QObject::connect( this, SIGNAL( setAlpha( double ) ),
&Facade::getInstance(), SLOT( setAlhpa( double ) ) );
}
// */
}
