void QgsMapRendererParallelJob::cancel()
{
if ( !isActive() )
return;
QgsDebugMsg( QString( "PARALLEL cancel at status %1" ).arg( mStatus ) );
mLabelingRenderContext.setRenderingStopped( true );
for ( LayerRenderJobs::iterator it = mLayerJobs.begin(); it != mLayerJobs.end(); ++it )
{
it->context.setRenderingStopped( true );
}
if ( mStatus == RenderingLayers )
{
disconnect( &mFutureWatcher, SIGNAL( finished() ), this, SLOT( renderLayersFinished() ) );
mFutureWatcher.waitForFinished();
renderLayersFinished();
}
if ( mStatus == RenderingLabels )
{
disconnect( &mLabelingFutureWatcher, SIGNAL( finished() ), this, SLOT( renderingFinished() ) );
mLabelingFutureWatcher.waitForFinished();
renderingFinished();
}
Q_ASSERT( mStatus == Idle );
}
void QgsMapRendererParallelJob::waitForFinished()
{
if ( !isActive() )
return;
if ( mStatus == RenderingLayers )
{
disconnect( &mFutureWatcher, SIGNAL( finished() ), this, SLOT( renderLayersFinished() ) );
QTime t;
t.start();
mFutureWatcher.waitForFinished();
QgsDebugMsg( QString( "waitForFinished (1): %1 ms" ).arg( t.elapsed() / 1000.0 ) );
renderLayersFinished();
}
if ( mStatus == RenderingLabels )
{
disconnect( &mLabelingFutureWatcher, SIGNAL( finished() ), this, SLOT( renderingFinished() ) );
QTime t;
t.start();
mLabelingFutureWatcher.waitForFinished();
QgsDebugMsg( QString( "waitForFinished (2): %1 ms" ).arg( t.elapsed() / 1000.0 ) );
renderingFinished();
}
Q_ASSERT( mStatus == Idle );
}
void QgsMapRendererParallelJob::renderLayersFinished()
{
Q_ASSERT( mStatus == RenderingLayers );
// compose final image
mFinalImage = composeImage( mSettings, mLayerJobs );
logRenderingTime( mLayerJobs );
cleanupJobs( mLayerJobs );
QgsDebugMsg( "PARALLEL layers finished" );
if ( mSettings.testFlag( QgsMapSettings::DrawLabeling ) && !mLabelingRenderContext.renderingStopped() )
{
mStatus = RenderingLabels;
connect( &mLabelingFutureWatcher, SIGNAL( finished() ), this, SLOT( renderingFinished() ) );
// now start rendering of labeling!
mLabelingFuture = QtConcurrent::run( renderLabelsStatic, this );
mLabelingFutureWatcher.setFuture( mLabelingFuture );
}
else
{
renderingFinished();
}
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent), _ui(new Ui::MainWindow), _nextScene(QString::null)
{
_ui->setupUi(this);
Camera* camera = new Camera;
camera->set(config->defaultCameraVerticalFOV(), config->defaultCameraAspectRatio());
camera->setAperture(config->defaultCameraAperture());
camera->setFocalPlane(config->defaultCameraFocusPlane());
_ui->renderer->setCamera(camera);
_setConfig();
_ui->sceneNames->addItems(sceneGenerator->scenes());
_ui->sceneNames->setCurrentIndex(0);
logger->setConsole(_ui->console);
logger->setStatusBar(_ui->statusBar);
onLoadScene();
connect(_ui->action_Save, SIGNAL(triggered()), SLOT(onSaveImage()));
connect(_ui->action_Play_Pause, SIGNAL(triggered()), SLOT(onPlayPause()));
connect(_ui->action_Stop, SIGNAL(triggered()), SLOT(onStop()));
connect(_ui->action_Reload, SIGNAL(triggered()), SLOT(onLoadScene()));
connect(_ui->sceneNames, SIGNAL(currentIndexChanged(QString)), SLOT(onLoadScene()));
connect(_ui->integrator, SIGNAL(currentTextChanged(QString)), SLOT(onIntegratorChanged()));
connect(_ui->renderer, SIGNAL(renderingFinished()), SLOT(onRenderingFinished()));
connect(_ui->renderer, SIGNAL(renderingStarted()), SLOT(onRenderingStarted()));
connect(_ui->renderer, SIGNAL(clicked(Intersection)), SLOT(onClick(Intersection)));
QTimer* progressTimer = new QTimer(this);
connect(progressTimer, SIGNAL(timeout()), SLOT(onUpdateProgress()));
progressTimer->start(35);
}
void EditorToolThreaded::slotAbort()
{
d->currentRenderingMode = EditorToolThreaded::NoneRendering;
if (analyser())
{
analyser()->cancelFilter();
}
if (filter())
{
filter()->cancelFilter();
}
EditorToolIface::editorToolIface()->setToolStopProgress();
toolSettings()->enableButton(EditorToolSettings::Ok, true);
toolSettings()->enableButton(EditorToolSettings::Load, true);
toolSettings()->enableButton(EditorToolSettings::SaveAs, true);
toolSettings()->enableButton(EditorToolSettings::Try, true);
toolSettings()->enableButton(EditorToolSettings::Default, true);
toolView()->setEnabled(true);
kapp->restoreOverrideCursor();
renderingFinished();
}
void RenderThread::run()
{
DEBUGOUT << "RenderThread for" << renderMe << "started";
QImage renderImage = RenderUtils::renderPagePart(m_page.page, renderMe.requestedPageSize(), renderMe.pagePart());
if ( renderImage.isNull() )
{
qWarning() << "RenderThread for" << renderMe << "failed";
QSharedPointer<RenderingIdentifier> ri( new RenderingIdentifier(renderMe) );
emit renderingFailed(ri);
return;
}
QList< AdjustedLink > links;
for( Poppler::Link* link: m_page.page->links() )
{
QSharedPointer<Poppler::Link> ptrLink(link);
try{
AdjustedLink al(renderMe, ptrLink);
links.append(al);
} catch( AdjustedLink::OutsidePage & e) {
// no-op
}
}
QSharedPointer<RenderedPage> renderResult(new RenderedPage( renderImage, links, renderMe ));
DEBUGOUT << "RenderThread for" << renderMe << "successful, image has size" << renderResult->getImage().size();
emit renderingFinished(renderResult);
}
Renderer::Renderer(QWidget *parent)
: QWidget(parent), _camera(0), _scene(0), _raytracerThread(0), _integrator(0)
{
setImageSize(config->defaultImageWidth(), config->defaultImageHeight());
QTimer* updator = new QTimer(this);
connect(updator, SIGNAL(timeout()), SLOT(repaint()));
connect(this, SIGNAL(renderingFinished()), SLOT(_onStop()));
updator->start(1000/60);
_stopThread = false;
_isRendering = false;
_isPaused = false;
}
void QgsGlobeTileUpdateManager::start()
{
if ( mRenderer == 0 && !mTileQueue.isEmpty() )
{
mCurrentTile = mTileQueue.takeFirst();
#ifdef GLOBE_SHOW_TILE_STATS
QgsGlobeTileStatistics::instance()->updateQueueTileCount( mTileQueue.size() );
#endif
mRenderer = new QgsMapRendererParallelJob( mCurrentTile->createSettings( mCurrentTile->dpi(), mLayerSet ) );
connect( mRenderer, SIGNAL( finished() ), this, SLOT( renderingFinished() ) );
mRenderer->start();
}
}
int RenderWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: exit(); break;
case 1: render(); break;
case 2: about(); break;
case 3: displayPartialImage((*reinterpret_cast< QImage*(*)>(_a[1]))); break;
case 4: renderingFinished((*reinterpret_cast< QImage*(*)>(_a[1]))); break;
default: ;
}
_id -= 5;
}
return _id;
}
void Renderer::_computeImage()
{
if (!_integrator) {
return ;
}
int s = qSqrt(config->renderingTaskNumber());
QSize imageSize = _image.size();
QSize sectionSize = imageSize / s;
sectionSize.setWidth(qMax(sectionSize.width(), 1));
sectionSize.setHeight(qMax(sectionSize.height(), 1));
QList<QRect> tasks;
for (int x = 0; x < imageSize.width(); x += sectionSize.width()) {
for (int y = 0; y < imageSize.height(); y += sectionSize.height()) {
QRect newTask(QPoint(x, y), sectionSize);
newTask.setRight(qMin(newTask.right(), imageSize.width() - 1));
newTask.setBottom(qMin(newTask.bottom(), imageSize.height() - 1));
tasks.append(newTask);
}
}
_imageColors.resize(imageSize.width() * imageSize.height());
_imageColors.fill(Color::BLACK);
_elapsedTime = 0;
_sampleNumber = 0;
_renderingTime.restart();
_integrator->preprocess(_scene, _camera);
_renderingTime.restart();
emit renderingStarted();
QTime saveTime;
saveTime.restart();
while (_stopThread == false) {
_renderingTasks = tasks;
std::random_shuffle(_renderingTasks.begin(), _renderingTasks.end());
for (int i = 0; i < config->threadNumber(); ++i) {
_computingThreads.append(new std::thread(&Renderer::_computeSections, this));
}
for (std::thread* computingThread : _computingThreads) {
computingThread->join();
delete computingThread;
}
_computingThreads.clear();
_renderingTasks.clear();
++_sampleNumber;
_elapsedTime += _renderingTime.elapsed();
if (saveTime.elapsed() > 10000) {
saveTime.restart();
_image.save(config->outputDir() + "/last.bmp");
}
_pauseMutex.lock();
_pauseMutex.unlock();
_renderingTime.restart();
}
emit renderingFinished();
_isRendering = false;
}
MainWindow::MainWindow(QThread *atermThread):
m_fileDialog("", this)
{
m_ui.setupUi(this);
m_ltsManager = new LtsManager(this, &m_settings, atermThread);
m_markManager = new MarkManager(this, m_ltsManager);
m_infoDock = new InfoDock(this, m_ltsManager, m_markManager);
m_markDock = new MarkDock(this, m_markManager);
m_simDock = new SimDock(this, m_ltsManager);
m_settingsDock = new SettingsDock(this, &m_settings);
m_settingsDialog = new SettingsDialog(this, &m_settings);
m_ltsCanvas = new LtsCanvas(this, &m_settings, m_ltsManager, m_markManager);
setCentralWidget(m_ltsCanvas);
m_progressDialog = new QProgressDialog("", QString(), 0, 6, this);
m_progressDialog->setMinimumDuration(0);
m_ui.informationDock->setWidget(m_infoDock);
m_ui.simulationDock->setWidget(m_simDock);
m_ui.markDock->setWidget(m_markDock);
m_ui.settingsDock->setWidget(m_settingsDock);
m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.informationDock->toggleViewAction());
m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.simulationDock->toggleViewAction());
m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.markDock->toggleViewAction());
m_ui.viewMenu->insertAction(m_ui.preferences, m_ui.settingsDock->toggleViewAction());
m_ui.viewMenu->insertSeparator(m_ui.preferences);
mcrl2::log::logger::register_output_policy(m_logRelay);
connect(&m_logRelay, SIGNAL(logMessage(QString, QString, QDateTime, QString)), this, SLOT(logMessage(QString, QString, QDateTime, QString)));
connect(m_ui.open, SIGNAL(triggered()), this, SLOT(open()));
connect(m_ui.openTrace, SIGNAL(triggered()), this, SLOT(openTrace()));
connect(m_ui.exportBitmap, SIGNAL(triggered()), this, SLOT(exportBitmap()));
connect(m_ui.exportText, SIGNAL(triggered()), this, SLOT(exportText()));
connect(m_ui.exportVector, SIGNAL(triggered()), this, SLOT(exportVector()));
connect(m_ui.exit, SIGNAL(triggered()), QApplication::instance(), SLOT(quit()));
connect(m_ui.resetViewpoint, SIGNAL(triggered()), m_ltsCanvas, SLOT(resetView()));
connect(m_ui.zoomIntoAbove, SIGNAL(triggered()), m_ltsManager, SLOT(zoomInAbove()));
connect(m_ui.zoomIntoBelow, SIGNAL(triggered()), m_ltsManager, SLOT(zoomInBelow()));
connect(m_ui.zoomOut, SIGNAL(triggered()), m_ltsManager, SLOT(zoomOut()));
connect(m_ui.displayStates, SIGNAL(triggered(bool)), &m_settings.displayStates, SLOT(setValue(bool)));
connect(&m_settings.displayStates, SIGNAL(changed(bool)), m_ui.displayStates, SLOT(setChecked(bool)));
connect(m_ui.displayTransitions, SIGNAL(triggered(bool)), &m_settings.displayTransitions, SLOT(setValue(bool)));
connect(&m_settings.displayTransitions, SIGNAL(changed(bool)), m_ui.displayTransitions, SLOT(setChecked(bool)));
connect(m_ui.displayBackpointers, SIGNAL(triggered(bool)), &m_settings.displayBackpointers, SLOT(setValue(bool)));
connect(&m_settings.displayBackpointers, SIGNAL(changed(bool)), m_ui.displayBackpointers, SLOT(setChecked(bool)));
connect(m_ui.displayWireframe, SIGNAL(triggered(bool)), &m_settings.displayWireframe, SLOT(setValue(bool)));
connect(&m_settings.displayWireframe, SIGNAL(changed(bool)), m_ui.displayWireframe, SLOT(setChecked(bool)));
connect(m_ui.preferences, SIGNAL(triggered()), m_settingsDialog, SLOT(show()));
connect(m_ltsManager, SIGNAL(loadingLts()), this, SLOT(loadingLts()));
connect(m_ltsManager, SIGNAL(rankingStates()), this, SLOT(rankingStates()));
connect(m_ltsManager, SIGNAL(clusteringStates()), this, SLOT(clusteringStates()));
connect(m_ltsManager, SIGNAL(computingClusterInfo()), this, SLOT(computingClusterInfo()));
connect(m_ltsManager, SIGNAL(positioningClusters()), this, SLOT(positioningClusters()));
connect(m_ltsManager, SIGNAL(positioningStates()), this, SLOT(positioningStates()));
connect(m_ltsManager, SIGNAL(ltsStructured()), this, SLOT(hideProgressDialog()));
connect(m_ltsManager, SIGNAL(errorLoadingLts()), this, SLOT(hideProgressDialog()));
connect(m_ltsManager, SIGNAL(startStructuring()), this, SLOT(startStructuring()));
connect(m_ltsManager, SIGNAL(stopStructuring()), this, SLOT(stopStructuring()));
connect(m_ltsManager, SIGNAL(selectionChanged()), this, SLOT(selectionChanged()));
connect(m_ltsManager, SIGNAL(ltsZoomed(LTS *)), this, SLOT(zoomChanged()));
m_ui.zoomIntoAbove->setEnabled(false);
m_ui.zoomIntoBelow->setEnabled(false);
m_ui.zoomOut->setEnabled(false);
connect(m_ltsCanvas, SIGNAL(renderingStarted()), this, SLOT(startRendering()));
connect(m_ltsCanvas, SIGNAL(renderingFinished()), this, SLOT(clearStatusBar()));
QSettings settings("mCRL2", "LTSView");
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("windowState").toByteArray());
}
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QStringList args = app.arguments();
QStringList preargs;
QString locale;
int pid = 0;
int in = -1;
int out = -1;
if (args.count() >= 7) {
// Remove program name
args.removeFirst();
bool erase = false;
if (args.at(0) == "-erase") {
erase = true;
args.removeFirst();
}
bool usekuiserver = false;
if (args.at(0) == "-kuiserver") {
usekuiserver = true;
args.removeFirst();
}
if (QString(args.at(0)).startsWith("-pid:")) {
pid = QString(args.at(0)).section(':', 1).toInt();
args.removeFirst();
}
if (QString(args.at(0)).startsWith("-locale:")) {
locale = QString(args.at(0)).section(':', 1);
args.removeFirst();
}
if (args.at(0).startsWith("in="))
in = args.takeFirst().section('=', -1).toInt();
if (args.at(0).startsWith("out="))
out = args.takeFirst().section('=', -1).toInt();
if (args.at(0).startsWith("preargs="))
preargs = args.takeFirst().section('=', 1).split(' ', QString::SkipEmptyParts);
QString render = args.takeFirst();
QString profile = args.takeFirst();
QString rendermodule = args.takeFirst();
QString player = args.takeFirst();
QUrl srcurl = QUrl::fromEncoded(args.takeFirst().toUtf8());
QString src = srcurl.path();
QUrl desturl = QUrl::fromEncoded(args.takeFirst().toUtf8());
QString dest = desturl.path();
bool dualpass = false;
bool doerase;
QString vpre;
int vprepos = args.indexOf(QRegExp("vpre=.*"));
if (vprepos >= 0) {
vpre=args.at(vprepos);
}
QStringList vprelist = vpre.replace("vpre=", "").split(',');
if (vprelist.size() > 0) {
args.replaceInStrings(QRegExp("^vpre=.*"), QString("vpre=").append(vprelist.at(0)));
}
if (args.contains("pass=2")) {
// dual pass encoding
dualpass = true;
doerase = false;
args.replace(args.indexOf("pass=2"), "pass=1");
if (args.contains("vcodec=libx264")) args << QString("passlogfile=%1").arg(dest + ".log");
} else {
args.removeAll("pass=1");
doerase = erase;
}
qDebug() << "//STARTING RENDERING: " << erase << "," << usekuiserver << "," << render << "," << profile << "," << rendermodule << "," << player << "," << src << "," << dest << "," << preargs << "," << args << "," << in << "," << out ;
RenderJob *job = new RenderJob(doerase, usekuiserver, pid, render, profile, rendermodule, player, src, dest, preargs, args, in, out);
if (!locale.isEmpty()) job->setLocale(locale);
job->start();
if (dualpass) {
if (vprelist.size()>1)
args.replaceInStrings(QRegExp("^vpre=.*"),QString("vpre=").append(vprelist.at(1)));
args.replace(args.indexOf("pass=1"), "pass=2");
RenderJob *dualjob = new RenderJob(erase, usekuiserver, pid, render, profile, rendermodule, player, src, dest, preargs, args, in, out);
QObject::connect(job, SIGNAL(renderingFinished()), dualjob, SLOT(start()));
}
app.exec();
} else {
fprintf(stderr, "Kdenlive video renderer for MLT.\nUsage: "
"kdenlive_render [-erase] [-kuiserver] [-locale:LOCALE] [in=pos] [out=pos] [render] [profile] [rendermodule] [player] [src] [dest] [[arg1] [arg2] ...]\n"
" -erase: if that parameter is present, src file will be erased at the end\n"
" -kuiserver: if that parameter is present, use KDE job tracker\n"
" -locale:LOCALE : set a locale for rendering. For example, -locale:fr_FR.UTF-8 will use a french locale (comma as numeric separator)\n"
" in=pos: start rendering at frame pos\n"
" out=pos: end rendering at frame pos\n"
" render: path to MLT melt renderer\n"
" profile: the MLT video profile\n"
" rendermodule: the MLT consumer used for rendering, usually it is avformat\n"
" player: path to video player to play when rendering is over, use '-' to disable playing\n"
" src: source file (usually MLT XML)\n"
" dest: destination file\n"
" args: space separated libavformat arguments\n");
}
}
