+ m_render->forceProcessing(id);
+}
+
+void ProjectList::slotAddOrUpdateSequence(const QString frameName)
+{
+ QString fileName = KUrl(frameName).fileName().section('_', 0, -2);
+ QStringList list;
+ QString pattern = SlideshowClip::selectedPath(frameName, false, QString(), &list);
+ int count = list.count();
+ if (count > 1) {
+ const QList <DocClipBase *> existing = m_doc->clipManager()->getClipByResource(pattern);
+ if (!existing.isEmpty()) {
+ // Sequence already exists, update
+ QString id = existing.at(0)->getId();
+ //ProjectItem *item = getItemById(id);
+ QMap <QString, QString> oldprops;
+ QMap <QString, QString> newprops;
+ int ttl = existing.at(0)->getProperty("ttl").toInt();
+ oldprops["out"] = existing.at(0)->getProperty("out");
+ newprops["out"] = QString::number(ttl * count - 1);
+ slotUpdateClipProperties(id, newprops);
+ EditClipCommand *command = new EditClipCommand(this, id, oldprops, newprops, false);
+ m_commandStack->push(command);
+ } else {
+ // Create sequence
+ QStringList groupInfo = getGroup();
+ QMap <QString, QString> properties;
+ properties.insert("name", fileName);
+ properties.insert("resource", pattern);
+ properties.insert("in", "0");
+ QString duration = m_timecode.reformatSeparators(KdenliveSettings::sequence_duration());
+ properties.insert("out", QString::number(m_doc->getFramePos(duration) * count));
+ properties.insert("ttl", QString::number(m_doc->getFramePos(duration)));
+ properties.insert("loop", QString::number(false));
+ properties.insert("crop", QString::number(false));
+ properties.insert("fade", QString::number(false));
+ properties.insert("luma_duration", m_timecode.getTimecodeFromFrames(int(ceil(m_timecode.fps()))));
+
+ m_doc->slotCreateSlideshowClipFile(properties, groupInfo.at(0), groupInfo.at(1));
+ }
+ } else emit displayMessage(i18n("Sequence not found"), -2);
+}
+
+QMap <QString, QString> ProjectList::getProxies()
+{
+ QMap <QString, QString> list;
+ ProjectItem *item;
+ QTreeWidgetItemIterator it(m_listView);
+ while (*it) {
+ if ((*it)->type() != PROJECTCLIPTYPE) {
+ ++it;
+ continue;
+ }
+ item = static_cast<ProjectItem *>(*it);
+ if (item && item->referencedClip() != NULL) {
+ if (item->hasProxy()) {
+ QString proxy = item->referencedClip()->getProperty("proxy");
+ list.insert(proxy, item->clipUrl().path());
+ }
+ }
+ ++it;
+ }
+ return list;
+}
+
+void ProjectList::slotCreateProxy(const QString id)
+{
+ ProjectItem *item = getItemById(id);
+ if (!item || hasPendingJob(item, PROXYJOB) || item->referencedClip()->isPlaceHolder()) return;
+ QString path = item->referencedClip()->getProperty("proxy");
+ if (path.isEmpty()) {
+ slotUpdateJobStatus(item, PROXYJOB, JOBCRASHED, i18n("Failed to create proxy, empty path."));
+ return;
+ }
+
+ if (QFileInfo(path).size() > 0) {
+ // Proxy already created
+ setJobStatus(item, PROXYJOB, JOBDONE);
+ slotGotProxy(path);
+ return;
+ }
+
+ ProxyJob *job = new ProxyJob(item->clipType(), id, QStringList() << path << item->clipUrl().path() << item->referencedClip()->producerProperty("_exif_orientation") << m_doc->getDocumentProperty("proxyparams").simplified() << QString::number(m_render->frameRenderWidth()) << QString::number(m_render->renderHeight()));
+ if (job->isExclusive() && hasPendingJob(item, job->jobType)) {
+ delete job;
+ return;
+ }
+
+ m_jobList.append(job);
+ setJobStatus(item, job->jobType, JOBWAITING, 0, job->statusMessage());
+ slotCheckJobProcess();
+}
+
+void ProjectList::slotCutClipJob(const QString &id, QPoint zone)
+{
+ ProjectItem *item = getItemById(id);
+ if (!item|| item->referencedClip()->isPlaceHolder()) return;
+ QString source = item->clipUrl().path();
+ QString ext = source.section('.', -1);
+ QString dest = source.section('.', 0, -2) + "_" + QString::number(zone.x()) + "." + ext;
+
+ double clipFps = item->referencedClip()->getProperty("fps").toDouble();
+ if (clipFps == 0) clipFps = m_fps;
+ // if clip and project have different frame rate, adjust in and out
+ int in = zone.x();
+ int out = zone.y();
+ in = GenTime(in, m_timecode.fps()).frames(clipFps);
+ out = GenTime(out, m_timecode.fps()).frames(clipFps);
+ int max = GenTime(item->clipMaxDuration(), m_timecode.fps()).frames(clipFps);
+ int duration = out - in + 1;
+ QString timeIn = Timecode::getStringTimecode(in, clipFps, true);
+ QString timeOut = Timecode::getStringTimecode(duration, clipFps, true);
+
+ QDialog *d = new QDialog(this);
+ Ui::CutJobDialog_UI ui;
+ ui.setupUi(d);
+ ui.extra_params->setVisible(false);
+ ui.add_clip->setChecked(KdenliveSettings::add_clip_cut());
+ ui.file_url->fileDialog()->setOperationMode(KFileDialog::Saving);
+ ui.extra_params->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
+ ui.file_url->setUrl(KUrl(dest));
+ ui.button_more->setIcon(KIcon("configure"));
+ ui.extra_params->setPlainText("-acodec copy -vcodec copy");
+ QString mess = i18n("Extracting %1 out of %2", timeOut, Timecode::getStringTimecode(max, clipFps, true));
+ ui.info_label->setText(mess);
+ if (d->exec() != QDialog::Accepted) {
+ delete d;
+ return;
+ }
+ dest = ui.file_url->url().path();
+ bool acceptPath = dest != source;
+ if (acceptPath && QFileInfo(dest).size() > 0) {
+ // destination file olready exists, overwrite?
+ acceptPath = false;
+ }
+ while (!acceptPath) {
+ // Do not allow to save over original clip
+ if (dest == source) ui.info_label->setText("<b>" + i18n("You cannot overwrite original clip.") + "</b><br>" + mess);
+ else if (KMessageBox::questionYesNo(this, i18n("Overwrite file %1", dest)) == KMessageBox::Yes) break;
+ if (d->exec() != QDialog::Accepted) {
+ delete d;
+ return;
+ }
+ dest = ui.file_url->url().path();
+ acceptPath = dest != source;
+ if (acceptPath && QFileInfo(dest).size() > 0) {
+ acceptPath = false;
+ }
+ }
+ QString extraParams = ui.extra_params->toPlainText().simplified();
+ KdenliveSettings::setAdd_clip_cut(ui.add_clip->isChecked());
+ delete d;
+
+ QStringList jobParams;
+ jobParams << dest << item->clipUrl().path() << timeIn << timeOut << QString::number(duration) << QString::number(KdenliveSettings::add_clip_cut());
+ if (!extraParams.isEmpty()) jobParams << extraParams;
+ CutClipJob *job = new CutClipJob(item->clipType(), id, jobParams);
+ if (job->isExclusive() && hasPendingJob(item, job->jobType)) {
+ delete job;
+ return;
+ }
+ m_jobList.append(job);
+ setJobStatus(item, job->jobType, JOBWAITING, 0, job->statusMessage());
+
+ slotCheckJobProcess();
+}
+
+void ProjectList::slotTranscodeClipJob(const QString &condition, QString params, QString desc)
+{
+ QStringList existingFiles;
+ QStringList ids = getConditionalIds(condition);
+ QStringList destinations;
+ foreach(const QString &id, ids) {
+ ProjectItem *item = getItemById(id);
+ if (!item) continue;
+ QString newFile = params.section(' ', -1).replace("%1", item->clipUrl().path());
+ destinations << newFile;
+ if (QFile::exists(newFile)) existingFiles << newFile;
+ }
+ if (!existingFiles.isEmpty()) {
+ if (KMessageBox::warningContinueCancelList(this, i18n("The transcoding job will overwrite the following files:"), existingFiles) == KMessageBox::Cancel) return;
+ }
+
+ QDialog *d = new QDialog(this);
+ Ui::CutJobDialog_UI ui;
+ ui.setupUi(d);
+ d->setWindowTitle(i18n("Transcoding"));
+ ui.extra_params->setMaximumHeight(QFontMetrics(font()).lineSpacing() * 5);
+ if (ids.count() == 1) {
+ ui.file_url->setUrl(KUrl(destinations.first()));
+ }
+ else {
+ ui.destination_label->setVisible(false);
+ ui.file_url->setVisible(false);
+ }
+ ui.extra_params->setVisible(false);
+ d->adjustSize();
+ ui.button_more->setIcon(KIcon("configure"));
+ ui.add_clip->setChecked(KdenliveSettings::add_clip_cut());
+ ui.extra_params->setPlainText(params.simplified().section(" ", 0, -2));
+ QString mess = desc;
+ mess.append(" " + i18np("(%1 clip)", "(%1 clips)", ids.count()));
+ ui.info_label->setText(mess);
+ if (d->exec() != QDialog::Accepted) {
+ delete d;
+ return;
+ }
+ params = ui.extra_params->toPlainText().simplified();
+ KdenliveSettings::setAdd_clip_cut(ui.add_clip->isChecked());
+
+ foreach(const QString &id, ids) {
+ ProjectItem *item = getItemById(id);
+ if (!item || !item->referencedClip()) continue;
+ QString src = item->clipUrl().path();
+ QString dest;
+ if (ids.count() > 1) dest = params.section(' ', -1).replace("%1", src);
+ else dest = ui.file_url->url().path();
+ QStringList jobParams;
+ jobParams << dest << src << QString() << QString();
+ double clipFps = item->referencedClip()->getProperty("fps").toDouble();
+ if (clipFps == 0) clipFps = m_fps;
+ int max = item->clipMaxDuration();
+ QString duration = QString::number(max);
+ jobParams << duration;
+ jobParams << QString::number(KdenliveSettings::add_clip_cut());
+ jobParams << params;
+ CutClipJob *job = new CutClipJob(item->clipType(), id, jobParams);
+ if (job->isExclusive() && hasPendingJob(item, job->jobType)) {
+ delete job;
+ continue;
+ }
+ m_jobList.append(job);
+ setJobStatus(item, job->jobType, JOBWAITING, 0, job->statusMessage());
+ }
+ delete d;
+ slotCheckJobProcess();
+
+}
+
+void ProjectList::slotCheckJobProcess()
+{
+ if (!m_jobThreads.futures().isEmpty()) {
+ // Remove inactive threads
+ QList <QFuture<void> > futures = m_jobThreads.futures();
+ m_jobThreads.clearFutures();
+ for (int i = 0; i < futures.count(); i++)
+ if (!futures.at(i).isFinished()) {
+ m_jobThreads.addFuture(futures.at(i));
+ }
+ }
+ if (m_jobList.isEmpty()) return;
+ int count = 0;
+ m_jobMutex.lock();
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->jobStatus == JOBWORKING || m_jobList.at(i)->jobStatus == JOBWAITING)
+ count ++;
+ else {
+ // remove finished jobs
+ AbstractClipJob *job = m_jobList.takeAt(i);
+ delete job;
+ i--;
+ }
+ }
+
+ emit jobCount(count);
+ m_jobMutex.unlock();
+
+ if (m_jobThreads.futures().isEmpty() || m_jobThreads.futures().count() < KdenliveSettings::proxythreads()) m_jobThreads.addFuture(QtConcurrent::run(this, &ProjectList::slotProcessJobs));
+}
+
+void ProjectList::slotAbortProxy(const QString id, const QString path)
+{
+ Q_UNUSED(path)
+
+ ProjectItem *item = getItemById(id);
+ if (!item) return;
+ if (!item->isProxyRunning()) slotGotProxy(item);
+ item->setConditionalJobStatus(NOJOB, PROXYJOB);
+ discardJobs(id, PROXYJOB);
+}
+
+void ProjectList::slotProcessJobs()
+{
+ while (!m_jobList.isEmpty() && !m_abortAllJobs) {
+ emit projectModified();
+ AbstractClipJob *job = NULL;
+ int count = 0;
+ m_jobMutex.lock();
+ for (int i = 0; i < m_jobList.count(); i++) {
+ if (m_jobList.at(i)->jobStatus == JOBWAITING) {
+ if (job == NULL) {
+ m_jobList.at(i)->jobStatus = JOBWORKING;
+ job = m_jobList.at(i);
+ }
+ count++;
+ }
+ else if (m_jobList.at(i)->jobStatus == JOBWORKING)
+ count ++;
+ }
+ // Set jobs count
+ emit jobCount(count);
+ m_jobMutex.unlock();
+
+ if (job == NULL) {
+ break;
+ }
+ QString destination = job->destination();
+ // Check if the clip is still here
+ DocClipBase *currentClip = m_doc->clipManager()->getClipById(job->clipId());
+ //ProjectItem *processingItem = getItemById(job->clipId());
+ if (currentClip == NULL) {
+ job->setStatus(JOBDONE);
+ continue;
+ }
+ // Set clip status to started
+ emit processLog(job->clipId(), 0, job->jobType, job->statusMessage());
+
+ // Make sure destination path is writable
+ if (!destination.isEmpty()) {
+ QFile file(destination);
+ if (!file.open(QIODevice::WriteOnly)) {
+ emit updateJobStatus(job->clipId(), job->jobType, JOBCRASHED, i18n("Cannot write to path: %1", destination));
+ job->setStatus(JOBCRASHED);
+ continue;
+ }
+ file.close();
+ QFile::remove(destination);
+ }
+ connect(job, SIGNAL(jobProgress(QString, int, int)), this, SIGNAL(processLog(QString, int, int)));
+ connect(job, SIGNAL(cancelRunningJob(const QString, stringMap)), this, SIGNAL(cancelRunningJob(const QString, stringMap)));
+ connect(job, SIGNAL(gotFilterJobResults(QString,int, int, QString,stringMap)), this, SIGNAL(gotFilterJobResults(QString,int, int, QString,stringMap)));
+
+ if (job->jobType == MLTJOB) {
+ MeltJob *jb = static_cast<MeltJob *> (job);
+ jb->setProducer(currentClip->getProducer());
+ }
+ job->startJob();
+ if (job->jobStatus == JOBDONE) {
+ emit updateJobStatus(job->clipId(), job->jobType, JOBDONE);
+ //TODO: replace with more generic clip replacement framework
+ if (job->jobType == PROXYJOB) emit gotProxy(job->clipId());
+ if (job->addClipToProject()) {
+ emit addClip(destination, QString(), QString());
+ }
+ } else if (job->jobStatus == JOBCRASHED || job->jobStatus == JOBABORTED) {
+ emit updateJobStatus(job->clipId(), job->jobType, job->jobStatus, job->errorMessage(), QString(), job->logDetails());
+ }
+ }
+ // Thread finished, cleanup & update count
+ QTimer::singleShot(200, this, SIGNAL(checkJobProcess()));
+}
+
+
+void ProjectList::updateProxyConfig()
+{
+ ProjectItem *item;
+ QTreeWidgetItemIterator it(m_listView);
+ QUndoCommand *command = new QUndoCommand();
+ command->setText(i18n("Update proxy settings"));
+ QString proxydir = m_doc->projectFolder().path( KUrl::AddTrailingSlash) + "proxy/";
+ while (*it) {
+ if ((*it)->type() != PROJECTCLIPTYPE) {
+ ++it;
+ continue;
+ }
+ item = static_cast<ProjectItem *>(*it);
+ if (item == NULL) {
+ ++it;
+ continue;
+ }
+ CLIPTYPE t = item->clipType();
+ if ((t == VIDEO || t == AV || t == UNKNOWN) && item->referencedClip() != NULL) {
+ if (generateProxy() && useProxy() && !hasPendingJob(item, PROXYJOB)) {
+ DocClipBase *clip = item->referencedClip();
+ if (clip->getProperty("frame_size").section('x', 0, 0).toInt() > m_doc->getDocumentProperty("proxyminsize").toInt()) {
+ if (clip->getProperty("proxy").isEmpty()) {
+ // We need to insert empty proxy in old properties so that undo will work
+ QMap <QString, QString> oldProps;// = clip->properties();
+ oldProps.insert("proxy", QString());
+ QMap <QString, QString> newProps;
+ newProps.insert("proxy", proxydir + item->referencedClip()->getClipHash() + "." + m_doc->getDocumentProperty("proxyextension"));
+ new EditClipCommand(this, clip->getId(), oldProps, newProps, true, command);
+ }
+ }
+ }
+ else if (item->hasProxy()) {
+ // remove proxy
+ QMap <QString, QString> newProps;
+ newProps.insert("proxy", QString());
+ // insert required duration for proxy
+ newProps.insert("proxy_out", item->referencedClip()->producerProperty("out"));
+ new EditClipCommand(this, item->clipId(), item->referencedClip()->currentProperties(newProps), newProps, true, command);
+ }
+ }
+ else if (t == IMAGE && item->referencedClip() != NULL) {
+ if (generateImageProxy() && useProxy()) {
+ DocClipBase *clip = item->referencedClip();
+ int maxImageSize = m_doc->getDocumentProperty("proxyimageminsize").toInt();
+ if (clip->getProperty("frame_size").section('x', 0, 0).toInt() > maxImageSize || clip->getProperty("frame_size").section('x', 1, 1).toInt() > maxImageSize) {
+ if (clip->getProperty("proxy").isEmpty()) {
+ // We need to insert empty proxy in old properties so that undo will work
+ QMap <QString, QString> oldProps = clip->properties();
+ oldProps.insert("proxy", QString());
+ QMap <QString, QString> newProps;
+ newProps.insert("proxy", proxydir + item->referencedClip()->getClipHash() + ".png");
+ new EditClipCommand(this, clip->getId(), oldProps, newProps, true, command);
+ }
+ }
+ }
+ else if (item->hasProxy()) {
+ // remove proxy
+ QMap <QString, QString> newProps;
+ newProps.insert("proxy", QString());
+ new EditClipCommand(this, item->clipId(), item->referencedClip()->properties(), newProps, true, command);
+ }
+ }
+ ++it;
+ }
+ if (command->childCount() > 0) m_doc->commandStack()->push(command);
+ else delete command;
+}
+
+void ProjectList::slotProcessLog(const QString id, int progress, int type, const QString message)
+{
+ ProjectItem *item = getItemById(id);
+ setJobStatus(item, (JOBTYPE) type, JOBWORKING, progress, message);
+}
+
+void ProjectList::slotProxyCurrentItem(bool doProxy, ProjectItem *itemToProxy)
+{
+ QList<QTreeWidgetItem *> list;
+ if (itemToProxy == NULL) list = m_listView->selectedItems();
+ else list << itemToProxy;
+
+ // expand list (folders, subclips) to get real clips
+ QTreeWidgetItem *listItem;
+ QList<ProjectItem *> clipList;
+ for (int i = 0; i < list.count(); i++) {
+ listItem = list.at(i);
+ if (listItem->type() == PROJECTFOLDERTYPE) {
+ for (int j = 0; j < listItem->childCount(); j++) {
+ QTreeWidgetItem *sub = listItem->child(j);
+ if (sub->type() == PROJECTCLIPTYPE) {
+ ProjectItem *item = static_cast <ProjectItem*>(sub);
+ if (!clipList.contains(item)) clipList.append(item);
+ }
+ }
+ }
+ else if (listItem->type() == PROJECTSUBCLIPTYPE) {
+ QTreeWidgetItem *sub = listItem->parent();
+ ProjectItem *item = static_cast <ProjectItem*>(sub);
+ if (!clipList.contains(item)) clipList.append(item);
+ }
+ else if (listItem->type() == PROJECTCLIPTYPE) {
+ ProjectItem *item = static_cast <ProjectItem*>(listItem);
+ if (!clipList.contains(item)) clipList.append(item);
+ }
+ }
+
+ QUndoCommand *command = new QUndoCommand();
+ if (doProxy) command->setText(i18np("Add proxy clip", "Add proxy clips", clipList.count()));
+ else command->setText(i18np("Remove proxy clip", "Remove proxy clips", clipList.count()));
+
+ // Make sure the proxy folder exists
+ QString proxydir = m_doc->projectFolder().path( KUrl::AddTrailingSlash) + "proxy/";
+ KStandardDirs::makeDir(proxydir);
+
+ QMap <QString, QString> newProps;
+ QMap <QString, QString> oldProps;
+ if (!doProxy) newProps.insert("proxy", "-");
+ for (int i = 0; i < clipList.count(); i++) {
+ ProjectItem *item = clipList.at(i);
+ CLIPTYPE t = item->clipType();
+ if ((t == VIDEO || t == AV || t == UNKNOWN || t == IMAGE || t == PLAYLIST) && item->referencedClip()) {
+ if ((doProxy && item->hasProxy()) || (!doProxy && !item->hasProxy() && item->referencedClip()->getProducer() != NULL)) continue;
+ DocClipBase *clip = item->referencedClip();
+ if (!clip || !clip->isClean() || m_render->isProcessing(item->clipId())) {
+ kDebug()<<"//// TRYING TO PROXY: "<<item->clipId()<<", but it is busy";
+ continue;
+ }
+
+ //oldProps = clip->properties();
+ if (doProxy) {
+ newProps.clear();
+ QString path = proxydir + clip->getClipHash() + "." + (t == IMAGE ? "png" : m_doc->getDocumentProperty("proxyextension"));
+ // insert required duration for proxy
+ newProps.insert("proxy_out", clip->producerProperty("out"));
+ newProps.insert("proxy", path);
+ // We need to insert empty proxy so that undo will work
+ //oldProps.insert("proxy", QString());
+ }
+ else if (item->referencedClip()->getProducer() == NULL) {
+ // Force clip reload
+ kDebug()<<"// CLIP HAD NULL PROD------------";
+ newProps.insert("resource", item->referencedClip()->getProperty("resource"));
+ }
+ // We need to insert empty proxy so that undo will work
+ oldProps = clip->currentProperties(newProps);
+ if (doProxy) oldProps.insert("proxy", "-");
+ new EditClipCommand(this, item->clipId(), oldProps, newProps, true, command);
+ }
+ }
+ if (command->childCount() > 0) {
+ m_doc->commandStack()->push(command);
+ }
+ else delete command;
+}
+
+
+void ProjectList::slotDeleteProxy(const QString proxyPath)
+{
+ if (proxyPath.isEmpty()) return;
+ QUndoCommand *proxyCommand = new QUndoCommand();
+ proxyCommand->setText(i18n("Remove Proxy"));
+ QTreeWidgetItemIterator it(m_listView);
+ ProjectItem *item;
+ while (*it) {
+ if ((*it)->type() == PROJECTCLIPTYPE) {
+ item = static_cast <ProjectItem *>(*it);
+ if (item->referencedClip()->getProperty("proxy") == proxyPath) {
+ QMap <QString, QString> props;
+ props.insert("proxy", QString());
+ new EditClipCommand(this, item->clipId(), item->referencedClip()->currentProperties(props), props, true, proxyCommand);
+
+ }
+ }
+ ++it;
+ }
+ if (proxyCommand->childCount() == 0)
+ delete proxyCommand;
+ else
+ m_commandStack->push(proxyCommand);
+ QFile::remove(proxyPath);
+}
+
+void ProjectList::setJobStatus(ProjectItem *item, JOBTYPE jobType, CLIPJOBSTATUS status, int progress, const QString &statusMessage)
+{
+ if (item == NULL || (m_abortAllJobs && m_closing)) return;
+ monitorItemEditing(false);
+ item->setJobStatus(jobType, status, progress, statusMessage);
+ if (status == JOBCRASHED) {
+ DocClipBase *clip = item->referencedClip();
+ if (!clip) {
+ kDebug()<<"// PROXY CRASHED";
+ }
+ else if (clip->getProducer() == NULL && !clip->isPlaceHolder()) {
+ // disable proxy and fetch real clip
+ clip->setProperty("proxy", "-");
+ QDomElement xml = clip->toXML();
+ m_render->getFileProperties(xml, clip->getId(), m_listView->iconSize().height(), true);
+ }
+ else {
+ // Disable proxy for this clip
+ clip->setProperty("proxy", "-");
+ }