void QmlProfilerTimelineModel::clear()
{
TimelineModel::clear();
updateProgress(0, 1);
}
/**
* this is the real workhorse.
* maybe we should not call this directly, but instead from doWork ?
*/
void RenderTask_sV::slotContinueRendering()
{
qDebug()<<"Starting rendering process in Thread "<<thread()->currentThreadId();
/* real workhorse, need to account for exporting */
setupProgress(trUtf8("Rendering Slow-Mo …"), 2* int(m_prefs.fps().fps() * (m_timeEnd-m_timeStart)));
//TODO: initialize
m_stopwatch.start();
m_nextFrameTime=m_timeStart;
int framesBefore;
qreal snapped = m_project->snapToOutFrame(m_nextFrameTime, false, m_prefs.fps(), &framesBefore);
qDebug() << "Frame snapping in from " << m_nextFrameTime << " to " << snapped;
m_nextFrameTime = snapped;
Q_ASSERT(int((m_nextFrameTime - m_project->nodes()->startTime()) * m_prefs.fps().fps() + .5) == framesBefore);
try {
m_renderTarget->openRenderTarget();
} catch (Error_sV &err) {
m_stopRendering = true;
emit signalRenderingAborted(tr("Rendering aborted.") + " " + err.message());
return;
}
// render loop
// TODO: add more threading here
while(m_nextFrameTime<m_timeEnd) {
QCoreApplication::processEvents();
// Checks if the process should be aborted
mutex.lock();
bool abort = m_stopRendering;
mutex.unlock();
if (abort) {
// user stop the process
qDebug()<<"Aborting Rendering process in Thread "<<thread()->currentThreadId();
m_renderTimeElapsed = m_stopwatch.elapsed();
emit signalRenderingStopped(QTime().addMSecs(m_renderTimeElapsed).toString("hh:mm:ss"));
qDebug() << "Rendering stopped after " << QTime().addMSecs(m_renderTimeElapsed).toString("hh:mm:ss");
break;
}
// do the work
int outputFrame = (m_nextFrameTime - m_project->nodes()->startTime()) * m_prefs.fps().fps() + .5;
qreal srcTime = m_project->nodes()->sourceTime(m_nextFrameTime);
qDebug() << "Rendering frame number " << outputFrame << " @" << m_nextFrameTime << " from source time " << srcTime;
updateMessage(tr("Rendering frame %1 @ %2 s from input position: %3 s (frame %4)")
.arg( QString::number(outputFrame),QString::number(m_nextFrameTime),
QString::number(srcTime),
QString::number(srcTime*m_project->frameSource()->fps()->fps())
) );
try {
QImage rendered = m_project->render(m_nextFrameTime, m_prefs);
m_renderTarget->slotConsumeFrame(rendered, outputFrame);
m_nextFrameTime = m_nextFrameTime + 1/m_prefs.fps().fps();
updateProgress( (m_nextFrameTime-m_timeStart) * m_prefs.fps().fps() );
} catch (FlowBuildingError &err) {
m_stopRendering = true;
emit signalRenderingAborted(err.message());
} catch (InterpolationError &err) {
updateMessage(err.message());
}
} /* while */
// Checks if the process should be aborted
mutex.lock();
bool abort = m_stopRendering;
mutex.unlock();
if (abort) {
qDebug() << "Rendering : aborting";
updateMessage(tr("Rendering : aborting"));
} else {
//TODO: closing rendering project
qDebug() << "Rendering : exporting";
updateMessage(tr("Rendering : exporting"));
m_renderTarget->closeRenderTarget();
}
m_renderTimeElapsed = m_stopwatch.elapsed();
qDebug() << "time : " << m_renderTimeElapsed;
emit signalRenderingFinished(QTime(0,0).addMSecs(m_renderTimeElapsed).toString("hh:mm:ss"));
qDebug() << "Rendering stopped after " << QTime(0,0).addMSecs(m_renderTimeElapsed).toString("hh:mm:ss");
qDebug()<<"Rendering process finished in Thread "<<thread()->currentThreadId();
// Set _working to false, meaning the process can't be aborted anymore.
mutex.lock();
_working = false;
mutex.unlock();
}
void NGSD::annotate(VariantList& variants, QString filename)
{
initProgress("NGSD annotation", true);
//get sample ids
QString s_id = sampleId(filename, false);
QString ps_id = processedSampleId(filename, false);
QString sys_id = getValue("SELECT processing_system_id FROM processed_sample WHERE id='" + processedSampleId(filename, false) + "'").toString();
//check if we could determine the sample
bool found_in_db = true;
if (s_id=="" || ps_id=="" || sys_id=="")
{
Log::warn("Could not find processed sample in NGSD by name '" + filename + "'. Annotation will be incomplete because processing system could not be determined!");
found_in_db = false;
}
//get sample ids that have processed samples with the same processing system (not same sample, variants imported, same processing system, good quality of sample, not tumor)
QSet<int> sys_sample_ids;
SqlQuery tmp = getQuery();
tmp.exec("SELECT DISTINCT s.id FROM processed_sample as ps, sample s WHERE ps.processing_system_id='" + sys_id + "' AND ps.sample_id=s.id AND s.tumor='0' AND s.quality='good' AND s.id!='" + s_id + "' AND (SELECT count(id) FROM detected_variant as dv WHERE dv.processed_sample_id = ps.id)>0");
while(tmp.next())
{
sys_sample_ids.insert(tmp.value(0).toInt());
}
//remove all NGSD-specific columns
QList<VariantAnnotationHeader> headers = variants.annotations();
foreach(const VariantAnnotationHeader& header, headers)
{
if (header.name().startsWith("ihdb_"))
{
removeColumnIfPresent(variants, header.name(), true);
}
}
removeColumnIfPresent(variants, "classification", true);
removeColumnIfPresent(variants, "classification_comment", true);
removeColumnIfPresent(variants, "validated", true);
removeColumnIfPresent(variants, "comment", true);
//get required column indices
QString num_samples = QString::number(sys_sample_ids.count());
int ihdb_hom_idx = addColumn(variants, "ihdb_hom", "Homozygous variant counts in NGSD for the same processing system (" + num_samples + " samples).");
int ihdb_het_idx = addColumn(variants, "ihdb_het", "Heterozyous variant counts in NGSD for the same processing system (" + num_samples + " samples).");
int ihdb_wt_idx = addColumn(variants, "ihdb_wt", "Wildtype variant counts in NGSD for the same processing system (" + num_samples + " samples).");
int ihdb_all_hom_idx = addColumn(variants, "ihdb_allsys_hom", "Homozygous variant counts in NGSD independent of the processing system.");
int ihdb_all_het_idx = addColumn(variants, "ihdb_allsys_het", "Heterozygous variant counts in NGSD independent of the processing system.");
int class_idx = addColumn(variants, "classification", "Classification from the NGSD.");
int clacom_idx = addColumn(variants, "classification_comment", "Classification comment from the NGSD.");
int valid_idx = addColumn(variants, "validated", "Validation information from the NGSD. Validation results of other samples are listed in brackets!");
if (variants.annotationIndexByName("comment", true, false)==-1) addColumn(variants, "comment", "Comments from the NGSD. Comments of other samples are listed in brackets!");
int comment_idx = variants.annotationIndexByName("comment", true, false);
//(re-)annotate the variants
SqlQuery query = getQuery();
for (int i=0; i<variants.count(); ++i)
{
//QTime timer;
//timer.start();
//variant id
Variant& v = variants[i];
QByteArray v_id = variantId(v, false).toLatin1();
//variant classification
QVariant classification = getValue("SELECT class FROM variant_classification WHERE variant_id='" + v_id + "'", true);
if (!classification.isNull())
{
v.annotations()[class_idx] = classification.toByteArray().replace("n/a", "");
v.annotations()[clacom_idx] = getValue("SELECT comment FROM variant_classification WHERE variant_id='" + v_id + "'", true).toByteArray().replace("\n", " ").replace("\t", " ");
}
//int t_v = timer.elapsed();
//timer.restart();
//detected variant infos
int dv_id = -1;
QByteArray comment = "";
if (found_in_db)
{
query.exec("SELECT id, comment FROM detected_variant WHERE processed_sample_id='" + ps_id + "' AND variant_id='" + v_id + "'");
if (query.size()==1)
{
query.next();
dv_id = query.value(0).toInt();
comment = query.value(1).toByteArray();
}
}
//validation info
int vv_id = -1;
QByteArray val_status = "";
if (found_in_db)
{
query.exec("SELECT id, status FROM variant_validation WHERE sample_id='" + s_id + "' AND variant_id='" + v_id + "'");
if (query.size()==1)
{
query.next();
vv_id = query.value(0).toInt();
val_status = query.value(1).toByteArray().replace("n/a", "");
}
}
//int t_dv = timer.elapsed();
//timer.restart();
//validation info other samples
int tps = 0;
int fps = 0;
query.exec("SELECT id, status FROM variant_validation WHERE variant_id='"+v_id+"' AND status!='n/a'");
while(query.next())
{
if (query.value(0).toInt()==vv_id) continue;
if (query.value(1).toByteArray()=="true positive") ++tps;
else if (query.value(1).toByteArray()=="false positive") ++fps;
}
if (tps>0 || fps>0)
{
if (val_status=="") val_status = "n/a";
val_status += " (" + QByteArray::number(tps) + "xTP, " + QByteArray::number(fps) + "xFP)";
}
//int t_val = timer.elapsed();
//timer.restart();
//comments other samples
QList<QByteArray> comments;
query.exec("SELECT id, comment FROM detected_variant WHERE variant_id='"+v_id+"' AND comment IS NOT NULL");
while(query.next())
{
if (query.value(0).toInt()==dv_id) continue;
QByteArray tmp = query.value(1).toByteArray().trimmed();
if (tmp!="") comments.append(tmp);
}
if (comments.size()>0)
{
if (comment=="") comment = "n/a";
comment += " (";
for (int i=0; i<comments.count(); ++i)
{
if (i>0)
{
comment += ", ";
}
comment += comments[i];
}
comment += ")";
}
//int t_com = timer.elapsed();
//timer.restart();
//genotype counts
int allsys_hom_count = 0;
int allsys_het_count = 0;
int sys_hom_count = 0;
int sys_het_count = 0;
QSet<int> s_ids_done;
int s_id_int = s_id.toInt();
query.exec("SELECT dv.genotype, ps.sample_id FROM detected_variant as dv, processed_sample ps WHERE dv.processed_sample_id=ps.id AND dv.variant_id='" + v_id + "'");
while(query.next())
{
//skip this sample id
int current_sample = query.value(1).toInt();
if (current_sample==s_id_int) continue;
//skip already seen samples (there could be several processings of the same sample because of different processing systems or because of experment repeats due to quality issues)
if (s_ids_done.contains(current_sample)) continue;
s_ids_done.insert(current_sample);
QByteArray current_geno = query.value(0).toByteArray();
if (current_geno=="hom")
{
++allsys_hom_count;
if (sys_sample_ids.contains(current_sample))
{
++sys_hom_count;
}
}
else if (current_geno=="het")
{
++allsys_het_count;
if (sys_sample_ids.contains(current_sample))
{
++sys_het_count;
}
}
}
//qDebug() << (v.isSNV() ? "S" : "I") << query.size() << t_v << t_dv << t_val << t_com << timer.elapsed();
v.annotations()[ihdb_all_hom_idx] = QByteArray::number(allsys_hom_count);
v.annotations()[ihdb_all_het_idx] = QByteArray::number(allsys_het_count);
if (found_in_db)
{
v.annotations()[ihdb_hom_idx] = QByteArray::number((double)sys_hom_count / sys_sample_ids.count(), 'f', 4);
v.annotations()[ihdb_het_idx] = QByteArray::number((double)sys_het_count / sys_sample_ids.count(), 'f', 4);
v.annotations()[ihdb_wt_idx] = QByteArray::number((double)(sys_sample_ids.count() - sys_hom_count - sys_het_count) / sys_sample_ids.count(), 'f', 4);
v.annotations()[valid_idx] = val_status;
v.annotations()[comment_idx] = comment.replace("\n", " ").replace("\t", " ");
}
else
{
v.annotations()[ihdb_hom_idx] = "n/a";
v.annotations()[ihdb_het_idx] = "n/a";
v.annotations()[ihdb_wt_idx] = "n/a";
v.annotations()[valid_idx] = "n/a";
v.annotations()[comment_idx] = "n/a";
}
emit updateProgress(100*i/variants.count());
}
}
QString GraphExport::generateCSV(quint32 limit)
{
const quint32 start = ui->sampleStartBox->value();
quint32 end = ui->sampleEndBox->value();
if(end - start > limit)
end = start + limit;
std::vector<GraphCurve*> order;
for(int i = 0; i < ui->colList->count(); ++i)
{
QListWidgetItem *item = ui->colList->item(i);
if(item->checkState() != Qt::Checked)
continue;
int idx = item->data(Qt::UserRole).toInt();
if(idx == -1)
order.push_back(NULL);
else
order.push_back(m_curves->at(idx)->curve);
}
QString csv;
QString lineEnd;
switch(ui->endBox->currentIndex())
{
case 0: lineEnd = "\r\n"; break;
case 1: lineEnd = "\n"; break;
case 2: lineEnd = "\n\r"; break;
case 3: lineEnd = "\r"; break;
}
if(ui->colNamesBox->isChecked())
{
for(quint32 i = 0; i < order.size(); ++i)
{
if(!order[i])
csv += "\"index\"";
else
csv += "\"" + order[i]->title().text() + "\"";
csv += ui->sepEdit->text();
}
csv += lineEnd;
}
for(quint32 line = start; line < end; ++line)
{
emit updateProgress((line - start)*100/(end - start));
for(quint32 i = 0; i < order.size(); ++i)
{
if(!order[i])
csv += QString::number(line);
else
{
if(line >= order[i]->getSize())
csv += "-1";
else
csv += QString::number(order[i]->sample(line).y());
}
csv += ui->sepEdit->text();
}
csv += lineEnd;
}
return csv;
}
bool KviPackageWriter::packFile(KviFile * pFile, KviPackageWriterDataField * pDataField)
{
QString szProgressText = QString(__tr2qs("Packaging file %1")).arg(pDataField->m_szFileLocalName);
if(!updateProgress(m_p->iCurrentProgress, szProgressText))
return false; // aborted
KviFile source(pDataField->m_szFileLocalName);
if(!source.open(QFile::ReadOnly))
{
setLastError(__tr2qs("Failed to open a source file for reading"));
return false;
}
kvi_u32_t uSize = source.size();
// Flags
#ifdef COMPILE_ZLIB_SUPPORT
kvi_u32_t uFlags = pDataField->m_bFileAllowCompression ? (uSize > 64 ? KVI_PACKAGE_DATAFIELD_FLAG_FILE_DEFLATE : 0)
: 0;
#else
kvi_u32_t uFlags = 0;
#endif
if(!pFile->save(uFlags))
return writeError();
QByteArray szTargetFileName = pDataField->m_szFileTargetName.toUtf8();
// Path
if(!pFile->save(szTargetFileName))
return writeError();
kvi_file_offset_t savedSizeOffset = pFile->pos();
// Size : will update it if compression is requested
if(!pFile->save(uSize))
return writeError();
pDataField->m_uWrittenFieldLength = 4 + 4 + 4 + szTargetFileName.length(); // sizeof(flags + uncompressed size + path len + path)
// FilePayload
#ifdef COMPILE_ZLIB_SUPPORT
if(uFlags & KVI_PACKAGE_DATAFIELD_FLAG_FILE_DEFLATE)
{
unsigned char ibuffer[BUFFER_SIZE];
unsigned char obuffer[BUFFER_SIZE];
kvi_i32_t iReaded = source.read((char *)ibuffer, BUFFER_SIZE);
if(iReaded < 0)
return readError();
z_stream zstr;
zstr.zalloc = Z_NULL;
zstr.zfree = Z_NULL;
zstr.opaque = Z_NULL;
zstr.next_in = ibuffer;
zstr.avail_in = iReaded;
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
if(deflateInit(&zstr, 9) != Z_OK)
{
setLastError(__tr2qs("Compression library initialization error"));
return false;
}
while(iReaded > 0)
{
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
if(deflate(&zstr, Z_NO_FLUSH) != Z_OK)
{
setLastError(__tr2qs("Compression library error"));
return false;
}
if(zstr.avail_out < BUFFER_SIZE)
{
int iCompressed = zstr.next_out - obuffer;
pDataField->m_uWrittenFieldLength += iCompressed;
if(pFile->write((char *)obuffer, iCompressed) != iCompressed)
{
deflateEnd(&zstr);
return writeError();
}
}
if(zstr.avail_in < BUFFER_SIZE)
{
int iDataToRead = BUFFER_SIZE - zstr.avail_in;
if(iDataToRead < BUFFER_SIZE)
{
if(ibuffer != zstr.next_in)
{
// hum, there is still some data in the buffer to be readed
// and it is not at the beginning...move it to the beginning of ibuffer
memmove(ibuffer, zstr.next_in, zstr.avail_in);
}
}
iReaded = source.read((char *)(ibuffer + zstr.avail_in), iDataToRead);
if(iReaded < 0)
{
deflateEnd(&zstr);
return readError();
}
zstr.avail_in += iReaded;
zstr.next_in = ibuffer;
if((zstr.total_in % 2000000) == 0)
{
QString szTmp = QString(" (%1 of %2 bytes)").arg(zstr.total_in, uSize);
QString szPrg = szProgressText + szTmp;
if(!updateProgress(m_p->iCurrentProgress, szPrg))
return false; // aborted
}
}
}
// flush pending output
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
int ret;
do
{
ret = deflate(&zstr, Z_FINISH);
if((ret == Z_OK) || (ret == Z_STREAM_END))
{
if(zstr.avail_out < BUFFER_SIZE)
{
int iCompressed = zstr.next_out - obuffer;
pDataField->m_uWrittenFieldLength += iCompressed;
if(pFile->write((char *)obuffer, iCompressed) != iCompressed)
{
deflateEnd(&zstr);
return writeError();
}
}
else
{
deflateEnd(&zstr);
setLastError(__tr2qs("Compression library internal error"));
return false;
}
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
}
} while(ret == Z_OK);
// store the compressed data size
kvi_file_offset_t here = pFile->pos();
pFile->seek(savedSizeOffset);
uSize = zstr.total_out;
deflateEnd(&zstr);
if(!pFile->save(uSize))
return writeError();
if(ret != Z_STREAM_END)
{
setLastError(__tr2qs("Error while compressing a file stream"));
return false;
}
pFile->seek(here);
}
else
{
#endif
unsigned char buffer[BUFFER_SIZE];
int iTotalFileSize = 0;
kvi_i32_t iReaded = source.read((char *)buffer, BUFFER_SIZE);
if(iReaded < 0)
return readError();
while(iReaded > 0)
{
iTotalFileSize += iReaded;
if((iTotalFileSize % 1000000) == 0)
{
QString szTmp = QString(" (%1 of %2 bytes)").arg(iTotalFileSize, uSize);
QString szPrg = szProgressText + szTmp;
if(!updateProgress(m_p->iCurrentProgress, szPrg))
return false; // aborted
}
pDataField->m_uWrittenFieldLength += iReaded;
if(pFile->write((char *)buffer, iReaded) != iReaded)
return writeError();
iReaded = source.read((char *)buffer, BUFFER_SIZE);
}
#ifdef COMPILE_ZLIB_SUPPORT
}
#endif
source.close();
return true;
}
void ArtworkUploader::onUploadStarted() {
LOG_DEBUG << "#";
beginProcessing();
m_Percent = 0;
updateProgress();
}
void TDownlad::downloadProgress(int un,int deux)
{
emit updateProgress(un, deux);
}
void Master::receiveReport() {
int thread_no = s.MPI_SOURCE-1;
MPI_Get_count(&s, MPI_INT, &message_length);
message = (int*) malloc(message_length*sizeof(int));
MPI_Recv(message, message_length, MPI_INT, s.MPI_SOURCE, REPORT_TAG, MPI_COMM_WORLD, &s);
Report& r = *((Report*) message);
//for (int i = 0; i < message_length; i++) fprintf(stderr, "%d ", message[i]); fprintf(stderr, "\n");
if (PAR_DEBUG) fprintf(stderr, "Received report %d from %d\n", r.status, thread_no);
if (r.status == RES_SEA) {
if (wallClockTime() - last_send_learnts[thread_no] > min_share_time) sendLearnts(thread_no);
}
if (r.status != RES_SEA) {
assert(job_start_time[thread_no] != NOT_WORKING);
num_free_slaves++;
job_start_time[thread_no] = NOT_WORKING;
if (PAR_DEBUG) fprintf(stderr, "%d is free, %f\n", thread_no, wallClockTime());
}
if(slaveStates[thread_no] == NORMAL_SEARCH && r.status == RES_LUN){
if(PAR_DEBUG) fprintf(stderr, "LUN: Slave %d solved cube of size %d\n", thread_no, cur_job[thread_no] ? cur_job[thread_no]->size : -1);
}
if (r.status == RES_GUN) {
if(PAR_DEBUG) fprintf(stderr, "Master: Received RES_GUN from %d\n", thread_no);
status = RES_GUN;
}
if (r.status == RES_SAT){
if(PAR_DEBUG) fprintf(stderr, "Master: Received RES_SAT from %d\n", thread_no);
status = RES_SAT;
}
if (r.status == RES_LUN && slaveStates[thread_no]==NORMAL_SEARCH && updateProgress(cur_job[thread_no]->size)) {
if(so.greedyInit){
assert(job_queue.size() == 0 && "size of job queue is strange? ");
status = RES_GUN;
}
else{
for (int i = 0; i < num_threads; i++)
assert(job_start_time[i] == NOT_WORKING);
assert(job_queue.size() == 0 && "Finished, but there are still jobs left?");
status = RES_GUN;
}
}
if(r.status == RES_GREEDY_DONE ){
if(thread_no % 3 == 0){
}
else if(thread_no % 3 == 1){
// Slave is waiting right now. So, set state here immediately!
if(so.mixWS_Portfolio){
slaveStates[thread_no] = PORTFOLIO_SEARCH;
setState(thread_no, PORTFOLIO_SEARCH);
}
else{
slaveStates[thread_no] = NORMAL_SEARCH;
setState(thread_no, NORMAL_SEARCH);
}
slavesRunningGreedy--;
}
assert(so.greedyInit && "Slave returns GREEDY_DONE, but not in greedy-mode?");
}
if(r.status == RES_LUN && slaveStates[thread_no] == RUNNING_GREEDY){
if(thread_no % 3 == 0){
}
else if(thread_no % 3 == 1){
setState(thread_no, NORMAL_SEARCH);
slaveStates[thread_no] = NORMAL_SEARCH;
}
else{
setState(thread_no, NORMAL_SEARCH);
}
}
if (num_free_slaves == num_threads && job_queue.size() == 0 && status != RES_GUN && !so.purePortfolio) {
for (int i = 0; i < search_progress.size(); i++) printf("%d ", search_progress[i]);
assert(false && "No free slave, and no RES_GUN! ");
}
if (status != RES_GUN || true) receiveLearnts(r, thread_no, message_length);
free(message);
}
RoutingWidget::RoutingWidget( MarbleWidget *marbleWidget, QWidget *parent ) :
QWidget( parent ), d( new RoutingWidgetPrivate( marbleWidget ) )
{
d->m_ui.setupUi( this );
d->m_ui.routeComboBox->setVisible( false );
d->m_ui.routeComboBox->setModel( d->m_routingManager->alternativeRoutesModel() );
d->m_routingLayer->synchronizeAlternativeRoutesWith( d->m_ui.routeComboBox );
d->m_ui.routingProfileComboBox->setModel( d->m_routingManager->profilesModel() );
connect( d->m_routingManager->profilesModel(), SIGNAL( rowsInserted( QModelIndex, int, int ) ),
this, SLOT( selectFirstProfile() ) );
connect( d->m_routingManager->profilesModel(), SIGNAL( modelReset() ),
this, SLOT( selectFirstProfile() ) );
connect( d->m_routingLayer, SIGNAL( placemarkSelected( QModelIndex ) ),
this, SLOT( activatePlacemark( QModelIndex ) ) );
connect( d->m_routingLayer, SIGNAL( pointSelected( GeoDataCoordinates ) ),
this, SLOT( retrieveSelectedPoint( GeoDataCoordinates ) ) );
connect( d->m_routingLayer, SIGNAL( pointSelectionAborted() ),
this, SLOT( pointSelectionCanceled() ) );
connect( d->m_routingManager, SIGNAL( stateChanged( RoutingManager::State, RouteRequest* ) ),
this, SLOT( updateRouteState( RoutingManager::State, RouteRequest* ) ) );
connect( d->m_routingManager, SIGNAL( routeRetrieved( GeoDataDocument* ) ),
this, SLOT( indicateRoutingFailure( GeoDataDocument* ) ) );
connect( d->m_routeRequest, SIGNAL( positionAdded( int ) ),
this, SLOT( insertInputWidget( int ) ) );
connect( d->m_routeRequest, SIGNAL( positionRemoved( int ) ),
this, SLOT( removeInputWidget( int ) ) );
connect( d->m_routeRequest, SIGNAL( routingProfileChanged() ),
this, SLOT( updateActiveRoutingProfile() ) );
connect( &d->m_progressTimer, SIGNAL( timeout() ),
this, SLOT( updateProgress() ) );
connect( d->m_ui.routeComboBox, SIGNAL( currentIndexChanged( int ) ),
this, SLOT( switchRoute( int ) ) );
connect( d->m_ui.routingProfileComboBox, SIGNAL( currentIndexChanged( int ) ),
this, SLOT( setRoutingProfile( int ) ) );
connect( d->m_routingManager->alternativeRoutesModel(), SIGNAL( rowsInserted( QModelIndex, int, int ) ),
this, SLOT( updateAlternativeRoutes() ) );
d->m_ui.directionsListView->setModel( d->m_routingModel );
QItemSelectionModel *selectionModel = d->m_ui.directionsListView->selectionModel();
d->m_routingLayer->synchronizeWith( selectionModel );
connect( d->m_ui.directionsListView, SIGNAL( activated ( QModelIndex ) ),
this, SLOT( activateItem ( QModelIndex ) ) );
connect( d->m_ui.searchButton, SIGNAL( clicked( ) ),
this, SLOT( retrieveRoute () ) );
connect( d->m_ui.showInstructionsButton, SIGNAL( clicked( bool ) ),
this, SLOT( showDirections() ) );
connect( d->m_ui.configureButton, SIGNAL( clicked() ),
this, SLOT( configureProfile() ) );
for( int i=0; i<d->m_routeRequest->size(); ++i ) {
insertInputWidget( i );
}
for ( int i=0; i<2 && d->m_inputWidgets.size()<2; ++i ) {
// Start with source and destination if the route is empty yet
addInputWidget();
}
//d->m_ui.descriptionLabel->setVisible( false );
d->m_ui.resultLabel->setVisible( false );
setShowDirectionsButtonVisible( false );
updateActiveRoutingProfile();
if ( MarbleGlobal::getInstance()->profiles() & MarbleGlobal::SmallScreen ) {
d->m_ui.directionsListView->setVisible( false );
#ifdef Q_WS_MAEMO_5
d->m_ui.directionsListView->setAttribute( Qt::WA_Maemo5StackedWindow );
d->m_ui.directionsListView->setWindowFlags( Qt::Window );
d->m_ui.directionsListView->setWindowTitle( tr( "Directions - Marble" ) );
#endif // Q_WS_MAEMO_5
}
}
bool
MacroDevice::download( const QDir &tmpdir,
QList<DeviceDownloadFile> &files,
QString &err)
{
if (MACRO_DEBUG) printf("download O-Synce Macro");
if (!dev->open(err)) {
err = tr("ERROR: open failed: ") + err;
return false;
}
emit updateStatus(tr("Request number of training..."));
if (MACRO_DEBUG) printf("Request number of training\n");
MacroPacket cmd(NUMBER_OF_TRAINING_REQUESTS);
cmd.addToPayload(UNKNOWN);
if (!cmd.write(dev, err)) return false;
if(m_Cancelled)
{
err = tr("download cancelled");
return false;
}
MacroPacket response = MacroPacket();
response.read(dev, 2, err);
if (response.payload.size() == 0)
{
err = tr("no data");
return false;
}
char count = response.payload.at(0);
if (count == 0)
{
err = tr("no data");
return false;
}
response.read(dev, 7*count, err);
if (!response.verifyCheckSum(dev, err))
{
err = tr("data error");
return false;
}
if(m_Cancelled)
{
err = tr("download cancelled");
return false;
}
// create temporary file
QString tmpl = tmpdir.absoluteFilePath(".macrodl.XXXXXX");
QTemporaryFile tmp(tmpl);
tmp.setAutoRemove(false);
if (!tmp.open()) {
err = tr("Failed to create temporary file ")
+ tmpl + ": " + tmp.error();
return false;
}
if (MACRO_DEBUG) printf("Acknowledge");
cmd= MacroPacket(ACKNOWLEDGE);
cmd.addToPayload(response.command);
if (!cmd.write(dev, err)) return false;
// timestamp from the first training
struct tm start;
start.tm_sec = bcd2Int(response.payload.at(2));
start.tm_min = bcd2Int(response.payload.at(3));
start.tm_hour = bcd2Int(response.payload.at(4));
start.tm_mday = bcd2Int(response.payload.at(5));
start.tm_mon = hex2Int(response.payload.at(6)) -1;
start.tm_year = bcd2Int(response.payload.at(7)) -100;
start.tm_isdst = -1;
DeviceDownloadFile file;
file.extension = "osyn";
file.name = tmp.fileName();
file.startTime.setTime_t( mktime( &start ));
files.append(file);
QTextStream os(&tmp);
os << hex;
for (int i = 0; i < count; i++)
{
if (MACRO_DEBUG) printf("Request training %d\n",i);
emit updateStatus( QString(tr("Request datas of training %1 / %2..."))
.arg(i+1).arg((int)count) );
if(m_Cancelled)
{
err = tr("download cancelled");
return false;
}
cmd = MacroPacket(TRAINING_DETAIL_REQUEST);
cmd.addToPayload(i);
if (!cmd.write(dev, err)) return false;
if(m_Cancelled)
{
err = tr("download cancelled");
return false;
}
bool lastpage = false;
while (!lastpage)
{
MacroPacket response2 = MacroPacket();
response2.read(dev, 259, err);
if (!response2.verifyCheckSum(dev, err))
{
err = tr("data error");
return false;
}
if (hexHex2Int(response2.payload.at(0), response2.payload.at(1)) == LAST_PAGE)
lastpage = true;
//int training_flag = hex2Int(response2.payload.at(43));
tmp.write(response2.dataArray());
emit updateProgress( QString(tr("training %1/%2... (%3 Bytes)"))
.arg(i+1)
.arg((int)count)
.arg(tmp.size()) );
if(m_Cancelled)
{
err = tr("download cancelled");
return false;
}
if (MACRO_DEBUG) printf("Acknowledge\n");
cmd= MacroPacket(ACKNOWLEDGE);
cmd.addToPayload(response2.command);
if (!cmd.write(dev, err)) return false;
}
}
tmp.close();
dev->close();
// QTemporaryFile initially has permissions set to 0600.
// Make it readable by everyone.
tmp.setPermissions(tmp.permissions()
| QFile::ReadOwner | QFile::ReadUser
| QFile::ReadGroup | QFile::ReadOther);
return true;
}
static void resetProgress()
{
loadingProgressCounter = 0;
updateProgress(loadingProgressCounter);
}
void Dirs::setProgress()
{
loadingProgressCounter++;
updateProgress(loadingProgressCounter);
}
void DownloadJob::emitUpdate(int value) {
emit updateProgress(value);
}
bool KviPackageReader::unpackFile(KviFile * pFile, const QString & szUnpackPath)
{
// Flags
kvi_u32_t uFlags;
if(!pFile->load(uFlags))
return readError();
#ifndef COMPILE_ZLIB_SUPPORT
if(uFlags & KVI_PACKAGE_DATAFIELD_FLAG_FILE_DEFLATE)
{
setLastError(__tr2qs("The package contains compressed data but this executable does not support compression"));
return false;
}
#endif
// Path
QString szPath;
if(!pFile->load(szPath))
return readError();
QString szFileName = szUnpackPath;
KviQString::ensureLastCharIs(szFileName, QChar(KVI_PATH_SEPARATOR_CHAR));
szFileName += szPath;
// no attacks please :)
szFileName.replace(QString("..\\"), QString(""));
szFileName.replace(QString("../"), QString(""));
KviFileUtils::adjustFilePath(szFileName);
int idx = szFileName.lastIndexOf(QChar(KVI_PATH_SEPARATOR_CHAR));
if(idx != -1)
{
QString szPrefixPath = szFileName.left(idx);
if(!KviFileUtils::makeDir(szPrefixPath))
{
setLastError(__tr2qs("Failed to create the target directory"));
return false;
}
}
KviFile dest(szFileName);
if(!dest.open(QFile::WriteOnly | QFile::Truncate))
{
setLastError(__tr2qs("Failed to open a source file for reading"));
return false;
}
QString szProgressText = QString(__tr2qs("Unpacking file %1")).arg(szFileName);
if(!updateProgress(pFile->pos(), szProgressText))
return false; // aborted
// Size
kvi_u32_t uSize;
if(!pFile->load(uSize))
return readError();
// FilePayload
#ifdef COMPILE_ZLIB_SUPPORT
if(uFlags & KVI_PACKAGE_DATAFIELD_FLAG_FILE_DEFLATE)
{
//qDebug ("loading compressed data");
int iRemainingSize = uSize;
unsigned char ibuffer[BUFFER_SIZE];
unsigned char obuffer[BUFFER_SIZE];
int iToRead = iRemainingSize;
if(iToRead > BUFFER_SIZE)
iToRead = BUFFER_SIZE;
int iReaded = pFile->read((char *)ibuffer, iToRead);
iRemainingSize -= iReaded;
z_stream zstr;
zstr.zalloc = Z_NULL;
zstr.zfree = Z_NULL;
zstr.opaque = Z_NULL;
zstr.next_in = ibuffer;
zstr.avail_in = iReaded;
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
if(inflateInit(&zstr) != Z_OK)
{
setLastError(__tr2qs("Compression library initialization error"));
return false;
}
while((iReaded > 0) && (iRemainingSize > 0))
{
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
if(inflate(&zstr, Z_NO_FLUSH) != Z_OK)
{
setLastError(__tr2qs("Compression library error"));
return false;
}
if(zstr.avail_out < BUFFER_SIZE)
{
int iDecompressed = zstr.next_out - obuffer;
if(dest.write((char *)obuffer, iDecompressed) != iDecompressed)
{
inflateEnd(&zstr);
return writeError();
}
}
if(zstr.avail_in < BUFFER_SIZE)
{
int iDataToRead = BUFFER_SIZE - zstr.avail_in;
if(iDataToRead < BUFFER_SIZE)
{
if(ibuffer != zstr.next_in)
{
// hum, there is still some data in the buffer to be readed
// and it is not at the beginning...move it to the beginning of ibuffer
memmove(ibuffer, zstr.next_in, zstr.avail_in);
}
}
if(iDataToRead > iRemainingSize)
iDataToRead = iRemainingSize;
iReaded = pFile->read((char *)(ibuffer + zstr.avail_in), iDataToRead);
if(iReaded < 0)
{
inflateEnd(&zstr);
return readError();
}
iRemainingSize -= iReaded;
zstr.avail_in += iReaded;
zstr.next_in = ibuffer;
if((zstr.total_in % 2000000) == 0)
{
QString szTmp = QString(" (%1 of %2 bytes)").arg(zstr.total_in, uSize);
QString szPrg = szProgressText + szTmp;
if(!updateProgress(pFile->pos(), szPrg))
return false; // aborted
}
}
}
// flush pending output
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
int ret;
do
{
ret = inflate(&zstr, Z_FINISH);
if((ret == Z_OK) || (ret == Z_STREAM_END) || (ret == Z_BUF_ERROR))
{
if(zstr.avail_out < BUFFER_SIZE)
{
int iDecompressed = zstr.next_out - obuffer;
if(dest.write((char *)obuffer, iDecompressed) != iDecompressed)
{
inflateEnd(&zstr);
return writeError();
}
}
else
{
//THIS HAPPENS FOR ZERO SIZE FILES
qDebug("Hum... internal, rEWq (ret = %d) (avail_out = %d)", ret, zstr.avail_out);
inflateEnd(&zstr);
setLastError(__tr2qs("Compression library internal error"));
return false;
}
zstr.next_out = obuffer;
zstr.avail_out = BUFFER_SIZE;
}
} while((ret == Z_OK) || (ret == Z_BUF_ERROR));
inflateEnd(&zstr);
if(ret != Z_STREAM_END)
{
setLastError(__tr2qs("Error in compressed file stream"));
return false;
}
}
else
{
#endif
//qDebug("Load uncompressed data");
unsigned char buffer[BUFFER_SIZE];
int iTotalFileSize = 0;
int iRemainingData = uSize;
int iToRead = iRemainingData;
if(iToRead > BUFFER_SIZE)
iToRead = BUFFER_SIZE;
int iReaded = 1;
//qDebug("iReaded %i and iToRead %i and index %i",iReaded,iToRead,pFile->pos());
while((iReaded > 0) && (iToRead > 0))
{
iReaded = pFile->read((char *)buffer, iToRead);
if(iReaded > 0)
{
iTotalFileSize += iReaded;
iRemainingData -= iReaded;
if((iTotalFileSize % 3000000) == 0)
{
QString szTmp = QString(" (%1 of %2 bytes)").arg(iTotalFileSize).arg(uSize);
QString szPrg = szProgressText + szTmp;
if(!updateProgress(pFile->pos(), szPrg))
return false; // aborted
}
//qDebug("write file with size %i and name %s",iReaded,dest.fileName().toUtf8().data());
if(dest.write((char *)buffer, iReaded) != iReaded)
return writeError();
}
//qDebug("Remains %i", iRemainingData);
iToRead = iRemainingData;
if(iToRead > BUFFER_SIZE)
iToRead = BUFFER_SIZE;
}
//qDebug("finish to read %i and index %i",iReaded,pFile->pos());
#ifdef COMPILE_ZLIB_SUPPORT
}
#endif
dest.close();
return true;
}
bool
PowerTapDevice::download( const QDir &tmpdir,
QList<DeviceDownloadFile> &files,
QString &err)
{
if (!dev->open(err)) {
err = tr("ERROR: open failed: ") + err;
return false;
}
// make several attempts at reading the version
int attempts = 3;
int veridx = -1;
int version_len;
char vbuf[256];
QByteArray version;
do {
if (!doWrite(dev, 0x56, false, err)) // 'V'
return false;
emit updateStatus( tr("Reading version...") );
if(m_Cancelled) {
err = tr("download cancelled");
return false;
}
version_len = readUntilNewline(dev, vbuf, sizeof(vbuf), err);
if (version_len < 0) {
err = tr("Error reading version: ") + err;
return false;
}
if (PT_DEBUG) {
printf("read version \"%s\"\n",
cEscape(vbuf, version_len).toAscii().constData());
}
version = QByteArray(vbuf, version_len);
// We expect the version string to be something like
// "VER 02.21 PRO...", so if we see two V's, it's probably
// because there's a hardware echo going on.
veridx = version.indexOf("VER");
} while ((--attempts > 0) && (veridx < 0));
if (veridx < 0) {
err = QString(tr("Unrecognized version \"%1\""))
.arg(cEscape(vbuf, version_len));
return false;
}
bool hwecho = version.indexOf('V') < veridx;
if (PT_DEBUG) printf("hwecho=%s\n", hwecho ? "true" : "false");
emit updateStatus( tr("Reading header...") );
if(m_Cancelled) {
err = tr("download cancelled");
return false;
}
if (!doWrite(dev, 0x44, hwecho, err)) // 'D'
return false;
unsigned char header[6];
int header_len = dev->read(header, sizeof(header), err);
if (header_len != 6) {
if (header_len < 0)
err = tr("ERROR: reading header: ") + err;
else
err = tr("ERROR: timeout reading header");
return false;
}
if (PT_DEBUG) {
printf("read header \"%s\"\n",
cEscape((char*) header,
sizeof(header)).toAscii().constData());
}
QVector<unsigned char> records;
for (size_t i = 0; i < sizeof(header); ++i)
records.append(header[i]);
emit updateStatus( tr("Reading ride data...") );
if(m_Cancelled) {
err = tr("download cancelled");
return false;
}
double recIntSecs = 0.0;
fflush(stdout);
while (true) {
if (PT_DEBUG) printf("reading block\n");
unsigned char buf[256 * 6 + 1];
int n = dev->read(buf, 2, err);
if (n < 2) {
if (n < 0)
err = tr("ERROR: reading first two: ") + err;
else
err = tr("ERROR: timeout reading first two");
return false;
}
if (PT_DEBUG) {
printf("read 2 bytes: \"%s\"\n",
cEscape((char*) buf, 2).toAscii().constData());
}
if (hasNewline((char*) buf, 2))
break;
unsigned count = 2;
while (count < sizeof(buf)) {
n = dev->read(buf + count, sizeof(buf) - count, err);
if (n < 0) {
err = tr("ERROR: reading block: ") + err;
return false;
}
if (n == 0) {
err = tr("ERROR: timeout reading block");
return false;
}
if (PT_DEBUG) {
printf("read %d bytes: \"%s\"\n", n,
cEscape((char*) buf + count, n).toAscii().constData());
}
count += n;
}
unsigned csum = 0;
for (int i = 0; i < ((int) sizeof(buf)) - 1; ++i)
csum += buf[i];
if ((csum % 256) != buf[sizeof(buf) - 1]) {
err = tr("ERROR: bad checksum");
return false;
}
if (PT_DEBUG) printf("good checksum\n");
for (size_t i = 0; i < sizeof(buf) - 1; ++i)
records.append(buf[i]);
if (recIntSecs == 0.0) {
unsigned char *data = records.data();
bool bIsVer81 = PowerTapUtil::is_Ver81(data);
for (int i = 0; i < records.size(); i += 6) {
if (PowerTapUtil::is_config(data + i, bIsVer81)) {
unsigned unused1, unused2, unused3;
PowerTapUtil::unpack_config(
data + i, &unused1, &unused2,
&recIntSecs, &unused3, bIsVer81);
}
}
}
if (recIntSecs != 0.0) {
int min = (int) round(records.size() / 6 * recIntSecs);
emit updateProgress( QString(tr("progress: %1:%2"))
.arg(min / 60)
.arg(min % 60, 2, 10, QLatin1Char('0')));
}
if(m_Cancelled){
err = tr("download cancelled");
return false;
}
if (!doWrite(dev, 0x71, hwecho, err)) // 'q'
return false;
}
QString tmpl = tmpdir.absoluteFilePath(".ptdl.XXXXXX");
QTemporaryFile tmp(tmpl);
tmp.setAutoRemove(false);
if (!tmp.open()) {
err = tr("Failed to create temporary file ")
+ tmpl + ": " + tmp.error();
return false;
}
// QTemporaryFile initially has permissions set to 0600.
// Make it readable by everyone.
tmp.setPermissions(tmp.permissions()
| QFile::ReadOwner | QFile::ReadUser
| QFile::ReadGroup | QFile::ReadOther);
DeviceDownloadFile file;
file.extension = "raw";
file.name = tmp.fileName();
QTextStream os(&tmp);
os << hex;
os.setPadChar('0');
bool time_set = false;
unsigned char *data = records.data();
bool bIsVer81 = PowerTapUtil::is_Ver81(data);
for (int i = 0; i < records.size(); i += 6) {
if (data[i] == 0 && !bIsVer81)
continue;
for (int j = 0; j < 6; ++j) {
os.setFieldWidth(2);
os << data[i+j];
os.setFieldWidth(1);
os << ((j == 5) ? "\n" : " ");
}
if (!time_set && PowerTapUtil::is_time(data + i, bIsVer81)) {
struct tm time;
time_t timet = PowerTapUtil::unpack_time(data + i, &time, bIsVer81);
file.startTime.setTime_t( timet );
time_set = true;
}
}
if (!time_set) {
err = tr("Failed to find ride time.");
tmp.setAutoRemove(true);
return false;
}
files << file;
return true;
}
void CompressTouche::compress_sound_data(Common::Filename *inpath, Common::Filename *outpath) {
int i;
uint32 current_offset;
uint32 offsets_table[MAX_OFFSETS];
Common::File output(*outpath, "wb");
output.writeUint16LE(1); /* current version */
output.writeUint16LE(0); /* flags */
current_offset = HEADER_SIZE;
/* write 0 offsets table */
for (i = 0; i < MAX_OFFSETS; ++i) {
offsets_table[i] = 0;
output.writeUint32LE(offsets_table[i]);
current_offset += 4;
}
/* process 'OBJ' file */
inpath->setFullName("OBJ");
Common::File input(*inpath, "rb");
offsets_table[0] = current_offset;
current_offset = compress_sound_data_file(current_offset, output, input, input_OBJ_offs, input_OBJ_size, OBJ_HDR_LEN);
input.close();
print("Processed '%s'.", inpath->getFullPath().c_str());
/* process Vxx files */
for (i = 1; i < MAX_OFFSETS; ++i) {
updateProgress(i, MAX_OFFSETS);
char d[16];
sprintf(d, "V%d", i);
inpath->setFullName(d);
try {
input.open(*inpath, "rb");
offsets_table[i] = current_offset;
current_offset = compress_sound_data_file(current_offset, output, input, input_Vxx_offs, input_Vxx_size, Vxx_HDR_LEN);
input.close();
print("Processed '%s'.", inpath->getFullPath().c_str());
} catch (...) {
//print("Skipping '%s'.", inpath->getFullPath().c_str());
}
}
/* fix global offsets table at the beginning of the file */
output.seek(HEADER_SIZE, SEEK_SET);
for (i = 0; i < MAX_OFFSETS; ++i) {
output.writeUint32LE(offsets_table[i]);
}
output.close();
/* cleanup */
Common::removeFile(TEMP_RAW);
Common::removeFile(tempEncoded);
print("Done.");
}
// ******************************************************************************************
// Save package using default path
// ******************************************************************************************
bool ConfigurationFilesWidget::generatePackage()
{
// Get path name
std::string new_package_path = stack_path_->getPath();
// Check that a valid stack package name has been given
if( new_package_path.empty() )
{
QMessageBox::warning( this, "Error Generating", "No package path provided. Please choose a directory location to generate the MoveIt configuration files." );
return false;
}
// Check setup assist deps
if( !checkDependencies() )
return false; // canceled
// Check that all groups have components
if( !noGroupsEmpty() )
return false; // not ready
// Trim whitespace from user input
boost::trim( new_package_path );
// Get the package name ---------------------------------------------------------------------------------
new_package_name_ = getPackageName( new_package_path );
const std::string setup_assistant_file = config_data_->appendPaths( new_package_path, ".setup_assistant" );
// Make sure old package is correct package type and verify over write
if( fs::is_directory( new_package_path ) && !fs::is_empty( new_package_path ) )
{
// Check if the old package is a setup assistant package. If it is not, quit
if( ! fs::is_regular_file( setup_assistant_file ) )
{
QMessageBox::warning( this, "Incorrect Folder/Package",
QString("The chosen package location already exists but was not previously created using this MoveIt Setup Assistant. If this is a mistake, replace the missing file: ")
.append( setup_assistant_file.c_str() ) );
return false;
}
// Confirm overwrite
if( QMessageBox::question( this, "Confirm Package Update",
QString("Are you sure you want to overwrite this existing package with updated configurations?<br /><i>")
.append( new_package_path.c_str() )
.append( "</i>" ),
QMessageBox::Ok | QMessageBox::Cancel)
== QMessageBox::Cancel )
{
return false; // abort
}
}
else // this is a new package (but maybe the folder already exists)
{
// Create new directory ------------------------------------------------------------------
try
{
fs::create_directory( new_package_path ) && !fs::is_directory( new_package_path );
}
catch( ... )
{
QMessageBox::critical( this, "Error Generating Files",
QString("Unable to create directory ").append( new_package_path.c_str() ) );
return false;
}
}
// Begin to create files and folders ----------------------------------------------------------------------
std::string absolute_path;
for (int i = 0; i < gen_files_.size(); ++i)
{
GenerateFile* file = &gen_files_[i];
// Check if we should skip this file
if( !file->generate_ )
{
continue;
}
// Create the absolute path
absolute_path = config_data_->appendPaths( new_package_path, file->rel_path_ );
ROS_DEBUG_STREAM("Creating file " << absolute_path );
// Run the generate function
if( !file->gen_func_(absolute_path) )
{
// Error occured
QMessageBox::critical( this, "Error Generating File",
QString("Failed to generate folder or file: '")
.append( file->rel_path_.c_str() ).append("' at location:\n").append( absolute_path.c_str() ));
return false;
}
updateProgress(); // Increment and update GUI
}
return true;
}
/*!
* \brief IPProcessGrid::execute
*/
void IPProcessGrid::execute(bool forcedUpdate /* = false*/)
{
// if no processes yet, then exit
if(_scene->steps()->size() < 1)
{
return;
}
// if already running or nothing has changed, exit
if(_isRunning || !_updateNeeded)
{
return;
}
// prevent user changes during execution
_mainWindow->lockScene();
_isRunning = true;
_sequenceCount = 0;
buildQueue();
int totalDurationMs = 0;
// execute the processes
int counter = 0;
int limit = 10000;
QList<IPProcessStep*> afterProcessingList;
QListIterator<IPProcessStep *> it(_processList);
while (it.hasNext() && counter < limit)
{
if(_stopExecution)
return;
IPProcessStep* step = it.next();
_currentStep = step;
// make sure the progress bar gets filled
updateProgress(1);
// source processes don't have inputs
if(step->process()->isSource())
{
// check if is sequence
//IPLLoadImageSequence* sequenceProcess = dynamic_cast<IPLLoadImageSequence*>(step->process());
// update if index has changed
/*if(sequenceProcess && (_sequenceIndex != _lastSequenceIndex))
{
sequenceProcess->setSequenceIndex(_sequenceIndex);
propagateNeedsUpdate(sequenceProcess);
}*/
// execute thread
if(!step->process()->isResultReady() || forcedUpdate)
{
step->process()->resetMessages();
step->process()->beforeProcessing();
int durationMs = executeThread(step->process());
//step->process()->afterProcessing();
// afterProcessing will be called later
afterProcessingList.append(step);
totalDurationMs += durationMs;
step->setDuration(durationMs);
if(!step->process()->hasErrors())
step->updateThumbnail();
// update error messages
_mainWindow->updateProcessMessages();
}
/*if(sequenceProcess)
{
int currentSequenceCount = sequenceProcess->sequenceCount();
_sequenceCount = std::max(_sequenceCount, currentSequenceCount);
emit sequenceChanged(_sequenceIndex, _sequenceCount);
}*/
}
else
{
if(!step->process()->isResultReady() || forcedUpdate)
{
// execute process once for every input
for(int i=0; i < step->edgesIn()->size(); i++)
{
IPProcessEdge* edge = step->edgesIn()->at(i);
int indexFrom = edge->indexFrom();
int indexTo = edge->indexTo();
IPProcessStep* stepFrom = edge->from();
IPLImage* result = static_cast<IPLImage*>(stepFrom->process()->getResultData(indexFrom));
// invalid result, stopp the execution
if(!result)
{
QString msg("Invalid operation at step: ");
msg.append(QString::fromStdString(stepFrom->process()->title()));
_mainWindow->showMessage(msg, MainWindow::MESSAGE_ERROR);
break;
}
// execute thread
step->process()->resetMessages();
step->process()->beforeProcessing();
int durationMs = executeThread(step->process(), result, indexTo, mainWindow()->useOpenCV());
//step->process()->afterProcessing();
// afterProcessing will be called later
afterProcessingList.append(step);
totalDurationMs += durationMs;
step->setDuration(durationMs);
step->updateThumbnail();
// update error messages
_mainWindow->updateProcessMessages();
}
}
}
// make sure the progress bar gets filled
updateProgress(100);
counter++;
}
if(_stopExecution)
return;
// update images
_mainWindow->imageViewer()->updateImage();
_mainWindow->imageViewer()->showProcessDuration(totalDurationMs);
// update process graph
_mainWindow->updateGraphicsView();
_mainWindow->unlockScene();
_isRunning = false;
_currentStep = NULL;
// if sequence, then run execute next step
/*if(_sequenceCount > 0)
{
// notify GUI
emit sequenceChanged(_sequenceIndex, _sequenceCount);
if(_isSequenceRunning)
{
//setParamsHaveChanged();
_mainWindow->execute(true);
}
}
// find sequence processes
//bool graphNeedsUpdate = false;
for(auto it = _scene->steps()->begin(); it < _scene->steps()->end(); ++it)
{
IPProcessStep* step = (IPProcessStep*) *it;
IPLProcess* process = step->process();
if(process->isSequence())
{
process->requestUpdate();
propertyChanged(process);
requestUpdate();
}
}*/
//if(_updateID > _currentUpdateID)
// _mainWindow->execute(false);
// only for testing the camera
//if(graphNeedsUpdate)
// _mainWindow->execute(false);
_updateNeeded = false;
// call afterProcessing of all steps which were executed this time
// processes like the camera might request another execution
QListIterator<IPProcessStep *> it2(_processList);
while (it2.hasNext())
{
IPProcessStep* step = it2.next();
step->process()->afterProcessing();
}
}
bool QmlProfilerFileReader::loadQzt(QIODevice *device)
{
QDataStream stream(device);
stream.setVersion(QDataStream::Qt_5_5);
QByteArray magic;
stream >> magic;
if (magic != QByteArray("QMLPROFILER")) {
emit error(tr("Invalid magic: %1").arg(QLatin1String(magic)));
return false;
}
qint32 dataStreamVersion;
stream >> dataStreamVersion;
if (dataStreamVersion > QDataStream::Qt_DefaultCompiledVersion) {
emit error(tr("Unknown data stream version: %1").arg(dataStreamVersion));
return false;
}
stream.setVersion(dataStreamVersion);
stream >> m_traceStart >> m_traceEnd;
QBuffer buffer;
QDataStream bufferStream(&buffer);
bufferStream.setVersion(dataStreamVersion);
QByteArray data;
updateProgress(device);
stream >> data;
buffer.setData(qUncompress(data));
buffer.open(QIODevice::ReadOnly);
bufferStream >> m_eventTypes;
buffer.close();
emit typesLoaded(m_eventTypes);
updateProgress(device);
stream >> data;
buffer.setData(qUncompress(data));
buffer.open(QIODevice::ReadOnly);
bufferStream >> m_notes;
buffer.close();
emit notesLoaded(m_notes);
updateProgress(device);
const int eventBufferLength = 1024;
QVector<QmlEvent> eventBuffer(eventBufferLength);
int eventBufferIndex = 0;
while (!stream.atEnd()) {
stream >> data;
buffer.setData(qUncompress(data));
buffer.open(QIODevice::ReadOnly);
while (!buffer.atEnd()) {
if (isCanceled())
return false;
QmlEvent &event = eventBuffer[eventBufferIndex];
bufferStream >> event;
if (bufferStream.status() == QDataStream::Ok) {
if (event.typeIndex() >= m_eventTypes.length()) {
emit error(tr("Invalid type index %1").arg(event.typeIndex()));
return false;
}
m_loadedFeatures |= (1ULL << m_eventTypes[event.typeIndex()].feature());
} else if (bufferStream.status() == QDataStream::ReadPastEnd) {
break; // Apparently EOF is a character so we end up here after the last event.
} else if (bufferStream.status() == QDataStream::ReadCorruptData) {
emit error(tr("Corrupt data before position %1.").arg(device->pos()));
return false;
} else {
Q_UNREACHABLE();
}
if (++eventBufferIndex == eventBufferLength) {
emit qmlEventsLoaded(eventBuffer);
eventBufferIndex = 0;
}
}
buffer.close();
updateProgress(device);
}
eventBuffer.resize(eventBufferIndex);
emit qmlEventsLoaded(eventBuffer);
emit success();
return true;
}
bool KviPackageWriter::packInternal(const QString & szFileName, kvi_u32_t)
{
KviFile f(szFileName);
if(!f.open(QFile::WriteOnly | QFile::Truncate))
{
setLastError(__tr2qs("Can't open file for writing"));
return false;
}
// write the PackageHeader
// Magic
char magic[4];
magic[0] = 'K';
magic[1] = 'V';
magic[2] = 'P';
magic[3] = 'F';
if(f.write(magic, 4) != 4)
return writeError();
// Version
kvi_u32_t uVersion = 0x1;
if(!f.save(uVersion))
return writeError();
// Flags
kvi_u32_t uFlags = 0x0;
if(!f.save(uFlags))
return writeError();
// write PackageInfo
// InfoFieldCount
kvi_u32_t uCount = stringInfoFields()->count() + binaryInfoFields()->count();
if(!f.save(uCount))
return writeError();
m_p->iCurrentProgress = 5;
if(!updateProgress(m_p->iCurrentProgress, __tr2qs("Writing informational fields")))
return false; // aborted
// InfoFields (string)
KviPointerHashTableIterator<QString, QString> it(*stringInfoFields());
while(QString * s = it.current())
{
if(!f.save(it.currentKey()))
return writeError();
kvi_u32_t uType = KVI_PACKAGE_INFOFIELD_TYPE_STRING;
if(!f.save(uType))
return writeError();
if(!f.save(*s))
return writeError();
++it;
}
// InfoFields (binary)
KviPointerHashTableIterator<QString, QByteArray> it2(*binaryInfoFields());
while(QByteArray * b = it2.current())
{
if(!f.save(it2.currentKey()))
return writeError();
kvi_u32_t uType = KVI_PACKAGE_INFOFIELD_TYPE_BINARYBUFFER;
if(!f.save(uType))
return writeError();
if(!f.save(*b))
return writeError();
++it2;
}
m_p->iCurrentProgress = 10;
if(!updateProgress(m_p->iCurrentProgress, __tr2qs("Writing package data")))
return false; // aborted
// write PackageData
int iIdx = 0;
for(KviPackageWriterDataField * pDataField = m_p->pDataFields->first(); pDataField; pDataField = m_p->pDataFields->next())
{
kvi_u32_t uKviPackageWriterDataFieldType = pDataField->m_uType;
if(!f.save(uKviPackageWriterDataFieldType))
return writeError();
kvi_file_offset_t savedLenOffset = f.pos();
// here we will store the length of the field once it's written
if(!f.save(uKviPackageWriterDataFieldType))
return writeError();
m_p->iCurrentProgress = 10 + ((90 * iIdx) / m_p->pDataFields->count());
switch(pDataField->m_uType)
{
case KVI_PACKAGE_DATAFIELD_TYPE_FILE:
if(!packFile(&f, pDataField))
return false;
break;
default:
setLastError(__tr2qs("Internal error"));
return false;
break;
}
kvi_file_offset_t savedEndOffset = f.pos();
f.seek(savedLenOffset);
if(!f.save(pDataField->m_uWrittenFieldLength))
return writeError();
f.seek(savedEndOffset);
iIdx++;
}
return true;
}
QByteArray GraphExport::generateBin()
{
GraphCurve *c = m_curves->at(ui->curveBox->itemData(ui->curveBox->currentIndex()).toInt())->curve;
Q_ASSERT(c);
QByteArray bin;
QBuffer buff(&bin);
buff.open(QIODevice::WriteOnly);
bool big = !ui->endianBox->currentIndex();
int idxW = (1 << ui->idxWidthBox->currentIndex());
const quint32 start = ui->sampleStartBox->value();
const quint32 end = ui->sampleEndBox->value();
for(quint32 i = start; i < end && i < c->getSize(); ++i)
{
emit updateProgress((i - start )*100/(end - start));
if(ui->indexBox->isChecked())
{
quint64 idx = i;
Utils::swapEndian(idx);
if(!big)
Utils::swapEndian(((char*)&idx)+(sizeof(idx)-idxW), idxW);
buff.write(((char*)&idx)+(sizeof(idx)-idxW), idxW);
}
qreal s = c->sample(i).y();
switch(c->getDataType())
{
case NUM_FLOAT:
{
float f = s;
buff.write((char*)&f, sizeof(f));
break;
}
case NUM_DOUBLE:
buff.write((char*)&s, sizeof(s));
break;
default:
{
QVariant var(s);
switch(c->getDataType())
{
case NUM_UINT8:
case NUM_INT8:
{
quint8 y = var.toInt();
if(big) Utils::swapEndian((char*)&y, sizeof(y));
buff.write((char*)&y, sizeof(y));
break;
}
case NUM_UINT16:
case NUM_INT16:
{
quint16 y = var.toInt();
if(big) Utils::swapEndian((char*)&y, sizeof(y));
buff.write((char*)&y, sizeof(y));
break;
}
case NUM_UINT32:
case NUM_INT32:
{
quint32 y = var.toInt();
if(big) Utils::swapEndian((char*)&y, sizeof(y));
buff.write((char*)&y, sizeof(y));
break;
}
case NUM_UINT64:
case NUM_INT64:
{
quint64 y = var.toLongLong();
if(big) Utils::swapEndian((char*)&y, sizeof(y));
buff.write((char*)&y, sizeof(y));
break;
}
}
break;
}
}
}
buff.close();
return bin;
}
AudioRecorder::AudioRecorder()
{
//! [create-objs-1]
audiosource = new QAudioCaptureSource;
capture = new QMediaRecorder(audiosource);
//! [create-objs-1]
// set a default file
capture->setOutputLocation(QUrl("test.raw"));
QWidget *window = new QWidget;
QGridLayout* layout = new QGridLayout;
QLabel* deviceLabel = new QLabel;
deviceLabel->setText("Devices");
deviceBox = new QComboBox(this);
deviceBox->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed);
QLabel* codecLabel = new QLabel;
codecLabel->setText("Codecs");
codecsBox = new QComboBox(this);
codecsBox->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed);
QLabel* qualityLabel = new QLabel;
qualityLabel->setText("Quality");
qualityBox = new QComboBox(this);
qualityBox->setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Fixed);
//! [device-list]
for(int i = 0; i < audiosource->deviceCount(); i++)
deviceBox->addItem(audiosource->name(i));
//! [device-list]
//! [codec-list]
QStringList codecs = capture->supportedAudioCodecs();
for(int i = 0; i < codecs.count(); i++)
codecsBox->addItem(codecs.at(i));
//! [codec-list]
qualityBox->addItem("Low");
qualityBox->addItem("Medium");
qualityBox->addItem("High");
connect(capture, SIGNAL(durationChanged(qint64)), this, SLOT(updateProgress(qint64)));
connect(capture, SIGNAL(stateChanged(QMediaRecorder::State)), this, SLOT(stateChanged(QMediaRecorder::State)));
layout->addWidget(deviceLabel,0,0,Qt::AlignHCenter);
connect(deviceBox,SIGNAL(activated(int)),SLOT(deviceChanged(int)));
layout->addWidget(deviceBox,0,1,1,3,Qt::AlignLeft);
layout->addWidget(codecLabel,1,0,Qt::AlignHCenter);
connect(codecsBox,SIGNAL(activated(int)),SLOT(codecChanged(int)));
layout->addWidget(codecsBox,1,1,Qt::AlignLeft);
layout->addWidget(qualityLabel,1,2,Qt::AlignHCenter);
connect(qualityBox,SIGNAL(activated(int)),SLOT(qualityChanged(int)));
layout->addWidget(qualityBox,1,3,Qt::AlignLeft);
fileButton = new QPushButton(this);
fileButton->setText(tr("Output File"));
connect(fileButton,SIGNAL(clicked()),SLOT(selectOutputFile()));
layout->addWidget(fileButton,3,0,Qt::AlignHCenter);
button = new QPushButton(this);
button->setText(tr("Record"));
connect(button,SIGNAL(clicked()),SLOT(toggleRecord()));
layout->addWidget(button,3,3,Qt::AlignHCenter);
recTime = new QLabel;
recTime->setText("0 sec");
layout->addWidget(recTime,4,0,Qt::AlignHCenter);
window->setLayout(layout);
setCentralWidget(window);
window->show();
active = false;
}
void CompressionExample::execute() {
// By now, all arguments have been parsed, all members setup and all input paths setup
// If this was a compression tool _format would contain the selected audio format
// Note that we almost need no error handling, since exceptions will be thrown if we do
// something bad, and all parameters have already been setup
// This 'tool' doesn't takes two input files
// It writes the of each file 100 times into X files, where X is the input file size.
// _inputPaths[0].path is always valid and contains the correct path, same for 1
Common::Filename inpath1(_inputPaths[0].path);
Common::Filename inpath2(_inputPaths[1].path);
// We always need to setup default output path, since there is no obligation to specify it
// If you don't do this, the OS will usually default to the working directory, if we output a file
// it will fail most likely
if (_outputPath.empty())
_outputPath = "output/";
// The File class is very similar to the FILE struct, look in util.h for details
File in1(inpath1, "r");
File in2(inpath2, "r");
// Read the complete contents of the files (if they don't contain NUL ofcourse)
std::string text1 = in1.readString();
std::string text2 = in2.readString();
// Start the 'extraction'
size_t total_files = in1.size() + in2.size();
// There has to be some roof on this
if (total_files > 1000)
throw ToolException("Input files are too large!");
for (size_t i = 0; i < total_files; ++i) {
// This updates any progress bar, if there is any
// if you don't support progress bars, you should use notifyProgress instead
// to make sure progress can be aborted (print calls notifyProgress internally)
updateProgress(i, total_files);
// Convert i to string
std::ostringstream outname;
outname << i;
// Open a file for writing
if (_outputFiles) {
File out(_outputPath.getPath() + outname.str() + ".exo", "w");
// What we actually do, output some text alot
for (size_t j = 0; j < 100; ++j) {
if (i < in1.size())
out.write(text1.c_str(), 1, text1.size());
else
out.write(text2.c_str(), 1, text2.size());
}
} else {
// Do nothing for awhile
for (int i = 0; i < 1000000; ++i) {
int *n = new int;
delete n;
}
}
// Print can also throw an AbortException
// Do NOT use printf or anything else that outputs to standard output, as it will not display in the GUI.
print("Outputted file %d of %d\n", i, total_files);
}
// We indicate success by not throwing any exceptions during the execution
print("Extraction finished without errors!");
}
